vendor: 4,860 bytes, lines 1-117
1/******/ (function(modules) { // webpackBootstrap 2/******/ function hotDisposeChunk(chunkId) { 3/******/ delete installedChunks[chunkId]; 4/******/ } 5/******/ var parentHotUpdateCallback = this["webpackHotUpdate"]; 6/******/ this["webpackHotUpdate"] = 7/******/ function webpackHotUpdateCallback(chunkId, moreModules) { // eslint-disable-line no-unused-vars 8/******/ hotAddUpdateChunk(chunkId, moreModules); 9/******/ if(parentHotUpdateCallback) parentHotUpdateCallback(chunkId, moreModules); 10/******/ } ; 11/******/ 12/******/ function hotDownloadUpdateChunk(chunkId) { // eslint-disable-line no-unused-vars 13/******/ var head = document.getElementsByTagName("head")[0]; 14/******/ var script = document.createElement("script"); 15/******/ script.type = "text/javascript"; 16/******/ script.charset = "utf-8"; 17/******/ script.src = __webpack_require__.p + "hot/hot-update.js"; 18/******/ head.appendChild(script); 19/******/ } 20/******/ 21/******/ function hotDownloadManifest() { // eslint-disable-line no-unused-vars 22/******/ return new Promise(function(resolve, reject) { 23/******/ if(typeof XMLHttpRequest === "undefined") 24/******/ return reject(new Error("No browser support")); 25/******/ try { 26/******/ var request = new XMLHttpRequest(); 27/******/ var requestPath = __webpack_require__.p + "hot/hot-update.json"; 28/******/ request.open("GET", requestPath, true); 29/******/ request.timeout = 10000; 30/******/ request.send(null); 31/******/ } catch(err) { 32/******/ return reject(err); 33/******/ } 34/******/ request.onreadystatechange = function() { 35/******/ if(request.readyState !== 4) return; 36/******/ if(request.status === 0) { 37/******/ // timeout 38/******/ reject(new Error("Manifest request to " + requestPath + " timed out.")); 39/******/ } else if(request.status === 404) { 40/******/ // no update available 41/******/ resolve(); 42/******/ } else if(request.status !== 200 && request.status !== 304) { 43/******/ // other failure 44/******/ reject(new Error("Manifest request to " + requestPath + " failed.")); 45/******/ } else { 46/******/ // success 47/******/ try { 48/******/ var update = JSON.parse(request.responseText); 49/******/ } catch(e) { 50/******/ reject(e); 51/******/ return; 52/******/ } 53/******/ resolve(update); 54/******/ } 55/******/ }; 56/******/ }); 57/******/ } 58/******/ 59/******/ 60/******/ 61/******/ var hotApplyOnUpdate = true; 62/******/ var hotCurrentHash = "f8981813fa3dd9405bff"; // eslint-disable-line no-unused-vars 63/******/ var hotCurrentModuleData = {}; 64/******/ var hotCurrentChildModule; // eslint-disable-line no-unused-vars 65/******/ var hotCurrentParents = []; // eslint-disable-line no-unused-vars 66/******/ var hotCurrentParentsTemp = []; // eslint-disable-line no-unused-vars 67/******/ 68/******/ function hotCreateRequire(moduleId) { // eslint-disable-line no-unused-vars 69/******/ var me = installedModules[moduleId]; 70/******/ if(!me) return __webpack_require__; 71/******/ var fn = function(request) { 72/******/ if(me.hot.active) { 73/******/ if(installedModules[request]) { 74/******/ if(installedModules[request].parents.indexOf(moduleId) < 0) 75/******/ installedModules[request].parents.push(moduleId); 76/******/ } else { 77/******/ hotCurrentParents = [moduleId]; 78/******/ hotCurrentChildModule = request; 79/******/ } 80/******/ if(me.children.indexOf(request) < 0) 81/******/ me.children.push(request); 82/******/ } else { 83/******/ console.warn("[HMR] unexpected require(" + request + ") from disposed module " + moduleId); 84/******/ hotCurrentParents = []; 85/******/ } 86/******/ return __webpack_require__(request); 87/******/ }; 88/******/ var ObjectFactory = function ObjectFactory(name) { 89/******/ return { 90/******/ configurable: true, 91/******/ enumerable: true, 92/******/ get: function() { 93/******/ return __webpack_require__[name]; 94/******/ }, 95/******/ set: function(value) { 96/******/ __webpack_require__[name] = value; 97/******/ } 98/******/ }; 99/******/ }; 100/******/ for(var name in __webpack_require__) { 101/******/ if(Object.prototype.hasOwnProperty.call(__webpack_require__, name) && name !== "e") { 102/******/ Object.defineProperty(fn, name, ObjectFactory(name)); 103/******/ } 104/******/ } 105/******/ fn.e = function(chunkId) { 106/******/ if(hotStatus === "ready") 107/******/ hotSetStatus("prepare"); 108/******/ hotChunksLoading++; 109/******/ return __webpack_require__.e(chunkId).then(finishChunkLoading, function(err) { 110/******/ finishChunkLoading(); 111/******/ throw err; 112/******/ }); 113/******/ 114/******/ function finishChunkLoading() { 115/******/ hotChunksLoading--; 116/******/ if(hotStatus === "prepare") { 117/******/ if(!hotWaitingFilesMap[chunkId]) {
vendor: 8,576 bytes, lines 118-361
118/******/ hotEnsureUpdateChunk(chunkId); 119/******/ } 120/******/ if(hotChunksLoading === 0 && hotWaitingFiles === 0) { 121/******/ hotUpdateDownloaded(); 122/******/ } 123/******/ } 124/******/ } 125/******/ }; 126/******/ return fn; 127/******/ } 128/******/ 129/******/ function hotCreateModule(moduleId) { // eslint-disable-line no-unused-vars 130/******/ var hot = { 131/******/ // private stuff 132/******/ _acceptedDependencies: {}, 133/******/ _declinedDependencies: {}, 134/******/ _selfAccepted: false, 135/******/ _selfDeclined: false, 136/******/ _disposeHandlers: [], 137/******/ _main: hotCurrentChildModule !== moduleId, 138/******/ 139/******/ // Module API 140/******/ active: true, 141/******/ accept: function(dep, callback) { 142/******/ if(typeof dep === "undefined") 143/******/ hot._selfAccepted = true; 144/******/ else if(typeof dep === "function") 145/******/ hot._selfAccepted = dep; 146/******/ else if(typeof dep === "object") 147/******/ for(var i = 0; i < dep.length; i++) 148/******/ hot._acceptedDependencies[dep[i]] = callback || function() {}; 149/******/ else 150/******/ hot._acceptedDependencies[dep] = callback || function() {}; 151/******/ }, 152/******/ decline: function(dep) { 153/******/ if(typeof dep === "undefined") 154/******/ hot._selfDeclined = true; 155/******/ else if(typeof dep === "object") 156/******/ for(var i = 0; i < dep.length; i++) 157/******/ hot._declinedDependencies[dep[i]] = true; 158/******/ else 159/******/ hot._declinedDependencies[dep] = true; 160/******/ }, 161/******/ dispose: function(callback) { 162/******/ hot._disposeHandlers.push(callback); 163/******/ }, 164/******/ addDisposeHandler: function(callback) { 165/******/ hot._disposeHandlers.push(callback); 166/******/ }, 167/******/ removeDisposeHandler: function(callback) { 168/******/ var idx = hot._disposeHandlers.indexOf(callback); 169/******/ if(idx >= 0) hot._disposeHandlers.splice(idx, 1); 170/******/ }, 171/******/ 172/******/ // Management API 173/******/ check: hotCheck, 174/******/ apply: hotApply, 175/******/ status: function(l) { 176/******/ if(!l) return hotStatus; 177/******/ hotStatusHandlers.push(l); 178/******/ }, 179/******/ addStatusHandler: function(l) { 180/******/ hotStatusHandlers.push(l); 181/******/ }, 182/******/ removeStatusHandler: function(l) { 183/******/ var idx = hotStatusHandlers.indexOf(l); 184/******/ if(idx >= 0) hotStatusHandlers.splice(idx, 1); 185/******/ }, 186/******/ 187/******/ //inherit from previous dispose call 188/******/ data: hotCurrentModuleData[moduleId] 189/******/ }; 190/******/ hotCurrentChildModule = undefined; 191/******/ return hot; 192/******/ } 193/******/ 194/******/ var hotStatusHandlers = []; 195/******/ var hotStatus = "idle"; 196/******/ 197/******/ function hotSetStatus(newStatus) { 198/******/ hotStatus = newStatus; 199/******/ for(var i = 0; i < hotStatusHandlers.length; i++) 200/******/ hotStatusHandlers[i].call(null, newStatus); 201/******/ } 202/******/ 203/******/ // while downloading 204/******/ var hotWaitingFiles = 0; 205/******/ var hotChunksLoading = 0; 206/******/ var hotWaitingFilesMap = {}; 207/******/ var hotRequestedFilesMap = {}; 208/******/ var hotAvailableFilesMap = {}; 209/******/ var hotDeferred; 210/******/ 211/******/ // The update info 212/******/ var hotUpdate, hotUpdateNewHash; 213/******/ 214/******/ function toModuleId(id) { 215/******/ var isNumber = (+id) + "" === id; 216/******/ return isNumber ? +id : id; 217/******/ } 218/******/ 219/******/ function hotCheck(apply) { 220/******/ if(hotStatus !== "idle") throw new Error("check() is only allowed in idle status"); 221/******/ hotApplyOnUpdate = apply; 222/******/ hotSetStatus("check"); 223/******/ return hotDownloadManifest().then(function(update) { 224/******/ if(!update) { 225/******/ hotSetStatus("idle"); 226/******/ return null; 227/******/ } 228/******/ hotRequestedFilesMap = {}; 229/******/ hotWaitingFilesMap = {}; 230/******/ hotAvailableFilesMap = update.c; 231/******/ hotUpdateNewHash = update.h; 232/******/ 233/******/ hotSetStatus("prepare"); 234/******/ var promise = new Promise(function(resolve, reject) { 235/******/ hotDeferred = { 236/******/ resolve: resolve, 237/******/ reject: reject 238/******/ }; 239/******/ }); 240/******/ hotUpdate = {}; 241/******/ var chunkId = 0; 242/******/ { // eslint-disable-line no-lone-blocks 243/******/ /*globals chunkId */ 244/******/ hotEnsureUpdateChunk(chunkId); 245/******/ } 246/******/ if(hotStatus === "prepare" && hotChunksLoading === 0 && hotWaitingFiles === 0) { 247/******/ hotUpdateDownloaded(); 248/******/ } 249/******/ return promise; 250/******/ }); 251/******/ } 252/******/ 253/******/ function hotAddUpdateChunk(chunkId, moreModules) { // eslint-disable-line no-unused-vars 254/******/ if(!hotAvailableFilesMap[chunkId] || !hotRequestedFilesMap[chunkId]) 255/******/ return; 256/******/ hotRequestedFilesMap[chunkId] = false; 257/******/ for(var moduleId in moreModules) { 258/******/ if(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) { 259/******/ hotUpdate[moduleId] = moreModules[moduleId]; 260/******/ } 261/******/ } 262/******/ if(--hotWaitingFiles === 0 && hotChunksLoading === 0) { 263/******/ hotUpdateDownloaded(); 264/******/ } 265/******/ } 266/******/ 267/******/ function hotEnsureUpdateChunk(chunkId) { 268/******/ if(!hotAvailableFilesMap[chunkId]) { 269/******/ hotWaitingFilesMap[chunkId] = true; 270/******/ } else { 271/******/ hotRequestedFilesMap[chunkId] = true; 272/******/ hotWaitingFiles++; 273/******/ hotDownloadUpdateChunk(chunkId); 274/******/ } 275/******/ } 276/******/ 277/******/ function hotUpdateDownloaded() { 278/******/ hotSetStatus("ready"); 279/******/ var deferred = hotDeferred; 280/******/ hotDeferred = null; 281/******/ if(!deferred) return; 282/******/ if(hotApplyOnUpdate) { 283/******/ hotApply(hotApplyOnUpdate).then(function(result) { 284/******/ deferred.resolve(result); 285/******/ }, function(err) { 286/******/ deferred.reject(err); 287/******/ }); 288/******/ } else { 289/******/ var outdatedModules = []; 290/******/ for(var id in hotUpdate) { 291/******/ if(Object.prototype.hasOwnProperty.call(hotUpdate, id)) { 292/******/ outdatedModules.push(toModuleId(id)); 293/******/ } 294/******/ } 295/******/ deferred.resolve(outdatedModules); 296/******/ } 297/******/ } 298/******/ 299/******/ function hotApply(options) { 300/******/ if(hotStatus !== "ready") throw new Error("apply() is only allowed in ready status"); 301/******/ options = options || {}; 302/******/ 303/******/ var cb; 304/******/ var i; 305/******/ var j; 306/******/ var module; 307/******/ var moduleId; 308/******/ 309/******/ function getAffectedStuff(updateModuleId) { 310/******/ var outdatedModules = [updateModuleId]; 311/******/ var outdatedDependencies = {}; 312/******/ 313/******/ var queue = outdatedModules.slice().map(function(id) { 314/******/ return { 315/******/ chain: [id], 316/******/ id: id 317/******/ }; 318/******/ }); 319/******/ while(queue.length > 0) { 320/******/ var queueItem = queue.pop(); 321/******/ var moduleId = queueItem.id; 322/******/ var chain = queueItem.chain; 323/******/ module = installedModules[moduleId]; 324/******/ if(!module || module.hot._selfAccepted) 325/******/ continue; 326/******/ if(module.hot._selfDeclined) { 327/******/ return { 328/******/ type: "self-declined", 329/******/ chain: chain, 330/******/ moduleId: moduleId 331/******/ }; 332/******/ } 333/******/ if(module.hot._main) { 334/******/ return { 335/******/ type: "unaccepted", 336/******/ chain: chain, 337/******/ moduleId: moduleId 338/******/ }; 339/******/ } 340/******/ for(var i = 0; i < module.parents.length; i++) { 341/******/ var parentId = module.parents[i]; 342/******/ var parent = installedModules[parentId]; 343/******/ if(!parent) continue; 344/******/ if(parent.hot._declinedDependencies[moduleId]) { 345/******/ return { 346/******/ type: "declined", 347/******/ chain: chain.concat([parentId]), 348/******/ moduleId: moduleId, 349/******/ parentId: parentId 350/******/ }; 351/******/ } 352/******/ if(outdatedModules.indexOf(parentId) >= 0) continue; 353/******/ if(parent.hot._acceptedDependencies[moduleId]) { 354/******/ if(!outdatedDependencies[parentId]) 355/******/ outdatedDependencies[parentId] = []; 356/******/ addAllToSet(outdatedDependencies[parentId], [moduleId]); 357/******/ continue; 358/******/ } 359/******/ delete outdatedDependencies[parentId]; 360/******/ outdatedModules.push(parentId); 361/******/ queue.push({
vendor: 1,398 bytes, lines 362-402
362/******/ chain: chain.concat([parentId]), 363/******/ id: parentId 364/******/ }); 365/******/ } 366/******/ } 367/******/ 368/******/ return { 369/******/ type: "accepted", 370/******/ moduleId: updateModuleId, 371/******/ outdatedModules: outdatedModules, 372/******/ outdatedDependencies: outdatedDependencies 373/******/ }; 374/******/ } 375/******/ 376/******/ function addAllToSet(a, b) { 377/******/ for(var i = 0; i < b.length; i++) { 378/******/ var item = b[i]; 379/******/ if(a.indexOf(item) < 0) 380/******/ a.push(item); 381/******/ } 382/******/ } 383/******/ 384/******/ // at begin all updates modules are outdated 385/******/ // the "outdated" status can propagate to parents if they don't accept the children 386/******/ var outdatedDependencies = {}; 387/******/ var outdatedModules = []; 388/******/ var appliedUpdate = {}; 389/******/ 390/******/ var warnUnexpectedRequire = function warnUnexpectedRequire() { 391/******/ console.warn("[HMR] unexpected require(" + result.moduleId + ") to disposed module"); 392/******/ }; 393/******/ 394/******/ for(var id in hotUpdate) { 395/******/ if(Object.prototype.hasOwnProperty.call(hotUpdate, id)) { 396/******/ moduleId = toModuleId(id); 397/******/ var result; 398/******/ if(hotUpdate[id]) { 399/******/ result = getAffectedStuff(moduleId); 400/******/ } else { 401/******/ result = { 402/******/ type: "disposed",
vendor: 9,649 bytes, lines 403-662
403/******/ moduleId: id 404/******/ }; 405/******/ } 406/******/ var abortError = false; 407/******/ var doApply = false; 408/******/ var doDispose = false; 409/******/ var chainInfo = ""; 410/******/ if(result.chain) { 411/******/ chainInfo = "\nUpdate propagation: " + result.chain.join(" -> "); 412/******/ } 413/******/ switch(result.type) { 414/******/ case "self-declined": 415/******/ if(options.onDeclined) 416/******/ options.onDeclined(result); 417/******/ if(!options.ignoreDeclined) 418/******/ abortError = new Error("Aborted because of self decline: " + result.moduleId + chainInfo); 419/******/ break; 420/******/ case "declined": 421/******/ if(options.onDeclined) 422/******/ options.onDeclined(result); 423/******/ if(!options.ignoreDeclined) 424/******/ abortError = new Error("Aborted because of declined dependency: " + result.moduleId + " in " + result.parentId + chainInfo); 425/******/ break; 426/******/ case "unaccepted": 427/******/ if(options.onUnaccepted) 428/******/ options.onUnaccepted(result); 429/******/ if(!options.ignoreUnaccepted) 430/******/ abortError = new Error("Aborted because " + moduleId + " is not accepted" + chainInfo); 431/******/ break; 432/******/ case "accepted": 433/******/ if(options.onAccepted) 434/******/ options.onAccepted(result); 435/******/ doApply = true; 436/******/ break; 437/******/ case "disposed": 438/******/ if(options.onDisposed) 439/******/ options.onDisposed(result); 440/******/ doDispose = true; 441/******/ break; 442/******/ default: 443/******/ throw new Error("Unexception type " + result.type); 444/******/ } 445/******/ if(abortError) { 446/******/ hotSetStatus("abort"); 447/******/ return Promise.reject(abortError); 448/******/ } 449/******/ if(doApply) { 450/******/ appliedUpdate[moduleId] = hotUpdate[moduleId]; 451/******/ addAllToSet(outdatedModules, result.outdatedModules); 452/******/ for(moduleId in result.outdatedDependencies) { 453/******/ if(Object.prototype.hasOwnProperty.call(result.outdatedDependencies, moduleId)) { 454/******/ if(!outdatedDependencies[moduleId]) 455/******/ outdatedDependencies[moduleId] = []; 456/******/ addAllToSet(outdatedDependencies[moduleId], result.outdatedDependencies[moduleId]); 457/******/ } 458/******/ } 459/******/ } 460/******/ if(doDispose) { 461/******/ addAllToSet(outdatedModules, [result.moduleId]); 462/******/ appliedUpdate[moduleId] = warnUnexpectedRequire; 463/******/ } 464/******/ } 465/******/ } 466/******/ 467/******/ // Store self accepted outdated modules to require them later by the module system 468/******/ var outdatedSelfAcceptedModules = []; 469/******/ for(i = 0; i < outdatedModules.length; i++) { 470/******/ moduleId = outdatedModules[i]; 471/******/ if(installedModules[moduleId] && installedModules[moduleId].hot._selfAccepted) 472/******/ outdatedSelfAcceptedModules.push({ 473/******/ module: moduleId, 474/******/ errorHandler: installedModules[moduleId].hot._selfAccepted 475/******/ }); 476/******/ } 477/******/ 478/******/ // Now in "dispose" phase 479/******/ hotSetStatus("dispose"); 480/******/ Object.keys(hotAvailableFilesMap).forEach(function(chunkId) { 481/******/ if(hotAvailableFilesMap[chunkId] === false) { 482/******/ hotDisposeChunk(chunkId); 483/******/ } 484/******/ }); 485/******/ 486/******/ var idx; 487/******/ var queue = outdatedModules.slice(); 488/******/ while(queue.length > 0) { 489/******/ moduleId = queue.pop(); 490/******/ module = installedModules[moduleId]; 491/******/ if(!module) continue; 492/******/ 493/******/ var data = {}; 494/******/ 495/******/ // Call dispose handlers 496/******/ var disposeHandlers = module.hot._disposeHandlers; 497/******/ for(j = 0; j < disposeHandlers.length; j++) { 498/******/ cb = disposeHandlers[j]; 499/******/ cb(data); 500/******/ } 501/******/ hotCurrentModuleData[moduleId] = data; 502/******/ 503/******/ // disable module (this disables requires from this module) 504/******/ module.hot.active = false; 505/******/ 506/******/ // remove module from cache 507/******/ delete installedModules[moduleId]; 508/******/ 509/******/ // remove "parents" references from all children 510/******/ for(j = 0; j < module.children.length; j++) { 511/******/ var child = installedModules[module.children[j]]; 512/******/ if(!child) continue; 513/******/ idx = child.parents.indexOf(moduleId); 514/******/ if(idx >= 0) { 515/******/ child.parents.splice(idx, 1); 516/******/ } 517/******/ } 518/******/ } 519/******/ 520/******/ // remove outdated dependency from module children 521/******/ var dependency; 522/******/ var moduleOutdatedDependencies; 523/******/ for(moduleId in outdatedDependencies) { 524/******/ if(Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)) { 525/******/ module = installedModules[moduleId]; 526/******/ if(module) { 527/******/ moduleOutdatedDependencies = outdatedDependencies[moduleId]; 528/******/ for(j = 0; j < moduleOutdatedDependencies.length; j++) { 529/******/ dependency = moduleOutdatedDependencies[j]; 530/******/ idx = module.children.indexOf(dependency); 531/******/ if(idx >= 0) module.children.splice(idx, 1); 532/******/ } 533/******/ } 534/******/ } 535/******/ } 536/******/ 537/******/ // Not in "apply" phase 538/******/ hotSetStatus("apply"); 539/******/ 540/******/ hotCurrentHash = hotUpdateNewHash; 541/******/ 542/******/ // insert new code 543/******/ for(moduleId in appliedUpdate) { 544/******/ if(Object.prototype.hasOwnProperty.call(appliedUpdate, moduleId)) { 545/******/ modules[moduleId] = appliedUpdate[moduleId]; 546/******/ } 547/******/ } 548/******/ 549/******/ // call accept handlers 550/******/ var error = null; 551/******/ for(moduleId in outdatedDependencies) { 552/******/ if(Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)) { 553/******/ module = installedModules[moduleId]; 554/******/ moduleOutdatedDependencies = outdatedDependencies[moduleId]; 555/******/ var callbacks = []; 556/******/ for(i = 0; i < moduleOutdatedDependencies.length; i++) { 557/******/ dependency = moduleOutdatedDependencies[i]; 558/******/ cb = module.hot._acceptedDependencies[dependency]; 559/******/ if(callbacks.indexOf(cb) >= 0) continue; 560/******/ callbacks.push(cb); 561/******/ } 562/******/ for(i = 0; i < callbacks.length; i++) { 563/******/ cb = callbacks[i]; 564/******/ try { 565/******/ cb(moduleOutdatedDependencies); 566/******/ } catch(err) { 567/******/ if(options.onErrored) { 568/******/ options.onErrored({ 569/******/ type: "accept-errored", 570/******/ moduleId: moduleId, 571/******/ dependencyId: moduleOutdatedDependencies[i], 572/******/ error: err 573/******/ }); 574/******/ } 575/******/ if(!options.ignoreErrored) { 576/******/ if(!error) 577/******/ error = err; 578/******/ } 579/******/ } 580/******/ } 581/******/ } 582/******/ } 583/******/ 584/******/ // Load self accepted modules 585/******/ for(i = 0; i < outdatedSelfAcceptedModules.length; i++) { 586/******/ var item = outdatedSelfAcceptedModules[i]; 587/******/ moduleId = item.module; 588/******/ hotCurrentParents = [moduleId]; 589/******/ try { 590/******/ __webpack_require__(moduleId); 591/******/ } catch(err) { 592/******/ if(typeof item.errorHandler === "function") { 593/******/ try { 594/******/ item.errorHandler(err); 595/******/ } catch(err2) { 596/******/ if(options.onErrored) { 597/******/ options.onErrored({ 598/******/ type: "self-accept-error-handler-errored", 599/******/ moduleId: moduleId, 600/******/ error: err2, 601/******/ orginalError: err 602/******/ }); 603/******/ } 604/******/ if(!options.ignoreErrored) { 605/******/ if(!error) 606/******/ error = err2; 607/******/ } 608/******/ if(!error) 609/******/ error = err; 610/******/ } 611/******/ } else { 612/******/ if(options.onErrored) { 613/******/ options.onErrored({ 614/******/ type: "self-accept-errored", 615/******/ moduleId: moduleId, 616/******/ error: err 617/******/ }); 618/******/ } 619/******/ if(!options.ignoreErrored) { 620/******/ if(!error) 621/******/ error = err; 622/******/ } 623/******/ } 624/******/ } 625/******/ } 626/******/ 627/******/ // handle errors in accept handlers and self accepted module load 628/******/ if(error) { 629/******/ hotSetStatus("fail"); 630/******/ return Promise.reject(error); 631/******/ } 632/******/ 633/******/ hotSetStatus("idle"); 634/******/ return new Promise(function(resolve) { 635/******/ resolve(outdatedModules); 636/******/ }); 637/******/ } 638/******/ 639/******/ // The module cache 640/******/ var installedModules = {}; 641/******/ 642/******/ // The require function 643/******/ function __webpack_require__(moduleId) { 644/******/ 645/******/ // Check if module is in cache 646/******/ if(installedModules[moduleId]) { 647/******/ return installedModules[moduleId].exports; 648/******/ } 649/******/ // Create a new module (and put it into the cache) 650/******/ var module = installedModules[moduleId] = { 651/******/ i: moduleId, 652/******/ l: false, 653/******/ exports: {}, 654/******/ hot: hotCreateModule(moduleId), 655/******/ parents: (hotCurrentParentsTemp = hotCurrentParents, hotCurrentParents = [], hotCurrentParentsTemp), 656/******/ children: [] 657/******/ }; 658/******/ 659/******/ // Execute the module function 660/******/ modules[moduleId].call(module.exports, module, module.exports, hotCreateRequire(moduleId)); 661/******/ 662/******/ // Flag the module as loaded
663/******/ module.l = true; 664/******/ 665/******/ // Return the exports of the module 666/******/ return module.exports; 667/******/ } 668/******/ 669/******/ 670/******/ // expose the modules object (__webpack_modules__) 671/******/ __webpack_require__.m = modules; 672/******/ 673/******/ // expose the module cache 674/******/ __webpack_require__.c = installedModules; 675/******/ 676/******/ // identity function for calling harmony imports with the correct context 677/******/ __webpack_require__.i = function(value) { return value; }; 678/******/ 679/******/ // define getter function for harmony exports 680/******/ __webpack_require__.d = function(exports, name, getter) { 681/******/ if(!__webpack_require__.o(exports, name)) { 682/******/ Object.defineProperty(exports, name, { 683/******/ configurable: false, 684/******/ enumerable: true, 685/******/ get: getter 686/******/ }); 687/******/ } 688/******/ }; 689/******/ 690/******/ // getDefaultExport function for compatibility with non-harmony modules 691/******/ __webpack_require__.n = function(module) { 692/******/ var getter = module && module.__esModule ? 693/******/ function getDefault() { return module['default']; } : 694/******/ function getModuleExports() { return module; }; 695/******/ __webpack_require__.d(getter, 'a', getter); 696/******/ return getter; 697/******/ }; 698/******/ 699/******/ // Object.prototype.hasOwnProperty.call 700/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; 701/******/ 702/******/ // __webpack_public_path__ 703/******/ __webpack_require__.p = "/"; 704/******/ 705/******/ // __webpack_hash__ 706/******/ __webpack_require__.h = function() { return hotCurrentHash; }; 707/******/ 708/******/ // Load entry module and return exports 709/******/ return hotCreateRequire(243)(__webpack_require__.s = 243); 710/******/ }) 711/************************************************************************/ 712/******/ ([ 713/* 0 */ 714/***/ (function(module, exports, __webpack_require__) { 715 716/* WEBPACK VAR INJECTION */(function(module) {var require;//! moment.js 717 718;(function (global, factory) { 719 true ? module.exports = factory() : 720 typeof define === 'function' && define.amd ? define(factory) : 721 global.moment = factory()
vendor: 35,273 bytes, lines 721-1860
721 722}(this, (function () { 'use strict'; 723 724 var hookCallback; 725 726 function hooks () { 727 return hookCallback.apply(null, arguments); 728 } 729 730 // This is done to register the method called with moment() 731 // without creating circular dependencies. 732 function setHookCallback (callback) { 733 hookCallback = callback; 734 } 735 736 function isArray(input) { 737 return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]'; 738 } 739 740 function isObject(input) { 741 // IE8 will treat undefined and null as object if it wasn't for 742 // input != null 743 return input != null && Object.prototype.toString.call(input) === '[object Object]'; 744 } 745 746 function isObjectEmpty(obj) { 747 if (Object.getOwnPropertyNames) { 748 return (Object.getOwnPropertyNames(obj).length === 0); 749 } else { 750 var k; 751 for (k in obj) { 752 if (obj.hasOwnProperty(k)) { 753 return false; 754 } 755 } 756 return true; 757 } 758 } 759 760 function isUndefined(input) { 761 return input === void 0; 762 } 763 764 function isNumber(input) { 765 return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]'; 766 } 767 768 function isDate(input) { 769 return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]'; 770 } 771 772 function map(arr, fn) { 773 var res = [], i; 774 for (i = 0; i < arr.length; ++i) { 775 res.push(fn(arr[i], i)); 776 } 777 return res; 778 } 779 780 function hasOwnProp(a, b) { 781 return Object.prototype.hasOwnProperty.call(a, b); 782 } 783 784 function extend(a, b) { 785 for (var i in b) { 786 if (hasOwnProp(b, i)) { 787 a[i] = b[i]; 788 } 789 } 790 791 if (hasOwnProp(b, 'toString')) { 792 a.toString = b.toString; 793 } 794 795 if (hasOwnProp(b, 'valueOf')) { 796 a.valueOf = b.valueOf; 797 } 798 799 return a; 800 } 801 802 function createUTC (input, format, locale, strict) { 803 return createLocalOrUTC(input, format, locale, strict, true).utc(); 804 } 805 806 function defaultParsingFlags() { 807 // We need to deep clone this object. 808 return { 809 empty : false, 810 unusedTokens : [], 811 unusedInput : [], 812 overflow : -2, 813 charsLeftOver : 0, 814 nullInput : false, 815 invalidMonth : null, 816 invalidFormat : false, 817 userInvalidated : false, 818 iso : false, 819 parsedDateParts : [], 820 meridiem : null, 821 rfc2822 : false, 822 weekdayMismatch : false 823 }; 824 } 825 826 function getParsingFlags(m) { 827 if (m._pf == null) { 828 m._pf = defaultParsingFlags(); 829 } 830 return m._pf; 831 } 832 833 var some; 834 if (Array.prototype.some) { 835 some = Array.prototype.some; 836 } else { 837 some = function (fun) { 838 var t = Object(this); 839 var len = t.length >>> 0; 840 841 for (var i = 0; i < len; i++) { 842 if (i in t && fun.call(this, t[i], i, t)) { 843 return true; 844 } 845 } 846 847 return false; 848 }; 849 } 850 851 function isValid(m) { 852 if (m._isValid == null) { 853 var flags = getParsingFlags(m); 854 var parsedParts = some.call(flags.parsedDateParts, function (i) { 855 return i != null; 856 }); 857 var isNowValid = !isNaN(m._d.getTime()) && 858 flags.overflow < 0 && 859 !flags.empty && 860 !flags.invalidMonth && 861 !flags.invalidWeekday && 862 !flags.weekdayMismatch && 863 !flags.nullInput && 864 !flags.invalidFormat && 865 !flags.userInvalidated && 866 (!flags.meridiem || (flags.meridiem && parsedParts)); 867 868 if (m._strict) { 869 isNowValid = isNowValid && 870 flags.charsLeftOver === 0 && 871 flags.unusedTokens.length === 0 && 872 flags.bigHour === undefined; 873 } 874 875 if (Object.isFrozen == null || !Object.isFrozen(m)) { 876 m._isValid = isNowValid; 877 } 878 else { 879 return isNowValid; 880 } 881 } 882 return m._isValid; 883 } 884 885 function createInvalid (flags) { 886 var m = createUTC(NaN); 887 if (flags != null) { 888 extend(getParsingFlags(m), flags); 889 } 890 else { 891 getParsingFlags(m).userInvalidated = true; 892 } 893 894 return m; 895 } 896 897 // Plugins that add properties should also add the key here (null value), 898 // so we can properly clone ourselves. 899 var momentProperties = hooks.momentProperties = []; 900 901 function copyConfig(to, from) { 902 var i, prop, val; 903 904 if (!isUndefined(from._isAMomentObject)) { 905 to._isAMomentObject = from._isAMomentObject; 906 } 907 if (!isUndefined(from._i)) { 908 to._i = from._i; 909 } 910 if (!isUndefined(from._f)) { 911 to._f = from._f; 912 } 913 if (!isUndefined(from._l)) { 914 to._l = from._l; 915 } 916 if (!isUndefined(from._strict)) { 917 to._strict = from._strict; 918 } 919 if (!isUndefined(from._tzm)) { 920 to._tzm = from._tzm; 921 } 922 if (!isUndefined(from._isUTC)) { 923 to._isUTC = from._isUTC; 924 } 925 if (!isUndefined(from._offset)) { 926 to._offset = from._offset; 927 } 928 if (!isUndefined(from._pf)) { 929 to._pf = getParsingFlags(from); 930 } 931 if (!isUndefined(from._locale)) { 932 to._locale = from._locale; 933 } 934 935 if (momentProperties.length > 0) { 936 for (i = 0; i < momentProperties.length; i++) { 937 prop = momentProperties[i]; 938 val = from[prop]; 939 if (!isUndefined(val)) { 940 to[prop] = val; 941 } 942 } 943 } 944 945 return to; 946 } 947 948 var updateInProgress = false; 949 950 // Moment prototype object 951 function Moment(config) { 952 copyConfig(this, config); 953 this._d = new Date(config._d != null ? config._d.getTime() : NaN); 954 if (!this.isValid()) { 955 this._d = new Date(NaN); 956 } 957 // Prevent infinite loop in case updateOffset creates new moment 958 // objects. 959 if (updateInProgress === false) { 960 updateInProgress = true; 961 hooks.updateOffset(this); 962 updateInProgress = false; 963 } 964 } 965 966 function isMoment (obj) { 967 return obj instanceof Moment || (obj != null && obj._isAMomentObject != null); 968 } 969 970 function absFloor (number) { 971 if (number < 0) { 972 // -0 -> 0 973 return Math.ceil(number) || 0; 974 } else { 975 return Math.floor(number); 976 } 977 } 978 979 function toInt(argumentForCoercion) { 980 var coercedNumber = +argumentForCoercion, 981 value = 0; 982 983 if (coercedNumber !== 0 && isFinite(coercedNumber)) { 984 value = absFloor(coercedNumber); 985 } 986 987 return value; 988 } 989 990 // compare two arrays, return the number of differences 991 function compareArrays(array1, array2, dontConvert) { 992 var len = Math.min(array1.length, array2.length), 993 lengthDiff = Math.abs(array1.length - array2.length), 994 diffs = 0, 995 i; 996 for (i = 0; i < len; i++) { 997 if ((dontConvert && array1[i] !== array2[i]) || 998 (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) { 999 diffs++; 1000 } 1001 } 1002 return diffs + lengthDiff; 1003 } 1004 1005 function warn(msg) { 1006 if (hooks.suppressDeprecationWarnings === false && 1007 (typeof console !== 'undefined') && console.warn) { 1008 console.warn('Deprecation warning: ' + msg); 1009 } 1010 } 1011 1012 function deprecate(msg, fn) { 1013 var firstTime = true; 1014 1015 return extend(function () { 1016 if (hooks.deprecationHandler != null) { 1017 hooks.deprecationHandler(null, msg); 1018 } 1019 if (firstTime) { 1020 var args = []; 1021 var arg; 1022 for (var i = 0; i < arguments.length; i++) { 1023 arg = ''; 1024 if (typeof arguments[i] === 'object') { 1025 arg += '\n[' + i + '] '; 1026 for (var key in arguments[0]) { 1027 arg += key + ': ' + arguments[0][key] + ', '; 1028 } 1029 arg = arg.slice(0, -2); // Remove trailing comma and space 1030 } else { 1031 arg = arguments[i]; 1032 } 1033 args.push(arg); 1034 } 1035 warn(msg + '\nArguments: ' + Array.prototype.slice.call(args).join('') + '\n' + (new Error()).stack); 1036 firstTime = false; 1037 } 1038 return fn.apply(this, arguments); 1039 }, fn); 1040 } 1041 1042 var deprecations = {}; 1043 1044 function deprecateSimple(name, msg) { 1045 if (hooks.deprecationHandler != null) { 1046 hooks.deprecationHandler(name, msg); 1047 } 1048 if (!deprecations[name]) { 1049 warn(msg); 1050 deprecations[name] = true; 1051 } 1052 } 1053 1054 hooks.suppressDeprecationWarnings = false; 1055 hooks.deprecationHandler = null; 1056 1057 function isFunction(input) { 1058 return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]'; 1059 } 1060 1061 function set (config) { 1062 var prop, i; 1063 for (i in config) { 1064 prop = config[i]; 1065 if (isFunction(prop)) { 1066 this[i] = prop; 1067 } else { 1068 this['_' + i] = prop; 1069 } 1070 } 1071 this._config = config; 1072 // Lenient ordinal parsing accepts just a number in addition to 1073 // number + (possibly) stuff coming from _dayOfMonthOrdinalParse. 1074 // TODO: Remove "ordinalParse" fallback in next major release. 1075 this._dayOfMonthOrdinalParseLenient = new RegExp( 1076 (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) + 1077 '|' + (/\d{1,2}/).source); 1078 } 1079 1080 function mergeConfigs(parentConfig, childConfig) { 1081 var res = extend({}, parentConfig), prop; 1082 for (prop in childConfig) { 1083 if (hasOwnProp(childConfig, prop)) { 1084 if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) { 1085 res[prop] = {}; 1086 extend(res[prop], parentConfig[prop]); 1087 extend(res[prop], childConfig[prop]); 1088 } else if (childConfig[prop] != null) { 1089 res[prop] = childConfig[prop]; 1090 } else { 1091 delete res[prop]; 1092 } 1093 } 1094 } 1095 for (prop in parentConfig) { 1096 if (hasOwnProp(parentConfig, prop) && 1097 !hasOwnProp(childConfig, prop) && 1098 isObject(parentConfig[prop])) { 1099 // make sure changes to properties don't modify parent config 1100 res[prop] = extend({}, res[prop]); 1101 } 1102 } 1103 return res; 1104 } 1105 1106 function Locale(config) { 1107 if (config != null) { 1108 this.set(config); 1109 } 1110 } 1111 1112 var keys; 1113 1114 if (Object.keys) { 1115 keys = Object.keys; 1116 } else { 1117 keys = function (obj) { 1118 var i, res = []; 1119 for (i in obj) { 1120 if (hasOwnProp(obj, i)) { 1121 res.push(i); 1122 } 1123 } 1124 return res; 1125 }; 1126 } 1127 1128 var defaultCalendar = { 1129 sameDay : '[Today at] LT', 1130 nextDay : '[Tomorrow at] LT', 1131 nextWeek : 'dddd [at] LT', 1132 lastDay : '[Yesterday at] LT', 1133 lastWeek : '[Last] dddd [at] LT', 1134 sameElse : 'L' 1135 }; 1136 1137 function calendar (key, mom, now) { 1138 var output = this._calendar[key] || this._calendar['sameElse']; 1139 return isFunction(output) ? output.call(mom, now) : output; 1140 } 1141 1142 var defaultLongDateFormat = { 1143 LTS : 'h:mm:ss A', 1144 LT : 'h:mm A', 1145 L : 'MM/DD/YYYY', 1146 LL : 'MMMM D, YYYY', 1147 LLL : 'MMMM D, YYYY h:mm A', 1148 LLLL : 'dddd, MMMM D, YYYY h:mm A' 1149 }; 1150 1151 function longDateFormat (key) { 1152 var format = this._longDateFormat[key], 1153 formatUpper = this._longDateFormat[key.toUpperCase()]; 1154 1155 if (format || !formatUpper) { 1156 return format; 1157 } 1158 1159 this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) { 1160 return val.slice(1); 1161 }); 1162 1163 return this._longDateFormat[key]; 1164 } 1165 1166 var defaultInvalidDate = 'Invalid date'; 1167 1168 function invalidDate () { 1169 return this._invalidDate; 1170 } 1171 1172 var defaultOrdinal = '%d'; 1173 var defaultDayOfMonthOrdinalParse = /\d{1,2}/; 1174 1175 function ordinal (number) { 1176 return this._ordinal.replace('%d', number); 1177 } 1178 1179 var defaultRelativeTime = { 1180 future : 'in %s', 1181 past : '%s ago', 1182 s : 'a few seconds', 1183 ss : '%d seconds', 1184 m : 'a minute', 1185 mm : '%d minutes', 1186 h : 'an hour', 1187 hh : '%d hours', 1188 d : 'a day', 1189 dd : '%d days', 1190 M : 'a month', 1191 MM : '%d months', 1192 y : 'a year', 1193 yy : '%d years' 1194 }; 1195 1196 function relativeTime (number, withoutSuffix, string, isFuture) { 1197 var output = this._relativeTime[string]; 1198 return (isFunction(output)) ? 1199 output(number, withoutSuffix, string, isFuture) : 1200 output.replace(/%d/i, number); 1201 } 1202 1203 function pastFuture (diff, output) { 1204 var format = this._relativeTime[diff > 0 ? 'future' : 'past']; 1205 return isFunction(format) ? format(output) : format.replace(/%s/i, output); 1206 } 1207 1208 var aliases = {}; 1209 1210 function addUnitAlias (unit, shorthand) { 1211 var lowerCase = unit.toLowerCase(); 1212 aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit; 1213 } 1214 1215 function normalizeUnits(units) { 1216 return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined; 1217 } 1218 1219 function normalizeObjectUnits(inputObject) { 1220 var normalizedInput = {}, 1221 normalizedProp, 1222 prop; 1223 1224 for (prop in inputObject) { 1225 if (hasOwnProp(inputObject, prop)) { 1226 normalizedProp = normalizeUnits(prop); 1227 if (normalizedProp) { 1228 normalizedInput[normalizedProp] = inputObject[prop]; 1229 } 1230 } 1231 } 1232 1233 return normalizedInput; 1234 } 1235 1236 var priorities = {}; 1237 1238 function addUnitPriority(unit, priority) { 1239 priorities[unit] = priority; 1240 } 1241 1242 function getPrioritizedUnits(unitsObj) { 1243 var units = []; 1244 for (var u in unitsObj) { 1245 units.push({unit: u, priority: priorities[u]}); 1246 } 1247 units.sort(function (a, b) { 1248 return a.priority - b.priority; 1249 }); 1250 return units; 1251 } 1252 1253 function zeroFill(number, targetLength, forceSign) { 1254 var absNumber = '' + Math.abs(number), 1255 zerosToFill = targetLength - absNumber.length, 1256 sign = number >= 0; 1257 return (sign ? (forceSign ? '+' : '') : '-') + 1258 Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber; 1259 } 1260 1261 var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g; 1262 1263 var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g; 1264 1265 var formatFunctions = {}; 1266 1267 var formatTokenFunctions = {}; 1268 1269 // token: 'M' 1270 // padded: ['MM', 2] 1271 // ordinal: 'Mo' 1272 // callback: function () { this.month() + 1 } 1273 function addFormatToken (token, padded, ordinal, callback) { 1274 var func = callback; 1275 if (typeof callback === 'string') { 1276 func = function () { 1277 return this[callback](); 1278 }; 1279 } 1280 if (token) { 1281 formatTokenFunctions[token] = func; 1282 } 1283 if (padded) { 1284 formatTokenFunctions[padded[0]] = function () { 1285 return zeroFill(func.apply(this, arguments), padded[1], padded[2]); 1286 }; 1287 } 1288 if (ordinal) { 1289 formatTokenFunctions[ordinal] = function () { 1290 return this.localeData().ordinal(func.apply(this, arguments), token); 1291 }; 1292 } 1293 } 1294 1295 function removeFormattingTokens(input) { 1296 if (input.match(/\[[\s\S]/)) { 1297 return input.replace(/^\[|\]$/g, ''); 1298 } 1299 return input.replace(/\\/g, ''); 1300 } 1301 1302 function makeFormatFunction(format) { 1303 var array = format.match(formattingTokens), i, length; 1304 1305 for (i = 0, length = array.length; i < length; i++) { 1306 if (formatTokenFunctions[array[i]]) { 1307 array[i] = formatTokenFunctions[array[i]]; 1308 } else { 1309 array[i] = removeFormattingTokens(array[i]); 1310 } 1311 } 1312 1313 return function (mom) { 1314 var output = '', i; 1315 for (i = 0; i < length; i++) { 1316 output += isFunction(array[i]) ? array[i].call(mom, format) : array[i]; 1317 } 1318 return output; 1319 }; 1320 } 1321 1322 // format date using native date object 1323 function formatMoment(m, format) { 1324 if (!m.isValid()) { 1325 return m.localeData().invalidDate(); 1326 } 1327 1328 format = expandFormat(format, m.localeData()); 1329 formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format); 1330 1331 return formatFunctions[format](m); 1332 } 1333 1334 function expandFormat(format, locale) { 1335 var i = 5; 1336 1337 function replaceLongDateFormatTokens(input) { 1338 return locale.longDateFormat(input) || input; 1339 } 1340 1341 localFormattingTokens.lastIndex = 0; 1342 while (i >= 0 && localFormattingTokens.test(format)) { 1343 format = format.replace(localFormattingTokens, replaceLongDateFormatTokens); 1344 localFormattingTokens.lastIndex = 0; 1345 i -= 1; 1346 } 1347 1348 return format; 1349 } 1350 1351 var match1 = /\d/; // 0 - 9 1352 var match2 = /\d\d/; // 00 - 99 1353 var match3 = /\d{3}/; // 000 - 999 1354 var match4 = /\d{4}/; // 0000 - 9999 1355 var match6 = /[+-]?\d{6}/; // -999999 - 999999 1356 var match1to2 = /\d\d?/; // 0 - 99 1357 var match3to4 = /\d\d\d\d?/; // 999 - 9999 1358 var match5to6 = /\d\d\d\d\d\d?/; // 99999 - 999999 1359 var match1to3 = /\d{1,3}/; // 0 - 999 1360 var match1to4 = /\d{1,4}/; // 0 - 9999 1361 var match1to6 = /[+-]?\d{1,6}/; // -999999 - 999999 1362 1363 var matchUnsigned = /\d+/; // 0 - inf 1364 var matchSigned = /[+-]?\d+/; // -inf - inf 1365 1366 var matchOffset = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z 1367 var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z 1368 1369 var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123 1370 1371 // any word (or two) characters or numbers including two/three word month in arabic. 1372 // includes scottish gaelic two word and hyphenated months 1373 var matchWord = /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i; 1374 1375 var regexes = {}; 1376 1377 function addRegexToken (token, regex, strictRegex) { 1378 regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) { 1379 return (isStrict && strictRegex) ? strictRegex : regex; 1380 }; 1381 } 1382 1383 function getParseRegexForToken (token, config) { 1384 if (!hasOwnProp(regexes, token)) { 1385 return new RegExp(unescapeFormat(token)); 1386 } 1387 1388 return regexes[token](config._strict, config._locale); 1389 } 1390 1391 // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript 1392 function unescapeFormat(s) { 1393 return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) { 1394 return p1 || p2 || p3 || p4; 1395 })); 1396 } 1397 1398 function regexEscape(s) { 1399 return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'); 1400 } 1401 1402 var tokens = {}; 1403 1404 function addParseToken (token, callback) { 1405 var i, func = callback; 1406 if (typeof token === 'string') { 1407 token = [token]; 1408 } 1409 if (isNumber(callback)) { 1410 func = function (input, array) { 1411 array[callback] = toInt(input); 1412 }; 1413 } 1414 for (i = 0; i < token.length; i++) { 1415 tokens[token[i]] = func; 1416 } 1417 } 1418 1419 function addWeekParseToken (token, callback) { 1420 addParseToken(token, function (input, array, config, token) { 1421 config._w = config._w || {}; 1422 callback(input, config._w, config, token); 1423 }); 1424 } 1425 1426 function addTimeToArrayFromToken(token, input, config) { 1427 if (input != null && hasOwnProp(tokens, token)) { 1428 tokens[token](input, config._a, config, token); 1429 } 1430 } 1431 1432 var YEAR = 0; 1433 var MONTH = 1; 1434 var DATE = 2; 1435 var HOUR = 3; 1436 var MINUTE = 4; 1437 var SECOND = 5; 1438 var MILLISECOND = 6; 1439 var WEEK = 7; 1440 var WEEKDAY = 8; 1441 1442 // FORMATTING 1443 1444 addFormatToken('Y', 0, 0, function () { 1445 var y = this.year(); 1446 return y <= 9999 ? '' + y : '+' + y; 1447 }); 1448 1449 addFormatToken(0, ['YY', 2], 0, function () { 1450 return this.year() % 100; 1451 }); 1452 1453 addFormatToken(0, ['YYYY', 4], 0, 'year'); 1454 addFormatToken(0, ['YYYYY', 5], 0, 'year'); 1455 addFormatToken(0, ['YYYYYY', 6, true], 0, 'year'); 1456 1457 // ALIASES 1458 1459 addUnitAlias('year', 'y'); 1460 1461 // PRIORITIES 1462 1463 addUnitPriority('year', 1); 1464 1465 // PARSING 1466 1467 addRegexToken('Y', matchSigned); 1468 addRegexToken('YY', match1to2, match2); 1469 addRegexToken('YYYY', match1to4, match4); 1470 addRegexToken('YYYYY', match1to6, match6); 1471 addRegexToken('YYYYYY', match1to6, match6); 1472 1473 addParseToken(['YYYYY', 'YYYYYY'], YEAR); 1474 addParseToken('YYYY', function (input, array) { 1475 array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input); 1476 }); 1477 addParseToken('YY', function (input, array) { 1478 array[YEAR] = hooks.parseTwoDigitYear(input); 1479 }); 1480 addParseToken('Y', function (input, array) { 1481 array[YEAR] = parseInt(input, 10); 1482 }); 1483 1484 // HELPERS 1485 1486 function daysInYear(year) { 1487 return isLeapYear(year) ? 366 : 365; 1488 } 1489 1490 function isLeapYear(year) { 1491 return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0; 1492 } 1493 1494 // HOOKS 1495 1496 hooks.parseTwoDigitYear = function (input) { 1497 return toInt(input) + (toInt(input) > 68 ? 1900 : 2000); 1498 }; 1499 1500 // MOMENTS 1501 1502 var getSetYear = makeGetSet('FullYear', true); 1503 1504 function getIsLeapYear () { 1505 return isLeapYear(this.year()); 1506 } 1507 1508 function makeGetSet (unit, keepTime) { 1509 return function (value) { 1510 if (value != null) { 1511 set$1(this, unit, value); 1512 hooks.updateOffset(this, keepTime); 1513 return this; 1514 } else { 1515 return get(this, unit); 1516 } 1517 }; 1518 } 1519 1520 function get (mom, unit) { 1521 return mom.isValid() ? 1522 mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN; 1523 } 1524 1525 function set$1 (mom, unit, value) { 1526 if (mom.isValid() && !isNaN(value)) { 1527 if (unit === 'FullYear' && isLeapYear(mom.year()) && mom.month() === 1 && mom.date() === 29) { 1528 mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value, mom.month(), daysInMonth(value, mom.month())); 1529 } 1530 else { 1531 mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value); 1532 } 1533 } 1534 } 1535 1536 // MOMENTS 1537 1538 function stringGet (units) { 1539 units = normalizeUnits(units); 1540 if (isFunction(this[units])) { 1541 return this[units](); 1542 } 1543 return this; 1544 } 1545 1546 1547 function stringSet (units, value) { 1548 if (typeof units === 'object') { 1549 units = normalizeObjectUnits(units); 1550 var prioritized = getPrioritizedUnits(units); 1551 for (var i = 0; i < prioritized.length; i++) { 1552 this[prioritized[i].unit](units[prioritized[i].unit]); 1553 } 1554 } else { 1555 units = normalizeUnits(units); 1556 if (isFunction(this[units])) { 1557 return this[units](value); 1558 } 1559 } 1560 return this; 1561 } 1562 1563 function mod(n, x) { 1564 return ((n % x) + x) % x; 1565 } 1566 1567 var indexOf; 1568 1569 if (Array.prototype.indexOf) { 1570 indexOf = Array.prototype.indexOf; 1571 } else { 1572 indexOf = function (o) { 1573 // I know 1574 var i; 1575 for (i = 0; i < this.length; ++i) { 1576 if (this[i] === o) { 1577 return i; 1578 } 1579 } 1580 return -1; 1581 }; 1582 } 1583 1584 function daysInMonth(year, month) { 1585 if (isNaN(year) || isNaN(month)) { 1586 return NaN; 1587 } 1588 var modMonth = mod(month, 12); 1589 year += (month - modMonth) / 12; 1590 return modMonth === 1 ? (isLeapYear(year) ? 29 : 28) : (31 - modMonth % 7 % 2); 1591 } 1592 1593 // FORMATTING 1594 1595 addFormatToken('M', ['MM', 2], 'Mo', function () { 1596 return this.month() + 1; 1597 }); 1598 1599 addFormatToken('MMM', 0, 0, function (format) { 1600 return this.localeData().monthsShort(this, format); 1601 }); 1602 1603 addFormatToken('MMMM', 0, 0, function (format) { 1604 return this.localeData().months(this, format); 1605 }); 1606 1607 // ALIASES 1608 1609 addUnitAlias('month', 'M'); 1610 1611 // PRIORITY 1612 1613 addUnitPriority('month', 8); 1614 1615 // PARSING 1616 1617 addRegexToken('M', match1to2); 1618 addRegexToken('MM', match1to2, match2); 1619 addRegexToken('MMM', function (isStrict, locale) { 1620 return locale.monthsShortRegex(isStrict); 1621 }); 1622 addRegexToken('MMMM', function (isStrict, locale) { 1623 return locale.monthsRegex(isStrict); 1624 }); 1625 1626 addParseToken(['M', 'MM'], function (input, array) { 1627 array[MONTH] = toInt(input) - 1; 1628 }); 1629 1630 addParseToken(['MMM', 'MMMM'], function (input, array, config, token) { 1631 var month = config._locale.monthsParse(input, token, config._strict); 1632 // if we didn't find a month name, mark the date as invalid. 1633 if (month != null) { 1634 array[MONTH] = month; 1635 } else { 1636 getParsingFlags(config).invalidMonth = input; 1637 } 1638 }); 1639 1640 // LOCALES 1641 1642 var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/; 1643 var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'); 1644 function localeMonths (m, format) { 1645 if (!m) { 1646 return isArray(this._months) ? this._months : 1647 this._months['standalone']; 1648 } 1649 return isArray(this._months) ? this._months[m.month()] : 1650 this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()]; 1651 } 1652 1653 var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'); 1654 function localeMonthsShort (m, format) { 1655 if (!m) { 1656 return isArray(this._monthsShort) ? this._monthsShort : 1657 this._monthsShort['standalone']; 1658 } 1659 return isArray(this._monthsShort) ? this._monthsShort[m.month()] : 1660 this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()]; 1661 } 1662 1663 function handleStrictParse(monthName, format, strict) { 1664 var i, ii, mom, llc = monthName.toLocaleLowerCase(); 1665 if (!this._monthsParse) { 1666 // this is not used 1667 this._monthsParse = []; 1668 this._longMonthsParse = []; 1669 this._shortMonthsParse = []; 1670 for (i = 0; i < 12; ++i) { 1671 mom = createUTC([2000, i]); 1672 this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase(); 1673 this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase(); 1674 } 1675 } 1676 1677 if (strict) { 1678 if (format === 'MMM') { 1679 ii = indexOf.call(this._shortMonthsParse, llc); 1680 return ii !== -1 ? ii : null; 1681 } else { 1682 ii = indexOf.call(this._longMonthsParse, llc); 1683 return ii !== -1 ? ii : null; 1684 } 1685 } else { 1686 if (format === 'MMM') { 1687 ii = indexOf.call(this._shortMonthsParse, llc); 1688 if (ii !== -1) { 1689 return ii; 1690 } 1691 ii = indexOf.call(this._longMonthsParse, llc); 1692 return ii !== -1 ? ii : null; 1693 } else { 1694 ii = indexOf.call(this._longMonthsParse, llc); 1695 if (ii !== -1) { 1696 return ii; 1697 } 1698 ii = indexOf.call(this._shortMonthsParse, llc); 1699 return ii !== -1 ? ii : null; 1700 } 1701 } 1702 } 1703 1704 function localeMonthsParse (monthName, format, strict) { 1705 var i, mom, regex; 1706 1707 if (this._monthsParseExact) { 1708 return handleStrictParse.call(this, monthName, format, strict); 1709 } 1710 1711 if (!this._monthsParse) { 1712 this._monthsParse = []; 1713 this._longMonthsParse = []; 1714 this._shortMonthsParse = []; 1715 } 1716 1717 // TODO: add sorting 1718 // Sorting makes sure if one month (or abbr) is a prefix of another 1719 // see sorting in computeMonthsParse 1720 for (i = 0; i < 12; i++) { 1721 // make the regex if we don't have it already 1722 mom = createUTC([2000, i]); 1723 if (strict && !this._longMonthsParse[i]) { 1724 this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i'); 1725 this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i'); 1726 } 1727 if (!strict && !this._monthsParse[i]) { 1728 regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, ''); 1729 this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i'); 1730 } 1731 // test the regex 1732 if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) { 1733 return i; 1734 } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) { 1735 return i; 1736 } else if (!strict && this._monthsParse[i].test(monthName)) { 1737 return i; 1738 } 1739 } 1740 } 1741 1742 // MOMENTS 1743 1744 function setMonth (mom, value) { 1745 var dayOfMonth; 1746 1747 if (!mom.isValid()) { 1748 // No op 1749 return mom; 1750 } 1751 1752 if (typeof value === 'string') { 1753 if (/^\d+$/.test(value)) { 1754 value = toInt(value); 1755 } else { 1756 value = mom.localeData().monthsParse(value); 1757 // TODO: Another silent failure? 1758 if (!isNumber(value)) { 1759 return mom; 1760 } 1761 } 1762 } 1763 1764 dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value)); 1765 mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth); 1766 return mom; 1767 } 1768 1769 function getSetMonth (value) { 1770 if (value != null) { 1771 setMonth(this, value); 1772 hooks.updateOffset(this, true); 1773 return this; 1774 } else { 1775 return get(this, 'Month'); 1776 } 1777 } 1778 1779 function getDaysInMonth () { 1780 return daysInMonth(this.year(), this.month()); 1781 } 1782 1783 var defaultMonthsShortRegex = matchWord; 1784 function monthsShortRegex (isStrict) { 1785 if (this._monthsParseExact) { 1786 if (!hasOwnProp(this, '_monthsRegex')) { 1787 computeMonthsParse.call(this); 1788 } 1789 if (isStrict) { 1790 return this._monthsShortStrictRegex; 1791 } else { 1792 return this._monthsShortRegex; 1793 } 1794 } else { 1795 if (!hasOwnProp(this, '_monthsShortRegex')) { 1796 this._monthsShortRegex = defaultMonthsShortRegex; 1797 } 1798 return this._monthsShortStrictRegex && isStrict ? 1799 this._monthsShortStrictRegex : this._monthsShortRegex; 1800 } 1801 } 1802 1803 var defaultMonthsRegex = matchWord; 1804 function monthsRegex (isStrict) { 1805 if (this._monthsParseExact) { 1806 if (!hasOwnProp(this, '_monthsRegex')) { 1807 computeMonthsParse.call(this); 1808 } 1809 if (isStrict) { 1810 return this._monthsStrictRegex; 1811 } else { 1812 return this._monthsRegex; 1813 } 1814 } else { 1815 if (!hasOwnProp(this, '_monthsRegex')) { 1816 this._monthsRegex = defaultMonthsRegex; 1817 } 1818 return this._monthsStrictRegex && isStrict ? 1819 this._monthsStrictRegex : this._monthsRegex; 1820 } 1821 } 1822 1823 function computeMonthsParse () { 1824 function cmpLenRev(a, b) { 1825 return b.length - a.length; 1826 } 1827 1828 var shortPieces = [], longPieces = [], mixedPieces = [], 1829 i, mom; 1830 for (i = 0; i < 12; i++) { 1831 // make the regex if we don't have it already 1832 mom = createUTC([2000, i]); 1833 shortPieces.push(this.monthsShort(mom, '')); 1834 longPieces.push(this.months(mom, '')); 1835 mixedPieces.push(this.months(mom, '')); 1836 mixedPieces.push(this.monthsShort(mom, '')); 1837 } 1838 // Sorting makes sure if one month (or abbr) is a prefix of another it 1839 // will match the longer piece. 1840 shortPieces.sort(cmpLenRev); 1841 longPieces.sort(cmpLenRev); 1842 mixedPieces.sort(cmpLenRev); 1843 for (i = 0; i < 12; i++) { 1844 shortPieces[i] = regexEscape(shortPieces[i]); 1845 longPieces[i] = regexEscape(longPieces[i]); 1846 } 1847 for (i = 0; i < 24; i++) { 1848 mixedPieces[i] = regexEscape(mixedPieces[i]); 1849 } 1850 1851 this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i'); 1852 this._monthsShortRegex = this._monthsRegex; 1853 this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i'); 1854 this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i'); 1855 } 1856 1857 function createDate (y, m, d, h, M, s, ms) { 1858 // can't just apply() to create a date: 1859 // https://stackoverflow.com/q/181348 1860 var date
vendor: 3,190 bytes, lines 1860-1962
1860 = new Date(y, m, d, h, M, s, ms); 1861 1862 // the date constructor remaps years 0-99 to 1900-1999 1863 if (y < 100 && y >= 0 && isFinite(date.getFullYear())) { 1864 date.setFullYear(y); 1865 } 1866 return date; 1867 } 1868 1869 function createUTCDate (y) { 1870 var date = new Date(Date.UTC.apply(null, arguments)); 1871 1872 // the Date.UTC function remaps years 0-99 to 1900-1999 1873 if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) { 1874 date.setUTCFullYear(y); 1875 } 1876 return date; 1877 } 1878 1879 // start-of-first-week - start-of-year 1880 function firstWeekOffset(year, dow, doy) { 1881 var // first-week day -- which january is always in the first week (4 for iso, 1 for other) 1882 fwd = 7 + dow - doy, 1883 // first-week day local weekday -- which local weekday is fwd 1884 fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7; 1885 1886 return -fwdlw + fwd - 1; 1887 } 1888 1889 // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday 1890 function dayOfYearFromWeeks(year, week, weekday, dow, doy) { 1891 var localWeekday = (7 + weekday - dow) % 7, 1892 weekOffset = firstWeekOffset(year, dow, doy), 1893 dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset, 1894 resYear, resDayOfYear; 1895 1896 if (dayOfYear <= 0) { 1897 resYear = year - 1; 1898 resDayOfYear = daysInYear(resYear) + dayOfYear; 1899 } else if (dayOfYear > daysInYear(year)) { 1900 resYear = year + 1; 1901 resDayOfYear = dayOfYear - daysInYear(year); 1902 } else { 1903 resYear = year; 1904 resDayOfYear = dayOfYear; 1905 } 1906 1907 return { 1908 year: resYear, 1909 dayOfYear: resDayOfYear 1910 }; 1911 } 1912 1913 function weekOfYear(mom, dow, doy) { 1914 var weekOffset = firstWeekOffset(mom.year(), dow, doy), 1915 week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1, 1916 resWeek, resYear; 1917 1918 if (week < 1) { 1919 resYear = mom.year() - 1; 1920 resWeek = week + weeksInYear(resYear, dow, doy); 1921 } else if (week > weeksInYear(mom.year(), dow, doy)) { 1922 resWeek = week - weeksInYear(mom.year(), dow, doy); 1923 resYear = mom.year() + 1; 1924 } else { 1925 resYear = mom.year(); 1926 resWeek = week; 1927 } 1928 1929 return { 1930 week: resWeek, 1931 year: resYear 1932 }; 1933 } 1934 1935 function weeksInYear(year, dow, doy) { 1936 var weekOffset = firstWeekOffset(year, dow, doy), 1937 weekOffsetNext = firstWeekOffset(year + 1, dow, doy); 1938 return (daysInYear(year) - weekOffset + weekOffsetNext) / 7; 1939 } 1940 1941 // FORMATTING 1942 1943 addFormatToken('w', ['ww', 2], 'wo', 'week'); 1944 addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek'); 1945 1946 // ALIASES 1947 1948 addUnitAlias('week', 'w'); 1949 addUnitAlias('isoWeek', 'W'); 1950 1951 // PRIORITIES 1952 1953 addUnitPriority('week', 5); 1954 addUnitPriority('isoWeek', 5); 1955 1956 // PARSING 1957 1958 addRegexToken('w', match1to2); 1959 addRegexToken('ww', match1to2, match2); 1960 addRegexToken('W', match1to2); 1961 addRegexToken('WW', match1to2, match2); 1962
vendor: 16,384 bytes, lines 1963-2445
1963 addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) { 1964 week[token.substr(0, 1)] = toInt(input); 1965 }); 1966 1967 // HELPERS 1968 1969 // LOCALES 1970 1971 function localeWeek (mom) { 1972 return weekOfYear(mom, this._week.dow, this._week.doy).week; 1973 } 1974 1975 var defaultLocaleWeek = { 1976 dow : 0, // Sunday is the first day of the week. 1977 doy : 6 // The week that contains Jan 1st is the first week of the year. 1978 }; 1979 1980 function localeFirstDayOfWeek () { 1981 return this._week.dow; 1982 } 1983 1984 function localeFirstDayOfYear () { 1985 return this._week.doy; 1986 } 1987 1988 // MOMENTS 1989 1990 function getSetWeek (input) { 1991 var week = this.localeData().week(this); 1992 return input == null ? week : this.add((input - week) * 7, 'd'); 1993 } 1994 1995 function getSetISOWeek (input) { 1996 var week = weekOfYear(this, 1, 4).week; 1997 return input == null ? week : this.add((input - week) * 7, 'd'); 1998 } 1999 2000 // FORMATTING 2001 2002 addFormatToken('d', 0, 'do', 'day'); 2003 2004 addFormatToken('dd', 0, 0, function (format) { 2005 return this.localeData().weekdaysMin(this, format); 2006 }); 2007 2008 addFormatToken('ddd', 0, 0, function (format) { 2009 return this.localeData().weekdaysShort(this, format); 2010 }); 2011 2012 addFormatToken('dddd', 0, 0, function (format) { 2013 return this.localeData().weekdays(this, format); 2014 }); 2015 2016 addFormatToken('e', 0, 0, 'weekday'); 2017 addFormatToken('E', 0, 0, 'isoWeekday'); 2018 2019 // ALIASES 2020 2021 addUnitAlias('day', 'd'); 2022 addUnitAlias('weekday', 'e'); 2023 addUnitAlias('isoWeekday', 'E'); 2024 2025 // PRIORITY 2026 addUnitPriority('day', 11); 2027 addUnitPriority('weekday', 11); 2028 addUnitPriority('isoWeekday', 11); 2029 2030 // PARSING 2031 2032 addRegexToken('d', match1to2); 2033 addRegexToken('e', match1to2); 2034 addRegexToken('E', match1to2); 2035 addRegexToken('dd', function (isStrict, locale) { 2036 return locale.weekdaysMinRegex(isStrict); 2037 }); 2038 addRegexToken('ddd', function (isStrict, locale) { 2039 return locale.weekdaysShortRegex(isStrict); 2040 }); 2041 addRegexToken('dddd', function (isStrict, locale) { 2042 return locale.weekdaysRegex(isStrict); 2043 }); 2044 2045 addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) { 2046 var weekday = config._locale.weekdaysParse(input, token, config._strict); 2047 // if we didn't get a weekday name, mark the date as invalid 2048 if (weekday != null) { 2049 week.d = weekday; 2050 } else { 2051 getParsingFlags(config).invalidWeekday = input; 2052 } 2053 }); 2054 2055 addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) { 2056 week[token] = toInt(input); 2057 }); 2058 2059 // HELPERS 2060 2061 function parseWeekday(input, locale) { 2062 if (typeof input !== 'string') { 2063 return input; 2064 } 2065 2066 if (!isNaN(input)) { 2067 return parseInt(input, 10); 2068 } 2069 2070 input = locale.weekdaysParse(input); 2071 if (typeof input === 'number') { 2072 return input; 2073 } 2074 2075 return null; 2076 } 2077 2078 function parseIsoWeekday(input, locale) { 2079 if (typeof input === 'string') { 2080 return locale.weekdaysParse(input) % 7 || 7; 2081 } 2082 return isNaN(input) ? null : input; 2083 } 2084 2085 // LOCALES 2086 2087 var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'); 2088 function localeWeekdays (m, format) { 2089 if (!m) { 2090 return isArray(this._weekdays) ? this._weekdays : 2091 this._weekdays['standalone']; 2092 } 2093 return isArray(this._weekdays) ? this._weekdays[m.day()] : 2094 this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()]; 2095 } 2096 2097 var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'); 2098 function localeWeekdaysShort (m) { 2099 return (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort; 2100 } 2101 2102 var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'); 2103 function localeWeekdaysMin (m) { 2104 return (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin; 2105 } 2106 2107 function handleStrictParse$1(weekdayName, format, strict) { 2108 var i, ii, mom, llc = weekdayName.toLocaleLowerCase(); 2109 if (!this._weekdaysParse) { 2110 this._weekdaysParse = []; 2111 this._shortWeekdaysParse = []; 2112 this._minWeekdaysParse = []; 2113 2114 for (i = 0; i < 7; ++i) { 2115 mom = createUTC([2000, 1]).day(i); 2116 this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase(); 2117 this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase(); 2118 this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase(); 2119 } 2120 } 2121 2122 if (strict) { 2123 if (format === 'dddd') { 2124 ii = indexOf.call(this._weekdaysParse, llc); 2125 return ii !== -1 ? ii : null; 2126 } else if (format === 'ddd') { 2127 ii = indexOf.call(this._shortWeekdaysParse, llc); 2128 return ii !== -1 ? ii : null; 2129 } else { 2130 ii = indexOf.call(this._minWeekdaysParse, llc); 2131 return ii !== -1 ? ii : null; 2132 } 2133 } else { 2134 if (format === 'dddd') { 2135 ii = indexOf.call(this._weekdaysParse, llc); 2136 if (ii !== -1) { 2137 return ii; 2138 } 2139 ii = indexOf.call(this._shortWeekdaysParse, llc); 2140 if (ii !== -1) { 2141 return ii; 2142 } 2143 ii = indexOf.call(this._minWeekdaysParse, llc); 2144 return ii !== -1 ? ii : null; 2145 } else if (format === 'ddd') { 2146 ii = indexOf.call(this._shortWeekdaysParse, llc); 2147 if (ii !== -1) { 2148 return ii; 2149 } 2150 ii = indexOf.call(this._weekdaysParse, llc); 2151 if (ii !== -1) { 2152 return ii; 2153 } 2154 ii = indexOf.call(this._minWeekdaysParse, llc); 2155 return ii !== -1 ? ii : null; 2156 } else { 2157 ii = indexOf.call(this._minWeekdaysParse, llc); 2158 if (ii !== -1) { 2159 return ii; 2160 } 2161 ii = indexOf.call(this._weekdaysParse, llc); 2162 if (ii !== -1) { 2163 return ii; 2164 } 2165 ii = indexOf.call(this._shortWeekdaysParse, llc); 2166 return ii !== -1 ? ii : null; 2167 } 2168 } 2169 } 2170 2171 function localeWeekdaysParse (weekdayName, format, strict) { 2172 var i, mom, regex; 2173 2174 if (this._weekdaysParseExact) { 2175 return handleStrictParse$1.call(this, weekdayName, format, strict); 2176 } 2177 2178 if (!this._weekdaysParse) { 2179 this._weekdaysParse = []; 2180 this._minWeekdaysParse = []; 2181 this._shortWeekdaysParse = []; 2182 this._fullWeekdaysParse = []; 2183 } 2184 2185 for (i = 0; i < 7; i++) { 2186 // make the regex if we don't have it already 2187 2188 mom = createUTC([2000, 1]).day(i); 2189 if (strict && !this._fullWeekdaysParse[i]) { 2190 this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\\.?') + '$', 'i'); 2191 this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\\.?') + '$', 'i'); 2192 this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\\.?') + '$', 'i'); 2193 } 2194 if (!this._weekdaysParse[i]) { 2195 regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, ''); 2196 this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i'); 2197 } 2198 // test the regex 2199 if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) { 2200 return i; 2201 } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) { 2202 return i; 2203 } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) { 2204 return i; 2205 } else if (!strict && this._weekdaysParse[i].test(weekdayName)) { 2206 return i; 2207 } 2208 } 2209 } 2210 2211 // MOMENTS 2212 2213 function getSetDayOfWeek (input) { 2214 if (!this.isValid()) { 2215 return input != null ? this : NaN; 2216 } 2217 var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay(); 2218 if (input != null) { 2219 input = parseWeekday(input, this.localeData()); 2220 return this.add(input - day, 'd'); 2221 } else { 2222 return day; 2223 } 2224 } 2225 2226 function getSetLocaleDayOfWeek (input) { 2227 if (!this.isValid()) { 2228 return input != null ? this : NaN; 2229 } 2230 var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7; 2231 return input == null ? weekday : this.add(input - weekday, 'd'); 2232 } 2233 2234 function getSetISODayOfWeek (input) { 2235 if (!this.isValid()) { 2236 return input != null ? this : NaN; 2237 } 2238 2239 // behaves the same as moment#day except 2240 // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6) 2241 // as a setter, sunday should belong to the previous week. 2242 2243 if (input != null) { 2244 var weekday = parseIsoWeekday(input, this.localeData()); 2245 return this.day(this.day() % 7 ? weekday : weekday - 7); 2246 } else { 2247 return this.day() || 7; 2248 } 2249 } 2250 2251 var defaultWeekdaysRegex = matchWord; 2252 function weekdaysRegex (isStrict) { 2253 if (this._weekdaysParseExact) { 2254 if (!hasOwnProp(this, '_weekdaysRegex')) { 2255 computeWeekdaysParse.call(this); 2256 } 2257 if (isStrict) { 2258 return this._weekdaysStrictRegex; 2259 } else { 2260 return this._weekdaysRegex; 2261 } 2262 } else { 2263 if (!hasOwnProp(this, '_weekdaysRegex')) { 2264 this._weekdaysRegex = defaultWeekdaysRegex; 2265 } 2266 return this._weekdaysStrictRegex && isStrict ? 2267 this._weekdaysStrictRegex : this._weekdaysRegex; 2268 } 2269 } 2270 2271 var defaultWeekdaysShortRegex = matchWord; 2272 function weekdaysShortRegex (isStrict) { 2273 if (this._weekdaysParseExact) { 2274 if (!hasOwnProp(this, '_weekdaysRegex')) { 2275 computeWeekdaysParse.call(this); 2276 } 2277 if (isStrict) { 2278 return this._weekdaysShortStrictRegex; 2279 } else { 2280 return this._weekdaysShortRegex; 2281 } 2282 } else { 2283 if (!hasOwnProp(this, '_weekdaysShortRegex')) { 2284 this._weekdaysShortRegex = defaultWeekdaysShortRegex; 2285 } 2286 return this._weekdaysShortStrictRegex && isStrict ? 2287 this._weekdaysShortStrictRegex : this._weekdaysShortRegex; 2288 } 2289 } 2290 2291 var defaultWeekdaysMinRegex = matchWord; 2292 function weekdaysMinRegex (isStrict) { 2293 if (this._weekdaysParseExact) { 2294 if (!hasOwnProp(this, '_weekdaysRegex')) { 2295 computeWeekdaysParse.call(this); 2296 } 2297 if (isStrict) { 2298 return this._weekdaysMinStrictRegex; 2299 } else { 2300 return this._weekdaysMinRegex; 2301 } 2302 } else { 2303 if (!hasOwnProp(this, '_weekdaysMinRegex')) { 2304 this._weekdaysMinRegex = defaultWeekdaysMinRegex; 2305 } 2306 return this._weekdaysMinStrictRegex && isStrict ? 2307 this._weekdaysMinStrictRegex : this._weekdaysMinRegex; 2308 } 2309 } 2310 2311 2312 function computeWeekdaysParse () { 2313 function cmpLenRev(a, b) { 2314 return b.length - a.length; 2315 } 2316 2317 var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [], 2318 i, mom, minp, shortp, longp; 2319 for (i = 0; i < 7; i++) { 2320 // make the regex if we don't have it already 2321 mom = createUTC([2000, 1]).day(i); 2322 minp = this.weekdaysMin(mom, ''); 2323 shortp = this.weekdaysShort(mom, ''); 2324 longp = this.weekdays(mom, ''); 2325 minPieces.push(minp); 2326 shortPieces.push(shortp); 2327 longPieces.push(longp); 2328 mixedPieces.push(minp); 2329 mixedPieces.push(shortp); 2330 mixedPieces.push(longp); 2331 } 2332 // Sorting makes sure if one weekday (or abbr) is a prefix of another it 2333 // will match the longer piece. 2334 minPieces.sort(cmpLenRev); 2335 shortPieces.sort(cmpLenRev); 2336 longPieces.sort(cmpLenRev); 2337 mixedPieces.sort(cmpLenRev); 2338 for (i = 0; i < 7; i++) { 2339 shortPieces[i] = regexEscape(shortPieces[i]); 2340 longPieces[i] = regexEscape(longPieces[i]); 2341 mixedPieces[i] = regexEscape(mixedPieces[i]); 2342 } 2343 2344 this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i'); 2345 this._weekdaysShortRegex = this._weekdaysRegex; 2346 this._weekdaysMinRegex = this._weekdaysRegex; 2347 2348 this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i'); 2349 this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i'); 2350 this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i'); 2351 } 2352 2353 // FORMATTING 2354 2355 function hFormat() { 2356 return this.hours() % 12 || 12; 2357 } 2358 2359 function kFormat() { 2360 return this.hours() || 24; 2361 } 2362 2363 addFormatToken('H', ['HH', 2], 0, 'hour'); 2364 addFormatToken('h', ['hh', 2], 0, hFormat); 2365 addFormatToken('k', ['kk', 2], 0, kFormat); 2366 2367 addFormatToken('hmm', 0, 0, function () { 2368 return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2); 2369 }); 2370 2371 addFormatToken('hmmss', 0, 0, function () { 2372 return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) + 2373 zeroFill(this.seconds(), 2); 2374 }); 2375 2376 addFormatToken('Hmm', 0, 0, function () { 2377 return '' + this.hours() + zeroFill(this.minutes(), 2); 2378 }); 2379 2380 addFormatToken('Hmmss', 0, 0, function () { 2381 return '' + this.hours() + zeroFill(this.minutes(), 2) + 2382 zeroFill(this.seconds(), 2); 2383 }); 2384 2385 function meridiem (token, lowercase) { 2386 addFormatToken(token, 0, 0, function () { 2387 return this.localeData().meridiem(this.hours(), this.minutes(), lowercase); 2388 }); 2389 } 2390 2391 meridiem('a', true); 2392 meridiem('A', false); 2393 2394 // ALIASES 2395 2396 addUnitAlias('hour', 'h'); 2397 2398 // PRIORITY 2399 addUnitPriority('hour', 13); 2400 2401 // PARSING 2402 2403 function matchMeridiem (isStrict, locale) { 2404 return locale._meridiemParse; 2405 } 2406 2407 addRegexToken('a', matchMeridiem); 2408 addRegexToken('A', matchMeridiem); 2409 addRegexToken('H', match1to2); 2410 addRegexToken('h', match1to2); 2411 addRegexToken('k', match1to2); 2412 addRegexToken('HH', match1to2, match2); 2413 addRegexToken('hh', match1to2, match2); 2414 addRegexToken('kk', match1to2, match2); 2415 2416 addRegexToken('hmm', match3to4); 2417 addRegexToken('hmmss', match5to6); 2418 addRegexToken('Hmm', match3to4); 2419 addRegexToken('Hmmss', match5to6); 2420 2421 addParseToken(['H', 'HH'], HOUR); 2422 addParseToken(['k', 'kk'], function (input, array, config) { 2423 var kInput = toInt(input); 2424 array[HOUR] = kInput === 24 ? 0 : kInput; 2425 }); 2426 addParseToken(['a', 'A'], function (input, array, config) { 2427 config._isPm = config._locale.isPM(input); 2428 config._meridiem = input; 2429 }); 2430 addParseToken(['h', 'hh'], function (input, array, config) { 2431 array[HOUR] = toInt(input); 2432 getParsingFlags(config).bigHour = true; 2433 }); 2434 addParseToken('hmm', function (input, array, config) { 2435 var pos = input.length - 2; 2436 array[HOUR] = toInt(input.substr(0, pos)); 2437 array[MINUTE] = toInt(input.substr(pos)); 2438 getParsingFlags(config).bigHour = true; 2439 }); 2440 addParseToken('hmmss', function (input, array, config) { 2441 var pos1 = input.length - 4; 2442 var pos2 = input.length - 2; 2443 array[HOUR] = toInt(input.substr(0, pos1)); 2444 array[MINUTE] = toInt(input.substr(pos1, 2)); 2445 array[SECOND] = toInt(input
vendor: 11,809 bytes, lines 2445-2780
2445.substr(pos2)); 2446 getParsingFlags(config).bigHour = true; 2447 }); 2448 addParseToken('Hmm', function (input, array, config) { 2449 var pos = input.length - 2; 2450 array[HOUR] = toInt(input.substr(0, pos)); 2451 array[MINUTE] = toInt(input.substr(pos)); 2452 }); 2453 addParseToken('Hmmss', function (input, array, config) { 2454 var pos1 = input.length - 4; 2455 var pos2 = input.length - 2; 2456 array[HOUR] = toInt(input.substr(0, pos1)); 2457 array[MINUTE] = toInt(input.substr(pos1, 2)); 2458 array[SECOND] = toInt(input.substr(pos2)); 2459 }); 2460 2461 // LOCALES 2462 2463 function localeIsPM (input) { 2464 // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays 2465 // Using charAt should be more compatible. 2466 return ((input + '').toLowerCase().charAt(0) === 'p'); 2467 } 2468 2469 var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i; 2470 function localeMeridiem (hours, minutes, isLower) { 2471 if (hours > 11) { 2472 return isLower ? 'pm' : 'PM'; 2473 } else { 2474 return isLower ? 'am' : 'AM'; 2475 } 2476 } 2477 2478 2479 // MOMENTS 2480 2481 // Setting the hour should keep the time, because the user explicitly 2482 // specified which hour they want. So trying to maintain the same hour (in 2483 // a new timezone) makes sense. Adding/subtracting hours does not follow 2484 // this rule. 2485 var getSetHour = makeGetSet('Hours', true); 2486 2487 var baseConfig = { 2488 calendar: defaultCalendar, 2489 longDateFormat: defaultLongDateFormat, 2490 invalidDate: defaultInvalidDate, 2491 ordinal: defaultOrdinal, 2492 dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse, 2493 relativeTime: defaultRelativeTime, 2494 2495 months: defaultLocaleMonths, 2496 monthsShort: defaultLocaleMonthsShort, 2497 2498 week: defaultLocaleWeek, 2499 2500 weekdays: defaultLocaleWeekdays, 2501 weekdaysMin: defaultLocaleWeekdaysMin, 2502 weekdaysShort: defaultLocaleWeekdaysShort, 2503 2504 meridiemParse: defaultLocaleMeridiemParse 2505 }; 2506 2507 // internal storage for locale config files 2508 var locales = {}; 2509 var localeFamilies = {}; 2510 var globalLocale; 2511 2512 function normalizeLocale(key) { 2513 return key ? key.toLowerCase().replace('_', '-') : key; 2514 } 2515 2516 // pick the locale from the array 2517 // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each 2518 // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root 2519 function chooseLocale(names) { 2520 var i = 0, j, next, locale, split; 2521 2522 while (i < names.length) { 2523 split = normalizeLocale(names[i]).split('-'); 2524 j = split.length; 2525 next = normalizeLocale(names[i + 1]); 2526 next = next ? next.split('-') : null; 2527 while (j > 0) { 2528 locale = loadLocale(split.slice(0, j).join('-')); 2529 if (locale) { 2530 return locale; 2531 } 2532 if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) { 2533 //the next array item is better than a shallower substring of this one 2534 break; 2535 } 2536 j--; 2537 } 2538 i++; 2539 } 2540 return globalLocale; 2541 } 2542 2543 function loadLocale(name) { 2544 var oldLocale = null; 2545 // TODO: Find a better way to register and load all the locales in Node 2546 if (!locales[name] && (typeof module !== 'undefined') && 2547 module && module.exports) { 2548 try { 2549 oldLocale = globalLocale._abbr; 2550 var aliasedRequire = require; 2551 __webpack_require__(237)("./" + name); 2552 getSetGlobalLocale(oldLocale); 2553 } catch (e) {} 2554 } 2555 return locales[name]; 2556 } 2557 2558 // This function will load locale and then set the global locale. If 2559 // no arguments are passed in, it will simply return the current global 2560 // locale key. 2561 function getSetGlobalLocale (key, values) { 2562 var data; 2563 if (key) { 2564 if (isUndefined(values)) { 2565 data = getLocale(key); 2566 } 2567 else { 2568 data = defineLocale(key, values); 2569 } 2570 2571 if (data) { 2572 // moment.duration._locale = moment._locale = data; 2573 globalLocale = data; 2574 } 2575 else { 2576 if ((typeof console !== 'undefined') && console.warn) { 2577 //warn user if arguments are passed but the locale could not be set 2578 console.warn('Locale ' + key + ' not found. Did you forget to load it?'); 2579 } 2580 } 2581 } 2582 2583 return globalLocale._abbr; 2584 } 2585 2586 function defineLocale (name, config) { 2587 if (config !== null) { 2588 var locale, parentConfig = baseConfig; 2589 config.abbr = name; 2590 if (locales[name] != null) { 2591 deprecateSimple('defineLocaleOverride', 2592 'use moment.updateLocale(localeName, config) to change ' + 2593 'an existing locale. moment.defineLocale(localeName, ' + 2594 'config) should only be used for creating a new locale ' + 2595 'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.'); 2596 parentConfig = locales[name]._config; 2597 } else if (config.parentLocale != null) { 2598 if (locales[config.parentLocale] != null) { 2599 parentConfig = locales[config.parentLocale]._config; 2600 } else { 2601 locale = loadLocale(config.parentLocale); 2602 if (locale != null) { 2603 parentConfig = locale._config; 2604 } else { 2605 if (!localeFamilies[config.parentLocale]) { 2606 localeFamilies[config.parentLocale] = []; 2607 } 2608 localeFamilies[config.parentLocale].push({ 2609 name: name, 2610 config: config 2611 }); 2612 return null; 2613 } 2614 } 2615 } 2616 locales[name] = new Locale(mergeConfigs(parentConfig, config)); 2617 2618 if (localeFamilies[name]) { 2619 localeFamilies[name].forEach(function (x) { 2620 defineLocale(x.name, x.config); 2621 }); 2622 } 2623 2624 // backwards compat for now: also set the locale 2625 // make sure we set the locale AFTER all child locales have been 2626 // created, so we won't end up with the child locale set. 2627 getSetGlobalLocale(name); 2628 2629 2630 return locales[name]; 2631 } else { 2632 // useful for testing 2633 delete locales[name]; 2634 return null; 2635 } 2636 } 2637 2638 function updateLocale(name, config) { 2639 if (config != null) { 2640 var locale, tmpLocale, parentConfig = baseConfig; 2641 // MERGE 2642 tmpLocale = loadLocale(name); 2643 if (tmpLocale != null) { 2644 parentConfig = tmpLocale._config; 2645 } 2646 config = mergeConfigs(parentConfig, config); 2647 locale = new Locale(config); 2648 locale.parentLocale = locales[name]; 2649 locales[name] = locale; 2650 2651 // backwards compat for now: also set the locale 2652 getSetGlobalLocale(name); 2653 } else { 2654 // pass null for config to unupdate, useful for tests 2655 if (locales[name] != null) { 2656 if (locales[name].parentLocale != null) { 2657 locales[name] = locales[name].parentLocale; 2658 } else if (locales[name] != null) { 2659 delete locales[name]; 2660 } 2661 } 2662 } 2663 return locales[name]; 2664 } 2665 2666 // returns locale data 2667 function getLocale (key) { 2668 var locale; 2669 2670 if (key && key._locale && key._locale._abbr) { 2671 key = key._locale._abbr; 2672 } 2673 2674 if (!key) { 2675 return globalLocale; 2676 } 2677 2678 if (!isArray(key)) { 2679 //short-circuit everything else 2680 locale = loadLocale(key); 2681 if (locale) { 2682 return locale; 2683 } 2684 key = [key]; 2685 } 2686 2687 return chooseLocale(key); 2688 } 2689 2690 function listLocales() { 2691 return keys(locales); 2692 } 2693 2694 function checkOverflow (m) { 2695 var overflow; 2696 var a = m._a; 2697 2698 if (a && getParsingFlags(m).overflow === -2) { 2699 overflow = 2700 a[MONTH] < 0 || a[MONTH] > 11 ? MONTH : 2701 a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) ? DATE : 2702 a[HOUR] < 0 || a[HOUR] > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR : 2703 a[MINUTE] < 0 || a[MINUTE] > 59 ? MINUTE : 2704 a[SECOND] < 0 || a[SECOND] > 59 ? SECOND : 2705 a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND : 2706 -1; 2707 2708 if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) { 2709 overflow = DATE; 2710 } 2711 if (getParsingFlags(m)._overflowWeeks && overflow === -1) { 2712 overflow = WEEK; 2713 } 2714 if (getParsingFlags(m)._overflowWeekday && overflow === -1) { 2715 overflow = WEEKDAY; 2716 } 2717 2718 getParsingFlags(m).overflow = overflow; 2719 } 2720 2721 return m; 2722 } 2723 2724 // Pick the first defined of two or three arguments. 2725 function defaults(a, b, c) { 2726 if (a != null) { 2727 return a; 2728 } 2729 if (b != null) { 2730 return b; 2731 } 2732 return c; 2733 } 2734 2735 function currentDateArray(config) { 2736 // hooks is actually the exported moment object 2737 var nowValue = new Date(hooks.now()); 2738 if (config._useUTC) { 2739 return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()]; 2740 } 2741 return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()]; 2742 } 2743 2744 // convert an array to a date. 2745 // the array should mirror the parameters below 2746 // note: all values past the year are optional and will default to the lowest possible value. 2747 // [year, month, day , hour, minute, second, millisecond] 2748 function configFromArray (config) { 2749 var i, date, input = [], currentDate, expectedWeekday, yearToUse; 2750 2751 if (config._d) { 2752 return; 2753 } 2754 2755 currentDate = currentDateArray(config); 2756 2757 //compute day of the year from weeks and weekdays 2758 if (config._w && config._a[DATE] == null && config._a[MONTH] == null) { 2759 dayOfYearFromWeekInfo(config); 2760 } 2761 2762 //if the day of the year is set, figure out what it is 2763 if (config._dayOfYear != null) { 2764 yearToUse = defaults(config._a[YEAR], currentDate[YEAR]); 2765 2766 if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) { 2767 getParsingFlags(config)._overflowDayOfYear = true; 2768 } 2769 2770 date = createUTCDate(yearToUse, 0, config._dayOfYear); 2771 config._a[MONTH] = date.getUTCMonth(); 2772 config._a[DATE] = date.getUTCDate(); 2773 } 2774 2775 // Default to current date. 2776 // * if no year, month, day of month are given, default to today 2777 // * if day of month is given, default month and year 2778 // * if month is given, default only year 2779 // * if year is given, don't default anything 2780 for (i = 0; i < 3 && config._a[i] == null; ++i) {
vendor: 2,915 bytes, lines 2781-2859
2781 config._a[i] = input[i] = currentDate[i]; 2782 } 2783 2784 // Zero out whatever was not defaulted, including time 2785 for (; i < 7; i++) { 2786 config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i]; 2787 } 2788 2789 // Check for 24:00:00.000 2790 if (config._a[HOUR] === 24 && 2791 config._a[MINUTE] === 0 && 2792 config._a[SECOND] === 0 && 2793 config._a[MILLISECOND] === 0) { 2794 config._nextDay = true; 2795 config._a[HOUR] = 0; 2796 } 2797 2798 config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input); 2799 expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay(); 2800 2801 // Apply timezone offset from input. The actual utcOffset can be changed 2802 // with parseZone. 2803 if (config._tzm != null) { 2804 config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm); 2805 } 2806 2807 if (config._nextDay) { 2808 config._a[HOUR] = 24; 2809 } 2810 2811 // check for mismatching day of week 2812 if (config._w && typeof config._w.d !== 'undefined' && config._w.d !== expectedWeekday) { 2813 getParsingFlags(config).weekdayMismatch = true; 2814 } 2815 } 2816 2817 function dayOfYearFromWeekInfo(config) { 2818 var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow; 2819 2820 w = config._w; 2821 if (w.GG != null || w.W != null || w.E != null) { 2822 dow = 1; 2823 doy = 4; 2824 2825 // TODO: We need to take the current isoWeekYear, but that depends on 2826 // how we interpret now (local, utc, fixed offset). So create 2827 // a now version of current config (take local/utc/offset flags, and 2828 // create now). 2829 weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year); 2830 week = defaults(w.W, 1); 2831 weekday = defaults(w.E, 1); 2832 if (weekday < 1 || weekday > 7) { 2833 weekdayOverflow = true; 2834 } 2835 } else { 2836 dow = config._locale._week.dow; 2837 doy = config._locale._week.doy; 2838 2839 var curWeek = weekOfYear(createLocal(), dow, doy); 2840 2841 weekYear = defaults(w.gg, config._a[YEAR], curWeek.year); 2842 2843 // Default to current week. 2844 week = defaults(w.w, curWeek.week); 2845 2846 if (w.d != null) { 2847 // weekday -- low day numbers are considered next week 2848 weekday = w.d; 2849 if (weekday < 0 || weekday > 6) { 2850 weekdayOverflow = true; 2851 } 2852 } else if (w.e != null) { 2853 // local weekday -- counting starts from begining of week 2854 weekday = w.e + dow; 2855 if (w.e < 0 || w.e > 6) { 2856 weekdayOverflow = true; 2857 } 2858 } else { 2859 // default to begi
vendor: 19,665 bytes, lines 2859-3453
2859ning of week 2860 weekday = dow; 2861 } 2862 } 2863 if (week < 1 || week > weeksInYear(weekYear, dow, doy)) { 2864 getParsingFlags(config)._overflowWeeks = true; 2865 } else if (weekdayOverflow != null) { 2866 getParsingFlags(config)._overflowWeekday = true; 2867 } else { 2868 temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy); 2869 config._a[YEAR] = temp.year; 2870 config._dayOfYear = temp.dayOfYear; 2871 } 2872 } 2873 2874 // iso 8601 regex 2875 // 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00) 2876 var extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/; 2877 var basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/; 2878 2879 var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/; 2880 2881 var isoDates = [ 2882 ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/], 2883 ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/], 2884 ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/], 2885 ['GGGG-[W]WW', /\d{4}-W\d\d/, false], 2886 ['YYYY-DDD', /\d{4}-\d{3}/], 2887 ['YYYY-MM', /\d{4}-\d\d/, false], 2888 ['YYYYYYMMDD', /[+-]\d{10}/], 2889 ['YYYYMMDD', /\d{8}/], 2890 // YYYYMM is NOT allowed by the standard 2891 ['GGGG[W]WWE', /\d{4}W\d{3}/], 2892 ['GGGG[W]WW', /\d{4}W\d{2}/, false], 2893 ['YYYYDDD', /\d{7}/] 2894 ]; 2895 2896 // iso time formats and regexes 2897 var isoTimes = [ 2898 ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/], 2899 ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/], 2900 ['HH:mm:ss', /\d\d:\d\d:\d\d/], 2901 ['HH:mm', /\d\d:\d\d/], 2902 ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/], 2903 ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/], 2904 ['HHmmss', /\d\d\d\d\d\d/], 2905 ['HHmm', /\d\d\d\d/], 2906 ['HH', /\d\d/] 2907 ]; 2908 2909 var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i; 2910 2911 // date from iso format 2912 function configFromISO(config) { 2913 var i, l, 2914 string = config._i, 2915 match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string), 2916 allowTime, dateFormat, timeFormat, tzFormat; 2917 2918 if (match) { 2919 getParsingFlags(config).iso = true; 2920 2921 for (i = 0, l = isoDates.length; i < l; i++) { 2922 if (isoDates[i][1].exec(match[1])) { 2923 dateFormat = isoDates[i][0]; 2924 allowTime = isoDates[i][2] !== false; 2925 break; 2926 } 2927 } 2928 if (dateFormat == null) { 2929 config._isValid = false; 2930 return; 2931 } 2932 if (match[3]) { 2933 for (i = 0, l = isoTimes.length; i < l; i++) { 2934 if (isoTimes[i][1].exec(match[3])) { 2935 // match[2] should be 'T' or space 2936 timeFormat = (match[2] || ' ') + isoTimes[i][0]; 2937 break; 2938 } 2939 } 2940 if (timeFormat == null) { 2941 config._isValid = false; 2942 return; 2943 } 2944 } 2945 if (!allowTime && timeFormat != null) { 2946 config._isValid = false; 2947 return; 2948 } 2949 if (match[4]) { 2950 if (tzRegex.exec(match[4])) { 2951 tzFormat = 'Z'; 2952 } else { 2953 config._isValid = false; 2954 return; 2955 } 2956 } 2957 config._f = dateFormat + (timeFormat || '') + (tzFormat || ''); 2958 configFromStringAndFormat(config); 2959 } else { 2960 config._isValid = false; 2961 } 2962 } 2963 2964 // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3 2965 var rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/; 2966 2967 function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) { 2968 var result = [ 2969 untruncateYear(yearStr), 2970 defaultLocaleMonthsShort.indexOf(monthStr), 2971 parseInt(dayStr, 10), 2972 parseInt(hourStr, 10), 2973 parseInt(minuteStr, 10) 2974 ]; 2975 2976 if (secondStr) { 2977 result.push(parseInt(secondStr, 10)); 2978 } 2979 2980 return result; 2981 } 2982 2983 function untruncateYear(yearStr) { 2984 var year = parseInt(yearStr, 10); 2985 if (year <= 49) { 2986 return 2000 + year; 2987 } else if (year <= 999) { 2988 return 1900 + year; 2989 } 2990 return year; 2991 } 2992 2993 function preprocessRFC2822(s) { 2994 // Remove comments and folding whitespace and replace multiple-spaces with a single space 2995 return s.replace(/\([^)]*\)|[\n\t]/g, ' ').replace(/(\s\s+)/g, ' ').replace(/^\s\s*/, '').replace(/\s\s*$/, ''); 2996 } 2997 2998 function checkWeekday(weekdayStr, parsedInput, config) { 2999 if (weekdayStr) { 3000 // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check. 3001 var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr), 3002 weekdayActual = new Date(parsedInput[0], parsedInput[1], parsedInput[2]).getDay(); 3003 if (weekdayProvided !== weekdayActual) { 3004 getParsingFlags(config).weekdayMismatch = true; 3005 config._isValid = false; 3006 return false; 3007 } 3008 } 3009 return true; 3010 } 3011 3012 var obsOffsets = { 3013 UT: 0, 3014 GMT: 0, 3015 EDT: -4 * 60, 3016 EST: -5 * 60, 3017 CDT: -5 * 60, 3018 CST: -6 * 60, 3019 MDT: -6 * 60, 3020 MST: -7 * 60, 3021 PDT: -7 * 60, 3022 PST: -8 * 60 3023 }; 3024 3025 function calculateOffset(obsOffset, militaryOffset, numOffset) { 3026 if (obsOffset) { 3027 return obsOffsets[obsOffset]; 3028 } else if (militaryOffset) { 3029 // the only allowed military tz is Z 3030 return 0; 3031 } else { 3032 var hm = parseInt(numOffset, 10); 3033 var m = hm % 100, h = (hm - m) / 100; 3034 return h * 60 + m; 3035 } 3036 } 3037 3038 // date and time from ref 2822 format 3039 function configFromRFC2822(config) { 3040 var match = rfc2822.exec(preprocessRFC2822(config._i)); 3041 if (match) { 3042 var parsedArray = extractFromRFC2822Strings(match[4], match[3], match[2], match[5], match[6], match[7]); 3043 if (!checkWeekday(match[1], parsedArray, config)) { 3044 return; 3045 } 3046 3047 config._a = parsedArray; 3048 config._tzm = calculateOffset(match[8], match[9], match[10]); 3049 3050 config._d = createUTCDate.apply(null, config._a); 3051 config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm); 3052 3053 getParsingFlags(config).rfc2822 = true; 3054 } else { 3055 config._isValid = false; 3056 } 3057 } 3058 3059 // date from iso format or fallback 3060 function configFromString(config) { 3061 var matched = aspNetJsonRegex.exec(config._i); 3062 3063 if (matched !== null) { 3064 config._d = new Date(+matched[1]); 3065 return; 3066 } 3067 3068 configFromISO(config); 3069 if (config._isValid === false) { 3070 delete config._isValid; 3071 } else { 3072 return; 3073 } 3074 3075 configFromRFC2822(config); 3076 if (config._isValid === false) { 3077 delete config._isValid; 3078 } else { 3079 return; 3080 } 3081 3082 // Final attempt, use Input Fallback 3083 hooks.createFromInputFallback(config); 3084 } 3085 3086 hooks.createFromInputFallback = deprecate( 3087 'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' + 3088 'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' + 3089 'discouraged and will be removed in an upcoming major release. Please refer to ' + 3090 'http://momentjs.com/guides/#/warnings/js-date/ for more info.', 3091 function (config) { 3092 config._d = new Date(config._i + (config._useUTC ? ' UTC' : '')); 3093 } 3094 ); 3095 3096 // constant that refers to the ISO standard 3097 hooks.ISO_8601 = function () {}; 3098 3099 // constant that refers to the RFC 2822 form 3100 hooks.RFC_2822 = function () {}; 3101 3102 // date from string and format string 3103 function configFromStringAndFormat(config) { 3104 // TODO: Move this to another part of the creation flow to prevent circular deps 3105 if (config._f === hooks.ISO_8601) { 3106 configFromISO(config); 3107 return; 3108 } 3109 if (config._f === hooks.RFC_2822) { 3110 configFromRFC2822(config); 3111 return; 3112 } 3113 config._a = []; 3114 getParsingFlags(config).empty = true; 3115 3116 // This array is used to make a Date, either with `new Date` or `Date.UTC` 3117 var string = '' + config._i, 3118 i, parsedInput, tokens, token, skipped, 3119 stringLength = string.length, 3120 totalParsedInputLength = 0; 3121 3122 tokens = expandFormat(config._f, config._locale).match(formattingTokens) || []; 3123 3124 for (i = 0; i < tokens.length; i++) { 3125 token = tokens[i]; 3126 parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0]; 3127 // console.log('token', token, 'parsedInput', parsedInput, 3128 // 'regex', getParseRegexForToken(token, config)); 3129 if (parsedInput) { 3130 skipped = string.substr(0, string.indexOf(parsedInput)); 3131 if (skipped.length > 0) { 3132 getParsingFlags(config).unusedInput.push(skipped); 3133 } 3134 string = string.slice(string.indexOf(parsedInput) + parsedInput.length); 3135 totalParsedInputLength += parsedInput.length; 3136 } 3137 // don't parse if it's not a known token 3138 if (formatTokenFunctions[token]) { 3139 if (parsedInput) { 3140 getParsingFlags(config).empty = false; 3141 } 3142 else { 3143 getParsingFlags(config).unusedTokens.push(token); 3144 } 3145 addTimeToArrayFromToken(token, parsedInput, config); 3146 } 3147 else if (config._strict && !parsedInput) { 3148 getParsingFlags(config).unusedTokens.push(token); 3149 } 3150 } 3151 3152 // add remaining unparsed input length to the string 3153 getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength; 3154 if (string.length > 0) { 3155 getParsingFlags(config).unusedInput.push(string); 3156 } 3157 3158 // clear _12h flag if hour is <= 12 3159 if (config._a[HOUR] <= 12 && 3160 getParsingFlags(config).bigHour === true && 3161 config._a[HOUR] > 0) { 3162 getParsingFlags(config).bigHour = undefined; 3163 } 3164 3165 getParsingFlags(config).parsedDateParts = config._a.slice(0); 3166 getParsingFlags(config).meridiem = config._meridiem; 3167 // handle meridiem 3168 config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem); 3169 3170 configFromArray(config); 3171 checkOverflow(config); 3172 } 3173 3174 3175 function meridiemFixWrap (locale, hour, meridiem) { 3176 var isPm; 3177 3178 if (meridiem == null) { 3179 // nothing to do 3180 return hour; 3181 } 3182 if (locale.meridiemHour != null) { 3183 return locale.meridiemHour(hour, meridiem); 3184 } else if (locale.isPM != null) { 3185 // Fallback 3186 isPm = locale.isPM(meridiem); 3187 if (isPm && hour < 12) { 3188 hour += 12; 3189 } 3190 if (!isPm && hour === 12) { 3191 hour = 0; 3192 } 3193 return hour; 3194 } else { 3195 // this is not supposed to happen 3196 return hour; 3197 } 3198 } 3199 3200 // date from string and array of format strings 3201 function configFromStringAndArray(config) { 3202 var tempConfig, 3203 bestMoment, 3204 3205 scoreToBeat, 3206 i, 3207 currentScore; 3208 3209 if (config._f.length === 0) { 3210 getParsingFlags(config).invalidFormat = true; 3211 config._d = new Date(NaN); 3212 return; 3213 } 3214 3215 for (i = 0; i < config._f.length; i++) { 3216 currentScore = 0; 3217 tempConfig = copyConfig({}, config); 3218 if (config._useUTC != null) { 3219 tempConfig._useUTC = config._useUTC; 3220 } 3221 tempConfig._f = config._f[i]; 3222 configFromStringAndFormat(tempConfig); 3223 3224 if (!isValid(tempConfig)) { 3225 continue; 3226 } 3227 3228 // if there is any input that was not parsed add a penalty for that format 3229 currentScore += getParsingFlags(tempConfig).charsLeftOver; 3230 3231 //or tokens 3232 currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10; 3233 3234 getParsingFlags(tempConfig).score = currentScore; 3235 3236 if (scoreToBeat == null || currentScore < scoreToBeat) { 3237 scoreToBeat = currentScore; 3238 bestMoment = tempConfig; 3239 } 3240 } 3241 3242 extend(config, bestMoment || tempConfig); 3243 } 3244 3245 function configFromObject(config) { 3246 if (config._d) { 3247 return; 3248 } 3249 3250 var i = normalizeObjectUnits(config._i); 3251 config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) { 3252 return obj && parseInt(obj, 10); 3253 }); 3254 3255 configFromArray(config); 3256 } 3257 3258 function createFromConfig (config) { 3259 var res = new Moment(checkOverflow(prepareConfig(config))); 3260 if (res._nextDay) { 3261 // Adding is smart enough around DST 3262 res.add(1, 'd'); 3263 res._nextDay = undefined; 3264 } 3265 3266 return res; 3267 } 3268 3269 function prepareConfig (config) { 3270 var input = config._i, 3271 format = config._f; 3272 3273 config._locale = config._locale || getLocale(config._l); 3274 3275 if (input === null || (format === undefined && input === '')) { 3276 return createInvalid({nullInput: true}); 3277 } 3278 3279 if (typeof input === 'string') { 3280 config._i = input = config._locale.preparse(input); 3281 } 3282 3283 if (isMoment(input)) { 3284 return new Moment(checkOverflow(input)); 3285 } else if (isDate(input)) { 3286 config._d = input; 3287 } else if (isArray(format)) { 3288 configFromStringAndArray(config); 3289 } else if (format) { 3290 configFromStringAndFormat(config); 3291 } else { 3292 configFromInput(config); 3293 } 3294 3295 if (!isValid(config)) { 3296 config._d = null; 3297 } 3298 3299 return config; 3300 } 3301 3302 function configFromInput(config) { 3303 var input = config._i; 3304 if (isUndefined(input)) { 3305 config._d = new Date(hooks.now()); 3306 } else if (isDate(input)) { 3307 config._d = new Date(input.valueOf()); 3308 } else if (typeof input === 'string') { 3309 configFromString(config); 3310 } else if (isArray(input)) { 3311 config._a = map(input.slice(0), function (obj) { 3312 return parseInt(obj, 10); 3313 }); 3314 configFromArray(config); 3315 } else if (isObject(input)) { 3316 configFromObject(config); 3317 } else if (isNumber(input)) { 3318 // from milliseconds 3319 config._d = new Date(input); 3320 } else { 3321 hooks.createFromInputFallback(config); 3322 } 3323 } 3324 3325 function createLocalOrUTC (input, format, locale, strict, isUTC) { 3326 var c = {}; 3327 3328 if (locale === true || locale === false) { 3329 strict = locale; 3330 locale = undefined; 3331 } 3332 3333 if ((isObject(input) && isObjectEmpty(input)) || 3334 (isArray(input) && input.length === 0)) { 3335 input = undefined; 3336 } 3337 // object construction must be done this way. 3338 // https://github.com/moment/moment/issues/1423 3339 c._isAMomentObject = true; 3340 c._useUTC = c._isUTC = isUTC; 3341 c._l = locale; 3342 c._i = input; 3343 c._f = format; 3344 c._strict = strict; 3345 3346 return createFromConfig(c); 3347 } 3348 3349 function createLocal (input, format, locale, strict) { 3350 return createLocalOrUTC(input, format, locale, strict, false); 3351 } 3352 3353 var prototypeMin = deprecate( 3354 'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/', 3355 function () { 3356 var other = createLocal.apply(null, arguments); 3357 if (this.isValid() && other.isValid()) { 3358 return other < this ? this : other; 3359 } else { 3360 return createInvalid(); 3361 } 3362 } 3363 ); 3364 3365 var prototypeMax = deprecate( 3366 'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/', 3367 function () { 3368 var other = createLocal.apply(null, arguments); 3369 if (this.isValid() && other.isValid()) { 3370 return other > this ? this : other; 3371 } else { 3372 return createInvalid(); 3373 } 3374 } 3375 ); 3376 3377 // Pick a moment m from moments so that m[fn](other) is true for all 3378 // other. This relies on the function fn to be transitive. 3379 // 3380 // moments should either be an array of moment objects or an array, whose 3381 // first element is an array of moment objects. 3382 function pickBy(fn, moments) { 3383 var res, i; 3384 if (moments.length === 1 && isArray(moments[0])) { 3385 moments = moments[0]; 3386 } 3387 if (!moments.length) { 3388 return createLocal(); 3389 } 3390 res = moments[0]; 3391 for (i = 1; i < moments.length; ++i) { 3392 if (!moments[i].isValid() || moments[i][fn](res)) { 3393 res = moments[i]; 3394 } 3395 } 3396 return res; 3397 } 3398 3399 // TODO: Use [].sort instead? 3400 function min () { 3401 var args = [].slice.call(arguments, 0); 3402 3403 return pickBy('isBefore', args); 3404 } 3405 3406 function max () { 3407 var args = [].slice.call(arguments, 0); 3408 3409 return pickBy('isAfter', args); 3410 } 3411 3412 var now = function () { 3413 return Date.now ? Date.now() : +(new Date()); 3414 }; 3415 3416 var ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond']; 3417 3418 function isDurationValid(m) { 3419 for (var key in m) { 3420 if (!(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) { 3421 return false; 3422 } 3423 } 3424 3425 var unitHasDecimal = false; 3426 for (var i = 0; i < ordering.length; ++i) { 3427 if (m[ordering[i]]) { 3428 if (unitHasDecimal) { 3429 return false; // only allow non-integers for smallest unit 3430 } 3431 if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) { 3432 unitHasDecimal = true; 3433 } 3434 } 3435 } 3436 3437 return true; 3438 } 3439 3440 function isValid$1() { 3441 return this._isValid; 3442 } 3443 3444 function createInvalid$1() { 3445 return createDuration(NaN); 3446 } 3447 3448 function Duration (duration) { 3449 var normalizedInput = normalizeObjectUnits(duration), 3450 years = normalizedInput.year || 0, 3451 quarters = normalizedInput.quarter || 0, 3452 months = normalizedInput.month || 0, 3453 weeks = normalizedInput.week ||
vendor: 4,158 bytes, lines 3453-3580
34530, 3454 days = normalizedInput.day || 0, 3455 hours = normalizedInput.hour || 0, 3456 minutes = normalizedInput.minute || 0, 3457 seconds = normalizedInput.second || 0, 3458 milliseconds = normalizedInput.millisecond || 0; 3459 3460 this._isValid = isDurationValid(normalizedInput); 3461 3462 // representation for dateAddRemove 3463 this._milliseconds = +milliseconds + 3464 seconds * 1e3 + // 1000 3465 minutes * 6e4 + // 1000 * 60 3466 hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978 3467 // Because of dateAddRemove treats 24 hours as different from a 3468 // day when working around DST, we need to store them separately 3469 this._days = +days + 3470 weeks * 7; 3471 // It is impossible to translate months into days without knowing 3472 // which months you are are talking about, so we have to store 3473 // it separately. 3474 this._months = +months + 3475 quarters * 3 + 3476 years * 12; 3477 3478 this._data = {}; 3479 3480 this._locale = getLocale(); 3481 3482 this._bubble(); 3483 } 3484 3485 function isDuration (obj) { 3486 return obj instanceof Duration; 3487 } 3488 3489 function absRound (number) { 3490 if (number < 0) { 3491 return Math.round(-1 * number) * -1; 3492 } else { 3493 return Math.round(number); 3494 } 3495 } 3496 3497 // FORMATTING 3498 3499 function offset (token, separator) { 3500 addFormatToken(token, 0, 0, function () { 3501 var offset = this.utcOffset(); 3502 var sign = '+'; 3503 if (offset < 0) { 3504 offset = -offset; 3505 sign = '-'; 3506 } 3507 return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2); 3508 }); 3509 } 3510 3511 offset('Z', ':'); 3512 offset('ZZ', ''); 3513 3514 // PARSING 3515 3516 addRegexToken('Z', matchShortOffset); 3517 addRegexToken('ZZ', matchShortOffset); 3518 addParseToken(['Z', 'ZZ'], function (input, array, config) { 3519 config._useUTC = true; 3520 config._tzm = offsetFromString(matchShortOffset, input); 3521 }); 3522 3523 // HELPERS 3524 3525 // timezone chunker 3526 // '+10:00' > ['10', '00'] 3527 // '-1530' > ['-15', '30'] 3528 var chunkOffset = /([\+\-]|\d\d)/gi; 3529 3530 function offsetFromString(matcher, string) { 3531 var matches = (string || '').match(matcher); 3532 3533 if (matches === null) { 3534 return null; 3535 } 3536 3537 var chunk = matches[matches.length - 1] || []; 3538 var parts = (chunk + '').match(chunkOffset) || ['-', 0, 0]; 3539 var minutes = +(parts[1] * 60) + toInt(parts[2]); 3540 3541 return minutes === 0 ? 3542 0 : 3543 parts[0] === '+' ? minutes : -minutes; 3544 } 3545 3546 // Return a moment from input, that is local/utc/zone equivalent to model. 3547 function cloneWithOffset(input, model) { 3548 var res, diff; 3549 if (model._isUTC) { 3550 res = model.clone(); 3551 diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf(); 3552 // Use low-level api, because this fn is low-level api. 3553 res._d.setTime(res._d.valueOf() + diff); 3554 hooks.updateOffset(res, false); 3555 return res; 3556 } else { 3557 return createLocal(input).local(); 3558 } 3559 } 3560 3561 function getDateOffset (m) { 3562 // On Firefox.24 Date#getTimezoneOffset returns a floating point. 3563 // https://github.com/moment/moment/pull/1871 3564 return -Math.round(m._d.getTimezoneOffset() / 15) * 15; 3565 } 3566 3567 // HOOKS 3568 3569 // This function will be called whenever a moment is mutated. 3570 // It is intended to keep the offset in sync with the timezone. 3571 hooks.updateOffset = function () {}; 3572 3573 // MOMENTS 3574 3575 // keepLocalTime = true means only change the timezone, without 3576 // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]--> 3577 // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset 3578 // +0200, so we adjust the time as needed, to be valid. 3579 // 3580 // Keeping the time actually adds/subtracts (one hour)
vendor: 20,735 bytes, lines 3581-4187
3581 // from the actual represented time. That is why we call updateOffset 3582 // a second time. In case it wants us to change the offset again 3583 // _changeInProgress == true case, then we have to adjust, because 3584 // there is no such time in the given timezone. 3585 function getSetOffset (input, keepLocalTime, keepMinutes) { 3586 var offset = this._offset || 0, 3587 localAdjust; 3588 if (!this.isValid()) { 3589 return input != null ? this : NaN; 3590 } 3591 if (input != null) { 3592 if (typeof input === 'string') { 3593 input = offsetFromString(matchShortOffset, input); 3594 if (input === null) { 3595 return this; 3596 } 3597 } else if (Math.abs(input) < 16 && !keepMinutes) { 3598 input = input * 60; 3599 } 3600 if (!this._isUTC && keepLocalTime) { 3601 localAdjust = getDateOffset(this); 3602 } 3603 this._offset = input; 3604 this._isUTC = true; 3605 if (localAdjust != null) { 3606 this.add(localAdjust, 'm'); 3607 } 3608 if (offset !== input) { 3609 if (!keepLocalTime || this._changeInProgress) { 3610 addSubtract(this, createDuration(input - offset, 'm'), 1, false); 3611 } else if (!this._changeInProgress) { 3612 this._changeInProgress = true; 3613 hooks.updateOffset(this, true); 3614 this._changeInProgress = null; 3615 } 3616 } 3617 return this; 3618 } else { 3619 return this._isUTC ? offset : getDateOffset(this); 3620 } 3621 } 3622 3623 function getSetZone (input, keepLocalTime) { 3624 if (input != null) { 3625 if (typeof input !== 'string') { 3626 input = -input; 3627 } 3628 3629 this.utcOffset(input, keepLocalTime); 3630 3631 return this; 3632 } else { 3633 return -this.utcOffset(); 3634 } 3635 } 3636 3637 function setOffsetToUTC (keepLocalTime) { 3638 return this.utcOffset(0, keepLocalTime); 3639 } 3640 3641 function setOffsetToLocal (keepLocalTime) { 3642 if (this._isUTC) { 3643 this.utcOffset(0, keepLocalTime); 3644 this._isUTC = false; 3645 3646 if (keepLocalTime) { 3647 this.subtract(getDateOffset(this), 'm'); 3648 } 3649 } 3650 return this; 3651 } 3652 3653 function setOffsetToParsedOffset () { 3654 if (this._tzm != null) { 3655 this.utcOffset(this._tzm, false, true); 3656 } else if (typeof this._i === 'string') { 3657 var tZone = offsetFromString(matchOffset, this._i); 3658 if (tZone != null) { 3659 this.utcOffset(tZone); 3660 } 3661 else { 3662 this.utcOffset(0, true); 3663 } 3664 } 3665 return this; 3666 } 3667 3668 function hasAlignedHourOffset (input) { 3669 if (!this.isValid()) { 3670 return false; 3671 } 3672 input = input ? createLocal(input).utcOffset() : 0; 3673 3674 return (this.utcOffset() - input) % 60 === 0; 3675 } 3676 3677 function isDaylightSavingTime () { 3678 return ( 3679 this.utcOffset() > this.clone().month(0).utcOffset() || 3680 this.utcOffset() > this.clone().month(5).utcOffset() 3681 ); 3682 } 3683 3684 function isDaylightSavingTimeShifted () { 3685 if (!isUndefined(this._isDSTShifted)) { 3686 return this._isDSTShifted; 3687 } 3688 3689 var c = {}; 3690 3691 copyConfig(c, this); 3692 c = prepareConfig(c); 3693 3694 if (c._a) { 3695 var other = c._isUTC ? createUTC(c._a) : createLocal(c._a); 3696 this._isDSTShifted = this.isValid() && 3697 compareArrays(c._a, other.toArray()) > 0; 3698 } else { 3699 this._isDSTShifted = false; 3700 } 3701 3702 return this._isDSTShifted; 3703 } 3704 3705 function isLocal () { 3706 return this.isValid() ? !this._isUTC : false; 3707 } 3708 3709 function isUtcOffset () { 3710 return this.isValid() ? this._isUTC : false; 3711 } 3712 3713 function isUtc () { 3714 return this.isValid() ? this._isUTC && this._offset === 0 : false; 3715 } 3716 3717 // ASP.NET json date format regex 3718 var aspNetRegex = /^(\-|\+)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/; 3719 3720 // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html 3721 // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere 3722 // and further modified to allow for strings containing both week and day 3723 var isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/; 3724 3725 function createDuration (input, key) { 3726 var duration = input, 3727 // matching against regexp is expensive, do it on demand 3728 match = null, 3729 sign, 3730 ret, 3731 diffRes; 3732 3733 if (isDuration(input)) { 3734 duration = { 3735 ms : input._milliseconds, 3736 d : input._days, 3737 M : input._months 3738 }; 3739 } else if (isNumber(input)) { 3740 duration = {}; 3741 if (key) { 3742 duration[key] = input; 3743 } else { 3744 duration.milliseconds = input; 3745 } 3746 } else if (!!(match = aspNetRegex.exec(input))) { 3747 sign = (match[1] === '-') ? -1 : 1; 3748 duration = { 3749 y : 0, 3750 d : toInt(match[DATE]) * sign, 3751 h : toInt(match[HOUR]) * sign, 3752 m : toInt(match[MINUTE]) * sign, 3753 s : toInt(match[SECOND]) * sign, 3754 ms : toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match 3755 }; 3756 } else if (!!(match = isoRegex.exec(input))) { 3757 sign = (match[1] === '-') ? -1 : (match[1] === '+') ? 1 : 1; 3758 duration = { 3759 y : parseIso(match[2], sign), 3760 M : parseIso(match[3], sign), 3761 w : parseIso(match[4], sign), 3762 d : parseIso(match[5], sign), 3763 h : parseIso(match[6], sign), 3764 m : parseIso(match[7], sign), 3765 s : parseIso(match[8], sign) 3766 }; 3767 } else if (duration == null) {// checks for null or undefined 3768 duration = {}; 3769 } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) { 3770 diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to)); 3771 3772 duration = {}; 3773 duration.ms = diffRes.milliseconds; 3774 duration.M = diffRes.months; 3775 } 3776 3777 ret = new Duration(duration); 3778 3779 if (isDuration(input) && hasOwnProp(input, '_locale')) { 3780 ret._locale = input._locale; 3781 } 3782 3783 return ret; 3784 } 3785 3786 createDuration.fn = Duration.prototype; 3787 createDuration.invalid = createInvalid$1; 3788 3789 function parseIso (inp, sign) { 3790 // We'd normally use ~~inp for this, but unfortunately it also 3791 // converts floats to ints. 3792 // inp may be undefined, so careful calling replace on it. 3793 var res = inp && parseFloat(inp.replace(',', '.')); 3794 // apply sign while we're at it 3795 return (isNaN(res) ? 0 : res) * sign; 3796 } 3797 3798 function positiveMomentsDifference(base, other) { 3799 var res = {milliseconds: 0, months: 0}; 3800 3801 res.months = other.month() - base.month() + 3802 (other.year() - base.year()) * 12; 3803 if (base.clone().add(res.months, 'M').isAfter(other)) { 3804 --res.months; 3805 } 3806 3807 res.milliseconds = +other - +(base.clone().add(res.months, 'M')); 3808 3809 return res; 3810 } 3811 3812 function momentsDifference(base, other) { 3813 var res; 3814 if (!(base.isValid() && other.isValid())) { 3815 return {milliseconds: 0, months: 0}; 3816 } 3817 3818 other = cloneWithOffset(other, base); 3819 if (base.isBefore(other)) { 3820 res = positiveMomentsDifference(base, other); 3821 } else { 3822 res = positiveMomentsDifference(other, base); 3823 res.milliseconds = -res.milliseconds; 3824 res.months = -res.months; 3825 } 3826 3827 return res; 3828 } 3829 3830 // TODO: remove 'name' arg after deprecation is removed 3831 function createAdder(direction, name) { 3832 return function (val, period) { 3833 var dur, tmp; 3834 //invert the arguments, but complain about it 3835 if (period !== null && !isNaN(+period)) { 3836 deprecateSimple(name, 'moment().' + name + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' + 3837 'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.'); 3838 tmp = val; val = period; period = tmp; 3839 } 3840 3841 val = typeof val === 'string' ? +val : val; 3842 dur = createDuration(val, period); 3843 addSubtract(this, dur, direction); 3844 return this; 3845 }; 3846 } 3847 3848 function addSubtract (mom, duration, isAdding, updateOffset) { 3849 var milliseconds = duration._milliseconds, 3850 days = absRound(duration._days), 3851 months = absRound(duration._months); 3852 3853 if (!mom.isValid()) { 3854 // No op 3855 return; 3856 } 3857 3858 updateOffset = updateOffset == null ? true : updateOffset; 3859 3860 if (months) { 3861 setMonth(mom, get(mom, 'Month') + months * isAdding); 3862 } 3863 if (days) { 3864 set$1(mom, 'Date', get(mom, 'Date') + days * isAdding); 3865 } 3866 if (milliseconds) { 3867 mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding); 3868 } 3869 if (updateOffset) { 3870 hooks.updateOffset(mom, days || months); 3871 } 3872 } 3873 3874 var add = createAdder(1, 'add'); 3875 var subtract = createAdder(-1, 'subtract'); 3876 3877 function getCalendarFormat(myMoment, now) { 3878 var diff = myMoment.diff(now, 'days', true); 3879 return diff < -6 ? 'sameElse' : 3880 diff < -1 ? 'lastWeek' : 3881 diff < 0 ? 'lastDay' : 3882 diff < 1 ? 'sameDay' : 3883 diff < 2 ? 'nextDay' : 3884 diff < 7 ? 'nextWeek' : 'sameElse'; 3885 } 3886 3887 function calendar$1 (time, formats) { 3888 // We want to compare the start of today, vs this. 3889 // Getting start-of-today depends on whether we're local/utc/offset or not. 3890 var now = time || createLocal(), 3891 sod = cloneWithOffset(now, this).startOf('day'), 3892 format = hooks.calendarFormat(this, sod) || 'sameElse'; 3893 3894 var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]); 3895 3896 return this.format(output || this.localeData().calendar(format, this, createLocal(now))); 3897 } 3898 3899 function clone () { 3900 return new Moment(this); 3901 } 3902 3903 function isAfter (input, units) { 3904 var localInput = isMoment(input) ? input : createLocal(input); 3905 if (!(this.isValid() && localInput.isValid())) { 3906 return false; 3907 } 3908 units = normalizeUnits(!isUndefined(units) ? units : 'millisecond'); 3909 if (units === 'millisecond') { 3910 return this.valueOf() > localInput.valueOf(); 3911 } else { 3912 return localInput.valueOf() < this.clone().startOf(units).valueOf(); 3913 } 3914 } 3915 3916 function isBefore (input, units) { 3917 var localInput = isMoment(input) ? input : createLocal(input); 3918 if (!(this.isValid() && localInput.isValid())) { 3919 return false; 3920 } 3921 units = normalizeUnits(!isUndefined(units) ? units : 'millisecond'); 3922 if (units === 'millisecond') { 3923 return this.valueOf() < localInput.valueOf(); 3924 } else { 3925 return this.clone().endOf(units).valueOf() < localInput.valueOf(); 3926 } 3927 } 3928 3929 function isBetween (from, to, units, inclusivity) { 3930 inclusivity = inclusivity || '()'; 3931 return (inclusivity[0] === '(' ? this.isAfter(from, units) : !this.isBefore(from, units)) && 3932 (inclusivity[1] === ')' ? this.isBefore(to, units) : !this.isAfter(to, units)); 3933 } 3934 3935 function isSame (input, units) { 3936 var localInput = isMoment(input) ? input : createLocal(input), 3937 inputMs; 3938 if (!(this.isValid() && localInput.isValid())) { 3939 return false; 3940 } 3941 units = normalizeUnits(units || 'millisecond'); 3942 if (units === 'millisecond') { 3943 return this.valueOf() === localInput.valueOf(); 3944 } else { 3945 inputMs = localInput.valueOf(); 3946 return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf(); 3947 } 3948 } 3949 3950 function isSameOrAfter (input, units) { 3951 return this.isSame(input, units) || this.isAfter(input,units); 3952 } 3953 3954 function isSameOrBefore (input, units) { 3955 return this.isSame(input, units) || this.isBefore(input,units); 3956 } 3957 3958 function diff (input, units, asFloat) { 3959 var that, 3960 zoneDelta, 3961 output; 3962 3963 if (!this.isValid()) { 3964 return NaN; 3965 } 3966 3967 that = cloneWithOffset(input, this); 3968 3969 if (!that.isValid()) { 3970 return NaN; 3971 } 3972 3973 zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4; 3974 3975 units = normalizeUnits(units); 3976 3977 switch (units) { 3978 case 'year': output = monthDiff(this, that) / 12; break; 3979 case 'month': output = monthDiff(this, that); break; 3980 case 'quarter': output = monthDiff(this, that) / 3; break; 3981 case 'second': output = (this - that) / 1e3; break; // 1000 3982 case 'minute': output = (this - that) / 6e4; break; // 1000 * 60 3983 case 'hour': output = (this - that) / 36e5; break; // 1000 * 60 * 60 3984 case 'day': output = (this - that - zoneDelta) / 864e5; break; // 1000 * 60 * 60 * 24, negate dst 3985 case 'week': output = (this - that - zoneDelta) / 6048e5; break; // 1000 * 60 * 60 * 24 * 7, negate dst 3986 default: output = this - that; 3987 } 3988 3989 return asFloat ? output : absFloor(output); 3990 } 3991 3992 function monthDiff (a, b) { 3993 // difference in months 3994 var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()), 3995 // b is in (anchor - 1 month, anchor + 1 month) 3996 anchor = a.clone().add(wholeMonthDiff, 'months'), 3997 anchor2, adjust; 3998 3999 if (b - anchor < 0) { 4000 anchor2 = a.clone().add(wholeMonthDiff - 1, 'months'); 4001 // linear across the month 4002 adjust = (b - anchor) / (anchor - anchor2); 4003 } else { 4004 anchor2 = a.clone().add(wholeMonthDiff + 1, 'months'); 4005 // linear across the month 4006 adjust = (b - anchor) / (anchor2 - anchor); 4007 } 4008 4009 //check for negative zero, return zero if negative zero 4010 return -(wholeMonthDiff + adjust) || 0; 4011 } 4012 4013 hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ'; 4014 hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]'; 4015 4016 function toString () { 4017 return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ'); 4018 } 4019 4020 function toISOString(keepOffset) { 4021 if (!this.isValid()) { 4022 return null; 4023 } 4024 var utc = keepOffset !== true; 4025 var m = utc ? this.clone().utc() : this; 4026 if (m.year() < 0 || m.year() > 9999) { 4027 return formatMoment(m, utc ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ'); 4028 } 4029 if (isFunction(Date.prototype.toISOString)) { 4030 // native implementation is ~50x faster, use it when we can 4031 if (utc) { 4032 return this.toDate().toISOString(); 4033 } else { 4034 return new Date(this.valueOf() + this.utcOffset() * 60 * 1000).toISOString().replace('Z', formatMoment(m, 'Z')); 4035 } 4036 } 4037 return formatMoment(m, utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ'); 4038 } 4039 4040 /** 4041 * Return a human readable representation of a moment that can 4042 * also be evaluated to get a new moment which is the same 4043 * 4044 * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects 4045 */ 4046 function inspect () { 4047 if (!this.isValid()) { 4048 return 'moment.invalid(/* ' + this._i + ' */)'; 4049 } 4050 var func = 'moment'; 4051 var zone = ''; 4052 if (!this.isLocal()) { 4053 func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone'; 4054 zone = 'Z'; 4055 } 4056 var prefix = '[' + func + '("]'; 4057 var year = (0 <= this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY'; 4058 var datetime = '-MM-DD[T]HH:mm:ss.SSS'; 4059 var suffix = zone + '[")]'; 4060 4061 return this.format(prefix + year + datetime + suffix); 4062 } 4063 4064 function format (inputString) { 4065 if (!inputString) { 4066 inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat; 4067 } 4068 var output = formatMoment(this, inputString); 4069 return this.localeData().postformat(output); 4070 } 4071 4072 function from (time, withoutSuffix) { 4073 if (this.isValid() && 4074 ((isMoment(time) && time.isValid()) || 4075 createLocal(time).isValid())) { 4076 return createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix); 4077 } else { 4078 return this.localeData().invalidDate(); 4079 } 4080 } 4081 4082 function fromNow (withoutSuffix) { 4083 return this.from(createLocal(), withoutSuffix); 4084 } 4085 4086 function to (time, withoutSuffix) { 4087 if (this.isValid() && 4088 ((isMoment(time) && time.isValid()) || 4089 createLocal(time).isValid())) { 4090 return createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix); 4091 } else { 4092 return this.localeData().invalidDate(); 4093 } 4094 } 4095 4096 function toNow (withoutSuffix) { 4097 return this.to(createLocal(), withoutSuffix); 4098 } 4099 4100 // If passed a locale key, it will set the locale for this 4101 // instance. Otherwise, it will return the locale configuration 4102 // variables for this instance. 4103 function locale (key) { 4104 var newLocaleData; 4105 4106 if (key === undefined) { 4107 return this._locale._abbr; 4108 } else { 4109 newLocaleData = getLocale(key); 4110 if (newLocaleData != null) { 4111 this._locale = newLocaleData; 4112 } 4113 return this; 4114 } 4115 } 4116 4117 var lang = deprecate( 4118 'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.', 4119 function (key) { 4120 if (key === undefined) { 4121 return this.localeData(); 4122 } else { 4123 return this.locale(key); 4124 } 4125 } 4126 ); 4127 4128 function localeData () { 4129 return this._locale; 4130 } 4131 4132 function startOf (units) { 4133 units = normalizeUnits(units); 4134 // the following switch intentionally omits break keywords 4135 // to utilize falling through the cases. 4136 switch (units) { 4137 case 'year': 4138 this.month(0); 4139 /* falls through */ 4140 case 'quarter': 4141 case 'month': 4142 this.date(1); 4143 /* falls through */ 4144 case 'week': 4145 case 'isoWeek': 4146 case 'day': 4147 case 'date': 4148 this.hours(0); 4149 /* falls through */ 4150 case 'hour': 4151 this.minutes(0); 4152 /* falls through */ 4153 case 'minute': 4154 this.seconds(0); 4155 /* falls through */ 4156 case 'second': 4157 this.milliseconds(0); 4158 } 4159 4160 // weeks are a special case 4161 if (units === 'week') { 4162 this.weekday(0); 4163 } 4164 if (units === 'isoWeek') { 4165 this.isoWeekday(1); 4166 } 4167 4168 // quarters are also special 4169 if (units === 'quarter') { 4170 this.month(Math.floor(this.month() / 3) * 3); 4171 } 4172 4173 return this; 4174 } 4175 4176 function endOf (units) { 4177 units = normalizeUnits(units); 4178 if (units === undefined || units === 'millisecond') { 4179 return this; 4180 } 4181 4182 // 'date' is an alias for 'day', so it should be considered as such. 4183 if (units === 'date') { 4184 units = 'day'; 4185 } 4186 4187 return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms')
vendor: 20,515 bytes, lines 4187-4893
4187; 4188 } 4189 4190 function valueOf () { 4191 return this._d.valueOf() - ((this._offset || 0) * 60000); 4192 } 4193 4194 function unix () { 4195 return Math.floor(this.valueOf() / 1000); 4196 } 4197 4198 function toDate () { 4199 return new Date(this.valueOf()); 4200 } 4201 4202 function toArray () { 4203 var m = this; 4204 return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()]; 4205 } 4206 4207 function toObject () { 4208 var m = this; 4209 return { 4210 years: m.year(), 4211 months: m.month(), 4212 date: m.date(), 4213 hours: m.hours(), 4214 minutes: m.minutes(), 4215 seconds: m.seconds(), 4216 milliseconds: m.milliseconds() 4217 }; 4218 } 4219 4220 function toJSON () { 4221 // new Date(NaN).toJSON() === null 4222 return this.isValid() ? this.toISOString() : null; 4223 } 4224 4225 function isValid$2 () { 4226 return isValid(this); 4227 } 4228 4229 function parsingFlags () { 4230 return extend({}, getParsingFlags(this)); 4231 } 4232 4233 function invalidAt () { 4234 return getParsingFlags(this).overflow; 4235 } 4236 4237 function creationData() { 4238 return { 4239 input: this._i, 4240 format: this._f, 4241 locale: this._locale, 4242 isUTC: this._isUTC, 4243 strict: this._strict 4244 }; 4245 } 4246 4247 // FORMATTING 4248 4249 addFormatToken(0, ['gg', 2], 0, function () { 4250 return this.weekYear() % 100; 4251 }); 4252 4253 addFormatToken(0, ['GG', 2], 0, function () { 4254 return this.isoWeekYear() % 100; 4255 }); 4256 4257 function addWeekYearFormatToken (token, getter) { 4258 addFormatToken(0, [token, token.length], 0, getter); 4259 } 4260 4261 addWeekYearFormatToken('gggg', 'weekYear'); 4262 addWeekYearFormatToken('ggggg', 'weekYear'); 4263 addWeekYearFormatToken('GGGG', 'isoWeekYear'); 4264 addWeekYearFormatToken('GGGGG', 'isoWeekYear'); 4265 4266 // ALIASES 4267 4268 addUnitAlias('weekYear', 'gg'); 4269 addUnitAlias('isoWeekYear', 'GG'); 4270 4271 // PRIORITY 4272 4273 addUnitPriority('weekYear', 1); 4274 addUnitPriority('isoWeekYear', 1); 4275 4276 4277 // PARSING 4278 4279 addRegexToken('G', matchSigned); 4280 addRegexToken('g', matchSigned); 4281 addRegexToken('GG', match1to2, match2); 4282 addRegexToken('gg', match1to2, match2); 4283 addRegexToken('GGGG', match1to4, match4); 4284 addRegexToken('gggg', match1to4, match4); 4285 addRegexToken('GGGGG', match1to6, match6); 4286 addRegexToken('ggggg', match1to6, match6); 4287 4288 addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) { 4289 week[token.substr(0, 2)] = toInt(input); 4290 }); 4291 4292 addWeekParseToken(['gg', 'GG'], function (input, week, config, token) { 4293 week[token] = hooks.parseTwoDigitYear(input); 4294 }); 4295 4296 // MOMENTS 4297 4298 function getSetWeekYear (input) { 4299 return getSetWeekYearHelper.call(this, 4300 input, 4301 this.week(), 4302 this.weekday(), 4303 this.localeData()._week.dow, 4304 this.localeData()._week.doy); 4305 } 4306 4307 function getSetISOWeekYear (input) { 4308 return getSetWeekYearHelper.call(this, 4309 input, this.isoWeek(), this.isoWeekday(), 1, 4); 4310 } 4311 4312 function getISOWeeksInYear () { 4313 return weeksInYear(this.year(), 1, 4); 4314 } 4315 4316 function getWeeksInYear () { 4317 var weekInfo = this.localeData()._week; 4318 return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy); 4319 } 4320 4321 function getSetWeekYearHelper(input, week, weekday, dow, doy) { 4322 var weeksTarget; 4323 if (input == null) { 4324 return weekOfYear(this, dow, doy).year; 4325 } else { 4326 weeksTarget = weeksInYear(input, dow, doy); 4327 if (week > weeksTarget) { 4328 week = weeksTarget; 4329 } 4330 return setWeekAll.call(this, input, week, weekday, dow, doy); 4331 } 4332 } 4333 4334 function setWeekAll(weekYear, week, weekday, dow, doy) { 4335 var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy), 4336 date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear); 4337 4338 this.year(date.getUTCFullYear()); 4339 this.month(date.getUTCMonth()); 4340 this.date(date.getUTCDate()); 4341 return this; 4342 } 4343 4344 // FORMATTING 4345 4346 addFormatToken('Q', 0, 'Qo', 'quarter'); 4347 4348 // ALIASES 4349 4350 addUnitAlias('quarter', 'Q'); 4351 4352 // PRIORITY 4353 4354 addUnitPriority('quarter', 7); 4355 4356 // PARSING 4357 4358 addRegexToken('Q', match1); 4359 addParseToken('Q', function (input, array) { 4360 array[MONTH] = (toInt(input) - 1) * 3; 4361 }); 4362 4363 // MOMENTS 4364 4365 function getSetQuarter (input) { 4366 return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3); 4367 } 4368 4369 // FORMATTING 4370 4371 addFormatToken('D', ['DD', 2], 'Do', 'date'); 4372 4373 // ALIASES 4374 4375 addUnitAlias('date', 'D'); 4376 4377 // PRIORITY 4378 addUnitPriority('date', 9); 4379 4380 // PARSING 4381 4382 addRegexToken('D', match1to2); 4383 addRegexToken('DD', match1to2, match2); 4384 addRegexToken('Do', function (isStrict, locale) { 4385 // TODO: Remove "ordinalParse" fallback in next major release. 4386 return isStrict ? 4387 (locale._dayOfMonthOrdinalParse || locale._ordinalParse) : 4388 locale._dayOfMonthOrdinalParseLenient; 4389 }); 4390 4391 addParseToken(['D', 'DD'], DATE); 4392 addParseToken('Do', function (input, array) { 4393 array[DATE] = toInt(input.match(match1to2)[0]); 4394 }); 4395 4396 // MOMENTS 4397 4398 var getSetDayOfMonth = makeGetSet('Date', true); 4399 4400 // FORMATTING 4401 4402 addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear'); 4403 4404 // ALIASES 4405 4406 addUnitAlias('dayOfYear', 'DDD'); 4407 4408 // PRIORITY 4409 addUnitPriority('dayOfYear', 4); 4410 4411 // PARSING 4412 4413 addRegexToken('DDD', match1to3); 4414 addRegexToken('DDDD', match3); 4415 addParseToken(['DDD', 'DDDD'], function (input, array, config) { 4416 config._dayOfYear = toInt(input); 4417 }); 4418 4419 // HELPERS 4420 4421 // MOMENTS 4422 4423 function getSetDayOfYear (input) { 4424 var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1; 4425 return input == null ? dayOfYear : this.add((input - dayOfYear), 'd'); 4426 } 4427 4428 // FORMATTING 4429 4430 addFormatToken('m', ['mm', 2], 0, 'minute'); 4431 4432 // ALIASES 4433 4434 addUnitAlias('minute', 'm'); 4435 4436 // PRIORITY 4437 4438 addUnitPriority('minute', 14); 4439 4440 // PARSING 4441 4442 addRegexToken('m', match1to2); 4443 addRegexToken('mm', match1to2, match2); 4444 addParseToken(['m', 'mm'], MINUTE); 4445 4446 // MOMENTS 4447 4448 var getSetMinute = makeGetSet('Minutes', false); 4449 4450 // FORMATTING 4451 4452 addFormatToken('s', ['ss', 2], 0, 'second'); 4453 4454 // ALIASES 4455 4456 addUnitAlias('second', 's'); 4457 4458 // PRIORITY 4459 4460 addUnitPriority('second', 15); 4461 4462 // PARSING 4463 4464 addRegexToken('s', match1to2); 4465 addRegexToken('ss', match1to2, match2); 4466 addParseToken(['s', 'ss'], SECOND); 4467 4468 // MOMENTS 4469 4470 var getSetSecond = makeGetSet('Seconds', false); 4471 4472 // FORMATTING 4473 4474 addFormatToken('S', 0, 0, function () { 4475 return ~~(this.millisecond() / 100); 4476 }); 4477 4478 addFormatToken(0, ['SS', 2], 0, function () { 4479 return ~~(this.millisecond() / 10); 4480 }); 4481 4482 addFormatToken(0, ['SSS', 3], 0, 'millisecond'); 4483 addFormatToken(0, ['SSSS', 4], 0, function () { 4484 return this.millisecond() * 10; 4485 }); 4486 addFormatToken(0, ['SSSSS', 5], 0, function () { 4487 return this.millisecond() * 100; 4488 }); 4489 addFormatToken(0, ['SSSSSS', 6], 0, function () { 4490 return this.millisecond() * 1000; 4491 }); 4492 addFormatToken(0, ['SSSSSSS', 7], 0, function () { 4493 return this.millisecond() * 10000; 4494 }); 4495 addFormatToken(0, ['SSSSSSSS', 8], 0, function () { 4496 return this.millisecond() * 100000; 4497 }); 4498 addFormatToken(0, ['SSSSSSSSS', 9], 0, function () { 4499 return this.millisecond() * 1000000; 4500 }); 4501 4502 4503 // ALIASES 4504 4505 addUnitAlias('millisecond', 'ms'); 4506 4507 // PRIORITY 4508 4509 addUnitPriority('millisecond', 16); 4510 4511 // PARSING 4512 4513 addRegexToken('S', match1to3, match1); 4514 addRegexToken('SS', match1to3, match2); 4515 addRegexToken('SSS', match1to3, match3); 4516 4517 var token; 4518 for (token = 'SSSS'; token.length <= 9; token += 'S') { 4519 addRegexToken(token, matchUnsigned); 4520 } 4521 4522 function parseMs(input, array) { 4523 array[MILLISECOND] = toInt(('0.' + input) * 1000); 4524 } 4525 4526 for (token = 'S'; token.length <= 9; token += 'S') { 4527 addParseToken(token, parseMs); 4528 } 4529 // MOMENTS 4530 4531 var getSetMillisecond = makeGetSet('Milliseconds', false); 4532 4533 // FORMATTING 4534 4535 addFormatToken('z', 0, 0, 'zoneAbbr'); 4536 addFormatToken('zz', 0, 0, 'zoneName'); 4537 4538 // MOMENTS 4539 4540 function getZoneAbbr () { 4541 return this._isUTC ? 'UTC' : ''; 4542 } 4543 4544 function getZoneName () { 4545 return this._isUTC ? 'Coordinated Universal Time' : ''; 4546 } 4547 4548 var proto = Moment.prototype; 4549 4550 proto.add = add; 4551 proto.calendar = calendar$1; 4552 proto.clone = clone; 4553 proto.diff = diff; 4554 proto.endOf = endOf; 4555 proto.format = format; 4556 proto.from = from; 4557 proto.fromNow = fromNow; 4558 proto.to = to; 4559 proto.toNow = toNow; 4560 proto.get = stringGet; 4561 proto.invalidAt = invalidAt; 4562 proto.isAfter = isAfter; 4563 proto.isBefore = isBefore; 4564 proto.isBetween = isBetween; 4565 proto.isSame = isSame; 4566 proto.isSameOrAfter = isSameOrAfter; 4567 proto.isSameOrBefore = isSameOrBefore; 4568 proto.isValid = isValid$2; 4569 proto.lang = lang; 4570 proto.locale = locale; 4571 proto.localeData = localeData; 4572 proto.max = prototypeMax; 4573 proto.min = prototypeMin; 4574 proto.parsingFlags = parsingFlags; 4575 proto.set = stringSet; 4576 proto.startOf = startOf; 4577 proto.subtract = subtract; 4578 proto.toArray = toArray; 4579 proto.toObject = toObject; 4580 proto.toDate = toDate; 4581 proto.toISOString = toISOString; 4582 proto.inspect = inspect; 4583 proto.toJSON = toJSON; 4584 proto.toString = toString; 4585 proto.unix = unix; 4586 proto.valueOf = valueOf; 4587 proto.creationData = creationData; 4588 proto.year = getSetYear; 4589 proto.isLeapYear = getIsLeapYear; 4590 proto.weekYear = getSetWeekYear; 4591 proto.isoWeekYear = getSetISOWeekYear; 4592 proto.quarter = proto.quarters = getSetQuarter; 4593 proto.month = getSetMonth; 4594 proto.daysInMonth = getDaysInMonth; 4595 proto.week = proto.weeks = getSetWeek; 4596 proto.isoWeek = proto.isoWeeks = getSetISOWeek; 4597 proto.weeksInYear = getWeeksInYear; 4598 proto.isoWeeksInYear = getISOWeeksInYear; 4599 proto.date = getSetDayOfMonth; 4600 proto.day = proto.days = getSetDayOfWeek; 4601 proto.weekday = getSetLocaleDayOfWeek; 4602 proto.isoWeekday = getSetISODayOfWeek; 4603 proto.dayOfYear = getSetDayOfYear; 4604 proto.hour = proto.hours = getSetHour; 4605 proto.minute = proto.minutes = getSetMinute; 4606 proto.second = proto.seconds = getSetSecond; 4607 proto.millisecond = proto.milliseconds = getSetMillisecond; 4608 proto.utcOffset = getSetOffset; 4609 proto.utc = setOffsetToUTC; 4610 proto.local = setOffsetToLocal; 4611 proto.parseZone = setOffsetToParsedOffset; 4612 proto.hasAlignedHourOffset = hasAlignedHourOffset; 4613 proto.isDST = isDaylightSavingTime; 4614 proto.isLocal = isLocal; 4615 proto.isUtcOffset = isUtcOffset; 4616 proto.isUtc = isUtc; 4617 proto.isUTC = isUtc; 4618 proto.zoneAbbr = getZoneAbbr; 4619 proto.zoneName = getZoneName; 4620 proto.dates = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth); 4621 proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth); 4622 proto.years = deprecate('years accessor is deprecated. Use year instead', getSetYear); 4623 proto.zone = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone); 4624 proto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted); 4625 4626 function createUnix (input) { 4627 return createLocal(input * 1000); 4628 } 4629 4630 function createInZone () { 4631 return createLocal.apply(null, arguments).parseZone(); 4632 } 4633 4634 function preParsePostFormat (string) { 4635 return string; 4636 } 4637 4638 var proto$1 = Locale.prototype; 4639 4640 proto$1.calendar = calendar; 4641 proto$1.longDateFormat = longDateFormat; 4642 proto$1.invalidDate = invalidDate; 4643 proto$1.ordinal = ordinal; 4644 proto$1.preparse = preParsePostFormat; 4645 proto$1.postformat = preParsePostFormat; 4646 proto$1.relativeTime = relativeTime; 4647 proto$1.pastFuture = pastFuture; 4648 proto$1.set = set; 4649 4650 proto$1.months = localeMonths; 4651 proto$1.monthsShort = localeMonthsShort; 4652 proto$1.monthsParse = localeMonthsParse; 4653 proto$1.monthsRegex = monthsRegex; 4654 proto$1.monthsShortRegex = monthsShortRegex; 4655 proto$1.week = localeWeek; 4656 proto$1.firstDayOfYear = localeFirstDayOfYear; 4657 proto$1.firstDayOfWeek = localeFirstDayOfWeek; 4658 4659 proto$1.weekdays = localeWeekdays; 4660 proto$1.weekdaysMin = localeWeekdaysMin; 4661 proto$1.weekdaysShort = localeWeekdaysShort; 4662 proto$1.weekdaysParse = localeWeekdaysParse; 4663 4664 proto$1.weekdaysRegex = weekdaysRegex; 4665 proto$1.weekdaysShortRegex = weekdaysShortRegex; 4666 proto$1.weekdaysMinRegex = weekdaysMinRegex; 4667 4668 proto$1.isPM = localeIsPM; 4669 proto$1.meridiem = localeMeridiem; 4670 4671 function get$1 (format, index, field, setter) { 4672 var locale = getLocale(); 4673 var utc = createUTC().set(setter, index); 4674 return locale[field](utc, format); 4675 } 4676 4677 function listMonthsImpl (format, index, field) { 4678 if (isNumber(format)) { 4679 index = format; 4680 format = undefined; 4681 } 4682 4683 format = format || ''; 4684 4685 if (index != null) { 4686 return get$1(format, index, field, 'month'); 4687 } 4688 4689 var i; 4690 var out = []; 4691 for (i = 0; i < 12; i++) { 4692 out[i] = get$1(format, i, field, 'month'); 4693 } 4694 return out; 4695 } 4696 4697 // () 4698 // (5) 4699 // (fmt, 5) 4700 // (fmt) 4701 // (true) 4702 // (true, 5) 4703 // (true, fmt, 5) 4704 // (true, fmt) 4705 function listWeekdaysImpl (localeSorted, format, index, field) { 4706 if (typeof localeSorted === 'boolean') { 4707 if (isNumber(format)) { 4708 index = format; 4709 format = undefined; 4710 } 4711 4712 format = format || ''; 4713 } else { 4714 format = localeSorted; 4715 index = format; 4716 localeSorted = false; 4717 4718 if (isNumber(format)) { 4719 index = format; 4720 format = undefined; 4721 } 4722 4723 format = format || ''; 4724 } 4725 4726 var locale = getLocale(), 4727 shift = localeSorted ? locale._week.dow : 0; 4728 4729 if (index != null) { 4730 return get$1(format, (index + shift) % 7, field, 'day'); 4731 } 4732 4733 var i; 4734 var out = []; 4735 for (i = 0; i < 7; i++) { 4736 out[i] = get$1(format, (i + shift) % 7, field, 'day'); 4737 } 4738 return out; 4739 } 4740 4741 function listMonths (format, index) { 4742 return listMonthsImpl(format, index, 'months'); 4743 } 4744 4745 function listMonthsShort (format, index) { 4746 return listMonthsImpl(format, index, 'monthsShort'); 4747 } 4748 4749 function listWeekdays (localeSorted, format, index) { 4750 return listWeekdaysImpl(localeSorted, format, index, 'weekdays'); 4751 } 4752 4753 function listWeekdaysShort (localeSorted, format, index) { 4754 return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort'); 4755 } 4756 4757 function listWeekdaysMin (localeSorted, format, index) { 4758 return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin'); 4759 } 4760 4761 getSetGlobalLocale('en', { 4762 dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/, 4763 ordinal : function (number) { 4764 var b = number % 10, 4765 output = (toInt(number % 100 / 10) === 1) ? 'th' : 4766 (b === 1) ? 'st' : 4767 (b === 2) ? 'nd' : 4768 (b === 3) ? 'rd' : 'th'; 4769 return number + output; 4770 } 4771 }); 4772 4773 // Side effect imports 4774 4775 hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale); 4776 hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale); 4777 4778 var mathAbs = Math.abs; 4779 4780 function abs () { 4781 var data = this._data; 4782 4783 this._milliseconds = mathAbs(this._milliseconds); 4784 this._days = mathAbs(this._days); 4785 this._months = mathAbs(this._months); 4786 4787 data.milliseconds = mathAbs(data.milliseconds); 4788 data.seconds = mathAbs(data.seconds); 4789 data.minutes = mathAbs(data.minutes); 4790 data.hours = mathAbs(data.hours); 4791 data.months = mathAbs(data.months); 4792 data.years = mathAbs(data.years); 4793 4794 return this; 4795 } 4796 4797 function addSubtract$1 (duration, input, value, direction) { 4798 var other = createDuration(input, value); 4799 4800 duration._milliseconds += direction * other._milliseconds; 4801 duration._days += direction * other._days; 4802 duration._months += direction * other._months; 4803 4804 return duration._bubble(); 4805 } 4806 4807 // supports only 2.0-style add(1, 's') or add(duration) 4808 function add$1 (input, value) { 4809 return addSubtract$1(this, input, value, 1); 4810 } 4811 4812 // supports only 2.0-style subtract(1, 's') or subtract(duration) 4813 function subtract$1 (input, value) { 4814 return addSubtract$1(this, input, value, -1); 4815 } 4816 4817 function absCeil (number) { 4818 if (number < 0) { 4819 return Math.floor(number); 4820 } else { 4821 return Math.ceil(number); 4822 } 4823 } 4824 4825 function bubble () { 4826 var milliseconds = this._milliseconds; 4827 var days = this._days; 4828 var months = this._months; 4829 var data = this._data; 4830 var seconds, minutes, hours, years, monthsFromDays; 4831 4832 // if we have a mix of positive and negative values, bubble down first 4833 // check: https://github.com/moment/moment/issues/2166 4834 if (!((milliseconds >= 0 && days >= 0 && months >= 0) || 4835 (milliseconds <= 0 && days <= 0 && months <= 0))) { 4836 milliseconds += absCeil(monthsToDays(months) + days) * 864e5; 4837 days = 0; 4838 months = 0; 4839 } 4840 4841 // The following code bubbles up values, see the tests for 4842 // examples of what that means. 4843 data.milliseconds = milliseconds % 1000; 4844 4845 seconds = absFloor(milliseconds / 1000); 4846 data.seconds = seconds % 60; 4847 4848 minutes = absFloor(seconds / 60); 4849 data.minutes = minutes % 60; 4850 4851 hours = absFloor(minutes / 60); 4852 data.hours = hours % 24; 4853 4854 days += absFloor(hours / 24); 4855 4856 // convert days to months 4857 monthsFromDays = absFloor(daysToMonths(days)); 4858 months += monthsFromDays; 4859 days -= absCeil(monthsToDays(monthsFromDays)); 4860 4861 // 12 months -> 1 year 4862 years = absFloor(months / 12); 4863 months %= 12; 4864 4865 data.days = days; 4866 data.months = months; 4867 data.years = years; 4868 4869 return this; 4870 } 4871 4872 function daysToMonths (days) { 4873 // 400 years have 146097 days (taking into account leap year rules) 4874 // 400 years have 12 months === 4800 4875 return days * 4800 / 146097; 4876 } 4877 4878 function monthsToDays (months) { 4879 // the reverse of daysToMonths 4880 return months * 146097 / 4800; 4881 } 4882 4883 function as (units) { 4884 if (!this.isValid()) { 4885 return NaN; 4886 } 4887 var days; 4888 var months; 4889 var milliseconds = this._milliseconds; 4890 4891 units = normalizeUnits(units); 4892 4893 if (units === 'month' || units === '
vendor: 1,721 bytes, lines 4893-4938
4893year') { 4894 days = this._days + milliseconds / 864e5; 4895 months = this._months + daysToMonths(days); 4896 return units === 'month' ? months : months / 12; 4897 } else { 4898 // handle milliseconds separately because of floating point math errors (issue #1867) 4899 days = this._days + Math.round(monthsToDays(this._months)); 4900 switch (units) { 4901 case 'week' : return days / 7 + milliseconds / 6048e5; 4902 case 'day' : return days + milliseconds / 864e5; 4903 case 'hour' : return days * 24 + milliseconds / 36e5; 4904 case 'minute' : return days * 1440 + milliseconds / 6e4; 4905 case 'second' : return days * 86400 + milliseconds / 1000; 4906 // Math.floor prevents floating point math errors here 4907 case 'millisecond': return Math.floor(days * 864e5) + milliseconds; 4908 default: throw new Error('Unknown unit ' + units); 4909 } 4910 } 4911 } 4912 4913 // TODO: Use this.as('ms')? 4914 function valueOf$1 () { 4915 if (!this.isValid()) { 4916 return NaN; 4917 } 4918 return ( 4919 this._milliseconds + 4920 this._days * 864e5 + 4921 (this._months % 12) * 2592e6 + 4922 toInt(this._months / 12) * 31536e6 4923 ); 4924 } 4925 4926 function makeAs (alias) { 4927 return function () { 4928 return this.as(alias); 4929 }; 4930 } 4931 4932 var asMilliseconds = makeAs('ms'); 4933 var asSeconds = makeAs('s'); 4934 var asMinutes = makeAs('m'); 4935 var asHours = makeAs('h'); 4936 var asDays = makeAs('d'); 4937 var asWeeks = makeAs('w'); 4938 var asMonths = makeAs('M
vendor: 6,605 bytes, lines 4938-5130
4938'); 4939 var asYears = makeAs('y'); 4940 4941 function clone$1 () { 4942 return createDuration(this); 4943 } 4944 4945 function get$2 (units) { 4946 units = normalizeUnits(units); 4947 return this.isValid() ? this[units + 's']() : NaN; 4948 } 4949 4950 function makeGetter(name) { 4951 return function () { 4952 return this.isValid() ? this._data[name] : NaN; 4953 }; 4954 } 4955 4956 var milliseconds = makeGetter('milliseconds'); 4957 var seconds = makeGetter('seconds'); 4958 var minutes = makeGetter('minutes'); 4959 var hours = makeGetter('hours'); 4960 var days = makeGetter('days'); 4961 var months = makeGetter('months'); 4962 var years = makeGetter('years'); 4963 4964 function weeks () { 4965 return absFloor(this.days() / 7); 4966 } 4967 4968 var round = Math.round; 4969 var thresholds = { 4970 ss: 44, // a few seconds to seconds 4971 s : 45, // seconds to minute 4972 m : 45, // minutes to hour 4973 h : 22, // hours to day 4974 d : 26, // days to month 4975 M : 11 // months to year 4976 }; 4977 4978 // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize 4979 function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) { 4980 return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture); 4981 } 4982 4983 function relativeTime$1 (posNegDuration, withoutSuffix, locale) { 4984 var duration = createDuration(posNegDuration).abs(); 4985 var seconds = round(duration.as('s')); 4986 var minutes = round(duration.as('m')); 4987 var hours = round(duration.as('h')); 4988 var days = round(duration.as('d')); 4989 var months = round(duration.as('M')); 4990 var years = round(duration.as('y')); 4991 4992 var a = seconds <= thresholds.ss && ['s', seconds] || 4993 seconds < thresholds.s && ['ss', seconds] || 4994 minutes <= 1 && ['m'] || 4995 minutes < thresholds.m && ['mm', minutes] || 4996 hours <= 1 && ['h'] || 4997 hours < thresholds.h && ['hh', hours] || 4998 days <= 1 && ['d'] || 4999 days < thresholds.d && ['dd', days] || 5000 months <= 1 && ['M'] || 5001 months < thresholds.M && ['MM', months] || 5002 years <= 1 && ['y'] || ['yy', years]; 5003 5004 a[2] = withoutSuffix; 5005 a[3] = +posNegDuration > 0; 5006 a[4] = locale; 5007 return substituteTimeAgo.apply(null, a); 5008 } 5009 5010 // This function allows you to set the rounding function for relative time strings 5011 function getSetRelativeTimeRounding (roundingFunction) { 5012 if (roundingFunction === undefined) { 5013 return round; 5014 } 5015 if (typeof(roundingFunction) === 'function') { 5016 round = roundingFunction; 5017 return true; 5018 } 5019 return false; 5020 } 5021 5022 // This function allows you to set a threshold for relative time strings 5023 function getSetRelativeTimeThreshold (threshold, limit) { 5024 if (thresholds[threshold] === undefined) { 5025 return false; 5026 } 5027 if (limit === undefined) { 5028 return thresholds[threshold]; 5029 } 5030 thresholds[threshold] = limit; 5031 if (threshold === 's') { 5032 thresholds.ss = limit - 1; 5033 } 5034 return true; 5035 } 5036 5037 function humanize (withSuffix) { 5038 if (!this.isValid()) { 5039 return this.localeData().invalidDate(); 5040 } 5041 5042 var locale = this.localeData(); 5043 var output = relativeTime$1(this, !withSuffix, locale); 5044 5045 if (withSuffix) { 5046 output = locale.pastFuture(+this, output); 5047 } 5048 5049 return locale.postformat(output); 5050 } 5051 5052 var abs$1 = Math.abs; 5053 5054 function sign(x) { 5055 return ((x > 0) - (x < 0)) || +x; 5056 } 5057 5058 function toISOString$1() { 5059 // for ISO strings we do not use the normal bubbling rules: 5060 // * milliseconds bubble up until they become hours 5061 // * days do not bubble at all 5062 // * months bubble up until they become years 5063 // This is because there is no context-free conversion between hours and days 5064 // (think of clock changes) 5065 // and also not between days and months (28-31 days per month) 5066 if (!this.isValid()) { 5067 return this.localeData().invalidDate(); 5068 } 5069 5070 var seconds = abs$1(this._milliseconds) / 1000; 5071 var days = abs$1(this._days); 5072 var months = abs$1(this._months); 5073 var minutes, hours, years; 5074 5075 // 3600 seconds -> 60 minutes -> 1 hour 5076 minutes = absFloor(seconds / 60); 5077 hours = absFloor(minutes / 60); 5078 seconds %= 60; 5079 minutes %= 60; 5080 5081 // 12 months -> 1 year 5082 years = absFloor(months / 12); 5083 months %= 12; 5084 5085 5086 // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js 5087 var Y = years; 5088 var M = months; 5089 var D = days; 5090 var h = hours; 5091 var m = minutes; 5092 var s = seconds ? seconds.toFixed(3).replace(/\.?0+$/, '') : ''; 5093 var total = this.asSeconds(); 5094 5095 if (!total) { 5096 // this is the same as C#'s (Noda) and python (isodate)... 5097 // but not other JS (goog.date) 5098 return 'P0D'; 5099 } 5100 5101 var totalSign = total < 0 ? '-' : ''; 5102 var ymSign = sign(this._months) !== sign(total) ? '-' : ''; 5103 var daysSign = sign(this._days) !== sign(total) ? '-' : ''; 5104 var hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : ''; 5105 5106 return totalSign + 'P' + 5107 (Y ? ymSign + Y + 'Y' : '') + 5108 (M ? ymSign + M + 'M' : '') + 5109 (D ? daysSign + D + 'D' : '') + 5110 ((h || m || s) ? 'T' : '') + 5111 (h ? hmsSign + h + 'H' : '') + 5112 (m ? hmsSign + m + 'M' : '') + 5113 (s ? hmsSign + s + 'S' : ''); 5114 } 5115 5116 var proto$2 = Duration.prototype; 5117 5118 proto$2.isValid = isValid$1; 5119 proto$2.abs = abs; 5120 proto$2.add = add$1; 5121 proto$2.subtract = subtract$1; 5122 proto$2.as = as; 5123 proto$2.asMilliseconds = asMilliseconds; 5124 proto$2.asSeconds = asSeconds; 5125 proto$2.asMinutes = asMinutes; 5126 proto$2.asHours = asHours; 5127 proto$2.asDays = asDays; 5128 proto$2.asWeeks = asWeeks; 5129 proto$2.asMonths = asMonths; 5130 proto$2.as
5130Years = asYears; 5131 proto$2.valueOf = valueOf$1; 5132 proto$2._bubble = bubble; 5133 proto$2.clone = clone$1; 5134 proto$2.get = get$2; 5135 proto$2.milliseconds = milliseconds; 5136 proto$2.seconds = seconds; 5137 proto$2.minutes = minutes; 5138 proto$2.hours = hours; 5139 proto$2.days = days; 5140 proto$2.weeks = weeks; 5141 proto$2.months = months; 5142 proto$2.years = years; 5143 proto$2.humanize = humanize; 5144 proto$2.toISOString = toISOString$1; 5145 proto$2.toString = toISOString$1; 5146 proto$2.toJSON = toISOString$1; 5147 proto$2.locale = locale; 5148 proto$2.localeData = localeData; 5149 5150 proto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1); 5151 proto$2.lang = lang; 5152 5153 // Side effect imports 5154 5155 // FORMATTING 5156 5157 addFormatToken('X', 0, 0, 'unix'); 5158 addFormatToken('x', 0, 0, 'valueOf'); 5159 5160 // PARSING 5161 5162 addRegexToken('x', matchSigned); 5163 addRegexToken('X', matchTimestamp); 5164 addParseToken('X', function (input, array, config) { 5165 config._d = new Date(parseFloat(input, 10) * 1000); 5166 }); 5167 addParseToken('x', function (input, array, config) { 5168 config._d = new Date(toInt(input)); 5169 }); 5170 5171 // Side effect imports 5172 5173 5174 hooks.version = '2.22.2'; 5175 5176 setHookCallback(createLocal); 5177 5178 hooks.fn = proto; 5179 hooks.min = min; 5180 hooks.max = max; 5181 hooks.now = now; 5182 hooks.utc = createUTC; 5183 hooks.unix = createUnix; 5184 hooks.months = listMonths; 5185 hooks.isDate = isDate; 5186 hooks.locale = getSetGlobalLocale; 5187 hooks.invalid = createInvalid; 5188 hooks.duration = createDuration; 5189 hooks.isMoment = isMoment; 5190 hooks.weekdays = listWeekdays; 5191 hooks.parseZone = createInZone; 5192 hooks.localeData = getLocale; 5193 hooks.isDuration = isDuration; 5194 hooks.monthsShort = listMonthsShort; 5195 hooks.weekdaysMin = listWeekdaysMin; 5196 hooks.defineLocale = defineLocale; 5197 hooks.updateLocale = updateLocale; 5198 hooks.locales = listLocales; 5199 hooks.weekdaysShort = listWeekdaysShort; 5200 hooks.normalizeUnits = normalizeUnits; 5201 hooks.relativeTimeRounding = getSetRelativeTimeRounding; 5202 hooks.relativeTimeThreshold = getSetRelativeTimeThreshold; 5203 hooks.calendarFormat = getCalendarFormat; 5204 hooks.prototype = proto; 5205 5206 // currently HTML5 input type only supports 24-hour formats 5207 hooks.HTML5_FMT = { 5208 DATETIME_LOCAL: 'YYYY-MM-DDTHH:mm', // <input type="datetime-local" /> 5209 DATETIME_LOCAL_SECONDS: 'YYYY-MM-DDTHH:mm:ss', // <input type="datetime-local" step="1" /> 5210 DATETIME_LOCAL_MS: 'YYYY-MM-DDTHH:mm:ss.SSS', // <input type="datetime-local" step="0.001" /> 5211 DATE: 'YYYY-MM-DD', // <input type="date" /> 5212 TIME: 'HH:mm', // <input type="time" /> 5213 TIME_SECONDS: 'HH:mm:ss', // <input type="time" step="1" /> 5214 TIME_MS: 'HH:mm:ss.SSS', // <input type="time" step="0.001" /> 5215 WEEK: 'YYYY-[W]WW', // <input type="week" /> 5216 MONTH: 'YYYY-MM' // <input type="month" /> 5217 }; 5218 5219 return hooks; 5220 5221}))); 5222 5223/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(156)(module))) 5224 5225/***/ }), 5226/* 1 */ 5227/***/ (function(module, exports, __webpack_require__) { 5228 5229"use strict"; 5230 5231 5232module.exports = __webpack_require__(11); 5233module.exports.easing = __webpack_require__(213); 5234module.exports.canvas = __webpack_require__(212); 5235module.exports.options = __webpack_require__(214); 5236 5237 5238/***/ }), 5239/* 2 */ 5240/***/ (function(module, exports, __webpack_require__) { 5241 5242"use strict"; 5243 5244 5245var helpers = __webpack_require__(1); 5246 5247module.exports = { 5248 /** 5249 * @private 5250 */ 5251 _set: function(scope, values) { 5252 return helpers.merge(this[scope] || (this[scope] = {}), values); 5253 } 5254}; 5255 5256 5257/***/ }), 5258/* 3 */ 5259/***/ (function(module, __webpack_exports__, __webpack_require__) { 5260 5261"use strict"; 5262Object.defineProperty(__webpack_exports__, "__esModule", { value: true }); 5263/* WEBPACK VAR INJECTION */(function(module, global) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return TweenLite; }); 5264/*! 5265 * VERSION: 2.0.1 5266 * DATE: 2018-05-30 5267 * UPDATES AND DOCS AT: http://greensock.com 5268 * 5269 * @license Copyright (c) 2008-2018, GreenSock. All rights reserved. 5270 * This work is subject to the terms at http://greensock.com/standard-license or for
5271 * Club GreenSock members, the software agreement that was issued with your membership. 5272 * 5273 * @author: Jack Doyle, [email protected] 5274 */ 5275 5276/* ES6 changes: 5277 - declare and export _gsScope at top. 5278 - set const TweenLite = the result of the main function 5279 - export default TweenLite at the bottom 5280 - return TweenLite at the bottom of the main function 5281 - pass in _gsScope as the first parameter of the main function (which is actually at the bottom) 5282 - remove the "export to multiple environments" in Definition(). 5283 */ 5284const _gsScope = (typeof(window) !== "undefined") ? window : (typeof(module) !== "undefined" && module.exports && typeof(global) !== "undefined") ? global : this || {}; 5285/* harmony export (immutable) */ __webpack_exports__["_gsScope"] = _gsScope; 5286 5287 5288const TweenLite = (function(window, moduleName) { 5289 5290 "use strict"; 5291 var _exports = {}, 5292 _doc = window.document, 5293 _globals = window.GreenSockGlobals = window.GreenSockGlobals || window; 5294 if (_globals.TweenLite) { 5295 return _globals.TweenLite; //in case the core set of classes is already loaded, don't instantiate twice. 5296 } 5297 var _namespace = function(ns) { 5298 var a = ns.split("."), 5299 p = _globals, i; 5300 for (i = 0; i < a.length; i++) { 5301 p[a[i]] = p = p[a[i]] || {}; 5302 } 5303 return p; 5304 }, 5305 gs = _namespace("com.greensock"), 5306 _tinyNum = 0.0000000001, 5307 _slice = function(a) { //don't use Array.prototype.slice.call(target, 0) because that doesn't work in IE8 with a NodeList that's returned by querySelectorAll() 5308 var b = [], 5309 l = a.length, 5310 i; 5311 for (i = 0; i !== l; b.push(a[i++])) {} 5312 return b; 5313 }, 5314 _emptyFunc = function() {}, 5315 _isArray = (function() { //works around issues in iframe environments where the Array global isn't shared, thus if the object originates in a different window/iframe, "(obj instanceof Array)" will evaluate false. We added some speed optimizations to avoid Object.prototype.toString.call() unless it's absolutely necessary because it's VERY slow (like 20x slower) 5316 var toString = Object.prototype.toString, 5317 array = toString.call([]); 5318 return function(obj) { 5319 return obj != null && (obj instanceof Array || (typeof(obj) === "object" && !!obj.push && toString.call(obj) === array)); 5320 }; 5321 }()), 5322 a, i, p, _ticker, _tickerActive, 5323 _defLookup = {}, 5324 5325 /** 5326 * @constructor 5327 * Defines a GreenSock class, optionally with an array of dependencies that must be instantiated first and passed into the definition. 5328 * This allows users to load GreenSock JS files in any order even if they have interdependencies (like CSSPlugin extends TweenPlugin which is 5329 * inside TweenLite.js, but if CSSPlugin is loaded first, it should wait to run its code until TweenLite.js loads and instantiates TweenPlugin 5330 * and then pass TweenPlugin to CSSPlugin's definition). This is all done automatically and internally. 5331 * 5332 * Every definition will be added to a "com.greensock" global object (typically window, but if a window.GreenSockGlobals object is found, 5333 * it will go there as of v1.7). For example, TweenLite will be found at window.com.greensock.TweenLite and since it's a global class that should be available anywhere, 5334 * it is ALSO referenced at window.TweenLite. However some classes aren't considered global, like the base com.greensock.core.Animation class, so 5335 * those will only be at the package like window.com.greensock.core.Animation. Again, if you define a GreenSockGlobals object on the window, everything 5336 * gets tucked neatly inside there instead of on the window directly. This allows you to do advanced things like load multiple versions of GreenSock 5337 * files and put them into distinct objects (imagine a banner ad uses a newer version but the main site uses an older one). In that case, you could 5338 * sandbox the banner one like: 5339 * 5340 * <script> 5341 * var gs = window.GreenSockGlobals = {}; //the newer version we're about to load could now be referenced in a "gs" object, like gs.TweenLite.to(...). Use whatever alias you want as long as it's unique, "gs" or "banner" or whatever. 5342 * </script> 5343 * <script src="js/greensock/v1.7/TweenMax.js"></script> 5344 * <script> 5345 * window.GreenSockGlobals = window._gsQueue = window._gsDefine = null; //reset it back to null (along with the special _gsQueue variable) so that the next load of TweenMax affects the window and we can reference things directly like TweenLite.to(...) 5346 * </script> 5347 * <script src="js/greensock/v1.6/TweenMax.js"></script> 5348 * <script> 5349 * gs.TweenLite.to(...); //would use v1.7 5350 * TweenLite.to(...); //would use v1.6 5351 * </script> 5352 * 5353 * @param {!string} ns The namespace of the class definition, leaving off "com.greensock." as that's assumed. For example, "TweenLite" or "plugins.CSSPlugin" or "easing.Back". 5354 * @param {!Array.<string>}
5354 dependencies An array of dependencies (described as their namespaces minus "com.greensock." prefix). For example ["TweenLite","plugins.TweenPlugin","core.Animation"] 5355 * @param {!function():Object} func The function that should be called and passed the resolved dependencies which will return the actual class for this definition. 5356 * @param {boolean=} global If true, the class will be added to the global scope (typically window unless you define a window.GreenSockGlobals object) 5357 */ 5358 Definition = function(ns, dependencies, func, global) { 5359 this.sc = (_defLookup[ns]) ? _defLookup[ns].sc : []; //subclasses 5360 _defLookup[ns] = this; 5361 this.gsClass = null; 5362 this.func = func; 5363 var _classes = []; 5364 this.check = function(init) { 5365 var i = dependencies.length, 5366 missing = i, 5367 cur, a, n, cl; 5368 while (--i > -1) { 5369 if ((cur = _defLookup[dependencies[i]] || new Definition(dependencies[i], [])).gsClass) { 5370 _classes[i] = cur.gsClass; 5371 missing--; 5372 } else if (init) { 5373 cur.sc.push(this); 5374 } 5375 } 5376 if (missing === 0 && func) { 5377 a = ("com.greensock." + ns).split("."); 5378 n = a.pop(); 5379 cl = _namespace(a.join("."))[n] = this.gsClass = func.apply(func, _classes); 5380 5381 //exports to multiple environments 5382 if (global) { 5383 _globals[n] = _exports[n] = cl; //provides a way to avoid global namespace pollution. By default, the main classes like TweenLite, Power1, Strong, etc. are added to window unless a GreenSockGlobals is defined. So if you want to have things added to a custom object instead, just do something like window.GreenSockGlobals = {} before loading any GreenSock files. You can even set up an alias like window.GreenSockGlobals = windows.gs = {} so that you can access everything like gs.TweenLite. Also remember that ALL classes are added to the window.com.greensock object (in their respective packages, like com.greensock.easing.Power1, com.greensock.TweenLite, etc.) 5384 /* 5385 if (typeof(module) !== "undefined" && module.exports) { //node 5386 if (ns === moduleName) { 5387 module.exports = _exports[moduleName] = cl; 5388 for (i in _exports) { 5389 cl[i] = _exports[i]; 5390 } 5391 } else if (_exports[moduleName]) { 5392 _exports[moduleName][n] = cl; 5393 } 5394 } else if (typeof(define) === "function" && define.amd){ //AMD 5395 define((window.GreenSockAMDPath ? window.GreenSockAMDPath + "/" : "") + ns.split(".").pop(), [], function() { return cl; }); 5396 } 5397 */ 5398 } 5399 for (i = 0; i < this.sc.length; i++) { 5400 this.sc[i].check(); 5401 } 5402 } 5403 }; 5404 this.check(true); 5405 }, 5406 5407 //used to create Definition instances (which basically registers a class that has dependencies). 5408 _gsDefine = window._gsDefine = function(ns, dependencies, func, global) { 5409 return new Definition(ns, dependencies, func, global); 5410 }, 5411 5412 //a quick way to create a class that doesn't have any dependencies. Returns the class, but first registers it in the GreenSock namespace so that other classes can grab it (other classes might be dependent on the class). 5413 _class = gs._class = function(ns, func, global) { 5414 func = func || function() {}; 5415 _gsDefine(ns, [], function(){ return func; }, global); 5416 return func; 5417 }; 5418 5419 _gsDefine.globals = _globals; 5420 5421 5422 5423/* 5424 * ---------------------------------------------------------------- 5425 * Ease 5426 * ---------------------------------------------------------------- 5427 */ 5428 var _baseParams = [0, 0, 1, 1], 5429 Ease = _class("easing.Ease", function(func, extraParams, type, power) { 5430 this._func = func; 5431 this._type = type || 0; 5432 this._power = power || 0; 5433 this._params = extraParams ? _baseParams.concat(extraParams) : _baseParams; 5434 }, true), 5435 _easeMap = Ease.map = {}, 5436 _easeReg = Ease.register = function(ease, names, types, create) { 5437 var na = names.split(","), 5438 i = na.length, 5439 ta = (types || "easeIn,easeOut,easeInOut").split(","), 5440 e, name, j, type; 5441 while (--i > -1) { 5442 name = na[i]; 5443 e = create ? _class("easing."+name, null, true) : gs.easing[name] || {}; 5444 j = ta.length; 5445 while (--j > -1) { 5446 type = ta[j]; 5447 _easeMap[name + "." + type] = _easeMap[type + name] = e[type] = ease.getRatio ? ease : ease[type] || new ease(); 5448 } 5449 } 5450 }; 5451 5452 p = Ease.prototype; 5453 p._calcEnd = false;
5454 p.getRatio = function(p) { 5455 if (this._func) { 5456 this._params[0] = p; 5457 return this._func.apply(null, this._params); 5458 } 5459 var t = this._type, 5460 pw = this._power, 5461 r = (t === 1) ? 1 - p : (t === 2) ? p : (p < 0.5) ? p * 2 : (1 - p) * 2; 5462 if (pw === 1) { 5463 r *= r; 5464 } else if (pw === 2) { 5465 r *= r * r; 5466 } else if (pw === 3) { 5467 r *= r * r * r; 5468 } else if (pw === 4) { 5469 r *= r * r * r * r; 5470 } 5471 return (t === 1) ? 1 - r : (t === 2) ? r : (p < 0.5) ? r / 2 : 1 - (r / 2); 5472 }; 5473 5474 //create all the standard eases like Linear, Quad, Cubic, Quart, Quint, Strong, Power0, Power1, Power2, Power3, and Power4 (each with easeIn, easeOut, and easeInOut) 5475 a = ["Linear","Quad","Cubic","Quart","Quint,Strong"]; 5476 i = a.length; 5477 while (--i > -1) { 5478 p = a[i]+",Power"+i; 5479 _easeReg(new Ease(null,null,1,i), p, "easeOut", true); 5480 _easeReg(new Ease(null,null,2,i), p, "easeIn" + ((i === 0) ? ",easeNone" : "")); 5481 _easeReg(new Ease(null,null,3,i), p, "easeInOut"); 5482 } 5483 _easeMap.linear = gs.easing.Linear.easeIn; 5484 _easeMap.swing = gs.easing.Quad.easeInOut; //for jQuery folks 5485 5486 5487/* 5488 * ---------------------------------------------------------------- 5489 * EventDispatcher 5490 * ---------------------------------------------------------------- 5491 */ 5492 var EventDispatcher = _class("events.EventDispatcher", function(target) { 5493 this._listeners = {}; 5494 this._eventTarget = target || this; 5495 }); 5496 p = EventDispatcher.prototype; 5497 5498 p.addEventListener = function(type, callback, scope, useParam, priority) { 5499 priority = priority || 0; 5500 var list = this._listeners[type], 5501 index = 0, 5502 listener, i; 5503 if (this === _ticker && !_tickerActive) { 5504 _ticker.wake(); 5505 } 5506 if (list == null) { 5507 this._listeners[type] = list = []; 5508 } 5509 i = list.length; 5510 while (--i > -1) { 5511 listener = list[i]; 5512 if (listener.c === callback && listener.s === scope) { 5513 list.splice(i, 1); 5514 } else if (index === 0 && listener.pr < priority) { 5515 index = i + 1; 5516 } 5517 } 5518 list.splice(index, 0, {c:callback, s:scope, up:useParam, pr:priority}); 5519 }; 5520 5521 p.removeEventListener = function(type, callback) { 5522 var list = this._listeners[type], i; 5523 if (list) { 5524 i = list.length; 5525 while (--i > -1) { 5526 if (list[i].c === callback) { 5527 list.splice(i, 1); 5528 return; 5529 } 5530 } 5531 } 5532 }; 5533 5534 p.dispatchEvent = function(type) { 5535 var list = this._listeners[type], 5536 i, t, listener; 5537 if (list) { 5538 i = list.length; 5539 if (i > 1) { 5540 list = list.slice(0); //in case addEventListener() is called from within a listener/callback (otherwise the index could change, resulting in a skip) 5541 } 5542 t = this._eventTarget; 5543 while (--i > -1) { 5544 listener = list[i]; 5545 if (listener) { 5546 if (listener.up) { 5547 listener.c.call(listener.s || t, {type:type, target:t}); 5548 } else { 5549 listener.c.call(listener.s || t); 5550 } 5551 } 5552 } 5553 } 5554 }; 5555 5556 5557/* 5558 * ---------------------------------------------------------------- 5559 * Ticker 5560 * ---------------------------------------------------------------- 5561 */ 5562 var _reqAnimFrame = window.requestAnimationFrame, 5563 _cancelAnimFrame = window.cancelAnimationFrame, 5564 _getTime = Date.now || function() {return new Date().getTime();}, 5565 _lastUpdate = _getTime(); 5566 5567 //now try to determine the requestAnimationFrame and cancelAnimationFrame functions and if none are found, we'll use a setTimeout()/clearTimeout() polyfill. 5568 a = ["ms","moz","webkit","o"]; 5569 i = a.length; 5570 while (--i > -1 && !_reqAnimFrame) { 5571 _reqAnimFrame = window[a[i] + "RequestAnimationFrame"]; 5572 _cancelAnimFrame = window[a[i] + "CancelAnimationFrame"] || window[a[i] + "CancelRequestAnimationFrame"]; 5573 } 5574 5575 _class("Ticker", function(fps, useRAF) { 5576 var _self = this, 5577 _startTime = _getTime(), 5578 _useRAF = (useRAF !== false && _reqAnimFrame) ? "auto" : false, 5579 _lagThreshold = 500, 5580 _adjustedLag = 33, 5581 _tickWord = "tick", //helps reduce gc burden 5582 _fps, _req, _id, _gap, _nextTime, 5583 _tick = function(manual) { 5584 var elapsed = _getTime() - _lastUpdate, 5585 overlap, dispatch; 5586 if (elapsed > _lagThreshold) { 5587 _startTime += elapsed - _adjustedLag; 5588 } 5589 _lastUpdate += elapsed; 5590 _self.time = (_lastUpdate - _startTime) / 1000; 5591 overlap = _self.time - _nextTime; 5592 if (!_fps || overlap > 0 || manual === true) { 5593 _self.frame++; 5594 _nextTime += overlap + (overlap >= _gap ? 0.004 : _gap - overlap); 5595 dispatch = true; 5596 } 5597 if (manual !== true) { //make sure the request is made before we dispatch the "tick" event so that timing is maintained. Otherwise, if processing the "tick" requires a bunch of time (like 15ms) and we're using a setTimeout() that's based on 16.7ms, it'd technically take 31.7ms between frames otherwise. 5598 _id = _req(_tick); 5599 }
5600 if (dispatch) { 5601 _self.dispatchEvent(_tickWord); 5602 } 5603 }; 5604 5605 EventDispatcher.call(_self); 5606 _self.time = _self.frame = 0; 5607 _self.tick = function() { 5608 _tick(true); 5609 }; 5610 5611 _self.lagSmoothing = function(threshold, adjustedLag) { 5612 if (!arguments.length) { //if lagSmoothing() is called with no arguments, treat it like a getter that returns a boolean indicating if it's enabled or not. This is purposely undocumented and is for internal use. 5613 return (_lagThreshold < 1 / _tinyNum); 5614 } 5615 _lagThreshold = threshold || (1 / _tinyNum); //zero should be interpreted as basically unlimited 5616 _adjustedLag = Math.min(adjustedLag, _lagThreshold, 0); 5617 }; 5618 5619 _self.sleep = function() { 5620 if (_id == null) { 5621 return; 5622 } 5623 if (!_useRAF || !_cancelAnimFrame) { 5624 clearTimeout(_id); 5625 } else { 5626 _cancelAnimFrame(_id); 5627 } 5628 _req = _emptyFunc; 5629 _id = null; 5630 if (_self === _ticker) { 5631 _tickerActive = false; 5632 } 5633 }; 5634 5635 _self.wake = function(seamless) { 5636 if (_id !== null) { 5637 _self.sleep(); 5638 } else if (seamless) { 5639 _startTime += -_lastUpdate + (_lastUpdate = _getTime()); 5640 } else if (_self.frame > 10) { //don't trigger lagSmoothing if we're just waking up, and make sure that at least 10 frames have elapsed because of the iOS bug that we work around below with the 1.5-second setTimout(). 5641 _lastUpdate = _getTime() - _lagThreshold + 5; 5642 } 5643 _req = (_fps === 0) ? _emptyFunc : (!_useRAF || !_reqAnimFrame) ? function(f) { return setTimeout(f, ((_nextTime - _self.time) * 1000 + 1) | 0); } : _reqAnimFrame; 5644 if (_self === _ticker) { 5645 _tickerActive = true; 5646 } 5647 _tick(2); 5648 }; 5649 5650 _self.fps = function(value) { 5651 if (!arguments.length) { 5652 return _fps; 5653 } 5654 _fps = value; 5655 _gap = 1 / (_fps || 60); 5656 _nextTime = this.time + _gap; 5657 _self.wake(); 5658 }; 5659 5660 _self.useRAF = function(value) { 5661 if (!arguments.length) { 5662 return _useRAF; 5663 } 5664 _self.sleep(); 5665 _useRAF = value; 5666 _self.fps(_fps); 5667 }; 5668 _self.fps(fps); 5669 5670 //a bug in iOS 6 Safari occasionally prevents the requestAnimationFrame from working initially, so we use a 1.5-second timeout that automatically falls back to setTimeout() if it senses this condition. 5671 setTimeout(function() { 5672 if (_useRAF === "auto" && _self.frame < 5 && (_doc || {}).visibilityState !== "hidden") { 5673 _self.useRAF(false); 5674 } 5675 }, 1500); 5676 }); 5677 5678 p = gs.Ticker.prototype = new gs.events.EventDispatcher(); 5679 p.constructor = gs.Ticker; 5680 5681 5682/* 5683 * ---------------------------------------------------------------- 5684 * Animation 5685 * ---------------------------------------------------------------- 5686 */ 5687 var Animation = _class("core.Animation", function(duration, vars) { 5688 this.vars = vars = vars || {}; 5689 this._duration = this._totalDuration = duration || 0; 5690 this._delay = Number(vars.delay) || 0; 5691 this._timeScale = 1; 5692 this._active = (vars.immediateRender === true); 5693 this.data = vars.data; 5694 this._reversed = (vars.reversed === true); 5695 5696 if (!_rootTimeline) { 5697 return; 5698 } 5699 if (!_tickerActive) { //some browsers (like iOS 6 Safari) shut down JavaScript execution when the tab is disabled and they [occasionally] neglect to start up requestAnimationFrame again when returning - this code ensures that the engine starts up again properly. 5700 _ticker.wake(); 5701 } 5702 5703 var tl = this.vars.useFrames ? _rootFramesTimeline : _rootTimeline; 5704 tl.add(this, tl._time); 5705 5706 if (this.vars.paused) { 5707 this.paused(true); 5708 } 5709 }); 5710 5711 _ticker = Animation.ticker = new gs.Ticker(); 5712 p = Animation.prototype; 5713 p._dirty = p._gc = p._initted = p._paused = false; 5714 p._totalTime = p._time = 0; 5715 p._rawPrevTime = -1; 5716 p._next = p._last = p._onUpdate = p._timeline = p.timeline = null; 5717 p._paused = false; 5718 5719 5720 //some browsers (like iOS) occasionally drop the requestAnimationFrame event when the user switches to a different tab and then comes back again, so we use a 2-second setTimeout() to sense if/when that condition occurs and then wake() the ticker. 5721 var _checkTimeout = function() { 5722 if (_tickerActive && _getTime() - _lastUpdate > 2000 && ((_doc || {}).visibilityState !== "hidden" || !_ticker.lagSmoothing())) { //note: if the tab is hidden, we should still wake if lagSmoothing has been disabled. 5723 _ticker.wake(); 5724 } 5725 var t = setTimeout(_checkTimeout, 2000); 5726 if (t.unref) { 5727 // allows a node process to exit even if the timeoutâs callback hasn't been invoked. Without it, the node process could hang as this function is called every two seconds. 5728 t.unref(); 5729 } 5730 }; 5731 _checkTimeout(); 5732 5733 5734 p.play = function(from, suppressEvents) { 5735 if (from != null) { 5736 this.seek(from, suppressEvents); 5737 } 5738 return this.reversed(false).paused(false); 5739 }; 5740 5741 p.pause = function(atTime, suppressEvents) { 5742 if (atTime != null) { 5743 this.seek(atTime, suppressEvents); 5744 } 5745 return this.paused(true); 5746 }; 5747 5748 p.resume = function(from, suppressEvents) { 5749 if (from != null) { 5750 this.seek(from, suppressEvents); 5751 } 5752 return this.paused(false); 5753 }; 5754 5755 p.seek = function(time, suppressEvents) { 5756 return this.totalTime(Number(time), suppressEvents !== false); 5757 }; 5758 5759 p.restart = function(includeDelay, suppressEvents) { 5760 return this.reversed(false).paused(false).totalTime(includeDelay ? -this._delay : 0, (suppressEvents !== false), true); 5761 }; 5762 5763 p.reverse = function(from, suppressEvents) { 5764 if (from != null) { 5765 this.seek((from || this.totalDuration()), suppressEvents); 5766 } 5767 return this.reversed(true).paused(false); 5768 }; 5769 5770 p.render = function(time, suppressEvents, force) { 5771 //stub - we override this method in subclasses. 5772 }; 5773 5774 p.invalidate = function() { 5775 this._time = this._totalTime = 0; 5776 this._initted = this._gc = false;
5777 this._rawPrevTime = -1; 5778 if (this._gc || !this.timeline) { 5779 this._enabled(true); 5780 } 5781 return this; 5782 }; 5783 5784 p.isActive = function() { 5785 var tl = this._timeline, //the 2 root timelines won't have a _timeline; they're always active. 5786 startTime = this._startTime, 5787 rawTime; 5788 return (!tl || (!this._gc && !this._paused && tl.isActive() && (rawTime = tl.rawTime(true)) >= startTime && rawTime < startTime + this.totalDuration() / this._timeScale - 0.0000001)); 5789 }; 5790 5791 p._enabled = function (enabled, ignoreTimeline) { 5792 if (!_tickerActive) { 5793 _ticker.wake(); 5794 } 5795 this._gc = !enabled; 5796 this._active = this.isActive(); 5797 if (ignoreTimeline !== true) { 5798 if (enabled && !this.timeline) { 5799 this._timeline.add(this, this._startTime - this._delay); 5800 } else if (!enabled && this.timeline) { 5801 this._timeline._remove(this, true); 5802 } 5803 } 5804 return false; 5805 }; 5806 5807 5808 p._kill = function(vars, target) { 5809 return this._enabled(false, false); 5810 }; 5811 5812 p.kill = function(vars, target) { 5813 this._kill(vars, target); 5814 return this; 5815 }; 5816 5817 p._uncache = function(includeSelf) { 5818 var tween = includeSelf ? this : this.timeline; 5819 while (tween) { 5820 tween._dirty = true; 5821 tween = tween.timeline; 5822 } 5823 return this; 5824 }; 5825 5826 p._swapSelfInParams = function(params) { 5827 var i = params.length, 5828 copy = params.concat(); 5829 while (--i > -1) { 5830 if (params[i] === "{self}") { 5831 copy[i] = this; 5832 } 5833 } 5834 return copy; 5835 }; 5836 5837 p._callback = function(type) { 5838 var v = this.vars, 5839 callback = v[type], 5840 params = v[type + "Params"], 5841 scope = v[type + "Scope"] || v.callbackScope || this, 5842 l = params ? params.length : 0; 5843 switch (l) { //speed optimization; call() is faster than apply() so use it when there are only a few parameters (which is by far most common). Previously we simply did var v = this.vars; v[type].apply(v[type + "Scope"] || v.callbackScope || this, v[type + "Params"] || _blankArray); 5844 case 0: callback.call(scope); break; 5845 case 1: callback.call(scope, params[0]); break; 5846 case 2: callback.call(scope, params[0], params[1]); break; 5847 default: callback.apply(scope, params); 5848 } 5849 }; 5850 5851//----Animation getters/setters -------------------------------------------------------- 5852 5853 p.eventCallback = function(type, callback, params, scope) { 5854 if ((type || "").substr(0,2) === "on") { 5855 var v = this.vars; 5856 if (arguments.length === 1) { 5857 return v[type]; 5858 } 5859 if (callback == null) { 5860 delete v[type]; 5861 } else { 5862 v[type] = callback; 5863 v[type + "Params"] = (_isArray(params) && params.join("").indexOf("{self}") !== -1) ? this._swapSelfInParams(params) : params; 5864 v[type + "Scope"] = scope; 5865 } 5866 if (type === "onUpdate") { 5867 this._onUpdate = callback; 5868 } 5869 } 5870 return this; 5871 }; 5872 5873 p.delay = function(value) { 5874 if (!arguments.length) { 5875 return this._delay; 5876 } 5877 if (this._timeline.smoothChildTiming) { 5878 this.startTime( this._startTime + value - this._delay ); 5879 } 5880 this._delay = value; 5881 return this; 5882 }; 5883 5884 p.duration = function(value) { 5885 if (!arguments.length) { 5886 this._dirty = false; 5887 return this._duration; 5888 } 5889 this._duration = this._totalDuration = value; 5890 this._uncache(true); //true in case it's a TweenMax or TimelineMax that has a repeat - we'll need to refresh the totalDuration. 5891 if (this._timeline.smoothChildTiming) if (this._time > 0) if (this._time < this._duration) if (value !== 0) { 5892 this.totalTime(this._totalTime * (value / this._duration), true); 5893 } 5894 return this; 5895 }; 5896 5897 p.totalDuration = function(value) { 5898 this._dirty = false; 5899 return (!arguments.length) ? this._totalDuration : this.duration(value); 5900 }; 5901 5902 p.time = function(value, suppressEvents) { 5903 if (!arguments.length) { 5904 return this._time; 5905 } 5906 if (this._dirty) { 5907 this.totalDuration(); 5908 } 5909 return this.totalTime((value > this._duration) ? this._duration : value, suppressEvents); 5910 }; 5911 5912 p.totalTime = function(time, suppressEvents, uncapped) { 5913 if (!_tickerActive) { 5914 _ticker.wake(); 5915 } 5916 if (!arguments.length) { 5917 return this._totalTime; 5918 } 5919 if (this._timeline) { 5920 if (time < 0 && !uncapped) { 5921 time += this.totalDuration(); 5922 } 5923 if (this._timeline.smoothChildTiming) { 5924 if (this._dirty) { 5925 this.totalDuration(); 5926 } 5927 var totalDuration = this._totalDuration, 5928 tl = this._timeline; 5929 if (time > totalDuration && !uncapped) { 5930 time = totalDuration; 5931 } 5932 this._startTime = (this._paused ? this._pauseTime : tl._time) - ((!this._reversed ? time : totalDuration - time) / this._timeScale); 5933 if (!tl._dirty) { //for performance improvement. If the parent's cache is already dirty, it already took care of marking the ancestors as dirty too, so skip the function call here. 5934 this._uncache(false); 5935 } 5936 //in case any of the ancestor timelines had completed but should now be enabled, we should reset the
5936ir totalTime() which will also ensure that they're lined up properly and enabled. Skip for animations that are on the root (wasteful). Example: a TimelineLite.exportRoot() is performed when there's a paused tween on the root, the export will not complete until that tween is unpaused, but imagine a child gets restarted later, after all [unpaused] tweens have completed. The startTime of that child would get pushed out, but one of the ancestors may have completed. 5937 if (tl._timeline) { 5938 while (tl._timeline) { 5939 if (tl._timeline._time !== (tl._startTime + tl._totalTime) / tl._timeScale) { 5940 tl.totalTime(tl._totalTime, true); 5941 } 5942 tl = tl._timeline; 5943 } 5944 } 5945 } 5946 if (this._gc) { 5947 this._enabled(true, false); 5948 } 5949 if (this._totalTime !== time || this._duration === 0) { 5950 if (_lazyTweens.length) { 5951 _lazyRender(); 5952 } 5953 this.render(time, suppressEvents, false); 5954 if (_lazyTweens.length) { //in case rendering caused any tweens to lazy-init, we should render them because typically when someone calls seek() or time() or progress(), they expect an immediate render. 5955 _lazyRender(); 5956 } 5957 } 5958 } 5959 return this; 5960 }; 5961 5962 p.progress = p.totalProgress = function(value, suppressEvents) { 5963 var duration = this.duration(); 5964 return (!arguments.length) ? (duration ? this._time / duration : this.ratio) : this.totalTime(duration * value, suppressEvents); 5965 }; 5966 5967 p.startTime = function(value) { 5968 if (!arguments.length) { 5969 return this._startTime; 5970 } 5971 if (value !== this._startTime) { 5972 this._startTime = value; 5973 if (this.timeline) if (this.timeline._sortChildren) { 5974 this.timeline.add(this, value - this._delay); //ensures that any necessary re-sequencing of Animations in the timeline occurs to make sure the rendering order is correct. 5975 } 5976 } 5977 return this; 5978 }; 5979 5980 p.endTime = function(includeRepeats) { 5981 return this._startTime + ((includeRepeats != false) ? this.totalDuration() : this.duration()) / this._timeScale; 5982 }; 5983 5984 p.timeScale = function(value) { 5985 if (!arguments.length) { 5986 return this._timeScale; 5987 } 5988 var pauseTime, t; 5989 value = value || _tinyNum; //can't allow zero because it'll throw the math off 5990 if (this._timeline && this._timeline.smoothChildTiming) { 5991 pauseTime = this._pauseTime; 5992 t = (pauseTime || pauseTime === 0) ? pauseTime : this._timeline.totalTime(); 5993 this._startTime = t - ((t - this._startTime) * this._timeScale / value); 5994 } 5995 this._timeScale = value; 5996 t = this.timeline; 5997 while (t && t.timeline) { //must update the duration/totalDuration of all ancestor timelines immediately in case in the middle of a render loop, one tween alters another tween's timeScale which shoves its startTime before 0, forcing the parent timeline to shift around and shiftChildren() which could affect that next tween's render (startTime). Doesn't matter for the root timeline though. 5998 t._dirty = true; 5999 t.totalDuration(); 6000 t = t.timeline; 6001 } 6002 return this; 6003 }; 6004 6005 p.reversed = function(value) { 6006 if (!arguments.length) { 6007 return this._reversed; 6008 } 6009 if (value != this._reversed) { 6010 this._reversed = value; 6011 this.totalTime(((this._timeline && !this._timeline.smoothChildTiming) ? this.totalDuration() - this._totalTime : this._totalTime), true); 6012 } 6013 return this; 6014 }; 6015 6016 p.paused = function(value) { 6017 if (!arguments.length) { 6018 return this._paused; 6019 } 6020 var tl = this._timeline, 6021 raw, elapsed; 6022 if (value != this._paused) if (tl) { 6023 if (!_tickerActive && !value) { 6024 _ticker.wake(); 6025 } 6026 raw = tl.rawTime(); 6027 elapsed = raw - this._pauseTime; 6028 if (!value && tl.smoothChildTiming) { 6029 this._startTime += elapsed; 6030 this._uncache(false); 6031 } 6032 this._pauseTime = value ? raw : null; 6033 this._paused = value; 6034 this._active = this.isActive(); 6035 if (!value && elapsed !== 0 && this._initted && this.duration()) { 6036 raw = tl.smoothChildTiming ? this._totalTime : (raw - this._startTime) / this._timeScale; 6037 this.render(raw, (raw === this._totalTime), true); //in case the target's properties changed via some other tween or manual update by the user, we should force a render. 6038 } 6039 } 6040 if (this._gc && !value) { 6041 this._enabled(true, false); 6042 } 6043 return this; 6044 }; 6045 6046
6047/* 6048 * ---------------------------------------------------------------- 6049 * SimpleTimeline 6050 * ---------------------------------------------------------------- 6051 */ 6052 var SimpleTimeline = _class("core.SimpleTimeline", function(vars) { 6053 Animation.call(this, 0, vars); 6054 this.autoRemoveChildren = this.smoothChildTiming = true; 6055 }); 6056 6057 p = SimpleTimeline.prototype = new Animation(); 6058 p.constructor = SimpleTimeline; 6059 p.kill()._gc = false; 6060 p._first = p._last = p._recent = null; 6061 p._sortChildren = false; 6062 6063 p.add = p.insert = function(child, position, align, stagger) { 6064 var prevTween, st; 6065 child._startTime = Number(position || 0) + child._delay; 6066 if (child._paused) if (this !== child._timeline) { //we only adjust the _pauseTime if it wasn't in this timeline already. Remember, sometimes a tween will be inserted again into the same timeline when its startTime is changed so that the tweens in the TimelineLite/Max are re-ordered properly in the linked list (so everything renders in the proper order). 6067 child._pauseTime = this.rawTime() - (child._timeline.rawTime() - child._pauseTime); 6068 } 6069 if (child.timeline) { 6070 child.timeline._remove(child, true); //removes from existing timeline so that it can be properly added to this one. 6071 } 6072 child.timeline = child._timeline = this; 6073 if (child._gc) { 6074 child._enabled(true, true); 6075 } 6076 prevTween = this._last; 6077 if (this._sortChildren) { 6078 st = child._startTime; 6079 while (prevTween && prevTween._startTime > st) { 6080 prevTween = prevTween._prev; 6081 } 6082 } 6083 if (prevTween) { 6084 child._next = prevTween._next; 6085 prevTween._next = child; 6086 } else { 6087 child._next = this._first; 6088 this._first = child; 6089 } 6090 if (child._next) { 6091 child._next._prev = child; 6092 } else { 6093 this._last = child; 6094 } 6095 child._prev = prevTween; 6096 this._recent = child; 6097 if (this._timeline) { 6098 this._uncache(true); 6099 } 6100 return this; 6101 }; 6102 6103 p._remove = function(tween, skipDisable) { 6104 if (tween.timeline === this) { 6105 if (!skipDisable) { 6106 tween._enabled(false, true); 6107 } 6108 6109 if (tween._prev) { 6110 tween._prev._next = tween._next; 6111 } else if (this._first === tween) { 6112 this._first = tween._next; 6113 } 6114 if (tween._next) { 6115 tween._next._prev = tween._prev; 6116 } else if (this._last === tween) { 6117 this._last = tween._prev; 6118 } 6119 tween._next = tween._prev = tween.timeline = null; 6120 if (tween === this._recent) { 6121 this._recent = this._last; 6122 } 6123 6124 if (this._timeline) { 6125 this._uncache(true); 6126 } 6127 } 6128 return this; 6129 }; 6130 6131 p.render = function(time, suppressEvents, force) { 6132 var tween = this._first, 6133 next; 6134 this._totalTime = this._time = this._rawPrevTime = time; 6135 while (tween) { 6136 next = tween._next; //record it here because the value could change after rendering... 6137 if (tween._active || (time >= tween._startTime && !tween._paused && !tween._gc)) { 6138 if (!tween._reversed) { 6139 tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force); 6140 } else { 6141 tween.render(((!tween._dirty) ? tween._totalDuration : tween.totalDuration()) - ((time - tween._startTime) * tween._timeScale), suppressEvents, force); 6142 } 6143 } 6144 tween = next; 6145 } 6146 }; 6147 6148 p.rawTime = function() { 6149 if (!_tickerActive) { 6150 _ticker.wake(); 6151 } 6152 return this._totalTime; 6153 }; 6154 6155/* 6156 * ---------------------------------------------------------------- 6157 * TweenLite 6158 * ---------------------------------------------------------------- 6159 */ 6160 var TweenLite = _class("TweenLite", function(target, duration, vars) { 6161 Animation.call(this, duration, vars); 6162 this.render = TweenLite.prototype.render; //speed optimization (avoid prototype lookup on this "hot" method) 6163 6164 if (target == null) { 6165 throw "Cannot tween a null target."; 6166 } 6167 6168 this.target = target = (typeof(target) !== "string") ? target : TweenLite.selector(target) || target; 6169 6170 var isSelector = (target.jquery || (target.length && target !== window && target[0] && (target[0] === window || (target[0].nodeType && target[0].style && !target.nodeType)))),
6171 overwrite = this.vars.overwrite, 6172 i, targ, targets; 6173 6174 this._overwrite = overwrite = (overwrite == null) ? _overwriteLookup[TweenLite.defaultOverwrite] : (typeof(overwrite) === "number") ? overwrite >> 0 : _overwriteLookup[overwrite]; 6175 6176 if ((isSelector || target instanceof Array || (target.push && _isArray(target))) && typeof(target[0]) !== "number") { 6177 this._targets = targets = _slice(target); //don't use Array.prototype.slice.call(target, 0) because that doesn't work in IE8 with a NodeList that's returned by querySelectorAll() 6178 this._propLookup = []; 6179 this._siblings = []; 6180 for (i = 0; i < targets.length; i++) { 6181 targ = targets[i]; 6182 if (!targ) { 6183 targets.splice(i--, 1); 6184 continue; 6185 } else if (typeof(targ) === "string") { 6186 targ = targets[i--] = TweenLite.selector(targ); //in case it's an array of strings 6187 if (typeof(targ) === "string") { 6188 targets.splice(i+1, 1); //to avoid an endless loop (can't imagine why the selector would return a string, but just in case) 6189 } 6190 continue; 6191 } else if (targ.length && targ !== window && targ[0] && (targ[0] === window || (targ[0].nodeType && targ[0].style && !targ.nodeType))) { //in case the user is passing in an array of selector objects (like jQuery objects), we need to check one more level and pull things out if necessary. Also note that <select> elements pass all the criteria regarding length and the first child having style, so we must also check to ensure the target isn't an HTML node itself. 6192 targets.splice(i--, 1); 6193 this._targets = targets = targets.concat(_slice(targ)); 6194 continue; 6195 } 6196 this._siblings[i] = _register(targ, this, false); 6197 if (overwrite === 1) if (this._siblings[i].length > 1) { 6198 _applyOverwrite(targ, this, null, 1, this._siblings[i]); 6199 } 6200 } 6201 6202 } else { 6203 this._propLookup = {}; 6204 this._siblings = _register(target, this, false); 6205 if (overwrite === 1) if (this._siblings.length > 1) { 6206 _applyOverwrite(target, this, null, 1, this._siblings); 6207 } 6208 } 6209 if (this.vars.immediateRender || (duration === 0 && this._delay === 0 && this.vars.immediateRender !== false)) { 6210 this._time = -_tinyNum; //forces a render without having to set the render() "force" parameter to true because we want to allow lazying by default (using the "force" parameter always forces an immediate full render) 6211 this.render(Math.min(0, -this._delay)); //in case delay is negative 6212 } 6213 }, true), 6214 _isSelector = function(v) { 6215 return (v && v.length && v !== window && v[0] && (v[0] === window || (v[0].nodeType && v[0].style && !v.nodeType))); //we cannot check "nodeType" if the target is window from within an iframe, otherwise it will trigger a security error in some browsers like Firefox. 6216 }, 6217 _autoCSS = function(vars, target) { 6218 var css = {}, 6219 p; 6220 for (p in vars) { 6221 if (!_reservedProps[p] && (!(p in target) || p === "transform" || p === "x" || p === "y" || p === "width" || p === "height" || p === "className" || p === "border") && (!_plugins[p] || (_plugins[p] && _plugins[p]._autoCSS))) { //note: <img> elements contain read-only "x" and "y" properties. We should also prioritize editing css width/height rather than the element's properties. 6222 css[p] = vars[p]; 6223 delete vars[p]; 6224 } 6225 } 6226 vars.css = css; 6227 }; 6228 6229 p = TweenLite.prototype = new Animation(); 6230 p.constructor = TweenLite; 6231 p.kill()._gc = false; 6232 6233//----TweenLite defaults, overwrite management, and root updates ---------------------------------------------------- 6234 6235 p.ratio = 0; 6236 p._firstPT = p._targets = p._overwrittenProps = p._startAt = null; 6237 p._notifyPluginsOfEnabled = p._lazy = false; 6238 6239 TweenLite.version = "2.0.1"; 6240 TweenLite.defaultEase = p._ease = new Ease(null, null, 1, 1); 6241 TweenLite.defaultOverwrite = "auto"; 6242 TweenLite.ticker = _ticker; 6243 TweenLite.autoSleep = 120; 6244 TweenLite.lagSmoothing = function(threshold, adjustedLag) { 6245 _ticker.lagSmoothing(threshold, adjustedLag); 6246 }; 6247 6248 TweenLite.selector = window.$ || window.jQuery || function(e) { 6249 var selector = window.$ || window.jQuery; 6250 if (selector) { 6251 TweenLite.selector = selector; 6252 return selector(e); 6253 } 6254 if (!_doc) { //in some dev environments (like Angular 6), GSAP gets loaded before the document is defined! So re-query it here if/when necessary. 6255 _doc = window.document; 6256 } 6257 return (!_doc) ? e : (_doc.querySelectorAll ? _doc.querySelectorAll(e) : _doc.getElementById((e.charAt(0) === "#") ? e.substr(1) : e)); 6258 }; 6259 6260 var _lazyTweens = [], 6261 _lazyLookup = {}, 6262 _numbersExp = /(?:(-|-=|\+=)?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/ig, 6263 _relExp = /[\+-]=-?[\.\d]/, 6264 //_nonNumbersExp = /(?:([\-+](?!(\d|=)))|[^\d\-+=e]|(e(?![\-+][\d])))+/ig, 6265 _setRatio = function(v) { 6266 var pt = this._firstPT, 6267 min = 0.000001, 6268 val; 6269 while (pt) { 6270 val = !pt.blob ? pt.c * v + pt.s : (v === 1 && this.end != null) ? this.end : v ? this.join("") : this.start; 6271 if (pt.m) { 6272 val = pt.m.call(this._tween, val, this._target || pt.t, this._tween); 6273 } else if (val < min) if (val >
6273 -min && !pt.blob) { //prevents issues with converting very small numbers to strings in the browser 6274 val = 0; 6275 } 6276 if (!pt.f) { 6277 pt.t[pt.p] = val; 6278 } else if (pt.fp) { 6279 pt.t[pt.p](pt.fp, val); 6280 } else { 6281 pt.t[pt.p](val); 6282 } 6283 pt = pt._next; 6284 } 6285 }, 6286 //compares two strings (start/end), finds the numbers that are different and spits back an array representing the whole value but with the changing values isolated as elements. For example, "rgb(0,0,0)" and "rgb(100,50,0)" would become ["rgb(", 0, ",", 50, ",0)"]. Notice it merges the parts that are identical (performance optimization). The array also has a linked list of PropTweens attached starting with _firstPT that contain the tweening data (t, p, s, c, f, etc.). It also stores the starting value as a "start" property so that we can revert to it if/when necessary, like when a tween rewinds fully. If the quantity of numbers differs between the start and end, it will always prioritize the end value(s). The pt parameter is optional - it's for a PropTween that will be appended to the end of the linked list and is typically for actually setting the value after all of the elements have been updated (with array.join("")). 6287 _blobDif = function(start, end, filter, pt) { 6288 var a = [], 6289 charIndex = 0, 6290 s = "", 6291 color = 0, 6292 startNums, endNums, num, i, l, nonNumbers, currentNum; 6293 a.start = start; 6294 a.end = end; 6295 start = a[0] = start + ""; //ensure values are strings 6296 end = a[1] = end + ""; 6297 if (filter) { 6298 filter(a); //pass an array with the starting and ending values and let the filter do whatever it needs to the values. 6299 start = a[0]; 6300 end = a[1]; 6301 } 6302 a.length = 0; 6303 startNums = start.match(_numbersExp) || []; 6304 endNums = end.match(_numbersExp) || []; 6305 if (pt) { 6306 pt._next = null; 6307 pt.blob = 1; 6308 a._firstPT = a._applyPT = pt; //apply last in the linked list (which means inserting it first) 6309 } 6310 l = endNums.length; 6311 for (i = 0; i < l; i++) { 6312 currentNum = endNums[i]; 6313 nonNumbers = end.substr(charIndex, end.indexOf(currentNum, charIndex)-charIndex); 6314 s += (nonNumbers || !i) ? nonNumbers : ","; //note: SVG spec allows omission of comma/space when a negative sign is wedged between two numbers, like 2.5-5.3 instead of 2.5,-5.3 but when tweening, the negative value may switch to positive, so we insert the comma just in case. 6315 charIndex += nonNumbers.length; 6316 if (color) { //sense rgba() values and round them. 6317 color = (color + 1) % 5; 6318 } else if (nonNumbers.substr(-5) === "rgba(") { 6319 color = 1; 6320 } 6321 if (currentNum === startNums[i] || startNums.length <= i) { 6322 s += currentNum; 6323 } else { 6324 if (s) { 6325 a.push(s); 6326 s = ""; 6327 } 6328 num = parseFloat(startNums[i]); 6329 a.push(num); 6330 a._firstPT = {_next: a._firstPT, t:a, p: a.length-1, s:num, c:((currentNum.charAt(1) === "=") ? parseInt(currentNum.charAt(0) + "1", 10) * parseFloat(currentNum.substr(2)) : (parseFloat(currentNum) - num)) || 0, f:0, m:(color && color < 4) ? Math.round : 0}; 6331 //note: we don't set _prev because we'll never need to remove individual PropTweens from this list. 6332 } 6333 charIndex += currentNum.length; 6334 } 6335 s += end.substr(charIndex); 6336 if (s) { 6337 a.push(s); 6338 } 6339 a.setRatio = _setRatio; 6340 if (_relExp.test(end)) { //if the end string contains relative values, delete it so that on the final render (in _setRatio()), we don't actually set it to the string with += or -= characters (forces it to use the calculated value). 6341 a.end = null; 6342 } 6343 return a; 6344 }, 6345 //note: "funcParam" is only necessary for function-based getters/setters that require an extra parameter like getAttribute("width") and setAttribute("width", value). In this example, funcParam would be "width". Used by AttrPlugin for example. 6346 _addPropTween = function(target, prop, start, end, overwriteProp, mod, funcParam, stringFilter, index) { 6347 if (typeof(end) === "function") { 6348 end = end(index || 0, target); 6349 } 6350 var type = typeof(target[prop]), 6351 getterName = (type !== "function") ? "" : ((prop.indexOf("set") || typeof(target["get" + prop.substr(3)]) !== "function") ? prop : "get" + prop.substr(3)), 6352 s = (start !== "get") ? start : !getterName ? target[prop] : funcParam ? target[getterName](funcParam) : target[getterName](), 6353 isRelative = (typeof(end) === "string" && end.charAt(1) === "="), 6354 pt = {t:target, p:prop, s:s, f:(type === "function"), pg:0, n:overwriteProp || prop, m:(!mod ? 0 : (typeof(mod) === "function") ? mod : Math.round), pr:0, c:isRelative ? parseInt(end.charAt(0) + "1", 10) * parseFloat(end.substr(2)) : (parseFloat(end) - s) || 0}, 6355 blob; 6356 6357 if (typeof(s) !== "number" || (typeof(end) !== "number" && !isRelative)) { 6358 if (funcParam || isNaN(s) || (!isRelative && isNaN(end)) || typeof(s) === "boolean" || typeof(end) === "boolean") { 6359 //a blob (string that has multiple numbers in it) 6360 pt.fp = funcParam; 6361 blob = _blobDif(s, (isRelative ? (parseFloat(pt.s) + pt.c) + (pt.s + "").replace(/[0-9\-\.]/g, "") : end), stringFilter || TweenLite.defaultStringFilter, pt); 6362 pt = {t: blob, p: "setRatio", s: 0, c: 1, f: 2, pg: 0, n: overwriteProp || prop, pr: 0, m: 0}; //"2" indicates it's a Blob property tween. Needed for RoundPropsPlugin for example. 6363 } else { 6364 pt.s = parseFloat(s); 6365 if (!isRelative) { 6366 pt.c = (parseFloat(end) - pt.s) || 0; 6367 } 6368 } 6369 } 6370 if (pt.c) { //only add it to the linked list if there's a change. 6371 if ((pt._next = this._firstPT)) { 6372 pt._next._prev = pt; 6373 } 6374 this._firstPT = pt; 6375 return pt; 6376 } 6377 }, 6378 _internals = TweenLite._internals = {isArray:_isArray, isSelector:_isSelector, lazyTweens:_lazyTweens, blobDif:_blobDif}, //gives us a way to expose certain private values to other GreenSock classes without contaminating tha main TweenLite object. 6379 _plugins = TweenLite._plugins = {}, 6380 _tweenLookup = _internals.tweenLookup = {}, 6381 _tweenLookupNum = 0, 6382 _reservedProps = _internals.reservedProps = {ease:1, delay:1, overwrite:1, onComplete:1, onCompleteParams:1, onCompleteScope:1, useFrames:1, runBackwards:1, startAt:1, onUp
6382date:1, onUpdateParams:1, onUpdateScope:1, onStart:1, onStartParams:1, onStartScope:1, onReverseComplete:1, onReverseCompleteParams:1, onReverseCompleteScope:1, onRepeat:1, onRepeatParams:1, onRepeatScope:1, easeParams:1, yoyo:1, immediateRender:1, repeat:1, repeatDelay:1, data:1, paused:1, reversed:1, autoCSS:1, lazy:1, onOverwrite:1, callbackScope:1, stringFilter:1, id:1, yoyoEase:1}, 6383 _overwriteLookup = {none:0, all:1, auto:2, concurrent:3, allOnStart:4, preexisting:5, "true":1, "false":0}, 6384 _rootFramesTimeline = Animation._rootFramesTimeline = new SimpleTimeline(), 6385 _rootTimeline = Animation._rootTimeline = new SimpleTimeline(), 6386 _nextGCFrame = 30, 6387 _lazyRender = _internals.lazyRender = function() { 6388 var i = _lazyTweens.length, 6389 tween; 6390 _lazyLookup = {}; 6391 while (--i > -1) { 6392 tween = _lazyTweens[i]; 6393 if (tween && tween._lazy !== false) { 6394 tween.render(tween._lazy[0], tween._lazy[1], true); 6395 tween._lazy = false; 6396 } 6397 } 6398 _lazyTweens.length = 0; 6399 }; 6400 6401 _rootTimeline._startTime = _ticker.time; 6402 _rootFramesTimeline._startTime = _ticker.frame; 6403 _rootTimeline._active = _rootFramesTimeline._active = true; 6404 setTimeout(_lazyRender, 1); //on some mobile devices, there isn't a "tick" before code runs which means any lazy renders wouldn't run before the next official "tick". 6405 6406 Animation._updateRoot = TweenLite.render = function() { 6407 var i, a, p; 6408 if (_lazyTweens.length) { //if code is run outside of the requestAnimationFrame loop, there may be tweens queued AFTER the engine refreshed, so we need to ensure any pending renders occur before we refresh again. 6409 _lazyRender(); 6410 } 6411 _rootTimeline.render((_ticker.time - _rootTimeline._startTime) * _rootTimeline._timeScale, false, false); 6412 _rootFramesTimeline.render((_ticker.frame - _rootFramesTimeline._startTime) * _rootFramesTimeline._timeScale, false, false); 6413 if (_lazyTweens.length) { 6414 _lazyRender(); 6415 } 6416 if (_ticker.frame >= _nextGCFrame) { //dump garbage every 120 frames or whatever the user sets TweenLite.autoSleep to 6417 _nextGCFrame = _ticker.frame + (parseInt(TweenLite.autoSleep, 10) || 120); 6418 for (p in _tweenLookup) { 6419 a = _tweenLookup[p].tweens; 6420 i = a.length; 6421 while (--i > -1) { 6422 if (a[i]._gc) { 6423 a.splice(i, 1); 6424 } 6425 } 6426 if (a.length === 0) { 6427 delete _tweenLookup[p]; 6428 } 6429 } 6430 //if there are no more tweens in the root timelines, or if they're all paused, make the _timer sleep to reduce load on the CPU slightly 6431 p = _rootTimeline._first; 6432 if (!p || p._paused) if (TweenLite.autoSleep && !_rootFramesTimeline._first && _ticker._listeners.tick.length === 1) { 6433 while (p && p._paused) { 6434 p = p._next; 6435 } 6436 if (!p) { 6437 _ticker.sleep(); 6438 } 6439 } 6440 } 6441 }; 6442 6443 _ticker.addEventListener("tick", Animation._updateRoot); 6444 6445 var _register = function(target, tween, scrub) { 6446 var id = target._gsTweenID, a, i; 6447 if (!_tweenLookup[id || (target._gsTweenID = id = "t" + (_tweenLookupNum++))]) { 6448 _tweenLookup[id] = {target:target, tweens:[]}; 6449 } 6450 if (tween) { 6451 a = _tweenLookup[id].tweens; 6452 a[(i = a.length)] = tween; 6453 if (scrub) { 6454 while (--i > -1) { 6455 if (a[i] === tween) { 6456 a.splice(i, 1); 6457 } 6458 } 6459 } 6460 } 6461 return _tweenLookup[id].tweens; 6462 }, 6463 _onOverwrite = function(overwrittenTween, overwritingTween, target, killedProps) { 6464 var func = overwrittenTween.vars.onOverwrite, r1, r2; 6465 if (func) { 6466 r1 = func(overwrittenTween, overwritingTween, target, killedProps); 6467 } 6468 func = TweenLite.onOverwrite; 6469 if (func) { 6470 r2 = func(overwrittenTween, overwritingTween, target, killedProps); 6471 } 6472 return (r1 !== false && r2 !== false); 6473 }, 6474 _applyOverwrite = function(target, tween, props, mode, siblings) { 6475 var i, changed, curTween, l; 6476 if (mode === 1 || mode >= 4) { 6477 l = siblings.length; 6478 for (i = 0; i < l; i++) { 6479 if ((curTween = siblings[i]) !== tween) { 6480 if (!curTween._gc) { 6481 if (curTween._kill(null, target, tween)) { 6482 changed = true; 6483 } 6484 } 6485 } else if (mode === 5) { 6486 break; 6487 } 6488 } 6489 return changed; 6490 } 6491 //NOTE: Add 0.0000000001 to overcome floating point errors that can cause the startTime to be VERY slightly off (when a tween's time() is set for example) 6492 var startTime = tween._startTime + _tinyNum, 6493 overlaps = [], 6494 oCount = 0, 6495 zeroDur = (tween._duration === 0), 6496 globalStart; 6497 i = siblings.length; 6498 while (--i > -1) { 6499 if ((curTween = siblings[i]) === tween || curTween._gc || curTween._paused) { 6500 //ignore 6501 } else if (curTween._timeline !== tween._timeline) { 6502 globalStart = globalStart || _checkOverlap(tween, 0, zeroDur); 6503 if (_checkOverlap(curTween, globalStart, zeroDur) === 0) { 6504 overlaps[oCount++] = curTween; 6505 } 6506 } else if (curTween._startTime <= startTime) if (curTween._startTime + curTween.totalDuration() / curTween._timeScale > startTime) if (!((zeroDur || !curTween._initted) && startTime - curTween._startTime <= 0.0000000002)) { 6507 overlaps[oCount++] = curTween; 6508 } 6509 } 6510 6511 i = oCount; 6512 while (--i > -1) { 6513 curTween = overlaps[i]; 6514 if (mode === 2) if (curTween._kill(props, target, tween)) { 6515 changed = true; 6516 } 6517 if (mode !== 2 || (!curTween._firstPT && curTween._initted)) { 6518 if (mode !== 2 && !_onOverwrite(curTween, tween)) { 6519 continue; 6520 } 6521 if (curTween._enabled(false, false)) { //if all property tweens have been overwritten, kill the tween. 6522 changed = true; 6523 } 6524 } 6525 } 6526 return changed; 6527 }, 6528 _checkOverlap = function(tween, reference, zeroDur) { 6529 var tl = tween._timeline, 6530 ts = tl._timeScale, 6531 t = tween._startTime; 6532 while (tl._timeline) { 6533 t += tl._startTime; 6534 ts *= tl._timeScale; 6535 if (tl._paused) { 6536 return -100; 6537 } 6538 tl = tl._timeline; 6539 } 6540 t /= ts; 6541 return (t > reference) ? t - reference : ((zeroDur && t === reference) || (!tween._initted && t - reference < 2 * _tinyNum)) ? _tinyNum : ((t += tween.totalDuration() / tween._timeScale / ts) > reference + _tinyNum) ? 0 : t - reference - _tinyNum; 6542 }; 6543 6544 6545//---- TweenLite instance methods ----------------------------------------------------------------------------- 6546 6547 p._init = function() { 6548 var v = this.vars, 6549 op = this._overwrittenProps, 6550 dur = this._duration, 6551 immediate = !!v.immediateRender, 6552 ease = v.ease, 6553 i, initPlugins, pt, p, startVars, l; 6554 if (v.startAt) { 6555 if (this._startAt) { 6556 this._startAt.render(-1, true); //if we've run a startAt previously (when the tween instantiated), we should revert it so that the values re-instantiate correctly particularly for relative tweens. Without this, a TweenLite.fromTo(obj, 1, {x:"+=100"}, {x:"-=100"}), for example, would actually jump to +=200 because the startAt would run twice, doubling the relative change. 6557 this._startAt.kill(); 6558 } 6559 startVars = {}; 6560 for (p in v.startAt) { //copy the properties/values into a new object to avoid collisions, like var to = {x:0}, from = {x:500}; timeline.fromTo(e, 1, from, to).fromTo(e, 1, to, from); 6561 startVars[p] = v.startAt[p]; 6562 } 6563 startVars.data = "isStart"; 6564 startVars.overwrite = false;
6565 startVars.immediateRender = true; 6566 startVars.lazy = (immediate && v.lazy !== false); 6567 startVars.startAt = startVars.delay = null; //no nesting of startAt objects allowed (otherwise it could cause an infinite loop). 6568 startVars.onUpdate = v.onUpdate; 6569 startVars.onUpdateParams = v.onUpdateParams; 6570 startVars.onUpdateScope = v.onUpdateScope || v.callbackScope || this; 6571 this._startAt = TweenLite.to(this.target || {}, 0, startVars); 6572 if (immediate) { 6573 if (this._time > 0) { 6574 this._startAt = null; //tweens that render immediately (like most from() and fromTo() tweens) shouldn't revert when their parent timeline's playhead goes backward past the startTime because the initial render could have happened anytime and it shouldn't be directly correlated to this tween's startTime. Imagine setting up a complex animation where the beginning states of various objects are rendered immediately but the tween doesn't happen for quite some time - if we revert to the starting values as soon as the playhead goes backward past the tween's startTime, it will throw things off visually. Reversion should only happen in TimelineLite/Max instances where immediateRender was false (which is the default in the convenience methods like from()). 6575 } else if (dur !== 0) { 6576 return; //we skip initialization here so that overwriting doesn't occur until the tween actually begins. Otherwise, if you create several immediateRender:true tweens of the same target/properties to drop into a TimelineLite or TimelineMax, the last one created would overwrite the first ones because they didn't get placed into the timeline yet before the first render occurs and kicks in overwriting. 6577 } 6578 } 6579 } else if (v.runBackwards && dur !== 0) { 6580 //from() tweens must be handled uniquely: their beginning values must be rendered but we don't want overwriting to occur yet (when time is still 0). Wait until the tween actually begins before doing all the routines like overwriting. At that time, we should render at the END of the tween to ensure that things initialize correctly (remember, from() tweens go backwards) 6581 if (this._startAt) { 6582 this._startAt.render(-1, true); 6583 this._startAt.kill(); 6584 this._startAt = null; 6585 } else { 6586 if (this._time !== 0) { //in rare cases (like if a from() tween runs and then is invalidate()-ed), immediateRender could be true but the initial forced-render gets skipped, so there's no need to force the render in this context when the _time is greater than 0 6587 immediate = false; 6588 } 6589 pt = {}; 6590 for (p in v) { //copy props into a new object and skip any reserved props, otherwise onComplete or onUpdate or onStart could fire. We should, however, permit autoCSS to go through. 6591 if (!_reservedProps[p] || p === "autoCSS") { 6592 pt[p] = v[p]; 6593 } 6594 } 6595 pt.overwrite = 0; 6596 pt.data = "isFromStart"; //we tag the tween with as "isFromStart" so that if [inside a plugin] we need to only do something at the very END of a tween, we have a way of identifying this tween as merely the one that's setting the beginning values for a "from()" tween. For example, clearProps in CSSPlugin should only get applied at the very END of a tween and without this tag, from(...{height:100, clearProps:"height", delay:1}) would wipe the height at the beginning of the tween and after 1 second, it'd kick back in. 6597 pt.lazy = (immediate && v.lazy !== false); 6598 pt.immediateRender = immediate; //zero-duration tweens render immediately by default, but if we're not specifically instructed to render this tween immediately, we should skip this and merely _init() to record the starting values (rendering them immediately would push them to completion which is wasteful in that case - we'd have to render(-1) immediately after) 6599 this._startAt = TweenLite.to(this.target, 0, pt); 6600 if (!immediate) { 6601 this._startAt._init(); //ensures that the initial values are recorded 6602 this._startAt._enabled(false); //no need to have the tween render on the next cycle. Disable it because we'll always manually control the renders of the _startAt tween. 6603 if (this.vars.immediateRender) { 6604 this._startAt = null; 6605 } 6606 } else if (this._time === 0) { 6607 return; 6608 } 6609 } 6610 } 6611 this._ease = ease = (!ease) ? TweenLite.defaultEase : (ease instanceof Ease) ? ease : (typeof(ease) === "function") ? new Ease(ease, v.easeParams) : _easeMap[ease] || TweenLite.defaultEase; 6612 if (v.easeParams instanceof Array && ease.config) { 6613 this._ease = ease.config.apply(ease, v.easeParams); 6614 } 6615 this._easeType = this._ease._type; 6616 this._easePower = this._ease._power; 6617 this._firstPT = null; 6618 6619 if (this._targets) { 6620 l = this._targets.length; 6621 for (i = 0; i < l; i++) { 6622 if ( this._initProps( this._targets[i], (this._propLookup[i] = {}), this._siblings[i], (op ? op[i] : null), i) ) { 6623 initPlugins = true; 6624 } 6625 } 6626 } else { 6627 initPlugins = this._initProps(this.target, this._propLookup, this._siblings, op, 0); 6628 } 6629 6630 if (initPlugins) { 6631 TweenLite._onPluginEvent("_onInitAllProps", this); //reorders the array in order of priority. Uses a static TweenPlugin method in order to minimize file size in TweenLite 6632 } 6633 if (op) if (!this._firstPT) if (typeof(this.target) !== "function") { //if all tweening properties have been overwritten, kill the tween. If the target is a function, it's probably a delayedCall so let it live. 6634 this._enabled(false, false); 6635 } 6636 if (v.runBackwards) { 6637 pt = this._firstPT; 6638 while (pt) { 6639 pt.s += pt.c; 6640 pt.c = -pt.c; 6641 pt = pt._next; 6642 } 6643 } 6644 this._onUpdate = v.onUpdate; 6645 this._initted = true; 6646 }; 6647 6648 p._initProps = function(target, propLookup, siblings, overwrittenProps, index) { 6649 var p, i, initPlugins, plugin, pt, v; 6650 if (target == null) { 6651 return false;
6652 } 6653 6654 if (_lazyLookup[target._gsTweenID]) { 6655 _lazyRender(); //if other tweens of the same target have recently initted but haven't rendered yet, we've got to force the render so that the starting values are correct (imagine populating a timeline with a bunch of sequential tweens and then jumping to the end) 6656 } 6657 6658 if (!this.vars.css) if (target.style) if (target !== window && target.nodeType) if (_plugins.css) if (this.vars.autoCSS !== false) { //it's so common to use TweenLite/Max to animate the css of DOM elements, we assume that if the target is a DOM element, that's what is intended (a convenience so that users don't have to wrap things in css:{}, although we still recommend it for a slight performance boost and better specificity). Note: we cannot check "nodeType" on the window inside an iframe. 6659 _autoCSS(this.vars, target); 6660 } 6661 for (p in this.vars) { 6662 v = this.vars[p]; 6663 if (_reservedProps[p]) { 6664 if (v) if ((v instanceof Array) || (v.push && _isArray(v))) if (v.join("").indexOf("{self}") !== -1) { 6665 this.vars[p] = v = this._swapSelfInParams(v, this); 6666 } 6667 6668 } else if (_plugins[p] && (plugin = new _plugins[p]())._onInitTween(target, this.vars[p], this, index)) { 6669 6670 //t - target [object] 6671 //p - property [string] 6672 //s - start [number] 6673 //c - change [number] 6674 //f - isFunction [boolean] 6675 //n - name [string] 6676 //pg - isPlugin [boolean] 6677 //pr - priority [number] 6678 //m - mod [function | 0] 6679 this._firstPT = pt = {_next:this._firstPT, t:plugin, p:"setRatio", s:0, c:1, f:1, n:p, pg:1, pr:plugin._priority, m:0}; 6680 i = plugin._overwriteProps.length; 6681 while (--i > -1) { 6682 propLookup[plugin._overwriteProps[i]] = this._firstPT; 6683 } 6684 if (plugin._priority || plugin._onInitAllProps) { 6685 initPlugins = true; 6686 } 6687 if (plugin._onDisable || plugin._onEnable) { 6688 this._notifyPluginsOfEnabled = true; 6689 } 6690 if (pt._next) { 6691 pt._next._prev = pt; 6692 } 6693 6694 } else { 6695 propLookup[p] = _addPropTween.call(this, target, p, "get", v, p, 0, null, this.vars.stringFilter, index); 6696 } 6697 } 6698 6699 if (overwrittenProps) if (this._kill(overwrittenProps, target)) { //another tween may have tried to overwrite properties of this tween before init() was called (like if two tweens start at the same time, the one created second will run first) 6700 return this._initProps(target, propLookup, siblings, overwrittenProps, index); 6701 } 6702 if (this._overwrite > 1) if (this._firstPT) if (siblings.length > 1) if (_applyOverwrite(target, this, propLookup, this._overwrite, siblings)) { 6703 this._kill(propLookup, target); 6704 return this._initProps(target, propLookup, siblings, overwrittenProps, index); 6705 } 6706 if (this._firstPT) if ((this.vars.lazy !== false && this._duration) || (this.vars.lazy && !this._duration)) { //zero duration tweens don't lazy render by default; everything else does. 6707 _lazyLookup[target._gsTweenID] = true; 6708 } 6709 return initPlugins; 6710 }; 6711 6712 p.render = function(time, suppressEvents, force) { 6713 var prevTime = this._time, 6714 duration = this._duration, 6715 prevRawPrevTime = this._rawPrevTime, 6716 isComplete, callback, pt, rawPrevTime; 6717 if (time >= duration - 0.0000001 && time >= 0) { //to work around occasional floating point math artifacts. 6718 this._totalTime = this._time = duration; 6719 this.ratio = this._ease._calcEnd ? this._ease.getRatio(1) : 1; 6720 if (!this._reversed ) { 6721 isComplete = true; 6722 callback = "onComplete"; 6723 force = (force || this._timeline.autoRemoveChildren); //otherwise, if the animation is unpaused/activated after it's already finished, it doesn't get removed from the parent timeline. 6724 } 6725 if (duration === 0) if (this._initted || !this.vars.lazy || force) { //zero-duration tweens are tricky because we must discern the momentum/direction of time in order to determine whether the starting values should be rendered or the ending values. If the "playhead" of its timeline goes past the zero-duration tween in the forward direction or lands directly on it, the end values should be rendered, but if the timeline's "playhead" moves past it in the backward direction (from a postitive time to a negative time), the starting values must be rendered. 6726 if (this._startTime === this._timeline._duration) { //if a zero-duration tween is at the VERY end of a timeline and that timeline renders at its end, it will typically add a tiny bit of cushion to the render time to prevent roun
6726ding errors from getting in the way of tweens rendering their VERY end. If we then reverse() that timeline, the zero-duration tween will trigger its onReverseComplete even though technically the playhead didn't pass over it again. It's a very specific edge case we must accommodate. 6727 time = 0; 6728 } 6729 if (prevRawPrevTime < 0 || (time <= 0 && time >= -0.0000001) || (prevRawPrevTime === _tinyNum && this.data !== "isPause")) if (prevRawPrevTime !== time) { //note: when this.data is "isPause", it's a callback added by addPause() on a timeline that we should not be triggered when LEAVING its exact start time. In other words, tl.addPause(1).play(1) shouldn't pause. 6730 force = true; 6731 if (prevRawPrevTime > _tinyNum) { 6732 callback = "onReverseComplete"; 6733 } 6734 } 6735 this._rawPrevTime = rawPrevTime = (!suppressEvents || time || prevRawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. 6736 } 6737 6738 } else if (time < 0.0000001) { //to work around occasional floating point math artifacts, round super small values to 0. 6739 this._totalTime = this._time = 0; 6740 this.ratio = this._ease._calcEnd ? this._ease.getRatio(0) : 0; 6741 if (prevTime !== 0 || (duration === 0 && prevRawPrevTime > 0)) { 6742 callback = "onReverseComplete"; 6743 isComplete = this._reversed; 6744 } 6745 if (time < 0) { 6746 this._active = false; 6747 if (duration === 0) if (this._initted || !this.vars.lazy || force) { //zero-duration tweens are tricky because we must discern the momentum/direction of time in order to determine whether the starting values should be rendered or the ending values. If the "playhead" of its timeline goes past the zero-duration tween in the forward direction or lands directly on it, the end values should be rendered, but if the timeline's "playhead" moves past it in the backward direction (from a postitive time to a negative time), the starting values must be rendered. 6748 if (prevRawPrevTime >= 0 && !(prevRawPrevTime === _tinyNum && this.data === "isPause")) { 6749 force = true; 6750 } 6751 this._rawPrevTime = rawPrevTime = (!suppressEvents || time || prevRawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. 6752 } 6753 } 6754 if (!this._initted || (this._startAt && this._startAt.progress())) { //if we render the very beginning (time == 0) of a fromTo(), we must force the render (normal tweens wouldn't need to render at a time of 0 when the prevTime was also 0). This is also mandatory to make sure overwriting kicks in immediately. Also, we check progress() because if startAt has already rendered at its end, we should force a render at its beginning. Otherwise, if you put the playhead directly on top of where a fromTo({immediateRender:false}) starts, and then move it backwards, the from() won't revert its values. 6755 force = true; 6756 } 6757 } else { 6758 this._totalTime = this._time = time; 6759 6760 if (this._easeType) { 6761 var r = time / duration, type = this._easeType, pow = this._easePower; 6762 if (type === 1 || (type === 3 && r >= 0.5)) { 6763 r = 1 - r; 6764 } 6765 if (type === 3) { 6766 r *= 2; 6767 } 6768 if (pow === 1) { 6769 r *= r; 6770 } else if (pow === 2) { 6771 r *= r * r; 6772 } else if (pow === 3) { 6773 r *= r * r * r; 6774 } else if (pow === 4) { 6775 r *= r * r * r * r; 6776 } 6777 6778 if (type === 1) { 6779 this.ratio = 1 - r; 6780 } else if (type === 2) { 6781 this.ratio = r; 6782 } else if (time / duration < 0.5) { 6783 this.ratio = r / 2; 6784 } else { 6785 this.ratio = 1 - (r / 2); 6786 } 6787 6788 } else { 6789 this.ratio = this._ease.getRatio(time / duration); 6790 } 6791 } 6792 6793 if (this._time === prevTime && !force) { 6794 return; 6795 } else if (!this._initted) { 6796 this._init(); 6797 if (!this._initted || this._gc) { //immediateRender tweens typically won't initialize until the playhead advances (_time is greater than 0) in order to ensure that over
6797writing occurs properly. Also, if all of the tweening properties have been overwritten (which would cause _gc to be true, as set in _init()), we shouldn't continue otherwise an onStart callback could be called for example. 6798 return; 6799 } else if (!force && this._firstPT && ((this.vars.lazy !== false && this._duration) || (this.vars.lazy && !this._duration))) { 6800 this._time = this._totalTime = prevTime; 6801 this._rawPrevTime = prevRawPrevTime; 6802 _lazyTweens.push(this); 6803 this._lazy = [time, suppressEvents]; 6804 return; 6805 } 6806 //_ease is initially set to defaultEase, so now that init() has run, _ease is set properly and we need to recalculate the ratio. Overall this is faster than using conditional logic earlier in the method to avoid having to set ratio twice because we only init() once but renderTime() gets called VERY frequently. 6807 if (this._time && !isComplete) { 6808 this.ratio = this._ease.getRatio(this._time / duration); 6809 } else if (isComplete && this._ease._calcEnd) { 6810 this.ratio = this._ease.getRatio((this._time === 0) ? 0 : 1); 6811 } 6812 } 6813 if (this._lazy !== false) { //in case a lazy render is pending, we should flush it because the new render is occurring now (imagine a lazy tween instantiating and then immediately the user calls tween.seek(tween.duration()), skipping to the end - the end render would be forced, and then if we didn't flush the lazy render, it'd fire AFTER the seek(), rendering it at the wrong time. 6814 this._lazy = false; 6815 } 6816 if (!this._active) if (!this._paused && this._time !== prevTime && time >= 0) { 6817 this._active = true; //so that if the user renders a tween (as opposed to the timeline rendering it), the timeline is forced to re-render and align it with the proper time/frame on the next rendering cycle. Maybe the tween already finished but the user manually re-renders it as halfway done. 6818 } 6819 if (prevTime === 0) { 6820 if (this._startAt) { 6821 if (time >= 0) { 6822 this._startAt.render(time, true, force); 6823 } else if (!callback) { 6824 callback = "_dummyGS"; //if no callback is defined, use a dummy value just so that the condition at the end evaluates as true because _startAt should render AFTER the normal render loop when the time is negative. We could handle this in a more intuitive way, of course, but the render loop is the MOST important thing to optimize, so this technique allows us to avoid adding extra conditional logic in a high-frequency area. 6825 } 6826 } 6827 if (this.vars.onStart) if (this._time !== 0 || duration === 0) if (!suppressEvents) { 6828 this._callback("onStart"); 6829 } 6830 } 6831 pt = this._firstPT; 6832 while (pt) { 6833 if (pt.f) { 6834 pt.t[pt.p](pt.c * this.ratio + pt.s); 6835 } else { 6836 pt.t[pt.p] = pt.c * this.ratio + pt.s; 6837 } 6838 pt = pt._next; 6839 } 6840 6841 if (this._onUpdate) { 6842 if (time < 0) if (this._startAt && time !== -0.0001) { //if the tween is positioned at the VERY beginning (_startTime 0) of its parent timeline, it's illegal for the playhead to go back further, so we should not render the recorded startAt values. 6843 this._startAt.render(time, true, force); //note: for performance reasons, we tuck this conditional logic inside less traveled areas (most tweens don't have an onUpdate). We'd just have it at the end before the onComplete, but the values should be updated before any onUpdate is called, so we ALSO put it here and then if it's not called, we do so later near the onComplete. 6844 } 6845 if (!suppressEvents) if (this._time !== prevTime || isComplete || force) { 6846 this._callback("onUpdate"); 6847 } 6848 } 6849 if (callback) if (!this._gc || force) { //check _gc because there's a chance that kill() could be called in an onUpdate 6850 if (time < 0 && this._startAt && !this._onUpdate && time !== -0.0001) { //-0.0001 is a special value that we use when looping back to the beginning of a repeated TimelineMax, in which case we shouldn't render the _startAt values. 6851 this._startAt.render(time, true, force); 6852 } 6853 if (isComplete) { 6854 if (this._timeline.autoRemoveChildren) { 6855 this._enabled(false, false); 6856 } 6857 this._active = false;
6858 } 6859 if (!suppressEvents && this.vars[callback]) { 6860 this._callback(callback); 6861 } 6862 if (duration === 0 && this._rawPrevTime === _tinyNum && rawPrevTime !== _tinyNum) { //the onComplete or onReverseComplete could trigger movement of the playhead and for zero-duration tweens (which must discern direction) that land directly back on their start time, we don't want to fire again on the next render. Think of several addPause()'s in a timeline that forces the playhead to a certain spot, but what if it's already paused and another tween is tweening the "time" of the timeline? Each time it moves [forward] past that spot, it would move back, and since suppressEvents is true, it'd reset _rawPrevTime to _tinyNum so that when it begins again, the callback would fire (so ultimately it could bounce back and forth during that tween). Again, this is a very uncommon scenario, but possible nonetheless. 6863 this._rawPrevTime = 0; 6864 } 6865 } 6866 }; 6867 6868 p._kill = function(vars, target, overwritingTween) { 6869 if (vars === "all") { 6870 vars = null; 6871 } 6872 if (vars == null) if (target == null || target === this.target) { 6873 this._lazy = false; 6874 return this._enabled(false, false); 6875 } 6876 target = (typeof(target) !== "string") ? (target || this._targets || this.target) : TweenLite.selector(target) || target; 6877 var simultaneousOverwrite = (overwritingTween && this._time && overwritingTween._startTime === this._startTime && this._timeline === overwritingTween._timeline), 6878 i, overwrittenProps, p, pt, propLookup, changed, killProps, record, killed; 6879 if ((_isArray(target) || _isSelector(target)) && typeof(target[0]) !== "number") { 6880 i = target.length; 6881 while (--i > -1) { 6882 if (this._kill(vars, target[i], overwritingTween)) { 6883 changed = true; 6884 } 6885 } 6886 } else { 6887 if (this._targets) { 6888 i = this._targets.length; 6889 while (--i > -1) { 6890 if (target === this._targets[i]) { 6891 propLookup = this._propLookup[i] || {}; 6892 this._overwrittenProps = this._overwrittenProps || []; 6893 overwrittenProps = this._overwrittenProps[i] = vars ? this._overwrittenProps[i] || {} : "all"; 6894 break; 6895 } 6896 } 6897 } else if (target !== this.target) { 6898 return false; 6899 } else { 6900 propLookup = this._propLookup; 6901 overwrittenProps = this._overwrittenProps = vars ? this._overwrittenProps || {} : "all"; 6902 } 6903 6904 if (propLookup) { 6905 killProps = vars || propLookup; 6906 record = (vars !== overwrittenProps && overwrittenProps !== "all" && vars !== propLookup && (typeof(vars) !== "object" || !vars._tempKill)); //_tempKill is a super-secret way to delete a particular tweening property but NOT have it remembered as an official overwritten property (like in BezierPlugin) 6907 if (overwritingTween && (TweenLite.onOverwrite || this.vars.onOverwrite)) { 6908 for (p in killProps) { 6909 if (propLookup[p]) { 6910 if (!killed) { 6911 killed = []; 6912 } 6913 killed.push(p); 6914 } 6915 } 6916 if ((killed || !vars) && !_onOverwrite(this, overwritingTween, target, killed)) { //if the onOverwrite returned false, that means the user wants to override the overwriting (cancel it). 6917 return false; 6918 } 6919 } 6920 6921 for (p in killProps) { 6922 if ((pt = propLookup[p])) { 6923 if (simultaneousOverwrite) { //if another tween overwrites this one and they both start at exactly the same time, yet this tween has already rendered once (for example, at 0.001) because it's first in the queue, we should revert the values to where they were at 0 so that the starting values aren't contaminated on the overwriting tween. 6924 if (pt.f) { 6925 pt.t[pt.p](pt.s); 6926 } else { 6927 pt.t[pt.p] = pt.s; 6928 } 6929 changed = true; 6930 } 6931 if (pt.pg && pt.t._kill(killProps)) { 6932 changed = true; //some plugins need to be notified so they can perform cleanup tasks first 6933 } 6934 if (!pt.pg || pt.t._overwriteProps.length === 0) { 6935 if (pt._prev) { 6936 pt._prev._next = pt._next; 6937 } else if (pt === this._firstPT) { 6938 this._firstPT = pt._next; 6939 } 6940 if (pt._next) { 6941 pt._next._prev = pt._prev; 6942 } 6943 pt._next = pt._prev = null; 6944 } 6945 delete propLookup[p]; 6946 } 6947 if (record) { 6948 overwrittenProps[p] = 1; 6949 } 6950 } 6951 if (!this._firstPT && this._initted) { //if all tweening properties are killed, kill the tween. Without this line, if there's a tween with multiple targets and then you killTweensOf() each target individually, the tween would technically still remain active and fire its onComplete even though there aren't any more properties tweening. 6952 this._enabled(false, false); 6953 } 6954 } 6955 } 6956 return changed; 6957 }; 6958 6959 p.invalidate = function() { 6960 if (this._notifyPluginsOfEnabled) { 6961 TweenLite._onPluginEvent("_onDisable", this); 6962 } 6963 this._firstPT = this._overwrittenProps = this._startAt = this._onUpdate = null; 6964 this._notifyPluginsOfEnabled = this._active = this._lazy = false;
6965 this._propLookup = (this._targets) ? {} : []; 6966 Animation.prototype.invalidate.call(this); 6967 if (this.vars.immediateRender) { 6968 this._time = -_tinyNum; //forces a render without having to set the render() "force" parameter to true because we want to allow lazying by default (using the "force" parameter always forces an immediate full render) 6969 this.render(Math.min(0, -this._delay)); //in case delay is negative. 6970 } 6971 return this; 6972 }; 6973 6974 p._enabled = function(enabled, ignoreTimeline) { 6975 if (!_tickerActive) { 6976 _ticker.wake(); 6977 } 6978 if (enabled && this._gc) { 6979 var targets = this._targets, 6980 i; 6981 if (targets) { 6982 i = targets.length; 6983 while (--i > -1) { 6984 this._siblings[i] = _register(targets[i], this, true); 6985 } 6986 } else { 6987 this._siblings = _register(this.target, this, true); 6988 } 6989 } 6990 Animation.prototype._enabled.call(this, enabled, ignoreTimeline); 6991 if (this._notifyPluginsOfEnabled) if (this._firstPT) { 6992 return TweenLite._onPluginEvent((enabled ? "_onEnable" : "_onDisable"), this); 6993 } 6994 return false; 6995 }; 6996 6997 6998//----TweenLite static methods ----------------------------------------------------- 6999 7000 TweenLite.to = function(target, duration, vars) { 7001 return new TweenLite(target, duration, vars); 7002 }; 7003 7004 TweenLite.from = function(target, duration, vars) { 7005 vars.runBackwards = true; 7006 vars.immediateRender = (vars.immediateRender != false); 7007 return new TweenLite(target, duration, vars); 7008 }; 7009 7010 TweenLite.fromTo = function(target, duration, fromVars, toVars) { 7011 toVars.startAt = fromVars; 7012 toVars.immediateRender = (toVars.immediateRender != false && fromVars.immediateRender != false); 7013 return new TweenLite(target, duration, toVars); 7014 }; 7015 7016 TweenLite.delayedCall = function(delay, callback, params, scope, useFrames) { 7017 return new TweenLite(callback, 0, {delay:delay, onComplete:callback, onCompleteParams:params, callbackScope:scope, onReverseComplete:callback, onReverseCompleteParams:params, immediateRender:false, lazy:false, useFrames:useFrames, overwrite:0}); 7018 }; 7019 7020 TweenLite.set = function(target, vars) { 7021 return new TweenLite(target, 0, vars); 7022 }; 7023 7024 TweenLite.getTweensOf = function(target, onlyActive) { 7025 if (target == null) { return []; } 7026 target = (typeof(target) !== "string") ? target : TweenLite.selector(target) || target; 7027 var i, a, j, t; 7028 if ((_isArray(target) || _isSelector(target)) && typeof(target[0]) !== "number") { 7029 i = target.length; 7030 a = []; 7031 while (--i > -1) { 7032 a = a.concat(TweenLite.getTweensOf(target[i], onlyActive)); 7033 } 7034 i = a.length; 7035 //now get rid of any duplicates (tweens of arrays of objects could cause duplicates) 7036 while (--i > -1) { 7037 t = a[i]; 7038 j = i; 7039 while (--j > -1) { 7040 if (t === a[j]) { 7041 a.splice(i, 1); 7042 } 7043 } 7044 } 7045 } else if (target._gsTweenID) { 7046 a = _register(target).concat(); 7047 i = a.length; 7048 while (--i > -1) { 7049 if (a[i]._gc || (onlyActive && !a[i].isActive())) { 7050 a.splice(i, 1); 7051 } 7052 } 7053 } 7054 return a || []; 7055 }; 7056 7057 TweenLite.killTweensOf = TweenLite.killDelayedCallsTo = function(target, onlyActive, vars) { 7058 if (typeof(onlyActive) === "object") { 7059 vars = onlyActive; //for backwards compatibility (before "onlyActive" parameter was inserted) 7060 onlyActive = false; 7061 } 7062 var a = TweenLite.getTweensOf(target, onlyActive), 7063 i = a.length; 7064 while (--i > -1) { 7065 a[i]._kill(vars, target); 7066 } 7067 }; 7068 7069 7070 7071/* 7072 * ---------------------------------------------------------------- 7073 * TweenPlugin (could easily be split out as a separate file/class, but included for ease of use (so that people don't need to include another script call before loading plugins which is easy to forget) 7074 * ---------------------------------------------------------------- 7075 */ 7076 var TweenPlugin = _class("plugins.TweenPlugin", function(props, priority) { 7077 this._overwriteProps = (props || "").split(","); 7078 this._propName = this._overwriteProps[0]; 7079 this._priority = priority || 0; 7080 this._super = TweenPlugin.prototype; 7081 }, true); 7082 7083 p = TweenPlugin.prototype; 7084 TweenPlugin.version = "1.19.0"; 7085 TweenPlugin.API = 2; 7086 p._firstPT = null; 7087 p._addTween = _addPropTween; 7088 p.setRatio = _setRatio; 7089 7090 p._kill = function(lookup) { 7091 var a = this._overwriteProps, 7092 pt = this._firstPT, 7093 i; 7094 if (lookup[this._propName] != null) { 7095 this._overwriteProps = []; 7096 } else { 7097 i = a.length; 7098 while (--i > -1) { 7099 if (lookup[a[i]] != null) { 7100 a.splice(i, 1); 7101 } 7102 } 7103 } 7104 while (pt) { 7105 if (lookup[pt.n] != null) { 7106 if (pt._next) { 7107 pt._next._prev = pt._prev; 7108 } 7109 if (pt._prev) { 7110 pt._prev._next = pt._next; 7111 pt._prev = null; 7112 } else if (this._firstPT === pt) { 7113 this._firstPT = pt._next; 7114 } 7115 } 7116 pt = pt._next; 7117 } 7118 return false;
7119 }; 7120 7121 p._mod = p._roundProps = function(lookup) { 7122 var pt = this._firstPT, 7123 val; 7124 while (pt) { 7125 val = lookup[this._propName] || (pt.n != null && lookup[ pt.n.split(this._propName + "_").join("") ]); 7126 if (val && typeof(val) === "function") { //some properties that are very plugin-specific add a prefix named after the _propName plus an underscore, so we need to ignore that extra stuff here. 7127 if (pt.f === 2) { 7128 pt.t._applyPT.m = val; 7129 } else { 7130 pt.m = val; 7131 } 7132 } 7133 pt = pt._next; 7134 } 7135 }; 7136 7137 TweenLite._onPluginEvent = function(type, tween) { 7138 var pt = tween._firstPT, 7139 changed, pt2, first, last, next; 7140 if (type === "_onInitAllProps") { 7141 //sorts the PropTween linked list in order of priority because some plugins need to render earlier/later than others, like MotionBlurPlugin applies its effects after all x/y/alpha tweens have rendered on each frame. 7142 while (pt) { 7143 next = pt._next; 7144 pt2 = first; 7145 while (pt2 && pt2.pr > pt.pr) { 7146 pt2 = pt2._next; 7147 } 7148 if ((pt._prev = pt2 ? pt2._prev : last)) { 7149 pt._prev._next = pt; 7150 } else { 7151 first = pt; 7152 } 7153 if ((pt._next = pt2)) { 7154 pt2._prev = pt; 7155 } else { 7156 last = pt; 7157 } 7158 pt = next; 7159 } 7160 pt = tween._firstPT = first; 7161 } 7162 while (pt) { 7163 if (pt.pg) if (typeof(pt.t[type]) === "function") if (pt.t[type]()) { 7164 changed = true; 7165 } 7166 pt = pt._next; 7167 } 7168 return changed; 7169 }; 7170 7171 TweenPlugin.activate = function(plugins) { 7172 var i = plugins.length; 7173 while (--i > -1) { 7174 if (plugins[i].API === TweenPlugin.API) { 7175 _plugins[(new plugins[i]())._propName] = plugins[i]; 7176 } 7177 } 7178 return true; 7179 }; 7180 7181 //provides a more concise way to define plugins that have no dependencies besides TweenPlugin and TweenLite, wrapping common boilerplate stuff into one function (added in 1.9.0). You don't NEED to use this to define a plugin - the old way still works and can be useful in certain (rare) situations. 7182 _gsDefine.plugin = function(config) { 7183 if (!config || !config.propName || !config.init || !config.API) { throw "illegal plugin definition."; } 7184 var propName = config.propName, 7185 priority = config.priority || 0, 7186 overwriteProps = config.overwriteProps, 7187 map = {init:"_onInitTween", set:"setRatio", kill:"_kill", round:"_mod", mod:"_mod", initAll:"_onInitAllProps"}, 7188 Plugin = _class("plugins." + propName.charAt(0).toUpperCase() + propName.substr(1) + "Plugin", 7189 function() { 7190 TweenPlugin.call(this, propName, priority); 7191 this._overwriteProps = overwriteProps || []; 7192 }, (config.global === true)), 7193 p = Plugin.prototype = new TweenPlugin(propName), 7194 prop; 7195 p.constructor = Plugin; 7196 Plugin.API = config.API; 7197 for (prop in map) { 7198 if (typeof(config[prop]) === "function") { 7199 p[map[prop]] = config[prop]; 7200 } 7201 } 7202 Plugin.version = config.version; 7203 TweenPlugin.activate([Plugin]); 7204 return Plugin; 7205 }; 7206 7207 7208 //now run through all the dependencies discovered and if any are missing, log that to the console as a warning. This is why it's best to have TweenLite load last - it can check all the dependencies for you. 7209 a = window._gsQueue; 7210 if (a) { 7211 for (i = 0; i < a.length; i++) { 7212 a[i](); 7213 } 7214 for (p in _defLookup) { 7215 if (!_defLookup[p].func) { 7216 window.console.log("GSAP encountered missing dependency: " + p); 7217 } 7218 } 7219 } 7220 7221 _tickerActive = false; //ensures that the first official animation forces a ticker.tick() to update the time when it is instantiated 7222 7223 return TweenLite; 7224 7225})(_gsScope, "TweenLite"); 7226/* harmony export (immutable) */ __webpack_exports__["TweenLite"] = TweenLite; 7227 7228 7229const gs = _gsScope.com.greensock; 7230 7231const SimpleTimeline = gs.core.SimpleTimeline; 7232/* harmony export (immutable) */ __webpack_exports__["SimpleTimeline"] = SimpleTimeline; 7233 7234const Animation = gs.core.Animation; 7235/* harmony export (immutable) */ __webpack_exports__["Animation"] = Animation; 7236 7237const Ease = _gsScope.Ease; 7238/* harmony export (immutable) */ __webpack_exports__["Ease"] = Ease; 7239 7240const Linear = _gsScope.Linear; 7241/* harmony export (immutable) */ __webpack_exports__["Linear"] = Linear; 7242 7243const Power0 = Linear; 7244/* harmony export (immutable) */ __webpack_exports__["Power0"] = Power0; 7245 7246const Power1 = _gsScope.Power1; 7247/* harmony export (immutable) */ __webpack_exports__["Power1"] = Power1; 7248 7249const Power2 = _gsScope.Power2; 7250/* harmony export (immutable) */ __webpack_exports__["Power2"] = Power2; 7251 7252const Power3 = _gsScope.Power3; 7253/* harmony export (immutable) */ __webpack_exports__["Power3"] = Power3; 7254 7255const Power4 = _gsScope.Power4; 7256/* harmony export (immutable) */ __webpack_exports__["Power4"] = Power4; 7257 7258const TweenPlugin = _gsScope.TweenPlugin; 7259/* harmony export (immutable) */ __webpack_exports__["TweenPlugin"] = TweenPlugin; 7260 7261const EventDispatcher = gs.events.EventDispatcher; 7262/* harmony export (immutable) */ __webpack_exports__["EventDispatcher"] = EventDispatcher; 7263 7264 7265/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(242)(module), __webpack_require__(12))) 7266 7267/***/ }), 7268/* 4 */ 7269/***/ (function(module, exports, __webpack_require__) { 7270 7271var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! 7272 * jQuery JavaScript Library v3.2.1 7273 * https://jquery.com/ 7274 * 7275 * Includes Sizzle.js 7276 * https://sizzlejs.com/ 7277 * 7278 * Copyright JS Foundation and other contributors 7279 * Released under the MIT license 7280 * https://jquery.org/license 7281 * 7282 * Date: 2017-03-20T18:59Z 7283 */ 7284( function( global, factory ) { 7285 7286 "use strict"; 7287 7288 if ( typeof module === "object" && typeof module.exports === "object" ) { 7289 7290 // For CommonJS and CommonJS-like environments where a proper `window` 7291 // is present, execute the factory and get jQuery. 7292 // For environments that do not have a `window` with a `document` 7293 // (such as Node.js), expose a factory as module.exports. 7294 // This accentuates the need for the creation of a real `window`. 7295 // e.g. var jQuery = require("jquery")(window); 7296 // See ticket #14549 for more info. 7297 module.exports = global.document ? 7298 factory( global, true ) : 7299 function( w ) { 7300 if ( !w.document ) { 7301 throw new Error( "jQuery requires a window with a document" ); 7302 } 7303 return factory( w ); 7304 }; 7305 } else { 7306 factory( global ); 7307 } 7308 7309// Pass this if window is not defined yet 7310} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) { 7311 7312// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1 7313// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode 7314// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), str
vendor: 11,277 bytes, lines 7314-7801
7314ict mode should be common 7315// enough that all such attempts are guarded in a try block. 7316"use strict"; 7317 7318var arr = []; 7319 7320var document = window.document; 7321 7322var getProto = Object.getPrototypeOf; 7323 7324var slice = arr.slice; 7325 7326var concat = arr.concat; 7327 7328var push = arr.push; 7329 7330var indexOf = arr.indexOf; 7331 7332var class2type = {}; 7333 7334var toString = class2type.toString; 7335 7336var hasOwn = class2type.hasOwnProperty; 7337 7338var fnToString = hasOwn.toString; 7339 7340var ObjectFunctionString = fnToString.call( Object ); 7341 7342var support = {}; 7343 7344 7345 7346 function DOMEval( code, doc ) { 7347 doc = doc || document; 7348 7349 var script = doc.createElement( "script" ); 7350 7351 script.text = code; 7352 doc.head.appendChild( script ).parentNode.removeChild( script ); 7353 } 7354/* global Symbol */ 7355// Defining this global in .eslintrc.json would create a danger of using the global 7356// unguarded in another place, it seems safer to define global only for this module 7357 7358 7359 7360var 7361 version = "3.2.1", 7362 7363 // Define a local copy of jQuery 7364 jQuery = function( selector, context ) { 7365 7366 // The jQuery object is actually just the init constructor 'enhanced' 7367 // Need init if jQuery is called (just allow error to be thrown if not included) 7368 return new jQuery.fn.init( selector, context ); 7369 }, 7370 7371 // Support: Android <=4.0 only 7372 // Make sure we trim BOM and NBSP 7373 rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, 7374 7375 // Matches dashed string for camelizing 7376 rmsPrefix = /^-ms-/, 7377 rdashAlpha = /-([a-z])/g, 7378 7379 // Used by jQuery.camelCase as callback to replace() 7380 fcamelCase = function( all, letter ) { 7381 return letter.toUpperCase(); 7382 }; 7383 7384jQuery.fn = jQuery.prototype = { 7385 7386 // The current version of jQuery being used 7387 jquery: version, 7388 7389 constructor: jQuery, 7390 7391 // The default length of a jQuery object is 0 7392 length: 0, 7393 7394 toArray: function() { 7395 return slice.call( this ); 7396 }, 7397 7398 // Get the Nth element in the matched element set OR 7399 // Get the whole matched element set as a clean array 7400 get: function( num ) { 7401 7402 // Return all the elements in a clean array 7403 if ( num == null ) { 7404 return slice.call( this ); 7405 } 7406 7407 // Return just the one element from the set 7408 return num < 0 ? this[ num + this.length ] : this[ num ]; 7409 }, 7410 7411 // Take an array of elements and push it onto the stack 7412 // (returning the new matched element set) 7413 pushStack: function( elems ) { 7414 7415 // Build a new jQuery matched element set 7416 var ret = jQuery.merge( this.constructor(), elems ); 7417 7418 // Add the old object onto the stack (as a reference) 7419 ret.prevObject = this; 7420 7421 // Return the newly-formed element set 7422 return ret; 7423 }, 7424 7425 // Execute a callback for every element in the matched set. 7426 each: function( callback ) { 7427 return jQuery.each( this, callback ); 7428 }, 7429 7430 map: function( callback ) { 7431 return this.pushStack( jQuery.map( this, function( elem, i ) { 7432 return callback.call( elem, i, elem ); 7433 } ) ); 7434 }, 7435 7436 slice: function() { 7437 return this.pushStack( slice.apply( this, arguments ) ); 7438 }, 7439 7440 first: function() { 7441 return this.eq( 0 ); 7442 }, 7443 7444 last: function() { 7445 return this.eq( -1 ); 7446 }, 7447 7448 eq: function( i ) { 7449 var len = this.length, 7450 j = +i + ( i < 0 ? len : 0 ); 7451 return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] ); 7452 }, 7453 7454 end: function() { 7455 return this.prevObject || this.constructor(); 7456 }, 7457 7458 // For internal use only. 7459 // Behaves like an Array's method, not like a jQuery method. 7460 push: push, 7461 sort: arr.sort, 7462 splice: arr.splice 7463}; 7464 7465jQuery.extend = jQuery.fn.extend = function() { 7466 var options, name, src, copy, copyIsArray, clone, 7467 target = arguments[ 0 ] || {}, 7468 i = 1, 7469 length = arguments.length, 7470 deep = false; 7471 7472 // Handle a deep copy situation 7473 if ( typeof target === "boolean" ) { 7474 deep = target; 7475 7476 // Skip the boolean and the target 7477 target = arguments[ i ] || {}; 7478 i++; 7479 } 7480 7481 // Handle case when target is a string or something (possible in deep copy) 7482 if ( typeof target !== "object" && !jQuery.isFunction( target ) ) { 7483 target = {}; 7484 } 7485 7486 // Extend jQuery itself if only one argument is passed 7487 if ( i === length ) { 7488 target = this; 7489 i--; 7490 } 7491 7492 for ( ; i < length; i++ ) { 7493 7494 // Only deal with non-null/undefined values 7495 if ( ( options = arguments[ i ] ) != null ) { 7496 7497 // Extend the base object 7498 for ( name in options ) { 7499 src = target[ name ]; 7500 copy = options[ name ]; 7501 7502 // Prevent never-ending loop 7503 if ( target === copy ) { 7504 continue; 7505 } 7506 7507 // Recurse if we're merging plain objects or arrays 7508 if ( deep && copy && ( jQuery.isPlainObject( copy ) || 7509 ( copyIsArray = Array.isArray( copy ) ) ) ) { 7510 7511 if ( copyIsArray ) { 7512 copyIsArray = false; 7513 clone = src && Array.isArray( src ) ? src : []; 7514 7515 } else { 7516 clone = src && jQuery.isPlainObject( src ) ? src : {}; 7517 } 7518 7519 // Never move original objects, clone them 7520 target[ name ] = jQuery.extend( deep, clone, copy ); 7521 7522 // Don't bring in undefined values 7523 } else if ( copy !== undefined ) { 7524 target[ name ] = copy; 7525 } 7526 } 7527 } 7528 } 7529 7530 // Return the modified object 7531 return target; 7532}; 7533 7534jQuery.extend( { 7535 7536 // Unique for each copy of jQuery on the page 7537 expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ), 7538 7539 // Assume jQuery is ready without the ready module 7540 isReady: true, 7541 7542 error: function( msg ) { 7543 throw new Error( msg ); 7544 }, 7545 7546 noop: function() {}, 7547 7548 isFunction: function( obj ) { 7549 return jQuery.type( obj ) === "function"; 7550 }, 7551 7552 isWindow: function( obj ) { 7553 return obj != null && obj === obj.window; 7554 }, 7555 7556 isNumeric: function( obj ) { 7557 7558 // As of jQuery 3.0, isNumeric is limited to 7559 // strings and numbers (primitives or objects) 7560 // that can be coerced to finite numbers (gh-2662) 7561 var type = jQuery.type( obj ); 7562 return ( type === "number" || type === "string" ) && 7563 7564 // parseFloat NaNs numeric-cast false positives ("") 7565 // ...but misinterprets leading-number strings, particularly hex literals ("0x...") 7566 // subtraction forces infinities to NaN 7567 !isNaN( obj - parseFloat( obj ) ); 7568 }, 7569 7570 isPlainObject: function( obj ) { 7571 var proto, Ctor; 7572 7573 // Detect obvious negatives 7574 // Use toString instead of jQuery.type to catch host objects 7575 if ( !obj || toString.call( obj ) !== "[object Object]" ) { 7576 return false; 7577 } 7578 7579 proto = getProto( obj ); 7580 7581 // Objects with no prototype (e.g., `Object.create( null )`) are plain 7582 if ( !proto ) { 7583 return true; 7584 } 7585 7586 // Objects with prototype are plain iff they were constructed by a global Object function 7587 Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor; 7588 return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString; 7589 }, 7590 7591 isEmptyObject: function( obj ) { 7592 7593 /* eslint-disable no-unused-vars */ 7594 // See https://github.com/eslint/eslint/issues/6125 7595 var name; 7596 7597 for ( name in obj ) { 7598 return false; 7599 } 7600 return true; 7601 }, 7602 7603 type: function( obj ) { 7604 if ( obj == null ) { 7605 return obj + ""; 7606 } 7607 7608 // Support: Android <=2.3 only (functionish RegExp) 7609 return typeof obj === "object" || typeof obj === "function" ? 7610 class2type[ toString.call( obj ) ] || "object" : 7611 typeof obj; 7612 }, 7613 7614 // Evaluates a script in a global context 7615 globalEval: function( code ) { 7616 DOMEval( code ); 7617 }, 7618 7619 // Convert dashed to camelCase; used by the css and data modules 7620 // Support: IE <=9 - 11, Edge 12 - 13 7621 // Microsoft forgot to hump their vendor prefix (#9572) 7622 camelCase: function( string ) { 7623 return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); 7624 }, 7625 7626 each: function( obj, callback ) { 7627 var length, i = 0; 7628 7629 if ( isArrayLike( obj ) ) { 7630 length = obj.length; 7631 for ( ; i < length; i++ ) { 7632 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { 7633 break; 7634 } 7635 } 7636 } else { 7637 for ( i in obj ) { 7638 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { 7639 break; 7640 } 7641 } 7642 } 7643 7644 return obj; 7645 }, 7646 7647 // Support: Android <=4.0 only 7648 trim: function( text ) { 7649 return text == null ? 7650 "" : 7651 ( text + "" ).replace( rtrim, "" ); 7652 }, 7653 7654 // results is for internal usage only 7655 makeArray: function( arr, results ) { 7656 var ret = results || []; 7657 7658 if ( arr != null ) { 7659 if ( isArrayLike( Object( arr ) ) ) { 7660 jQuery.merge( ret, 7661 typeof arr === "string" ? 7662 [ arr ] : arr 7663 ); 7664 } else { 7665 push.call( ret, arr ); 7666 } 7667 } 7668 7669 return ret; 7670 }, 7671 7672 inArray: function( elem, arr, i ) { 7673 return arr == null ? -1 : indexOf.call( arr, elem, i ); 7674 }, 7675 7676 // Support: Android <=4.0 only, PhantomJS 1 only 7677 // push.apply(_, arraylike) throws on ancient WebKit 7678 merge: function( first, second ) { 7679 var len = +second.length, 7680 j = 0, 7681 i = first.length; 7682 7683 for ( ; j < len; j++ ) { 7684 first[ i++ ] = second[ j ]; 7685 } 7686 7687 first.length = i; 7688 7689 return first; 7690 }, 7691 7692 grep: function( elems, callback, invert ) { 7693 var callbackInverse, 7694 matches = [], 7695 i = 0, 7696 length = elems.length, 7697 callbackExpect = !invert; 7698 7699 // Go through the array, only saving the items 7700 // that pass the validator function 7701 for ( ; i < length; i++ ) { 7702 callbackInverse = !callback( elems[ i ], i ); 7703 if ( callbackInverse !== callbackExpect ) { 7704 matches.push( elems[ i ] ); 7705 } 7706 } 7707 7708 return matches; 7709 }, 7710 7711 // arg is for internal usage only 7712 map: function( elems, callback, arg ) { 7713 var length, value, 7714 i = 0, 7715 ret = []; 7716 7717 // Go through the array, translating each of the items to their new values 7718 if ( isArrayLike( elems ) ) { 7719 length = elems.length; 7720 for ( ; i < length; i++ ) { 7721 value = callback( elems[ i ], i, arg ); 7722 7723 if ( value != null ) { 7724 ret.push( value ); 7725 } 7726 } 7727 7728 // Go through every key on the object, 7729 } else { 7730 for ( i in elems ) { 7731 value = callback( elems[ i ], i, arg ); 7732 7733 if ( value != null ) { 7734 ret.push( value ); 7735 } 7736 } 7737 } 7738 7739 // Flatten any nested arrays 7740 return concat.apply( [], ret ); 7741 }, 7742 7743 // A global GUID counter for objects 7744 guid: 1, 7745 7746 // Bind a function to a context, optionally partially applying any 7747 // arguments. 7748 proxy: function( fn, context ) { 7749 var tmp, args, proxy; 7750 7751 if ( typeof context === "string" ) { 7752 tmp = fn[ context ]; 7753 context = fn; 7754 fn = tmp; 7755 } 7756 7757 // Quick check to determine if target is callable, in the spec 7758 // this throws a TypeError, but we will just return undefined. 7759 if ( !jQuery.isFunction( fn ) ) { 7760 return undefined; 7761 } 7762 7763 // Simulated bind 7764 args = slice.call( arguments, 2 ); 7765 proxy = function() { 7766 return fn.apply( context || this, args.concat( slice.call( arguments ) ) ); 7767 }; 7768 7769 // Set the guid of unique handler to the same of original handler, so it can be removed 7770 proxy.guid = fn.guid = fn.guid || jQuery.guid++; 7771 7772 return proxy; 7773 }, 7774 7775 now: Date.now, 7776 7777 // jQuery.support is not used in Core but other projects attach their 7778 // properties to it so it needs to exist. 7779 support: support 7780} ); 7781 7782if ( typeof Symbol === "function" ) { 7783 jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ]; 7784} 7785 7786// Populate the class2type map 7787jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ), 7788function( i, name ) { 7789 class2type[ "[object " + name + "]" ] = name.toLowerCase(); 7790} ); 7791 7792function isArrayLike( obj ) { 7793 7794 // Support: real iOS 8.2 only (not reproducible in simulator) 7795 // `in` check used to prevent JIT error (gh-2145) 7796 // hasOwn isn't used here due to false negatives 7797 // regarding Nodelist length in IE 7798 var length = !!obj && "length" in obj && obj.length, 7799 type = jQuery.type( obj ); 7800 7801 if ( type === "function" || jQuery.
vendor: 31,442 bytes, lines 7801-8898
7801isWindow( obj ) ) { 7802 return false; 7803 } 7804 7805 return type === "array" || length === 0 || 7806 typeof length === "number" && length > 0 && ( length - 1 ) in obj; 7807} 7808var Sizzle = 7809/*! 7810 * Sizzle CSS Selector Engine v2.3.3 7811 * https://sizzlejs.com/ 7812 * 7813 * Copyright jQuery Foundation and other contributors 7814 * Released under the MIT license 7815 * http://jquery.org/license 7816 * 7817 * Date: 2016-08-08 7818 */ 7819(function( window ) { 7820 7821var i, 7822 support, 7823 Expr, 7824 getText, 7825 isXML, 7826 tokenize, 7827 compile, 7828 select, 7829 outermostContext, 7830 sortInput, 7831 hasDuplicate, 7832 7833 // Local document vars 7834 setDocument, 7835 document, 7836 docElem, 7837 documentIsHTML, 7838 rbuggyQSA, 7839 rbuggyMatches, 7840 matches, 7841 contains, 7842 7843 // Instance-specific data 7844 expando = "sizzle" + 1 * new Date(), 7845 preferredDoc = window.document, 7846 dirruns = 0, 7847 done = 0, 7848 classCache = createCache(), 7849 tokenCache = createCache(), 7850 compilerCache = createCache(), 7851 sortOrder = function( a, b ) { 7852 if ( a === b ) { 7853 hasDuplicate = true; 7854 } 7855 return 0; 7856 }, 7857 7858 // Instance methods 7859 hasOwn = ({}).hasOwnProperty, 7860 arr = [], 7861 pop = arr.pop, 7862 push_native = arr.push, 7863 push = arr.push, 7864 slice = arr.slice, 7865 // Use a stripped-down indexOf as it's faster than native 7866 // https://jsperf.com/thor-indexof-vs-for/5 7867 indexOf = function( list, elem ) { 7868 var i = 0, 7869 len = list.length; 7870 for ( ; i < len; i++ ) { 7871 if ( list[i] === elem ) { 7872 return i; 7873 } 7874 } 7875 return -1; 7876 }, 7877 7878 booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", 7879 7880 // Regular expressions 7881 7882 // http://www.w3.org/TR/css3-selectors/#whitespace 7883 whitespace = "[\\x20\\t\\r\\n\\f]", 7884 7885 // http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier 7886 identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+", 7887 7888 // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors 7889 attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + 7890 // Operator (capture 2) 7891 "*([*^$|!~]?=)" + whitespace + 7892 // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]" 7893 "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + 7894 "*\\]", 7895 7896 pseudos = ":(" + identifier + ")(?:\\((" + 7897 // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments: 7898 // 1. quoted (capture 3; capture 4 or capture 5) 7899 "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + 7900 // 2. simple (capture 6) 7901 "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + 7902 // 3. anything else (capture 2) 7903 ".*" + 7904 ")\\)|)", 7905 7906 // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter 7907 rwhitespace = new RegExp( whitespace + "+", "g" ), 7908 rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ), 7909 7910 rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), 7911 rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ), 7912 7913 rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ), 7914 7915 rpseudo = new RegExp( pseudos ), 7916 ridentifier = new RegExp( "^" + identifier + "$" ), 7917 7918 matchExpr = { 7919 "ID": new RegExp( "^#(" + identifier + ")" ), 7920 "CLASS": new RegExp( "^\\.(" + identifier + ")" ), 7921 "TAG": new RegExp( "^(" + identifier + "|[*])" ), 7922 "ATTR": new RegExp( "^" + attributes ), 7923 "PSEUDO": new RegExp( "^" + pseudos ), 7924 "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + 7925 "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + 7926 "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), 7927 "bool": new RegExp( "^(?:" + booleans + ")$", "i" ), 7928 // For use in libraries implementing .is() 7929 // We use this for POS matching in `select` 7930 "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + 7931 whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) 7932 }, 7933 7934 rinputs = /^(?:input|select|textarea|button)$/i, 7935 rheader = /^h\d$/i, 7936 7937 rnative = /^[^{]+\{\s*\[native \w/, 7938 7939 // Easily-parseable/retrievable ID or TAG or CLASS selectors 7940 rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, 7941 7942 rsibling = /[+~]/, 7943 7944 // CSS escapes 7945 // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters 7946 runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ), 7947 funescape = function( _, escaped, escapedWhitespace ) { 7948 var high = "0x" + escaped - 0x10000; 7949 // NaN means non-codepoint 7950 // Support: Firefox<24 7951 // Workaround erroneous numeric interpretation of +"0x" 7952 return high !== high || escapedWhitespace ? 7953 escaped : 7954 high < 0 ? 7955 // BMP codepoint 7956 String.fromCharCode( high + 0x10000 ) : 7957 // Supplemental Plane codepoint (surrogate pair) 7958 String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); 7959 }, 7960 7961 // CSS string/identifier serialization 7962 // https://drafts.csswg.org/cssom/#common-serializing-idioms 7963 rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g, 7964 fcssescape = function( ch, asCodePoint ) { 7965 if ( asCodePoint ) { 7966 7967 // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER 7968 if ( ch === "\0" ) { 7969 return "\uFFFD"; 7970 } 7971 7972 // Control characters and (dependent upon position) numbers get escaped as code points 7973 return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " "; 7974 } 7975 7976 // Other potentially-special ASCII characters get backslash-escaped 7977 return "\\" + ch; 7978 }, 7979 7980 // Used for iframes 7981 // See setDocument() 7982 // Removing the function wrapper causes a "Permission Denied" 7983 // error in IE 7984 unloadHandler = function() { 7985 setDocument(); 7986 }, 7987 7988 disabledAncestor = addCombinator( 7989 function( elem ) { 7990 return elem.disabled === true && ("form" in elem || "label" in elem); 7991 }, 7992 { dir: "parentNode", next: "legend" } 7993 ); 7994 7995// Optimize for push.apply( _, NodeList ) 7996try { 7997 push.apply( 7998 (arr = slice.call( preferredDoc.childNodes )), 7999 preferredDoc.childNodes 8000 ); 8001 // Support: Android<4.0 8002 // Detect silently failing push.apply 8003 arr[ preferredDoc.childNodes.length ].nodeType; 8004} catch ( e ) { 8005 push = { apply: arr.length ? 8006 8007 // Leverage slice if possible 8008 function( target, els ) { 8009 push_native.apply( target, slice.call(els) ); 8010 } : 8011 8012 // Support: IE<9 8013 // Otherwise append directly 8014 function( target, els ) { 8015 var j = target.length, 8016 i = 0; 8017 // Can't trust NodeList.length 8018 while ( (target[j++] = els[i++]) ) {} 8019 target.length = j - 1; 8020 } 8021 }; 8022} 8023 8024function Sizzle( selector, context, results, seed ) { 8025 var m, i, elem, nid, match, groups, newSelector, 8026 newContext = context && context.ownerDocument, 8027 8028 // nodeType defaults to 9, since context defaults to document 8029 nodeType = context ? context.nodeType : 9; 8030 8031 results = results || []; 8032 8033 // Return early from calls with invalid selector or context 8034 if ( typeof selector !== "string" || !selector || 8035 nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) { 8036 8037 return results; 8038 } 8039 8040 // Try to shortcut find operations (as opposed to filters) in HTML documents 8041 if ( !seed ) { 8042 8043 if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) { 8044 setDocument( context ); 8045 } 8046 context = context || document; 8047 8048 if ( documentIsHTML ) { 8049 8050 // If the selector is sufficiently simple, try using a "get*By*" DOM method 8051 // (excepting DocumentFragment context, where the methods don't exist) 8052 if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) { 8053 8054 // ID selector 8055 if ( (m = match[1]) ) { 8056 8057 // Document context 8058 if ( nodeType === 9 ) { 8059 if ( (elem = context.getElementById( m )) ) { 8060 8061 // Support: IE, Opera, Webkit 8062 // TODO: identify versions 8063 // getElementById can match elements by name instead of ID 8064 if ( elem.id === m ) { 8065 results.push( elem ); 8066 return results; 8067 } 8068 } else { 8069 return results; 8070 } 8071 8072 // Element context 8073 } else { 8074 8075 // Support: IE, Opera, Webkit 8076 // TODO: identify versions 8077 // getElementById can match elements by name instead of ID 8078 if ( newContext && (elem = newContext.getElementById( m )) && 8079 contains( context, elem ) && 8080 elem.id === m ) { 8081 8082 results.push( elem ); 8083 return results; 8084 } 8085 } 8086 8087 // Type selector 8088 } else if ( match[2] ) { 8089 push.apply( results, context.getElementsByTagName( selector ) ); 8090 return results; 8091 8092 // Class selector 8093 } else if ( (m = match[3]) && support.getElementsByClassName && 8094 context.getElementsByClassName ) { 8095 8096 push.apply( results, context.getElementsByClassName( m ) ); 8097 return results; 8098 } 8099 } 8100 8101 // Take advantage of querySelectorAll 8102 if ( support.qsa && 8103 !compilerCache[ selector + " " ] && 8104 (!rbuggyQSA || !rbuggyQSA.test( selector )) ) { 8105 8106 if ( nodeType !== 1 ) { 8107 newContext = context; 8108 newSelector = selector; 8109 8110 // qSA looks outside Element context, which is not what we want 8111 // Thanks to Andrew Dupont for this workaround technique 8112 // Support: IE <=8 8113 // Exclude object elements 8114 } else if ( context.nodeName.toLowerCase() !== "object" ) { 8115 8116 // Capture the context ID, setting it first if necessary 8117 if ( (nid = context.getAttribute( "id" )) ) { 8118 nid = nid.replace( rcssescape, fcssescape ); 8119 } else { 8120 context.setAttribute( "id", (nid = expando) ); 8121 } 8122 8123 // Prefix every selector in the list 8124 groups = tokenize( selector ); 8125 i = groups.length; 8126 while ( i-- ) { 8127 groups[i] = "#" + nid + " " + toSelector( groups[i] ); 8128 } 8129 newSelector = groups.join( "," ); 8130 8131 // Expand context for sibling selectors 8132 newContext = rsibling.test( selector ) && testContext( context.parentNode ) || 8133 context; 8134 } 8135 8136 if ( newSelector ) { 8137 try { 8138 push.apply( results, 8139 newContext.querySelectorAll( newSelector ) 8140 ); 8141 return results; 8142 } catch ( qsaError ) { 8143 } finally { 8144 if ( nid === expando ) { 8145 context.removeAttribute( "id" ); 8146 } 8147 } 8148 } 8149 } 8150 } 8151 } 8152 8153 // All others 8154 return select( selector.replace( rtrim, "$1" ), context, results, seed ); 8155} 8156 8157/** 8158 * Create key-value caches of limited size 8159 * @returns {function(string, object)} Returns the Object data after storing it on itself with 8160 * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) 8161 * deleting the oldest entry 8162 */ 8163function createCache() { 8164 var keys = []; 8165 8166 function cache( key, value ) { 8167 // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) 8168 if ( keys.push( key + " " ) > Expr.cacheLength ) { 8169 // Only keep the most recent entries 8170 delete cache[ keys.shift() ]; 8171 } 8172 return (cache[ key + " " ] = value); 8173 } 8174 return cache; 8175} 8176 8177/** 8178 * Mark a function for special use by Sizzle 8179 * @param {Function} fn The function to mark 8180 */ 8181function markFunction( fn ) { 8182 fn[ expando ] = true; 8183 return fn; 8184} 8185 8186/** 8187 * Support testing using an element 8188 * @param {Function} fn Passed the created element and returns a boolean result 8189 */ 8190function assert( fn ) { 8191 var el = document.createElement("fieldset"); 8192 8193 try { 8194 return !!fn( el ); 8195 } catch (e) { 8196 return false; 8197 } finally { 8198 // Remove from its parent by default 8199 if ( el.parentNode ) { 8200 el.parentNode.removeChild( el ); 8201 } 8202 // release memory in IE 8203 el = null; 8204 } 8205} 8206 8207/** 8208 * Adds the same handler for all of the specified attrs 8209 * @param {String} attrs Pipe-separated list of attributes 8210 * @param {Function} handler The method that will be applied 8211 */ 8212function addHandle( attrs, handler ) { 8213 var arr = attrs.split("|"), 8214 i = arr.length; 8215 8216 while ( i-- ) { 8217 Expr.attrHandle[ arr[i] ] = handler; 8218 } 8219} 8220 8221/** 8222 * Checks document order of two siblings 8223 * @param {Element} a 8224 * @param {Element} b 8225 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b 8226 */ 8227function siblingCheck( a, b ) { 8228 var cur = b && a, 8229 diff = cur && a.nodeType === 1 && b.nodeType === 1 && 8230 a.sourceIndex - b.sourceIndex; 8231 8232 // Use IE sourceIndex if available on both nodes 8233 if ( diff ) { 8234 return diff; 8235 } 8236 8237 // Check if b follows a 8238 if ( cur ) { 8239 while ( (cur = cur.nextSibling) ) { 8240 if ( cur === b ) { 8241 return -1; 8242 } 8243 } 8244 } 8245 8246 return a ? 1 : -1; 8247} 8248 8249/** 8250 * Returns a function to use in pseudos for input types 8251 * @param {String} type 8252 */ 8253function createInputPseudo( type ) { 8254 return function( elem ) { 8255 var name = elem.nodeName.toLowerCase(); 8256 return name === "input" && elem.type === type; 8257 }; 8258} 8259 8260/** 8261 * Returns a function to use in pseudos for buttons 8262 * @param {String} type 8263 */ 8264function createButtonPseudo( type ) { 8265 return function( elem ) { 8266 var name = elem.nodeName.toLowerCase(); 8267 return (name === "input" || name === "button") && elem.type === type; 8268 }; 8269} 8270 8271/** 8272 * Returns a function to use in pseudos for :enabled/:disabled 8273 * @param {Boolean} disabled true for :disabled; false for :enabled 8274 */ 8275function createDisabledPseudo( disabled ) { 8276 8277 // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable 8278 return function( elem ) { 8279 8280 // Only certain elements can match :enabled or :disabled 8281 // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled 8282 // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled 8283 if ( "form" in elem ) { 8284 8285 // Check for inherited disabledness on relevant non-disabled elements: 8286 // * listed form-associated elements in a disabled fieldset 8287 // https://html.spec.whatwg.org/multipage/forms.html#category-listed 8288 // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled 8289 // * option elements in a disabled optgroup 8290 // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled 8291 // All such elements have a "form" property. 8292 if ( elem.parentNode && elem.disabled === false ) { 8293 8294 // Option elements defer to a parent optgroup if present 8295 if ( "label" in elem ) { 8296 if ( "label" in elem.parentNode ) { 8297 return elem.parentNode.disabled === disabled; 8298 } else { 8299 return elem.disabled === disabled; 8300 } 8301 } 8302 8303 // Support: IE 6 - 11 8304 // Use the isDisabled shortcut property to check for disabled fieldset ancestors 8305 return elem.isDisabled === disabled || 8306 8307 // Where there is no isDisabled, check manually 8308 /* jshint -W018 */ 8309 elem.isDisabled !== !disabled && 8310 disabledAncestor( elem ) === disabled; 8311 } 8312 8313 return elem.disabled === disabled; 8314 8315 // Try to winnow out elements that can't be disabled before trusting the disabled property. 8316 // Some victims get caught in our net (label, legend, menu, track), but it shouldn't 8317 // even exist on them, let alone have a boolean value. 8318 } else if ( "label" in elem ) { 8319 return elem.disabled === disabled; 8320 } 8321 8322 // Remaining elements are neither :enabled nor :disabled 8323 return false; 8324 }; 8325} 8326 8327/** 8328 * Returns a function to use in pseudos for positionals 8329 * @param {Function} fn 8330 */ 8331function createPositionalPseudo( fn ) { 8332 return markFunction(function( argument ) { 8333 argument = +argument; 8334 return markFunction(function( seed, matches ) { 8335 var j, 8336 matchIndexes = fn( [], seed.length, argument ), 8337 i = matchIndexes.length; 8338 8339 // Match elements found at the specified indexes 8340 while ( i-- ) { 8341 if ( seed[ (j = matchIndexes[i]) ] ) { 8342 seed[j] = !(matches[j] = seed[j]); 8343 } 8344 } 8345 }); 8346 }); 8347} 8348 8349/** 8350 * Checks a node for validity as a Sizzle context 8351 * @param {Element|Object=} context 8352 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value 8353 */ 8354function testContext( context ) { 8355 return context && typeof context.getElementsByTagName !== "undefined" && context; 8356} 8357 8358// Expose support vars for convenience 8359support = Sizzle.support = {}; 8360 8361/** 8362 * Detects XML nodes 8363 * @param {Element|Object} elem An element or a document 8364 * @returns {Boolean} True iff elem is a non-HTML XML node 8365 */ 8366isXML = Sizzle.isXML = function( elem ) { 8367 // documentElement is verified for cases where it doesn't yet exist 8368 // (such as loading iframes in IE - #4833) 8369 var documentElement = elem && (elem.ownerDocument || elem).documentElement; 8370 return documentElement ? documentElement.nodeName !== "HTML" : false; 8371}; 8372 8373/** 8374 * Sets document-related variables once based on the current document 8375 * @param {Element|Object} [doc] An element or document object to use to set the document 8376 * @returns {Object} Returns the current document 8377 */ 8378setDocument = Sizzle.setDocument = function( node ) { 8379 var hasCompare, subWindow, 8380 doc = node ? node.ownerDocument || node : preferredDoc; 8381 8382 // Return early if doc is invalid or already selected 8383 if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) { 8384 return document; 8385 } 8386 8387 // Update global variables 8388 document = doc; 8389 docElem = document.documentElement; 8390 documentIsHTML = !isXML( document ); 8391 8392 // Support: IE 9-11, Edge 8393 // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936) 8394 if ( preferredDoc !== document && 8395 (subWindow = document.defaultView) && subWindow.top !== subWindow ) { 8396 8397 // Support: IE 11, Edge 8398 if ( subWindow.addEventListener ) { 8399 subWindow.addEventListener( "unload", unloadHandler, false ); 8400 8401 // Support: IE 9 - 10 only 8402 } else if ( subWindow.attachEvent ) { 8403 subWindow.attachEvent( "onunload", unloadHandler ); 8404 } 8405 } 8406 8407 /* Attributes 8408 ---------------------------------------------------------------------- */ 8409 8410 // Support: IE<8 8411 // Verify that getAttribute really returns attributes and not properties 8412 // (excepting IE8 booleans) 8413 support.attributes = assert(function( el ) { 8414 el.className = "i"; 8415 return !el.getAttribute("className"); 8416 }); 8417 8418 /* getElement(s)By* 8419 ---------------------------------------------------------------------- */ 8420 8421 // Check if getElementsByTagName("*") returns only elements 8422 support.getElementsByTagName = assert(function( el ) { 8423 el.appendChild( document.createComment("") ); 8424 return !el.getElementsByTagName("*").length; 8425 }); 8426 8427 // Support: IE<9 8428 support.getElementsByClassName = rnative.test( document.getElementsByClassName ); 8429 8430 // Support: IE<10 8431 // Check if getElementById returns elements by name 8432 // The broken getElementById methods don't pick up programmatically-set names, 8433 // so use a roundabout getElementsByName test 8434 support.getById = assert(function( el ) { 8435 docElem.appendChild( el ).id = expando; 8436 return !document.getElementsByName || !document.getElementsByName( expando ).length; 8437 }); 8438 8439 // ID filter and find 8440 if ( support.getById ) { 8441 Expr.filter["ID"] = function( id ) { 8442 var attrId = id.replace( runescape, funescape ); 8443 return function( elem ) { 8444 return elem.getAttribute("id") === attrId; 8445 }; 8446 }; 8447 Expr.find["ID"] = function( id, context ) { 8448 if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { 8449 var elem = context.getElementById( id ); 8450 return elem ? [ elem ] : []; 8451 } 8452 }; 8453 } else { 8454 Expr.filter["ID"] = function( id ) { 8455 var attrId = id.replace( runescape, funescape ); 8456 return function( elem ) { 8457 var node = typeof elem.getAttributeNode !== "undefined" && 8458 elem.getAttributeNode("id"); 8459 return node && node.value === attrId; 8460 }; 8461 }; 8462 8463 // Support: IE 6 - 7 only 8464 // getElementById is not reliable as a find shortcut 8465 Expr.find["ID"] = function( id, context ) { 8466 if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { 8467 var node, i, elems, 8468 elem = context.getElementById( id ); 8469 8470 if ( elem ) { 8471 8472 // Verify the id attribute 8473 node = elem.getAttributeNode("id"); 8474 if ( node && node.value === id ) { 8475 return [ elem ]; 8476 } 8477 8478 // Fall back on getElementsByName 8479 elems = context.getElementsByName( id ); 8480 i = 0; 8481 while ( (elem = elems[i++]) ) { 8482 node = elem.getAttributeNode("id"); 8483 if ( node && node.value === id ) { 8484 return [ elem ]; 8485 } 8486 } 8487 } 8488 8489 return []; 8490 } 8491 }; 8492 } 8493 8494 // Tag 8495 Expr.find["TAG"] = support.getElementsByTagName ? 8496 function( tag, context ) { 8497 if ( typeof context.getElementsByTagName !== "undefined" ) { 8498 return context.getElementsByTagName( tag ); 8499 8500 // DocumentFragment nodes don't have gEBTN 8501 } else if ( support.qsa ) { 8502 return context.querySelectorAll( tag ); 8503 } 8504 } : 8505 8506 function( tag, context ) { 8507 var elem, 8508 tmp = [], 8509 i = 0, 8510 // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too 8511 results = context.getElementsByTagName( tag ); 8512 8513 // Filter out possible comments 8514 if ( tag === "*" ) { 8515 while ( (elem = results[i++]) ) { 8516 if ( elem.nodeType === 1 ) { 8517 tmp.push( elem ); 8518 } 8519 } 8520 8521 return tmp; 8522 } 8523 return results; 8524 }; 8525 8526 // Class 8527 Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) { 8528 if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) { 8529 return context.getElementsByClassName( className ); 8530 } 8531 }; 8532 8533 /* QSA/matchesSelector 8534 ---------------------------------------------------------------------- */ 8535 8536 // QSA and matchesSelector support 8537 8538 // matchesSelector(:active) reports false when true (IE9/Opera 11.5) 8539 rbuggyMatches = []; 8540 8541 // qSa(:focus) reports false when true (Chrome 21) 8542 // We allow this because of a bug in IE8/9 that throws an error 8543 // whenever `document.activeElement` is accessed on an iframe 8544 // So, we allow :focus to pass through QSA all the time to avoid the IE error 8545 // See https://bugs.jquery.com/ticket/13378 8546 rbuggyQSA = []; 8547 8548 if ( (support.qsa = rnative.test( document.querySelectorAll )) ) { 8549 // Build QSA regex 8550 // Regex strategy adopted from Diego Perini 8551 assert(function( el ) { 8552 // Select is set to empty string on purpose 8553 // This is to test IE's treatment of not explicitly 8554 // setting a boolean content attribute, 8555 // since its presence should be enough 8556 // https://bugs.jquery.com/ticket/12359 8557 docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" + 8558 "<select id='" + expando + "-\r\\' msallowcapture=''>" + 8559 "<option selected=''></option></select>"; 8560 8561 // Support: IE8, Opera 11-12.16 8562 // Nothing should be selected when empty strings follow ^= or $= or *= 8563 // The test attribute must be unknown in Opera but "safe" for WinRT 8564 // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section 8565 if ( el.querySelectorAll("[msallowcapture^='']").length ) { 8566 rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" ); 8567 } 8568 8569 // Support: IE8 8570 // Boolean attributes and "value" are not treated correctly 8571 if ( !el.querySelectorAll("[selected]").length ) { 8572 rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" ); 8573 } 8574 8575 // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+ 8576 if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) { 8577 rbuggyQSA.push("~="); 8578 } 8579 8580 // Webkit/Opera - :checked should return selected option elements 8581 // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked 8582 // IE8 throws error here and will not see later tests 8583 if ( !el.querySelectorAll(":checked").length ) { 8584 rbuggyQSA.push(":checked"); 8585 } 8586 8587 // Support: Safari 8+, iOS 8+ 8588 // https://bugs.webkit.org/show_bug.cgi?id=136851 8589 // In-page `selector#id sibling-combinator selector` fails 8590 if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) { 8591 rbuggyQSA.push(".#.+[+~]"); 8592 } 8593 }); 8594 8595 assert(function( el ) { 8596 el.innerHTML = "<a href='' disabled='disabled'></a>" + 8597 "<select disabled='disabled'><option/></select>"; 8598 8599 // Support: Windows 8 Native Apps 8600 // The type and name attributes are restricted during .innerHTML assignment 8601 var input = document.createElement("input"); 8602 input.setAttribute( "type", "hidden" ); 8603 el.appendChild( input ).setAttribute( "name", "D" ); 8604 8605 // Support: IE8 8606 // Enforce case-sensitivity of name attribute 8607 if ( el.querySelectorAll("[name=d]").length ) { 8608 rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" ); 8609 } 8610 8611 // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) 8612 // IE8 throws error here and will not see later tests 8613 if ( el.querySelectorAll(":enabled").length !== 2 ) { 8614 rbuggyQSA.push( ":enabled", ":disabled" ); 8615 } 8616 8617 // Support: IE9-11+ 8618 // IE's :disabled selector does not pick up the children of disabled fieldsets 8619 docElem.appendChild( el ).disabled = true; 8620 if ( el.querySelectorAll(":disabled").length !== 2 ) { 8621 rbuggyQSA.push( ":enabled", ":disabled" ); 8622 } 8623 8624 // Opera 10-11 does not throw on post-comma invalid pseudos 8625 el.querySelectorAll("*,:x"); 8626 rbuggyQSA.push(",.*:"); 8627 }); 8628 } 8629 8630 if ( (support.matchesSelector = rnative.test( (matches = docElem.matches || 8631 docElem.webkitMatchesSelector || 8632 docElem.mozMatchesSelector || 8633 docElem.oMatchesSelector || 8634 docElem.msMatchesSelector) )) ) { 8635 8636 assert(function( el ) { 8637 // Check to see if it's possible to do matchesSelector 8638 // on a disconnected node (IE 9) 8639 support.disconnectedMatch = matches.call( el, "*" ); 8640 8641 // This should fail with an exception 8642 // Gecko does not error, returns false instead 8643 matches.call( el, "[s!='']:x" ); 8644 rbuggyMatches.push( "!=", pseudos ); 8645 }); 8646 } 8647 8648 rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") ); 8649 rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") ); 8650 8651 /* Contains 8652 ---------------------------------------------------------------------- */ 8653 hasCompare = rnative.test( docElem.compareDocumentPosition ); 8654 8655 // Element contains another 8656 // Purposefully self-exclusive 8657 // As in, an element does not contain itself 8658 contains = hasCompare || rnative.test( docElem.contains ) ? 8659 function( a, b ) { 8660 var adown = a.nodeType === 9 ? a.documentElement : a, 8661 bup = b && b.parentNode; 8662 return a === bup || !!( bup && bup.nodeType === 1 && ( 8663 adown.contains ? 8664 adown.contains( bup ) : 8665 a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 8666 )); 8667 } : 8668 function( a, b ) { 8669 if ( b ) { 8670 while ( (b = b.parentNode) ) { 8671 if ( b === a ) { 8672 return true; 8673 } 8674 } 8675 } 8676 return false; 8677 }; 8678 8679 /* Sorting 8680 ---------------------------------------------------------------------- */ 8681 8682 // Document order sorting 8683 sortOrder = hasCompare ? 8684 function( a, b ) { 8685 8686 // Flag for duplicate removal 8687 if ( a === b ) { 8688 hasDuplicate = true; 8689 return 0; 8690 } 8691 8692 // Sort on method existence if only one input has compareDocumentPosition 8693 var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; 8694 if ( compare ) { 8695 return compare; 8696 } 8697 8698 // Calculate position if both inputs belong to the same document 8699 compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ? 8700 a.compareDocumentPosition( b ) : 8701 8702 // Otherwise we know they are disconnected 8703 1; 8704 8705 // Disconnected nodes 8706 if ( compare & 1 || 8707 (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) { 8708 8709 // Choose the first element that is related to our preferred document 8710 if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) { 8711 return -1; 8712 } 8713 if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) { 8714 return 1; 8715 } 8716 8717 // Maintain original order 8718 return sortInput ? 8719 ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : 8720 0; 8721 } 8722 8723 return compare & 4 ? -1 : 1; 8724 } : 8725 function( a, b ) { 8726 // Exit early if the nodes are identical 8727 if ( a === b ) { 8728 hasDuplicate = true; 8729 return 0; 8730 } 8731 8732 var cur, 8733 i = 0, 8734 aup = a.parentNode, 8735 bup = b.parentNode, 8736 ap = [ a ], 8737 bp = [ b ]; 8738 8739 // Parentless nodes are either documents or disconnected 8740 if ( !aup || !bup ) { 8741 return a === document ? -1 : 8742 b === document ? 1 : 8743 aup ? -1 : 8744 bup ? 1 : 8745 sortInput ? 8746 ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : 8747 0; 8748 8749 // If the nodes are siblings, we can do a quick check 8750 } else if ( aup === bup ) { 8751 return siblingCheck( a, b ); 8752 } 8753 8754 // Otherwise we need full lists of their ancestors for comparison 8755 cur = a; 8756 while ( (cur = cur.parentNode) ) { 8757 ap.unshift( cur ); 8758 } 8759 cur = b; 8760 while ( (cur = cur.parentNode) ) { 8761 bp.unshift( cur ); 8762 } 8763 8764 // Walk down the tree looking for a discrepancy 8765 while ( ap[i] === bp[i] ) { 8766 i++; 8767 } 8768 8769 return i ? 8770 // Do a sibling check if the nodes have a common ancestor 8771 siblingCheck( ap[i], bp[i] ) : 8772 8773 // Otherwise nodes in our document sort first 8774 ap[i] === preferredDoc ? -1 : 8775 bp[i] === preferredDoc ? 1 : 8776 0; 8777 }; 8778 8779 return document; 8780}; 8781 8782Sizzle.matches = function( expr, elements ) { 8783 return Sizzle( expr, null, null, elements ); 8784}; 8785 8786Sizzle.matchesSelector = function( elem, expr ) { 8787 // Set document vars if needed 8788 if ( ( elem.ownerDocument || elem ) !== document ) { 8789 setDocument( elem ); 8790 } 8791 8792 // Make sure that attribute selectors are quoted 8793 expr = expr.replace( rattributeQuotes, "='$1']" ); 8794 8795 if ( support.matchesSelector && documentIsHTML && 8796 !compilerCache[ expr + " " ] && 8797 ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) && 8798 ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) { 8799 8800 try { 8801 var ret = matches.call( elem, expr ); 8802 8803 // IE 9's matchesSelector returns false on disconnected nodes 8804 if ( ret || support.disconnectedMatch || 8805 // As well, disconnected nodes are said to be in a document 8806 // fragment in IE 9 8807 elem.document && elem.document.nodeType !== 11 ) { 8808 return ret; 8809 } 8810 } catch (e) {} 8811 } 8812 8813 return Sizzle( expr, document, null, [ elem ] ).length > 0; 8814}; 8815 8816Sizzle.contains = function( context, elem ) { 8817 // Set document vars if needed 8818 if ( ( context.ownerDocument || context ) !== document ) { 8819 setDocument( context ); 8820 } 8821 return contains( context, elem ); 8822}; 8823 8824Sizzle.attr = function( elem, name ) { 8825 // Set document vars if needed 8826 if ( ( elem.ownerDocument || elem ) !== document ) { 8827 setDocument( elem ); 8828 } 8829 8830 var fn = Expr.attrHandle[ name.toLowerCase() ], 8831 // Don't get fooled by Object.prototype properties (jQuery #13807) 8832 val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ? 8833 fn( elem, name, !documentIsHTML ) : 8834 undefined; 8835 8836 return val !== undefined ? 8837 val : 8838 support.attributes || !documentIsHTML ? 8839 elem.getAttribute( name ) : 8840 (val = elem.getAttributeNode(name)) && val.specified ? 8841 val.value : 8842 null; 8843}; 8844 8845Sizzle.escape = function( sel ) { 8846 return (sel + "").replace( rcssescape, fcssescape ); 8847}; 8848 8849Sizzle.error = function( msg ) { 8850 throw new Error( "Syntax error, unrecognized expression: " + msg ); 8851}; 8852 8853/** 8854 * Document sorting and removing duplicates 8855 * @param {ArrayLike} results 8856 */ 8857Sizzle.uniqueSort = function( results ) { 8858 var elem, 8859 duplicates = [], 8860 j = 0, 8861 i = 0; 8862 8863 // Unless we *know* we can detect duplicates, assume their presence 8864 hasDuplicate = !support.detectDuplicates; 8865 sortInput = !support.sortStable && results.slice( 0 ); 8866 results.sort( sortOrder ); 8867 8868 if ( hasDuplicate ) { 8869 while ( (elem = results[i++]) ) { 8870 if ( elem === results[ i ] ) { 8871 j = duplicates.push( i ); 8872 } 8873 } 8874 while ( j-- ) { 8875 results.splice( duplicates[ j ], 1 ); 8876 } 8877 } 8878 8879 // Clear input after sorting to release objects 8880 // See https://github.com/jquery/sizzle/pull/225 8881 sortInput = null; 8882 8883 return results; 8884}; 8885 8886/** 8887 * Utility function for retrieving the text value of an array of DOM nodes 8888 * @param {Array|Element} elem 8889 */ 8890getText = Sizzle.getText = function( elem ) { 8891 var node, 8892 ret = "", 8893 i = 0, 8894 nodeType = elem.nodeType; 8895 8896 if ( !nodeType ) { 8897 // If no nodeType, this is expected to be an array 8898 while ( (node = elem[i++]) ) {
vendor: 11,976 bytes, lines 8899-9297
8899 // Do not traverse comment nodes 8900 ret += getText( node ); 8901 } 8902 } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { 8903 // Use textContent for elements 8904 // innerText usage removed for consistency of new lines (jQuery #11153) 8905 if ( typeof elem.textContent === "string" ) { 8906 return elem.textContent; 8907 } else { 8908 // Traverse its children 8909 for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { 8910 ret += getText( elem ); 8911 } 8912 } 8913 } else if ( nodeType === 3 || nodeType === 4 ) { 8914 return elem.nodeValue; 8915 } 8916 // Do not include comment or processing instruction nodes 8917 8918 return ret; 8919}; 8920 8921Expr = Sizzle.selectors = { 8922 8923 // Can be adjusted by the user 8924 cacheLength: 50, 8925 8926 createPseudo: markFunction, 8927 8928 match: matchExpr, 8929 8930 attrHandle: {}, 8931 8932 find: {}, 8933 8934 relative: { 8935 ">": { dir: "parentNode", first: true }, 8936 " ": { dir: "parentNode" }, 8937 "+": { dir: "previousSibling", first: true }, 8938 "~": { dir: "previousSibling" } 8939 }, 8940 8941 preFilter: { 8942 "ATTR": function( match ) { 8943 match[1] = match[1].replace( runescape, funescape ); 8944 8945 // Move the given value to match[3] whether quoted or unquoted 8946 match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape ); 8947 8948 if ( match[2] === "~=" ) { 8949 match[3] = " " + match[3] + " "; 8950 } 8951 8952 return match.slice( 0, 4 ); 8953 }, 8954 8955 "CHILD": function( match ) { 8956 /* matches from matchExpr["CHILD"] 8957 1 type (only|nth|...) 8958 2 what (child|of-type) 8959 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) 8960 4 xn-component of xn+y argument ([+-]?\d*n|) 8961 5 sign of xn-component 8962 6 x of xn-component 8963 7 sign of y-component 8964 8 y of y-component 8965 */ 8966 match[1] = match[1].toLowerCase(); 8967 8968 if ( match[1].slice( 0, 3 ) === "nth" ) { 8969 // nth-* requires argument 8970 if ( !match[3] ) { 8971 Sizzle.error( match[0] ); 8972 } 8973 8974 // numeric x and y parameters for Expr.filter.CHILD 8975 // remember that false/true cast respectively to 0/1 8976 match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) ); 8977 match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" ); 8978 8979 // other types prohibit arguments 8980 } else if ( match[3] ) { 8981 Sizzle.error( match[0] ); 8982 } 8983 8984 return match; 8985 }, 8986 8987 "PSEUDO": function( match ) { 8988 var excess, 8989 unquoted = !match[6] && match[2]; 8990 8991 if ( matchExpr["CHILD"].test( match[0] ) ) { 8992 return null; 8993 } 8994 8995 // Accept quoted arguments as-is 8996 if ( match[3] ) { 8997 match[2] = match[4] || match[5] || ""; 8998 8999 // Strip excess characters from unquoted arguments 9000 } else if ( unquoted && rpseudo.test( unquoted ) && 9001 // Get excess from tokenize (recursively) 9002 (excess = tokenize( unquoted, true )) && 9003 // advance to the next closing parenthesis 9004 (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) { 9005 9006 // excess is a negative index 9007 match[0] = match[0].slice( 0, excess ); 9008 match[2] = unquoted.slice( 0, excess ); 9009 } 9010 9011 // Return only captures needed by the pseudo filter method (type and argument) 9012 return match.slice( 0, 3 ); 9013 } 9014 }, 9015 9016 filter: { 9017 9018 "TAG": function( nodeNameSelector ) { 9019 var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase(); 9020 return nodeNameSelector === "*" ? 9021 function() { return true; } : 9022 function( elem ) { 9023 return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; 9024 }; 9025 }, 9026 9027 "CLASS": function( className ) { 9028 var pattern = classCache[ className + " " ]; 9029 9030 return pattern || 9031 (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) && 9032 classCache( className, function( elem ) { 9033 return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" ); 9034 }); 9035 }, 9036 9037 "ATTR": function( name, operator, check ) { 9038 return function( elem ) { 9039 var result = Sizzle.attr( elem, name ); 9040 9041 if ( result == null ) { 9042 return operator === "!="; 9043 } 9044 if ( !operator ) { 9045 return true; 9046 } 9047 9048 result += ""; 9049 9050 return operator === "=" ? result === check : 9051 operator === "!=" ? result !== check : 9052 operator === "^=" ? check && result.indexOf( check ) === 0 : 9053 operator === "*=" ? check && result.indexOf( check ) > -1 : 9054 operator === "$=" ? check && result.slice( -check.length ) === check : 9055 operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 : 9056 operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" : 9057 false; 9058 }; 9059 }, 9060 9061 "CHILD": function( type, what, argument, first, last ) { 9062 var simple = type.slice( 0, 3 ) !== "nth", 9063 forward = type.slice( -4 ) !== "last", 9064 ofType = what === "of-type"; 9065 9066 return first === 1 && last === 0 ? 9067 9068 // Shortcut for :nth-*(n) 9069 function( elem ) { 9070 return !!elem.parentNode; 9071 } : 9072 9073 function( elem, context, xml ) { 9074 var cache, uniqueCache, outerCache, node, nodeIndex, start, 9075 dir = simple !== forward ? "nextSibling" : "previousSibling", 9076 parent = elem.parentNode, 9077 name = ofType && elem.nodeName.toLowerCase(), 9078 useCache = !xml && !ofType, 9079 diff = false; 9080 9081 if ( parent ) { 9082 9083 // :(first|last|only)-(child|of-type) 9084 if ( simple ) { 9085 while ( dir ) { 9086 node = elem; 9087 while ( (node = node[ dir ]) ) { 9088 if ( ofType ? 9089 node.nodeName.toLowerCase() === name : 9090 node.nodeType === 1 ) { 9091 9092 return false; 9093 } 9094 } 9095 // Reverse direction for :only-* (if we haven't yet done so) 9096 start = dir = type === "only" && !start && "nextSibling"; 9097 } 9098 return true; 9099 } 9100 9101 start = [ forward ? parent.firstChild : parent.lastChild ]; 9102 9103 // non-xml :nth-child(...) stores cache data on `parent` 9104 if ( forward && useCache ) { 9105 9106 // Seek `elem` from a previously-cached index 9107 9108 // ...in a gzip-friendly way 9109 node = parent; 9110 outerCache = node[ expando ] || (node[ expando ] = {}); 9111 9112 // Support: IE <9 only 9113 // Defend against cloned attroperties (jQuery gh-1709) 9114 uniqueCache = outerCache[ node.uniqueID ] || 9115 (outerCache[ node.uniqueID ] = {}); 9116 9117 cache = uniqueCache[ type ] || []; 9118 nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; 9119 diff = nodeIndex && cache[ 2 ]; 9120 node = nodeIndex && parent.childNodes[ nodeIndex ]; 9121 9122 while ( (node = ++nodeIndex && node && node[ dir ] || 9123 9124 // Fallback to seeking `elem` from the start 9125 (diff = nodeIndex = 0) || start.pop()) ) { 9126 9127 // When found, cache indexes on `parent` and break 9128 if ( node.nodeType === 1 && ++diff && node === elem ) { 9129 uniqueCache[ type ] = [ dirruns, nodeIndex, diff ]; 9130 break; 9131 } 9132 } 9133 9134 } else { 9135 // Use previously-cached element index if available 9136 if ( useCache ) { 9137 // ...in a gzip-friendly way 9138 node = elem; 9139 outerCache = node[ expando ] || (node[ expando ] = {}); 9140 9141 // Support: IE <9 only 9142 // Defend against cloned attroperties (jQuery gh-1709) 9143 uniqueCache = outerCache[ node.uniqueID ] || 9144 (outerCache[ node.uniqueID ] = {}); 9145 9146 cache = uniqueCache[ type ] || []; 9147 nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; 9148 diff = nodeIndex; 9149 } 9150 9151 // xml :nth-child(...) 9152 // or :nth-last-child(...) or :nth(-last)?-of-type(...) 9153 if ( diff === false ) { 9154 // Use the same loop as above to seek `elem` from the start 9155 while ( (node = ++nodeIndex && node && node[ dir ] || 9156 (diff = nodeIndex = 0) || start.pop()) ) { 9157 9158 if ( ( ofType ? 9159 node.nodeName.toLowerCase() === name : 9160 node.nodeType === 1 ) && 9161 ++diff ) { 9162 9163 // Cache the index of each encountered element 9164 if ( useCache ) { 9165 outerCache = node[ expando ] || (node[ expando ] = {}); 9166 9167 // Support: IE <9 only 9168 // Defend against cloned attroperties (jQuery gh-1709) 9169 uniqueCache = outerCache[ node.uniqueID ] || 9170 (outerCache[ node.uniqueID ] = {}); 9171 9172 uniqueCache[ type ] = [ dirruns, diff ]; 9173 } 9174 9175 if ( node === elem ) { 9176 break; 9177 } 9178 } 9179 } 9180 } 9181 } 9182 9183 // Incorporate the offset, then check against cycle size 9184 diff -= last; 9185 return diff === first || ( diff % first === 0 && diff / first >= 0 ); 9186 } 9187 }; 9188 }, 9189 9190 "PSEUDO": function( pseudo, argument ) { 9191 // pseudo-class names are case-insensitive 9192 // http://www.w3.org/TR/selectors/#pseudo-classes 9193 // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters 9194 // Remember that setFilters inherits from pseudos 9195 var args, 9196 fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || 9197 Sizzle.error( "unsupported pseudo: " + pseudo ); 9198 9199 // The user may use createPseudo to indicate that 9200 // arguments are needed to create the filter function 9201 // just as Sizzle does 9202 if ( fn[ expando ] ) { 9203 return fn( argument ); 9204 } 9205 9206 // But maintain support for old signatures 9207 if ( fn.length > 1 ) { 9208 args = [ pseudo, pseudo, "", argument ]; 9209 return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? 9210 markFunction(function( seed, matches ) { 9211 var idx, 9212 matched = fn( seed, argument ), 9213 i = matched.length; 9214 while ( i-- ) { 9215 idx = indexOf( seed, matched[i] ); 9216 seed[ idx ] = !( matches[ idx ] = matched[i] ); 9217 } 9218 }) : 9219 function( elem ) { 9220 return fn( elem, 0, args ); 9221 }; 9222 } 9223 9224 return fn; 9225 } 9226 }, 9227 9228 pseudos: { 9229 // Potentially complex pseudos 9230 "not": markFunction(function( selector ) { 9231 // Trim the selector passed to compile 9232 // to avoid treating leading and trailing 9233 // spaces as combinators 9234 var input = [], 9235 results = [], 9236 matcher = compile( selector.replace( rtrim, "$1" ) ); 9237 9238 return matcher[ expando ] ? 9239 markFunction(function( seed, matches, context, xml ) { 9240 var elem, 9241 unmatched = matcher( seed, null, xml, [] ), 9242 i = seed.length; 9243 9244 // Match elements unmatched by `matcher` 9245 while ( i-- ) { 9246 if ( (elem = unmatched[i]) ) { 9247 seed[i] = !(matches[i] = elem); 9248 } 9249 } 9250 }) : 9251 function( elem, context, xml ) { 9252 input[0] = elem; 9253 matcher( input, null, xml, results ); 9254 // Don't keep the element (issue #299) 9255 input[0] = null; 9256 return !results.pop(); 9257 }; 9258 }), 9259 9260 "has": markFunction(function( selector ) { 9261 return function( elem ) { 9262 return Sizzle( selector, elem ).length > 0; 9263 }; 9264 }), 9265 9266 "contains": markFunction(function( text ) { 9267 text = text.replace( runescape, funescape ); 9268 return function( elem ) { 9269 return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1; 9270 }; 9271 }), 9272 9273 // "Whether an element is represented by a :lang() selector 9274 // is based solely on the element's language value 9275 // being equal to the identifier C, 9276 // or beginning with the identifier C immediately followed by "-". 9277 // The matching of C against the element's language value is performed case-insensitively. 9278 // The identifier C does not have to be a valid language name." 9279 // http://www.w3.org/TR/selectors/#lang-pseudo 9280 "lang": markFunction( function( lang ) { 9281 // lang value must be a valid identifier 9282 if ( !ridentifier.test(lang || "") ) { 9283 Sizzle.error( "unsupported lang: " + lang ); 9284 } 9285 lang = lang.replace( runescape, funescape ).toLowerCase(); 9286 return function( elem ) { 9287 var elemLang; 9288 do { 9289 if ( (elemLang = documentIsHTML ? 9290 elem.lang : 9291 elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) { 9292 9293 elemLang = elemLang.toLowerCase(); 9294 return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; 9295 } 9296 } while ( (elem = elem.parentNode) && elem.nodeType === 1 ); 9297 return false;
vendor: 22,724 bytes, lines 9298-10120
9298 }; 9299 }), 9300 9301 // Miscellaneous 9302 "target": function( elem ) { 9303 var hash = window.location && window.location.hash; 9304 return hash && hash.slice( 1 ) === elem.id; 9305 }, 9306 9307 "root": function( elem ) { 9308 return elem === docElem; 9309 }, 9310 9311 "focus": function( elem ) { 9312 return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex); 9313 }, 9314 9315 // Boolean properties 9316 "enabled": createDisabledPseudo( false ), 9317 "disabled": createDisabledPseudo( true ), 9318 9319 "checked": function( elem ) { 9320 // In CSS3, :checked should return both checked and selected elements 9321 // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked 9322 var nodeName = elem.nodeName.toLowerCase(); 9323 return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected); 9324 }, 9325 9326 "selected": function( elem ) { 9327 // Accessing this property makes selected-by-default 9328 // options in Safari work properly 9329 if ( elem.parentNode ) { 9330 elem.parentNode.selectedIndex; 9331 } 9332 9333 return elem.selected === true; 9334 }, 9335 9336 // Contents 9337 "empty": function( elem ) { 9338 // http://www.w3.org/TR/selectors/#empty-pseudo 9339 // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), 9340 // but not by others (comment: 8; processing instruction: 7; etc.) 9341 // nodeType < 6 works because attributes (2) do not appear as children 9342 for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { 9343 if ( elem.nodeType < 6 ) { 9344 return false; 9345 } 9346 } 9347 return true; 9348 }, 9349 9350 "parent": function( elem ) { 9351 return !Expr.pseudos["empty"]( elem ); 9352 }, 9353 9354 // Element/input types 9355 "header": function( elem ) { 9356 return rheader.test( elem.nodeName ); 9357 }, 9358 9359 "input": function( elem ) { 9360 return rinputs.test( elem.nodeName ); 9361 }, 9362 9363 "button": function( elem ) { 9364 var name = elem.nodeName.toLowerCase(); 9365 return name === "input" && elem.type === "button" || name === "button"; 9366 }, 9367 9368 "text": function( elem ) { 9369 var attr; 9370 return elem.nodeName.toLowerCase() === "input" && 9371 elem.type === "text" && 9372 9373 // Support: IE<8 9374 // New HTML5 attribute values (e.g., "search") appear with elem.type === "text" 9375 ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" ); 9376 }, 9377 9378 // Position-in-collection 9379 "first": createPositionalPseudo(function() { 9380 return [ 0 ]; 9381 }), 9382 9383 "last": createPositionalPseudo(function( matchIndexes, length ) { 9384 return [ length - 1 ]; 9385 }), 9386 9387 "eq": createPositionalPseudo(function( matchIndexes, length, argument ) { 9388 return [ argument < 0 ? argument + length : argument ]; 9389 }), 9390 9391 "even": createPositionalPseudo(function( matchIndexes, length ) { 9392 var i = 0; 9393 for ( ; i < length; i += 2 ) { 9394 matchIndexes.push( i ); 9395 } 9396 return matchIndexes; 9397 }), 9398 9399 "odd": createPositionalPseudo(function( matchIndexes, length ) { 9400 var i = 1; 9401 for ( ; i < length; i += 2 ) { 9402 matchIndexes.push( i ); 9403 } 9404 return matchIndexes; 9405 }), 9406 9407 "lt": createPositionalPseudo(function( matchIndexes, length, argument ) { 9408 var i = argument < 0 ? argument + length : argument; 9409 for ( ; --i >= 0; ) { 9410 matchIndexes.push( i ); 9411 } 9412 return matchIndexes; 9413 }), 9414 9415 "gt": createPositionalPseudo(function( matchIndexes, length, argument ) { 9416 var i = argument < 0 ? argument + length : argument; 9417 for ( ; ++i < length; ) { 9418 matchIndexes.push( i ); 9419 } 9420 return matchIndexes; 9421 }) 9422 } 9423}; 9424 9425Expr.pseudos["nth"] = Expr.pseudos["eq"]; 9426 9427// Add button/input type pseudos 9428for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { 9429 Expr.pseudos[ i ] = createInputPseudo( i ); 9430} 9431for ( i in { submit: true, reset: true } ) { 9432 Expr.pseudos[ i ] = createButtonPseudo( i ); 9433} 9434 9435// Easy API for creating new setFilters 9436function setFilters() {} 9437setFilters.prototype = Expr.filters = Expr.pseudos; 9438Expr.setFilters = new setFilters(); 9439 9440tokenize = Sizzle.tokenize = function( selector, parseOnly ) { 9441 var matched, match, tokens, type, 9442 soFar, groups, preFilters, 9443 cached = tokenCache[ selector + " " ]; 9444 9445 if ( cached ) { 9446 return parseOnly ? 0 : cached.slice( 0 ); 9447 } 9448 9449 soFar = selector; 9450 groups = []; 9451 preFilters = Expr.preFilter; 9452 9453 while ( soFar ) { 9454 9455 // Comma and first run 9456 if ( !matched || (match = rcomma.exec( soFar )) ) { 9457 if ( match ) { 9458 // Don't consume trailing commas as valid 9459 soFar = soFar.slice( match[0].length ) || soFar; 9460 } 9461 groups.push( (tokens = []) ); 9462 } 9463 9464 matched = false; 9465 9466 // Combinators 9467 if ( (match = rcombinators.exec( soFar )) ) { 9468 matched = match.shift(); 9469 tokens.push({ 9470 value: matched, 9471 // Cast descendant combinators to space 9472 type: match[0].replace( rtrim, " " ) 9473 }); 9474 soFar = soFar.slice( matched.length ); 9475 } 9476 9477 // Filters 9478 for ( type in Expr.filter ) { 9479 if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] || 9480 (match = preFilters[ type ]( match ))) ) { 9481 matched = match.shift(); 9482 tokens.push({ 9483 value: matched, 9484 type: type, 9485 matches: match 9486 }); 9487 soFar = soFar.slice( matched.length ); 9488 } 9489 } 9490 9491 if ( !matched ) { 9492 break; 9493 } 9494 } 9495 9496 // Return the length of the invalid excess 9497 // if we're just parsing 9498 // Otherwise, throw an error or return tokens 9499 return parseOnly ? 9500 soFar.length : 9501 soFar ? 9502 Sizzle.error( selector ) : 9503 // Cache the tokens 9504 tokenCache( selector, groups ).slice( 0 ); 9505}; 9506 9507function toSelector( tokens ) { 9508 var i = 0, 9509 len = tokens.length, 9510 selector = ""; 9511 for ( ; i < len; i++ ) { 9512 selector += tokens[i].value; 9513 } 9514 return selector; 9515} 9516 9517function addCombinator( matcher, combinator, base ) { 9518 var dir = combinator.dir, 9519 skip = combinator.next, 9520 key = skip || dir, 9521 checkNonElements = base && key === "parentNode", 9522 doneName = done++; 9523 9524 return combinator.first ? 9525 // Check against closest ancestor/preceding element 9526 function( elem, context, xml ) { 9527 while ( (elem = elem[ dir ]) ) { 9528 if ( elem.nodeType === 1 || checkNonElements ) { 9529 return matcher( elem, context, xml ); 9530 } 9531 } 9532 return false; 9533 } : 9534 9535 // Check against all ancestor/preceding elements 9536 function( elem, context, xml ) { 9537 var oldCache, uniqueCache, outerCache, 9538 newCache = [ dirruns, doneName ]; 9539 9540 // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching 9541 if ( xml ) { 9542 while ( (elem = elem[ dir ]) ) { 9543 if ( elem.nodeType === 1 || checkNonElements ) { 9544 if ( matcher( elem, context, xml ) ) { 9545 return true; 9546 } 9547 } 9548 } 9549 } else { 9550 while ( (elem = elem[ dir ]) ) { 9551 if ( elem.nodeType === 1 || checkNonElements ) { 9552 outerCache = elem[ expando ] || (elem[ expando ] = {}); 9553 9554 // Support: IE <9 only 9555 // Defend against cloned attroperties (jQuery gh-1709) 9556 uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {}); 9557 9558 if ( skip && skip === elem.nodeName.toLowerCase() ) { 9559 elem = elem[ dir ] || elem; 9560 } else if ( (oldCache = uniqueCache[ key ]) && 9561 oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) { 9562 9563 // Assign to newCache so results back-propagate to previous elements 9564 return (newCache[ 2 ] = oldCache[ 2 ]); 9565 } else { 9566 // Reuse newcache so results back-propagate to previous elements 9567 uniqueCache[ key ] = newCache; 9568 9569 // A match means we're done; a fail means we have to keep checking 9570 if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) { 9571 return true; 9572 } 9573 } 9574 } 9575 } 9576 } 9577 return false; 9578 }; 9579} 9580 9581function elementMatcher( matchers ) { 9582 return matchers.length > 1 ? 9583 function( elem, context, xml ) { 9584 var i = matchers.length; 9585 while ( i-- ) { 9586 if ( !matchers[i]( elem, context, xml ) ) { 9587 return false; 9588 } 9589 } 9590 return true; 9591 } : 9592 matchers[0]; 9593} 9594 9595function multipleContexts( selector, contexts, results ) { 9596 var i = 0, 9597 len = contexts.length; 9598 for ( ; i < len; i++ ) { 9599 Sizzle( selector, contexts[i], results ); 9600 } 9601 return results; 9602} 9603 9604function condense( unmatched, map, filter, context, xml ) { 9605 var elem, 9606 newUnmatched = [], 9607 i = 0, 9608 len = unmatched.length, 9609 mapped = map != null; 9610 9611 for ( ; i < len; i++ ) { 9612 if ( (elem = unmatched[i]) ) { 9613 if ( !filter || filter( elem, context, xml ) ) { 9614 newUnmatched.push( elem ); 9615 if ( mapped ) { 9616 map.push( i ); 9617 } 9618 } 9619 } 9620 } 9621 9622 return newUnmatched; 9623} 9624 9625function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { 9626 if ( postFilter && !postFilter[ expando ] ) { 9627 postFilter = setMatcher( postFilter ); 9628 } 9629 if ( postFinder && !postFinder[ expando ] ) { 9630 postFinder = setMatcher( postFinder, postSelector ); 9631 } 9632 return markFunction(function( seed, results, context, xml ) { 9633 var temp, i, elem, 9634 preMap = [], 9635 postMap = [], 9636 preexisting = results.length, 9637 9638 // Get initial elements from seed or context 9639 elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ), 9640 9641 // Prefilter to get matcher input, preserving a map for seed-results synchronization 9642 matcherIn = preFilter && ( seed || !selector ) ? 9643 condense( elems, preMap, preFilter, context, xml ) : 9644 elems, 9645 9646 matcherOut = matcher ? 9647 // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results, 9648 postFinder || ( seed ? preFilter : preexisting || postFilter ) ? 9649 9650 // ...intermediate processing is necessary 9651 [] : 9652 9653 // ...otherwise use results directly 9654 results : 9655 matcherIn; 9656 9657 // Find primary matches 9658 if ( matcher ) { 9659 matcher( matcherIn, matcherOut, context, xml ); 9660 } 9661 9662 // Apply postFilter 9663 if ( postFilter ) { 9664 temp = condense( matcherOut, postMap ); 9665 postFilter( temp, [], context, xml ); 9666 9667 // Un-match failing elements by moving them back to matcherIn 9668 i = temp.length; 9669 while ( i-- ) { 9670 if ( (elem = temp[i]) ) { 9671 matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem); 9672 } 9673 } 9674 } 9675 9676 if ( seed ) { 9677 if ( postFinder || preFilter ) { 9678 if ( postFinder ) { 9679 // Get the final matcherOut by condensing this intermediate into postFinder contexts 9680 temp = []; 9681 i = matcherOut.length; 9682 while ( i-- ) { 9683 if ( (elem = matcherOut[i]) ) { 9684 // Restore matcherIn since elem is not yet a final match 9685 temp.push( (matcherIn[i] = elem) ); 9686 } 9687 } 9688 postFinder( null, (matcherOut = []), temp, xml ); 9689 } 9690 9691 // Move matched elements from seed to results to keep them synchronized 9692 i = matcherOut.length; 9693 while ( i-- ) { 9694 if ( (elem = matcherOut[i]) && 9695 (temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) { 9696 9697 seed[temp] = !(results[temp] = elem); 9698 } 9699 } 9700 } 9701 9702 // Add elements to results, through postFinder if defined 9703 } else { 9704 matcherOut = condense( 9705 matcherOut === results ? 9706 matcherOut.splice( preexisting, matcherOut.length ) : 9707 matcherOut 9708 ); 9709 if ( postFinder ) { 9710 postFinder( null, results, matcherOut, xml ); 9711 } else { 9712 push.apply( results, matcherOut ); 9713 } 9714 } 9715 }); 9716} 9717 9718function matcherFromTokens( tokens ) { 9719 var checkContext, matcher, j, 9720 len = tokens.length, 9721 leadingRelative = Expr.relative[ tokens[0].type ], 9722 implicitRelative = leadingRelative || Expr.relative[" "], 9723 i = leadingRelative ? 1 : 0, 9724 9725 // The foundational matcher ensures that elements are reachable from top-level context(s) 9726 matchContext = addCombinator( function( elem ) { 9727 return elem === checkContext; 9728 }, implicitRelative, true ), 9729 matchAnyContext = addCombinator( function( elem ) { 9730 return indexOf( checkContext, elem ) > -1; 9731 }, implicitRelative, true ), 9732 matchers = [ function( elem, context, xml ) { 9733 var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || ( 9734 (checkContext = context).nodeType ? 9735 matchContext( elem, context, xml ) : 9736 matchAnyContext( elem, context, xml ) ); 9737 // Avoid hanging onto element (issue #299) 9738 checkContext = null; 9739 return ret; 9740 } ]; 9741 9742 for ( ; i < len; i++ ) { 9743 if ( (matcher = Expr.relative[ tokens[i].type ]) ) { 9744 matchers = [ addCombinator(elementMatcher( matchers ), matcher) ]; 9745 } else { 9746 matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches ); 9747 9748 // Return special upon seeing a positional matcher 9749 if ( matcher[ expando ] ) { 9750 // Find the next relative operator (if any) for proper handling 9751 j = ++i; 9752 for ( ; j < len; j++ ) { 9753 if ( Expr.relative[ tokens[j].type ] ) { 9754 break; 9755 } 9756 } 9757 return setMatcher( 9758 i > 1 && elementMatcher( matchers ), 9759 i > 1 && toSelector( 9760 // If the preceding token was a descendant combinator, insert an implicit any-element `*` 9761 tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" }) 9762 ).replace( rtrim, "$1" ), 9763 matcher, 9764 i < j && matcherFromTokens( tokens.slice( i, j ) ), 9765 j < len && matcherFromTokens( (tokens = tokens.slice( j )) ), 9766 j < len && toSelector( tokens ) 9767 ); 9768 } 9769 matchers.push( matcher ); 9770 } 9771 } 9772 9773 return elementMatcher( matchers ); 9774} 9775 9776function matcherFromGroupMatchers( elementMatchers, setMatchers ) { 9777 var bySet = setMatchers.length > 0, 9778 byElement = elementMatchers.length > 0, 9779 superMatcher = function( seed, context, xml, results, outermost ) { 9780 var elem, j, matcher, 9781 matchedCount = 0, 9782 i = "0", 9783 unmatched = seed && [], 9784 setMatched = [], 9785 contextBackup = outermostContext, 9786 // We must always have either seed elements or outermost context 9787 elems = seed || byElement && Expr.find["TAG"]( "*", outermost ), 9788 // Use integer dirruns iff this is the outermost matcher 9789 dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1), 9790 len = elems.length; 9791 9792 if ( outermost ) { 9793 outermostContext = context === document || context || outermost; 9794 } 9795 9796 // Add elements passing elementMatchers directly to results 9797 // Support: IE<9, Safari 9798 // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id 9799 for ( ; i !== len && (elem = elems[i]) != null; i++ ) { 9800 if ( byElement && elem ) { 9801 j = 0; 9802 if ( !context && elem.ownerDocument !== document ) { 9803 setDocument( elem ); 9804 xml = !documentIsHTML; 9805 } 9806 while ( (matcher = elementMatchers[j++]) ) { 9807 if ( matcher( elem, context || document, xml) ) { 9808 results.push( elem ); 9809 break; 9810 } 9811 } 9812 if ( outermost ) { 9813 dirruns = dirrunsUnique; 9814 } 9815 } 9816 9817 // Track unmatched elements for set filters 9818 if ( bySet ) { 9819 // They will have gone through all possible matchers 9820 if ( (elem = !matcher && elem) ) { 9821 matchedCount--; 9822 } 9823 9824 // Lengthen the array for every element, matched or not 9825 if ( seed ) { 9826 unmatched.push( elem ); 9827 } 9828 } 9829 } 9830 9831 // `i` is now the count of elements visited above, and adding it to `matchedCount` 9832 // makes the latter nonnegative. 9833 matchedCount += i; 9834 9835 // Apply set filters to unmatched elements 9836 // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount` 9837 // equals `i`), unless we didn't visit _any_ elements in the above loop because we have 9838 // no element matchers and no seed. 9839 // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that 9840 // case, which will result in a "00" `matchedCount` that differs from `i` but is also 9841 // numerically zero. 9842 if ( bySet && i !== matchedCount ) { 9843 j = 0; 9844 while ( (matcher = setMatchers[j++]) ) { 9845 matcher( unmatched, setMatched, context, xml ); 9846 } 9847 9848 if ( seed ) { 9849 // Reintegrate element matches to eliminate the need for sorting 9850 if ( matchedCount > 0 ) { 9851 while ( i-- ) { 9852 if ( !(unmatched[i] || setMatched[i]) ) { 9853 setMatched[i] = pop.call( results ); 9854 } 9855 } 9856 } 9857 9858 // Discard index placeholder values to get only actual matches 9859 setMatched = condense( setMatched ); 9860 } 9861 9862 // Add matches to results 9863 push.apply( results, setMatched ); 9864 9865 // Seedless set matches succeeding multiple successful matchers stipulate sorting 9866 if ( outermost && !seed && setMatched.length > 0 && 9867 ( matchedCount + setMatchers.length ) > 1 ) { 9868 9869 Sizzle.uniqueSort( results ); 9870 } 9871 } 9872 9873 // Override manipulation of globals by nested matchers 9874 if ( outermost ) { 9875 dirruns = dirrunsUnique; 9876 outermostContext = contextBackup; 9877 } 9878 9879 return unmatched; 9880 }; 9881 9882 return bySet ? 9883 markFunction( superMatcher ) : 9884 superMatcher; 9885} 9886 9887compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) { 9888 var i, 9889 setMatchers = [], 9890 elementMatchers = [], 9891 cached = compilerCache[ selector + " " ]; 9892 9893 if ( !cached ) { 9894 // Generate a function of recursive functions that can be used to check each element 9895 if ( !match ) { 9896 match = tokenize( selector ); 9897 } 9898 i = match.length; 9899 while ( i-- ) { 9900 cached = matcherFromTokens( match[i] ); 9901 if ( cached[ expando ] ) { 9902 setMatchers.push( cached ); 9903 } else { 9904 elementMatchers.push( cached ); 9905 } 9906 } 9907 9908 // Cache the compiled function 9909 cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) ); 9910 9911 // Save selector and tokenization 9912 cached.selector = selector; 9913 } 9914 return cached; 9915}; 9916 9917/** 9918 * A low-level selection function that works with Sizzle's compiled 9919 * selector functions 9920 * @param {String|Function} selector A selector or a pre-compiled 9921 * selector function built with Sizzle.compile 9922 * @param {Element} context 9923 * @param {Array} [results] 9924 * @param {Array} [seed] A set of elements to match against 9925 */ 9926select = Sizzle.select = function( selector, context, results, seed ) { 9927 var i, tokens, token, type, find, 9928 compiled = typeof selector === "function" && selector, 9929 match = !seed && tokenize( (selector = compiled.selector || selector) ); 9930 9931 results = results || []; 9932 9933 // Try to minimize operations if there is only one selector in the list and no seed 9934 // (the latter of which guarantees us context) 9935 if ( match.length === 1 ) { 9936 9937 // Reduce context if the leading compound selector is an ID 9938 tokens = match[0] = match[0].slice( 0 ); 9939 if ( tokens.length > 2 && (token = tokens[0]).type === "ID" && 9940 context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) { 9941 9942 context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0]; 9943 if ( !context ) { 9944 return results; 9945 9946 // Precompiled matchers will still verify ancestry, so step up a level 9947 } else if ( compiled ) { 9948 context = context.parentNode; 9949 } 9950 9951 selector = selector.slice( tokens.shift().value.length ); 9952 } 9953 9954 // Fetch a seed set for right-to-left matching 9955 i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length; 9956 while ( i-- ) { 9957 token = tokens[i]; 9958 9959 // Abort if we hit a combinator 9960 if ( Expr.relative[ (type = token.type) ] ) { 9961 break; 9962 } 9963 if ( (find = Expr.find[ type ]) ) { 9964 // Search, expanding context for leading sibling combinators 9965 if ( (seed = find( 9966 token.matches[0].replace( runescape, funescape ), 9967 rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context 9968 )) ) { 9969 9970 // If seed is empty or no tokens remain, we can return early 9971 tokens.splice( i, 1 ); 9972 selector = seed.length && toSelector( tokens ); 9973 if ( !selector ) { 9974 push.apply( results, seed ); 9975 return results; 9976 } 9977 9978 break; 9979 } 9980 } 9981 } 9982 } 9983 9984 // Compile and execute a filtering function if one is not provided 9985 // Provide `match` to avoid retokenization if we modified the selector above 9986 ( compiled || compile( selector, match ) )( 9987 seed, 9988 context, 9989 !documentIsHTML, 9990 results, 9991 !context || rsibling.test( selector ) && testContext( context.parentNode ) || context 9992 ); 9993 return results; 9994}; 9995 9996// One-time assignments 9997 9998// Sort stability 9999support.sortStable = expando.split("").sort( sortOrder ).join("") === expando; 10000 10001// Support: Chrome 14-35+ 10002// Always assume duplicates if they aren't passed to the comparison function 10003support.detectDuplicates = !!hasDuplicate; 10004 10005// Initialize against the default document 10006setDocument(); 10007 10008// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27) 10009// Detached nodes confoundingly follow *each other* 10010support.sortDetached = assert(function( el ) { 10011 // Should return 1, but returns 4 (following) 10012 return el.compareDocumentPosition( document.createElement("fieldset") ) & 1; 10013}); 10014 10015// Support: IE<8 10016// Prevent attribute/property "interpolation" 10017// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx 10018if ( !assert(function( el ) { 10019 el.innerHTML = "<a href='#'></a>"; 10020 return el.firstChild.getAttribute("href") === "#" ; 10021}) ) { 10022 addHandle( "type|href|height|width", function( elem, name, isXML ) { 10023 if ( !isXML ) { 10024 return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 ); 10025 } 10026 }); 10027} 10028 10029// Support: IE<9 10030// Use defaultValue in place of getAttribute("value") 10031if ( !support.attributes || !assert(function( el ) { 10032 el.innerHTML = "<input/>"; 10033 el.firstChild.setAttribute( "value", "" ); 10034 return el.firstChild.getAttribute( "value" ) === ""; 10035}) ) { 10036 addHandle( "value", function( elem, name, isXML ) { 10037 if ( !isXML && elem.nodeName.toLowerCase() === "input" ) { 10038 return elem.defaultValue; 10039 } 10040 }); 10041} 10042 10043// Support: IE<9 10044// Use getAttributeNode to fetch booleans when getAttribute lies 10045if ( !assert(function( el ) { 10046 return el.getAttribute("disabled") == null; 10047}) ) { 10048 addHandle( booleans, function( elem, name, isXML ) { 10049 var val; 10050 if ( !isXML ) { 10051 return elem[ name ] === true ? name.toLowerCase() : 10052 (val = elem.getAttributeNode( name )) && val.specified ? 10053 val.value : 10054 null; 10055 } 10056 }); 10057} 10058 10059return Sizzle; 10060 10061})( window ); 10062 10063 10064 10065jQuery.find = Sizzle; 10066jQuery.expr = Sizzle.selectors; 10067 10068// Deprecated 10069jQuery.expr[ ":" ] = jQuery.expr.pseudos; 10070jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort; 10071jQuery.text = Sizzle.getText; 10072jQuery.isXMLDoc = Sizzle.isXML; 10073jQuery.contains = Sizzle.contains; 10074jQuery.escapeSelector = Sizzle.escape; 10075 10076 10077 10078 10079var dir = function( elem, dir, until ) { 10080 var matched = [], 10081 truncate = until !== undefined; 10082 10083 while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) { 10084 if ( elem.nodeType === 1 ) { 10085 if ( truncate && jQuery( elem ).is( until ) ) { 10086 break; 10087 } 10088 matched.push( elem ); 10089 } 10090 } 10091 return matched; 10092}; 10093 10094 10095var siblings = function( n, elem ) { 10096 var matched = []; 10097 10098 for ( ; n; n = n.nextSibling ) { 10099 if ( n.nodeType === 1 && n !== elem ) { 10100 matched.push( n ); 10101 } 10102 } 10103 10104 return matched; 10105}; 10106 10107 10108var rneedsContext = jQuery.expr.match.needsContext; 10109 10110 10111 10112function nodeName( elem, name ) { 10113 10114 return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); 10115 10116}; 10117var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i ); 10118 10119 10120
vendor: 1,441 bytes, lines 10121-10169
10121var risSimple = /^.[^:#\[\.,]*$/; 10122 10123// Implement the identical functionality for filter and not 10124function winnow( elements, qualifier, not ) { 10125 if ( jQuery.isFunction( qualifier ) ) { 10126 return jQuery.grep( elements, function( elem, i ) { 10127 return !!qualifier.call( elem, i, elem ) !== not; 10128 } ); 10129 } 10130 10131 // Single element 10132 if ( qualifier.nodeType ) { 10133 return jQuery.grep( elements, function( elem ) { 10134 return ( elem === qualifier ) !== not; 10135 } ); 10136 } 10137 10138 // Arraylike of elements (jQuery, arguments, Array) 10139 if ( typeof qualifier !== "string" ) { 10140 return jQuery.grep( elements, function( elem ) { 10141 return ( indexOf.call( qualifier, elem ) > -1 ) !== not; 10142 } ); 10143 } 10144 10145 // Simple selector that can be filtered directly, removing non-Elements 10146 if ( risSimple.test( qualifier ) ) { 10147 return jQuery.filter( qualifier, elements, not ); 10148 } 10149 10150 // Complex selector, compare the two sets, removing non-Elements 10151 qualifier = jQuery.filter( qualifier, elements ); 10152 return jQuery.grep( elements, function( elem ) { 10153 return ( indexOf.call( qualifier, elem ) > -1 ) !== not && elem.nodeType === 1; 10154 } ); 10155} 10156 10157jQuery.filter = function( expr, elems, not ) { 10158 var elem = elems[ 0 ]; 10159 10160 if ( not ) { 10161 expr = ":not(" + expr + ")"; 10162 } 10163 10164 if ( elems.length === 1 && elem.nodeType === 1 ) { 10165 return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : []; 10166 } 10167 10168 return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) { 10169 return elem.nodeType === 1;
vendor: 4,831 bytes, lines 10170-10365
10170 } ) ); 10171}; 10172 10173jQuery.fn.extend( { 10174 find: function( selector ) { 10175 var i, ret, 10176 len = this.length, 10177 self = this; 10178 10179 if ( typeof selector !== "string" ) { 10180 return this.pushStack( jQuery( selector ).filter( function() { 10181 for ( i = 0; i < len; i++ ) { 10182 if ( jQuery.contains( self[ i ], this ) ) { 10183 return true; 10184 } 10185 } 10186 } ) ); 10187 } 10188 10189 ret = this.pushStack( [] ); 10190 10191 for ( i = 0; i < len; i++ ) { 10192 jQuery.find( selector, self[ i ], ret ); 10193 } 10194 10195 return len > 1 ? jQuery.uniqueSort( ret ) : ret; 10196 }, 10197 filter: function( selector ) { 10198 return this.pushStack( winnow( this, selector || [], false ) ); 10199 }, 10200 not: function( selector ) { 10201 return this.pushStack( winnow( this, selector || [], true ) ); 10202 }, 10203 is: function( selector ) { 10204 return !!winnow( 10205 this, 10206 10207 // If this is a positional/relative selector, check membership in the returned set 10208 // so $("p:first").is("p:last") won't return true for a doc with two "p". 10209 typeof selector === "string" && rneedsContext.test( selector ) ? 10210 jQuery( selector ) : 10211 selector || [], 10212 false 10213 ).length; 10214 } 10215} ); 10216 10217 10218// Initialize a jQuery object 10219 10220 10221// A central reference to the root jQuery(document) 10222var rootjQuery, 10223 10224 // A simple way to check for HTML strings 10225 // Prioritize #id over <tag> to avoid XSS via location.hash (#9521) 10226 // Strict HTML recognition (#11290: must start with <) 10227 // Shortcut simple #id case for speed 10228 rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, 10229 10230 init = jQuery.fn.init = function( selector, context, root ) { 10231 var match, elem; 10232 10233 // HANDLE: $(""), $(null), $(undefined), $(false) 10234 if ( !selector ) { 10235 return this; 10236 } 10237 10238 // Method init() accepts an alternate rootjQuery 10239 // so migrate can support jQuery.sub (gh-2101) 10240 root = root || rootjQuery; 10241 10242 // Handle HTML strings 10243 if ( typeof selector === "string" ) { 10244 if ( selector[ 0 ] === "<" && 10245 selector[ selector.length - 1 ] === ">" && 10246 selector.length >= 3 ) { 10247 10248 // Assume that strings that start and end with <> are HTML and skip the regex check 10249 match = [ null, selector, null ]; 10250 10251 } else { 10252 match = rquickExpr.exec( selector ); 10253 } 10254 10255 // Match html or make sure no context is specified for #id 10256 if ( match && ( match[ 1 ] || !context ) ) { 10257 10258 // HANDLE: $(html) -> $(array) 10259 if ( match[ 1 ] ) { 10260 context = context instanceof jQuery ? context[ 0 ] : context; 10261 10262 // Option to run scripts is true for back-compat 10263 // Intentionally let the error be thrown if parseHTML is not present 10264 jQuery.merge( this, jQuery.parseHTML( 10265 match[ 1 ], 10266 context && context.nodeType ? context.ownerDocument || context : document, 10267 true 10268 ) ); 10269 10270 // HANDLE: $(html, props) 10271 if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) { 10272 for ( match in context ) { 10273 10274 // Properties of context are called as methods if possible 10275 if ( jQuery.isFunction( this[ match ] ) ) { 10276 this[ match ]( context[ match ] ); 10277 10278 // ...and otherwise set as attributes 10279 } else { 10280 this.attr( match, context[ match ] ); 10281 } 10282 } 10283 } 10284 10285 return this; 10286 10287 // HANDLE: $(#id) 10288 } else { 10289 elem = document.getElementById( match[ 2 ] ); 10290 10291 if ( elem ) { 10292 10293 // Inject the element directly into the jQuery object 10294 this[ 0 ] = elem; 10295 this.length = 1; 10296 } 10297 return this; 10298 } 10299 10300 // HANDLE: $(expr, $(...)) 10301 } else if ( !context || context.jquery ) { 10302 return ( context || root ).find( selector ); 10303 10304 // HANDLE: $(expr, context) 10305 // (which is just equivalent to: $(context).find(expr) 10306 } else { 10307 return this.constructor( context ).find( selector ); 10308 } 10309 10310 // HANDLE: $(DOMElement) 10311 } else if ( selector.nodeType ) { 10312 this[ 0 ] = selector; 10313 this.length = 1; 10314 return this; 10315 10316 // HANDLE: $(function) 10317 // Shortcut for document ready 10318 } else if ( jQuery.isFunction( selector ) ) { 10319 return root.ready !== undefined ? 10320 root.ready( selector ) : 10321 10322 // Execute immediately if ready is not present 10323 selector( jQuery ); 10324 } 10325 10326 return jQuery.makeArray( selector, this ); 10327 }; 10328 10329// Give the init function the jQuery prototype for later instantiation 10330init.prototype = jQuery.fn; 10331 10332// Initialize central reference 10333rootjQuery = jQuery( document ); 10334 10335 10336var rparentsprev = /^(?:parents|prev(?:Until|All))/, 10337 10338 // Methods guaranteed to produce a unique set when starting from a unique set 10339 guaranteedUnique = { 10340 children: true, 10341 contents: true, 10342 next: true, 10343 prev: true 10344 }; 10345 10346jQuery.fn.extend( { 10347 has: function( target ) { 10348 var targets = jQuery( target, this ), 10349 l = targets.length; 10350 10351 return this.filter( function() { 10352 var i = 0; 10353 for ( ; i < l; i++ ) { 10354 if ( jQuery.contains( this, targets[ i ] ) ) { 10355 return true; 10356 } 10357 } 10358 } ); 10359 }, 10360 10361 closest: function( selectors, context ) { 10362 var cur, 10363 i = 0, 10364 l = this.length, 10365 matched = [],
vendor: 6,797 bytes, lines 10366-10633
10366 targets = typeof selectors !== "string" && jQuery( selectors ); 10367 10368 // Positional selectors never match, since there's no _selection_ context 10369 if ( !rneedsContext.test( selectors ) ) { 10370 for ( ; i < l; i++ ) { 10371 for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) { 10372 10373 // Always skip document fragments 10374 if ( cur.nodeType < 11 && ( targets ? 10375 targets.index( cur ) > -1 : 10376 10377 // Don't pass non-elements to Sizzle 10378 cur.nodeType === 1 && 10379 jQuery.find.matchesSelector( cur, selectors ) ) ) { 10380 10381 matched.push( cur ); 10382 break; 10383 } 10384 } 10385 } 10386 } 10387 10388 return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched ); 10389 }, 10390 10391 // Determine the position of an element within the set 10392 index: function( elem ) { 10393 10394 // No argument, return index in parent 10395 if ( !elem ) { 10396 return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1; 10397 } 10398 10399 // Index in selector 10400 if ( typeof elem === "string" ) { 10401 return indexOf.call( jQuery( elem ), this[ 0 ] ); 10402 } 10403 10404 // Locate the position of the desired element 10405 return indexOf.call( this, 10406 10407 // If it receives a jQuery object, the first element is used 10408 elem.jquery ? elem[ 0 ] : elem 10409 ); 10410 }, 10411 10412 add: function( selector, context ) { 10413 return this.pushStack( 10414 jQuery.uniqueSort( 10415 jQuery.merge( this.get(), jQuery( selector, context ) ) 10416 ) 10417 ); 10418 }, 10419 10420 addBack: function( selector ) { 10421 return this.add( selector == null ? 10422 this.prevObject : this.prevObject.filter( selector ) 10423 ); 10424 } 10425} ); 10426 10427function sibling( cur, dir ) { 10428 while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {} 10429 return cur; 10430} 10431 10432jQuery.each( { 10433 parent: function( elem ) { 10434 var parent = elem.parentNode; 10435 return parent && parent.nodeType !== 11 ? parent : null; 10436 }, 10437 parents: function( elem ) { 10438 return dir( elem, "parentNode" ); 10439 }, 10440 parentsUntil: function( elem, i, until ) { 10441 return dir( elem, "parentNode", until ); 10442 }, 10443 next: function( elem ) { 10444 return sibling( elem, "nextSibling" ); 10445 }, 10446 prev: function( elem ) { 10447 return sibling( elem, "previousSibling" ); 10448 }, 10449 nextAll: function( elem ) { 10450 return dir( elem, "nextSibling" ); 10451 }, 10452 prevAll: function( elem ) { 10453 return dir( elem, "previousSibling" ); 10454 }, 10455 nextUntil: function( elem, i, until ) { 10456 return dir( elem, "nextSibling", until ); 10457 }, 10458 prevUntil: function( elem, i, until ) { 10459 return dir( elem, "previousSibling", until ); 10460 }, 10461 siblings: function( elem ) { 10462 return siblings( ( elem.parentNode || {} ).firstChild, elem ); 10463 }, 10464 children: function( elem ) { 10465 return siblings( elem.firstChild ); 10466 }, 10467 contents: function( elem ) { 10468 if ( nodeName( elem, "iframe" ) ) { 10469 return elem.contentDocument; 10470 } 10471 10472 // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only 10473 // Treat the template element as a regular one in browsers that 10474 // don't support it. 10475 if ( nodeName( elem, "template" ) ) { 10476 elem = elem.content || elem; 10477 } 10478 10479 return jQuery.merge( [], elem.childNodes ); 10480 } 10481}, function( name, fn ) { 10482 jQuery.fn[ name ] = function( until, selector ) { 10483 var matched = jQuery.map( this, fn, until ); 10484 10485 if ( name.slice( -5 ) !== "Until" ) { 10486 selector = until; 10487 } 10488 10489 if ( selector && typeof selector === "string" ) { 10490 matched = jQuery.filter( selector, matched ); 10491 } 10492 10493 if ( this.length > 1 ) { 10494 10495 // Remove duplicates 10496 if ( !guaranteedUnique[ name ] ) { 10497 jQuery.uniqueSort( matched ); 10498 } 10499 10500 // Reverse order for parents* and prev-derivatives 10501 if ( rparentsprev.test( name ) ) { 10502 matched.reverse(); 10503 } 10504 } 10505 10506 return this.pushStack( matched ); 10507 }; 10508} ); 10509var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g ); 10510 10511 10512 10513// Convert String-formatted options into Object-formatted ones 10514function createOptions( options ) { 10515 var object = {}; 10516 jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) { 10517 object[ flag ] = true; 10518 } ); 10519 return object; 10520} 10521 10522/* 10523 * Create a callback list using the following parameters: 10524 * 10525 * options: an optional list of space-separated options that will change how 10526 * the callback list behaves or a more traditional option object 10527 * 10528 * By default a callback list will act like an event callback list and can be 10529 * "fired" multiple times. 10530 * 10531 * Possible options: 10532 * 10533 * once: will ensure the callback list can only be fired once (like a Deferred) 10534 * 10535 * memory: will keep track of previous values and will call any callback added 10536 * after the list has been fired right away with the latest "memorized" 10537 * values (like a Deferred) 10538 * 10539 * unique: will ensure a callback can only be added once (no duplicate in the list) 10540 * 10541 * stopOnFalse: interrupt callings when a callback returns false 10542 * 10543 */ 10544jQuery.Callbacks = function( options ) { 10545 10546 // Convert options from String-formatted to Object-formatted if needed 10547 // (we check in cache first) 10548 options = typeof options === "string" ? 10549 createOptions( options ) : 10550 jQuery.extend( {}, options ); 10551 10552 var // Flag to know if list is currently firing 10553 firing, 10554 10555 // Last fire value for non-forgettable lists 10556 memory, 10557 10558 // Flag to know if list was already fired 10559 fired, 10560 10561 // Flag to prevent firing 10562 locked, 10563 10564 // Actual callback list 10565 list = [], 10566 10567 // Queue of execution data for repeatable lists 10568 queue = [], 10569 10570 // Index of currently firing callback (modified by add/remove as needed) 10571 firingIndex = -1, 10572 10573 // Fire callbacks 10574 fire = function() { 10575 10576 // Enforce single-firing 10577 locked = locked || options.once; 10578 10579 // Execute callbacks for all pending executions, 10580 // respecting firingIndex overrides and runtime changes 10581 fired = firing = true; 10582 for ( ; queue.length; firingIndex = -1 ) { 10583 memory = queue.shift(); 10584 while ( ++firingIndex < list.length ) { 10585 10586 // Run callback and check for early termination 10587 if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false && 10588 options.stopOnFalse ) { 10589 10590 // Jump to end and forget the data so .add doesn't re-fire 10591 firingIndex = list.length; 10592 memory = false; 10593 } 10594 } 10595 } 10596 10597 // Forget the data if we're done with it 10598 if ( !options.memory ) { 10599 memory = false; 10600 } 10601 10602 firing = false; 10603 10604 // Clean up if we're done firing for good 10605 if ( locked ) { 10606 10607 // Keep an empty list if we have data for future add calls 10608 if ( memory ) { 10609 list = []; 10610 10611 // Otherwise, this object is spent 10612 } else { 10613 list = ""; 10614 } 10615 } 10616 }, 10617 10618 // Actual Callbacks object 10619 self = { 10620 10621 // Add a callback or a collection of callbacks to the list 10622 add: function() { 10623 if ( list ) { 10624 10625 // If we have memory from a past run, we should fire after adding 10626 if ( memory && !firing ) { 10627 firingIndex = list.length - 1; 10628 queue.push( memory ); 10629 } 10630 10631 ( function add( args ) { 10632 jQuery.each( args, function( _, arg ) { 10633 if (
vendor: 3,423 bytes, lines 10633-10775
10633jQuery.isFunction( arg ) ) { 10634 if ( !options.unique || !self.has( arg ) ) { 10635 list.push( arg ); 10636 } 10637 } else if ( arg && arg.length && jQuery.type( arg ) !== "string" ) { 10638 10639 // Inspect recursively 10640 add( arg ); 10641 } 10642 } ); 10643 } )( arguments ); 10644 10645 if ( memory && !firing ) { 10646 fire(); 10647 } 10648 } 10649 return this; 10650 }, 10651 10652 // Remove a callback from the list 10653 remove: function() { 10654 jQuery.each( arguments, function( _, arg ) { 10655 var index; 10656 while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { 10657 list.splice( index, 1 ); 10658 10659 // Handle firing indexes 10660 if ( index <= firingIndex ) { 10661 firingIndex--; 10662 } 10663 } 10664 } ); 10665 return this; 10666 }, 10667 10668 // Check if a given callback is in the list. 10669 // If no argument is given, return whether or not list has callbacks attached. 10670 has: function( fn ) { 10671 return fn ? 10672 jQuery.inArray( fn, list ) > -1 : 10673 list.length > 0; 10674 }, 10675 10676 // Remove all callbacks from the list 10677 empty: function() { 10678 if ( list ) { 10679 list = []; 10680 } 10681 return this; 10682 }, 10683 10684 // Disable .fire and .add 10685 // Abort any current/pending executions 10686 // Clear all callbacks and values 10687 disable: function() { 10688 locked = queue = []; 10689 list = memory = ""; 10690 return this; 10691 }, 10692 disabled: function() { 10693 return !list; 10694 }, 10695 10696 // Disable .fire 10697 // Also disable .add unless we have memory (since it would have no effect) 10698 // Abort any pending executions 10699 lock: function() { 10700 locked = queue = []; 10701 if ( !memory && !firing ) { 10702 list = memory = ""; 10703 } 10704 return this; 10705 }, 10706 locked: function() { 10707 return !!locked; 10708 }, 10709 10710 // Call all callbacks with the given context and arguments 10711 fireWith: function( context, args ) { 10712 if ( !locked ) { 10713 args = args || []; 10714 args = [ context, args.slice ? args.slice() : args ]; 10715 queue.push( args ); 10716 if ( !firing ) { 10717 fire(); 10718 } 10719 } 10720 return this; 10721 }, 10722 10723 // Call all the callbacks with the given arguments 10724 fire: function() { 10725 self.fireWith( this, arguments ); 10726 return this; 10727 }, 10728 10729 // To know if the callbacks have already been called at least once 10730 fired: function() { 10731 return !!fired; 10732 } 10733 }; 10734 10735 return self; 10736}; 10737 10738 10739function Identity( v ) { 10740 return v; 10741} 10742function Thrower( ex ) { 10743 throw ex; 10744} 10745 10746function adoptValue( value, resolve, reject, noValue ) { 10747 var method; 10748 10749 try { 10750 10751 // Check for promise aspect first to privilege synchronous behavior 10752 if ( value && jQuery.isFunction( ( method = value.promise ) ) ) { 10753 method.call( value ).done( resolve ).fail( reject ); 10754 10755 // Other thenables 10756 } else if ( value && jQuery.isFunction( ( method = value.then ) ) ) { 10757 method.call( value, resolve, reject ); 10758 10759 // Other non-thenables 10760 } else { 10761 10762 // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer: 10763 // * false: [ value ].slice( 0 ) => resolve( value ) 10764 // * true: [ value ].slice( 1 ) => resolve() 10765 resolve.apply( undefined, [ value ].slice( noValue ) ); 10766 } 10767 10768 // For Promises/A+, convert exceptions into rejections 10769 // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in 10770 // Deferred#then to conditionally suppress rejection. 10771 } catch ( value ) { 10772 10773 // Support: Android 4.0 only 10774 // Strict mode functions invoked without .call/.apply get global-object context 10775 reject.apply( undefined, [ value ]
vendor: 9,153 bytes, lines 10775-11100
10775 ); 10776 } 10777} 10778 10779jQuery.extend( { 10780 10781 Deferred: function( func ) { 10782 var tuples = [ 10783 10784 // action, add listener, callbacks, 10785 // ... .then handlers, argument index, [final state] 10786 [ "notify", "progress", jQuery.Callbacks( "memory" ), 10787 jQuery.Callbacks( "memory" ), 2 ], 10788 [ "resolve", "done", jQuery.Callbacks( "once memory" ), 10789 jQuery.Callbacks( "once memory" ), 0, "resolved" ], 10790 [ "reject", "fail", jQuery.Callbacks( "once memory" ), 10791 jQuery.Callbacks( "once memory" ), 1, "rejected" ] 10792 ], 10793 state = "pending", 10794 promise = { 10795 state: function() { 10796 return state; 10797 }, 10798 always: function() { 10799 deferred.done( arguments ).fail( arguments ); 10800 return this; 10801 }, 10802 "catch": function( fn ) { 10803 return promise.then( null, fn ); 10804 }, 10805 10806 // Keep pipe for back-compat 10807 pipe: function( /* fnDone, fnFail, fnProgress */ ) { 10808 var fns = arguments; 10809 10810 return jQuery.Deferred( function( newDefer ) { 10811 jQuery.each( tuples, function( i, tuple ) { 10812 10813 // Map tuples (progress, done, fail) to arguments (done, fail, progress) 10814 var fn = jQuery.isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ]; 10815 10816 // deferred.progress(function() { bind to newDefer or newDefer.notify }) 10817 // deferred.done(function() { bind to newDefer or newDefer.resolve }) 10818 // deferred.fail(function() { bind to newDefer or newDefer.reject }) 10819 deferred[ tuple[ 1 ] ]( function() { 10820 var returned = fn && fn.apply( this, arguments ); 10821 if ( returned && jQuery.isFunction( returned.promise ) ) { 10822 returned.promise() 10823 .progress( newDefer.notify ) 10824 .done( newDefer.resolve ) 10825 .fail( newDefer.reject ); 10826 } else { 10827 newDefer[ tuple[ 0 ] + "With" ]( 10828 this, 10829 fn ? [ returned ] : arguments 10830 ); 10831 } 10832 } ); 10833 } ); 10834 fns = null; 10835 } ).promise(); 10836 }, 10837 then: function( onFulfilled, onRejected, onProgress ) { 10838 var maxDepth = 0; 10839 function resolve( depth, deferred, handler, special ) { 10840 return function() { 10841 var that = this, 10842 args = arguments, 10843 mightThrow = function() { 10844 var returned, then; 10845 10846 // Support: Promises/A+ section 2.3.3.3.3 10847 // https://promisesaplus.com/#point-59 10848 // Ignore double-resolution attempts 10849 if ( depth < maxDepth ) { 10850 return; 10851 } 10852 10853 returned = handler.apply( that, args ); 10854 10855 // Support: Promises/A+ section 2.3.1 10856 // https://promisesaplus.com/#point-48 10857 if ( returned === deferred.promise() ) { 10858 throw new TypeError( "Thenable self-resolution" ); 10859 } 10860 10861 // Support: Promises/A+ sections 2.3.3.1, 3.5 10862 // https://promisesaplus.com/#point-54 10863 // https://promisesaplus.com/#point-75 10864 // Retrieve `then` only once 10865 then = returned && 10866 10867 // Support: Promises/A+ section 2.3.4 10868 // https://promisesaplus.com/#point-64 10869 // Only check objects and functions for thenability 10870 ( typeof returned === "object" || 10871 typeof returned === "function" ) && 10872 returned.then; 10873 10874 // Handle a returned thenable 10875 if ( jQuery.isFunction( then ) ) { 10876 10877 // Special processors (notify) just wait for resolution 10878 if ( special ) { 10879 then.call( 10880 returned, 10881 resolve( maxDepth, deferred, Identity, special ), 10882 resolve( maxDepth, deferred, Thrower, special ) 10883 ); 10884 10885 // Normal processors (resolve) also hook into progress 10886 } else { 10887 10888 // ...and disregard older resolution values 10889 maxDepth++; 10890 10891 then.call( 10892 returned, 10893 resolve( maxDepth, deferred, Identity, special ), 10894 resolve( maxDepth, deferred, Thrower, special ), 10895 resolve( maxDepth, deferred, Identity, 10896 deferred.notifyWith ) 10897 ); 10898 } 10899 10900 // Handle all other returned values 10901 } else { 10902 10903 // Only substitute handlers pass on context 10904 // and multiple values (non-spec behavior) 10905 if ( handler !== Identity ) { 10906 that = undefined; 10907 args = [ returned ]; 10908 } 10909 10910 // Process the value(s) 10911 // Default process is resolve 10912 ( special || deferred.resolveWith )( that, args ); 10913 } 10914 }, 10915 10916 // Only normal processors (resolve) catch and reject exceptions 10917 process = special ? 10918 mightThrow : 10919 function() { 10920 try { 10921 mightThrow(); 10922 } catch ( e ) { 10923 10924 if ( jQuery.Deferred.exceptionHook ) { 10925 jQuery.Deferred.exceptionHook( e, 10926 process.stackTrace ); 10927 } 10928 10929 // Support: Promises/A+ section 2.3.3.3.4.1 10930 // https://promisesaplus.com/#point-61 10931 // Ignore post-resolution exceptions 10932 if ( depth + 1 >= maxDepth ) { 10933 10934 // Only substitute handlers pass on context 10935 // and multiple values (non-spec behavior) 10936 if ( handler !== Thrower ) { 10937 that = undefined; 10938 args = [ e ]; 10939 } 10940 10941 deferred.rejectWith( that, args ); 10942 } 10943 } 10944 }; 10945 10946 // Support: Promises/A+ section 2.3.3.3.1 10947 // https://promisesaplus.com/#point-57 10948 // Re-resolve promises immediately to dodge false rejection from 10949 // subsequent errors 10950 if ( depth ) { 10951 process(); 10952 } else { 10953 10954 // Call an optional hook to record the stack, in case of exception 10955 // since it's otherwise lost when execution goes async 10956 if ( jQuery.Deferred.getStackHook ) { 10957 process.stackTrace = jQuery.Deferred.getStackHook(); 10958 } 10959 window.setTimeout( process ); 10960 } 10961 }; 10962 } 10963 10964 return jQuery.Deferred( function( newDefer ) { 10965 10966 // progress_handlers.add( ... ) 10967 tuples[ 0 ][ 3 ].add( 10968 resolve( 10969 0, 10970 newDefer, 10971 jQuery.isFunction( onProgress ) ? 10972 onProgress : 10973 Identity, 10974 newDefer.notifyWith 10975 ) 10976 ); 10977 10978 // fulfilled_handlers.add( ... ) 10979 tuples[ 1 ][ 3 ].add( 10980 resolve( 10981 0, 10982 newDefer, 10983 jQuery.isFunction( onFulfilled ) ? 10984 onFulfilled : 10985 Identity 10986 ) 10987 ); 10988 10989 // rejected_handlers.add( ... ) 10990 tuples[ 2 ][ 3 ].add( 10991 resolve( 10992 0, 10993 newDefer, 10994 jQuery.isFunction( onRejected ) ? 10995 onRejected : 10996 Thrower 10997 ) 10998 ); 10999 } ).promise(); 11000 }, 11001 11002 // Get a promise for this deferred 11003 // If obj is provided, the promise aspect is added to the object 11004 promise: function( obj ) { 11005 return obj != null ? jQuery.extend( obj, promise ) : promise; 11006 } 11007 }, 11008 deferred = {}; 11009 11010 // Add list-specific methods 11011 jQuery.each( tuples, function( i, tuple ) { 11012 var list = tuple[ 2 ], 11013 stateString = tuple[ 5 ]; 11014 11015 // promise.progress = list.add 11016 // promise.done = list.add 11017 // promise.fail = list.add 11018 promise[ tuple[ 1 ] ] = list.add; 11019 11020 // Handle state 11021 if ( stateString ) { 11022 list.add( 11023 function() { 11024 11025 // state = "resolved" (i.e., fulfilled) 11026 // state = "rejected" 11027 state = stateString; 11028 }, 11029 11030 // rejected_callbacks.disable 11031 // fulfilled_callbacks.disable 11032 tuples[ 3 - i ][ 2 ].disable, 11033 11034 // progress_callbacks.lock 11035 tuples[ 0 ][ 2 ].lock 11036 ); 11037 } 11038 11039 // progress_handlers.fire 11040 // fulfilled_handlers.fire 11041 // rejected_handlers.fire 11042 list.add( tuple[ 3 ].fire ); 11043 11044 // deferred.notify = function() { deferred.notifyWith(...) } 11045 // deferred.resolve = function() { deferred.resolveWith(...) } 11046 // deferred.reject = function() { deferred.rejectWith(...) } 11047 deferred[ tuple[ 0 ] ] = function() { 11048 deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments ); 11049 return this; 11050 }; 11051 11052 // deferred.notifyWith = list.fireWith 11053 // deferred.resolveWith = list.fireWith 11054 // deferred.rejectWith = list.fireWith 11055 deferred[ tuple[ 0 ] + "With" ] = list.fireWith; 11056 } ); 11057 11058 // Make the deferred a promise 11059 promise.promise( deferred ); 11060 11061 // Call given func if any 11062 if ( func ) { 11063 func.call( deferred, deferred ); 11064 } 11065 11066 // All done! 11067 return deferred; 11068 }, 11069 11070 // Deferred helper 11071 when: function( singleValue ) { 11072 var 11073 11074 // count of uncompleted subordinates 11075 remaining = arguments.length, 11076 11077 // count of unprocessed arguments 11078 i = remaining, 11079 11080 // subordinate fulfillment data 11081 resolveContexts = Array( i ), 11082 resolveValues = slice.call( arguments ), 11083 11084 // the master Deferred 11085 master = jQuery.Deferred(), 11086 11087 // subordinate callback factory 11088 updateFunc = function( i ) { 11089 return function( value ) { 11090 resolveContexts[ i ] = this; 11091 resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value; 11092 if ( !( --remaining ) ) { 11093 master.resolveWith( resolveContexts, resolveValues ); 11094 } 11095 }; 11096 }; 11097 11098 // Single- and empty arguments are adopted like Promise.resolve 11099 if ( remaining <= 1 ) { 11100 adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject
vendor: 2,079 bytes, lines 11100-11188
11100, 11101 !remaining ); 11102 11103 // Use .then() to unwrap secondary thenables (cf. gh-3000) 11104 if ( master.state() === "pending" || 11105 jQuery.isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) { 11106 11107 return master.then(); 11108 } 11109 } 11110 11111 // Multiple arguments are aggregated like Promise.all array elements 11112 while ( i-- ) { 11113 adoptValue( resolveValues[ i ], updateFunc( i ), master.reject ); 11114 } 11115 11116 return master.promise(); 11117 } 11118} ); 11119 11120 11121// These usually indicate a programmer mistake during development, 11122// warn about them ASAP rather than swallowing them by default. 11123var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/; 11124 11125jQuery.Deferred.exceptionHook = function( error, stack ) { 11126 11127 // Support: IE 8 - 9 only 11128 // Console exists when dev tools are open, which can happen at any time 11129 if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) { 11130 window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack ); 11131 } 11132}; 11133 11134 11135 11136 11137jQuery.readyException = function( error ) { 11138 window.setTimeout( function() { 11139 throw error; 11140 } ); 11141}; 11142 11143 11144 11145 11146// The deferred used on DOM ready 11147var readyList = jQuery.Deferred(); 11148 11149jQuery.fn.ready = function( fn ) { 11150 11151 readyList 11152 .then( fn ) 11153 11154 // Wrap jQuery.readyException in a function so that the lookup 11155 // happens at the time of error handling instead of callback 11156 // registration. 11157 .catch( function( error ) { 11158 jQuery.readyException( error ); 11159 } ); 11160 11161 return this; 11162}; 11163 11164jQuery.extend( { 11165 11166 // Is the DOM ready to be used? Set to true once it occurs. 11167 isReady: false, 11168 11169 // A counter to track how many items to wait for before 11170 // the ready event fires. See #6781 11171 readyWait: 1, 11172 11173 // Handle when the DOM is ready 11174 ready: function( wait ) { 11175 11176 // Abort if there are pending holds or we're already ready 11177 if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { 11178 return; 11179 } 11180 11181 // Remember that the DOM is ready 11182 jQuery.isReady = true; 11183 11184 // If a normal DOM Ready event fired, decrement, and wait if need be 11185 if ( wait !== true && --jQuery.readyWait > 0 ) { 11186 return; 11187 } 11188
vendor: 4,098 bytes, lines 11189-11370
11189 // If there are functions bound, to execute 11190 readyList.resolveWith( document, [ jQuery ] ); 11191 } 11192} ); 11193 11194jQuery.ready.then = readyList.then; 11195 11196// The ready event handler and self cleanup method 11197function completed() { 11198 document.removeEventListener( "DOMContentLoaded", completed ); 11199 window.removeEventListener( "load", completed ); 11200 jQuery.ready(); 11201} 11202 11203// Catch cases where $(document).ready() is called 11204// after the browser event has already occurred. 11205// Support: IE <=9 - 10 only 11206// Older IE sometimes signals "interactive" too soon 11207if ( document.readyState === "complete" || 11208 ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) { 11209 11210 // Handle it asynchronously to allow scripts the opportunity to delay ready 11211 window.setTimeout( jQuery.ready ); 11212 11213} else { 11214 11215 // Use the handy event callback 11216 document.addEventListener( "DOMContentLoaded", completed ); 11217 11218 // A fallback to window.onload, that will always work 11219 window.addEventListener( "load", completed ); 11220} 11221 11222 11223 11224 11225// Multifunctional method to get and set values of a collection 11226// The value/s can optionally be executed if it's a function 11227var access = function( elems, fn, key, value, chainable, emptyGet, raw ) { 11228 var i = 0, 11229 len = elems.length, 11230 bulk = key == null; 11231 11232 // Sets many values 11233 if ( jQuery.type( key ) === "object" ) { 11234 chainable = true; 11235 for ( i in key ) { 11236 access( elems, fn, i, key[ i ], true, emptyGet, raw ); 11237 } 11238 11239 // Sets one value 11240 } else if ( value !== undefined ) { 11241 chainable = true; 11242 11243 if ( !jQuery.isFunction( value ) ) { 11244 raw = true; 11245 } 11246 11247 if ( bulk ) { 11248 11249 // Bulk operations run against the entire set 11250 if ( raw ) { 11251 fn.call( elems, value ); 11252 fn = null; 11253 11254 // ...except when executing function values 11255 } else { 11256 bulk = fn; 11257 fn = function( elem, key, value ) { 11258 return bulk.call( jQuery( elem ), value ); 11259 }; 11260 } 11261 } 11262 11263 if ( fn ) { 11264 for ( ; i < len; i++ ) { 11265 fn( 11266 elems[ i ], key, raw ? 11267 value : 11268 value.call( elems[ i ], i, fn( elems[ i ], key ) ) 11269 ); 11270 } 11271 } 11272 } 11273 11274 if ( chainable ) { 11275 return elems; 11276 } 11277 11278 // Gets 11279 if ( bulk ) { 11280 return fn.call( elems ); 11281 } 11282 11283 return len ? fn( elems[ 0 ], key ) : emptyGet; 11284}; 11285var acceptData = function( owner ) { 11286 11287 // Accepts only: 11288 // - Node 11289 // - Node.ELEMENT_NODE 11290 // - Node.DOCUMENT_NODE 11291 // - Object 11292 // - Any 11293 return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType ); 11294}; 11295 11296 11297 11298 11299function Data() { 11300 this.expando = jQuery.expando + Data.uid++; 11301} 11302 11303Data.uid = 1; 11304 11305Data.prototype = { 11306 11307 cache: function( owner ) { 11308 11309 // Check if the owner object already has a cache 11310 var value = owner[ this.expando ]; 11311 11312 // If not, create one 11313 if ( !value ) { 11314 value = {}; 11315 11316 // We can accept data for non-element nodes in modern browsers, 11317 // but we should not, see #8335. 11318 // Always return an empty object. 11319 if ( acceptData( owner ) ) { 11320 11321 // If it is a node unlikely to be stringify-ed or looped over 11322 // use plain assignment 11323 if ( owner.nodeType ) { 11324 owner[ this.expando ] = value; 11325 11326 // Otherwise secure it in a non-enumerable property 11327 // configurable must be true to allow the property to be 11328 // deleted when data is removed 11329 } else { 11330 Object.defineProperty( owner, this.expando, { 11331 value: value, 11332 configurable: true 11333 } ); 11334 } 11335 } 11336 } 11337 11338 return value; 11339 }, 11340 set: function( owner, data, value ) { 11341 var prop, 11342 cache = this.cache( owner ); 11343 11344 // Handle: [ owner, key, value ] args 11345 // Always use camelCase key (gh-2257) 11346 if ( typeof data === "string" ) { 11347 cache[ jQuery.camelCase( data ) ] = value; 11348 11349 // Handle: [ owner, { properties } ] args 11350 } else { 11351 11352 // Copy the properties one-by-one to the cache object 11353 for ( prop in data ) { 11354 cache[ jQuery.camelCase( prop ) ] = data[ prop ]; 11355 } 11356 } 11357 return cache; 11358 }, 11359 get: function( owner, key ) { 11360 return key === undefined ? 11361 this.cache( owner ) : 11362 11363 // Always use camelCase key (gh-2257) 11364 owner[ this.expando ] && owner[ this.expando ][ jQuery.camelCase( key ) ]; 11365 }, 11366 access: function( owner, key, value ) { 11367 11368 // In cases where either: 11369 // 11370 // 1. No key was specified
vendor: 4,593 bytes, lines 11371-11554
11371 // 2. A string key was specified, but no value provided 11372 // 11373 // Take the "read" path and allow the get method to determine 11374 // which value to return, respectively either: 11375 // 11376 // 1. The entire cache object 11377 // 2. The data stored at the key 11378 // 11379 if ( key === undefined || 11380 ( ( key && typeof key === "string" ) && value === undefined ) ) { 11381 11382 return this.get( owner, key ); 11383 } 11384 11385 // When the key is not a string, or both a key and value 11386 // are specified, set or extend (existing objects) with either: 11387 // 11388 // 1. An object of properties 11389 // 2. A key and value 11390 // 11391 this.set( owner, key, value ); 11392 11393 // Since the "set" path can have two possible entry points 11394 // return the expected data based on which path was taken[*] 11395 return value !== undefined ? value : key; 11396 }, 11397 remove: function( owner, key ) { 11398 var i, 11399 cache = owner[ this.expando ]; 11400 11401 if ( cache === undefined ) { 11402 return; 11403 } 11404 11405 if ( key !== undefined ) { 11406 11407 // Support array or space separated string of keys 11408 if ( Array.isArray( key ) ) { 11409 11410 // If key is an array of keys... 11411 // We always set camelCase keys, so remove that. 11412 key = key.map( jQuery.camelCase ); 11413 } else { 11414 key = jQuery.camelCase( key ); 11415 11416 // If a key with the spaces exists, use it. 11417 // Otherwise, create an array by matching non-whitespace 11418 key = key in cache ? 11419 [ key ] : 11420 ( key.match( rnothtmlwhite ) || [] ); 11421 } 11422 11423 i = key.length; 11424 11425 while ( i-- ) { 11426 delete cache[ key[ i ] ]; 11427 } 11428 } 11429 11430 // Remove the expando if there's no more data 11431 if ( key === undefined || jQuery.isEmptyObject( cache ) ) { 11432 11433 // Support: Chrome <=35 - 45 11434 // Webkit & Blink performance suffers when deleting properties 11435 // from DOM nodes, so set to undefined instead 11436 // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted) 11437 if ( owner.nodeType ) { 11438 owner[ this.expando ] = undefined; 11439 } else { 11440 delete owner[ this.expando ]; 11441 } 11442 } 11443 }, 11444 hasData: function( owner ) { 11445 var cache = owner[ this.expando ]; 11446 return cache !== undefined && !jQuery.isEmptyObject( cache ); 11447 } 11448}; 11449var dataPriv = new Data(); 11450 11451var dataUser = new Data(); 11452 11453 11454 11455// Implementation Summary 11456// 11457// 1. Enforce API surface and semantic compatibility with 1.9.x branch 11458// 2. Improve the module's maintainability by reducing the storage 11459// paths to a single mechanism. 11460// 3. Use the same single mechanism to support "private" and "user" data. 11461// 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData) 11462// 5. Avoid exposing implementation details on user objects (eg. expando properties) 11463// 6. Provide a clear path for implementation upgrade to WeakMap in 2014 11464 11465var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, 11466 rmultiDash = /[A-Z]/g; 11467 11468function getData( data ) { 11469 if ( data === "true" ) { 11470 return true; 11471 } 11472 11473 if ( data === "false" ) { 11474 return false; 11475 } 11476 11477 if ( data === "null" ) { 11478 return null; 11479 } 11480 11481 // Only convert to a number if it doesn't change the string 11482 if ( data === +data + "" ) { 11483 return +data; 11484 } 11485 11486 if ( rbrace.test( data ) ) { 11487 return JSON.parse( data ); 11488 } 11489 11490 return data; 11491} 11492 11493function dataAttr( elem, key, data ) { 11494 var name; 11495 11496 // If nothing was found internally, try to fetch any 11497 // data from the HTML5 data-* attribute 11498 if ( data === undefined && elem.nodeType === 1 ) { 11499 name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase(); 11500 data = elem.getAttribute( name ); 11501 11502 if ( typeof data === "string" ) { 11503 try { 11504 data = getData( data ); 11505 } catch ( e ) {} 11506 11507 // Make sure we set the data so it isn't changed later 11508 dataUser.set( elem, key, data ); 11509 } else { 11510 data = undefined; 11511 } 11512 } 11513 return data; 11514} 11515 11516jQuery.extend( { 11517 hasData: function( elem ) { 11518 return dataUser.hasData( elem ) || dataPriv.hasData( elem ); 11519 }, 11520 11521 data: function( elem, name, data ) { 11522 return dataUser.access( elem, name, data ); 11523 }, 11524 11525 removeData: function( elem, name ) { 11526 dataUser.remove( elem, name ); 11527 }, 11528 11529 // TODO: Now that all calls to _data and _removeData have been replaced 11530 // with direct calls to dataPriv methods, these can be deprecated. 11531 _data: function( elem, name, data ) { 11532 return dataPriv.access( elem, name, data ); 11533 }, 11534 11535 _removeData: function( elem, name ) { 11536 dataPriv.remove( elem, name ); 11537 } 11538} ); 11539 11540jQuery.fn.extend( { 11541 data: function( key, value ) { 11542 var i, name, data, 11543 elem = this[ 0 ], 11544 attrs = elem && elem.attributes; 11545 11546 // Gets all values 11547 if ( key === undefined ) { 11548 if ( this.length ) { 11549 data = dataUser.get( elem ); 11550 11551 if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) { 11552 i = attrs.length; 11553 while ( i-- ) { 11554
vendor: 7,789 bytes, lines 11555-11877
11555 // Support: IE 11 only 11556 // The attrs elements can be null (#14894) 11557 if ( attrs[ i ] ) { 11558 name = attrs[ i ].name; 11559 if ( name.indexOf( "data-" ) === 0 ) { 11560 name = jQuery.camelCase( name.slice( 5 ) ); 11561 dataAttr( elem, name, data[ name ] ); 11562 } 11563 } 11564 } 11565 dataPriv.set( elem, "hasDataAttrs", true ); 11566 } 11567 } 11568 11569 return data; 11570 } 11571 11572 // Sets multiple values 11573 if ( typeof key === "object" ) { 11574 return this.each( function() { 11575 dataUser.set( this, key ); 11576 } ); 11577 } 11578 11579 return access( this, function( value ) { 11580 var data; 11581 11582 // The calling jQuery object (element matches) is not empty 11583 // (and therefore has an element appears at this[ 0 ]) and the 11584 // `value` parameter was not undefined. An empty jQuery object 11585 // will result in `undefined` for elem = this[ 0 ] which will 11586 // throw an exception if an attempt to read a data cache is made. 11587 if ( elem && value === undefined ) { 11588 11589 // Attempt to get data from the cache 11590 // The key will always be camelCased in Data 11591 data = dataUser.get( elem, key ); 11592 if ( data !== undefined ) { 11593 return data; 11594 } 11595 11596 // Attempt to "discover" the data in 11597 // HTML5 custom data-* attrs 11598 data = dataAttr( elem, key ); 11599 if ( data !== undefined ) { 11600 return data; 11601 } 11602 11603 // We tried really hard, but the data doesn't exist. 11604 return; 11605 } 11606 11607 // Set the data... 11608 this.each( function() { 11609 11610 // We always store the camelCased key 11611 dataUser.set( this, key, value ); 11612 } ); 11613 }, null, value, arguments.length > 1, null, true ); 11614 }, 11615 11616 removeData: function( key ) { 11617 return this.each( function() { 11618 dataUser.remove( this, key ); 11619 } ); 11620 } 11621} ); 11622 11623 11624jQuery.extend( { 11625 queue: function( elem, type, data ) { 11626 var queue; 11627 11628 if ( elem ) { 11629 type = ( type || "fx" ) + "queue"; 11630 queue = dataPriv.get( elem, type ); 11631 11632 // Speed up dequeue by getting out quickly if this is just a lookup 11633 if ( data ) { 11634 if ( !queue || Array.isArray( data ) ) { 11635 queue = dataPriv.access( elem, type, jQuery.makeArray( data ) ); 11636 } else { 11637 queue.push( data ); 11638 } 11639 } 11640 return queue || []; 11641 } 11642 }, 11643 11644 dequeue: function( elem, type ) { 11645 type = type || "fx"; 11646 11647 var queue = jQuery.queue( elem, type ), 11648 startLength = queue.length, 11649 fn = queue.shift(), 11650 hooks = jQuery._queueHooks( elem, type ), 11651 next = function() { 11652 jQuery.dequeue( elem, type ); 11653 }; 11654 11655 // If the fx queue is dequeued, always remove the progress sentinel 11656 if ( fn === "inprogress" ) { 11657 fn = queue.shift(); 11658 startLength--; 11659 } 11660 11661 if ( fn ) { 11662 11663 // Add a progress sentinel to prevent the fx queue from being 11664 // automatically dequeued 11665 if ( type === "fx" ) { 11666 queue.unshift( "inprogress" ); 11667 } 11668 11669 // Clear up the last queue stop function 11670 delete hooks.stop; 11671 fn.call( elem, next, hooks ); 11672 } 11673 11674 if ( !startLength && hooks ) { 11675 hooks.empty.fire(); 11676 } 11677 }, 11678 11679 // Not public - generate a queueHooks object, or return the current one 11680 _queueHooks: function( elem, type ) { 11681 var key = type + "queueHooks"; 11682 return dataPriv.get( elem, key ) || dataPriv.access( elem, key, { 11683 empty: jQuery.Callbacks( "once memory" ).add( function() { 11684 dataPriv.remove( elem, [ type + "queue", key ] ); 11685 } ) 11686 } ); 11687 } 11688} ); 11689 11690jQuery.fn.extend( { 11691 queue: function( type, data ) { 11692 var setter = 2; 11693 11694 if ( typeof type !== "string" ) { 11695 data = type; 11696 type = "fx"; 11697 setter--; 11698 } 11699 11700 if ( arguments.length < setter ) { 11701 return jQuery.queue( this[ 0 ], type ); 11702 } 11703 11704 return data === undefined ? 11705 this : 11706 this.each( function() { 11707 var queue = jQuery.queue( this, type, data ); 11708 11709 // Ensure a hooks for this queue 11710 jQuery._queueHooks( this, type ); 11711 11712 if ( type === "fx" && queue[ 0 ] !== "inprogress" ) { 11713 jQuery.dequeue( this, type ); 11714 } 11715 } ); 11716 }, 11717 dequeue: function( type ) { 11718 return this.each( function() { 11719 jQuery.dequeue( this, type ); 11720 } ); 11721 }, 11722 clearQueue: function( type ) { 11723 return this.queue( type || "fx", [] ); 11724 }, 11725 11726 // Get a promise resolved when queues of a certain type 11727 // are emptied (fx is the type by default) 11728 promise: function( type, obj ) { 11729 var tmp, 11730 count = 1, 11731 defer = jQuery.Deferred(), 11732 elements = this, 11733 i = this.length, 11734 resolve = function() { 11735 if ( !( --count ) ) { 11736 defer.resolveWith( elements, [ elements ] ); 11737 } 11738 }; 11739 11740 if ( typeof type !== "string" ) { 11741 obj = type; 11742 type = undefined; 11743 } 11744 type = type || "fx"; 11745 11746 while ( i-- ) { 11747 tmp = dataPriv.get( elements[ i ], type + "queueHooks" ); 11748 if ( tmp && tmp.empty ) { 11749 count++; 11750 tmp.empty.add( resolve ); 11751 } 11752 } 11753 resolve(); 11754 return defer.promise( obj ); 11755 } 11756} ); 11757var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source; 11758 11759var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ); 11760 11761 11762var cssExpand = [ "Top", "Right", "Bottom", "Left" ]; 11763 11764var isHiddenWithinTree = function( elem, el ) { 11765 11766 // isHiddenWithinTree might be called from jQuery#filter function; 11767 // in that case, element will be second argument 11768 elem = el || elem; 11769 11770 // Inline style trumps all 11771 return elem.style.display === "none" || 11772 elem.style.display === "" && 11773 11774 // Otherwise, check computed style 11775 // Support: Firefox <=43 - 45 11776 // Disconnected elements can have computed display: none, so first confirm that elem is 11777 // in the document. 11778 jQuery.contains( elem.ownerDocument, elem ) && 11779 11780 jQuery.css( elem, "display" ) === "none"; 11781 }; 11782 11783var swap = function( elem, options, callback, args ) { 11784 var ret, name, 11785 old = {}; 11786 11787 // Remember the old values, and insert the new ones 11788 for ( name in options ) { 11789 old[ name ] = elem.style[ name ]; 11790 elem.style[ name ] = options[ name ]; 11791 } 11792 11793 ret = callback.apply( elem, args || [] ); 11794 11795 // Revert the old values 11796 for ( name in options ) { 11797 elem.style[ name ] = old[ name ]; 11798 } 11799 11800 return ret; 11801}; 11802 11803 11804 11805 11806function adjustCSS( elem, prop, valueParts, tween ) { 11807 var adjusted, 11808 scale = 1, 11809 maxIterations = 20, 11810 currentValue = tween ? 11811 function() { 11812 return tween.cur(); 11813 } : 11814 function() { 11815 return jQuery.css( elem, prop, "" ); 11816 }, 11817 initial = currentValue(), 11818 unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ), 11819 11820 // Starting value computation is required for potential unit mismatches 11821 initialInUnit = ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) && 11822 rcssNum.exec( jQuery.css( elem, prop ) ); 11823 11824 if ( initialInUnit && initialInUnit[ 3 ] !== unit ) { 11825 11826 // Trust units reported by jQuery.css 11827 unit = unit || initialInUnit[ 3 ]; 11828 11829 // Make sure we update the tween properties later on 11830 valueParts = valueParts || []; 11831 11832 // Iteratively approximate from a nonzero starting point 11833 initialInUnit = +initial || 1; 11834 11835 do { 11836 11837 // If previous iteration zeroed out, double until we get *something*. 11838 // Use string for doubling so we don't accidentally see scale as unchanged below 11839 scale = scale || ".5"; 11840 11841 // Adjust and apply 11842 initialInUnit = initialInUnit / scale; 11843 jQuery.style( elem, prop, initialInUnit + unit ); 11844 11845 // Update scale, tolerating zero or NaN from tween.cur() 11846 // Break the loop if scale is unchanged or perfect, or if we've just had enough. 11847 } while ( 11848 scale !== ( scale = currentValue() / initial ) && scale !== 1 && --maxIterations 11849 ); 11850 } 11851 11852 if ( valueParts ) { 11853 initialInUnit = +initialInUnit || +initial || 0; 11854 11855 // Apply relative offset (+=/-=) if specified 11856 adjusted = valueParts[ 1 ] ? 11857 initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] : 11858 +valueParts[ 2 ]; 11859 if ( tween ) { 11860 tween.unit = unit; 11861 tween.start = initialInUnit; 11862 tween.end = adjusted; 11863 } 11864 } 11865 return adjusted; 11866} 11867 11868 11869var defaultDisplayMap = {}; 11870 11871function getDefaultDisplay( elem ) { 11872 var temp, 11873 doc = elem.ownerDocument, 11874 nodeName = elem.nodeName, 11875 display = defaultDisplayMap[ nodeName ]; 11876 11877 if ( display ) {
vendor: 4,001 bytes, lines 11878-12049
11878 return display; 11879 } 11880 11881 temp = doc.body.appendChild( doc.createElement( nodeName ) ); 11882 display = jQuery.css( temp, "display" ); 11883 11884 temp.parentNode.removeChild( temp ); 11885 11886 if ( display === "none" ) { 11887 display = "block"; 11888 } 11889 defaultDisplayMap[ nodeName ] = display; 11890 11891 return display; 11892} 11893 11894function showHide( elements, show ) { 11895 var display, elem, 11896 values = [], 11897 index = 0, 11898 length = elements.length; 11899 11900 // Determine new display value for elements that need to change 11901 for ( ; index < length; index++ ) { 11902 elem = elements[ index ]; 11903 if ( !elem.style ) { 11904 continue; 11905 } 11906 11907 display = elem.style.display; 11908 if ( show ) { 11909 11910 // Since we force visibility upon cascade-hidden elements, an immediate (and slow) 11911 // check is required in this first loop unless we have a nonempty display value (either 11912 // inline or about-to-be-restored) 11913 if ( display === "none" ) { 11914 values[ index ] = dataPriv.get( elem, "display" ) || null; 11915 if ( !values[ index ] ) { 11916 elem.style.display = ""; 11917 } 11918 } 11919 if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) { 11920 values[ index ] = getDefaultDisplay( elem ); 11921 } 11922 } else { 11923 if ( display !== "none" ) { 11924 values[ index ] = "none"; 11925 11926 // Remember what we're overwriting 11927 dataPriv.set( elem, "display", display ); 11928 } 11929 } 11930 } 11931 11932 // Set the display of the elements in a second loop to avoid constant reflow 11933 for ( index = 0; index < length; index++ ) { 11934 if ( values[ index ] != null ) { 11935 elements[ index ].style.display = values[ index ]; 11936 } 11937 } 11938 11939 return elements; 11940} 11941 11942jQuery.fn.extend( { 11943 show: function() { 11944 return showHide( this, true ); 11945 }, 11946 hide: function() { 11947 return showHide( this ); 11948 }, 11949 toggle: function( state ) { 11950 if ( typeof state === "boolean" ) { 11951 return state ? this.show() : this.hide(); 11952 } 11953 11954 return this.each( function() { 11955 if ( isHiddenWithinTree( this ) ) { 11956 jQuery( this ).show(); 11957 } else { 11958 jQuery( this ).hide(); 11959 } 11960 } ); 11961 } 11962} ); 11963var rcheckableType = ( /^(?:checkbox|radio)$/i ); 11964 11965var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]+)/i ); 11966 11967var rscriptType = ( /^$|\/(?:java|ecma)script/i ); 11968 11969 11970 11971// We have to close these tags to support XHTML (#13200) 11972var wrapMap = { 11973 11974 // Support: IE <=9 only 11975 option: [ 1, "<select multiple='multiple'>", "</select>" ], 11976 11977 // XHTML parsers do not magically insert elements in the 11978 // same way that tag soup parsers do. So we cannot shorten 11979 // this by omitting <tbody> or other required elements. 11980 thead: [ 1, "<table>", "</table>" ], 11981 col: [ 2, "<table><colgroup>", "</colgroup></table>" ], 11982 tr: [ 2, "<table><tbody>", "</tbody></table>" ], 11983 td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ], 11984 11985 _default: [ 0, "", "" ] 11986}; 11987 11988// Support: IE <=9 only 11989wrapMap.optgroup = wrapMap.option; 11990 11991wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; 11992wrapMap.th = wrapMap.td; 11993 11994 11995function getAll( context, tag ) { 11996 11997 // Support: IE <=9 - 11 only 11998 // Use typeof to avoid zero-argument method invocation on host objects (#15151) 11999 var ret; 12000 12001 if ( typeof context.getElementsByTagName !== "undefined" ) { 12002 ret = context.getElementsByTagName( tag || "*" ); 12003 12004 } else if ( typeof context.querySelectorAll !== "undefined" ) { 12005 ret = context.querySelectorAll( tag || "*" ); 12006 12007 } else { 12008 ret = []; 12009 } 12010 12011 if ( tag === undefined || tag && nodeName( context, tag ) ) { 12012 return jQuery.merge( [ context ], ret ); 12013 } 12014 12015 return ret; 12016} 12017 12018 12019// Mark scripts as having already been evaluated 12020function setGlobalEval( elems, refElements ) { 12021 var i = 0, 12022 l = elems.length; 12023 12024 for ( ; i < l; i++ ) { 12025 dataPriv.set( 12026 elems[ i ], 12027 "globalEval", 12028 !refElements || dataPriv.get( refElements[ i ], "globalEval" ) 12029 ); 12030 } 12031} 12032 12033 12034var rhtml = /<|&#?\w+;/; 12035 12036function buildFragment( elems, context, scripts, selection, ignored ) { 12037 var elem, tmp, tag, wrap, contains, j, 12038 fragment = context.createDocumentFragment(), 12039 nodes = [], 12040 i = 0, 12041 l = elems.length; 12042 12043 for ( ; i < l; i++ ) { 12044 elem = elems[ i ]; 12045 12046 if ( elem || elem === 0 ) { 12047 12048 // Add nodes directly 12049 if ( jQuery.t
vendor: 14,415 bytes, lines 12049-12559
12049ype( elem ) === "object" ) { 12050 12051 // Support: Android <=4.0 only, PhantomJS 1 only 12052 // push.apply(_, arraylike) throws on ancient WebKit 12053 jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem ); 12054 12055 // Convert non-html into a text node 12056 } else if ( !rhtml.test( elem ) ) { 12057 nodes.push( context.createTextNode( elem ) ); 12058 12059 // Convert html into DOM nodes 12060 } else { 12061 tmp = tmp || fragment.appendChild( context.createElement( "div" ) ); 12062 12063 // Deserialize a standard representation 12064 tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase(); 12065 wrap = wrapMap[ tag ] || wrapMap._default; 12066 tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ]; 12067 12068 // Descend through wrappers to the right content 12069 j = wrap[ 0 ]; 12070 while ( j-- ) { 12071 tmp = tmp.lastChild; 12072 } 12073 12074 // Support: Android <=4.0 only, PhantomJS 1 only 12075 // push.apply(_, arraylike) throws on ancient WebKit 12076 jQuery.merge( nodes, tmp.childNodes ); 12077 12078 // Remember the top-level container 12079 tmp = fragment.firstChild; 12080 12081 // Ensure the created nodes are orphaned (#12392) 12082 tmp.textContent = ""; 12083 } 12084 } 12085 } 12086 12087 // Remove wrapper from fragment 12088 fragment.textContent = ""; 12089 12090 i = 0; 12091 while ( ( elem = nodes[ i++ ] ) ) { 12092 12093 // Skip elements already in the context collection (trac-4087) 12094 if ( selection && jQuery.inArray( elem, selection ) > -1 ) { 12095 if ( ignored ) { 12096 ignored.push( elem ); 12097 } 12098 continue; 12099 } 12100 12101 contains = jQuery.contains( elem.ownerDocument, elem ); 12102 12103 // Append to fragment 12104 tmp = getAll( fragment.appendChild( elem ), "script" ); 12105 12106 // Preserve script evaluation history 12107 if ( contains ) { 12108 setGlobalEval( tmp ); 12109 } 12110 12111 // Capture executables 12112 if ( scripts ) { 12113 j = 0; 12114 while ( ( elem = tmp[ j++ ] ) ) { 12115 if ( rscriptType.test( elem.type || "" ) ) { 12116 scripts.push( elem ); 12117 } 12118 } 12119 } 12120 } 12121 12122 return fragment; 12123} 12124 12125 12126( function() { 12127 var fragment = document.createDocumentFragment(), 12128 div = fragment.appendChild( document.createElement( "div" ) ), 12129 input = document.createElement( "input" ); 12130 12131 // Support: Android 4.0 - 4.3 only 12132 // Check state lost if the name is set (#11217) 12133 // Support: Windows Web Apps (WWA) 12134 // `name` and `type` must use .setAttribute for WWA (#14901) 12135 input.setAttribute( "type", "radio" ); 12136 input.setAttribute( "checked", "checked" ); 12137 input.setAttribute( "name", "t" ); 12138 12139 div.appendChild( input ); 12140 12141 // Support: Android <=4.1 only 12142 // Older WebKit doesn't clone checked state correctly in fragments 12143 support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked; 12144 12145 // Support: IE <=11 only 12146 // Make sure textarea (and checkbox) defaultValue is properly cloned 12147 div.innerHTML = "<textarea>x</textarea>"; 12148 support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue; 12149} )(); 12150var documentElement = document.documentElement; 12151 12152 12153 12154var 12155 rkeyEvent = /^key/, 12156 rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/, 12157 rtypenamespace = /^([^.]*)(?:\.(.+)|)/; 12158 12159function returnTrue() { 12160 return true; 12161} 12162 12163function returnFalse() { 12164 return false; 12165} 12166 12167// Support: IE <=9 only 12168// See #13393 for more info 12169function safeActiveElement() { 12170 try { 12171 return document.activeElement; 12172 } catch ( err ) { } 12173} 12174 12175function on( elem, types, selector, data, fn, one ) { 12176 var origFn, type; 12177 12178 // Types can be a map of types/handlers 12179 if ( typeof types === "object" ) { 12180 12181 // ( types-Object, selector, data ) 12182 if ( typeof selector !== "string" ) { 12183 12184 // ( types-Object, data ) 12185 data = data || selector; 12186 selector = undefined; 12187 } 12188 for ( type in types ) { 12189 on( elem, type, selector, data, types[ type ], one ); 12190 } 12191 return elem; 12192 } 12193 12194 if ( data == null && fn == null ) { 12195 12196 // ( types, fn ) 12197 fn = selector; 12198 data = selector = undefined; 12199 } else if ( fn == null ) { 12200 if ( typeof selector === "string" ) { 12201 12202 // ( types, selector, fn ) 12203 fn = data; 12204 data = undefined; 12205 } else { 12206 12207 // ( types, data, fn ) 12208 fn = data; 12209 data = selector; 12210 selector = undefined; 12211 } 12212 } 12213 if ( fn === false ) { 12214 fn = returnFalse; 12215 } else if ( !fn ) { 12216 return elem; 12217 } 12218 12219 if ( one === 1 ) { 12220 origFn = fn; 12221 fn = function( event ) { 12222 12223 // Can use an empty set, since event contains the info 12224 jQuery().off( event ); 12225 return origFn.apply( this, arguments ); 12226 }; 12227 12228 // Use same guid so caller can remove using origFn 12229 fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); 12230 } 12231 return elem.each( function() { 12232 jQuery.event.add( this, types, fn, data, selector ); 12233 } ); 12234} 12235 12236/* 12237 * Helper functions for managing events -- not part of the public interface. 12238 * Props to Dean Edwards' addEvent library for many of the ideas. 12239 */ 12240jQuery.event = { 12241 12242 global: {}, 12243 12244 add: function( elem, types, handler, data, selector ) { 12245 12246 var handleObjIn, eventHandle, tmp, 12247 events, t, handleObj, 12248 special, handlers, type, namespaces, origType, 12249 elemData = dataPriv.get( elem ); 12250 12251 // Don't attach events to noData or text/comment nodes (but allow plain objects) 12252 if ( !elemData ) { 12253 return; 12254 } 12255 12256 // Caller can pass in an object of custom data in lieu of the handler 12257 if ( handler.handler ) { 12258 handleObjIn = handler; 12259 handler = handleObjIn.handler; 12260 selector = handleObjIn.selector; 12261 } 12262 12263 // Ensure that invalid selectors throw exceptions at attach time 12264 // Evaluate against documentElement in case elem is a non-element node (e.g., document) 12265 if ( selector ) { 12266 jQuery.find.matchesSelector( documentElement, selector ); 12267 } 12268 12269 // Make sure that the handler has a unique ID, used to find/remove it later 12270 if ( !handler.guid ) { 12271 handler.guid = jQuery.guid++; 12272 } 12273 12274 // Init the element's event structure and main handler, if this is the first 12275 if ( !( events = elemData.events ) ) { 12276 events = elemData.events = {}; 12277 } 12278 if ( !( eventHandle = elemData.handle ) ) { 12279 eventHandle = elemData.handle = function( e ) { 12280 12281 // Discard the second event of a jQuery.event.trigger() and 12282 // when an event is called after a page has unloaded 12283 return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? 12284 jQuery.event.dispatch.apply( elem, arguments ) : undefined; 12285 }; 12286 } 12287 12288 // Handle multiple events separated by a space 12289 types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; 12290 t = types.length; 12291 while ( t-- ) { 12292 tmp = rtypenamespace.exec( types[ t ] ) || []; 12293 type = origType = tmp[ 1 ]; 12294 namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); 12295 12296 // There *must* be a type, no attaching namespace-only handlers 12297 if ( !type ) { 12298 continue; 12299 } 12300 12301 // If event changes its type, use the special event handlers for the changed type 12302 special = jQuery.event.special[ type ] || {}; 12303 12304 // If selector defined, determine special event api type, otherwise given type 12305 type = ( selector ? special.delegateType : special.bindType ) || type; 12306 12307 // Update special based on newly reset type 12308 special = jQuery.event.special[ type ] || {}; 12309 12310 // handleObj is passed to all event handlers 12311 handleObj = jQuery.extend( { 12312 type: type, 12313 origType: origType, 12314 data: data, 12315 handler: handler, 12316 guid: handler.guid, 12317 selector: selector, 12318 needsContext: selector && jQuery.expr.match.needsContext.test( selector ), 12319 namespace: namespaces.join( "." ) 12320 }, handleObjIn ); 12321 12322 // Init the event handler queue if we're the first 12323 if ( !( handlers = events[ type ] ) ) { 12324 handlers = events[ type ] = []; 12325 handlers.delegateCount = 0; 12326 12327 // Only use addEventListener if the special events handler returns false 12328 if ( !special.setup || 12329 special.setup.call( elem, data, namespaces, eventHandle ) === false ) { 12330 12331 if ( elem.addEventListener ) { 12332 elem.addEventListener( type, eventHandle ); 12333 } 12334 } 12335 } 12336 12337 if ( special.add ) { 12338 special.add.call( elem, handleObj ); 12339 12340 if ( !handleObj.handler.guid ) { 12341 handleObj.handler.guid = handler.guid; 12342 } 12343 } 12344 12345 // Add to the element's handler list, delegates in front 12346 if ( selector ) { 12347 handlers.splice( handlers.delegateCount++, 0, handleObj ); 12348 } else { 12349 handlers.push( handleObj ); 12350 } 12351 12352 // Keep track of which events have ever been used, for event optimization 12353 jQuery.event.global[ type ] = true; 12354 } 12355 12356 }, 12357 12358 // Detach an event or set of events from an element 12359 remove: function( elem, types, handler, selector, mappedTypes ) { 12360 12361 var j, origCount, tmp, 12362 events, t, handleObj, 12363 special, handlers, type, namespaces, origType, 12364 elemData = dataPriv.hasData( elem ) && dataPriv.get( elem ); 12365 12366 if ( !elemData || !( events = elemData.events ) ) { 12367 return; 12368 } 12369 12370 // Once for each type.namespace in types; type may be omitted 12371 types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; 12372 t = types.length; 12373 while ( t-- ) { 12374 tmp = rtypenamespace.exec( types[ t ] ) || []; 12375 type = origType = tmp[ 1 ]; 12376 namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); 12377 12378 // Unbind all events (on this namespace, if provided) for the element 12379 if ( !type ) { 12380 for ( type in events ) { 12381 jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); 12382 } 12383 continue; 12384 } 12385 12386 special = jQuery.event.special[ type ] || {}; 12387 type = ( selector ? special.delegateType : special.bindType ) || type; 12388 handlers = events[ type ] || []; 12389 tmp = tmp[ 2 ] && 12390 new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ); 12391 12392 // Remove matching events 12393 origCount = j = handlers.length; 12394 while ( j-- ) { 12395 handleObj = handlers[ j ]; 12396 12397 if ( ( mappedTypes || origType === handleObj.origType ) && 12398 ( !handler || handler.guid === handleObj.guid ) && 12399 ( !tmp || tmp.test( handleObj.namespace ) ) && 12400 ( !selector || selector === handleObj.selector || 12401 selector === "**" && handleObj.selector ) ) { 12402 handlers.splice( j, 1 ); 12403 12404 if ( handleObj.selector ) { 12405 handlers.delegateCount--; 12406 } 12407 if ( special.remove ) { 12408 special.remove.call( elem, handleObj ); 12409 } 12410 } 12411 } 12412 12413 // Remove generic event handler if we removed something and no more handlers exist 12414 // (avoids potential for endless recursion during removal of special event handlers) 12415 if ( origCount && !handlers.length ) { 12416 if ( !special.teardown || 12417 special.teardown.call( elem, namespaces, elemData.handle ) === false ) { 12418 12419 jQuery.removeEvent( elem, type, elemData.handle ); 12420 } 12421 12422 delete events[ type ]; 12423 } 12424 } 12425 12426 // Remove data and the expando if it's no longer used 12427 if ( jQuery.isEmptyObject( events ) ) { 12428 dataPriv.remove( elem, "handle events" ); 12429 } 12430 }, 12431 12432 dispatch: function( nativeEvent ) { 12433 12434 // Make a writable jQuery.Event from the native event object 12435 var event = jQuery.event.fix( nativeEvent ); 12436 12437 var i, j, ret, matched, handleObj, handlerQueue, 12438 args = new Array( arguments.length ), 12439 handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [], 12440 special = jQuery.event.special[ event.type ] || {}; 12441 12442 // Use the fix-ed jQuery.Event rather than the (read-only) native event 12443 args[ 0 ] = event; 12444 12445 for ( i = 1; i < arguments.length; i++ ) { 12446 args[ i ] = arguments[ i ]; 12447 } 12448 12449 event.delegateTarget = this; 12450 12451 // Call the preDispatch hook for the mapped type, and let it bail if desired 12452 if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { 12453 return; 12454 } 12455 12456 // Determine handlers 12457 handlerQueue = jQuery.event.handlers.call( this, event, handlers ); 12458 12459 // Run delegates first; they may want to stop propagation beneath us 12460 i = 0; 12461 while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) { 12462 event.currentTarget = matched.elem; 12463 12464 j = 0; 12465 while ( ( handleObj = matched.handlers[ j++ ] ) && 12466 !event.isImmediatePropagationStopped() ) { 12467 12468 // Triggered event must either 1) have no namespace, or 2) have namespace(s) 12469 // a subset or equal to those in the bound event (both can have no namespace). 12470 if ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) { 12471 12472 event.handleObj = handleObj; 12473 event.data = handleObj.data; 12474 12475 ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle || 12476 handleObj.handler ).apply( matched.elem, args ); 12477 12478 if ( ret !== undefined ) { 12479 if ( ( event.result = ret ) === false ) { 12480 event.preventDefault(); 12481 event.stopPropagation(); 12482 } 12483 } 12484 } 12485 } 12486 } 12487 12488 // Call the postDispatch hook for the mapped type 12489 if ( special.postDispatch ) { 12490 special.postDispatch.call( this, event ); 12491 } 12492 12493 return event.result; 12494 }, 12495 12496 handlers: function( event, handlers ) { 12497 var i, handleObj, sel, matchedHandlers, matchedSelectors, 12498 handlerQueue = [], 12499 delegateCount = handlers.delegateCount, 12500 cur = event.target; 12501 12502 // Find delegate handlers 12503 if ( delegateCount && 12504 12505 // Support: IE <=9 12506 // Black-hole SVG <use> instance trees (trac-13180) 12507 cur.nodeType && 12508 12509 // Support: Firefox <=42 12510 // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861) 12511 // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click 12512 // Support: IE 11 only 12513 // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343) 12514 !( event.type === "click" && event.button >= 1 ) ) { 12515 12516 for ( ; cur !== this; cur = cur.parentNode || this ) { 12517 12518 // Don't check non-elements (#13208) 12519 // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764) 12520 if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) { 12521 matchedHandlers = []; 12522 matchedSelectors = {}; 12523 for ( i = 0; i < delegateCount; i++ ) { 12524 handleObj = handlers[ i ]; 12525 12526 // Don't conflict with Object.prototype properties (#13203) 12527 sel = handleObj.selector + " "; 12528 12529 if ( matchedSelectors[ sel ] === undefined ) { 12530 matchedSelectors[ sel ] = handleObj.needsContext ? 12531 jQuery( sel, this ).index( cur ) > -1 : 12532 jQuery.find( sel, this, null, [ cur ] ).length; 12533 } 12534 if ( matchedSelectors[ sel ] ) { 12535 matchedHandlers.push( handleObj ); 12536 } 12537 } 12538 if ( matchedHandlers.length ) { 12539 handlerQueue.push( { elem: cur, handlers: matchedHandlers } ); 12540 } 12541 } 12542 } 12543 } 12544 12545 // Add the remaining (directly-bound) handlers 12546 cur = this; 12547 if ( delegateCount < handlers.length ) { 12548 handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } ); 12549 } 12550 12551 return handlerQueue; 12552 }, 12553 12554 addProp: function( name, hook ) { 12555 Object.defineProperty( jQuery.Event.prototype, name, { 12556 enumerable: true, 12557 configurable: true, 12558 12559 get:
vendor: 8,400 bytes, lines 12559-12908
12559jQuery.isFunction( hook ) ? 12560 function() { 12561 if ( this.originalEvent ) { 12562 return hook( this.originalEvent ); 12563 } 12564 } : 12565 function() { 12566 if ( this.originalEvent ) { 12567 return this.originalEvent[ name ]; 12568 } 12569 }, 12570 12571 set: function( value ) { 12572 Object.defineProperty( this, name, { 12573 enumerable: true, 12574 configurable: true, 12575 writable: true, 12576 value: value 12577 } ); 12578 } 12579 } ); 12580 }, 12581 12582 fix: function( originalEvent ) { 12583 return originalEvent[ jQuery.expando ] ? 12584 originalEvent : 12585 new jQuery.Event( originalEvent ); 12586 }, 12587 12588 special: { 12589 load: { 12590 12591 // Prevent triggered image.load events from bubbling to window.load 12592 noBubble: true 12593 }, 12594 focus: { 12595 12596 // Fire native event if possible so blur/focus sequence is correct 12597 trigger: function() { 12598 if ( this !== safeActiveElement() && this.focus ) { 12599 this.focus(); 12600 return false; 12601 } 12602 }, 12603 delegateType: "focusin" 12604 }, 12605 blur: { 12606 trigger: function() { 12607 if ( this === safeActiveElement() && this.blur ) { 12608 this.blur(); 12609 return false; 12610 } 12611 }, 12612 delegateType: "focusout" 12613 }, 12614 click: { 12615 12616 // For checkbox, fire native event so checked state will be right 12617 trigger: function() { 12618 if ( this.type === "checkbox" && this.click && nodeName( this, "input" ) ) { 12619 this.click(); 12620 return false; 12621 } 12622 }, 12623 12624 // For cross-browser consistency, don't fire native .click() on links 12625 _default: function( event ) { 12626 return nodeName( event.target, "a" ); 12627 } 12628 }, 12629 12630 beforeunload: { 12631 postDispatch: function( event ) { 12632 12633 // Support: Firefox 20+ 12634 // Firefox doesn't alert if the returnValue field is not set. 12635 if ( event.result !== undefined && event.originalEvent ) { 12636 event.originalEvent.returnValue = event.result; 12637 } 12638 } 12639 } 12640 } 12641}; 12642 12643jQuery.removeEvent = function( elem, type, handle ) { 12644 12645 // This "if" is needed for plain objects 12646 if ( elem.removeEventListener ) { 12647 elem.removeEventListener( type, handle ); 12648 } 12649}; 12650 12651jQuery.Event = function( src, props ) { 12652 12653 // Allow instantiation without the 'new' keyword 12654 if ( !( this instanceof jQuery.Event ) ) { 12655 return new jQuery.Event( src, props ); 12656 } 12657 12658 // Event object 12659 if ( src && src.type ) { 12660 this.originalEvent = src; 12661 this.type = src.type; 12662 12663 // Events bubbling up the document may have been marked as prevented 12664 // by a handler lower down the tree; reflect the correct value. 12665 this.isDefaultPrevented = src.defaultPrevented || 12666 src.defaultPrevented === undefined && 12667 12668 // Support: Android <=2.3 only 12669 src.returnValue === false ? 12670 returnTrue : 12671 returnFalse; 12672 12673 // Create target properties 12674 // Support: Safari <=6 - 7 only 12675 // Target should not be a text node (#504, #13143) 12676 this.target = ( src.target && src.target.nodeType === 3 ) ? 12677 src.target.parentNode : 12678 src.target; 12679 12680 this.currentTarget = src.currentTarget; 12681 this.relatedTarget = src.relatedTarget; 12682 12683 // Event type 12684 } else { 12685 this.type = src; 12686 } 12687 12688 // Put explicitly provided properties onto the event object 12689 if ( props ) { 12690 jQuery.extend( this, props ); 12691 } 12692 12693 // Create a timestamp if incoming event doesn't have one 12694 this.timeStamp = src && src.timeStamp || jQuery.now(); 12695 12696 // Mark it as fixed 12697 this[ jQuery.expando ] = true; 12698}; 12699 12700// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding 12701// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html 12702jQuery.Event.prototype = { 12703 constructor: jQuery.Event, 12704 isDefaultPrevented: returnFalse, 12705 isPropagationStopped: returnFalse, 12706 isImmediatePropagationStopped: returnFalse, 12707 isSimulated: false, 12708 12709 preventDefault: function() { 12710 var e = this.originalEvent; 12711 12712 this.isDefaultPrevented = returnTrue; 12713 12714 if ( e && !this.isSimulated ) { 12715 e.preventDefault(); 12716 } 12717 }, 12718 stopPropagation: function() { 12719 var e = this.originalEvent; 12720 12721 this.isPropagationStopped = returnTrue; 12722 12723 if ( e && !this.isSimulated ) { 12724 e.stopPropagation(); 12725 } 12726 }, 12727 stopImmediatePropagation: function() { 12728 var e = this.originalEvent; 12729 12730 this.isImmediatePropagationStopped = returnTrue; 12731 12732 if ( e && !this.isSimulated ) { 12733 e.stopImmediatePropagation(); 12734 } 12735 12736 this.stopPropagation(); 12737 } 12738}; 12739 12740// Includes all common event props including KeyEvent and MouseEvent specific props 12741jQuery.each( { 12742 altKey: true, 12743 bubbles: true, 12744 cancelable: true, 12745 changedTouches: true, 12746 ctrlKey: true, 12747 detail: true, 12748 eventPhase: true, 12749 metaKey: true, 12750 pageX: true, 12751 pageY: true, 12752 shiftKey: true, 12753 view: true, 12754 "char": true, 12755 charCode: true, 12756 key: true, 12757 keyCode: true, 12758 button: true, 12759 buttons: true, 12760 clientX: true, 12761 clientY: true, 12762 offsetX: true, 12763 offsetY: true, 12764 pointerId: true, 12765 pointerType: true, 12766 screenX: true, 12767 screenY: true, 12768 targetTouches: true, 12769 toElement: true, 12770 touches: true, 12771 12772 which: function( event ) { 12773 var button = event.button; 12774 12775 // Add which for key events 12776 if ( event.which == null && rkeyEvent.test( event.type ) ) { 12777 return event.charCode != null ? event.charCode : event.keyCode; 12778 } 12779 12780 // Add which for click: 1 === left; 2 === middle; 3 === right 12781 if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) { 12782 if ( button & 1 ) { 12783 return 1; 12784 } 12785 12786 if ( button & 2 ) { 12787 return 3; 12788 } 12789 12790 if ( button & 4 ) { 12791 return 2; 12792 } 12793 12794 return 0; 12795 } 12796 12797 return event.which; 12798 } 12799}, jQuery.event.addProp ); 12800 12801// Create mouseenter/leave events using mouseover/out and event-time checks 12802// so that event delegation works in jQuery. 12803// Do the same for pointerenter/pointerleave and pointerover/pointerout 12804// 12805// Support: Safari 7 only 12806// Safari sends mouseenter too often; see: 12807// https://bugs.chromium.org/p/chromium/issues/detail?id=470258 12808// for the description of the bug (it existed in older Chrome versions as well). 12809jQuery.each( { 12810 mouseenter: "mouseover", 12811 mouseleave: "mouseout", 12812 pointerenter: "pointerover", 12813 pointerleave: "pointerout" 12814}, function( orig, fix ) { 12815 jQuery.event.special[ orig ] = { 12816 delegateType: fix, 12817 bindType: fix, 12818 12819 handle: function( event ) { 12820 var ret, 12821 target = this, 12822 related = event.relatedTarget, 12823 handleObj = event.handleObj; 12824 12825 // For mouseenter/leave call the handler if related is outside the target. 12826 // NB: No relatedTarget if the mouse left/entered the browser window 12827 if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) { 12828 event.type = handleObj.origType; 12829 ret = handleObj.handler.apply( this, arguments ); 12830 event.type = fix; 12831 } 12832 return ret; 12833 } 12834 }; 12835} ); 12836 12837jQuery.fn.extend( { 12838 12839 on: function( types, selector, data, fn ) { 12840 return on( this, types, selector, data, fn ); 12841 }, 12842 one: function( types, selector, data, fn ) { 12843 return on( this, types, selector, data, fn, 1 ); 12844 }, 12845 off: function( types, selector, fn ) { 12846 var handleObj, type; 12847 if ( types && types.preventDefault && types.handleObj ) { 12848 12849 // ( event ) dispatched jQuery.Event 12850 handleObj = types.handleObj; 12851 jQuery( types.delegateTarget ).off( 12852 handleObj.namespace ? 12853 handleObj.origType + "." + handleObj.namespace : 12854 handleObj.origType, 12855 handleObj.selector, 12856 handleObj.handler 12857 ); 12858 return this; 12859 } 12860 if ( typeof types === "object" ) { 12861 12862 // ( types-object [, selector] ) 12863 for ( type in types ) { 12864 this.off( type, selector, types[ type ] ); 12865 } 12866 return this; 12867 } 12868 if ( selector === false || typeof selector === "function" ) { 12869 12870 // ( types [, fn] ) 12871 fn = selector; 12872 selector = undefined; 12873 } 12874 if ( fn === false ) { 12875 fn = returnFalse; 12876 } 12877 return this.each( function() { 12878 jQuery.event.remove( this, types, fn, selector ); 12879 } ); 12880 } 12881} ); 12882 12883 12884var 12885 12886 /* eslint-disable max-len */ 12887 12888 // See https://github.com/eslint/eslint/issues/3229 12889 rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi, 12890 12891 /* eslint-enable */ 12892 12893 // Support: IE <=10 - 11, Edge 12 - 13 12894 // In IE/Edge using regex groups here causes severe slowdowns. 12895 // See https://connect.microsoft.com/IE/feedback/details/1736512/ 12896 rnoInnerhtml = /<script|<style|<link/i, 12897 12898 // checked="checked" or checked 12899 rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, 12900 rscriptTypeMasked = /^true\/(.*)/, 12901 rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g; 12902 12903// Prefer a tbody over its parent table for containing new rows 12904function manipulationTarget( elem, content ) { 12905 if ( nodeName( elem, "table" ) && 12906 nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) { 12907 12908 return jQuery( ">tbody", elem
vendor: 6,531 bytes, lines 12908-13156
12908 )[ 0 ] || elem; 12909 } 12910 12911 return elem; 12912} 12913 12914// Replace/restore the type attribute of script elements for safe DOM manipulation 12915function disableScript( elem ) { 12916 elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type; 12917 return elem; 12918} 12919function restoreScript( elem ) { 12920 var match = rscriptTypeMasked.exec( elem.type ); 12921 12922 if ( match ) { 12923 elem.type = match[ 1 ]; 12924 } else { 12925 elem.removeAttribute( "type" ); 12926 } 12927 12928 return elem; 12929} 12930 12931function cloneCopyEvent( src, dest ) { 12932 var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events; 12933 12934 if ( dest.nodeType !== 1 ) { 12935 return; 12936 } 12937 12938 // 1. Copy private data: events, handlers, etc. 12939 if ( dataPriv.hasData( src ) ) { 12940 pdataOld = dataPriv.access( src ); 12941 pdataCur = dataPriv.set( dest, pdataOld ); 12942 events = pdataOld.events; 12943 12944 if ( events ) { 12945 delete pdataCur.handle; 12946 pdataCur.events = {}; 12947 12948 for ( type in events ) { 12949 for ( i = 0, l = events[ type ].length; i < l; i++ ) { 12950 jQuery.event.add( dest, type, events[ type ][ i ] ); 12951 } 12952 } 12953 } 12954 } 12955 12956 // 2. Copy user data 12957 if ( dataUser.hasData( src ) ) { 12958 udataOld = dataUser.access( src ); 12959 udataCur = jQuery.extend( {}, udataOld ); 12960 12961 dataUser.set( dest, udataCur ); 12962 } 12963} 12964 12965// Fix IE bugs, see support tests 12966function fixInput( src, dest ) { 12967 var nodeName = dest.nodeName.toLowerCase(); 12968 12969 // Fails to persist the checked state of a cloned checkbox or radio button. 12970 if ( nodeName === "input" && rcheckableType.test( src.type ) ) { 12971 dest.checked = src.checked; 12972 12973 // Fails to return the selected option to the default selected state when cloning options 12974 } else if ( nodeName === "input" || nodeName === "textarea" ) { 12975 dest.defaultValue = src.defaultValue; 12976 } 12977} 12978 12979function domManip( collection, args, callback, ignored ) { 12980 12981 // Flatten any nested arrays 12982 args = concat.apply( [], args ); 12983 12984 var fragment, first, scripts, hasScripts, node, doc, 12985 i = 0, 12986 l = collection.length, 12987 iNoClone = l - 1, 12988 value = args[ 0 ], 12989 isFunction = jQuery.isFunction( value ); 12990 12991 // We can't cloneNode fragments that contain checked, in WebKit 12992 if ( isFunction || 12993 ( l > 1 && typeof value === "string" && 12994 !support.checkClone && rchecked.test( value ) ) ) { 12995 return collection.each( function( index ) { 12996 var self = collection.eq( index ); 12997 if ( isFunction ) { 12998 args[ 0 ] = value.call( this, index, self.html() ); 12999 } 13000 domManip( self, args, callback, ignored ); 13001 } ); 13002 } 13003 13004 if ( l ) { 13005 fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored ); 13006 first = fragment.firstChild; 13007 13008 if ( fragment.childNodes.length === 1 ) { 13009 fragment = first; 13010 } 13011 13012 // Require either new content or an interest in ignored elements to invoke the callback 13013 if ( first || ignored ) { 13014 scripts = jQuery.map( getAll( fragment, "script" ), disableScript ); 13015 hasScripts = scripts.length; 13016 13017 // Use the original fragment for the last item 13018 // instead of the first because it can end up 13019 // being emptied incorrectly in certain situations (#8070). 13020 for ( ; i < l; i++ ) { 13021 node = fragment; 13022 13023 if ( i !== iNoClone ) { 13024 node = jQuery.clone( node, true, true ); 13025 13026 // Keep references to cloned scripts for later restoration 13027 if ( hasScripts ) { 13028 13029 // Support: Android <=4.0 only, PhantomJS 1 only 13030 // push.apply(_, arraylike) throws on ancient WebKit 13031 jQuery.merge( scripts, getAll( node, "script" ) ); 13032 } 13033 } 13034 13035 callback.call( collection[ i ], node, i ); 13036 } 13037 13038 if ( hasScripts ) { 13039 doc = scripts[ scripts.length - 1 ].ownerDocument; 13040 13041 // Reenable scripts 13042 jQuery.map( scripts, restoreScript ); 13043 13044 // Evaluate executable scripts on first document insertion 13045 for ( i = 0; i < hasScripts; i++ ) { 13046 node = scripts[ i ]; 13047 if ( rscriptType.test( node.type || "" ) && 13048 !dataPriv.access( node, "globalEval" ) && 13049 jQuery.contains( doc, node ) ) { 13050 13051 if ( node.src ) { 13052 13053 // Optional AJAX dependency, but won't run scripts if not present 13054 if ( jQuery._evalUrl ) { 13055 jQuery._evalUrl( node.src ); 13056 } 13057 } else { 13058 DOMEval( node.textContent.replace( rcleanScript, "" ), doc ); 13059 } 13060 } 13061 } 13062 } 13063 } 13064 } 13065 13066 return collection; 13067} 13068 13069function remove( elem, selector, keepData ) { 13070 var node, 13071 nodes = selector ? jQuery.filter( selector, elem ) : elem, 13072 i = 0; 13073 13074 for ( ; ( node = nodes[ i ] ) != null; i++ ) { 13075 if ( !keepData && node.nodeType === 1 ) { 13076 jQuery.cleanData( getAll( node ) ); 13077 } 13078 13079 if ( node.parentNode ) { 13080 if ( keepData && jQuery.contains( node.ownerDocument, node ) ) { 13081 setGlobalEval( getAll( node, "script" ) ); 13082 } 13083 node.parentNode.removeChild( node ); 13084 } 13085 } 13086 13087 return elem; 13088} 13089 13090jQuery.extend( { 13091 htmlPrefilter: function( html ) { 13092 return html.replace( rxhtmlTag, "<$1></$2>" ); 13093 }, 13094 13095 clone: function( elem, dataAndEvents, deepDataAndEvents ) { 13096 var i, l, srcElements, destElements, 13097 clone = elem.cloneNode( true ), 13098 inPage = jQuery.contains( elem.ownerDocument, elem ); 13099 13100 // Fix IE cloning issues 13101 if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) && 13102 !jQuery.isXMLDoc( elem ) ) { 13103 13104 // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2 13105 destElements = getAll( clone ); 13106 srcElements = getAll( elem ); 13107 13108 for ( i = 0, l = srcElements.length; i < l; i++ ) { 13109 fixInput( srcElements[ i ], destElements[ i ] ); 13110 } 13111 } 13112 13113 // Copy the events from the original to the clone 13114 if ( dataAndEvents ) { 13115 if ( deepDataAndEvents ) { 13116 srcElements = srcElements || getAll( elem ); 13117 destElements = destElements || getAll( clone ); 13118 13119 for ( i = 0, l = srcElements.length; i < l; i++ ) { 13120 cloneCopyEvent( srcElements[ i ], destElements[ i ] ); 13121 } 13122 } else { 13123 cloneCopyEvent( elem, clone ); 13124 } 13125 } 13126 13127 // Preserve script evaluation history 13128 destElements = getAll( clone, "script" ); 13129 if ( destElements.length > 0 ) { 13130 setGlobalEval( destElements, !inPage && getAll( elem, "script" ) ); 13131 } 13132 13133 // Return the cloned set 13134 return clone; 13135 }, 13136 13137 cleanData: function( elems ) { 13138 var data, elem, type, 13139 special = jQuery.event.special, 13140 i = 0; 13141 13142 for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) { 13143 if ( acceptData( elem ) ) { 13144 if ( ( data = elem[ dataPriv.expando ] ) ) { 13145 if ( data.events ) { 13146 for ( type in data.events ) { 13147 if ( special[ type ] ) { 13148 jQuery.event.remove( elem, type ); 13149 13150 // This is a shortcut to avoid jQuery.event.remove's overhead 13151 } else { 13152 jQuery.removeEvent( elem, type, data.handle ); 13153 } 13154 } 13155 } 13156
vendor: 1,119 bytes, lines 13157-13201
13157 // Support: Chrome <=35 - 45+ 13158 // Assign undefined instead of using delete, see Data#remove 13159 elem[ dataPriv.expando ] = undefined; 13160 } 13161 if ( elem[ dataUser.expando ] ) { 13162 13163 // Support: Chrome <=35 - 45+ 13164 // Assign undefined instead of using delete, see Data#remove 13165 elem[ dataUser.expando ] = undefined; 13166 } 13167 } 13168 } 13169 } 13170} ); 13171 13172jQuery.fn.extend( { 13173 detach: function( selector ) { 13174 return remove( this, selector, true ); 13175 }, 13176 13177 remove: function( selector ) { 13178 return remove( this, selector ); 13179 }, 13180 13181 text: function( value ) { 13182 return access( this, function( value ) { 13183 return value === undefined ? 13184 jQuery.text( this ) : 13185 this.empty().each( function() { 13186 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { 13187 this.textContent = value; 13188 } 13189 } ); 13190 }, null, value, arguments.length ); 13191 }, 13192 13193 append: function() { 13194 return domManip( this, arguments, function( elem ) { 13195 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { 13196 var target = manipulationTarget( this, elem ); 13197 target.appendChild( elem ); 13198 } 13199 } ); 13200 }, 13201
vendor: 6,076 bytes, lines 13202-13437
13202 prepend: function() { 13203 return domManip( this, arguments, function( elem ) { 13204 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { 13205 var target = manipulationTarget( this, elem ); 13206 target.insertBefore( elem, target.firstChild ); 13207 } 13208 } ); 13209 }, 13210 13211 before: function() { 13212 return domManip( this, arguments, function( elem ) { 13213 if ( this.parentNode ) { 13214 this.parentNode.insertBefore( elem, this ); 13215 } 13216 } ); 13217 }, 13218 13219 after: function() { 13220 return domManip( this, arguments, function( elem ) { 13221 if ( this.parentNode ) { 13222 this.parentNode.insertBefore( elem, this.nextSibling ); 13223 } 13224 } ); 13225 }, 13226 13227 empty: function() { 13228 var elem, 13229 i = 0; 13230 13231 for ( ; ( elem = this[ i ] ) != null; i++ ) { 13232 if ( elem.nodeType === 1 ) { 13233 13234 // Prevent memory leaks 13235 jQuery.cleanData( getAll( elem, false ) ); 13236 13237 // Remove any remaining nodes 13238 elem.textContent = ""; 13239 } 13240 } 13241 13242 return this; 13243 }, 13244 13245 clone: function( dataAndEvents, deepDataAndEvents ) { 13246 dataAndEvents = dataAndEvents == null ? false : dataAndEvents; 13247 deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; 13248 13249 return this.map( function() { 13250 return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); 13251 } ); 13252 }, 13253 13254 html: function( value ) { 13255 return access( this, function( value ) { 13256 var elem = this[ 0 ] || {}, 13257 i = 0, 13258 l = this.length; 13259 13260 if ( value === undefined && elem.nodeType === 1 ) { 13261 return elem.innerHTML; 13262 } 13263 13264 // See if we can take a shortcut and just use innerHTML 13265 if ( typeof value === "string" && !rnoInnerhtml.test( value ) && 13266 !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) { 13267 13268 value = jQuery.htmlPrefilter( value ); 13269 13270 try { 13271 for ( ; i < l; i++ ) { 13272 elem = this[ i ] || {}; 13273 13274 // Remove element nodes and prevent memory leaks 13275 if ( elem.nodeType === 1 ) { 13276 jQuery.cleanData( getAll( elem, false ) ); 13277 elem.innerHTML = value; 13278 } 13279 } 13280 13281 elem = 0; 13282 13283 // If using innerHTML throws an exception, use the fallback method 13284 } catch ( e ) {} 13285 } 13286 13287 if ( elem ) { 13288 this.empty().append( value ); 13289 } 13290 }, null, value, arguments.length ); 13291 }, 13292 13293 replaceWith: function() { 13294 var ignored = []; 13295 13296 // Make the changes, replacing each non-ignored context element with the new content 13297 return domManip( this, arguments, function( elem ) { 13298 var parent = this.parentNode; 13299 13300 if ( jQuery.inArray( this, ignored ) < 0 ) { 13301 jQuery.cleanData( getAll( this ) ); 13302 if ( parent ) { 13303 parent.replaceChild( elem, this ); 13304 } 13305 } 13306 13307 // Force callback invocation 13308 }, ignored ); 13309 } 13310} ); 13311 13312jQuery.each( { 13313 appendTo: "append", 13314 prependTo: "prepend", 13315 insertBefore: "before", 13316 insertAfter: "after", 13317 replaceAll: "replaceWith" 13318}, function( name, original ) { 13319 jQuery.fn[ name ] = function( selector ) { 13320 var elems, 13321 ret = [], 13322 insert = jQuery( selector ), 13323 last = insert.length - 1, 13324 i = 0; 13325 13326 for ( ; i <= last; i++ ) { 13327 elems = i === last ? this : this.clone( true ); 13328 jQuery( insert[ i ] )[ original ]( elems ); 13329 13330 // Support: Android <=4.0 only, PhantomJS 1 only 13331 // .get() because push.apply(_, arraylike) throws on ancient WebKit 13332 push.apply( ret, elems.get() ); 13333 } 13334 13335 return this.pushStack( ret ); 13336 }; 13337} ); 13338var rmargin = ( /^margin/ ); 13339 13340var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" ); 13341 13342var getStyles = function( elem ) { 13343 13344 // Support: IE <=11 only, Firefox <=30 (#15098, #14150) 13345 // IE throws on elements created in popups 13346 // FF meanwhile throws on frame elements through "defaultView.getComputedStyle" 13347 var view = elem.ownerDocument.defaultView; 13348 13349 if ( !view || !view.opener ) { 13350 view = window; 13351 } 13352 13353 return view.getComputedStyle( elem ); 13354 }; 13355 13356 13357 13358( function() { 13359 13360 // Executing both pixelPosition & boxSizingReliable tests require only one layout 13361 // so they're executed at the same time to save the second computation. 13362 function computeStyleTests() { 13363 13364 // This is a singleton, we need to execute it only once 13365 if ( !div ) { 13366 return; 13367 } 13368 13369 div.style.cssText = 13370 "box-sizing:border-box;" + 13371 "position:relative;display:block;" + 13372 "margin:auto;border:1px;padding:1px;" + 13373 "top:1%;width:50%"; 13374 div.innerHTML = ""; 13375 documentElement.appendChild( container ); 13376 13377 var divStyle = window.getComputedStyle( div ); 13378 pixelPositionVal = divStyle.top !== "1%"; 13379 13380 // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44 13381 reliableMarginLeftVal = divStyle.marginLeft === "2px"; 13382 boxSizingReliableVal = divStyle.width === "4px"; 13383 13384 // Support: Android 4.0 - 4.3 only 13385 // Some styles come back with percentage values, even though they shouldn't 13386 div.style.marginRight = "50%"; 13387 pixelMarginRightVal = divStyle.marginRight === "4px"; 13388 13389 documentElement.removeChild( container ); 13390 13391 // Nullify the div so it wouldn't be stored in the memory and 13392 // it will also be a sign that checks already performed 13393 div = null; 13394 } 13395 13396 var pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, reliableMarginLeftVal, 13397 container = document.createElement( "div" ), 13398 div = document.createElement( "div" ); 13399 13400 // Finish early in limited (non-browser) environments 13401 if ( !div.style ) { 13402 return; 13403 } 13404 13405 // Support: IE <=9 - 11 only 13406 // Style of cloned element affects source element cloned (#8908) 13407 div.style.backgroundClip = "content-box"; 13408 div.cloneNode( true ).style.backgroundClip = ""; 13409 support.clearCloneStyle = div.style.backgroundClip === "content-box"; 13410 13411 container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" + 13412 "padding:0;margin-top:1px;position:absolute"; 13413 container.appendChild( div ); 13414 13415 jQuery.extend( support, { 13416 pixelPosition: function() { 13417 computeStyleTests(); 13418 return pixelPositionVal; 13419 }, 13420 boxSizingReliable: function() { 13421 computeStyleTests(); 13422 return boxSizingReliableVal; 13423 }, 13424 pixelMarginRight: function() { 13425 computeStyleTests(); 13426 return pixelMarginRightVal; 13427 }, 13428 reliableMarginLeft: function() { 13429 computeStyleTests(); 13430 return reliableMarginLeftVal; 13431 } 13432 } ); 13433} )(); 13434 13435 13436function curCSS( elem, name, computed ) { 13437 var width, minWidth, maxWidth, ret,
vendor: 8,366 bytes, lines 13438-13743
13438 13439 // Support: Firefox 51+ 13440 // Retrieving style before computed somehow 13441 // fixes an issue with getting wrong values 13442 // on detached elements 13443 style = elem.style; 13444 13445 computed = computed || getStyles( elem ); 13446 13447 // getPropertyValue is needed for: 13448 // .css('filter') (IE 9 only, #12537) 13449 // .css('--customProperty) (#3144) 13450 if ( computed ) { 13451 ret = computed.getPropertyValue( name ) || computed[ name ]; 13452 13453 if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) { 13454 ret = jQuery.style( elem, name ); 13455 } 13456 13457 // A tribute to the "awesome hack by Dean Edwards" 13458 // Android Browser returns percentage for some values, 13459 // but width seems to be reliably pixels. 13460 // This is against the CSSOM draft spec: 13461 // https://drafts.csswg.org/cssom/#resolved-values 13462 if ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) { 13463 13464 // Remember the original values 13465 width = style.width; 13466 minWidth = style.minWidth; 13467 maxWidth = style.maxWidth; 13468 13469 // Put in the new values to get a computed value out 13470 style.minWidth = style.maxWidth = style.width = ret; 13471 ret = computed.width; 13472 13473 // Revert the changed values 13474 style.width = width; 13475 style.minWidth = minWidth; 13476 style.maxWidth = maxWidth; 13477 } 13478 } 13479 13480 return ret !== undefined ? 13481 13482 // Support: IE <=9 - 11 only 13483 // IE returns zIndex value as an integer. 13484 ret + "" : 13485 ret; 13486} 13487 13488 13489function addGetHookIf( conditionFn, hookFn ) { 13490 13491 // Define the hook, we'll check on the first run if it's really needed. 13492 return { 13493 get: function() { 13494 if ( conditionFn() ) { 13495 13496 // Hook not needed (or it's not possible to use it due 13497 // to missing dependency), remove it. 13498 delete this.get; 13499 return; 13500 } 13501 13502 // Hook needed; redefine it so that the support test is not executed again. 13503 return ( this.get = hookFn ).apply( this, arguments ); 13504 } 13505 }; 13506} 13507 13508 13509var 13510 13511 // Swappable if display is none or starts with table 13512 // except "table", "table-cell", or "table-caption" 13513 // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display 13514 rdisplayswap = /^(none|table(?!-c[ea]).+)/, 13515 rcustomProp = /^--/, 13516 cssShow = { position: "absolute", visibility: "hidden", display: "block" }, 13517 cssNormalTransform = { 13518 letterSpacing: "0", 13519 fontWeight: "400" 13520 }, 13521 13522 cssPrefixes = [ "Webkit", "Moz", "ms" ], 13523 emptyStyle = document.createElement( "div" ).style; 13524 13525// Return a css property mapped to a potentially vendor prefixed property 13526function vendorPropName( name ) { 13527 13528 // Shortcut for names that are not vendor prefixed 13529 if ( name in emptyStyle ) { 13530 return name; 13531 } 13532 13533 // Check for vendor prefixed names 13534 var capName = name[ 0 ].toUpperCase() + name.slice( 1 ), 13535 i = cssPrefixes.length; 13536 13537 while ( i-- ) { 13538 name = cssPrefixes[ i ] + capName; 13539 if ( name in emptyStyle ) { 13540 return name; 13541 } 13542 } 13543} 13544 13545// Return a property mapped along what jQuery.cssProps suggests or to 13546// a vendor prefixed property. 13547function finalPropName( name ) { 13548 var ret = jQuery.cssProps[ name ]; 13549 if ( !ret ) { 13550 ret = jQuery.cssProps[ name ] = vendorPropName( name ) || name; 13551 } 13552 return ret; 13553} 13554 13555function setPositiveNumber( elem, value, subtract ) { 13556 13557 // Any relative (+/-) values have already been 13558 // normalized at this point 13559 var matches = rcssNum.exec( value ); 13560 return matches ? 13561 13562 // Guard against undefined "subtract", e.g., when used as in cssHooks 13563 Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) : 13564 value; 13565} 13566 13567function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) { 13568 var i, 13569 val = 0; 13570 13571 // If we already have the right measurement, avoid augmentation 13572 if ( extra === ( isBorderBox ? "border" : "content" ) ) { 13573 i = 4; 13574 13575 // Otherwise initialize for horizontal or vertical properties 13576 } else { 13577 i = name === "width" ? 1 : 0; 13578 } 13579 13580 for ( ; i < 4; i += 2 ) { 13581 13582 // Both box models exclude margin, so add it if we want it 13583 if ( extra === "margin" ) { 13584 val += jQuery.css( elem, extra + cssExpand[ i ], true, styles ); 13585 } 13586 13587 if ( isBorderBox ) { 13588 13589 // border-box includes padding, so remove it if we want content 13590 if ( extra === "content" ) { 13591 val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); 13592 } 13593 13594 // At this point, extra isn't border nor margin, so remove border 13595 if ( extra !== "margin" ) { 13596 val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); 13597 } 13598 } else { 13599 13600 // At this point, extra isn't content, so add padding 13601 val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); 13602 13603 // At this point, extra isn't content nor padding, so add border 13604 if ( extra !== "padding" ) { 13605 val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); 13606 } 13607 } 13608 } 13609 13610 return val; 13611} 13612 13613function getWidthOrHeight( elem, name, extra ) { 13614 13615 // Start with computed style 13616 var valueIsBorderBox, 13617 styles = getStyles( elem ), 13618 val = curCSS( elem, name, styles ), 13619 isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box"; 13620 13621 // Computed unit is not pixels. Stop here and return. 13622 if ( rnumnonpx.test( val ) ) { 13623 return val; 13624 } 13625 13626 // Check for style in case a browser which returns unreliable values 13627 // for getComputedStyle silently falls back to the reliable elem.style 13628 valueIsBorderBox = isBorderBox && 13629 ( support.boxSizingReliable() || val === elem.style[ name ] ); 13630 13631 // Fall back to offsetWidth/Height when value is "auto" 13632 // This happens for inline elements with no explicit setting (gh-3571) 13633 if ( val === "auto" ) { 13634 val = elem[ "offset" + name[ 0 ].toUpperCase() + name.slice( 1 ) ]; 13635 } 13636 13637 // Normalize "", auto, and prepare for extra 13638 val = parseFloat( val ) || 0; 13639 13640 // Use the active box-sizing model to add/subtract irrelevant styles 13641 return ( val + 13642 augmentWidthOrHeight( 13643 elem, 13644 name, 13645 extra || ( isBorderBox ? "border" : "content" ), 13646 valueIsBorderBox, 13647 styles 13648 ) 13649 ) + "px"; 13650} 13651 13652jQuery.extend( { 13653 13654 // Add in style property hooks for overriding the default 13655 // behavior of getting and setting a style property 13656 cssHooks: { 13657 opacity: { 13658 get: function( elem, computed ) { 13659 if ( computed ) { 13660 13661 // We should always get a number back from opacity 13662 var ret = curCSS( elem, "opacity" ); 13663 return ret === "" ? "1" : ret; 13664 } 13665 } 13666 } 13667 }, 13668 13669 // Don't automatically add "px" to these possibly-unitless properties 13670 cssNumber: { 13671 "animationIterationCount": true, 13672 "columnCount": true, 13673 "fillOpacity": true, 13674 "flexGrow": true, 13675 "flexShrink": true, 13676 "fontWeight": true, 13677 "lineHeight": true, 13678 "opacity": true, 13679 "order": true, 13680 "orphans": true, 13681 "widows": true, 13682 "zIndex": true, 13683 "zoom": true 13684 }, 13685 13686 // Add in properties whose names you wish to fix before 13687 // setting or getting the value 13688 cssProps: { 13689 "float": "cssFloat" 13690 }, 13691 13692 // Get and set the style property on a DOM Node 13693 style: function( elem, name, value, extra ) { 13694 13695 // Don't set styles on text and comment nodes 13696 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) { 13697 return; 13698 } 13699 13700 // Make sure that we're working with the right name 13701 var ret, type, hooks, 13702 origName = jQuery.camelCase( name ), 13703 isCustomProp = rcustomProp.test( name ), 13704 style = elem.style; 13705 13706 // Make sure that we're working with the right name. We don't 13707 // want to query the value if it is a CSS custom property 13708 // since they are user-defined. 13709 if ( !isCustomProp ) { 13710 name = finalPropName( origName ); 13711 } 13712 13713 // Gets hook for the prefixed version, then unprefixed version 13714 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; 13715 13716 // Check if we're setting a value 13717 if ( value !== undefined ) { 13718 type = typeof value; 13719 13720 // Convert "+=" or "-=" to relative numbers (#7345) 13721 if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) { 13722 value = adjustCSS( elem, name, ret ); 13723 13724 // Fixes bug #9237 13725 type = "number"; 13726 } 13727 13728 // Make sure that null and NaN values aren't set (#7116) 13729 if ( value == null || value !== value ) { 13730 return; 13731 } 13732 13733 // If a number was passed in, add the unit (except for certain CSS properties) 13734 if ( type === "number" ) { 13735 value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" ); 13736 } 13737 13738 // background-* props affect original clone's values 13739 if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) { 13740 style[ name ] = "inherit"; 13741 } 13742 13743 // If a hook was provided, use that value, otherwise just set the specified value
vendor: 4,779 bytes, lines 13744-13926
13744 if ( !hooks || !( "set" in hooks ) || 13745 ( value = hooks.set( elem, value, extra ) ) !== undefined ) { 13746 13747 if ( isCustomProp ) { 13748 style.setProperty( name, value ); 13749 } else { 13750 style[ name ] = value; 13751 } 13752 } 13753 13754 } else { 13755 13756 // If a hook was provided get the non-computed value from there 13757 if ( hooks && "get" in hooks && 13758 ( ret = hooks.get( elem, false, extra ) ) !== undefined ) { 13759 13760 return ret; 13761 } 13762 13763 // Otherwise just get the value from the style object 13764 return style[ name ]; 13765 } 13766 }, 13767 13768 css: function( elem, name, extra, styles ) { 13769 var val, num, hooks, 13770 origName = jQuery.camelCase( name ), 13771 isCustomProp = rcustomProp.test( name ); 13772 13773 // Make sure that we're working with the right name. We don't 13774 // want to modify the value if it is a CSS custom property 13775 // since they are user-defined. 13776 if ( !isCustomProp ) { 13777 name = finalPropName( origName ); 13778 } 13779 13780 // Try prefixed name followed by the unprefixed name 13781 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; 13782 13783 // If a hook was provided get the computed value from there 13784 if ( hooks && "get" in hooks ) { 13785 val = hooks.get( elem, true, extra ); 13786 } 13787 13788 // Otherwise, if a way to get the computed value exists, use that 13789 if ( val === undefined ) { 13790 val = curCSS( elem, name, styles ); 13791 } 13792 13793 // Convert "normal" to computed value 13794 if ( val === "normal" && name in cssNormalTransform ) { 13795 val = cssNormalTransform[ name ]; 13796 } 13797 13798 // Make numeric if forced or a qualifier was provided and val looks numeric 13799 if ( extra === "" || extra ) { 13800 num = parseFloat( val ); 13801 return extra === true || isFinite( num ) ? num || 0 : val; 13802 } 13803 13804 return val; 13805 } 13806} ); 13807 13808jQuery.each( [ "height", "width" ], function( i, name ) { 13809 jQuery.cssHooks[ name ] = { 13810 get: function( elem, computed, extra ) { 13811 if ( computed ) { 13812 13813 // Certain elements can have dimension info if we invisibly show them 13814 // but it must have a current display style that would benefit 13815 return rdisplayswap.test( jQuery.css( elem, "display" ) ) && 13816 13817 // Support: Safari 8+ 13818 // Table columns in Safari have non-zero offsetWidth & zero 13819 // getBoundingClientRect().width unless display is changed. 13820 // Support: IE <=11 only 13821 // Running getBoundingClientRect on a disconnected node 13822 // in IE throws an error. 13823 ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ? 13824 swap( elem, cssShow, function() { 13825 return getWidthOrHeight( elem, name, extra ); 13826 } ) : 13827 getWidthOrHeight( elem, name, extra ); 13828 } 13829 }, 13830 13831 set: function( elem, value, extra ) { 13832 var matches, 13833 styles = extra && getStyles( elem ), 13834 subtract = extra && augmentWidthOrHeight( 13835 elem, 13836 name, 13837 extra, 13838 jQuery.css( elem, "boxSizing", false, styles ) === "border-box", 13839 styles 13840 ); 13841 13842 // Convert to pixels if value adjustment is needed 13843 if ( subtract && ( matches = rcssNum.exec( value ) ) && 13844 ( matches[ 3 ] || "px" ) !== "px" ) { 13845 13846 elem.style[ name ] = value; 13847 value = jQuery.css( elem, name ); 13848 } 13849 13850 return setPositiveNumber( elem, value, subtract ); 13851 } 13852 }; 13853} ); 13854 13855jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft, 13856 function( elem, computed ) { 13857 if ( computed ) { 13858 return ( parseFloat( curCSS( elem, "marginLeft" ) ) || 13859 elem.getBoundingClientRect().left - 13860 swap( elem, { marginLeft: 0 }, function() { 13861 return elem.getBoundingClientRect().left; 13862 } ) 13863 ) + "px"; 13864 } 13865 } 13866); 13867 13868// These hooks are used by animate to expand properties 13869jQuery.each( { 13870 margin: "", 13871 padding: "", 13872 border: "Width" 13873}, function( prefix, suffix ) { 13874 jQuery.cssHooks[ prefix + suffix ] = { 13875 expand: function( value ) { 13876 var i = 0, 13877 expanded = {}, 13878 13879 // Assumes a single number if not a string 13880 parts = typeof value === "string" ? value.split( " " ) : [ value ]; 13881 13882 for ( ; i < 4; i++ ) { 13883 expanded[ prefix + cssExpand[ i ] + suffix ] = 13884 parts[ i ] || parts[ i - 2 ] || parts[ 0 ]; 13885 } 13886 13887 return expanded; 13888 } 13889 }; 13890 13891 if ( !rmargin.test( prefix ) ) { 13892 jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber; 13893 } 13894} ); 13895 13896jQuery.fn.extend( { 13897 css: function( name, value ) { 13898 return access( this, function( elem, name, value ) { 13899 var styles, len, 13900 map = {}, 13901 i = 0; 13902 13903 if ( Array.isArray( name ) ) { 13904 styles = getStyles( elem ); 13905 len = name.length; 13906 13907 for ( ; i < len; i++ ) { 13908 map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles ); 13909 } 13910 13911 return map; 13912 } 13913 13914 return value !== undefined ? 13915 jQuery.style( elem, name, value ) : 13916 jQuery.css( elem, name ); 13917 }, name, value, arguments.length > 1 ); 13918 } 13919} ); 13920 13921 13922function Tween( elem, options, prop, end, easing ) { 13923 return new Tween.prototype.init( elem, options, prop, end, easing ); 13924} 13925jQuery.Tween = Tween; 13926
vendor: 6,216 bytes, lines 13927-14165
13927Tween.prototype = { 13928 constructor: Tween, 13929 init: function( elem, options, prop, end, easing, unit ) { 13930 this.elem = elem; 13931 this.prop = prop; 13932 this.easing = easing || jQuery.easing._default; 13933 this.options = options; 13934 this.start = this.now = this.cur(); 13935 this.end = end; 13936 this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); 13937 }, 13938 cur: function() { 13939 var hooks = Tween.propHooks[ this.prop ]; 13940 13941 return hooks && hooks.get ? 13942 hooks.get( this ) : 13943 Tween.propHooks._default.get( this ); 13944 }, 13945 run: function( percent ) { 13946 var eased, 13947 hooks = Tween.propHooks[ this.prop ]; 13948 13949 if ( this.options.duration ) { 13950 this.pos = eased = jQuery.easing[ this.easing ]( 13951 percent, this.options.duration * percent, 0, 1, this.options.duration 13952 ); 13953 } else { 13954 this.pos = eased = percent; 13955 } 13956 this.now = ( this.end - this.start ) * eased + this.start; 13957 13958 if ( this.options.step ) { 13959 this.options.step.call( this.elem, this.now, this ); 13960 } 13961 13962 if ( hooks && hooks.set ) { 13963 hooks.set( this ); 13964 } else { 13965 Tween.propHooks._default.set( this ); 13966 } 13967 return this; 13968 } 13969}; 13970 13971Tween.prototype.init.prototype = Tween.prototype; 13972 13973Tween.propHooks = { 13974 _default: { 13975 get: function( tween ) { 13976 var result; 13977 13978 // Use a property on the element directly when it is not a DOM element, 13979 // or when there is no matching style property that exists. 13980 if ( tween.elem.nodeType !== 1 || 13981 tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) { 13982 return tween.elem[ tween.prop ]; 13983 } 13984 13985 // Passing an empty string as a 3rd parameter to .css will automatically 13986 // attempt a parseFloat and fallback to a string if the parse fails. 13987 // Simple values such as "10px" are parsed to Float; 13988 // complex values such as "rotate(1rad)" are returned as-is. 13989 result = jQuery.css( tween.elem, tween.prop, "" ); 13990 13991 // Empty strings, null, undefined and "auto" are converted to 0. 13992 return !result || result === "auto" ? 0 : result; 13993 }, 13994 set: function( tween ) { 13995 13996 // Use step hook for back compat. 13997 // Use cssHook if its there. 13998 // Use .style if available and use plain properties where available. 13999 if ( jQuery.fx.step[ tween.prop ] ) { 14000 jQuery.fx.step[ tween.prop ]( tween ); 14001 } else if ( tween.elem.nodeType === 1 && 14002 ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || 14003 jQuery.cssHooks[ tween.prop ] ) ) { 14004 jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); 14005 } else { 14006 tween.elem[ tween.prop ] = tween.now; 14007 } 14008 } 14009 } 14010}; 14011 14012// Support: IE <=9 only 14013// Panic based approach to setting things on disconnected nodes 14014Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { 14015 set: function( tween ) { 14016 if ( tween.elem.nodeType && tween.elem.parentNode ) { 14017 tween.elem[ tween.prop ] = tween.now; 14018 } 14019 } 14020}; 14021 14022jQuery.easing = { 14023 linear: function( p ) { 14024 return p; 14025 }, 14026 swing: function( p ) { 14027 return 0.5 - Math.cos( p * Math.PI ) / 2; 14028 }, 14029 _default: "swing" 14030}; 14031 14032jQuery.fx = Tween.prototype.init; 14033 14034// Back compat <1.8 extension point 14035jQuery.fx.step = {}; 14036 14037 14038 14039 14040var 14041 fxNow, inProgress, 14042 rfxtypes = /^(?:toggle|show|hide)$/, 14043 rrun = /queueHooks$/; 14044 14045function schedule() { 14046 if ( inProgress ) { 14047 if ( document.hidden === false && window.requestAnimationFrame ) { 14048 window.requestAnimationFrame( schedule ); 14049 } else { 14050 window.setTimeout( schedule, jQuery.fx.interval ); 14051 } 14052 14053 jQuery.fx.tick(); 14054 } 14055} 14056 14057// Animations created synchronously will run synchronously 14058function createFxNow() { 14059 window.setTimeout( function() { 14060 fxNow = undefined; 14061 } ); 14062 return ( fxNow = jQuery.now() ); 14063} 14064 14065// Generate parameters to create a standard animation 14066function genFx( type, includeWidth ) { 14067 var which, 14068 i = 0, 14069 attrs = { height: type }; 14070 14071 // If we include width, step value is 1 to do all cssExpand values, 14072 // otherwise step value is 2 to skip over Left and Right 14073 includeWidth = includeWidth ? 1 : 0; 14074 for ( ; i < 4; i += 2 - includeWidth ) { 14075 which = cssExpand[ i ]; 14076 attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; 14077 } 14078 14079 if ( includeWidth ) { 14080 attrs.opacity = attrs.width = type; 14081 } 14082 14083 return attrs; 14084} 14085 14086function createTween( value, prop, animation ) { 14087 var tween, 14088 collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ), 14089 index = 0, 14090 length = collection.length; 14091 for ( ; index < length; index++ ) { 14092 if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) { 14093 14094 // We're done with this property 14095 return tween; 14096 } 14097 } 14098} 14099 14100function defaultPrefilter( elem, props, opts ) { 14101 var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display, 14102 isBox = "width" in props || "height" in props, 14103 anim = this, 14104 orig = {}, 14105 style = elem.style, 14106 hidden = elem.nodeType && isHiddenWithinTree( elem ), 14107 dataShow = dataPriv.get( elem, "fxshow" ); 14108 14109 // Queue-skipping animations hijack the fx hooks 14110 if ( !opts.queue ) { 14111 hooks = jQuery._queueHooks( elem, "fx" ); 14112 if ( hooks.unqueued == null ) { 14113 hooks.unqueued = 0; 14114 oldfire = hooks.empty.fire; 14115 hooks.empty.fire = function() { 14116 if ( !hooks.unqueued ) { 14117 oldfire(); 14118 } 14119 }; 14120 } 14121 hooks.unqueued++; 14122 14123 anim.always( function() { 14124 14125 // Ensure the complete handler is called before this completes 14126 anim.always( function() { 14127 hooks.unqueued--; 14128 if ( !jQuery.queue( elem, "fx" ).length ) { 14129 hooks.empty.fire(); 14130 } 14131 } ); 14132 } ); 14133 } 14134 14135 // Detect show/hide animations 14136 for ( prop in props ) { 14137 value = props[ prop ]; 14138 if ( rfxtypes.test( value ) ) { 14139 delete props[ prop ]; 14140 toggle = toggle || value === "toggle"; 14141 if ( value === ( hidden ? "hide" : "show" ) ) { 14142 14143 // Pretend to be hidden if this is a "show" and 14144 // there is still data from a stopped show/hide 14145 if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) { 14146 hidden = true; 14147 14148 // Ignore all other no-op show/hide data 14149 } else { 14150 continue; 14151 } 14152 } 14153 orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop ); 14154 } 14155 } 14156 14157 // Bail out if this is a no-op like .hide().hide() 14158 propTween = !jQuery.isEmptyObject( props ); 14159 if ( !propTween && jQuery.isEmptyObject( orig ) ) { 14160 return; 14161 } 14162 14163 // Restrict "overflow" and "display" styles during box animations 14164 if ( isBox && elem.nodeType === 1 ) { 14165
vendor: 4,173 bytes, lines 14166-14324
14166 // Support: IE <=9 - 11, Edge 12 - 13 14167 // Record all 3 overflow attributes because IE does not infer the shorthand 14168 // from identically-valued overflowX and overflowY 14169 opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; 14170 14171 // Identify a display type, preferring old show/hide data over the CSS cascade 14172 restoreDisplay = dataShow && dataShow.display; 14173 if ( restoreDisplay == null ) { 14174 restoreDisplay = dataPriv.get( elem, "display" ); 14175 } 14176 display = jQuery.css( elem, "display" ); 14177 if ( display === "none" ) { 14178 if ( restoreDisplay ) { 14179 display = restoreDisplay; 14180 } else { 14181 14182 // Get nonempty value(s) by temporarily forcing visibility 14183 showHide( [ elem ], true ); 14184 restoreDisplay = elem.style.display || restoreDisplay; 14185 display = jQuery.css( elem, "display" ); 14186 showHide( [ elem ] ); 14187 } 14188 } 14189 14190 // Animate inline elements as inline-block 14191 if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) { 14192 if ( jQuery.css( elem, "float" ) === "none" ) { 14193 14194 // Restore the original display value at the end of pure show/hide animations 14195 if ( !propTween ) { 14196 anim.done( function() { 14197 style.display = restoreDisplay; 14198 } ); 14199 if ( restoreDisplay == null ) { 14200 display = style.display; 14201 restoreDisplay = display === "none" ? "" : display; 14202 } 14203 } 14204 style.display = "inline-block"; 14205 } 14206 } 14207 } 14208 14209 if ( opts.overflow ) { 14210 style.overflow = "hidden"; 14211 anim.always( function() { 14212 style.overflow = opts.overflow[ 0 ]; 14213 style.overflowX = opts.overflow[ 1 ]; 14214 style.overflowY = opts.overflow[ 2 ]; 14215 } ); 14216 } 14217 14218 // Implement show/hide animations 14219 propTween = false; 14220 for ( prop in orig ) { 14221 14222 // General show/hide setup for this element animation 14223 if ( !propTween ) { 14224 if ( dataShow ) { 14225 if ( "hidden" in dataShow ) { 14226 hidden = dataShow.hidden; 14227 } 14228 } else { 14229 dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } ); 14230 } 14231 14232 // Store hidden/visible for toggle so `.stop().toggle()` "reverses" 14233 if ( toggle ) { 14234 dataShow.hidden = !hidden; 14235 } 14236 14237 // Show elements before animating them 14238 if ( hidden ) { 14239 showHide( [ elem ], true ); 14240 } 14241 14242 /* eslint-disable no-loop-func */ 14243 14244 anim.done( function() { 14245 14246 /* eslint-enable no-loop-func */ 14247 14248 // The final step of a "hide" animation is actually hiding the element 14249 if ( !hidden ) { 14250 showHide( [ elem ] ); 14251 } 14252 dataPriv.remove( elem, "fxshow" ); 14253 for ( prop in orig ) { 14254 jQuery.style( elem, prop, orig[ prop ] ); 14255 } 14256 } ); 14257 } 14258 14259 // Per-property setup 14260 propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim ); 14261 if ( !( prop in dataShow ) ) { 14262 dataShow[ prop ] = propTween.start; 14263 if ( hidden ) { 14264 propTween.end = propTween.start; 14265 propTween.start = 0; 14266 } 14267 } 14268 } 14269} 14270 14271function propFilter( props, specialEasing ) { 14272 var index, name, easing, value, hooks; 14273 14274 // camelCase, specialEasing and expand cssHook pass 14275 for ( index in props ) { 14276 name = jQuery.camelCase( index ); 14277 easing = specialEasing[ name ]; 14278 value = props[ index ]; 14279 if ( Array.isArray( value ) ) { 14280 easing = value[ 1 ]; 14281 value = props[ index ] = value[ 0 ]; 14282 } 14283 14284 if ( index !== name ) { 14285 props[ name ] = value; 14286 delete props[ index ]; 14287 } 14288 14289 hooks = jQuery.cssHooks[ name ]; 14290 if ( hooks && "expand" in hooks ) { 14291 value = hooks.expand( value ); 14292 delete props[ name ]; 14293 14294 // Not quite $.extend, this won't overwrite existing keys. 14295 // Reusing 'index' because we have the correct "name" 14296 for ( index in value ) { 14297 if ( !( index in props ) ) { 14298 props[ index ] = value[ index ]; 14299 specialEasing[ index ] = easing; 14300 } 14301 } 14302 } else { 14303 specialEasing[ name ] = easing; 14304 } 14305 } 14306} 14307 14308function Animation( elem, properties, options ) { 14309 var result, 14310 stopped, 14311 index = 0, 14312 length = Animation.prefilters.length, 14313 deferred = jQuery.Deferred().always( function() { 14314 14315 // Don't match elem in the :animated selector 14316 delete tick.elem; 14317 } ), 14318 tick = function() { 14319 if ( stopped ) { 14320 return false; 14321 } 14322 var currentTime = fxNow || createFxNow(), 14323 remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ), 14324
vendor: 6,686 bytes, lines 14325-14584
14325 // Support: Android 2.3 only 14326 // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497) 14327 temp = remaining / animation.duration || 0, 14328 percent = 1 - temp, 14329 index = 0, 14330 length = animation.tweens.length; 14331 14332 for ( ; index < length; index++ ) { 14333 animation.tweens[ index ].run( percent ); 14334 } 14335 14336 deferred.notifyWith( elem, [ animation, percent, remaining ] ); 14337 14338 // If there's more to do, yield 14339 if ( percent < 1 && length ) { 14340 return remaining; 14341 } 14342 14343 // If this was an empty animation, synthesize a final progress notification 14344 if ( !length ) { 14345 deferred.notifyWith( elem, [ animation, 1, 0 ] ); 14346 } 14347 14348 // Resolve the animation and report its conclusion 14349 deferred.resolveWith( elem, [ animation ] ); 14350 return false; 14351 }, 14352 animation = deferred.promise( { 14353 elem: elem, 14354 props: jQuery.extend( {}, properties ), 14355 opts: jQuery.extend( true, { 14356 specialEasing: {}, 14357 easing: jQuery.easing._default 14358 }, options ), 14359 originalProperties: properties, 14360 originalOptions: options, 14361 startTime: fxNow || createFxNow(), 14362 duration: options.duration, 14363 tweens: [], 14364 createTween: function( prop, end ) { 14365 var tween = jQuery.Tween( elem, animation.opts, prop, end, 14366 animation.opts.specialEasing[ prop ] || animation.opts.easing ); 14367 animation.tweens.push( tween ); 14368 return tween; 14369 }, 14370 stop: function( gotoEnd ) { 14371 var index = 0, 14372 14373 // If we are going to the end, we want to run all the tweens 14374 // otherwise we skip this part 14375 length = gotoEnd ? animation.tweens.length : 0; 14376 if ( stopped ) { 14377 return this; 14378 } 14379 stopped = true; 14380 for ( ; index < length; index++ ) { 14381 animation.tweens[ index ].run( 1 ); 14382 } 14383 14384 // Resolve when we played the last frame; otherwise, reject 14385 if ( gotoEnd ) { 14386 deferred.notifyWith( elem, [ animation, 1, 0 ] ); 14387 deferred.resolveWith( elem, [ animation, gotoEnd ] ); 14388 } else { 14389 deferred.rejectWith( elem, [ animation, gotoEnd ] ); 14390 } 14391 return this; 14392 } 14393 } ), 14394 props = animation.props; 14395 14396 propFilter( props, animation.opts.specialEasing ); 14397 14398 for ( ; index < length; index++ ) { 14399 result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts ); 14400 if ( result ) { 14401 if ( jQuery.isFunction( result.stop ) ) { 14402 jQuery._queueHooks( animation.elem, animation.opts.queue ).stop = 14403 jQuery.proxy( result.stop, result ); 14404 } 14405 return result; 14406 } 14407 } 14408 14409 jQuery.map( props, createTween, animation ); 14410 14411 if ( jQuery.isFunction( animation.opts.start ) ) { 14412 animation.opts.start.call( elem, animation ); 14413 } 14414 14415 // Attach callbacks from options 14416 animation 14417 .progress( animation.opts.progress ) 14418 .done( animation.opts.done, animation.opts.complete ) 14419 .fail( animation.opts.fail ) 14420 .always( animation.opts.always ); 14421 14422 jQuery.fx.timer( 14423 jQuery.extend( tick, { 14424 elem: elem, 14425 anim: animation, 14426 queue: animation.opts.queue 14427 } ) 14428 ); 14429 14430 return animation; 14431} 14432 14433jQuery.Animation = jQuery.extend( Animation, { 14434 14435 tweeners: { 14436 "*": [ function( prop, value ) { 14437 var tween = this.createTween( prop, value ); 14438 adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween ); 14439 return tween; 14440 } ] 14441 }, 14442 14443 tweener: function( props, callback ) { 14444 if ( jQuery.isFunction( props ) ) { 14445 callback = props; 14446 props = [ "*" ]; 14447 } else { 14448 props = props.match( rnothtmlwhite ); 14449 } 14450 14451 var prop, 14452 index = 0, 14453 length = props.length; 14454 14455 for ( ; index < length; index++ ) { 14456 prop = props[ index ]; 14457 Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || []; 14458 Animation.tweeners[ prop ].unshift( callback ); 14459 } 14460 }, 14461 14462 prefilters: [ defaultPrefilter ], 14463 14464 prefilter: function( callback, prepend ) { 14465 if ( prepend ) { 14466 Animation.prefilters.unshift( callback ); 14467 } else { 14468 Animation.prefilters.push( callback ); 14469 } 14470 } 14471} ); 14472 14473jQuery.speed = function( speed, easing, fn ) { 14474 var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : { 14475 complete: fn || !fn && easing || 14476 jQuery.isFunction( speed ) && speed, 14477 duration: speed, 14478 easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing 14479 }; 14480 14481 // Go to the end state if fx are off 14482 if ( jQuery.fx.off ) { 14483 opt.duration = 0; 14484 14485 } else { 14486 if ( typeof opt.duration !== "number" ) { 14487 if ( opt.duration in jQuery.fx.speeds ) { 14488 opt.duration = jQuery.fx.speeds[ opt.duration ]; 14489 14490 } else { 14491 opt.duration = jQuery.fx.speeds._default; 14492 } 14493 } 14494 } 14495 14496 // Normalize opt.queue - true/undefined/null -> "fx" 14497 if ( opt.queue == null || opt.queue === true ) { 14498 opt.queue = "fx"; 14499 } 14500 14501 // Queueing 14502 opt.old = opt.complete; 14503 14504 opt.complete = function() { 14505 if ( jQuery.isFunction( opt.old ) ) { 14506 opt.old.call( this ); 14507 } 14508 14509 if ( opt.queue ) { 14510 jQuery.dequeue( this, opt.queue ); 14511 } 14512 }; 14513 14514 return opt; 14515}; 14516 14517jQuery.fn.extend( { 14518 fadeTo: function( speed, to, easing, callback ) { 14519 14520 // Show any hidden elements after setting opacity to 0 14521 return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show() 14522 14523 // Animate to the value specified 14524 .end().animate( { opacity: to }, speed, easing, callback ); 14525 }, 14526 animate: function( prop, speed, easing, callback ) { 14527 var empty = jQuery.isEmptyObject( prop ), 14528 optall = jQuery.speed( speed, easing, callback ), 14529 doAnimation = function() { 14530 14531 // Operate on a copy of prop so per-property easing won't be lost 14532 var anim = Animation( this, jQuery.extend( {}, prop ), optall ); 14533 14534 // Empty animations, or finishing resolves immediately 14535 if ( empty || dataPriv.get( this, "finish" ) ) { 14536 anim.stop( true ); 14537 } 14538 }; 14539 doAnimation.finish = doAnimation; 14540 14541 return empty || optall.queue === false ? 14542 this.each( doAnimation ) : 14543 this.queue( optall.queue, doAnimation ); 14544 }, 14545 stop: function( type, clearQueue, gotoEnd ) { 14546 var stopQueue = function( hooks ) { 14547 var stop = hooks.stop; 14548 delete hooks.stop; 14549 stop( gotoEnd ); 14550 }; 14551 14552 if ( typeof type !== "string" ) { 14553 gotoEnd = clearQueue; 14554 clearQueue = type; 14555 type = undefined; 14556 } 14557 if ( clearQueue && type !== false ) { 14558 this.queue( type || "fx", [] ); 14559 } 14560 14561 return this.each( function() { 14562 var dequeue = true, 14563 index = type != null && type + "queueHooks", 14564 timers = jQuery.timers, 14565 data = dataPriv.get( this ); 14566 14567 if ( index ) { 14568 if ( data[ index ] && data[ index ].stop ) { 14569 stopQueue( data[ index ] ); 14570 } 14571 } else { 14572 for ( index in data ) { 14573 if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { 14574 stopQueue( data[ index ] ); 14575 } 14576 } 14577 } 14578 14579 for ( index = timers.length; index--; ) { 14580 if ( timers[ index ].elem === this && 14581 ( type == null || timers[ index ].queue === type ) ) { 14582 14583 timers[ index ].anim.stop( gotoEnd ); 14584 dequeue = false;
vendor: 2,199 bytes, lines 14585-14669
14585 timers.splice( index, 1 ); 14586 } 14587 } 14588 14589 // Start the next in the queue if the last step wasn't forced. 14590 // Timers currently will call their complete callbacks, which 14591 // will dequeue but only if they were gotoEnd. 14592 if ( dequeue || !gotoEnd ) { 14593 jQuery.dequeue( this, type ); 14594 } 14595 } ); 14596 }, 14597 finish: function( type ) { 14598 if ( type !== false ) { 14599 type = type || "fx"; 14600 } 14601 return this.each( function() { 14602 var index, 14603 data = dataPriv.get( this ), 14604 queue = data[ type + "queue" ], 14605 hooks = data[ type + "queueHooks" ], 14606 timers = jQuery.timers, 14607 length = queue ? queue.length : 0; 14608 14609 // Enable finishing flag on private data 14610 data.finish = true; 14611 14612 // Empty the queue first 14613 jQuery.queue( this, type, [] ); 14614 14615 if ( hooks && hooks.stop ) { 14616 hooks.stop.call( this, true ); 14617 } 14618 14619 // Look for any active animations, and finish them 14620 for ( index = timers.length; index--; ) { 14621 if ( timers[ index ].elem === this && timers[ index ].queue === type ) { 14622 timers[ index ].anim.stop( true ); 14623 timers.splice( index, 1 ); 14624 } 14625 } 14626 14627 // Look for any animations in the old queue and finish them 14628 for ( index = 0; index < length; index++ ) { 14629 if ( queue[ index ] && queue[ index ].finish ) { 14630 queue[ index ].finish.call( this ); 14631 } 14632 } 14633 14634 // Turn off finishing flag 14635 delete data.finish; 14636 } ); 14637 } 14638} ); 14639 14640jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) { 14641 var cssFn = jQuery.fn[ name ]; 14642 jQuery.fn[ name ] = function( speed, easing, callback ) { 14643 return speed == null || typeof speed === "boolean" ? 14644 cssFn.apply( this, arguments ) : 14645 this.animate( genFx( name, true ), speed, easing, callback ); 14646 }; 14647} ); 14648 14649// Generate shortcuts for custom animations 14650jQuery.each( { 14651 slideDown: genFx( "show" ), 14652 slideUp: genFx( "hide" ), 14653 slideToggle: genFx( "toggle" ), 14654 fadeIn: { opacity: "show" }, 14655 fadeOut: { opacity: "hide" }, 14656 fadeToggle: { opacity: "toggle" } 14657}, function( name, props ) { 14658 jQuery.fn[ name ] = function( speed, easing, callback ) { 14659 return this.animate( props, speed, easing, callback ); 14660 }; 14661} ); 14662 14663jQuery.timers = []; 14664jQuery.fx.tick = function() { 14665 var timer, 14666 i = 0, 14667 timers = jQuery.timers; 14668 14669 fxNow = jQuery
vendor: 7,814 bytes, lines 14669-15022
14669.now(); 14670 14671 for ( ; i < timers.length; i++ ) { 14672 timer = timers[ i ]; 14673 14674 // Run the timer and safely remove it when done (allowing for external removal) 14675 if ( !timer() && timers[ i ] === timer ) { 14676 timers.splice( i--, 1 ); 14677 } 14678 } 14679 14680 if ( !timers.length ) { 14681 jQuery.fx.stop(); 14682 } 14683 fxNow = undefined; 14684}; 14685 14686jQuery.fx.timer = function( timer ) { 14687 jQuery.timers.push( timer ); 14688 jQuery.fx.start(); 14689}; 14690 14691jQuery.fx.interval = 13; 14692jQuery.fx.start = function() { 14693 if ( inProgress ) { 14694 return; 14695 } 14696 14697 inProgress = true; 14698 schedule(); 14699}; 14700 14701jQuery.fx.stop = function() { 14702 inProgress = null; 14703}; 14704 14705jQuery.fx.speeds = { 14706 slow: 600, 14707 fast: 200, 14708 14709 // Default speed 14710 _default: 400 14711}; 14712 14713 14714// Based off of the plugin by Clint Helfers, with permission. 14715// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/ 14716jQuery.fn.delay = function( time, type ) { 14717 time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; 14718 type = type || "fx"; 14719 14720 return this.queue( type, function( next, hooks ) { 14721 var timeout = window.setTimeout( next, time ); 14722 hooks.stop = function() { 14723 window.clearTimeout( timeout ); 14724 }; 14725 } ); 14726}; 14727 14728 14729( function() { 14730 var input = document.createElement( "input" ), 14731 select = document.createElement( "select" ), 14732 opt = select.appendChild( document.createElement( "option" ) ); 14733 14734 input.type = "checkbox"; 14735 14736 // Support: Android <=4.3 only 14737 // Default value for a checkbox should be "on" 14738 support.checkOn = input.value !== ""; 14739 14740 // Support: IE <=11 only 14741 // Must access selectedIndex to make default options select 14742 support.optSelected = opt.selected; 14743 14744 // Support: IE <=11 only 14745 // An input loses its value after becoming a radio 14746 input = document.createElement( "input" ); 14747 input.value = "t"; 14748 input.type = "radio"; 14749 support.radioValue = input.value === "t"; 14750} )(); 14751 14752 14753var boolHook, 14754 attrHandle = jQuery.expr.attrHandle; 14755 14756jQuery.fn.extend( { 14757 attr: function( name, value ) { 14758 return access( this, jQuery.attr, name, value, arguments.length > 1 ); 14759 }, 14760 14761 removeAttr: function( name ) { 14762 return this.each( function() { 14763 jQuery.removeAttr( this, name ); 14764 } ); 14765 } 14766} ); 14767 14768jQuery.extend( { 14769 attr: function( elem, name, value ) { 14770 var ret, hooks, 14771 nType = elem.nodeType; 14772 14773 // Don't get/set attributes on text, comment and attribute nodes 14774 if ( nType === 3 || nType === 8 || nType === 2 ) { 14775 return; 14776 } 14777 14778 // Fallback to prop when attributes are not supported 14779 if ( typeof elem.getAttribute === "undefined" ) { 14780 return jQuery.prop( elem, name, value ); 14781 } 14782 14783 // Attribute hooks are determined by the lowercase version 14784 // Grab necessary hook if one is defined 14785 if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { 14786 hooks = jQuery.attrHooks[ name.toLowerCase() ] || 14787 ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined ); 14788 } 14789 14790 if ( value !== undefined ) { 14791 if ( value === null ) { 14792 jQuery.removeAttr( elem, name ); 14793 return; 14794 } 14795 14796 if ( hooks && "set" in hooks && 14797 ( ret = hooks.set( elem, value, name ) ) !== undefined ) { 14798 return ret; 14799 } 14800 14801 elem.setAttribute( name, value + "" ); 14802 return value; 14803 } 14804 14805 if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { 14806 return ret; 14807 } 14808 14809 ret = jQuery.find.attr( elem, name ); 14810 14811 // Non-existent attributes return null, we normalize to undefined 14812 return ret == null ? undefined : ret; 14813 }, 14814 14815 attrHooks: { 14816 type: { 14817 set: function( elem, value ) { 14818 if ( !support.radioValue && value === "radio" && 14819 nodeName( elem, "input" ) ) { 14820 var val = elem.value; 14821 elem.setAttribute( "type", value ); 14822 if ( val ) { 14823 elem.value = val; 14824 } 14825 return value; 14826 } 14827 } 14828 } 14829 }, 14830 14831 removeAttr: function( elem, value ) { 14832 var name, 14833 i = 0, 14834 14835 // Attribute names can contain non-HTML whitespace characters 14836 // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2 14837 attrNames = value && value.match( rnothtmlwhite ); 14838 14839 if ( attrNames && elem.nodeType === 1 ) { 14840 while ( ( name = attrNames[ i++ ] ) ) { 14841 elem.removeAttribute( name ); 14842 } 14843 } 14844 } 14845} ); 14846 14847// Hooks for boolean attributes 14848boolHook = { 14849 set: function( elem, value, name ) { 14850 if ( value === false ) { 14851 14852 // Remove boolean attributes when set to false 14853 jQuery.removeAttr( elem, name ); 14854 } else { 14855 elem.setAttribute( name, name ); 14856 } 14857 return name; 14858 } 14859}; 14860 14861jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) { 14862 var getter = attrHandle[ name ] || jQuery.find.attr; 14863 14864 attrHandle[ name ] = function( elem, name, isXML ) { 14865 var ret, handle, 14866 lowercaseName = name.toLowerCase(); 14867 14868 if ( !isXML ) { 14869 14870 // Avoid an infinite loop by temporarily removing this function from the getter 14871 handle = attrHandle[ lowercaseName ]; 14872 attrHandle[ lowercaseName ] = ret; 14873 ret = getter( elem, name, isXML ) != null ? 14874 lowercaseName : 14875 null; 14876 attrHandle[ lowercaseName ] = handle; 14877 } 14878 return ret; 14879 }; 14880} ); 14881 14882 14883 14884 14885var rfocusable = /^(?:input|select|textarea|button)$/i, 14886 rclickable = /^(?:a|area)$/i; 14887 14888jQuery.fn.extend( { 14889 prop: function( name, value ) { 14890 return access( this, jQuery.prop, name, value, arguments.length > 1 ); 14891 }, 14892 14893 removeProp: function( name ) { 14894 return this.each( function() { 14895 delete this[ jQuery.propFix[ name ] || name ]; 14896 } ); 14897 } 14898} ); 14899 14900jQuery.extend( { 14901 prop: function( elem, name, value ) { 14902 var ret, hooks, 14903 nType = elem.nodeType; 14904 14905 // Don't get/set properties on text, comment and attribute nodes 14906 if ( nType === 3 || nType === 8 || nType === 2 ) { 14907 return; 14908 } 14909 14910 if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { 14911 14912 // Fix name and attach hooks 14913 name = jQuery.propFix[ name ] || name; 14914 hooks = jQuery.propHooks[ name ]; 14915 } 14916 14917 if ( value !== undefined ) { 14918 if ( hooks && "set" in hooks && 14919 ( ret = hooks.set( elem, value, name ) ) !== undefined ) { 14920 return ret; 14921 } 14922 14923 return ( elem[ name ] = value ); 14924 } 14925 14926 if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { 14927 return ret; 14928 } 14929 14930 return elem[ name ]; 14931 }, 14932 14933 propHooks: { 14934 tabIndex: { 14935 get: function( elem ) { 14936 14937 // Support: IE <=9 - 11 only 14938 // elem.tabIndex doesn't always return the 14939 // correct value when it hasn't been explicitly set 14940 // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ 14941 // Use proper attribute retrieval(#12072) 14942 var tabindex = jQuery.find.attr( elem, "tabindex" ); 14943 14944 if ( tabindex ) { 14945 return parseInt( tabindex, 10 ); 14946 } 14947 14948 if ( 14949 rfocusable.test( elem.nodeName ) || 14950 rclickable.test( elem.nodeName ) && 14951 elem.href 14952 ) { 14953 return 0; 14954 } 14955 14956 return -1; 14957 } 14958 } 14959 }, 14960 14961 propFix: { 14962 "for": "htmlFor", 14963 "class": "className" 14964 } 14965} ); 14966 14967// Support: IE <=11 only 14968// Accessing the selectedIndex property 14969// forces the browser to respect setting selected 14970// on the option 14971// The getter ensures a default option is selected 14972// when in an optgroup 14973// eslint rule "no-unused-expressions" is disabled for this code 14974// since it considers such accessions noop 14975if ( !support.optSelected ) { 14976 jQuery.propHooks.selected = { 14977 get: function( elem ) { 14978 14979 /* eslint no-unused-expressions: "off" */ 14980 14981 var parent = elem.parentNode; 14982 if ( parent && parent.parentNode ) { 14983 parent.parentNode.selectedIndex; 14984 } 14985 return null; 14986 }, 14987 set: function( elem ) { 14988 14989 /* eslint no-unused-expressions: "off" */ 14990 14991 var parent = elem.parentNode; 14992 if ( parent ) { 14993 parent.selectedIndex; 14994 14995 if ( parent.parentNode ) { 14996 parent.parentNode.selectedIndex; 14997 } 14998 } 14999 } 15000 }; 15001} 15002 15003jQuery.each( [ 15004 "tabIndex", 15005 "readOnly", 15006 "maxLength", 15007 "cellSpacing", 15008 "cellPadding", 15009 "rowSpan", 15010 "colSpan", 15011 "useMap", 15012 "frameBorder", 15013 "contentEditable" 15014], function() { 15015 jQuery.propFix[ this.toLowerCase() ] = this; 15016} ); 15017 15018 15019 15020 15021 // Strip and collapse whitespace according to HTML spec 15022 // https://
vendor: 4,260 bytes, lines 15022-15188
15022html.spec.whatwg.org/multipage/infrastructure.html#strip-and-collapse-whitespace 15023 function stripAndCollapse( value ) { 15024 var tokens = value.match( rnothtmlwhite ) || []; 15025 return tokens.join( " " ); 15026 } 15027 15028 15029function getClass( elem ) { 15030 return elem.getAttribute && elem.getAttribute( "class" ) || ""; 15031} 15032 15033jQuery.fn.extend( { 15034 addClass: function( value ) { 15035 var classes, elem, cur, curValue, clazz, j, finalValue, 15036 i = 0; 15037 15038 if ( jQuery.isFunction( value ) ) { 15039 return this.each( function( j ) { 15040 jQuery( this ).addClass( value.call( this, j, getClass( this ) ) ); 15041 } ); 15042 } 15043 15044 if ( typeof value === "string" && value ) { 15045 classes = value.match( rnothtmlwhite ) || []; 15046 15047 while ( ( elem = this[ i++ ] ) ) { 15048 curValue = getClass( elem ); 15049 cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); 15050 15051 if ( cur ) { 15052 j = 0; 15053 while ( ( clazz = classes[ j++ ] ) ) { 15054 if ( cur.indexOf( " " + clazz + " " ) < 0 ) { 15055 cur += clazz + " "; 15056 } 15057 } 15058 15059 // Only assign if different to avoid unneeded rendering. 15060 finalValue = stripAndCollapse( cur ); 15061 if ( curValue !== finalValue ) { 15062 elem.setAttribute( "class", finalValue ); 15063 } 15064 } 15065 } 15066 } 15067 15068 return this; 15069 }, 15070 15071 removeClass: function( value ) { 15072 var classes, elem, cur, curValue, clazz, j, finalValue, 15073 i = 0; 15074 15075 if ( jQuery.isFunction( value ) ) { 15076 return this.each( function( j ) { 15077 jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) ); 15078 } ); 15079 } 15080 15081 if ( !arguments.length ) { 15082 return this.attr( "class", "" ); 15083 } 15084 15085 if ( typeof value === "string" && value ) { 15086 classes = value.match( rnothtmlwhite ) || []; 15087 15088 while ( ( elem = this[ i++ ] ) ) { 15089 curValue = getClass( elem ); 15090 15091 // This expression is here for better compressibility (see addClass) 15092 cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); 15093 15094 if ( cur ) { 15095 j = 0; 15096 while ( ( clazz = classes[ j++ ] ) ) { 15097 15098 // Remove *all* instances 15099 while ( cur.indexOf( " " + clazz + " " ) > -1 ) { 15100 cur = cur.replace( " " + clazz + " ", " " ); 15101 } 15102 } 15103 15104 // Only assign if different to avoid unneeded rendering. 15105 finalValue = stripAndCollapse( cur ); 15106 if ( curValue !== finalValue ) { 15107 elem.setAttribute( "class", finalValue ); 15108 } 15109 } 15110 } 15111 } 15112 15113 return this; 15114 }, 15115 15116 toggleClass: function( value, stateVal ) { 15117 var type = typeof value; 15118 15119 if ( typeof stateVal === "boolean" && type === "string" ) { 15120 return stateVal ? this.addClass( value ) : this.removeClass( value ); 15121 } 15122 15123 if ( jQuery.isFunction( value ) ) { 15124 return this.each( function( i ) { 15125 jQuery( this ).toggleClass( 15126 value.call( this, i, getClass( this ), stateVal ), 15127 stateVal 15128 ); 15129 } ); 15130 } 15131 15132 return this.each( function() { 15133 var className, i, self, classNames; 15134 15135 if ( type === "string" ) { 15136 15137 // Toggle individual class names 15138 i = 0; 15139 self = jQuery( this ); 15140 classNames = value.match( rnothtmlwhite ) || []; 15141 15142 while ( ( className = classNames[ i++ ] ) ) { 15143 15144 // Check each className given, space separated list 15145 if ( self.hasClass( className ) ) { 15146 self.removeClass( className ); 15147 } else { 15148 self.addClass( className ); 15149 } 15150 } 15151 15152 // Toggle whole class name 15153 } else if ( value === undefined || type === "boolean" ) { 15154 className = getClass( this ); 15155 if ( className ) { 15156 15157 // Store className if set 15158 dataPriv.set( this, "__className__", className ); 15159 } 15160 15161 // If the element has a class name or if we're passed `false`, 15162 // then remove the whole classname (if there was one, the above saved it). 15163 // Otherwise bring back whatever was previously saved (if anything), 15164 // falling back to the empty string if nothing was stored. 15165 if ( this.setAttribute ) { 15166 this.setAttribute( "class", 15167 className || value === false ? 15168 "" : 15169 dataPriv.get( this, "__className__" ) || "" 15170 ); 15171 } 15172 } 15173 } ); 15174 }, 15175 15176 hasClass: function( selector ) { 15177 var className, elem, 15178 i = 0; 15179 15180 className = " " + selector + " "; 15181 while ( ( elem = this[ i++ ] ) ) { 15182 if ( elem.nodeType === 1 && 15183 ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) { 15184 return true; 15185 } 15186 } 15187 15188 return false;
vendor: 1,377 bytes, lines 15189-15258
15189 } 15190} ); 15191 15192 15193 15194 15195var rreturn = /\r/g; 15196 15197jQuery.fn.extend( { 15198 val: function( value ) { 15199 var hooks, ret, isFunction, 15200 elem = this[ 0 ]; 15201 15202 if ( !arguments.length ) { 15203 if ( elem ) { 15204 hooks = jQuery.valHooks[ elem.type ] || 15205 jQuery.valHooks[ elem.nodeName.toLowerCase() ]; 15206 15207 if ( hooks && 15208 "get" in hooks && 15209 ( ret = hooks.get( elem, "value" ) ) !== undefined 15210 ) { 15211 return ret; 15212 } 15213 15214 ret = elem.value; 15215 15216 // Handle most common string cases 15217 if ( typeof ret === "string" ) { 15218 return ret.replace( rreturn, "" ); 15219 } 15220 15221 // Handle cases where value is null/undef or number 15222 return ret == null ? "" : ret; 15223 } 15224 15225 return; 15226 } 15227 15228 isFunction = jQuery.isFunction( value ); 15229 15230 return this.each( function( i ) { 15231 var val; 15232 15233 if ( this.nodeType !== 1 ) { 15234 return; 15235 } 15236 15237 if ( isFunction ) { 15238 val = value.call( this, i, jQuery( this ).val() ); 15239 } else { 15240 val = value; 15241 } 15242 15243 // Treat null/undefined as ""; convert numbers to string 15244 if ( val == null ) { 15245 val = ""; 15246 15247 } else if ( typeof val === "number" ) { 15248 val += ""; 15249 15250 } else if ( Array.isArray( val ) ) { 15251 val = jQuery.map( val, function( value ) { 15252 return value == null ? "" : value + ""; 15253 } ); 15254 } 15255 15256 hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; 15257 15258 // If set returns undefined, fall back to normal setting
vendor: 8,160 bytes, lines 15259-15577
15259 if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) { 15260 this.value = val; 15261 } 15262 } ); 15263 } 15264} ); 15265 15266jQuery.extend( { 15267 valHooks: { 15268 option: { 15269 get: function( elem ) { 15270 15271 var val = jQuery.find.attr( elem, "value" ); 15272 return val != null ? 15273 val : 15274 15275 // Support: IE <=10 - 11 only 15276 // option.text throws exceptions (#14686, #14858) 15277 // Strip and collapse whitespace 15278 // https://html.spec.whatwg.org/#strip-and-collapse-whitespace 15279 stripAndCollapse( jQuery.text( elem ) ); 15280 } 15281 }, 15282 select: { 15283 get: function( elem ) { 15284 var value, option, i, 15285 options = elem.options, 15286 index = elem.selectedIndex, 15287 one = elem.type === "select-one", 15288 values = one ? null : [], 15289 max = one ? index + 1 : options.length; 15290 15291 if ( index < 0 ) { 15292 i = max; 15293 15294 } else { 15295 i = one ? index : 0; 15296 } 15297 15298 // Loop through all the selected options 15299 for ( ; i < max; i++ ) { 15300 option = options[ i ]; 15301 15302 // Support: IE <=9 only 15303 // IE8-9 doesn't update selected after form reset (#2551) 15304 if ( ( option.selected || i === index ) && 15305 15306 // Don't return options that are disabled or in a disabled optgroup 15307 !option.disabled && 15308 ( !option.parentNode.disabled || 15309 !nodeName( option.parentNode, "optgroup" ) ) ) { 15310 15311 // Get the specific value for the option 15312 value = jQuery( option ).val(); 15313 15314 // We don't need an array for one selects 15315 if ( one ) { 15316 return value; 15317 } 15318 15319 // Multi-Selects return an array 15320 values.push( value ); 15321 } 15322 } 15323 15324 return values; 15325 }, 15326 15327 set: function( elem, value ) { 15328 var optionSet, option, 15329 options = elem.options, 15330 values = jQuery.makeArray( value ), 15331 i = options.length; 15332 15333 while ( i-- ) { 15334 option = options[ i ]; 15335 15336 /* eslint-disable no-cond-assign */ 15337 15338 if ( option.selected = 15339 jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 15340 ) { 15341 optionSet = true; 15342 } 15343 15344 /* eslint-enable no-cond-assign */ 15345 } 15346 15347 // Force browsers to behave consistently when non-matching value is set 15348 if ( !optionSet ) { 15349 elem.selectedIndex = -1; 15350 } 15351 return values; 15352 } 15353 } 15354 } 15355} ); 15356 15357// Radios and checkboxes getter/setter 15358jQuery.each( [ "radio", "checkbox" ], function() { 15359 jQuery.valHooks[ this ] = { 15360 set: function( elem, value ) { 15361 if ( Array.isArray( value ) ) { 15362 return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 ); 15363 } 15364 } 15365 }; 15366 if ( !support.checkOn ) { 15367 jQuery.valHooks[ this ].get = function( elem ) { 15368 return elem.getAttribute( "value" ) === null ? "on" : elem.value; 15369 }; 15370 } 15371} ); 15372 15373 15374 15375 15376// Return jQuery for attributes-only inclusion 15377 15378 15379var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/; 15380 15381jQuery.extend( jQuery.event, { 15382 15383 trigger: function( event, data, elem, onlyHandlers ) { 15384 15385 var i, cur, tmp, bubbleType, ontype, handle, special, 15386 eventPath = [ elem || document ], 15387 type = hasOwn.call( event, "type" ) ? event.type : event, 15388 namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : []; 15389 15390 cur = tmp = elem = elem || document; 15391 15392 // Don't do events on text and comment nodes 15393 if ( elem.nodeType === 3 || elem.nodeType === 8 ) { 15394 return; 15395 } 15396 15397 // focus/blur morphs to focusin/out; ensure we're not firing them right now 15398 if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { 15399 return; 15400 } 15401 15402 if ( type.indexOf( "." ) > -1 ) { 15403 15404 // Namespaced trigger; create a regexp to match event type in handle() 15405 namespaces = type.split( "." ); 15406 type = namespaces.shift(); 15407 namespaces.sort(); 15408 } 15409 ontype = type.indexOf( ":" ) < 0 && "on" + type; 15410 15411 // Caller can pass in a jQuery.Event object, Object, or just an event type string 15412 event = event[ jQuery.expando ] ? 15413 event : 15414 new jQuery.Event( type, typeof event === "object" && event ); 15415 15416 // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) 15417 event.isTrigger = onlyHandlers ? 2 : 3; 15418 event.namespace = namespaces.join( "." ); 15419 event.rnamespace = event.namespace ? 15420 new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) : 15421 null; 15422 15423 // Clean up the event in case it is being reused 15424 event.result = undefined; 15425 if ( !event.target ) { 15426 event.target = elem; 15427 } 15428 15429 // Clone any incoming data and prepend the event, creating the handler arg list 15430 data = data == null ? 15431 [ event ] : 15432 jQuery.makeArray( data, [ event ] ); 15433 15434 // Allow special events to draw outside the lines 15435 special = jQuery.event.special[ type ] || {}; 15436 if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { 15437 return; 15438 } 15439 15440 // Determine event propagation path in advance, per W3C events spec (#9951) 15441 // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) 15442 if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) { 15443 15444 bubbleType = special.delegateType || type; 15445 if ( !rfocusMorph.test( bubbleType + type ) ) { 15446 cur = cur.parentNode; 15447 } 15448 for ( ; cur; cur = cur.parentNode ) { 15449 eventPath.push( cur ); 15450 tmp = cur; 15451 } 15452 15453 // Only add window if we got to document (e.g., not plain obj or detached DOM) 15454 if ( tmp === ( elem.ownerDocument || document ) ) { 15455 eventPath.push( tmp.defaultView || tmp.parentWindow || window ); 15456 } 15457 } 15458 15459 // Fire handlers on the event path 15460 i = 0; 15461 while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) { 15462 15463 event.type = i > 1 ? 15464 bubbleType : 15465 special.bindType || type; 15466 15467 // jQuery handler 15468 handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] && 15469 dataPriv.get( cur, "handle" ); 15470 if ( handle ) { 15471 handle.apply( cur, data ); 15472 } 15473 15474 // Native handler 15475 handle = ontype && cur[ ontype ]; 15476 if ( handle && handle.apply && acceptData( cur ) ) { 15477 event.result = handle.apply( cur, data ); 15478 if ( event.result === false ) { 15479 event.preventDefault(); 15480 } 15481 } 15482 } 15483 event.type = type; 15484 15485 // If nobody prevented the default action, do it now 15486 if ( !onlyHandlers && !event.isDefaultPrevented() ) { 15487 15488 if ( ( !special._default || 15489 special._default.apply( eventPath.pop(), data ) === false ) && 15490 acceptData( elem ) ) { 15491 15492 // Call a native DOM method on the target with the same name as the event. 15493 // Don't do default actions on window, that's where global variables be (#6170) 15494 if ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) { 15495 15496 // Don't re-trigger an onFOO event when we call its FOO() method 15497 tmp = elem[ ontype ]; 15498 15499 if ( tmp ) { 15500 elem[ ontype ] = null; 15501 } 15502 15503 // Prevent re-triggering of the same event, since we already bubbled it above 15504 jQuery.event.triggered = type; 15505 elem[ type ](); 15506 jQuery.event.triggered = undefined; 15507 15508 if ( tmp ) { 15509 elem[ ontype ] = tmp; 15510 } 15511 } 15512 } 15513 } 15514 15515 return event.result; 15516 }, 15517 15518 // Piggyback on a donor event to simulate a different one 15519 // Used only for `focus(in | out)` events 15520 simulate: function( type, elem, event ) { 15521 var e = jQuery.extend( 15522 new jQuery.Event(), 15523 event, 15524 { 15525 type: type, 15526 isSimulated: true 15527 } 15528 ); 15529 15530 jQuery.event.trigger( e, null, elem ); 15531 } 15532 15533} ); 15534 15535jQuery.fn.extend( { 15536 15537 trigger: function( type, data ) { 15538 return this.each( function() { 15539 jQuery.event.trigger( type, data, this ); 15540 } ); 15541 }, 15542 triggerHandler: function( type, data ) { 15543 var elem = this[ 0 ]; 15544 if ( elem ) { 15545 return jQuery.event.trigger( type, data, elem, true ); 15546 } 15547 } 15548} ); 15549 15550 15551jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " + 15552 "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + 15553 "change select submit keydown keypress keyup contextmenu" ).split( " " ), 15554 function( i, name ) { 15555 15556 // Handle event binding 15557 jQuery.fn[ name ] = function( data, fn ) { 15558 return arguments.length > 0 ? 15559 this.on( name, null, data, fn ) : 15560 this.trigger( name ); 15561 }; 15562} ); 15563 15564jQuery.fn.extend( { 15565 hover: function( fnOver, fnOut ) { 15566 return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver ); 15567 } 15568} ); 15569 15570 15571 15572 15573support.focusin = "onfocusin" in window; 15574 15575 15576// Support: Firefox <=44 15577// Firefox doesn't have focus(in | out) events
vendor: 4,174 bytes, lines 15578-15741
15578// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787 15579// 15580// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1 15581// focus(in | out) events fire after focus & blur events, 15582// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order 15583// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857 15584if ( !support.focusin ) { 15585 jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) { 15586 15587 // Attach a single capturing handler on the document while someone wants focusin/focusout 15588 var handler = function( event ) { 15589 jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) ); 15590 }; 15591 15592 jQuery.event.special[ fix ] = { 15593 setup: function() { 15594 var doc = this.ownerDocument || this, 15595 attaches = dataPriv.access( doc, fix ); 15596 15597 if ( !attaches ) { 15598 doc.addEventListener( orig, handler, true ); 15599 } 15600 dataPriv.access( doc, fix, ( attaches || 0 ) + 1 ); 15601 }, 15602 teardown: function() { 15603 var doc = this.ownerDocument || this, 15604 attaches = dataPriv.access( doc, fix ) - 1; 15605 15606 if ( !attaches ) { 15607 doc.removeEventListener( orig, handler, true ); 15608 dataPriv.remove( doc, fix ); 15609 15610 } else { 15611 dataPriv.access( doc, fix, attaches ); 15612 } 15613 } 15614 }; 15615 } ); 15616} 15617var location = window.location; 15618 15619var nonce = jQuery.now(); 15620 15621var rquery = ( /\?/ ); 15622 15623 15624 15625// Cross-browser xml parsing 15626jQuery.parseXML = function( data ) { 15627 var xml; 15628 if ( !data || typeof data !== "string" ) { 15629 return null; 15630 } 15631 15632 // Support: IE 9 - 11 only 15633 // IE throws on parseFromString with invalid input. 15634 try { 15635 xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" ); 15636 } catch ( e ) { 15637 xml = undefined; 15638 } 15639 15640 if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) { 15641 jQuery.error( "Invalid XML: " + data ); 15642 } 15643 return xml; 15644}; 15645 15646 15647var 15648 rbracket = /\[\]$/, 15649 rCRLF = /\r?\n/g, 15650 rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, 15651 rsubmittable = /^(?:input|select|textarea|keygen)/i; 15652 15653function buildParams( prefix, obj, traditional, add ) { 15654 var name; 15655 15656 if ( Array.isArray( obj ) ) { 15657 15658 // Serialize array item. 15659 jQuery.each( obj, function( i, v ) { 15660 if ( traditional || rbracket.test( prefix ) ) { 15661 15662 // Treat each array item as a scalar. 15663 add( prefix, v ); 15664 15665 } else { 15666 15667 // Item is non-scalar (array or object), encode its numeric index. 15668 buildParams( 15669 prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]", 15670 v, 15671 traditional, 15672 add 15673 ); 15674 } 15675 } ); 15676 15677 } else if ( !traditional && jQuery.type( obj ) === "object" ) { 15678 15679 // Serialize object item. 15680 for ( name in obj ) { 15681 buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); 15682 } 15683 15684 } else { 15685 15686 // Serialize scalar item. 15687 add( prefix, obj ); 15688 } 15689} 15690 15691// Serialize an array of form elements or a set of 15692// key/values into a query string 15693jQuery.param = function( a, traditional ) { 15694 var prefix, 15695 s = [], 15696 add = function( key, valueOrFunction ) { 15697 15698 // If value is a function, invoke it and use its return value 15699 var value = jQuery.isFunction( valueOrFunction ) ? 15700 valueOrFunction() : 15701 valueOrFunction; 15702 15703 s[ s.length ] = encodeURIComponent( key ) + "=" + 15704 encodeURIComponent( value == null ? "" : value ); 15705 }; 15706 15707 // If an array was passed in, assume that it is an array of form elements. 15708 if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) { 15709 15710 // Serialize the form elements 15711 jQuery.each( a, function() { 15712 add( this.name, this.value ); 15713 } ); 15714 15715 } else { 15716 15717 // If traditional, encode the "old" way (the way 1.3.2 or older 15718 // did it), otherwise encode params recursively. 15719 for ( prefix in a ) { 15720 buildParams( prefix, a[ prefix ], traditional, add ); 15721 } 15722 } 15723 15724 // Return the resulting serialization 15725 return s.join( "&" ); 15726}; 15727 15728jQuery.fn.extend( { 15729 serialize: function() { 15730 return jQuery.param( this.serializeArray() ); 15731 }, 15732 serializeArray: function() { 15733 return this.map( function() { 15734 15735 // Can add propHook for "elements" to filter or add form elements 15736 var elements = jQuery.prop( this, "elements" ); 15737 return elements ? jQuery.makeArray( elements ) : this; 15738 } ) 15739 .filter( function() { 15740 var type = this.type; 15741
vendor: 4,939 bytes, lines 15742-15914
15742 // Use .is( ":disabled" ) so that fieldset[disabled] works 15743 return this.name && !jQuery( this ).is( ":disabled" ) && 15744 rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) && 15745 ( this.checked || !rcheckableType.test( type ) ); 15746 } ) 15747 .map( function( i, elem ) { 15748 var val = jQuery( this ).val(); 15749 15750 if ( val == null ) { 15751 return null; 15752 } 15753 15754 if ( Array.isArray( val ) ) { 15755 return jQuery.map( val, function( val ) { 15756 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; 15757 } ); 15758 } 15759 15760 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; 15761 } ).get(); 15762 } 15763} ); 15764 15765 15766var 15767 r20 = /%20/g, 15768 rhash = /#.*$/, 15769 rantiCache = /([?&])_=[^&]*/, 15770 rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg, 15771 15772 // #7653, #8125, #8152: local protocol detection 15773 rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, 15774 rnoContent = /^(?:GET|HEAD)$/, 15775 rprotocol = /^\/\//, 15776 15777 /* Prefilters 15778 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example) 15779 * 2) These are called: 15780 * - BEFORE asking for a transport 15781 * - AFTER param serialization (s.data is a string if s.processData is true) 15782 * 3) key is the dataType 15783 * 4) the catchall symbol "*" can be used 15784 * 5) execution will start with transport dataType and THEN continue down to "*" if needed 15785 */ 15786 prefilters = {}, 15787 15788 /* Transports bindings 15789 * 1) key is the dataType 15790 * 2) the catchall symbol "*" can be used 15791 * 3) selection will start with transport dataType and THEN go to "*" if needed 15792 */ 15793 transports = {}, 15794 15795 // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression 15796 allTypes = "*/".concat( "*" ), 15797 15798 // Anchor tag for parsing the document origin 15799 originAnchor = document.createElement( "a" ); 15800 originAnchor.href = location.href; 15801 15802// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport 15803function addToPrefiltersOrTransports( structure ) { 15804 15805 // dataTypeExpression is optional and defaults to "*" 15806 return function( dataTypeExpression, func ) { 15807 15808 if ( typeof dataTypeExpression !== "string" ) { 15809 func = dataTypeExpression; 15810 dataTypeExpression = "*"; 15811 } 15812 15813 var dataType, 15814 i = 0, 15815 dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || []; 15816 15817 if ( jQuery.isFunction( func ) ) { 15818 15819 // For each dataType in the dataTypeExpression 15820 while ( ( dataType = dataTypes[ i++ ] ) ) { 15821 15822 // Prepend if requested 15823 if ( dataType[ 0 ] === "+" ) { 15824 dataType = dataType.slice( 1 ) || "*"; 15825 ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func ); 15826 15827 // Otherwise append 15828 } else { 15829 ( structure[ dataType ] = structure[ dataType ] || [] ).push( func ); 15830 } 15831 } 15832 } 15833 }; 15834} 15835 15836// Base inspection function for prefilters and transports 15837function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) { 15838 15839 var inspected = {}, 15840 seekingTransport = ( structure === transports ); 15841 15842 function inspect( dataType ) { 15843 var selected; 15844 inspected[ dataType ] = true; 15845 jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) { 15846 var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR ); 15847 if ( typeof dataTypeOrTransport === "string" && 15848 !seekingTransport && !inspected[ dataTypeOrTransport ] ) { 15849 15850 options.dataTypes.unshift( dataTypeOrTransport ); 15851 inspect( dataTypeOrTransport ); 15852 return false; 15853 } else if ( seekingTransport ) { 15854 return !( selected = dataTypeOrTransport ); 15855 } 15856 } ); 15857 return selected; 15858 } 15859 15860 return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" ); 15861} 15862 15863// A special extend for ajax options 15864// that takes "flat" options (not to be deep extended) 15865// Fixes #9887 15866function ajaxExtend( target, src ) { 15867 var key, deep, 15868 flatOptions = jQuery.ajaxSettings.flatOptions || {}; 15869 15870 for ( key in src ) { 15871 if ( src[ key ] !== undefined ) { 15872 ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; 15873 } 15874 } 15875 if ( deep ) { 15876 jQuery.extend( true, target, deep ); 15877 } 15878 15879 return target; 15880} 15881 15882/* Handles responses to an ajax request: 15883 * - finds the right dataType (mediates between content-type and expected dataType) 15884 * - returns the corresponding response 15885 */ 15886function ajaxHandleResponses( s, jqXHR, responses ) { 15887 15888 var ct, type, finalDataType, firstDataType, 15889 contents = s.contents, 15890 dataTypes = s.dataTypes; 15891 15892 // Remove auto dataType and get content-type in the process 15893 while ( dataTypes[ 0 ] === "*" ) { 15894 dataTypes.shift(); 15895 if ( ct === undefined ) { 15896 ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" ); 15897 } 15898 } 15899 15900 // Check if we're dealing with a known content-type 15901 if ( ct ) { 15902 for ( type in contents ) { 15903 if ( contents[ type ] && contents[ type ].test( ct ) ) { 15904 dataTypes.unshift( type ); 15905 break; 15906 } 15907 } 15908 } 15909 15910 // Check to see if we have a response for the expected dataType 15911 if ( dataTypes[ 0 ] in responses ) { 15912 finalDataType = dataTypes[ 0 ]; 15913 } else { 15914
vendor: 18,932 bytes, lines 15915-16672
15915 // Try convertible dataTypes 15916 for ( type in responses ) { 15917 if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) { 15918 finalDataType = type; 15919 break; 15920 } 15921 if ( !firstDataType ) { 15922 firstDataType = type; 15923 } 15924 } 15925 15926 // Or just use first one 15927 finalDataType = finalDataType || firstDataType; 15928 } 15929 15930 // If we found a dataType 15931 // We add the dataType to the list if needed 15932 // and return the corresponding response 15933 if ( finalDataType ) { 15934 if ( finalDataType !== dataTypes[ 0 ] ) { 15935 dataTypes.unshift( finalDataType ); 15936 } 15937 return responses[ finalDataType ]; 15938 } 15939} 15940 15941/* Chain conversions given the request and the original response 15942 * Also sets the responseXXX fields on the jqXHR instance 15943 */ 15944function ajaxConvert( s, response, jqXHR, isSuccess ) { 15945 var conv2, current, conv, tmp, prev, 15946 converters = {}, 15947 15948 // Work with a copy of dataTypes in case we need to modify it for conversion 15949 dataTypes = s.dataTypes.slice(); 15950 15951 // Create converters map with lowercased keys 15952 if ( dataTypes[ 1 ] ) { 15953 for ( conv in s.converters ) { 15954 converters[ conv.toLowerCase() ] = s.converters[ conv ]; 15955 } 15956 } 15957 15958 current = dataTypes.shift(); 15959 15960 // Convert to each sequential dataType 15961 while ( current ) { 15962 15963 if ( s.responseFields[ current ] ) { 15964 jqXHR[ s.responseFields[ current ] ] = response; 15965 } 15966 15967 // Apply the dataFilter if provided 15968 if ( !prev && isSuccess && s.dataFilter ) { 15969 response = s.dataFilter( response, s.dataType ); 15970 } 15971 15972 prev = current; 15973 current = dataTypes.shift(); 15974 15975 if ( current ) { 15976 15977 // There's only work to do if current dataType is non-auto 15978 if ( current === "*" ) { 15979 15980 current = prev; 15981 15982 // Convert response if prev dataType is non-auto and differs from current 15983 } else if ( prev !== "*" && prev !== current ) { 15984 15985 // Seek a direct converter 15986 conv = converters[ prev + " " + current ] || converters[ "* " + current ]; 15987 15988 // If none found, seek a pair 15989 if ( !conv ) { 15990 for ( conv2 in converters ) { 15991 15992 // If conv2 outputs current 15993 tmp = conv2.split( " " ); 15994 if ( tmp[ 1 ] === current ) { 15995 15996 // If prev can be converted to accepted input 15997 conv = converters[ prev + " " + tmp[ 0 ] ] || 15998 converters[ "* " + tmp[ 0 ] ]; 15999 if ( conv ) { 16000 16001 // Condense equivalence converters 16002 if ( conv === true ) { 16003 conv = converters[ conv2 ]; 16004 16005 // Otherwise, insert the intermediate dataType 16006 } else if ( converters[ conv2 ] !== true ) { 16007 current = tmp[ 0 ]; 16008 dataTypes.unshift( tmp[ 1 ] ); 16009 } 16010 break; 16011 } 16012 } 16013 } 16014 } 16015 16016 // Apply converter (if not an equivalence) 16017 if ( conv !== true ) { 16018 16019 // Unless errors are allowed to bubble, catch and return them 16020 if ( conv && s.throws ) { 16021 response = conv( response ); 16022 } else { 16023 try { 16024 response = conv( response ); 16025 } catch ( e ) { 16026 return { 16027 state: "parsererror", 16028 error: conv ? e : "No conversion from " + prev + " to " + current 16029 }; 16030 } 16031 } 16032 } 16033 } 16034 } 16035 } 16036 16037 return { state: "success", data: response }; 16038} 16039 16040jQuery.extend( { 16041 16042 // Counter for holding the number of active queries 16043 active: 0, 16044 16045 // Last-Modified header cache for next request 16046 lastModified: {}, 16047 etag: {}, 16048 16049 ajaxSettings: { 16050 url: location.href, 16051 type: "GET", 16052 isLocal: rlocalProtocol.test( location.protocol ), 16053 global: true, 16054 processData: true, 16055 async: true, 16056 contentType: "application/x-www-form-urlencoded; charset=UTF-8", 16057 16058 /* 16059 timeout: 0, 16060 data: null, 16061 dataType: null, 16062 username: null, 16063 password: null, 16064 cache: null, 16065 throws: false, 16066 traditional: false, 16067 headers: {}, 16068 */ 16069 16070 accepts: { 16071 "*": allTypes, 16072 text: "text/plain", 16073 html: "text/html", 16074 xml: "application/xml, text/xml", 16075 json: "application/json, text/javascript" 16076 }, 16077 16078 contents: { 16079 xml: /\bxml\b/, 16080 html: /\bhtml/, 16081 json: /\bjson\b/ 16082 }, 16083 16084 responseFields: { 16085 xml: "responseXML", 16086 text: "responseText", 16087 json: "responseJSON" 16088 }, 16089 16090 // Data converters 16091 // Keys separate source (or catchall "*") and destination types with a single space 16092 converters: { 16093 16094 // Convert anything to text 16095 "* text": String, 16096 16097 // Text to html (true = no transformation) 16098 "text html": true, 16099 16100 // Evaluate text as a json expression 16101 "text json": JSON.parse, 16102 16103 // Parse text as xml 16104 "text xml": jQuery.parseXML 16105 }, 16106 16107 // For options that shouldn't be deep extended: 16108 // you can add your own custom options here if 16109 // and when you create one that shouldn't be 16110 // deep extended (see ajaxExtend) 16111 flatOptions: { 16112 url: true, 16113 context: true 16114 } 16115 }, 16116 16117 // Creates a full fledged settings object into target 16118 // with both ajaxSettings and settings fields. 16119 // If target is omitted, writes into ajaxSettings. 16120 ajaxSetup: function( target, settings ) { 16121 return settings ? 16122 16123 // Building a settings object 16124 ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) : 16125 16126 // Extending ajaxSettings 16127 ajaxExtend( jQuery.ajaxSettings, target ); 16128 }, 16129 16130 ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), 16131 ajaxTransport: addToPrefiltersOrTransports( transports ), 16132 16133 // Main method 16134 ajax: function( url, options ) { 16135 16136 // If url is an object, simulate pre-1.5 signature 16137 if ( typeof url === "object" ) { 16138 options = url; 16139 url = undefined; 16140 } 16141 16142 // Force options to be an object 16143 options = options || {}; 16144 16145 var transport, 16146 16147 // URL without anti-cache param 16148 cacheURL, 16149 16150 // Response headers 16151 responseHeadersString, 16152 responseHeaders, 16153 16154 // timeout handle 16155 timeoutTimer, 16156 16157 // Url cleanup var 16158 urlAnchor, 16159 16160 // Request state (becomes false upon send and true upon completion) 16161 completed, 16162 16163 // To know if global events are to be dispatched 16164 fireGlobals, 16165 16166 // Loop variable 16167 i, 16168 16169 // uncached part of the url 16170 uncached, 16171 16172 // Create the final options object 16173 s = jQuery.ajaxSetup( {}, options ), 16174 16175 // Callbacks context 16176 callbackContext = s.context || s, 16177 16178 // Context for global events is callbackContext if it is a DOM node or jQuery collection 16179 globalEventContext = s.context && 16180 ( callbackContext.nodeType || callbackContext.jquery ) ? 16181 jQuery( callbackContext ) : 16182 jQuery.event, 16183 16184 // Deferreds 16185 deferred = jQuery.Deferred(), 16186 completeDeferred = jQuery.Callbacks( "once memory" ), 16187 16188 // Status-dependent callbacks 16189 statusCode = s.statusCode || {}, 16190 16191 // Headers (they are sent all at once) 16192 requestHeaders = {}, 16193 requestHeadersNames = {}, 16194 16195 // Default abort message 16196 strAbort = "canceled", 16197 16198 // Fake xhr 16199 jqXHR = { 16200 readyState: 0, 16201 16202 // Builds headers hashtable if needed 16203 getResponseHeader: function( key ) { 16204 var match; 16205 if ( completed ) { 16206 if ( !responseHeaders ) { 16207 responseHeaders = {}; 16208 while ( ( match = rheaders.exec( responseHeadersString ) ) ) { 16209 responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ]; 16210 } 16211 } 16212 match = responseHeaders[ key.toLowerCase() ]; 16213 } 16214 return match == null ? null : match; 16215 }, 16216 16217 // Raw string 16218 getAllResponseHeaders: function() { 16219 return completed ? responseHeadersString : null; 16220 }, 16221 16222 // Caches the header 16223 setRequestHeader: function( name, value ) { 16224 if ( completed == null ) { 16225 name = requestHeadersNames[ name.toLowerCase() ] = 16226 requestHeadersNames[ name.toLowerCase() ] || name; 16227 requestHeaders[ name ] = value; 16228 } 16229 return this; 16230 }, 16231 16232 // Overrides response content-type header 16233 overrideMimeType: function( type ) { 16234 if ( completed == null ) { 16235 s.mimeType = type; 16236 } 16237 return this; 16238 }, 16239 16240 // Status-dependent callbacks 16241 statusCode: function( map ) { 16242 var code; 16243 if ( map ) { 16244 if ( completed ) { 16245 16246 // Execute the appropriate callbacks 16247 jqXHR.always( map[ jqXHR.status ] ); 16248 } else { 16249 16250 // Lazy-add the new callbacks in a way that preserves old ones 16251 for ( code in map ) { 16252 statusCode[ code ] = [ statusCode[ code ], map[ code ] ]; 16253 } 16254 } 16255 } 16256 return this; 16257 }, 16258 16259 // Cancel the request 16260 abort: function( statusText ) { 16261 var finalText = statusText || strAbort; 16262 if ( transport ) { 16263 transport.abort( finalText ); 16264 } 16265 done( 0, finalText ); 16266 return this; 16267 } 16268 }; 16269 16270 // Attach deferreds 16271 deferred.promise( jqXHR ); 16272 16273 // Add protocol if not provided (prefilters might expect it) 16274 // Handle falsy url in the settings object (#10093: consistency with old signature) 16275 // We also use the url parameter if available 16276 s.url = ( ( url || s.url || location.href ) + "" ) 16277 .replace( rprotocol, location.protocol + "//" ); 16278 16279 // Alias method option to type as per ticket #12004 16280 s.type = options.method || options.type || s.method || s.type; 16281 16282 // Extract dataTypes list 16283 s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ]; 16284 16285 // A cross-domain request is in order when the origin doesn't match the current origin. 16286 if ( s.crossDomain == null ) { 16287 urlAnchor = document.createElement( "a" ); 16288 16289 // Support: IE <=8 - 11, Edge 12 - 13 16290 // IE throws exception on accessing the href property if url is malformed, 16291 // e.g. http://example.com:80x/ 16292 try { 16293 urlAnchor.href = s.url; 16294 16295 // Support: IE <=8 - 11 only 16296 // Anchor's host property isn't correctly set when s.url is relative 16297 urlAnchor.href = urlAnchor.href; 16298 s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== 16299 urlAnchor.protocol + "//" + urlAnchor.host; 16300 } catch ( e ) { 16301 16302 // If there is an error parsing the URL, assume it is crossDomain, 16303 // it can be rejected by the transport if it is invalid 16304 s.crossDomain = true; 16305 } 16306 } 16307 16308 // Convert data if not already a string 16309 if ( s.data && s.processData && typeof s.data !== "string" ) { 16310 s.data = jQuery.param( s.data, s.traditional ); 16311 } 16312 16313 // Apply prefilters 16314 inspectPrefiltersOrTransports( prefilters, s, options, jqXHR ); 16315 16316 // If request was aborted inside a prefilter, stop there 16317 if ( completed ) { 16318 return jqXHR; 16319 } 16320 16321 // We can fire global events as of now if asked to 16322 // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118) 16323 fireGlobals = jQuery.event && s.global; 16324 16325 // Watch for a new set of requests 16326 if ( fireGlobals && jQuery.active++ === 0 ) { 16327 jQuery.event.trigger( "ajaxStart" ); 16328 } 16329 16330 // Uppercase the type 16331 s.type = s.type.toUpperCase(); 16332 16333 // Determine if request has content 16334 s.hasContent = !rnoContent.test( s.type ); 16335 16336 // Save the URL in case we're toying with the If-Modified-Since 16337 // and/or If-None-Match header later on 16338 // Remove hash to simplify url manipulation 16339 cacheURL = s.url.replace( rhash, "" ); 16340 16341 // More options handling for requests with no content 16342 if ( !s.hasContent ) { 16343 16344 // Remember the hash so we can put it back 16345 uncached = s.url.slice( cacheURL.length ); 16346 16347 // If data is available, append data to url 16348 if ( s.data ) { 16349 cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data; 16350 16351 // #9682: remove data so that it's not used in an eventual retry 16352 delete s.data; 16353 } 16354 16355 // Add or update anti-cache param if needed 16356 if ( s.cache === false ) { 16357 cacheURL = cacheURL.replace( rantiCache, "$1" ); 16358 uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached; 16359 } 16360 16361 // Put hash and anti-cache on the URL that will be requested (gh-1732) 16362 s.url = cacheURL + uncached; 16363 16364 // Change '%20' to '+' if this is encoded form body content (gh-2658) 16365 } else if ( s.data && s.processData && 16366 ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) { 16367 s.data = s.data.replace( r20, "+" ); 16368 } 16369 16370 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. 16371 if ( s.ifModified ) { 16372 if ( jQuery.lastModified[ cacheURL ] ) { 16373 jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] ); 16374 } 16375 if ( jQuery.etag[ cacheURL ] ) { 16376 jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] ); 16377 } 16378 } 16379 16380 // Set the correct header, if data is being sent 16381 if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { 16382 jqXHR.setRequestHeader( "Content-Type", s.contentType ); 16383 } 16384 16385 // Set the Accepts header for the server, depending on the dataType 16386 jqXHR.setRequestHeader( 16387 "Accept", 16388 s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ? 16389 s.accepts[ s.dataTypes[ 0 ] ] + 16390 ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) : 16391 s.accepts[ "*" ] 16392 ); 16393 16394 // Check for headers option 16395 for ( i in s.headers ) { 16396 jqXHR.setRequestHeader( i, s.headers[ i ] ); 16397 } 16398 16399 // Allow custom headers/mimetypes and early abort 16400 if ( s.beforeSend && 16401 ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) { 16402 16403 // Abort if not done already and return 16404 return jqXHR.abort(); 16405 } 16406 16407 // Aborting is no longer a cancellation 16408 strAbort = "abort"; 16409 16410 // Install callbacks on deferreds 16411 completeDeferred.add( s.complete ); 16412 jqXHR.done( s.success ); 16413 jqXHR.fail( s.error ); 16414 16415 // Get transport 16416 transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR ); 16417 16418 // If no transport, we auto-abort 16419 if ( !transport ) { 16420 done( -1, "No Transport" ); 16421 } else { 16422 jqXHR.readyState = 1; 16423 16424 // Send global event 16425 if ( fireGlobals ) { 16426 globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); 16427 } 16428 16429 // If request was aborted inside ajaxSend, stop there 16430 if ( completed ) { 16431 return jqXHR; 16432 } 16433 16434 // Timeout 16435 if ( s.async && s.timeout > 0 ) { 16436 timeoutTimer = window.setTimeout( function() { 16437 jqXHR.abort( "timeout" ); 16438 }, s.timeout ); 16439 } 16440 16441 try { 16442 completed = false; 16443 transport.send( requestHeaders, done ); 16444 } catch ( e ) { 16445 16446 // Rethrow post-completion exceptions 16447 if ( completed ) { 16448 throw e; 16449 } 16450 16451 // Propagate others as results 16452 done( -1, e ); 16453 } 16454 } 16455 16456 // Callback for when everything is done 16457 function done( status, nativeStatusText, responses, headers ) { 16458 var isSuccess, success, error, response, modified, 16459 statusText = nativeStatusText; 16460 16461 // Ignore repeat invocations 16462 if ( completed ) { 16463 return; 16464 } 16465 16466 completed = true; 16467 16468 // Clear timeout if it exists 16469 if ( timeoutTimer ) { 16470 window.clearTimeout( timeoutTimer ); 16471 } 16472 16473 // Dereference transport for early garbage collection 16474 // (no matter how long the jqXHR object will be used) 16475 transport = undefined; 16476 16477 // Cache response headers 16478 responseHeadersString = headers || ""; 16479 16480 // Set readyState 16481 jqXHR.readyState = status > 0 ? 4 : 0; 16482 16483 // Determine if successful 16484 isSuccess = status >= 200 && status < 300 || status === 304; 16485 16486 // Get response data 16487 if ( responses ) { 16488 response = ajaxHandleResponses( s, jqXHR, responses ); 16489 } 16490 16491 // Convert no matter what (that way responseXXX fields are always set) 16492 response = ajaxConvert( s, response, jqXHR, isSuccess ); 16493 16494 // If successful, handle type chaining 16495 if ( isSuccess ) { 16496 16497 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. 16498 if ( s.ifModified ) { 16499 modified = jqXHR.getResponseHeader( "Last-Modified" ); 16500 if ( modified ) { 16501 jQuery.lastModified[ cacheURL ] = modified; 16502 } 16503 modified = jqXHR.getResponseHeader( "etag" ); 16504 if ( modified ) { 16505 jQuery.etag[ cacheURL ] = modified; 16506 } 16507 } 16508 16509 // if no content 16510 if ( status === 204 || s.type === "HEAD" ) { 16511 statusText = "nocontent"; 16512 16513 // if not modified 16514 } else if ( status === 304 ) { 16515 statusText = "notmodified"; 16516 16517 // If we have data, let's convert it 16518 } else { 16519 statusText = response.state; 16520 success = response.data; 16521 error = response.error; 16522 isSuccess = !error; 16523 } 16524 } else { 16525 16526 // Extract error from statusText and normalize for non-aborts 16527 error = statusText; 16528 if ( status || !statusText ) { 16529 statusText = "error"; 16530 if ( status < 0 ) { 16531 status = 0; 16532 } 16533 } 16534 } 16535 16536 // Set data for the fake xhr object 16537 jqXHR.status = status; 16538 jqXHR.statusText = ( nativeStatusText || statusText ) + ""; 16539 16540 // Success/Error 16541 if ( isSuccess ) { 16542 deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); 16543 } else { 16544 deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); 16545 } 16546 16547 // Status-dependent callbacks 16548 jqXHR.statusCode( statusCode ); 16549 statusCode = undefined; 16550 16551 if ( fireGlobals ) { 16552 globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError", 16553 [ jqXHR, s, isSuccess ? success : error ] ); 16554 } 16555 16556 // Complete 16557 completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); 16558 16559 if ( fireGlobals ) { 16560 globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] ); 16561 16562 // Handle the global AJAX counter 16563 if ( !( --jQuery.active ) ) { 16564 jQuery.event.trigger( "ajaxStop" ); 16565 } 16566 } 16567 } 16568 16569 return jqXHR; 16570 }, 16571 16572 getJSON: function( url, data, callback ) { 16573 return jQuery.get( url, data, callback, "json" ); 16574 }, 16575 16576 getScript: function( url, callback ) { 16577 return jQuery.get( url, undefined, callback, "script" ); 16578 } 16579} ); 16580 16581jQuery.each( [ "get", "post" ], function( i, method ) { 16582 jQuery[ method ] = function( url, data, callback, type ) { 16583 16584 // Shift arguments if data argument was omitted 16585 if ( jQuery.isFunction( data ) ) { 16586 type = type || callback; 16587 callback = data; 16588 data = undefined; 16589 } 16590 16591 // The url can be an options object (which then must have .url) 16592 return jQuery.ajax( jQuery.extend( { 16593 url: url, 16594 type: method, 16595 dataType: type, 16596 data: data, 16597 success: callback 16598 }, jQuery.isPlainObject( url ) && url ) ); 16599 }; 16600} ); 16601 16602 16603jQuery._evalUrl = function( url ) { 16604 return jQuery.ajax( { 16605 url: url, 16606 16607 // Make this explicit, since user can override this through ajaxSetup (#11264) 16608 type: "GET", 16609 dataType: "script", 16610 cache: true, 16611 async: false, 16612 global: false, 16613 "throws": true 16614 } ); 16615}; 16616 16617 16618jQuery.fn.extend( { 16619 wrapAll: function( html ) { 16620 var wrap; 16621 16622 if ( this[ 0 ] ) { 16623 if ( jQuery.isFunction( html ) ) { 16624 html = html.call( this[ 0 ] ); 16625 } 16626 16627 // The elements to wrap the target around 16628 wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true ); 16629 16630 if ( this[ 0 ].parentNode ) { 16631 wrap.insertBefore( this[ 0 ] ); 16632 } 16633 16634 wrap.map( function() { 16635 var elem = this; 16636 16637 while ( elem.firstElementChild ) { 16638 elem = elem.firstElementChild; 16639 } 16640 16641 return elem; 16642 } ).append( this ); 16643 } 16644 16645 return this; 16646 }, 16647 16648 wrapInner: function( html ) { 16649 if ( jQuery.isFunction( html ) ) { 16650 return this.each( function( i ) { 16651 jQuery( this ).wrapInner( html.call( this, i ) ); 16652 } ); 16653 } 16654 16655 return this.each( function() { 16656 var self = jQuery( this ), 16657 contents = self.contents(); 16658 16659 if ( contents.length ) { 16660 contents.wrapAll( html ); 16661 16662 } else { 16663 self.append( html ); 16664 } 16665 } ); 16666 }, 16667 16668 wrap: function( html ) { 16669 var isFunction = jQuery.isFunction( html ); 16670 16671 return this.each( function( i ) { 16672 jQuery( this ).wrapAll( i
vendor: 2,399 bytes, lines 16672-16764
16672sFunction ? html.call( this, i ) : html ); 16673 } ); 16674 }, 16675 16676 unwrap: function( selector ) { 16677 this.parent( selector ).not( "body" ).each( function() { 16678 jQuery( this ).replaceWith( this.childNodes ); 16679 } ); 16680 return this; 16681 } 16682} ); 16683 16684 16685jQuery.expr.pseudos.hidden = function( elem ) { 16686 return !jQuery.expr.pseudos.visible( elem ); 16687}; 16688jQuery.expr.pseudos.visible = function( elem ) { 16689 return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length ); 16690}; 16691 16692 16693 16694 16695jQuery.ajaxSettings.xhr = function() { 16696 try { 16697 return new window.XMLHttpRequest(); 16698 } catch ( e ) {} 16699}; 16700 16701var xhrSuccessStatus = { 16702 16703 // File protocol always yields status code 0, assume 200 16704 0: 200, 16705 16706 // Support: IE <=9 only 16707 // #1450: sometimes IE returns 1223 when it should be 204 16708 1223: 204 16709 }, 16710 xhrSupported = jQuery.ajaxSettings.xhr(); 16711 16712support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported ); 16713support.ajax = xhrSupported = !!xhrSupported; 16714 16715jQuery.ajaxTransport( function( options ) { 16716 var callback, errorCallback; 16717 16718 // Cross domain only allowed if supported through XMLHttpRequest 16719 if ( support.cors || xhrSupported && !options.crossDomain ) { 16720 return { 16721 send: function( headers, complete ) { 16722 var i, 16723 xhr = options.xhr(); 16724 16725 xhr.open( 16726 options.type, 16727 options.url, 16728 options.async, 16729 options.username, 16730 options.password 16731 ); 16732 16733 // Apply custom fields if provided 16734 if ( options.xhrFields ) { 16735 for ( i in options.xhrFields ) { 16736 xhr[ i ] = options.xhrFields[ i ]; 16737 } 16738 } 16739 16740 // Override mime type if needed 16741 if ( options.mimeType && xhr.overrideMimeType ) { 16742 xhr.overrideMimeType( options.mimeType ); 16743 } 16744 16745 // X-Requested-With header 16746 // For cross-domain requests, seeing as conditions for a preflight are 16747 // akin to a jigsaw puzzle, we simply never set it to be sure. 16748 // (it can always be set on a per-request basis or even using ajaxSetup) 16749 // For same-domain requests, won't change header if already provided. 16750 if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) { 16751 headers[ "X-Requested-With" ] = "XMLHttpRequest"; 16752 } 16753 16754 // Set headers 16755 for ( i in headers ) { 16756 xhr.setRequestHeader( i, headers[ i ] ); 16757 } 16758 16759 // Callback 16760 callback = function( type ) { 16761 return function() { 16762 if ( callback ) { 16763 callback = errorCallback = xhr.onload = 16764 xhr.onerror = xhr.onabort = xhr.on
vendor: 5,102 bytes, lines 16764-16969
16764readystatechange = null; 16765 16766 if ( type === "abort" ) { 16767 xhr.abort(); 16768 } else if ( type === "error" ) { 16769 16770 // Support: IE <=9 only 16771 // On a manual native abort, IE9 throws 16772 // errors on any property access that is not readyState 16773 if ( typeof xhr.status !== "number" ) { 16774 complete( 0, "error" ); 16775 } else { 16776 complete( 16777 16778 // File: protocol always yields status 0; see #8605, #14207 16779 xhr.status, 16780 xhr.statusText 16781 ); 16782 } 16783 } else { 16784 complete( 16785 xhrSuccessStatus[ xhr.status ] || xhr.status, 16786 xhr.statusText, 16787 16788 // Support: IE <=9 only 16789 // IE9 has no XHR2 but throws on binary (trac-11426) 16790 // For XHR2 non-text, let the caller handle it (gh-2498) 16791 ( xhr.responseType || "text" ) !== "text" || 16792 typeof xhr.responseText !== "string" ? 16793 { binary: xhr.response } : 16794 { text: xhr.responseText }, 16795 xhr.getAllResponseHeaders() 16796 ); 16797 } 16798 } 16799 }; 16800 }; 16801 16802 // Listen to events 16803 xhr.onload = callback(); 16804 errorCallback = xhr.onerror = callback( "error" ); 16805 16806 // Support: IE 9 only 16807 // Use onreadystatechange to replace onabort 16808 // to handle uncaught aborts 16809 if ( xhr.onabort !== undefined ) { 16810 xhr.onabort = errorCallback; 16811 } else { 16812 xhr.onreadystatechange = function() { 16813 16814 // Check readyState before timeout as it changes 16815 if ( xhr.readyState === 4 ) { 16816 16817 // Allow onerror to be called first, 16818 // but that will not handle a native abort 16819 // Also, save errorCallback to a variable 16820 // as xhr.onerror cannot be accessed 16821 window.setTimeout( function() { 16822 if ( callback ) { 16823 errorCallback(); 16824 } 16825 } ); 16826 } 16827 }; 16828 } 16829 16830 // Create the abort callback 16831 callback = callback( "abort" ); 16832 16833 try { 16834 16835 // Do send the request (this may raise an exception) 16836 xhr.send( options.hasContent && options.data || null ); 16837 } catch ( e ) { 16838 16839 // #14683: Only rethrow if this hasn't been notified as an error yet 16840 if ( callback ) { 16841 throw e; 16842 } 16843 } 16844 }, 16845 16846 abort: function() { 16847 if ( callback ) { 16848 callback(); 16849 } 16850 } 16851 }; 16852 } 16853} ); 16854 16855 16856 16857 16858// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432) 16859jQuery.ajaxPrefilter( function( s ) { 16860 if ( s.crossDomain ) { 16861 s.contents.script = false; 16862 } 16863} ); 16864 16865// Install script dataType 16866jQuery.ajaxSetup( { 16867 accepts: { 16868 script: "text/javascript, application/javascript, " + 16869 "application/ecmascript, application/x-ecmascript" 16870 }, 16871 contents: { 16872 script: /\b(?:java|ecma)script\b/ 16873 }, 16874 converters: { 16875 "text script": function( text ) { 16876 jQuery.globalEval( text ); 16877 return text; 16878 } 16879 } 16880} ); 16881 16882// Handle cache's special case and crossDomain 16883jQuery.ajaxPrefilter( "script", function( s ) { 16884 if ( s.cache === undefined ) { 16885 s.cache = false; 16886 } 16887 if ( s.crossDomain ) { 16888 s.type = "GET"; 16889 } 16890} ); 16891 16892// Bind script tag hack transport 16893jQuery.ajaxTransport( "script", function( s ) { 16894 16895 // This transport only deals with cross domain requests 16896 if ( s.crossDomain ) { 16897 var script, callback; 16898 return { 16899 send: function( _, complete ) { 16900 script = jQuery( "<script>" ).prop( { 16901 charset: s.scriptCharset, 16902 src: s.url 16903 } ).on( 16904 "load error", 16905 callback = function( evt ) { 16906 script.remove(); 16907 callback = null; 16908 if ( evt ) { 16909 complete( evt.type === "error" ? 404 : 200, evt.type ); 16910 } 16911 } 16912 ); 16913 16914 // Use native DOM manipulation to avoid our domManip AJAX trickery 16915 document.head.appendChild( script[ 0 ] ); 16916 }, 16917 abort: function() { 16918 if ( callback ) { 16919 callback(); 16920 } 16921 } 16922 }; 16923 } 16924} ); 16925 16926 16927 16928 16929var oldCallbacks = [], 16930 rjsonp = /(=)\?(?=&|$)|\?\?/; 16931 16932// Default jsonp settings 16933jQuery.ajaxSetup( { 16934 jsonp: "callback", 16935 jsonpCallback: function() { 16936 var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) ); 16937 this[ callback ] = true; 16938 return callback; 16939 } 16940} ); 16941 16942// Detect, normalize options and install callbacks for jsonp requests 16943jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) { 16944 16945 var callbackName, overwritten, responseContainer, 16946 jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ? 16947 "url" : 16948 typeof s.data === "string" && 16949 ( s.contentType || "" ) 16950 .indexOf( "application/x-www-form-urlencoded" ) === 0 && 16951 rjsonp.test( s.data ) && "data" 16952 ); 16953 16954 // Handle iff the expected data type is "jsonp" or we have a parameter to set 16955 if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) { 16956 16957 // Get callback name, remembering preexisting value associated with it 16958 callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ? 16959 s.jsonpCallback() : 16960 s.jsonpCallback; 16961 16962 // Insert callback into url or form data 16963 if ( jsonProp ) { 16964 s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName ); 16965 } else if ( s.jsonp !== false ) { 16966 s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName; 16967 } 16968 16969 // Use data converter to retrieve json after script execution
vendor: 2,994 bytes, lines 16970-17079
16970 s.converters[ "script json" ] = function() { 16971 if ( !responseContainer ) { 16972 jQuery.error( callbackName + " was not called" ); 16973 } 16974 return responseContainer[ 0 ]; 16975 }; 16976 16977 // Force json dataType 16978 s.dataTypes[ 0 ] = "json"; 16979 16980 // Install callback 16981 overwritten = window[ callbackName ]; 16982 window[ callbackName ] = function() { 16983 responseContainer = arguments; 16984 }; 16985 16986 // Clean-up function (fires after converters) 16987 jqXHR.always( function() { 16988 16989 // If previous value didn't exist - remove it 16990 if ( overwritten === undefined ) { 16991 jQuery( window ).removeProp( callbackName ); 16992 16993 // Otherwise restore preexisting value 16994 } else { 16995 window[ callbackName ] = overwritten; 16996 } 16997 16998 // Save back as free 16999 if ( s[ callbackName ] ) { 17000 17001 // Make sure that re-using the options doesn't screw things around 17002 s.jsonpCallback = originalSettings.jsonpCallback; 17003 17004 // Save the callback name for future use 17005 oldCallbacks.push( callbackName ); 17006 } 17007 17008 // Call if it was a function and we have a response 17009 if ( responseContainer && jQuery.isFunction( overwritten ) ) { 17010 overwritten( responseContainer[ 0 ] ); 17011 } 17012 17013 responseContainer = overwritten = undefined; 17014 } ); 17015 17016 // Delegate to script 17017 return "script"; 17018 } 17019} ); 17020 17021 17022 17023 17024// Support: Safari 8 only 17025// In Safari 8 documents created via document.implementation.createHTMLDocument 17026// collapse sibling forms: the second one becomes a child of the first one. 17027// Because of that, this security measure has to be disabled in Safari 8. 17028// https://bugs.webkit.org/show_bug.cgi?id=137337 17029support.createHTMLDocument = ( function() { 17030 var body = document.implementation.createHTMLDocument( "" ).body; 17031 body.innerHTML = "<form></form><form></form>"; 17032 return body.childNodes.length === 2; 17033} )(); 17034 17035 17036// Argument "data" should be string of html 17037// context (optional): If specified, the fragment will be created in this context, 17038// defaults to document 17039// keepScripts (optional): If true, will include scripts passed in the html string 17040jQuery.parseHTML = function( data, context, keepScripts ) { 17041 if ( typeof data !== "string" ) { 17042 return []; 17043 } 17044 if ( typeof context === "boolean" ) { 17045 keepScripts = context; 17046 context = false; 17047 } 17048 17049 var base, parsed, scripts; 17050 17051 if ( !context ) { 17052 17053 // Stop scripts or inline event handlers from being executed immediately 17054 // by using document.implementation 17055 if ( support.createHTMLDocument ) { 17056 context = document.implementation.createHTMLDocument( "" ); 17057 17058 // Set the base href for the created document 17059 // so any parsed elements with URLs 17060 // are based on the document's URL (gh-2965) 17061 base = context.createElement( "base" ); 17062 base.href = document.location.href; 17063 context.head.appendChild( base ); 17064 } else { 17065 context = document; 17066 } 17067 } 17068 17069 parsed = rsingleTag.exec( data ); 17070 scripts = !keepScripts && []; 17071 17072 // Single tag 17073 if ( parsed ) { 17074 return [ context.createElement( parsed[ 1 ] ) ]; 17075 } 17076 17077 parsed = buildFragment( [ data ], context, scripts ); 17078 17079 if ( scripts && scripts.length ) {
vendor: 4,095 bytes, lines 17080-17250
17080 jQuery( scripts ).remove(); 17081 } 17082 17083 return jQuery.merge( [], parsed.childNodes ); 17084}; 17085 17086 17087/** 17088 * Load a url into a page 17089 */ 17090jQuery.fn.load = function( url, params, callback ) { 17091 var selector, type, response, 17092 self = this, 17093 off = url.indexOf( " " ); 17094 17095 if ( off > -1 ) { 17096 selector = stripAndCollapse( url.slice( off ) ); 17097 url = url.slice( 0, off ); 17098 } 17099 17100 // If it's a function 17101 if ( jQuery.isFunction( params ) ) { 17102 17103 // We assume that it's the callback 17104 callback = params; 17105 params = undefined; 17106 17107 // Otherwise, build a param string 17108 } else if ( params && typeof params === "object" ) { 17109 type = "POST"; 17110 } 17111 17112 // If we have elements to modify, make the request 17113 if ( self.length > 0 ) { 17114 jQuery.ajax( { 17115 url: url, 17116 17117 // If "type" variable is undefined, then "GET" method will be used. 17118 // Make value of this field explicit since 17119 // user can override it through ajaxSetup method 17120 type: type || "GET", 17121 dataType: "html", 17122 data: params 17123 } ).done( function( responseText ) { 17124 17125 // Save response for use in complete callback 17126 response = arguments; 17127 17128 self.html( selector ? 17129 17130 // If a selector was specified, locate the right elements in a dummy div 17131 // Exclude scripts to avoid IE 'Permission Denied' errors 17132 jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) : 17133 17134 // Otherwise use the full result 17135 responseText ); 17136 17137 // If the request succeeds, this function gets "data", "status", "jqXHR" 17138 // but they are ignored because response was set above. 17139 // If it fails, this function gets "jqXHR", "status", "error" 17140 } ).always( callback && function( jqXHR, status ) { 17141 self.each( function() { 17142 callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] ); 17143 } ); 17144 } ); 17145 } 17146 17147 return this; 17148}; 17149 17150 17151 17152 17153// Attach a bunch of functions for handling common AJAX events 17154jQuery.each( [ 17155 "ajaxStart", 17156 "ajaxStop", 17157 "ajaxComplete", 17158 "ajaxError", 17159 "ajaxSuccess", 17160 "ajaxSend" 17161], function( i, type ) { 17162 jQuery.fn[ type ] = function( fn ) { 17163 return this.on( type, fn ); 17164 }; 17165} ); 17166 17167 17168 17169 17170jQuery.expr.pseudos.animated = function( elem ) { 17171 return jQuery.grep( jQuery.timers, function( fn ) { 17172 return elem === fn.elem; 17173 } ).length; 17174}; 17175 17176 17177 17178 17179jQuery.offset = { 17180 setOffset: function( elem, options, i ) { 17181 var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition, 17182 position = jQuery.css( elem, "position" ), 17183 curElem = jQuery( elem ), 17184 props = {}; 17185 17186 // Set position first, in-case top/left are set even on static elem 17187 if ( position === "static" ) { 17188 elem.style.position = "relative"; 17189 } 17190 17191 curOffset = curElem.offset(); 17192 curCSSTop = jQuery.css( elem, "top" ); 17193 curCSSLeft = jQuery.css( elem, "left" ); 17194 calculatePosition = ( position === "absolute" || position === "fixed" ) && 17195 ( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1; 17196 17197 // Need to be able to calculate position if either 17198 // top or left is auto and position is either absolute or fixed 17199 if ( calculatePosition ) { 17200 curPosition = curElem.position(); 17201 curTop = curPosition.top; 17202 curLeft = curPosition.left; 17203 17204 } else { 17205 curTop = parseFloat( curCSSTop ) || 0; 17206 curLeft = parseFloat( curCSSLeft ) || 0; 17207 } 17208 17209 if ( jQuery.isFunction( options ) ) { 17210 17211 // Use jQuery.extend here to allow modification of coordinates argument (gh-1848) 17212 options = options.call( elem, i, jQuery.extend( {}, curOffset ) ); 17213 } 17214 17215 if ( options.top != null ) { 17216 props.top = ( options.top - curOffset.top ) + curTop; 17217 } 17218 if ( options.left != null ) { 17219 props.left = ( options.left - curOffset.left ) + curLeft; 17220 } 17221 17222 if ( "using" in options ) { 17223 options.using.call( elem, props ); 17224 17225 } else { 17226 curElem.css( props ); 17227 } 17228 } 17229}; 17230 17231jQuery.fn.extend( { 17232 offset: function( options ) { 17233 17234 // Preserve chaining for setter 17235 if ( arguments.length ) { 17236 return options === undefined ? 17237 this : 17238 this.each( function( i ) { 17239 jQuery.offset.setOffset( this, options, i ); 17240 } ); 17241 } 17242 17243 var doc, docElem, rect, win, 17244 elem = this[ 0 ]; 17245 17246 if ( !elem ) { 17247 return; 17248 } 17249 17250 // Return zeros for disconnected and hidden (display: none) elements (gh-2310)
vendor: 4,119 bytes, lines 17251-17389
17251 // Support: IE <=11 only 17252 // Running getBoundingClientRect on a 17253 // disconnected node in IE throws an error 17254 if ( !elem.getClientRects().length ) { 17255 return { top: 0, left: 0 }; 17256 } 17257 17258 rect = elem.getBoundingClientRect(); 17259 17260 doc = elem.ownerDocument; 17261 docElem = doc.documentElement; 17262 win = doc.defaultView; 17263 17264 return { 17265 top: rect.top + win.pageYOffset - docElem.clientTop, 17266 left: rect.left + win.pageXOffset - docElem.clientLeft 17267 }; 17268 }, 17269 17270 position: function() { 17271 if ( !this[ 0 ] ) { 17272 return; 17273 } 17274 17275 var offsetParent, offset, 17276 elem = this[ 0 ], 17277 parentOffset = { top: 0, left: 0 }; 17278 17279 // Fixed elements are offset from window (parentOffset = {top:0, left: 0}, 17280 // because it is its only offset parent 17281 if ( jQuery.css( elem, "position" ) === "fixed" ) { 17282 17283 // Assume getBoundingClientRect is there when computed position is fixed 17284 offset = elem.getBoundingClientRect(); 17285 17286 } else { 17287 17288 // Get *real* offsetParent 17289 offsetParent = this.offsetParent(); 17290 17291 // Get correct offsets 17292 offset = this.offset(); 17293 if ( !nodeName( offsetParent[ 0 ], "html" ) ) { 17294 parentOffset = offsetParent.offset(); 17295 } 17296 17297 // Add offsetParent borders 17298 parentOffset = { 17299 top: parentOffset.top + jQuery.css( offsetParent[ 0 ], "borderTopWidth", true ), 17300 left: parentOffset.left + jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true ) 17301 }; 17302 } 17303 17304 // Subtract parent offsets and element margins 17305 return { 17306 top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ), 17307 left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true ) 17308 }; 17309 }, 17310 17311 // This method will return documentElement in the following cases: 17312 // 1) For the element inside the iframe without offsetParent, this method will return 17313 // documentElement of the parent window 17314 // 2) For the hidden or detached element 17315 // 3) For body or html element, i.e. in case of the html node - it will return itself 17316 // 17317 // but those exceptions were never presented as a real life use-cases 17318 // and might be considered as more preferable results. 17319 // 17320 // This logic, however, is not guaranteed and can change at any point in the future 17321 offsetParent: function() { 17322 return this.map( function() { 17323 var offsetParent = this.offsetParent; 17324 17325 while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) { 17326 offsetParent = offsetParent.offsetParent; 17327 } 17328 17329 return offsetParent || documentElement; 17330 } ); 17331 } 17332} ); 17333 17334// Create scrollLeft and scrollTop methods 17335jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) { 17336 var top = "pageYOffset" === prop; 17337 17338 jQuery.fn[ method ] = function( val ) { 17339 return access( this, function( elem, method, val ) { 17340 17341 // Coalesce documents and windows 17342 var win; 17343 if ( jQuery.isWindow( elem ) ) { 17344 win = elem; 17345 } else if ( elem.nodeType === 9 ) { 17346 win = elem.defaultView; 17347 } 17348 17349 if ( val === undefined ) { 17350 return win ? win[ prop ] : elem[ method ]; 17351 } 17352 17353 if ( win ) { 17354 win.scrollTo( 17355 !top ? val : win.pageXOffset, 17356 top ? val : win.pageYOffset 17357 ); 17358 17359 } else { 17360 elem[ method ] = val; 17361 } 17362 }, method, val, arguments.length ); 17363 }; 17364} ); 17365 17366// Support: Safari <=7 - 9.1, Chrome <=37 - 49 17367// Add the top/left cssHooks using jQuery.fn.position 17368// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084 17369// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347 17370// getComputedStyle returns percent when specified for top/left/bottom/right; 17371// rather than make the css module depend on the offset module, just check for it here 17372jQuery.each( [ "top", "left" ], function( i, prop ) { 17373 jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition, 17374 function( elem, computed ) { 17375 if ( computed ) { 17376 computed = curCSS( elem, prop ); 17377 17378 // If curCSS returns percentage, fallback to offset 17379 return rnumnonpx.test( computed ) ? 17380 jQuery( elem ).position()[ prop ] + "px" : 17381 computed; 17382 } 17383 } 17384 ); 17385} ); 17386 17387 17388// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods 17389jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
vendor: 4,471 bytes, lines 17390-17553
17390 jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name }, 17391 function( defaultExtra, funcName ) { 17392 17393 // Margin is only for outerHeight, outerWidth 17394 jQuery.fn[ funcName ] = function( margin, value ) { 17395 var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ), 17396 extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" ); 17397 17398 return access( this, function( elem, type, value ) { 17399 var doc; 17400 17401 if ( jQuery.isWindow( elem ) ) { 17402 17403 // $( window ).outerWidth/Height return w/h including scrollbars (gh-1729) 17404 return funcName.indexOf( "outer" ) === 0 ? 17405 elem[ "inner" + name ] : 17406 elem.document.documentElement[ "client" + name ]; 17407 } 17408 17409 // Get document width or height 17410 if ( elem.nodeType === 9 ) { 17411 doc = elem.documentElement; 17412 17413 // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], 17414 // whichever is greatest 17415 return Math.max( 17416 elem.body[ "scroll" + name ], doc[ "scroll" + name ], 17417 elem.body[ "offset" + name ], doc[ "offset" + name ], 17418 doc[ "client" + name ] 17419 ); 17420 } 17421 17422 return value === undefined ? 17423 17424 // Get width or height on the element, requesting but not forcing parseFloat 17425 jQuery.css( elem, type, extra ) : 17426 17427 // Set width or height on the element 17428 jQuery.style( elem, type, value, extra ); 17429 }, type, chainable ? margin : undefined, chainable ); 17430 }; 17431 } ); 17432} ); 17433 17434 17435jQuery.fn.extend( { 17436 17437 bind: function( types, data, fn ) { 17438 return this.on( types, null, data, fn ); 17439 }, 17440 unbind: function( types, fn ) { 17441 return this.off( types, null, fn ); 17442 }, 17443 17444 delegate: function( selector, types, data, fn ) { 17445 return this.on( types, selector, data, fn ); 17446 }, 17447 undelegate: function( selector, types, fn ) { 17448 17449 // ( namespace ) or ( selector, types [, fn] ) 17450 return arguments.length === 1 ? 17451 this.off( selector, "**" ) : 17452 this.off( types, selector || "**", fn ); 17453 } 17454} ); 17455 17456jQuery.holdReady = function( hold ) { 17457 if ( hold ) { 17458 jQuery.readyWait++; 17459 } else { 17460 jQuery.ready( true ); 17461 } 17462}; 17463jQuery.isArray = Array.isArray; 17464jQuery.parseJSON = JSON.parse; 17465jQuery.nodeName = nodeName; 17466 17467 17468 17469 17470// Register as a named AMD module, since jQuery can be concatenated with other 17471// files that may use define, but not via a proper concatenation script that 17472// understands anonymous AMD modules. A named AMD is safest and most robust 17473// way to register. Lowercase jquery is used because AMD module names are 17474// derived from file names, and jQuery is normally delivered in a lowercase 17475// file name. Do this after creating the global so that if an AMD module wants 17476// to call noConflict to hide this version of jQuery, it will work. 17477 17478// Note that for maximum portability, libraries that are not jQuery should 17479// declare themselves as anonymous modules, and avoid setting a global if an 17480// AMD loader is present. jQuery is a special case. For more information, see 17481// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon 17482 17483if ( true ) { 17484 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function() { 17485 return jQuery; 17486 }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 17487 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 17488} 17489 17490 17491 17492 17493var 17494 17495 // Map over jQuery in case of overwrite 17496 _jQuery = window.jQuery, 17497 17498 // Map over the $ in case of overwrite 17499 _$ = window.$; 17500 17501jQuery.noConflict = function( deep ) { 17502 if ( window.$ === jQuery ) { 17503 window.$ = _$; 17504 } 17505 17506 if ( deep && window.jQuery === jQuery ) { 17507 window.jQuery = _jQuery; 17508 } 17509 17510 return jQuery; 17511}; 17512 17513// Expose jQuery and $ identifiers, even in AMD 17514// (#7102#comment:10, https://github.com/jquery/jquery/pull/557) 17515// and CommonJS for browser emulators (#13566) 17516if ( !noGlobal ) { 17517 window.jQuery = window.$ = jQuery; 17518} 17519 17520 17521 17522 17523return jQuery; 17524} ); 17525 17526 17527/***/ }), 17528/* 5 */ 17529/***/ (function(module, exports, __webpack_require__) { 17530 17531"use strict"; 17532 17533 17534var color = __webpack_require__(24); 17535var helpers = __webpack_require__(1); 17536 17537function interpolate(start, view, model, ease) { 17538 var keys = Object.keys(model); 17539 var i, ilen, key, actual, origin, target, type, c0, c1; 17540 17541 for (i = 0, ilen = keys.length; i < ilen; ++i) { 17542 key = keys[i]; 17543 17544 target = model[key]; 17545 17546 // if a value is added to the model after pivot() has been called, the view 17547 // doesn't contain it, so let's initialize the view to the target value. 17548 if (!view.hasOwnProperty(key)) { 17549 view[key] = target; 17550 } 17551 17552 actual = view[key]; 17553
17554 if (actual === target || key[0] === '_') { 17555 continue; 17556 } 17557 17558 if (!start.hasOwnProperty(key)) { 17559 start[key] = actual; 17560 } 17561 17562 origin = start[key]; 17563 17564 type = typeof target; 17565 17566 if (type === typeof origin) { 17567 if (type === 'string') { 17568 c0 = color(origin); 17569 if (c0.valid) { 17570 c1 = color(target); 17571 if (c1.valid) { 17572 view[key] = c1.mix(c0, ease).rgbString(); 17573 continue; 17574 } 17575 } 17576 } else if (type === 'number' && isFinite(origin) && isFinite(target)) { 17577 view[key] = origin + (target - origin) * ease; 17578 continue; 17579 } 17580 } 17581 17582 view[key] = target; 17583 } 17584} 17585 17586var Element = function(configuration) { 17587 helpers.extend(this, configuration); 17588 this.initialize.apply(this, arguments); 17589}; 17590 17591helpers.extend(Element.prototype, { 17592 17593 initialize: function() { 17594 this.hidden = false; 17595 }, 17596 17597 pivot: function() { 17598 var me = this; 17599 if (!me._view) { 17600 me._view = helpers.clone(me._model); 17601 } 17602 me._start = {}; 17603 return me; 17604 }, 17605 17606 transition: function(ease) { 17607 var me = this; 17608 var model = me._model; 17609 var start = me._start; 17610 var view = me._view; 17611 17612 // No animation -> No Transition 17613 if (!model || ease === 1) { 17614 me._view = model; 17615 me._start = null; 17616 return me; 17617 } 17618 17619 if (!view) { 17620 view = me._view = {}; 17621 } 17622 17623 if (!start) { 17624 start = me._start = {}; 17625 } 17626 17627 interpolate(start, view, model, ease); 17628 17629 return me; 17630 }, 17631 17632 tooltipPosition: function() { 17633 return { 17634 x: this._model.x, 17635 y: this._model.y 17636 }; 17637 }, 17638 17639 hasValue: function() { 17640 return helpers.isNumber(this._model.x) && helpers.isNumber(this._model.y); 17641 } 17642}); 17643 17644Element.extend = helpers.inherits; 17645 17646module.exports = Element; 17647 17648 17649/***/ }), 17650/* 6 */ 17651/***/ (function(module, exports, __webpack_require__) { 17652 17653"use strict"; 17654/* WEBPACK VAR INJECTION */(function(jQuery) { 17655 17656Object.defineProperty(exports, "__esModule", { 17657 value: true 17658}); 17659exports.get_language = exports.get_random_int = exports.is_in_view = exports.enableScroll = exports.disableScroll = exports.cleanTimeline = exports.cleanNode = exports.scrollTo = undefined; 17660 17661var _gsap = __webpack_require__(8); 17662 17663var scrollTo = function scrollTo(element, to, duration) { 17664 var start = element.scrollTop, 17665 change = to - start, 17666 currentTime = 0, 17667 increment = 20; 17668 17669 var animateScroll = function animateScroll() { 17670 currentTime += increment; 17671 element.scrollTop = Math.easeInOutQuad(currentTime, start, change, duration); 17672 if (currentTime < duration) { 17673 setTimeout(animateScroll, increment); 17674 } 17675 }; 17676 animateScroll(); 17677}; 17678 17679Math.easeInOutQuad = function (t, b, c, d) { 17680 t /= d / 2; 17681 if (t < 1) return c / 2 * t * t + b; 17682 t--; 17683 return -c / 2 * (t * (t - 2) - 1) + b; 17684}; 17685 17686var iterate = function iterate(task, node) { 17687 for (var x = 0; x < node.childNodes.length; x++) { 17688 var childNode = node.childNodes[x]; 17689 17690 task(childNode); 17691 17692 if (childNode.childNodes.length > 0) { 17693 iterate(task, childNode); 17694 } 17695 } 17696}; 17697 17698var cleanTimeline = function cleanTimeline(timeline) { 17699 17700 timeline.seek(0); 17701 var targets = [];
17702 timeline.getChildren().forEach(function (tween) { 17703 return targets.push(tween.target); 17704 }); 17705 17706 targets.forEach(function (node) { 17707 _gsap.TweenMax.killTweensOf(node); 17708 _gsap.TweenMax.set(node, { clearProps: 'all' }); 17709 }); 17710}; 17711 17712var cleanNode = function cleanNode(el) { 17713 var element = el || document.body; 17714 17715 iterate(function (node) { 17716 if (node._gsTransform) { 17717 _gsap.TweenMax.killTweensOf(node); 17718 _gsap.TweenMax.set(node, { clearProps: 'all' }); 17719 } 17720 }, element); 17721}; 17722 17723var keys = { 37: 1, 38: 1, 39: 1, 40: 1 }; 17724 17725var preventDefault = function preventDefault(e) { 17726 e = e || window.event; 17727 if (e.preventDefault) e.preventDefault(); 17728 e.returnValue = false; 17729}; 17730 17731var preventDefaultForScrollKeys = function preventDefaultForScrollKeys(e) { 17732 if (keys[e.keyCode]) { 17733 preventDefault(e); 17734 return false; 17735 } 17736}; 17737 17738var disableScroll = function disableScroll() { 17739 if (window.addEventListener) // older FF 17740 window.addEventListener('DOMMouseScroll', preventDefault, false); 17741 window.addEventListener('scroll', preventDefault, false); 17742 window.addEventListener('touchmove', preventDefault, false); 17743 window.onwheel = preventDefault; // modern standard 17744 window.onmousewheel = document.onmousewheel = preventDefault; // older browsers, IE 17745 window.ontouchmove = preventDefault; // mobile 17746 document.onkeydown = preventDefaultForScrollKeys; 17747}; 17748 17749var enableScroll = function enableScroll() { 17750 if (window.removeEventListener) window.removeEventListener('DOMMouseScroll', preventDefault, false); 17751 window.removeEventListener('scroll', preventDefault, false); 17752 window.removeEventListener('touchmove', preventDefault, false); 17753 window.onmousewheel = document.onmousewheel = null; 17754 window.onwheel = null; 17755 window.ontouchmove = null; 17756 document.onkeydown = null; 17757}; 17758 17759var is_in_view = function is_in_view(element) { 17760 var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 500; 17761 17762 17763 if (typeof jQuery === "function" && element instanceof jQuery) { 17764 element = element[0]; 17765 } 17766 17767 var rect = element.getBoundingClientRect(); 17768 17769 return rect.top <= window.innerHeight - 50; 17770}; 17771 17772var get_random_int = function get_random_int(min, max) { 17773 17774 min = Math.ceil(min); 17775 max = Math.floor(max); 17776 return Math.floor(Math.random() * (max - min)) + min; 17777}; 17778 17779var get_language = function get_language() { 17780 17781 var language = false; 17782 17783 if (currentLanguage) { 17784 language = currentLanguage; 17785 } else { 17786 language = 'fr'; 17787 } 17788 17789 return language; 17790}; 17791 17792exports.scrollTo = scrollTo; 17793exports.cleanNode = cleanNode; 17794exports.cleanTimeline = cleanTimeline; 17795exports.disableScroll = disableScroll; 17796exports.enableScroll = enableScroll; 17797exports.is_in_view = is_in_view; 17798exports.get_random_int = get_random_int; 17799exports.get_language = get_language; 17800/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4))) 17801 17802/***/ }), 17803/* 7 */ 17804/***/ (function(module, exports, __webpack_require__) { 17805 17806"use strict"; 17807 17808 17809module.exports = {}; 17810module.exports.Arc = __webpack_require__(208); 17811module.exports.Line = __webpack_require__(209); 17812module.exports.Point = __webpack_require__(210); 17813module.exports.Rectangle = __webpack_require__(211); 17814 17815 17816/***/ }), 17817/* 8 */ 17818/***/ (function(module, __webpack_exports__, __webpack_require__) { 17819 17820"use strict"; 17821Object.defineProperty(__webpack_exports__, "__esModule", { value: true }); 17822/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__ = __webpack_require__(3); 17823/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__TimelineLite_js__ = __webpack_require__(15); 17824/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__TimelineMax_js__ = __webpack_require__(31); 17825/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__TweenMax_js__ = __webpack_require__(235); 17826/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__CSSPlugin_js__ = __webpack_require__(27); 17827/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__AttrPlugin_js__ = __webpack_require__(25); 17828/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__RoundPropsPlugin_js__ = __webpack_require__(30); 17829/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__DirectionalRotationPlugin_js__ = __webpack_require__(28); 17830/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__BezierPlugin_js__ = __webpack_require__(26); 17831/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__EasePack_js__ = __webpack_require__(29); 17832/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return __WEBPACK_IMPORTED_MODULE_3__TweenMax_js__["a"]; }); 17833/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "TweenLite", function() { return __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"]; }); 17834/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "TweenMax", function() { return __WEBPACK_IMPORTED_MODULE_3__TweenMax_js__["a"]; }); 17835/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "TimelineLite", function() { return __WEBPACK_IMPORTED_MODULE_1__TimelineLite_js__["a"]; }); 17836/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "TimelineMax", function() { return __WEBPACK_IMPORTED_MODULE_2__TimelineMax_js__["a"]; }); 17837/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "CSSPlugin", function() { return __WEBPACK_IMPORTED_MODULE_4__CSSPlugin_js__["a"]; }); 17838/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "AttrPlugin", function() { return __WEBPACK_IMPORTED_MODULE_5__AttrPlugin_js__["a"]; }); 17839/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "BezierPlugin", function() { return __WEBPACK_IMPORTED_MODULE_8__BezierPlugin_js__["a"]; }); 17840/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "RoundPropsPlugin", function() { return __WEBPACK_IMPORTED_MODULE_6__RoundPropsPlugin_js__["a"]; }); 17841/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "DirectionalRotationPlugin", function() { return __WEBPACK_IMPORTED_MODULE_7__DirectionalRotationPlugin_js__["a"]; }); 17842/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "TweenPlugin", function() { return __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["TweenPlugin"]; }); 17843/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Ease", function() { return __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Ease"]; }); 17844/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Power0", function() { return __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Power0"]; }); 17845/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Power1", function() { return __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Power1"]; }); 17846/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Power2", function() { return __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Power2"]; }); 17847/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Power3", function() { return __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Power3"]; }); 17848/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Power4", function() { return __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Power4"]; }); 17849/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Linear", function() { return __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Linear"]; }); 17850/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Back", function() { return __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["a"]; }); 17851/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Elastic", function() { return __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["b"]; }); 17852/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Bounce", function() { return __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["c"]; }); 17853/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "RoughEase", function() { return __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["d"]; }); 17854/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "SlowMo", function() { return __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["e"]; }); 17855/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "SteppedEase", function() { return __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["f"]; }); 17856/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Circ", function() { return __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["g"]; }); 17857/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Expo", function() { return __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["h"]; }); 17858/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Sine", function() { return __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["i"]; }); 17859/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "ExpoScaleEase", function() { return __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["j"]; }); 17860/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "_gsScope", function() { return __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"]; }); 17861/*! 17862 * VERSION: 2.0.1 17863 * DATE: 2018-05-30 17864 * UPDATES AND DOCS AT: http://greensock.com 17865 * 17866 * @license Copyright (c) 2008-2018, GreenSock. All rights reserved. 17867 * This work is subject to the terms at http://greensock.com/standard-license or for
17868 * Club GreenSock members, the software agreement that was issued with your membership. 17869 * 17870 * @author: Jack Doyle, [email protected] 17871 **/ 17872 17873 17874 17875 17876 17877 17878 17879 17880 17881 17882 17883 17884 17885 17886 17887 17888/***/ }), 17889/* 9 */ 17890/***/ (function(module, exports, __webpack_require__) { 17891 17892"use strict"; 17893 17894 17895var helpers = __webpack_require__(1); 17896 17897function filterByPosition(array, position) { 17898 return helpers.where(array, function(v) { 17899 return v.position === position; 17900 }); 17901} 17902 17903function sortByWeight(array, reverse) { 17904 array.forEach(function(v, i) { 17905 v._tmpIndex_ = i; 17906 return v; 17907 }); 17908 array.sort(function(a, b) { 17909 var v0 = reverse ? b : a; 17910 var v1 = reverse ? a : b; 17911 return v0.weight === v1.weight ? 17912 v0._tmpIndex_ - v1._tmpIndex_ : 17913 v0.weight - v1.weight; 17914 }); 17915 array.forEach(function(v) { 17916 delete v._tmpIndex_; 17917 }); 17918} 17919 17920/** 17921 * @interface ILayoutItem 17922 * @prop {String} position - The position of the item in the chart layout. Possible values are 17923 * 'left', 'top', 'right', 'bottom', and 'chartArea' 17924 * @prop {Number} weight - The weight used to sort the item. Higher weights are further away from the chart area 17925 * @prop {Boolean} fullWidth - if true, and the item is horizontal, then push vertical boxes down 17926 * @prop {Function} isHorizontal - returns true if the layout item is horizontal (ie. top or bottom) 17927 * @prop {Function} update - Takes two parameters: width and height. Returns size of item 17928 * @prop {Function} getPadding - Returns an object with padding on the edges 17929 * @prop {Number} width - Width of item. Must be valid after update() 17930 * @prop {Number} height - Height of item. Must be valid after update() 17931 * @prop {Number} left - Left edge of the item. Set by layout system and cannot be used in update 17932 * @prop {Number} top - Top edge of the item. Set by layout system and cannot be used in update 17933 * @prop {Number} right - Right edge of the item. Set by layout system and cannot be used in update 17934 * @prop {Number} bottom - Bottom edge of the item. Set by layout system and cannot be used in update 17935 */ 17936 17937// The layout service is very self explanatory. It's responsible for the layout within a chart. 17938// Scales, Legends and Plugins all rely on the layout service and can easily register to be placed anywhere they need 17939// It is this service's responsibility of carrying out that layout. 17940module.exports = { 17941 defaults: {}, 17942 17943 /** 17944 * Register a box to a chart. 17945 * A box is simply a reference to an object that requires layout. eg. Scales, Legend, Title. 17946 * @param {Chart} chart - the chart to use 17947 * @param {ILayoutItem} item - the item to add to be layed out 17948 */ 17949 addBox: function(chart, item) { 17950 if (!chart.boxes) { 17951 chart.boxes = []; 17952 } 17953 17954 // initialize item with default values 17955 item.fullWidth = item.fullWidth || false; 17956 item.position = item.position || 'top'; 17957 item.weight = item.weight || 0; 17958 17959 chart.boxes.push(item); 17960 }, 17961 17962 /** 17963 * Remove a layoutItem from a chart 17964 * @param {Chart} chart - the chart to remove the box from 17965 * @param {Object} layoutItem - the item to remove from the layout 17966 */ 17967 removeBox: function(chart, layoutItem) { 17968 var index = chart.boxes ? chart.boxes.indexOf(layoutItem) : -1; 17969 if (index !== -1) { 17970 chart.boxes.splice(index, 1); 17971 } 17972 }, 17973 17974 /** 17975 * Sets (or updates) options on the given `item`. 17976 * @param {Chart} chart - the chart in which the item lives (or will be added to) 17977 * @param {Object} item - the item to configure with the given options 17978 * @param {Object} options - the new item options. 17979 */ 17980 configure: function(chart, item, options) { 17981 var props = ['fullWidth', 'position', 'weight']; 17982 var ilen = props.length; 17983 var i = 0; 17984 var prop; 17985 17986 for (; i < ilen; ++i) { 17987 prop = props[i]; 17988 if (options.hasOwnProperty(prop)) { 17989 item[prop] = options[prop]; 17990 } 17991 } 17992 }, 17993 17994 /** 17995 * Fits boxes of the given chart into the given size by having each box measure itself 17996 * then running a fitting algorithm 17997 * @param {Chart} chart - the chart 17998 * @param {Number} width - the width to fit into 17999 * @param {Number} height - the height to fit into 18000 */ 18001 update: function(chart, width, height) { 18002 if (!chart) { 18003 return; 18004 } 18005 18006 var layoutOptions = chart.options.layout || {}; 18007 var padding = helpers.options.toPadding(layoutOptions.padding); 18008 var leftPadding = padding.left; 18009 var rightPadding = padding.right; 18010 var topPadding = padding.top; 18011 var bottomPadding = padding.bottom; 18012
18013 var leftBoxes = filterByPosition(chart.boxes, 'left'); 18014 var rightBoxes = filterByPosition(chart.boxes, 'right'); 18015 var topBoxes = filterByPosition(chart.boxes, 'top'); 18016 var bottomBoxes = filterByPosition(chart.boxes, 'bottom'); 18017 var chartAreaBoxes = filterByPosition(chart.boxes, 'chartArea'); 18018 18019 // Sort boxes by weight. A higher weight is further away from the chart area 18020 sortByWeight(leftBoxes, true); 18021 sortByWeight(rightBoxes, false); 18022 sortByWeight(topBoxes, true); 18023 sortByWeight(bottomBoxes, false); 18024 18025 // Essentially we now have any number of boxes on each of the 4 sides. 18026 // Our canvas looks like the following. 18027 // The areas L1 and L2 are the left axes. R1 is the right axis, T1 is the top axis and 18028 // B1 is the bottom axis 18029 // There are also 4 quadrant-like locations (left to right instead of clockwise) reserved for chart overlays 18030 // These locations are single-box locations only, when trying to register a chartArea location that is already taken, 18031 // an error will be thrown. 18032 // 18033 // |----------------------------------------------------| 18034 // | T1 (Full Width) | 18035 // |----------------------------------------------------| 18036 // | | | T2 | | 18037 // | |----|-------------------------------------|----| 18038 // | | | C1 | | C2 | | 18039 // | | |----| |----| | 18040 // | | | | | 18041 // | L1 | L2 | ChartArea (C0) | R1 | 18042 // | | | | | 18043 // | | |----| |----| | 18044 // | | | C3 | | C4 | | 18045 // | |----|-------------------------------------|----| 18046 // | | | B1 | | 18047 // |----------------------------------------------------| 18048 // | B2 (Full Width) | 18049 // |----------------------------------------------------| 18050 // 18051 // What we do to find the best sizing, we do the following 18052 // 1. Determine the minimum size of the chart area. 18053 // 2. Split the remaining width equally between each vertical axis 18054 // 3. Split the remaining height equally between each horizontal axis 18055 // 4. Give each layout the maximum size it can be. The layout will return it's minimum size 18056 // 5. Adjust the sizes of each axis based on it's minimum reported size. 18057 // 6. Refit each axis 18058 // 7. Position each axis in the final location 18059 // 8. Tell the chart the final location of the chart area 18060 // 9. Tell any axes that overlay the chart area the positions of the chart area 18061 18062 // Step 1 18063 var chartWidth = width - leftPadding - rightPadding; 18064 var chartHeight = height - topPadding - bottomPadding; 18065 var chartAreaWidth = chartWidth / 2; // min 50% 18066 var chartAreaHeight = chartHeight / 2; // min 50% 18067 18068 // Step 2 18069 var verticalBoxWidth = (width - chartAreaWidth) / (leftBoxes.length + rightBoxes.length); 18070 18071 // Step 3 18072 var horizontalBoxHeight = (height - chartAreaHeight) / (topBoxes.length + bottomBoxes.length); 18073 18074 // Step 4 18075 var maxChartAreaWidth = chartWidth; 18076 var maxChartAreaHeight = chartHeight; 18077 var minBoxSizes = []; 18078 18079 function getMinimumBoxSize(box) { 18080 var minSize; 18081 var isHorizontal = box.isHorizontal(); 18082 18083 if (isHorizontal) { 18084 minSize = box.update(box.fullWidth ? chartWidth : maxChartAreaWidth, horizontalBoxHeight); 18085 maxChartAreaHeight -= minSize.height; 18086 } else { 18087 minSize = box.update(verticalBoxWidth, maxChartAreaHeight); 18088 maxChartAreaWidth -= minSize.width; 18089 } 18090 18091 minBoxSizes.push({ 18092 horizontal: isHorizontal, 18093 minSize: minSize, 18094 box: box, 18095 }); 18096 } 18097 18098 helpers.each(leftBoxes.concat(rightBoxes, topBoxes, bottomBoxes), getMinimumBoxSize); 18099 18100 // If a horizontal box has padding, we move the left boxes over to avoid ugly charts (see issue #2478) 18101 var maxHorizontalLeftPadding = 0; 18102 var maxHorizontalRightPadding = 0; 18103 var maxVerticalTopPadding = 0; 18104 var maxVerticalBottomPadding = 0; 18105 18106 helpers.each(topBoxes.concat(bottomBoxes), function(horizontalBox) { 18107 if (horizontalBox.getPadding) { 18108 var boxPadding = horizontalBox.getPadding(); 18109 maxHorizontalLeftPadding = Math.max(maxHorizontalLeftPadding, boxPadding.left); 18110 maxHorizontalRightPadding = Math.max(maxHorizontalRightPadding, boxPadding.right); 18111 } 18112 }); 18113 18114 helpers.each(leftBoxes.concat(rightBoxes), function(verticalBox) { 18115 if (verticalBox.getPadding) { 18116 var boxPadding = verticalBox.getPadding(); 18117 maxVerticalTopPadding = Math.max(maxVerticalTopPadding, boxPadding.top); 18118 maxVerticalBottomPadding = Math.max(maxVerticalBottomPadding, boxPadding.bottom); 18119 } 18120 }); 18121 18122 // At this point, maxChartAreaHeight and maxChartAreaWidth are the size the chart area could 18123 // be if the axes are drawn at their minimum sizes. 18124 // Steps 5 & 6 18125 var totalLeftBoxesWidth = leftPadding; 18126 var totalRightBoxesWidth = rightPadding;
18127 var totalTopBoxesHeight = topPadding; 18128 var totalBottomBoxesHeight = bottomPadding; 18129 18130 // Function to fit a box 18131 function fitBox(box) { 18132 var minBoxSize = helpers.findNextWhere(minBoxSizes, function(minBox) { 18133 return minBox.box === box; 18134 }); 18135 18136 if (minBoxSize) { 18137 if (box.isHorizontal()) { 18138 var scaleMargin = { 18139 left: Math.max(totalLeftBoxesWidth, maxHorizontalLeftPadding), 18140 right: Math.max(totalRightBoxesWidth, maxHorizontalRightPadding), 18141 top: 0, 18142 bottom: 0 18143 }; 18144 18145 // Don't use min size here because of label rotation. When the labels are rotated, their rotation highly depends 18146 // on the margin. Sometimes they need to increase in size slightly 18147 box.update(box.fullWidth ? chartWidth : maxChartAreaWidth, chartHeight / 2, scaleMargin); 18148 } else { 18149 box.update(minBoxSize.minSize.width, maxChartAreaHeight); 18150 } 18151 } 18152 } 18153 18154 // Update, and calculate the left and right margins for the horizontal boxes 18155 helpers.each(leftBoxes.concat(rightBoxes), fitBox); 18156 18157 helpers.each(leftBoxes, function(box) { 18158 totalLeftBoxesWidth += box.width; 18159 }); 18160 18161 helpers.each(rightBoxes, function(box) { 18162 totalRightBoxesWidth += box.width; 18163 }); 18164 18165 // Set the Left and Right margins for the horizontal boxes 18166 helpers.each(topBoxes.concat(bottomBoxes), fitBox); 18167 18168 // Figure out how much margin is on the top and bottom of the vertical boxes 18169 helpers.each(topBoxes, function(box) { 18170 totalTopBoxesHeight += box.height; 18171 }); 18172 18173 helpers.each(bottomBoxes, function(box) { 18174 totalBottomBoxesHeight += box.height; 18175 }); 18176 18177 function finalFitVerticalBox(box) { 18178 var minBoxSize = helpers.findNextWhere(minBoxSizes, function(minSize) { 18179 return minSize.box === box; 18180 }); 18181 18182 var scaleMargin = { 18183 left: 0, 18184 right: 0, 18185 top: totalTopBoxesHeight, 18186 bottom: totalBottomBoxesHeight 18187 }; 18188 18189 if (minBoxSize) { 18190 box.update(minBoxSize.minSize.width, maxChartAreaHeight, scaleMargin); 18191 } 18192 } 18193 18194 // Let the left layout know the final margin 18195 helpers.each(leftBoxes.concat(rightBoxes), finalFitVerticalBox); 18196 18197 // Recalculate because the size of each layout might have changed slightly due to the margins (label rotation for instance) 18198 totalLeftBoxesWidth = leftPadding; 18199 totalRightBoxesWidth = rightPadding; 18200 totalTopBoxesHeight = topPadding; 18201 totalBottomBoxesHeight = bottomPadding; 18202 18203 helpers.each(leftBoxes, function(box) { 18204 totalLeftBoxesWidth += box.width; 18205 }); 18206 18207 helpers.each(rightBoxes, function(box) { 18208 totalRightBoxesWidth += box.width; 18209 }); 18210 18211 helpers.each(topBoxes, function(box) { 18212 totalTopBoxesHeight += box.height; 18213 }); 18214 helpers.each(bottomBoxes, function(box) { 18215 totalBottomBoxesHeight += box.height; 18216 }); 18217 18218 // We may be adding some padding to account for rotated x axis labels 18219 var leftPaddingAddition = Math.max(maxHorizontalLeftPadding - totalLeftBoxesWidth, 0); 18220 totalLeftBoxesWidth += leftPaddingAddition; 18221 totalRightBoxesWidth += Math.max(maxHorizontalRightPadding - totalRightBoxesWidth, 0); 18222 18223 var topPaddingAddition = Math.max(maxVerticalTopPadding - totalTopBoxesHeight, 0); 18224 totalTopBoxesHeight += topPaddingAddition; 18225 totalBottomBoxesHeight += Math.max(maxVerticalBottomPadding - totalBottomBoxesHeight, 0); 18226 18227 // Figure out if our chart area changed. This would occur if the dataset layout label rotation 18228 // changed due to the application of the margins in step 6. Since we can only get bigger, this is safe to do 18229 // without calling `fit` again 18230 var newMaxChartAreaHeight = height - totalTopBoxesHeight - totalBottomBoxesHeight; 18231 var newMaxChartAreaWidth = width - totalLeftBoxesWidth - totalRightBoxesWidth; 18232 18233 if (newMaxChartAreaWidth !== maxChartAreaWidth || newMaxChartAreaHeight !== maxChartAreaHeight) { 18234 helpers.each(leftBoxes, function(box) { 18235 box.height = newMaxChartAreaHeight; 18236 }); 18237 18238 helpers.each(rightBoxes, function(box) { 18239 box.height = newMaxChartAreaHeight; 18240 }); 18241 18242 helpers.each(topBoxes, function(box) { 18243 if (!box.fullWidth) { 18244 box.width = newMaxChartAreaWidth; 18245 } 18246 }); 18247 18248 helpers.each(bottomBoxes, function(box) { 18249 if (!box.fullWidth) { 18250 box.width = newMaxChartAreaWidth; 18251 } 18252 }); 18253 18254 maxChartAreaHeight = newMaxChartAreaHeight; 18255 maxChartAreaWidth = newMaxChartAreaWidth; 18256 } 18257 18258 // Step 7 - Position the boxes 18259 var left = leftPadding + leftPaddingAddition; 18260 var top = topPadding + topPaddingAddition; 18261 18262 function placeBox(box) { 18263 if (box.isHorizontal()) { 18264 box.left = box.fullWidth ? leftPadding : totalLeftBoxesWidth; 18265 box.right = box.fullWidth ? width - rightPadding : totalLeftBoxesWidth + maxChartAreaWidth; 18266 box.top = top; 18267 box.bottom = top + box.height; 18268 18269 // Move to next point 18270 top = box.bottom; 18271 18272 } else { 18273 18274 box.left = left; 18275 box.right = left + box.width;
vendor: 12,989 bytes, lines 18276-18738
18276 box.top = totalTopBoxesHeight; 18277 box.bottom = totalTopBoxesHeight + maxChartAreaHeight; 18278 18279 // Move to next point 18280 left = box.right; 18281 } 18282 } 18283 18284 helpers.each(leftBoxes.concat(topBoxes), placeBox); 18285 18286 // Account for chart width and height 18287 left += maxChartAreaWidth; 18288 top += maxChartAreaHeight; 18289 18290 helpers.each(rightBoxes, placeBox); 18291 helpers.each(bottomBoxes, placeBox); 18292 18293 // Step 8 18294 chart.chartArea = { 18295 left: totalLeftBoxesWidth, 18296 top: totalTopBoxesHeight, 18297 right: totalLeftBoxesWidth + maxChartAreaWidth, 18298 bottom: totalTopBoxesHeight + maxChartAreaHeight 18299 }; 18300 18301 // Step 9 18302 helpers.each(chartAreaBoxes, function(box) { 18303 box.left = chart.chartArea.left; 18304 box.top = chart.chartArea.top; 18305 box.right = chart.chartArea.right; 18306 box.bottom = chart.chartArea.bottom; 18307 18308 box.update(maxChartAreaWidth, maxChartAreaHeight); 18309 }); 18310 } 18311}; 18312 18313 18314/***/ }), 18315/* 10 */ 18316/***/ (function(module, exports, __webpack_require__) { 18317 18318"use strict"; 18319 18320 18321var helpers = __webpack_require__(1); 18322 18323/** 18324 * Namespace to hold static tick generation functions 18325 * @namespace Chart.Ticks 18326 */ 18327module.exports = { 18328 /** 18329 * Namespace to hold formatters for different types of ticks 18330 * @namespace Chart.Ticks.formatters 18331 */ 18332 formatters: { 18333 /** 18334 * Formatter for value labels 18335 * @method Chart.Ticks.formatters.values 18336 * @param value the value to display 18337 * @return {String|Array} the label to display 18338 */ 18339 values: function(value) { 18340 return helpers.isArray(value) ? value : '' + value; 18341 }, 18342 18343 /** 18344 * Formatter for linear numeric ticks 18345 * @method Chart.Ticks.formatters.linear 18346 * @param tickValue {Number} the value to be formatted 18347 * @param index {Number} the position of the tickValue parameter in the ticks array 18348 * @param ticks {Array<Number>} the list of ticks being converted 18349 * @return {String} string representation of the tickValue parameter 18350 */ 18351 linear: function(tickValue, index, ticks) { 18352 // If we have lots of ticks, don't use the ones 18353 var delta = ticks.length > 3 ? ticks[2] - ticks[1] : ticks[1] - ticks[0]; 18354 18355 // If we have a number like 2.5 as the delta, figure out how many decimal places we need 18356 if (Math.abs(delta) > 1) { 18357 if (tickValue !== Math.floor(tickValue)) { 18358 // not an integer 18359 delta = tickValue - Math.floor(tickValue); 18360 } 18361 } 18362 18363 var logDelta = helpers.log10(Math.abs(delta)); 18364 var tickString = ''; 18365 18366 if (tickValue !== 0) { 18367 var numDecimal = -1 * Math.floor(logDelta); 18368 numDecimal = Math.max(Math.min(numDecimal, 20), 0); // toFixed has a max of 20 decimal places 18369 tickString = tickValue.toFixed(numDecimal); 18370 } else { 18371 tickString = '0'; // never show decimal places for 0 18372 } 18373 18374 return tickString; 18375 }, 18376 18377 logarithmic: function(tickValue, index, ticks) { 18378 var remain = tickValue / (Math.pow(10, Math.floor(helpers.log10(tickValue)))); 18379 18380 if (tickValue === 0) { 18381 return '0'; 18382 } else if (remain === 1 || remain === 2 || remain === 5 || index === 0 || index === ticks.length - 1) { 18383 return tickValue.toExponential(); 18384 } 18385 return ''; 18386 } 18387 } 18388}; 18389 18390 18391/***/ }), 18392/* 11 */ 18393/***/ (function(module, exports, __webpack_require__) { 18394 18395"use strict"; 18396 18397 18398/** 18399 * @namespace Chart.helpers 18400 */ 18401var helpers = { 18402 /** 18403 * An empty function that can be used, for example, for optional callback. 18404 */ 18405 noop: function() {}, 18406 18407 /** 18408 * Returns a unique id, sequentially generated from a global variable. 18409 * @returns {Number} 18410 * @function 18411 */ 18412 uid: (function() { 18413 var id = 0; 18414 return function() { 18415 return id++; 18416 }; 18417 }()), 18418 18419 /** 18420 * Returns true if `value` is neither null nor undefined, else returns false. 18421 * @param {*} value - The value to test. 18422 * @returns {Boolean} 18423 * @since 2.7.0 18424 */ 18425 isNullOrUndef: function(value) { 18426 return value === null || typeof value === 'undefined'; 18427 }, 18428 18429 /** 18430 * Returns true if `value` is an array, else returns false. 18431 * @param {*} value - The value to test. 18432 * @returns {Boolean} 18433 * @function 18434 */ 18435 isArray: Array.isArray ? Array.isArray : function(value) { 18436 return Object.prototype.toString.call(value) === '[object Array]'; 18437 }, 18438 18439 /** 18440 * Returns true if `value` is an object (excluding null), else returns false. 18441 * @param {*} value - The value to test. 18442 * @returns {Boolean} 18443 * @since 2.7.0 18444 */ 18445 isObject: function(value) { 18446 return value !== null && Object.prototype.toString.call(value) === '[object Object]'; 18447 }, 18448 18449 /** 18450 * Returns `value` if defined, else returns `defaultValue`. 18451 * @param {*} value - The value to return if defined. 18452 * @param {*} defaultValue - The value to return if `value` is undefined. 18453 * @returns {*} 18454 */ 18455 valueOrDefault: function(value, defaultValue) { 18456 return typeof value === 'undefined' ? defaultValue : value; 18457 }, 18458 18459 /** 18460 * Returns value at the given `index` in array if defined, else returns `defaultValue`. 18461 * @param {Array} value - The array to lookup for value at `index`. 18462 * @param {Number} index - The index in `value` to lookup for value. 18463 * @param {*} defaultValue - The value to return if `value[index]` is undefined. 18464 * @returns {*} 18465 */ 18466 valueAtIndexOrDefault: function(value, index, defaultValue) { 18467 return helpers.valueOrDefault(helpers.isArray(value) ? value[index] : value, defaultValue); 18468 }, 18469 18470 /** 18471 * Calls `fn` with the given `args` in the scope defined by `thisArg` and returns the 18472 * value returned by `fn`. If `fn` is not a function, this method returns undefined. 18473 * @param {Function} fn - The function to call. 18474 * @param {Array|undefined|null} args - The arguments with which `fn` should be called. 18475 * @param {Object} [thisArg] - The value of `this` provided for the call to `fn`. 18476 * @returns {*} 18477 */ 18478 callback: function(fn, args, thisArg) { 18479 if (fn && typeof fn.call === 'function') { 18480 return fn.apply(thisArg, args); 18481 } 18482 }, 18483 18484 /** 18485 * Note(SB) for performance sake, this method should only be used when loopable type 18486 * is unknown or in none intensive code (not called often and small loopable). Else 18487 * it's preferable to use a regular for() loop and save extra function calls. 18488 * @param {Object|Array} loopable - The object or array to be iterated. 18489 * @param {Function} fn - The function to call for each item. 18490 * @param {Object} [thisArg] - The value of `this` provided for the call to `fn`. 18491 * @param {Boolean} [reverse] - If true, iterates backward on the loopable. 18492 */ 18493 each: function(loopable, fn, thisArg, reverse) { 18494 var i, len, keys; 18495 if (helpers.isArray(loopable)) { 18496 len = loopable.length; 18497 if (reverse) { 18498 for (i = len - 1; i >= 0; i--) { 18499 fn.call(thisArg, loopable[i], i); 18500 } 18501 } else { 18502 for (i = 0; i < len; i++) { 18503 fn.call(thisArg, loopable[i], i); 18504 } 18505 } 18506 } else if (helpers.isObject(loopable)) { 18507 keys = Object.keys(loopable); 18508 len = keys.length; 18509 for (i = 0; i < len; i++) { 18510 fn.call(thisArg, loopable[keys[i]], keys[i]); 18511 } 18512 } 18513 }, 18514 18515 /** 18516 * Returns true if the `a0` and `a1` arrays have the same content, else returns false. 18517 * @see http://stackoverflow.com/a/14853974 18518 * @param {Array} a0 - The array to compare 18519 * @param {Array} a1 - The array to compare 18520 * @returns {Boolean} 18521 */ 18522 arrayEquals: function(a0, a1) { 18523 var i, ilen, v0, v1; 18524 18525 if (!a0 || !a1 || a0.length !== a1.length) { 18526 return false; 18527 } 18528 18529 for (i = 0, ilen = a0.length; i < ilen; ++i) { 18530 v0 = a0[i]; 18531 v1 = a1[i]; 18532 18533 if (v0 instanceof Array && v1 instanceof Array) { 18534 if (!helpers.arrayEquals(v0, v1)) { 18535 return false; 18536 } 18537 } else if (v0 !== v1) { 18538 // NOTE: two different object instances will never be equal: {x:20} != {x:20} 18539 return false; 18540 } 18541 } 18542 18543 return true; 18544 }, 18545 18546 /** 18547 * Returns a deep copy of `source` without keeping references on objects and arrays. 18548 * @param {*} source - The value to clone. 18549 * @returns {*} 18550 */ 18551 clone: function(source) { 18552 if (helpers.isArray(source)) { 18553 return source.map(helpers.clone); 18554 } 18555 18556 if (helpers.isObject(source)) { 18557 var target = {}; 18558 var keys = Object.keys(source); 18559 var klen = keys.length; 18560 var k = 0; 18561 18562 for (; k < klen; ++k) { 18563 target[keys[k]] = helpers.clone(source[keys[k]]); 18564 } 18565 18566 return target; 18567 } 18568 18569 return source; 18570 }, 18571 18572 /** 18573 * The default merger when Chart.helpers.merge is called without merger option. 18574 * Note(SB): this method is also used by configMerge and scaleMerge as fallback. 18575 * @private 18576 */ 18577 _merger: function(key, target, source, options) { 18578 var tval = target[key]; 18579 var sval = source[key]; 18580 18581 if (helpers.isObject(tval) && helpers.isObject(sval)) { 18582 helpers.merge(tval, sval, options); 18583 } else { 18584 target[key] = helpers.clone(sval); 18585 } 18586 }, 18587 18588 /** 18589 * Merges source[key] in target[key] only if target[key] is undefined. 18590 * @private 18591 */ 18592 _mergerIf: function(key, target, source) { 18593 var tval = target[key]; 18594 var sval = source[key]; 18595 18596 if (helpers.isObject(tval) && helpers.isObject(sval)) { 18597 helpers.mergeIf(tval, sval); 18598 } else if (!target.hasOwnProperty(key)) { 18599 target[key] = helpers.clone(sval); 18600 } 18601 }, 18602 18603 /** 18604 * Recursively deep copies `source` properties into `target` with the given `options`. 18605 * IMPORTANT: `target` is not cloned and will be updated with `source` properties. 18606 * @param {Object} target - The target object in which all sources are merged into. 18607 * @param {Object|Array(Object)} source - Object(s) to merge into `target`. 18608 * @param {Object} [options] - Merging options: 18609 * @param {Function} [options.merger] - The merge method (key, target, source, options) 18610 * @returns {Object} The `target` object. 18611 */ 18612 merge: function(target, source, options) { 18613 var sources = helpers.isArray(source) ? source : [source]; 18614 var ilen = sources.length; 18615 var merge, i, keys, klen, k; 18616 18617 if (!helpers.isObject(target)) { 18618 return target; 18619 } 18620 18621 options = options || {}; 18622 merge = options.merger || helpers._merger; 18623 18624 for (i = 0; i < ilen; ++i) { 18625 source = sources[i]; 18626 if (!helpers.isObject(source)) { 18627 continue; 18628 } 18629 18630 keys = Object.keys(source); 18631 for (k = 0, klen = keys.length; k < klen; ++k) { 18632 merge(keys[k], target, source, options); 18633 } 18634 } 18635 18636 return target; 18637 }, 18638 18639 /** 18640 * Recursively deep copies `source` properties into `target` *only* if not defined in target. 18641 * IMPORTANT: `target` is not cloned and will be updated with `source` properties. 18642 * @param {Object} target - The target object in which all sources are merged into. 18643 * @param {Object|Array(Object)} source - Object(s) to merge into `target`. 18644 * @returns {Object} The `target` object. 18645 */ 18646 mergeIf: function(target, source) { 18647 return helpers.merge(target, source, {merger: helpers._mergerIf}); 18648 }, 18649 18650 /** 18651 * Applies the contents of two or more objects together into the first object. 18652 * @param {Object} target - The target object in which all objects are merged into. 18653 * @param {Object} arg1 - Object containing additional properties to merge in target. 18654 * @param {Object} argN - Additional objects containing properties to merge in target. 18655 * @returns {Object} The `target` object. 18656 */ 18657 extend: function(target) { 18658 var setFn = function(value, key) { 18659 target[key] = value; 18660 }; 18661 for (var i = 1, ilen = arguments.length; i < ilen; ++i) { 18662 helpers.each(arguments[i], setFn); 18663 } 18664 return target; 18665 }, 18666 18667 /** 18668 * Basic javascript inheritance based on the model created in Backbone.js 18669 */ 18670 inherits: function(extensions) { 18671 var me = this; 18672 var ChartElement = (extensions && extensions.hasOwnProperty('constructor')) ? extensions.constructor : function() { 18673 return me.apply(this, arguments); 18674 }; 18675 18676 var Surrogate = function() { 18677 this.constructor = ChartElement; 18678 }; 18679 18680 Surrogate.prototype = me.prototype; 18681 ChartElement.prototype = new Surrogate(); 18682 ChartElement.extend = helpers.inherits; 18683 18684 if (extensions) { 18685 helpers.extend(ChartElement.prototype, extensions); 18686 } 18687 18688 ChartElement.__super__ = me.prototype; 18689 return ChartElement; 18690 } 18691}; 18692 18693module.exports = helpers; 18694 18695// DEPRECATIONS 18696 18697/** 18698 * Provided for backward compatibility, use Chart.helpers.callback instead. 18699 * @function Chart.helpers.callCallback 18700 * @deprecated since version 2.6.0 18701 * @todo remove at version 3 18702 * @private 18703 */ 18704helpers.callCallback = helpers.callback; 18705 18706/** 18707 * Provided for backward compatibility, use Array.prototype.indexOf instead. 18708 * Array.prototype.indexOf compatibility: Chrome, Opera, Safari, FF1.5+, IE9+ 18709 * @function Chart.helpers.indexOf 18710 * @deprecated since version 2.7.0 18711 * @todo remove at version 3 18712 * @private 18713 */ 18714helpers.indexOf = function(array, item, fromIndex) { 18715 return Array.prototype.indexOf.call(array, item, fromIndex); 18716}; 18717 18718/** 18719 * Provided for backward compatibility, use Chart.helpers.valueOrDefault instead. 18720 * @function Chart.helpers.getValueOrDefault 18721 * @deprecated since version 2.7.0 18722 * @todo remove at version 3 18723 * @private 18724 */ 18725helpers.getValueOrDefault = helpers.valueOrDefault; 18726 18727/** 18728 * Provided for backward compatibility, use Chart.helpers.valueAtIndexOrDefault instead. 18729 * @function Chart.helpers.getValueAtIndexOrDefault 18730 * @deprecated since version 2.7.0 18731 * @todo remove at version 3 18732 * @private 18733 */ 18734helpers.getValueAtIndexOrDefault = helpers.valueAtIndexOrDefault; 18735 18736 18737/***/ }), 18738/* 12 */
18739/***/ (function(module, exports) { 18740 18741var g; 18742 18743// This works in non-strict mode 18744g = (function() { 18745 return this; 18746})(); 18747 18748try { 18749 // This works if eval is allowed (see CSP) 18750 g = g || Function("return this")() || (1,eval)("this"); 18751} catch(e) { 18752 // This works if the window reference is available 18753 if(typeof window === "object") 18754 g = window; 18755} 18756 18757// g can still be undefined, but nothing to do about it... 18758// We return undefined, instead of nothing here, so it's 18759// easier to handle this case. if(!global) { ...} 18760 18761module.exports = g; 18762 18763 18764/***/ }), 18765/* 13 */ 18766/***/ (function(module, exports, __webpack_require__) { 18767 18768"use strict"; 18769 18770 18771Object.defineProperty(exports, "__esModule", { 18772 value: true 18773}); 18774 18775var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 18776 18777var _gsap = __webpack_require__(8); 18778 18779var _utils = __webpack_require__(6); 18780 18781var _DrawSVGPlugin = __webpack_require__(178); 18782 18783function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 18784 18785__webpack_require__(18); 18786__webpack_require__(14); 18787 18788var Snap = __webpack_require__(16); 18789 18790var Navigation = function () { 18791 function Navigation(options) { 18792 _classCallCheck(this, Navigation); 18793 18794 this.options = options || {}; 18795 this.container = document.querySelector('.header_nav'); 18796 this.main_nav = document.querySelector('.header_nav_main_list'); 18797 this.secondary_nav = document.querySelector('.header_nav_secondary_list'); 18798 this.main_nav_items = this.main_nav.querySelectorAll('.menu-item-has-children'); 18799 this.secondary_nav_items = this.secondary_nav.querySelectorAll('.menu-item'); 18800 this.search_input = this.container.querySelector('.header_nav_search input'); 18801 this.search_icon = this.container.querySelector('.header_nav_search_icon'); 18802 this.decorators = this.container.querySelectorAll('.header_nav_decorator'); 18803 this.contact_btn = this.container.querySelector('#menu-contact a'); 18804 this.open_btn = document.querySelector('.header_burger'); 18805 this.back_btn = document.querySelector('.header_nav_back'); 18806 this.close_btn = document.querySelector('.header_nav_close-btn'); 18807 this.secondary_back_btn = document.querySelector('.header_nav_secondary_back'); 18808 this.init(); 18809 } 18810 18811 _createClass(Navigation, [{ 18812 key: 'init', 18813 value: function init() { 18814 18815 this.opened = false; 18816 this.active_submenu = null; 18817 // this.decorator_paths = this.decorator.querySelectorAll('path') 18818 this.timeline_is_active = false; 18819 this.device = this.get_device(); 18820 18821 this.open_tl = new _gsap.TimelineMax({ 18822 paused: true, 18823 support: this.device 18824 }); 18825 18826 this.submenuTL = new _gsap.TimelineMax({ 18827 paused: true 18828 }); 18829 18830 this.focus_tl = new _gsap.TimelineMax({ 18831 paused: true 18832 }); 18833 18834 // this.build_focus_timeline() 18835 18836 // this.load_decorator() 18837 this.init_events(); 18838 } 18839 }, { 18840 key: 'init_events', 18841 value: function init_events() { 18842 var _this = this; 18843 18844 // this.build_focus_timeline() 18845 18846 this.main_nav_items.forEach(function (item) { 18847 item.addEventListener('click', function (event) { 18848 18849 _this.close_contact(); 18850 18851 var target = null; 18852 18853 if (typeof event.target.attributes.href !== 'undefined' && event.target.attributes.href.value === '#') { 18854 event.preventDefault(); 18855 target = event.target.parentNode; 18856 } else { 18857 target = event.target; 18858 } 18859 18860 if (target.parentNode.classList.contains('active-item')) { 18861 target.parentNode.classList.remove('active-item'); 18862 } else { 18863 if (document.querySelector('.active-item')) { 18864 document.querySelector('.active-item').classList.remove('active-item'); 18865 } 18866 target.parentNode.classList.add('active-item'); 18867 } 18868 18869 if (!_this.timeline_is_active && window.innerWidth < 1024) { 18870 _this.active_submenu = target.querySelector('.sub-menu'); 18871 _this.toggle_submenu(_this.active_submenu); 18872 } 18873 }); 18874 }); 18875 18876 this.open_btn.addEventListener('click', function () { 18877 _this.open(); 18878 }); 18879 18880 this.close_btn.addEventListener('click', function () { 18881 _this.close(); 18882 _this.close_contact(); 18883 }); 18884 18885 this.back_btn.addEventListener('click', function () { 18886 if (!_this.timeline_is_active) { 18887 _this.toggle_submenu(_this.active_submenu); 18888 } 18889 }); 18890 18891 this.secondary_back_btn.addEventListener('click', function () { 18892 _this.close_contact(); 18893 }); 18894 18895 this.contact_btn.addEventListener('click', function (event) { 18896 _this.toggle_contact(); 18897 18898 var target = null; 18899 18900 if (typeof event.target.attributes.href !== 'undefined' && event.target.attributes.href.value === '#') { 18901 event.preventDefault(); 18902 target = event.target.parentNode; 18903 } else { 18904 target = event.target; 18905 } 18906 18907 if (target.parentNode.classList.contains('active-item')) { 18908 target.parentNode.classList.remove('active-item'); 18909 } else { 18910 if (document.querySelector('.active-item')) { 18911 document.querySelector('.active-item').classList.remove('active-item'); 18912 } 18913 target.parentNode.classList.add('active-item'); 18914 } 18915 18916 if (!_this.timeline_is_active && window.innerWidth < 1024) { 18917 _this.active_submenu = target.querySelector('.sub-menu'); 18918 _this.toggle_submenu(_this.active_submenu); 18919 } 18920 }); 18921 18922 // this.search_input.addEventListener('focus', () => { 18923 // // this.focus_search() 18924 // }) 18925 // 18926 // this.search_input.addEventListener('blur', () => { 18927 // // this.blur_search() 18928 // }) 18929 18930 // document.addEventListener('click', (event) => { 18931 // 18932 // const contact_btn_clicked = this.contact_btn.contains(event.target) 18933 // 18934 // if(!contact_btn_clicked) { 18935 // this.close_contact() 18936 // } 18937 // 18938 // }) 18939 18940 window.addEventListener('resize', function () { 18941 _this.device = _this.get_device(); 18942 _this.change_timelines(); 18943 }); 18944 18945 window.addEventListener('scroll', function (event) { 18946 if (_this.opened) { 18947 event.preventDefault(); 18948 } 18949 }); 18950 18951 document.addEventListener('DOMContentLoaded', function () { 18952 18953 if (window.innerWidth < 1024) { 18954 _this.build_mobile_timelines(); 18955 } else { 18956 _this.build_desktop_timelines(); 18957 } 18958 }); 18959 } 18960 }, {
18961 key: 'open', 18962 value: function open() { 18963 18964 this.open_tl.play(); 18965 this.container.classList.add('opened'); 18966 document.querySelector('html').classList.add('menu-opened'); 18967 // disableScroll() 18968 } 18969 }, { 18970 key: 'close', 18971 value: function close() { 18972 18973 this.open_tl.reverse(); 18974 this.container.classList.remove('opened'); 18975 this.close_contact(); 18976 document.querySelector('body').classList.remove('results-displayed'); 18977 document.querySelector('.header_nav_search_result_container').classList.remove('open'); 18978 document.querySelector('html').classList.remove('menu-opened'); 18979 if (this.container.querySelector('.active-item')) { 18980 this.container.querySelector('.active-item').classList.remove('active-item'); 18981 } 18982 // enableScroll() 18983 } 18984 }, { 18985 key: 'open_contact', 18986 value: function open_contact() { 18987 18988 this.container.classList.add('contact-opened'); 18989 } 18990 }, { 18991 key: 'close_contact', 18992 value: function close_contact() { 18993 18994 this.container.classList.remove('contact-opened'); 18995 } 18996 }, { 18997 key: 'toggle_contact', 18998 value: function toggle_contact() { 18999 19000 if (this.container.classList.contains('contact-opened')) { 19001 19002 this.close_contact(); 19003 } else { 19004 19005 this.open_contact(); 19006 } 19007 } 19008 }, { 19009 key: 'toggle_submenu', 19010 value: function toggle_submenu(submenu) { 19011 19012 var that = this; 19013 19014 this.submenuTL.add(_gsap.TweenMax.to(this.main_nav, 1, { 19015 x: '-150%', 19016 ease: Expo.easeInOut 19017 })); 19018 19019 this.submenuTL.add(_gsap.TweenMax.to(submenu, 1, { 19020 opacity: 1, 19021 visibility: 'visible' 19022 }), '-=1'); 19023 19024 this.submenuTL.add(_gsap.TweenMax.to(this.back_btn, 1, { 19025 x: 0, 19026 opacity: 1, 19027 visibility: 'visible', 19028 ease: Expo.easeInOut 19029 }), '-=1'); 19030 19031 var tween_to_remove = this.submenuTL.getTweensOf(submenu); 19032 19033 this.submenuTL.eventCallback('onReverseComplete', function () { 19034 that.submenuTL.remove(tween_to_remove); 19035 that.submenuTL.shiftChildren(); 19036 that.timeline_is_active = false; 19037 }); 19038 19039 this.submenuTL.eventCallback('onComplete', function () { 19040 that.timeline_is_active = false; 19041 }); 19042 19043 if (this.opened) { 19044 19045 this.submenuTL.reverse(); 19046 this.timeline_is_active = true; 19047 this.opened = false; 19048 } else { 19049 19050 this.submenuTL.play(); 19051 this.timeline_is_active = true; 19052 this.opened = true; 19053 } 19054 } 19055 }, { 19056 key: 'build_desktop_timelines', 19057 value: function build_desktop_timelines() { 19058 var _this2 = this; 19059 19060 this.open_tl.add(_gsap.TweenMax.to(this.container, 1, { 19061 y: 0, 19062 ease: Expo.easeInOut 19063 })); 19064 19065 this.secondary_nav_items.forEach(function (item) { 19066 _this2.open_tl.add(_gsap.TweenMax.to(item, 1, { 19067 y: 0, 19068 ease: Power3.easeInOut 19069 }, 0.05), 0.5); 19070 }); 19071 19072 this.main_nav_items.forEach(function (item) { 19073 19074 var direct_children = []; 19075 var line = item.querySelector('.header_nav_main_line'); 19076 19077 for (var i = 0; i < line.children.length; i++) { 19078 if (line.children[i].tagName === 'A') { 19079 direct_children.push(line.children[i]); 19080 } 19081 } 19082 19083 _this2.open_tl.add(_gsap.TweenMax.staggerTo(direct_children, 1, { 19084 y: 0, 19085 ease: Power3.easeInOut 19086 }, 0.05), 0.5); 19087 19088 // this.open_tl.add(TweenMax.staggerTo(item.querySelectorAll('.sub-menu a'), 1, { 19089 // y: 0, 19090 // ease: Power3.easeInOut 19091 // }, 0.05), 0.5) 19092 }); 19093 19094 this.open_tl.add(_gsap.TweenMax.to(this.search_input,
190941, { 19095 y: 0, 19096 ease: Power3.easeInOut 19097 }), 0.5); 19098 19099 this.open_tl.add(_gsap.TweenMax.to(this.decorators, 1, { 19100 opacity: 1 19101 }), 0.5); 19102 } 19103 }, { 19104 key: 'build_mobile_timelines', 19105 value: function build_mobile_timelines() { 19106 this.open_tl.add(_gsap.TweenMax.to(this.container, 1, { 19107 x: 0, 19108 ease: Expo.easeInOut 19109 })); 19110 } 19111 }, { 19112 key: 'change_timelines', 19113 value: function change_timelines() { 19114 19115 if (this.open_tl.vars.support === 'mobile' && window.innerWidth >= 1024) { 19116 19117 (0, _utils.cleanTimeline)(this.open_tl); 19118 (0, _utils.cleanTimeline)(this.submenuTL); 19119 this.open_tl.vars.support = this.device; 19120 this.build_desktop_timelines(); 19121 } else if (this.open_tl.vars.support === 'desktop' && window.innerWidth < 1024) { 19122 19123 (0, _utils.cleanTimeline)(this.open_tl); 19124 this.open_tl.vars.support = this.device; 19125 this.build_mobile_timelines(); 19126 } 19127 } 19128 }, { 19129 key: 'get_device', 19130 value: function get_device() { 19131 19132 var device = null; 19133 19134 if (window.innerWidth < 1024) { 19135 device = 'mobile'; 19136 } else { 19137 device = 'desktop'; 19138 } 19139 19140 return device; 19141 } 19142 }]); 19143 19144 return Navigation; 19145}(); 19146 19147exports.default = new Navigation(); 19148 19149/***/ }), 19150/* 14 */ 19151/***/ (function(module, exports, __webpack_require__) { 19152 19153"use strict"; 19154/* WEBPACK VAR INJECTION */(function(global) {var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__; 19155 19156/*! 19157 * VERSION: 0.6.0 19158 * DATE: 2018-05-21 19159 * UPDATES AND DOCS AT: http://greensock.com 19160 * 19161 * @license Copyright (c) 2008-2018, GreenSock. All rights reserved. 19162 * SplitText is a Club GreenSock membership benefit; You must have a valid membership to use 19163 * this code without violating the terms of use. Visit http://greensock.com/club/ to sign up or get more details. 19164 * This work is subject to the software agreement that was issued with your membership. 19165 * 19166 * @author: Jack Doyle, [email protected] 19167 */ 19168var _gsScope = "undefined" != typeof module && module.exports && "undefined" != typeof global ? global : undefined || window;!function (a) { 19169 "use strict"; 19170 var b = a.GreenSockGlobals || a, 19171 c = function c(a) { 19172 var c, 19173 d = a.split("."), 19174 e = b;for (c = 0; c < d.length; c++) { 19175 e[d[c]] = e = e[d[c]] || {}; 19176 }return e; 19177 }, 19178 d = c("com.greensock.utils"), 19179 e = function e(a) { 19180 var b = a.nodeType, 19181 c = "";if (1 === b || 9 === b || 11 === b) { 19182 if ("string" == typeof a.textContent) return a.textContent;for (a = a.firstChild; a; a = a.nextSibling) { 19183 c += e(a); 19184 } 19185 } else if (3 === b || 4 === b) return a.nodeValue;return c; 19186 }, 19187 f = document, 19188 g = f.defaultView ? f.defaultView.getComputedStyle : function () {}, 19189 h = /([A-Z])/g, 19190 i = function i(a, b, c, d) { 19191 var e;return (c = c || g(a, null)) ? (a = c.getPropertyValue(b.replace(h, "-$1").toLowerCase()), e = a || c.length ? a : c[b]) : a.currentStyle && (c = a.currentStyle, e = c[b]), d ? e : parseInt(e, 10) || 0; 19192 }, 19193 j = function j(a) { 19194 return a.length && a[0] && (a[0].nodeType && a[0].style && !a.nodeType || a[0].length && a[0][0]) ? !0 : !1; 19195 }, 19196 k = function k(a) { 19197 var b, 19198 c, 19199 d, 19200 e = [], 19201 f = a.length;for (b = 0; f > b; b++) { 19202 if (c = a[b], j(c)) for (d = c.length, d = 0; d < c.length; d++) { 19203 e.push(c[d]); 19204 } else e.push(c); 19205 }return e; 19206 }, 19207 l = function l(a, b) { 19208 for (var c, d = b.length; --d > -1;) { 19209 if (c = b[d], a.substr(0, c.length) === c) return c.length; 19210 } 19211 }, 19212 m = /(?:\r|\n|\t\t)/g, 19213 n = /(?:\s\s+)/g, 19214 o = 55296, 19215 p = 56319, 19216 q = 56320, 19217 r = 127462, 19218 s = 127487, 19219 t = 127995, 19220 u = 127999, 19221 v = function v(a) {
vendor: 4,624 bytes, lines 19222-19302
19222 return (a.charCodeAt(0) - o << 10) + (a.charCodeAt(1) - q) + 65536; 19223 }, 19224 w = f.all && !f.addEventListener, 19225 x = " style='position:relative;display:inline-block;" + (w ? "*display:inline;*zoom:1;'" : "'"), 19226 y = function y(a, b) { 19227 a = a || "";var c = -1 !== a.indexOf("++"), 19228 d = 1;return c && (a = a.split("++").join("")), function () { 19229 return "<" + b + x + (a ? " class='" + a + (c ? d++ : "") + "'>" : ">"); 19230 }; 19231 }, 19232 z = d.SplitText = b.SplitText = function (a, b) { 19233 if ("string" == typeof a && (a = z.selector(a)), !a) throw "cannot split a null element.";this.elements = j(a) ? k(a) : [a], this.chars = [], this.words = [], this.lines = [], this._originals = [], this.vars = b || {}, this.split(b); 19234 }, 19235 A = function A(a, b, c) { 19236 var d = a.nodeType;if (1 === d || 9 === d || 11 === d) for (a = a.firstChild; a; a = a.nextSibling) { 19237 A(a, b, c); 19238 } else (3 === d || 4 === d) && (a.nodeValue = a.nodeValue.split(b).join(c)); 19239 }, 19240 B = function B(a, b) { 19241 for (var c = b.length; --c > -1;) { 19242 a.push(b[c]); 19243 } 19244 }, 19245 C = function C(a) { 19246 var b, 19247 c = [], 19248 d = a.length;for (b = 0; b !== d; c.push(a[b++])) {}return c; 19249 }, 19250 D = function D(a, b, c) { 19251 for (var d; a && a !== b;) { 19252 if (d = a._next || a.nextSibling) return d.textContent.charAt(0) === c;a = a.parentNode || a._parent; 19253 }return !1; 19254 }, 19255 E = function E(a) { 19256 var b, 19257 c, 19258 d = C(a.childNodes), 19259 e = d.length;for (b = 0; e > b; b++) { 19260 c = d[b], c._isSplit ? E(c) : (b && 3 === c.previousSibling.nodeType ? c.previousSibling.nodeValue += 3 === c.nodeType ? c.nodeValue : c.firstChild.nodeValue : 3 !== c.nodeType && a.insertBefore(c.firstChild, c), a.removeChild(c)); 19261 } 19262 }, 19263 F = function F(a, b, c, d, e, h, j) { 19264 var k, 19265 l, 19266 m, 19267 n, 19268 o, 19269 p, 19270 q, 19271 r, 19272 s, 19273 t, 19274 u, 19275 v, 19276 w = g(a), 19277 x = i(a, "paddingLeft", w), 19278 y = -999, 19279 z = i(a, "borderBottomWidth", w) + i(a, "borderTopWidth", w), 19280 C = i(a, "borderLeftWidth", w) + i(a, "borderRightWidth", w), 19281 F = i(a, "paddingTop", w) + i(a, "paddingBottom", w), 19282 G = i(a, "paddingLeft", w) + i(a, "paddingRight", w), 19283 H = .2 * i(a, "fontSize"), 19284 I = i(a, "textAlign", w, !0), 19285 J = [], 19286 K = [], 19287 L = [], 19288 M = b.wordDelimiter || " ", 19289 N = b.span ? "span" : "div", 19290 O = b.type || b.split || "chars,words,lines", 19291 P = e && -1 !== O.indexOf("lines") ? [] : null, 19292 Q = -1 !== O.indexOf("words"), 19293 R = -1 !== O.indexOf("chars"), 19294 S = "absolute" === b.position || b.absolute === !0, 19295 T = b.linesClass, 19296 U = -1 !== (T || "").indexOf("++"), 19297 V = [];for (P && 1 === a.children.length && a.children[0]._isSplit && (a = a.children[0]), U && (T = T.split("++").join("")), l = a.getElementsByTagName("*"), m = l.length, o = [], k = 0; m > k; k++) { 19298 o[k] = l[k]; 19299 }if (P || S) for (k = 0; m > k; k++) { 19300 n = o[k], p = n.parentNode === a, (p || S || R && !Q) && (v = n.offsetTop, P && p && Math.abs(v - y) > H && ("BR" !== n.nodeName || 0 === k) && (q = [], P.push(q), y = v), S && (n._x = n.offsetLeft, n._y = v, n._w = n.offsetWidth, n._h = n.offsetHeight), P && ((n._isSplit && p || !R && p || Q && p || !Q && n.parentNode.parentNode === a && !n.parentNode._isSplit) && (q.push(n), n._x -= x, D(n, a, M) && (n._wordEnd = !0)), "BR" === n.nodeName && (n.nextSibling && "BR" === n.nextSibling.nodeName || 0 === k) && P.push([]))); 19301 }for (k = 0; m > k; k++) { 19302 n = o[k], p = n.parentNode === a, "BR" !== n.nodeName ? (S && (s = n.style, Q || p || (n._x += n.parentNode._x, n._y += n.parentNode._y), s.left = n._x + "px", s.top = n._y + "px", s.position = "absolute", s.display = "block", s.width = n._w + 1 + "px", s.height = n._h + "px"), !Q && R ? n._isSplit ? (n._next = n.nextSibling, n.parentNode.appendChild(n)) : n.parentNode._isSplit ? (n._parent = n.parentNode, !n.previousSibling && n.firstChild && (n.firstChild._isFirst = !0), n.nextSibling && " " === n.nextSibling.textContent && !n.nextSibling.nextSibling && V.push(n.nextSibling), n._next = n.nextSibling && n.nextSibling._isFirst ? null : n.nextSibling, n.parentNode.removeChild(n), o.splice(k--, 1), m--) : p || (v = !n.nextSibling && D(n.parentNode, a, M), n.parentNode._parent && n.parentNode._parent.appendChild(n), v && n.parentNode.appendChild(f.createTextNode(" ")), b.span && (n.style.display = "inline"), J.push(n)) : n.parentNode._isSplit && !n._isS
19302plit && "" !== n.innerHTML ? K.push(n) : R && !n._isSplit && (b.span && (n.style.display = "inline"), J.push(n))) : P || S ? (n.parentNode && n.parentNode.removeChild(n), o.splice(k--, 1), m--) : Q || a.appendChild(n); 19303 }for (k = V.length; --k > -1;) { 19304 V[k].parentNode.removeChild(V[k]); 19305 }if (P) { 19306 for (S && (t = f.createElement(N), a.appendChild(t), u = t.offsetWidth + "px", v = t.offsetParent === a ? 0 : a.offsetLeft, a.removeChild(t)), s = a.style.cssText, a.style.cssText = "display:none;"; a.firstChild;) { 19307 a.removeChild(a.firstChild); 19308 }for (r = " " === M && (!S || !Q && !R), k = 0; k < P.length; k++) { 19309 for (q = P[k], t = f.createElement(N), t.style.cssText = "display:block;text-align:" + I + ";position:" + (S ? "absolute;" : "relative;"), T && (t.className = T + (U ? k + 1 : "")), L.push(t), m = q.length, l = 0; m > l; l++) { 19310 "BR" !== q[l].nodeName && (n = q[l], t.appendChild(n), r && n._wordEnd && t.appendChild(f.createTextNode(" ")), S && (0 === l && (t.style.top = n._y + "px", t.style.left = x + v + "px"), n.style.top = "0px", v && (n.style.left = n._x - v + "px"))); 19311 }0 === m ? t.innerHTML = " " : Q || R || (E(t), A(t, String.fromCharCode(160), " ")), S && (t.style.width = u, t.style.height = n._h + "px"), a.appendChild(t); 19312 }a.style.cssText = s; 19313 }S && (j > a.clientHeight && (a.style.height = j - F + "px", a.clientHeight < j && (a.style.height = j + z + "px")), h > a.clientWidth && (a.style.width = h - G + "px", a.clientWidth < h && (a.style.width = h + C + "px"))), B(c, J), Q && B(d, K), B(e, L); 19314 }, 19315 G = function G(a, b, c, d) { 19316 var g, 19317 h, 19318 i, 19319 j, 19320 k, 19321 q, 19322 w, 19323 x, 19324 y, 19325 z, 19326 B = b.span ? "span" : "div", 19327 C = b.type || b.split || "chars,words,lines", 19328 D = -1 !== C.indexOf("chars"), 19329 E = "absolute" === b.position || b.absolute === !0, 19330 F = b.wordDelimiter || " ", 19331 G = " " !== F ? "" : E ? "­ " : " ", 19332 H = b.span ? "</span>" : "</div>", 19333 I = !0, 19334 J = b.specialChars ? "function" == typeof b.specialChars ? b.specialChars : l : null, 19335 K = f.createElement("div"), 19336 L = a.parentNode;for (L.insertBefore(K, a), K.textContent = a.nodeValue, L.removeChild(a), a = K, g = e(a), w = -1 !== g.indexOf("<"), b.reduceWhiteSpace !== !1 && (g = g.replace(n, " ").replace(m, "")), w && (g = g.split("<").join("{{LT}}
19336")), k = g.length, h = (" " === g.charAt(0) ? G : "") + c(), i = 0; k > i; i++) { 19337 if (q = g.charAt(i), J && (z = J(g.substr(i), b.specialChars))) q = g.substr(i, z || 1), h += D && " " !== q ? d() + q + "</" + B + ">" : q, i += z - 1;else if (q === F && g.charAt(i - 1) !== F && i) { 19338 for (h += I ? H : "", I = !1; g.charAt(i + 1) === F;) { 19339 h += G, i++; 19340 }i === k - 1 ? h += G : ")" !== g.charAt(i + 1) && (h += G + c(), I = !0); 19341 } else "{" === q && "{{LT}}" === g.substr(i, 6) ? (h += D ? d() + "{{LT}}</" + B + ">" : "{{LT}}", i += 5) : q.charCodeAt(0) >= o && q.charCodeAt(0) <= p || g.charCodeAt(i + 1) >= 65024 && g.charCodeAt(i + 1) <= 65039 ? (x = v(g.substr(i, 2)), y = v(g.substr(i + 2, 2)), j = x >= r && s >= x && y >= r && s >= y || y >= t && u >= y ? 4 : 2, h += D && " " !== q ? d() + g.substr(i, j) + "</" + B + ">" : g.substr(i, j), i += j - 1) : h += D && " " !== q ? d() + q + "</" + B + ">" : q; 19342 }a.outerHTML = h + (I ? H : ""), w && A(L, "{{LT}}", "<"); 19343 }, 19344 H = function H(a, b, c, d) { 19345 var e, 19346 f, 19347 g = C(a.childNodes), 19348 h = g.length, 19349 j = "absolute" === b.position || b.absolute === !0;if (3 !== a.nodeType || h > 1) { 19350 for (b.absolute = !1, e = 0; h > e; e++) { 19351 f = g[e], (3 !== f.nodeType || /\S+/.test(f.nodeValue)) && (j && 3 !== f.nodeType && "inline" === i(f, "display", null, !0) && (f.style.display = "inline-block", f.style.position = "relative"), f._isSplit = !0, H(f, b, c, d)); 19352 }return b.absolute = j, void (a._isSplit = !0); 19353 }G(a, b, c, d); 19354 }, 19355 I = z.prototype;I.split = function (a) { 19356 this.isSplit && this.revert(), this.vars = a = a || this.vars, this._originals.length = this.chars.length = this.words.length = this.lines.length = 0;for (var b, c, d, e = this.elements.length, f = a.span ? "span" : "div", g = y(a.wordsClass, f), h = y(a.charsClass, f); --e > -1;) { 19357 d = this.elements[e], this._originals[e] = d.innerHTML, b = d.clientHeight, c = d.clientWidth, H(d, a, g, h), F(d, a, this.chars, this.words, this.lines, c, b); 19358 }return this.chars.reverse(), this.words.reverse(), this.lines.reverse(), this.isSplit = !0, this; 19359 }, I.revert = function () { 19360 if (!this._originals) throw "revert() call wasn't scoped properly.";for (var a = this._originals.length; --a > -1;) { 19361 this.elements[a].innerHTML = this._originals[a]; 19362 }return this.chars = [], this.words = [], this.lines = [], this.isSplit = !1, this; 19363 }, z.selector = a.$ || a.jQuery || function (b) { 19364 var c = a.$ || a.jQuery;return c ? (z.selector = c, c(b)) : "undefined" == typeof document ? b : document.querySelectorAll ? document.querySelectorAll(b) : document.getElementById("#" === b.charAt(0) ? b.substr(1) : b); 19365 }, z.version = "0.6.0"; 19366}(_gsScope), function (a) { 19367 "use strict"; 19368 var b = function b() { 19369 return (_gsScope.GreenSockGlobals || _gsScope)[a]; 19370 };"undefined" != typeof module && module.exports ? module.exports = b() : "function" == "function" && __webpack_require__(241) && !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (b), 19371 __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? 19372 (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), 19373 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 19374}("SplitText"); 19375/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(12))) 19376 19377/***/ }), 19378/* 15 */ 19379/***/ (function(module, __webpack_exports__, __webpack_require__) { 19380 19381"use strict"; 19382/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return TimelineLite; }); 19383/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__ = __webpack_require__(3); 19384/*! 19385 * VERSION: 2.0.1 19386 * DATE: 2018-05-30 19387 * UPDATES AND DOCS AT: http://greensock.com 19388 * 19389 * @license Copyright (c) 2008-2018, GreenSock. All rights reserved. 19390 * This work is subject to the terms at http://greensock.com/standard-license or for
19391 * Club GreenSock members, the software agreement that was issued with your membership. 19392 * 19393 * @author: Jack Doyle, [email protected] 19394 */ 19395 19396 19397__WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"]._gsDefine("TimelineLite", ["core.Animation","core.SimpleTimeline","TweenLite"], function() { 19398 19399 var TimelineLite = function(vars) { 19400 __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["SimpleTimeline"].call(this, vars); 19401 this._labels = {}; 19402 this.autoRemoveChildren = (this.vars.autoRemoveChildren === true); 19403 this.smoothChildTiming = (this.vars.smoothChildTiming === true); 19404 this._sortChildren = true; 19405 this._onUpdate = this.vars.onUpdate; 19406 var v = this.vars, 19407 val, p; 19408 for (p in v) { 19409 val = v[p]; 19410 if (_isArray(val)) if (val.join("").indexOf("{self}") !== -1) { 19411 v[p] = this._swapSelfInParams(val); 19412 } 19413 } 19414 if (_isArray(v.tweens)) { 19415 this.add(v.tweens, 0, v.align, v.stagger); 19416 } 19417 }, 19418 _tinyNum = 0.0000000001, 19419 TweenLiteInternals = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"]._internals, 19420 _internals = TimelineLite._internals = {}, 19421 _isSelector = TweenLiteInternals.isSelector, 19422 _isArray = TweenLiteInternals.isArray, 19423 _lazyTweens = TweenLiteInternals.lazyTweens, 19424 _lazyRender = TweenLiteInternals.lazyRender, 19425 _globals = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"]._gsDefine.globals, 19426 _copy = function(vars) { 19427 var copy = {}, p; 19428 for (p in vars) { 19429 copy[p] = vars[p]; 19430 } 19431 return copy; 19432 }, 19433 _applyCycle = function(vars, targets, i) { 19434 var alt = vars.cycle, 19435 p, val; 19436 for (p in alt) { 19437 val = alt[p]; 19438 vars[p] = (typeof(val) === "function") ? val(i, targets[i]) : val[i % val.length]; 19439 } 19440 delete vars.cycle; 19441 }, 19442 _pauseCallback = _internals.pauseCallback = function() {}, 19443 _slice = function(a) { //don't use [].slice because that doesn't work in IE8 with a NodeList that's returned by querySelectorAll() 19444 var b = [], 19445 l = a.length, 19446 i; 19447 for (i = 0; i !== l; b.push(a[i++])); 19448 return b; 19449 }, 19450 p = TimelineLite.prototype = new __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["SimpleTimeline"](); 19451 19452 TimelineLite.version = "2.0.1"; 19453 p.constructor = TimelineLite; 19454 p.kill()._gc = p._forcingPlayhead = p._hasPause = false; 19455 19456 /* might use later... 19457 //translates a local time inside an animation to the corresponding time on the root/global timeline, factoring in all nesting and timeScales. 19458 function localToGlobal(time, animation) { 19459 while (animation) { 19460 time = (time / animation._timeScale) + animation._startTime; 19461 animation = animation.timeline; 19462 } 19463 return time; 19464 } 19465 19466 //translates the supplied time on the root/global timeline into the corresponding local time inside a particular animation, factoring in all nesting and timeScales 19467 function globalToLocal(time, animation) { 19468 var scale = 1; 19469 time -= localToGlobal(0, animation); 19470 while (animation) { 19471 scale *= animation._timeScale; 19472 animation = animation.timeline; 19473 } 19474 return time * scale; 19475 } 19476 */ 19477 19478 p.to = function(target, duration, vars, position) { 19479 var Engine = (vars.repeat && _globals.TweenMax) || __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"]; 19480 return duration ? this.add( new Engine(target, duration, vars), position) : this.set(target, vars, position); 19481 }; 19482 19483 p.from = function(target, duration, vars, position) { 19484 return this.add( ((vars.repeat && _globals.TweenMax) || __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"]).from(target, duration, vars), position); 19485 }; 19486 19487 p.fromTo = function(target, duration, fromVars, toVars, position) { 19488 var Engine = (toVars.repeat && _globals.TweenMax) || __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"]; 19489 return duration ? this.add( Engine.fromTo(target, duration, fromVars, toVars), position) : this.set(target, toVars, position); 19490 }; 19491 19492 p.staggerTo = function(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope) { 19493 var tl = new TimelineLite({onComplete:onCompleteAll, onCompleteParams:onCompleteAllParams, callbackScope:onCompleteAllScope, smoothChildTiming:this.smoothChildTiming}), 19494 cycle = vars.cycle, 19495 copy, i; 19496 if (typeof(targets) === "string") { 19497 targets = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].selector(targets) || targets; 19498 } 19499 targets = targets || []; 19500 if (_isSelector(targets)) { //senses if the targets object is a selector. If it is, we should translate it into an array.
19501 targets = _slice(targets); 19502 } 19503 stagger = stagger || 0; 19504 if (stagger < 0) { 19505 targets = _slice(targets); 19506 targets.reverse(); 19507 stagger *= -1; 19508 } 19509 for (i = 0; i < targets.length; i++) { 19510 copy = _copy(vars); 19511 if (copy.startAt) { 19512 copy.startAt = _copy(copy.startAt); 19513 if (copy.startAt.cycle) { 19514 _applyCycle(copy.startAt, targets, i); 19515 } 19516 } 19517 if (cycle) { 19518 _applyCycle(copy, targets, i); 19519 if (copy.duration != null) { 19520 duration = copy.duration; 19521 delete copy.duration; 19522 } 19523 } 19524 tl.to(targets[i], duration, copy, i * stagger); 19525 } 19526 return this.add(tl, position); 19527 }; 19528 19529 p.staggerFrom = function(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope) { 19530 vars.immediateRender = (vars.immediateRender != false); 19531 vars.runBackwards = true; 19532 return this.staggerTo(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope); 19533 }; 19534 19535 p.staggerFromTo = function(targets, duration, fromVars, toVars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope) { 19536 toVars.startAt = fromVars; 19537 toVars.immediateRender = (toVars.immediateRender != false && fromVars.immediateRender != false); 19538 return this.staggerTo(targets, duration, toVars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope); 19539 }; 19540 19541 p.call = function(callback, params, scope, position) { 19542 return this.add( __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].delayedCall(0, callback, params, scope), position); 19543 }; 19544 19545 p.set = function(target, vars, position) { 19546 position = this._parseTimeOrLabel(position, 0, true); 19547 if (vars.immediateRender == null) { 19548 vars.immediateRender = (position === this._time && !this._paused); 19549 } 19550 return this.add( new __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"](target, 0, vars), position); 19551 }; 19552 19553 TimelineLite.exportRoot = function(vars, ignoreDelayedCalls) { 19554 vars = vars || {}; 19555 if (vars.smoothChildTiming == null) { 19556 vars.smoothChildTiming = true; 19557 } 19558 var tl = new TimelineLite(vars), 19559 root = tl._timeline, 19560 hasNegativeStart, time, tween, next; 19561 if (ignoreDelayedCalls == null) { 19562 ignoreDelayedCalls = true; 19563 } 19564 root._remove(tl, true); 19565 tl._startTime = 0; 19566 tl._rawPrevTime = tl._time = tl._totalTime = root._time; 19567 tween = root._first; 19568 while (tween) { 19569 next = tween._next; 19570 if (!ignoreDelayedCalls || !(tween instanceof __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"] && tween.target === tween.vars.onComplete)) { 19571 time = tween._startTime - tween._delay; 19572 if (time < 0) { 19573 hasNegativeStart = 1; 19574 } 19575 tl.add(tween, time); 19576 } 19577 tween = next; 19578 } 19579 root.add(tl, 0); 19580 if (hasNegativeStart) { //calling totalDuration() will force the adjustment necessary to shift the children forward so none of them start before zero, and moves the timeline backwards the same amount, so the playhead is still aligned where it should be globally, but the timeline doesn't have illegal children that start before zero. 19581 tl.totalDuration(); 19582 } 19583 return tl; 19584 }; 19585 19586 p.add = function(value, position, align, stagger) { 19587 var curTime, l, i, child, tl, beforeRawTime; 19588 if (typeof(position) !== "number") { 19589 position = this._parseTimeOrLabel(position, 0, true, value); 19590 } 19591 if (!(value instanceof __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Animation"])) { 19592 if ((value instanceof Array) || (value && value.push && _isArray(value))) { 19593 align = align || "normal"; 19594 stagger = stagger || 0; 19595 curTime = position; 19596 l = value.length; 19597 for (i = 0; i < l; i++) { 19598 if (_isArray(child = value[i])) { 19599 child = new TimelineLite({tweens:child}); 19600 } 19601 this.add(child, curTime); 19602 if (typeof(child) !== "string" && typeof(child) !== "function") { 19603 if (align === "sequence") { 19604 curTime = child._startTime + (child.totalDuration() / child._timeScale); 19605 } else if (align === "start") { 19606 child._startTime -= child.delay(); 19607 } 19608 } 19609 curTime += stagger; 19610 } 19611 return this._uncache(true); 19612 } else if (typeof(value) === "string") { 19613 return this.addLabel(value, position); 19614 } else if (typeof(value) === "function") { 19615 value = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].delayedCall(0, value); 19616 } else { 19617 throw("Cannot add " + value + " into the timeline; it is not a tween, timeline, function, or string."); 19618 } 19619 } 19620 19621 __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["SimpleTimeline"].prototype.add.call(this, value, position); 19622 19623 if (value._time) { //in case, for example, the _startTime is moved on a tween that has already rendered. Imagine it's at its end state, then the startTime is moved WAY later (after the end of this timeline), it should render at its beginning. 19624 value.render((this.rawTime() - value._startTime) * value._timeScale, false, false); 19625 } 19626 19627 //if the timeline has already ended but the inserted tween/timeline extends the duration, we should enable this timeline again so that it renders properly. We should also align the playhead with the parent timeline's when appropriate. 19628 if (this._gc || this._time === this._duration) if (!this._paused) if (this._duration < this.duration()) { 19629 //in case any of the ancestors had completed but should now be enabled... 19630 tl = this; 19631 beforeRawTime = (tl.rawTime() > value._startTime); //if the tween is placed on the timeline so that it starts BEFORE the current rawTime, we should align the playhead (move the timeline). This is because sometimes users will create a timeline, let it finish, and much later append a tween and expect it to run instead of jumping to its end state. While technically one could argue that it should jump to its end state, that's not what users intuitively expect. 19632 while (tl._timeline) { 19633 if (beforeRawTime && tl._timeline.smoothChildTiming) { 19634 tl.totalTime(tl._totalTime, true); //moves the timeline (shifts its startTime) if necessary, and also enables it. 19635 } else if (tl._gc) { 19636 tl._enabled(true, false); 19637 } 19638 tl = tl._timeline; 19639 } 19640 } 19641 19642 return this; 19643 }; 19644 19645 p.remove = function(value) { 19646 if (value instanceof __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Animation"]) { 19647 this._remove(value, false); 19648 var tl = value._timeline = value.vars.useFrames ? __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Animation"]._rootFramesTimeline : __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Animation"]._rootTimeline; //now that it's removed, default it to the root timeline so that if it gets played again, it doesn't jump back into this timeline. 19649 value._startTime = (value._paused ? value._pauseTime : tl._time) - ((!value._reversed ? value._totalTime : value.totalDuration() - value._totalTime) / value._timeScale); //ensure that if it gets played again, the timing is correct. 19650 return this; 19651 } else if (value instanceof Array || (value && value.push && _isArray(value))) { 19652 var i = value.length; 19653 while (--i > -1) { 19654 this.remove(value[i]); 19655 } 19656 return this; 19657 } else if (typeof(value) === "string") { 19658 return this.removeLabel(value); 19659 } 19660 return this.kill(null, value); 19661 }; 19662 19663 p._remove = function(tween, skipDisable) { 19664 __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["SimpleTimeline"].prototype._remove.call(this, tween, skipDisable); 19665 var last = this._last; 19666 if (!last) { 19667 this._time = this._totalTime = this._duration = this._totalDuration = 0; 19668 } else if (this._time > this.duration()) { 19669 this._time = this._duration; 19670 this._totalTime = this._totalDuration; 19671 } 19672 return this; 19673 }; 19674 19675 p.append = function(value, offsetOrLabel) { 19676 return this.add(value, this._parseTimeOrLabel(null, offsetOrLabel, true, value)); 19677 }; 19678 19679 p.insert = p.insertMultiple = function(value, position, align, stagger) { 19680 return this.add(value, position || 0, align, stagger); 19681 }; 19682 19683 p.appendMultiple = function(tweens, offsetOrLabel, align, stagger) { 19684 return this.add(tweens, this._parseTimeOrLabel(null, offsetOrLabel, true, tweens), align, stagger); 19685 }; 19686 19687 p.addLabel = function(label, position) { 19688 this._labels[label] = this._parseTimeOrLabel(position); 19689 return this; 19690 }; 19691 19692 p.addPause = function(position, callback, params, scope) { 19693 var t = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].delayedCall(0, _pauseCallback, params, scope || this); 19694 t.vars.onComplete = t.vars.onReverseComplete = callback;
19695 t.data = "isPause"; 19696 this._hasPause = true; 19697 return this.add(t, position); 19698 }; 19699 19700 p.removeLabel = function(label) { 19701 delete this._labels[label]; 19702 return this; 19703 }; 19704 19705 p.getLabelTime = function(label) { 19706 return (this._labels[label] != null) ? this._labels[label] : -1; 19707 }; 19708 19709 p._parseTimeOrLabel = function(timeOrLabel, offsetOrLabel, appendIfAbsent, ignore) { 19710 var clippedDuration, i; 19711 //if we're about to add a tween/timeline (or an array of them) that's already a child of this timeline, we should remove it first so that it doesn't contaminate the duration(). 19712 if (ignore instanceof __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Animation"] && ignore.timeline === this) { 19713 this.remove(ignore); 19714 } else if (ignore && ((ignore instanceof Array) || (ignore.push && _isArray(ignore)))) { 19715 i = ignore.length; 19716 while (--i > -1) { 19717 if (ignore[i] instanceof __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Animation"] && ignore[i].timeline === this) { 19718 this.remove(ignore[i]); 19719 } 19720 } 19721 } 19722 clippedDuration = (typeof(timeOrLabel) === "number" && !offsetOrLabel) ? 0 : (this.duration() > 99999999999) ? this.recent().endTime(false) : this._duration; //in case there's a child that infinitely repeats, users almost never intend for the insertion point of a new child to be based on a SUPER long value like that so we clip it and assume the most recently-added child's endTime should be used instead. 19723 if (typeof(offsetOrLabel) === "string") { 19724 return this._parseTimeOrLabel(offsetOrLabel, (appendIfAbsent && typeof(timeOrLabel) === "number" && this._labels[offsetOrLabel] == null) ? timeOrLabel - clippedDuration : 0, appendIfAbsent); 19725 } 19726 offsetOrLabel = offsetOrLabel || 0; 19727 if (typeof(timeOrLabel) === "string" && (isNaN(timeOrLabel) || this._labels[timeOrLabel] != null)) { //if the string is a number like "1", check to see if there's a label with that name, otherwise interpret it as a number (absolute value). 19728 i = timeOrLabel.indexOf("="); 19729 if (i === -1) { 19730 if (this._labels[timeOrLabel] == null) { 19731 return appendIfAbsent ? (this._labels[timeOrLabel] = clippedDuration + offsetOrLabel) : offsetOrLabel; 19732 } 19733 return this._labels[timeOrLabel] + offsetOrLabel; 19734 } 19735 offsetOrLabel = parseInt(timeOrLabel.charAt(i-1) + "1", 10) * Number(timeOrLabel.substr(i+1)); 19736 timeOrLabel = (i > 1) ? this._parseTimeOrLabel(timeOrLabel.substr(0, i-1), 0, appendIfAbsent) : clippedDuration; 19737 } else if (timeOrLabel == null) { 19738 timeOrLabel = clippedDuration; 19739 } 19740 return Number(timeOrLabel) + offsetOrLabel; 19741 }; 19742 19743 p.seek = function(position, suppressEvents) { 19744 return this.totalTime((typeof(position) === "number") ? position : this._parseTimeOrLabel(position), (suppressEvents !== false)); 19745 }; 19746 19747 p.stop = function() { 19748 return this.paused(true); 19749 }; 19750 19751 p.gotoAndPlay = function(position, suppressEvents) { 19752 return this.play(position, suppressEvents); 19753 }; 19754 19755 p.gotoAndStop = function(position, suppressEvents) { 19756 return this.pause(position, suppressEvents); 19757 }; 19758 19759 p.render = function(time, suppressEvents, force) { 19760 if (this._gc) { 19761 this._enabled(true, false); 19762 } 19763 var prevTime = this._time, 19764 totalDur = (!this._dirty) ? this._totalDuration : this.totalDuration(), 19765 prevStart = this._startTime, 19766 prevTimeScale = this._timeScale, 19767 prevPaused = this._paused, 19768 tween, isComplete, next, callback, internalForce, pauseTween, curTime; 19769 if (prevTime !== this._time) { //if totalDuration() finds a child with a negative startTime and smoothChildTiming is true, things get shifted around internally so we need to adjust the time accordingly. For example, if a tween starts at -30 we must shift EVERYTHING forward 30 seconds and move this timeline's startTime backward by 30 seconds so that things align with the playhead (no jump). 19770 time += this._time - prevTime; 19771 } 19772 if (time >= totalDur - 0.0000001 && time >= 0) { //to work around occasional floating point math artifacts. 19773 this._totalTime = this._time = totalDur; 19774 if (!this._reversed) if (!this._hasPausedChild()) { 19775 isComplete = true; 19776 callback = "onComplete"; 19777 internalForce = !!this._timeline.autoRemoveChildren; //otherwise, if the animation is unpaused/activated after it's already finished, it doesn't get removed from the parent timeline. 19778 if (this._duration === 0) if ((time <= 0 && time >= -0.0000001) || this._rawPrevTime < 0 || this._rawPrevTime === _tinyNum) if (this._rawPrevTime !== time && this._first) { 19779 internalForce = true; 19780 if (this._rawPrevTime > _tinyNum) { 19781 callback = "onReverseComplete"; 19782 } 19783 } 19784 } 19785 this._rawPrevTime = (this._duration || !suppressEvents || time || this._rawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration timeline or tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. 19786 time = totalDur + 0.0001; //to avoid occasional floating point rounding errors - sometimes child tweens/timelines were not being fully completed (their progress might be 0.999999999999998 instead of 1 because when _time - tween._startTime is performed, floating point errors would return a value that was SLIGHTLY off). Try (999999999999.7 - 999999999999) * 1 = 0.699951171875 instead of 0.7. 19787 19788 } else if (time < 0.0000001) { //to work around occasional floating point math artifacts, round super small values to 0. 19789 this._totalTime = this._time = 0; 19790 if (prevTime !== 0 || (this._duration === 0 && this._rawPrevTime !== _tinyNum && (this._rawPrevTime > 0 || (time < 0 && this._rawPrevTime >= 0)))) { 19791 callback = "onReverseComplete"; 19792 isComplete = this._reversed; 19793 } 19794 if (time < 0) { 19795 this._active = false;
19796 if (this._timeline.autoRemoveChildren && this._reversed) { //ensures proper GC if a timeline is resumed after it's finished reversing. 19797 internalForce = isComplete = true; 19798 callback = "onReverseComplete"; 19799 } else if (this._rawPrevTime >= 0 && this._first) { //when going back beyond the start, force a render so that zero-duration tweens that sit at the very beginning render their start values properly. Otherwise, if the parent timeline's playhead lands exactly at this timeline's startTime, and then moves backwards, the zero-duration tweens at the beginning would still be at their end state. 19800 internalForce = true; 19801 } 19802 this._rawPrevTime = time; 19803 } else { 19804 this._rawPrevTime = (this._duration || !suppressEvents || time || this._rawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration timeline or tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. 19805 if (time === 0 && isComplete) { //if there's a zero-duration tween at the very beginning of a timeline and the playhead lands EXACTLY at time 0, that tween will correctly render its end values, but we need to keep the timeline alive for one more render so that the beginning values render properly as the parent's playhead keeps moving beyond the begining. Imagine obj.x starts at 0 and then we do tl.set(obj, {x:100}).to(obj, 1, {x:200}) and then later we tl.reverse()...the goal is to have obj.x revert to 0. If the playhead happens to land on exactly 0, without this chunk of code, it'd complete the timeline and remove it from the rendering queue (not good). 19806 tween = this._first; 19807 while (tween && tween._startTime === 0) { 19808 if (!tween._duration) { 19809 isComplete = false; 19810 } 19811 tween = tween._next; 19812 } 19813 } 19814 time = 0; //to avoid occasional floating point rounding errors (could cause problems especially with zero-duration tweens at the very beginning of the timeline) 19815 if (!this._initted) { 19816 internalForce = true; 19817 } 19818 } 19819 19820 } else { 19821 19822 if (this._hasPause && !this._forcingPlayhead && !suppressEvents) { 19823 if (time >= prevTime) { 19824 tween = this._first; 19825 while (tween && tween._startTime <= time && !pauseTween) { 19826 if (!tween._duration) if (tween.data === "isPause" && !tween.ratio && !(tween._startTime === 0 && this._rawPrevTime === 0)) { 19827 pauseTween = tween; 19828 } 19829 tween = tween._next; 19830 } 19831 } else { 19832 tween = this._last; 19833 while (tween && tween._startTime >= time && !pauseTween) { 19834 if (!tween._duration) if (tween.data === "isPause" && tween._rawPrevTime > 0) { 19835 pauseTween = tween; 19836 } 19837 tween = tween._prev; 19838 } 19839 } 19840 if (pauseTween) { 19841 this._time = time = pauseTween._startTime; 19842 this._totalTime = time + (this._cycle * (this._totalDuration + this._repeatDelay)); 19843 } 19844 } 19845 19846 this._totalTime = this._time = this._rawPrevTime = time; 19847 } 19848 if ((this._time === prevTime || !this._first) && !force && !internalForce && !pauseTween) { 19849 return; 19850 } else if (!this._initted) { 19851 this._initted = true; 19852 } 19853 19854 if (!this._active) if (!this._paused && this._time !== prevTime && time > 0) { 19855 this._active = true; //so that if the user renders the timeline (as opposed to the parent timeline rendering it), it is forced to re-render and align it with the proper time/frame on the next rendering cycle. Maybe the timeline already finished but the user manually re-renders it as halfway done, for example. 19856 } 19857 19858 if (prevTime === 0) if (this.vars.onStart) if (this._time !== 0 || !this._duration) if (!suppressEvents) { 19859 this._callback("onStart"); 19860 } 19861 19862 curTime = this._time; 19863 if (curTime >= prevTime) { 19864 tween = this._first; 19865 while (tween) { 19866 next = tween._next; //record it here because the value could change after rendering... 19867 if (curTime !== this._time || (this._paused && !prevPaused)) { //in case a tween pauses or seeks the timeline when rendering, like inside of an onUpdate/onComplete 19868 break; 19869 } else if (tween._active || (tween._startTime <= curTime && !tween._paused && !tween._gc)) { 19870 if (pauseTween === tween) { 19871 this.pause(); 19872 } 19873 if (!tween._reversed) { 19874 tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force); 19875 } else { 19876 tween.render(((!tween._dirty) ? tween._totalDuration : tween.totalDuration()) - ((time - tween._startTime) * tween._timeScale), suppressEvents, force); 19877 } 19878 } 19879 tween = next; 19880 } 19881 } else { 19882 tween = this._last; 19883 while (tween) { 19884 next = tween._prev; //record it here because the value could change after rendering... 19885 if (curTime !== this._time || (this._paused && !prevPaused)) { //in case a tween pauses or seeks the timeline when rendering, like inside of an onUpdate/onComplete 19886 break; 19887 } else if (tween._active || (tween._startTime <= prevTime && !tween._paused && !tween._gc)) { 19888 if (pauseTween === tween) { 19889 pauseTween = tween._prev; //the linked list is organized by _startTime, thus it's possible that a tween could start BEFORE the pause and end after it, in which case it would be positioned before the pause tween in the linked list, but we should render it before we pause() the timeline and cease rendering. This is only a concern when going in reverse. 19890 while (pauseTween && pauseTween.endTime() > this._time) { 19891 pauseTween.render( (pauseTween._reversed ? pauseTween.totalDuration() - ((time - pauseTween._startTime) * pauseTween._timeScale) : (time - pauseTween._startTime) * pauseTween._timeScale), suppressEvents, force); 19892 pauseTween = pauseTween._prev; 19893 } 19894 pauseTween = null; 19895 this.pause(); 19896 } 19897 if (!tween._reversed) { 19898 tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force); 19899 } else { 19900 tween.render(((!tween._dirty) ? tween._totalDuration : tween.totalDuration()) - ((time - tween._startTime) * tween._timeScale), suppressEvents, force); 19901 } 19902 } 19903 tween = next; 19904 } 19905 } 19906 19907 if (this._onUpdate) if (!suppressEvents) { 19908 if (_lazyTweens.length) { //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onUpdate on a timeline that reports/checks tweened values. 19909 _lazyRender(); 19910 }
19911 this._callback("onUpdate"); 19912 } 19913 19914 if (callback) if (!this._gc) if (prevStart === this._startTime || prevTimeScale !== this._timeScale) if (this._time === 0 || totalDur >= this.totalDuration()) { //if one of the tweens that was rendered altered this timeline's startTime (like if an onComplete reversed the timeline), it probably isn't complete. If it is, don't worry, because whatever call altered the startTime would complete if it was necessary at the new time. The only exception is the timeScale property. Also check _gc because there's a chance that kill() could be called in an onUpdate 19915 if (isComplete) { 19916 if (_lazyTweens.length) { //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onComplete on a timeline that reports/checks tweened values. 19917 _lazyRender(); 19918 } 19919 if (this._timeline.autoRemoveChildren) { 19920 this._enabled(false, false); 19921 } 19922 this._active = false; 19923 } 19924 if (!suppressEvents && this.vars[callback]) { 19925 this._callback(callback); 19926 } 19927 } 19928 }; 19929 19930 p._hasPausedChild = function() { 19931 var tween = this._first; 19932 while (tween) { 19933 if (tween._paused || ((tween instanceof TimelineLite) && tween._hasPausedChild())) { 19934 return true; 19935 } 19936 tween = tween._next; 19937 } 19938 return false; 19939 }; 19940 19941 p.getChildren = function(nested, tweens, timelines, ignoreBeforeTime) { 19942 ignoreBeforeTime = ignoreBeforeTime || -9999999999; 19943 var a = [], 19944 tween = this._first, 19945 cnt = 0; 19946 while (tween) { 19947 if (tween._startTime < ignoreBeforeTime) { 19948 //do nothing 19949 } else if (tween instanceof __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"]) { 19950 if (tweens !== false) { 19951 a[cnt++] = tween; 19952 } 19953 } else { 19954 if (timelines !== false) { 19955 a[cnt++] = tween; 19956 } 19957 if (nested !== false) { 19958 a = a.concat(tween.getChildren(true, tweens, timelines)); 19959 cnt = a.length; 19960 } 19961 } 19962 tween = tween._next; 19963 } 19964 return a; 19965 }; 19966 19967 p.getTweensOf = function(target, nested) { 19968 var disabled = this._gc, 19969 a = [], 19970 cnt = 0, 19971 tweens, i; 19972 if (disabled) { 19973 this._enabled(true, true); //getTweensOf() filters out disabled tweens, and we have to mark them as _gc = true when the timeline completes in order to allow clean garbage collection, so temporarily re-enable the timeline here. 19974 } 19975 tweens = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].getTweensOf(target); 19976 i = tweens.length; 19977 while (--i > -1) { 19978 if (tweens[i].timeline === this || (nested && this._contains(tweens[i]))) { 19979 a[cnt++] = tweens[i]; 19980 } 19981 } 19982 if (disabled) { 19983 this._enabled(false, true); 19984 } 19985 return a; 19986 }; 19987 19988 p.recent = function() { 19989 return this._recent; 19990 }; 19991 19992 p._contains = function(tween) { 19993 var tl = tween.timeline; 19994 while (tl) { 19995 if (tl === this) { 19996 return true; 19997 } 19998 tl = tl.timeline; 19999 } 20000 return false; 20001 }; 20002 20003 p.shiftChildren = function(amount, adjustLabels, ignoreBeforeTime) { 20004 ignoreBeforeTime = ignoreBeforeTime || 0; 20005 var tween = this._first, 20006 labels = this._labels, 20007 p; 20008 while (tween) { 20009 if (tween._startTime >= ignoreBeforeTime) { 20010 tween._startTime += amount; 20011 } 20012 tween = tween._next; 20013 }
20014 if (adjustLabels) { 20015 for (p in labels) { 20016 if (labels[p] >= ignoreBeforeTime) { 20017 labels[p] += amount; 20018 } 20019 } 20020 } 20021 return this._uncache(true); 20022 }; 20023 20024 p._kill = function(vars, target) { 20025 if (!vars && !target) { 20026 return this._enabled(false, false); 20027 } 20028 var tweens = (!target) ? this.getChildren(true, true, false) : this.getTweensOf(target), 20029 i = tweens.length, 20030 changed = false; 20031 while (--i > -1) { 20032 if (tweens[i]._kill(vars, target)) { 20033 changed = true; 20034 } 20035 } 20036 return changed; 20037 }; 20038 20039 p.clear = function(labels) { 20040 var tweens = this.getChildren(false, true, true), 20041 i = tweens.length; 20042 this._time = this._totalTime = 0; 20043 while (--i > -1) { 20044 tweens[i]._enabled(false, false); 20045 } 20046 if (labels !== false) { 20047 this._labels = {}; 20048 } 20049 return this._uncache(true); 20050 }; 20051 20052 p.invalidate = function() { 20053 var tween = this._first; 20054 while (tween) { 20055 tween.invalidate(); 20056 tween = tween._next; 20057 } 20058 return __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Animation"].prototype.invalidate.call(this);; 20059 }; 20060 20061 p._enabled = function(enabled, ignoreTimeline) { 20062 if (enabled === this._gc) { 20063 var tween = this._first; 20064 while (tween) { 20065 tween._enabled(enabled, true); 20066 tween = tween._next; 20067 } 20068 } 20069 return __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["SimpleTimeline"].prototype._enabled.call(this, enabled, ignoreTimeline); 20070 }; 20071 20072 p.totalTime = function(time, suppressEvents, uncapped) { 20073 this._forcingPlayhead = true; 20074 var val = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Animation"].prototype.totalTime.apply(this, arguments); 20075 this._forcingPlayhead = false; 20076 return val; 20077 }; 20078 20079 p.duration = function(value) { 20080 if (!arguments.length) { 20081 if (this._dirty) { 20082 this.totalDuration(); //just triggers recalculation 20083 } 20084 return this._duration; 20085 } 20086 if (this.duration() !== 0 && value !== 0) { 20087 this.timeScale(this._duration / value); 20088 } 20089 return this; 20090 }; 20091 20092 p.totalDuration = function(value) { 20093 if (!arguments.length) { 20094 if (this._dirty) { 20095 var max = 0, 20096 tween = this._last, 20097 prevStart = 999999999999, 20098 prev, end; 20099 while (tween) { 20100 prev = tween._prev; //record it here in case the tween changes position in the sequence... 20101 if (tween._dirty) { 20102 tween.totalDuration(); //could change the tween._startTime, so make sure the tween's cache is clean before analyzing it. 20103 } 20104 if (tween._startTime > prevStart && this._sortChildren && !tween._paused && !this._calculatingDuration) { //in case one of the tweens shifted out of order, it needs to be re-inserted into the correct position in the sequence 20105 this._calculatingDuration = 1; //prevent endless recursive calls - there are methods that get triggered that check duration/totalDuration when we add(), like _parseTimeOrLabel(). 20106 this.add(tween, tween._startTime - tween._delay); 20107 this._calculatingDuration = 0; 20108 } else { 20109 prevStart = tween._startTime; 20110 } 20111 if (tween._startTime < 0 && !tween._paused) { //children aren't allowed to have negative startTimes unless smoothChildTiming is true, so adjust here if one is found. 20112 max -= tween._startTime; 20113 if (this._timeline.smoothChildTiming) { 20114 this._startTime += tween._startTime / this._timeScale; 20115 this._time -= tween._startTime; 20116 this._totalTime -= tween._startTime; 20117 this._rawPrevTime -= tween._startTime; 20118 } 20119 this.shiftChildren(-tween._startTime, false, -9999999999); 20120 prevStart = 0; 20121 } 20122 end = tween._startTime + (tween._totalDuration / tween._timeScale); 20123 if (end > max) { 20124 max = end; 20125 } 20126 tween = prev; 20127 } 20128 this._duration = this._totalDuration = max; 20129 this._dirty = false; 20130 } 20131 return this._totalDuration; 20132 } 20133 return (value && this.totalDuration()) ? this.timeScale(this._totalDuration / value) : this; 20134 }; 20135 20136 p.paused = function(value) { 20137 if (!value) { //if there's a pause directly at the spot from where we're unpausing, skip it. 20138 var tween = this._first, 20139 time = this._time; 20140 while (tween) { 20141 if (tween._startTime === time && tween.data === "isPause") { 20142 tween._rawPrevTime = 0; //remember, _rawPrevTime is how zero-duration tweens/callbacks sense directionality and determine whether or not to fire. If _rawPrevTime is the same as _startTime on the next render, it won't fire. 20143 } 20144 tween = tween._next; 20145 } 20146 } 20147 return __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Animation"].prototype.paused.apply(this, arguments); 20148 }; 20149 20150 p.usesFrames = function() { 20151 var tl = this._timeline; 20152 while (tl._timeline) { 20153 tl = tl._timeline; 20154 } 20155 return (tl === __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Animation"]._rootFramesTimeline); 20156 }; 20157 20158 p.rawTime = function(wrapRepeats) { 20159 return (wrapRepeats && (this._paused || (this._repeat && this.time() > 0 && this.totalProgress() < 1))) ? this._totalTime % (this._duration + this._repeatDelay) : this._paused ? this._totalTime : (this._timeline.rawTime(wrapRepeats) - this._startTime) * this._timeScale; 20160 }; 20161 20162 return TimelineLite; 20163 20164 }, true); 20165 20166const TimelineLite = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].TimelineLite; 20167/* unused harmony export TimelineLite */ 20168 20169 20170 20171 20172/***/ }), 20173/* 16 */ 20174/***/ (function(module, exports, __webpack_require__) { 20175 20176var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_LOCAL_MODULE_0__;var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*** IMPORTS FROM imports-loader ***/ 20177(function() { 20178var fix = module.exports=0; 20179
vendor: 16,337 bytes, lines 20180-20645
20180// Snap.svg 0.5.0 20181// 20182// Copyright (c) 2013 â 2017 Adobe Systems Incorporated. All rights reserved. 20183// 20184// Licensed under the Apache License, Version 2.0 (the "License"); 20185// you may not use this file except in compliance with the License. 20186// You may obtain a copy of the License at 20187// 20188// http://www.apache.org/licenses/LICENSE-2.0 20189// 20190// Unless required by applicable law or agreed to in writing, software 20191// distributed under the License is distributed on an "AS IS" BASIS, 20192// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 20193// See the License for the specific language governing permissions and 20194// limitations under the License. 20195// 20196// build: 2017-02-06 20197 20198// Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved. 20199// 20200// Licensed under the Apache License, Version 2.0 (the "License"); 20201// you may not use this file except in compliance with the License. 20202// You may obtain a copy of the License at 20203// 20204// http://www.apache.org/licenses/LICENSE-2.0 20205// 20206// Unless required by applicable law or agreed to in writing, software 20207// distributed under the License is distributed on an "AS IS" BASIS, 20208// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 20209// See the License for the specific language governing permissions and 20210// limitations under the License. 20211// ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ \\ 20212// â Eve 0.5.0 - JavaScript Events Library â \\ 20213// âââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ⤠\\ 20214// â Author Dmitry Baranovskiy (http://dmitry.baranovskiy.com/) â \\ 20215// ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ \\ 20216 20217(function (glob) { 20218 var version = "0.5.0", 20219 has = "hasOwnProperty", 20220 separator = /[\.\/]/, 20221 comaseparator = /\s*,\s*/, 20222 wildcard = "*", 20223 fun = function () {}, 20224 numsort = function (a, b) { 20225 return a - b; 20226 }, 20227 current_event, 20228 stop, 20229 events = {n: {}}, 20230 firstDefined = function () { 20231 for (var i = 0, ii = this.length; i < ii; i++) { 20232 if (typeof this[i] != "undefined") { 20233 return this[i]; 20234 } 20235 } 20236 }, 20237 lastDefined = function () { 20238 var i = this.length; 20239 while (--i) { 20240 if (typeof this[i] != "undefined") { 20241 return this[i]; 20242 } 20243 } 20244 }, 20245 objtos = Object.prototype.toString, 20246 Str = String, 20247 isArray = Array.isArray || function (ar) { 20248 return ar instanceof Array || objtos.call(ar) == "[object Array]"; 20249 }; 20250 /*\ 20251 * eve 20252 [ method ] 20253 20254 * Fires event with given `name`, given scope and other parameters. 20255 20256 > Arguments 20257 20258 - name (string) name of the *event*, dot (`.`) or slash (`/`) separated 20259 - scope (object) context for the event handlers 20260 - varargs (...) the rest of arguments will be sent to event handlers 20261 20262 = (object) array of returned values from the listeners. Array has two methods `.firstDefined()` and `.lastDefined()` to get first or last not `undefined` value. 20263 \*/ 20264 eve = function (name, scope) { 20265 var e = events, 20266 oldstop = stop, 20267 args = Array.prototype.slice.call(arguments, 2), 20268 listeners = eve.listeners(name), 20269 z = 0, 20270 f = false, 20271 l, 20272 indexed = [], 20273 queue = {}, 20274 out = [], 20275 ce = current_event, 20276 errors = []; 20277 out.firstDefined = firstDefined; 20278 out.lastDefined = lastDefined; 20279 current_event = name; 20280 stop = 0; 20281 for (var i = 0, ii = listeners.length; i < ii; i++) if ("zIndex" in listeners[i]) { 20282 indexed.push(listeners[i].zIndex); 20283 if (listeners[i].zIndex < 0) { 20284 queue[listeners[i].zIndex] = listeners[i]; 20285 } 20286 } 20287 indexed.sort(numsort); 20288 while (indexed[z] < 0) { 20289 l = queue[indexed[z++]]; 20290 out.push(l.apply(scope, args)); 20291 if (stop) { 20292 stop = oldstop; 20293 return out; 20294 } 20295 } 20296 for (i = 0; i < ii; i++) { 20297 l = listeners[i]; 20298 if ("zIndex" in l) { 20299 if (l.zIndex == indexed[z]) { 20300 out.push(l.apply(scope, args)); 20301 if (stop) { 20302 break; 20303 } 20304 do { 20305 z++; 20306 l = queue[indexed[z]]; 20307 l && out.push(l.apply(scope, args)); 20308 if (stop) { 20309 break; 20310 } 20311 } while (l) 20312 } else { 20313 queue[l.zIndex] = l; 20314 } 20315 } else { 20316 out.push(l.apply(scope, args)); 20317 if (stop) { 20318 break; 20319 } 20320 } 20321 } 20322 stop = oldstop; 20323 current_event = ce; 20324 return out; 20325 }; 20326 // Undocumented. Debug only. 20327 eve._events = events; 20328 /*\ 20329 * eve.listeners 20330 [ method ] 20331 20332 * Internal method which gives you array of all event handlers that will be triggered by the given `name`. 20333 20334 > Arguments 20335 20336 - name (string) name of the event, dot (`.`) or slash (`/`) separated 20337 20338 = (array) array of event handlers 20339 \*/ 20340 eve.listeners = function (name) { 20341 var names = isArray(name) ? name : name.split(separator), 20342 e = events, 20343 item, 20344 items, 20345 k, 20346 i, 20347 ii, 20348 j, 20349 jj, 20350 nes, 20351 es = [e], 20352 out = []; 20353 for (i = 0, ii = names.length; i < ii; i++) { 20354 nes = []; 20355 for (j = 0, jj = es.length; j < jj; j++) { 20356 e = es[j].n; 20357 items = [e[names[i]], e[wildcard]]; 20358 k = 2; 20359 while (k--) { 20360 item = items[k]; 20361 if (item) { 20362 nes.push(item); 20363 out = out.concat(item.f || []); 20364 } 20365 } 20366 } 20367 es = nes; 20368 } 20369 return out; 20370 }; 20371 /*\ 20372 * eve.separator 20373 [ method ] 20374 20375 * If for some reasons you donât like default separators (`.` or `/`) you can specify yours 20376 * here. Be aware that if you pass a string longer than one character it will be treated as 20377 * a list of characters. 20378 20379 - separator (string) new separator. Empty string resets to default: `.` or `/`. 20380 \*/ 20381 eve.separator = function (sep) { 20382 if (sep) { 20383 sep = Str(sep).replace(/(?=[\.\^\]\[\-])/g, "\\"); 20384 sep = "[" + sep + "]"; 20385 separator = new RegExp(sep); 20386 } else { 20387 separator = /[\.\/]/; 20388 } 20389 }; 20390 /*\ 20391 * eve.on 20392 [ method ] 20393 ** 20394 * Binds given event handler with a given name. You can use wildcards â`*`â for the names: 20395 | eve.on("*.under.*", f); 20396 | eve("mouse.under.floor"); // triggers f 20397 * Use @eve to trigger the listener. 20398 ** 20399 - name (string) name of the event, dot (`.`) or slash (`/`) separated, with optional wildcards 20400 - f (function) event handler function 20401 ** 20402 - name (array) if you donât want to use separators, you can use array of strings 20403 - f (function) event handler function 20404 ** 20405 = (function) returned function accepts a single numeric parameter that represents z-index of the handler. It is an optional feature and only used when you need to ensure that some subset of handlers will be invoked in a given order, despite of the order of assignment. 20406 > Example: 20407 | eve.on("mouse", eatIt)(2); 20408 | eve.on("mouse", scream); 20409 | eve.on("mouse", catchIt)(1); 20410 * This will ensure that `catchIt` function will be called before `eatIt`. 20411 * 20412 * If you want to put your handler before non-indexed handlers, specify a negative value. 20413 * Note: I assume most of the time you donât need to worry about z-index, but itâs nice to have this feature âjust in caseâ. 20414 \*/ 20415 eve.on = function (name, f) { 20416 if (typeof f != "function") { 20417 return function () {}; 20418 } 20419 var names = isArray(name) ? (isArray(name[0]) ? name : [name]) : Str(name).split(comaseparator); 20420 for (var i = 0, ii = names.length; i < ii; i++) { 20421 (function (name) { 20422 var names = isArray(name) ? name : Str(name).split(separator), 20423 e = events, 20424 exist; 20425 for (var i = 0, ii = names.length; i < ii; i++) { 20426 e = e.n; 20427 e = e.hasOwnProperty(names[i]) && e[names[i]] || (e[names[i]] = {n: {}}); 20428 } 20429 e.f = e.f || []; 20430 for (i = 0, ii = e.f.length; i < ii; i++) if (e.f[i] == f) { 20431 exist = true; 20432 break; 20433 } 20434 !exist && e.f.push(f); 20435 }(names[i])); 20436 } 20437 return function (zIndex) { 20438 if (+zIndex == +zIndex) { 20439 f.zIndex = +zIndex; 20440 } 20441 }; 20442 }; 20443 /*\ 20444 * eve.f 20445 [ method ] 20446 ** 20447 * Returns function that will fire given event with optional arguments. 20448 * Arguments that will be passed to the result function will be also 20449 * concated to the list of final arguments. 20450 | el.onclick = eve.f("click", 1, 2); 20451 | eve.on("click", function (a, b, c) { 20452 | console.log(a, b, c); // 1, 2, [event object] 20453 | }); 20454 > Arguments 20455 - event (string) event name 20456 - varargs (â¦) and any other arguments 20457 = (function) possible event handler function 20458 \*/ 20459 eve.f = function (event) { 20460 var attrs = [].slice.call(arguments, 1); 20461 return function () { 20462 eve.apply(null, [event, null].concat(attrs).concat([].slice.call(arguments, 0))); 20463 }; 20464 }; 20465 /*\ 20466 * eve.stop 20467 [ method ] 20468 ** 20469 * Is used inside an event handler to stop the event, preventing any subsequent listeners from firing. 20470 \*/ 20471 eve.stop = function () { 20472 stop = 1; 20473 }; 20474 /*\ 20475 * eve.nt 20476 [ method ] 20477 ** 20478 * Could be used inside event handler to figure out actual name of the event. 20479 ** 20480 > Arguments 20481 ** 20482 - subname (string) #optional subname of the event 20483 ** 20484 = (string) name of the event, if `subname` is not specified 20485 * or 20486 = (boolean) `true`, if current eventâs name contains `subname` 20487 \*/ 20488 eve.nt = function (subname) { 20489 var cur = isArray(current_event) ? current_event.join(".") : current_event; 20490 if (subname) { 20491 return new RegExp("(?:\\.|\\/|^)" + subname + "(?:\\.|\\/|$)").test(cur); 20492 } 20493 return cur; 20494 }; 20495 /*\ 20496 * eve.nts 20497 [ method ] 20498 ** 20499 * Could be used inside event handler to figure out actual name of the event. 20500 ** 20501 ** 20502 = (array) names of the event 20503 \*/ 20504 eve.nts = function () { 20505 return isArray(current_event) ? current_event : current_event.split(separator); 20506 }; 20507 /*\ 20508 * eve.off 20509 [ method ] 20510 ** 20511 * Removes given function from the list of event listeners assigned to given name. 20512 * If no arguments specified all the events will be cleared. 20513 ** 20514 > Arguments 20515 ** 20516 - name (string) name of the event, dot (`.`) or slash (`/`) separated, with optional wildcards 20517 - f (function) event handler function 20518 \*/ 20519 /*\ 20520 * eve.unbind 20521 [ method ] 20522 ** 20523 * See @eve.off 20524 \*/ 20525 eve.off = eve.unbind = function (name, f) { 20526 if (!name) { 20527 eve._events = events = {n: {}}; 20528 return; 20529 } 20530 var names = isArray(name) ? (isArray(name[0]) ? name : [name]) : Str(name).split(comaseparator); 20531 if (names.length > 1) { 20532 for (var i = 0, ii = names.length; i < ii; i++) { 20533 eve.off(names[i], f); 20534 } 20535 return; 20536 } 20537 names = isArray(name) ? name : Str(name).split(separator); 20538 var e, 20539 key, 20540 splice, 20541 i, ii, j, jj, 20542 cur = [events], 20543 inodes = []; 20544 for (i = 0, ii = names.length; i < ii; i++) { 20545 for (j = 0; j < cur.length; j += splice.length - 2) { 20546 splice = [j, 1]; 20547 e = cur[j].n; 20548 if (names[i] != wildcard) { 20549 if (e[names[i]]) { 20550 splice.push(e[names[i]]); 20551 inodes.unshift({ 20552 n: e, 20553 name: names[i] 20554 }); 20555 } 20556 } else { 20557 for (key in e) if (e[has](key)) { 20558 splice.push(e[key]); 20559 inodes.unshift({ 20560 n: e, 20561 name: key 20562 }); 20563 } 20564 } 20565 cur.splice.apply(cur, splice); 20566 } 20567 } 20568 for (i = 0, ii = cur.length; i < ii; i++) { 20569 e = cur[i]; 20570 while (e.n) { 20571 if (f) { 20572 if (e.f) { 20573 for (j = 0, jj = e.f.length; j < jj; j++) if (e.f[j] == f) { 20574 e.f.splice(j, 1); 20575 break; 20576 } 20577 !e.f.length && delete e.f; 20578 } 20579 for (key in e.n) if (e.n[has](key) && e.n[key].f) { 20580 var funcs = e.n[key].f; 20581 for (j = 0, jj = funcs.length; j < jj; j++) if (funcs[j] == f) { 20582 funcs.splice(j, 1); 20583 break; 20584 } 20585 !funcs.length && delete e.n[key].f; 20586 } 20587 } else { 20588 delete e.f; 20589 for (key in e.n) if (e.n[has](key) && e.n[key].f) { 20590 delete e.n[key].f; 20591 } 20592 } 20593 e = e.n; 20594 } 20595 } 20596 // prune inner nodes in path 20597 prune: for (i = 0, ii = inodes.length; i < ii; i++) { 20598 e = inodes[i]; 20599 for (key in e.n[e.name].f) { 20600 // not empty (has listeners) 20601 continue prune; 20602 } 20603 for (key in e.n[e.name].n) { 20604 // not empty (has children) 20605 continue prune; 20606 } 20607 // is empty 20608 delete e.n[e.name]; 20609 } 20610 }; 20611 /*\ 20612 * eve.once 20613 [ method ] 20614 ** 20615 * Binds given event handler with a given name to only run once then unbind itself. 20616 | eve.once("login", f); 20617 | eve("login"); // triggers f 20618 | eve("login"); // no listeners 20619 * Use @eve to trigger the listener. 20620 ** 20621 > Arguments 20622 ** 20623 - name (string) name of the event, dot (`.`) or slash (`/`) separated, with optional wildcards 20624 - f (function) event handler function 20625 ** 20626 = (function) same return function as @eve.on 20627 \*/ 20628 eve.once = function (name, f) { 20629 var f2 = function () { 20630 eve.off(name, f2); 20631 return f.apply(this, arguments); 20632 }; 20633 return eve.on(name, f2); 20634 }; 20635 /*\ 20636 * eve.version 20637 [ property (string) ] 20638 ** 20639 * Current version of the library. 20640 \*/ 20641 eve.version = version; 20642 eve.toString = function () { 20643 return "You are running Eve " + version; 20644 }; 20645 (typeof module != "undefined" && module.exports) ? (module.exports = eve) : (
20645 true ? (!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_LOCAL_MODULE_0__ = (function() { return eve; }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)))) : (glob.eve = eve)); 20646})(this); 20647 20648(function (glob, factory) { 20649 // AMD support 20650 if (true) { 20651 // Define as an anonymous module 20652 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__WEBPACK_LOCAL_MODULE_0__], __WEBPACK_AMD_DEFINE_RESULT__ = function (eve) { 20653 return factory(glob, eve); 20654 }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 20655 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)
vendor: 265,914 bytes, lines 20655-28810
20655); 20656 } else if (typeof exports != "undefined") { 20657 // Next for Node.js or CommonJS 20658 var eve = require("eve"); 20659 module.exports = factory(glob, eve); 20660 } else { 20661 // Browser globals (glob is window) 20662 // Snap adds itself to window 20663 factory(glob, glob.eve); 20664 } 20665}(window || this, function (window, eve) { 20666 20667// Copyright (c) 2017 Adobe Systems Incorporated. All rights reserved. 20668// 20669// Licensed under the Apache License, Version 2.0 (the "License"); 20670// you may not use this file except in compliance with the License. 20671// You may obtain a copy of the License at 20672// 20673// http://www.apache.org/licenses/LICENSE-2.0 20674// 20675// Unless required by applicable law or agreed to in writing, software 20676// distributed under the License is distributed on an "AS IS" BASIS, 20677// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 20678// See the License for the specific language governing permissions and 20679// limitations under the License. 20680var mina = (function (eve) { 20681 var animations = {}, 20682 requestAnimFrame = window.requestAnimationFrame || 20683 window.webkitRequestAnimationFrame || 20684 window.mozRequestAnimationFrame || 20685 window.oRequestAnimationFrame || 20686 window.msRequestAnimationFrame || 20687 function (callback) { 20688 setTimeout(callback, 16, new Date().getTime()); 20689 return true; 20690 }, 20691 requestID, 20692 isArray = Array.isArray || function (a) { 20693 return a instanceof Array || 20694 Object.prototype.toString.call(a) == "[object Array]"; 20695 }, 20696 idgen = 0, 20697 idprefix = "M" + (+new Date).toString(36), 20698 ID = function () { 20699 return idprefix + (idgen++).toString(36); 20700 }, 20701 diff = function (a, b, A, B) { 20702 if (isArray(a)) { 20703 res = []; 20704 for (var i = 0, ii = a.length; i < ii; i++) { 20705 res[i] = diff(a[i], b, A[i], B); 20706 } 20707 return res; 20708 } 20709 var dif = (A - a) / (B - b); 20710 return function (bb) { 20711 return a + dif * (bb - b); 20712 }; 20713 }, 20714 timer = Date.now || function () { 20715 return +new Date; 20716 }, 20717 sta = function (val) { 20718 var a = this; 20719 if (val == null) { 20720 return a.s; 20721 } 20722 var ds = a.s - val; 20723 a.b += a.dur * ds; 20724 a.B += a.dur * ds; 20725 a.s = val; 20726 }, 20727 speed = function (val) { 20728 var a = this; 20729 if (val == null) { 20730 return a.spd; 20731 } 20732 a.spd = val; 20733 }, 20734 duration = function (val) { 20735 var a = this; 20736 if (val == null) { 20737 return a.dur; 20738 } 20739 a.s = a.s * val / a.dur; 20740 a.dur = val; 20741 }, 20742 stopit = function () { 20743 var a = this; 20744 delete animations[a.id]; 20745 a.update(); 20746 eve("mina.stop." + a.id, a); 20747 }, 20748 pause = function () { 20749 var a = this; 20750 if (a.pdif) { 20751 return; 20752 } 20753 delete animations[a.id]; 20754 a.update(); 20755 a.pdif = a.get() - a.b; 20756 }, 20757 resume = function () { 20758 var a = this; 20759 if (!a.pdif) { 20760 return; 20761 } 20762 a.b = a.get() - a.pdif; 20763 delete a.pdif; 20764 animations[a.id] = a; 20765 frame(); 20766 }, 20767 update = function () { 20768 var a = this, 20769 res; 20770 if (isArray(a.start)) { 20771 res = []; 20772 for (var j = 0, jj = a.start.length; j < jj; j++) { 20773 res[j] = +a.start[j] + 20774 (a.end[j] - a.start[j]) * a.easing(a.s); 20775 } 20776 } else { 20777 res = +a.start + (a.end - a.start) * a.easing(a.s); 20778 } 20779 a.set(res); 20780 }, 20781 frame = function (timeStamp) { 20782 // Manual invokation? 20783 if (!timeStamp) { 20784 // Frame loop stopped? 20785 if (!requestID) { 20786 // Start frame loop... 20787 requestID = requestAnimFrame(frame); 20788 } 20789 return; 20790 } 20791 var len = 0; 20792 for (var i in animations) if (animations.hasOwnProperty(i)) { 20793 var a = animations[i], 20794 b = a.get(), 20795 res; 20796 len++; 20797 a.s = (b - a.b) / (a.dur / a.spd); 20798 if (a.s >= 1) { 20799 delete animations[i]; 20800 a.s = 1; 20801 len--; 20802 (function (a) { 20803 setTimeout(function () { 20804 eve("mina.finish." + a.id, a); 20805 }); 20806 }(a)); 20807 } 20808 a.update(); 20809 } 20810 requestID = len ? requestAnimFrame(frame) : false; 20811 }, 20812 /*\ 20813 * mina 20814 [ method ] 20815 ** 20816 * Generic animation of numbers 20817 ** 20818 - a (number) start _slave_ number 20819 - A (number) end _slave_ number 20820 - b (number) start _master_ number (start time in general case) 20821 - B (number) end _master_ number (end time in general case) 20822 - get (function) getter of _master_ number (see @mina.time) 20823 - set (function) setter of _slave_ number 20824 - easing (function) #optional easing function, default is @mina.linear 20825 = (object) animation descriptor 20826 o { 20827 o id (string) animation id, 20828 o start (number) start _slave_ number, 20829 o end (number) end _slave_ number, 20830 o b (number) start _master_ number, 20831 o s (number) animation status (0..1), 20832 o dur (number) animation duration, 20833 o spd (number) animation speed, 20834 o get (function) getter of _master_ number (see @mina.time), 20835 o set (function) setter of _slave_ number, 20836 o easing (function) easing function, default is @mina.linear, 20837 o status (function) status getter/setter, 20838 o speed (function) speed getter/setter, 20839 o duration (function) duration getter/setter, 20840 o stop (function) animation stopper 20841 o pause (function) pauses the animation 20842 o resume (function) resumes the animation 20843 o update (function) calles setter with the right value of the animation 20844 o } 20845 \*/ 20846 mina = function (a, A, b, B, get, set, easing) { 20847 var anim = { 20848 id: ID(), 20849 start: a, 20850 end: A, 20851 b: b, 20852 s: 0, 20853 dur: B - b, 20854 spd: 1, 20855 get: get, 20856 set: set, 20857 easing: easing || mina.linear, 20858 status: sta, 20859 speed: speed, 20860 duration: duration, 20861 stop: stopit, 20862 pause: pause, 20863 resume: resume, 20864 update: update 20865 }; 20866 animations[anim.id] = anim; 20867 var len = 0, i; 20868 for (i in animations) if (animations.hasOwnProperty(i)) { 20869 len++; 20870 if (len == 2) { 20871 break; 20872 } 20873 } 20874 len == 1 && frame(); 20875 return anim; 20876 }; 20877 /*\ 20878 * mina.time 20879 [ method ] 20880 ** 20881 * Returns the current time. Equivalent to: 20882 | function () { 20883 | return (new Date).getTime(); 20884 | } 20885 \*/ 20886 mina.time = timer; 20887 /*\ 20888 * mina.getById 20889 [ method ] 20890 ** 20891 * Returns an animation by its id 20892 - id (string) animation's id 20893 = (object) See @mina 20894 \*/ 20895 mina.getById = function (id) { 20896 return animations[id] || null; 20897 }; 20898 20899 /*\ 20900 * mina.linear 20901 [ method ] 20902 ** 20903 * Default linear easing 20904 - n (number) input 0..1 20905 = (number) output 0..1 20906 \*/ 20907 mina.linear = function (n) { 20908 return n; 20909 }; 20910 /*\ 20911 * mina.easeout 20912 [ method ] 20913 ** 20914 * Easeout easing 20915 - n (number) input 0..1 20916 = (number) output 0..1 20917 \*/ 20918 mina.easeout = function (n) { 20919 return Math.pow(n, 1.7); 20920 }; 20921 /*\ 20922 * mina.easein 20923 [ method ] 20924 ** 20925 * Easein easing 20926 - n (number) input 0..1 20927 = (number) output 0..1 20928 \*/ 20929 mina.easein = function (n) { 20930 return Math.pow(n, .48); 20931 }; 20932 /*\ 20933 * mina.easeinout 20934 [ method ] 20935 ** 20936 * Easeinout easing 20937 - n (number) input 0..1 20938 = (number) output 0..1 20939 \*/ 20940 mina.easeinout = function (n) { 20941 if (n == 1) { 20942 return 1; 20943 } 20944 if (n == 0) { 20945 return 0; 20946 } 20947 var q = .48 - n / 1.04, 20948 Q = Math.sqrt(.1734 + q * q), 20949 x = Q - q, 20950 X = Math.pow(Math.abs(x), 1 / 3) * (x < 0 ? -1 : 1), 20951 y = -Q - q, 20952 Y = Math.pow(Math.abs(y), 1 / 3) * (y < 0 ? -1 : 1), 20953 t = X + Y + .5; 20954 return (1 - t) * 3 * t * t + t * t * t; 20955 }; 20956 /*\ 20957 * mina.backin 20958 [ method ] 20959 ** 20960 * Backin easing 20961 - n (number) input 0..1 20962 = (number) output 0..1 20963 \*/ 20964 mina.backin = function (n) { 20965 if (n == 1) { 20966 return 1; 20967 } 20968 var s = 1.70158; 20969 return n * n * ((s + 1) * n - s); 20970 }; 20971 /*\ 20972 * mina.backout 20973 [ method ] 20974 ** 20975 * Backout easing 20976 - n (number) input 0..1 20977 = (number) output 0..1 20978 \*/ 20979 mina.backout = function (n) { 20980 if (n == 0) { 20981 return 0; 20982 } 20983 n = n - 1; 20984 var s = 1.70158; 20985 return n * n * ((s + 1) * n + s) + 1; 20986 }; 20987 /*\ 20988 * mina.elastic 20989 [ method ] 20990 ** 20991 * Elastic easing 20992 - n (number) input 0..1 20993 = (number) output 0..1 20994 \*/ 20995 mina.elastic = function (n) { 20996 if (n == !!n) { 20997 return n; 20998 } 20999 return Math.pow(2, -10 * n) * Math.sin((n - .075) * 21000 (2 * Math.PI) / .3) + 1; 21001 }; 21002 /*\ 21003 * mina.bounce 21004 [ method ] 21005 ** 21006 * Bounce easing 21007 - n (number) input 0..1 21008 = (number) output 0..1 21009 \*/ 21010 mina.bounce = function (n) { 21011 var s = 7.5625, 21012 p = 2.75, 21013 l; 21014 if (n < 1 / p) { 21015 l = s * n * n; 21016 } else { 21017 if (n < 2 / p) { 21018 n -= 1.5 / p; 21019 l = s * n * n + .75; 21020 } else { 21021 if (n < 2.5 / p) { 21022 n -= 2.25 / p; 21023 l = s * n * n + .9375; 21024 } else { 21025 n -= 2.625 / p; 21026 l = s * n * n + .984375; 21027 } 21028 } 21029 } 21030 return l; 21031 }; 21032 window.mina = mina; 21033 return mina; 21034})(typeof eve == "undefined" ? function () {} : eve); 21035 21036// Copyright (c) 2013 - 2017 Adobe Systems Incorporated. All rights reserved. 21037// 21038// Licensed under the Apache License, Version 2.0 (the "License"); 21039// you may not use this file except in compliance with the License. 21040// You may obtain a copy of the License at 21041// 21042// http://www.apache.org/licenses/LICENSE-2.0 21043// 21044// Unless required by applicable law or agreed to in writing, software 21045// distributed under the License is distributed on an "AS IS" BASIS, 21046// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 21047// See the License for the specific language governing permissions and 21048// limitations under the License. 21049 21050var Snap = (function(root) { 21051Snap.version = "0.5.1"; 21052/*\ 21053 * Snap 21054 [ method ] 21055 ** 21056 * Creates a drawing surface or wraps existing SVG element. 21057 ** 21058 - width (number|string) width of surface 21059 - height (number|string) height of surface 21060 * or 21061 - DOM (SVGElement) element to be wrapped into Snap structure 21062 * or 21063 - array (array) array of elements (will return set of elements) 21064 * or 21065 - query (string) CSS query selector 21066 = (object) @Element 21067\*/ 21068function Snap(w, h) { 21069 if (w) { 21070 if (w.nodeType) { 21071 return wrap(w); 21072 } 21073 if (is(w, "array") && Snap.set) { 21074 return Snap.set.apply(Snap, w); 21075 } 21076 if (w instanceof Element) { 21077 return w; 21078 } 21079 if (h == null) { 21080 // try { 21081 w = glob.doc.querySelector(String(w)); 21082 return wrap(w); 21083 // } catch (e) { 21084 // return null; 21085 // } 21086 } 21087 } 21088 w = w == null ? "100%" : w; 21089 h = h == null ? "100%" : h; 21090 return new Paper(w, h); 21091} 21092Snap.toString = function () { 21093 return "Snap v" + this.version; 21094}; 21095Snap._ = {}; 21096var glob = { 21097 win: root.window, 21098 doc: root.window.document 21099}; 21100Snap._.glob = glob; 21101var has = "hasOwnProperty", 21102 Str = String, 21103 toFloat = parseFloat, 21104 toInt = parseInt, 21105 math = Math, 21106 mmax = math.max, 21107 mmin = math.min, 21108 abs = math.abs, 21109 pow = math.pow, 21110 PI = math.PI, 21111 round = math.round, 21112 E = "", 21113 S = " ", 21114 objectToString = Object.prototype.toString, 21115 ISURL = /^url\(['"]?([^\)]+?)['"]?\)$/i, 21116 colourRegExp = /^\s*((#[a-f\d]{6})|(#[a-f\d]{3})|rgba?\(\s*([\d\.]+%?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+%?(?:\s*,\s*[\d\.]+%?)?)\s*\)|hsba?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+(?:%?\s*,\s*[\d\.]+)?%?)\s*\)|hsla?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+(?:%?\s*,\s*[\d\.]+)?%?)\s*\))\s*$/i, 21117 bezierrg = /^(?:cubic-)?bezier\(([^,]+),([^,]+),([^,]+),([^\)]+)\)/, 21118 separator = Snap._.separator = /[,\s]+/, 21119 whitespace = /[\s]/g, 21120 commaSpaces = /[\s]*,[\s]*/, 21121 hsrg = {hs: 1, rg: 1}, 21122 pathCommand = /([a-z])[\s,]*((-?\d*\.?\d*(?:e[\-+]?\d+)?[\s]*,?[\s]*)+)/ig, 21123 tCommand = /([rstm])[\s,]*((-?\d*\.?\d*(?:e[\-+]?\d+)?[\s]*,?[\s]*)+)/ig, 21124 pathValues = /(-?\d*\.?\d*(?:e[\-+]?\d+)?)[\s]*,?[\s]*/ig, 21125 idgen = 0, 21126 idprefix = "S" + (+new Date).toString(36), 21127 ID = function (el) { 21128 return (el && el.type ? el.type : E) + idprefix + (idgen++).toString(36); 21129 }, 21130 xlink = "http://www.w3.org/1999/xlink", 21131 xmlns = "http://www.w3.org/2000/svg", 21132 hub = {}, 21133 /*\ 21134 * Snap.url 21135 [ method ] 21136 ** 21137 * Wraps path into `"url('<path>')"`. 21138 - value (string) path 21139 = (string) wrapped path 21140 \*/ 21141 URL = Snap.url = function (url) { 21142 return "url('#" + url + "')"; 21143 }; 21144 21145function $(el, attr) { 21146 if (attr) { 21147 if (el == "#text") { 21148 el = glob.doc.createTextNode(attr.text || attr["#text"] || ""); 21149 } 21150 if (el == "#comment") { 21151 el = glob.doc.createComment(attr.text || attr["#text"] || ""); 21152 } 21153 if (typeof el == "string") { 21154 el = $(el); 21155 } 21156 if (typeof attr == "string") { 21157 if (el.nodeType == 1) { 21158 if (attr.substring(0, 6) == "xlink:") { 21159 return el.getAttributeNS(xlink, attr.substring(6)); 21160 } 21161 if (attr.substring(0, 4) == "xml:") { 21162 return el.getAttributeNS(xmlns, attr.substring(4)); 21163 } 21164 return el.getAttribute(attr); 21165 } else if (attr == "text") { 21166 return el.nodeValue; 21167 } else { 21168 return null; 21169 } 21170 } 21171 if (el.nodeType == 1) { 21172 for (var key in attr) if (attr[has](key)) { 21173 var val = Str(attr[key]); 21174 if (val) { 21175 if (key.substring(0, 6) == "xlink:") { 21176 el.setAttributeNS(xlink, key.substring(6), val); 21177 } else if (key.substring(0, 4) == "xml:") { 21178 el.setAttributeNS(xmlns, key.substring(4), val); 21179 } else { 21180 el.setAttribute(key, val); 21181 } 21182 } else { 21183 el.removeAttribute(key); 21184 } 21185 } 21186 } else if ("text" in attr) { 21187 el.nodeValue = attr.text; 21188 } 21189 } else { 21190 el = glob.doc.createElementNS(xmlns, el); 21191 } 21192 return el; 21193} 21194Snap._.$ = $; 21195Snap._.id = ID; 21196function getAttrs(el) { 21197 var attrs = el.attributes, 21198 name, 21199 out = {}; 21200 for (var i = 0; i < attrs.length; i++) { 21201 if (attrs[i].namespaceURI == xlink) { 21202 name = "xlink:"; 21203 } else { 21204 name = ""; 21205 } 21206 name += attrs[i].name; 21207 out[name] = attrs[i].textContent; 21208 } 21209 return out; 21210} 21211function is(o, type) { 21212 type = Str.prototype.toLowerCase.call(type); 21213 if (type == "finite") { 21214 return isFinite(o); 21215 } 21216 if (type == "array" && 21217 (o instanceof Array || Array.isArray && Array.isArray(o))) { 21218 return true; 21219 } 21220 return type == "null" && o === null || 21221 type == typeof o && o !== null || 21222 type == "object" && o === Object(o) || 21223 objectToString.call(o).slice(8, -1).toLowerCase() == type; 21224} 21225/*\ 21226 * Snap.format 21227 [ method ] 21228 ** 21229 * Replaces construction of type `{<name>}` to the corresponding argument 21230 ** 21231 - token (string) string to format 21232 - json (object) object which properties are used as a replacement 21233 = (string) formatted string 21234 > Usage 21235 | // this draws a rectangular shape equivalent to "M10,20h40v50h-40z" 21236 | paper.path(Snap.format("M{x},{y}h{dim.width}v{dim.height}h{dim['negative width']}z", { 21237 | x: 10, 21238 | y: 20, 21239 | dim: { 21240 | width: 40, 21241 | height: 50, 21242 | "negative width": -40 21243 | } 21244 | })); 21245\*/ 21246Snap.format = (function () { 21247 var tokenRegex = /\{([^\}]+)\}/g, 21248 objNotationRegex = /(?:(?:^|\.)(.+?)(?=\[|\.|$|\()|\[('|")(.+?)\2\])(\(\))?/g, // matches .xxxxx or ["xxxxx"] to run over object properties 21249 replacer = function (all, key, obj) { 21250 var res = obj; 21251 key.replace(objNotationRegex, function (all, name, quote, quotedName, isFunc) { 21252 name = name || quotedName; 21253 if (res) { 21254 if (name in res) { 21255 res = res[name]; 21256 } 21257 typeof res == "function" && isFunc && (res = res()); 21258 } 21259 }); 21260 res = (res == null || res == obj ? all : res) + ""; 21261 return res; 21262 }; 21263 return function (str, obj) { 21264 return Str(str).replace(tokenRegex, function (all, key) { 21265 return replacer(all, key, obj); 21266 }); 21267 }; 21268})(); 21269function clone(obj) { 21270 if (typeof obj == "function" || Object(obj) !== obj) { 21271 return obj; 21272 } 21273 var res = new obj.constructor; 21274 for (var key in obj) if (obj[has](key)) { 21275 res[key] = clone(obj[key]); 21276 } 21277 return res; 21278} 21279Snap._.clone = clone; 21280function repush(array, item) { 21281 for (var i = 0, ii = array.length; i < ii; i++) if (array[i] === item) { 21282 return array.push(array.splice(i, 1)[0]); 21283 } 21284} 21285function cacher(f, scope, postprocessor) { 21286 function newf() { 21287 var arg = Array.prototype.slice.call(arguments, 0), 21288 args = arg.join("\u2400"), 21289 cache = newf.cache = newf.cache || {}, 21290 count = newf.count = newf.count || []; 21291 if (cache[has](args)) { 21292 repush(count, args); 21293 return postprocessor ? postprocessor(cache[args]) : cache[args]; 21294 } 21295 count.length >= 1e3 && delete cache[count.shift()]; 21296 count.push(args); 21297 cache[args] = f.apply(scope, arg); 21298 return postprocessor ? postprocessor(cache[args]) : cache[args]; 21299 } 21300 return newf; 21301} 21302Snap._.cacher = cacher; 21303function angle(x1, y1, x2, y2, x3, y3) { 21304 if (x3 == null) { 21305 var x = x1 - x2, 21306 y = y1 - y2; 21307 if (!x && !y) { 21308 return 0; 21309 } 21310 return (180 + math.atan2(-y, -x) * 180 / PI + 360) % 360; 21311 } else { 21312 return angle(x1, y1, x3, y3) - angle(x2, y2, x3, y3); 21313 } 21314} 21315function rad(deg) { 21316 return deg % 360 * PI / 180; 21317} 21318function deg(rad) { 21319 return rad * 180 / PI % 360; 21320} 21321function x_y() { 21322 return this.x + S + this.y; 21323} 21324function x_y_w_h() { 21325 return this.x + S + this.y + S + this.width + " \xd7 " + this.height; 21326} 21327 21328/*\ 21329 * Snap.rad 21330 [ method ] 21331 ** 21332 * Transform angle to radians 21333 - deg (number) angle in degrees 21334 = (number) angle in radians 21335\*/ 21336Snap.rad = rad; 21337/*\ 21338 * Snap.deg 21339 [ method ] 21340 ** 21341 * Transform angle to degrees 21342 - rad (number) angle in radians 21343 = (number) angle in degrees 21344\*/ 21345Snap.deg = deg; 21346/*\ 21347 * Snap.sin 21348 [ method ] 21349 ** 21350 * Equivalent to `Math.sin()` only works with degrees, not radians. 21351 - angle (number) angle in degrees 21352 = (number) sin 21353\*/ 21354Snap.sin = function (angle) { 21355 return math.sin(Snap.rad(angle)); 21356}; 21357/*\ 21358 * Snap.tan 21359 [ method ] 21360 ** 21361 * Equivalent to `Math.tan()` only works with degrees, not radians. 21362 - angle (number) angle in degrees 21363 = (number) tan 21364\*/ 21365Snap.tan = function (angle) { 21366 return math.tan(Snap.rad(angle)); 21367}; 21368/*\ 21369 * Snap.cos 21370 [ method ] 21371 ** 21372 * Equivalent to `Math.cos()` only works with degrees, not radians. 21373 - angle (number) angle in degrees 21374 = (number) cos 21375\*/ 21376Snap.cos = function (angle) { 21377 return math.cos(Snap.rad(angle)); 21378}; 21379/*\ 21380 * Snap.asin 21381 [ method ] 21382 ** 21383 * Equivalent to `Math.asin()` only works with degrees, not radians. 21384 - num (number) value 21385 = (number) asin in degrees 21386\*/ 21387Snap.asin = function (num) { 21388 return Snap.deg(math.asin(num)); 21389}; 21390/*\ 21391 * Snap.acos 21392 [ method ] 21393 ** 21394 * Equivalent to `Math.acos()` only works with degrees, not radians. 21395 - num (number) value 21396 = (number) acos in degrees 21397\*/ 21398Snap.acos = function (num) { 21399 return Snap.deg(math.acos(num)); 21400}; 21401/*\ 21402 * Snap.atan 21403 [ method ] 21404 ** 21405 * Equivalent to `Math.atan()` only works with degrees, not radians. 21406 - num (number) value 21407 = (number) atan in degrees 21408\*/ 21409Snap.atan = function (num) { 21410 return Snap.deg(math.atan(num)); 21411}; 21412/*\ 21413 * Snap.atan2 21414 [ method ] 21415 ** 21416 * Equivalent to `Math.atan2()` only works with degrees, not radians. 21417 - num (number) value 21418 = (number) atan2 in degrees 21419\*/ 21420Snap.atan2 = function (num) { 21421 return Snap.deg(math.atan2(num)); 21422}; 21423/*\ 21424 * Snap.angle 21425 [ method ] 21426 ** 21427 * Returns an angle between two or three points 21428 - x1 (number) x coord of first point 21429 - y1 (number) y coord of first point 21430 - x2 (number) x coord of second point 21431 - y2 (number) y coord of second point 21432 - x3 (number) #optional x coord of third point 21433 - y3 (number) #optional y coord of third point 21434 = (number) angle in degrees 21435\*/ 21436Snap.angle = angle; 21437/*\ 21438 * Snap.len 21439 [ method ] 21440 ** 21441 * Returns distance between two points 21442 - x1 (number) x coord of first point 21443 - y1 (number) y coord of first point 21444 - x2 (number) x coord of second point 21445 - y2 (number) y coord of second point 21446 = (number) distance 21447\*/ 21448Snap.len = function (x1, y1, x2, y2) { 21449 return Math.sqrt(Snap.len2(x1, y1, x2, y2)); 21450}; 21451/*\ 21452 * Snap.len2 21453 [ method ] 21454 ** 21455 * Returns squared distance between two points 21456 - x1 (number) x coord of first point 21457 - y1 (number) y coord of first point 21458 - x2 (number) x coord of second point 21459 - y2 (number) y coord of second point 21460 = (number) distance 21461\*/ 21462Snap.len2 = function (x1, y1, x2, y2) { 21463 return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2); 21464}; 21465/*\ 21466 * Snap.closestPoint 21467 [ method ] 21468 ** 21469 * Returns closest point to a given one on a given path. 21470 - path (Element) path element 21471 - x (number) x coord of a point 21472 - y (number) y coord of a point 21473 = (object) in format 21474 { 21475 x (number) x coord of the point on the path 21476 y (number) y coord of the point on the path 21477 length (number) length of the path to the point 21478 distance (number) distance from the given point to the path 21479 } 21480\*/ 21481// Copied from http://bl.ocks.org/mbostock/8027637 21482Snap.closestPoint = function (path, x, y) { 21483 function distance2(p) { 21484 var dx = p.x - x, 21485 dy = p.y - y; 21486 return dx * dx + dy * dy; 21487 } 21488 var pathNode = path.node, 21489 pathLength = pathNode.getTotalLength(), 21490 precision = pathLength / pathNode.pathSegList.numberOfItems * .125, 21491 best, 21492 bestLength, 21493 bestDistance = Infinity; 21494 21495 // linear scan for coarse approximation 21496 for (var scan, scanLength = 0, scanDistance; scanLength <= pathLength; scanLength += precision) { 21497 if ((scanDistance = distance2(scan = pathNode.getPointAtLength(scanLength))) < bestDistance) { 21498 best = scan; 21499 bestLength = scanLength; 21500 bestDistance = scanDistance; 21501 } 21502 } 21503 21504 // binary search for precise estimate 21505 precision *= .5; 21506 while (precision > .5) { 21507 var before, 21508 after, 21509 beforeLength, 21510 afterLength, 21511 beforeDistance, 21512 afterDistance; 21513 if ((beforeLength = bestLength - precision) >= 0 && (beforeDistance = distance2(before = pathNode.getPointAtLength(beforeLength))) < bestDistance) { 21514 best = before; 21515 bestLength = beforeLength; 21516 bestDistance = beforeDistance; 21517 } else if ((afterLength = bestLength + precision) <= pathLength && (afterDistance = distance2(after = pathNode.getPointAtLength(afterLength))) < bestDistance) { 21518 best = after; 21519 bestLength = afterLength; 21520 bestDistance = afterDistance; 21521 } else { 21522 precision *= .5; 21523 } 21524 } 21525 21526 best = { 21527 x: best.x, 21528 y: best.y, 21529 length: bestLength, 21530 distance: Math.sqrt(bestDistance) 21531 }; 21532 return best; 21533} 21534/*\ 21535 * Snap.is 21536 [ method ] 21537 ** 21538 * Handy replacement for the `typeof` operator 21539 - o (â¦) any object or primitive 21540 - type (string) name of the type, e.g., `string`, `function`, `number`, etc. 21541 = (boolean) `true` if given value is of given type 21542\*/ 21543Snap.is = is; 21544/*\ 21545 * Snap.snapTo 21546 [ method ] 21547 ** 21548 * Snaps given value to given grid 21549 - values (array|number) given array of values or step of the grid 21550 - value (number) value to adjust 21551 - tolerance (number) #optional maximum distance to the target value that would trigger the snap. Default is `10`. 21552 = (number) adjusted value 21553\*/ 21554Snap.snapTo = function (values, value, tolerance) { 21555 tolerance = is(tolerance, "finite") ? tolerance : 10; 21556 if (is(values, "array")) { 21557 var i = values.length; 21558 while (i--) if (abs(values[i] - value) <= tolerance) { 21559 return values[i]; 21560 } 21561 } else { 21562 values = +values; 21563 var rem = value % values; 21564 if (rem < tolerance) { 21565 return value - rem; 21566 } 21567 if (rem > values - tolerance) { 21568 return value - rem + values; 21569 } 21570 } 21571 return value; 21572}; 21573// Colour 21574/*\ 21575 * Snap.getRGB 21576 [ method ] 21577 ** 21578 * Parses color string as RGB object 21579 - color (string) color string in one of the following formats: 21580 # <ul> 21581 # <li>Color name (<code>red</code>, <code>green</code>, <code>cornflowerblue</code>, etc)</li> 21582 # <li>#â¢â¢â¢ â shortened HTML color: (<code>#000</code>, <code>#fc0</code>, etc.)</li> 21583 # <li>#â¢â¢â¢â¢â¢â¢ â full length HTML color: (<code>#000000</code>, <code>#bd2300</code>)</li> 21584 # <li>rgb(â¢â¢â¢, â¢â¢â¢, â¢â¢â¢) â red, green and blue channels values: (<code>rgb(200, 100, 0)</code>)</li> 21585 # <li>rgba(â¢â¢â¢, â¢â¢â¢, â¢â¢â¢, â¢â¢â¢) â also with opacity</li> 21586 # <li>rgb(â¢â¢â¢%, â¢â¢â¢%, â¢â¢â¢%) â same as above, but in %: (<code>rgb(100%, 175%, 0%)</code>)</li> 21587 # <li>rgba(â¢â¢â¢%, â¢â¢â¢%, â¢â¢â¢%, â¢â¢â¢%) â also with opacity</li> 21588 # <li>hsb(â¢â¢â¢, â¢â¢â¢, â¢â¢â¢) â hue, saturation and brightness values: (<code>hsb(0.5, 0.25, 1)</code>)</li> 21589 # <li>hsba(â¢â¢â¢, â¢â¢â¢, â¢â¢â¢, â¢â¢â¢) â also with opacity</li> 21590 # <li>hsb(â¢â¢â¢%, â¢â¢â¢%, â¢â¢â¢%) â same as above, but in %</li> 21591 # <li>hsba(â¢â¢â¢%, â¢â¢â¢%, â¢â¢â¢%, â¢â¢â¢%) â also with opacity</li> 21592 # <li>hsl(â¢â¢â¢, â¢â¢â¢, â¢â¢â¢) â hue, saturation and luminosity values: (<code>hsb(0.5, 0.25, 0.5)</code>)</li> 21593 # <li>hsla(â¢â¢â¢, â¢â¢â¢, â¢â¢â¢, â¢â¢â¢) â also with opacity</li> 21594 # <li>hsl(â¢â¢â¢%, â¢â¢â¢%, â¢â¢â¢%) â same as above, but in %</li> 21595 # <li>hsla(â¢â¢â¢%, â¢â¢â¢%, â¢â¢â¢%, â¢â¢â¢%) â also with opacity</li> 21596 # </ul> 21597 * Note that `%` can be used any time: `rgb(20%, 255, 50%)`. 21598 = (object) RGB object in the following format: 21599 o { 21600 o r (number) red, 21601 o g (number) green, 21602 o b (number) blue, 21603 o hex (string) color in HTML/CSS format: #â¢â¢â¢â¢â¢â¢, 21604 o error (boolean) true if string can't be parsed 21605 o } 21606\*/ 21607Snap.getRGB = cacher(function (colour) { 21608 if (!colour || !!((colour = Str(colour)).indexOf("-") + 1)) { 21609 return {r: -1, g: -1, b: -1, hex: "none", error: 1, toString: rgbtoString}; 21610 } 21611 if (colour == "none") { 21612 return {r: -1, g: -1, b: -1, hex: "none", toString: rgbtoString}; 21613 } 21614 !(hsrg[has](colour.toLowerCase().substring(0, 2)) || colour.charAt() == "#") && (colour = toHex(colour)); 21615 if (!colour) { 21616 return {r: -1, g: -1, b: -1, hex: "none", error: 1, toString: rgbtoString}; 21617 } 21618 var res, 21619 red, 21620 green, 21621 blue, 21622 opacity, 21623 t, 21624 values, 21625 rgb = colour.match(colourRegExp); 21626 if (rgb) { 21627 if (rgb[2]) { 21628 blue = toInt(rgb[2].substring(5), 16); 21629 green = toInt(rgb[2].substring(3, 5), 16); 21630 red = toInt(rgb[2].substring(1, 3), 16); 21631 } 21632 if (rgb[3]) { 21633 blue = toInt((t = rgb[3].charAt(3)) + t, 16); 21634 green = toInt((t = rgb[3].charAt(2)) + t, 16); 21635 red = toInt((t = rgb[3].charAt(1)) + t, 16); 21636 } 21637 if (rgb[4]) { 21638 values = rgb[4].split(commaSpaces); 21639 red = toFloat(values[0]); 21640 values[0].slice(-1) == "%" && (red *= 2.55); 21641 green = toFloat(values[1]); 21642 values[1].slice(-1) == "%" && (green *= 2.55); 21643 blue = toFloat(values[2]); 21644 values[2].slice(-1) == "%" && (blue *= 2.55); 21645 rgb[1].toLowerCase().slice(0, 4) == "rgba" && (opacity = toFloat(values[3])); 21646 values[3] && values[3].slice(-1) == "%" && (opacity /= 100); 21647 } 21648 if (rgb[5]) { 21649 values = rgb[5].split(commaSpaces); 21650 red = toFloat(values[0]); 21651 values[0].slice(-1) == "%" && (red /= 100); 21652 green = toFloat(values[1]); 21653 values[1].slice(-1) == "%" && (green /= 100); 21654 blue = toFloat(values[2]); 21655 values[2].slice(-1) == "%" && (blue /= 100); 21656 (values[0].slice(-3) == "deg" || values[0].slice(-1) == "\xb0") && (red /= 360); 21657 rgb[1].toLowerCase().slice(0, 4) == "hsba" && (opacity = toFloat(values[3])); 21658 values[3] && values[3].slice(-1) == "%" && (opacity /= 100); 21659 return Snap.hsb2rgb(red, green, blue, opacity); 21660 } 21661 if (rgb[6]) { 21662 values = rgb[6].split(commaSpaces); 21663 red = toFloat(values[0]); 21664 values[0].slice(-1) == "%" && (red /= 100); 21665 green = toFloat(values[1]); 21666 values[1].slice(-1) == "%" && (green /= 100); 21667 blue = toFloat(values[2]); 21668 values[2].slice(-1) == "%" && (blue /= 100); 21669 (values[0].slice(-3) == "deg" || values[0].slice(-1) == "\xb0") && (red /= 360); 21670 rgb[1].toLowerCase().slice(0, 4) == "hsla" && (opacity = toFloat(values[3])); 21671 values[3] && values[3].slice(-1) == "%" && (opacity /= 100); 21672 return Snap.hsl2rgb(red, green, blue, opacity); 21673 } 21674 red = mmin(math.round(red), 255); 21675 green = mmin(math.round(green), 255); 21676 blue = mmin(math.round(blue), 255); 21677 opacity = mmin(mmax(opacity, 0), 1); 21678 rgb = {r: red, g: green, b: blue, toString: rgbtoString}; 21679 rgb.hex = "#" + (16777216 | blue | green << 8 | red << 16).toString(16).slice(1); 21680 rgb.opacity = is(opacity, "finite") ? opacity : 1; 21681 return rgb; 21682 } 21683 return {r: -1, g: -1, b: -1, hex: "none", error: 1, toString: rgbtoString}; 21684}, Snap); 21685/*\ 21686 * Snap.hsb 21687 [ method ] 21688 ** 21689 * Converts HSB values to a hex representation of the color 21690 - h (number) hue 21691 - s (number) saturation 21692 - b (number) value or brightness 21693 = (string) hex representation of the color 21694\*/ 21695Snap.hsb = cacher(function (h, s, b) { 21696 return Snap.hsb2rgb(h, s, b).hex; 21697}); 21698/*\ 21699 * Snap.hsl 21700 [ method ] 21701 ** 21702 * Converts HSL values to a hex representation of the color 21703 - h (number) hue 21704 - s (number) saturation 21705 - l (number) luminosity 21706 = (string) hex representation of the color 21707\*/ 21708Snap.hsl = cacher(function (h, s, l) { 21709 return Snap.hsl2rgb(h, s, l).hex; 21710}); 21711/*\ 21712 * Snap.rgb 21713 [ method ] 21714 ** 21715 * Converts RGB values to a hex representation of the color 21716 - r (number) red 21717 - g (number) green 21718 - b (number) blue 21719 = (string) hex representation of the color 21720\*/ 21721Snap.rgb = cacher(function (r, g, b, o) { 21722 if (is(o, "finite")) { 21723 var round = math.round; 21724 return "rgba(" + [round(r), round(g), round(b), +o.toFixed(2)] + ")"; 21725 } 21726 return "#" + (16777216 | b | g << 8 | r << 16).toString(16).slice(1); 21727}); 21728var toHex = function (color) { 21729 var i = glob.doc.getElementsByTagName("head")[0] || glob.doc.getElementsByTagName("svg")[0], 21730 red = "rgb(255, 0, 0)"; 21731 toHex = cacher(function (color) { 21732 if (color.toLowerCase() == "red") { 21733 return red; 21734 } 21735 i.style.color = red; 21736 i.style.color = color; 21737 var out = glob.doc.defaultView.getComputedStyle(i, E).getPropertyValue("color"); 21738 return out == red ? null : out; 21739 }); 21740 return toHex(color); 21741}, 21742hsbtoString = function () { 21743 return "hsb(" + [this.h, this.s, this.b] + ")"; 21744}, 21745hsltoString = function () { 21746 return "hsl(" + [this.h, this.s, this.l] + ")"; 21747}, 21748rgbtoString = function () { 21749 return this.opacity == 1 || this.opacity == null ? 21750 this.hex : 21751 "rgba(" + [this.r, this.g, this.b, this.opacity] + ")"; 21752}, 21753prepareRGB = function (r, g, b) { 21754 if (g == null && is(r, "object") && "r" in r && "g" in r && "b" in r) { 21755 b = r.b; 21756 g = r.g; 21757 r = r.r; 21758 } 21759 if (g == null && is(r, string)) { 21760 var clr = Snap.getRGB(r); 21761 r = clr.r; 21762 g = clr.g; 21763 b = clr.b; 21764 } 21765 if (r > 1 || g > 1 || b > 1) { 21766 r /= 255; 21767 g /= 255; 21768 b /= 255; 21769 } 21770 21771 return [r, g, b]; 21772}, 21773packageRGB = function (r, g, b, o) { 21774 r = math.round(r * 255); 21775 g = math.round(g * 255); 21776 b = math.round(b * 255); 21777 var rgb = { 21778 r: r, 21779 g: g, 21780 b: b, 21781 opacity: is(o, "finite") ? o : 1, 21782 hex: Snap.rgb(r, g, b), 21783 toString: rgbtoString 21784 }; 21785 is(o, "finite") && (rgb.opacity = o); 21786 return rgb; 21787}; 21788/*\ 21789 * Snap.color 21790 [ method ] 21791 ** 21792 * Parses the color string and returns an object featuring the color's component values 21793 - clr (string) color string in one of the supported formats (see @Snap.getRGB) 21794 = (object) Combined RGB/HSB object in the following format: 21795 o { 21796 o r (number) red, 21797 o g (number) green, 21798 o b (number) blue, 21799 o hex (string) color in HTML/CSS format: #â¢â¢â¢â¢â¢â¢, 21800 o error (boolean) `true` if string can't be parsed, 21801 o h (number) hue, 21802 o s (number) saturation, 21803 o v (number) value (brightness), 21804 o l (number) lightness 21805 o } 21806\*/ 21807Snap.color = function (clr) { 21808 var rgb; 21809 if (is(clr, "object") && "h" in clr && "s" in clr && "b" in clr) { 21810 rgb = Snap.hsb2rgb(clr); 21811 clr.r = rgb.r; 21812 clr.g = rgb.g; 21813 clr.b = rgb.b; 21814 clr.opacity = 1; 21815 clr.hex = rgb.hex; 21816 } else if (is(clr, "object") && "h" in clr && "s" in clr && "l" in clr) { 21817 rgb = Snap.hsl2rgb(clr); 21818 clr.r = rgb.r; 21819 clr.g = rgb.g; 21820 clr.b = rgb.b; 21821 clr.opacity = 1; 21822 clr.hex = rgb.hex; 21823 } else { 21824 if (is(clr, "string")) { 21825 clr = Snap.getRGB(clr); 21826 } 21827 if (is(clr, "object") && "r" in clr && "g" in clr && "b" in clr && !("error" in clr)) { 21828 rgb = Snap.rgb2hsl(clr); 21829 clr.h = rgb.h; 21830 clr.s = rgb.s; 21831 clr.l = rgb.l; 21832 rgb = Snap.rgb2hsb(clr); 21833 clr.v = rgb.b; 21834 } else { 21835 clr = {hex: "none"}; 21836 clr.r = clr.g = clr.b = clr.h = clr.s = clr.v = clr.l = -1; 21837 clr.error = 1; 21838 } 21839 } 21840 clr.toString = rgbtoString; 21841 return clr; 21842}; 21843/*\ 21844 * Snap.hsb2rgb 21845 [ method ] 21846 ** 21847 * Converts HSB values to an RGB object 21848 - h (number) hue 21849 - s (number) saturation 21850 - v (number) value or brightness 21851 = (object) RGB object in the following format: 21852 o { 21853 o r (number) red, 21854 o g (number) green, 21855 o b (number) blue, 21856 o hex (string) color in HTML/CSS format: #â¢â¢â¢â¢â¢â¢ 21857 o } 21858\*/ 21859Snap.hsb2rgb = function (h, s, v, o) { 21860 if (is(h, "object") && "h" in h && "s" in h && "b" in h) { 21861 v = h.b; 21862 s = h.s; 21863 o = h.o; 21864 h = h.h; 21865 } 21866 h *= 360; 21867 var R, G, B, X, C; 21868 h = h % 360 / 60; 21869 C = v * s; 21870 X = C * (1 - abs(h % 2 - 1)); 21871 R = G = B = v - C; 21872 21873 h = ~~h; 21874 R += [C, X, 0, 0, X, C][h]; 21875 G += [X, C, C, X, 0, 0][h]; 21876 B += [0, 0, X, C, C, X][h]; 21877 return packageRGB(R, G, B, o); 21878}; 21879/*\ 21880 * Snap.hsl2rgb 21881 [ method ] 21882 ** 21883 * Converts HSL values to an RGB object 21884 - h (number) hue 21885 - s (number) saturation 21886 - l (number) luminosity 21887 = (object) RGB object in the following format: 21888 o { 21889 o r (number) red, 21890 o g (number) green, 21891 o b (number) blue, 21892 o hex (string) color in HTML/CSS format: #â¢â¢â¢â¢â¢â¢ 21893 o } 21894\*/ 21895Snap.hsl2rgb = function (h, s, l, o) { 21896 if (is(h, "object") && "h" in h && "s" in h && "l" in h) { 21897 l = h.l; 21898 s = h.s; 21899 h = h.h; 21900 } 21901 if (h > 1 || s > 1 || l > 1) { 21902 h /= 360; 21903 s /= 100; 21904 l /= 100; 21905 } 21906 h *= 360; 21907 var R, G, B, X, C; 21908 h = h % 360 / 60; 21909 C = 2 * s * (l < .5 ? l : 1 - l); 21910 X = C * (1 - abs(h % 2 - 1)); 21911 R = G = B = l - C / 2; 21912 21913 h = ~~h; 21914 R += [C, X, 0, 0, X, C][h]; 21915 G += [X, C, C, X, 0, 0][h]; 21916 B += [0, 0, X, C, C, X][h]; 21917 return packageRGB(R, G, B, o); 21918}; 21919/*\ 21920 * Snap.rgb2hsb 21921 [ method ] 21922 ** 21923 * Converts RGB values to an HSB object 21924 - r (number) red 21925 - g (number) green 21926 - b (number) blue 21927 = (object) HSB object in the following format: 21928 o { 21929 o h (number) hue, 21930 o s (number) saturation, 21931 o b (number) brightness 21932 o } 21933\*/ 21934Snap.rgb2hsb = function (r, g, b) { 21935 b = prepareRGB(r, g, b); 21936 r = b[0]; 21937 g = b[1]; 21938 b = b[2]; 21939 21940 var H, S, V, C; 21941 V = mmax(r, g, b); 21942 C = V - mmin(r, g, b); 21943 H = C == 0 ? null : 21944 V == r ? (g - b) / C : 21945 V == g ? (b - r) / C + 2 : 21946 (r - g) / C + 4; 21947 H = (H + 360) % 6 * 60 / 360; 21948 S = C == 0 ? 0 : C / V; 21949 return {h: H, s: S, b: V, toString: hsbtoString}; 21950}; 21951/*\ 21952 * Snap.rgb2hsl 21953 [ method ] 21954 ** 21955 * Converts RGB values to an HSL object 21956 - r (number) red 21957 - g (number) green 21958 - b (number) blue 21959 = (object) HSL object in the following format: 21960 o { 21961 o h (number) hue, 21962 o s (number) saturation, 21963 o l (number) luminosity 21964 o } 21965\*/ 21966Snap.rgb2hsl = function (r, g, b) { 21967 b = prepareRGB(r, g, b); 21968 r = b[0]; 21969 g = b[1]; 21970 b = b[2]; 21971 21972 var H, S, L, M, m, C; 21973 M = mmax(r, g, b); 21974 m = mmin(r, g, b); 21975 C = M - m; 21976 H = C == 0 ? null : 21977 M == r ? (g - b) / C : 21978 M == g ? (b - r) / C + 2 : 21979 (r - g) / C + 4; 21980 H = (H + 360) % 6 * 60 / 360; 21981 L = (M + m) / 2; 21982 S = C == 0 ? 0 : 21983 L < .5 ? C / (2 * L) : 21984 C / (2 - 2 * L); 21985 return {h: H, s: S, l: L, toString: hsltoString}; 21986}; 21987 21988// Transformations 21989/*\ 21990 * Snap.parsePathString 21991 [ method ] 21992 ** 21993 * Utility method 21994 ** 21995 * Parses given path string into an array of arrays of path segments 21996 - pathString (string|array) path string or array of segments (in the last case it is returned straight away) 21997 = (array) array of segments 21998\*/ 21999Snap.parsePathString = function (pathString) { 22000 if (!pathString) { 22001 return null; 22002 } 22003 var pth = Snap.path(pathString); 22004 if (pth.arr) { 22005 return Snap.path.clone(pth.arr); 22006 } 22007 22008 var paramCounts = {a: 7, c: 6, o: 2, h: 1, l: 2, m: 2, r: 4, q: 4, s: 4, t: 2, v: 1, u: 3, z: 0}, 22009 data = []; 22010 if (is(pathString, "array") && is(pathString[0], "array")) { // rough assumption 22011 data = Snap.path.clone(pathString); 22012 } 22013 if (!data.length) { 22014 Str(pathString).replace(pathCommand, function (a, b, c) { 22015 var params = [], 22016 name = b.toLowerCase(); 22017 c.replace(pathValues, function (a, b) { 22018 b && params.push(+b); 22019 }); 22020 if (name == "m" && params.length > 2) { 22021 data.push([b].concat(params.splice(0, 2))); 22022 name = "l"; 22023 b = b == "m" ? "l" : "L"; 22024 } 22025 if (name == "o" && params.length == 1) { 22026 data.push([b, params[0]]); 22027 } 22028 if (name == "r") { 22029 data.push([b].concat(params)); 22030 } else while (params.length >= paramCounts[name]) { 22031 data.push([b].concat(params.splice(0, paramCounts[name]))); 22032 if (!paramCounts[name]) { 22033 break; 22034 } 22035 } 22036 }); 22037 } 22038 data.toString = Snap.path.toString; 22039 pth.arr = Snap.path.clone(data); 22040 return data; 22041}; 22042/*\ 22043 * Snap.parseTransformString 22044 [ method ] 22045 ** 22046 * Utility method 22047 ** 22048 * Parses given transform string into an array of transformations 22049 - TString (string|array) transform string or array of transformations (in the last case it is returned straight away) 22050 = (array) array of transformations 22051\*/ 22052var parseTransformString = Snap.parseTransformString = function (TString) { 22053 if (!TString) { 22054 return null; 22055 } 22056 var paramCounts = {r: 3, s: 4, t: 2, m: 6}, 22057 data = []; 22058 if (is(TString, "array") && is(TString[0], "array")) { // rough assumption 22059 data = Snap.path.clone(TString); 22060 } 22061 if (!data.length) { 22062 Str(TString).replace(tCommand, function (a, b, c) { 22063 var params = [], 22064 name = b.toLowerCase(); 22065 c.replace(pathValues, function (a, b) { 22066 b && params.push(+b); 22067 }); 22068 data.push([b].concat(params)); 22069 }); 22070 } 22071 data.toString = Snap.path.toString; 22072 return data; 22073}; 22074function svgTransform2string(tstr) { 22075 var res = []; 22076 tstr = tstr.replace(/(?:^|\s)(\w+)\(([^)]+)\)/g, function (all, name, params) { 22077 params = params.split(/\s*,\s*|\s+/); 22078 if (name == "rotate" && params.length == 1) { 22079 params.push(0, 0); 22080 } 22081 if (name == "scale") { 22082 if (params.length > 2) { 22083 params = params.slice(0, 2); 22084 } else if (params.length == 2) { 22085 params.push(0, 0); 22086 } 22087 if (params.length == 1) { 22088 params.push(params[0], 0, 0); 22089 } 22090 } 22091 if (name == "skewX") { 22092 res.push(["m", 1, 0, math.tan(rad(params[0])), 1, 0, 0]); 22093 } else if (name == "skewY") { 22094 res.push(["m", 1, math.tan(rad(params[0])), 0, 1, 0, 0]); 22095 } else { 22096 res.push([name.charAt(0)].concat(params)); 22097 } 22098 return all; 22099 }); 22100 return res; 22101} 22102Snap._.svgTransform2string = svgTransform2string; 22103Snap._.rgTransform = /^[a-z][\s]*-?\.?\d/i; 22104function transform2matrix(tstr, bbox) { 22105 var tdata = parseTransformString(tstr), 22106 m = new Snap.Matrix; 22107 if (tdata) { 22108 for (var i = 0, ii = tdata.length; i < ii; i++) { 22109 var t = tdata[i], 22110 tlen = t.length, 22111 command = Str(t[0]).toLowerCase(), 22112 absolute = t[0] != command, 22113 inver = absolute ? m.invert() : 0, 22114 x1, 22115 y1, 22116 x2, 22117 y2, 22118 bb; 22119 if (command == "t" && tlen == 2){ 22120 m.translate(t[1], 0); 22121 } else if (command == "t" && tlen == 3) { 22122 if (absolute) { 22123 x1 = inver.x(0, 0); 22124 y1 = inver.y(0, 0); 22125 x2 = inver.x(t[1], t[2]); 22126 y2 = inver.y(t[1], t[2]); 22127 m.translate(x2 - x1, y2 - y1); 22128 } else { 22129 m.translate(t[1], t[2]); 22130 } 22131 } else if (command == "r") { 22132 if (tlen == 2) { 22133 bb = bb || bbox; 22134 m.rotate(t[1], bb.x + bb.width / 2, bb.y + bb.height / 2); 22135 } else if (tlen == 4) { 22136 if (absolute) { 22137 x2 = inver.x(t[2], t[3]); 22138 y2 = inver.y(t[2], t[3]); 22139 m.rotate(t[1], x2, y2); 22140 } else { 22141 m.rotate(t[1], t[2], t[3]); 22142 } 22143 } 22144 } else if (command == "s") { 22145 if (tlen == 2 || tlen == 3) { 22146 bb = bb || bbox; 22147 m.scale(t[1], t[tlen - 1], bb.x + bb.width / 2, bb.y + bb.height / 2); 22148 } else if (tlen == 4) { 22149 if (absolute) { 22150 x2 = inver.x(t[2], t[3]); 22151 y2 = inver.y(t[2], t[3]); 22152 m.scale(t[1], t[1], x2, y2); 22153 } else { 22154 m.scale(t[1], t[1], t[2], t[3]); 22155 } 22156 } else if (tlen == 5) { 22157 if (absolute) { 22158 x2 = inver.x(t[3], t[4]); 22159 y2 = inver.y(t[3], t[4]); 22160 m.scale(t[1], t[2], x2, y2); 22161 } else { 22162 m.scale(t[1], t[2], t[3], t[4]); 22163 } 22164 } 22165 } else if (command == "m" && tlen == 7) { 22166 m.add(t[1], t[2], t[3], t[4], t[5], t[6]); 22167 } 22168 } 22169 } 22170 return m; 22171} 22172Snap._.transform2matrix = transform2matrix; 22173Snap._unit2px = unit2px; 22174var contains = glob.doc.contains || glob.doc.compareDocumentPosition ? 22175 function (a, b) { 22176 var adown = a.nodeType == 9 ? a.documentElement : a, 22177 bup = b && b.parentNode; 22178 return a == bup || !!(bup && bup.nodeType == 1 && ( 22179 adown.contains ? 22180 adown.contains(bup) : 22181 a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16 22182 )); 22183 } : 22184 function (a, b) { 22185 if (b) { 22186 while (b) { 22187 b = b.parentNode; 22188 if (b == a) { 22189 return true; 22190 } 22191 } 22192 } 22193 return false; 22194 }; 22195function getSomeDefs(el) { 22196 var p = el.node.ownerSVGElement && wrap(el.node.ownerSVGElement) || 22197 el.node.parentNode && wrap(el.node.parentNode) || 22198 Snap.select("svg") || 22199 Snap(0, 0), 22200 pdefs = p.select("defs"), 22201 defs = pdefs == null ? false : pdefs.node; 22202 if (!defs) { 22203 defs = make("defs", p.node).node; 22204 } 22205 return defs; 22206} 22207function getSomeSVG(el) { 22208 return el.node.ownerSVGElement && wrap(el.node.ownerSVGElement) || Snap.select("svg"); 22209} 22210Snap._.getSomeDefs = getSomeDefs; 22211Snap._.getSomeSVG = getSomeSVG; 22212function unit2px(el, name, value) { 22213 var svg = getSomeSVG(el).node, 22214 out = {}, 22215 mgr = svg.querySelector(".svg---mgr"); 22216 if (!mgr) { 22217 mgr = $("rect"); 22218 $(mgr, {x: -9e9, y: -9e9, width: 10, height: 10, "class": "svg---mgr", fill: "none"}); 22219 svg.appendChild(mgr); 22220 } 22221 function getW(val) { 22222 if (val == null) { 22223 return E; 22224 } 22225 if (val == +val) { 22226 return val; 22227 } 22228 $(mgr, {width: val}); 22229 try { 22230 return mgr.getBBox().width; 22231 } catch (e) { 22232 return 0; 22233 } 22234 } 22235 function getH(val) { 22236 if (val == null) { 22237 return E; 22238 } 22239 if (val == +val) { 22240 return val; 22241 } 22242 $(mgr, {height: val}); 22243 try { 22244 return mgr.getBBox().height; 22245 } catch (e) { 22246 return 0; 22247 } 22248 } 22249 function set(nam, f) { 22250 if (name == null) { 22251 out[nam] = f(el.attr(nam) || 0); 22252 } else if (nam == name) { 22253 out = f(value == null ? el.attr(nam) || 0 : value); 22254 } 22255 } 22256 switch (el.type) { 22257 case "rect": 22258 set("rx", getW); 22259 set("ry", getH); 22260 case "image": 22261 set("width", getW); 22262 set("height", getH); 22263 case "text": 22264 set("x", getW); 22265 set("y", getH); 22266 break; 22267 case "circle": 22268 set("cx", getW); 22269 set("cy", getH); 22270 set("r", getW); 22271 break; 22272 case "ellipse": 22273 set("cx", getW); 22274 set("cy", getH); 22275 set("rx", getW); 22276 set("ry", getH); 22277 break; 22278 case "line": 22279 set("x1", getW); 22280 set("x2", getW); 22281 set("y1", getH); 22282 set("y2", getH); 22283 break; 22284 case "marker": 22285 set("refX", getW); 22286 set("markerWidth", getW); 22287 set("refY", getH); 22288 set("markerHeight", getH); 22289 break; 22290 case "radialGradient": 22291 set("fx", getW); 22292 set("fy", getH); 22293 break; 22294 case "tspan": 22295 set("dx", getW); 22296 set("dy", getH); 22297 break; 22298 default: 22299 set(name, getW); 22300 } 22301 svg.removeChild(mgr); 22302 return out; 22303} 22304/*\ 22305 * Snap.select 22306 [ method ] 22307 ** 22308 * Wraps a DOM element specified by CSS selector as @Element 22309 - query (string) CSS selector of the element 22310 = (Element) the current element 22311\*/ 22312Snap.select = function (query) { 22313 query = Str(query).replace(/([^\\]):/g, "$1\\:"); 22314 return wrap(glob.doc.querySelector(query)); 22315}; 22316/*\ 22317 * Snap.selectAll 22318 [ method ] 22319 ** 22320 * Wraps DOM elements specified by CSS selector as set or array of @Element 22321 - query (string) CSS selector of the element 22322 = (Element) the current element 22323\*/ 22324Snap.selectAll = function (query) { 22325 var nodelist = glob.doc.querySelectorAll(query), 22326 set = (Snap.set || Array)(); 22327 for (var i = 0; i < nodelist.length; i++) { 22328 set.push(wrap(nodelist[i])); 22329 } 22330 return set; 22331}; 22332 22333function add2group(list) { 22334 if (!is(list, "array")) { 22335 list = Array.prototype.slice.call(arguments, 0); 22336 } 22337 var i = 0, 22338 j = 0, 22339 node = this.node; 22340 while (this[i]) delete this[i++]; 22341 for (i = 0; i < list.length; i++) { 22342 if (list[i].type == "set") { 22343 list[i].forEach(function (el) { 22344 node.appendChild(el.node); 22345 }); 22346 } else { 22347 node.appendChild(list[i].node); 22348 } 22349 } 22350 var children = node.childNodes; 22351 for (i = 0; i < children.length; i++) { 22352 this[j++] = wrap(children[i]); 22353 } 22354 return this; 22355} 22356// Hub garbage collector every 10s 22357setInterval(function () { 22358 for (var key in hub) if (hub[has](key)) { 22359 var el = hub[key], 22360 node = el.node; 22361 if (el.type != "svg" && !node.ownerSVGElement || el.type == "svg" && (!node.parentNode || "ownerSVGElement" in node.parentNode && !node.ownerSVGElement)) { 22362 delete hub[key]; 22363 } 22364 } 22365}, 1e4); 22366function Element(el) { 22367 if (el.snap in hub) { 22368 return hub[el.snap]; 22369 } 22370 var svg; 22371 try { 22372 svg = el.ownerSVGElement; 22373 } catch(e) {} 22374 /*\ 22375 * Element.node 22376 [ property (object) ] 22377 ** 22378 * Gives you a reference to the DOM object, so you can assign event handlers or just mess around. 22379 > Usage 22380 | // draw a circle at coordinate 10,10 with radius of 10 22381 | var c = paper.circle(10, 10, 10); 22382 | c.node.onclick = function () { 22383 | c.attr("fill", "red"); 22384 | }; 22385 \*/ 22386 this.node = el; 22387 if (svg) { 22388 this.paper = new Paper(svg); 22389 } 22390 /*\ 22391 * Element.type 22392 [ property (string) ] 22393 ** 22394 * SVG tag name of the given element. 22395 \*/ 22396 this.type = el.tagName || el.nodeName; 22397 var id = this.id = ID(this); 22398 this.anims = {}; 22399 this._ = { 22400 transform: [] 22401 }; 22402 el.snap = id; 22403 hub[id] = this; 22404 if (this.type == "g") { 22405 this.add = add2group; 22406 } 22407 if (this.type in {g: 1, mask: 1, pattern: 1, symbol: 1}) { 22408 for (var method in Paper.prototype) if (Paper.prototype[has](method)) { 22409 this[method] = Paper.prototype[method]; 22410 } 22411 } 22412} 22413 /*\ 22414 * Element.attr 22415 [ method ] 22416 ** 22417 * Gets or sets given attributes of the element. 22418 ** 22419 - params (object) contains key-value pairs of attributes you want to set 22420 * or 22421 - param (string) name of the attribute 22422 = (Element) the current element 22423 * or 22424 = (string) value of attribute 22425 > Usage 22426 | el.attr({ 22427 | fill: "#fc0", 22428 | stroke: "#000", 22429 | strokeWidth: 2, // CamelCase... 22430 | "fill-opacity": 0.5, // or dash-separated names 22431 | width: "*=2" // prefixed values 22432 | }); 22433 | console.log(el.attr("fill")); // #fc0 22434 * Prefixed values in format `"+=10"` supported. All four operations 22435 * (`+`, `-`, `*` and `/`) could be used. Optionally you can use units for `+` 22436 * and `-`: `"+=2em"`. 22437 \*/ 22438 Element.prototype.attr = function (params, value) { 22439 var el = this, 22440 node = el.node; 22441 if (!params) { 22442 if (node.nodeType != 1) { 22443 return { 22444 text: node.nodeValue 22445 }; 22446 } 22447 var attr = node.attributes, 22448 out = {}; 22449 for (var i = 0, ii = attr.length; i < ii; i++) { 22450 out[attr[i].nodeName] = attr[i].nodeValue; 22451 } 22452 return out; 22453 } 22454 if (is(params, "string")) { 22455 if (arguments.length > 1) { 22456 var json = {}; 22457 json[params] = value; 22458 params = json; 22459 } else { 22460 return eve("snap.util.getattr." + params, el).firstDefined(); 22461 } 22462 } 22463 for (var att in params) { 22464 if (params[has](att)) { 22465 eve("snap.util.attr." + att, el, params[att]); 22466 } 22467 } 22468 return el; 22469 }; 22470/*\ 22471 * Snap.parse 22472 [ method ] 22473 ** 22474 * Parses SVG fragment and converts it into a @Fragment 22475 ** 22476 - svg (string) SVG string 22477 = (Fragment) the @Fragment 22478\*/ 22479Snap.parse = function (svg) { 22480 var f = glob.doc.createDocumentFragment(), 22481 full = true, 22482 div = glob.doc.createElement("div"); 22483 svg = Str(svg); 22484 if (!svg.match(/^\s*<\s*svg(?:\s|>)/)) { 22485 svg = "<svg>" + svg + "</svg>"; 22486 full = false; 22487 } 22488 div.innerHTML = svg; 22489 svg = div.getElementsByTagName("svg")[0]; 22490 if (svg) { 22491 if (full) { 22492 f = svg; 22493 } else { 22494 while (svg.firstChild) { 22495 f.appendChild(svg.firstChild); 22496 } 22497 } 22498 } 22499 return new Fragment(f); 22500}; 22501function Fragment(frag) { 22502 this.node = frag; 22503} 22504/*\ 22505 * Snap.fragment 22506 [ method ] 22507 ** 22508 * Creates a DOM fragment from a given list of elements or strings 22509 ** 22510 - varargs (â¦) SVG string 22511 = (Fragment) the @Fragment 22512\*/ 22513Snap.fragment = function () { 22514 var args = Array.prototype.slice.call(arguments, 0), 22515 f = glob.doc.createDocumentFragment(); 22516 for (var i = 0, ii = args.length; i < ii; i++) { 22517 var item = args[i]; 22518 if (item.node && item.node.nodeType) { 22519 f.appendChild(item.node); 22520 } 22521 if (item.nodeType) { 22522 f.appendChild(item); 22523 } 22524 if (typeof item == "string") { 22525 f.appendChild(Snap.parse(item).node); 22526 } 22527 } 22528 return new Fragment(f); 22529}; 22530 22531function make(name, parent) { 22532 var res = $(name); 22533 parent.appendChild(res); 22534 var el = wrap(res); 22535 return el; 22536} 22537function Paper(w, h) { 22538 var res, 22539 desc, 22540 defs, 22541 proto = Paper.prototype; 22542 if (w && w.tagName && w.tagName.toLowerCase() == "svg") { 22543 if (w.snap in hub) { 22544 return hub[w.snap]; 22545 } 22546 var doc = w.ownerDocument; 22547 res = new Element(w); 22548 desc = w.getElementsByTagName("desc")[0]; 22549 defs = w.getElementsByTagName("defs")[0]; 22550 if (!desc) { 22551 desc = $("desc"); 22552 desc.appendChild(doc.createTextNode("Created with Snap")); 22553 res.node.appendChild(desc); 22554 } 22555 if (!defs) { 22556 defs = $("defs"); 22557 res.node.appendChild(defs); 22558 } 22559 res.defs = defs; 22560 for (var key in proto) if (proto[has](key)) { 22561 res[key] = proto[key]; 22562 } 22563 res.paper = res.root = res; 22564 } else { 22565 res = make("svg", glob.doc.body); 22566 $(res.node, { 22567 height: h, 22568 version: 1.1, 22569 width: w, 22570 xmlns: xmlns 22571 }); 22572 } 22573 return res; 22574} 22575function wrap(dom) { 22576 if (!dom) { 22577 return dom; 22578 } 22579 if (dom instanceof Element || dom instanceof Fragment) { 22580 return dom; 22581 } 22582 if (dom.tagName && dom.tagName.toLowerCase() == "svg") { 22583 return new Paper(dom); 22584 } 22585 if (dom.tagName && dom.tagName.toLowerCase() == "object" && dom.type == "image/svg+xml") { 22586 return new Paper(dom.contentDocument.getElementsByTagName("svg")[0]); 22587 } 22588 return new Element(dom); 22589} 22590 22591Snap._.make = make; 22592Snap._.wrap = wrap; 22593/*\ 22594 * Paper.el 22595 [ method ] 22596 ** 22597 * Creates an element on paper with a given name and no attributes 22598 ** 22599 - name (string) tag name 22600 - attr (object) attributes 22601 = (Element) the current element 22602 > Usage 22603 | var c = paper.circle(10, 10, 10); // is the same as... 22604 | var c = paper.el("circle").attr({ 22605 | cx: 10, 22606 | cy: 10, 22607 | r: 10 22608 | }); 22609 | // and the same as 22610 | var c = paper.el("circle", { 22611 | cx: 10, 22612 | cy: 10, 22613 | r: 10 22614 | }); 22615\*/ 22616Paper.prototype.el = function (name, attr) { 22617 var el = make(name, this.node); 22618 attr && el.attr(attr); 22619 return el; 22620}; 22621/*\ 22622 * Element.children 22623 [ method ] 22624 ** 22625 * Returns array of all the children of the element. 22626 = (array) array of Elements 22627\*/ 22628Element.prototype.children = function () { 22629 var out = [], 22630 ch = this.node.childNodes; 22631 for (var i = 0, ii = ch.length; i < ii; i++) { 22632 out[i] = Snap(ch[i]); 22633 } 22634 return out; 22635}; 22636function jsonFiller(root, o) { 22637 for (var i = 0, ii = root.length; i < ii; i++) { 22638 var item = { 22639 type: root[i].type, 22640 attr: root[i].attr() 22641 }, 22642 children = root[i].children(); 22643 o.push(item); 22644 if (children.length) { 22645 jsonFiller(children, item.childNodes = []); 22646 } 22647 } 22648} 22649/*\ 22650 * Element.toJSON 22651 [ method ] 22652 ** 22653 * Returns object representation of the given element and all its children. 22654 = (object) in format 22655 o { 22656 o type (string) this.type, 22657 o attr (object) attributes map, 22658 o childNodes (array) optional array of children in the same format 22659 o } 22660\*/ 22661Element.prototype.toJSON = function () { 22662 var out = []; 22663 jsonFiller([this], out); 22664 return out[0]; 22665}; 22666// default 22667eve.on("snap.util.getattr", function () { 22668 var att = eve.nt(); 22669 att = att.substring(att.lastIndexOf(".") + 1); 22670 var css = att.replace(/[A-Z]/g, function (letter) { 22671 return "-" + letter.toLowerCase(); 22672 }); 22673 if (cssAttr[has](css)) { 22674 return this.node.ownerDocument.defaultView.getComputedStyle(this.node, null).getPropertyValue(css); 22675 } else { 22676 return $(this.node, att); 22677 } 22678}); 22679var cssAttr = { 22680 "alignment-baseline": 0, 22681 "baseline-shift": 0, 22682 "clip": 0, 22683 "clip-path": 0, 22684 "clip-rule": 0, 22685 "color": 0, 22686 "color-interpolation": 0, 22687 "color-interpolation-filters": 0, 22688 "color-profile": 0, 22689 "color-rendering": 0, 22690 "cursor": 0, 22691 "direction": 0, 22692 "display": 0, 22693 "dominant-baseline": 0, 22694 "enable-background": 0, 22695 "fill": 0, 22696 "fill-opacity": 0, 22697 "fill-rule": 0, 22698 "filter": 0, 22699 "flood-color": 0, 22700 "flood-opacity": 0, 22701 "font": 0, 22702 "font-family": 0, 22703 "font-size": 0, 22704 "font-size-adjust": 0, 22705 "font-stretch": 0, 22706 "font-style": 0, 22707 "font-variant": 0, 22708 "font-weight": 0, 22709 "glyph-orientation-horizontal": 0, 22710 "glyph-orientation-vertical": 0, 22711 "image-rendering": 0, 22712 "kerning": 0, 22713 "letter-spacing": 0, 22714 "lighting-color": 0, 22715 "marker": 0, 22716 "marker-end": 0, 22717 "marker-mid": 0, 22718 "marker-start": 0, 22719 "mask": 0, 22720 "opacity": 0, 22721 "overflow": 0, 22722 "pointer-events": 0, 22723 "shape-rendering": 0, 22724 "stop-color": 0, 22725 "stop-opacity": 0, 22726 "stroke": 0, 22727 "stroke-dasharray": 0, 22728 "stroke-dashoffset": 0, 22729 "stroke-linecap": 0, 22730 "stroke-linejoin": 0, 22731 "stroke-miterlimit": 0, 22732 "stroke-opacity": 0, 22733 "stroke-width": 0, 22734 "text-anchor": 0, 22735 "text-decoration": 0, 22736 "text-rendering": 0, 22737 "unicode-bidi": 0, 22738 "visibility": 0, 22739 "word-spacing": 0, 22740 "writing-mode": 0 22741}; 22742 22743eve.on("snap.util.attr", function (value) { 22744 var att = eve.nt(), 22745 attr = {}; 22746 att = att.substring(att.lastIndexOf(".") + 1); 22747 attr[att] = value; 22748 var style = att.replace(/-(\w)/gi, function (all, letter) { 22749 return letter.toUpperCase(); 22750 }), 22751 css = att.replace(/[A-Z]/g, function (letter) { 22752 return "-" + letter.toLowerCase(); 22753 }); 22754 if (cssAttr[has](css)) { 22755 this.node.style[style] = value == null ? E : value; 22756 } else { 22757 $(this.node, attr); 22758 } 22759}); 22760(function (proto) {}(Paper.prototype)); 22761 22762// simple ajax 22763/*\ 22764 * Snap.ajax 22765 [ method ] 22766 ** 22767 * Simple implementation of Ajax 22768 ** 22769 - url (string) URL 22770 - postData (object|string) data for post request 22771 - callback (function) callback 22772 - scope (object) #optional scope of callback 22773 * or 22774 - url (string) URL 22775 - callback (function) callback 22776 - scope (object) #optional scope of callback 22777 = (XMLHttpRequest) the XMLHttpRequest object, just in case 22778\*/ 22779Snap.ajax = function (url, postData, callback, scope){ 22780 var req = new XMLHttpRequest, 22781 id = ID(); 22782 if (req) { 22783 if (is(postData, "function")) { 22784 scope = callback; 22785 callback = postData; 22786 postData = null; 22787 } else if (is(postData, "object")) { 22788 var pd = []; 22789 for (var key in postData) if (postData.hasOwnProperty(key)) { 22790 pd.push(encodeURIComponent(key) + "=" + encodeURIComponent(postData[key])); 22791 } 22792 postData = pd.join("&"); 22793 } 22794 req.open(postData ? "POST" : "GET", url, true); 22795 if (postData) { 22796 req.setRequestHeader("X-Requested-With", "XMLHttpRequest"); 22797 req.setRequestHeader("Content-type", "application/x-www-form-urlencoded"); 22798 } 22799 if (callback) { 22800 eve.once("snap.ajax." + id + ".0", callback); 22801 eve.once("snap.ajax." + id + ".200", callback); 22802 eve.once("snap.ajax." + id + ".304", callback); 22803 } 22804 req.onreadystatechange = function() { 22805 if (req.readyState != 4) return; 22806 eve("snap.ajax." + id + "." + req.status, scope, req); 22807 }; 22808 if (req.readyState == 4) { 22809 return req; 22810 } 22811 req.send(postData); 22812 return req; 22813 } 22814}; 22815/*\ 22816 * Snap.load 22817 [ method ] 22818 ** 22819 * Loads external SVG file as a @Fragment (see @Snap.ajax for more advanced AJAX) 22820 ** 22821 - url (string) URL 22822 - callback (function) callback 22823 - scope (object) #optional scope of callback 22824\*/ 22825Snap.load = function (url, callback, scope) { 22826 Snap.ajax(url, function (req) { 22827 var f = Snap.parse(req.responseText); 22828 scope ? callback.call(scope, f) : callback(f); 22829 }); 22830}; 22831var getOffset = function (elem) { 22832 var box = elem.getBoundingClientRect(), 22833 doc = elem.ownerDocument, 22834 body = doc.body, 22835 docElem = doc.documentElement, 22836 clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0, 22837 top = box.top + (g.win.pageYOffset || docElem.scrollTop || body.scrollTop ) - clientTop, 22838 left = box.left + (g.win.pageXOffset || docElem.scrollLeft || body.scrollLeft) - clientLeft; 22839 return { 22840 y: top, 22841 x: left 22842 }; 22843}; 22844/*\ 22845 * Snap.getElementByPoint 22846 [ method ] 22847 ** 22848 * Returns you topmost element under given point. 22849 ** 22850 = (object) Snap element object 22851 - x (number) x coordinate from the top left corner of the window 22852 - y (number) y coordinate from the top left corner of the window 22853 > Usage 22854 | Snap.getElementByPoint(mouseX, mouseY).attr({stroke: "#f00"}); 22855\*/ 22856Snap.getElementByPoint = function (x, y) { 22857 var paper = this, 22858 svg = paper.canvas, 22859 target = glob.doc.elementFromPoint(x, y); 22860 if (glob.win.opera && target.tagName == "svg") { 22861 var so = getOffset(target), 22862 sr = target.createSVGRect(); 22863 sr.x = x - so.x; 22864 sr.y = y - so.y; 22865 sr.width = sr.height = 1; 22866 var hits = target.getIntersectionList(sr, null); 22867 if (hits.length) { 22868 target = hits[hits.length - 1]; 22869 } 22870 } 22871 if (!target) { 22872 return null; 22873 } 22874 return wrap(target); 22875}; 22876/*\ 22877 * Snap.plugin 22878 [ method ] 22879 ** 22880 * Let you write plugins. You pass in a function with five arguments, like this: 22881 | Snap.plugin(function (Snap, Element, Paper, global, Fragment) { 22882 | Snap.newmethod = function () {}; 22883 | Element.prototype.newmethod = function () {}; 22884 | Paper.prototype.newmethod = function () {}; 22885 | }); 22886 * Inside the function you have access to all main objects (and their 22887 * prototypes). This allow you to extend anything you want. 22888 ** 22889 - f (function) your plugin body 22890\*/ 22891Snap.plugin = function (f) { 22892 f(Snap, Element, Paper, glob, Fragment); 22893}; 22894glob.win.Snap = Snap; 22895return Snap; 22896}(window || this)); 22897 22898// Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved. 22899// 22900// Licensed under the Apache License, Version 2.0 (the "License"); 22901// you may not use this file except in compliance with the License. 22902// You may obtain a copy of the License at 22903// 22904// http://www.apache.org/licenses/LICENSE-2.0 22905// 22906// Unless required by applicable law or agreed to in writing, software 22907// distributed under the License is distributed on an "AS IS" BASIS, 22908// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 22909// See the License for the specific language governing permissions and 22910// limitations under the License. 22911Snap.plugin(function (Snap, Element, Paper, glob, Fragment) { 22912 var elproto = Element.prototype, 22913 is = Snap.is, 22914 Str = String, 22915 unit2px = Snap._unit2px, 22916 $ = Snap._.$, 22917 make = Snap._.make, 22918 getSomeDefs = Snap._.getSomeDefs, 22919 has = "hasOwnProperty", 22920 wrap = Snap._.wrap; 22921 /*\ 22922 * Element.getBBox 22923 [ method ] 22924 ** 22925 * Returns the bounding box descriptor for the given element 22926 ** 22927 = (object) bounding box descriptor: 22928 o { 22929 o cx: (number) x of the center, 22930 o cy: (number) x of the center, 22931 o h: (number) height, 22932 o height: (number) height, 22933 o path: (string) path command for the box, 22934 o r0: (number) radius of a circle that fully encloses the box, 22935 o r1: (number) radius of the smallest circle that can be enclosed, 22936 o r2: (number) radius of the largest circle that can be enclosed, 22937 o vb: (string) box as a viewbox command, 22938 o w: (number) width, 22939 o width: (number) width, 22940 o x2: (number) x of the right side, 22941 o x: (number) x of the left side, 22942 o y2: (number) y of the bottom edge, 22943 o y: (number) y of the top edge 22944 o } 22945 \*/ 22946 elproto.getBBox = function (isWithoutTransform) { 22947 if (this.type == "tspan") { 22948 return Snap._.box(this.node.getClientRects().item(0)); 22949 } 22950 if (!Snap.Matrix || !Snap.path) { 22951 return this.node.getBBox(); 22952 } 22953 var el = this, 22954 m = new Snap.Matrix; 22955 if (el.removed) { 22956 return Snap._.box(); 22957 } 22958 while (el.type == "use") { 22959 if (!isWithoutTransform) { 22960 m = m.add(el.transform().localMatrix.translate(el.attr("x") || 0, el.attr("y") || 0)); 22961 } 22962 if (el.original) { 22963 el = el.original; 22964 } else { 22965 var href = el.attr("xlink:href"); 22966 el = el.original = el.node.ownerDocument.getElementById(href.substring(href.indexOf("#") + 1)); 22967 } 22968 } 22969 var _ = el._, 22970 pathfinder = Snap.path.get[el.type] || Snap.path.get.deflt; 22971 try { 22972 if (isWithoutTransform) { 22973 _.bboxwt = pathfinder ? Snap.path.getBBox(el.realPath = pathfinder(el)) : Snap._.box(el.node.getBBox()); 22974 return Snap._.box(_.bboxwt); 22975 } else { 22976 el.realPath = pathfinder(el); 22977 el.matrix = el.transform().localMatrix; 22978 _.bbox = Snap.path.getBBox(Snap.path.map(el.realPath, m.add(el.matrix))); 22979 return Snap._.box(_.bbox); 22980 } 22981 } catch (e) { 22982 // Firefox doesnât give you bbox of hidden element 22983 return Snap._.box(); 22984 } 22985 }; 22986 var propString = function () { 22987 return this.string; 22988 }; 22989 function extractTransform(el, tstr) { 22990 if (tstr == null) { 22991 var doReturn = true; 22992 if (el.type == "linearGradient" || el.type == "radialGradient") { 22993 tstr = el.node.getAttribute("gradientTransform"); 22994 } else if (el.type == "pattern") { 22995 tstr = el.node.getAttribute("patternTransform"); 22996 } else { 22997 tstr = el.node.getAttribute("transform"); 22998 } 22999 if (!tstr) { 23000 return new Snap.Matrix; 23001 } 23002 tstr = Snap._.svgTransform2string(tstr); 23003 } else { 23004 if (!Snap._.rgTransform.test(tstr)) { 23005 tstr = Snap._.svgTransform2string(tstr); 23006 } else { 23007 tstr = Str(tstr).replace(/\.{3}|\u2026/g, el._.transform || ""); 23008 } 23009 if (is(tstr, "array")) { 23010 tstr = Snap.path ? Snap.path.toString.call(tstr) : Str(tstr); 23011 } 23012 el._.transform = tstr; 23013 } 23014 var m = Snap._.transform2matrix(tstr, el.getBBox(1)); 23015 if (doReturn) { 23016 return m; 23017 } else { 23018 el.matrix = m; 23019 } 23020 } 23021 /*\ 23022 * Element.transform 23023 [ method ] 23024 ** 23025 * Gets or sets transformation of the element 23026 ** 23027 - tstr (string) transform string in Snap or SVG format 23028 = (Element) the current element 23029 * or 23030 = (object) transformation descriptor: 23031 o { 23032 o string (string) transform string, 23033 o globalMatrix (Matrix) matrix of all transformations applied to element or its parents, 23034 o localMatrix (Matrix) matrix of transformations applied only to the element, 23035 o diffMatrix (Matrix) matrix of difference between global and local transformations, 23036 o global (string) global transformation as string, 23037 o local (string) local transformation as string, 23038 o toString (function) returns `string` property 23039 o } 23040 \*/ 23041 elproto.transform = function (tstr) { 23042 var _ = this._; 23043 if (tstr == null) { 23044 var papa = this, 23045 global = new Snap.Matrix(this.node.getCTM()), 23046 local = extractTransform(this), 23047 ms = [local], 23048 m = new Snap.Matrix, 23049 i, 23050 localString = local.toTransformString(), 23051 string = Str(local) == Str(this.matrix) ? 23052 Str(_.transform) : localString; 23053 while (papa.type != "svg" && (papa = papa.parent())) { 23054 ms.push(extractTransform(papa)); 23055 } 23056 i = ms.length; 23057 while (i--) { 23058 m.add(ms[i]); 23059 } 23060 return { 23061 string: string, 23062 globalMatrix: global, 23063 totalMatrix: m, 23064 localMatrix: local, 23065 diffMatrix: global.clone().add(local.invert()), 23066 global: global.toTransformString(), 23067 total: m.toTransformString(), 23068 local: localString, 23069 toString: propString 23070 }; 23071 } 23072 if (tstr instanceof Snap.Matrix) { 23073 this.matrix = tstr; 23074 this._.transform = tstr.toTransformString(); 23075 } else { 23076 extractTransform(this, tstr); 23077 } 23078 23079 if (this.node) { 23080 if (this.type == "linearGradient" || this.type == "radialGradient") { 23081 $(this.node, {gradientTransform: this.matrix}); 23082 } else if (this.type == "pattern") { 23083 $(this.node, {patternTransform: this.matrix}); 23084 } else { 23085 $(this.node, {transform: this.matrix}); 23086 } 23087 } 23088 23089 return this; 23090 }; 23091 /*\ 23092 * Element.parent 23093 [ method ] 23094 ** 23095 * Returns the element's parent 23096 ** 23097 = (Element) the parent element 23098 \*/ 23099 elproto.parent = function () { 23100 return wrap(this.node.parentNode); 23101 }; 23102 /*\ 23103 * Element.append 23104 [ method ] 23105 ** 23106 * Appends the given element to current one 23107 ** 23108 - el (Element|Set) element to append 23109 = (Element) the parent element 23110 \*/ 23111 /*\ 23112 * Element.add 23113 [ method ] 23114 ** 23115 * See @Element.append 23116 \*/ 23117 elproto.append = elproto.add = function (el) { 23118 if (el) { 23119 if (el.type == "set") { 23120 var it = this; 23121 el.forEach(function (el) { 23122 it.add(el); 23123 }); 23124 return this; 23125 } 23126 el = wrap(el); 23127 this.node.appendChild(el.node); 23128 el.paper = this.paper; 23129 } 23130 return this; 23131 }; 23132 /*\ 23133 * Element.appendTo 23134 [ method ] 23135 ** 23136 * Appends the current element to the given one 23137 ** 23138 - el (Element) parent element to append to 23139 = (Element) the child element 23140 \*/ 23141 elproto.appendTo = function (el) { 23142 if (el) { 23143 el = wrap(el); 23144 el.append(this); 23145 } 23146 return this; 23147 }; 23148 /*\ 23149 * Element.prepend 23150 [ method ] 23151 ** 23152 * Prepends the given element to the current one 23153 ** 23154 - el (Element) element to prepend 23155 = (Element) the parent element 23156 \*/ 23157 elproto.prepend = function (el) { 23158 if (el) { 23159 if (el.type == "set") { 23160 var it = this, 23161 first; 23162 el.forEach(function (el) { 23163 if (first) { 23164 first.after(el); 23165 } else { 23166 it.prepend(el); 23167 } 23168 first = el; 23169 }); 23170 return this; 23171 } 23172 el = wrap(el); 23173 var parent = el.parent(); 23174 this.node.insertBefore(el.node, this.node.firstChild); 23175 this.add && this.add(); 23176 el.paper = this.paper; 23177 this.parent() && this.parent().add(); 23178 parent && parent.add(); 23179 } 23180 return this; 23181 }; 23182 /*\ 23183 * Element.prependTo 23184 [ method ] 23185 ** 23186 * Prepends the current element to the given one 23187 ** 23188 - el (Element) parent element to prepend to 23189 = (Element) the child element 23190 \*/ 23191 elproto.prependTo = function (el) { 23192 el = wrap(el); 23193 el.prepend(this); 23194 return this; 23195 }; 23196 /*\ 23197 * Element.before 23198 [ method ] 23199 ** 23200 * Inserts given element before the current one 23201 ** 23202 - el (Element) element to insert 23203 = (Element) the parent element 23204 \*/ 23205 elproto.before = function (el) { 23206 if (el.type == "set") { 23207 var it = this; 23208 el.forEach(function (el) { 23209 var parent = el.parent(); 23210 it.node.parentNode.insertBefore(el.node, it.node); 23211 parent && parent.add(); 23212 }); 23213 this.parent().add(); 23214 return this; 23215 } 23216 el = wrap(el); 23217 var parent = el.parent(); 23218 this.node.parentNode.insertBefore(el.node, this.node); 23219 this.parent() && this.parent().add(); 23220 parent && parent.add(); 23221 el.paper = this.paper; 23222 return this; 23223 }; 23224 /*\ 23225 * Element.after 23226 [ method ] 23227 ** 23228 * Inserts given element after the current one 23229 ** 23230 - el (Element) element to insert 23231 = (Element) the parent element 23232 \*/ 23233 elproto.after = function (el) { 23234 el = wrap(el); 23235 var parent = el.parent(); 23236 if (this.node.nextSibling) { 23237 this.node.parentNode.insertBefore(el.node, this.node.nextSibling); 23238 } else { 23239 this.node.parentNode.appendChild(el.node); 23240 } 23241 this.parent() && this.parent().add(); 23242 parent && parent.add(); 23243 el.paper = this.paper; 23244 return this; 23245 }; 23246 /*\ 23247 * Element.insertBefore 23248 [ method ] 23249 ** 23250 * Inserts the element after the given one 23251 ** 23252 - el (Element) element next to whom insert to 23253 = (Element) the parent element 23254 \*/ 23255 elproto.insertBefore = function (el) { 23256 el = wrap(el); 23257 var parent = this.parent(); 23258 el.node.parentNode.insertBefore(this.node, el.node); 23259 this.paper = el.paper; 23260 parent && parent.add(); 23261 el.parent() && el.parent().add(); 23262 return this; 23263 }; 23264 /*\ 23265 * Element.insertAfter 23266 [ method ] 23267 ** 23268 * Inserts the element after the given one 23269 ** 23270 - el (Element) element next to whom insert to 23271 = (Element) the parent element 23272 \*/ 23273 elproto.insertAfter = function (el) { 23274 el = wrap(el); 23275 var parent = this.parent(); 23276 el.node.parentNode.insertBefore(this.node, el.node.nextSibling); 23277 this.paper = el.paper; 23278 parent && parent.add(); 23279 el.parent() && el.parent().add(); 23280 return this; 23281 }; 23282 /*\ 23283 * Element.remove 23284 [ method ] 23285 ** 23286 * Removes element from the DOM 23287 = (Element) the detached element 23288 \*/ 23289 elproto.remove = function () { 23290 var parent = this.parent(); 23291 this.node.parentNode && this.node.parentNode.removeChild(this.node); 23292 delete this.paper; 23293 this.removed = true; 23294 parent && parent.add(); 23295 return this; 23296 }; 23297 /*\ 23298 * Element.select 23299 [ method ] 23300 ** 23301 * Gathers the nested @Element matching the given set of CSS selectors 23302 ** 23303 - query (string) CSS selector 23304 = (Element) result of query selection 23305 \*/ 23306 elproto.select = function (query) { 23307 return wrap(this.node.querySelector(query)); 23308 }; 23309 /*\ 23310 * Element.selectAll 23311 [ method ] 23312 ** 23313 * Gathers nested @Element objects matching the given set of CSS selectors 23314 ** 23315 - query (string) CSS selector 23316 = (Set|array) result of query selection 23317 \*/ 23318 elproto.selectAll = function (query) { 23319 var nodelist = this.node.querySelectorAll(query), 23320 set = (Snap.set || Array)(); 23321 for (var i = 0; i < nodelist.length; i++) { 23322 set.push(wrap(nodelist[i])); 23323 } 23324 return set; 23325 }; 23326 /*\ 23327 * Element.asPX 23328 [ method ] 23329 ** 23330 * Returns given attribute of the element as a `px` value (not %, em, etc.) 23331 ** 23332 - attr (string) attribute name 23333 - value (string) #optional attribute value 23334 = (Element) result of query selection 23335 \*/ 23336 elproto.asPX = function (attr, value) { 23337 if (value == null) { 23338 value = this.attr(attr); 23339 } 23340 return +unit2px(this, attr, value); 23341 }; 23342 // SIERRA Element.use(): I suggest adding a note about how to access the original element the returned <use> instantiates. It's a part of SVG with which ordinary web developers may be least familiar. 23343 /*\ 23344 * Element.use 23345 [ method ] 23346 ** 23347 * Creates a `<use>` element linked to the current element 23348 ** 23349 = (Element) the `<use>` element 23350 \*/ 23351 elproto.use = function () { 23352 var use, 23353 id = this.node.id; 23354 if (!id) { 23355 id = this.id; 23356 $(this.node, { 23357 id: id 23358 }); 23359 } 23360 if (this.type == "linearGradient" || this.type == "radialGradient" || 23361 this.type == "pattern") { 23362 use = make(this.type, this.node.parentNode); 23363 } else { 23364 use = make("use", this.node.parentNode); 23365 } 23366 $(use.node, { 23367 "xlink:href": "#" + id 23368 }); 23369 use.original = this; 23370 return use; 23371 }; 23372 function fixids(el) { 23373 var els = el.selectAll("*"), 23374 it, 23375 url = /^\s*url\(("|'|)(.*)\1\)\s*$/, 23376 ids = [], 23377 uses = {}; 23378 function urltest(it, name) { 23379 var val = $(it.node, name); 23380 val = val && val.match(url); 23381 val = val && val[2]; 23382 if (val && val.charAt() == "#") { 23383 val = val.substring(1); 23384 } else { 23385 return; 23386 } 23387 if (val) { 23388 uses[val] = (uses[val] || []).concat(function (id) { 23389 var attr = {}; 23390 attr[name] = Snap.url(id); 23391 $(it.node, attr); 23392 }); 23393 } 23394 } 23395 function linktest(it) { 23396 var val = $(it.node, "xlink:href"); 23397 if (val && val.charAt() == "#") { 23398 val = val.substring(1); 23399 } else { 23400 return; 23401 } 23402 if (val) { 23403 uses[val] = (uses[val] || []).concat(function (id) { 23404 it.attr("xlink:href", "#" + id); 23405 }); 23406 } 23407 } 23408 for (var i = 0, ii = els.length; i < ii; i++) { 23409 it = els[i]; 23410 urltest(it, "fill"); 23411 urltest(it, "stroke"); 23412 urltest(it, "filter"); 23413 urltest(it, "mask"); 23414 urltest(it, "clip-path"); 23415 linktest(it); 23416 var oldid = $(it.node, "id"); 23417 if (oldid) { 23418 $(it.node, {id: it.id}); 23419 ids.push({ 23420 old: oldid, 23421 id: it.id 23422 }); 23423 } 23424 } 23425 for (i = 0, ii = ids.length; i < ii; i++) { 23426 var fs = uses[ids[i].old]; 23427 if (fs) { 23428 for (var j = 0, jj = fs.length; j < jj; j++) { 23429 fs[j](ids[i].id); 23430 } 23431 } 23432 } 23433 } 23434 /*\ 23435 * Element.clone 23436 [ method ] 23437 ** 23438 * Creates a clone of the element and inserts it after the element 23439 ** 23440 = (Element) the clone 23441 \*/ 23442 elproto.clone = function () { 23443 var clone = wrap(this.node.cloneNode(true)); 23444 if ($(clone.node, "id")) { 23445 $(clone.node, {id: clone.id}); 23446 } 23447 fixids(clone); 23448 clone.insertAfter(this); 23449 return clone; 23450 }; 23451 /*\ 23452 * Element.toDefs 23453 [ method ] 23454 ** 23455 * Moves element to the shared `<defs>` area 23456 ** 23457 = (Element) the element 23458 \*/ 23459 elproto.toDefs = function () { 23460 var defs = getSomeDefs(this); 23461 defs.appendChild(this.node); 23462 return this; 23463 }; 23464 /*\ 23465 * Element.toPattern 23466 [ method ] 23467 ** 23468 * Creates a `<pattern>` element from the current element 23469 ** 23470 * To create a pattern you have to specify the pattern rect: 23471 - x (string|number) 23472 - y (string|number) 23473 - width (string|number) 23474 - height (string|number) 23475 = (Element) the `<pattern>` element 23476 * You can use pattern later on as an argument for `fill` attribute: 23477 | var p = paper.path("M10-5-10,15M15,0,0,15M0-5-20,15").attr({ 23478 | fill: "none", 23479 | stroke: "#bada55", 23480 | strokeWidth: 5 23481 | }).pattern(0, 0, 10, 10), 23482 | c = paper.circle(200, 200, 100); 23483 | c.attr({ 23484 | fill: p 23485 | }); 23486 \*/ 23487 elproto.pattern = elproto.toPattern = function (x, y, width, height) { 23488 var p = make("pattern", getSomeDefs(this)); 23489 if (x == null) { 23490 x = this.getBBox(); 23491 } 23492 if (is(x, "object") && "x" in x) { 23493 y = x.y; 23494 width = x.width; 23495 height = x.height; 23496 x = x.x; 23497 } 23498 $(p.node, { 23499 x: x, 23500 y: y, 23501 width: width, 23502 height: height, 23503 patternUnits: "userSpaceOnUse", 23504 id: p.id, 23505 viewBox: [x, y, width, height].join(" ") 23506 }); 23507 p.node.appendChild(this.node); 23508 return p; 23509 }; 23510// SIERRA Element.marker(): clarify what a reference point is. E.g., helps you offset the object from its edge such as when centering it over a path. 23511// SIERRA Element.marker(): I suggest the method should accept default reference point values. Perhaps centered with (refX = width/2) and (refY = height/2)? Also, couldn't it assume the element's current _width_ and _height_? And please specify what _x_ and _y_ mean: offsets? If so, from where? Couldn't they also be assigned default values? 23512 /*\ 23513 * Element.marker 23514 [ method ] 23515 ** 23516 * Creates a `<marker>` element from the current element 23517 ** 23518 * To create a marker you have to specify the bounding rect and reference point: 23519 - x (number) 23520 - y (number) 23521 - width (number) 23522 - height (number) 23523 - refX (number) 23524 - refY (number) 23525 = (Element) the `<marker>` element 23526 * You can specify the marker later as an argument for `marker-start`, `marker-end`, `marker-mid`, and `marker` attributes. The `marker` attribute places the marker at every point along the path, and `marker-mid` places them at every point except the start and end. 23527 \*/ 23528 // TODO add usage for markers 23529 elproto.marker = function (x, y, width, height, refX, refY) { 23530 var p = make("marker", getSomeDefs(this)); 23531 if (x == null) { 23532 x = this.getBBox(); 23533 } 23534 if (is(x, "object") && "x" in x) { 23535 y = x.y; 23536 width = x.width; 23537 height = x.height; 23538 refX = x.refX || x.cx; 23539 refY = x.refY || x.cy; 23540 x = x.x; 23541 } 23542 $(p.node, { 23543 viewBox: [x, y, width, height].join(" "), 23544 markerWidth: width, 23545 markerHeight: height, 23546 orient: "auto", 23547 refX: refX || 0, 23548 refY: refY || 0, 23549 id: p.id 23550 }); 23551 p.node.appendChild(this.node); 23552 return p; 23553 }; 23554 var eldata = {}; 23555 /*\ 23556 * Element.data 23557 [ method ] 23558 ** 23559 * Adds or retrieves given value associated with given key. (Donât confuse 23560 * with `data-` attributes) 23561 * 23562 * See also @Element.removeData 23563 - key (string) key to store data 23564 - value (any) #optional value to store 23565 = (object) @Element 23566 * or, if value is not specified: 23567 = (any) value 23568 > Usage 23569 | for (var i = 0, i < 5, i++) { 23570 | paper.circle(10 + 15 * i, 10, 10) 23571 | .attr({fill: "#000"}) 23572 | .data("i", i) 23573 | .click(function () { 23574 | alert(this.data("i")); 23575 | }); 23576 | } 23577 \*/ 23578 elproto.data = function (key, value) { 23579 var data = eldata[this.id] = eldata[this.id] || {}; 23580 if (arguments.length == 0){ 23581 eve("snap.data.get." + this.id, this, data, null); 23582 return data; 23583 } 23584 if (arguments.length == 1) { 23585 if (Snap.is(key, "object")) { 23586 for (var i in key) if (key[has](i)) { 23587 this.data(i, key[i]); 23588 } 23589 return this; 23590 } 23591 eve("snap.data.get." + this.id, this, data[key], key); 23592 return data[key]; 23593 } 23594 data[key] = value; 23595 eve("snap.data.set." + this.id, this, value, key); 23596 return this; 23597 }; 23598 /*\ 23599 * Element.removeData 23600 [ method ] 23601 ** 23602 * Removes value associated with an element by given key. 23603 * If key is not provided, removes all the data of the element. 23604 - key (string) #optional key 23605 = (object) @Element 23606 \*/ 23607 elproto.removeData = function (key) { 23608 if (key == null) { 23609 eldata[this.id] = {}; 23610 } else { 23611 eldata[this.id] && delete eldata[this.id][key]; 23612 } 23613 return this; 23614 }; 23615 /*\ 23616 * Element.outerSVG 23617 [ method ] 23618 ** 23619 * Returns SVG code for the element, equivalent to HTML's `outerHTML`. 23620 * 23621 * See also @Element.innerSVG 23622 = (string) SVG code for the element 23623 \*/ 23624 /*\ 23625 * Element.toString 23626 [ method ] 23627 ** 23628 * See @Element.outerSVG 23629 \*/ 23630 elproto.outerSVG = elproto.toString = toString(1); 23631 /*\ 23632 * Element.innerSVG 23633 [ method ] 23634 ** 23635 * Returns SVG code for the element's contents, equivalent to HTML's `innerHTML` 23636 = (string) SVG code for the element 23637 \*/ 23638 elproto.innerSVG = toString(); 23639 function toString(type) { 23640 return function () { 23641 var res = type ? "<" + this.type : "", 23642 attr = this.node.attributes, 23643 chld = this.node.childNodes; 23644 if (type) { 23645 for (var i = 0, ii = attr.length; i < ii; i++) { 23646 res += " " + attr[i].name + '="' + 23647 attr[i].value.replace(/"/g, '\\"') + '"'; 23648 } 23649 } 23650 if (chld.length) { 23651 type && (res += ">"); 23652 for (i = 0, ii = chld.length; i < ii; i++) { 23653 if (chld[i].nodeType == 3) { 23654 res += chld[i].nodeValue; 23655 } else if (chld[i].nodeType == 1) { 23656 res += wrap(chld[i]).toString(); 23657 } 23658 } 23659 type && (res += "</" + this.type + ">"); 23660 } else { 23661 type && (res += "/>"); 23662 } 23663 return res; 23664 }; 23665 } 23666 elproto.toDataURL = function () { 23667 if (window && window.btoa) { 23668 var bb = this.getBBox(), 23669 svg = Snap.format('<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="{width}" height="{height}" viewBox="{x} {y} {width} {height}">{contents}</svg>', { 23670 x: +bb.x.toFixed(3), 23671 y: +bb.y.toFixed(3), 23672 width: +bb.width.toFixed(3), 23673 height: +bb.height.toFixed(3), 23674 contents: this.outerSVG() 23675 }); 23676 return "data:image/svg+xml;base64," + btoa(unescape(encodeURIComponent(svg))); 23677 } 23678 }; 23679 /*\ 23680 * Fragment.select 23681 [ method ] 23682 ** 23683 * See @Element.select 23684 \*/ 23685 Fragment.prototype.select = elproto.select; 23686 /*\ 23687 * Fragment.selectAll 23688 [ method ] 23689 ** 23690 * See @Element.selectAll 23691 \*/ 23692 Fragment.prototype.selectAll = elproto.selectAll; 23693}); 23694 23695// Copyright (c) 2016 Adobe Systems Incorporated. All rights reserved. 23696// 23697// Licensed under the Apache License, Version 2.0 (the "License"); 23698// you may not use this file except in compliance with the License. 23699// You may obtain a copy of the License at 23700// 23701// http://www.apache.org/licenses/LICENSE-2.0 23702// 23703// Unless required by applicable law or agreed to in writing, software 23704// distributed under the License is distributed on an "AS IS" BASIS, 23705// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 23706// See the License for the specific language governing permissions and 23707// limitations under the License. 23708Snap.plugin(function (Snap, Element, Paper, glob, Fragment) { 23709 var elproto = Element.prototype, 23710 is = Snap.is, 23711 Str = String, 23712 has = "hasOwnProperty"; 23713 function slice(from, to, f) { 23714 return function (arr) { 23715 var res = arr.slice(from, to); 23716 if (res.length == 1) { 23717 res = res[0]; 23718 } 23719 return f ? f(res) : res; 23720 }; 23721 } 23722 var Animation = function (attr, ms, easing, callback) { 23723 if (typeof easing == "function" && !easing.length) { 23724 callback = easing; 23725 easing = mina.linear; 23726 } 23727 this.attr = attr; 23728 this.dur = ms; 23729 easing && (this.easing = easing); 23730 callback && (this.callback = callback); 23731 }; 23732 Snap._.Animation = Animation; 23733 /*\ 23734 * Snap.animation 23735 [ method ] 23736 ** 23737 * Creates an animation object 23738 ** 23739 - attr (object) attributes of final destination 23740 - duration (number) duration of the animation, in milliseconds 23741 - easing (function) #optional one of easing functions of @mina or custom one 23742 - callback (function) #optional callback function that fires when animation ends 23743 = (object) animation object 23744 \*/ 23745 Snap.animation = function (attr, ms, easing, callback) { 23746 return new Animation(attr, ms, easing, callback); 23747 }; 23748 /*\ 23749 * Element.inAnim 23750 [ method ] 23751 ** 23752 * Returns a set of animations that may be able to manipulate the current element 23753 ** 23754 = (object) in format: 23755 o { 23756 o anim (object) animation object, 23757 o mina (object) @mina object, 23758 o curStatus (number) 0..1 â status of the animation: 0 â just started, 1 â just finished, 23759 o status (function) gets or sets the status of the animation, 23760 o stop (function) stops the animation 23761 o } 23762 \*/ 23763 elproto.inAnim = function () { 23764 var el = this, 23765 res = []; 23766 for (var id in el.anims) if (el.anims[has](id)) { 23767 (function (a) { 23768 res.push({ 23769 anim: new Animation(a._attrs, a.dur, a.easing, a._callback), 23770 mina: a, 23771 curStatus: a.status(), 23772 status: function (val) { 23773 return a.status(val); 23774 }, 23775 stop: function () { 23776 a.stop(); 23777 } 23778 }); 23779 }(el.anims[id])); 23780 } 23781 return res; 23782 }; 23783 /*\ 23784 * Snap.animate 23785 [ method ] 23786 ** 23787 * Runs generic animation of one number into another with a caring function 23788 ** 23789 - from (number|array) number or array of numbers 23790 - to (number|array) number or array of numbers 23791 - setter (function) caring function that accepts one number argument 23792 - duration (number) duration, in milliseconds 23793 - easing (function) #optional easing function from @mina or custom 23794 - callback (function) #optional callback function to execute when animation ends 23795 = (object) animation object in @mina format 23796 o { 23797 o id (string) animation id, consider it read-only, 23798 o duration (function) gets or sets the duration of the animation, 23799 o easing (function) easing, 23800 o speed (function) gets or sets the speed of the animation, 23801 o status (function) gets or sets the status of the animation, 23802 o stop (function) stops the animation 23803 o } 23804 | var rect = Snap().rect(0, 0, 10, 10); 23805 | Snap.animate(0, 10, function (val) { 23806 | rect.attr({ 23807 | x: val 23808 | }); 23809 | }, 1000); 23810 | // in given context is equivalent to 23811 | rect.animate({x: 10}, 1000); 23812 \*/ 23813 Snap.animate = function (from, to, setter, ms, easing, callback) { 23814 if (typeof easing == "function" && !easing.length) { 23815 callback = easing; 23816 easing = mina.linear; 23817 } 23818 var now = mina.time(), 23819 anim = mina(from, to, now, now + ms, mina.time, setter, easing); 23820 callback && eve.once("mina.finish." + anim.id, callback); 23821 return anim; 23822 }; 23823 /*\ 23824 * Element.stop 23825 [ method ] 23826 ** 23827 * Stops all the animations for the current element 23828 ** 23829 = (Element) the current element 23830 \*/ 23831 elproto.stop = function () { 23832 var anims = this.inAnim(); 23833 for (var i = 0, ii = anims.length; i < ii; i++) { 23834 anims[i].stop(); 23835 } 23836 return this; 23837 }; 23838 /*\ 23839 * Element.animate 23840 [ method ] 23841 ** 23842 * Animates the given attributes of the element 23843 ** 23844 - attrs (object) key-value pairs of destination attributes 23845 - duration (number) duration of the animation in milliseconds 23846 - easing (function) #optional easing function from @mina or custom 23847 - callback (function) #optional callback function that executes when the animation ends 23848 = (Element) the current element 23849 \*/ 23850 elproto.animate = function (attrs, ms, easing, callback) { 23851 if (typeof easing == "function" && !easing.length) { 23852 callback = easing; 23853 easing = mina.linear; 23854 } 23855 if (attrs instanceof Animation) { 23856 callback = attrs.callback; 23857 easing = attrs.easing; 23858 ms = attrs.dur; 23859 attrs = attrs.attr; 23860 } 23861 var fkeys = [], tkeys = [], keys = {}, from, to, f, eq, 23862 el = this; 23863 for (var key in attrs) if (attrs[has](key)) { 23864 if (el.equal) { 23865 eq = el.equal(key, Str(attrs[key])); 23866 from = eq.from; 23867 to = eq.to; 23868 f = eq.f; 23869 } else { 23870 from = +el.attr(key); 23871 to = +attrs[key]; 23872 } 23873 var len = is(from, "array") ? from.length : 1; 23874 keys[key] = slice(fkeys.length, fkeys.length + len, f); 23875 fkeys = fkeys.concat(from); 23876 tkeys = tkeys.concat(to); 23877 } 23878 var now = mina.time(), 23879 anim = mina(fkeys, tkeys, now, now + ms, mina.time, function (val) { 23880 var attr = {}; 23881 for (var key in keys) if (keys[has](key)) { 23882 attr[key] = keys[key](val); 23883 } 23884 el.attr(attr); 23885 }, easing); 23886 el.anims[anim.id] = anim; 23887 anim._attrs = attrs; 23888 anim._callback = callback; 23889 eve("snap.animcreated." + el.id, anim); 23890 eve.once("mina.finish." + anim.id, function () { 23891 eve.off("mina.*." + anim.id); 23892 delete el.anims[anim.id]; 23893 callback && callback.call(el); 23894 }); 23895 eve.once("mina.stop." + anim.id, function () { 23896 eve.off("mina.*." + anim.id); 23897 delete el.anims[anim.id]; 23898 }); 23899 return el; 23900 }; 23901}); 23902 23903// Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved. 23904// 23905// Licensed under the Apache License, Version 2.0 (the "License"); 23906// you may not use this file except in compliance with the License. 23907// You may obtain a copy of the License at 23908// 23909// http://www.apache.org/licenses/LICENSE-2.0 23910// 23911// Unless required by applicable law or agreed to in writing, software 23912// distributed under the License is distributed on an "AS IS" BASIS, 23913// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 23914// See the License for the specific language governing permissions and 23915// limitations under the License. 23916Snap.plugin(function (Snap, Element, Paper, glob, Fragment) { 23917 var objectToString = Object.prototype.toString, 23918 Str = String, 23919 math = Math, 23920 E = ""; 23921 function Matrix(a, b, c, d, e, f) { 23922 if (b == null && objectToString.call(a) == "[object SVGMatrix]") { 23923 this.a = a.a; 23924 this.b = a.b; 23925 this.c = a.c; 23926 this.d = a.d; 23927 this.e = a.e; 23928 this.f = a.f; 23929 return; 23930 } 23931 if (a != null) { 23932 this.a = +a; 23933 this.b = +b; 23934 this.c = +c; 23935 this.d = +d; 23936 this.e = +e; 23937 this.f = +f; 23938 } else { 23939 this.a = 1; 23940 this.b = 0; 23941 this.c = 0; 23942 this.d = 1; 23943 this.e = 0; 23944 this.f = 0; 23945 } 23946 } 23947 (function (matrixproto) { 23948 /*\ 23949 * Matrix.add 23950 [ method ] 23951 ** 23952 * Adds the given matrix to existing one 23953 - a (number) 23954 - b (number) 23955 - c (number) 23956 - d (number) 23957 - e (number) 23958 - f (number) 23959 * or 23960 - matrix (object) @Matrix 23961 \*/ 23962 matrixproto.add = function (a, b, c, d, e, f) { 23963 if (a && a instanceof Matrix) { 23964 return this.add(a.a, a.b, a.c, a.d, a.e, a.f); 23965 } 23966 var aNew = a * this.a + b * this.c, 23967 bNew = a * this.b + b * this.d; 23968 this.e += e * this.a + f * this.c; 23969 this.f += e * this.b + f * this.d; 23970 this.c = c * this.a + d * this.c; 23971 this.d = c * this.b + d * this.d; 23972 23973 this.a = aNew; 23974 this.b = bNew; 23975 return this; 23976 }; 23977 /*\ 23978 * Matrix.multLeft 23979 [ method ] 23980 ** 23981 * Multiplies a passed affine transform to the left: M * this. 23982 - a (number) 23983 - b (number) 23984 - c (number) 23985 - d (number) 23986 - e (number) 23987 - f (number) 23988 * or 23989 - matrix (object) @Matrix 23990 \*/ 23991 Matrix.prototype.multLeft = function (a, b, c, d, e, f) { 23992 if (a && a instanceof Matrix) { 23993 return this.multLeft(a.a, a.b, a.c, a.d, a.e, a.f); 23994 } 23995 var aNew = a * this.a + c * this.b, 23996 cNew = a * this.c + c * this.d, 23997 eNew = a * this.e + c * this.f + e; 23998 this.b = b * this.a + d * this.b; 23999 this.d = b * this.c + d * this.d; 24000 this.f = b * this.e + d * this.f + f; 24001 24002 this.a = aNew; 24003 this.c = cNew; 24004 this.e = eNew; 24005 return this; 24006 }; 24007 /*\ 24008 * Matrix.invert 24009 [ method ] 24010 ** 24011 * Returns an inverted version of the matrix 24012 = (object) @Matrix 24013 \*/ 24014 matrixproto.invert = function () { 24015 var me = this, 24016 x = me.a * me.d - me.b * me.c; 24017 return new Matrix(me.d / x, -me.b / x, -me.c / x, me.a / x, (me.c * me.f - me.d * me.e) / x, (me.b * me.e - me.a * me.f) / x); 24018 }; 24019 /*\ 24020 * Matrix.clone 24021 [ method ] 24022 ** 24023 * Returns a copy of the matrix 24024 = (object) @Matrix 24025 \*/ 24026 matrixproto.clone = function () { 24027 return new Matrix(this.a, this.b, this.c, this.d, this.e, this.f); 24028 }; 24029 /*\ 24030 * Matrix.translate 24031 [ method ] 24032 ** 24033 * Translate the matrix 24034 - x (number) horizontal offset distance 24035 - y (number) vertical offset distance 24036 \*/ 24037 matrixproto.translate = function (x, y) { 24038 this.e += x * this.a + y * this.c; 24039 this.f += x * this.b + y * this.d; 24040 return this; 24041 }; 24042 /*\ 24043 * Matrix.scale 24044 [ method ] 24045 ** 24046 * Scales the matrix 24047 - x (number) amount to be scaled, with `1` resulting in no change 24048 - y (number) #optional amount to scale along the vertical axis. (Otherwise `x` applies to both axes.) 24049 - cx (number) #optional horizontal origin point from which to scale 24050 - cy (number) #optional vertical origin point from which to scale 24051 * Default cx, cy is the middle point of the element. 24052 \*/ 24053 matrixproto.scale = function (x, y, cx, cy) { 24054 y == null && (y = x); 24055 (cx || cy) && this.translate(cx, cy); 24056 this.a *= x; 24057 this.b *= x; 24058 this.c *= y; 24059 this.d *= y; 24060 (cx || cy) && this.translate(-cx, -cy); 24061 return this; 24062 }; 24063 /*\ 24064 * Matrix.rotate 24065 [ method ] 24066 ** 24067 * Rotates the matrix 24068 - a (number) angle of rotation, in degrees 24069 - x (number) horizontal origin point from which to rotate 24070 - y (number) vertical origin point from which to rotate 24071 \*/ 24072 matrixproto.rotate = function (a, x, y) { 24073 a = Snap.rad(a); 24074 x = x || 0; 24075 y = y || 0; 24076 var cos = +math.cos(a).toFixed(9), 24077 sin = +math.sin(a).toFixed(9); 24078 this.add(cos, sin, -sin, cos, x, y); 24079 return this.add(1, 0, 0, 1, -x, -y); 24080 }; 24081 /*\ 24082 * Matrix.skewX 24083 [ method ] 24084 ** 24085 * Skews the matrix along the x-axis 24086 - x (number) Angle to skew along the x-axis (in degrees). 24087 \*/ 24088 matrixproto.skewX = function (x) { 24089 return this.skew(x, 0); 24090 }; 24091 /*\ 24092 * Matrix.skewY 24093 [ method ] 24094 ** 24095 * Skews the matrix along the y-axis 24096 - y (number) Angle to skew along the y-axis (in degrees). 24097 \*/ 24098 matrixproto.skewY = function (y) { 24099 return this.skew(0, y); 24100 }; 24101 /*\ 24102 * Matrix.skew 24103 [ method ] 24104 ** 24105 * Skews the matrix 24106 - y (number) Angle to skew along the y-axis (in degrees). 24107 - x (number) Angle to skew along the x-axis (in degrees). 24108 \*/ 24109 matrixproto.skew = function (x, y) { 24110 x = x || 0; 24111 y = y || 0; 24112 x = Snap.rad(x); 24113 y = Snap.rad(y); 24114 var c = math.tan(x).toFixed(9); 24115 var b = math.tan(y).toFixed(9); 24116 return this.add(1, b, c, 1, 0, 0); 24117 }; 24118 /*\ 24119 * Matrix.x 24120 [ method ] 24121 ** 24122 * Returns x coordinate for given point after transformation described by the matrix. See also @Matrix.y 24123 - x (number) 24124 - y (number) 24125 = (number) x 24126 \*/ 24127 matrixproto.x = function (x, y) { 24128 return x * this.a + y * this.c + this.e; 24129 }; 24130 /*\ 24131 * Matrix.y 24132 [ method ] 24133 ** 24134 * Returns y coordinate for given point after transformation described by the matrix. See also @Matrix.x 24135 - x (number) 24136 - y (number) 24137 = (number) y 24138 \*/ 24139 matrixproto.y = function (x, y) { 24140 return x * this.b + y * this.d + this.f; 24141 }; 24142 matrixproto.get = function (i) { 24143 return +this[Str.fromCharCode(97 + i)].toFixed(4); 24144 }; 24145 matrixproto.toString = function () { 24146 return "matrix(" + [this.get(0), this.get(1), this.get(2), this.get(3), this.get(4), this.get(5)].join() + ")"; 24147 }; 24148 matrixproto.offset = function () { 24149 return [this.e.toFixed(4), this.f.toFixed(4)]; 24150 }; 24151 function norm(a) { 24152 return a[0] * a[0] + a[1] * a[1]; 24153 } 24154 function normalize(a) { 24155 var mag = math.sqrt(norm(a)); 24156 a[0] && (a[0] /= mag); 24157 a[1] && (a[1] /= mag); 24158 } 24159 /*\ 24160 * Matrix.determinant 24161 [ method ] 24162 ** 24163 * Finds determinant of the given matrix. 24164 = (number) determinant 24165 \*/ 24166 matrixproto.determinant = function () { 24167 return this.a * this.d - this.b * this.c; 24168 }; 24169 /*\ 24170 * Matrix.split 24171 [ method ] 24172 ** 24173 * Splits matrix into primitive transformations 24174 = (object) in format: 24175 o dx (number) translation by x 24176 o dy (number) translation by y 24177 o scalex (number) scale by x 24178 o scaley (number) scale by y 24179 o shear (number) shear 24180 o rotate (number) rotation in deg 24181 o isSimple (boolean) could it be represented via simple transformations 24182 \*/ 24183 matrixproto.split = function () { 24184 var out = {}; 24185 // translation 24186 out.dx = this.e; 24187 out.dy = this.f; 24188 24189 // scale and shear 24190 var row = [[this.a, this.b], [this.c, this.d]]; 24191 out.scalex = math.sqrt(norm(row[0])); 24192 normalize(row[0]); 24193 24194 out.shear = row[0][0] * row[1][0] + row[0][1] * row[1][1]; 24195 row[1] = [row[1][0] - row[0][0] * out.shear, row[1][1] - row[0][1] * out.shear]; 24196 24197 out.scaley = math.sqrt(norm(row[1])); 24198 normalize(row[1]); 24199 out.shear /= out.scaley; 24200 24201 if (this.determinant() < 0) { 24202 out.scalex = -out.scalex; 24203 } 24204 24205 // rotation 24206 var sin = row[0][1], 24207 cos = row[1][1]; 24208 if (cos < 0) { 24209 out.rotate = Snap.deg(math.acos(cos)); 24210 if (sin < 0) { 24211 out.rotate = 360 - out.rotate; 24212 } 24213 } else { 24214 out.rotate = Snap.deg(math.asin(sin)); 24215 } 24216 24217 out.isSimple = !+out.shear.toFixed(9) && (out.scalex.toFixed(9) == out.scaley.toFixed(9) || !out.rotate); 24218 out.isSuperSimple = !+out.shear.toFixed(9) && out.scalex.toFixed(9) == out.scaley.toFixed(9) && !out.rotate; 24219 out.noRotation = !+out.shear.toFixed(9) && !out.rotate; 24220 return out; 24221 }; 24222 /*\ 24223 * Matrix.toTransformString 24224 [ method ] 24225 ** 24226 * Returns transform string that represents given matrix 24227 = (string) transform string 24228 \*/ 24229 matrixproto.toTransformString = function (shorter) { 24230 var s = shorter || this.split(); 24231 if (!+s.shear.toFixed(9)) { 24232 s.scalex = +s.scalex.toFixed(4); 24233 s.scaley = +s.scaley.toFixed(4); 24234 s.rotate = +s.rotate.toFixed(4); 24235 return (s.dx || s.dy ? "t" + [+s.dx.toFixed(4), +s.dy.toFixed(4)] : E) + 24236 (s.rotate ? "r" + [+s.rotate.toFixed(4), 0, 0] : E) + 24237 (s.scalex != 1 || s.scaley != 1 ? "s" + [s.scalex, s.scaley, 0, 0] : E); 24238 } else { 24239 return "m" + [this.get(0), this.get(1), this.get(2), this.get(3), this.get(4), this.get(5)]; 24240 } 24241 }; 24242 })(Matrix.prototype); 24243 /*\ 24244 * Snap.Matrix 24245 [ method ] 24246 ** 24247 * Matrix constructor, extend on your own risk. 24248 * To create matrices use @Snap.matrix. 24249 \*/ 24250 Snap.Matrix = Matrix; 24251 /*\ 24252 * Snap.matrix 24253 [ method ] 24254 ** 24255 * Utility method 24256 ** 24257 * Returns a matrix based on the given parameters 24258 - a (number) 24259 - b (number) 24260 - c (number) 24261 - d (number) 24262 - e (number) 24263 - f (number) 24264 * or 24265 - svgMatrix (SVGMatrix) 24266 = (object) @Matrix 24267 \*/ 24268 Snap.matrix = function (a, b, c, d, e, f) { 24269 return new Matrix(a, b, c, d, e, f); 24270 }; 24271}); 24272 24273// Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved. 24274// 24275// Licensed under the Apache License, Version 2.0 (the "License"); 24276// you may not use this file except in compliance with the License. 24277// You may obtain a copy of the License at 24278// 24279// http://www.apache.org/licenses/LICENSE-2.0 24280// 24281// Unless required by applicable law or agreed to in writing, software 24282// distributed under the License is distributed on an "AS IS" BASIS, 24283// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 24284// See the License for the specific language governing permissions and 24285// limitations under the License. 24286Snap.plugin(function (Snap, Element, Paper, glob, Fragment) { 24287 var has = "hasOwnProperty", 24288 make = Snap._.make, 24289 wrap = Snap._.wrap, 24290 is = Snap.is, 24291 getSomeDefs = Snap._.getSomeDefs, 24292 reURLValue = /^url\((['"]?)([^)]+)\1\)$/, 24293 $ = Snap._.$, 24294 URL = Snap.url, 24295 Str = String, 24296 separator = Snap._.separator, 24297 E = ""; 24298 /*\ 24299 * Snap.deurl 24300 [ method ] 24301 ** 24302 * Unwraps path from `"url(<path>)"`. 24303 - value (string) url path 24304 = (string) unwrapped path 24305 \*/ 24306 Snap.deurl = function (value) { 24307 var res = String(value).match(reURLValue); 24308 return res ? res[2] : value; 24309 } 24310 // Attributes event handlers 24311 eve.on("snap.util.attr.mask", function (value) { 24312 if (value instanceof Element || value instanceof Fragment) { 24313 eve.stop(); 24314 if (value instanceof Fragment && value.node.childNodes.length == 1) { 24315 value = value.node.firstChild; 24316 getSomeDefs(this).appendChild(value); 24317 value = wrap(value); 24318 } 24319 if (value.type == "mask") { 24320 var mask = value; 24321 } else { 24322 mask = make("mask", getSomeDefs(this)); 24323 mask.node.appendChild(value.node); 24324 } 24325 !mask.node.id && $(mask.node, { 24326 id: mask.id 24327 }); 24328 $(this.node, { 24329 mask: URL(mask.id) 24330 }); 24331 } 24332 }); 24333 (function (clipIt) { 24334 eve.on("snap.util.attr.clip", clipIt); 24335 eve.on("snap.util.attr.clip-path", clipIt); 24336 eve.on("snap.util.attr.clipPath", clipIt); 24337 }(function (value) { 24338 if (value instanceof Element || value instanceof Fragment) { 24339 eve.stop(); 24340 var clip, 24341 node = value.node; 24342 while (node) { 24343 if (node.nodeName === "clipPath") { 24344 clip = new Element(node); 24345 break; 24346 } 24347 if (node.nodeName === "svg") { 24348 clip = undefined; 24349 break; 24350 } 24351 node = node.parentNode; 24352 } 24353 if (!clip) { 24354 clip = make("clipPath", getSomeDefs(this)); 24355 clip.node.appendChild(value.node); 24356 !clip.node.id && $(clip.node, { 24357 id: clip.id 24358 }); 24359 } 24360 $(this.node, { 24361 "clip-path": URL(clip.node.id || clip.id) 24362 }); 24363 } 24364 })); 24365 function fillStroke(name) { 24366 return function (value) { 24367 eve.stop(); 24368 if (value instanceof Fragment && value.node.childNodes.length == 1 && 24369 (value.node.firstChild.tagName == "radialGradient" || 24370 value.node.firstChild.tagName == "linearGradient" || 24371 value.node.firstChild.tagName == "pattern")) { 24372 value = value.node.firstChild; 24373 getSomeDefs(this).appendChild(value); 24374 value = wrap(value); 24375 } 24376 if (value instanceof Element) { 24377 if (value.type == "radialGradient" || value.type == "linearGradient" 24378 || value.type == "pattern") { 24379 if (!value.node.id) { 24380 $(value.node, { 24381 id: value.id 24382 }); 24383 } 24384 var fill = URL(value.node.id); 24385 } else { 24386 fill = value.attr(name); 24387 } 24388 } else { 24389 fill = Snap.color(value); 24390 if (fill.error) { 24391 var grad = Snap(getSomeDefs(this).ownerSVGElement).gradient(value); 24392 if (grad) { 24393 if (!grad.node.id) { 24394 $(grad.node, { 24395 id: grad.id 24396 }); 24397 } 24398 fill = URL(grad.node.id); 24399 } else { 24400 fill = value; 24401 } 24402 } else { 24403 fill = Str(fill); 24404 } 24405 } 24406 var attrs = {}; 24407 attrs[name] = fill; 24408 $(this.node, attrs); 24409 this.node.style[name] = E; 24410 }; 24411 } 24412 eve.on("snap.util.attr.fill", fillStroke("fill")); 24413 eve.on("snap.util.attr.stroke", fillStroke("stroke")); 24414 var gradrg = /^([lr])(?:\(([^)]*)\))?(.*)$/i; 24415 eve.on("snap.util.grad.parse", function parseGrad(string) { 24416 string = Str(string); 24417 var tokens = string.match(gradrg); 24418 if (!tokens) { 24419 return null; 24420 } 24421 var type = tokens[1], 24422 params = tokens[2], 24423 stops = tokens[3]; 24424 params = params.split(/\s*,\s*/).map(function (el) { 24425 return +el == el ? +el : el; 24426 }); 24427 if (params.length == 1 && params[0] == 0) { 24428 params = []; 24429 } 24430 stops = stops.split("-"); 24431 stops = stops.map(function (el) { 24432 el = el.split(":"); 24433 var out = { 24434 color: el[0] 24435 }; 24436 if (el[1]) { 24437 out.offset = parseFloat(el[1]); 24438 } 24439 return out; 24440 }); 24441 var len = stops.length, 24442 start = 0, 24443 j = 0; 24444 function seed(i, end) { 24445 var step = (end - start) / (i - j); 24446 for (var k = j; k < i; k++) { 24447 stops[k].offset = +(+start + step * (k - j)).toFixed(2); 24448 } 24449 j = i; 24450 start = end; 24451 } 24452 len--; 24453 for (var i = 0; i < len; i++) if ("offset" in stops[i]) { 24454 seed(i, stops[i].offset); 24455 } 24456 stops[len].offset = stops[len].offset || 100; 24457 seed(len, stops[len].offset); 24458 return { 24459 type: type, 24460 params: params, 24461 stops: stops 24462 }; 24463 }); 24464 24465 eve.on("snap.util.attr.d", function (value) { 24466 eve.stop(); 24467 if (is(value, "array") && is(value[0], "array")) { 24468 value = Snap.path.toString.call(value); 24469 } 24470 value = Str(value); 24471 if (value.match(/[ruo]/i)) { 24472 value = Snap.path.toAbsolute(value); 24473 } 24474 $(this.node, {d: value}); 24475 })(-1); 24476 eve.on("snap.util.attr.#text", function (value) { 24477 eve.stop(); 24478 value = Str(value); 24479 var txt = glob.doc.createTextNode(value); 24480 while (this.node.firstChild) { 24481 this.node.removeChild(this.node.firstChild); 24482 } 24483 this.node.appendChild(txt); 24484 })(-1); 24485 eve.on("snap.util.attr.path", function (value) { 24486 eve.stop(); 24487 this.attr({d: value}); 24488 })(-1); 24489 eve.on("snap.util.attr.class", function (value) { 24490 eve.stop(); 24491 this.node.className.baseVal = value; 24492 })(-1); 24493 eve.on("snap.util.attr.viewBox", function (value) { 24494 var vb; 24495 if (is(value, "object") && "x" in value) { 24496 vb = [value.x, value.y, value.width, value.height].join(" "); 24497 } else if (is(value, "array")) { 24498 vb = value.join(" "); 24499 } else { 24500 vb = value; 24501 } 24502 $(this.node, { 24503 viewBox: vb 24504 }); 24505 eve.stop(); 24506 })(-1); 24507 eve.on("snap.util.attr.transform", function (value) { 24508 this.transform(value); 24509 eve.stop(); 24510 })(-1); 24511 eve.on("snap.util.attr.r", function (value) { 24512 if (this.type == "rect") { 24513 eve.stop(); 24514 $(this.node, { 24515 rx: value, 24516 ry: value 24517 }); 24518 } 24519 })(-1); 24520 eve.on("snap.util.attr.textpath", function (value) { 24521 eve.stop(); 24522 if (this.type == "text") { 24523 var id, tp, node; 24524 if (!value && this.textPath) { 24525 tp = this.textPath; 24526 while (tp.node.firstChild) { 24527 this.node.appendChild(tp.node.firstChild); 24528 } 24529 tp.remove(); 24530 delete this.textPath; 24531 return; 24532 } 24533 if (is(value, "string")) { 24534 var defs = getSomeDefs(this), 24535 path = wrap(defs.parentNode).path(value); 24536 defs.appendChild(path.node); 24537 id = path.id; 24538 path.attr({id: id}); 24539 } else { 24540 value = wrap(value); 24541 if (value instanceof Element) { 24542 id = value.attr("id"); 24543 if (!id) { 24544 id = value.id; 24545 value.attr({id: id}); 24546 } 24547 } 24548 } 24549 if (id) { 24550 tp = this.textPath; 24551 node = this.node; 24552 if (tp) { 24553 tp.attr({"xlink:href": "#" + id}); 24554 } else { 24555 tp = $("textPath", { 24556 "xlink:href": "#" + id 24557 }); 24558 while (node.firstChild) { 24559 tp.appendChild(node.firstChild); 24560 } 24561 node.appendChild(tp); 24562 this.textPath = wrap(tp); 24563 } 24564 } 24565 } 24566 })(-1); 24567 eve.on("snap.util.attr.text", function (value) { 24568 if (this.type == "text") { 24569 var i = 0, 24570 node = this.node, 24571 tuner = function (chunk) { 24572 var out = $("tspan"); 24573 if (is(chunk, "array")) { 24574 for (var i = 0; i < chunk.length; i++) { 24575 out.appendChild(tuner(chunk[i])); 24576 } 24577 } else { 24578 out.appendChild(glob.doc.createTextNode(chunk)); 24579 } 24580 out.normalize && out.normalize(); 24581 return out; 24582 }; 24583 while (node.firstChild) { 24584 node.removeChild(node.firstChild); 24585 } 24586 var tuned = tuner(value); 24587 while (tuned.firstChild) { 24588 node.appendChild(tuned.firstChild); 24589 } 24590 } 24591 eve.stop(); 24592 })(-1); 24593 function setFontSize(value) { 24594 eve.stop(); 24595 if (value == +value) { 24596 value += "px"; 24597 } 24598 this.node.style.fontSize = value; 24599 } 24600 eve.on("snap.util.attr.fontSize", setFontSize)(-1); 24601 eve.on("snap.util.attr.font-size", setFontSize)(-1); 24602 24603 24604 eve.on("snap.util.getattr.transform", function () { 24605 eve.stop(); 24606 return this.transform(); 24607 })(-1); 24608 eve.on("snap.util.getattr.textpath", function () { 24609 eve.stop(); 24610 return this.textPath; 24611 })(-1); 24612 // Markers 24613 (function () { 24614 function getter(end) { 24615 return function () { 24616 eve.stop(); 24617 var style = glob.doc.defaultView.getComputedStyle(this.node, null).getPropertyValue("marker-" + end); 24618 if (style == "none") { 24619 return style; 24620 } else { 24621 return Snap(glob.doc.getElementById(style.match(reURLValue)[1])); 24622 } 24623 }; 24624 } 24625 function setter(end) { 24626 return function (value) { 24627 eve.stop(); 24628 var name = "marker" + end.charAt(0).toUpperCase() + end.substring(1); 24629 if (value == "" || !value) { 24630 this.node.style[name] = "none"; 24631 return; 24632 } 24633 if (value.type == "marker") { 24634 var id = value.node.id; 24635 if (!id) { 24636 $(value.node, {id: value.id}); 24637 } 24638 this.node.style[name] = URL(id); 24639 return; 24640 } 24641 }; 24642 } 24643 eve.on("snap.util.getattr.marker-end", getter("end"))(-1); 24644 eve.on("snap.util.getattr.markerEnd", getter("end"))(-1); 24645 eve.on("snap.util.getattr.marker-start", getter("start"))(-1); 24646 eve.on("snap.util.getattr.markerStart", getter("start"))(-1); 24647 eve.on("snap.util.getattr.marker-mid", getter("mid"))(-1); 24648 eve.on("snap.util.getattr.markerMid", getter("mid"))(-1); 24649 eve.on("snap.util.attr.marker-end", setter("end"))(-1); 24650 eve.on("snap.util.attr.markerEnd", setter("end"))(-1); 24651 eve.on("snap.util.attr.marker-start", setter("start"))(-1); 24652 eve.on("snap.util.attr.markerStart", setter("start"))(-1); 24653 eve.on("snap.util.attr.marker-mid", setter("mid"))(-1); 24654 eve.on("snap.util.attr.markerMid", setter("mid"))(-1); 24655 }()); 24656 eve.on("snap.util.getattr.r", function () { 24657 if (this.type == "rect" && $(this.node, "rx") == $(this.node, "ry")) { 24658 eve.stop(); 24659 return $(this.node, "rx"); 24660 } 24661 })(-1); 24662 function textExtract(node) { 24663 var out = []; 24664 var children = node.childNodes; 24665 for (var i = 0, ii = children.length; i < ii; i++) { 24666 var chi = children[i]; 24667 if (chi.nodeType == 3) { 24668 out.push(chi.nodeValue); 24669 } 24670 if (chi.tagName == "tspan") { 24671 if (chi.childNodes.length == 1 && chi.firstChild.nodeType == 3) { 24672 out.push(chi.firstChild.nodeValue); 24673 } else { 24674 out.push(textExtract(chi)); 24675 } 24676 } 24677 } 24678 return out; 24679 } 24680 eve.on("snap.util.getattr.text", function () { 24681 if (this.type == "text" || this.type == "tspan") { 24682 eve.stop(); 24683 var out = textExtract(this.node); 24684 return out.length == 1 ? out[0] : out; 24685 } 24686 })(-1); 24687 eve.on("snap.util.getattr.#text", function () { 24688 return this.node.textContent; 24689 })(-1); 24690 eve.on("snap.util.getattr.fill", function (internal) { 24691 if (internal) { 24692 return; 24693 } 24694 eve.stop(); 24695 var value = eve("snap.util.getattr.fill", this, true).firstDefined(); 24696 return Snap(Snap.deurl(value)) || value; 24697 })(-1); 24698 eve.on("snap.util.getattr.stroke", function (internal) { 24699 if (internal) { 24700 return; 24701 } 24702 eve.stop(); 24703 var value = eve("snap.util.getattr.stroke", this, true).firstDefined(); 24704 return Snap(Snap.deurl(value)) || value; 24705 })(-1); 24706 eve.on("snap.util.getattr.viewBox", function () { 24707 eve.stop(); 24708 var vb = $(this.node, "viewBox"); 24709 if (vb) { 24710 vb = vb.split(separator); 24711 return Snap._.box(+vb[0], +vb[1], +vb[2], +vb[3]); 24712 } else { 24713 return; 24714 } 24715 })(-1); 24716 eve.on("snap.util.getattr.points", function () { 24717 var p = $(this.node, "points"); 24718 eve.stop(); 24719 if (p) { 24720 return p.split(separator); 24721 } else { 24722 return; 24723 } 24724 })(-1); 24725 eve.on("snap.util.getattr.path", function () { 24726 var p = $(this.node, "d"); 24727 eve.stop(); 24728 return p; 24729 })(-1); 24730 eve.on("snap.util.getattr.class", function () { 24731 return this.node.className.baseVal; 24732 })(-1); 24733 function getFontSize() { 24734 eve.stop(); 24735 return this.node.style.fontSize; 24736 } 24737 eve.on("snap.util.getattr.fontSize", getFontSize)(-1); 24738 eve.on("snap.util.getattr.font-size", getFontSize)(-1); 24739}); 24740 24741// Copyright (c) 2014 Adobe Systems Incorporated. All rights reserved. 24742// 24743// Licensed under the Apache License, Version 2.0 (the "License"); 24744// you may not use this file except in compliance with the License. 24745// You may obtain a copy of the License at 24746// 24747// http://www.apache.org/licenses/LICENSE-2.0 24748// 24749// Unless required by applicable law or agreed to in writing, software 24750// distributed under the License is distributed on an "AS IS" BASIS, 24751// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 24752// See the License for the specific language governing permissions and 24753// limitations under the License. 24754Snap.plugin(function (Snap, Element, Paper, glob, Fragment) { 24755 var rgNotSpace = /\S+/g, 24756 rgBadSpace = /[\t\r\n\f]/g, 24757 rgTrim = /(^\s+|\s+$)/g, 24758 Str = String, 24759 elproto = Element.prototype; 24760 /*\ 24761 * Element.addClass 24762 [ method ] 24763 ** 24764 * Adds given class name or list of class names to the element. 24765 - value (string) class name or space separated list of class names 24766 ** 24767 = (Element) original element. 24768 \*/ 24769 elproto.addClass = function (value) { 24770 var classes = Str(value || "").match(rgNotSpace) || [], 24771 elem = this.node, 24772 className = elem.className.baseVal, 24773 curClasses = className.match(rgNotSpace) || [], 24774 j, 24775 pos, 24776 clazz, 24777 finalValue; 24778 24779 if (classes.length) { 24780 j = 0; 24781 while (clazz = classes[j++]) { 24782 pos = curClasses.indexOf(clazz); 24783 if (!~pos) { 24784 curClasses.push(clazz); 24785 } 24786 } 24787 24788 finalValue = curClasses.join(" "); 24789 if (className != finalValue) { 24790 elem.className.baseVal = finalValue; 24791 } 24792 } 24793 return this; 24794 }; 24795 /*\ 24796 * Element.removeClass 24797 [ method ] 24798 ** 24799 * Removes given class name or list of class names from the element. 24800 - value (string) class name or space separated list of class names 24801 ** 24802 = (Element) original element. 24803 \*/ 24804 elproto.removeClass = function (value) { 24805 var classes = Str(value || "").match(rgNotSpace) || [], 24806 elem = this.node, 24807 className = elem.className.baseVal, 24808 curClasses = className.match(rgNotSpace) || [], 24809 j, 24810 pos, 24811 clazz, 24812 finalValue; 24813 if (curClasses.length) { 24814 j = 0; 24815 while (clazz = classes[j++]) { 24816 pos = curClasses.indexOf(clazz); 24817 if (~pos) { 24818 curClasses.splice(pos, 1); 24819 } 24820 } 24821 24822 finalValue = curClasses.join(" "); 24823 if (className != finalValue) { 24824 elem.className.baseVal = finalValue; 24825 } 24826 } 24827 return this; 24828 }; 24829 /*\ 24830 * Element.hasClass 24831 [ method ] 24832 ** 24833 * Checks if the element has a given class name in the list of class names applied to it. 24834 - value (string) class name 24835 ** 24836 = (boolean) `true` if the element has given class 24837 \*/ 24838 elproto.hasClass = function (value) { 24839 var elem = this.node, 24840 className = elem.className.baseVal, 24841 curClasses = className.match(rgNotSpace) || []; 24842 return !!~curClasses.indexOf(value); 24843 }; 24844 /*\ 24845 * Element.toggleClass 24846 [ method ] 24847 ** 24848 * Add or remove one or more classes from the element, depending on either 24849 * the classâs presence or the value of the `flag` argument. 24850 - value (string) class name or space separated list of class names 24851 - flag (boolean) value to determine whether the class should be added or removed 24852 ** 24853 = (Element) original element. 24854 \*/ 24855 elproto.toggleClass = function (value, flag) { 24856 if (flag != null) { 24857 if (flag) { 24858 return this.addClass(value); 24859 } else { 24860 return this.removeClass(value); 24861 } 24862 } 24863 var classes = (value || "").match(rgNotSpace) || [], 24864 elem = this.node, 24865 className = elem.className.baseVal, 24866 curClasses = className.match(rgNotSpace) || [], 24867 j, 24868 pos, 24869 clazz, 24870 finalValue; 24871 j = 0; 24872 while (clazz = classes[j++]) { 24873 pos = curClasses.indexOf(clazz); 24874 if (~pos) { 24875 curClasses.splice(pos, 1); 24876 } else { 24877 curClasses.push(clazz); 24878 } 24879 } 24880 24881 finalValue = curClasses.join(" "); 24882 if (className != finalValue) { 24883 elem.className.baseVal = finalValue; 24884 } 24885 return this; 24886 }; 24887}); 24888 24889// Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved. 24890// 24891// Licensed under the Apache License, Version 2.0 (the "License"); 24892// you may not use this file except in compliance with the License. 24893// You may obtain a copy of the License at 24894// 24895// http://www.apache.org/licenses/LICENSE-2.0 24896// 24897// Unless required by applicable law or agreed to in writing, software 24898// distributed under the License is distributed on an "AS IS" BASIS, 24899// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 24900// See the License for the specific language governing permissions and 24901// limitations under the License. 24902Snap.plugin(function (Snap, Element, Paper, glob, Fragment) { 24903 var operators = { 24904 "+": function (x, y) { 24905 return x + y; 24906 }, 24907 "-": function (x, y) { 24908 return x - y; 24909 }, 24910 "/": function (x, y) { 24911 return x / y; 24912 }, 24913 "*": function (x, y) { 24914 return x * y; 24915 } 24916 }, 24917 Str = String, 24918 reUnit = /[a-z]+$/i, 24919 reAddon = /^\s*([+\-\/*])\s*=\s*([\d.eE+\-]+)\s*([^\d\s]+)?\s*$/; 24920 function getNumber(val) { 24921 return val; 24922 } 24923 function getUnit(unit) { 24924 return function (val) { 24925 return +val.toFixed(3) + unit; 24926 }; 24927 } 24928 eve.on("snap.util.attr", function (val) { 24929 var plus = Str(val).match(reAddon); 24930 if (plus) { 24931 var evnt = eve.nt(), 24932 name = evnt.substring(evnt.lastIndexOf(".") + 1), 24933 a = this.attr(name), 24934 atr = {}; 24935 eve.stop(); 24936 var unit = plus[3] || "", 24937 aUnit = a.match(reUnit), 24938 op = operators[plus[1]]; 24939 if (aUnit && aUnit == unit) { 24940 val = op(parseFloat(a), +plus[2]); 24941 } else { 24942 a = this.asPX(name); 24943 val = op(this.asPX(name), this.asPX(name, plus[2] + unit)); 24944 } 24945 if (isNaN(a) || isNaN(val)) { 24946 return; 24947 } 24948 atr[name] = val; 24949 this.attr(atr); 24950 } 24951 })(-10); 24952 eve.on("snap.util.equal", function (name, b) { 24953 var A, B, a = Str(this.attr(name) || ""), 24954 el = this, 24955 bplus = Str(b).match(reAddon); 24956 if (bplus) { 24957 eve.stop(); 24958 var unit = bplus[3] || "", 24959 aUnit = a.match(reUnit), 24960 op = operators[bplus[1]]; 24961 if (aUnit && aUnit == unit) { 24962 return { 24963 from: parseFloat(a), 24964 to: op(parseFloat(a), +bplus[2]), 24965 f: getUnit(aUnit) 24966 }; 24967 } else { 24968 a = this.asPX(name); 24969 return { 24970 from: a, 24971 to: op(a, this.asPX(name, bplus[2] + unit)), 24972 f: getNumber 24973 }; 24974 } 24975 } 24976 })(-10); 24977}); 24978 24979// Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved. 24980// 24981// Licensed under the Apache License, Version 2.0 (the "License"); 24982// you may not use this file except in compliance with the License. 24983// You may obtain a copy of the License at 24984// 24985// http://www.apache.org/licenses/LICENSE-2.0 24986// 24987// Unless required by applicable law or agreed to in writing, software 24988// distributed under the License is distributed on an "AS IS" BASIS, 24989// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 24990// See the License for the specific language governing permissions and 24991// limitations under the License. 24992Snap.plugin(function (Snap, Element, Paper, glob, Fragment) { 24993 var proto = Paper.prototype, 24994 is = Snap.is; 24995 /*\ 24996 * Paper.rect 24997 [ method ] 24998 * 24999 * Draws a rectangle 25000 ** 25001 - x (number) x coordinate of the top left corner 25002 - y (number) y coordinate of the top left corner 25003 - width (number) width 25004 - height (number) height 25005 - rx (number) #optional horizontal radius for rounded corners, default is 0 25006 - ry (number) #optional vertical radius for rounded corners, default is rx or 0 25007 = (object) the `rect` element 25008 ** 25009 > Usage 25010 | // regular rectangle 25011 | var c = paper.rect(10, 10, 50, 50); 25012 | // rectangle with rounded corners 25013 | var c = paper.rect(40, 40, 50, 50, 10); 25014 \*/ 25015 proto.rect = function (x, y, w, h, rx, ry) { 25016 var attr; 25017 if (ry == null) { 25018 ry = rx; 25019 } 25020 if (is(x, "object") && x == "[object Object]") { 25021 attr = x; 25022 } else if (x != null) { 25023 attr = { 25024 x: x, 25025 y: y, 25026 width: w, 25027 height: h 25028 }; 25029 if (rx != null) { 25030 attr.rx = rx; 25031 attr.ry = ry; 25032 } 25033 } 25034 return this.el("rect", attr); 25035 }; 25036 /*\ 25037 * Paper.circle 25038 [ method ] 25039 ** 25040 * Draws a circle 25041 ** 25042 - x (number) x coordinate of the centre 25043 - y (number) y coordinate of the centre 25044 - r (number) radius 25045 = (object) the `circle` element 25046 ** 25047 > Usage 25048 | var c = paper.circle(50, 50, 40); 25049 \*/ 25050 proto.circle = function (cx, cy, r) { 25051 var attr; 25052 if (is(cx, "object") && cx == "[object Object]") { 25053 attr = cx; 25054 } else if (cx != null) { 25055 attr = { 25056 cx: cx, 25057 cy: cy, 25058 r: r 25059 }; 25060 } 25061 return this.el("circle", attr); 25062 }; 25063 25064 var preload = (function () { 25065 function onerror() { 25066 this.parentNode.removeChild(this); 25067 } 25068 return function (src, f) { 25069 var img = glob.doc.createElement("img"), 25070 body = glob.doc.body; 25071 img.style.cssText = "position:absolute;left:-9999em;top:-9999em"; 25072 img.onload = function () { 25073 f.call(img); 25074 img.onload = img.onerror = null; 25075 body.removeChild(img); 25076 }; 25077 img.onerror = onerror; 25078 body.appendChild(img); 25079 img.src = src; 25080 }; 25081 }()); 25082 25083 /*\ 25084 * Paper.image 25085 [ method ] 25086 ** 25087 * Places an image on the surface 25088 ** 25089 - src (string) URI of the source image 25090 - x (number) x offset position 25091 - y (number) y offset position 25092 - width (number) width of the image 25093 - height (number) height of the image 25094 = (object) the `image` element 25095 * or 25096 = (object) Snap element object with type `image` 25097 ** 25098 > Usage 25099 | var c = paper.image("apple.png", 10, 10, 80, 80); 25100 \*/ 25101 proto.image = function (src, x, y, width, height) { 25102 var el = this.el("image"); 25103 if (is(src, "object") && "src" in src) { 25104 el.attr(src); 25105 } else if (src != null) { 25106 var set = { 25107 "xlink:href": src, 25108 preserveAspectRatio: "none" 25109 }; 25110 if (x != null && y != null) { 25111 set.x = x; 25112 set.y = y; 25113 } 25114 if (width != null && height != null) { 25115 set.width = width; 25116 set.height = height; 25117 } else { 25118 preload(src, function () { 25119 Snap._.$(el.node, { 25120 width: this.offsetWidth, 25121 height: this.offsetHeight 25122 }); 25123 }); 25124 } 25125 Snap._.$(el.node, set); 25126 } 25127 return el; 25128 }; 25129 /*\ 25130 * Paper.ellipse 25131 [ method ] 25132 ** 25133 * Draws an ellipse 25134 ** 25135 - x (number) x coordinate of the centre 25136 - y (number) y coordinate of the centre 25137 - rx (number) horizontal radius 25138 - ry (number) vertical radius 25139 = (object) the `ellipse` element 25140 ** 25141 > Usage 25142 | var c = paper.ellipse(50, 50, 40, 20); 25143 \*/ 25144 proto.ellipse = function (cx, cy, rx, ry) { 25145 var attr; 25146 if (is(cx, "object") && cx == "[object Object]") { 25147 attr = cx; 25148 } else if (cx != null) { 25149 attr ={ 25150 cx: cx, 25151 cy: cy, 25152 rx: rx, 25153 ry: ry 25154 }; 25155 } 25156 return this.el("ellipse", attr); 25157 }; 25158 // SIERRA Paper.path(): Unclear from the link what a Catmull-Rom curveto is, and why it would make life any easier. 25159 /*\ 25160 * Paper.path 25161 [ method ] 25162 ** 25163 * Creates a `<path>` element using the given string as the path's definition 25164 - pathString (string) #optional path string in SVG format 25165 * Path string consists of one-letter commands, followed by comma seprarated arguments in numerical form. Example: 25166 | "M10,20L30,40" 25167 * This example features two commands: `M`, with arguments `(10, 20)` and `L` with arguments `(30, 40)`. Uppercase letter commands express coordinates in absolute terms, while lowercase commands express them in relative terms from the most recently declared coordinates. 25168 * 25169 # <p>Here is short list of commands available, for more details see <a href="http://www.w3.org/TR/SVG/paths.html#PathData" title="Details of a path's data attribute's format are described in the SVG specification.">SVG path string format</a> or <a href="https://developer.mozilla.org/en/SVG/Tutorial/Paths">article about path strings at MDN</a>.</p> 25170 # <table><thead><tr><th>Command</th><th>Name</th><th>Parameters</th></tr></thead><tbody> 25171 # <tr><td>M</td><td>moveto</td><td>(x y)+</td></tr> 25172 # <tr><td>Z</td><td>closepath</td><td>(none)</td></tr> 25173 # <tr><td>L</td><td>lineto</td><td>(x y)+</td></tr> 25174 # <tr><td>H</td><td>horizontal lineto</td><td>x+</td></tr> 25175 # <tr><td>V</td><td>vertical lineto</td><td>y+</td></tr> 25176 # <tr><td>C</td><td>curveto</td><td>(x1 y1 x2 y2 x y)+</td></tr> 25177 # <tr><td>S</td><td>smooth curveto</td><td>(x2 y2 x y)+</td></tr> 25178 # <tr><td>Q</td><td>quadratic Bézier curveto</td><td>(x1 y1 x y)+</td></tr> 25179 # <tr><td>T</td><td>smooth quadratic Bézier curveto</td><td>(x y)+</td></tr> 25180 # <tr><td>A</td><td>elliptical arc</td><td>(rx ry x-axis-rotation large-arc-flag sweep-flag x y)+</td></tr> 25181 # <tr><td>R</td><td><a href="http://en.wikipedia.org/wiki/CatmullâRom_spline#Catmull.E2.80.93Rom_spline">Catmull-Rom curveto</a>*</td><td>x1 y1 (x y)+</td></tr></tbody></table> 25182 * * _Catmull-Rom curveto_ is a not standard SVG command and added to make life easier. 25183 * Note: there is a special case when a path consists of only three commands: `M10,10Râ¦z`. In this case the path connects back to its starting point. 25184 > Usage 25185 | var c = paper.path("M10 10L90 90"); 25186 | // draw a diagonal line: 25187 | // move to 10,10, line to 90,90 25188 \*/ 25189 proto.path = function (d) { 25190 var attr; 25191 if (is(d, "object") && !is(d, "array")) { 25192 attr = d; 25193 } else if (d) { 25194 attr = {d: d}; 25195 } 25196 return this.el("path", attr); 25197 }; 25198 /*\ 25199 * Paper.g 25200 [ method ] 25201 ** 25202 * Creates a group element 25203 ** 25204 - varargs (â¦) #optional elements to nest within the group 25205 = (object) the `g` element 25206 ** 25207 > Usage 25208 | var c1 = paper.circle(), 25209 | c2 = paper.rect(), 25210 | g = paper.g(c2, c1); // note that the order of elements is different 25211 * or 25212 | var c1 = paper.circle(), 25213 | c2 = paper.rect(), 25214 | g = paper.g(); 25215 | g.add(c2, c1); 25216 \*/ 25217 /*\ 25218 * Paper.group 25219 [ method ] 25220 ** 25221 * See @Paper.g 25222 \*/ 25223 proto.group = proto.g = function (first) { 25224 var attr, 25225 el = this.el("g"); 25226 if (arguments.length == 1 && first && !first.type) { 25227 el.attr(first); 25228 } else if (arguments.length) { 25229 el.add(Array.prototype.slice.call(arguments, 0)); 25230 } 25231 return el; 25232 }; 25233 /*\ 25234 * Paper.svg 25235 [ method ] 25236 ** 25237 * Creates a nested SVG element. 25238 - x (number) @optional X of the element 25239 - y (number) @optional Y of the element 25240 - width (number) @optional width of the element 25241 - height (number) @optional height of the element 25242 - vbx (number) @optional viewbox X 25243 - vby (number) @optional viewbox Y 25244 - vbw (number) @optional viewbox width 25245 - vbh (number) @optional viewbox height 25246 ** 25247 = (object) the `svg` element 25248 ** 25249 \*/ 25250 proto.svg = function (x, y, width, height, vbx, vby, vbw, vbh) { 25251 var attrs = {}; 25252 if (is(x, "object") && y == null) { 25253 attrs = x; 25254 } else { 25255 if (x != null) { 25256 attrs.x = x; 25257 } 25258 if (y != null) { 25259 attrs.y = y; 25260 } 25261 if (width != null) { 25262 attrs.width = width; 25263 } 25264 if (height != null) { 25265 attrs.height = height; 25266 } 25267 if (vbx != null && vby != null && vbw != null && vbh != null) { 25268 attrs.viewBox = [vbx, vby, vbw, vbh]; 25269 } 25270 } 25271 return this.el("svg", attrs); 25272 }; 25273 /*\ 25274 * Paper.mask 25275 [ method ] 25276 ** 25277 * Equivalent in behaviour to @Paper.g, except itâs a mask. 25278 ** 25279 = (object) the `mask` element 25280 ** 25281 \*/ 25282 proto.mask = function (first) { 25283 var attr, 25284 el = this.el("mask"); 25285 if (arguments.length == 1 && first && !first.type) { 25286 el.attr(first); 25287 } else if (arguments.length) { 25288 el.add(Array.prototype.slice.call(arguments, 0)); 25289 } 25290 return el; 25291 }; 25292 /*\ 25293 * Paper.ptrn 25294 [ method ] 25295 ** 25296 * Equivalent in behaviour to @Paper.g, except itâs a pattern. 25297 - x (number) @optional X of the element 25298 - y (number) @optional Y of the element 25299 - width (number) @optional width of the element 25300 - height (number) @optional height of the element 25301 - vbx (number) @optional viewbox X 25302 - vby (number) @optional viewbox Y 25303 - vbw (number) @optional viewbox width 25304 - vbh (number) @optional viewbox height 25305 ** 25306 = (object) the `pattern` element 25307 ** 25308 \*/ 25309 proto.ptrn = function (x, y, width, height, vx, vy, vw, vh) { 25310 if (is(x, "object")) { 25311 var attr = x; 25312 } else { 25313 attr = {patternUnits: "userSpaceOnUse"}; 25314 if (x) { 25315 attr.x = x; 25316 } 25317 if (y) { 25318 attr.y = y; 25319 } 25320 if (width != null) { 25321 attr.width = width; 25322 } 25323 if (height != null) { 25324 attr.height = height; 25325 } 25326 if (vx != null && vy != null && vw != null && vh != null) { 25327 attr.viewBox = [vx, vy, vw, vh]; 25328 } else { 25329 attr.viewBox = [x || 0, y || 0, width || 0, height || 0]; 25330 } 25331 } 25332 return this.el("pattern", attr); 25333 }; 25334 /*\ 25335 * Paper.use 25336 [ method ] 25337 ** 25338 * Creates a <use> element. 25339 - id (string) @optional id of element to link 25340 * or 25341 - id (Element) @optional element to link 25342 ** 25343 = (object) the `use` element 25344 ** 25345 \*/ 25346 proto.use = function (id) { 25347 if (id != null) { 25348 if (id instanceof Element) { 25349 if (!id.attr("id")) { 25350 id.attr({id: Snap._.id(id)}); 25351 } 25352 id = id.attr("id"); 25353 } 25354 if (String(id).charAt() == "#") { 25355 id = id.substring(1); 25356 } 25357 return this.el("use", {"xlink:href": "#" + id}); 25358 } else { 25359 return Element.prototype.use.call(this); 25360 } 25361 }; 25362 /*\ 25363 * Paper.symbol 25364 [ method ] 25365 ** 25366 * Creates a <symbol> element. 25367 - vbx (number) @optional viewbox X 25368 - vby (number) @optional viewbox Y 25369 - vbw (number) @optional viewbox width 25370 - vbh (number) @optional viewbox height 25371 = (object) the `symbol` element 25372 ** 25373 \*/ 25374 proto.symbol = function (vx, vy, vw, vh) { 25375 var attr = {}; 25376 if (vx != null && vy != null && vw != null && vh != null) { 25377 attr.viewBox = [vx, vy, vw, vh]; 25378 } 25379 25380 return this.el("symbol", attr); 25381 }; 25382 /*\ 25383 * Paper.text 25384 [ method ] 25385 ** 25386 * Draws a text string 25387 ** 25388 - x (number) x coordinate position 25389 - y (number) y coordinate position 25390 - text (string|array) The text string to draw or array of strings to nest within separate `<tspan>` elements 25391 = (object) the `text` element 25392 ** 25393 > Usage 25394 | var t1 = paper.text(50, 50, "Snap"); 25395 | var t2 = paper.text(50, 50, ["S","n","a","p"]); 25396 | // Text path usage 25397 | t1.attr({textpath: "M10,10L100,100"}); 25398 | // or 25399 | var pth = paper.path("M10,10L100,100"); 25400 | t1.attr({textpath: pth}); 25401 \*/ 25402 proto.text = function (x, y, text) { 25403 var attr = {}; 25404 if (is(x, "object")) { 25405 attr = x; 25406 } else if (x != null) { 25407 attr = { 25408 x: x, 25409 y: y, 25410 text: text || "" 25411 }; 25412 } 25413 return this.el("text", attr); 25414 }; 25415 /*\ 25416 * Paper.line 25417 [ method ] 25418 ** 25419 * Draws a line 25420 ** 25421 - x1 (number) x coordinate position of the start 25422 - y1 (number) y coordinate position of the start 25423 - x2 (number) x coordinate position of the end 25424 - y2 (number) y coordinate position of the end 25425 = (object) the `line` element 25426 ** 25427 > Usage 25428 | var t1 = paper.line(50, 50, 100, 100); 25429 \*/ 25430 proto.line = function (x1, y1, x2, y2) { 25431 var attr = {}; 25432 if (is(x1, "object")) { 25433 attr = x1; 25434 } else if (x1 != null) { 25435 attr = { 25436 x1: x1, 25437 x2: x2, 25438 y1: y1, 25439 y2: y2 25440 }; 25441 } 25442 return this.el("line", attr); 25443 }; 25444 /*\ 25445 * Paper.polyline 25446 [ method ] 25447 ** 25448 * Draws a polyline 25449 ** 25450 - points (array) array of points 25451 * or 25452 - varargs (â¦) points 25453 = (object) the `polyline` element 25454 ** 25455 > Usage 25456 | var p1 = paper.polyline([10, 10, 100, 100]); 25457 | var p2 = paper.polyline(10, 10, 100, 100); 25458 \*/ 25459 proto.polyline = function (points) { 25460 if (arguments.length > 1) { 25461 points = Array.prototype.slice.call(arguments, 0); 25462 } 25463 var attr = {}; 25464 if (is(points, "object") && !is(points, "array")) { 25465 attr = points; 25466 } else if (points != null) { 25467 attr = {points: points}; 25468 } 25469 return this.el("polyline", attr); 25470 }; 25471 /*\ 25472 * Paper.polygon 25473 [ method ] 25474 ** 25475 * Draws a polygon. See @Paper.polyline 25476 \*/ 25477 proto.polygon = function (points) { 25478 if (arguments.length > 1) { 25479 points = Array.prototype.slice.call(arguments, 0); 25480 } 25481 var attr = {}; 25482 if (is(points, "object") && !is(points, "array")) { 25483 attr = points; 25484 } else if (points != null) { 25485 attr = {points: points}; 25486 } 25487 return this.el("polygon", attr); 25488 }; 25489 // gradients 25490 (function () { 25491 var $ = Snap._.$; 25492 // gradients' helpers 25493 /*\ 25494 * Element.stops 25495 [ method ] 25496 ** 25497 * Only for gradients! 25498 * Returns array of gradient stops elements. 25499 = (array) the stops array. 25500 \*/ 25501 function Gstops() { 25502 return this.selectAll("stop"); 25503 } 25504 /*\ 25505 * Element.addStop 25506 [ method ] 25507 ** 25508 * Only for gradients! 25509 * Adds another stop to the gradient. 25510 - color (string) stops color 25511 - offset (number) stops offset 0..100 25512 = (object) gradient element 25513 \*/ 25514 function GaddStop(color, offset) { 25515 var stop = $("stop"), 25516 attr = { 25517 offset: +offset + "%" 25518 }; 25519 color = Snap.color(color); 25520 attr["stop-color"] = color.hex; 25521 if (color.opacity < 1) { 25522 attr["stop-opacity"] = color.opacity; 25523 } 25524 $(stop, attr); 25525 var stops = this.stops(), 25526 inserted; 25527 for (var i = 0; i < stops.length; i++) { 25528 var stopOffset = parseFloat(stops[i].attr("offset")); 25529 if (stopOffset > offset) { 25530 this.node.insertBefore(stop, stops[i].node); 25531 inserted = true; 25532 break; 25533 } 25534 } 25535 if (!inserted) { 25536 this.node.appendChild(stop); 25537 } 25538 return this; 25539 } 25540 function GgetBBox() { 25541 if (this.type == "linearGradient") { 25542 var x1 = $(this.node, "x1") || 0, 25543 x2 = $(this.node, "x2") || 1, 25544 y1 = $(this.node, "y1") || 0, 25545 y2 = $(this.node, "y2") || 0; 25546 return Snap._.box(x1, y1, math.abs(x2 - x1), math.abs(y2 - y1)); 25547 } else { 25548 var cx = this.node.cx || .5, 25549 cy = this.node.cy || .5, 25550 r = this.node.r || 0; 25551 return Snap._.box(cx - r, cy - r, r * 2, r * 2); 25552 } 25553 } 25554 /*\ 25555 * Element.setStops 25556 [ method ] 25557 ** 25558 * Only for gradients! 25559 * Updates stops of the gradient based on passed gradient descriptor. See @Ppaer.gradient 25560 - str (string) gradient descriptor part after `()`. 25561 = (object) gradient element 25562 | var g = paper.gradient("l(0, 0, 1, 1)#000-#f00-#fff"); 25563 | g.setStops("#fff-#000-#f00-#fc0"); 25564 \*/ 25565 function GsetStops(str) { 25566 var grad = str, 25567 stops = this.stops(); 25568 if (typeof str == "string") { 25569 grad = eve("snap.util.grad.parse", null, "l(0,0,0,1)" + str).firstDefined().stops; 25570 } 25571 if (!Snap.is(grad, "array")) { 25572 return; 25573 } 25574 for (var i = 0; i < stops.length; i++) { 25575 if (grad[i]) { 25576 var color = Snap.color(grad[i].color), 25577 attr = {"offset": grad[i].offset + "%"}; 25578 attr["stop-color"] = color.hex; 25579 if (color.opacity < 1) { 25580 attr["stop-opacity"] = color.opacity; 25581 } 25582 stops[i].attr(attr); 25583 } else { 25584 stops[i].remove(); 25585 } 25586 } 25587 for (i = stops.length; i < grad.length; i++) { 25588 this.addStop(grad[i].color, grad[i].offset); 25589 } 25590 return this; 25591 } 25592 function gradient(defs, str) { 25593 var grad = eve("snap.util.grad.parse", null, str).firstDefined(), 25594 el; 25595 if (!grad) { 25596 return null; 25597 } 25598 grad.params.unshift(defs); 25599 if (grad.type.toLowerCase() == "l") { 25600 el = gradientLinear.apply(0, grad.params); 25601 } else { 25602 el = gradientRadial.apply(0, grad.params); 25603 } 25604 if (grad.type != grad.type.toLowerCase()) { 25605 $(el.node, { 25606 gradientUnits: "userSpaceOnUse" 25607 }); 25608 } 25609 var stops = grad.stops, 25610 len = stops.length; 25611 for (var i = 0; i < len; i++) { 25612 var stop = stops[i]; 25613 el.addStop(stop.color, stop.offset); 25614 } 25615 return el; 25616 } 25617 function gradientLinear(defs, x1, y1, x2, y2) { 25618 var el = Snap._.make("linearGradient", defs); 25619 el.stops = Gstops; 25620 el.addStop = GaddStop; 25621 el.getBBox = GgetBBox; 25622 el.setStops = GsetStops; 25623 if (x1 != null) { 25624 $(el.node, { 25625 x1: x1, 25626 y1: y1, 25627 x2: x2, 25628 y2: y2 25629 }); 25630 } 25631 return el; 25632 } 25633 function gradientRadial(defs, cx, cy, r, fx, fy) { 25634 var el = Snap._.make("radialGradient", defs); 25635 el.stops = Gstops; 25636 el.addStop = GaddStop; 25637 el.getBBox = GgetBBox; 25638 if (cx != null) { 25639 $(el.node, { 25640 cx: cx, 25641 cy: cy, 25642 r: r 25643 }); 25644 } 25645 if (fx != null && fy != null) { 25646 $(el.node, { 25647 fx: fx, 25648 fy: fy 25649 }); 25650 } 25651 return el; 25652 } 25653 /*\ 25654 * Paper.gradient 25655 [ method ] 25656 ** 25657 * Creates a gradient element 25658 ** 25659 - gradient (string) gradient descriptor 25660 > Gradient Descriptor 25661 * The gradient descriptor is an expression formatted as 25662 * follows: `<type>(<coords>)<colors>`. The `<type>` can be 25663 * either linear or radial. The uppercase `L` or `R` letters 25664 * indicate absolute coordinates offset from the SVG surface. 25665 * Lowercase `l` or `r` letters indicate coordinates 25666 * calculated relative to the element to which the gradient is 25667 * applied. Coordinates specify a linear gradient vector as 25668 * `x1`, `y1`, `x2`, `y2`, or a radial gradient as `cx`, `cy`, 25669 * `r` and optional `fx`, `fy` specifying a focal point away 25670 * from the center of the circle. Specify `<colors>` as a list 25671 * of dash-separated CSS color values. Each color may be 25672 * followed by a custom offset value, separated with a colon 25673 * character. 25674 > Examples 25675 * Linear gradient, relative from top-left corner to bottom-right 25676 * corner, from black through red to white: 25677 | var g = paper.gradient("l(0, 0, 1, 1)#000-#f00-#fff"); 25678 * Linear gradient, absolute from (0, 0) to (100, 100), from black 25679 * through red at 25% to white: 25680 | var g = paper.gradient("L(0, 0, 100, 100)#000-#f00:25-#fff"); 25681 * Radial gradient, relative from the center of the element with radius 25682 * half the width, from black to white: 25683 | var g = paper.gradient("r(0.5, 0.5, 0.5)#000-#fff"); 25684 * To apply the gradient: 25685 | paper.circle(50, 50, 40).attr({ 25686 | fill: g 25687 | }); 25688 = (object) the `gradient` element 25689 \*/ 25690 proto.gradient = function (str) { 25691 return gradient(this.defs, str); 25692 }; 25693 proto.gradientLinear = function (x1, y1, x2, y2) { 25694 return gradientLinear(this.defs, x1, y1, x2, y2); 25695 }; 25696 proto.gradientRadial = function (cx, cy, r, fx, fy) { 25697 return gradientRadial(this.defs, cx, cy, r, fx, fy); 25698 }; 25699 /*\ 25700 * Paper.toString 25701 [ method ] 25702 ** 25703 * Returns SVG code for the @Paper 25704 = (string) SVG code for the @Paper 25705 \*/ 25706 proto.toString = function () { 25707 var doc = this.node.ownerDocument, 25708 f = doc.createDocumentFragment(), 25709 d = doc.createElement("div"), 25710 svg = this.node.cloneNode(true), 25711 res; 25712 f.appendChild(d); 25713 d.appendChild(svg); 25714 Snap._.$(svg, {xmlns: "http://www.w3.org/2000/svg"}); 25715 res = d.innerHTML; 25716 f.removeChild(f.firstChild); 25717 return res; 25718 }; 25719 /*\ 25720 * Paper.toDataURL 25721 [ method ] 25722 ** 25723 * Returns SVG code for the @Paper as Data URI string. 25724 = (string) Data URI string 25725 \*/ 25726 proto.toDataURL = function () { 25727 if (window && window.btoa) { 25728 return "data:image/svg+xml;base64," + btoa(unescape(encodeURIComponent(this))); 25729 } 25730 }; 25731 /*\ 25732 * Paper.clear 25733 [ method ] 25734 ** 25735 * Removes all child nodes of the paper, except <defs>. 25736 \*/ 25737 proto.clear = function () { 25738 var node = this.node.firstChild, 25739 next; 25740 while (node) { 25741 next = node.nextSibling; 25742 if (node.tagName != "defs") { 25743 node.parentNode.removeChild(node); 25744 } else { 25745 proto.clear.call({node: node}); 25746 } 25747 node = next; 25748 } 25749 }; 25750 }()); 25751}); 25752 25753// Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved. 25754// 25755// Licensed under the Apache License, Version 2.0 (the "License"); 25756// you may not use this file except in compliance with the License. 25757// You may obtain a copy of the License at 25758// 25759// http://www.apache.org/licenses/LICENSE-2.0 25760// 25761// Unless required by applicable law or agreed to in writing, software 25762// distributed under the License is distributed on an "AS IS" BASIS, 25763// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 25764// See the License for the specific language governing permissions and 25765// limitations under the License. 25766Snap.plugin(function (Snap, Element, Paper, glob) { 25767 var elproto = Element.prototype, 25768 is = Snap.is, 25769 clone = Snap._.clone, 25770 has = "hasOwnProperty", 25771 p2s = /,?([a-z]),?/gi, 25772 toFloat = parseFloat, 25773 math = Math, 25774 PI = math.PI, 25775 mmin = math.min, 25776 mmax = math.max, 25777 pow = math.pow, 25778 abs = math.abs; 25779 function paths(ps) { 25780 var p = paths.ps = paths.ps || {}; 25781 if (p[ps]) { 25782 p[ps].sleep = 100; 25783 } else { 25784 p[ps] = { 25785 sleep: 100 25786 }; 25787 } 25788 setTimeout(function () { 25789 for (var key in p) if (p[has](key) && key != ps) { 25790 p[key].sleep--; 25791 !p[key].sleep && delete p[key]; 25792 } 25793 }); 25794 return p[ps]; 25795 } 25796 function box(x, y, width, height) { 25797 if (x == null) { 25798 x = y = width = height = 0; 25799 } 25800 if (y == null) { 25801 y = x.y; 25802 width = x.width; 25803 height = x.height; 25804 x = x.x; 25805 } 25806 return { 25807 x: x, 25808 y: y, 25809 width: width, 25810 w: width, 25811 height: height, 25812 h: height, 25813 x2: x + width, 25814 y2: y + height, 25815 cx: x + width / 2, 25816 cy: y + height / 2, 25817 r1: math.min(width, height) / 2, 25818 r2: math.max(width, height) / 2, 25819 r0: math.sqrt(width * width + height * height) / 2, 25820 path: rectPath(x, y, width, height), 25821 vb: [x, y, width, height].join(" ") 25822 }; 25823 } 25824 function toString() { 25825 return this.join(",").replace(p2s, "$1"); 25826 } 25827 function pathClone(pathArray) { 25828 var res = clone(pathArray); 25829 res.toString = toString; 25830 return res; 25831 } 25832 function getPointAtSegmentLength(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, length) { 25833 if (length == null) { 25834 return bezlen(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y); 25835 } else { 25836 return findDotsAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, 25837 getTotLen(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, length)); 25838 } 25839 } 25840 function getLengthFactory(istotal, subpath) { 25841 function O(val) { 25842 return +(+val).toFixed(3); 25843 } 25844 return Snap._.cacher(function (path, length, onlystart) { 25845 if (path instanceof Element) { 25846 path = path.attr("d"); 25847 } 25848 path = path2curve(path); 25849 var x, y, p, l, sp = "", subpaths = {}, point, 25850 len = 0; 25851 for (var i = 0, ii = path.length; i < ii; i++) { 25852 p = path[i]; 25853 if (p[0] == "M") { 25854 x = +p[1]; 25855 y = +p[2]; 25856 } else { 25857 l = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6]); 25858 if (len + l > length) { 25859 if (subpath && !subpaths.start) { 25860 point = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6], length - len); 25861 sp += [ 25862 "C" + O(point.start.x), 25863 O(point.start.y), 25864 O(point.m.x), 25865 O(point.m.y), 25866 O(point.x), 25867 O(point.y) 25868 ]; 25869 if (onlystart) {return sp;} 25870 subpaths.start = sp; 25871 sp = [ 25872 "M" + O(point.x), 25873 O(point.y) + "C" + O(point.n.x), 25874 O(point.n.y), 25875 O(point.end.x), 25876 O(point.end.y), 25877 O(p[5]), 25878 O(p[6]) 25879 ].join(); 25880 len += l; 25881 x = +p[5]; 25882 y = +p[6]; 25883 continue; 25884 } 25885 if (!istotal && !subpath) { 25886 point = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6], length - len); 25887 return point; 25888 } 25889 } 25890 len += l; 25891 x = +p[5]; 25892 y = +p[6]; 25893 } 25894 sp += p.shift() + p; 25895 } 25896 subpaths.end = sp; 25897 point = istotal ? len : subpath ? subpaths : findDotsAtSegment(x, y, p[0], p[1], p[2], p[3], p[4], p[5], 1); 25898 return point; 25899 }, null, Snap._.clone); 25900 } 25901 var getTotalLength = getLengthFactory(1), 25902 getPointAtLength = getLengthFactory(), 25903 getSubpathsAtLength = getLengthFactory(0, 1); 25904 function findDotsAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) { 25905 var t1 = 1 - t, 25906 t13 = pow(t1, 3), 25907 t12 = pow(t1, 2), 25908 t2 = t * t, 25909 t3 = t2 * t, 25910 x = t13 * p1x + t12 * 3 * t * c1x + t1 * 3 * t * t * c2x + t3 * p2x, 25911 y = t13 * p1y + t12 * 3 * t * c1y + t1 * 3 * t * t * c2y + t3 * p2y, 25912 mx = p1x + 2 * t * (c1x - p1x) + t2 * (c2x - 2 * c1x + p1x), 25913 my = p1y + 2 * t * (c1y - p1y) + t2 * (c2y - 2 * c1y + p1y), 25914 nx = c1x + 2 * t * (c2x - c1x) + t2 * (p2x - 2 * c2x + c1x), 25915 ny = c1y + 2 * t * (c2y - c1y) + t2 * (p2y - 2 * c2y + c1y), 25916 ax = t1 * p1x + t * c1x, 25917 ay = t1 * p1y + t * c1y, 25918 cx = t1 * c2x + t * p2x, 25919 cy = t1 * c2y + t * p2y, 25920 alpha = 90 - math.atan2(mx - nx, my - ny) * 180 / PI; 25921 // (mx > nx || my < ny) && (alpha += 180); 25922 return { 25923 x: x, 25924 y: y, 25925 m: {x: mx, y: my}, 25926 n: {x: nx, y: ny}, 25927 start: {x: ax, y: ay}, 25928 end: {x: cx, y: cy}, 25929 alpha: alpha 25930 }; 25931 } 25932 function bezierBBox(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y) { 25933 if (!Snap.is(p1x, "array")) { 25934 p1x = [p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y]; 25935 } 25936 var bbox = curveDim.apply(null, p1x); 25937 return box( 25938 bbox.min.x, 25939 bbox.min.y, 25940 bbox.max.x - bbox.min.x, 25941 bbox.max.y - bbox.min.y 25942 ); 25943 } 25944 function isPointInsideBBox(bbox, x, y) { 25945 return x >= bbox.x && 25946 x <= bbox.x + bbox.width && 25947 y >= bbox.y && 25948 y <= bbox.y + bbox.height; 25949 } 25950 function isBBoxIntersect(bbox1, bbox2) { 25951 bbox1 = box(bbox1); 25952 bbox2 = box(bbox2); 25953 return isPointInsideBBox(bbox2, bbox1.x, bbox1.y) 25954 || isPointInsideBBox(bbox2, bbox1.x2, bbox1.y) 25955 || isPointInsideBBox(bbox2, bbox1.x, bbox1.y2) 25956 || isPointInsideBBox(bbox2, bbox1.x2, bbox1.y2) 25957 || isPointInsideBBox(bbox1, bbox2.x, bbox2.y) 25958 || isPointInsideBBox(bbox1, bbox2.x2, bbox2.y) 25959 || isPointInsideBBox(bbox1, bbox2.x, bbox2.y2) 25960 || isPointInsideBBox(bbox1, bbox2.x2, bbox2.y2) 25961 || (bbox1.x < bbox2.x2 && bbox1.x > bbox2.x 25962 || bbox2.x < bbox1.x2 && bbox2.x > bbox1.x) 25963 && (bbox1.y < bbox2.y2 && bbox1.y > bbox2.y 25964 || bbox2.y < bbox1.y2 && bbox2.y > bbox1.y); 25965 } 25966 function base3(t, p1, p2, p3, p4) { 25967 var t1 = -3 * p1 + 9 * p2 - 9 * p3 + 3 * p4, 25968 t2 = t * t1 + 6 * p1 - 12 * p2 + 6 * p3; 25969 return t * t2 - 3 * p1 + 3 * p2; 25970 } 25971 function bezlen(x1, y1, x2, y2, x3, y3, x4, y4, z) { 25972 if (z == null) { 25973 z = 1; 25974 } 25975 z = z > 1 ? 1 : z < 0 ? 0 : z; 25976 var z2 = z / 2, 25977 n = 12, 25978 Tvalues = [-.1252,.1252,-.3678,.3678,-.5873,.5873,-.7699,.7699,-.9041,.9041,-.9816,.9816], 25979 Cvalues = [0.2491,0.2491,0.2335,0.2335,0.2032,0.2032,0.1601,0.1601,0.1069,0.1069,0.0472,0.0472], 25980 sum = 0; 25981 for (var i = 0; i < n; i++) { 25982 var ct = z2 * Tvalues[i] + z2, 25983 xbase = base3(ct, x1, x2, x3, x4), 25984 ybase = base3(ct, y1, y2, y3, y4), 25985 comb = xbase * xbase + ybase * ybase; 25986 sum += Cvalues[i] * math.sqrt(comb); 25987 } 25988 return z2 * sum; 25989 } 25990 function getTotLen(x1, y1, x2, y2, x3, y3, x4, y4, ll) { 25991 if (ll < 0 || bezlen(x1, y1, x2, y2, x3, y3, x4, y4) < ll) { 25992 return; 25993 } 25994 var t = 1, 25995 step = t / 2, 25996 t2 = t - step, 25997 l, 25998 e = .01; 25999 l = bezlen(x1, y1, x2, y2, x3, y3, x4, y4, t2); 26000 while (abs(l - ll) > e) { 26001 step /= 2; 26002 t2 += (l < ll ? 1 : -1) * step; 26003 l = bezlen(x1, y1, x2, y2, x3, y3, x4, y4, t2); 26004 } 26005 return t2; 26006 } 26007 function intersect(x1, y1, x2, y2, x3, y3, x4, y4) { 26008 if ( 26009 mmax(x1, x2) < mmin(x3, x4) || 26010 mmin(x1, x2) > mmax(x3, x4) || 26011 mmax(y1, y2) < mmin(y3, y4) || 26012 mmin(y1, y2) > mmax(y3, y4) 26013 ) { 26014 return; 26015 } 26016 var nx = (x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4), 26017 ny = (x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4), 26018 denominator = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4); 26019 26020 if (!denominator) { 26021 return; 26022 } 26023 var px = nx / denominator, 26024 py = ny / denominator, 26025 px2 = +px.toFixed(2), 26026 py2 = +py.toFixed(2); 26027 if ( 26028 px2 < +mmin(x1, x2).toFixed(2) || 26029 px2 > +mmax(x1, x2).toFixed(2) || 26030 px2 < +mmin(x3, x4).toFixed(2) || 26031 px2 > +mmax(x3, x4).toFixed(2) || 26032 py2 < +mmin(y1, y2).toFixed(2) || 26033 py2 > +mmax(y1, y2).toFixed(2) || 26034 py2 < +mmin(y3, y4).toFixed(2) || 26035 py2 > +mmax(y3, y4).toFixed(2) 26036 ) { 26037 return; 26038 } 26039 return {x: px, y: py}; 26040 } 26041 function inter(bez1, bez2) { 26042 return interHelper(bez1, bez2); 26043 } 26044 function interCount(bez1, bez2) { 26045 return interHelper(bez1, bez2, 1); 26046 } 26047 function interHelper(bez1, bez2, justCount) { 26048 var bbox1 = bezierBBox(bez1), 26049 bbox2 = bezierBBox(bez2); 26050 if (!isBBoxIntersect(bbox1, bbox2)) { 26051 return justCount ? 0 : []; 26052 } 26053 var l1 = bezlen.apply(0, bez1), 26054 l2 = bezlen.apply(0, bez2), 26055 n1 = ~~(l1 / 8), 26056 n2 = ~~(l2 / 8), 26057 dots1 = [], 26058 dots2 = [], 26059 xy = {}, 26060 res = justCount ? 0 : []; 26061 for (var i = 0; i < n1 + 1; i++) { 26062 var p = findDotsAtSegment.apply(0, bez1.concat(i / n1)); 26063 dots1.push({x: p.x, y: p.y, t: i / n1}); 26064 } 26065 for (i = 0; i < n2 + 1; i++) { 26066 p = findDotsAtSegment.apply(0, bez2.concat(i / n2)); 26067 dots2.push({x: p.x, y: p.y, t: i / n2}); 26068 } 26069 for (i = 0; i < n1; i++) { 26070 for (var j = 0; j < n2; j++) { 26071 var di = dots1[i], 26072 di1 = dots1[i + 1], 26073 dj = dots2[j], 26074 dj1 = dots2[j + 1], 26075 ci = abs(di1.x - di.x) < .001 ? "y" : "x", 26076 cj = abs(dj1.x - dj.x) < .001 ? "y" : "x", 26077 is = intersect(di.x, di.y, di1.x, di1.y, dj.x, dj.y, dj1.x, dj1.y); 26078 if (is) { 26079 if (xy[is.x.toFixed(4)] == is.y.toFixed(4)) { 26080 continue; 26081 } 26082 xy[is.x.toFixed(4)] = is.y.toFixed(4); 26083 var t1 = di.t + abs((is[ci] - di[ci]) / (di1[ci] - di[ci])) * (di1.t - di.t), 26084 t2 = dj.t + abs((is[cj] - dj[cj]) / (dj1[cj] - dj[cj])) * (dj1.t - dj.t); 26085 if (t1 >= 0 && t1 <= 1 && t2 >= 0 && t2 <= 1) { 26086 if (justCount) { 26087 res++; 26088 } else { 26089 res.push({ 26090 x: is.x, 26091 y: is.y, 26092 t1: t1, 26093 t2: t2 26094 }); 26095 } 26096 } 26097 } 26098 } 26099 } 26100 return res; 26101 } 26102 function pathIntersection(path1, path2) { 26103 return interPathHelper(path1, path2); 26104 } 26105 function pathIntersectionNumber(path1, path2) { 26106 return interPathHelper(path1, path2, 1); 26107 } 26108 function interPathHelper(path1, path2, justCount) { 26109 path1 = path2curve(path1); 26110 path2 = path2curve(path2); 26111 var x1, y1, x2, y2, x1m, y1m, x2m, y2m, bez1, bez2, 26112 res = justCount ? 0 : []; 26113 for (var i = 0, ii = path1.length; i < ii; i++) { 26114 var pi = path1[i]; 26115 if (pi[0] == "M") { 26116 x1 = x1m = pi[1]; 26117 y1 = y1m = pi[2]; 26118 } else { 26119 if (pi[0] == "C") { 26120 bez1 = [x1, y1].concat(pi.slice(1)); 26121 x1 = bez1[6]; 26122 y1 = bez1[7]; 26123 } else { 26124 bez1 = [x1, y1, x1, y1, x1m, y1m, x1m, y1m]; 26125 x1 = x1m; 26126 y1 = y1m; 26127 } 26128 for (var j = 0, jj = path2.length; j < jj; j++) { 26129 var pj = path2[j]; 26130 if (pj[0] == "M") { 26131 x2 = x2m = pj[1]; 26132 y2 = y2m = pj[2]; 26133 } else { 26134 if (pj[0] == "C") { 26135 bez2 = [x2, y2].concat(pj.slice(1)); 26136 x2 = bez2[6]; 26137 y2 = bez2[7]; 26138 } else { 26139 bez2 = [x2, y2, x2, y2, x2m, y2m, x2m, y2m]; 26140 x2 = x2m; 26141 y2 = y2m; 26142 } 26143 var intr = interHelper(bez1, bez2, justCount); 26144 if (justCount) { 26145 res += intr; 26146 } else { 26147 for (var k = 0, kk = intr.length; k < kk; k++) { 26148 intr[k].segment1 = i; 26149 intr[k].segment2 = j; 26150 intr[k].bez1 = bez1; 26151 intr[k].bez2 = bez2; 26152 } 26153 res = res.concat(intr); 26154 } 26155 } 26156 } 26157 } 26158 } 26159 return res; 26160 } 26161 function isPointInsidePath(path, x, y) { 26162 var bbox = pathBBox(path); 26163 return isPointInsideBBox(bbox, x, y) && 26164 interPathHelper(path, [["M", x, y], ["H", bbox.x2 + 10]], 1) % 2 == 1; 26165 } 26166 function pathBBox(path) { 26167 var pth = paths(path); 26168 if (pth.bbox) { 26169 return clone(pth.bbox); 26170 } 26171 if (!path) { 26172 return box(); 26173 } 26174 path = path2curve(path); 26175 var x = 0, 26176 y = 0, 26177 X = [], 26178 Y = [], 26179 p; 26180 for (var i = 0, ii = path.length; i < ii; i++) { 26181 p = path[i]; 26182 if (p[0] == "M") { 26183 x = p[1]; 26184 y = p[2]; 26185 X.push(x); 26186 Y.push(y); 26187 } else { 26188 var dim = curveDim(x, y, p[1], p[2], p[3], p[4], p[5], p[6]); 26189 X = X.concat(dim.min.x, dim.max.x); 26190 Y = Y.concat(dim.min.y, dim.max.y); 26191 x = p[5]; 26192 y = p[6]; 26193 } 26194 } 26195 var xmin = mmin.apply(0, X), 26196 ymin = mmin.apply(0, Y), 26197 xmax = mmax.apply(0, X), 26198 ymax = mmax.apply(0, Y), 26199 bb = box(xmin, ymin, xmax - xmin, ymax - ymin); 26200 pth.bbox = clone(bb); 26201 return bb; 26202 } 26203 function rectPath(x, y, w, h, r) { 26204 if (r) { 26205 return [ 26206 ["M", +x + +r, y], 26207 ["l", w - r * 2, 0], 26208 ["a", r, r, 0, 0, 1, r, r], 26209 ["l", 0, h - r * 2], 26210 ["a", r, r, 0, 0, 1, -r, r], 26211 ["l", r * 2 - w, 0], 26212 ["a", r, r, 0, 0, 1, -r, -r], 26213 ["l", 0, r * 2 - h], 26214 ["a", r, r, 0, 0, 1, r, -r], 26215 ["z"] 26216 ]; 26217 } 26218 var res = [["M", x, y], ["l", w, 0], ["l", 0, h], ["l", -w, 0], ["z"]]; 26219 res.toString = toString; 26220 return res; 26221 } 26222 function ellipsePath(x, y, rx, ry, a) { 26223 if (a == null && ry == null) { 26224 ry = rx; 26225 } 26226 x = +x; 26227 y = +y; 26228 rx = +rx; 26229 ry = +ry; 26230 if (a != null) { 26231 var rad = Math.PI / 180, 26232 x1 = x + rx * Math.cos(-ry * rad), 26233 x2 = x + rx * Math.cos(-a * rad), 26234 y1 = y + rx * Math.sin(-ry * rad), 26235 y2 = y + rx * Math.sin(-a * rad), 26236 res = [["M", x1, y1], ["A", rx, rx, 0, +(a - ry > 180), 0, x2, y2]]; 26237 } else { 26238 res = [ 26239 ["M", x, y], 26240 ["m", 0, -ry], 26241 ["a", rx, ry, 0, 1, 1, 0, 2 * ry], 26242 ["a", rx, ry, 0, 1, 1, 0, -2 * ry], 26243 ["z"] 26244 ]; 26245 } 26246 res.toString = toString; 26247 return res; 26248 } 26249 var unit2px = Snap._unit2px, 26250 getPath = { 26251 path: function (el) { 26252 return el.attr("path"); 26253 }, 26254 circle: function (el) { 26255 var attr = unit2px(el); 26256 return ellipsePath(attr.cx, attr.cy, attr.r); 26257 }, 26258 ellipse: function (el) { 26259 var attr = unit2px(el); 26260 return ellipsePath(attr.cx || 0, attr.cy || 0, attr.rx, attr.ry); 26261 }, 26262 rect: function (el) { 26263 var attr = unit2px(el); 26264 return rectPath(attr.x || 0, attr.y || 0, attr.width, attr.height, attr.rx, attr.ry); 26265 }, 26266 image: function (el) { 26267 var attr = unit2px(el); 26268 return rectPath(attr.x || 0, attr.y || 0, attr.width, attr.height); 26269 }, 26270 line: function (el) { 26271 return "M" + [el.attr("x1") || 0, el.attr("y1") || 0, el.attr("x2"), el.attr("y2")]; 26272 }, 26273 polyline: function (el) { 26274 return "M" + el.attr("points"); 26275 }, 26276 polygon: function (el) { 26277 return "M" + el.attr("points") + "z"; 26278 }, 26279 deflt: function (el) { 26280 var bbox = el.node.getBBox(); 26281 return rectPath(bbox.x, bbox.y, bbox.width, bbox.height); 26282 } 26283 }; 26284 function pathToRelative(pathArray) { 26285 var pth = paths(pathArray), 26286 lowerCase = String.prototype.toLowerCase; 26287 if (pth.rel) { 26288 return pathClone(pth.rel); 26289 } 26290 if (!Snap.is(pathArray, "array") || !Snap.is(pathArray && pathArray[0], "array")) { 26291 pathArray = Snap.parsePathString(pathArray); 26292 } 26293 var res = [], 26294 x = 0, 26295 y = 0, 26296 mx = 0, 26297 my = 0, 26298 start = 0; 26299 if (pathArray[0][0] == "M") { 26300 x = pathArray[0][1]; 26301 y = pathArray[0][2]; 26302 mx = x; 26303 my = y; 26304 start++; 26305 res.push(["M", x, y]); 26306 } 26307 for (var i = start, ii = pathArray.length; i < ii; i++) { 26308 var r = res[i] = [], 26309 pa = pathArray[i]; 26310 if (pa[0] != lowerCase.call(pa[0])) { 26311 r[0] = lowerCase.call(pa[0]); 26312 switch (r[0]) { 26313 case "a": 26314 r[1] = pa[1]; 26315 r[2] = pa[2]; 26316 r[3] = pa[3]; 26317 r[4] = pa[4]; 26318 r[5] = pa[5]; 26319 r[6] = +(pa[6] - x).toFixed(3); 26320 r[7] = +(pa[7] - y).toFixed(3); 26321 break; 26322 case "v": 26323 r[1] = +(pa[1] - y).toFixed(3); 26324 break; 26325 case "m": 26326 mx = pa[1]; 26327 my = pa[2]; 26328 default: 26329 for (var j = 1, jj = pa.length; j < jj; j++) { 26330 r[j] = +(pa[j] - (j % 2 ? x : y)).toFixed(3); 26331 } 26332 } 26333 } else { 26334 r = res[i] = []; 26335 if (pa[0] == "m") { 26336 mx = pa[1] + x; 26337 my = pa[2] + y; 26338 } 26339 for (var k = 0, kk = pa.length; k < kk; k++) { 26340 res[i][k] = pa[k]; 26341 } 26342 } 26343 var len = res[i].length; 26344 switch (res[i][0]) { 26345 case "z": 26346 x = mx; 26347 y = my; 26348 break; 26349 case "h": 26350 x += +res[i][len - 1]; 26351 break; 26352 case "v": 26353 y += +res[i][len - 1]; 26354 break; 26355 default: 26356 x += +res[i][len - 2]; 26357 y += +res[i][len - 1]; 26358 } 26359 } 26360 res.toString = toString; 26361 pth.rel = pathClone(res); 26362 return res; 26363 } 26364 function pathToAbsolute(pathArray) { 26365 var pth = paths(pathArray); 26366 if (pth.abs) { 26367 return pathClone(pth.abs); 26368 } 26369 if (!is(pathArray, "array") || !is(pathArray && pathArray[0], "array")) { // rough assumption 26370 pathArray = Snap.parsePathString(pathArray); 26371 } 26372 if (!pathArray || !pathArray.length) { 26373 return [["M", 0, 0]]; 26374 } 26375 var res = [], 26376 x = 0, 26377 y = 0, 26378 mx = 0, 26379 my = 0, 26380 start = 0, 26381 pa0; 26382 if (pathArray[0][0] == "M") { 26383 x = +pathArray[0][1]; 26384 y = +pathArray[0][2]; 26385 mx = x; 26386 my = y; 26387 start++; 26388 res[0] = ["M", x, y]; 26389 } 26390 var crz = pathArray.length == 3 && 26391 pathArray[0][0] == "M" && 26392 pathArray[1][0].toUpperCase() == "R" && 26393 pathArray[2][0].toUpperCase() == "Z"; 26394 for (var r, pa, i = start, ii = pathArray.length; i < ii; i++) { 26395 res.push(r = []); 26396 pa = pathArray[i]; 26397 pa0 = pa[0]; 26398 if (pa0 != pa0.toUpperCase()) { 26399 r[0] = pa0.toUpperCase(); 26400 switch (r[0]) { 26401 case "A": 26402 r[1] = pa[1]; 26403 r[2] = pa[2]; 26404 r[3] = pa[3]; 26405 r[4] = pa[4]; 26406 r[5] = pa[5]; 26407 r[6] = +pa[6] + x; 26408 r[7] = +pa[7] + y; 26409 break; 26410 case "V": 26411 r[1] = +pa[1] + y; 26412 break; 26413 case "H": 26414 r[1] = +pa[1] + x; 26415 break; 26416 case "R": 26417 var dots = [x, y].concat(pa.slice(1)); 26418 for (var j = 2, jj = dots.length; j < jj; j++) { 26419 dots[j] = +dots[j] + x; 26420 dots[++j] = +dots[j] + y; 26421 } 26422 res.pop(); 26423 res = res.concat(catmullRom2bezier(dots, crz)); 26424 break; 26425 case "O": 26426 res.pop(); 26427 dots = ellipsePath(x, y, pa[1], pa[2]); 26428 dots.push(dots[0]); 26429 res = res.concat(dots); 26430 break; 26431 case "U": 26432 res.pop(); 26433 res = res.concat(ellipsePath(x, y, pa[1], pa[2], pa[3])); 26434 r = ["U"].concat(res[res.length - 1].slice(-2)); 26435 break; 26436 case "M": 26437 mx = +pa[1] + x; 26438 my = +pa[2] + y; 26439 default: 26440 for (j = 1, jj = pa.length; j < jj; j++) { 26441 r[j] = +pa[j] + (j % 2 ? x : y); 26442 } 26443 } 26444 } else if (pa0 == "R") { 26445 dots = [x, y].concat(pa.slice(1)); 26446 res.pop(); 26447 res = res.concat(catmullRom2bezier(dots, crz)); 26448 r = ["R"].concat(pa.slice(-2)); 26449 } else if (pa0 == "O") { 26450 res.pop(); 26451 dots = ellipsePath(x, y, pa[1], pa[2]); 26452 dots.push(dots[0]); 26453 res = res.concat(dots); 26454 } else if (pa0 == "U") { 26455 res.pop(); 26456 res = res.concat(ellipsePath(x, y, pa[1], pa[2], pa[3])); 26457 r = ["U"].concat(res[res.length - 1].slice(-2)); 26458 } else { 26459 for (var k = 0, kk = pa.length; k < kk; k++) { 26460 r[k] = pa[k]; 26461 } 26462 } 26463 pa0 = pa0.toUpperCase(); 26464 if (pa0 != "O") { 26465 switch (r[0]) { 26466 case "Z": 26467 x = +mx; 26468 y = +my; 26469 break; 26470 case "H": 26471 x = r[1]; 26472 break; 26473 case "V": 26474 y = r[1]; 26475 break; 26476 case "M": 26477 mx = r[r.length - 2]; 26478 my = r[r.length - 1]; 26479 default: 26480 x = r[r.length - 2]; 26481 y = r[r.length - 1]; 26482 } 26483 } 26484 } 26485 res.toString = toString; 26486 pth.abs = pathClone(res); 26487 return res; 26488 } 26489 function l2c(x1, y1, x2, y2) { 26490 return [x1, y1, x2, y2, x2, y2]; 26491 } 26492 function q2c(x1, y1, ax, ay, x2, y2) { 26493 var _13 = 1 / 3, 26494 _23 = 2 / 3; 26495 return [ 26496 _13 * x1 + _23 * ax, 26497 _13 * y1 + _23 * ay, 26498 _13 * x2 + _23 * ax, 26499 _13 * y2 + _23 * ay, 26500 x2, 26501 y2 26502 ]; 26503 } 26504 function a2c(x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2, recursive) { 26505 // for more information of where this math came from visit: 26506 // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes 26507 var _120 = PI * 120 / 180, 26508 rad = PI / 180 * (+angle || 0), 26509 res = [], 26510 xy, 26511 rotate = Snap._.cacher(function (x, y, rad) { 26512 var X = x * math.cos(rad) - y * math.sin(rad), 26513 Y = x * math.sin(rad) + y * math.cos(rad); 26514 return {x: X, y: Y}; 26515 }); 26516 if (!rx || !ry) { 26517 return [x1, y1, x2, y2, x2, y2]; 26518 } 26519 if (!recursive) { 26520 xy = rotate(x1, y1, -rad); 26521 x1 = xy.x; 26522 y1 = xy.y; 26523 xy = rotate(x2, y2, -rad); 26524 x2 = xy.x; 26525 y2 = xy.y; 26526 var cos = math.cos(PI / 180 * angle), 26527 sin = math.sin(PI / 180 * angle), 26528 x = (x1 - x2) / 2, 26529 y = (y1 - y2) / 2; 26530 var h = x * x / (rx * rx) + y * y / (ry * ry); 26531 if (h > 1) { 26532 h = math.sqrt(h); 26533 rx = h * rx; 26534 ry = h * ry; 26535 } 26536 var rx2 = rx * rx, 26537 ry2 = ry * ry, 26538 k = (large_arc_flag == sweep_flag ? -1 : 1) * 26539 math.sqrt(abs((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x))), 26540 cx = k * rx * y / ry + (x1 + x2) / 2, 26541 cy = k * -ry * x / rx + (y1 + y2) / 2, 26542 f1 = math.asin(((y1 - cy) / ry).toFixed(9)), 26543 f2 = math.asin(((y2 - cy) / ry).toFixed(9)); 26544 26545 f1 = x1 < cx ? PI - f1 : f1; 26546 f2 = x2 < cx ? PI - f2 : f2; 26547 f1 < 0 && (f1 = PI * 2 + f1); 26548 f2 < 0 && (f2 = PI * 2 + f2); 26549 if (sweep_flag && f1 > f2) { 26550 f1 = f1 - PI * 2; 26551 } 26552 if (!sweep_flag && f2 > f1) { 26553 f2 = f2 - PI * 2; 26554 } 26555 } else { 26556 f1 = recursive[0]; 26557 f2 = recursive[1]; 26558 cx = recursive[2]; 26559 cy = recursive[3]; 26560 } 26561 var df = f2 - f1; 26562 if (abs(df) > _120) { 26563 var f2old = f2, 26564 x2old = x2, 26565 y2old = y2; 26566 f2 = f1 + _120 * (sweep_flag && f2 > f1 ? 1 : -1); 26567 x2 = cx + rx * math.cos(f2); 26568 y2 = cy + ry * math.sin(f2); 26569 res = a2c(x2, y2, rx, ry, angle, 0, sweep_flag, x2old, y2old, [f2, f2old, cx, cy]); 26570 } 26571 df = f2 - f1; 26572 var c1 = math.cos(f1), 26573 s1 = math.sin(f1), 26574 c2 = math.cos(f2), 26575 s2 = math.sin(f2), 26576 t = math.tan(df / 4), 26577 hx = 4 / 3 * rx * t, 26578 hy = 4 / 3 * ry * t, 26579 m1 = [x1, y1], 26580 m2 = [x1 + hx * s1, y1 - hy * c1], 26581 m3 = [x2 + hx * s2, y2 - hy * c2], 26582 m4 = [x2, y2]; 26583 m2[0] = 2 * m1[0] - m2[0]; 26584 m2[1] = 2 * m1[1] - m2[1]; 26585 if (recursive) { 26586 return [m2, m3, m4].concat(res); 26587 } else { 26588 res = [m2, m3, m4].concat(res).join().split(","); 26589 var newres = []; 26590 for (var i = 0, ii = res.length; i < ii; i++) { 26591 newres[i] = i % 2 ? rotate(res[i - 1], res[i], rad).y : rotate(res[i], res[i + 1], rad).x; 26592 } 26593 return newres; 26594 } 26595 } 26596 function findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) { 26597 var t1 = 1 - t; 26598 return { 26599 x: pow(t1, 3) * p1x + pow(t1, 2) * 3 * t * c1x + t1 * 3 * t * t * c2x + pow(t, 3) * p2x, 26600 y: pow(t1, 3) * p1y + pow(t1, 2) * 3 * t * c1y + t1 * 3 * t * t * c2y + pow(t, 3) * p2y 26601 }; 26602 } 26603 26604 // Returns bounding box of cubic bezier curve. 26605 // Source: http://blog.hackers-cafe.net/2009/06/how-to-calculate-bezier-curves-bounding.html 26606 // Original version: NISHIO Hirokazu 26607 // Modifications: https://github.com/timo22345 26608 function curveDim(x0, y0, x1, y1, x2, y2, x3, y3) { 26609 var tvalues = [], 26610 bounds = [[], []], 26611 a, b, c, t, t1, t2, b2ac, sqrtb2ac; 26612 for (var i = 0; i < 2; ++i) { 26613 if (i == 0) { 26614 b = 6 * x0 - 12 * x1 + 6 * x2; 26615 a = -3 * x0 + 9 * x1 - 9 * x2 + 3 * x3; 26616 c = 3 * x1 - 3 * x0; 26617 } else { 26618 b = 6 * y0 - 12 * y1 + 6 * y2; 26619 a = -3 * y0 + 9 * y1 - 9 * y2 + 3 * y3; 26620 c = 3 * y1 - 3 * y0; 26621 } 26622 if (abs(a) < 1e-12) { 26623 if (abs(b) < 1e-12) { 26624 continue; 26625 } 26626 t = -c / b; 26627 if (0 < t && t < 1) { 26628 tvalues.push(t); 26629 } 26630 continue; 26631 } 26632 b2ac = b * b - 4 * c * a; 26633 sqrtb2ac = math.sqrt(b2ac); 26634 if (b2ac < 0) { 26635 continue; 26636 } 26637 t1 = (-b + sqrtb2ac) / (2 * a); 26638 if (0 < t1 && t1 < 1) { 26639 tvalues.push(t1); 26640 } 26641 t2 = (-b - sqrtb2ac) / (2 * a); 26642 if (0 < t2 && t2 < 1) { 26643 tvalues.push(t2); 26644 } 26645 } 26646 26647 var x, y, j = tvalues.length, 26648 jlen = j, 26649 mt; 26650 while (j--) { 26651 t = tvalues[j]; 26652 mt = 1 - t; 26653 bounds[0][j] = mt * mt * mt * x0 + 3 * mt * mt * t * x1 + 3 * mt * t * t * x2 + t * t * t * x3; 26654 bounds[1][j] = mt * mt * mt * y0 + 3 * mt * mt * t * y1 + 3 * mt * t * t * y2 + t * t * t * y3; 26655 } 26656 26657 bounds[0][jlen] = x0; 26658 bounds[1][jlen] = y0; 26659 bounds[0][jlen + 1] = x3; 26660 bounds[1][jlen + 1] = y3; 26661 bounds[0].length = bounds[1].length = jlen + 2; 26662 26663 26664 return { 26665 min: {x: mmin.apply(0, bounds[0]), y: mmin.apply(0, bounds[1])}, 26666 max: {x: mmax.apply(0, bounds[0]), y: mmax.apply(0, bounds[1])} 26667 }; 26668 } 26669 26670 function path2curve(path, path2) { 26671 var pth = !path2 && paths(path); 26672 if (!path2 && pth.curve) { 26673 return pathClone(pth.curve); 26674 } 26675 var p = pathToAbsolute(path), 26676 p2 = path2 && pathToAbsolute(path2), 26677 attrs = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null}, 26678 attrs2 = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null}, 26679 processPath = function (path, d, pcom) { 26680 var nx, ny; 26681 if (!path) { 26682 return ["C", d.x, d.y, d.x, d.y, d.x, d.y]; 26683 } 26684 !(path[0] in {T: 1, Q: 1}) && (d.qx = d.qy = null); 26685 switch (path[0]) { 26686 case "M": 26687 d.X = path[1]; 26688 d.Y = path[2]; 26689 break; 26690 case "A": 26691 path = ["C"].concat(a2c.apply(0, [d.x, d.y].concat(path.slice(1)))); 26692 break; 26693 case "S": 26694 if (pcom == "C" || pcom == "S") { // In "S" case we have to take into account, if the previous command is C/S. 26695 nx = d.x * 2 - d.bx; // And reflect the previous 26696 ny = d.y * 2 - d.by; // command's control point relative to the current point. 26697 } 26698 else { // or some else or nothing 26699 nx = d.x; 26700 ny = d.y; 26701 } 26702 path = ["C", nx, ny].concat(path.slice(1)); 26703 break; 26704 case "T": 26705 if (pcom == "Q" || pcom == "T") { // In "T" case we have to take into account, if the previous command is Q/T. 26706 d.qx = d.x * 2 - d.qx; // And make a reflection similar 26707 d.qy = d.y * 2 - d.qy; // to case "S". 26708 } 26709 else { // or something else or nothing 26710 d.qx = d.x; 26711 d.qy = d.y; 26712 } 26713 path = ["C"].concat(q2c(d.x, d.y, d.qx, d.qy, path[1], path[2])); 26714 break; 26715 case "Q": 26716 d.qx = path[1]; 26717 d.qy = path[2]; 26718 path = ["C"].concat(q2c(d.x, d.y, path[1], path[2], path[3], path[4])); 26719 break; 26720 case "L": 26721 path = ["C"].concat(l2c(d.x, d.y, path[1], path[2])); 26722 break; 26723 case "H": 26724 path = ["C"].concat(l2c(d.x, d.y, path[1], d.y)); 26725 break; 26726 case "V": 26727 path = ["C"].concat(l2c(d.x, d.y, d.x, path[1])); 26728 break; 26729 case "Z": 26730 path = ["C"].concat(l2c(d.x, d.y, d.X, d.Y)); 26731 break; 26732 } 26733 return path; 26734 }, 26735 fixArc = function (pp, i) { 26736 if (pp[i].length > 7) { 26737 pp[i].shift(); 26738 var pi = pp[i]; 26739 while (pi.length) { 26740 pcoms1[i] = "A"; // if created multiple C:s, their original seg is saved 26741 p2 && (pcoms2[i] = "A"); // the same as above 26742 pp.splice(i++, 0, ["C"].concat(pi.splice(0, 6))); 26743 } 26744 pp.splice(i, 1); 26745 ii = mmax(p.length, p2 && p2.length || 0); 26746 } 26747 }, 26748 fixM = function (path1, path2, a1, a2, i) { 26749 if (path1 && path2 && path1[i][0] == "M" && path2[i][0] != "M") { 26750 path2.splice(i, 0, ["M", a2.x, a2.y]); 26751 a1.bx = 0; 26752 a1.by = 0; 26753 a1.x = path1[i][1]; 26754 a1.y = path1[i][2]; 26755 ii = mmax(p.length, p2 && p2.length || 0); 26756 } 26757 }, 26758 pcoms1 = [], // path commands of original path p 26759 pcoms2 = [], // path commands of original path p2 26760 pfirst = "", // temporary holder for original path command 26761 pcom = ""; // holder for previous path command of original path 26762 for (var i = 0, ii = mmax(p.length, p2 && p2.length || 0); i < ii; i++) { 26763 p[i] && (pfirst = p[i][0]); // save current path command 26764 26765 if (pfirst != "C") // C is not saved yet, because it may be result of conversion 26766 { 26767 pcoms1[i] = pfirst; // Save current path command 26768 i && ( pcom = pcoms1[i - 1]); // Get previous path command pcom 26769 } 26770 p[i] = processPath(p[i], attrs, pcom); // Previous path command is inputted to processPath 26771 26772 if (pcoms1[i] != "A" && pfirst == "C") pcoms1[i] = "C"; // A is the only command 26773 // which may produce multiple C:s 26774 // so we have to make sure that C is also C in original path 26775 26776 fixArc(p, i); // fixArc adds also the right amount of A:s to pcoms1 26777 26778 if (p2) { // the same procedures is done to p2 26779 p2[i] && (pfirst = p2[i][0]); 26780 if (pfirst != "C") { 26781 pcoms2[i] = pfirst; 26782 i && (pcom = pcoms2[i - 1]); 26783 } 26784 p2[i] = processPath(p2[i], attrs2, pcom); 26785 26786 if (pcoms2[i] != "A" && pfirst == "C") { 26787 pcoms2[i] = "C"; 26788 } 26789 26790 fixArc(p2, i); 26791 } 26792 fixM(p, p2, attrs, attrs2, i); 26793 fixM(p2, p, attrs2, attrs, i); 26794 var seg = p[i], 26795 seg2 = p2 && p2[i], 26796 seglen = seg.length, 26797 seg2len = p2 && seg2.length; 26798 attrs.x = seg[seglen - 2]; 26799 attrs.y = seg[seglen - 1]; 26800 attrs.bx = toFloat(seg[seglen - 4]) || attrs.x; 26801 attrs.by = toFloat(seg[seglen - 3]) || attrs.y; 26802 attrs2.bx = p2 && (toFloat(seg2[seg2len - 4]) || attrs2.x); 26803 attrs2.by = p2 && (toFloat(seg2[seg2len - 3]) || attrs2.y); 26804 attrs2.x = p2 && seg2[seg2len - 2]; 26805 attrs2.y = p2 && seg2[seg2len - 1]; 26806 } 26807 if (!p2) { 26808 pth.curve = pathClone(p); 26809 } 26810 return p2 ? [p, p2] : p; 26811 } 26812 function mapPath(path, matrix) { 26813 if (!matrix) { 26814 return path; 26815 } 26816 var x, y, i, j, ii, jj, pathi; 26817 path = path2curve(path); 26818 for (i = 0, ii = path.length; i < ii; i++) { 26819 pathi = path[i]; 26820 for (j = 1, jj = pathi.length; j < jj; j += 2) { 26821 x = matrix.x(pathi[j], pathi[j + 1]); 26822 y = matrix.y(pathi[j], pathi[j + 1]); 26823 pathi[j] = x; 26824 pathi[j + 1] = y; 26825 } 26826 } 26827 return path; 26828 } 26829 26830 // http://schepers.cc/getting-to-the-point 26831 function catmullRom2bezier(crp, z) { 26832 var d = []; 26833 for (var i = 0, iLen = crp.length; iLen - 2 * !z > i; i += 2) { 26834 var p = [ 26835 {x: +crp[i - 2], y: +crp[i - 1]}, 26836 {x: +crp[i], y: +crp[i + 1]}, 26837 {x: +crp[i + 2], y: +crp[i + 3]}, 26838 {x: +crp[i + 4], y: +crp[i + 5]} 26839 ]; 26840 if (z) { 26841 if (!i) { 26842 p[0] = {x: +crp[iLen - 2], y: +crp[iLen - 1]}; 26843 } else if (iLen - 4 == i) { 26844 p[3] = {x: +crp[0], y: +crp[1]}; 26845 } else if (iLen - 2 == i) { 26846 p[2] = {x: +crp[0], y: +crp[1]}; 26847 p[3] = {x: +crp[2], y: +crp[3]}; 26848 } 26849 } else { 26850 if (iLen - 4 == i) { 26851 p[3] = p[2]; 26852 } else if (!i) { 26853 p[0] = {x: +crp[i], y: +crp[i + 1]}; 26854 } 26855 } 26856 d.push(["C", 26857 (-p[0].x + 6 * p[1].x + p[2].x) / 6, 26858 (-p[0].y + 6 * p[1].y + p[2].y) / 6, 26859 (p[1].x + 6 * p[2].x - p[3].x) / 6, 26860 (p[1].y + 6*p[2].y - p[3].y) / 6, 26861 p[2].x, 26862 p[2].y 26863 ]); 26864 } 26865 26866 return d; 26867 } 26868 26869 // export 26870 Snap.path = paths; 26871 26872 /*\ 26873 * Snap.path.getTotalLength 26874 [ method ] 26875 ** 26876 * Returns the length of the given path in pixels 26877 ** 26878 - path (string) SVG path string 26879 ** 26880 = (number) length 26881 \*/ 26882 Snap.path.getTotalLength = getTotalLength; 26883 /*\ 26884 * Snap.path.getPointAtLength 26885 [ method ] 26886 ** 26887 * Returns the coordinates of the point located at the given length along the given path 26888 ** 26889 - path (string) SVG path string 26890 - length (number) length, in pixels, from the start of the path, excluding non-rendering jumps 26891 ** 26892 = (object) representation of the point: 26893 o { 26894 o x: (number) x coordinate, 26895 o y: (number) y coordinate, 26896 o alpha: (number) angle of derivative 26897 o } 26898 \*/ 26899 Snap.path.getPointAtLength = getPointAtLength; 26900 /*\ 26901 * Snap.path.getSubpath 26902 [ method ] 26903 ** 26904 * Returns the subpath of a given path between given start and end lengths 26905 ** 26906 - path (string) SVG path string 26907 - from (number) length, in pixels, from the start of the path to the start of the segment 26908 - to (number) length, in pixels, from the start of the path to the end of the segment 26909 ** 26910 = (string) path string definition for the segment 26911 \*/ 26912 Snap.path.getSubpath = function (path, from, to) { 26913 if (this.getTotalLength(path) - to < 1e-6) { 26914 return getSubpathsAtLength(path, from).end; 26915 } 26916 var a = getSubpathsAtLength(path, to, 1); 26917 return from ? getSubpathsAtLength(a, from).end : a; 26918 }; 26919 /*\ 26920 * Element.getTotalLength 26921 [ method ] 26922 ** 26923 * Returns the length of the path in pixels (only works for `path` elements) 26924 = (number) length 26925 \*/ 26926 elproto.getTotalLength = function () { 26927 if (this.node.getTotalLength) { 26928 return this.node.getTotalLength(); 26929 } 26930 }; 26931 // SIERRA Element.getPointAtLength()/Element.getTotalLength(): If a <path> is broken into different segments, is the jump distance to the new coordinates set by the _M_ or _m_ commands calculated as part of the path's total length? 26932 /*\ 26933 * Element.getPointAtLength 26934 [ method ] 26935 ** 26936 * Returns coordinates of the point located at the given length on the given path (only works for `path` elements) 26937 ** 26938 - length (number) length, in pixels, from the start of the path, excluding non-rendering jumps 26939 ** 26940 = (object) representation of the point: 26941 o { 26942 o x: (number) x coordinate, 26943 o y: (number) y coordinate, 26944 o alpha: (number) angle of derivative 26945 o } 26946 \*/ 26947 elproto.getPointAtLength = function (length) { 26948 return getPointAtLength(this.attr("d"), length); 26949 }; 26950 // SIERRA Element.getSubpath(): Similar to the problem for Element.getPointAtLength(). Unclear how this would work for a segmented path. Overall, the concept of _subpath_ and what I'm calling a _segment_ (series of non-_M_ or _Z_ commands) is unclear. 26951 /*\ 26952 * Element.getSubpath 26953 [ method ] 26954 ** 26955 * Returns subpath of a given element from given start and end lengths (only works for `path` elements) 26956 ** 26957 - from (number) length, in pixels, from the start of the path to the start of the segment 26958 - to (number) length, in pixels, from the start of the path to the end of the segment 26959 ** 26960 = (string) path string definition for the segment 26961 \*/ 26962 elproto.getSubpath = function (from, to) { 26963 return Snap.path.getSubpath(this.attr("d"), from, to); 26964 }; 26965 Snap._.box = box; 26966 /*\ 26967 * Snap.path.findDotsAtSegment 26968 [ method ] 26969 ** 26970 * Utility method 26971 ** 26972 * Finds dot coordinates on the given cubic beziér curve at the given t 26973 - p1x (number) x of the first point of the curve 26974 - p1y (number) y of the first point of the curve 26975 - c1x (number) x of the first anchor of the curve 26976 - c1y (number) y of the first anchor of the curve 26977 - c2x (number) x of the second anchor of the curve 26978 - c2y (number) y of the second anchor of the curve 26979 - p2x (number) x of the second point of the curve 26980 - p2y (number) y of the second point of the curve 26981 - t (number) position on the curve (0..1) 26982 = (object) point information in format: 26983 o { 26984 o x: (number) x coordinate of the point, 26985 o y: (number) y coordinate of the point, 26986 o m: { 26987 o x: (number) x coordinate of the left anchor, 26988 o y: (number) y coordinate of the left anchor 26989 o }, 26990 o n: { 26991 o x: (number) x coordinate of the right anchor, 26992 o y: (number) y coordinate of the right anchor 26993 o }, 26994 o start: { 26995 o x: (number) x coordinate of the start of the curve, 26996 o y: (number) y coordinate of the start of the curve 26997 o }, 26998 o end: { 26999 o x: (number) x coordinate of the end of the curve, 27000 o y: (number) y coordinate of the end of the curve 27001 o }, 27002 o alpha: (number) angle of the curve derivative at the point 27003 o } 27004 \*/ 27005 Snap.path.findDotsAtSegment = findDotsAtSegment; 27006 /*\ 27007 * Snap.path.bezierBBox 27008 [ method ] 27009 ** 27010 * Utility method 27011 ** 27012 * Returns the bounding box of a given cubic beziér curve 27013 - p1x (number) x of the first point of the curve 27014 - p1y (number) y of the first point of the curve 27015 - c1x (number) x of the first anchor of the curve 27016 - c1y (number) y of the first anchor of the curve 27017 - c2x (number) x of the second anchor of the curve 27018 - c2y (number) y of the second anchor of the curve 27019 - p2x (number) x of the second point of the curve 27020 - p2y (number) y of the second point of the curve 27021 * or 27022 - bez (array) array of six points for beziér curve 27023 = (object) bounding box 27024 o { 27025 o x: (number) x coordinate of the left top point of the box, 27026 o y: (number) y coordinate of the left top point of the box, 27027 o x2: (number) x coordinate of the right bottom point of the box, 27028 o y2: (number) y coordinate of the right bottom point of the box, 27029 o width: (number) width of the box, 27030 o height: (number) height of the box 27031 o } 27032 \*/ 27033 Snap.path.bezierBBox = bezierBBox; 27034 /*\ 27035 * Snap.path.isPointInsideBBox 27036 [ method ] 27037 ** 27038 * Utility method 27039 ** 27040 * Returns `true` if given point is inside bounding box 27041 - bbox (string) bounding box 27042 - x (string) x coordinate of the point 27043 - y (string) y coordinate of the point 27044 = (boolean) `true` if point is inside 27045 \*/ 27046 Snap.path.isPointInsideBBox = isPointInsideBBox; 27047 Snap.closest = function (x, y, X, Y) { 27048 var r = 100, 27049 b = box(x - r / 2, y - r / 2, r, r), 27050 inside = [], 27051 getter = X[0].hasOwnProperty("x") ? function (i) { 27052 return { 27053 x: X[i].x, 27054 y: X[i].y 27055 }; 27056 } : function (i) { 27057 return { 27058 x: X[i], 27059 y: Y[i] 27060 }; 27061 }, 27062 found = 0; 27063 while (r <= 1e6 && !found) { 27064 for (var i = 0, ii = X.length; i < ii; i++) { 27065 var xy = getter(i); 27066 if (isPointInsideBBox(b, xy.x, xy.y)) { 27067 found++; 27068 inside.push(xy); 27069 break; 27070 } 27071 } 27072 if (!found) { 27073 r *= 2; 27074 b = box(x - r / 2, y - r / 2, r, r) 27075 } 27076 } 27077 if (r == 1e6) { 27078 return; 27079 } 27080 var len = Infinity, 27081 res; 27082 for (i = 0, ii = inside.length; i < ii; i++) { 27083 var l = Snap.len(x, y, inside[i].x, inside[i].y); 27084 if (len > l) { 27085 len = l; 27086 inside[i].len = l; 27087 res = inside[i]; 27088 } 27089 } 27090 return res; 27091 }; 27092 /*\ 27093 * Snap.path.isBBoxIntersect 27094 [ method ] 27095 ** 27096 * Utility method 27097 ** 27098 * Returns `true` if two bounding boxes intersect 27099 - bbox1 (string) first bounding box 27100 - bbox2 (string) second bounding box 27101 = (boolean) `true` if bounding boxes intersect 27102 \*/ 27103 Snap.path.isBBoxIntersect = isBBoxIntersect; 27104 /*\ 27105 * Snap.path.intersection 27106 [ method ] 27107 ** 27108 * Utility method 27109 ** 27110 * Finds intersections of two paths 27111 - path1 (string) path string 27112 - path2 (string) path string 27113 = (array) dots of intersection 27114 o [ 27115 o { 27116 o x: (number) x coordinate of the point, 27117 o y: (number) y coordinate of the point, 27118 o t1: (number) t value for segment of path1, 27119 o t2: (number) t value for segment of path2, 27120 o segment1: (number) order number for segment of path1, 27121 o segment2: (number) order number for segment of path2, 27122 o bez1: (array) eight coordinates representing beziér curve for the segment of path1, 27123 o bez2: (array) eight coordinates representing beziér curve for the segment of path2 27124 o } 27125 o ] 27126 \*/ 27127 Snap.path.intersection = pathIntersection; 27128 Snap.path.intersectionNumber = pathIntersectionNumber; 27129 /*\ 27130 * Snap.path.isPointInside 27131 [ method ] 27132 ** 27133 * Utility method 27134 ** 27135 * Returns `true` if given point is inside a given closed path. 27136 * 27137 * Note: fill mode doesnât affect the result of this method. 27138 - path (string) path string 27139 - x (number) x of the point 27140 - y (number) y of the point 27141 = (boolean) `true` if point is inside the path 27142 \*/ 27143 Snap.path.isPointInside = isPointInsidePath; 27144 /*\ 27145 * Snap.path.getBBox 27146 [ method ] 27147 ** 27148 * Utility method 27149 ** 27150 * Returns the bounding box of a given path 27151 - path (string) path string 27152 = (object) bounding box 27153 o { 27154 o x: (number) x coordinate of the left top point of the box, 27155 o y: (number) y coordinate of the left top point of the box, 27156 o x2: (number) x coordinate of the right bottom point of the box, 27157 o y2: (number) y coordinate of the right bottom point of the box, 27158 o width: (number) width of the box, 27159 o height: (number) height of the box 27160 o } 27161 \*/ 27162 Snap.path.getBBox = pathBBox; 27163 Snap.path.get = getPath; 27164 /*\ 27165 * Snap.path.toRelative 27166 [ method ] 27167 ** 27168 * Utility method 27169 ** 27170 * Converts path coordinates into relative values 27171 - path (string) path string 27172 = (array) path string 27173 \*/ 27174 Snap.path.toRelative = pathToRelative; 27175 /*\ 27176 * Snap.path.toAbsolute 27177 [ method ] 27178 ** 27179 * Utility method 27180 ** 27181 * Converts path coordinates into absolute values 27182 - path (string) path string 27183 = (array) path string 27184 \*/ 27185 Snap.path.toAbsolute = pathToAbsolute; 27186 /*\ 27187 * Snap.path.toCubic 27188 [ method ] 27189 ** 27190 * Utility method 27191 ** 27192 * Converts path to a new path where all segments are cubic beziér curves 27193 - pathString (string|array) path string or array of segments 27194 = (array) array of segments 27195 \*/ 27196 Snap.path.toCubic = path2curve; 27197 /*\ 27198 * Snap.path.map 27199 [ method ] 27200 ** 27201 * Transform the path string with the given matrix 27202 - path (string) path string 27203 - matrix (object) see @Matrix 27204 = (string) transformed path string 27205 \*/ 27206 Snap.path.map = mapPath; 27207 Snap.path.toString = toString; 27208 Snap.path.clone = pathClone; 27209}); 27210 27211// Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved. 27212// 27213// Licensed under the Apache License, Version 2.0 (the "License"); 27214// you may not use this file except in compliance with the License. 27215// You may obtain a copy of the License at 27216// 27217// http://www.apache.org/licenses/LICENSE-2.0 27218// 27219// Unless required by applicable law or agreed to in writing, software 27220// distributed under the License is distributed on an "AS IS" BASIS, 27221// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 27222// See the License for the specific language governing permissions and 27223// limitations under the License. 27224Snap.plugin(function (Snap, Element, Paper, glob) { 27225 var mmax = Math.max, 27226 mmin = Math.min; 27227 27228 // Set 27229 var Set = function (items) { 27230 this.items = []; 27231 this.bindings = {}; 27232 this.length = 0; 27233 this.type = "set"; 27234 if (items) { 27235 for (var i = 0, ii = items.length; i < ii; i++) { 27236 if (items[i]) { 27237 this[this.items.length] = this.items[this.items.length] = items[i]; 27238 this.length++; 27239 } 27240 } 27241 } 27242 }, 27243 setproto = Set.prototype; 27244 /*\ 27245 * Set.push 27246 [ method ] 27247 ** 27248 * Adds each argument to the current set 27249 = (object) original element 27250 \*/ 27251 setproto.push = function () { 27252 var item, 27253 len; 27254 for (var i = 0, ii = arguments.length; i < ii; i++) { 27255 item = arguments[i]; 27256 if (item) { 27257 len = this.items.length; 27258 this[len] = this.items[len] = item; 27259 this.length++; 27260 } 27261 } 27262 return this; 27263 }; 27264 /*\ 27265 * Set.pop 27266 [ method ] 27267 ** 27268 * Removes last element and returns it 27269 = (object) element 27270 \*/ 27271 setproto.pop = function () { 27272 this.length && delete this[this.length--]; 27273 return this.items.pop(); 27274 }; 27275 /*\ 27276 * Set.forEach 27277 [ method ] 27278 ** 27279 * Executes given function for each element in the set 27280 * 27281 * If the function returns `false`, the loop stops running. 27282 ** 27283 - callback (function) function to run 27284 - thisArg (object) context object for the callback 27285 = (object) Set object 27286 \*/ 27287 setproto.forEach = function (callback, thisArg) { 27288 for (var i = 0, ii = this.items.length; i < ii; i++) { 27289 if (callback.call(thisArg, this.items[i], i) === false) { 27290 return this; 27291 } 27292 } 27293 return this; 27294 }; 27295 /*\ 27296 * Set.animate 27297 [ method ] 27298 ** 27299 * Animates each element in set in sync. 27300 * 27301 ** 27302 - attrs (object) key-value pairs of destination attributes 27303 - duration (number) duration of the animation in milliseconds 27304 - easing (function) #optional easing function from @mina or custom 27305 - callback (function) #optional callback function that executes when the animation ends 27306 * or 27307 - animation (array) array of animation parameter for each element in set in format `[attrs, duration, easing, callback]` 27308 > Usage 27309 | // animate all elements in set to radius 10 27310 | set.animate({r: 10}, 500, mina.easein); 27311 | // or 27312 | // animate first element to radius 10, but second to radius 20 and in different time 27313 | set.animate([{r: 10}, 500, mina.easein], [{r: 20}, 1500, mina.easein]); 27314 = (Element) the current element 27315 \*/ 27316 setproto.animate = function (attrs, ms, easing, callback) { 27317 if (typeof easing == "function" && !easing.length) { 27318 callback = easing; 27319 easing = mina.linear; 27320 } 27321 if (attrs instanceof Snap._.Animation) { 27322 callback = attrs.callback; 27323 easing = attrs.easing; 27324 ms = easing.dur; 27325 attrs = attrs.attr; 27326 } 27327 var args = arguments; 27328 if (Snap.is(attrs, "array") && Snap.is(args[args.length - 1], "array")) { 27329 var each = true; 27330 } 27331 var begin, 27332 handler = function () { 27333 if (begin) { 27334 this.b = begin; 27335 } else { 27336 begin = this.b; 27337 } 27338 }, 27339 cb = 0, 27340 set = this, 27341 callbacker = callback && function () { 27342 if (++cb == set.length) { 27343 callback.call(this); 27344 } 27345 }; 27346 return this.forEach(function (el, i) { 27347 eve.once("snap.animcreated." + el.id, handler); 27348 if (each) { 27349 args[i] && el.animate.apply(el, args[i]); 27350 } else { 27351 el.animate(attrs, ms, easing, callbacker); 27352 } 27353 }); 27354 }; 27355 /*\ 27356 * Set.remove 27357 [ method ] 27358 ** 27359 * Removes all children of the set. 27360 * 27361 = (object) Set object 27362 \*/ 27363 setproto.remove = function () { 27364 while (this.length) { 27365 this.pop().remove(); 27366 } 27367 return this; 27368 }; 27369 /*\ 27370 * Set.bind 27371 [ method ] 27372 ** 27373 * Specifies how to handle a specific attribute when applied 27374 * to a set. 27375 * 27376 ** 27377 - attr (string) attribute name 27378 - callback (function) function to run 27379 * or 27380 - attr (string) attribute name 27381 - element (Element) specific element in the set to apply the attribute to 27382 * or 27383 - attr (string) attribute name 27384 - element (Element) specific element in the set to apply the attribute to 27385 - eattr (string) attribute on the element to bind the attribute to 27386 = (object) Set object 27387 \*/ 27388 setproto.bind = function (attr, a, b) { 27389 var data = {}; 27390 if (typeof a == "function") { 27391 this.bindings[attr] = a; 27392 } else { 27393 var aname = b || attr; 27394 this.bindings[attr] = function (v) { 27395 data[aname] = v; 27396 a.attr(data); 27397 }; 27398 } 27399 return this; 27400 }; 27401 /*\ 27402 * Set.attr 27403 [ method ] 27404 ** 27405 * Equivalent of @Element.attr. 27406 = (object) Set object 27407 \*/ 27408 setproto.attr = function (value) { 27409 var unbound = {}; 27410 for (var k in value) { 27411 if (this.bindings[k]) { 27412 this.bindings[k](value[k]); 27413 } else { 27414 unbound[k] = value[k]; 27415 } 27416 } 27417 for (var i = 0, ii = this.items.length; i < ii; i++) { 27418 this.items[i].attr(unbound); 27419 } 27420 return this; 27421 }; 27422 /*\ 27423 * Set.clear 27424 [ method ] 27425 ** 27426 * Removes all elements from the set 27427 \*/ 27428 setproto.clear = function () { 27429 while (this.length) { 27430 this.pop(); 27431 } 27432 }; 27433 /*\ 27434 * Set.splice 27435 [ method ] 27436 ** 27437 * Removes range of elements from the set 27438 ** 27439 - index (number) position of the deletion 27440 - count (number) number of element to remove 27441 - insertion⦠(object) #optional elements to insert 27442 = (object) set elements that were deleted 27443 \*/ 27444 setproto.splice = function (index, count, insertion) { 27445 index = index < 0 ? mmax(this.length + index, 0) : index; 27446 count = mmax(0, mmin(this.length - index, count)); 27447 var tail = [], 27448 todel = [], 27449 args = [], 27450 i; 27451 for (i = 2; i < arguments.length; i++) { 27452 args.push(arguments[i]); 27453 } 27454 for (i = 0; i < count; i++) { 27455 todel.push(this[index + i]); 27456 } 27457 for (; i < this.length - index; i++) { 27458 tail.push(this[index + i]); 27459 } 27460 var arglen = args.length; 27461 for (i = 0; i < arglen + tail.length; i++) { 27462 this.items[index + i] = this[index + i] = i < arglen ? args[i] : tail[i - arglen]; 27463 } 27464 i = this.items.length = this.length -= count - arglen; 27465 while (this[i]) { 27466 delete this[i++]; 27467 } 27468 return new Set(todel); 27469 }; 27470 /*\ 27471 * Set.exclude 27472 [ method ] 27473 ** 27474 * Removes given element from the set 27475 ** 27476 - element (object) element to remove 27477 = (boolean) `true` if object was found and removed from the set 27478 \*/ 27479 setproto.exclude = function (el) { 27480 for (var i = 0, ii = this.length; i < ii; i++) if (this[i] == el) { 27481 this.splice(i, 1); 27482 return true; 27483 } 27484 return false; 27485 }; 27486 /*\ 27487 * Set.insertAfter 27488 [ method ] 27489 ** 27490 * Inserts set elements after given element. 27491 ** 27492 - element (object) set will be inserted after this element 27493 = (object) Set object 27494 \*/ 27495 setproto.insertAfter = function (el) { 27496 var i = this.items.length; 27497 while (i--) { 27498 this.items[i].insertAfter(el); 27499 } 27500 return this; 27501 }; 27502 /*\ 27503 * Set.getBBox 27504 [ method ] 27505 ** 27506 * Union of all bboxes of the set. See @Element.getBBox. 27507 = (object) bounding box descriptor. See @Element.getBBox. 27508 \*/ 27509 setproto.getBBox = function () { 27510 var x = [], 27511 y = [], 27512 x2 = [], 27513 y2 = []; 27514 for (var i = this.items.length; i--;) if (!this.items[i].removed) { 27515 var box = this.items[i].getBBox(); 27516 x.push(box.x); 27517 y.push(box.y); 27518 x2.push(box.x + box.width); 27519 y2.push(box.y + box.height); 27520 } 27521 x = mmin.apply(0, x); 27522 y = mmin.apply(0, y); 27523 x2 = mmax.apply(0, x2); 27524 y2 = mmax.apply(0, y2); 27525 return { 27526 x: x, 27527 y: y, 27528 x2: x2, 27529 y2: y2, 27530 width: x2 - x, 27531 height: y2 - y, 27532 cx: x + (x2 - x) / 2, 27533 cy: y + (y2 - y) / 2 27534 }; 27535 }; 27536 /*\ 27537 * Set.insertAfter 27538 [ method ] 27539 ** 27540 * Creates a clone of the set. 27541 ** 27542 = (object) New Set object 27543 \*/ 27544 setproto.clone = function (s) { 27545 s = new Set; 27546 for (var i = 0, ii = this.items.length; i < ii; i++) { 27547 s.push(this.items[i].clone()); 27548 } 27549 return s; 27550 }; 27551 setproto.toString = function () { 27552 return "Snap\u2018s set"; 27553 }; 27554 setproto.type = "set"; 27555 // export 27556 /*\ 27557 * Snap.Set 27558 [ property ] 27559 ** 27560 * Set constructor. 27561 \*/ 27562 Snap.Set = Set; 27563 /*\ 27564 * Snap.set 27565 [ method ] 27566 ** 27567 * Creates a set and fills it with list of arguments. 27568 ** 27569 = (object) New Set object 27570 | var r = paper.rect(0, 0, 10, 10), 27571 | s1 = Snap.set(), // empty set 27572 | s2 = Snap.set(r, paper.circle(100, 100, 20)); // prefilled set 27573 \*/ 27574 Snap.set = function () { 27575 var set = new Set; 27576 if (arguments.length) { 27577 set.push.apply(set, Array.prototype.slice.call(arguments, 0)); 27578 } 27579 return set; 27580 }; 27581}); 27582 27583// Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved. 27584// 27585// Licensed under the Apache License, Version 2.0 (the "License"); 27586// you may not use this file except in compliance with the License. 27587// You may obtain a copy of the License at 27588// 27589// http://www.apache.org/licenses/LICENSE-2.0 27590// 27591// Unless required by applicable law or agreed to in writing, software 27592// distributed under the License is distributed on an "AS IS" BASIS, 27593// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 27594// See the License for the specific language governing permissions and 27595// limitations under the License. 27596Snap.plugin(function (Snap, Element, Paper, glob) { 27597 var names = {}, 27598 reUnit = /[%a-z]+$/i, 27599 Str = String; 27600 names.stroke = names.fill = "colour"; 27601 function getEmpty(item) { 27602 var l = item[0]; 27603 switch (l.toLowerCase()) { 27604 case "t": return [l, 0, 0]; 27605 case "m": return [l, 1, 0, 0, 1, 0, 0]; 27606 case "r": if (item.length == 4) { 27607 return [l, 0, item[2], item[3]]; 27608 } else { 27609 return [l, 0]; 27610 } 27611 case "s": if (item.length == 5) { 27612 return [l, 1, 1, item[3], item[4]]; 27613 } else if (item.length == 3) { 27614 return [l, 1, 1]; 27615 } else { 27616 return [l, 1]; 27617 } 27618 } 27619 } 27620 function equaliseTransform(t1, t2, getBBox) { 27621 t1 = t1 || new Snap.Matrix; 27622 t2 = t2 || new Snap.Matrix; 27623 t1 = Snap.parseTransformString(t1.toTransformString()) || []; 27624 t2 = Snap.parseTransformString(t2.toTransformString()) || []; 27625 var maxlength = Math.max(t1.length, t2.length), 27626 from = [], 27627 to = [], 27628 i = 0, j, jj, 27629 tt1, tt2; 27630 for (; i < maxlength; i++) { 27631 tt1 = t1[i] || getEmpty(t2[i]); 27632 tt2 = t2[i] || getEmpty(tt1); 27633 if (tt1[0] != tt2[0] || 27634 tt1[0].toLowerCase() == "r" && (tt1[2] != tt2[2] || tt1[3] != tt2[3]) || 27635 tt1[0].toLowerCase() == "s" && (tt1[3] != tt2[3] || tt1[4] != tt2[4]) 27636 ) { 27637 t1 = Snap._.transform2matrix(t1, getBBox()); 27638 t2 = Snap._.transform2matrix(t2, getBBox()); 27639 from = [["m", t1.a, t1.b, t1.c, t1.d, t1.e, t1.f]]; 27640 to = [["m", t2.a, t2.b, t2.c, t2.d, t2.e, t2.f]]; 27641 break; 27642 } 27643 from[i] = []; 27644 to[i] = []; 27645 for (j = 0, jj = Math.max(tt1.length, tt2.length); j < jj; j++) { 27646 j in tt1 && (from[i][j] = tt1[j]); 27647 j in tt2 && (to[i][j] = tt2[j]); 27648 } 27649 } 27650 return { 27651 from: path2array(from), 27652 to: path2array(to), 27653 f: getPath(from) 27654 }; 27655 } 27656 function getNumber(val) { 27657 return val; 27658 } 27659 function getUnit(unit) { 27660 return function (val) { 27661 return +val.toFixed(3) + unit; 27662 }; 27663 } 27664 function getViewBox(val) { 27665 return val.join(" "); 27666 } 27667 function getColour(clr) { 27668 return Snap.rgb(clr[0], clr[1], clr[2], clr[3]); 27669 } 27670 function getPath(path) { 27671 var k = 0, i, ii, j, jj, out, a, b = []; 27672 for (i = 0, ii = path.length; i < ii; i++) { 27673 out = "["; 27674 a = ['"' + path[i][0] + '"']; 27675 for (j = 1, jj = path[i].length; j < jj; j++) { 27676 a[j] = "val[" + k++ + "]"; 27677 } 27678 out += a + "]"; 27679 b[i] = out; 27680 } 27681 return Function("val", "return Snap.path.toString.call([" + b + "])"); 27682 } 27683 function path2array(path) { 27684 var out = []; 27685 for (var i = 0, ii = path.length; i < ii; i++) { 27686 for (var j = 1, jj = path[i].length; j < jj; j++) { 27687 out.push(path[i][j]); 27688 } 27689 } 27690 return out; 27691 } 27692 function isNumeric(obj) { 27693 return isFinite(obj); 27694 } 27695 function arrayEqual(arr1, arr2) { 27696 if (!Snap.is(arr1, "array") || !Snap.is(arr2, "array")) { 27697 return false; 27698 } 27699 return arr1.toString() == arr2.toString(); 27700 } 27701 Element.prototype.equal = function (name, b) { 27702 return eve("snap.util.equal", this, name, b).firstDefined(); 27703 }; 27704 eve.on("snap.util.equal", function (name, b) { 27705 var A, B, a = Str(this.attr(name) || ""), 27706 el = this; 27707 if (names[name] == "colour") { 27708 A = Snap.color(a); 27709 B = Snap.color(b); 27710 return { 27711 from: [A.r, A.g, A.b, A.opacity], 27712 to: [B.r, B.g, B.b, B.opacity], 27713 f: getColour 27714 }; 27715 } 27716 if (name == "viewBox") { 27717 A = this.attr(name).vb.split(" ").map(Number); 27718 B = b.split(" ").map(Number); 27719 return { 27720 from: A, 27721 to: B, 27722 f: getViewBox 27723 }; 27724 } 27725 if (name == "transform" || name == "gradientTransform" || name == "patternTransform") { 27726 if (typeof b == "string") { 27727 b = Str(b).replace(/\.{3}|\u2026/g, a); 27728 } 27729 a = this.matrix; 27730 if (!Snap._.rgTransform.test(b)) { 27731 b = Snap._.transform2matrix(Snap._.svgTransform2string(b), this.getBBox()); 27732 } else { 27733 b = Snap._.transform2matrix(b, this.getBBox()); 27734 } 27735 return equaliseTransform(a, b, function () { 27736 return el.getBBox(1); 27737 }); 27738 } 27739 if (name == "d" || name == "path") { 27740 A = Snap.path.toCubic(a, b); 27741 return { 27742 from: path2array(A[0]), 27743 to: path2array(A[1]), 27744 f: getPath(A[0]) 27745 }; 27746 } 27747 if (name == "points") { 27748 A = Str(a).split(Snap._.separator); 27749 B = Str(b).split(Snap._.separator); 27750 return { 27751 from: A, 27752 to: B, 27753 f: function (val) { return val; } 27754 }; 27755 } 27756 if (isNumeric(a) && isNumeric(b)) { 27757 return { 27758 from: parseFloat(a), 27759 to: parseFloat(b), 27760 f: getNumber 27761 }; 27762 } 27763 var aUnit = a.match(reUnit), 27764 bUnit = Str(b).match(reUnit); 27765 if (aUnit && arrayEqual(aUnit, bUnit)) { 27766 return { 27767 from: parseFloat(a), 27768 to: parseFloat(b), 27769 f: getUnit(aUnit) 27770 }; 27771 } else { 27772 return { 27773 from: this.asPX(name), 27774 to: this.asPX(name, b), 27775 f: getNumber 27776 }; 27777 } 27778 }); 27779}); 27780 27781// Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved. 27782// 27783// Licensed under the Apache License, Version 2.0 (the "License"); 27784// you may not use this file except in compliance with the License. 27785// You may obtain a copy of the License at 27786// 27787// http://www.apache.org/licenses/LICENSE-2.0 27788// 27789// Unless required by applicable law or agreed to in writing, software 27790// distributed under the License is distributed on an "AS IS" BASIS, 27791// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 27792// See the License for the specific language governing permissions and 27793// limitations under the License. 27794Snap.plugin(function (Snap, Element, Paper, glob) { 27795 var elproto = Element.prototype, 27796 has = "hasOwnProperty", 27797 supportsTouch = "createTouch" in glob.doc, 27798 events = [ 27799 "click", "dblclick", "mousedown", "mousemove", "mouseout", 27800 "mouseover", "mouseup", "touchstart", "touchmove", "touchend", 27801 "touchcancel" 27802 ], 27803 touchMap = { 27804 mousedown: "touchstart", 27805 mousemove: "touchmove", 27806 mouseup: "touchend" 27807 }, 27808 getScroll = function (xy, el) { 27809 var name = xy == "y" ? "scrollTop" : "scrollLeft", 27810 doc = el && el.node ? el.node.ownerDocument : glob.doc; 27811 return doc[name in doc.documentElement ? "documentElement" : "body"][name]; 27812 }, 27813 preventDefault = function () { 27814 this.returnValue = false; 27815 }, 27816 preventTouch = function () { 27817 return this.originalEvent.preventDefault(); 27818 }, 27819 stopPropagation = function () { 27820 this.cancelBubble = true; 27821 }, 27822 stopTouch = function () { 27823 return this.originalEvent.stopPropagation(); 27824 }, 27825 addEvent = function (obj, type, fn, element) { 27826 var realName = supportsTouch && touchMap[type] ? touchMap[type] : type, 27827 f = function (e) { 27828 var scrollY = getScroll("y", element), 27829 scrollX = getScroll("x", element); 27830 if (supportsTouch && touchMap[has](type)) { 27831 for (var i = 0, ii = e.targetTouches && e.targetTouches.length; i < ii; i++) { 27832 if (e.targetTouches[i].target == obj || obj.contains(e.targetTouches[i].target)) { 27833 var olde = e; 27834 e = e.targetTouches[i]; 27835 e.originalEvent = olde; 27836 e.preventDefault = preventTouch; 27837 e.stopPropagation = stopTouch; 27838 break; 27839 } 27840 } 27841 } 27842 var x = e.clientX + scrollX, 27843 y = e.clientY + scrollY; 27844 return fn.call(element, e, x, y); 27845 }; 27846 27847 if (type !== realName) { 27848 obj.addEventListener(type, f, false); 27849 } 27850 27851 obj.addEventListener(realName, f, false); 27852 27853 return function () { 27854 if (type !== realName) { 27855 obj.removeEventListener(type, f, false); 27856 } 27857 27858 obj.removeEventListener(realName, f, false); 27859 return true; 27860 }; 27861 }, 27862 drag = [], 27863 dragMove = function (e) { 27864 var x = e.clientX, 27865 y = e.clientY, 27866 scrollY = getScroll("y"), 27867 scrollX = getScroll("x"), 27868 dragi, 27869 j = drag.length; 27870 while (j--) { 27871 dragi = drag[j]; 27872 if (supportsTouch) { 27873 var i = e.touches && e.touches.length, 27874 touch; 27875 while (i--) { 27876 touch = e.touches[i]; 27877 if (touch.identifier == dragi.el._drag.id || dragi.el.node.contains(touch.target)) { 27878 x = touch.clientX; 27879 y = touch.clientY; 27880 (e.originalEvent ? e.originalEvent : e).preventDefault(); 27881 break; 27882 } 27883 } 27884 } else { 27885 e.preventDefault(); 27886 } 27887 var node = dragi.el.node, 27888 o, 27889 next = node.nextSibling, 27890 parent = node.parentNode, 27891 display = node.style.display; 27892 // glob.win.opera && parent.removeChild(node); 27893 // node.style.display = "none"; 27894 // o = dragi.el.paper.getElementByPoint(x, y); 27895 // node.style.display = display; 27896 // glob.win.opera && (next ? parent.insertBefore(node, next) : parent.appendChild(node)); 27897 // o && eve("snap.drag.over." + dragi.el.id, dragi.el, o); 27898 x += scrollX; 27899 y += scrollY; 27900 eve("snap.drag.move." + dragi.el.id, dragi.move_scope || dragi.el, x - dragi.el._drag.x, y - dragi.el._drag.y, x, y, e); 27901 } 27902 }, 27903 dragUp = function (e) { 27904 Snap.unmousemove(dragMove).unmouseup(dragUp); 27905 var i = drag.length, 27906 dragi; 27907 while (i--) { 27908 dragi = drag[i]; 27909 dragi.el._drag = {}; 27910 eve("snap.drag.end." + dragi.el.id, dragi.end_scope || dragi.start_scope || dragi.move_scope || dragi.el, e); 27911 eve.off("snap.drag.*." + dragi.el.id); 27912 } 27913 drag = []; 27914 }; 27915 /*\ 27916 * Element.click 27917 [ method ] 27918 ** 27919 * Adds a click event handler to the element 27920 - handler (function) handler for the event 27921 = (object) @Element 27922 \*/ 27923 /*\ 27924 * Element.unclick 27925 [ method ] 27926 ** 27927 * Removes a click event handler from the element 27928 - handler (function) handler for the event 27929 = (object) @Element 27930 \*/ 27931 27932 /*\ 27933 * Element.dblclick 27934 [ method ] 27935 ** 27936 * Adds a double click event handler to the element 27937 - handler (function) handler for the event 27938 = (object) @Element 27939 \*/ 27940 /*\ 27941 * Element.undblclick 27942 [ method ] 27943 ** 27944 * Removes a double click event handler from the element 27945 - handler (function) handler for the event 27946 = (object) @Element 27947 \*/ 27948 27949 /*\ 27950 * Element.mousedown 27951 [ method ] 27952 ** 27953 * Adds a mousedown event handler to the element 27954 - handler (function) handler for the event 27955 = (object) @Element 27956 \*/ 27957 /*\ 27958 * Element.unmousedown 27959 [ method ] 27960 ** 27961 * Removes a mousedown event handler from the element 27962 - handler (function) handler for the event 27963 = (object) @Element 27964 \*/ 27965 27966 /*\ 27967 * Element.mousemove 27968 [ method ] 27969 ** 27970 * Adds a mousemove event handler to the element 27971 - handler (function) handler for the event 27972 = (object) @Element 27973 \*/ 27974 /*\ 27975 * Element.unmousemove 27976 [ method ] 27977 ** 27978 * Removes a mousemove event handler from the element 27979 - handler (function) handler for the event 27980 = (object) @Element 27981 \*/ 27982 27983 /*\ 27984 * Element.mouseout 27985 [ method ] 27986 ** 27987 * Adds a mouseout event handler to the element 27988 - handler (function) handler for the event 27989 = (object) @Element 27990 \*/ 27991 /*\ 27992 * Element.unmouseout 27993 [ method ] 27994 ** 27995 * Removes a mouseout event handler from the element 27996 - handler (function) handler for the event 27997 = (object) @Element 27998 \*/ 27999 28000 /*\ 28001 * Element.mouseover 28002 [ method ] 28003 ** 28004 * Adds a mouseover event handler to the element 28005 - handler (function) handler for the event 28006 = (object) @Element 28007 \*/ 28008 /*\ 28009 * Element.unmouseover 28010 [ method ] 28011 ** 28012 * Removes a mouseover event handler from the element 28013 - handler (function) handler for the event 28014 = (object) @Element 28015 \*/ 28016 28017 /*\ 28018 * Element.mouseup 28019 [ method ] 28020 ** 28021 * Adds a mouseup event handler to the element 28022 - handler (function) handler for the event 28023 = (object) @Element 28024 \*/ 28025 /*\ 28026 * Element.unmouseup 28027 [ method ] 28028 ** 28029 * Removes a mouseup event handler from the element 28030 - handler (function) handler for the event 28031 = (object) @Element 28032 \*/ 28033 28034 /*\ 28035 * Element.touchstart 28036 [ method ] 28037 ** 28038 * Adds a touchstart event handler to the element 28039 - handler (function) handler for the event 28040 = (object) @Element 28041 \*/ 28042 /*\ 28043 * Element.untouchstart 28044 [ method ] 28045 ** 28046 * Removes a touchstart event handler from the element 28047 - handler (function) handler for the event 28048 = (object) @Element 28049 \*/ 28050 28051 /*\ 28052 * Element.touchmove 28053 [ method ] 28054 ** 28055 * Adds a touchmove event handler to the element 28056 - handler (function) handler for the event 28057 = (object) @Element 28058 \*/ 28059 /*\ 28060 * Element.untouchmove 28061 [ method ] 28062 ** 28063 * Removes a touchmove event handler from the element 28064 - handler (function) handler for the event 28065 = (object) @Element 28066 \*/ 28067 28068 /*\ 28069 * Element.touchend 28070 [ method ] 28071 ** 28072 * Adds a touchend event handler to the element 28073 - handler (function) handler for the event 28074 = (object) @Element 28075 \*/ 28076 /*\ 28077 * Element.untouchend 28078 [ method ] 28079 ** 28080 * Removes a touchend event handler from the element 28081 - handler (function) handler for the event 28082 = (object) @Element 28083 \*/ 28084 28085 /*\ 28086 * Element.touchcancel 28087 [ method ] 28088 ** 28089 * Adds a touchcancel event handler to the element 28090 - handler (function) handler for the event 28091 = (object) @Element 28092 \*/ 28093 /*\ 28094 * Element.untouchcancel 28095 [ method ] 28096 ** 28097 * Removes a touchcancel event handler from the element 28098 - handler (function) handler for the event 28099 = (object) @Element 28100 \*/ 28101 for (var i = events.length; i--;) { 28102 (function (eventName) { 28103 Snap[eventName] = elproto[eventName] = function (fn, scope) { 28104 if (Snap.is(fn, "function")) { 28105 this.events = this.events || []; 28106 this.events.push({ 28107 name: eventName, 28108 f: fn, 28109 unbind: addEvent(this.node || document, eventName, fn, scope || this) 28110 }); 28111 } else { 28112 for (var i = 0, ii = this.events.length; i < ii; i++) if (this.events[i].name == eventName) { 28113 try { 28114 this.events[i].f.call(this); 28115 } catch (e) {} 28116 } 28117 } 28118 return this; 28119 }; 28120 Snap["un" + eventName] = 28121 elproto["un" + eventName] = function (fn) { 28122 var events = this.events || [], 28123 l = events.length; 28124 while (l--) if (events[l].name == eventName && 28125 (events[l].f == fn || !fn)) { 28126 events[l].unbind(); 28127 events.splice(l, 1); 28128 !events.length && delete this.events; 28129 return this; 28130 } 28131 return this; 28132 }; 28133 })(events[i]); 28134 } 28135 /*\ 28136 * Element.hover 28137 [ method ] 28138 ** 28139 * Adds hover event handlers to the element 28140 - f_in (function) handler for hover in 28141 - f_out (function) handler for hover out 28142 - icontext (object) #optional context for hover in handler 28143 - ocontext (object) #optional context for hover out handler 28144 = (object) @Element 28145 \*/ 28146 elproto.hover = function (f_in, f_out, scope_in, scope_out) { 28147 return this.mouseover(f_in, scope_in).mouseout(f_out, scope_out || scope_in); 28148 }; 28149 /*\ 28150 * Element.unhover 28151 [ method ] 28152 ** 28153 * Removes hover event handlers from the element 28154 - f_in (function) handler for hover in 28155 - f_out (function) handler for hover out 28156 = (object) @Element 28157 \*/ 28158 elproto.unhover = function (f_in, f_out) { 28159 return this.unmouseover(f_in).unmouseout(f_out); 28160 }; 28161 var draggable = []; 28162 // SIERRA unclear what _context_ refers to for starting, ending, moving the drag gesture. 28163 // SIERRA Element.drag(): _x position of the mouse_: Where are the x/y values offset from? 28164 // SIERRA Element.drag(): much of this member's doc appears to be duplicated for some reason. 28165 // SIERRA Unclear about this sentence: _Additionally following drag events will be triggered: drag.start.<id> on start, drag.end.<id> on end and drag.move.<id> on every move._ Is there a global _drag_ object to which you can assign handlers keyed by an element's ID? 28166 /*\ 28167 * Element.drag 28168 [ method ] 28169 ** 28170 * Adds event handlers for an element's drag gesture 28171 ** 28172 - onmove (function) handler for moving 28173 - onstart (function) handler for drag start 28174 - onend (function) handler for drag end 28175 - mcontext (object) #optional context for moving handler 28176 - scontext (object) #optional context for drag start handler 28177 - econtext (object) #optional context for drag end handler 28178 * Additionaly following `drag` events are triggered: `drag.start.<id>` on start, 28179 * `drag.end.<id>` on end and `drag.move.<id>` on every move. When element is dragged over another element 28180 * `drag.over.<id>` fires as well. 28181 * 28182 * Start event and start handler are called in specified context or in context of the element with following parameters: 28183 o x (number) x position of the mouse 28184 o y (number) y position of the mouse 28185 o event (object) DOM event object 28186 * Move event and move handler are called in specified context or in context of the element with following parameters: 28187 o dx (number) shift by x from the start point 28188 o dy (number) shift by y from the start point 28189 o x (number) x position of the mouse 28190 o y (number) y position of the mouse 28191 o event (object) DOM event object 28192 * End event and end handler are called in specified context or in context of the element with following parameters: 28193 o event (object) DOM event object 28194 = (object) @Element 28195 \*/ 28196 elproto.drag = function (onmove, onstart, onend, move_scope, start_scope, end_scope) { 28197 var el = this; 28198 if (!arguments.length) { 28199 var origTransform; 28200 return el.drag(function (dx, dy) { 28201 this.attr({ 28202 transform: origTransform + (origTransform ? "T" : "t") + [dx, dy] 28203 }); 28204 }, function () { 28205 origTransform = this.transform().local; 28206 }); 28207 } 28208 function start(e, x, y) { 28209 (e.originalEvent || e).preventDefault(); 28210 el._drag.x = x; 28211 el._drag.y = y; 28212 el._drag.id = e.identifier; 28213 !drag.length && Snap.mousemove(dragMove).mouseup(dragUp); 28214 drag.push({el: el, move_scope: move_scope, start_scope: start_scope, end_scope: end_scope}); 28215 onstart && eve.on("snap.drag.start." + el.id, onstart); 28216 onmove && eve.on("snap.drag.move." + el.id, onmove); 28217 onend && eve.on("snap.drag.end." + el.id, onend); 28218 eve("snap.drag.start." + el.id, start_scope || move_scope || el, x, y, e); 28219 } 28220 function init(e, x, y) { 28221 eve("snap.draginit." + el.id, el, e, x, y); 28222 } 28223 eve.on("snap.draginit." + el.id, start); 28224 el._drag = {}; 28225 draggable.push({el: el, start: start, init: init}); 28226 el.mousedown(init); 28227 return el; 28228 }; 28229 /* 28230 * Element.onDragOver 28231 [ method ] 28232 ** 28233 * Shortcut to assign event handler for `drag.over.<id>` event, where `id` is the element's `id` (see @Element.id) 28234 - f (function) handler for event, first argument would be the element you are dragging over 28235 \*/ 28236 // elproto.onDragOver = function (f) { 28237 // f ? eve.on("snap.drag.over." + this.id, f) : eve.unbind("snap.drag.over." + this.id); 28238 // }; 28239 /*\ 28240 * Element.undrag 28241 [ method ] 28242 ** 28243 * Removes all drag event handlers from the given element 28244 \*/ 28245 elproto.undrag = function () { 28246 var i = draggable.length; 28247 while (i--) if (draggable[i].el == this) { 28248 this.unmousedown(draggable[i].init); 28249 draggable.splice(i, 1); 28250 eve.unbind("snap.drag.*." + this.id); 28251 eve.unbind("snap.draginit." + this.id); 28252 } 28253 !draggable.length && Snap.unmousemove(dragMove).unmouseup(dragUp); 28254 return this; 28255 }; 28256}); 28257 28258// Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved. 28259// 28260// Licensed under the Apache License, Version 2.0 (the "License"); 28261// you may not use this file except in compliance with the License. 28262// You may obtain a copy of the License at 28263// 28264// http://www.apache.org/licenses/LICENSE-2.0 28265// 28266// Unless required by applicable law or agreed to in writing, software 28267// distributed under the License is distributed on an "AS IS" BASIS, 28268// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 28269// See the License for the specific language governing permissions and 28270// limitations under the License. 28271Snap.plugin(function (Snap, Element, Paper, glob) { 28272 var elproto = Element.prototype, 28273 pproto = Paper.prototype, 28274 rgurl = /^\s*url\((.+)\)/, 28275 Str = String, 28276 $ = Snap._.$; 28277 Snap.filter = {}; 28278 /*\ 28279 * Paper.filter 28280 [ method ] 28281 ** 28282 * Creates a `<filter>` element 28283 ** 28284 - filstr (string) SVG fragment of filter provided as a string 28285 = (object) @Element 28286 * Note: It is recommended to use filters embedded into the page inside an empty SVG element. 28287 > Usage 28288 | var f = paper.filter('<feGaussianBlur stdDeviation="2"/>'), 28289 | c = paper.circle(10, 10, 10).attr({ 28290 | filter: f 28291 | }); 28292 \*/ 28293 pproto.filter = function (filstr) { 28294 var paper = this; 28295 if (paper.type != "svg") { 28296 paper = paper.paper; 28297 } 28298 var f = Snap.parse(Str(filstr)), 28299 id = Snap._.id(), 28300 width = paper.node.offsetWidth, 28301 height = paper.node.offsetHeight, 28302 filter = $("filter"); 28303 $(filter, { 28304 id: id, 28305 filterUnits: "userSpaceOnUse" 28306 }); 28307 filter.appendChild(f.node); 28308 paper.defs.appendChild(filter); 28309 return new Element(filter); 28310 }; 28311 28312 eve.on("snap.util.getattr.filter", function () { 28313 eve.stop(); 28314 var p = $(this.node, "filter"); 28315 if (p) { 28316 var match = Str(p).match(rgurl); 28317 return match && Snap.select(match[1]); 28318 } 28319 }); 28320 eve.on("snap.util.attr.filter", function (value) { 28321 if (value instanceof Element && value.type == "filter") { 28322 eve.stop(); 28323 var id = value.node.id; 28324 if (!id) { 28325 $(value.node, {id: value.id}); 28326 id = value.id; 28327 } 28328 $(this.node, { 28329 filter: Snap.url(id) 28330 }); 28331 } 28332 if (!value || value == "none") { 28333 eve.stop(); 28334 this.node.removeAttribute("filter"); 28335 } 28336 }); 28337 /*\ 28338 * Snap.filter.blur 28339 [ method ] 28340 ** 28341 * Returns an SVG markup string for the blur filter 28342 ** 28343 - x (number) amount of horizontal blur, in pixels 28344 - y (number) #optional amount of vertical blur, in pixels 28345 = (string) filter representation 28346 > Usage 28347 | var f = paper.filter(Snap.filter.blur(5, 10)), 28348 | c = paper.circle(10, 10, 10).attr({ 28349 | filter: f 28350 | }); 28351 \*/ 28352 Snap.filter.blur = function (x, y) { 28353 if (x == null) { 28354 x = 2; 28355 } 28356 var def = y == null ? x : [x, y]; 28357 return Snap.format('\<feGaussianBlur stdDeviation="{def}"/>', { 28358 def: def 28359 }); 28360 }; 28361 Snap.filter.blur.toString = function () { 28362 return this(); 28363 }; 28364 /*\ 28365 * Snap.filter.shadow 28366 [ method ] 28367 ** 28368 * Returns an SVG markup string for the shadow filter 28369 ** 28370 - dx (number) #optional horizontal shift of the shadow, in pixels 28371 - dy (number) #optional vertical shift of the shadow, in pixels 28372 - blur (number) #optional amount of blur 28373 - color (string) #optional color of the shadow 28374 - opacity (number) #optional `0..1` opacity of the shadow 28375 * or 28376 - dx (number) #optional horizontal shift of the shadow, in pixels 28377 - dy (number) #optional vertical shift of the shadow, in pixels 28378 - color (string) #optional color of the shadow 28379 - opacity (number) #optional `0..1` opacity of the shadow 28380 * which makes blur default to `4`. Or 28381 - dx (number) #optional horizontal shift of the shadow, in pixels 28382 - dy (number) #optional vertical shift of the shadow, in pixels 28383 - opacity (number) #optional `0..1` opacity of the shadow 28384 = (string) filter representation 28385 > Usage 28386 | var f = paper.filter(Snap.filter.shadow(0, 2, .3)), 28387 | c = paper.circle(10, 10, 10).attr({ 28388 | filter: f 28389 | }); 28390 \*/ 28391 Snap.filter.shadow = function (dx, dy, blur, color, opacity) { 28392 if (opacity == null) { 28393 if (color == null) { 28394 opacity = blur; 28395 blur = 4; 28396 color = "#000"; 28397 } else { 28398 opacity = color; 28399 color = blur; 28400 blur = 4; 28401 } 28402 } 28403 if (blur == null) { 28404 blur = 4; 28405 } 28406 if (opacity == null) { 28407 opacity = 1; 28408 } 28409 if (dx == null) { 28410 dx = 0; 28411 dy = 2; 28412 } 28413 if (dy == null) { 28414 dy = dx; 28415 } 28416 color = Snap.color(color); 28417 return Snap.format('<feGaussianBlur in="SourceAlpha" stdDeviation="{blur}"/><feOffset dx="{dx}" dy="{dy}" result="offsetblur"/><feFlood flood-color="{color}"/><feComposite in2="offsetblur" operator="in"/><feComponentTransfer><feFuncA type="linear" slope="{opacity}"/></feComponentTransfer><feMerge><feMergeNode/><feMergeNode in="SourceGraphic"/></feMerge>', { 28418 color: color, 28419 dx: dx, 28420 dy: dy, 28421 blur: blur, 28422 opacity: opacity 28423 }); 28424 }; 28425 Snap.filter.shadow.toString = function () { 28426 return this(); 28427 }; 28428 /*\ 28429 * Snap.filter.grayscale 28430 [ method ] 28431 ** 28432 * Returns an SVG markup string for the grayscale filter 28433 ** 28434 - amount (number) amount of filter (`0..1`) 28435 = (string) filter representation 28436 \*/ 28437 Snap.filter.grayscale = function (amount) { 28438 if (amount == null) { 28439 amount = 1; 28440 } 28441 return Snap.format('<feColorMatrix type="matrix" values="{a} {b} {c} 0 0 {d} {e} {f} 0 0 {g} {b} {h} 0 0 0 0 0 1 0"/>', { 28442 a: 0.2126 + 0.7874 * (1 - amount), 28443 b: 0.7152 - 0.7152 * (1 - amount), 28444 c: 0.0722 - 0.0722 * (1 - amount), 28445 d: 0.2126 - 0.2126 * (1 - amount), 28446 e: 0.7152 + 0.2848 * (1 - amount), 28447 f: 0.0722 - 0.0722 * (1 - amount), 28448 g: 0.2126 - 0.2126 * (1 - amount), 28449 h: 0.0722 + 0.9278 * (1 - amount) 28450 }); 28451 }; 28452 Snap.filter.grayscale.toString = function () { 28453 return this(); 28454 }; 28455 /*\ 28456 * Snap.filter.sepia 28457 [ method ] 28458 ** 28459 * Returns an SVG markup string for the sepia filter 28460 ** 28461 - amount (number) amount of filter (`0..1`) 28462 = (string) filter representation 28463 \*/ 28464 Snap.filter.sepia = function (amount) { 28465 if (amount == null) { 28466 amount = 1; 28467 } 28468 return Snap.format('<feColorMatrix type="matrix" values="{a} {b} {c} 0 0 {d} {e} {f} 0 0 {g} {h} {i} 0 0 0 0 0 1 0"/>', { 28469 a: 0.393 + 0.607 * (1 - amount), 28470 b: 0.769 - 0.769 * (1 - amount), 28471 c: 0.189 - 0.189 * (1 - amount), 28472 d: 0.349 - 0.349 * (1 - amount), 28473 e: 0.686 + 0.314 * (1 - amount), 28474 f: 0.168 - 0.168 * (1 - amount), 28475 g: 0.272 - 0.272 * (1 - amount), 28476 h: 0.534 - 0.534 * (1 - amount), 28477 i: 0.131 + 0.869 * (1 - amount) 28478 }); 28479 }; 28480 Snap.filter.sepia.toString = function () { 28481 return this(); 28482 }; 28483 /*\ 28484 * Snap.filter.saturate 28485 [ method ] 28486 ** 28487 * Returns an SVG markup string for the saturate filter 28488 ** 28489 - amount (number) amount of filter (`0..1`) 28490 = (string) filter representation 28491 \*/ 28492 Snap.filter.saturate = function (amount) { 28493 if (amount == null) { 28494 amount = 1; 28495 } 28496 return Snap.format('<feColorMatrix type="saturate" values="{amount}"/>', { 28497 amount: 1 - amount 28498 }); 28499 }; 28500 Snap.filter.saturate.toString = function () { 28501 return this(); 28502 }; 28503 /*\ 28504 * Snap.filter.hueRotate 28505 [ method ] 28506 ** 28507 * Returns an SVG markup string for the hue-rotate filter 28508 ** 28509 - angle (number) angle of rotation 28510 = (string) filter representation 28511 \*/ 28512 Snap.filter.hueRotate = function (angle) { 28513 angle = angle || 0; 28514 return Snap.format('<feColorMatrix type="hueRotate" values="{angle}"/>', { 28515 angle: angle 28516 }); 28517 }; 28518 Snap.filter.hueRotate.toString = function () { 28519 return this(); 28520 }; 28521 /*\ 28522 * Snap.filter.invert 28523 [ method ] 28524 ** 28525 * Returns an SVG markup string for the invert filter 28526 ** 28527 - amount (number) amount of filter (`0..1`) 28528 = (string) filter representation 28529 \*/ 28530 Snap.filter.invert = function (amount) { 28531 if (amount == null) { 28532 amount = 1; 28533 } 28534// <feColorMatrix type="matrix" values="-1 0 0 0 1 0 -1 0 0 1 0 0 -1 0 1 0 0 0 1 0" color-interpolation-filters="sRGB"/> 28535 return Snap.format('<feComponentTransfer><feFuncR type="table" tableValues="{amount} {amount2}"/><feFuncG type="table" tableValues="{amount} {amount2}"/><feFuncB type="table" tableValues="{amount} {amount2}"/></feComponentTransfer>', { 28536 amount: amount, 28537 amount2: 1 - amount 28538 }); 28539 }; 28540 Snap.filter.invert.toString = function () { 28541 return this(); 28542 }; 28543 /*\ 28544 * Snap.filter.brightness 28545 [ method ] 28546 ** 28547 * Returns an SVG markup string for the brightness filter 28548 ** 28549 - amount (number) amount of filter (`0..1`) 28550 = (string) filter representation 28551 \*/ 28552 Snap.filter.brightness = function (amount) { 28553 if (amount == null) { 28554 amount = 1; 28555 } 28556 return Snap.format('<feComponentTransfer><feFuncR type="linear" slope="{amount}"/><feFuncG type="linear" slope="{amount}"/><feFuncB type="linear" slope="{amount}"/></feComponentTransfer>', { 28557 amount: amount 28558 }); 28559 }; 28560 Snap.filter.brightness.toString = function () { 28561 return this(); 28562 }; 28563 /*\ 28564 * Snap.filter.contrast 28565 [ method ] 28566 ** 28567 * Returns an SVG markup string for the contrast filter 28568 ** 28569 - amount (number) amount of filter (`0..1`) 28570 = (string) filter representation 28571 \*/ 28572 Snap.filter.contrast = function (amount) { 28573 if (amount == null) { 28574 amount = 1; 28575 } 28576 return Snap.format('<feComponentTransfer><feFuncR type="linear" slope="{amount}" intercept="{amount2}"/><feFuncG type="linear" slope="{amount}" intercept="{amount2}"/><feFuncB type="linear" slope="{amount}" intercept="{amount2}"/></feComponentTransfer>', { 28577 amount: amount, 28578 amount2: .5 - amount / 2 28579 }); 28580 }; 28581 Snap.filter.contrast.toString = function () { 28582 return this(); 28583 }; 28584}); 28585 28586// Copyright (c) 2014 Adobe Systems Incorporated. All rights reserved. 28587// 28588// Licensed under the Apache License, Version 2.0 (the "License"); 28589// you may not use this file except in compliance with the License. 28590// You may obtain a copy of the License at 28591// 28592// http://www.apache.org/licenses/LICENSE-2.0 28593// 28594// Unless required by applicable law or agreed to in writing, software 28595// distributed under the License is distributed on an "AS IS" BASIS, 28596// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 28597// See the License for the specific language governing permissions and 28598// limitations under the License. 28599Snap.plugin(function (Snap, Element, Paper, glob, Fragment) { 28600 var box = Snap._.box, 28601 is = Snap.is, 28602 firstLetter = /^[^a-z]*([tbmlrc])/i, 28603 toString = function () { 28604 return "T" + this.dx + "," + this.dy; 28605 }; 28606 /*\ 28607 * Element.getAlign 28608 [ method ] 28609 ** 28610 * Returns shift needed to align the element relatively to given element. 28611 * If no elements specified, parent `<svg>` container will be used. 28612 - el (object) @optional alignment element 28613 - way (string) one of six values: `"top"`, `"middle"`, `"bottom"`, `"left"`, `"center"`, `"right"` 28614 = (object|string) Object in format `{dx: , dy: }` also has a string representation as a transformation string 28615 > Usage 28616 | el.transform(el.getAlign(el2, "top")); 28617 * or 28618 | var dy = el.getAlign(el2, "top").dy; 28619 \*/ 28620 Element.prototype.getAlign = function (el, way) { 28621 if (way == null && is(el, "string")) { 28622 way = el; 28623 el = null; 28624 } 28625 el = el || this.paper; 28626 var bx = el.getBBox ? el.getBBox() : box(el), 28627 bb = this.getBBox(), 28628 out = {}; 28629 way = way && way.match(firstLetter); 28630 way = way ? way[1].toLowerCase() : "c"; 28631 switch (way) { 28632 case "t": 28633 out.dx = 0; 28634 out.dy = bx.y - bb.y; 28635 break; 28636 case "b": 28637 out.dx = 0; 28638 out.dy = bx.y2 - bb.y2; 28639 break; 28640 case "m": 28641 out.dx = 0; 28642 out.dy = bx.cy - bb.cy; 28643 break; 28644 case "l": 28645 out.dx = bx.x - bb.x; 28646 out.dy = 0; 28647 break; 28648 case "r": 28649 out.dx = bx.x2 - bb.x2; 28650 out.dy = 0; 28651 break; 28652 default: 28653 out.dx = bx.cx - bb.cx; 28654 out.dy = 0; 28655 break; 28656 } 28657 out.toString = toString; 28658 return out; 28659 }; 28660 /*\ 28661 * Element.align 28662 [ method ] 28663 ** 28664 * Aligns the element relatively to given one via transformation. 28665 * If no elements specified, parent `<svg>` container will be used. 28666 - el (object) @optional alignment element 28667 - way (string) one of six values: `"top"`, `"middle"`, `"bottom"`, `"left"`, `"center"`, `"right"` 28668 = (object) this element 28669 > Usage 28670 | el.align(el2, "top"); 28671 * or 28672 | el.align("middle"); 28673 \*/ 28674 Element.prototype.align = function (el, way) { 28675 return this.transform("..." + this.getAlign(el, way)); 28676 }; 28677}); 28678 28679// Copyright (c) 2017 Adobe Systems Incorporated. All rights reserved. 28680// 28681// Licensed under the Apache License, Version 2.0 (the "License"); 28682// you may not use this file except in compliance with the License. 28683// You may obtain a copy of the License at 28684// 28685// http://www.apache.org/licenses/LICENSE-2.0 28686// 28687// Unless required by applicable law or agreed to in writing, software 28688// distributed under the License is distributed on an "AS IS" BASIS, 28689// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 28690// See the License for the specific language governing permissions and 28691// limitations under the License. 28692Snap.plugin(function (Snap, Element, Paper, glob) { 28693 // Colours are from https://www.materialui.co 28694 var red = "#ffebee#ffcdd2#ef9a9a#e57373#ef5350#f44336#e53935#d32f2f#c62828#b71c1c#ff8a80#ff5252#ff1744#d50000", 28695 pink = "#FCE4EC#F8BBD0#F48FB1#F06292#EC407A#E91E63#D81B60#C2185B#AD1457#880E4F#FF80AB#FF4081#F50057#C51162", 28696 purple = "#F3E5F5#E1BEE7#CE93D8#BA68C8#AB47BC#9C27B0#8E24AA#7B1FA2#6A1B9A#4A148C#EA80FC#E040FB#D500F9#AA00FF", 28697 deeppurple = "#EDE7F6#D1C4E9#B39DDB#9575CD#7E57C2#673AB7#5E35B1#512DA8#4527A0#311B92#B388FF#7C4DFF#651FFF#6200EA", 28698 indigo = "#E8EAF6#C5CAE9#9FA8DA#7986CB#5C6BC0#3F51B5#3949AB#303F9F#283593#1A237E#8C9EFF#536DFE#3D5AFE#304FFE", 28699 blue = "#E3F2FD#BBDEFB#90CAF9#64B5F6#64B5F6#2196F3#1E88E5#1976D2#1565C0#0D47A1#82B1FF#448AFF#2979FF#2962FF", 28700 lightblue = "#E1F5FE#B3E5FC#81D4FA#4FC3F7#29B6F6#03A9F4#039BE5#0288D1#0277BD#01579B#80D8FF#40C4FF#00B0FF#0091EA", 28701 cyan = "#E0F7FA#B2EBF2#80DEEA#4DD0E1#26C6DA#00BCD4#00ACC1#0097A7#00838F#006064#84FFFF#18FFFF#00E5FF#00B8D4", 28702 teal = "#E0F2F1#B2DFDB#80CBC4#4DB6AC#26A69A#009688#00897B#00796B#00695C#004D40#A7FFEB#64FFDA#1DE9B6#00BFA5", 28703 green = "#E8F5E9#C8E6C9#A5D6A7#81C784#66BB6A#4CAF50#43A047#388E3C#2E7D32#1B5E20#B9F6CA#69F0AE#00E676#00C853", 28704 lightgreen = "#F1F8E9#DCEDC8#C5E1A5#AED581#9CCC65#8BC34A#7CB342#689F38#558B2F#33691E#CCFF90#B2FF59#76FF03#64DD17", 28705 lime = "#F9FBE7#F0F4C3#E6EE9C#DCE775#D4E157#CDDC39#C0CA33#AFB42B#9E9D24#827717#F4FF81#EEFF41#C6FF00#AEEA00", 28706 yellow = "#FFFDE7#FFF9C4#FFF59D#FFF176#FFEE58#FFEB3B#FDD835#FBC02D#F9A825#F57F17#FFFF8D#FFFF00#FFEA00#FFD600", 28707 amber = "#FFF8E1#FFECB3#FFE082#FFD54F#FFCA28#FFC107#FFB300#FFA000#FF8F00#FF6F00#FFE57F#FFD740#FFC400#FFAB00", 28708 orange = "#FFF3E0#FFE0B2#FFCC80#FFB74D#FFA726#FF9800#FB8C00#F57C00#EF6C00#E65100#FFD180#FFAB40#FF9100#FF6D00", 28709 deeporange = "#FBE9E7#FFCCBC#FFAB91#FF8A65#FF7043#FF5722#F4511E#E64A19#D84315#BF360C#FF9E80#FF6E40#FF3D00#DD2C00", 28710 brown = "#EFEBE9#D7CCC8#BCAAA4#A1887F#8D6E63#795548#6D4C41#5D4037#4E342E#3E2723", 28711 grey = "#FAFAFA#F5F5F5#EEEEEE#E0E0E0#BDBDBD#9E9E9E#757575#616161#424242#212121", 28712 bluegrey = "#ECEFF1#CFD8DC#B0BEC5#90A4AE#78909C#607D8B#546E7A#455A64#37474F#263238"; 28713 /*\ 28714 * Snap.mui 28715 [ property ] 28716 ** 28717 * Contain Material UI colours. 28718 | Snap().rect(0, 0, 10, 10).attr({fill: Snap.mui.deeppurple, stroke: Snap.mui.amber[600]}); 28719 # For colour reference: <a href="https://www.materialui.co">https://www.materialui.co</a>. 28720 \*/ 28721 Snap.mui = {}; 28722 /*\ 28723 * Snap.flat 28724 [ property ] 28725 ** 28726 * Contain Flat UI colours. 28727 | Snap().rect(0, 0, 10, 10).attr({fill: Snap.flat.carrot, stroke: Snap.flat.wetasphalt}); 28728 # For colour reference: <a href="https://www.materialui.co">https://www.materialui.co</a>. 28729 \*/ 28730 Snap.flat = {}; 28731 function saveColor(colors) { 28732 colors = colors.split(/(?=#)/); 28733 var color = new String(colors[5]); 28734 color[50] = colors[0]; 28735 color[100] = colors[1]; 28736 color[200] = colors[2]; 28737 color[300] = colors[3]; 28738 color[400] = colors[4]; 28739 color[500] = colors[5]; 28740 color[600] = colors[6]; 28741 color[700] = colors[7]; 28742 color[800] = colors[8]; 28743 color[900] = colors[9]; 28744 if (colors[10]) { 28745 color.A100 = colors[10]; 28746 color.A200 = colors[11]; 28747 color.A400 = colors[12]; 28748 color.A700 = colors[13]; 28749 } 28750 return color; 28751 } 28752 Snap.mui.red = saveColor(red); 28753 Snap.mui.pink = saveColor(pink); 28754 Snap.mui.purple = saveColor(purple); 28755 Snap.mui.deeppurple = saveColor(deeppurple); 28756 Snap.mui.indigo = saveColor(indigo); 28757 Snap.mui.blue = saveColor(blue); 28758 Snap.mui.lightblue = saveColor(lightblue); 28759 Snap.mui.cyan = saveColor(cyan); 28760 Snap.mui.teal = saveColor(teal); 28761 Snap.mui.green = saveColor(green); 28762 Snap.mui.lightgreen = saveColor(lightgreen); 28763 Snap.mui.lime = saveColor(lime); 28764 Snap.mui.yellow = saveColor(yellow); 28765 Snap.mui.amber = saveColor(amber); 28766 Snap.mui.orange = saveColor(orange); 28767 Snap.mui.deeporange = saveColor(deeporange); 28768 Snap.mui.brown = saveColor(brown); 28769 Snap.mui.grey = saveColor(grey); 28770 Snap.mui.bluegrey = saveColor(bluegrey); 28771 Snap.flat.turquoise = "#1abc9c"; 28772 Snap.flat.greensea = "#16a085"; 28773 Snap.flat.sunflower = "#f1c40f"; 28774 Snap.flat.orange = "#f39c12"; 28775 Snap.flat.emerland = "#2ecc71"; 28776 Snap.flat.nephritis = "#27ae60"; 28777 Snap.flat.carrot = "#e67e22"; 28778 Snap.flat.pumpkin = "#d35400"; 28779 Snap.flat.peterriver = "#3498db"; 28780 Snap.flat.belizehole = "#2980b9"; 28781 Snap.flat.alizarin = "#e74c3c"; 28782 Snap.flat.pomegranate = "#c0392b"; 28783 Snap.flat.amethyst = "#9b59b6"; 28784 Snap.flat.wisteria = "#8e44ad"; 28785 Snap.flat.clouds = "#ecf0f1"; 28786 Snap.flat.silver = "#bdc3c7"; 28787 Snap.flat.wetasphalt = "#34495e"; 28788 Snap.flat.midnightblue = "#2c3e50"; 28789 Snap.flat.concrete = "#95a5a6"; 28790 Snap.flat.asbestos = "#7f8c8d"; 28791 /*\ 28792 * Snap.importMUIColors 28793 [ method ] 28794 ** 28795 * Imports Material UI colours into global object. 28796 | Snap.importMUIColors(); 28797 | Snap().rect(0, 0, 10, 10).attr({fill: deeppurple, stroke: amber[600]}); 28798 # For colour reference: <a href="https://www.materialui.co">https://www.materialui.co</a>. 28799 \*/ 28800 Snap.importMUIColors = function () { 28801 for (var color in Snap.mui) { 28802 if (Snap.mui.hasOwnProperty(color)) { 28803 window[color] = Snap.mui[color]; 28804 } 28805 } 28806 }; 28807}); 28808 28809return Snap; 28810}));
28810 28811}.call(window)); 28812 28813/***/ }), 28814/* 17 */ 28815/***/ (function(module, exports, __webpack_require__) { 28816 28817"use strict"; 28818 28819 28820Object.defineProperty(exports, "__esModule", { 28821 value: true 28822}); 28823exports.default = exports.MorphSVGPlugin = undefined; 28824 28825var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; /*! 28826 * VERSION: 0.8.11 28827 * DATE: 2018-05-30 28828 * UPDATES AND DOCS AT: http://greensock.com 28829 * 28830 * @license Copyright (c) 2008-2018, GreenSock. All rights reserved. 28831 * MorphSVGPlugin is a Club GreenSock membership benefit; You must have a valid membership to use 28832 * this code without violating the terms of use. Visit http://greensock.com/club/ to sign up or get more details. 28833 * This work is subject to the software agreement that was issued with your membership. 28834 * 28835 * @author: Jack Doyle, [email protected] 28836 */ 28837 28838var _TweenLite = __webpack_require__(3); 28839 28840var _DEG2RAD = Math.PI / 180, 28841 _RAD2DEG = 180 / Math.PI, 28842 _svgPathExp = /[achlmqstvz]|(-?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/ig, 28843 _numbersExp = /(?:(-|-=|\+=)?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/ig, 28844 _selectorExp = /(^[#\.][a-z]|[a-y][a-z])/gi, 28845 _commands = /[achlmqstvz]/ig, 28846 _scientific = /[\+\-]?\d*\.?\d+e[\+\-]?\d+/ig, 28847 28848//_attrExp = /(\S+)=["']?((?:.(?!["']?\s+(?:\S+)=|[>"']))+.)["']?/gi, //finds all the attribute name/value pairs in an HTML element 28849//_outerTagExp = /^<([A-Za-z0-9_\-]+)((?:\s+[A-Za-z0-9_\-]+(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/i, //takes the outerHTML and pulls out [0] - the first tag, [1] - the tag name, and [2] - the attribute name/value pairs (space-delimited) 28850//_wrappingQuotesExp = /^["']|["']$/g, 28851TweenLite = _TweenLite._gsScope._gsDefine.globals.TweenLite, 28852 28853//_nonNumbersExp = /(?:([\-+](?!(\d|=)))|[^\d\-+=e]|(e(?![\-+][\d])))+/ig, 28854 28855_log = function _log(message) { 28856 if (_TweenLite._gsScope.console) { 28857 console.log(message); 28858 } 28859}, 28860 28861 28862// translates an arc into a normalized array of cubic beziers excluding the starting x/y. The circle the arc follows will be centered at 0,0 and have a radius of 1 (hence normalized). Each bezier covers no more than 90 degrees; the arc will be divided evenly into a maximum of four curves. 28863_normalizedArcToBeziers = function _normalizedArcToBeziers(angleStart, angleExtent) { 28864 var segments = Math.ceil(Math.abs(angleExtent) / 90), 28865 l = 0, 28866 a = [], 28867 angleIncrement,
28868 controlLength, 28869 angle, 28870 dx, 28871 dy, 28872 i; 28873 angleStart *= _DEG2RAD; 28874 angleExtent *= _DEG2RAD; 28875 angleIncrement = angleExtent / segments; 28876 controlLength = 4 / 3 * Math.sin(angleIncrement / 2) / (1 + Math.cos(angleIncrement / 2)); 28877 for (i = 0; i < segments; i++) { 28878 angle = angleStart + i * angleIncrement; 28879 dx = Math.cos(angle); 28880 dy = Math.sin(angle); 28881 a[l++] = dx - controlLength * dy; 28882 a[l++] = dy + controlLength * dx; 28883 angle += angleIncrement; 28884 dx = Math.cos(angle); 28885 dy = Math.sin(angle); 28886 a[l++] = dx + controlLength * dy; 28887 a[l++] = dy - controlLength * dx; 28888 a[l++] = dx; 28889 a[l++] = dy; 28890 } 28891 return a; 28892}, 28893 28894 28895// translates SVG arc data into an array of cubic beziers 28896_arcToBeziers = function _arcToBeziers(lastX, lastY, rx, ry, angle, largeArcFlag, sweepFlag, x, y) { 28897 if (lastX === x && lastY === y) { 28898 return; 28899 } 28900 rx = Math.abs(rx); 28901 ry = Math.abs(ry); 28902 var angleRad = angle % 360 * _DEG2RAD, 28903 cosAngle = Math.cos(angleRad), 28904 sinAngle = Math.sin(angleRad), 28905 dx2 = (lastX - x) / 2, 28906 dy2 = (lastY - y) / 2, 28907 x1 = cosAngle * dx2 + sinAngle * dy2, 28908 y1 = -sinAngle * dx2 + cosAngle * dy2, 28909 rx_sq = rx * rx, 28910 ry_sq = ry * ry, 28911 x1_sq = x1 * x1, 28912 y1_sq = y1 * y1, 28913 radiiCheck = x1_sq / rx_sq + y1_sq / ry_sq; 28914 if (radiiCheck > 1) { 28915 rx = Math.sqrt(radiiCheck) * rx; 28916 ry = Math.sqrt(radiiCheck) * ry; 28917 rx_sq = rx * rx; 28918 ry_sq = ry * ry; 28919 } 28920 var sign = largeArcFlag === sweepFlag ? -1 : 1, 28921 sq = (rx_sq * ry_sq - rx_sq * y1_sq - ry_sq * x1_sq) / (rx_sq * y1_sq + ry_sq * x1_sq); 28922 if (sq < 0) { 28923 sq = 0; 28924 } 28925 var coef = sign * Math.sqrt(sq), 28926 cx1 = coef * (rx * y1 / ry), 28927 cy1 = coef * -(ry * x1 / rx), 28928 sx2 = (lastX + x) / 2, 28929 sy2 = (lastY + y) / 2, 28930 cx = sx2 + (cosAngle * cx1 - sinAngle * cy1), 28931 cy = sy2 + (sinAngle * cx1 + cosAngle * cy1), 28932 ux = (x1 - cx1) / rx, 28933 uy = (y1 - cy1) / ry, 28934 vx = (-x1 - cx1) / rx, 28935 vy = (-y1 - cy1) / ry, 28936 n = Math.sqrt(ux * ux + uy * uy), 28937 p = ux; 28938 sign = uy < 0 ? -1 : 1; 28939 var angleStart = sign * Math.acos(p / n) * _RAD2DEG; 28940 28941 n = Math.sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy)); 28942 p = ux * vx + uy * vy; 28943 sign = ux * vy - uy * vx < 0 ? -1 : 1; 28944 var angleExtent = sign * Math.acos(p / n) * _RAD2DEG; 28945 if (!sweepFlag && angleExtent > 0) { 28946 angleExtent -= 360; 28947 } else if (sweepFlag && angleExtent < 0) { 28948 angleExtent += 360; 28949 } 28950 angleExtent %= 360; 28951 angleStart %= 360; 28952 28953 var bezierPoints = _normalizedArcToBeziers(angleStart, angleExtent), 28954 a = cosAngle * rx, 28955 b = sinAngle * rx, 28956 c = sinAngle * -ry, 28957 d = cosAngle * ry, 28958 l = bezierPoints.length - 2, 28959 i, 28960 px, 28961 py; 28962 //translate all the bezier points according to the matrix... 28963 for (i = 0; i < l; i += 2) { 28964 px = bezierPoints[i]; 28965 py = bezierPoints[i + 1]; 28966 bezierPoints[i] = px * a + py * c + cx; 28967 bezierPoints[i + 1] = px * b + py * d + cy; 28968 } 28969 bezierPoints[bezierPoints.length - 2] = x; //always set the end to exactly where it's supposed to be 28970 bezierPoints[bezierPoints.length - 1] = y; 28971 return bezierPoints; 28972}, 28973 28974 28975//Spits back an array of cubic Bezier segments that use absolute coordinates. Each segment starts with a "moveTo" command (x coordinate, then y) and then 2 control points (x, y, x, y), then anchor. The goal is to minimize memory and maximize speed. 28976_pathDataToBezier = function _pathDataToBezier(d) { 28977 var a = (d + "").replace(_scientific, function (m) { 28978 var n = +m;return n < 0.0001 && n > -0.0001 ? 0 : n; 28979 }).match(_svgPathExp) || [], 28980 //some authoring programs spit out very small numbers in scientific notation like "1e-5", so make sure we round that down to 0 first. 28981 path = [], 28982 relativeX = 0, 28983 relativeY = 0, 28984 elements = a.length, 28985 l = 2, 28986 points = 0, 28987 i, 28988 j, 28989 x, 28990 y, 28991 command, 28992 isRelative, 28993 segment, 28994 startX, 28995 startY, 28996 difX, 28997 difY, 28998 beziers, 28999 prevCommand; 29000 if (!d || !isNaN(a[0]) || isNaN(a[1])) { 29001 _log("ERROR: malformed path data: " + d); 29002 return path; 29003 } 29004 for (i = 0; i < elements; i++) { 29005 prevCommand = command; 29006 if (isNaN(a[i])) { 29007 command = a[i].toUpperCase(); 29008 isRelative = command !== a[i]; //lower case means relative 29009 } else { 29010 //commands like "C" can be strung together without any new command characters between. 29011 i--; 29012 } 29013 x = +a[i + 1]; 29014 y = +a[i + 2]; 29015 if (isRelative) { 29016 x += relativeX; 29017 y += relativeY; 29018 } 29019 if (i === 0) { 29020 startX = x; 29021 startY = y; 29022 } 29023 29024 // "M" (move) 29025 if (command === "M") { 29026 if (segment && segment.length < 8) {
29027 //if the path data was funky and just had a M with no actual drawing anywhere, skip it. 29028 path.length -= 1; 29029 l = 0; 29030 } 29031 relativeX = startX = x; 29032 relativeY = startY = y; 29033 segment = [x, y]; 29034 points += l; 29035 l = 2; 29036 path.push(segment); 29037 i += 2; 29038 command = "L"; //an "M" with more than 2 values gets interpreted as "lineTo" commands ("L"). 29039 29040 // "C" (cubic bezier) 29041 } else if (command === "C") { 29042 if (!segment) { 29043 segment = [0, 0]; 29044 } 29045 segment[l++] = x; 29046 segment[l++] = y; 29047 if (!isRelative) { 29048 relativeX = relativeY = 0; 29049 } 29050 segment[l++] = relativeX + a[i + 3] * 1; //note: "*1" is just a fast/short way to cast the value as a Number. WAAAY faster in Chrome, slightly slower in Firefox. 29051 segment[l++] = relativeY + a[i + 4] * 1; 29052 segment[l++] = relativeX = relativeX + a[i + 5] * 1; 29053 segment[l++] = relativeY = relativeY + a[i + 6] * 1; 29054 //if (y === segment[l-1] && y === segment[l-3] && x === segment[l-2] && x === segment[l-4]) { //if all the values are the same, eliminate the waste. 29055 // segment.length = l = l-6; 29056 //} 29057 i += 6; 29058 29059 // "S" (continuation of cubic bezier) 29060 } else if (command === "S") { 29061 if (prevCommand === "C" || prevCommand === "S") { 29062 difX = relativeX - segment[l - 4]; 29063 difY = relativeY - segment[l - 3]; 29064 segment[l++] = relativeX + difX; 29065 segment[l++] = relativeY + difY; 29066 } else { 29067 segment[l++] = relativeX; 29068 segment[l++] = relativeY; 29069 } 29070 segment[l++] = x; 29071 segment[l++] = y; 29072 if (!isRelative) { 29073 relativeX = relativeY = 0; 29074 } 29075 segment[l++] = relativeX = relativeX + a[i + 3] * 1; 29076 segment[l++] = relativeY = relativeY + a[i + 4] * 1; 29077 //if (y === segment[l-1] && y === segment[l-3] && x === segment[l-2] && x === segment[l-4]) { //if all the values are the same, eliminate the waste. 29078 // segment.length = l = l-6; 29079 //} 29080 i += 4; 29081 29082 // "Q" (quadratic bezier) 29083 } else if (command === "Q") { 29084 difX = x - relativeX; 29085 difY = y - relativeY; 29086 segment[l++] = relativeX + difX * 2 / 3; 29087 segment[l++] = relativeY + difY * 2 / 3; 29088 if (!isRelative) { 29089 relativeX = relativeY = 0; 29090 } 29091 relativeX = relativeX + a[i + 3] * 1; 29092 relativeY = relativeY + a[i + 4] * 1; 29093 difX = x - relativeX; 29094 difY = y - relativeY; 29095 segment[l++] = relativeX + difX * 2 / 3; 29096 segment[l++] = relativeY + difY * 2 / 3; 29097 segment[l++] = relativeX; 29098 segment[l++] = relativeY; 29099 29100 i += 4; 29101 29102 // "T" (continuation of quadratic bezier) 29103 } else if (command === "T") { 29104 difX = relativeX - segment[l - 4]; 29105 difY = relativeY - segment[l - 3]; 29106 segment[l++] = relativeX + difX; 29107 segment[l++] = relativeY + difY; 29108 difX = relativeX + difX * 1.5 - x; 29109 difY = relativeY + difY * 1.5 - y; 29110 segment[l++] = x + difX * 2 / 3; 29111 segment[l++] = y + difY * 2 / 3; 29112 segment[l++] = relativeX = x; 29113 segment[l++] = relativeY = y; 29114 29115 i += 2; 29116 29117 // "H" (horizontal line) 29118 } else if (command === "H") { 29119 y = relativeY; 29120 //if (x !== relativeX) { 29121 segment[l++] = relativeX + (x - relativeX) / 3; 29122 segment[l++] = relativeY + (y - relativeY) / 3; 29123 segment[l++] = relativeX + (x - relativeX) * 2 / 3; 29124 segment[l++] = relativeY + (y - relativeY) * 2 / 3; 29125 segment[l++] = relativeX = x; 29126 segment[l++] = y; 29127 //} 29128 i += 1; 29129 29130 // "V" (horizontal line) 29131 } else if (command === "V") { 29132 y = x; //adjust values because the first (and only one) isn't x in this case, it's y. 29133 x = relativeX; 29134 if (isRelative) { 29135 y += relativeY - relativeX; 29136 } 29137 //if (y !== relativeY) { 29138 segment[l++] = x; 29139 segment[l++] = relativeY + (y - relativeY) / 3; 29140 segment[l++] = x; 29141 segment[l++] = relativeY + (y - relativeY) * 2 / 3; 29142 segment[l++] = x; 29143 segment[l++] = relativeY = y; 29144 //} 29145 i += 1; 29146 29147 // "L" (line) or "Z" (close) 29148 } else if (command === "L" || command === "Z") { 29149 if (command === "Z") { 29150 x = startX; 29151 y = startY; 29152 segment.closed = true; 29153 } 29154 if (command === "L" || Math.abs(relativeX - x) > 0.5 || Math.abs(relativeY - y) > 0.5) { 29155 segment[l++] = relativeX + (x - relativeX) / 3; 29156 segment[l++] = relativeY + (y - relativeY) / 3; 29157 segment[l++] = relativeX + (x - relativeX) * 2 / 3; 29158 segment[l++] = relativeY + (y - relativeY) * 2 / 3; 29159 segment[l++] = x; 29160 segment[l++] = y; 29161 if (command === "L") { 29162 i += 2; 29163 } 29164 } 29165 relativeX = x; 29166 relativeY = y; 29167 29168 // "A" (arc) 29169 } else if (command === "A") {
29170 beziers = _arcToBeziers(relativeX, relativeY, a[i + 1] * 1, a[i + 2] * 1, a[i + 3] * 1, a[i + 4] * 1, a[i + 5] * 1, (isRelative ? relativeX : 0) + a[i + 6] * 1, (isRelative ? relativeY : 0) + a[i + 7] * 1); 29171 if (beziers) { 29172 for (j = 0; j < beziers.length; j++) { 29173 segment[l++] = beziers[j]; 29174 } 29175 } 29176 relativeX = segment[l - 2]; 29177 relativeY = segment[l - 1]; 29178 i += 7; 29179 } else { 29180 _log("Error: malformed path data: " + d); 29181 } 29182 } 29183 path.totalPoints = points + l; 29184 return path; 29185}, 29186 29187 29188//adds a certain number of Beziers while maintaining the path shape (so that the start/end values can have a matching quantity of points to animate). Only pass in ONE segment of the Bezier at a time. Format: [xAnchor, yAnchor, xControlPoint1, yControlPoint1, xControlPoint2, yControlPoint2, xAnchor, yAnchor, xControlPoint1, etc...] 29189_subdivideBezier = function _subdivideBezier(bezier, quantity) { 29190 var tally = 0, 29191 max = 0.999999, 29192 l = bezier.length, 29193 newPointsPerSegment = quantity / ((l - 2) / 6), 29194 ax, 29195 ay, 29196 cp1x, 29197 cp1y, 29198 cp2x, 29199 cp2y, 29200 bx, 29201 by, 29202 x1, 29203 y1, 29204 x2, 29205 y2, 29206 i, 29207 t; 29208 for (i = 2; i < l; i += 6) { 29209 tally += newPointsPerSegment; 29210 while (tally > max) { 29211 //compare with 0.99999 instead of 1 in order to prevent rounding errors 29212 ax = bezier[i - 2]; 29213 ay = bezier[i - 1]; 29214 cp1x = bezier[i]; 29215 cp1y = bezier[i + 1]; 29216 cp2x = bezier[i + 2]; 29217 cp2y = bezier[i + 3]; 29218 bx = bezier[i + 4]; 29219 by = bezier[i + 5]; 29220 t = 1 / (Math.floor(tally) + 1); //progress along the bezier (value between 0 and 1) 29221 29222 x1 = ax + (cp1x - ax) * t; 29223 x2 = cp1x + (cp2x - cp1x) * t; 29224 x1 += (x2 - x1) * t; 29225 x2 += (cp2x + (bx - cp2x) * t - x2) * t; 29226 29227 y1 = ay + (cp1y - ay) * t; 29228 y2 = cp1y + (cp2y - cp1y) * t; 29229 y1 += (y2 - y1) * t; 29230 y2 += (cp2y + (by - cp2y) * t - y2) * t; 29231 29232 bezier.splice(i, 4, ax + (cp1x - ax) * t, //first control point 29233 ay + (cp1y - ay) * t, x1, //second control point 29234 y1, x1 + (x2 - x1) * t, //new fabricated anchor on line 29235 y1 + (y2 - y1) * t, x2, //third control point 29236 y2, cp2x + (bx - cp2x) * t, //fourth control point 29237 cp2y + (by - cp2y) * t); 29238 i += 6; 29239 l += 6; 29240 tally--; 29241 } 29242 } 29243 return bezier; 29244}, 29245 _bezierToPathData = function _bezierToPathData(beziers) { 29246 var data = "", 29247 l = beziers.length, 29248 rnd = 100, 29249 sl, 29250 s, 29251 i, 29252 segment; 29253 for (s = 0; s < l; s++) { 29254 segment = beziers[s]; 29255 data += "M" + segment[0] + "," + segment[1] + " C"; 29256 sl = segment.length; 29257 for (i = 2; i < sl; i++) { 29258 data += (segment[i++] * rnd | 0) / rnd + "," + (segment[i++] * rnd | 0) / rnd + " " + (segment[i++] * rnd | 0) / rnd + "," + (segment[i++] * rnd | 0) / rnd + " " + (segment[i++] * rnd | 0) / rnd + "," + (segment[i] * rnd | 0) / rnd + " "; 29259 } 29260 if (segment.closed) { 29261 data += "z"; 29262 } 29263 } 29264 return data; 29265}, 29266 _reverseBezier = function _reverseBezier(bezier) { 29267 var a = [], 29268 i = bezier.length - 1, 29269 l = 0; 29270 while (--i > -1) { 29271 a[l++] = bezier[i]; 29272 a[l++] = bezier[i + 1]; 29273 i--; 29274 } 29275 for (i = 0; i < l; i++) { 29276 bezier[i] = a[i]; 29277 } 29278 bezier.reversed = bezier.reversed ? false : true; 29279}, 29280 _getAverageXY = function _getAverageXY(bezier) { 29281 var l = bezier.length, 29282 x = 0, 29283 y = 0, 29284 i; 29285 for (i = 0; i < l; i++) { 29286 x += bezier[i++]; 29287 y += bezier[i]; 29288 } 29289 return [x / (l / 2), y / (l / 2)]; 29290}, 29291 _getSize = function _getSize(bezier) { 29292 //rough estimate of the bounding box (based solely on the anchors) of a single segment. sets "size", "centerX", and "centerY" properties on the bezier array itself, and returns the size (width * height) 29293 var l = bezier.length, 29294 xMax = bezier[0], 29295 xMin = xMax, 29296 yMax = bezier[1], 29297 yMin = yMax, 29298 x, 29299 y, 29300 i; 29301 for (i = 6; i < l; i += 6) { 29302 x = bezier[i]; 29303 y = bezier[i + 1]; 29304 if (x > xMax) { 29305 xMax = x; 29306 } else if (x < xMin) { 29307 xMin = x; 29308 } 29309 if (y > yMax) { 29310 yMax = y; 29311 } else if (y < yMin) { 29312 yMin = y; 29313 } 29314 } 29315 bezier.centerX = (xMax + xMin) / 2; 29316 bezier.centerY = (yMax + yMin) / 2; 29317 return bezier.size = (xMax - xMin) * (yMax - yMin); 29318}, 29319 _getTotalSize = function _getTotalSize(bezier) { 29320 //rough estimate of the bounding box of the entire list of Bezier segments (based solely on the anch
vendor: 8,534 bytes, lines 29320-29570
29320ors). sets "size", "centerX", and "centerY" properties on the bezier array itself, and returns the size (width * height) 29321 var segment = bezier.length, 29322 xMax = bezier[0][0], 29323 xMin = xMax, 29324 yMax = bezier[0][1], 29325 yMin = yMax, 29326 l, 29327 x, 29328 y, 29329 i, 29330 b; 29331 while (--segment > -1) { 29332 b = bezier[segment]; 29333 l = b.length; 29334 for (i = 6; i < l; i += 6) { 29335 x = b[i]; 29336 y = b[i + 1]; 29337 if (x > xMax) { 29338 xMax = x; 29339 } else if (x < xMin) { 29340 xMin = x; 29341 } 29342 if (y > yMax) { 29343 yMax = y; 29344 } else if (y < yMin) { 29345 yMin = y; 29346 } 29347 } 29348 } 29349 bezier.centerX = (xMax + xMin) / 2; 29350 bezier.centerY = (yMax + yMin) / 2; 29351 return bezier.size = (xMax - xMin) * (yMax - yMin); 29352}, 29353 _sortByComplexity = function _sortByComplexity(a, b) { 29354 return b.length - a.length; 29355}, 29356 _sortBySize = function _sortBySize(a, b) { 29357 var sizeA = a.size || _getSize(a), 29358 sizeB = b.size || _getSize(b); 29359 return Math.abs(sizeB - sizeA) < (sizeA + sizeB) / 20 ? b.centerX - a.centerX || b.centerY - a.centerY : sizeB - sizeA; //if the size is within 10% of each other, prioritize position from left to right, then top to bottom. 29360}, 29361 _offsetBezier = function _offsetBezier(bezier, shapeIndex) { 29362 var a = bezier.slice(0), 29363 l = bezier.length, 29364 wrap = l - 2, 29365 i, 29366 index; 29367 shapeIndex = shapeIndex | 0; 29368 for (i = 0; i < l; i++) { 29369 index = (i + shapeIndex) % wrap; 29370 bezier[i++] = a[index]; 29371 bezier[i] = a[index + 1]; 29372 } 29373}, 29374 _getTotalMovement = function _getTotalMovement(sb, eb, shapeIndex, offsetX, offsetY) { 29375 var l = sb.length, 29376 d = 0, 29377 wrap = l - 2, 29378 index, 29379 i, 29380 x, 29381 y; 29382 shapeIndex *= 6; 29383 for (i = 0; i < l; i += 6) { 29384 index = (i + shapeIndex) % wrap; 29385 y = sb[index] - (eb[i] - offsetX); 29386 x = sb[index + 1] - (eb[i + 1] - offsetY); 29387 d += Math.sqrt(x * x + y * y); 29388 } 29389 return d; 29390}, 29391 _getClosestShapeIndex = function _getClosestShapeIndex(sb, eb, checkReverse) { 29392 //finds the index in a closed cubic bezier array that's closest to the angle provided (angle measured from the center or average x/y). 29393 var l = sb.length, 29394 sCenter = _getAverageXY(sb), 29395 //when comparing distances, adjust the coordinates as if the shapes are centered with each other. 29396 eCenter = _getAverageXY(eb), 29397 offsetX = eCenter[0] - sCenter[0], 29398 offsetY = eCenter[1] - sCenter[1], 29399 min = _getTotalMovement(sb, eb, 0, offsetX, offsetY), 29400 minIndex = 0, 29401 copy, 29402 d, 29403 i; 29404 for (i = 6; i < l; i += 6) { 29405 d = _getTotalMovement(sb, eb, i / 6, offsetX, offsetY); 29406 if (d < min) { 29407 min = d; 29408 minIndex = i; 29409 } 29410 } 29411 if (checkReverse) { 29412 copy = sb.slice(0); 29413 _reverseBezier(copy); 29414 for (i = 6; i < l; i += 6) { 29415 d = _getTotalMovement(copy, eb, i / 6, offsetX, offsetY); 29416 if (d < min) { 29417 min = d; 29418 minIndex = -i; 29419 } 29420 } 29421 } 29422 return minIndex / 6; 29423}, 29424 _getClosestAnchor = function _getClosestAnchor(bezier, x, y) { 29425 //finds the x/y of the anchor that's closest to the provided x/y coordinate (returns an array, like [x, y]). The bezier should be the top-level type that contains an array for each segment. 29426 var j = bezier.length, 29427 closestDistance = 99999999999, 29428 closestX = 0, 29429 closestY = 0, 29430 b, 29431 dx, 29432 dy, 29433 d, 29434 i, 29435 l; 29436 while (--j > -1) { 29437 b = bezier[j]; 29438 l = b.length; 29439 for (i = 0; i < l; i += 6) { 29440 dx = b[i] - x; 29441 dy = b[i + 1] - y; 29442 d = Math.sqrt(dx * dx + dy * dy); 29443 if (d < closestDistance) { 29444 closestDistance = d; 29445 closestX = b[i]; 29446 closestY = b[i + 1]; 29447 } 29448 } 29449 } 29450 return [closestX, closestY]; 29451}, 29452 _getClosestSegment = function _getClosestSegment(bezier, pool, startIndex, sortRatio, offsetX, offsetY) { 29453 //matches the bezier to the closest one in a pool (array) of beziers, assuming they are in order of size and we shouldn't drop more than 20% of the size, otherwise prioritizing location (total distance to the center). Extracts the segment out of the pool array and returns it. 29454 var l = pool.length, 29455 index = 0, 29456 minSize = Math.min(bezier.size || _getSize(bezier), pool[startIndex].size || _getSize(pool[startIndex])) * sortRatio, 29457 //limit things based on a percentage of the size of either the bezier or the next element in the array, whichever is smaller. 29458 min = 999999999999, 29459 cx = bezier.centerX + offsetX, 29460 cy = bezier.centerY + offsetY, 29461 size, 29462 i, 29463 dx, 29464 dy, 29465 d; 29466 for (i = startIndex; i < l; i++) { 29467 size = pool[i].size || _getSize(pool[i]); 29468 if (size < minSize) { 29469 break; 29470 } 29471 dx = pool[i].centerX - cx; 29472 dy = pool[i].centerY - cy; 29473 d = Math.sqrt(dx * dx + dy * dy); 29474 if (d < min) { 29475 index = i; 29476 min = d; 29477 } 29478 } 29479 d = pool[index]; 29480 pool.splice(index, 1); 29481 return d; 29482}, 29483 _equalizeSegmentQuantity = function _equalizeSegmentQuantity(start, end, shapeIndex, map) { 29484 //returns an array of shape indexes, 1 for each segment. 29485 var dif = end.length - start.length, 29486 longer = dif > 0 ? end : start, 29487 shorter = dif > 0 ? start : end, 29488 added = 0, 29489 sortMethod = map === "complexity" ? _sortByComplexity : _sortBySize, 29490 sortRatio = map === "position" ? 0 : typeof map === "number" ? map : 0.8, 29491 i = shorter.length, 29492 shapeIndices = (typeof shapeIndex === "undefined" ? "undefined" : _typeof(shapeIndex)) === "object" && shapeIndex.push ? shapeIndex.slice(0) : [shapeIndex], 29493 reverse = shapeIndices[0] === "reverse" || shapeIndices[0] < 0, 29494 log = shapeIndex === "log", 29495 eb, 29496 sb, 29497 b, 29498 x, 29499 y, 29500 offsetX, 29501 offsetY; 29502 if (!shorter[0]) { 29503 return; 29504 } 29505 if (longer.length > 1) { 29506 start.sort(sortMethod); 29507 end.sort(sortMethod); 29508 offsetX = longer.size || _getTotalSize(longer); //ensures centerX and centerY are defined (used below). 29509 offsetX = shorter.size || _getTotalSize(shorter); 29510 offsetX = longer.centerX - shorter.centerX; 29511 offsetY = longer.centerY - shorter.centerY; 29512 if (sortMethod === _sortBySize) { 29513 for (i = 0; i < shorter.length; i++) { 29514 longer.splice(i, 0, _getClosestSegment(shorter[i], longer, i, sortRatio, offsetX, offsetY)); 29515 } 29516 } 29517 } 29518 if (dif) { 29519 if (dif < 0) { 29520 dif = -dif; 29521 } 29522 if (longer[0].length > shorter[0].length) { 29523 //since we use shorter[0] as the one to map the origination point of any brand new fabricated segments, do any subdividing first so that there are more points to choose from (if necessary) 29524 _subdivideBezier(shorter[0], (longer[0].length - shorter[0].length) / 6 | 0); 29525 } 29526 i = shorter.length; 29527 while (added < dif) { 29528 x = longer[i].size || _getSize(longer[i]); //just to ensure centerX and centerY are calculated which we use on the next line. 29529 b = _getClosestAnchor(shorter, longer[i].centerX, longer[i].centerY); 29530 x = b[0]; 29531 y = b[1]; 29532 shorter[i++] = [x, y, x, y, x, y, x, y]; 29533 shorter.totalPoints += 8; 29534 added++; 29535 } 29536 } 29537 for (i = 0; i < start.length; i++) { 29538 eb = end[i]; 29539 sb = start[i]; 29540 dif = eb.length - sb.length; 29541 if (dif < 0) { 29542 _subdivideBezier(eb, -dif / 6 | 0); 29543 } else if (dif > 0) { 29544 _subdivideBezier(sb, dif / 6 | 0); 29545 } 29546 if (reverse && !sb.reversed) { 29547 _reverseBezier(sb); 29548 } 29549 shapeIndex = shapeIndices[i] || shapeIndices[i] === 0 ? shapeIndices[i] : "auto"; 29550 if (shapeIndex) { 29551 //if start shape is closed, find the closest point to the start/end, and re-organize the bezier points accordingly so that the shape morphs in a more intuitive way. 29552 if (sb.closed || Math.abs(sb[0] - sb[sb.length - 2]) < 0.5 && Math.abs(sb[1] - sb[sb.length - 1]) < 0.5) { 29553 if (shapeIndex === "auto" || shapeIndex === "log") { 29554 shapeIndices[i] = shapeIndex = _getClosestShapeIndex(sb, eb, i === 0); 29555 if (shapeIndex < 0) { 29556 reverse = true; 29557 _reverseBezier(sb); 29558 shapeIndex = -shapeIndex; 29559 } 29560 _offsetBezier(sb, shapeIndex * 6); 29561 } else if (shapeIndex !== "reverse") { 29562 if (i && shapeIndex < 0) { 29563 //only happens if an array is passed as shapeIndex and a negative value is defined for an index beyond 0. Very rare, but helpful sometimes. 29564 _reverseBezier(sb); 29565 } 29566 _offsetBezier(sb, (shapeIndex < 0 ? -shapeIndex : shapeIndex) * 6); 29567 } 29568 //otherwise, if it's not a closed shape, consider reversing it if that would make the overall travel less 29569 } else if (!reverse && (shapeIndex === "auto" && Math.abs(eb[0] - sb[0]) + Math.abs(eb[1] - sb[1]) + Math.abs(eb[eb.length - 2] - sb[sb.length - 2]) + Math.abs(eb[eb.length - 1] - sb[sb.length - 1]) > Math.abs(eb[0] - sb[sb.length - 2]) + Math.abs(eb[1] - sb[sb.length - 1]) + Math.abs(eb[eb.length - 2] - sb[0]) + Math.abs(eb[eb.length - 1] - sb[1]) || shapeIndex % 2)) { 29570 _reverseBezier(sb);
29571 shapeIndices[i] = -1; 29572 reverse = true; 29573 } else if (shapeIndex === "auto") { 29574 shapeIndices[i] = 0; 29575 } else if (shapeIndex === "reverse") { 29576 shapeIndices[i] = -1; 29577 } 29578 if (sb.closed !== eb.closed) { 29579 //if one is closed and one isn't, don't close either one otherwise the tweening will look weird (but remember, the beginning and final states will honor the actual values, so this only affects the inbetween state) 29580 sb.closed = eb.closed = false; 29581 } 29582 } 29583 } 29584 if (log) { 29585 _log("shapeIndex:[" + shapeIndices.join(",") + "]"); 29586 } 29587 return shapeIndices; 29588}, 29589 _pathFilter = function _pathFilter(a, shapeIndex, map, precompile) { 29590 var start = _pathDataToBezier(a[0]), 29591 end = _pathDataToBezier(a[1]); 29592 if (!_equalizeSegmentQuantity(start, end, shapeIndex || shapeIndex === 0 ? shapeIndex : "auto", map)) { 29593 return; //malformed path data or null target 29594 } 29595 a[0] = _bezierToPathData(start); 29596 a[1] = _bezierToPathData(end); 29597 if (precompile === "log" || precompile === true) { 29598 _log('precompile:["' + a[0] + '","' + a[1] + '"]'); 29599 } 29600}, 29601 _buildPathFilter = function _buildPathFilter(shapeIndex, map, precompile) { 29602 return map || precompile || shapeIndex || shapeIndex === 0 ? function (a) { 29603 _pathFilter(a, shapeIndex, map, precompile); 29604 } : _pathFilter; 29605}, 29606 _offsetPoints = function _offsetPoints(text, offset) { 29607 if (!offset) { 29608 return text; 29609 } 29610 var a = text.match(_numbersExp) || [], 29611 l = a.length, 29612 s = "", 29613 inc, 29614 i, 29615 j; 29616 if (offset === "reverse") { 29617 i = l - 1; 29618 inc = -2; 29619 } else { 29620 i = ((parseInt(offset, 10) || 0) * 2 + 1 + l * 100) % l; 29621 inc = 2; 29622 } 29623 for (j = 0; j < l; j += 2) { 29624 s += a[i - 1] + "," + a[i] + " "; 29625 i = (i + inc) % l; 29626 } 29627 return s; 29628}, 29629 29630//adds a certain number of points while maintaining the polygon/polyline shape (so that the start/end values can have a matching quantity of points to animate). Returns the revised string. 29631_equalizePointQuantity = function _equalizePointQuantity(a, quantity) { 29632 var tally = 0, 29633 x = parseFloat(a[0]), 29634 y = parseFloat(a[1]), 29635 s = x + "," + y + " ", 29636 max = 0.999999, 29637 newPointsPerSegment, 29638 i, 29639 l, 29640 j, 29641 factor, 29642 nextX, 29643 nextY; 29644 l = a.length; 29645 newPointsPerSegment = quantity * 0.5 / (l * 0.5 - 1); 29646 for (i = 0; i < l - 2; i += 2) { 29647 tally += newPointsPerSegment; 29648 nextX = parseFloat(a[i + 2]); 29649 nextY = parseFloat(a[i + 3]); 29650 if (tally > max) { 29651 //compare with 0.99999 instead of 1 in order to prevent rounding errors 29652 factor = 1 / (Math.floor(tally) + 1); 29653 j = 1; 29654 while (tally > max) { 29655 s += (x + (nextX - x) * factor * j).toFixed(2) + "," + (y + (nextY - y) * factor * j).toFixed(2) + " "; 29656 tally--; 29657 j++; 29658 } 29659 } 29660 s += nextX + "," + nextY + " "; 29661 x = nextX; 29662 y = nextY; 29663 } 29664 return s; 29665}, 29666 _pointsFilter = function _pointsFilter(a) { 29667 var startNums = a[0].match(_numbersExp) || [], 29668 endNums = a[1].match(_numbersExp) || [], 29669 dif = endNums.length - startNums.length; 29670 if (dif > 0) { 29671 a[0] = _equalizePointQuantity(startNums, dif); 29672 } else { 29673 a[1] = _equalizePointQuantity(endNums, -dif); 29674 } 29675}, 29676 _buildPointsFilter = function _buildPointsFilter(shapeIndex) { 29677 return !isNaN(shapeIndex) ? function (a) { 29678 _pointsFilter(a); 29679 a[1] = _offsetPoints(a[1], parseInt(shapeIndex, 10)); 29680 } : _pointsFilter; 29681}, 29682 _createPath = function _createPath(e, ignore) { 29683 var path = _TweenLite._gsScope.document.createElementNS("http://www.w3.org/2000/svg", "path"), 29684 attr = Array.prototype.slice.call(e.attributes), 29685 i = attr.length, 29686 name; 29687 ignore = "," + ignore + ","; 29688 while (--i > -1) { 29689 name = attr[i].nodeName.toLowerCase(); //in Microsoft Edge, if you don't set the attribute with a lowercase name, it doesn't render correctly! Super weird. 29690 if (ignore.indexOf("," + name + ",") === -1) { 29691 path.setAttributeNS(null, name, attr[i].nodeValue); 29692 } 29693 } 29694 return path; 29695}, 29696 _convertToPath = function _convertToPath(e, swap) { 29697 var type = e.tagName.toLowerCase(), 29698 circ = 0.552284749831, 29699 data, 29700 x, 29701 y, 29702 r, 29703 ry, 29704 path, 29705 rcirc, 29706 rycirc, 29707 points, 29708 w, 29709 h, 29710 x2, 29711 x3, 29712 x4, 29713 x5, 29714 x6, 29715 y2, 29716 y3, 29717 y4, 29718 y5, 29719 y6; 29720 if (type === "path" || !e.getBBox) { 29721 return e; 29722 } 29723 path = _createPath(e, "x,y,width,height,cx,cy,rx,ry,r,x1,x2,y1,y2,points"); 29724 if (type === "rect") { 29725 r = +e.getAttribute("rx") || 0; 29726 ry = +e.getAttribute("ry") || 0; 29727 x = +e.getAttribute("x") || 0; 29728 y = +e.getAttribute("y") || 0; 29729 w = (+e.getAttribute("width") || 0) - r * 2; 29730 h = (+e.getAttribute("height") || 0) - ry * 2; 29731 if (r || ry) { 29732 //if there are rounded corners, render cubic beziers 29733 x2 = x + r * (1 - circ); 29734 x3 = x + r; 29735 x4 = x3 + w; 29736 x5 = x4 + r * circ; 29737 x6 = x4 + r;
29738 y2 = y + ry * (1 - circ); 29739 y3 = y + ry; 29740 y4 = y3 + h; 29741 y5 = y4 + ry * circ; 29742 y6 = y4 + ry; 29743 data = "M" + x6 + "," + y3 + " V" + y4 + " C" + [x6, y5, x5, y6, x4, y6, x4 - (x4 - x3) / 3, y6, x3 + (x4 - x3) / 3, y6, x3, y6, x2, y6, x, y5, x, y4, x, y4 - (y4 - y3) / 3, x, y3 + (y4 - y3) / 3, x, y3, x, y2, x2, y, x3, y, x3 + (x4 - x3) / 3, y, x4 - (x4 - x3) / 3, y, x4, y, x5, y, x6, y2, x6, y3].join(",") + "z"; 29744 } else { 29745 data = "M" + (x + w) + "," + y + " v" + h + " h" + -w + " v" + -h + " h" + w + "z"; 29746 } 29747 } else if (type === "circle" || type === "ellipse") { 29748 if (type === "circle") { 29749 r = ry = +e.getAttribute("r") || 0; 29750 rycirc = r * circ; 29751 } else { 29752 r = +e.getAttribute("rx") || 0; 29753 ry = +e.getAttribute("ry") || 0; 29754 rycirc = ry * circ; 29755 } 29756 x = +e.getAttribute("cx") || 0; 29757 y = +e.getAttribute("cy") || 0; 29758 rcirc = r * circ; 29759 data = "M" + (x + r) + "," + y + " C" + [x + r, y + rycirc, x + rcirc, y + ry, x, y + ry, x - rcirc, y + ry, x - r, y + rycirc, x - r, y, x - r, y - rycirc, x - rcirc, y - ry, x, y - ry, x + rcirc, y - ry, x + r, y - rycirc, x + r, y].join(",") + "z"; 29760 } else if (type === "line") { 29761 data = _bezierToPathData(_pathDataToBezier("M" + (e.getAttribute("x1") || 0) + "," + (e.getAttribute("y1") || 0) + " L" + (e.getAttribute("x2") || 0) + "," + (e.getAttribute("y2") || 0))); //previously, we just converted to "Mx,y Lx,y" but Safari has bugs that cause that not to render properly when using a stroke-dasharray that's not fully visible! Using a cubic bezier fixes that issue. 29762 } else if (type === "polyline" || type === "polygon") { 29763 points = (e.getAttribute("points") + "").match(_numbersExp) || []; 29764 x = points.shift(); 29765 y = points.shift(); 29766 data = "M" + x + "," + y + " L" + points.join(","); 29767 if (type === "polygon") { 29768 data += "," + x + "," + y + "z"; 29769 } 29770 } 29771 path.setAttribute("d", data); 29772 if (swap && e.parentNode) { 29773 e.parentNode.insertBefore(path, e); 29774 e.parentNode.removeChild(e); 29775 } 29776 29777 return path; 29778}, 29779 _parseShape = function _parseShape(shape, forcePath, target) { 29780 var isString = typeof shape === "string", 29781 e, 29782 type; 29783 if (!isString || _selectorExp.test(shape) || (shape.match(_numbersExp) || []).length < 3) { 29784 e = isString ? TweenLite.selector(shape) : shape && shape[0] ? shape : [shape]; //allow array-like objects like jQuery objects. 29785 if (e && e[0]) { 29786 e = e[0]; 29787 type = e.nodeName.toUpperCase(); 29788 if (forcePath && type !== "PATH") { 29789 //if we were passed an element (or selector text for an element) that isn't a path, convert it. 29790 e = _convertToPath(e, false); 29791 type = "PATH"; 29792 } 29793 shape = e.getAttribute(type === "PATH" ? "d" : "points") || ""; 29794 if (e === target) { 29795 //if the shape matches the target element, the user wants to revert to the original which should have been stored in the data-original attribute 29796 shape = e.getAttributeNS(null, "data-original") || shape; 29797 } 29798 } else { 29799 _log("WARNING: invalid morph to: " + shape); 29800 shape = false;
29801 } 29802 } 29803 return shape; 29804}, 29805 _morphMessage = "Use MorphSVGPlugin.convertToPath(elementOrSelectorText) to convert to a path before morphing.", 29806 MorphSVGPlugin = _TweenLite._gsScope._gsDefine.plugin({ 29807 propName: "morphSVG", 29808 API: 2, 29809 global: true, 29810 version: "0.8.11", 29811 29812 //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. 29813 init: function init(target, value, tween, index) { 29814 var type, p, pt, shape, isPoly; 29815 if (typeof target.setAttribute !== "function") { 29816 return false; 29817 } 29818 if (typeof value === "function") { 29819 value = value(index, target); 29820 } 29821 type = target.nodeName.toUpperCase(); 29822 isPoly = type === "POLYLINE" || type === "POLYGON"; 29823 if (type !== "PATH" && !isPoly) { 29824 _log("WARNING: cannot morph a <" + type + "> SVG element. " + _morphMessage); 29825 return false; 29826 } 29827 p = type === "PATH" ? "d" : "points"; 29828 if (typeof value === "string" || value.getBBox || value[0]) { 29829 value = { shape: value }; 29830 } 29831 shape = _parseShape(value.shape || value.d || value.points || "", p === "d", target); 29832 if (isPoly && _commands.test(shape)) { 29833 _log("WARNING: a <" + type + "> cannot accept path data. " + _morphMessage); 29834 return false; 29835 } 29836 if (shape) { 29837 this._target = target; 29838 if (!target.getAttributeNS(null, "data-original")) { 29839 target.setAttributeNS(null, "data-original", target.getAttribute(p)); //record the original state in a data-original attribute so that we can revert to it later. 29840 } 29841 pt = this._addTween(target, "setAttribute", target.getAttribute(p) + "", shape + "", "morphSVG", false, p, _typeof(value.precompile) === "object" ? function (a) { 29842 a[0] = value.precompile[0];a[1] = value.precompile[1]; 29843 } : p === "d" ? _buildPathFilter(value.shapeIndex, value.map || MorphSVGPlugin.defaultMap, value.precompile) : _buildPointsFilter(value.shapeIndex)); 29844 if (pt) { 29845 this._overwriteProps.push("morphSVG"); 29846 pt.end = shape; 29847 pt.endProp = p; 29848 } 29849 } 29850 return true; 29851 }, 29852 29853 set: function set(ratio) { 29854 var pt; 29855 this._super.setRatio.call(this, ratio); 29856 if (ratio === 1) { 29857 pt = this._firstPT; 29858 while (pt) { 29859 if (pt.end) { 29860 this._target.setAttribute(pt.endProp, pt.end); //make sure the end value is exactly as specified (in case we had to add fabricated points during the tween) 29861 } 29862 pt = pt._next; 29863 } 29864 } 29865 } 29866 29867}); 29868 29869MorphSVGPlugin.pathFilter = _pathFilter; 29870MorphSVGPlugin.pointsFilter = _pointsFilter; 29871MorphSVGPlugin.subdivideRawBezier = _subdivideBezier; 29872MorphSVGPlugin.defaultMap = "size"; 29873MorphSVGPlugin.pathDataToRawBezier = function (data) { 29874 return _pathDataToBezier(_parseShape(data, true)); 29875}; 29876MorphSVGPlugin.equalizeSegmentQuantity = _equalizeSegmentQuantity; 29877 29878MorphSVGPlugin.convertToPath = function (targets, swap) { 29879 if (typeof targets === "string") { 29880 targets = TweenLite.selector(targets); 29881 } 29882 var a = !targets || targets.length === 0 ? [] : targets.length && targets[0] && targets[0].nodeType ? Array.prototype.slice.call(targets, 0) : [targets], 29883 i = a.length; 29884 while (--i > -1) { 29885 a[i] = _convertToPath(a[i], swap !== false); 29886 } 29887 return a; 29888}; 29889 29890MorphSVGPlugin.pathDataToBezier = function (data, vars) { 29891 //converts SVG path data into an array of {x, y} objects that can be plugged directly into a bezier tween. You can optionally pass in a 2D matrix like [a, b, c, d, tx, ty] containing numbers that should transform each point. 29892 var bezier = _pathDataToBezier(_parseShape(data, true))[0] || [], 29893 prefix = 0, 29894 a, 29895 i, 29896 l, 29897 matrix, 29898 offsetX, 29899 offsetY, 29900 bbox, 29901 e; 29902 vars = vars || {}; 29903 e = vars.align || vars.relative; 29904 matrix = vars.matrix || [1, 0, 0, 1, 0, 0]; 29905 offsetX = vars.offsetX || 0; 29906 offsetY = vars.offsetY || 0; 29907 if (e === "relative" || e === true) { 29908 offsetX -= bezier[0] * matrix[0] + bezier[1] * matrix[2]; 29909 offsetY -= bezier[0] * matrix[1] + bezier[1] * matrix[3]; 29910 prefix = "+="; 29911 } else { 29912 offsetX += matrix[4]; 29913 offsetY += matrix[5]; 29914 if (e) { 29915 e = typeof e === "string" ? TweenLite.selector(e) : e && e[0] ? e : [e]; //allow array-like objects like jQuery objects. 29916 if (e && e[0]) { 29917 bbox = e[0].getBBox() || { x: 0, y: 0 }; 29918 offsetX -= bbox.x; 29919 offsetY -= bbox.y; 29920 } 29921 } 29922 } 29923 a = []; 29924 l = bezier.length; 29925 if (matrix && matrix.join(",") !== "1,0,0,1,0,0") { 29926 for (i = 0; i < l; i += 2) { 29927 a.push({ x: prefix + (bezier[i] * matrix[0] + bezier[i + 1] * matrix[2] + offsetX), y: prefix + (bezier[i] * matrix[1] + bezier[i + 1] * matrix[3] + offsetY) }); 29928 } 29929 } else { 29930 for (i = 0; i < l; i += 2) { 29931 a.push({ x: prefix + (bezier[i] + offsetX), y: prefix + (bezier[i + 1] + offsetY) }); 29932 } 29933 } 29934 return a; 29935}; 29936 29937exports.MorphSVGPlugin = MorphSVGPlugin; 29938exports.default = MorphSVGPlugin; 29939 29940/***/ }), 29941/* 18 */ 29942/***/ (function(module, exports, __webpack_require__) { 29943 29944"use strict"; 29945 29946 29947if (!Array.prototype.forEach) { 29948 29949 Array.prototype.forEach = function (callback /*, thisArg*/) { 29950 29951 var T, k; 29952 29953 if (this == null) { 29954 throw new TypeError(' this vaut null ou n est pas défini'); 29955 } 29956 29957 // 1. Soit O le résultat de l'appel à ToObject 29958 // auquel on a passé |this| en argument. 29959 var O = Object(this); 29960 29961 // 2. Soit lenValue le résultat de l'appel de la méthode 29962 // interne Get sur O avec l'argument "length". 29963 // 3. Soit len la valeur ToUint32(lenValue). 29964 var len = O.length >>> 0; 29965 29966 // 4. Si IsCallable(callback) est false, on lève une TypeError. 29967 // Voir : http://es5.github.com/#x9.11 29968 if (typeof callback !== "function") { 29969 throw new TypeError(callback + ' n est pas une fonction'); 29970 } 29971 29972 // 5. Si thisArg a été fourni, soit T ce thisArg ; 29973 // sinon soit T égal à undefined. 29974 if (arguments.length > 1) { 29975 T = arguments[1]; 29976 } 29977 29978 // 6. Soit k égal à 0 29979 k = 0; 29980 29981 // 7. On répète tant que k < len 29982 while (k < len) { 29983 29984 var kValue; 29985 29986 // a. Soit Pk égal ToString(k). 29987 // (implicite pour l'opérande gauche de in) 29988 // b. Soit kPresent le résultat de l'appel de la 29989 // méthode interne HasProperty de O avec l'argument Pk. 29990 // Cette étape peut être combinée avec c 29991 // c. Si kPresent vaut true, alors 29992 if (k in O) { 29993 29994 // i. Soit kValue le résultat de l'appel de la 29995 // méthode interne Get de O avec l'argument Pk. 29996 kValue = O[k]; 29997 29998 // ii. On appelle la méthode interne Call de callback 29999 // avec T comme valeur this et la liste des arguments 30000 // qui contient kValue, k, et O. 30001 callback.call(T, kValue, k, O); 30002 } 30003 // d. On augmente k de 1. 30004 k++; 30005 } 30006 // 8. on renvoie undefined 30007 }; 30008} 30009 30010if (!Array.from) { 30011 Array.from = function () { 30012 var toStr = Object.prototype.toString; 30013 var isCallable = function isCallable(fn) { 30014 return typeof fn === 'function' || toStr.call(fn) === '[object Function]'; 30015 }; 30016 var toInteger = function toInteger(value) { 30017 var number = Number(value); 30018 if (isNaN(number)) { 30019 return 0; 30020 } 30021 if (number === 0 || !isFinite(number)) { 30022 return number; 30023 } 30024 return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number)); 30025 }; 30026 var maxSafeInteger = Math.pow(2, 53) - 1; 30027 var toLength = function toLength(value) { 30028 var len = toInteger(value); 30029 return Math.min(Math.max(len, 0), maxSafeInteger); 30030 }; 30031 30032 // La propriété length de la méthode vaut 1. 30033 return function from(arrayLike /*, mapFn, thisArg */) { 30034 // 1. Soit C, la valeur this 30035 var C = this; 30036 30037 // 2. Soit items le ToObject(arrayLike). 30038 var items = Object(arrayLike); 30039 30040 // 3. ReturnIfAbrupt(items). 30041 if (arrayLike == null) { 30042 throw new TypeError("Array.from doit utiliser un objet semblable à un tableau - null ou undefined ne peuvent pas être utilisés"); 30043 } 30044 30045 // 4. Si mapfn est undefined, le mapping sera false. 30046 var mapFn = arguments.length > 1 ? arguments[1] : void undefined; 30047 var T; 30048 if (typeof mapFn !== 'undefined') { 30049 // 5. sinon 30050 // 5. a. si IsCallable(mapfn) est false, on lève une TypeError. 30051 if (!isCallable(mapFn)) { 30052 throw new TypeError('Array.from: lorsqu il est utilisé le deuxième argument doit être une fonction'); 30053 } 30054 30055 // 5. b. si thisArg a été fourni, T sera thisArg ; sinon T sera undefined. 30056 if (arguments.length > 2) { 30057 T = arguments[2]; 30058 } 30059 } 30060 30061 // 10. Soit lenValue pour Get(items, "length"). 30062 // 11. Soit len pour ToLength(lenValue). 30063 var len = toLength(items.length); 30064 30065 // 13. Si IsConstructor(C) vaut true, alors 30066 // 13. a. Soit A le résultat de l'appel à la méthode interne [[Construct]] avec une liste en argument qui contient l'élément len. 30067 // 14. a. Sinon, soit A le résultat de ArrayCreate(len). 30068 var A = isCallable(C) ? Object(new C(len)) : new Array(len); 30069 30070 // 16. Soit k égal à 0. 30071 var k = 0; // 17. On répète tant que k < len⦠30072 var kValue; 30073 while (k < len) { 30074 kValue = items[k]; 30075 if (mapFn) { 30076 A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k); 30077 } else { 30078 A[k] = kValue; 30079 } 30080 k += 1; 30081 } 30082 // 18. Soit putStatus égal à Put(A, "length", len, true). 30083 A.length = len;
30083 // 20. On renvoie A. 30084 return A; 30085 }; 30086 }(); 30087} 30088 30089if (window.NodeList && !NodeList.prototype.forEach) { 30090 NodeList.prototype.forEach = function (callback, thisArg) { 30091 thisArg = thisArg || window; 30092 for (var i = 0; i < this.length; i++) { 30093 callback.call(thisArg, this[i], i, this); 30094 } 30095 }; 30096} 30097 30098/***/ }), 30099/* 19 */ 30100/***/ (function(module, exports, __webpack_require__) { 30101 30102"use strict"; 30103 30104 30105Object.defineProperty(exports, "__esModule", { 30106 value: true 30107}); 30108var TRANSLATIONS = { 30109 30110 turnover: { 30111 fr: 'Chiffre d\'affaires en Mâ¬', 30112 en: 'Turnover in ⬠million', 30113 de: 'Umsatz in Millionen Euro', 30114 es: 'Volumen de negocios en Mâ¬', 30115 cn: 'ä¸ç»©æ°ä»¥äº¿è®¡' 30116 }, 30117 30118 map_anchor: { 30119 fr: 'presence-mondiale', 30120 en: 'global-presence', 30121 de: 'unsere-weltweite-prasenz', 30122 es: 'nuestra-presencia-mundial', 30123 cn: 'æ们çå½é ä¸å¡' 30124 } 30125 30126}; 30127 30128exports.TRANSLATIONS = TRANSLATIONS; 30129 30130/***/ }), 30131/* 20 */ 30132/***/ (function(module, exports, __webpack_require__) { 30133 30134"use strict"; 30135 30136 30137Object.defineProperty(exports, "__esModule", { 30138 value: true 30139}); 30140var COLORS = { 30141 white: '#FFFFFF', 30142 offwhite: '#f8f6f6', 30143 pureblack: '#000000', 30144 bodytext: '#002043', 30145 lightgrey: '#E0E0E0', 30146 grey: '#A1A5A7', 30147 greyblue: '#A6B1BD', 30148 blue: '#002043', 30149 gold: '#C3987A', 30150 30151 rgba: { 30152 blue: 'rgba(0, 32, 67, 0.8)' 30153 } 30154}; 30155 30156exports.COLORS = COLORS; 30157 30158/***/ }), 30159/* 21 */ 30160/***/ (function(module, exports, __webpack_require__) { 30161 30162"use strict"; 30163 30164 30165var helpers = __webpack_require__(1); 30166 30167/** 30168 * Helper function to get relative position for an event 30169 * @param {Event|IEvent} event - The event to get the position for 30170 * @param {Chart} chart - The chart 30171 * @returns {Point} the event position 30172 */ 30173function getRelativePosition(e, chart) { 30174 if (e.native) { 30175 return { 30176 x: e.x, 30177 y: e.y 30178 }; 30179 } 30180 30181 return helpers.getRelativePosition(e, chart); 30182} 30183 30184/** 30185 * Helper function to traverse all of the visible elements in the chart 30186 * @param chart {chart} the chart 30187 * @param handler {Function} the callback to execute for each visible item 30188 */ 30189function parseVisibleItems(chart, handler) { 30190 var datasets = chart.data.datasets; 30191 var meta, i, j, ilen, jlen; 30192 30193 for (i = 0, ilen = datasets.length; i < ilen; ++i) { 30194 if (!chart.isDatasetVisible(i)) { 30195 continue; 30196 } 30197 30198 meta = chart.getDatasetMeta(i); 30199 for (j = 0, jlen = meta.data.length; j < jlen; ++j) { 30200 var element = meta.data[j]; 30201 if (!element._view.skip) { 30202 handler(element); 30203 } 30204 } 30205 } 30206} 30207 30208/** 30209 * Helper function to get the items that intersect the event position 30210 * @param items {ChartElement[]} elements to filter 30211 * @param position {Point} the point to be nearest to 30212 * @return {ChartElement[]} the nearest items 30213 */ 30214function getIntersectItems(chart, position) { 30215 var elements = []; 30216 30217 parseVisibleItems(chart, function(element) { 30218 if (element.inRange(position.x, position.y)) { 30219 elements.push(element); 30220 } 30221 }); 30222 30223 return elements; 30224} 30225 30226/** 30227 * Helper function to get the items nearest to the event position considering all visible items in teh chart 30228 * @param chart {Chart} the chart to look at elements from 30229 * @param position {Point} the point to be nearest to 30230 * @param intersect {Boolean} if true, only consider items that intersect the position 30231 * @param distanceMetric {Function} function to provide the distance between points 30232 * @return {ChartElement[]} the nearest items 30233 */ 30234function getNearestItems(chart, position, intersect, distanceMetric) { 30235 var minDistance = Number.POSITIVE_INFINITY; 30236 var nearestItems = []; 30237 30238 parseVisibleItems(chart, function(element) { 30239 if (intersect && !element.inRange(position.x, position.y)) { 30240 return; 30241 } 30242 30243 var center = element.getCenterPoint(); 30244 var distance = distanceMetric(position, center); 30245 30246 if (distance < minDistance) { 30247 nearestItems = [element]; 30248 minDistance = distance; 30249 } else if (distance === minDistance) { 30250 // Can have multiple items at the same distance in which case we sort by size 30251 nearestItems.push(element); 30252 } 30253 }); 30254 30255 return nearestItems; 30256} 30257 30258/** 30259 * Get a distance metric function for two points based on the 30260 * axis mode setting 30261 * @param {String} axis the axis mode. x|y|xy 30262 */ 30263function getDistanceMetricForAxis(axis) { 30264 var useX = axis.indexOf('x') !== -1; 30265 var useY = axis.indexOf('y') !== -1; 30266 30267 return function(pt1, pt2) { 30268 var deltaX = useX ? Math.abs(pt1.x - pt2.x) : 0; 30269 var deltaY = useY ? Math.abs(pt1.y - pt2.y) : 0; 30270 return Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2)); 30271 }; 30272} 30273 30274function indexMode(chart, e, options) {
vendor: 4,459 bytes, lines 30275-30403
30275 var position = getRelativePosition(e, chart); 30276 // Default axis for index mode is 'x' to match old behaviour 30277 options.axis = options.axis || 'x'; 30278 var distanceMetric = getDistanceMetricForAxis(options.axis); 30279 var items = options.intersect ? getIntersectItems(chart, position) : getNearestItems(chart, position, false, distanceMetric); 30280 var elements = []; 30281 30282 if (!items.length) { 30283 return []; 30284 } 30285 30286 chart.data.datasets.forEach(function(dataset, datasetIndex) { 30287 if (chart.isDatasetVisible(datasetIndex)) { 30288 var meta = chart.getDatasetMeta(datasetIndex); 30289 var element = meta.data[items[0]._index]; 30290 30291 // don't count items that are skipped (null data) 30292 if (element && !element._view.skip) { 30293 elements.push(element); 30294 } 30295 } 30296 }); 30297 30298 return elements; 30299} 30300 30301/** 30302 * @interface IInteractionOptions 30303 */ 30304/** 30305 * If true, only consider items that intersect the point 30306 * @name IInterfaceOptions#boolean 30307 * @type Boolean 30308 */ 30309 30310/** 30311 * Contains interaction related functions 30312 * @namespace Chart.Interaction 30313 */ 30314module.exports = { 30315 // Helper function for different modes 30316 modes: { 30317 single: function(chart, e) { 30318 var position = getRelativePosition(e, chart); 30319 var elements = []; 30320 30321 parseVisibleItems(chart, function(element) { 30322 if (element.inRange(position.x, position.y)) { 30323 elements.push(element); 30324 return elements; 30325 } 30326 }); 30327 30328 return elements.slice(0, 1); 30329 }, 30330 30331 /** 30332 * @function Chart.Interaction.modes.label 30333 * @deprecated since version 2.4.0 30334 * @todo remove at version 3 30335 * @private 30336 */ 30337 label: indexMode, 30338 30339 /** 30340 * Returns items at the same index. If the options.intersect parameter is true, we only return items if we intersect something 30341 * If the options.intersect mode is false, we find the nearest item and return the items at the same index as that item 30342 * @function Chart.Interaction.modes.index 30343 * @since v2.4.0 30344 * @param chart {chart} the chart we are returning items from 30345 * @param e {Event} the event we are find things at 30346 * @param options {IInteractionOptions} options to use during interaction 30347 * @return {Chart.Element[]} Array of elements that are under the point. If none are found, an empty array is returned 30348 */ 30349 index: indexMode, 30350 30351 /** 30352 * Returns items in the same dataset. If the options.intersect parameter is true, we only return items if we intersect something 30353 * If the options.intersect is false, we find the nearest item and return the items in that dataset 30354 * @function Chart.Interaction.modes.dataset 30355 * @param chart {chart} the chart we are returning items from 30356 * @param e {Event} the event we are find things at 30357 * @param options {IInteractionOptions} options to use during interaction 30358 * @return {Chart.Element[]} Array of elements that are under the point. If none are found, an empty array is returned 30359 */ 30360 dataset: function(chart, e, options) { 30361 var position = getRelativePosition(e, chart); 30362 options.axis = options.axis || 'xy'; 30363 var distanceMetric = getDistanceMetricForAxis(options.axis); 30364 var items = options.intersect ? getIntersectItems(chart, position) : getNearestItems(chart, position, false, distanceMetric); 30365 30366 if (items.length > 0) { 30367 items = chart.getDatasetMeta(items[0]._datasetIndex).data; 30368 } 30369 30370 return items; 30371 }, 30372 30373 /** 30374 * @function Chart.Interaction.modes.x-axis 30375 * @deprecated since version 2.4.0. Use index mode and intersect == true 30376 * @todo remove at version 3 30377 * @private 30378 */ 30379 'x-axis': function(chart, e) { 30380 return indexMode(chart, e, {intersect: false}); 30381 }, 30382 30383 /** 30384 * Point mode returns all elements that hit test based on the event position 30385 * of the event 30386 * @function Chart.Interaction.modes.intersect 30387 * @param chart {chart} the chart we are returning items from 30388 * @param e {Event} the event we are find things at 30389 * @return {Chart.Element[]} Array of elements that are under the point. If none are found, an empty array is returned 30390 */ 30391 point: function(chart, e) { 30392 var position = getRelativePosition(e, chart); 30393 return getIntersectItems(chart, position); 30394 }, 30395 30396 /** 30397 * nearest mode returns the element closest to the point 30398 * @function Chart.Interaction.modes.intersect 30399 * @param chart {chart} the chart we are returning items from 30400 * @param e {Event} the event we are find things at 30401 * @param options {IInteractionOptions} options to use 30402 * @return {Chart.Element[]} Array of elements that are under the point. If none are found, an empty array is returned 30403 */
30404 nearest: function(chart, e, options) { 30405 var position = getRelativePosition(e, chart); 30406 options.axis = options.axis || 'xy'; 30407 var distanceMetric = getDistanceMetricForAxis(options.axis); 30408 var nearestItems = getNearestItems(chart, position, options.intersect, distanceMetric); 30409 30410 // We have multiple items at the same distance from the event. Now sort by smallest 30411 if (nearestItems.length > 1) { 30412 nearestItems.sort(function(a, b) { 30413 var sizeA = a.getArea(); 30414 var sizeB = b.getArea(); 30415 var ret = sizeA - sizeB; 30416 30417 if (ret === 0) { 30418 // if equal sort by dataset index 30419 ret = a._datasetIndex - b._datasetIndex; 30420 } 30421 30422 return ret; 30423 }); 30424 } 30425 30426 // Return only 1 item 30427 return nearestItems.slice(0, 1); 30428 }, 30429 30430 /** 30431 * x mode returns the elements that hit-test at the current x coordinate 30432 * @function Chart.Interaction.modes.x 30433 * @param chart {chart} the chart we are returning items from 30434 * @param e {Event} the event we are find things at 30435 * @param options {IInteractionOptions} options to use 30436 * @return {Chart.Element[]} Array of elements that are under the point. If none are found, an empty array is returned 30437 */ 30438 x: function(chart, e, options) { 30439 var position = getRelativePosition(e, chart); 30440 var items = []; 30441 var intersectsItem = false; 30442 30443 parseVisibleItems(chart, function(element) { 30444 if (element.inXRange(position.x)) { 30445 items.push(element); 30446 } 30447 30448 if (element.inRange(position.x, position.y)) { 30449 intersectsItem = true; 30450 } 30451 }); 30452 30453 // If we want to trigger on an intersect and we don't have any items 30454 // that intersect the position, return nothing 30455 if (options.intersect && !intersectsItem) { 30456 items = []; 30457 } 30458 return items; 30459 }, 30460 30461 /** 30462 * y mode returns the elements that hit-test at the current y coordinate 30463 * @function Chart.Interaction.modes.y 30464 * @param chart {chart} the chart we are returning items from 30465 * @param e {Event} the event we are find things at 30466 * @param options {IInteractionOptions} options to use 30467 * @return {Chart.Element[]} Array of elements that are under the point. If none are found, an empty array is returned 30468 */ 30469 y: function(chart, e, options) { 30470 var position = getRelativePosition(e, chart); 30471 var items = []; 30472 var intersectsItem = false; 30473 30474 parseVisibleItems(chart, function(element) { 30475 if (element.inYRange(position.y)) { 30476 items.push(element); 30477 } 30478 30479 if (element.inRange(position.x, position.y)) { 30480 intersectsItem = true; 30481 } 30482 }); 30483 30484 // If we want to trigger on an intersect and we don't have any items 30485 // that intersect the position, return nothing 30486 if (options.intersect && !intersectsItem) { 30487 items = []; 30488 } 30489 return items; 30490 } 30491 } 30492}; 30493 30494 30495/***/ }), 30496/* 22 */ 30497/***/ (function(module, exports, __webpack_require__) { 30498 30499"use strict"; 30500 30501 30502var defaults = __webpack_require__(2); 30503var helpers = __webpack_require__(1); 30504 30505defaults._set('global', { 30506 plugins: {} 30507}); 30508 30509/** 30510 * The plugin service singleton 30511 * @namespace Chart.plugins 30512 * @since 2.1.0 30513 */ 30514module.exports = { 30515 /** 30516 * Globally registered plugins. 30517 * @private 30518 */ 30519 _plugins: [], 30520 30521 /** 30522 * This identifier is used to invalidate the descriptors cache attached to each chart 30523 * when a global plugin is registered or unregistered. In this case, the cache ID is 30524 * incremented and descriptors are regenerated during following API calls. 30525 * @private 30526 */ 30527 _cacheId: 0, 30528 30529 /** 30530 * Registers the given plugin(s) if not already registered. 30531 * @param {Array|Object} plugins plugin instance(s). 30532 */ 30533 register: function(plugins) { 30534 var p = this._plugins; 30535 ([]).concat(plugins).forEach(function(plugin) { 30536 if (p.indexOf(plugin) === -1) { 30537 p.push(plugin); 30538 } 30539 }); 30540 30541 this._cacheId++; 30542 }, 30543 30544 /** 30545 * Unregisters the given plugin(s) only if registered. 30546 * @param {Array|Object} plugins plugin instance(s). 30547 */ 30548 unregister: function(plugins) { 30549 var p = this._plugins; 30550 ([]).concat(plugins).forEach(function(plugin) { 30551 var idx = p.indexOf(plugin); 30552 if (idx !== -1) { 30553 p.splice(idx, 1); 30554 } 30555 }); 30556 30557 this._cacheId++; 30558 }, 30559 30560 /** 30561 * Remove all registered plugins. 30562 * @since 2.1.5 30563 */ 30564 clear: function() { 30565 this._plugins = []; 30566 this._cacheId++; 30567 }, 30568 30569 /** 30570 * Returns the number of registered plugins? 30571 * @returns {Number} 30572 * @since 2.1.5 30573 */ 30574 count: function() { 30575 return this._plugins.length; 30576 }, 30577 30578 /** 30579 * Returns all registered plugin instances. 30580 * @returns {Array} array of plugin objects. 30581 * @since 2.1.5 30582 */ 30583 getAll: function() { 30584 return this._plugins; 30585 }, 30586 30587 /** 30588 * Calls enabled plugins for `chart` on the specified hook and with the given args. 30589 * This method immediately returns as soon as a plugin explicitly returns false. The 30590 * returned value can be used, for instance, to interrupt the current action. 30591 * @param {Object} chart - The chart instance for which plugins should be called. 30592 * @param {String} hook - The name of the plugin method to call (e.g. 'beforeUpdate'). 30593 * @param {Array} [args] - Extra arguments to apply to the hook call. 30594 * @returns {Boolean} false if any of the plugins return false, else returns true. 30595 */
vendor: 10,360 bytes, lines 30596-30861
30596 notify: function(chart, hook, args) { 30597 var descriptors = this.descriptors(chart); 30598 var ilen = descriptors.length; 30599 var i, descriptor, plugin, params, method; 30600 30601 for (i = 0; i < ilen; ++i) { 30602 descriptor = descriptors[i]; 30603 plugin = descriptor.plugin; 30604 method = plugin[hook]; 30605 if (typeof method === 'function') { 30606 params = [chart].concat(args || []); 30607 params.push(descriptor.options); 30608 if (method.apply(plugin, params) === false) { 30609 return false; 30610 } 30611 } 30612 } 30613 30614 return true; 30615 }, 30616 30617 /** 30618 * Returns descriptors of enabled plugins for the given chart. 30619 * @returns {Array} [{ plugin, options }] 30620 * @private 30621 */ 30622 descriptors: function(chart) { 30623 var cache = chart.$plugins || (chart.$plugins = {}); 30624 if (cache.id === this._cacheId) { 30625 return cache.descriptors; 30626 } 30627 30628 var plugins = []; 30629 var descriptors = []; 30630 var config = (chart && chart.config) || {}; 30631 var options = (config.options && config.options.plugins) || {}; 30632 30633 this._plugins.concat(config.plugins || []).forEach(function(plugin) { 30634 var idx = plugins.indexOf(plugin); 30635 if (idx !== -1) { 30636 return; 30637 } 30638 30639 var id = plugin.id; 30640 var opts = options[id]; 30641 if (opts === false) { 30642 return; 30643 } 30644 30645 if (opts === true) { 30646 opts = helpers.clone(defaults.global.plugins[id]); 30647 } 30648 30649 plugins.push(plugin); 30650 descriptors.push({ 30651 plugin: plugin, 30652 options: opts || {} 30653 }); 30654 }); 30655 30656 cache.descriptors = descriptors; 30657 cache.id = this._cacheId; 30658 return descriptors; 30659 }, 30660 30661 /** 30662 * Invalidates cache for the given chart: descriptors hold a reference on plugin option, 30663 * but in some cases, this reference can be changed by the user when updating options. 30664 * https://github.com/chartjs/Chart.js/issues/5111#issuecomment-355934167 30665 * @private 30666 */ 30667 _invalidate: function(chart) { 30668 delete chart.$plugins; 30669 } 30670}; 30671 30672/** 30673 * Plugin extension hooks. 30674 * @interface IPlugin 30675 * @since 2.1.0 30676 */ 30677/** 30678 * @method IPlugin#beforeInit 30679 * @desc Called before initializing `chart`. 30680 * @param {Chart.Controller} chart - The chart instance. 30681 * @param {Object} options - The plugin options. 30682 */ 30683/** 30684 * @method IPlugin#afterInit 30685 * @desc Called after `chart` has been initialized and before the first update. 30686 * @param {Chart.Controller} chart - The chart instance. 30687 * @param {Object} options - The plugin options. 30688 */ 30689/** 30690 * @method IPlugin#beforeUpdate 30691 * @desc Called before updating `chart`. If any plugin returns `false`, the update 30692 * is cancelled (and thus subsequent render(s)) until another `update` is triggered. 30693 * @param {Chart.Controller} chart - The chart instance. 30694 * @param {Object} options - The plugin options. 30695 * @returns {Boolean} `false` to cancel the chart update. 30696 */ 30697/** 30698 * @method IPlugin#afterUpdate 30699 * @desc Called after `chart` has been updated and before rendering. Note that this 30700 * hook will not be called if the chart update has been previously cancelled. 30701 * @param {Chart.Controller} chart - The chart instance. 30702 * @param {Object} options - The plugin options. 30703 */ 30704/** 30705 * @method IPlugin#beforeDatasetsUpdate 30706 * @desc Called before updating the `chart` datasets. If any plugin returns `false`, 30707 * the datasets update is cancelled until another `update` is triggered. 30708 * @param {Chart.Controller} chart - The chart instance. 30709 * @param {Object} options - The plugin options. 30710 * @returns {Boolean} false to cancel the datasets update. 30711 * @since version 2.1.5 30712*/ 30713/** 30714 * @method IPlugin#afterDatasetsUpdate 30715 * @desc Called after the `chart` datasets have been updated. Note that this hook 30716 * will not be called if the datasets update has been previously cancelled. 30717 * @param {Chart.Controller} chart - The chart instance. 30718 * @param {Object} options - The plugin options. 30719 * @since version 2.1.5 30720 */ 30721/** 30722 * @method IPlugin#beforeDatasetUpdate 30723 * @desc Called before updating the `chart` dataset at the given `args.index`. If any plugin 30724 * returns `false`, the datasets update is cancelled until another `update` is triggered. 30725 * @param {Chart} chart - The chart instance. 30726 * @param {Object} args - The call arguments. 30727 * @param {Number} args.index - The dataset index. 30728 * @param {Object} args.meta - The dataset metadata. 30729 * @param {Object} options - The plugin options. 30730 * @returns {Boolean} `false` to cancel the chart datasets drawing. 30731 */ 30732/** 30733 * @method IPlugin#afterDatasetUpdate 30734 * @desc Called after the `chart` datasets at the given `args.index` has been updated. Note 30735 * that this hook will not be called if the datasets update has been previously cancelled. 30736 * @param {Chart} chart - The chart instance. 30737 * @param {Object} args - The call arguments. 30738 * @param {Number} args.index - The dataset index. 30739 * @param {Object} args.meta - The dataset metadata. 30740 * @param {Object} options - The plugin options. 30741 */ 30742/** 30743 * @method IPlugin#beforeLayout 30744 * @desc Called before laying out `chart`. If any plugin returns `false`, 30745 * the layout update is cancelled until another `update` is triggered. 30746 * @param {Chart.Controller} chart - The chart instance. 30747 * @param {Object} options - The plugin options. 30748 * @returns {Boolean} `false` to cancel the chart layout. 30749 */ 30750/** 30751 * @method IPlugin#afterLayout 30752 * @desc Called after the `chart` has been layed out. Note that this hook will not 30753 * be called if the layout update has been previously cancelled. 30754 * @param {Chart.Controller} chart - The chart instance. 30755 * @param {Object} options - The plugin options. 30756 */ 30757/** 30758 * @method IPlugin#beforeRender 30759 * @desc Called before rendering `chart`. If any plugin returns `false`, 30760 * the rendering is cancelled until another `render` is triggered. 30761 * @param {Chart.Controller} chart - The chart instance. 30762 * @param {Object} options - The plugin options. 30763 * @returns {Boolean} `false` to cancel the chart rendering. 30764 */ 30765/** 30766 * @method IPlugin#afterRender 30767 * @desc Called after the `chart` has been fully rendered (and animation completed). Note 30768 * that this hook will not be called if the rendering has been previously cancelled. 30769 * @param {Chart.Controller} chart - The chart instance. 30770 * @param {Object} options - The plugin options. 30771 */ 30772/** 30773 * @method IPlugin#beforeDraw 30774 * @desc Called before drawing `chart` at every animation frame specified by the given 30775 * easing value. If any plugin returns `false`, the frame drawing is cancelled until 30776 * another `render` is triggered. 30777 * @param {Chart.Controller} chart - The chart instance. 30778 * @param {Number} easingValue - The current animation value, between 0.0 and 1.0. 30779 * @param {Object} options - The plugin options. 30780 * @returns {Boolean} `false` to cancel the chart drawing. 30781 */ 30782/** 30783 * @method IPlugin#afterDraw 30784 * @desc Called after the `chart` has been drawn for the specific easing value. Note 30785 * that this hook will not be called if the drawing has been previously cancelled. 30786 * @param {Chart.Controller} chart - The chart instance. 30787 * @param {Number} easingValue - The current animation value, between 0.0 and 1.0. 30788 * @param {Object} options - The plugin options. 30789 */ 30790/** 30791 * @method IPlugin#beforeDatasetsDraw 30792 * @desc Called before drawing the `chart` datasets. If any plugin returns `false`, 30793 * the datasets drawing is cancelled until another `render` is triggered. 30794 * @param {Chart.Controller} chart - The chart instance. 30795 * @param {Number} easingValue - The current animation value, between 0.0 and 1.0. 30796 * @param {Object} options - The plugin options. 30797 * @returns {Boolean} `false` to cancel the chart datasets drawing. 30798 */ 30799/** 30800 * @method IPlugin#afterDatasetsDraw 30801 * @desc Called after the `chart` datasets have been drawn. Note that this hook 30802 * will not be called if the datasets drawing has been previously cancelled. 30803 * @param {Chart.Controller} chart - The chart instance. 30804 * @param {Number} easingValue - The current animation value, between 0.0 and 1.0. 30805 * @param {Object} options - The plugin options. 30806 */ 30807/** 30808 * @method IPlugin#beforeDatasetDraw 30809 * @desc Called before drawing the `chart` dataset at the given `args.index` (datasets 30810 * are drawn in the reverse order). If any plugin returns `false`, the datasets drawing 30811 * is cancelled until another `render` is triggered. 30812 * @param {Chart} chart - The chart instance. 30813 * @param {Object} args - The call arguments. 30814 * @param {Number} args.index - The dataset index. 30815 * @param {Object} args.meta - The dataset metadata. 30816 * @param {Number} args.easingValue - The current animation value, between 0.0 and 1.0. 30817 * @param {Object} options - The plugin options. 30818 * @returns {Boolean} `false` to cancel the chart datasets drawing. 30819 */ 30820/** 30821 * @method IPlugin#afterDatasetDraw 30822 * @desc Called after the `chart` datasets at the given `args.index` have been drawn 30823 * (datasets are drawn in the reverse order). Note that this hook will not be called 30824 * if the datasets drawing has been previously cancelled. 30825 * @param {Chart} chart - The chart instance. 30826 * @param {Object} args - The call arguments. 30827 * @param {Number} args.index - The dataset index. 30828 * @param {Object} args.meta - The dataset metadata. 30829 * @param {Number} args.easingValue - The current animation value, between 0.0 and 1.0. 30830 * @param {Object} options - The plugin options. 30831 */ 30832/** 30833 * @method IPlugin#beforeTooltipDraw 30834 * @desc Called before drawing the `tooltip`. If any plugin returns `false`, 30835 * the tooltip drawing is cancelled until another `render` is triggered. 30836 * @param {Chart} chart - The chart instance. 30837 * @param {Object} args - The call arguments. 30838 * @param {Object} args.tooltip - The tooltip. 30839 * @param {Number} args.easingValue - The current animation value, between 0.0 and 1.0. 30840 * @param {Object} options - The plugin options. 30841 * @returns {Boolean} `false` to cancel the chart tooltip drawing. 30842 */ 30843/** 30844 * @method IPlugin#afterTooltipDraw 30845 * @desc Called after drawing the `tooltip`. Note that this hook will not 30846 * be called if the tooltip drawing has been previously cancelled. 30847 * @param {Chart} chart - The chart instance. 30848 * @param {Object} args - The call arguments. 30849 * @param {Object} args.tooltip - The tooltip. 30850 * @param {Number} args.easingValue - The current animation value, between 0.0 and 1.0. 30851 * @param {Object} options - The plugin options. 30852 */ 30853/** 30854 * @method IPlugin#beforeEvent 30855 * @desc Called before processing the specified `event`. If any plugin returns `false`, 30856 * the event will be discarded. 30857 * @param {Chart.Controller} chart - The chart instance. 30858 * @param {IEvent} event - The event object. 30859 * @param {Object} options - The plugin options. 30860 */ 30861/**
30862 * @method IPlugin#afterEvent 30863 * @desc Called after the `event` has been consumed. Note that this hook 30864 * will not be called if the `event` has been previously discarded. 30865 * @param {Chart.Controller} chart - The chart instance. 30866 * @param {IEvent} event - The event object. 30867 * @param {Object} options - The plugin options. 30868 */ 30869/** 30870 * @method IPlugin#resize 30871 * @desc Called after the chart as been resized. 30872 * @param {Chart.Controller} chart - The chart instance. 30873 * @param {Number} size - The new canvas display size (eq. canvas.style width & height). 30874 * @param {Object} options - The plugin options. 30875 */ 30876/** 30877 * @method IPlugin#destroy 30878 * @desc Called after the chart as been destroyed. 30879 * @param {Chart.Controller} chart - The chart instance. 30880 * @param {Object} options - The plugin options. 30881 */ 30882 30883 30884/***/ }), 30885/* 23 */ 30886/***/ (function(module, exports, __webpack_require__) { 30887 30888"use strict"; 30889 30890 30891var helpers = __webpack_require__(1); 30892var basic = __webpack_require__(215); 30893var dom = __webpack_require__(216); 30894 30895// @TODO Make possible to select another platform at build time. 30896var implementation = dom._enabled ? dom : basic; 30897 30898/** 30899 * @namespace Chart.platform 30900 * @see https://chartjs.gitbooks.io/proposals/content/Platform.html 30901 * @since 2.4.0 30902 */ 30903module.exports = helpers.extend({ 30904 /** 30905 * @since 2.7.0 30906 */ 30907 initialize: function() {}, 30908 30909 /** 30910 * Called at chart construction time, returns a context2d instance implementing 30911 * the [W3C Canvas 2D Context API standard]{@link https://www.w3.org/TR/2dcontext/}. 30912 * @param {*} item - The native item from which to acquire context (platform specific) 30913 * @param {Object} options - The chart options 30914 * @returns {CanvasRenderingContext2D} context2d instance 30915 */ 30916 acquireContext: function() {}, 30917 30918 /** 30919 * Called at chart destruction time, releases any resources associated to the context 30920 * previously returned by the acquireContext() method. 30921 * @param {CanvasRenderingContext2D} context - The context2d instance 30922 * @returns {Boolean} true if the method succeeded, else false 30923 */ 30924 releaseContext: function() {}, 30925 30926 /** 30927 * Registers the specified listener on the given chart. 30928 * @param {Chart} chart - Chart from which to listen for event 30929 * @param {String} type - The ({@link IEvent}) type to listen for 30930 * @param {Function} listener - Receives a notification (an object that implements 30931 * the {@link IEvent} interface) when an event of the specified type occurs. 30932 */ 30933 addEventListener: function() {}, 30934 30935 /** 30936 * Removes the specified listener previously registered with addEventListener. 30937 * @param {Chart} chart -Chart from which to remove the listener 30938 * @param {String} type - The ({@link IEvent}) type to remove 30939 * @param {Function} listener - The listener function to remove from the event target. 30940 */ 30941 removeEventListener: function() {} 30942 30943}, implementation); 30944 30945/** 30946 * @interface IPlatform 30947 * Allows abstracting platform dependencies away from the chart 30948 * @borrows Chart.platform.acquireContext as acquireContext 30949 * @borrows Chart.platform.releaseContext as releaseContext 30950 * @borrows Chart.platform.addEventListener as addEventListener 30951 * @borrows Chart.platform.removeEventListener as removeEventListener 30952 */ 30953 30954/** 30955 * @interface IEvent 30956 * @prop {String} type - The event type name, possible values are: 30957 * 'contextmenu', 'mouseenter', 'mousedown', 'mousemove', 'mouseup', 'mouseout', 30958 * 'click', 'dblclick', 'keydown', 'keypress', 'keyup' and 'resize' 30959 * @prop {*} native - The original native event (null for emulated events, e.g. 'resize') 30960 * @prop {Number} x - The mouse x position, relative to the canvas (null for incompatible events) 30961 * @prop {Number} y - The mouse y position, relative to the canvas (null for incompatible events) 30962 */ 30963 30964 30965/***/ }), 30966/* 24 */ 30967/***/ (function(module, exports, __webpack_require__) { 30968 30969/* MIT license */ 30970var convert = __webpack_require__(229); 30971var string = __webpack_require__(227); 30972 30973var Color = function (obj) { 30974 if (obj instanceof Color) { 30975 return obj; 30976 } 30977 if (!(this instanceof Color)) { 30978 return new Color(obj); 30979 } 30980 30981 this.valid = false; 30982 this.values = { 30983 rgb: [0, 0, 0], 30984 hsl: [0, 0, 0], 30985 hsv: [0, 0, 0], 30986 hwb: [0, 0, 0], 30987 cmyk: [0, 0, 0, 0], 30988 alpha: 1 30989 }; 30990 30991 // parse Color() argument 30992 var vals; 30993 if (typeof obj === 'string') { 30994 vals = string.getRgba(obj); 30995 if (vals) { 30996 this.setValues('rgb', vals); 30997 } else if (vals = string.getHsla(obj)) { 30998 this.setValues('hsl', vals); 30999 } else if (vals = string.getHwb(obj)) { 31000 this.setValues('hwb', vals); 31001 } 31002 } else if (typeof obj === 'object') { 31003 vals = obj; 31004 if (vals.r !== undefined || vals.red !== undefined) { 31005 this.setValues('rgb', vals); 31006 } else if (vals.l !== undefined || vals.lightness !== undefined) { 31007 this.setValues('hsl', vals); 31008 } else if (vals.v !== undefined || vals.value !== undefined) { 31009 this.setValues('hsv', vals); 31010 } else if (vals.w !== undefined || vals.whiteness !== undefined) { 31011 this.setValues('hwb', vals); 31012 } else if (vals.c !== undefined || vals.cyan !== undefined) { 31013 this.setValues('cmyk', vals); 31014 } 31015 } 31016}; 31017 31018Color.prototype = { 31019 isValid: function () { 31020 return this.valid; 31021 }, 31022 rgb: function () { 31023 return this.setSpace('rgb', arguments); 31024 }, 31025 hsl: function () { 31026 return this.setSpace('hsl', arguments); 31027 }, 31028 hsv: function () { 31029 return this.setSpace('hsv', arguments); 31030 }, 31031 hwb: function () { 31032 return this.setSpace('hwb', arguments); 31033 }, 31034 cmyk: function () {
vendor: 10,194 bytes, lines 31035-31469
31035 return this.setSpace('cmyk', arguments); 31036 }, 31037 31038 rgbArray: function () { 31039 return this.values.rgb; 31040 }, 31041 hslArray: function () { 31042 return this.values.hsl; 31043 }, 31044 hsvArray: function () { 31045 return this.values.hsv; 31046 }, 31047 hwbArray: function () { 31048 var values = this.values; 31049 if (values.alpha !== 1) { 31050 return values.hwb.concat([values.alpha]); 31051 } 31052 return values.hwb; 31053 }, 31054 cmykArray: function () { 31055 return this.values.cmyk; 31056 }, 31057 rgbaArray: function () { 31058 var values = this.values; 31059 return values.rgb.concat([values.alpha]); 31060 }, 31061 hslaArray: function () { 31062 var values = this.values; 31063 return values.hsl.concat([values.alpha]); 31064 }, 31065 alpha: function (val) { 31066 if (val === undefined) { 31067 return this.values.alpha; 31068 } 31069 this.setValues('alpha', val); 31070 return this; 31071 }, 31072 31073 red: function (val) { 31074 return this.setChannel('rgb', 0, val); 31075 }, 31076 green: function (val) { 31077 return this.setChannel('rgb', 1, val); 31078 }, 31079 blue: function (val) { 31080 return this.setChannel('rgb', 2, val); 31081 }, 31082 hue: function (val) { 31083 if (val) { 31084 val %= 360; 31085 val = val < 0 ? 360 + val : val; 31086 } 31087 return this.setChannel('hsl', 0, val); 31088 }, 31089 saturation: function (val) { 31090 return this.setChannel('hsl', 1, val); 31091 }, 31092 lightness: function (val) { 31093 return this.setChannel('hsl', 2, val); 31094 }, 31095 saturationv: function (val) { 31096 return this.setChannel('hsv', 1, val); 31097 }, 31098 whiteness: function (val) { 31099 return this.setChannel('hwb', 1, val); 31100 }, 31101 blackness: function (val) { 31102 return this.setChannel('hwb', 2, val); 31103 }, 31104 value: function (val) { 31105 return this.setChannel('hsv', 2, val); 31106 }, 31107 cyan: function (val) { 31108 return this.setChannel('cmyk', 0, val); 31109 }, 31110 magenta: function (val) { 31111 return this.setChannel('cmyk', 1, val); 31112 }, 31113 yellow: function (val) { 31114 return this.setChannel('cmyk', 2, val); 31115 }, 31116 black: function (val) { 31117 return this.setChannel('cmyk', 3, val); 31118 }, 31119 31120 hexString: function () { 31121 return string.hexString(this.values.rgb); 31122 }, 31123 rgbString: function () { 31124 return string.rgbString(this.values.rgb, this.values.alpha); 31125 }, 31126 rgbaString: function () { 31127 return string.rgbaString(this.values.rgb, this.values.alpha); 31128 }, 31129 percentString: function () { 31130 return string.percentString(this.values.rgb, this.values.alpha); 31131 }, 31132 hslString: function () { 31133 return string.hslString(this.values.hsl, this.values.alpha); 31134 }, 31135 hslaString: function () { 31136 return string.hslaString(this.values.hsl, this.values.alpha); 31137 }, 31138 hwbString: function () { 31139 return string.hwbString(this.values.hwb, this.values.alpha); 31140 }, 31141 keyword: function () { 31142 return string.keyword(this.values.rgb, this.values.alpha); 31143 }, 31144 31145 rgbNumber: function () { 31146 var rgb = this.values.rgb; 31147 return (rgb[0] << 16) | (rgb[1] << 8) | rgb[2]; 31148 }, 31149 31150 luminosity: function () { 31151 // http://www.w3.org/TR/WCAG20/#relativeluminancedef 31152 var rgb = this.values.rgb; 31153 var lum = []; 31154 for (var i = 0; i < rgb.length; i++) { 31155 var chan = rgb[i] / 255; 31156 lum[i] = (chan <= 0.03928) ? chan / 12.92 : Math.pow(((chan + 0.055) / 1.055), 2.4); 31157 } 31158 return 0.2126 * lum[0] + 0.7152 * lum[1] + 0.0722 * lum[2]; 31159 }, 31160 31161 contrast: function (color2) { 31162 // http://www.w3.org/TR/WCAG20/#contrast-ratiodef 31163 var lum1 = this.luminosity(); 31164 var lum2 = color2.luminosity(); 31165 if (lum1 > lum2) { 31166 return (lum1 + 0.05) / (lum2 + 0.05); 31167 } 31168 return (lum2 + 0.05) / (lum1 + 0.05); 31169 }, 31170 31171 level: function (color2) { 31172 var contrastRatio = this.contrast(color2); 31173 if (contrastRatio >= 7.1) { 31174 return 'AAA'; 31175 } 31176 31177 return (contrastRatio >= 4.5) ? 'AA' : ''; 31178 }, 31179 31180 dark: function () { 31181 // YIQ equation from http://24ways.org/2010/calculating-color-contrast 31182 var rgb = this.values.rgb; 31183 var yiq = (rgb[0] * 299 + rgb[1] * 587 + rgb[2] * 114) / 1000; 31184 return yiq < 128; 31185 }, 31186 31187 light: function () { 31188 return !this.dark(); 31189 }, 31190 31191 negate: function () { 31192 var rgb = []; 31193 for (var i = 0; i < 3; i++) { 31194 rgb[i] = 255 - this.values.rgb[i]; 31195 } 31196 this.setValues('rgb', rgb); 31197 return this; 31198 }, 31199 31200 lighten: function (ratio) { 31201 var hsl = this.values.hsl; 31202 hsl[2] += hsl[2] * ratio; 31203 this.setValues('hsl', hsl); 31204 return this; 31205 }, 31206 31207 darken: function (ratio) { 31208 var hsl = this.values.hsl; 31209 hsl[2] -= hsl[2] * ratio; 31210 this.setValues('hsl', hsl); 31211 return this; 31212 }, 31213 31214 saturate: function (ratio) { 31215 var hsl = this.values.hsl; 31216 hsl[1] += hsl[1] * ratio; 31217 this.setValues('hsl', hsl); 31218 return this; 31219 }, 31220 31221 desaturate: function (ratio) { 31222 var hsl = this.values.hsl; 31223 hsl[1] -= hsl[1] * ratio; 31224 this.setValues('hsl', hsl); 31225 return this; 31226 }, 31227 31228 whiten: function (ratio) { 31229 var hwb = this.values.hwb; 31230 hwb[1] += hwb[1] * ratio; 31231 this.setValues('hwb', hwb); 31232 return this; 31233 }, 31234 31235 blacken: function (ratio) { 31236 var hwb = this.values.hwb; 31237 hwb[2] += hwb[2] * ratio; 31238 this.setValues('hwb', hwb); 31239 return this; 31240 }, 31241 31242 greyscale: function () { 31243 var rgb = this.values.rgb; 31244 // http://en.wikipedia.org/wiki/Grayscale#Converting_color_to_grayscale 31245 var val = rgb[0] * 0.3 + rgb[1] * 0.59 + rgb[2] * 0.11; 31246 this.setValues('rgb', [val, val, val]); 31247 return this; 31248 }, 31249 31250 clearer: function (ratio) { 31251 var alpha = this.values.alpha; 31252 this.setValues('alpha', alpha - (alpha * ratio)); 31253 return this; 31254 }, 31255 31256 opaquer: function (ratio) { 31257 var alpha = this.values.alpha; 31258 this.setValues('alpha', alpha + (alpha * ratio)); 31259 return this; 31260 }, 31261 31262 rotate: function (degrees) { 31263 var hsl = this.values.hsl; 31264 var hue = (hsl[0] + degrees) % 360; 31265 hsl[0] = hue < 0 ? 360 + hue : hue; 31266 this.setValues('hsl', hsl); 31267 return this; 31268 }, 31269 31270 /** 31271 * Ported from sass implementation in C 31272 * https://github.com/sass/libsass/blob/0e6b4a2850092356aa3ece07c6b249f0221caced/functions.cpp#L209 31273 */ 31274 mix: function (mixinColor, weight) { 31275 var color1 = this; 31276 var color2 = mixinColor; 31277 var p = weight === undefined ? 0.5 : weight; 31278 31279 var w = 2 * p - 1; 31280 var a = color1.alpha() - color2.alpha(); 31281 31282 var w1 = (((w * a === -1) ? w : (w + a) / (1 + w * a)) + 1) / 2.0; 31283 var w2 = 1 - w1; 31284 31285 return this 31286 .rgb( 31287 w1 * color1.red() + w2 * color2.red(), 31288 w1 * color1.green() + w2 * color2.green(), 31289 w1 * color1.blue() + w2 * color2.blue() 31290 ) 31291 .alpha(color1.alpha() * p + color2.alpha() * (1 - p)); 31292 }, 31293 31294 toJSON: function () { 31295 return this.rgb(); 31296 }, 31297 31298 clone: function () { 31299 // NOTE(SB): using node-clone creates a dependency to Buffer when using browserify, 31300 // making the final build way to big to embed in Chart.js. So let's do it manually, 31301 // assuming that values to clone are 1 dimension arrays containing only numbers, 31302 // except 'alpha' which is a number. 31303 var result = new Color(); 31304 var source = this.values; 31305 var target = result.values; 31306 var value, type; 31307 31308 for (var prop in source) { 31309 if (source.hasOwnProperty(prop)) { 31310 value = source[prop]; 31311 type = ({}).toString.call(value); 31312 if (type === '[object Array]') { 31313 target[prop] = value.slice(0); 31314 } else if (type === '[object Number]') { 31315 target[prop] = value; 31316 } else { 31317 console.error('unexpected color value:', value); 31318 } 31319 } 31320 } 31321 31322 return result; 31323 } 31324}; 31325 31326Color.prototype.spaces = { 31327 rgb: ['red', 'green', 'blue'], 31328 hsl: ['hue', 'saturation', 'lightness'], 31329 hsv: ['hue', 'saturation', 'value'], 31330 hwb: ['hue', 'whiteness', 'blackness'], 31331 cmyk: ['cyan', 'magenta', 'yellow', 'black'] 31332}; 31333 31334Color.prototype.maxes = { 31335 rgb: [255, 255, 255], 31336 hsl: [360, 100, 100], 31337 hsv: [360, 100, 100], 31338 hwb: [360, 100, 100], 31339 cmyk: [100, 100, 100, 100] 31340}; 31341 31342Color.prototype.getValues = function (space) { 31343 var values = this.values; 31344 var vals = {}; 31345 31346 for (var i = 0; i < space.length; i++) { 31347 vals[space.charAt(i)] = values[space][i]; 31348 } 31349 31350 if (values.alpha !== 1) { 31351 vals.a = values.alpha; 31352 } 31353 31354 // {r: 255, g: 255, b: 255, a: 0.4} 31355 return vals; 31356}; 31357 31358Color.prototype.setValues = function (space, vals) { 31359 var values = this.values; 31360 var spaces = this.spaces; 31361 var maxes = this.maxes; 31362 var alpha = 1; 31363 var i; 31364 31365 this.valid = true; 31366 31367 if (space === 'alpha') { 31368 alpha = vals; 31369 } else if (vals.length) { 31370 // [10, 10, 10] 31371 values[space] = vals.slice(0, space.length); 31372 alpha = vals[space.length]; 31373 } else if (vals[space.charAt(0)] !== undefined) { 31374 // {r: 10, g: 10, b: 10} 31375 for (i = 0; i < space.length; i++) { 31376 values[space][i] = vals[space.charAt(i)]; 31377 } 31378 31379 alpha = vals.a; 31380 } else if (vals[spaces[space][0]] !== undefined) { 31381 // {red: 10, green: 10, blue: 10} 31382 var chans = spaces[space]; 31383 31384 for (i = 0; i < space.length; i++) { 31385 values[space][i] = vals[chans[i]]; 31386 } 31387 31388 alpha = vals.alpha; 31389 } 31390 31391 values.alpha = Math.max(0, Math.min(1, (alpha === undefined ? values.alpha : alpha))); 31392 31393 if (space === 'alpha') { 31394 return false; 31395 } 31396 31397 var capped; 31398 31399 // cap values of the space prior converting all values 31400 for (i = 0; i < space.length; i++) { 31401 capped = Math.max(0, Math.min(maxes[space][i], values[space][i])); 31402 values[space][i] = Math.round(capped); 31403 } 31404 31405 // convert to all the other color spaces 31406 for (var sname in spaces) { 31407 if (sname !== space) { 31408 values[sname] = convert[space][sname](values[space]); 31409 } 31410 } 31411 31412 return true; 31413}; 31414 31415Color.prototype.setSpace = function (space, args) { 31416 var vals = args[0]; 31417 31418 if (vals === undefined) { 31419 // color.rgb() 31420 return this.getValues(space); 31421 } 31422 31423 // color.rgb(10, 10, 10) 31424 if (typeof vals === 'number') { 31425 vals = Array.prototype.slice.call(args); 31426 } 31427 31428 this.setValues(space, vals); 31429 return this; 31430}; 31431 31432Color.prototype.setChannel = function (space, index, val) { 31433 var svalues = this.values[space]; 31434 if (val === undefined) { 31435 // color.red() 31436 return svalues[index]; 31437 } else if (val === svalues[index]) { 31438 // color.red(color.red()) 31439 return this; 31440 } 31441 31442 // color.red(100) 31443 svalues[index] = val; 31444 this.setValues(space, svalues); 31445 31446 return this; 31447}; 31448 31449if (typeof window !== 'undefined') { 31450 window.Color = Color; 31451} 31452 31453module.exports = Color; 31454 31455 31456/***/ }), 31457/* 25 */ 31458/***/ (function(module, __webpack_exports__, __webpack_require__) { 31459 31460"use strict"; 31461/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return AttrPlugin; }); 31462/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__ = __webpack_require__(3); 31463/*! 31464 * VERSION: 0.6.1 31465 * DATE: 2018-05-30 31466 * UPDATES AND DOCS AT: http://greensock.com 31467 * 31468 * @license Copyright (c) 2008-2018, GreenSock. All rights reserved. 31469 * This work is subject to the terms at http://greensock.com/standard-license or for
31470 * Club GreenSock members, the software agreement that was issued with your membership. 31471 * 31472 * @author: Jack Doyle, [email protected] 31473 */ 31474 31475 31476 31477const AttrPlugin = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"]._gsDefine.plugin({ 31478 propName: "attr", 31479 API: 2, 31480 version: "0.6.1", 31481 31482 //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. 31483 init: function(target, value, tween, index) { 31484 var p, end; 31485 if (typeof(target.setAttribute) !== "function") { 31486 return false; 31487 } 31488 for (p in value) { 31489 end = value[p]; 31490 if (typeof(end) === "function") { 31491 end = end(index, target); 31492 } 31493 this._addTween(target, "setAttribute", target.getAttribute(p) + "", end + "", p, false, p); 31494 this._overwriteProps.push(p); 31495 } 31496 return true; 31497 } 31498 31499}); 31500/* unused harmony export AttrPlugin */ 31501 31502 31503 31504 31505 31506 31507 31508 31509/***/ }), 31510/* 26 */ 31511/***/ (function(module, __webpack_exports__, __webpack_require__) { 31512 31513"use strict"; 31514/* unused harmony export BezierPlugin */ 31515/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return BezierPlugin; }); 31516/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__ = __webpack_require__(3); 31517/*! 31518 * VERSION: 1.3.8 31519 * DATE: 2018-05-30 31520 * UPDATES AND DOCS AT: http://greensock.com 31521 * 31522 * @license Copyright (c) 2008-2018, GreenSock. All rights reserved. 31523 * This work is subject to the terms at http://greensock.com/standard-license or for 31524 * Club GreenSock members, the software agreement that was issued with your membership. 31525 * 31526 * @author: Jack Doyle, [email protected] 31527 **/ 31528 31529 31530 var _RAD2DEG = 180 / Math.PI, 31531 _r1 = [], 31532 _r2 = [], 31533 _r3 = [], 31534 _corProps = {}, 31535 _globals = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"]._gsDefine.globals, 31536 Segment = function(a, b, c, d) { 31537 if (c === d) { //if c and d match, the final autoRotate value could lock at -90 degrees, so differentiate them slightly. 31538 c = d - (d - b) / 1000000; 31539 } 31540 if (a === b) { //if a and b match, the starting autoRotate value could lock at -90 degrees, so differentiate them slightly. 31541 b = a + (c - a) / 1000000; 31542 } 31543 this.a = a; 31544 this.b = b; 31545 this.c = c; 31546 this.d = d; 31547 this.da = d - a; 31548 this.ca = c - a; 31549 this.ba = b - a; 31550 }, 31551 _correlate = ",x,y,z,left,top,right,bottom,marginTop,marginLeft,marginRight,marginBottom,paddingLeft,paddingTop,paddingRight,paddingBottom,backgroundPosition,backgroundPosition_y,", 31552 cubicToQuadratic = function(a, b, c, d) { 31553 var q1 = {a:a}, 31554 q2 = {}, 31555 q3 = {}, 31556 q4 = {c:d}, 31557 mab = (a + b) / 2, 31558 mbc = (b + c) / 2, 31559 mcd = (c + d) / 2, 31560 mabc = (mab + mbc) / 2, 31561 mbcd = (mbc + mcd) / 2, 31562 m8 = (mbcd - mabc) / 8; 31563 q1.b = mab + (a - mab) / 4; 31564 q2.b = mabc + m8; 31565 q1.c = q2.a = (q1.b + q2.b) / 2; 31566 q2.c = q3.a = (mabc + mbcd) / 2; 31567 q3.b = mbcd - m8; 31568 q4.b = mcd + (d - mcd) / 4; 31569 q3.c = q4.a = (q3.b + q4.b) / 2; 31570 return [q1, q2, q3, q4]; 31571 }, 31572 _calculateControlPoints = function(a, curviness, quad, basic, correlate) { 31573 var l = a.length - 1, 31574 ii = 0, 31575 cp1 = a[0].a, 31576 i, p1, p2, p3, seg, m1, m2, mm, cp2, qb, r1, r2, tl; 31577 for (i = 0; i < l; i++) { 31578 seg = a[ii]; 31579 p1 = seg.a; 31580 p2 = seg.d; 31581 p3 = a[ii+1].d; 31582 31583 if (correlate) { 31584 r1 = _r1[i]; 31585 r2 = _r2[i]; 31586 tl = ((r2 + r1) * curviness * 0.25) / (basic ? 0.5 : _r3[i] || 0.5); 31587 m1 = p2 - (p2 - p1) * (basic ? curviness * 0.5 : (r1 !== 0 ? tl / r1 : 0)); 31588 m2 = p2 + (p3 - p2) * (basic ? curviness * 0.5 : (r2 !== 0 ? tl / r2 : 0)); 31589 mm = p2 - (m1 + (((m2 - m1) * ((r1 * 3 / (r1 + r2)) + 0.5) / 4) || 0)); 31590 } else { 31591 m1 = p2 - (p2 - p1) * curviness * 0.5; 31592 m2 = p2 + (p3 - p2) * curviness * 0.5; 31593 mm = p2 - (m1 + m2) / 2; 31594 } 31595 m1 += mm; 31596 m2 += mm; 31597 31598 seg.c = cp2 = m1; 31599 if (i !== 0) { 31600 seg.b = cp1; 31601 } else { 31602 seg.b = cp1 = seg.a + (seg.c - seg.a) * 0.6; //instead of placing b on a exactly, we move it inline with c so that if the user specifies an ease like Back.easeIn or Elastic.easeIn which goes BEYOND the beginning, it will do so smoothly. 31603 } 31604 31605 seg.da = p2 - p1; 31606 seg.ca = cp2 - p1; 31607 seg.ba = cp1 - p1; 31608 31609 if (quad) { 31610 qb = cubicToQuadratic(p1, cp1, cp2, p2); 31611 a.splice(ii, 1, qb[0], qb[1], qb[2], qb[3]); 31612 ii += 4; 31613 } else { 31614 ii++; 31615 } 31616 31617 cp1 = m2; 31618 } 31619 seg = a[ii]; 31620 seg.b = cp1; 31621 seg.c = cp1 + (seg.d - cp1) * 0.4; //instead of placing c on d exactly, we move it inline with b so that if the user specifies an ease like Back.easeOut or Elastic.easeOut which goes BEYOND the end, it will do so smoothly. 31622 seg.da = seg.d - seg.a; 31623 seg.ca = seg.c - seg.a; 31624 seg.ba = cp1 - seg.a; 31625 if (quad) { 31626 qb = cubicToQuadratic(seg.a, cp1, seg.c, seg.d); 31627 a.splice(ii, 1, qb[0], qb[1], qb[2], qb[3]); 31628 } 31629 }, 31630 _parseAnchors = function(values, p, correlate, prepend) { 31631 var a = [], 31632 l, i, p1, p2, p3, tmp; 31633 if (prepend) {
31634 values = [prepend].concat(values); 31635 i = values.length; 31636 while (--i > -1) { 31637 if (typeof( (tmp = values[i][p]) ) === "string") if (tmp.charAt(1) === "=") { 31638 values[i][p] = prepend[p] + Number(tmp.charAt(0) + tmp.substr(2)); //accommodate relative values. Do it inline instead of breaking it out into a function for speed reasons 31639 } 31640 } 31641 } 31642 l = values.length - 2; 31643 if (l < 0) { 31644 a[0] = new Segment(values[0][p], 0, 0, values[0][p]); 31645 return a; 31646 } 31647 for (i = 0; i < l; i++) { 31648 p1 = values[i][p]; 31649 p2 = values[i+1][p]; 31650 a[i] = new Segment(p1, 0, 0, p2); 31651 if (correlate) { 31652 p3 = values[i+2][p]; 31653 _r1[i] = (_r1[i] || 0) + (p2 - p1) * (p2 - p1); 31654 _r2[i] = (_r2[i] || 0) + (p3 - p2) * (p3 - p2); 31655 } 31656 } 31657 a[i] = new Segment(values[i][p], 0, 0, values[i+1][p]); 31658 return a; 31659 }, 31660 bezierThrough = function(values, curviness, quadratic, basic, correlate, prepend) { 31661 var obj = {}, 31662 props = [], 31663 first = prepend || values[0], 31664 i, p, a, j, r, l, seamless, last; 31665 correlate = (typeof(correlate) === "string") ? ","+correlate+"," : _correlate; 31666 if (curviness == null) { 31667 curviness = 1; 31668 } 31669 for (p in values[0]) { 31670 props.push(p); 31671 } 31672 //check to see if the last and first values are identical (well, within 0.05). If so, make seamless by appending the second element to the very end of the values array and the 2nd-to-last element to the very beginning (we'll remove those segments later) 31673 if (values.length > 1) { 31674 last = values[values.length - 1]; 31675 seamless = true; 31676 i = props.length; 31677 while (--i > -1) { 31678 p = props[i]; 31679 if (Math.abs(first[p] - last[p]) > 0.05) { //build in a tolerance of +/-0.05 to accommodate rounding errors. 31680 seamless = false; 31681 break; 31682 } 31683 } 31684 if (seamless) { 31685 values = values.concat(); //duplicate the array to avoid contaminating the original which the user may be reusing for other tweens 31686 if (prepend) { 31687 values.unshift(prepend); 31688 } 31689 values.push(values[1]); 31690 prepend = values[values.length - 3]; 31691 } 31692 } 31693 _r1.length = _r2.length = _r3.length = 0; 31694 i = props.length; 31695 while (--i > -1) { 31696 p = props[i]; 31697 _corProps[p] = (correlate.indexOf(","+p+",") !== -1); 31698 obj[p] = _parseAnchors(values, p, _corProps[p], prepend); 31699 } 31700 i = _r1.length; 31701 while (--i > -1) { 31702 _r1[i] = Math.sqrt(_r1[i]); 31703 _r2[i] = Math.sqrt(_r2[i]); 31704 } 31705 if (!basic) { 31706 i = props.length; 31707 while (--i > -1) { 31708 if (_corProps[p]) { 31709 a = obj[props[i]]; 31710 l = a.length - 1; 31711 for (j = 0; j < l; j++) { 31712 r = (a[j+1].da / _r2[j] + a[j].da / _r1[j]) || 0; 31713 _r3[j] = (_r3[j] || 0) + r * r; 31714 } 31715 } 31716 } 31717 i = _r3.length; 31718 while (--i > -1) { 31719 _r3[i] = Math.sqrt(_r3[i]); 31720 } 31721 } 31722 i = props.length; 31723 j = quadratic ? 4 : 1; 31724 while (--i > -1) { 31725 p = props[i]; 31726 a = obj[p]; 31727 _calculateControlPoints(a, curviness, quadratic, basic, _corProps[p]); //this method requires that _parseAnchors() and _setSegmentRatios() ran first so that _r1, _r2, and _r3 values are populated for all properties 31728 if (seamless) { 31729 a.splice(0, j); 31730 a.splice(a.length - j, j); 31731 } 31732 } 31733 return obj; 31734 }, 31735 _parseBezierData = function(values, type, prepend) { 31736 type = type || "soft"; 31737 var obj = {}, 31738 inc = (type === "cubic") ? 3 : 2, 31739 soft = (type === "soft"), 31740 props = [], 31741 a, b, c, d, cur, i, j, l, p, cnt, tmp; 31742 if (soft && prepend) { 31743 values = [prepend].concat(values); 31744 } 31745 if (values == null || values.length < inc + 1) { throw "invalid Bezier data"; } 31746 for (p in values[0]) { 31747 props.push(p); 31748 } 31749 i = props.length; 31750 while (--i > -1) { 31751 p = props[i]; 31752 obj[p] = cur = []; 31753 cnt = 0; 31754 l = values.length; 31755 for (j = 0; j < l; j++) { 31756 a = (prepend == null) ? values[j][p] : (typeof( (tmp = values[j][p]) ) === "string" && tmp.charAt(1) === "=") ? prepend[p] + Number(tmp.charAt(0) + tmp.substr(2)) : Number(tmp); 31757 if (soft) if (j > 1) if (j < l - 1) { 31758 cur[cnt++] = (a + cur[cnt-2]) / 2; 31759 } 31760 cur[cnt++] = a; 31761 } 31762 l = cnt - inc + 1; 31763 cnt = 0; 31764 for (j = 0; j < l; j += inc) { 31765 a = cur[j]; 31766 b = cur[j+1]; 31767 c = cur[j+2]; 31768 d = (inc === 2) ? 0 : cur[j+3]; 31769 cur[cnt++] = tmp = (inc === 3) ? new Segment(a, b, c, d) : new Segment(a, (2 * b + a) / 3, (2 * b + c) / 3, c); 31770 } 31771 cur.length = cnt; 31772 } 31773 return obj; 31774 }, 31775 _addCubicLengths = function(a, steps, resolution) { 31776 var inc = 1 / resolution, 31777 j = a.length, 31778 d, d1, s, da, ca, ba, p, i, inv, bez, index; 31779 while (--j > -1) { 31780 bez = a[j]; 31781 s = bez.a; 31782 da = bez.d - s; 31783 ca = bez.c - s; 31784 ba = bez.b - s; 31785 d = d1 = 0; 31786 for (i = 1; i <= resolution; i++) { 31787 p = inc * i; 31788 inv = 1 - p; 31789 d = d1 - (d1 = (p * p * da + 3 * inv * (p * ca + inv * ba)) * p); 31790 index = j * resolution + i - 1; 31791 steps[index] = (steps[index] || 0) + d * d; 31792 } 31793 } 31794 }, 31795 _parseLengthData = function(obj, resolution) { 31796 resolution = resolution >> 0 || 6; 31797 var a = [], 31798 lengths = [], 31799 d = 0, 31800 total = 0, 31801 threshold = resolution - 1, 31802 segments = [], 31803 curLS = [], //current length segments array 31804 p, i, l, index; 31805 for (p in obj) { 31806 _addCubicLengths(obj[p], a, resolution); 31807 } 31808 l = a.length; 31809 for (i = 0; i < l; i++) { 31810 d += Math.sqrt(a[i]); 31811 index = i % resolution; 31812 curLS[index] = d; 31813 if (index === threshold) { 31814 total += d; 31815 index = (i / resolution) >> 0; 31816 segments[index] = curLS; 31817 lengths[index] = total; 31818 d = 0; 31819 curLS = []; 31820 } 31821 } 31822 return {length:total, lengths:lengths, segments:segments}; 31823 }, 31824 31825 31826 31827 BezierPlugin = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"]._gsDefine.plugin({ 31828 propName: "bezier", 31829 priority: -1, 31830 version: "1.3.8", 31831 API: 2, 31832 global:true, 31833 31834 //gets called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. 31835 init: function(target, vars, tween) { 31836 this._target = target; 31837 if (vars instanceof Array) { 31838 vars = {values:vars}; 31839 } 31840 this._func = {}; 31841 this._mod = {}; 31842 this._props = []; 31843 this._timeRes = (vars.timeResolution == null) ? 6 : parseInt(vars.timeResolution, 10); 31844 var values = vars.values || [], 31845 first = {}, 31846 second = values[0], 31847 autoRotate = vars.autoRotate || tween.vars.orientToBezier, 31848 p, isFunc, i, j, prepend; 31849 31850 this._autoRotate = autoRotate ? (autoRotate instanceof Array) ? autoRotate : [["x","y","rotation",((autoRotate === true) ? 0 : Number(autoRotate) || 0)]] : null; 31851 for (p in second) { 31852 this._props.push(p); 31853 } 31854 31855 i = this._props.length; 31856 while (--i > -1) { 31857 p = this._props[i]; 31858 31859 this._overwriteProps.push(p); 31860 isFunc = this._func[p] = (typeof(target[p]) === "function"); 31861 first[p] = (!isFunc) ? parseFloat(target[p]) : target[ ((p.indexOf("set") || typeof(target["get" + p.substr(3)]) !== "function") ? p : "get" + p.substr(3)) ](); 31862 if (!prepend) if (first[p] !== values[0][p]) { 31863 prepend = first; 31864 } 31865 } 31866 this._beziers = (vars.type !== "cubic" && vars.type !== "quadratic" && vars.type !== "soft") ? bezierThrough(values, isNaN(vars.curviness) ? 1 : vars.curviness, false, (vars.type === "thruBasic"), vars.correlate, prepend) : _parseBezierData(values, vars.type, first); 31867 this._segCount = this._beziers[p].length; 31868 31869 if (this._timeRes) { 31870 var ld = _parseLengthData(this._beziers, this._timeRes); 31871 this._length = ld.length; 31872 this._lengths = ld.lengths; 31873 this._segments = ld.segments; 31874 this._l1 = this._li = this._s1 = this._si = 0; 31875 this._l2 = this._lengths[0]; 31876 this._curSeg = this._segments[0]; 31877 this._s2 = this._curSeg[0]; 31878 this._prec = 1 / this._curSeg.length; 31879 } 31880 31881 if ((autoRotate = this._autoRotate)) { 31882 this._initialRotations = []; 31883 if (!(autoRotate[0] instanceof Array)) { 31884 this._autoRotate = autoRotate = [autoRotate]; 31885 } 31886 i = autoRotate.length; 31887 while (--i > -1) { 31888 for (j = 0; j < 3; j++) { 31889 p = autoRotate[i][j]; 31890 this._func[p] = (typeof(target[p]) === "function") ? target[ ((p.indexOf("set") || typeof(target["get" + p.substr(3)]) !== "function") ? p : "get" + p.substr(3)) ] : false;
31891 } 31892 p = autoRotate[i][2]; 31893 this._initialRotations[i] = (this._func[p] ? this._func[p].call(this._target) : this._target[p]) || 0; 31894 this._overwriteProps.push(p); 31895 } 31896 } 31897 this._startRatio = tween.vars.runBackwards ? 1 : 0; //we determine the starting ratio when the tween inits which is always 0 unless the tween has runBackwards:true (indicating it's a from() tween) in which case it's 1. 31898 return true; 31899 }, 31900 31901 //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.) 31902 set: function(v) { 31903 var segments = this._segCount, 31904 func = this._func, 31905 target = this._target, 31906 notStart = (v !== this._startRatio), 31907 curIndex, inv, i, p, b, t, val, l, lengths, curSeg; 31908 if (!this._timeRes) { 31909 curIndex = (v < 0) ? 0 : (v >= 1) ? segments - 1 : (segments * v) >> 0; 31910 t = (v - (curIndex * (1 / segments))) * segments; 31911 } else { 31912 lengths = this._lengths; 31913 curSeg = this._curSeg; 31914 v *= this._length; 31915 i = this._li; 31916 //find the appropriate segment (if the currently cached one isn't correct) 31917 if (v > this._l2 && i < segments - 1) { 31918 l = segments - 1; 31919 while (i < l && (this._l2 = lengths[++i]) <= v) { } 31920 this._l1 = lengths[i-1]; 31921 this._li = i; 31922 this._curSeg = curSeg = this._segments[i]; 31923 this._s2 = curSeg[(this._s1 = this._si = 0)]; 31924 } else if (v < this._l1 && i > 0) { 31925 while (i > 0 && (this._l1 = lengths[--i]) >= v) { } 31926 if (i === 0 && v < this._l1) { 31927 this._l1 = 0; 31928 } else { 31929 i++; 31930 } 31931 this._l2 = lengths[i]; 31932 this._li = i; 31933 this._curSeg = curSeg = this._segments[i]; 31934 this._s1 = curSeg[(this._si = curSeg.length - 1) - 1] || 0; 31935 this._s2 = curSeg[this._si]; 31936 } 31937 curIndex = i; 31938 //now find the appropriate sub-segment (we split it into the number of pieces that was defined by "precision" and measured each one) 31939 v -= this._l1; 31940 i = this._si; 31941 if (v > this._s2 && i < curSeg.length - 1) { 31942 l = curSeg.length - 1; 31943 while (i < l && (this._s2 = curSeg[++i]) <= v) { } 31944 this._s1 = curSeg[i-1]; 31945 this._si = i; 31946 } else if (v < this._s1 && i > 0) { 31947 while (i > 0 && (this._s1 = curSeg[--i]) >= v) { } 31948 if (i === 0 && v < this._s1) { 31949 this._s1 = 0; 31950 } else { 31951 i++; 31952 } 31953 this._s2 = curSeg[i]; 31954 this._si = i; 31955 } 31956 t = ((i + (v - this._s1) / (this._s2 - this._s1)) * this._prec) || 0; 31957 } 31958 inv = 1 - t; 31959 31960 i = this._props.length; 31961 while (--i > -1) { 31962 p = this._props[i]; 31963 b = this._beziers[p][curIndex]; 31964 val = (t * t * b.da + 3 * inv * (t * b.ca + inv * b.ba)) * t + b.a; 31965 if (this._mod[p]) { 31966 val = this._mod[p](val, target); 31967 } 31968 if (func[p]) { 31969 target[p](val); 31970 } else { 31971 target[p] = val; 31972 } 31973 } 31974 31975 if (this._autoRotate) { 31976 var ar = this._autoRotate, 31977 b2, x1, y1, x2, y2, add, conv; 31978 i = ar.length; 31979 while (--i > -1) { 31980 p = ar[i][2]; 31981 add = ar[i][3] || 0; 31982 conv = (ar[i][4] === true) ? 1 : _RAD2DEG; 31983 b = this._beziers[ar[i][0]]; 31984 b2 = this._beziers[ar[i][1]]; 31985 31986 if (b && b2) { //in case one of the properties got overwritten. 31987 b = b[curIndex]; 31988 b2 = b2[curIndex]; 31989 31990 x1 = b.a + (b.b - b.a) * t; 31991 x2 = b.b + (b.c - b.b) * t; 31992 x1 += (x2 - x1) * t; 31993 x2 += ((b.c + (b.d - b.c) * t) - x2) * t; 31994 31995 y1 = b2.a + (b2.b - b2.a) * t; 31996 y2 = b2.b + (b2.c - b2.b) * t; 31997 y1 += (y2 - y1) * t; 31998 y2 += ((b2.c + (b2.d - b2.c) * t) - y2) * t; 31999 32000 val = notStart ? Math.atan2(y2 - y1, x2 - x1) * conv + add : this._initialRotations[i]; 32001 32002 if (this._mod[p]) { 32003 val = this._mod[p](val, target); //for modProps 32004 } 32005 32006 if (func[p]) { 32007 target[p](val); 32008 } else { 32009 target[p] = val; 32010 } 32011 } 32012 } 32013 } 32014 } 32015 }), 32016 p = BezierPlugin.prototype; 32017 32018 32019 BezierPlugin.bezierThrough = bezierThrough; 32020 BezierPlugin.cubicToQuadratic = cubicToQuadratic; 32021 BezierPlugin._autoCSS = true; //indicates that this plugin can be inserted into the "css" object using the autoCSS feature of TweenLite 32022 BezierPlugin.quadraticToCubic = function(a, b, c) { 32023 return new Segment(a, (2 * b + a) / 3, (2 * b + c) / 3, c); 32024 }; 32025 32026 BezierPlugin._cssRegister = function() { 32027 var CSSPlugin = _globals.CSSPlugin; 32028 if (!CSSPlugin) { 32029 return; 32030 } 32031 var _internals = CSSPlugin._internals, 32032 _parseToProxy = _internals._parseToProxy, 32033 _setPluginRatio = _internals._setPluginRatio, 32034 CSSPropTween = _internals.CSSPropTween; 32035 _internals._registerComplexSpecialProp("bezier", {parser:function(t, e, prop, cssp, pt, plugin) { 32036 if (e instanceof Array) { 32037 e = {values:e}; 32038 } 32039 plugin = new BezierPlugin(); 32040 var values = e.values, 32041 l = values.length - 1, 32042 pluginValues = [], 32043 v = {}, 32044 i, p, data; 32045 if (l < 0) { 32046 return pt; 32047 } 32048 for (i = 0; i <= l; i++) { 32049 data = _parseToProxy(t, values[i], cssp, pt, plugin, (l !== i)); 32050 pluginValues[i] = data.end; 32051 } 32052 for (p in e) { 32053 v[p] = e[p]; //duplicate the vars object because we need to alter some things which w
32053ould cause problems if the user plans to reuse the same vars object for another tween. 32054 } 32055 v.values = pluginValues; 32056 pt = new CSSPropTween(t, "bezier", 0, 0, data.pt, 2); 32057 pt.data = data; 32058 pt.plugin = plugin; 32059 pt.setRatio = _setPluginRatio; 32060 if (v.autoRotate === 0) { 32061 v.autoRotate = true; 32062 } 32063 if (v.autoRotate && !(v.autoRotate instanceof Array)) { 32064 i = (v.autoRotate === true) ? 0 : Number(v.autoRotate); 32065 v.autoRotate = (data.end.left != null) ? [["left","top","rotation",i,false]] : (data.end.x != null) ? [["x","y","rotation",i,false]] : false; 32066 } 32067 if (v.autoRotate) { 32068 if (!cssp._transform) { 32069 cssp._enableTransforms(false); 32070 } 32071 data.autoRotate = cssp._target._gsTransform; 32072 data.proxy.rotation = data.autoRotate.rotation || 0; 32073 cssp._overwriteProps.push("rotation"); 32074 } 32075 plugin._onInitTween(data.proxy, v, cssp._tween); 32076 return pt; 32077 }}); 32078 }; 32079 32080 p._mod = function(lookup) { 32081 var op = this._overwriteProps, 32082 i = op.length, 32083 val; 32084 while (--i > -1) { 32085 val = lookup[op[i]]; 32086 if (val && typeof(val) === "function") { 32087 this._mod[op[i]] = val; 32088 } 32089 } 32090 }; 32091 32092 p._kill = function(lookup) { 32093 var a = this._props, 32094 p, i; 32095 for (p in this._beziers) { 32096 if (p in lookup) { 32097 delete this._beziers[p]; 32098 delete this._func[p]; 32099 i = a.length; 32100 while (--i > -1) { 32101 if (a[i] === p) { 32102 a.splice(i, 1); 32103 } 32104 } 32105 } 32106 } 32107 a = this._autoRotate; 32108 if (a) { 32109 i = a.length; 32110 while (--i > -1) { 32111 if (lookup[a[i][2]]) { 32112 a.splice(i, 1); 32113 } 32114 } 32115 } 32116 return this._super._kill.call(this, lookup); 32117 }; 32118 32119 32120 32121/***/ }), 32122/* 27 */ 32123/***/ (function(module, __webpack_exports__, __webpack_require__) { 32124 32125"use strict"; 32126/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return CSSPlugin; }); 32127/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__ = __webpack_require__(3); 32128/*! 32129 * VERSION: 1.20.5 32130 * DATE: 2018-05-30 32131 * UPDATES AND DOCS AT: http://greensock.com 32132 * 32133 * @license Copyright (c) 2008-2018, GreenSock. All rights reserved. 32134 * This work is subject to the terms at http://greensock.com/standard-license or for 32135 * Club GreenSock members, the software agreement that was issued with your membership. 32136 * 32137 * @author: Jack Doyle, [email protected] 32138 */ 32139 32140 32141 __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"]._gsDefine("plugins.CSSPlugin", ["plugins.TweenPlugin","TweenLite"], function() { 32142 32143 /** @constructor **/ 32144 var CSSPlugin = function() { 32145 __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["TweenPlugin"].call(this, "css"); 32146 this._overwriteProps.length = 0; 32147 this.setRatio = CSSPlugin.prototype.setRatio; //speed optimization (avoid prototype lookup on this "hot" method) 32148 }, 32149 _globals = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"]._gsDefine.globals, 32150 _hasPriority, //turns true whenever a CSSPropTween instance is created that has a priority other than 0. This helps us discern whether or not we should spend the time organizing the linked list or not after a CSSPlugin's _onInitTween() method is called. 32151 _suffixMap, //we set this in _onInitTween() each time as a way to have a persistent variable we can use in other methods like _parse() without having to pass it around as a parameter and we keep _parse() decoupled from a particular CSSPlugin instance 32152 _cs, //computed style (we store this in a shared variable to conserve memory and make minification tighter 32153 _overwriteProps, //alias to the currently instantiating CSSPlugin's _overwriteProps array. We use this closure in order to avoid having to pass a reference around from method to method and aid in minification. 32154 _specialProps = {}, 32155 p = CSSPlugin.prototype = new __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["TweenPlugin"]("css"); 32156 32157 p.constructor = CSSPlugin; 32158 CSSPlugin.version = "1.20.5"; 32159 CSSPlugin.API = 2; 32160 CSSPlugin.defaultTransformPerspective = 0; 32161 CSSPlugin.defaultSkewType = "compensated"; 32162 CSSPlugin.defaultSmoothOrigin = true; 32163 p = "px"; //we'll reuse the "p" variable to keep file size down 32164 CSSPlugin.suffixMap = {top:p, right:p, bottom:p, left:p, width:p, height:p, fontSize:p, padding:p, margin:p, perspective:p, lineHeight:""}; 32165 32166 32167 var _numExp = /(?:\-|\.|\b)(\d|\.|e\-)+/g, 32168 _relNumExp = /(?:\d|\-\d|\.\d|\-\.\d|\+=\d|\-=\d|\+=.\d|\-=\.\d)+/g,
32169 _valuesExp = /(?:\+=|\-=|\-|\b)[\d\-\.]+[a-zA-Z0-9]*(?:%|\b)/gi, //finds all the values that begin with numbers or += or -= and then a number. Includes suffixes. We use this to split complex values apart like "1px 5px 20px rgb(255,102,51)" 32170 _NaNExp = /(?![+-]?\d*\.?\d+|[+-]|e[+-]\d+)[^0-9]/g, //also allows scientific notation and doesn't kill the leading -/+ in -= and += 32171 _suffixExp = /(?:\d|\-|\+|=|#|\.)*/g, 32172 _opacityExp = /opacity *= *([^)]*)/i, 32173 _opacityValExp = /opacity:([^;]*)/i, 32174 _alphaFilterExp = /alpha\(opacity *=.+?\)/i, 32175 _rgbhslExp = /^(rgb|hsl)/, 32176 _capsExp = /([A-Z])/g, 32177 _camelExp = /-([a-z])/gi, 32178 _urlExp = /(^(?:url\(\"|url\())|(?:(\"\))$|\)$)/gi, //for pulling out urls from url(...) or url("...") strings (some browsers wrap urls in quotes, some don't when reporting things like backgroundImage) 32179 _camelFunc = function(s, g) { return g.toUpperCase(); }, 32180 _horizExp = /(?:Left|Right|Width)/i, 32181 _ieGetMatrixExp = /(M11|M12|M21|M22)=[\d\-\.e]+/gi, 32182 _ieSetMatrixExp = /progid\:DXImageTransform\.Microsoft\.Matrix\(.+?\)/i, 32183 _commasOutsideParenExp = /,(?=[^\)]*(?:\(|$))/gi, //finds any commas that are not within parenthesis 32184 _complexExp = /[\s,\(]/i, //for testing a string to find if it has a space, comma, or open parenthesis (clues that it's a complex value) 32185 _DEG2RAD = Math.PI / 180, 32186 _RAD2DEG = 180 / Math.PI, 32187 _forcePT = {}, 32188 _dummyElement = {style:{}}, 32189 _doc = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].document || {createElement: function() {return _dummyElement;}}, 32190 _createElement = function(type, ns) { 32191 return _doc.createElementNS ? _doc.createElementNS(ns || "http://www.w3.org/1999/xhtml", type) : _doc.createElement(type); 32192 }, 32193 _tempDiv = _createElement("div"), 32194 _tempImg = _createElement("img"), 32195 _internals = CSSPlugin._internals = {_specialProps:_specialProps}, //provides a hook to a few internal methods that we need to access from inside other plugins 32196 _agent = (__WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].navigator || {}).userAgent || "", 32197 _autoRound, 32198 _reqSafariFix, //we won't apply the Safari transform fix until we actually come across a tween that affects a transform property (to maintain best performance). 32199 32200 _isSafari, 32201 _isFirefox, //Firefox has a bug that causes 3D transformed elements to randomly disappear unless a repaint is forced after each update on each element. 32202 _isSafariLT6, //Safari (and Android 4 which uses a flavor of Safari) has a bug that prevents changes to "top" and "left" properties from rendering properly if changed on the same frame as a transform UNLESS we set the element's WebkitBackfaceVisibility to hidden (weird, I know). Doing this for Android 3 and earlier seems to actually cause other problems, though (fun!) 32203 _ieVers, 32204 _supportsOpacity = (function() { //we set _isSafari, _ieVers, _isFirefox, and _supportsOpacity all in one function here to reduce file size slightly, especially in the minified version. 32205 var i = _agent.indexOf("Android"), 32206 a = _createElement("a"); 32207 _isSafari = (_agent.indexOf("Safari") !== -1 && _agent.indexOf("Chrome") === -1 && (i === -1 || parseFloat(_agent.substr(i+8, 2)) > 3)); 32208 _isSafariLT6 = (_isSafari && (parseFloat(_agent.substr(_agent.indexOf("Version/")+8, 2)) < 6)); 32209 _isFirefox = (_agent.indexOf("Firefox") !== -1); 32210 if ((/MSIE ([0-9]{1,}[\.0-9]{0,})/).exec(_agent) || (/Trident\/.*rv:([0-9]{1,}[\.0-9]{0,})/).exec(_agent)) { 32211 _ieVers = parseFloat( RegExp.$1 ); 32212 } 32213 if (!a) { 32214 return false; 32215 } 32216 a.style.cssText = "top:1px;opacity:.55;"; 32217 return /^0.55/.test(a.style.opacity); 32218 }()), 32219 _getIEOpacity = function(v) { 32220 return (_opacityExp.test( ((typeof(v) === "string") ? v : (v.currentStyle ? v.currentStyle.filter : v.style.filter) || "") ) ? ( parseFloat( RegExp.$1 ) / 100 ) : 1); 32221 }, 32222 _log = function(s) {//for logging messages, but in a way that won't throw errors in old versions of IE. 32223 if (__WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].console) { 32224 console.log(s); 32225 } 32226 }, 32227 _target, //when initting a CSSPlugin, we set this variable so that we can access it from within many other functions without having to pass it around as params 32228 _index, //when initting a CSSPlugin, we set this variable so that we can access it from within many other functions without having to pass it around as params 32229 32230 _prefixCSS = "", //the non-camelCase vendor prefix like "-o-", "-moz-", "-ms-", or "-webkit-" 32231 _prefix = "", //camelCase vendor prefix like "O", "ms", "Webkit", or "Moz". 32232 32233 // @private feed in a camelCase property name like "transform" and it will check to see if it is valid as-is or if it needs a vendor prefix. It returns the corrected camelCase property name (i.e. "WebkitTransform" or "MozTransform" or "transform" or null if no such property is found, like if the browser is IE8 or before, "transform" won't be found at all) 32234 _checkPropPrefix = function(p, e) { 32235 e = e || _tempDiv; 32236 var s = e.style, 32237 a, i; 32238 if (s[p] !== undefined) { 32239 return p; 32240 } 32241 p = p.charAt(0).toUpperCase() + p.substr(1); 32242 a = ["O","Moz","ms","Ms","Webkit"]; 32243 i = 5; 32244 while (--i > -1 && s[a[i]+p] === undefined) { } 32245 if (i >= 0) { 32246 _prefix = (i === 3) ? "ms" : a[i]; 32247 _prefixCSS = "-" + _prefix.toLowerCase() + "-"; 32248 return _prefix + p; 32249 } 32250 return null; 32251 }, 32252 32253 _getComputedStyle = (typeof(window) !== "undefined" ? window : _doc.defaultView || {getComputedStyle:function() {}}).getComputedStyle, 32254 32255 /** 32256 * @private Returns the css style for a particular property of an element. For example, to get whatever the current "left" css value for an element with an ID of "myElement", you could do: 32257 * var currentLeft = CSSPlugin.getStyle( document.getElementById("myElement"), "left"); 32258 * 32259 * @param {!Object} t Target element whose style property you want to query 32260 * @param {!string} p Property name (like "left" or "top" or "marginTop", etc.) 32261 * @param {Object=} cs Computed style object. This just provides a way to speed processing if you're going to get several properties on the same element in quick succession - you can reuse the result of the getComputedStyle() call. 32262 * @param {boolean=} calc If true, the value will not be read directly from the element's "style" property (if it exists there), but instead the getComputedStyle() result will be used. This can be useful when you want to ensure that the browser itself is interpreting the value. 32263 * @param {string=} dflt Default value that should be returned in the place of null, "none", "auto" or "auto auto". 32264 * @return {?string} The current property value 32265 */ 32266 _getStyle = CSSPlugin.getStyle = function(t, p, cs, calc, dflt) { 32267 var rv; 32268 if (!_supportsOpacity) if (p === "opacity") { //several versions of IE don't use the standard "opacity" property - they use things like filter:alpha(opacity=50), so we parse that here. 32269 return _getIEOpacity(t); 32270 } 32271 if (!calc && t.style[p]) { 32272 rv = t.style[p]; 32273 } else if ((cs = cs || _getComputedStyle(t))) { 32274 rv = cs[p] || cs.getPropertyValue(p) || cs.getPropertyValue(p.replace(_capsExp, "-$1").toLowerCase()); 32275 } else if (t.currentStyle) { 32276 rv = t.currentStyle[p]; 32277 } 32278 return (dflt != null && (!rv || rv === "none" || rv === "auto" || rv === "auto auto")) ? dflt : rv; 32279 }, 32280 32281 /** 32282 * @private Pass the target element, the property name, the numeric value, and the suffix (like "%", "em", "px", etc.) and it will spit back the equivalent pixel number. 32283 * @param {!Object} t Target element 32284 * @param {!string} p Property name (like "left", "top", "marginLeft", etc.) 32285 * @param {!number} v Value 32286 * @param {string=} sfx Suffix (like "px" or "%" or "em") 32287 * @param {boolean=} recurse If true, the call is a recursive one. In some browsers (like IE7/8), occasionally the value isn't accurately reported initially, but if we run the function again it will take effect. 32288 * @return {number} value in pixels 32289 */ 32290 _convertToPixels = _internals.convertToPixels = function(t, p, v, sfx, recurse) { 32291 if (sfx === "px" || (!sfx && p !== "lineHeight")) { return v; } 32292 if (sfx === "auto" || !v) { return 0; } 32293 var horiz = _horizExp.test(p), 32294 node = t, 32295 style = _tempDiv.style, 32296 neg = (v < 0), 32297 precise = (v === 1), 32298 pix, cache, time; 32299 if (neg) { 32300 v = -v; 32301 } 32302 if (precise) { 32303 v *= 100; 32304 } 32305 if (p === "lineHeight" && !sfx) { //special case of when a simple lineHeight (without a unit) is used. Set it to the value, read back the computed value, and then revert. 32306 cache = _getComputedStyle(t).lineHeight; 32307 t.style.lineHeight = v; 32308 pix = parseFloat(_getComputedStyle(t).lineHeight); 32309 t.style.lineHeight = cache; 32310 } else if (sfx === "%" && p.indexOf("border") !== -1) { 32311 pix = (v / 100) * (horiz ? t.clientWidth : t.clientHeight); 32312 } else { 32313 style.cssText = "border:0 solid red;position:" + _getStyle(t, "position") + ";line-height:0;"; 32314 if (sfx === "%" || !node.appendChild || sfx.charAt(0) === "v" || sfx === "rem") { 32315 node = t.parentNode || _doc.body; 32316 if (_getStyle(node, "display").indexOf("flex") !== -1) { //Edge and IE11 have a bug that causes offsetWidth to report as 0 if the container has display:flex and the child is position:relative. Switching to position: absolute solves it. 32317 style.position = "absolute"; 32318 } 32319 cache = node._gsCache; 32320 time = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].ticker.frame; 32321 if (cache && horiz && cache.time === time) { //performance optimization: we record the width of elements along with the ticker frame so that we can quickly get it again on the same tick (seems relatively safe to assume it wouldn't change on the same tick) 32322 return cache.width * v / 100; 32323 } 32324 style[(horiz ? "width" : "height")] = v + sfx; 32325 } else { 32326 style[(horiz ? "borderLeftWidth" : "borderTopWidth")] = v + sfx; 32327 } 32328 node.appendChild(_tempDiv); 32329 pix = parseFloat(_tempDiv[(horiz ? "offsetWidth" : "offsetHeight")]); 32330 node.removeChild(_tempDiv); 32331 if (horiz && sfx === "%" && CSSPlugin.cacheWidths !== false) { 32332 cache = node._gsCache = node._gsCache || {}; 32333 cache.time = time; 32334 cache.width = pix / v * 100; 32335 } 32336 if (pix === 0 && !recurse) { 32337 pix = _convertToPixels(t, p, v, sfx, true); 32338 } 32339 } 32340 if (precise) { 32341 pix /= 100; 32342 } 32343 return neg ? -pix : pix; 32344 }, 32345 _calculateOffset = _internals.calculateOffset = function(t, p, cs) { //for figuring out "top" or "left" in px when it's "auto". We need to factor in margin with the offsetLeft/offsetTop 32346 if (_getStyle(t, "position", cs) !== "absolute") { return 0; } 32347 var dim = ((p === "left") ? "Left" : "Top"),
32348 v = _getStyle(t, "margin" + dim, cs); 32349 return t["offset" + dim] - (_convertToPixels(t, p, parseFloat(v), v.replace(_suffixExp, "")) || 0); 32350 }, 32351 32352 // @private returns at object containing ALL of the style properties in camelCase and their associated values. 32353 _getAllStyles = function(t, cs) { 32354 var s = {}, 32355 i, tr, p; 32356 if ((cs = cs || _getComputedStyle(t, null))) { 32357 if ((i = cs.length)) { 32358 while (--i > -1) { 32359 p = cs[i]; 32360 if (p.indexOf("-transform") === -1 || _transformPropCSS === p) { //Some webkit browsers duplicate transform values, one non-prefixed and one prefixed ("transform" and "WebkitTransform"), so we must weed out the extra one here. 32361 s[p.replace(_camelExp, _camelFunc)] = cs.getPropertyValue(p); 32362 } 32363 } 32364 } else { //some browsers behave differently - cs.length is always 0, so we must do a for...in loop. 32365 for (i in cs) { 32366 if (i.indexOf("Transform") === -1 || _transformProp === i) { //Some webkit browsers duplicate transform values, one non-prefixed and one prefixed ("transform" and "WebkitTransform"), so we must weed out the extra one here. 32367 s[i] = cs[i]; 32368 } 32369 } 32370 } 32371 } else if ((cs = t.currentStyle || t.style)) { 32372 for (i in cs) { 32373 if (typeof(i) === "string" && s[i] === undefined) { 32374 s[i.replace(_camelExp, _camelFunc)] = cs[i]; 32375 } 32376 } 32377 } 32378 if (!_supportsOpacity) { 32379 s.opacity = _getIEOpacity(t); 32380 } 32381 tr = _getTransform(t, cs, false); 32382 s.rotation = tr.rotation; 32383 s.skewX = tr.skewX; 32384 s.scaleX = tr.scaleX; 32385 s.scaleY = tr.scaleY; 32386 s.x = tr.x; 32387 s.y = tr.y; 32388 if (_supports3D) { 32389 s.z = tr.z; 32390 s.rotationX = tr.rotationX; 32391 s.rotationY = tr.rotationY; 32392 s.scaleZ = tr.scaleZ; 32393 } 32394 if (s.filters) { 32395 delete s.filters; 32396 } 32397 return s; 32398 }, 32399 32400 // @private analyzes two style objects (as returned by _getAllStyles()) and only looks for differences between them that contain tweenable values (like a number or color). It returns an object with a "difs" property which refers to an object c
32400ontaining only those isolated properties and values for tweening, and a "firstMPT" property which refers to the first MiniPropTween instance in a linked list that recorded all the starting values of the different properties so that we can revert to them at the end or beginning of the tween - we don't want the cascading to get messed up. The forceLookup parameter is an optional generic object with properties that should be forced into the results - this is necessary for className tweens that are overwriting others because imagine a scenario where a rollover/rollout adds/removes a class and the user swipes the mouse over the target SUPER fast, thus nothing actually changed yet and the subsequent comparison of the properties would indicate they match (especially when px rounding is taken into consideration), thus no tweening is necessary even though it SHOULD tween and remove those properties after the tween (otherwise the inline styles will contaminate things). See the className SpecialProp code for details. 32401 _cssDif = function(t, s1, s2, vars, forceLookup) { 32402 var difs = {}, 32403 style = t.style, 32404 val, p, mpt; 32405 for (p in s2) { 32406 if (p !== "cssText") if (p !== "length") if (isNaN(p)) if (s1[p] !== (val = s2[p]) || (forceLookup && forceLookup[p])) if (p.indexOf("Origin") === -1) if (typeof(val) === "number" || typeof(val) === "string") { 32407 difs[p] = (val === "auto" && (p === "left" || p === "top")) ? _calculateOffset(t, p) : ((val === "" || val === "auto" || val === "none") && typeof(s1[p]) === "string" && s1[p].replace(_NaNExp, "") !== "") ? 0 : val; //if the ending value is defaulting ("" or "auto"), we check the starting value and if it can be parsed into a number (a string which could have a suffix too, like 700px), then we swap in 0 for "" or "auto" so that things actually tween. 32408 if (style[p] !== undefined) { //for className tweens, we must remember which properties already existed inline - the ones that didn't should be removed when the tween isn't in progress because they were only introduced to facilitate the transition between classes. 32409 mpt = new MiniPropTween(style, p, style[p], mpt); 32410 } 32411 } 32412 } 32413 if (vars) { 32414 for (p in vars) { //copy properties (except className) 32415 if (p !== "className") { 32416 difs[p] = vars[p]; 32417 } 32418 } 32419 } 32420 return {difs:difs, firstMPT:mpt}; 32421 }, 32422 _dimensions = {width:["Left","Right"], height:["Top","Bottom"]}, 32423 _margins = ["marginLeft","marginRight","marginTop","marginBottom"], 32424 32425 /** 32426 * @private Gets the width or height of an element 32427 * @param {!Object} t Target element 32428 * @param {!string} p Property name ("width" or "height") 32429 * @param {Object=} cs Computed style object (if one exists). Just a speed optimization. 32430 * @return {number} Dimension (in pixels) 32431 */ 32432 _getDimension = function(t, p, cs) { 32433 if ((t.nodeName + "").toLowerCase() === "svg") { //Chrome no longer supports offsetWidth/offsetHeight on SVG elements. 32434 return (cs || _getComputedStyle(t))[p] || 0; 32435 } else if (t.getCTM && _isSVG(t)) { 32436 return t.getBBox()[p] || 0; 32437 } 32438 var v = parseFloat((p === "width") ? t.offsetWidth : t.offsetHeight), 32439 a = _dimensions[p], 32440 i = a.length; 32441 cs = cs || _getComputedStyle(t, null); 32442 while (--i > -1) { 32443 v -= parseFloat( _getStyle(t, "padding" + a[i], cs, true) ) || 0; 32444 v -= parseFloat( _getStyle(t, "border" + a[i] + "Width", cs, true) ) || 0; 32445 } 32446 return v; 32447 }, 32448 32449 // @private Parses position-related complex strings like "top left" or "50px 10px" or "70% 20%", etc. which are used for things like transformOrigin or backgroundPosition. Optionally decorates a supplied object (recObj) with the following properties: "ox" (offsetX), "oy" (offsetY), "oxp" (if true, "ox" is a percentage not a pixel value), and "oxy" (if true, "oy" is a percentage not a pixel value) 32450 _parsePosition = function(v, recObj) { 32451 if (v === "contain" || v === "auto" || v === "auto auto") { //note: Firefox uses "auto auto" as default whereas Chrome uses "auto". 32452 return v + " "; 32453 } 32454 if (v == null || v === "") { 32455 v = "0 0"; 32456 } 32457 var a = v.split(" "), 32458 x = (v.indexOf("left") !== -1) ? "0%" : (v.indexOf("right") !== -1) ? "100%" : a[0], 32459 y = (v.indexOf("top") !== -1) ? "0%" : (v.indexOf("bottom") !== -1) ? "100%" : a[1], 32460 i; 32461 if (a.length > 3 && !recObj) { //multiple positions 32462 a = v.split(", ").join(",").split(","); 32463 v = []; 32464 for (i = 0; i < a.length; i++) { 32465 v.push(_parsePosition(a[i])); 32466 } 32467 return v.join(","); 32468 } 32469 if (y == null) { 32470 y = (x === "center") ? "50%" : "0"; 32471 } else if (y === "center") { 32472 y = "50%"; 32473 } 32474 if (x === "center" || (isNaN(parseFloat(x)) && (x + "").indexOf("=") === -1)) { //remember, the user could flip-flop the values and say "bottom center" or "center bottom", etc. "center" is ambiguous because it c
32474ould be used to describe horizontal or vertical, hence the isNaN(). If there's an "=" sign in the value, it's relative. 32475 x = "50%"; 32476 } 32477 v = x + " " + y + ((a.length > 2) ? " " + a[2] : ""); 32478 if (recObj) { 32479 recObj.oxp = (x.indexOf("%") !== -1); 32480 recObj.oyp = (y.indexOf("%") !== -1); 32481 recObj.oxr = (x.charAt(1) === "="); 32482 recObj.oyr = (y.charAt(1) === "="); 32483 recObj.ox = parseFloat(x.replace(_NaNExp, "")); 32484 recObj.oy = parseFloat(y.replace(_NaNExp, "")); 32485 recObj.v = v; 32486 } 32487 return recObj || v; 32488 }, 32489 32490 /** 32491 * @private Takes an ending value (typically a string, but can be a number) and a starting value and returns the change between the two, looking for relative value indicators like += and -= and it also ignores suffixes (but make sure the ending value starts with a number or +=/-= and that the starting value is a NUMBER!) 32492 * @param {(number|string)} e End value which is typically a string, but could be a number 32493 * @param {(number|string)} b Beginning value which is typically a string but could be a number 32494 * @return {number} Amount of change between the beginning and ending values (relative values that have a "+=" or "-=" are recognized) 32495 */ 32496 _parseChange = function(e, b) { 32497 if (typeof(e) === "function") { 32498 e = e(_index, _target); 32499 } 32500 return (typeof(e) === "string" && e.charAt(1) === "=") ? parseInt(e.charAt(0) + "1", 10) * parseFloat(e.substr(2)) : (parseFloat(e) - parseFloat(b)) || 0; 32501 }, 32502 32503 /** 32504 * @private Takes a value and a default number, checks if the value is relative, null, or numeric and spits back a normalized number accordingly. Primarily used in the _parseTransform() function. 32505 * @param {Object} v Value to be parsed 32506 * @param {!number} d Default value (which is also used for relative calculations if "+=" or "-=" is found in the first parameter) 32507 * @return {number} Parsed value 32508 */ 32509 _parseVal = function(v, d) { 32510 if (typeof(v) === "function") { 32511 v = v(_index, _target); 32512 } 32513 return (v == null) ? d : (typeof(v) === "string" && v.charAt(1) === "=") ? parseInt(v.charAt(0) + "1", 10) * parseFloat(v.substr(2)) + d : parseFloat(v) || 0; 32514 }, 32515 32516 /** 32517 * @private Translates strings like "40deg" or "40" or 40rad" or "+=40deg" or "270_short" or "-90_cw" or "+=45_ccw" to a numeric radian angle. Of course a starting/default value must be fed in too so that relative values can be calculated properly. 32518 * @param {Object} v Value to be parsed 32519 * @param {!number} d Default value (which is also used for relative calculations if "+=" or "-=" is found in the first parameter) 32520 * @param {string=} p property name for directionalEnd (optional - only used when the parsed value is directional ("_short", "_cw", or "_ccw" suffix). We need a way to store the uncompensated value so that at the end of the tween, we set it to exactly what was requested with no directional compensation). Property name would be "rotation", "rotationX", or "rotationY" 32521 * @param {Object=} directionalEnd An object that will store the raw end values for directional angles ("_short", "_cw", or "_ccw" suffix). We need a way to store the uncompensated value so that at the end of the tween, we set it to exactly what was requested with no directional compensation. 32522 * @return {number} parsed angle in radians 32523 */ 32524 _parseAngle = function(v, d, p, directionalEnd) { 32525 var min = 0.000001, 32526 cap, split, dif, result, isRelative; 32527 if (typeof(v) === "function") { 32528 v = v(_index, _target); 32529 } 32530 if (v == null) { 32531 result = d; 32532 } else if (typeof(v) === "number") { 32533 result = v; 32534 } else { 32535 cap = 360; 32536 split = v.split("_"); 32537 isRelative = (v.charAt(1) === "="); 32538 dif = (isRelative ? parseInt(v.charAt(0) + "1", 10) * parseFloat(split[0].substr(2)) : parseFloat(split[0])) * ((v.indexOf("rad") === -1) ? 1 : _RAD2DEG) - (isRelative ? 0 : d); 32539 if (split.length) { 32540 if (directionalEnd) { 32541 directionalEnd[p] = d + dif; 32542 } 32543 if (v.indexOf("short") !== -1) { 32544 dif = dif % cap; 32545 if (dif !== dif % (cap / 2)) { 32546 dif = (dif < 0) ? dif + cap : dif - cap; 32547 } 32548 } 32549 if (v.indexOf("_cw") !== -1 && dif < 0) { 32550 dif = ((dif + cap * 9999999999) % cap) - ((dif / cap) | 0) * cap; 32551 } else if (v.indexOf("ccw") !== -1 && dif > 0) { 32552 dif = ((dif - cap * 9999999999) % cap) - ((dif / cap) | 0) * cap; 32553 } 32554 } 32555 result = d + dif; 32556 } 32557 if (result < min && result > -min) { 32558 result = 0; 32559 } 32560 return result; 32561 }, 32562 32563 _colorLookup = {aqua:[0,255,255], 32564 lime:[0,255,0], 32565 silver:[192,192,192], 32566 black:[0,0,0], 32567 maroon:[128,0,0], 32568 teal:[0,128,128], 32569 blue:[0,0,255], 32570 navy:[0,0,128], 32571 white:[255,255,255], 32572 fuchsia:[255,0,255], 32573 olive:[128,128,0], 32574 yellow:[255,255,0], 32575 orange:[255,165,0], 32576 gray:[128,128,128], 32577 purple:[128,0,128], 32578 green:[0,128,0], 32579 red:[255,0,0], 32580 pink:[255,192,203], 32581 cyan:[0,255,255], 32582 transparent:[255,255,255,0]}, 32583 32584 _hue = function(h, m1, m2) { 32585 h = (h < 0) ? h + 1 : (h > 1) ? h - 1 : h; 32586 return ((((h * 6 < 1) ? m1 + (m2 - m1) * h * 6 : (h < 0.5) ? m2 : (h * 3 < 2) ? m1 + (m2 - m1) * (2 / 3 - h) * 6 : m1) * 255) + 0.5) | 0; 32587 }, 32588 32589 /** 32590 * @private Parses a color (like #9F0, #FF9900, rgb(255,51,153) or hsl(108, 50%, 10%)) into an array with 3 elements for red, green, and blue or if toHSL parameter is true, it will populate the array with hue, saturation, and lightness values. If a relative value is found in an hsl() or hsla() string, it will preserve those relative prefixes and all the values in the array will be strings instead of numbers (in all other cases it will be populated with numbers). 32591 * @param {(string|number)} v The value the should be parsed which could be a string like #9F0 or rgb(255,102,51) or rgba(255,0,0,0.5) or it could be a number like 0xFF00CC or even a named color like red, blue, purple, etc. 32592 * @param {(boolean)} toHSL If true, an hsl() or hsla() value will be returned instead of rgb() or rgba() 32593 * @return {Array.<number>} An array containing red, green, and blue (and optionally alpha) in that order, or if the toHSL parameter was true, the array will contain hue, saturation and lightness (and optionally alpha) in that order. Always numbers unless there's a relative prefix found in an hsl() or hsla() string and toHSL is true. 32594 */ 32595 _parseColor = CSSPlugin.parseColor = function(v, toHSL) { 32596 var a, r, g, b, h, s, l, max, min, d, wasHSL; 32597 if (!v) { 32598 a = _colorLookup.black; 32599 } else if (typeof(v) === "number") { 32600 a = [v >> 16, (v >> 8) & 255, v & 255]; 32601 } else { 32602 if (v.charAt(v.length - 1) === ",") { //sometimes a trailing comma is included and we should chop it off (typically from a comma-delimited list of values like a textShadow:"2px 2px 2px blue, 5px 5px 5px rgb(255,0,0)" - in this example "blue," has a trailing comma. We could strip it out inside parseComplex() but we'd need to do it to the beginning and ending values plus it wouldn't provide protection from other potential scenarios like if the user passes in a similar value. 32603 v = v.substr(0, v.length - 1); 32604 } 32605 if (_colorLookup[v]) { 32606 a = _colorLookup[v]; 32607 } else if (v.charAt(0) === "#") { 32608 if (v.length === 4) { //for shorthand like #9F0 32609 r = v.charAt(1); 32610 g = v.charAt(2); 32611 b = v.charAt(3); 32612 v = "#" + r + r + g + g + b + b; 32613 } 32614 v = parseInt(v.substr(1), 16); 32615 a = [v >> 16, (v >> 8) & 255, v & 255]; 32616 } else if (v.substr(0, 3) === "hsl") { 32617 a = wasHSL = v.match(_numExp); 32618 if (!toHSL) { 32619 h = (Number(a[0]) % 360) / 360;
32620 s = Number(a[1]) / 100; 32621 l = Number(a[2]) / 100; 32622 g = (l <= 0.5) ? l * (s + 1) : l + s - l * s; 32623 r = l * 2 - g; 32624 if (a.length > 3) { 32625 a[3] = Number(a[3]); 32626 } 32627 a[0] = _hue(h + 1 / 3, r, g); 32628 a[1] = _hue(h, r, g); 32629 a[2] = _hue(h - 1 / 3, r, g); 32630 } else if (v.indexOf("=") !== -1) { //if relative values are found, just return the raw strings with the relative prefixes in place. 32631 return v.match(_relNumExp); 32632 } 32633 } else { 32634 a = v.match(_numExp) || _colorLookup.transparent; 32635 } 32636 a[0] = Number(a[0]); 32637 a[1] = Number(a[1]); 32638 a[2] = Number(a[2]); 32639 if (a.length > 3) { 32640 a[3] = Number(a[3]); 32641 } 32642 } 32643 if (toHSL && !wasHSL) { 32644 r = a[0] / 255; 32645 g = a[1] / 255; 32646 b = a[2] / 255; 32647 max = Math.max(r, g, b); 32648 min = Math.min(r, g, b); 32649 l = (max + min) / 2; 32650 if (max === min) { 32651 h = s = 0; 32652 } else { 32653 d = max - min; 32654 s = l > 0.5 ? d / (2 - max - min) : d / (max + min); 32655 h = (max === r) ? (g - b) / d + (g < b ? 6 : 0) : (max === g) ? (b - r) / d + 2 : (r - g) / d + 4; 32656 h *= 60; 32657 } 32658 a[0] = (h + 0.5) | 0; 32659 a[1] = (s * 100 + 0.5) | 0; 32660 a[2] = (l * 100 + 0.5) | 0; 32661 } 32662 return a; 32663 }, 32664 _formatColors = function(s, toHSL) { 32665 var colors = s.match(_colorExp) || [], 32666 charIndex = 0, 32667 parsed = "", 32668 i, color, temp; 32669 if (!colors.length) { 32670 return s; 32671 } 32672 for (i = 0; i < colors.length; i++) { 32673 color = colors[i]; 32674 temp = s.substr(charIndex, s.indexOf(color, charIndex)-charIndex); 32675 charIndex += temp.length + color.length; 32676 color = _parseColor(color, toHSL); 32677 if (color.length === 3) { 32678 color.push(1); 32679 } 32680 parsed += temp + (toHSL ? "hsla(" + color[0] + "," + color[1] + "%," + color[2] + "%," + color[3] : "rgba(" + color.join(",")) + ")"; 32681 } 32682 return parsed + s.substr(charIndex); 32683 }, 32684 _colorExp = "(?:\\b(?:(?:rgb|rgba|hsl|hsla)\\(.+?\\))|\\B#(?:[0-9a-f]{3}){1,2}\\b"; //we'll dynamically build this Regular Expression to conserve file size. After building it, it will be able to find rgb(), rgba(), # (hexadecimal), and named color values like red, blue, purple, etc. 32685 32686 for (p in _colorLookup) { 32687 _colorExp += "|" + p + "\\b"; 32688 } 32689 _colorExp = new RegExp(_colorExp+")", "gi"); 32690 32691 CSSPlugin.colorStringFilter = function(a) { 32692 var combined = a[0] + " " + a[1], 32693 toHSL; 32694 if (_colorExp.test(combined)) { 32695 toHSL = (combined.indexOf("hsl(") !== -1 || combined.indexOf("hsla(") !== -1); 32696 a[0] = _formatColors(a[0], toHSL); 32697 a[1] = _formatColors(a[1], toHSL); 32698 } 32699 _colorExp.lastIndex = 0; 32700 }; 32701 32702 if (!__WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].defaultStringFilter) { 32703 __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].defaultStringFilter = CSSPlugin.colorStringFilter; 32704 } 32705 32706 /** 32707 * @private Returns a formatter function that handles taking a string (or number in some cases) and returning a consistently formatted one in terms of delimiters, quantity of values, etc. For example, we may get boxShadow values defined as "0px red" or "0px 0px 10px rgb(255,0,0)" or "0px 0px 20px 20px #F00" and we need to ensure that what we get back is described with 4 numbers and a color. This allows us to feed it into the _parseComplex() method and split the values up appropriately. The neat thing about this _getFormatter() function is that the dflt defines a pattern as well as a default, so for example, _getFormatter("0px 0px 0px 0px #777", true) not only sets the default as 0px for all distances and #777 for the color, but also sets the pattern such that 4 numbers and a color will always get returned. 32708 * @param {!string} dflt The default value and pattern to follow. So "0px 0px 0px 0px #777" will ensure that 4 numbers and a color will always get returned. 32709 * @param {boolean=} clr If true, the values should be searched for color-related data. For example, boxShadow values typically contain a color whereas borderRadius don't. 32710 * @param {boolean=} collapsible If true, the value is a top/left/right/bottom style one that acts like margin or padding, where if only one value is received, it's used for all 4; if 2 are received, the first is duplicated for 3rd (bottom) and the 2nd is duplicated for the 4th spot (left), etc. 32711 * @return {Function} formatter function 32712 */ 32713 var _getFormatter = function(dflt, clr, collapsible, multi) { 32714 if (dflt == null) { 32715 return function(v) {return v;}; 32716 } 32717 var dColor = clr ? (dflt.match(_colorExp) || [""])[0] : "", 32718 dVals = dflt.split(dColor).join("").match(_valuesExp) || [], 32719 pfx = dflt.substr(0, dflt.indexOf(dVals[0])), 32720 sfx = (dflt.charAt(dflt.length - 1) === ")") ? ")" : "", 32721 delim = (dflt.indexOf(" ") !== -1) ? " " : ",", 32722 numVals = dVals.length, 32723 dSfx = (numVals > 0) ? dVals[0].replace(_numExp, "") : "", 32724 formatter; 32725 if (!numVals) { 32726 return function(v) {return v;}; 32727 } 32728 if (clr) { 32729 formatter = function(v) { 32730 var color, vals, i, a; 32731 if (typeof(v) === "number") { 32732 v += dSfx; 32733 } else if (multi && _commasOutsideParenExp.test(v)) { 32734 a = v.replace(_commasOutsideParenExp, "|").split("|"); 32735 for (i = 0; i < a.length; i++) { 32736 a[i] = formatter(a[i]); 32737 } 32738 return a.join(","); 32739 } 32740 color = (v.match(_colorExp) || [dColor])[0]; 32741 vals = v.split(color).join("").match(_valuesExp) || []; 32742 i = vals.length; 32743 if (numVals > i--) { 32744 while (++i < numVals) { 32745 vals[i] = collapsible ? vals[(((i - 1) / 2) | 0)] : dVals[i]; 32746 } 32747 } 32748 return pfx + vals.join(delim) + delim + color + sfx + (v.indexOf("inset") !== -1 ? " inset" : ""); 32749 }; 32750 return formatter; 32751 32752 } 32753 formatter = function(v) { 32754 var vals, a, i; 32755 if (typeof(v) === "number") { 32756 v += dSfx; 32757 } else if (multi && _commasOutsideParenExp.test(v)) { 32758 a = v.replace(_commasOutsideParenExp, "|").split("|"); 32759 for (i = 0; i < a.length; i++) { 32760 a[i] = formatter(a[i]); 32761 } 32762 return a.join(","); 32763 } 32764 vals = v.match(_valuesExp) || []; 32765 i = vals.length; 32766 if (numVals > i--) { 32767 while (++i < numVals) { 32768 vals[i] = collapsible ? vals[(((i - 1) / 2) | 0)] : dVals[i]; 32769 } 32770 } 32771 return pfx + vals.join(delim) + sfx; 32772 }; 32773 return formatter; 32774 }, 32775 32776 /** 32777 * @private returns a formatter function that's used for edge-related values like marginTop, marginLeft, paddingBottom, paddingRight, etc. Just pass a comma-delimited list of property names related to the edges. 32778 * @param {!string} props a comma-delimited list of property names in order from top to left, like "marginTop,marginRight,marginBottom,marginLeft" 32779 * @return {Function} a formatter function 32780 */ 32781 _getEdgeParser = function(props) { 32782 props = props.split(","); 32783 return function(t, e, p, cssp, pt, plugin, vars) { 32784 var a = (e + "").split(" "), 32785 i; 32786 vars = {}; 32787 for (i = 0; i < 4; i++) { 32788 vars[props[i]] = a[i] = a[i] || a[(((i - 1) / 2) >> 0)]; 32789 } 32790 return cssp.parse(t, vars, pt, plugin); 32791 }; 32792 }, 32793 32794 // @private used when other plugins must tween values first, like BezierPlugin or ThrowPropsPlugin, etc. That plugin's setRatio() gets called first so that the values are updated, and then we loop through the MiniPropTweens which handle copying the values into their appropriate slots so that they can then be applied correctly in the main CSSPlugin setRatio() method. Remember, we typically create a proxy object that has a bunch of uniquely-named properties that we feed to the sub-plugin and it does its magic normally, and then we must interpret those values and apply them to the css because often numbers must get combined/concatenated, suffixes added, etc. to work with css, like boxShadow could have 4 values plus a color. 32795 _setPluginRatio = _internals._setPluginRatio = function(v) { 32796 this.plugin.setRatio(v); 32797 var d = this.data, 32798 proxy = d.proxy, 32799 mpt = d.firstMPT, 32800 min = 0.000001, 32801 val, pt, i, str, p; 32802 while (mpt) { 32803 val = proxy[mpt.v]; 32804 if (mpt.r) { 32805 val = mpt.r(val); 32806 } else if (val < min && val > -min) { 32807 val = 0; 32808 } 32809 mpt.t[mpt.p] = val; 32810 mpt = mpt._next; 32811 } 32812 if (d.autoRotate) { 32813 d.autoRotate.rotation = d.mod ? d.mod.call(this._tween, proxy.rotation, this.t, this._tween) : proxy.rotation; //special case for ModifyPlugin to hook into an auto-rotating bezier 32814 } 32815 //at the end, we must set the CSSPropTween's "e" (end) value dynamically here because that's what is used in the final setRatio() method. Same for "b" at the beginning. 32816 if (v === 1 || v === 0) { 32817 mpt = d.firstMPT; 32818 p = (v === 1) ? "e" : "b"; 32819 while (mpt) { 32820 pt = mpt.t; 32821 if (!pt.type) { 32822 pt[p] = pt.s + pt.xs0; 32823 } else if (pt.type === 1) { 32824 str = pt.xs0 + pt.s + pt.xs1; 32825 for (i = 1; i < pt.l; i++) {
32826 str += pt["xn"+i] + pt["xs"+(i+1)]; 32827 } 32828 pt[p] = str; 32829 } 32830 mpt = mpt._next; 32831 } 32832 } 32833 }, 32834 32835 /** 32836 * @private @constructor Used by a few SpecialProps to hold important values for proxies. For example, _parseToProxy() creates a MiniPropTween instance for each property that must get tweened on the proxy, and we record the original property name as well as the unique one we create for the proxy, plus whether or not the value needs to be rounded plus the original value. 32837 * @param {!Object} t target object whose property we're tweening (often a CSSPropTween) 32838 * @param {!string} p property name 32839 * @param {(number|string|object)} v value 32840 * @param {MiniPropTween=} next next MiniPropTween in the linked list 32841 * @param {boolean=} r if true, the tweened value should be rounded to the nearest integer 32842 */ 32843 MiniPropTween = function(t, p, v, next, r) { 32844 this.t = t; 32845 this.p = p; 32846 this.v = v; 32847 this.r = r; 32848 if (next) { 32849 next._prev = this; 32850 this._next = next; 32851 } 32852 }, 32853 32854 /** 32855 * @private Most other plugins (like BezierPlugin and ThrowPropsPlugin and others) can only tween numeric values, but CSSPlugin must accommodate special values that have a bunch of extra data (like a suffix or strings between numeric values, etc.). For example, boxShadow has values like "10px 10px 20px 30px rgb(255,0,0)" which would utterly confuse other plugins. This method allows us to split that data apart and grab only the numeric data and attach it to uniquely-named properties of a generic proxy object ({}) so that we can feed that to virtually any plugin to have the numbers tweened. However, we must also keep track of which properties from the proxy go with which CSSPropTween values and instances. So we create a linked list of MiniPropTweens. Each one records a target (the original CSSPropTween), property (like "s" or "xn1" or "xn2") that we're tweening and the unique property name that was used for the proxy (like "boxShadow_xn1" and "boxShadow_xn2") and whether or not they need to be rounded. That way, in the _setPluginRatio() method we can simply copy the values over from the proxy to the CSSPropTween instance(s). Then, when the main CSSPlugin setRatio() method runs and applies the CSSPropTween values accordingly, they're updated nicely. So the external plugin tweens the numbers, _setPluginRatio() copies them over, and setRatio() acts normally, applying css-specific values to the element. 32856 * This method returns an object that has the following properties:
32857 * - proxy: a generic object containing the starting values for all the properties that will be tweened by the external plugin. This is what we feed to the external _onInitTween() as the target 32858 * - end: a generic object containing the ending values for all the properties that will be tweened by the external plugin. This is what we feed to the external plugin's _onInitTween() as the destination values 32859 * - firstMPT: the first MiniPropTween in the linked list 32860 * - pt: the first CSSPropTween in the linked list that was created when parsing. If shallow is true, this linked list will NOT attach to the one passed into the _parseToProxy() as the "pt" (4th) parameter. 32861 * @param {!Object} t target object to be tweened 32862 * @param {!(Object|string)} vars the object containing the information about the tweening values (typically the end/destination values) that should be parsed 32863 * @param {!CSSPlugin} cssp The CSSPlugin instance 32864 * @param {CSSPropTween=} pt the next CSSPropTween in the linked list 32865 * @param {TweenPlugin=} plugin the external TweenPlugin instance that will be handling tweening the numeric values 32866 * @param {boolean=} shallow if true, the resulting linked list from the parse will NOT be attached to the CSSPropTween that was passed in as the "pt" (4th) parameter. 32867 * @return An object containing the following properties: proxy, end, firstMPT, and pt (see above for descriptions) 32868 */ 32869 _parseToProxy = _internals._parseToProxy = function(t, vars, cssp, pt, plugin, shallow) { 32870 var bpt = pt, 32871 start = {}, 32872 end = {}, 32873 transform = cssp._transform, 32874 oldForce = _forcePT, 32875 i, p, xp, mpt, firstPT; 32876 cssp._transform = null; 32877 _forcePT = vars; 32878 pt = firstPT = cssp.parse(t, vars, pt, plugin); 32879 _forcePT = oldForce; 32880 //break off from the linked list so the new ones are isolated. 32881 if (shallow) { 32882 cssp._transform = transform; 32883 if (bpt) { 32884 bpt._prev = null; 32885 if (bpt._prev) { 32886 bpt._prev._next = null; 32887 } 32888 } 32889 } 32890 while (pt && pt !== bpt) { 32891 if (pt.type <= 1) { 32892 p = pt.p; 32893 end[p] = pt.s + pt.c; 32894 start[p] = pt.s; 32895 if (!shallow) { 32896 mpt = new MiniPropTween(pt, "s", p, mpt, pt.r); 32897 pt.c = 0; 32898 } 32899 if (pt.type === 1) { 32900 i = pt.l; 32901 while (--i > 0) { 32902 xp = "xn" + i; 32903 p = pt.p + "_" + xp; 32904 end[p] = pt.data[xp]; 32905 start[p] = pt[xp]; 32906 if (!shallow) { 32907 mpt = new MiniPropTween(pt, xp, p, mpt, pt.rxp[xp]); 32908 } 32909 } 32910 } 32911 } 32912 pt = pt._next; 32913 } 32914 return {proxy:start, end:end, firstMPT:mpt, pt:firstPT}; 32915 }, 32916 32917 32918 32919 /** 32920 * @constructor Each property that is tweened has at least one CSSPropTween associated with it. These instances store important information like the target, property, starting value, amount of change, etc. They can also optionally have a number of "extra" strings and numeric values named xs1, xn1, xs2, xn2, xs3, xn3, etc. where "s" indicates string and "n" indicates number. These can be pieced together in a complex-value tween (type:1) that has alternating types of data like a string, number, string, number, etc. For example, boxShadow could be "5px 5px 8px rgb(102, 102, 51)". In that value, there are 6 numbers that may need to tween and then pieced back together into a string again with spaces, suffixes, etc. xs0 is special in that it stores the suffix for standard (type:0) tweens, -OR- the first string (prefix) in a complex-value (type:1) CSSPropTween -OR- it can be the non-tweening value in a type:-1 CSSPropTween. We do this to conserve memory. 32921 * CSSPropTweens have the following optional properties as well (not defined through the constructor): 32922 * - l: Length in terms of the number of extra properties that the CSSPropTween has (default: 0). For example, for a boxShadow we may need to tween 5 numbers in which case l would be 5; Keep in mind that the start/end values for the first number that's tweened are always stored in the s and c properties to conserve memory. All additional values thereafter are stored in xn1, xn2, etc. 32923 * - xfirst: The first instance of any sub-CSSPropTweens that are tweening properties of this instance. For example, we may split up a boxShadow tween so that there's a main CSSPropTween of type:1 that has various xs* and xn* values associated with the h-shadow, v-shadow, blur, color, etc. Then we spawn a CSSPropTween for each of those that has a higher priority and runs BEFORE the main CSSPropTween so that the values are all set by the time it needs to re-assemble them. The xfirst gives us an easy way to identify the first one in that chain which typically ends at the main one (because they're all prepende to the linked list) 32924 * - plugin: The TweenPlugin instance that will handle the tweening of any complex values. For example, sometimes we don't want to use normal subt
32924weens (like xfirst refers to) to tween the values - we might want ThrowPropsPlugin or BezierPlugin some other plugin to do the actual tweening, so we create a plugin instance and store a reference here. We need this reference so that if we get a request to round values or disable a tween, we can pass along that request. 32925 * - data: Arbitrary data that needs to be stored with the CSSPropTween. Typically if we're going to have a plugin handle the tweening of a complex-value tween, we create a generic object that stores the END values that we're tweening to and the CSSPropTween's xs1, xs2, etc. have the starting values. We store that object as data. That way, we can simply pass that object to the plugin and use the CSSPropTween as the target. 32926 * - setRatio: Only used for type:2 tweens that require custom functionality. In this case, we call the CSSPropTween's setRatio() method and pass the ratio each time the tween updates. This isn't quite as efficient as doing things directly in the CSSPlugin's setRatio() method, but it's very convenient and flexible. 32927 * @param {!Object} t Target object whose property will be tweened. Often a DOM element, but not always. It could be anything. 32928 * @param {string} p Property to tween (name). For example, to tween element.width, p would be "width". 32929 * @param {number} s Starting numeric value 32930 * @param {number} c Change in numeric value over the course of the entire tween. For example, if element.width starts at 5 and should end at 100, c would be 95. 32931 * @param {CSSPropTween=} next The next CSSPropTween in the linked list. If one is defined, we will define its _prev as the new instance, and the new instance's _next will be pointed at it. 32932 * @param {number=} type The type of CSSPropTween where -1 = a non-tweening value, 0 = a standard simple tween, 1 = a complex value (like one that has multiple numbers in a comma- or space-delimited string like border:"1px solid red"), and 2 = one that uses a custom setRatio function that does all of the work of applying the values on each update. 32933 * @param {string=} n Name of the property that should be used for overwriting purposes which is typically the same as p but not always. For example, we may need to create a subtween for the 2nd part of a "clip:rect(...)" tween in which case "p" might be xs1 but "n" is still "clip" 32934 * @param {boolean=} r If true, the value(s) should be rounded 32935 * @param {number=} pr Priority in the linked list order. Higher priority CSSPropTweens will be updated before lower priority ones. The default priority is 0. 32936 * @param {string=} b Beginning value. We store this to ensure that it is EXACTLY what it was when the tween began without any risk of interpretation issues. 32937 * @param {string=} e Ending value. We store this to ensure that it is EXACTLY what the user defined at the end of the tween without any risk of interpretation issues. 32938 */ 32939 CSSPropTween = _internals.CSSPropTween = function(t, p, s, c, next, type, n, r, pr, b, e) { 32940 this.t = t; //target 32941 this.p = p; //property 32942 this.s = s; //starting value 32943 this.c = c; //change value 32944 this.n = n || p; //name that this CSSPropTween should be associated to (usually the same as p, but not always - n is what overwriting looks at) 32945 if (!(t instanceof CSSPropTween)) { 32946 _overwriteProps.push(this.n); 32947 } 32948 this.r = !r ? r : (typeof(r) === "function") ? r : Math.round; //round (boolean) 32949 this.type = type || 0; //0 = normal tween, -1 = non-tweening (in which case xs0 will be applied to the target's property, like tp.t[tp.p] = tp.xs0), 1 = complex-value SpecialProp, 2 = custom setRatio() that does all the work 32950 if (pr) { 32951 this.pr = pr; 32952 _hasPriority = true; 32953 } 32954 this.b = (b === undefined) ? s : b; 32955 this.e = (e === undefined) ? s + c : e; 32956 if (next) { 32957 this._next = next; 32958 next._prev = this; 32959 } 32960 }, 32961 32962 _addNonTweeningNumericPT = function(target, prop, start, end, next, overwriteProp) { //cleans up some code redundancies and helps minification. Just a fast way to add a NUMERIC non-tweening CSSPropTween
32963 var pt = new CSSPropTween(target, prop, start, end - start, next, -1, overwriteProp); 32964 pt.b = start; 32965 pt.e = pt.xs0 = end; 32966 return pt; 32967 }, 32968 32969 /** 32970 * Takes a target, the beginning value and ending value (as strings) and parses them into a CSSPropTween (possibly with child CSSPropTweens) that accommodates multiple numbers, colors, comma-delimited values, etc. For example: 32971 * sp.parseComplex(element, "boxShadow", "5px 10px 20px rgb(255,102,51)", "0px 0px 0px red", true, "0px 0px 0px rgb(0,0,0,0)", pt); 32972 * It will walk through the beginning and ending values (which should be in the same format with the same number and type of values) and figure out which parts are numbers, what strings separate the numeric/tweenable values, and then create the CSSPropTweens accordingly. If a plugin is defined, no child CSSPropTweens will be created. Instead, the ending values will be stored in the "data" property of the returned CSSPropTween like: {s:-5, xn1:-10, xn2:-20, xn3:255, xn4:0, xn5:0} so that it can be fed to any other plugin and it'll be plain numeric tweens but the recomposition of the complex value will be handled inside CSSPlugin's setRatio(). 32973 * If a setRatio is defined, the type of the CSSPropTween will be set to 2 and recomposition of the values will be the responsibility of that method. 32974 * 32975 * @param {!Object} t Target whose property will be tweened 32976 * @param {!string} p Property that will be tweened (its name, like "left" or "backgroundColor" or "boxShadow") 32977 * @param {string} b Beginning value 32978 * @param {string} e Ending value 32979 * @param {boolean} clrs If true, the value could contain a color value like "rgb(255,0,0)" or "#F00" or "red". The default is false, so no colors will be recognized (a performance optimization) 32980 * @param {(string|number|Object)} dflt The default beginning value that should be used if no valid beginning value is defined or if the number of values inside the complex beginning and ending values don't match 32981 * @param {?CSSPropTween} pt CSSPropTween instance that is the current head of the linked list (we'll prepend to this). 32982 * @param {number=} pr Priority in the linked list order. Higher priority properties will be updated before lower priority ones. The default priority is 0. 32983 * @param {TweenPlugin=} plugin If a plugin should handle the tweening of extra properties, pass the plugin instance here. If one is defined, then NO subtweens will be created for any extra properties (the properties will be created - just not additional CSSPropTween instances to tween them) because the plugin is expected to do so. However, the end values WILL be populated in the "data" property, like {s:100, xn1:50, xn2:300} 32984 * @param {function(number)=} setRatio If values should be set in a custom function instead of being pieced together in a type:1 (complex-value) CSSPropTween, define that custom function here. 32985 * @return {CSSPropTween} The first CSSPropTween in the linked list which includes the new one(s) added by the parseComplex() call. 32986 */ 32987 _parseComplex = CSSPlugin.parseComplex = function(t, p, b, e, clrs, dflt, pt, pr, plugin, setRatio) { 32988 //DEBUG: _log("parseComplex: "+p+", b: "+b+", e: "+e); 32989 b = b || dflt || ""; 32990 if (typeof(e) === "function") { 32991 e = e(_index, _target); 32992 } 32993 pt = new CSSPropTween(t, p, 0, 0, pt, (setRatio ? 2 : 1), null, false, pr, b, e); 32994 e += ""; //ensures it's a string 32995 if (clrs && _colorExp.test(e + b)) { //if colors are found, normalize the formatting to rgba() or hsla(). 32996 e = [b, e]; 32997 CSSPlugin.colorStringFilter(e); 32998 b = e[0]; 32999 e = e[1]; 33000 } 33001 var ba = b.split(", ").join(",").split(" "), //beginning array 33002 ea = e.split(", ").join(",").split(" "), //ending array 33003 l = ba.length, 33004 autoRound = (_autoRound !== false), 33005 i, xi, ni, bv, ev, bnums, enums, bn, hasAlpha, temp, cv, str, useHSL; 33006 if (e.indexOf(",") !== -1 || b.indexOf(",") !== -1) { 33007 if ((e + b).indexOf("rgb") !== -1 || (e + b).indexOf("hsl") !== -1) { //keep rgb(), rgba(), hsl(), and hsla() values together! (remember, we're splitting on spaces) 33008 ba = ba.join(" ").replace(_commasOutsideParenExp, ", ").split(" "); 33009 ea = ea.join(" ").replace(_commasOutsideParenExp, ", ").split(" "); 33010 } else { 33011 ba = ba.join(" ").split(",").join(", ").split(" "); 33012 ea = ea.join(" ").split(",").join(", ").split(" "); 33013 } 33014 l = ba.length; 33015 } 33016 if (l !== ea.length) { 33017 //DEBUG: _log("mismatched formatting detected on " + p + " (" + b + " vs " + e + ")"); 33018 ba = (dflt || "").split(" "); 33019 l = ba.length; 33020 } 33021 pt.plugin = plugin; 33022 pt.setRatio = setRatio; 33023 _colorExp.lastIndex = 0; 33024 for (i = 0; i < l; i++) { 33025 bv = ba[i]; 33026 ev = ea[i] + ""; 33027 bn = parseFloat(bv); 33028 //if the value begins with a number (most common). It's fine if it has a suffix like px 33029 if (bn || bn === 0) { 33030 pt.appendXtra("", bn, _parseChange(ev, bn), ev.replace(_relNumExp, ""), (autoRound && ev.indexOf("px") !== -1) ? Math.round : false, true); 33031 33032 //if the value is a color 33033 } else if (clrs && _colorExp.test(bv)) { 33034 str = ev.indexOf(")") + 1; 33035 str = ")" + (str ? ev.substr(str) : ""); //if there's a comma or ) at the end, retain it. 33036 useHSL = (ev.indexOf("hsl") !== -1 && _supportsOpacity); 33037 temp = ev; //original string value so we can look for any prefix later. 33038 bv = _parseColor(bv, useHSL); 33039 ev = _parseColor(ev, useHSL); 33040 hasAlpha = (bv.length + ev.length > 6); 33041 if (hasAlpha && !_supportsOpacity && ev[3] === 0) { //older versions of IE don't support rgba(), so if the destination alpha is 0, just use "transparent" for the end color 33042 pt["xs" + pt.l] += pt.l ? " transparent" : "transparent";
33043 pt.e = pt.e.split(ea[i]).join("transparent"); 33044 } else { 33045 if (!_supportsOpacity) { //old versions of IE don't support rgba(). 33046 hasAlpha = false; 33047 } 33048 if (useHSL) { 33049 pt.appendXtra(temp.substr(0, temp.indexOf("hsl")) + (hasAlpha ? "hsla(" : "hsl("), bv[0], _parseChange(ev[0], bv[0]), ",", false, true) 33050 .appendXtra("", bv[1], _parseChange(ev[1], bv[1]), "%,", false) 33051 .appendXtra("", bv[2], _parseChange(ev[2], bv[2]), (hasAlpha ? "%," : "%" + str), false); 33052 } else { 33053 pt.appendXtra(temp.substr(0, temp.indexOf("rgb")) + (hasAlpha ? "rgba(" : "rgb("), bv[0], ev[0] - bv[0], ",", Math.round, true) 33054 .appendXtra("", bv[1], ev[1] - bv[1], ",", Math.round) 33055 .appendXtra("", bv[2], ev[2] - bv[2], (hasAlpha ? "," : str), Math.round); 33056 } 33057 33058 if (hasAlpha) { 33059 bv = (bv.length < 4) ? 1 : bv[3]; 33060 pt.appendXtra("", bv, ((ev.length < 4) ? 1 : ev[3]) - bv, str, false); 33061 } 33062 } 33063 _colorExp.lastIndex = 0; //otherwise the test() on the RegExp could move the lastIndex and taint future results. 33064 33065 } else { 33066 bnums = bv.match(_numExp); //gets each group of numbers in the beginning value string and drops them into an array 33067 33068 //if no number is found, treat it as a non-tweening value and just append the string to the current xs. 33069 if (!bnums) { 33070 pt["xs" + pt.l] += (pt.l || pt["xs" + pt.l]) ? " " + ev : ev; 33071 33072 //loop through all the numbers that are found and construct the extra values on the pt. 33073 } else { 33074 enums = ev.match(_relNumExp); //get each group of numbers in the end value string and drop them into an array. We allow relative values too, like +=50 or -=.5 33075 if (!enums || enums.length !== bnums.length) { 33076 //DEBUG: _log("mismatched formatting detected on " + p + " (" + b + " vs " + e + ")"); 33077 return pt; 33078 } 33079 ni = 0; 33080 for (xi = 0; xi < bnums.length; xi++) { 33081 cv = bnums[xi]; 33082 temp = bv.indexOf(cv, ni); 33083 pt.appendXtra(bv.substr(ni, temp - ni), Number(cv), _parseChange(enums[xi], cv), "", (autoRound && bv.substr(temp + cv.length, 2) === "px") ? Math.round : false, (xi === 0)); 33084 ni = temp + cv.length; 33085 } 33086 pt["xs" + pt.l] += bv.substr(ni); 33087 } 33088 } 33089 } 33090 //if there are relative values ("+=" or "-=" prefix), we need to adjust the ending value to eliminate the prefixes and combine the values properly. 33091 if (e.indexOf("=") !== -1) if (pt.data) { 33092 str = pt.xs0 + pt.data.s; 33093 for (i = 1; i < pt.l; i++) { 33094 str += pt["xs" + i] + pt.data["xn" + i]; 33095 } 33096 pt.e = str + pt["xs" + i]; 33097 } 33098 if (!pt.l) { 33099 pt.type = -1; 33100 pt.xs0 = pt.e; 33101 } 33102 return pt.xfirst || pt; 33103 }, 33104 i = 9; 33105 33106 33107 p = CSSPropTween.prototype; 33108 p.l = p.pr = 0; //length (number of extra properties like xn1, xn2, xn3, etc. 33109 while (--i > 0) { 33110 p["xn" + i] = 0; 33111 p["xs" + i] = ""; 33112 } 33113 p.xs0 = ""; 33114 p._next = p._prev = p.xfirst = p.data = p.plugin = p.setRatio = p.rxp = null; 33115 33116 33117 /** 33118 * Appends and extra tweening value to a CSSPropTween and automatically manages any prefix and suffix strings. The first extra value is stored in the s and c of the main CSSPropTween instance, but thereafter any extras are stored in the xn1, xn2, xn3, etc. The prefixes and suffixes are stored in the xs0, xs1, xs2, etc. properties. For example, if I walk through a clip value like "rect(10px, 5px, 0px, 20px)", the values would be stored like this: 33119 * xs0:"rect(", s:10, xs1:"px, ", xn1:5, xs2:"px, ", xn2:0, xs3:"px, ", xn3:20, xn4:"px)" 33120 * And they'd all get joined together when the CSSPlugin renders (in the setRatio() method). 33121 * @param {string=} pfx Prefix (if any) 33122 * @param {!number} s Starting value 33123 * @param {!number} c Change in numeric value over the course of the entire tween. For example, if the start is 5 and the end is 100, the change would be 95. 33124 * @param {string=} sfx Suffix (if any) 33125 * @param {boolean=} r Round (if true). 33126 * @param {boolean=} pad If true, this extra value should be separated by the previous one by a space. If there is no previous extra and pad is true, it will automatically drop the space. 33127 * @return {CSSPropTween} returns itself so that multiple methods can be chained together. 33128 */ 33129 p.appendXtra = function(pfx, s, c, sfx, r, pad) { 33130 var pt = this, 33131 l = pt.l; 33132 pt["xs" + l] += (pad && (l || pt["xs" + l])) ? " " + pfx : pfx || ""; 33133 if (!c) if (l !== 0 && !pt.plugin) { //typically we'll combine non-changing values right into the xs to optimize performance, but we don't combine them when there's a plugin that will be tweening the values because it may depend on the values being split apart, like for a bezier, if a value doesn't change between the first and second iteration but then it does on the 3rd, we'll run into trouble because there's no xn slot for that value! 33134 pt["xs" + l] += s + (sfx || ""); 33135 return pt; 33136 } 33137 pt.l++; 33138 pt.type = pt.setRatio ? 2 : 1; 33139 pt["xs" + pt.l] = sfx || ""; 33140 if (l > 0) { 33141 pt.data["xn" + l] = s + c; 33142 pt.rxp["xn" + l] = r; //round extra property (we need to tap into this in the _parseToProxy() method) 33143 pt["xn" + l] = s; 33144 if (!pt.plugin) { 33145 pt.xfirst = new CSSPropTween(pt, "xn" + l, s, c, pt.xfirst || pt, 0, pt.n, r, pt.pr); 33146 pt.xfirst.xs0 = 0; //just to ensure that the property stays numeric which helps modern browsers speed up processing. Remember, in the setRatio() method, we do pt.t[pt.p] = val + pt.xs0 so if pt.xs0 is "" (the default), it'll cast the end value as a string. When a property is a number sometimes and a string sometimes, it prevents the compiler from locking in the data type, slowing things down slightly. 33147 } 33148 return pt; 33149 } 33150 pt.data = {s:s + c}; 33151 pt.rxp = {}; 33152 pt.s = s; 33153 pt.c = c; 33154 pt.r = r; 33155 return pt; 33156 }; 33157 33158 /** 33159 * @constructor A SpecialProp is basically a css property that needs to be treated in a non-standard way, like if it may contain a complex value like boxShadow:"5px 10px 15px rgb(255, 102, 51)" or if it is associated with another plugin like ThrowPropsPlugin or BezierPlugin. Every SpecialProp is associated with a particular property name like "boxShadow" or "throwProps" or "bezier" and it will intercept those values in the vars object that's passed to the CSSPlugin and handle them accordingly. 33160 * @param {!string} p Property name (like "boxShadow" or "throwProps") 33161 * @param {Object=}
33161 options An object containing any of the following configuration options: 33162 * - defaultValue: the default value 33163 * - parser: A function that should be called when the associated property name is found in the vars. This function should return a CSSPropTween instance and it should ensure that it is properly inserted into the linked list. It will receive 4 paramters: 1) The target, 2) The value defined in the vars, 3) The CSSPlugin instance (whose _firstPT should be used for the linked list), and 4) A computed style object if one was calculated (this is a speed optimization that allows retrieval of starting values quicker) 33164 * - formatter: a function that formats any value received for this special property (for example, boxShadow could take "5px 5px red" and format it to "5px 5px 0px 0px red" so that both the beginning and ending values have a common order and quantity of values.) 33165 * - prefix: if true, we'll determine whether or not this property requires a vendor prefix (like Webkit or Moz or ms or O) 33166 * - color: set this to true if the value for this SpecialProp may contain color-related values like rgb(), rgba(), etc. 33167 * - priority: priority in the linked list order. Higher priority SpecialProps will be updated before lower priority ones. The default priority is 0. 33168 * - multi: if true, the formatter should accommodate a comma-delimited list of values, like boxShadow could have multiple boxShadows listed out. 33169 * - collapsible: if true, the formatter should treat the value like it's a top/right/bottom/left value that could be collapsed, like "5px" would apply to all, "5px, 10px" would use 5px for top/bottom and 10px for right/left, etc. 33170 * - keyword: a special keyword that can [optionally] be found inside the value (like "inset" for boxShadow). This allows us to validate beginning/ending values to make sure they match (if the keyword is found in one, it'll be added to the other for consistency by default). 33171 */ 33172 var SpecialProp = function(p, options) { 33173 options = options || {}; 33174 this.p = options.prefix ? _checkPropPrefix(p) || p : p; 33175 _specialProps[p] = _specialProps[this.p] = this; 33176 this.format = options.formatter || _getFormatter(options.defaultValue, options.color, options.collapsible, options.multi); 33177 if (options.parser) { 33178 this.parse = options.parser; 33179 } 33180 this.clrs = options.color; 33181 this.multi = options.multi; 33182 this.keyword = options.keyword; 33183 this.dflt = options.defaultValue; 33184 this.pr = options.priority || 0; 33185 }, 33186 33187 //shortcut for creating a new SpecialProp that can accept multiple properties as a comma-delimited list (helps minification). dflt can be an array for multiple values (we don't do a comma-delimited list because the default value may contain commas, like rect(0px,0px,0px,0px)). We attach this method to the SpecialProp class/object instead of using a private _createSpecialProp() method so that we can tap into it externally if necessary, like from another plugin. 33188 _registerComplexSpecialProp = _internals._registerComplexSpecialProp = function(p, options, defaults) { 33189 if (typeof(options) !== "object") { 33190 options = {parser:defaults}; //to make backwards compatible with older versions of BezierPlugin and ThrowPropsPlugin 33191 } 33192 var a = p.split(","), 33193 d = options.defaultValue, 33194 i, temp; 33195 defaults = defaults || [d]; 33196 for (i = 0; i < a.length; i++) { 33197 options.prefix = (i === 0 && options.prefix); 33198 options.defaultValue = defaults[i] || d; 33199 temp = new SpecialProp(a[i], options); 33200 } 33201 }, 33202 33203 //creates a placeholder special prop for a plugin so that the property gets caught the first time a tween of it is attempted, and at that time it makes the plugin register itself, thus taking over for all future tweens of that property. This allows us to not mandate that things load in a particular order and it also allows us to log() an error that informs the user when they attempt to tween an external plugin-related property without loading its .js file. 33204 _registerPluginProp = _internals._registerPluginProp = function(p) { 33205 if (!_specialProps[p]) { 33206 var pluginName = p.charAt(0).toUpperCase() + p.substr(1) + "Plugin"; 33207 _registerComplexSpecialProp(p, {parser:function(t, e, p, cssp, pt, plugin, vars) { 33208 var pluginClass = _globals.com.greensock.plugins[pluginName]; 33209 if (!pluginClass) { 33210 _log("Error: " + pluginName + " js file not loaded."); 33211 return pt; 33212 } 33213 pluginClass._cssRegister(); 33214 return _specialProps[p].parse(t, e, p, cssp, pt, plugin, vars); 33215 }}); 33216 } 33217 }; 33218 33219 33220 p = SpecialProp.prototype; 33221 33222 /** 33223 * Alias for _parseComplex() that automatically plugs in certain values for this SpecialProp, like its property name, whether or not colors should be sensed, the default value, and priority. It also looks for any keyword that the SpecialProp defines (like "inset" for boxSh
33223adow) and ensures that the beginning and ending values have the same number of values for SpecialProps where multi is true (like boxShadow and textShadow can have a comma-delimited list) 33224 * @param {!Object} t target element 33225 * @param {(string|number|object)} b beginning value 33226 * @param {(string|number|object)} e ending (destination) value 33227 * @param {CSSPropTween=} pt next CSSPropTween in the linked list 33228 * @param {TweenPlugin=} plugin If another plugin will be tweening the complex value, that TweenPlugin instance goes here. 33229 * @param {function=} setRatio If a custom setRatio() method should be used to handle this complex value, that goes here. 33230 * @return {CSSPropTween=} First CSSPropTween in the linked list 33231 */ 33232 p.parseComplex = function(t, b, e, pt, plugin, setRatio) { 33233 var kwd = this.keyword, 33234 i, ba, ea, l, bi, ei; 33235 //if this SpecialProp's value can contain a comma-delimited list of values (like boxShadow or textShadow), we must parse them in a special way, and look for a keyword (like "inset" for boxShadow) and ensure that the beginning and ending BOTH have it if the end defines it as such. We also must ensure that there are an equal number of values specified (we can't tween 1 boxShadow to 3 for example) 33236 if (this.multi) if (_commasOutsideParenExp.test(e) || _commasOutsideParenExp.test(b)) { 33237 ba = b.replace(_commasOutsideParenExp, "|").split("|"); 33238 ea = e.replace(_commasOutsideParenExp, "|").split("|"); 33239 } else if (kwd) { 33240 ba = [b]; 33241 ea = [e]; 33242 } 33243 if (ea) { 33244 l = (ea.length > ba.length) ? ea.length : ba.length; 33245 for (i = 0; i < l; i++) { 33246 b = ba[i] = ba[i] || this.dflt; 33247 e = ea[i] = ea[i] || this.dflt; 33248 if (kwd) { 33249 bi = b.indexOf(kwd); 33250 ei = e.indexOf(kwd); 33251 if (bi !== ei) { 33252 if (ei === -1) { //if the keyword isn't in the end value, remove it from the beginning one. 33253 ba[i] = ba[i].split(kwd).join(""); 33254 } else if (bi === -1) { //if the keyword isn't in the beginning, add it. 33255 ba[i] += " " + kwd; 33256 } 33257 } 33258 } 33259 } 33260 b = ba.join(", "); 33261 e = ea.join(", "); 33262 } 33263 return _parseComplex(t, this.p, b, e, this.clrs, this.dflt, pt, this.pr, plugin, setRatio); 33264 }; 33265 33266 /** 33267 * Accepts a target and end value and spits back a CSSPropTween that has been inserted into the CSSPlugin's linked list and conforms with all the conventions we use internally, like type:-1, 0, 1, or 2, setting up any extra property tweens, priority, etc. For example, if we have a boxShadow SpecialProp and call: 33268 * this._firstPT = sp.parse(element, "5px 10px 20px rgb(2550,102,51)", "boxShadow", this); 33269 * It should figure out the starting value of the element's boxShadow, compare it to the provided end value and create all the necessary CSSPropTweens of the appropriate types to tween the boxShadow. The CSSPropTween that gets spit back should already be inserted into the linked list (the 4th parameter is the current head, so prepend to that). 33270 * @param {!Object} t Target object whose property is being tweened 33271 * @param {Object} e End value as provided in the vars object (typically a string, but not always - like a throwProps would be an object). 33272 * @param {!string} p Property name 33273 * @param {!CSSPlugin} cssp The CSSPlugin instance that should be associated with this tween. 33274 * @param {?CSSPropTween} pt The CSSPropTween that is the current head of the linked list (we'll prepend to it) 33275 * @param {TweenPlugin=} plugin If a plugin will be used to tween the parsed value, this is the plugin instance. 33276 * @param {Object=} vars Original vars object that contains the data for parsing. 33277 * @return {CSSPropTween} The first CSSPropTween in the linked list which includes the new one(s) added by the parse() call. 33278 */ 33279 p.parse = function(t, e, p, cssp, pt, plugin, vars) { 33280 return this.parseComplex(t.style, this.format(_getStyle(t, this.p, _cs, false, this.dflt)), this.format(e), pt, plugin); 33281 }; 33282 33283 /** 33284 * Registers a special property that should be intercepted from any "css" objects defined in tweens. This allows you to handle them however you want without CSSPlugin doing it for you. The 2nd parameter should be a function that accepts 3 parameters: 33285 * 1) Target object whose property should be tweened (typically a DOM element) 33286 * 2) The end/destination value (could be a string, number, object, or whatever you want) 33287 * 3) The tween instance (you probably don't need to worry about this, but it can be useful for looking up information like the duration) 33288 * 33289 * Then, your function should return a function which will be called each time the tween gets rendered, passing a numeric "ratio" parameter to your function that indicates the change factor (usually between 0 and 1). For example: 33290 * 33291 * CSSPlugin.registerSpecialProp("myCustomProp", function(target, value, tween) { 33292 * var start = target.style.width;
33293 * return function(ratio) { 33294 * target.style.width = (start + value * ratio) + "px"; 33295 * console.log("set width to " + target.style.width); 33296 * } 33297 * }, 0); 33298 * 33299 * Then, when I do this tween, it will trigger my special property: 33300 * 33301 * TweenLite.to(element, 1, {css:{myCustomProp:100}}); 33302 * 33303 * In the example, of course, we're just changing the width, but you can do anything you want. 33304 * 33305 * @param {!string} name Property name (or comma-delimited list of property names) that should be intercepted and handled by your function. For example, if I define "myCustomProp", then it would handle that portion of the following tween: TweenLite.to(element, 1, {css:{myCustomProp:100}}) 33306 * @param {!function(Object, Object, Object, string):function(number)} onInitTween The function that will be called when a tween of this special property is performed. The function will receive 4 parameters: 1) Target object that should be tweened, 2) Value that was passed to the tween, 3) The tween instance itself (rarely used), and 4) The property name that's being tweened. Your function should return a function that should be called on every update of the tween. That function will receive a single parameter that is a "change factor" value (typically between 0 and 1) indicating the amount of change as a ratio. You can use this to determine how to set the values appropriately in your function. 33307 * @param {number=} priority Priority that helps the engine determine the order in which to set the properties (default: 0). Higher priority properties will be updated before lower priority ones. 33308 */ 33309 CSSPlugin.registerSpecialProp = function(name, onInitTween, priority) { 33310 _registerComplexSpecialProp(name, {parser:function(t, e, p, cssp, pt, plugin, vars) { 33311 var rv = new CSSPropTween(t, p, 0, 0, pt, 2, p, false, priority); 33312 rv.plugin = plugin; 33313 rv.setRatio = onInitTween(t, e, cssp._tween, p); 33314 return rv; 33315 }, priority:priority}); 33316 }; 33317 33318 33319 33320 33321 33322 33323 //transform-related methods and properties 33324 CSSPlugin.useSVGTransformAttr = true; //Safari and Firefox both have some rendering bugs when applying CSS transforms to SVG elements, so default to using the "transform" attribute instead (users can override this). 33325 var _transformProps = ("scaleX,scaleY,scaleZ,x,y,z,skewX,skewY,rotation,rotationX,rotationY,perspective,xPercent,yPercent").split(","), 33326 _transformProp = _checkPropPrefix("transform"), //the Javascript (camelCase) transform property, like msTransform, WebkitTransform, MozTransform, or OTransform. 33327 _transformPropCSS = _prefixCSS + "transform", 33328 _transformOriginProp = _checkPropPrefix("transformOrigin"), 33329 _supports3D = (_checkPropPrefix("perspective") !== null), 33330 Transform = _internals.Transform = function() { 33331 this.perspective = parseFloat(CSSPlugin.defaultTransformPerspective) || 0; 33332 this.force3D = (CSSPlugin.defaultForce3D === false || !_supports3D) ? false : CSSPlugin.defaultForce3D || "auto"; 33333 }, 33334 _SVGElement = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].SVGElement, 33335 _useSVGTransformAttr, 33336 //Some browsers (like Firefox and IE) don't honor transform-origin properly in SVG elements, so we need to manually adjust the matrix accordingly. We feature detect here rather than always doing the conversion for certain browsers because they may fix the problem at some point in the future. 33337 33338 _createSVG = function(type, container, attributes) { 33339 var element = _doc.createElementNS("http://www.w3.org/2000/svg", type), 33340 reg = /([a-z])([A-Z])/g, 33341 p; 33342 for (p in attributes) { 33343 element.setAttributeNS(null, p.replace(reg, "$1-$2").toLowerCase(), attributes[p]); 33344 } 33345 container.appendChild(element); 33346 return element; 33347 }, 33348 _docElement = _doc.documentElement || {}, 33349 _forceSVGTransformAttr = (function() { 33350 //IE and Android stock don't support CSS transforms on SVG elements, so we must write them to the "transform" attribute. We populate this variable in the _parseTransform() method, and only if/when we come across an SVG element 33351 var force = _ieVers || (/Android/i.test(_agent) && !__WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].chrome), 33352 svg, rect, width; 33353 if (_doc.createElementNS && !force) { //IE8 and earlier doesn't support SVG anyway 33354 svg = _createSVG("svg", _docElement); 33355 rect = _createSVG("rect", svg, {width:100, height:50, x:100}); 33356 width = rect.getBoundingClientRect().width; 33357 rect.style[_transformOriginProp] = "50% 50%"; 33358 rect.style[_transformProp] = "scaleX(0.5)"; 33359 force = (width === rect.getBoundingClientRect().width && !(_is
33359Firefox && _supports3D)); //note: Firefox fails the test even though it does support CSS transforms in 3D. Since we can't push 3D stuff into the transform attribute, we force Firefox to pass the test here (as long as it does truly support 3D). 33360 _docElement.removeChild(svg); 33361 } 33362 return force; 33363 })(), 33364 _parseSVGOrigin = function(e, local, decoratee, absolute, smoothOrigin, skipRecord) { 33365 var tm = e._gsTransform, 33366 m = _getMatrix(e, true), 33367 v, x, y, xOrigin, yOrigin, a, b, c, d, tx, ty, determinant, xOriginOld, yOriginOld; 33368 if (tm) { 33369 xOriginOld = tm.xOrigin; //record the original values before we alter them. 33370 yOriginOld = tm.yOrigin; 33371 } 33372 if (!absolute || (v = absolute.split(" ")).length < 2) { 33373 b = e.getBBox(); 33374 if (b.x === 0 && b.y === 0 && b.width + b.height === 0) { //some browsers (like Firefox) misreport the bounds if the element has zero width and height (it just assumes it's at x:0, y:0), thus we need to manually grab the position in that case. 33375 b = {x: parseFloat(e.hasAttribute("x") ? e.getAttribute("x") : e.hasAttribute("cx") ? e.getAttribute("cx") : 0) || 0, y: parseFloat(e.hasAttribute("y") ? e.getAttribute("y") : e.hasAttribute("cy") ? e.getAttribute("cy") : 0) || 0, width:0, height:0}; 33376 } 33377 local = _parsePosition(local).split(" "); 33378 v = [(local[0].indexOf("%") !== -1 ? parseFloat(local[0]) / 100 * b.width : parseFloat(local[0])) + b.x, 33379 (local[1].indexOf("%") !== -1 ? parseFloat(local[1]) / 100 * b.height : parseFloat(local[1])) + b.y]; 33380 } 33381 decoratee.xOrigin = xOrigin = parseFloat(v[0]); 33382 decoratee.yOrigin = yOrigin = parseFloat(v[1]); 33383 if (absolute && m !== _identity2DMatrix) { //if svgOrigin is being set, we must invert the matrix and determine where the absolute point is, factoring in the current transforms. Otherwise, the svgOrigin would be based on the element's non-transformed position on the canvas. 33384 a = m[0]; 33385 b = m[1]; 33386 c = m[2]; 33387 d = m[3]; 33388 tx = m[4]; 33389 ty = m[5]; 33390 determinant = (a * d - b * c); 33391 if (determinant) { //if it's zero (like if scaleX and scaleY are zero), skip it to avoid errors with dividing by zero. 33392 x = xOrigin * (d / determinant) + yOrigin * (-c / determinant) + ((c * ty - d * tx) / determinant); 33393 y = xOrigin * (-b / determinant) + yOrigin * (a / determinant) - ((a * ty - b * tx) / determinant); 33394 xOrigin = decoratee.xOrigin = v[0] = x; 33395 yOrigin = decoratee.yOrigin = v[1] = y; 33396 } 33397 } 33398 if (tm) { //avoid jump when transformOrigin is changed - adjust the x/y values accordingly 33399 if (skipRecord) { 33400 decoratee.xOffset = tm.xOffset; 33401 decoratee.yOffset = tm.yOffset; 33402 tm = decoratee; 33403 } 33404 if (smoothOrigin || (smoothOrigin !== false && CSSPlugin.defaultSmoothOrigin !== false)) { 33405 x = xOrigin - xOriginOld; 33406 y = yOrigin - yOriginOld; 33407 //originally, we simply adjusted the x and y values, but that would cause problems if, for example, you created a rotational tween part-way through an x/y tween. Managing the offset in a separate variable gives us ultimate flexibility. 33408 //tm.x -= x - (x * m[0] + y * m[2]); 33409 //tm.y -= y - (x * m[1] + y * m[3]); 33410 tm.xOffset += (x * m[0] + y * m[2]) - x; 33411 tm.yOffset += (x * m[1] + y * m[3]) - y; 33412 } else { 33413 tm.xOffset = tm.yOffset = 0; 33414 } 33415 } 33416 if (!skipRecord) { 33417 e.setAttribute("data-svg-origin", v.join(" ")); 33418 } 33419 }, 33420 _getBBoxHack = function(swapIfPossible) { //works around issues in some browsers (like Firefox) that don't correctly report getBBox() on SVG elements inside a <defs> element and/or <mask>. We try creating an SVG, adding it to the documentElement and toss the element in there so that it's definitely part of the rendering tree, then grab the bbox and if it works, we actually swap out the original getBBox() method for our own that does these extra steps whenever getBBox is needed. This helps ensure that performance is optimal (only do all these extra steps when absolutely necessary...most elements don't need it). 33421 var svg = _createElement("svg", (this.ownerSVGElement && this.ownerSVGElement.getAttribute("xmlns")) || "http://www.w3.org/2000/svg"), 33422 oldParent = this.parentNode, 33423 oldSibling = this.nextSibling, 33424 oldCSS = this.style.cssText, 33425 bbox; 33426 _docElement.appendChild(svg); 33427 svg.appendChild(this); 33428 this.style.display = "block"; 33429 if (swapIfPossible) { 33430 try { 33431 bbox = this.getBBox(); 33432 this._originalGetBBox = this.getBBox; 33433 this.getBBox = _getBBoxHack; 33434 } catch (e) { } 33435 } else if (this._originalGetBBox) { 33436 bbox = this._originalGetBBox(); 33437 } 33438 if (oldSibling) { 33439 oldParent.insertBefore(this, oldSibling); 33440 } else { 33441 oldParent.appendChild(this); 33442 } 33443 _docElement.removeChild(svg); 33444 this.style.cssText = oldCSS; 33445 return bbox; 33446 }, 33447 _getBBox = function(e) { 33448 try { 33449 return e.getBBox(); //Firefox throws errors if you try calling getBBox() on an SVG element that's not rendered (like in a <symbol> or <defs>). https://bugzilla.mozilla.org/show_bug.cgi?id=612118 33450 } catch (error) { 33451 return _getBBoxHack.call(e, true); 33452 } 33453 }, 33454 _isSVG = function(e) { //reports if the element is an SVG on which getBBox() actually works 33455 return !!(_SVGElement && e.getCTM && (!e.parentNode || e.ownerSVGElement) && _getBBox(e)); 33456 }, 33457 _identity2DMatrix = [1,0,0,1,0,0], 33458 _getMatrix = function(e, force2D) { 33459 var tm = e._gsTransform || new Transform(), 33460 rnd = 100000, 33461 style = e.style, 33462 isDefault, s, m, n, dec, none; 33463 if (_transformProp) { 33464 s = _getStyle(e, _transformPropCSS, null, true); 33465 } else if (e.currentStyle) { 33466 //for older versions of IE, we need to interpret the filter portion that is in the format: progid:DXImageTransform.Microsoft.Matrix(M11=6.123233995736766e-17, M12=-1, M21=1, M22=6.123233995736766e-17, sizingMethod='auto expand') Notice that we need to swap b and c compared to a normal matrix. 33467 s = e.currentStyle.filter.match(_ieGetMatrixExp); 33468 s = (s && s.length === 4) ? [s[0].substr(4), Number(s[2].substr(4)), Number(s[1].substr(4)), s[3].substr(4), (tm.x || 0), (tm.y || 0)].join(",") : ""; 33469 }
33470 isDefault = (!s || s === "none" || s === "matrix(1, 0, 0, 1, 0, 0)"); 33471 if (_transformProp && ((none = (!_getComputedStyle(e) || _getComputedStyle(e).display === "none")) || !e.parentNode)) { //note: Firefox returns null for getComputedStyle() if the element is in an iframe that has display:none. https://bugzilla.mozilla.org/show_bug.cgi?id=548397 33472 if (none) { //browsers don't report transforms accurately unless the element is in the DOM and has a display value that's not "none". Firefox and Microsoft browsers have a partial bug where they'll report transforms even if display:none BUT not any percentage-based values like translate(-50%, 8px) will be reported as if it's translate(0, 8px). 33473 n = style.display; 33474 style.display = "block"; 33475 } 33476 if (!e.parentNode) { 33477 dec = 1; //flag 33478 _docElement.appendChild(e); 33479 } 33480 s = _getStyle(e, _transformPropCSS, null, true); 33481 isDefault = (!s || s === "none" || s === "matrix(1, 0, 0, 1, 0, 0)"); 33482 if (n) { 33483 style.display = n; 33484 } else if (none) { 33485 _removeProp(style, "display"); 33486 } 33487 if (dec) { 33488 _docElement.removeChild(e); 33489 } 33490 } 33491 if (tm.svg || (e.getCTM && _isSVG(e))) { 33492 if (isDefault && (style[_transformProp] + "").indexOf("matrix") !== -1) { //some browsers (like Chrome 40) don't correctly report transforms that are applied inline on an SVG element (they don't get included in the computed style), so we double-check here and accept matrix values 33493 s = style[_transformProp]; 33494 isDefault = 0; 33495 } 33496 m = e.getAttribute("transform"); 33497 if (isDefault && m) { 33498 m = e.transform.baseVal.consolidate().matrix; //ensures that even complex values like "translate(50,60) rotate(135,0,0)" are parsed because it mashes it into a matrix. 33499 s = "matrix(" + m.a + "," + m.b + "," + m.c + "," + m.d + "," + m.e + "," + m.f + ")"; 33500 isDefault = 0; 33501 } 33502 } 33503 if (isDefault) { 33504 return _identity2DMatrix; 33505 } 33506 //split the matrix values out into an array (m for matrix) 33507 m = (s || "").match(_numExp) || []; 33508 i = m.length; 33509 while (--i > -1) { 33510 n = Number(m[i]); 33511 m[i] = (dec = n - (n |= 0)) ? ((dec * rnd + (dec < 0 ? -0.5 : 0.5)) | 0) / rnd + n : n; //convert strings to Numbers and round to 5 decimal places to avoid issues with tiny numbers. Roughly 20x faster than Number.toFixed(). We also must make sure to round before dividing so that values like 0.9999999999 become 1 to avoid glitches in browser rendering and interpretation of flipped/rotated 3D matrices. And don't just multiply the number by rnd, floor it, and then divide by rnd because the bitwise operations max out at a 32-bit signed integer, thus it could get clipped at a relatively low value (like 22,000.00000 for example). 33512 } 33513 return (force2D && m.length > 6) ? [m[0], m[1], m[4], m[5], m[12], m[13]] : m; 33514 }, 33515 33516 /** 33517 * Parses the transform values for an element, returning an object with x, y, z, scaleX, scaleY, scaleZ, rotation, rotationX, rotationY, skewX, and skewY properties. Note: by default (for performance reasons), all skewing is combined into skewX and rotation but skewY still has a place in the transform object so that we can record how much of the skew is attributed to skewX vs skewY. Remember, a skewY of 10 looks the same as a rotation of 10 and skewX of -10. 33518 * @param {!Object} t target element 33519 * @param {Object=} cs computed style object (optional) 33520 * @param {boolean=} rec if true, the transform values will be recorded to the target element's _gsTransform object, like target._gsTransform = {x:0, y:0, z:0, scaleX:1...} 33521 * @param {boolean=} parse if true, we'll ignore any _gsTransform values that already exist on the element, and force a reparsing of the css (calculated style) 33522 * @return {object}
33522 object containing all of the transform properties/values like {x:0, y:0, z:0, scaleX:1...} 33523 */ 33524 _getTransform = _internals.getTransform = function(t, cs, rec, parse) { 33525 if (t._gsTransform && rec && !parse) { 33526 return t._gsTransform; //if the element already has a _gsTransform, use that. Note: some browsers don't accurately return the calculated style for the transform (particularly for SVG), so it's almost always safest to just use the values we've already applied rather than re-parsing things. 33527 } 33528 var tm = rec ? t._gsTransform || new Transform() : new Transform(), 33529 invX = (tm.scaleX < 0), //in order to interpret things properly, we need to know if the user applied a negative scaleX previously so that we can adjust the rotation and skewX accordingly. Otherwise, if we always interpret a flipped matrix as affecting scaleY and the user only wants to tween the scaleX on multiple sequential tweens, it would keep the negative scaleY without that being the user's intent. 33530 min = 0.00002, 33531 rnd = 100000, 33532 zOrigin = _supports3D ? parseFloat(_getStyle(t, _transformOriginProp, cs, false, "0 0 0").split(" ")[2]) || tm.zOrigin || 0 : 0, 33533 defaultTransformPerspective = parseFloat(CSSPlugin.defaultTransformPerspective) || 0, 33534 m, i, scaleX, scaleY, rotation, skewX; 33535 33536 tm.svg = !!(t.getCTM && _isSVG(t)); 33537 if (tm.svg) { 33538 _parseSVGOrigin(t, _getStyle(t, _transformOriginProp, cs, false, "50% 50%") + "", tm, t.getAttribute("data-svg-origin")); 33539 _useSVGTransformAttr = CSSPlugin.useSVGTransformAttr || _forceSVGTransformAttr; 33540 } 33541 m = _getMatrix(t); 33542 if (m !== _identity2DMatrix) { 33543 33544 if (m.length === 16) { 33545 //we'll only look at these position-related 6 variables first because if x/y/z all match, it's relatively safe to assume we don't need to re-parse everything which risks losing important rotational information (like rotationX:180 plus rotationY:180 would look the same as rotation:180 - there's no way to know for sure which direction was taken based solely on the matrix3d() values) 33546 var a11 = m[0], a21 = m[1], a31 = m[2], a41 = m[3], 33547 a12 = m[4], a22 = m[5], a32 = m[6], a42 = m[7], 33548 a13 = m[8], a23 = m[9], a33 = m[10], 33549 a14 = m[12], a24 = m[13], a34 = m[14], 33550 a43 = m[11], 33551 angle = Math.atan2(a32, a33), 33552 t1, t2, t3, t4, cos, sin; 33553 //we manually compensate for non-zero z component of transformOrigin to work around bugs in Safari 33554 if (tm.zOrigin) { 33555 a34 = -tm.zOrigin; 33556 a14 = a13*a34-m[12]; 33557 a24 = a23*a34-m[13]; 33558 a34 = a33*a34+tm.zOrigin-m[14]; 33559 } 33560 //note for possible future consolidation: rotationX: Math.atan2(a32, a33), rotationY: Math.atan2(-a31, Math.sqrt(a33 * a33 + a32 * a32)), rotation: Math.atan2(a21, a11), skew: Math.atan2(a12, a22). However, it doesn't seem to be quite as reliable as the full-on backwards rotation procedure. 33561 tm.rotationX = angle * _RAD2DEG; 33562 //rotationX 33563 if (angle) { 33564 cos = Math.cos(-angle); 33565 sin = Math.sin(-angle); 33566 t1 = a12*cos+a13*sin; 33567 t2 = a22*cos+a23*sin; 33568 t3 = a32*cos+a33*sin; 33569 a13 = a12*-sin+a13*cos; 33570 a23 = a22*-sin+a23*cos; 33571 a33 = a32*-sin+a33*cos; 33572 a43 = a42*-sin+a43*cos; 33573 a12 = t1; 33574 a22 = t2; 33575 a32 = t3; 33576 } 33577 //rotationY 33578 angle = Math.atan2(-a31, a33); 33579 tm.rotationY = angle * _RAD2DEG; 33580 if (angle) { 33581 cos = Math.cos(-angle); 33582 sin = Math.sin(-angle); 33583 t1 = a11*cos-a13*sin; 33584 t2 = a21*cos-a23*sin; 33585 t3 = a31*cos-a33*sin; 33586 a23 = a21*sin+a23*cos; 33587 a33 = a31*sin+a33*cos; 33588 a43 = a41*sin+a43*cos; 33589 a11 = t1; 33590 a21 = t2; 33591 a31 = t3; 33592 } 33593 //rotationZ 33594 angle = Math.atan2(a21, a11); 33595 tm.rotation = angle * _RAD2DEG; 33596 if (angle) { 33597 cos = Math.cos(angle); 33598 sin = Math.sin(angle); 33599 t1 = a11*cos+a21*sin; 33600 t2 = a12*cos+a22*sin; 33601 t3 = a13*cos+a23*sin; 33602 a21 = a21*cos-a11*sin; 33603 a22 = a22*cos-a12*sin; 33604 a23 = a23*cos-a13*sin; 33605 a11 = t1; 33606 a12 = t2; 33607 a13 = t3; 33608 } 33609 33610 if (tm.rotationX && Math.abs(tm.rotationX) + Math.abs(tm.rotation) > 359.9) { //when rotationY is set, it will often be parsed as 180 degrees different than it should be, and rotationX and rotation both being 180 (it looks the same), so we adjust for that here. 33611 tm.rotationX = tm.rotation = 0; 33612 tm.rotationY = 180 - tm.rotationY; 33613 } 33614 33615 //skewX 33616 angle = Math.atan2(a12, a22); 33617 33618 //scales 33619 tm.scaleX = ((Math.sqrt(a11 * a11 + a21 * a21 + a31 * a31) * rnd + 0.5) | 0) / rnd; 33620 tm.scaleY = ((Math.sqrt(a22 * a22 + a32 * a32) * rnd + 0.5) | 0) / rnd; 33621 tm.scaleZ = ((Math.sqrt(a13 * a13 + a23 * a23 + a33 * a33) * rnd + 0.5) | 0) / rnd; 33622 a11 /= tm.scaleX; 33623 a12 /= tm.scaleY; 33624 a21 /= tm.scaleX; 33625 a22 /= tm.scaleY; 33626 if (Math.abs(angle) > min) { 33627 tm.skewX = angle * _RAD2DEG; 33628 a12 = 0;
33628 //unskews 33629 if (tm.skewType !== "simple") { 33630 tm.scaleY *= 1 / Math.cos(angle); //by default, we compensate the scale based on the skew so that the element maintains a similar proportion when skewed, so we have to alter the scaleY here accordingly to match the default (non-adjusted) skewing that CSS does (stretching more and more as it skews). 33631 } 33632 33633 } else { 33634 tm.skewX = 0; 33635 } 33636 33637 /* //for testing purposes 33638 var transform = "matrix3d(", 33639 comma = ",", 33640 zero = "0"; 33641 a13 /= tm.scaleZ; 33642 a23 /= tm.scaleZ; 33643 a31 /= tm.scaleX; 33644 a32 /= tm.scaleY; 33645 a33 /= tm.scaleZ; 33646 transform += ((a11 < min && a11 > -min) ? zero : a11) + comma + ((a21 < min && a21 > -min) ? zero : a21) + comma + ((a31 < min && a31 > -min) ? zero : a31); 33647 transform += comma + ((a41 < min && a41 > -min) ? zero : a41) + comma + ((a12 < min && a12 > -min) ? zero : a12) + comma + ((a22 < min && a22 > -min) ? zero : a22); 33648 transform += comma + ((a32 < min && a32 > -min) ? zero : a32) + comma + ((a42 < min && a42 > -min) ? zero : a42) + comma + ((a13 < min && a13 > -min) ? zero : a13); 33649 transform += comma + ((a23 < min && a23 > -min) ? zero : a23) + comma + ((a33 < min && a33 > -min) ? zero : a33) + comma + ((a43 < min && a43 > -min) ? zero : a43) + comma; 33650 transform += a14 + comma + a24 + comma + a34 + comma + (tm.perspective ? (1 + (-a34 / tm.perspective)) : 1) + ")"; 33651 console.log(transform); 33652 document.querySelector(".test").style[_transformProp] = transform; 33653 */ 33654 33655 tm.perspective = a43 ? 1 / ((a43 < 0) ? -a43 : a43) : 0; 33656 tm.x = a14; 33657 tm.y = a24; 33658 tm.z = a34; 33659 if (tm.svg) { 33660 tm.x -= tm.xOrigin - (tm.xOrigin * a11 - tm.yOrigin * a12); 33661 tm.y -= tm.yOrigin - (tm.yOrigin * a21 - tm.xOrigin * a22); 33662 } 33663 33664 } else if ((!_supports3D || parse || !m.length || tm.x !== m[4] || tm.y !== m[5] || (!tm.rotationX && !tm.rotationY))) { //sometimes a 6-element matrix is returned even when we performed 3D transforms, like if rotationX and rotationY are 180. In cases like this, we still need to honor the 3D transforms. If we just rely on the 2D info, it could affect how the data is interpreted, like scaleY might get set to -1 or rotation could get offset by 180 degrees. For example, do a TweenLite.to(element, 1, {css:{rotationX:180, rotationY:180}}) and then later, TweenLite.to(element, 1, {css:{rotationX:0}}) and without this conditional logic in place, it'd jump to a state of being unrotated when the 2nd tween starts. Then again, we need to honor the fact that the user COULD alter the transforms outside of CSSPlugin, like by manually applying new css, so we try to sense that by looking at x and y because if those changed, we know the changes were made outside CSSPlugin and we force a reinterpretation of the matrix values. Also, in Webkit browsers, if the element's "display" is "none", its calculated style value will always return empty, so if we've already recorded the values in the _gsTransform object, we'll just rely on those. 33665 var k = (m.length >= 6), 33666 a = k ? m[0] : 1, 33667 b = m[1] || 0, 33668 c = m[2] || 0, 33669 d = k ? m[3] : 1; 33670 tm.x = m[4] || 0; 33671 tm.y = m[5] || 0; 33672 scaleX = Math.sqrt(a * a + b * b); 33673 scaleY = Math.sqrt(d * d + c * c); 33674 rotation = (a || b) ? Math.atan2(b, a) * _RAD2DEG : tm.rotation || 0; //note: if scaleX is 0, we cannot accurately measure rotation. Same for skewX with a scaleY of 0. Therefore, we default to the previously recorded value (or zero if that doesn't exist). 33675 skewX = (c || d) ? Math.atan2(c, d) * _RAD2DEG + rotation : tm.skewX || 0; 33676 tm.scaleX = scaleX; 33677 tm.scaleY = scaleY; 33678 tm.rotation = rotation; 33679 tm.skewX = skewX; 33680 if (_supports3D) { 33681 tm.rotationX = tm.rotationY = tm.z = 0; 33682 tm.perspective = defaultTransformPerspective; 33683 tm.scaleZ = 1; 33684 } 33685 if (tm.svg) { 33686 tm.x -= tm.xOrigin - (tm.xOrigin * a + tm.yOrigin * c); 33687 tm.y -= tm.yOrigin - (tm.xOrigin * b + tm.yOrigin * d); 33688 } 33689 } 33690 if (Math.abs(tm.skewX) > 90 && Math.abs(tm.skewX) < 270) { 33691 if (invX) { 33692 tm.scaleX *= -1; 33693 tm.skewX += (tm.rotation <= 0) ? 180 : -180; 33694 tm.rotation += (tm.rotation <= 0) ? 180 : -180; 33695 } else { 33696 tm.scaleY *= -1; 33697 tm.skewX += (tm.skewX <= 0) ? 180 : -180; 33698 } 33699 } 33700 tm.zOrigin = zOrigin;
33701 //some browsers have a hard time with very small values like 2.4492935982947064e-16 (notice the "e-" towards the end) and would render the object slightly off. So we round to 0 in these cases. The conditional logic here is faster than calling Math.abs(). Also, browsers tend to render a SLIGHTLY rotated object in a fuzzy way, so we need to snap to exactly 0 when appropriate. 33702 for (i in tm) { 33703 if (tm[i] < min) if (tm[i] > -min) { 33704 tm[i] = 0; 33705 } 33706 } 33707 } 33708 //DEBUG: _log("parsed rotation of " + t.getAttribute("id")+": "+(tm.rotationX)+", "+(tm.rotationY)+", "+(tm.rotation)+", scale: "+tm.scaleX+", "+tm.scaleY+", "+tm.scaleZ+", position: "+tm.x+", "+tm.y+", "+tm.z+", perspective: "+tm.perspective+ ", origin: "+ tm.xOrigin+ ","+ tm.yOrigin); 33709 if (rec) { 33710 t._gsTransform = tm; //record to the object's _gsTransform which we use so that tweens can control individual properties independently (we need all the properties to accurately recompose the matrix in the setRatio() method) 33711 if (tm.svg) { //if we're supposed to apply transforms to the SVG element's "transform" attribute, make sure there aren't any CSS transforms applied or they'll override the attribute ones. Also clear the transform attribute if we're using CSS, just to be clean. 33712 if (_useSVGTransformAttr && t.style[_transformProp]) { 33713 __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].delayedCall(0.001, function(){ //if we apply this right away (before anything has rendered), we risk there being no transforms for a brief moment and it also interferes with adjusting the transformOrigin in a tween with immediateRender:true (it'd try reading the matrix and it wouldn't have the appropriate data in place because we just removed it). 33714 _removeProp(t.style, _transformProp); 33715 }); 33716 } else if (!_useSVGTransformAttr && t.getAttribute("transform")) { 33717 __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].delayedCall(0.001, function(){ 33718 t.removeAttribute("transform"); 33719 }); 33720 } 33721 } 33722 } 33723 return tm; 33724 }, 33725 33726 //for setting 2D transforms in IE6, IE7, and IE8 (must use a "filter" to emulate the behavior of modern day browser transforms) 33727 _setIETransformRatio = function(v) { 33728 var t = this.data, //refers to the element's _gsTransform object 33729 ang = -t.rotation * _DEG2RAD, 33730 skew = ang + t.skewX * _DEG2RAD, 33731 rnd = 100000, 33732 a = ((Math.cos(ang) * t.scaleX * rnd) | 0) / rnd, 33733 b = ((Math.sin(ang) * t.scaleX * rnd) | 0) / rnd, 33734 c = ((Math.sin(skew) * -t.scaleY * rnd) | 0) / rnd, 33735 d = ((Math.cos(skew) * t.scaleY * rnd) | 0) / rnd, 33736 style = this.t.style, 33737 cs = this.t.currentStyle, 33738 filters, val; 33739 if (!cs) { 33740 return; 33741 } 33742 val = b; //just for swapping the variables an inverting them (reused "val" to avoid creating another variable in memory). IE's filter matrix uses a non-standard matrix configuration (angle goes the opposite way, and b and c are reversed and inverted) 33743 b = -c; 33744 c = -val; 33745 filters = cs.filter; 33746 style.filter = ""; //remove filters so that we can accurately measure offsetWidth/offsetHeight 33747 var w = this.t.offsetWidth, 33748 h = this.t.offsetHeight, 33749 clip = (cs.position !== "absolute"), 33750 m = "progid:DXImageTransform.Microsoft.Matrix(M11=" + a + ", M12=" + b + ", M21=" + c + ", M22=" + d, 33751 ox = t.x + (w * t.xPercent / 100), 33752 oy = t.y + (h * t.yPercent / 100), 33753 dx, dy; 33754 33755 //if transformOrigin is being used, adjust the offset x and y 33756 if (t.ox != null) { 33757 dx = ((t.oxp) ? w * t.ox * 0.01 : t.ox) - w / 2; 33758 dy = ((t.oyp) ? h * t.oy * 0.01 : t.oy) - h / 2; 33759 ox += dx - (dx * a + dy * b); 33760 oy += dy - (dx * c + dy * d); 33761 } 33762 33763 if (!clip) { 33764 m += ", sizingMethod='auto expand')"; 33765 } else { 33766 dx = (w / 2); 33767 dy = (h / 2); 33768 //translate to ensure that transformations occur around the correct origin (default is center). 33769 m += ", Dx=" + (dx - (dx * a + dy * b) + ox) + ", Dy=" + (dy - (dx * c + dy * d) + oy) + ")"; 33770 } 33771 if (filters.indexOf("DXImageTransform.Microsoft.Matrix(") !== -1) {
33772 style.filter = filters.replace(_ieSetMatrixExp, m); 33773 } else { 33774 style.filter = m + " " + filters; //we must always put the transform/matrix FIRST (before alpha(opacity=xx)) to avoid an IE bug that slices part of the object when rotation is applied with alpha. 33775 } 33776 33777 //at the end or beginning of the tween, if the matrix is normal (1, 0, 0, 1) and opacity is 100 (or doesn't exist), remove the filter to improve browser performance. 33778 if (v === 0 || v === 1) if (a === 1) if (b === 0) if (c === 0) if (d === 1) if (!clip || m.indexOf("Dx=0, Dy=0") !== -1) if (!_opacityExp.test(filters) || parseFloat(RegExp.$1) === 100) if (filters.indexOf("gradient(" && filters.indexOf("Alpha")) === -1) { 33779 style.removeAttribute("filter"); 33780 } 33781 33782 //we must set the margins AFTER applying the filter in order to avoid some bugs in IE8 that could (in rare scenarios) cause them to be ignored intermittently (vibration). 33783 if (!clip) { 33784 var mult = (_ieVers < 8) ? 1 : -1, //in Internet Explorer 7 and before, the box model is broken, causing the browser to treat the width/height of the actual rotated filtered image as the width/height of the box itself, but Microsoft corrected that in IE8. We must use a negative offset in IE8 on the right/bottom 33785 marg, prop, dif; 33786 dx = t.ieOffsetX || 0; 33787 dy = t.ieOffsetY || 0; 33788 t.ieOffsetX = Math.round((w - ((a < 0 ? -a : a) * w + (b < 0 ? -b : b) * h)) / 2 + ox); 33789 t.ieOffsetY = Math.round((h - ((d < 0 ? -d : d) * h + (c < 0 ? -c : c) * w)) / 2 + oy); 33790 for (i = 0; i < 4; i++) { 33791 prop = _margins[i]; 33792 marg = cs[prop]; 33793 //we need to get the current margin in case it is being tweened separately (we want to respect that tween's changes) 33794 val = (marg.indexOf("px") !== -1) ? parseFloat(marg) : _convertToPixels(this.t, prop, parseFloat(marg), marg.replace(_suffixExp, "")) || 0; 33795 if (val !== t[prop]) { 33796 dif = (i < 2) ? -t.ieOffsetX : -t.ieOffsetY; //if another tween is controlling a margin, we cannot only apply the difference in the ieOffsets, so we essentially zero-out the dx and dy here in that case. We record the margin(s) later so that we can keep comparing them, making this code very flexible. 33797 } else { 33798 dif = (i < 2) ? dx - t.ieOffsetX : dy - t.ieOffsetY; 33799 } 33800 style[prop] = (t[prop] = Math.round( val - dif * ((i === 0 || i === 2) ? 1 : mult) )) + "px"; 33801 } 33802 } 33803 }, 33804 33805 /* translates a super small decimal to a string WITHOUT scientific notation 33806 _safeDecimal = function(n) { 33807 var s = (n < 0 ? -n : n) + "", 33808 a = s.split("e-"); 33809 return (n < 0 ? "-0." : "0.") + new Array(parseInt(a[1], 10) || 0).join("0") + a[0].split(".").join(""); 33810 }, 33811 */ 33812 33813 _setTransformRatio = _internals.set3DTransformRatio = _internals.setTransformRatio = function(v) { 33814 var t = this.data, //refers to the element's _gsTransform object 33815 style = this.t.style, 33816 angle = t.rotation, 33817 rotationX = t.rotationX, 33818 rotationY = t.rotationY, 33819 sx = t.scaleX, 33820 sy = t.scaleY, 33821 sz = t.scaleZ, 33822 x = t.x, 33823 y = t.y, 33824 z = t.z, 33825 isSVG = t.svg, 33826 perspective = t.perspective, 33827 force3D = t.force3D, 33828 skewY = t.skewY, 33829 skewX = t.skewX, 33830 t1, a11, a12, a13, a21, a22, a23, a31, a32, a33, a41, a42, a43, 33831 zOrigin, min, cos, sin, t2, transform, comma, zero, skew, rnd; 33832 if (skewY) { //for performance reasons, we combine all skewing into the skewX and rotation values. Remember, a skewY of 10 degrees looks the same as a rotation of 10 degrees plus a skewX of 10 degrees. 33833 skewX += skewY; 33834 angle += skewY; 33835 } 33836 33837 //check to see if we should render as 2D (and SVGs must use 2D when _useSVGTransformAttr is true) 33838 if (((((v === 1 || v === 0) && force3D === "auto" && (this.tween._totalTime === this.tween._totalDuration || !this.tween._totalTime)) || !force3D) && !z && !perspective && !rotationY && !rotationX && sz === 1) || (_useSVGTransformAttr && isSVG) || !_supports3D) { //on the final render (which could be 0 for a from tween), if there are no 3D aspects, render in 2D to free up memory and improve performance especially on mobile devices. Check the tween's totalTime/totalDuration too in order to make sure it doesn't happen between repeats if it's a repeating tween. 33839 33840 //2D 33841 if (angle || skewX || isSVG) { 33842 angle *= _DEG2RAD; 33843 skew = skewX * _DEG2RAD; 33844 rnd = 100000; 33845 a11 = Math.cos(angle) * sx; 33846 a21 = Math.sin(angle) * sx; 33847 a12 = Math.sin(angle - skew) * -sy;
33848 a22 = Math.cos(angle - skew) * sy; 33849 if (skew && t.skewType === "simple") { //by default, we compensate skewing on the other axis to make it look more natural, but you can set the skewType to "simple" to use the uncompensated skewing that CSS does 33850 t1 = Math.tan(skew - skewY * _DEG2RAD); 33851 t1 = Math.sqrt(1 + t1 * t1); 33852 a12 *= t1; 33853 a22 *= t1; 33854 if (skewY) { 33855 t1 = Math.tan(skewY * _DEG2RAD); 33856 t1 = Math.sqrt(1 + t1 * t1); 33857 a11 *= t1; 33858 a21 *= t1; 33859 } 33860 } 33861 if (isSVG) { 33862 x += t.xOrigin - (t.xOrigin * a11 + t.yOrigin * a12) + t.xOffset; 33863 y += t.yOrigin - (t.xOrigin * a21 + t.yOrigin * a22) + t.yOffset; 33864 if (_useSVGTransformAttr && (t.xPercent || t.yPercent)) { //The SVG spec doesn't support percentage-based translation in the "transform" attribute, so we merge it into the matrix to simulate it. 33865 min = this.t.getBBox(); 33866 x += t.xPercent * 0.01 * min.width; 33867 y += t.yPercent * 0.01 * min.height; 33868 } 33869 min = 0.000001; 33870 if (x < min) if (x > -min) { 33871 x = 0; 33872 } 33873 if (y < min) if (y > -min) { 33874 y = 0; 33875 } 33876 } 33877 transform = (((a11 * rnd) | 0) / rnd) + "," + (((a21 * rnd) | 0) / rnd) + "," + (((a12 * rnd) | 0) / rnd) + "," + (((a22 * rnd) | 0) / rnd) + "," + x + "," + y + ")"; 33878 if (isSVG && _useSVGTransformAttr) {
33879 this.t.setAttribute("transform", "matrix(" + transform); 33880 } else { 33881 //some browsers have a hard time with very small values like 2.4492935982947064e-16 (notice the "e-" towards the end) and would render the object slightly off. So we round to 5 decimal places. 33882 style[_transformProp] = ((t.xPercent || t.yPercent) ? "translate(" + t.xPercent + "%," + t.yPercent + "%) matrix(" : "matrix(") + transform; 33883 } 33884 } else { 33885 style[_transformProp] = ((t.xPercent || t.yPercent) ? "translate(" + t.xPercent + "%," + t.yPercent + "%) matrix(" : "matrix(") + sx + ",0,0," + sy + "," + x + "," + y + ")"; 33886 } 33887 return; 33888 33889 } 33890 if (_isFirefox) { //Firefox has a bug (at least in v25) that causes it to render the transparent part of 32-bit PNG images as black when displayed inside an iframe and the 3D scale is very small and doesn't change sufficiently enough between renders (like if you use a Power4.easeInOut to scale from 0 to 1 where the beginning values only change a tiny amount to begin the tween before accelerating). In this case, we force the scale to be 0.00002 instead which is visually the same but works around the Firefox issue. 33891 min = 0.0001; 33892 if (sx < min && sx > -min) { 33893 sx = sz = 0.00002; 33894 } 33895 if (sy < min && sy > -min) { 33896 sy = sz = 0.00002; 33897 } 33898 if (perspective && !t.z && !t.rotationX && !t.rotationY) { //Firefox has a bug that causes elements to have an odd super-thin, broken/dotted black border on elements that have a perspective set but aren't utilizing 3D space (no rotationX, rotationY, or z). 33899 perspective = 0; 33900 } 33901 } 33902 if (angle || skewX) { 33903 angle *= _DEG2RAD; 33904 cos = a11 = Math.cos(angle); 33905 sin = a21 = Math.sin(angle); 33906 if (skewX) { 33907 angle -= skewX * _DEG2RAD; 33908 cos = Math.cos(angle); 33909 sin = Math.sin(angle); 33910 if (t.skewType === "simple") { //by default, we compensate skewing on the other axis to make it look more natural, but you can set the skewType to "simple" to use the uncompensated skewing that CSS does 33911 t1 = Math.tan((skewX - skewY) * _DEG2RAD); 33912 t1 = Math.sqrt(1 + t1 * t1); 33913 cos *= t1; 33914 sin *= t1; 33915 if (t.skewY) { 33916 t1 = Math.tan(skewY * _DEG2RAD); 33917 t1 = Math.sqrt(1 + t1 * t1); 33918 a11 *= t1; 33919 a21 *= t1; 33920 } 33921 } 33922 } 33923 a12 = -sin; 33924 a22 = cos; 33925 33926 } else if (!rotationY && !rotationX && sz === 1 && !perspective && !isSVG) { //if we're only translating and/or 2D scaling, this is faster... 33927 style[_transformProp] = ((t.xPercent || t.yPercent) ? "translate(" + t.xPercent + "%," + t.yPercent + "%) translate3d(" : "translate3d(") + x + "px," + y + "px," + z +"px)" + ((sx !== 1 || sy !== 1) ? " scale(" + sx + "," + sy + ")" : ""); 33928 return; 33929 } else { 33930 a11 = a22 = 1; 33931 a12 = a21 = 0; 33932 } 33933 // KEY INDEX AFFECTS a[row][column] 33934 // a11 0 rotation, rotationY, scaleX 33935 // a21 1 rotation, rotationY, scaleX 33936 // a31 2 rotationY, scaleX 33937 // a41 3 rotationY, scaleX 33938 // a12 4 rotation, skewX, rotationX, scaleY 33939 // a22 5 rotation, skewX, rotationX, scaleY 33940 // a32 6 rotationX, scaleY 33941 // a42 7 rotationX, scaleY 33942 // a13 8 rotationY, rotationX, scaleZ 33943 // a23 9 rotationY, rotationX, scaleZ 33944 // a33 10 rotationY, rotationX, scaleZ 33945 // a43 11 rotationY, rotationX, perspective, scaleZ 33946 // a14 12 x, zOrigin, svgOrigin 33947 // a24 13 y, zOrigin, svgOrigin 33948 // a34 14 z, zOrigin 33949 // a44 15 33950 // rotation: Math.atan2(a21, a11) 33951 // rotationY: Math.atan2(a13, a33) (or Math.atan2(a13, a11)) 33952 // rotationX: Math.atan2(a32, a33) 33953 a33 = 1; 33954 a13 = a23 = a31 = a32 = a41 = a42 = 0; 33955 a43 = (perspective) ? -1 / perspective : 0; 33956 zOrigin = t.zOrigin; 33957 min = 0.000001; //threshold below which browsers use scientific notation which won't work. 33958 comma = ","; 33959 zero = "0"; 33960 angle = rotationY * _DEG2RAD; 33961 if (angle) { 33962 cos = Math.cos(angle); 33963 sin = Math.sin(angle);
33964 a31 = -sin; 33965 a41 = a43*-sin; 33966 a13 = a11*sin; 33967 a23 = a21*sin; 33968 a33 = cos; 33969 a43 *= cos; 33970 a11 *= cos; 33971 a21 *= cos; 33972 } 33973 angle = rotationX * _DEG2RAD; 33974 if (angle) { 33975 cos = Math.cos(angle); 33976 sin = Math.sin(angle); 33977 t1 = a12*cos+a13*sin; 33978 t2 = a22*cos+a23*sin; 33979 a32 = a33*sin; 33980 a42 = a43*sin; 33981 a13 = a12*-sin+a13*cos; 33982 a23 = a22*-sin+a23*cos; 33983 a33 = a33*cos; 33984 a43 = a43*cos; 33985 a12 = t1; 33986 a22 = t2; 33987 } 33988 if (sz !== 1) { 33989 a13*=sz; 33990 a23*=sz; 33991 a33*=sz; 33992 a43*=sz; 33993 } 33994 if (sy !== 1) { 33995 a12*=sy; 33996 a22*=sy; 33997 a32*=sy; 33998 a42*=sy; 33999 } 34000 if (sx !== 1) { 34001 a11*=sx; 34002 a21*=sx; 34003 a31*=sx; 34004 a41*=sx; 34005 } 34006 34007 if (zOrigin || isSVG) { 34008 if (zOrigin) { 34009 x += a13*-zOrigin; 34010 y += a23*-zOrigin; 34011 z += a33*-zOrigin+zOrigin; 34012 } 34013 if (isSVG) { //due to bugs in some browsers, we need to manage the transform-origin of SVG manually 34014 x += t.xOrigin - (t.xOrigin * a11 + t.yOrigin * a12) + t.xOffset; 34015 y += t.yOrigin - (t.xOrigin * a21 + t.yOrigin * a22) + t.yOffset; 34016 } 34017 if (x < min && x > -min) { 34018 x = zero; 34019 } 34020 if (y < min && y > -min) { 34021 y = zero; 34022 } 34023 if (z < min && z > -min) { 34024 z = 0; //don't use string because we calculate perspective later and need the number. 34025 } 34026 } 34027 34028 //optimized way of concatenating all the values into a string. If we do it all in one shot, it's slower because of the way browsers have to create temp strings and the way it affects memory. If we do it piece-by-piece with +=, it's a bit slower too. We found that doing it in these sized chunks works best overall: 34029 transform = ((t.xPercent || t.yPercent) ? "translate(" + t.xPercent + "%," + t.yPercent + "%) matrix3d(" : "matrix3d("); 34030 transform += ((a11 < min && a11 > -min) ? zero : a11) + comma + ((a21 < min && a21 > -min) ? zero : a21) + comma + ((a31 < min && a31 > -min) ? zero : a31); 34031 transform += comma + ((a41 < min && a41 > -min) ? zero : a41) + comma + ((a12 < min && a12 > -min) ? zero : a12) + comma + ((a22 < min && a22 > -min) ? zero : a22); 34032 if (rotationX || rotationY || sz !== 1) { //performance optimization (often there's no rotationX or rotationY, so we can skip these calculations) 34033 transform += comma + ((a32 < min && a32 > -min) ? zero : a32) + comma + ((a42 < min && a42 > -min) ? zero : a42) + comma + ((a13 < min && a13 > -min) ? zero : a13); 34034 transform += comma + ((a23 < min && a23 > -min) ? zero : a23) + comma + ((a33 < min && a33 > -min) ? zero : a33) + comma + ((a43 < min && a43 > -min) ? zero : a43) + comma; 34035 } else { 34036 transform += ",0,0,0,0,1,0,"; 34037 } 34038 transform += x + comma + y + comma + z + comma + (perspective ? (1 + (-z / perspective)) : 1) + ")"; 34039 34040 style[_transformProp] = transform; 34041 }; 34042 34043 p = Transform.prototype; 34044 p.x = p.y = p.z = p.skewX = p.skewY = p.rotation = p.rotationX = p.rotationY = p.zOrigin = p.xPercent = p.yPercent = p.xOffset = p.yOffset = 0; 34045 p.scaleX = p.scaleY = p.scaleZ = 1; 34046 34047 _registerComplexSpecialProp("transform,scale,scaleX,scaleY,scaleZ,x,y,z,rotation,rotationX,rotationY,rotationZ,skewX,skewY,shortRotation,shortRotationX,shortRotationY,shortRotationZ,transformOrigin,svgOrigin,transformPerspective,directionalRotation,parseTransform,force3D,skewType,xPercent,yPercent,smoothOrigin", {parser:function(t, e, parsingProp, cssp, pt, plugin, vars) { 34048 if (cssp._lastParsedTransform === vars) { return pt; } //only need to parse the transform once, and only if the browser supports it. 34049 cssp._lastParsedTransform = vars; 34050 var scaleFunc = (vars.scale && typeof(vars.scale) === "function") ? vars.scale : 0, //if there's a function-based "scale" value, swap in the resulting numeric value temporarily. Otherwise, if it's called for both scaleX and scaleY independently, they may not match (like if the function uses Math.random()). 34051 swapFunc; 34052 if (typeof(vars[parsingProp]) === "function") { //whatever property triggers the initial parsing might be a function-based value in which case it already got called in parse(), thus we don't want to call it again in here. The most efficient way to avoid this is to temporarily swap the value directly into the vars object, and then after we do all our parsing in this function, we'll swap it back again. 34053 swapFunc = vars[parsingProp]; 34054 vars[parsingProp] = e; 34055 } 34056 if (scaleFunc) { 34057 vars.scale = scaleFunc(_index, t); 34058 } 34059 var originalGSTransform = t._gsTransform, 34060 style = t.style, 34061 min = 0.000001, 34062 i = _transformProps.length, 34063 v = vars, 34064 endRotations = {}, 34065 transformOriginString = "transformOrigin", 34066 m1 = _getTransform(t, _cs, true, v.parseTransform), 34067 orig = v.transform && ((typeof(v.transform) === "function") ? v.transform(_index, _target) : v.transform), 34068 m2, copy, has3D, hasChange, dr, x, y, matrix, p; 34069 m1.skewType = v.skewType || m1.skewType || CSSPlugin.defaultSkewType; 34070 cssp._transform = m1; 34071 if (orig && typeof(orig) === "string" && _transformProp) { //for values like transform:"rotate(60deg) scale(0.5, 0.8)" 34072 copy = _tempDiv.style; //don't use the original target because it might be SVG in which case some browsers don't report computed style correctly. 34073 copy[_transformProp] = orig; 34074 copy.display = "block"; //if display is "none", the browser often refuses to report the transform properties correctly. 34075 copy.position = "absolute"; 34076 if (orig.indexOf("%") !== -1) { //%-based translations will fail unless we set the width/height to match the original target... 34077 copy.width = _getStyle(t, "width");
34078 copy.height = _getStyle(t, "height"); 34079 } 34080 _doc.body.appendChild(_tempDiv); 34081 m2 = _getTransform(_tempDiv, null, false); 34082 if (m1.skewType === "simple") { //the default _getTransform() reports the skewX/scaleY as if skewType is "compensated", thus we need to adjust that here if skewType is "simple". 34083 m2.scaleY *= Math.cos(m2.skewX * _DEG2RAD); 34084 } 34085 if (m1.svg) { //if it's an SVG element, x/y part of the matrix will be affected by whatever we use as the origin and the offsets, so compensate here... 34086 x = m1.xOrigin; 34087 y = m1.yOrigin; 34088 m2.x -= m1.xOffset; 34089 m2.y -= m1.yOffset; 34090 if (v.transformOrigin || v.svgOrigin) { //if this tween is altering the origin, we must factor that in here. The actual work of recording the transformOrigin values and setting up the PropTween is done later (still inside this function) so we cannot leave the changes intact here - we only want to update the x/y accordingly. 34091 orig = {}; 34092 _parseSVGOrigin(t, _parsePosition(v.transformOrigin), orig, v.svgOrigin, v.smoothOrigin, true); 34093 x = orig.xOrigin; 34094 y = orig.yOrigin; 34095 m2.x -= orig.xOffset - m1.xOffset; 34096 m2.y -= orig.yOffset - m1.yOffset; 34097 } 34098 if (x || y) { 34099 matrix = _getMatrix(_tempDiv, true); 34100 m2.x -= x - (x * matrix[0] + y * matrix[2]); 34101 m2.y -= y - (x * matrix[1] + y * matrix[3]); 34102 } 34103 } 34104 _doc.body.removeChild(_tempDiv); 34105 if (!m2.perspective) { 34106 m2.perspective = m1.perspective; //tweening to no perspective gives very unintuitive results - just keep the same perspective in that case. 34107 } 34108 if (v.xPercent != null) { 34109 m2.xPercent = _parseVal(v.xPercent, m1.xPercent); 34110 } 34111 if (v.yPercent != null) { 34112 m2.yPercent = _parseVal(v.yPercent, m1.yPercent); 34113 } 34114 } else if (typeof(v) === "object") { //for values like scaleX, scaleY, rotation, x, y, skewX, and skewY or transform:{...} (object) 34115 m2 = {scaleX:_parseVal((v.scaleX != null) ? v.scaleX : v.scale, m1.scaleX), 34116 scaleY:_parseVal((v.scaleY != null) ? v.scaleY : v.scale, m1.scaleY), 34117 scaleZ:_parseVal(v.scaleZ, m1.scaleZ), 34118 x:_parseVal(v.x, m1.x), 34119 y:_parseVal(v.y, m1.y), 34120 z:_parseVal(v.z, m1.z), 34121 xPercent:_parseVal(v.xPercent, m1.xPercent), 34122 yPercent:_parseVal(v.yPercent, m1.yPercent), 34123 perspective:_parseVal(v.transformPerspective, m1.perspective)}; 34124 dr = v.directionalRotation; 34125 if (dr != null) { 34126 if (typeof(dr) === "object") { 34127 for (copy in dr) { 34128 v[copy] = dr[copy]; 34129 } 34130 } else { 34131 v.rotation = dr; 34132 } 34133 } 34134 if (typeof(v.x) === "string" && v.x.indexOf("%") !== -1) { 34135 m2.x = 0; 34136 m2.xPercent = _parseVal(v.x, m1.xPercent); 34137 } 34138 if (typeof(v.y) === "string" && v.y.indexOf("%") !== -1) { 34139 m2.y = 0; 34140 m2.yPercent = _parseVal(v.y, m1.yPercent); 34141 } 34142 34143 m2.rotation = _parseAngle(("rotation" in v) ? v.rotation : ("shortRotation" in v) ? v.shortRotation + "_short" : ("rotationZ" in v) ? v.rotationZ : m1.rotation, m1.rotation, "rotation", endRotations); 34144 if (_supports3D) { 34145 m2.rotationX = _parseAngle(("rotationX" in v) ? v.rotationX : ("shortRotationX" in v) ? v.shortRotationX + "_short" : m1.rotationX || 0, m1.rotationX, "rotationX", endRotations); 34146 m2.rotationY = _parseAngle(("rotationY" in v) ? v.rotationY : ("shortRotationY" in v) ? v.shortRotationY + "_short" : m1.rotationY || 0, m1.rotationY, "rotationY", endRotations); 34147 } 34148 m2.skewX = _parseAngle(v.skewX, m1.skewX); 34149 m2.skewY = _parseAngle(v.skewY, m1.skewY); 34150 } 34151 if (_supports3D && v.force3D != null) { 34152 m1.force3D = v.force3D; 34153 hasChange = true; 34154 } 34155 34156 has3D = (m1.force3D || m1.z || m1.rotationX || m1.rotationY || m2.z || m2.rotationX || m2.rotationY || m2.perspective); 34157 if (!has3D && v.scale != null) { 34158 m2.scaleZ = 1; //no need to tween scaleZ. 34159 } 34160 34161 while (--i > -1) { 34162 p = _transformProps[i]; 34163 orig = m2[p] - m1[p]; 34164 if (orig > min || orig < -min || v[p] != null || _forcePT[p] != null) { 34165 hasChange = true; 34166 pt = new CSSPropTween(m1, p, m1[p], orig, pt); 34167 if (p in endRotations) { 34168 pt.e = endRotations[p]; //directional rotations typically have compensated values during the tween, but we need to make sure they end at exactly what the user requested 34169 } 34170 pt.xs0 = 0; //ensures the value stays numeric in setRatio() 34171 pt.plugin = plugin; 34172 cssp._overwriteProps.push(pt.n); 34173 } 34174 } 34175 34176 orig = v.transformOrigin; 34177 if (m1.svg && (orig || v.svgOrigin)) { 34178 x = m1.xOffset; //when we change the origin, in order to prevent things from jumping we adjust the x/y so we must record those here so that we can create PropTweens for them and flip them at the same time as the origin 34179 y = m1.yOffset; 34180 _parseSVGOrigin(t, _parsePosition(orig), m2, v.svgOrigin, v.smoothOrigin); 34181 pt = _addNonTweeningNumericPT(m1, "xOrigin", (originalGSTransform ? m1 : m2).xOrigin, m2.xOrigin, pt, transformOriginString); //note: if there wasn't a transformOrigin defined yet, just start with the destination one; it's wasteful otherwise, and it causes problems with fromTo() tweens. For example, TweenLite.to("#wheel", 3, {rotation:180, transformOrigin:"50% 50%", delay:1}); TweenLite.fromTo("#wheel", 3, {scale:0.5, transformOrigin:"50% 50%"}, {scale:1, delay:2}); would cause a jump when the from values revert at the beginning of the 2nd tween.
34182 pt = _addNonTweeningNumericPT(m1, "yOrigin", (originalGSTransform ? m1 : m2).yOrigin, m2.yOrigin, pt, transformOriginString); 34183 if (x !== m1.xOffset || y !== m1.yOffset) { 34184 pt = _addNonTweeningNumericPT(m1, "xOffset", (originalGSTransform ? x : m1.xOffset), m1.xOffset, pt, transformOriginString); 34185 pt = _addNonTweeningNumericPT(m1, "yOffset", (originalGSTransform ? y : m1.yOffset), m1.yOffset, pt, transformOriginString); 34186 } 34187 orig = "0px 0px"; //certain browsers (like firefox) completely botch transform-origin, so we must remove it to prevent it from contaminating transforms. We manage it ourselves with xOrigin and yOrigin 34188 } 34189 if (orig || (_supports3D && has3D && m1.zOrigin)) { //if anything 3D is happening and there's a transformOrigin with a z component that's non-zero, we must ensure that the transformOrigin's z-component is set to 0 so that we can manually do those calculations to get around Safari bugs. Even if the user didn't specifically define a "transformOrigin" in this particular tween (maybe they did it via css directly). 34190 if (_transformProp) { 34191 hasChange = true; 34192 p = _transformOriginProp; 34193 orig = (orig || _getStyle(t, p, _cs, false, "50% 50%")) + ""; //cast as string to avoid errors 34194 pt = new CSSPropTween(style, p, 0, 0, pt, -1, transformOriginString); 34195 pt.b = style[p]; 34196 pt.plugin = plugin; 34197 if (_supports3D) { 34198 copy = m1.zOrigin; 34199 orig = orig.split(" "); 34200 m1.zOrigin = ((orig.length > 2 && !(copy !== 0 && orig[2] === "0px")) ? parseFloat(orig[2]) : copy) || 0; //Safari doesn't handle the z part of transformOrigin correctly, so we'll manually handle it in the _set3DTransformRatio() method. 34201 pt.xs0 = pt.e = orig[0] + " " + (orig[1] || "50%") + " 0px"; //we must define a z value of 0px specifically otherwise iOS 5 Safari will stick with the old one (if one was defined)! 34202 pt = new CSSPropTween(m1, "zOrigin", 0, 0, pt, -1, pt.n); //we must create a CSSPropTween for the _gsTransform.zOrigin so that it gets reset properly at the beginning if the tween runs backward (as opposed to just setting m1.zOrigin here) 34203 pt.b = copy; 34204 pt.xs0 = pt.e = m1.zOrigin; 34205 } else { 34206 pt.xs0 = pt.e = orig; 34207 } 34208 34209 //for older versions of IE (6-8), we need to manually calculate things inside the setRatio() function. We record origin x and y (ox and oy) and whether or not the values are percentages (oxp and oyp). 34210 } else { 34211 _parsePosition(orig + "", m1); 34212 } 34213 } 34214 if (hasChange) { 34215 cssp._transformType = (!(m1.svg && _useSVGTransformAttr) && (has3D || this._transformType === 3)) ? 3 : 2; //quicker than calling cssp._enableTransforms(); 34216 } 34217 if (swapFunc) { 34218 vars[parsingProp] = swapFunc; 34219 } 34220 if (scaleFunc) { 34221 vars.scale = scaleFunc; 34222 } 34223 return pt; 34224 }, prefix:true}); 34225 34226 _registerComplexSpecialProp("boxShadow", {defaultValue:"0px 0px 0px 0px #999", prefix:true, color:true, multi:true, keyword:"inset"}); 34227 34228 _registerComplexSpecialProp("borderRadius", {defaultValue:"0px", parser:function(t, e, p, cssp, pt, plugin) { 34229 e = this.format(e); 34230 var props = ["borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius"], 34231 style = t.style, 34232 ea1, i, es2, bs2, bs, es, bn, en, w, h, esfx, bsfx, rel, hn, vn, em; 34233 w = parseFloat(t.offsetWidth); 34234 h = parseFloat(t.offsetHeight); 34235 ea1 = e.split(" "); 34236 for (i = 0; i < props.length; i++) { //if we're dealing with percentages, we must convert things separately for the horizontal and vertical axis! 34237 if (this.p.indexOf("border")) { //older browsers used a prefix 34238 props[i] = _checkPropPrefix(props[i]); 34239 } 34240 bs = bs2 = _getStyle(t, props[i], _cs, false, "0px"); 34241 if (bs.indexOf(" ") !== -1) { 34242 bs2 = bs.split(" "); 34243 bs = bs2[0]; 34244 bs2 = bs2[1]; 34245 } 34246 es = es2 = ea1[i]; 34247 bn = parseFloat(bs); 34248 bsfx = bs.substr((bn + "").length); 34249 rel = (es.charAt(1) === "="); 34250 if (rel) { 34251 en = parseInt(es.charAt(0)+"1", 10); 34252 es = es.substr(2); 34253 en *= parseFloat(es); 34254 esfx = es.substr((en + "").length - (en < 0 ? 1 : 0)) || ""; 34255 } else { 34256 en = parseFloat(es); 34257 esfx = es.substr((en + "").length); 34258 } 34259 if (esfx === "") { 34260 esfx = _suffixMap[p] || bsfx; 34261 } 34262 if (esfx !== bsfx) { 34263 hn = _convertToPixels(t, "borderLeft", bn, bsfx); //horizontal number (we use a bogus "borderLeft" property just because the _convertToPixels() method searches for the keywords "Left", "Right", "Top", and "Bottom" to determine of it's a horizontal or vertical property, and we need "border" in the name so that it knows it should measure relative to the element itself, not its parent. 34264 vn = _convertToPixels(t, "borderTop", bn, bsfx); //vertical number 34265 if (esfx === "%") { 34266 bs = (hn / w * 100) + "%"; 34267 bs2 = (vn / h * 100) + "%"; 34268 } else if (esfx === "em") { 34269 em = _convertToPixels(t, "borderLeft", 1, "em"); 34270 bs = (hn / em) + "em"; 34271 bs2 = (vn / em) + "em"; 34272 } else { 34273 bs = hn + "px"; 34274 bs2 = vn + "px"; 34275 } 34276 if (rel) { 34277 es = (parseFloat(bs) + en) + esfx; 34278 es2 = (parseFloat(bs2) + en) + esfx; 34279 } 34280 } 34281 pt = _parseComplex(style, props[i], bs + " " + bs2, es + " " + es2, false, "0px", pt); 34282 } 34283 return pt; 34284 }, prefix:true, formatter:_getFormatter("0px 0px 0px 0px", false, true)}); 34285 _registerComplexSpecialProp("borderBottomLeftRadius,borderBottomRightRadius,borderTopLeftRadius,borderTopRightRadius", {defaultValue:"0px", parser:function(t, e, p, cssp, pt, plugin) { 34286 return _parseComplex(t.style, p, this.format(_getStyle(t, p, _cs, false, "0px 0px")), this.format(e), false, "0px", pt); 34287 }, prefix:true, formatter:_getFormatter("0px 0px", false, true)}); 34288 _registerComplexSpecialProp("backgroundPosition", {defaultValue:"0 0", parser:function(t, e, p, cssp, pt, plugin) { 34289 var bp = "background-position", 34290 cs = (_cs || _getComputedStyle(t, null)), 34291 bs = this.format( ((cs) ? _ieVers ? cs.getPropertyValue(bp + "-x") + " " + cs.getPropertyValue(bp + "-y") : cs.getPropertyValue(bp) : t.currentStyle.backgroundPositionX + " " + t.currentStyle.backgroundPositionY) || "0 0"), //Internet Explorer doesn't report background-position correctly - we must query background-position-x and background-position-y and combine them (even in IE10). Before IE9, we must do the same with the currentStyle object and use camelCase 34292 es = this.format(e), 34293 ba, ea, i, pct, overlap, src; 34294 if ((bs.indexOf("%") !== -1) !== (es.indexOf("%") !== -1) && es.split(",").length < 2) { 34295 src = _getStyle(t, "backgroundImage").replace(_urlExp, ""); 34296 if (src && src !== "none") { 34297 ba = bs.split(" "); 34298 ea = es.split(" "); 34299 _tempImg.setAttribute("src", src); //set the temp IMG's src to the background-image so that we can measure its width/height 34300 i = 2; 34301 while (--i > -1) { 34302 bs = ba[i]; 34303 pct = (bs.indexOf("%") !== -1); 34304 if (pct !== (ea[i].indexOf("%") !== -1)) { 34305 overlap = (i === 0) ? t.offsetWidth - _tempImg.width : t.offsetHeight - _tempImg.height; 34306 ba[i] = pct ? (parseFloat(bs) / 100 * overlap) + "px" : (parseFloat(bs) / overlap * 100) + "%"; 34307 } 34308 } 34309 bs = ba.join(" "); 34310 } 34311 } 34312 return this.parseComplex(t.style, bs, es, pt, plugin); 34313 }, formatter:_parsePosition}); 34314 _registerComplexSpecialProp("backgroundSize", {defaultValue:"0 0", formatter:function(v) { 34315 v += ""; //ensure it's a string 34316 return (v.substr(0,2) === "co") ? v : _parsePosition(v.indexOf(" ") === -1 ? v + " " + v : v); //if set to something like "100% 100%", Safari typically reports the computed style as just "100%" (no 2nd value), but we should ensure that there are two values, so copy the first one. Otherwise, it'd be interpreted as "100% 0" (wrong). Also remember that it could be "cover" or "contain" which we can't tween but should be able to set. 34317 }}); 34318 _registerComplexSpecialProp("perspective", {defaultValue:"0px", prefix:true}); 34319 _registerComplexSpecialProp("perspectiveOrigin", {defaultValue:"50% 50%", prefix:true}); 34320 _registerComplexSpecialProp("transformStyle", {prefix:true}); 34321 _registerComplexSpecialProp("backfaceVisibility", {prefix:true}); 34322 _registerComplexSpecialProp("userSelect", {prefix:true}); 34323 _registerComplexSpecialProp("margin", {parser:_getEdgeParser("marginTop,marginRight,marginBottom,marginLeft")}); 34324 _registerComplexSpecialProp("padding", {parser:_getEdgeParser("paddingTop,paddingRight,paddingBottom,paddingLeft")}); 34325 _registerComplexSpecialProp("clip", {defaultValue:"rect(0px,0px,0px,0px)", parser:function(t, e, p, cssp, pt, plugin){ 34326 var b, cs, delim; 34327 if (_ieVers < 9) { //IE8 and earlier don't report a "clip" value in the currentStyle - instead, the values are split apart into clipTop, clipRight, clipBottom, and clipLeft. Also, in IE7 and earlier, the values inside rect() are space-delimited, not comma-delimited. 34328 cs = t.currentStyle; 34329 delim = _ieVers < 8 ? " " : ","; 34330 b = "rect(" + cs.clipTop + delim + cs.clipRight + delim + cs.clipBottom + delim + cs.clipLeft + ")"; 34331 e = this.format(e).split(",").join(delim); 34332 } else { 34333 b = this.format(_getStyle(t, this.p, _cs, false, this.dflt)); 34334 e = this.format(e); 34335 } 34336 return this.parseComplex(t.style, b, e, pt, plugin); 34337 }}); 34338 _registerComplexSpecialProp("textShadow", {defaultValue:"0px 0px 0px #999", color:true, multi:true}); 34339 _registerComplexSpecialProp("autoRound,strictUnits", {parser:function(t, e, p, cssp, pt) {return pt;}}); //just so that we can ignore these properties (not tween them) 34340 _registerComplexSpecialProp("border", {defaultValue:"0px solid #000", parser:function(t, e, p, cssp, pt, plugin) { 34341 var bw = _getStyle(t, "borderTopWidth", _cs, false, "0px"), 34342 end = this.format(e).split(" "), 34343 esfx = end[0].replace(_suffixExp, ""); 34344 if (esfx !== "px") { //if we're animating to a non-px value, we need to convert the beginning width to that unit. 34345 bw = (parseFloat(bw) / _convertToPixels(t, "borderTopWidth", 1, esfx)) + esfx; 34346 } 34347 return this.parseComplex(t.style, this.format(bw + " " + _getStyle(t, "borderTopStyle", _cs, false, "solid") + " " + _getStyle(t, "borderTopColor", _cs, false, "#000")), end.join(" "), pt, plugin); 34348 }, color:true, formatter:function(v) { 34349 var a = v.split(" "); 34350 return a[0] + " " + (a[1] || "solid") + " " + (v.match(_colorExp) || ["#000"])[0]; 34351 }}); 34352 _registerComplexSpecialProp("borderWidth", {parser:_getEdgeParser("borderTopWidth,borderRightWidth,borderBottomWidth,borderLeftWidth")}); //Firefox doesn't pick up on borderWidth set in style sheets (only inline). 34353 _registerComplexSpecialProp("float,cssFloat,styleFloat", {parser:function(t, e, p, cssp, pt, plugin) { 34354 var s = t.style, 34355 prop = ("cssFloat" in s) ? "cssFloat" : "styleFloat"; 34356 return new CSSPropTween(s, prop, 0, 0, pt, -1, p, false, 0, s[prop], e); 34357 }}); 34358 34359 //opacity-related 34360 var _setIEOpacityRatio = function(v) { 34361 var t = this.t, //refers to the element's style property 34362 filters = t.filter || _getStyle(this.data, "filter") || "", 34363 val = (this.s + this.c * v) | 0, 34364 skip; 34365 if (val === 100) { //for older versions of IE that need to use a filter to apply opacity, we should remove the filter if opacity hits 1 in order to improve performance, but make sure there isn't a transform (matrix) or gradient in the filters. 34366 if (filters.indexOf("atrix(") === -1 && filters.indexOf("radient(") === -1 && filters.indexOf("oader(") === -1) { 34367 t.removeAttribute("filter"); 34368 skip = (!_getStyle(this.data, "filter")); //if a class is applied that has an alpha filter, it will take effect (we don't want that), so re-apply our alpha filter in that case. We must first remove it and then check. 34369 } else {
34370 t.filter = filters.replace(_alphaFilterExp, ""); 34371 skip = true; 34372 } 34373 } 34374 if (!skip) { 34375 if (this.xn1) { 34376 t.filter = filters = filters || ("alpha(opacity=" + val + ")"); //works around bug in IE7/8 that prevents changes to "visibility" from being applied properly if the filter is changed to a different alpha on the same frame. 34377 } 34378 if (filters.indexOf("pacity") === -1) { //only used if browser doesn't support the standard opacity style property (IE 7 and 8). We omit the "O" to avoid case-sensitivity issues 34379 if (val !== 0 || !this.xn1) { //bugs in IE7/8 won't render the filter properly if opacity is ADDED on the same frame/render as "visibility" changes (this.xn1 is 1 if this tween is an "autoAlpha" tween) 34380 t.filter = filters + " alpha(opacity=" + val + ")"; //we round the value because otherwise, bugs in IE7/8 can prevent "visibility" changes from being applied properly. 34381 } 34382 } else { 34383 t.filter = filters.replace(_opacityExp, "opacity=" + val); 34384 } 34385 } 34386 }; 34387 _registerComplexSpecialProp("opacity,alpha,autoAlpha", {defaultValue:"1", parser:function(t, e, p, cssp, pt, plugin) { 34388 var b = parseFloat(_getStyle(t, "opacity", _cs, false, "1")), 34389 style = t.style, 34390 isAutoAlpha = (p === "autoAlpha"); 34391 if (typeof(e) === "string" && e.charAt(1) === "=") { 34392 e = ((e.charAt(0) === "-") ? -1 : 1) * parseFloat(e.substr(2)) + b; 34393 } 34394 if (isAutoAlpha && b === 1 && _getStyle(t, "visibility", _cs) === "hidden" && e !== 0) { //if visibility is initially set to "hidden", we should interpret that as intent to make opacity 0 (a convenience) 34395 b = 0; 34396 } 34397 if (_supportsOpacity) { 34398 pt = new CSSPropTween(style, "opacity", b, e - b, pt); 34399 } else { 34400 pt = new CSSPropTween(style, "opacity", b * 100, (e - b) * 100, pt); 34401 pt.xn1 = isAutoAlpha ? 1 : 0; //we need to record whether or not this is an autoAlpha so that in the setRatio(), we know to duplicate the setting of the alpha in order to work around a bug in IE7 and IE8 that prevents changes to "visibility" from taking effect if the filter is changed to a different alpha(opacity) at the same time. Setting it to the SAME value first, then the new value works around the IE7/8 bug. 34402 style.zoom = 1; //helps correct an IE issue. 34403 pt.type = 2; 34404 pt.b = "alpha(opacity=" + pt.s + ")"; 34405 pt.e = "alpha(opacity=" + (pt.s + pt.c) + ")"; 34406 pt.data = t; 34407 pt.plugin = plugin; 34408 pt.setRatio = _setIEOpacityRatio; 34409 } 34410 if (isAutoAlpha) { //we have to create the "visibility" PropTween after the opacity one in the linked list so that they run in the order that works properly in IE8 and earlier 34411 pt = new CSSPropTween(style, "visibility", 0, 0, pt, -1, null, false, 0, ((b !== 0) ? "inherit" : "hidden"), ((e === 0) ? "hidden" : "inherit")); 34412 pt.xs0 = "inherit"; 34413 cssp._overwriteProps.push(pt.n); 34414 cssp._overwriteProps.push(p); 34415 } 34416 return pt; 34417 }}); 34418 34419 34420 var _removeProp = function(s, p) { 34421 if (p) { 34422 if (s.removeProperty) { 34423 if (p.substr(0,2) === "ms" || p.substr(0,6) === "webkit") { //Microsoft and some Webkit browsers don't conform to the standard of capitalizing the first prefix character, so we adjust so that when we prefix the caps with a dash, it's correct (otherwise it'd be "ms-transform" instead of "-ms-transform" for IE9, for example) 34424 p = "-" + p; 34425 } 34426 s.removeProperty(p.replace(_capsExp, "-$1").toLowerCase()); 34427 } else { //note: old versions of IE use "removeAttribute()" instead of "removeProperty()" 34428 s.removeAttribute(p); 34429 } 34430 } 34431 }, 34432 _setClassNameRatio = function(v) { 34433 this.t._gsClassPT = this; 34434 if (v === 1 || v === 0) { 34435 this.t.setAttribute("class", (v === 0) ? this.b : this.e); 34436 var mpt = this.data, //first MiniPropTween 34437 s = this.t.style; 34438 while (mpt) { 34439 if (!mpt.v) { 34440 _removeProp(s, mpt.p); 34441 } else { 34442 s[mpt.p] = mpt.v; 34443 } 34444 mpt = mpt._next; 34445 } 34446 if (v === 1 && this.t._gsClassPT === this) { 34447 this.t._gsClassPT = null; 34448 } 34449 } else if (this.t.getAttribute("class") !== this.e) { 34450 this.t.setAttribute("class", this.e); 34451 } 34452 }; 34453 _registerComplexSpecialProp("className", {parser:function(t, e, p, cssp, pt, plugin, vars) { 34454 var b = t.getAttribute("class") || "", //don't use t.className because it doesn't work consistently on SVG elements; getAttribute("class") and setAttribute("class", value") is more reliable. 34455 cssText = t.style.cssText, 34456 difData, bs, cnpt, cnptLookup, mpt; 34457 pt = cssp._classNamePT = new CSSPropTween(t, p, 0, 0, pt, 2); 34458 pt.setRatio = _setClassNameRatio; 34459 pt.pr = -11; 34460 _hasPriority = true; 34461 pt.b = b; 34462 bs = _getAllStyles(t, _cs); 34463 //if there's a className tween already operating on the target, force it to its end so that the necessary inline styles are removed and the class name is applied before we determine the end state (we don't want inline styles interfer
34463ing that were there just for class-specific values) 34464 cnpt = t._gsClassPT; 34465 if (cnpt) { 34466 cnptLookup = {}; 34467 mpt = cnpt.data; //first MiniPropTween which stores the inline styles - we need to force these so that the inline styles don't contaminate things. Otherwise, there's a small chance that a tween could start and the inline values match the destination values and they never get cleaned. 34468 while (mpt) { 34469 cnptLookup[mpt.p] = 1; 34470 mpt = mpt._next; 34471 } 34472 cnpt.setRatio(1); 34473 } 34474 t._gsClassPT = pt; 34475 pt.e = (e.charAt(1) !== "=") ? e : b.replace(new RegExp("(?:\\s|^)" + e.substr(2) + "(?![\\w-])"), "") + ((e.charAt(0) === "+") ? " " + e.substr(2) : ""); 34476 t.setAttribute("class", pt.e); 34477 difData = _cssDif(t, bs, _getAllStyles(t), vars, cnptLookup); 34478 t.setAttribute("class", b); 34479 pt.data = difData.firstMPT; 34480 t.style.cssText = cssText; //we recorded cssText before we swapped classes and ran _getAllStyles() because in cases when a className tween is overwritten, we remove all the related tweening properties from that class change (otherwise class-specific stuff can't override properties we've directly set on the target's style object due to specificity). 34481 pt = pt.xfirst = cssp.parse(t, difData.difs, pt, plugin); //we record the CSSPropTween as the xfirst so that we can handle overwriting propertly (if "className" gets overwritten, we must kill all the properties associated with the className part of the tween, so we can loop through from xfirst to the pt itself) 34482 return pt; 34483 }}); 34484 34485 34486 var _setClearPropsRatio = function(v) { 34487 if (v === 1 || v === 0) if (this.data._totalTime === this.data._totalDuration && this.data.data !== "isFromStart") { //this.data refers to the tween. Only clear at the END of the tween (remember, from() tweens make the ratio go from 1 to 0, so we can't just check that and if the tween is the zero-duration one that's created internally to render the starting values in a from() tween, ignore that because otherwise, for example, from(...{height:100, clearProps:"height", delay:1}) would wipe the height at the beginning of the tween and after 1 second, it'd kick back in). 34488 var s = this.t.style, 34489 transformParse = _specialProps.transform.parse, 34490 a, p, i, clearTransform, transform; 34491 if (this.e === "all") { 34492 s.cssText = ""; 34493 clearTransform = true; 34494 } else { 34495 a = this.e.split(" ").join("").split(","); 34496 i = a.length; 34497 while (--i > -1) { 34498 p = a[i]; 34499 if (_specialProps[p]) { 34500 if (_specialProps[p].parse === transformParse) { 34501 clearTransform = true; 34502 } else { 34503 p = (p === "transformOrigin") ? _transformOriginProp : _specialProps[p].p; //ensures that special properties use the proper browser-specific property name, like "scaleX" might be "-webkit-transform" or "boxShadow" might be "-moz-box-shadow" 34504 } 34505 } 34506 _removeProp(s, p); 34507 } 34508 } 34509 if (clearTransform) { 34510 _removeProp(s, _transformProp); 34511 transform = this.t._gsTransform; 34512 if (transform) { 34513 if (transform.svg) { 34514 this.t.removeAttribute("data-svg-origin"); 34515 this.t.removeAttribute("transform"); 34516 } 34517 delete this.t._gsTransform; 34518 } 34519 } 34520 34521 } 34522 }; 34523 _registerComplexSpecialProp("clearProps", {parser:function(t, e, p, cssp, pt) { 34524 pt = new CSSPropTween(t, p, 0, 0, pt, 2); 34525 pt.setRatio = _setClearPropsRatio; 34526 pt.e = e; 34527 pt.pr = -10; 34528 pt.data = cssp._tween; 34529 _hasPriority = true; 34530 return pt; 34531 }}); 34532 34533 p = "bezier,throwProps,physicsProps,physics2D".split(","); 34534 i = p.length; 34535 while (i--) { 34536 _registerPluginProp(p[i]); 34537 } 34538 34539 34540 34541 34542 34543 34544 34545 34546 p = CSSPlugin.prototype; 34547 p._firstPT = p._lastParsedTransform = p._transform = null; 34548 34549 //gets called when the tween renders for the first time. This kicks everything off, recording start/end values, etc. 34550 p._onInitTween = function(target, vars, tween, index) { 34551 if (!target.nodeType) { //css is only for dom elements 34552 return false; 34553 } 34554 this._target = _target = target; 34555 this._tween = tween; 34556 this._vars = vars; 34557 _index = index; 34558 _autoRound = vars.autoRound; 34559 _hasPriority = false;
34560 _suffixMap = vars.suffixMap || CSSPlugin.suffixMap; 34561 _cs = _getComputedStyle(target, ""); 34562 _overwriteProps = this._overwriteProps; 34563 var style = target.style, 34564 v, pt, pt2, first, last, next, zIndex, tpt, threeD; 34565 if (_reqSafariFix) if (style.zIndex === "") { 34566 v = _getStyle(target, "zIndex", _cs); 34567 if (v === "auto" || v === "") { 34568 //corrects a bug in [non-Android] Safari that prevents it from repainting elements in their new positions if they don't have a zIndex set. We also can't just apply this inside _parseTransform() because anything that's moved in any way (like using "left" or "top" instead of transforms like "x" and "y") can be affected, so it is best to ensure that anything that's tweening has a z-index. Setting "WebkitPerspective" to a non-zero value worked too except that on iOS Safari things would flicker randomly. Plus zIndex is less memory-intensive. 34569 this._addLazySet(style, "zIndex", 0); 34570 } 34571 } 34572 34573 if (typeof(vars) === "string") { 34574 first = style.cssText; 34575 v = _getAllStyles(target, _cs); 34576 style.cssText = first + ";" + vars; 34577 v = _cssDif(target, v, _getAllStyles(target)).difs; 34578 if (!_supportsOpacity && _opacityValExp.test(vars)) { 34579 v.opacity = parseFloat( RegExp.$1 ); 34580 } 34581 vars = v; 34582 style.cssText = first; 34583 } 34584 34585 if (vars.className) { //className tweens will combine any differences they find in the css with the vars that are passed in, so {className:"myClass", scale:0.5, left:20} would work. 34586 this._firstPT = pt = _specialProps.className.parse(target, vars.className, "className", this, null, null, vars); 34587 } else { 34588 this._firstPT = pt = this.parse(target, vars, null); 34589 } 34590 34591 if (this._transformType) { 34592 threeD = (this._transformType === 3); 34593 if (!_transformProp) { 34594 style.zoom = 1; //helps correct an IE issue. 34595 } else if (_isSafari) { 34596 _reqSafariFix = true; 34597 //if zIndex isn't set, iOS Safari doesn't repaint things correctly sometimes (seemingly at random). 34598 if (style.zIndex === "") { 34599 zIndex = _getStyle(target, "zIndex", _cs); 34600 if (zIndex === "auto" || zIndex === "") { 34601 this._addLazySet(style, "zIndex", 0); 34602 } 34603 } 34604 //Setting WebkitBackfaceVisibility corrects 3 bugs: 34605 // 1) [non-Android] Safari skips rendering changes to "top" and "left" that are made on the same frame/render as a transform update. 34606 // 2) iOS Safari sometimes neglects to repaint elements in their new positions. Setting "WebkitPerspective" to a non-zero value worked too except that on iOS Safari things would flicker randomly. 34607 // 3) Safari sometimes displayed odd artifacts when tweening the transform (or WebkitTransform) property, like ghosts of the edges of the element remained. Definitely a browser bug. 34608 //Note: we allow the user to override the auto-setting by defining WebkitBackfaceVisibility in the vars of the tween. 34609 if (_isSafariLT6) { 34610 this._addLazySet(style, "WebkitBackfaceVisibility", this._vars.WebkitBackfaceVisibility || (threeD ? "visible" : "hidden")); 34611 } 34612 } 34613 pt2 = pt; 34614 while (pt2 && pt2._next) { 34615 pt2 = pt2._next; 34616 } 34617 tpt = new CSSPropTween(target, "transform", 0, 0, null, 2); 34618 this._linkCSSP(tpt, null, pt2); 34619 tpt.setRatio = _transformProp ? _setTransformRatio : _setIETransformRatio; 34620 tpt.data = this._transform || _getTransform(target, _cs, true); 34621 tpt.tween = tween; 34622 tpt.pr = -1; //ensures that the transforms get applied after the components are updated. 34623 _overwriteProps.pop(); //we don't want to force the overwrite of all "transform" tweens of the target - we only care about individual transform properties like scaleX, rotation, etc. The CSSPropTween constructor automatically adds the property to _overwriteProps which is why we need to pop() here. 34624 } 34625 34626 if (_hasPriority) { 34627 //reorders the linked list in order of pr (priority) 34628 while (pt) { 34629 next = pt._next; 34630 pt2 = first; 34631 while (pt2 && pt2.pr > pt.pr) { 34632 pt2 = pt2._next; 34633 } 34634 if ((pt._prev = pt2 ? pt2._prev : last)) { 34635 pt._prev._next = pt; 34636 } else { 34637 first = pt; 34638 } 34639 if ((pt._next = pt2)) { 34640 pt2._prev = pt; 34641 } else { 34642 last = pt; 34643 } 34644 pt = next; 34645 } 34646 this._firstPT = first; 34647 } 34648 return true; 34649 }; 34650 34651 34652 p.parse = function(target, vars, pt, plugin) { 34653 var style = target.style, 34654 p, sp, bn, en, bs, es, bsfx, esfx, isStr, rel; 34655 for (p in vars) { 34656 es = vars[p]; //ending value string 34657 if (typeof(es) === "function") { 34658 es = es(_index, _target); 34659 } 34660 sp = _specialProps[p]; //SpecialProp lookup. 34661 if (sp) { 34662 pt = sp.parse(target, es, p, this, pt, plugin, vars); 34663 } else if (p.substr(0,2) === "--") { //for tweening CSS variables (which always start with "--"). To maximize performance and simplicity, we bypass CSSPlugin altogether and just add a normal property tween to the tween instance itself. 34664 this._tween._propLookup[p] = this._addTween.call(this._tween, target.style, "setProperty", _getComputedStyle(target).getPropertyValue(p) + "", es + "", p, false, p); 34665 continue; 34666 } else { 34667 bs = _getStyle(target, p, _cs) + ""; 34668 isStr = (typeof(es) === "string"); 34669 if (p === "color" || p === "fill" || p === "stroke" || p.indexOf("Color") !== -1 || (isStr && _rgbhslExp.test(es))) { //Opera uses background: to define color sometimes in addition to backgroundColor: 34670 if (!isStr) { 34671 es = _parseColor(es); 34672 es = ((es.length > 3) ? "rgba(" : "rgb(") + es.join(",") + ")"; 34673 } 34674 pt = _parseComplex(style, p, bs, es, true, "transparent", pt, 0, plugin); 34675 34676 } else if (isStr && _complexExp.test(es)) { 34677 pt = _parseComplex(style, p, bs, es, true, null, pt, 0, plugin); 34678 34679 } else { 34680 bn = parseFloat(bs); 34681 bsfx = (bn || bn === 0) ? bs.substr((bn + "").length) : ""; //remember, bs could be non-numeric like "normal" for fontWeight, so we should default to a blank suffix in that case. 34682 34683 if (bs === "" || bs === "auto") { 34684 if (p === "width" || p === "height") { 34685 bn = _getDimension(target, p, _cs); 34686 bsfx = "px"; 34687 } else if (p === "left" || p === "top") {
34688 bn = _calculateOffset(target, p, _cs); 34689 bsfx = "px"; 34690 } else { 34691 bn = (p !== "opacity") ? 0 : 1; 34692 bsfx = ""; 34693 } 34694 } 34695 34696 rel = (isStr && es.charAt(1) === "="); 34697 if (rel) { 34698 en = parseInt(es.charAt(0) + "1", 10); 34699 es = es.substr(2); 34700 en *= parseFloat(es); 34701 esfx = es.replace(_suffixExp, ""); 34702 } else { 34703 en = parseFloat(es); 34704 esfx = isStr ? es.replace(_suffixExp, "") : ""; 34705 } 34706 34707 if (esfx === "") { 34708 esfx = (p in _suffixMap) ? _suffixMap[p] : bsfx; //populate the end suffix, prioritizing the map, then if none is found, use the beginning suffix. 34709 } 34710 34711 es = (en || en === 0) ? (rel ? en + bn : en) + esfx : vars[p]; //ensures that any += or -= prefixes are taken care of. Record the end value before normalizing the suffix because we always want to end the tween on exactly what they intended even if it doesn't match the beginning value's suffix. 34712 //if the beginning/ending suffixes don't match, normalize them... 34713 if (bsfx !== esfx) if (esfx !== "" || p === "lineHeight") if (en || en === 0) if (bn) { //note: if the beginning value (bn) is 0, we don't need to convert units! 34714 bn = _convertToPixels(target, p, bn, bsfx); 34715 if (esfx === "%") { 34716 bn /= _convertToPixels(target, p, 100, "%") / 100; 34717 if (vars.strictUnits !== true) { //some browsers report only "px" values instead of allowing "%" with getComputedStyle(), so we assume that if we're tweening to a %, we should start there too unless strictUnits:true is defined. This approach is particularly useful for responsive designs that use from() tweens. 34718 bs = bn + "%"; 34719 } 34720 34721 } else if (esfx === "em" || esfx === "rem" || esfx === "vw" || esfx === "vh") { 34722 bn /= _convertToPixels(target, p, 1, esfx); 34723 34724 //otherwise convert to pixels. 34725 } else if (esfx !== "px") { 34726 en = _convertToPixels(target, p, en, esfx); 34727 esfx = "px"; //we don't use bsfx after this, so we don't need to set it to px too. 34728 } 34729 if (rel) if (en || en === 0) { 34730 es = (en + bn) + esfx; //the changes we made affect relative calculations, so adjust the end value here. 34731 } 34732 } 34733 34734 if (rel) { 34735 en += bn; 34736 } 34737 34738 if ((bn || bn === 0) && (en || en === 0)) { //faster than isNaN(). Also, previously we required en !== bn but that doesn't really gain much performance and it prevents _parseToProxy() from working properly if beginning and ending values match but need to get tweened by an external plugin anyway. For example, a bezier tween where the target starts at left:0 and has these points: [{left:50},{left:0}] wouldn't work properly because when parsing the last point, it'd match the first (current) one and a non-tweening CSSPropTween would be recorded when we actually need a normal tween (type:0) so that things get updated during the tween properly. 34739 pt = new CSSPropTween(style, p, bn, en - bn, pt, 0, p, (_autoRound !== false && (esfx === "px" || p === "zIndex")), 0, bs, es); 34740 pt.xs0 = esfx; 34741 //DEBUG: _log("tween "+p+" from "+pt.b+" ("+bn+esfx+") to "+pt.e+" with suffix: "+pt.xs0); 34742 } else if (style[p] === undefined || !es && (es + "" === "NaN" || es == null)) { 34743 _log("invalid " + p + " tween value: " + vars[p]); 34744 } else { 34745 pt = new CSSPropTween(style, p, en || bn || 0, 0, pt, -1, p, false, 0, bs, es); 34746 pt.xs0 = (es === "none" && (p === "display" || p.indexOf("Style") !== -1)) ? bs : es; //intermediate value should typically be set immediately (end value) except for "display" or things like borderTopStyle, borderBottomStyle, etc. which should use the beginning value during the tween. 34747 //DEBUG: _log("non-tweening value "+p+": "+pt.xs0); 34748 } 34749 } 34750 } 34751 if (plugin) if (pt && !pt.plugin) { 34752 pt.plugin = plugin; 34753 } 34754 } 34755 return pt; 34756 }; 34757 34758 34759 //gets called every time the tween updates, passing the new ratio (typically a value between 0 and 1, but not always (for example, if an Elastic.easeOut is used, the value can jump above 1 mid-tween). It will always start and 0 and end at 1. 34760 p.setRatio = function(v) { 34761 var pt = this._firstPT, 34762 min = 0.000001, 34763 val, str, i; 34764 //at the end of the tween, we set the values to exactly what we received in order to make sure non-tweening values (like "position" or "float" or whatever) are set and so that if the beginning/ending suffixes (units) didn't match and we normalized to px, the value that the user passed in is used here. We check to see if the tween is at its beginning in case it's a from() tween in which case the ratio will actually go from 1 to 0 over the course of the tween (backwards). 34765 if (v === 1 && (this._tween._time === this._tween._duration || this._tween._time === 0)) { 34766 while (pt) { 34767 if (pt.type !== 2) { 34768 if (pt.r && pt.type !== -1) { 34769 val = pt.r(pt.s + pt.c); 34770 if (!pt.type) { 34771 pt.t[pt.p] = val + pt.xs0; 34772 } else if (pt.type === 1) { //complex value (one that typically has multiple numbers inside a string, like "rect(5px,10px,20px,25px)" 34773 i = pt.l; 34774 str = pt.xs0 + val + pt.xs1; 34775 for (i = 1; i < pt.l; i++) {
34776 str += pt["xn"+i] + pt["xs"+(i+1)]; 34777 } 34778 pt.t[pt.p] = str; 34779 } 34780 } else { 34781 pt.t[pt.p] = pt.e; 34782 } 34783 } else { 34784 pt.setRatio(v); 34785 } 34786 pt = pt._next; 34787 } 34788 34789 } else if (v || !(this._tween._time === this._tween._duration || this._tween._time === 0) || this._tween._rawPrevTime === -0.000001) { 34790 while (pt) { 34791 val = pt.c * v + pt.s; 34792 if (pt.r) { 34793 val = pt.r(val); 34794 } else if (val < min) if (val > -min) { 34795 val = 0; 34796 } 34797 if (!pt.type) { 34798 pt.t[pt.p] = val + pt.xs0; 34799 } else if (pt.type === 1) { //complex value (one that typically has multiple numbers inside a string, like "rect(5px,10px,20px,25px)" 34800 i = pt.l; 34801 if (i === 2) { 34802 pt.t[pt.p] = pt.xs0 + val + pt.xs1 + pt.xn1 + pt.xs2; 34803 } else if (i === 3) { 34804 pt.t[pt.p] = pt.xs0 + val + pt.xs1 + pt.xn1 + pt.xs2 + pt.xn2 + pt.xs3; 34805 } else if (i === 4) { 34806 pt.t[pt.p] = pt.xs0 + val + pt.xs1 + pt.xn1 + pt.xs2 + pt.xn2 + pt.xs3 + pt.xn3 + pt.xs4; 34807 } else if (i === 5) { 34808 pt.t[pt.p] = pt.xs0 + val + pt.xs1 + pt.xn1 + pt.xs2 + pt.xn2 + pt.xs3 + pt.xn3 + pt.xs4 + pt.xn4 + pt.xs5; 34809 } else { 34810 str = pt.xs0 + val + pt.xs1; 34811 for (i = 1; i < pt.l; i++) { 34812 str += pt["xn"+i] + pt["xs"+(i+1)]; 34813 } 34814 pt.t[pt.p] = str; 34815 } 34816 34817 } else if (pt.type === -1) { //non-tweening value 34818 pt.t[pt.p] = pt.xs0; 34819 34820 } else if (pt.setRatio) { //custom setRatio() for things like SpecialProps, external plugins, etc. 34821 pt.setRatio(v); 34822 } 34823 pt = pt._next; 34824 } 34825 34826 //if the tween is reversed all the way back to the beginning, we need to restore the original values which may have different units (like % instead of px or em or whatever). 34827 } else { 34828 while (pt) { 34829 if (pt.type !== 2) { 34830 pt.t[pt.p] = pt.b; 34831 } else { 34832 pt.setRatio(v); 34833 } 34834 pt = pt._next; 34835 } 34836 } 34837 }; 34838 34839 /** 34840 * @private 34841 * Forces rendering of the target's transforms (rotation, scale, etc.) whenever the CSSPlugin's setRatio() is called. 34842 * Basically, this tells the CSSPlugin to create a CSSPropTween (type 2) after instantiation that runs last in the linked 34843 * list and calls the appropriate (3D or 2D) rendering function. We separate this into its own method so that we can call 34844 * it from other plugins like BezierPlugin if, for example, it needs to apply an autoRotation and this CSSPlugin 34845 * doesn't have any transform-related properties of its own. You can call this method as many times as you 34846 * want and it won't create duplicate CSSPropTweens. 34847 * 34848 * @param {boolean} threeD if true, it should apply 3D tweens (otherwise, just 2D ones are fine and typically faster) 34849 */ 34850 p._enableTransforms = function(threeD) { 34851 this._transform = this._transform || _getTransform(this._target, _cs, true); //ensures that the element has a _gsTransform property with the appropriate values. 34852 this._transformType = (!(this._transform.svg && _useSVGTransformAttr) && (threeD || this._transformType === 3)) ? 3 : 2; 34853 }; 34854 34855 var lazySet = function(v) { 34856 this.t[this.p] = this.e; 34857 this.data._linkCSSP(this, this._next, null, true); //we purposefully keep this._next even though it'd make sense to null it, but this is a performance optimization, as this happens during the while (pt) {} loop in setRatio() at the bottom of which it sets pt = pt._next, so if we null it, the linked list will be broken in that loop. 34858 }; 34859 /** @private Gives us a way to set a value on the first render (and only the first render). **/ 34860 p._addLazySet = function(t, p, v) { 34861 var pt = this._firstPT = new CSSPropTween(t, p, 0, 0, this._firstPT, 2); 34862 pt.e = v; 34863 pt.setRatio = lazySet; 34864 pt.data = this; 34865 }; 34866 34867 /** @private **/ 34868 p._linkCSSP = function(pt, next, prev, remove) { 34869 if (pt) { 34870 if (next) { 34871 next._prev = pt; 34872 } 34873 if (pt._next) { 34874 pt._next._prev = pt._prev; 34875 } 34876 if (pt._prev) { 34877 pt._prev._next = pt._next; 34878 } else if (this._firstPT === pt) { 34879 this._firstPT = pt._next; 34880 remove = true; //just to prevent resetting this._firstPT 5 lines down in case pt._next is null. (optimized for speed) 34881 } 34882 if (prev) { 34883 prev._next = pt; 34884 } else if (!remove && this._firstPT === null) { 34885 this._firstPT = pt; 34886 } 34887 pt._next = next; 34888 pt._prev = prev; 34889 } 34890 return pt; 34891 }; 34892 34893 p._mod = function(lookup) { 34894 var pt = this._firstPT; 34895 while (pt) { 34896 if (typeof(lookup[pt.p]) === "function") { //only gets called by RoundPropsPlugin (ModifyPlugin manages all the rendering internally for CSSPlugin properties that need modification). Remember, we handle rounding a bit differently in this plugin for performance reasons, leveraging "r" as an indicator that the value should be roun
34896ded internally. 34897 pt.r = lookup[pt.p]; 34898 } 34899 pt = pt._next; 34900 } 34901 }; 34902 34903 //we need to make sure that if alpha or autoAlpha is killed, opacity is too. And autoAlpha affects the "visibility" property. 34904 p._kill = function(lookup) { 34905 var copy = lookup, 34906 pt, p, xfirst; 34907 if (lookup.autoAlpha || lookup.alpha) { 34908 copy = {}; 34909 for (p in lookup) { //copy the lookup so that we're not changing the original which may be passed elsewhere. 34910 copy[p] = lookup[p]; 34911 } 34912 copy.opacity = 1; 34913 if (copy.autoAlpha) { 34914 copy.visibility = 1; 34915 } 34916 } 34917 if (lookup.className && (pt = this._classNamePT)) { //for className tweens, we need to kill any associated CSSPropTweens too; a linked list starts at the className's "xfirst". 34918 xfirst = pt.xfirst; 34919 if (xfirst && xfirst._prev) { 34920 this._linkCSSP(xfirst._prev, pt._next, xfirst._prev._prev); //break off the prev 34921 } else if (xfirst === this._firstPT) { 34922 this._firstPT = pt._next; 34923 } 34924 if (pt._next) { 34925 this._linkCSSP(pt._next, pt._next._next, xfirst._prev); 34926 } 34927 this._classNamePT = null; 34928 } 34929 pt = this._firstPT; 34930 while (pt) { 34931 if (pt.plugin && pt.plugin !== p && pt.plugin._kill) { //for plugins that are registered with CSSPlugin, we should notify them of the kill. 34932 pt.plugin._kill(lookup); 34933 p = pt.plugin; 34934 } 34935 pt = pt._next; 34936 } 34937 return __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["TweenPlugin"].prototype._kill.call(this, copy); 34938 }; 34939 34940 34941 34942 //used by cascadeTo() for gathering all the style properties of each child element into an array for comparison. 34943 var _getChildStyles = function(e, props, targets) { 34944 var children, i, child, type; 34945 if (e.slice) { 34946 i = e.length; 34947 while (--i > -1) { 34948 _getChildStyles(e[i], props, targets); 34949 } 34950 return; 34951 } 34952 children = e.childNodes; 34953 i = children.length; 34954 while (--i > -1) { 34955 child = children[i]; 34956 type = child.type; 34957 if (child.style) { 34958 props.push(_getAllStyles(child)); 34959 if (targets) { 34960 targets.push(child); 34961 } 34962 } 34963 if ((type === 1 || type === 9 || type === 11) && child.childNodes.length) { 34964 _getChildStyles(child, props, targets); 34965 } 34966 } 34967 }; 34968 34969 /** 34970 * Typically only useful for className tweens that may affect child elements, this method creates a TweenLite 34971 * and then compares the style properties of all the target's child elements at the tween's start and end, and 34972 * if any are different, it also creates tweens for those and returns an array containing ALL of the resulting 34973 * tweens (so that you can easily add() them to a TimelineLite, for example). The reason this functionality is 34974 * wrapped into a separate static method of CSSPlugin instead of being integrated into all regular className tweens 34975 * is because it creates entirely new tweens that may have completely different targets than the original tween, 34976 * so if they were all lumped into the original tween instance, it would be inconsistent with the rest of the API 34977 * and it would create other problems. For example: 34978 * - If I create a tween of elementA, that tween instance may suddenly change its target to include 50 other elements (unintuitive if I specifically defined the target I wanted) 34979 * - We can't just create new independent tweens because otherwise, what happens if the original/parent tween is reversed or pause or dropped into a TimelineLite for tight control? You'd expect that tween's behavior to affect all the others. 34980 * - Analyzing every style property of every child before and after the tween is an expensive operation when there are many children, so this behavior shouldn't be imposed on all className tweens by default, especially since it's probably rare that this extra functionality is needed. 34981 * 34982 * @param {Object} target object to be tweened 34983 * @param {number} Duration in seconds (or frames for frames-based tweens) 34984 * @param {Object} Object containing the end values, like {className:"newClass", ease:Linear.easeNone} 34985 * @return {Array} An array of TweenLite instances 34986 */ 34987 CSSPlugin.cascadeTo = function(target, duration, vars) { 34988 var tween = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].to(target, duration, vars), 34989 results = [tween], 34990 b = [], 34991 e = [], 34992 targets = [], 34993 _reservedProps = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"]._internals.reservedProps, 34994 i, difs, p, from; 34995 target = tween._targets || tween.target; 34996 _getChildStyles(target, b, targets); 34997 tween.render(duration, true, true); 34998 _getChildStyles(target, e); 34999 tween.render(0, true, true); 35000 tween._enabled(true); 35001 i = targets.length; 35002 while (--i > -1) { 35003 difs = _cssDif(targets[i], b[i], e[i]); 35004 if (difs.firstMPT) { 35005 difs = difs.difs; 35006 for (p in vars) { 35007 if (_reservedProps[p]) { 35008 difs[p] = vars[p]; 35009 } 35010 } 35011 from = {}; 35012 for (p in difs) { 35013 from[p] = b[i][p]; 35014 } 35015 results.push(__WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].fromTo(targets[i], duration, from, difs)); 35016 } 35017 } 35018 return results; 35019 }; 35020 35021 __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["TweenPlugin"].activate([CSSPlugin]); 35022 return CSSPlugin; 35023 35024 }, true); 35025 35026const CSSPlugin = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].CSSPlugin; 35027/* unused harmony export CSSPlugin */ 35028 35029 35030 35031/***/ }), 35032/* 28 */ 35033/***/ (function(module, __webpack_exports__, __webpack_require__) { 35034 35035"use strict"; 35036/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return DirectionalRotationPlugin; }); 35037/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__ = __webpack_require__(3); 35038/*! 35039 * VERSION: 0.3.1 35040 * DATE: 2018-05-30 35041 * UPDATES AND DOCS AT: http://greensock.com 35042 * 35043 * @license Copyright (c) 2008-2018, GreenSock. All rights reserved. 35044 * This work is subject to the terms at http://greensock.com/standard-license or for
35045 * Club GreenSock members, the software agreement that was issued with your membership. 35046 * 35047 * @author: Jack Doyle, [email protected] 35048 **/ 35049 35050 35051 35052const DirectionalRotationPlugin = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"]._gsDefine.plugin({ 35053 propName: "directionalRotation", 35054 version: "0.3.1", 35055 API: 2, 35056 35057 //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. 35058 init: function(target, value, tween, index) { 35059 if (typeof(value) !== "object") { 35060 value = {rotation:value}; 35061 } 35062 this.finals = {}; 35063 var cap = (value.useRadians === true) ? Math.PI * 2 : 360, 35064 min = 0.000001, 35065 p, v, start, end, dif, split; 35066 for (p in value) { 35067 if (p !== "useRadians") { 35068 end = value[p]; 35069 if (typeof(end) === "function") { 35070 end = end(index, target); 35071 } 35072 split = (end + "").split("_"); 35073 v = split[0]; 35074 start = parseFloat( (typeof(target[p]) !== "function") ? target[p] : target[ ((p.indexOf("set") || typeof(target["get" + p.substr(3)]) !== "function") ? p : "get" + p.substr(3)) ]() ); 35075 end = this.finals[p] = (typeof(v) === "string" && v.charAt(1) === "=") ? start + parseInt(v.charAt(0) + "1", 10) * Number(v.substr(2)) : Number(v) || 0; 35076 dif = end - start; 35077 if (split.length) { 35078 v = split.join("_"); 35079 if (v.indexOf("short") !== -1) { 35080 dif = dif % cap; 35081 if (dif !== dif % (cap / 2)) { 35082 dif = (dif < 0) ? dif + cap : dif - cap; 35083 } 35084 } 35085 if (v.indexOf("_cw") !== -1 && dif < 0) { 35086 dif = ((dif + cap * 9999999999) % cap) - ((dif / cap) | 0) * cap; 35087 } else if (v.indexOf("ccw") !== -1 && dif > 0) { 35088 dif = ((dif - cap * 9999999999) % cap) - ((dif / cap) | 0) * cap; 35089 } 35090 } 35091 if (dif > min || dif < -min) { 35092 this._addTween(target, p, start, start + dif, p); 35093 this._overwriteProps.push(p); 35094 } 35095 } 35096 } 35097 return true; 35098 }, 35099 35100 //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.) 35101 set: function(ratio) { 35102 var pt; 35103 if (ratio !== 1) { 35104 this._super.setRatio.call(this, ratio); 35105 } else { 35106 pt = this._firstPT; 35107 while (pt) { 35108 if (pt.f) { 35109 pt.t[pt.p](this.finals[pt.p]); 35110 } else { 35111 pt.t[pt.p] = this.finals[pt.p]; 35112 } 35113 pt = pt._next; 35114 } 35115 } 35116 } 35117 35118 }); 35119/* unused harmony export DirectionalRotationPlugin */ 35120 35121 35122DirectionalRotationPlugin._autoCSS = true; 35123 35124 35125 35126/***/ }), 35127/* 29 */ 35128/***/ (function(module, __webpack_exports__, __webpack_require__) { 35129 35130"use strict"; 35131/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__ = __webpack_require__(3); 35132/* unused harmony reexport Linear */ 35133/* unused harmony reexport Power0 */ 35134/* unused harmony reexport Power1 */ 35135/* unused harmony reexport Power2 */ 35136/* unused harmony reexport Power3 */ 35137/* unused harmony reexport Power4 */ 35138/*! 35139 * VERSION: 1.16.0 35140 * DATE: 2018-05-30 35141 * UPDATES AND DOCS AT: http://greensock.com 35142 * 35143 * @license Copyright (c) 2008-2018, GreenSock. All rights reserved. 35144 * This work is subject to the terms at http://greensock.com/standard-license or for 35145 * Club GreenSock members, the software agreement that was issued with your membership. 35146 * 35147 * @author: Jack Doyle, [email protected] 35148 **/ 35149 35150 35151 35152__WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"]._gsDefine("easing.Back", ["easing.Ease"], function() { 35153 35154 var w = (__WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].GreenSockGlobals || __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"]), 35155 gs = w.com.greensock, 35156 _2PI = Math.PI * 2, 35157 _HALF_PI = Math.PI / 2, 35158 _class = gs._class, 35159 _create = function(n, f) { 35160 var C = _class("easing." + n, function(){}, true), 35161 p = C.prototype = new __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Ease"](); 35162 p.constructor = C; 35163 p.getRatio = f; 35164 return C; 35165 }, 35166 _easeReg = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Ease"].register || function(){}, //put an empty function in place just as a safety measure in case someone loads an OLD version of TweenLite.js where Ease.register doesn't exist. 35167 _wrap = function(name, EaseOut, EaseIn, EaseInOut, aliases) { 35168 var C = _class("easing."+name, { 35169 easeOut:new EaseOut(), 35170 easeIn:new EaseIn(), 35171 easeInOut:new EaseInOut() 35172 }, true); 35173 _easeReg(C, name); 35174 return C; 35175 }, 35176 EasePoint = function(time, value, next) { 35177 this.t = time; 35178 this.v = value; 35179 if (next) { 35180 this.next = next; 35181 next.prev = this; 35182 this.c = next.v - value; 35183 this.gap = next.t - time; 35184 } 35185 }, 35186 35187 //Back 35188 _createBack = function(n, f) { 35189 var C = _class("easing." + n, function(overshoot) { 35190 this._p1 = (overshoot || overshoot === 0) ? overshoot : 1.70158; 35191 this._p2 = this._p1 * 1.525; 35192 }, true), 35193 p = C.prototype = new __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Ease"](); 35194 p.constructor = C; 35195 p.getRatio = f; 35196 p.config = function(overshoot) { 35197 return new C(overshoot); 35198 }; 35199 return C; 35200 }, 35201 35202 Back = _wrap("Back", 35203 _createBack("BackOut", function(p) { 35204 return ((p = p - 1) * p * ((this._p1 + 1) * p + this._p1) + 1); 35205 }), 35206 _createBack("BackIn", function(p) { 35207 return p * p * ((this._p1 + 1) * p - this._p1); 35208 }), 35209 _createBack("BackInOut", function(p) { 35210 return ((p *= 2) < 1) ? 0.5 * p * p * ((this._p2 + 1) * p - this._p2) : 0.5 * ((p -= 2) * p * ((this._p2 + 1) * p + this._p2) + 2); 35211 }) 35212 ), 35213 35214 35215 //SlowMo
35216 SlowMo = _class("easing.SlowMo", function(linearRatio, power, yoyoMode) { 35217 power = (power || power === 0) ? power : 0.7; 35218 if (linearRatio == null) { 35219 linearRatio = 0.7; 35220 } else if (linearRatio > 1) { 35221 linearRatio = 1; 35222 } 35223 this._p = (linearRatio !== 1) ? power : 0; 35224 this._p1 = (1 - linearRatio) / 2; 35225 this._p2 = linearRatio; 35226 this._p3 = this._p1 + this._p2; 35227 this._calcEnd = (yoyoMode === true); 35228 }, true), 35229 p = SlowMo.prototype = new __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Ease"](), 35230 SteppedEase, ExpoScaleEase, RoughEase, _createElastic; 35231 35232 p.constructor = SlowMo; 35233 p.getRatio = function(p) { 35234 var r = p + (0.5 - p) * this._p; 35235 if (p < this._p1) { 35236 return this._calcEnd ? 1 - ((p = 1 - (p / this._p1)) * p) : r - ((p = 1 - (p / this._p1)) * p * p * p * r); 35237 } else if (p > this._p3) { 35238 return this._calcEnd ? (p === 1 ? 0 : 1 - (p = (p - this._p3) / this._p1) * p) : r + ((p - r) * (p = (p - this._p3) / this._p1) * p * p * p); //added p === 1 ? 0 to avoid floating point rounding errors from affecting the final value, like 1 - 0.7 = 0.30000000000000004 instead of 0.3 35239 } 35240 return this._calcEnd ? 1 : r; 35241 }; 35242 SlowMo.ease = new SlowMo(0.7, 0.7); 35243 35244 p.config = SlowMo.config = function(linearRatio, power, yoyoMode) { 35245 return new SlowMo(linearRatio, power, yoyoMode); 35246 }; 35247 35248 35249 //SteppedEase 35250 SteppedEase = _class("easing.SteppedEase", function(steps, immediateStart) { 35251 steps = steps || 1; 35252 this._p1 = 1 / steps; 35253 this._p2 = steps + (immediateStart ? 0 : 1); 35254 this._p3 = immediateStart ? 1 : 0; 35255 }, true); 35256 p = SteppedEase.prototype = new __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Ease"](); 35257 p.constructor = SteppedEase; 35258 p.getRatio = function(p) { 35259 if (p < 0) { 35260 p = 0; 35261 } else if (p >= 1) { 35262 p = 0.999999999; 35263 } 35264 return (((this._p2 * p) | 0) + this._p3) * this._p1; 35265 }; 35266 p.config = SteppedEase.config = function(steps, immediateStart) { 35267 return new SteppedEase(steps, immediateStart); 35268 }; 35269 35270 35271 //ExpoScaleEase 35272 ExpoScaleEase = _class("easing.ExpoScaleEase", function(start, end, ease) { 35273 this._p1 = Math.log(end / start); 35274 this._p2 = end - start; 35275 this._p3 = start; 35276 this._ease = ease; 35277 }, true); 35278 p = ExpoScaleEase.prototype = new __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Ease"](); 35279 p.constructor = ExpoScaleEase; 35280 p.getRatio = function(p) { 35281 if (this._ease) { 35282 p = this._ease.getRatio(p); 35283 } 35284 return (this._p3 * Math.exp(this._p1 * p) - this._p3) / this._p2; 35285 }; 35286 p.config = ExpoScaleEase.config = function(start, end, ease) { 35287 return new ExpoScaleEase(start, end, ease); 35288 }; 35289 35290 35291 //RoughEase 35292 RoughEase = _class("easing.RoughEase", function(vars) { 35293 vars = vars || {}; 35294 var taper = vars.taper || "none", 35295 a = [], 35296 cnt = 0, 35297 points = (vars.points || 20) | 0, 35298 i = points, 35299 randomize = (vars.randomize !== false), 35300 clamp = (vars.clamp === true), 35301 template = (vars.template instanceof __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Ease"]) ? vars.template : null, 35302 strength = (typeof(vars.strength) === "number") ? vars.strength * 0.4 : 0.4, 35303 x, y, bump, invX, obj, pnt; 35304 while (--i > -1) { 35305 x = randomize ? Math.random() : (1 / points) * i; 35306 y = template ? template.getRatio(x) : x; 35307 if (taper === "none") { 35308 bump = strength; 35309 } else if (taper === "out") { 35310 invX = 1 - x; 35311 bump = invX * invX * strength; 35312 } else if (taper === "in") { 35313 bump = x * x * strength; 35314 } else if (x < 0.5) { //"both" (start) 35315 invX = x * 2; 35316 bump = invX * invX * 0.5 * strength; 35317 } else { //"both" (end) 35318 invX = (1 - x) * 2; 35319 bump = invX * invX * 0.5 * strength; 35320 } 35321 if (randomize) { 35322 y += (Math.random() * bump) - (bump * 0.5); 35323 } else if (i % 2) { 35324 y += bump * 0.5; 35325 } else { 35326 y -= bump * 0.5; 35327 } 35328 if (clamp) { 35329 if (y > 1) { 35330 y = 1; 35331 } else if (y < 0) { 35332 y = 0; 35333 } 35334 } 35335 a[cnt++] = {x:x, y:y}; 35336 } 35337 a.sort(function(a, b) { 35338 return a.x - b.x; 35339 }); 35340 35341 pnt = new EasePoint(1, 1, null); 35342 i = points; 35343 while (--i > -1) { 35344 obj = a[i]; 35345 pnt = new EasePoint(obj.x, obj.y, pnt); 35346 } 35347 35348 this._prev = new EasePoint(0, 0, (pnt.t !== 0) ? pnt : pnt.next); 35349 }, true); 35350 p = RoughEase.prototype = new __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Ease"](); 35351 p.constructor = RoughEase; 35352 p.getRatio = function(p) { 35353 var pnt = this._prev; 35354 if (p > pnt.t) { 35355 while (pnt.next && p >= pnt.t) { 35356 pnt = pnt.next; 35357 } 35358 pnt = pnt.prev; 35359 } else { 35360 while (pnt.prev && p <= pnt.t) { 35361 pnt = pnt.prev; 35362 } 35363 } 35364 this._prev = pnt; 35365 return (pnt.v + ((p - pnt.t) / pnt.gap) * pnt.c); 35366 }; 35367 p.config = function(vars) { 35368 return new RoughEase(vars); 35369 }; 35370 RoughEase.ease = new RoughEase(); 35371 35372 35373 //Bounce 35374 _wrap("Bounce", 35375 _create("BounceOut", function(p) { 35376 if (p < 1 / 2.75) { 35377 return 7.5625 * p * p; 35378 } else if (p < 2 / 2.75) { 35379 return 7.5625 * (p -= 1.5 / 2.75) * p + 0.75; 35380 } else if (p < 2.5 / 2.75) { 35381 return 7.5625 * (p -= 2.25 / 2.75) * p + 0.9375; 35382 } 35383 return 7.5625 * (p -= 2.625 / 2.75) * p + 0.984375; 35384 }), 35385 _create("BounceIn", function(p) { 35386 if ((p = 1 - p) < 1 / 2.75) { 35387 return 1 - (7.5625 * p * p); 35388 } else if (p < 2 / 2.75) { 35389 return 1 - (7.5625 * (p -= 1.5 / 2.75) * p + 0.75); 35390 } else if (p < 2.5 / 2.75) { 35391 return 1 - (7.5625 * (p -= 2.25 / 2.75) * p + 0.9375); 35392 } 35393 return 1 - (7.5625 * (p -= 2.625 / 2.75) * p + 0.984375); 35394 }), 35395 _create("BounceInOut", function(p) { 35396 var invert = (p < 0.5); 35397 if (invert) { 35398 p = 1 - (p * 2); 35399 } else { 35400 p = (p * 2) - 1; 35401 } 35402 if (p < 1 / 2.75) { 35403 p = 7.5625 * p * p; 35404 } else if (p < 2 / 2.75) { 35405 p = 7.5625 * (p -= 1.5 / 2.75) * p + 0.75; 35406 } else if (p < 2.5 / 2.75) { 35407 p = 7.5625 * (p -= 2.25 / 2.75) * p + 0.9375; 35408 } else { 35409 p = 7.5625 * (p -= 2.625 / 2.75) * p + 0.984375; 35410 } 35411 return invert ? (1 - p) * 0.5 : p * 0.5 + 0.5; 35412 }) 35413 ); 35414 35415 35416 //CIRC 35417 _wrap("Circ", 35418 _create("CircOut", function(p) { 35419 return Math.sqrt(1 - (p = p - 1) * p); 35420 }), 35421 _create("CircIn", function(p) { 35422 return -(Math.sqrt(1 - (p * p)) - 1); 35423 }), 35424 _create("CircInOut", function(p) { 35425 return ((p*=2) < 1) ? -0.5 * (Math.sqrt(1 - p * p) - 1) : 0.5 * (Math.sqrt(1 - (p -= 2) * p) + 1); 35426 }) 35427 ); 35428 35429 35430 //Elastic 35431 _createElastic = function(n, f, def) { 35432 var C = _class("easing." + n, function(amplitude, period) { 35433 this._p1 = (amplitude >= 1) ? amplitude : 1;
35433 //note: if amplitude is < 1, we simply adjust the period for a more natural feel. Otherwise the math doesn't work right and the curve starts at 1. 35434 this._p2 = (period || def) / (amplitude < 1 ? amplitude : 1); 35435 this._p3 = this._p2 / _2PI * (Math.asin(1 / this._p1) || 0); 35436 this._p2 = _2PI / this._p2; //precalculate to optimize 35437 }, true), 35438 p = C.prototype = new __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Ease"](); 35439 p.constructor = C; 35440 p.getRatio = f; 35441 p.config = function(amplitude, period) { 35442 return new C(amplitude, period); 35443 }; 35444 return C; 35445 }; 35446 _wrap("Elastic", 35447 _createElastic("ElasticOut", function(p) { 35448 return this._p1 * Math.pow(2, -10 * p) * Math.sin( (p - this._p3) * this._p2 ) + 1; 35449 }, 0.3), 35450 _createElastic("ElasticIn", function(p) { 35451 return -(this._p1 * Math.pow(2, 10 * (p -= 1)) * Math.sin( (p - this._p3) * this._p2 )); 35452 }, 0.3), 35453 _createElastic("ElasticInOut", function(p) { 35454 return ((p *= 2) < 1) ? -0.5 * (this._p1 * Math.pow(2, 10 * (p -= 1)) * Math.sin( (p - this._p3) * this._p2)) : this._p1 * Math.pow(2, -10 *(p -= 1)) * Math.sin( (p - this._p3) * this._p2 ) * 0.5 + 1; 35455 }, 0.45) 35456 ); 35457 35458 35459 //Expo 35460 _wrap("Expo", 35461 _create("ExpoOut", function(p) { 35462 return 1 - Math.pow(2, -10 * p); 35463 }), 35464 _create("ExpoIn", function(p) { 35465 return Math.pow(2, 10 * (p - 1)) - 0.001; 35466 }), 35467 _create("ExpoInOut", function(p) { 35468 return ((p *= 2) < 1) ? 0.5 * Math.pow(2, 10 * (p - 1)) : 0.5 * (2 - Math.pow(2, -10 * (p - 1))); 35469 }) 35470 ); 35471 35472 35473 //Sine 35474 _wrap("Sine", 35475 _create("SineOut", function(p) { 35476 return Math.sin(p * _HALF_PI); 35477 }), 35478 _create("SineIn", function(p) { 35479 return -Math.cos(p * _HALF_PI) + 1; 35480 }), 35481 _create("SineInOut", function(p) { 35482 return -0.5 * (Math.cos(Math.PI * p) - 1); 35483 }) 35484 ); 35485 35486 _class("easing.EaseLookup", { 35487 find:function(s) { 35488 return __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Ease"].map[s]; 35489 } 35490 }, true); 35491 35492 //register the non-standard eases 35493 _easeReg(w.SlowMo, "SlowMo", "ease,"); 35494 _easeReg(RoughEase, "RoughEase", "ease,"); 35495 _easeReg(SteppedEase, "SteppedEase", "ease,"); 35496 35497 return Back; 35498 35499 }, true); 35500 35501const Back = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].Back; 35502/* harmony export (immutable) */ __webpack_exports__["a"] = Back; 35503 35504const Elastic = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].Elastic; 35505/* harmony export (immutable) */ __webpack_exports__["b"] = Elastic; 35506 35507const Bounce = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].Bounce; 35508/* harmony export (immutable) */ __webpack_exports__["c"] = Bounce; 35509 35510const RoughEase = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].RoughEase; 35511/* harmony export (immutable) */ __webpack_exports__["d"] = RoughEase; 35512 35513const SlowMo = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].SlowMo; 35514/* harmony export (immutable) */ __webpack_exports__["e"] = SlowMo; 35515 35516const SteppedEase = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].SteppedEase; 35517/* harmony export (immutable) */ __webpack_exports__["f"] = SteppedEase; 35518 35519const Circ = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].Circ; 35520/* harmony export (immutable) */ __webpack_exports__["g"] = Circ; 35521 35522const Expo = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].Expo; 35523/* harmony export (immutable) */ __webpack_exports__["h"] = Expo; 35524 35525const Sine = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].Sine; 35526/* harmony export (immutable) */ __webpack_exports__["i"] = Sine; 35527 35528const ExpoScaleEase = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].ExpoScaleEase; 35529/* harmony export (immutable) */ __webpack_exports__["j"] = ExpoScaleEase; 35530 35531 35532 35533/***/ }), 35534/* 30 */ 35535/***/ (function(module, __webpack_exports__, __webpack_require__) { 35536 35537"use strict"; 35538/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return RoundPropsPlugin; }); 35539/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__ = __webpack_require__(3); 35540/*! 35541 * VERSION: 1.6.0 35542 * DATE: 2018-05-30 35543 * UPDATES AND DOCS AT: http://greensock.com 35544 * 35545 * @license Copyright (c) 2008-2018, GreenSock. All rights reserved. 35546 * This work is subject to the terms at http://greensock.com/standard-license or for
35547 * Club GreenSock members, the software agreement that was issued with your membership. 35548 * 35549 * @author: Jack Doyle, [email protected] 35550 **/ 35551 35552 35553const RoundPropsPlugin = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"]._gsDefine.plugin({ 35554 propName: "roundProps", 35555 version: "1.7.0", 35556 priority: -1, 35557 API: 2, 35558 35559 //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. 35560 init: function(target, value, tween) { 35561 this._tween = tween; 35562 return true; 35563 } 35564 35565 }), 35566 _getRoundFunc = function(v) { //pass in 0.1 get a function that'll round to the nearest tenth, or 5 to round to the closest 5, or 0.001 to the closest 1000th, etc. 35567 var p = v < 1 ? Math.pow(10, (v + "").length - 2) : 1; //to avoid floating point math errors (like 24 * 0.1 == 2.4000000000000004), we chop off at a specific number of decimal places (much faster than toFixed() 35568 return function(n) { 35569 return ((Math.round(n / v) * v * p) | 0) / p; 35570 }; 35571 }, 35572 _roundLinkedList = function(node, mod) { 35573 while (node) { 35574 if (!node.f && !node.blob) { 35575 node.m = mod || Math.round; 35576 } 35577 node = node._next; 35578 } 35579 }, 35580 p = RoundPropsPlugin.prototype; 35581/* unused harmony export RoundPropsPlugin */ 35582 35583/* unused harmony export _getRoundFunc */ 35584 35585/* unused harmony export _roundLinkedList */ 35586 35587/* unused harmony export p */ 35588 35589 35590 p._onInitAllProps = function() { 35591 var tween = this._tween, 35592 rp = tween.vars.roundProps, 35593 lookup = {}, 35594 rpt = tween._propLookup.roundProps, 35595 pt, next, i, p; 35596 if (typeof(rp) === "object" && !rp.push) { 35597 for (p in rp) { 35598 lookup[p] = _getRoundFunc(rp[p]); 35599 } 35600 } else { 35601 if (typeof(rp) === "string") { 35602 rp = rp.split(","); 35603 } 35604 i = rp.length; 35605 while (--i > -1) { 35606 lookup[rp[i]] = Math.round; 35607 } 35608 } 35609 35610 for (p in lookup) { 35611 pt = tween._firstPT; 35612 while (pt) { 35613 next = pt._next; //record here, because it may get removed 35614 if (pt.pg) { 35615 pt.t._mod(lookup); 35616 } else if (pt.n === p) { 35617 if (pt.f === 2 && pt.t) { //a blob (text containing multiple numeric values) 35618 _roundLinkedList(pt.t._firstPT, lookup[p]); 35619 } else { 35620 this._add(pt.t, p, pt.s, pt.c, lookup[p]); 35621 //remove from linked list 35622 if (next) { 35623 next._prev = pt._prev; 35624 } 35625 if (pt._prev) { 35626 pt._prev._next = next; 35627 } else if (tween._firstPT === pt) { 35628 tween._firstPT = next; 35629 } 35630 pt._next = pt._prev = null; 35631 tween._propLookup[p] = rpt; 35632 } 35633 } 35634 pt = next; 35635 } 35636 } 35637 return false; 35638 }; 35639 35640 p._add = function(target, p, s, c, mod) { 35641 this._addTween(target, p, s, s + c, p, mod || Math.round); 35642 this._overwriteProps.push(p); 35643 }; 35644 35645 35646 35647 35648/***/ }), 35649/* 31 */ 35650/***/ (function(module, __webpack_exports__, __webpack_require__) { 35651 35652"use strict"; 35653/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return TimelineMax; }); 35654/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__ = __webpack_require__(3); 35655/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__TimelineLite_js__ = __webpack_require__(15); 35656/* unused harmony reexport TimelineLite */ 35657/*! 35658 * VERSION: 2.0.1 35659 * DATE: 2018-05-30 35660 * UPDATES AND DOCS AT: http://greensock.com 35661 * 35662 * @license Copyright (c) 2008-2018, GreenSock. All rights reserved. 35663 * This work is subject to the terms at http://greensock.com/standard-license or for 35664 * Club GreenSock members, the software agreement that was issued with your membership. 35665 * 35666 * @author: Jack Doyle, [email protected] 35667 */ 35668 35669 35670 35671 35672__WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"]._gsDefine("TimelineMax", ["TimelineLite","TweenLite","easing.Ease"], function() { 35673 35674 var TimelineMax = function(vars) { 35675 __WEBPACK_IMPORTED_MODULE_1__TimelineLite_js__["a" /* default */].call(this, vars); 35676 this._repeat = this.vars.repeat || 0; 35677 this._repeatDelay = this.vars.repeatDelay || 0; 35678 this._cycle = 0; 35679 this._yoyo = (this.vars.yoyo === true); 35680 this._dirty = true; 35681 }, 35682 _tinyNum = 0.0000000001, 35683 TweenLiteInternals = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"]._internals, 35684 _lazyTweens = TweenLiteInternals.lazyTweens, 35685 _lazyRender = TweenLiteInternals.lazyRender, 35686 _globals = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"]._gsDefine.globals,
35687 _easeNone = new __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Ease"](null, null, 1, 0), 35688 p = TimelineMax.prototype = new __WEBPACK_IMPORTED_MODULE_1__TimelineLite_js__["a" /* default */](); 35689 35690 p.constructor = TimelineMax; 35691 p.kill()._gc = false; 35692 TimelineMax.version = "2.0.1"; 35693 35694 p.invalidate = function() { 35695 this._yoyo = (this.vars.yoyo === true); 35696 this._repeat = this.vars.repeat || 0; 35697 this._repeatDelay = this.vars.repeatDelay || 0; 35698 this._uncache(true); 35699 return __WEBPACK_IMPORTED_MODULE_1__TimelineLite_js__["a" /* default */].prototype.invalidate.call(this); 35700 }; 35701 35702 p.addCallback = function(callback, position, params, scope) { 35703 return this.add( __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].delayedCall(0, callback, params, scope), position); 35704 }; 35705 35706 p.removeCallback = function(callback, position) { 35707 if (callback) { 35708 if (position == null) { 35709 this._kill(null, callback); 35710 } else { 35711 var a = this.getTweensOf(callback, false), 35712 i = a.length, 35713 time = this._parseTimeOrLabel(position); 35714 while (--i > -1) { 35715 if (a[i]._startTime === time) { 35716 a[i]._enabled(false, false); 35717 } 35718 } 35719 } 35720 } 35721 return this; 35722 }; 35723 35724 p.removePause = function(position) { 35725 return this.removeCallback(__WEBPACK_IMPORTED_MODULE_1__TimelineLite_js__["a" /* default */]._internals.pauseCallback, position); 35726 }; 35727 35728 p.tweenTo = function(position, vars) { 35729 vars = vars || {}; 35730 var copy = {ease:_easeNone, useFrames:this.usesFrames(), immediateRender:false, lazy:false}, 35731 Engine = (vars.repeat && _globals.TweenMax) || __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"], 35732 duration, p, t; 35733 for (p in vars) { 35734 copy[p] = vars[p]; 35735 } 35736 copy.time = this._parseTimeOrLabel(position); 35737 duration = (Math.abs(Number(copy.time) - this._time) / this._timeScale) || 0.001; 35738 t = new Engine(this, duration, copy); 35739 copy.onStart = function() { 35740 t.target.paused(true); 35741 if (t.vars.time !== t.target.time() && duration === t.duration() && !t.isFromTo) { //don't make the duration zero - if it's supposed to be zero, don't worry because it's already initting the tween and will complete immediately, effectively making the duration zero anyway. If we make duration zero, the tween won't run at all. 35742 t.duration( Math.abs( t.vars.time - t.target.time()) / t.target._timeScale ).render(t.time(), true, true); //render() right away to ensure that things look right, especially in the case of .tweenTo(0). 35743 } 35744 if (vars.onStart) { //in case the user had an onStart in the vars - we don't want to overwrite it. 35745 vars.onStart.apply(vars.onStartScope || vars.callbackScope || t, vars.onStartParams || []); //don't use t._callback("onStart") or it'll point to the copy.onStart and we'll get a recursion error. 35746 } 35747 }; 35748 return t; 35749 }; 35750 35751 p.tweenFromTo = function(fromPosition, toPosition, vars) { 35752 vars = vars || {}; 35753 fromPosition = this._parseTimeOrLabel(fromPosition); 35754 vars.startAt = {onComplete:this.seek, onCompleteParams:[fromPosition], callbackScope:this}; 35755 vars.immediateRender = (vars.immediateRender !== false); 35756 var t = this.tweenTo(toPosition, vars); 35757 t.isFromTo = 1; //to ensure we don't mess with the duration in the onStart (we've got the start and end values here, so lock it in) 35758 return t.duration((Math.abs( t.vars.time - fromPosition) / this._timeScale) || 0.001); 35759 }; 35760 35761 p.render = function(time, suppressEvents, force) { 35762 if (this._gc) { 35763 this._enabled(true, false); 35764 } 35765 var prevTime = this._time, 35766 totalDur = (!this._dirty) ? this._totalDuration : this.totalDuration(), 35767 dur = this._duration, 35768 prevTotalTime = this._totalTime, 35769 prevStart = this._startTime, 35770 prevTimeScale = this._timeScale, 35771 prevRawPrevTime = this._rawPrevTime, 35772 prevPaused = this._paused, 35773 prevCycle = this._cycle, 35774 tween, isComplete, next, callback, internalForce, cycleDuration, pauseTween, curTime; 35775 if (prevTime !== this._time) { //if totalDuration() finds a child with a negative startTime and smoothChildTiming is true, things get shifted around internally so we need to adjust the time accordingly. For example, if a tween starts at -30 we must shift EVERYTHING forward 30 seconds and move this timeline's startTime backward by 30 seconds so that things align with the playhead (no jump). 35776 time += this._time - prevTime; 35777 } 35778 if (time >= totalDur - 0.0000001 && time >= 0) { //to work around occasional floating point math artifacts. 35779 if (!this._locked) { 35780 this._totalTime = totalDur; 35781 this._cycle = this._repeat; 35782 } 35783 if (!this._reversed) if (!this._hasPausedChild()) { 35784 isComplete = true; 35785 callback = "onComplete"; 35786 internalForce = !!this._timeline.autoRemoveChildren; //otherwise, if the animation is unpaused/activated after it's already finished, it doesn't get removed from the parent timeline. 35787 if (this._duration === 0) if ((time <= 0 && time >= -0.0000001) || prevRawPrevTime < 0 || prevRawPrevTime === _tinyNum) if (prevRawPrevTime !== time && this._first) { 35788 internalForce = true; 35789 if (prevRawPrevTime > _tinyNum) { 35790 callback = "onReverseComplete"; 35791 } 35792 } 35793 } 35794 this._rawPrevTime = (this._duration || !suppressEvents || time || this._rawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration timeline or tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. 35795 if (this._yoyo && (this._cycle & 1) !== 0) { 35796 this._time = time = 0; 35797 } else { 35798 this._time = dur; 35799 time = dur + 0.0001; //to avoid occasional floating point rounding errors - sometimes child tweens/timelines were not being fully completed (their progress might be 0.999999999999998 instead of 1 because when _time - tween._startTime is performed, floating point errors would return a value that was SLIGHTLY off). Try (999999999999.7 - 999999999999) * 1 = 0.699951171875 instead of 0.7. We cannot do less then 0.0001 because the same issue can occur when the duration is extremely large like 999999999999 in
35799which case adding 0.00000001, for example, causes it to act like nothing was added. 35800 } 35801 35802 } else if (time < 0.0000001) { //to work around occasional floating point math artifacts, round super small values to 0. 35803 if (!this._locked) { 35804 this._totalTime = this._cycle = 0; 35805 } 35806 this._time = 0; 35807 if (prevTime !== 0 || (dur === 0 && prevRawPrevTime !== _tinyNum && (prevRawPrevTime > 0 || (time < 0 && prevRawPrevTime >= 0)) && !this._locked)) { //edge case for checking time < 0 && prevRawPrevTime >= 0: a zero-duration fromTo() tween inside a zero-duration timeline (yeah, very rare) 35808 callback = "onReverseComplete"; 35809 isComplete = this._reversed; 35810 } 35811 if (time < 0) { 35812 this._active = false; 35813 if (this._timeline.autoRemoveChildren && this._reversed) { 35814 internalForce = isComplete = true; 35815 callback = "onReverseComplete"; 35816 } else if (prevRawPrevTime >= 0 && this._first) { //when going back beyond the start, force a render so that zero-duration tweens that sit at the very beginning render their start values properly. Otherwise, if the parent timeline's playhead lands exactly at this timeline's startTime, and then moves backwards, the zero-duration tweens at the beginning would still be at their end state. 35817 internalForce = true; 35818 } 35819 this._rawPrevTime = time; 35820 } else { 35821 this._rawPrevTime = (dur || !suppressEvents || time || this._rawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration timeline or tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. 35822 if (time === 0 && isComplete) { //if there's a zero-duration tween at the very beginning of a timeline and the playhead lands EXACTLY at time 0, that tween will correctly render its end values, but we need to keep the timeline alive for one more render so that the beginning values render properly as the parent's playhead keeps moving beyond the begining. Imagine obj.x starts at 0 and then we do tl.set(obj, {x:100}).to(obj, 1, {x:200}) and then later we tl.reverse()...the goal is to have obj.x revert to 0. If the playhead happens to land on exactly 0, without this chunk of code, it'd complete the timeline and remove it from the rendering queue (not good). 35823 tween = this._first; 35824 while (tween && tween._startTime === 0) { 35825 if (!tween._duration) { 35826 isComplete = false; 35827 } 35828 tween = tween._next; 35829 } 35830 } 35831 time = 0; //to avoid occasional floating point rounding errors (could cause problems especially with zero-duration tweens at the very beginning of the timeline) 35832 if (!this._initted) { 35833 internalForce = true; 35834 } 35835 } 35836 35837 } else { 35838 if (dur === 0 && prevRawPrevTime < 0) { //without this, zero-duration repeating timelines (like with a simple callback nested at the very beginning and a repeatDelay) wouldn't render the first time through. 35839 internalForce = true; 35840 } 35841 this._time = this._rawPrevTime = time; 35842 if (!this._locked) { 35843 this._totalTime = time; 35844 if (this._repeat !== 0) { 35845 cycleDuration = dur + this._repeatDelay; 35846 this._cycle = (this._totalTime / cycleDuration) >> 0; //originally _totalTime % cycleDuration but floating point errors caused problems, so I normalized it. (4 % 0.8 should be 0 but it gets reported as 0.79999999!) 35847 if (this._cycle !== 0) if (this._cycle === this._totalTime / cycleDuration && prevTotalTime <= time) { 35848 this._cycle--; //otherwise when rendered exactly at the end time, it will act as though it is repeating (at the beginning) 35849 } 35850 this._time = this._totalTime - (this._cycle * cycleDuration); 35851 if (this._yoyo) if ((this._cycle & 1) !== 0) { 35852 this._time = dur - this._time; 35853 } 35854 if (this._time > dur) { 35855 this._time = dur; 35856 time = dur + 0.0001; //to avoid occasional floating point rounding error 35857 } else if (this._time < 0) { 35858 this._time = time = 0; 35859 } else { 35860 time = this._time; 35861 } 35862 } 35863 } 35864 35865 if (this._hasPause && !this._forcingPlayhead && !suppressEvents) { 35866 time = this._time; 35867 if (time >= prevTime || (this._repeat && prevCycle !== this._cycle)) { 35868 tween = this._first; 35869 while (tween && tween._startTime <= time && !pauseTween) { 35870 if (!tween._duration) if (tween.data === "isPause" && !tween.ratio && !(tween._startTime === 0 && this._rawPrevTime === 0)) { 35871 pauseTween = tween; 35872 } 35873 tween = tween._next; 35874 } 35875 } else { 35876 tween = this._last; 35877 while (tween && tween._startTime >= time && !pauseTween) { 35878 if (!tween._duration) if (tween.data === "isPause" && tween._rawPrevTime > 0) { 35879 pauseTween = tween; 35880 } 35881 tween = tween._prev; 35882 } 35883 } 35884 if (pauseTween && pauseTween._startTime < dur) { 35885 this._time = time = pauseTween._startTime; 35886 this._totalTime = time + (this._cycle * (this._totalDuration + this._repeatDelay)); 35887 } 35888 } 35889 35890 } 35891 35892 if (this._cycle !== prevCycle) if (!this._locked) { 35893 /* 35894 make sure children at the end/beginning of the timeline are rendered properly. If, for example, 35895 a 3-second long timeline rendered at 2.9 seconds previously, and now renders at 3.2 seconds (which
35896 would get transated to 2.8 seconds if the timeline yoyos or 0.2 seconds if it just repeats), there 35897 could be a callback or a short tween that's at 2.95 or 3 seconds in which wouldn't render. So 35898 we need to push the timeline to the end (and/or beginning depending on its yoyo value). Also we must 35899 ensure that zero-duration tweens at the very beginning or end of the TimelineMax work. 35900 */ 35901 var backwards = (this._yoyo && (prevCycle & 1) !== 0), 35902 wrap = (backwards === (this._yoyo && (this._cycle & 1) !== 0)), 35903 recTotalTime = this._totalTime, 35904 recCycle = this._cycle, 35905 recRawPrevTime = this._rawPrevTime, 35906 recTime = this._time; 35907 35908 this._totalTime = prevCycle * dur; 35909 if (this._cycle < prevCycle) { 35910 backwards = !backwards; 35911 } else { 35912 this._totalTime += dur; 35913 } 35914 this._time = prevTime; //temporarily revert _time so that render() renders the children in the correct order. Without this, tweens won't rewind correctly. We could arhictect things in a "cleaner" way by splitting out the rendering queue into a separate method but for performance reasons, we kept it all inside this method. 35915 35916 this._rawPrevTime = (dur === 0) ? prevRawPrevTime - 0.0001 : prevRawPrevTime; 35917 this._cycle = prevCycle; 35918 this._locked = true; //prevents changes to totalTime and skips repeat/yoyo behavior when we recursively call render() 35919 prevTime = (backwards) ? 0 : dur; 35920 this.render(prevTime, suppressEvents, (dur === 0)); 35921 if (!suppressEvents) if (!this._gc) { 35922 if (this.vars.onRepeat) { 35923 this._cycle = recCycle; //in case the onRepeat alters the playhead or invalidates(), we shouldn't stay locked or use the previous cycle. 35924 this._locked = false; 35925 this._callback("onRepeat"); 35926 } 35927 } 35928 if (prevTime !== this._time) { //in case there's a callback like onComplete in a nested tween/timeline that changes the playhead position, like via seek(), we should just abort. 35929 return; 35930 } 35931 if (wrap) { 35932 this._cycle = prevCycle; //if there's an onRepeat, we reverted this above, so make sure it's set properly again. We also unlocked in that scenario, so reset that too. 35933 this._locked = true; 35934 prevTime = (backwards) ? dur + 0.0001 : -0.0001; 35935 this.render(prevTime, true, false); 35936 } 35937 this._locked = false; 35938 if (this._paused && !prevPaused) { //if the render() triggered callback that paused this timeline, we should abort (very rare, but possible) 35939 return; 35940 } 35941 this._time = recTime; 35942 this._totalTime = recTotalTime; 35943 this._cycle = recCycle; 35944 this._rawPrevTime = recRawPrevTime; 35945 } 35946 35947 if ((this._time === prevTime || !this._first) && !force && !internalForce && !pauseTween) { 35948 if (prevTotalTime !== this._totalTime) if (this._onUpdate) if (!suppressEvents) { //so that onUpdate fires even during the repeatDelay - as long as the totalTime changed, we should trigger onUpdate. 35949 this._callback("onUpdate"); 35950 } 35951 return; 35952 } else if (!this._initted) { 35953 this._initted = true; 35954 } 35955 35956 if (!this._active) if (!this._paused && this._totalTime !== prevTotalTime && time > 0) { 35957 this._active = true; //so that if the user renders the timeline (as opposed to the parent timeline rendering it), it is forced to re-render and align it with the proper time/frame on the next rendering cycle. Maybe the timeline already finished but the user manually re-renders it as halfway done, for example. 35958 } 35959 35960 if (prevTotalTime === 0) if (this.vars.onStart) if (this._totalTime !== 0 || !this._totalDuration) if (!suppressEvents) { 35961 this._callback("onStart"); 35962 } 35963 35964 curTime = this._time; 35965 if (curTime >= prevTime) { 35966 tween = this._first; 35967 while (tween) { 35968 next = tween._next; //record it here because the value could change after rendering... 35969 if (curTime !== this._time || (this._paused && !prevPaused)) { //in case a tween pauses or seeks the timeline when rendering, like inside of an onUpdate/onComplete 35970 break; 35971 } else if (tween._active || (tween._startTime <= this._time && !tween._paused && !tween._gc)) { 35972 if (pauseTween === tween) { 35973 this.pause(); 35974 } 35975 if (!tween._reversed) { 35976 tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force); 35977 } else { 35978 tween.render(((!tween._dirty) ? tween._totalDuration : tween.totalDuration()) - ((time - tween._startTime) * tween._timeScale), suppressEvents, force); 35979 } 35980 } 35981 tween = next; 35982 } 35983 } else { 35984 tween = this._last; 35985 while (tween) { 35986 next = tween._prev; //record it here because the value could change after rendering... 35987 if (curTime !== this._time || (this._paused && !prevPaused)) { //in case a tween pauses or seeks the timeline when rendering, like inside of an onUpdate/onComplete 35988 break; 35989 } else if (tween._active || (tween._startTime <= prevTime && !tween._paused && !tween._gc)) { 35990 if (pauseTween === tween) { 35991 pauseTween = tween._prev; //the linked list is organized by _startTime, thus it's possible that a tween could start BEFORE the pause and end after it, in which case it would be positioned before the pause tween in the linked list, but we should render it before we pause() the timeline and cease rendering. This is only a concern when going in reverse. 35992 while (pauseTween && pauseTween.endTime() > this._time) { 35993 pauseTween.render( (pauseTween._reversed ? pauseTween.totalDuration() - ((time - pauseTween._startTime) * pauseTween._timeScale) : (time - pauseTween._startTime) * pauseTween._timeScale), suppressEvents, force); 35994 pauseTween = pauseTween._prev; 35995 } 35996 pauseTween = null; 35997 this.pause(); 35998 } 35999 if (!tween._reversed) { 36000 tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force); 36001 } else { 36002 tween.render(((!tween._dirty) ? tween._totalDuration : tween.totalDuration()) - ((time - tween._startTime) * tween._timeScale), suppressEvents, force); 36003 } 36004 } 36005 tween = next; 36006 } 36007 } 36008 36009 if (this._onUpdate) if (!suppressEvents) { 36010 if (_lazyTweens.length) { //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onUpdate on a timeline that reports/checks tweened values. 36011 _lazyRender(); 36012 }
36013 this._callback("onUpdate"); 36014 } 36015 if (callback) if (!this._locked) if (!this._gc) if (prevStart === this._startTime || prevTimeScale !== this._timeScale) if (this._time === 0 || totalDur >= this.totalDuration()) { //if one of the tweens that was rendered altered this timeline's startTime (like if an onComplete reversed the timeline), it probably isn't complete. If it is, don't worry, because whatever call altered the startTime would complete if it was necessary at the new time. The only exception is the timeScale property. Also check _gc because there's a chance that kill() could be called in an onUpdate 36016 if (isComplete) { 36017 if (_lazyTweens.length) { //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onComplete on a timeline that reports/checks tweened values. 36018 _lazyRender(); 36019 } 36020 if (this._timeline.autoRemoveChildren) { 36021 this._enabled(false, false); 36022 } 36023 this._active = false; 36024 } 36025 if (!suppressEvents && this.vars[callback]) { 36026 this._callback(callback); 36027 } 36028 } 36029 }; 36030 36031 p.getActive = function(nested, tweens, timelines) { 36032 if (nested == null) { 36033 nested = true; 36034 } 36035 if (tweens == null) { 36036 tweens = true; 36037 } 36038 if (timelines == null) { 36039 timelines = false; 36040 } 36041 var a = [], 36042 all = this.getChildren(nested, tweens, timelines), 36043 cnt = 0, 36044 l = all.length, 36045 i, tween; 36046 for (i = 0; i < l; i++) { 36047 tween = all[i]; 36048 if (tween.isActive()) { 36049 a[cnt++] = tween; 36050 } 36051 } 36052 return a; 36053 }; 36054 36055 36056 p.getLabelAfter = function(time) { 36057 if (!time) if (time !== 0) { //faster than isNan() 36058 time = this._time; 36059 } 36060 var labels = this.getLabelsArray(), 36061 l = labels.length, 36062 i; 36063 for (i = 0; i < l; i++) { 36064 if (labels[i].time > time) { 36065 return labels[i].name; 36066 } 36067 } 36068 return null; 36069 }; 36070 36071 p.getLabelBefore = function(time) { 36072 if (time == null) { 36073 time = this._time; 36074 } 36075 var labels = this.getLabelsArray(), 36076 i = labels.length; 36077 while (--i > -1) { 36078 if (labels[i].time < time) { 36079 return labels[i].name; 36080 } 36081 } 36082 return null; 36083 }; 36084 36085 p.getLabelsArray = function() { 36086 var a = [], 36087 cnt = 0, 36088 p; 36089 for (p in this._labels) { 36090 a[cnt++] = {time:this._labels[p], name:p}; 36091 } 36092 a.sort(function(a,b) { 36093 return a.time - b.time; 36094 }); 36095 return a; 36096 }; 36097 36098 p.invalidate = function() { 36099 this._locked = false; //unlock and set cycle in case invalidate() is called from inside an onRepeat 36100 return __WEBPACK_IMPORTED_MODULE_1__TimelineLite_js__["a" /* default */].prototype.invalidate.call(this); 36101 }; 36102 36103 36104//---- GETTERS / SETTERS ------------------------------------------------------------------------------------------------------- 36105 36106 p.progress = function(value, suppressEvents) { 36107 return (!arguments.length) ? (this._time / this.duration()) || 0 : this.totalTime( this.duration() * ((this._yoyo && (this._cycle & 1) !== 0) ? 1 - value : value) + (this._cycle * (this._duration + this._repeatDelay)), suppressEvents); 36108 }; 36109 36110 p.totalProgress = function(value, suppressEvents) { 36111 return (!arguments.length) ? (this._totalTime / this.totalDuration()) || 0 : this.totalTime( this.totalDuration() * value, suppressEvents); 36112 }; 36113 36114 p.totalDuration = function(value) { 36115 if (!arguments.length) { 36116 if (this._dirty) { 36117 __WEBPACK_IMPORTED_MODULE_1__TimelineLite_js__["a" /* default */].prototype.totalDuration.call(this); //just forces refresh 36118 //Instead of Infinity, we use 999999999999 so that we can accommodate reverses. 36119 this._totalDuration = (this._repeat === -1) ? 999999999999 : this._duration * (this._repeat + 1) + (this._repeatDelay * this._repeat); 36120 } 36121 return this._totalDuration; 36122 } 36123 return (this._repeat === -1 || !value) ? this : this.timeScale( this.totalDuration() / value ); 36124 }; 36125 36126 p.time = function(value, suppressEvents) { 36127 if (!arguments.length) { 36128 return this._time; 36129 } 36130 if (this._dirty) { 36131 this.totalDuration(); 36132 } 36133 if (value > this._duration) { 36134 value = this._duration; 36135 } 36136 if (this._yoyo && (this._cycle & 1) !== 0) { 36137 value = (this._duration - value) + (this._cycle * (this._duration + this._repeatDelay)); 36138 } else if (this._repeat !== 0) { 36139 value += this._cycle * (this._duration + this._repeatDelay); 36140 } 36141 return this.totalTime(value, suppressEvents); 36142 }; 36143
36144 p.repeat = function(value) { 36145 if (!arguments.length) { 36146 return this._repeat; 36147 } 36148 this._repeat = value; 36149 return this._uncache(true); 36150 }; 36151 36152 p.repeatDelay = function(value) { 36153 if (!arguments.length) { 36154 return this._repeatDelay; 36155 } 36156 this._repeatDelay = value; 36157 return this._uncache(true); 36158 }; 36159 36160 p.yoyo = function(value) { 36161 if (!arguments.length) { 36162 return this._yoyo; 36163 } 36164 this._yoyo = value; 36165 return this; 36166 }; 36167 36168 p.currentLabel = function(value) { 36169 if (!arguments.length) { 36170 return this.getLabelBefore(this._time + 0.00000001); 36171 } 36172 return this.seek(value, true); 36173 }; 36174 36175 return TimelineMax; 36176 36177 }, true); 36178 36179const TimelineMax = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].TimelineMax; 36180/* unused harmony export TimelineMax */ 36181 36182 36183 36184/***/ }), 36185/* 32 */ 36186/***/ (function(module, exports, __webpack_require__) { 36187 36188//! moment.js locale configuration 36189 36190;(function (global, factory) { 36191 true ? factory(__webpack_require__(0)) : 36192 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 36193 factory(global.moment) 36194}(this, (function (moment) { 'use strict'; 36195 36196 36197 var af = moment.defineLocale('af', { 36198 months : 'Januarie_Februarie_Maart_April_Mei_Junie_Julie_Augustus_September_Oktober_November_Desember'.split('_'), 36199 monthsShort : 'Jan_Feb_Mrt_Apr_Mei_Jun_Jul_Aug_Sep_Okt_Nov_Des'.split('_'), 36200 weekdays : 'Sondag_Maandag_Dinsdag_Woensdag_Donderdag_Vrydag_Saterdag'.split('_'), 36201 weekdaysShort : 'Son_Maa_Din_Woe_Don_Vry_Sat'.split('_'), 36202 weekdaysMin : 'So_Ma_Di_Wo_Do_Vr_Sa'.split('_'), 36203 meridiemParse: /vm|nm/i, 36204 isPM : function (input) { 36205 return /^nm$/i.test(input); 36206 }, 36207 meridiem : function (hours, minutes, isLower) { 36208 if (hours < 12) { 36209 return isLower ? 'vm' : 'VM'; 36210 } else { 36211 return isLower ? 'nm' : 'NM'; 36212 } 36213 }, 36214 longDateFormat : { 36215 LT : 'HH:mm', 36216 LTS : 'HH:mm:ss', 36217 L : 'DD/MM/YYYY', 36218 LL : 'D MMMM YYYY', 36219 LLL : 'D MMMM YYYY HH:mm', 36220 LLLL : 'dddd, D MMMM YYYY HH:mm' 36221 }, 36222 calendar : { 36223 sameDay : '[Vandag om] LT', 36224 nextDay : '[Môre om] LT', 36225 nextWeek : 'dddd [om] LT', 36226 lastDay : '[Gister om] LT', 36227 lastWeek : '[Laas] dddd [om] LT', 36228 sameElse : 'L' 36229 }, 36230 relativeTime : { 36231 future : 'oor %s', 36232 past : '%s gelede', 36233 s : '\'n paar sekondes', 36234 ss : '%d sekondes', 36235 m : '\'n minuut', 36236 mm : '%d minute', 36237 h : '\'n uur', 36238 hh : '%d ure', 36239 d : '\'n dag', 36240 dd : '%d dae', 36241 M : '\'n maand', 36242 MM : '%d maande', 36243 y : '\'n jaar', 36244 yy : '%d jaar' 36245 }, 36246 dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/, 36247 ordinal : function (number) { 36248 return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de'); // Thanks to Joris Röling : https://github.com/jjupiter 36249 }, 36250 week : { 36251 dow : 1, // Maandag is die eerste dag van die week. 36252 doy : 4 // Die week wat die 4de Januarie bevat is die eerste week van die jaar. 36253 } 36254 }); 36255 36256 return af; 36257 36258}))); 36259 36260 36261/***/ }), 36262/* 33 */ 36263/***/ (function(module, exports, __webpack_require__) { 36264 36265//! moment.js locale configuration 36266 36267;(function (global, factory) { 36268 true ? factory(__webpack_require__(0)) : 36269 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 36270 factory(global.moment) 36271}(this, (function (moment) { 'use strict'; 36272 36273 36274 var arDz = moment.defineLocale('ar-dz', { 36275 months : 'جاÙÙÙ_ÙÙÙرÙ_٠ارس_Ø£ÙرÙÙ_٠اÙ_جÙاÙ_جÙÙÙÙØ©_Ø£Ùت_سبت٠بر_Ø£ÙتÙبر_ÙÙÙ٠بر_دÙس٠بر'.split('_'), 36276 monthsShort : 'جاÙÙÙ_ÙÙÙرÙ_٠ارس_Ø£ÙرÙÙ_٠اÙ_جÙاÙ_جÙÙÙÙØ©_Ø£Ùت_سبت٠بر_Ø£ÙتÙبر_ÙÙÙ٠بر_دÙس٠بر'.split('_'), 36277 weekdays : 'اÙØ£Øد_اÙإثÙÙÙ_اÙØ«Ùاثاء_اÙأربعاء_اÙخ٠Ùس_اÙج٠عة_اÙسبت'.split('_'), 36278 weekdaysShort : 'اØد_اثÙÙÙ_Ø«Ùاثاء_اربعاء_خ٠Ùس_ج٠عة_سبت'.split('_'), 36279 weekdaysMin : 'Ø£Ø_إث_Ø«Ùا_أر_خ٠_ج٠_سب'.split('_'), 36280 weekdaysParseExact : true, 36281 longDateFormat : { 36282 LT : 'HH:mm', 36283 LTS : 'HH:mm:ss', 36284 L : 'DD/MM/YYYY', 36285 LL : 'D MMMM YYYY', 36286 LLL : 'D MMMM YYYY HH:mm', 36287 LLLL : 'dddd D MMMM YYYY HH:mm' 36288 }, 36289 calendar : { 36290 sameDay: '[اÙÙÙ٠عÙ٠اÙساعة] LT', 36291 nextDay: '[غدا عÙ٠اÙساعة] LT', 36292 nextWeek: 'dddd [عÙ٠اÙساعة] LT', 36293 lastDay: '[أ٠س عÙ٠اÙساعة] LT', 36294 lastWeek: 'dddd [عÙ٠اÙساعة] LT', 36295 sameElse: 'L' 36296 }, 36297 relativeTime : { 36298 future : 'ÙÙ %s', 36299 past : 'Ù ÙØ° %s', 36300 s : 'Ø«ÙاÙ', 36301 ss : '%d ثاÙÙØ©', 36302 m : 'دÙÙÙØ©', 36303 mm : '%d دÙائÙ', 36304 h : 'ساعة', 36305 hh : '%d ساعات', 36306 d : 'ÙÙÙ ', 36307 dd : '%d Ø£Ùا٠', 36308 M : 'Ø´Ùر', 36309 MM : '%d أشÙر', 36310 y : 'سÙØ©', 36311 yy : '%d سÙÙات' 36312 }, 36313 week : { 36314 dow : 0, // Sunday is the first day of the week. 36315 doy : 4 // The week that contains Jan 1st is the first week of the year. 36316 } 36317 }); 36318 36319 return arDz; 36320 36321}))); 36322 36323 36324/***/ }), 36325/* 34 */ 36326/***/ (function(module, exports, __webpack_require__) { 36327 36328//! moment.js locale configuration 36329 36330;(function (global, factory) { 36331 true ? factory(__webpack_require__(0)) : 36332 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 36333 factory(global.moment) 36334}(this, (function (moment) { 'use strict'; 36335 36336 36337 var arKw = moment.defineLocale('ar-kw', { 36338 months : 'ÙÙاÙر_ÙبراÙر_٠ارس_أبرÙÙ_٠اÙ_ÙÙÙÙÙ_ÙÙÙÙÙز_غشت_شتÙبر_Ø£ÙتÙبر_ÙÙÙبر_دجÙبر'.split('_'), 36339 monthsShort : 'ÙÙاÙر_ÙبراÙر_٠ارس_أبرÙÙ_٠اÙ_ÙÙÙÙÙ_ÙÙÙÙÙز_غشت_شتÙبر_Ø£ÙتÙبر_ÙÙÙبر_دجÙبر'.split('_'), 36340 weekdays : 'اÙØ£Øد_اÙإتÙÙÙ_اÙØ«Ùاثاء_اÙأربعاء_اÙخ٠Ùس_اÙج٠عة_اÙسبت'.split('_'), 36341 weekdaysShort : 'اØد_اتÙÙÙ_Ø«Ùاثاء_اربعاء_خ٠Ùس_ج٠عة_سبت'.split('_'), 36342 weekdaysMin : 'Ø_Ù_Ø«_ر_Ø®_ج_س'.split('_'), 36343 weekdaysParseExact : true, 36344 longDateFormat : { 36345 LT : 'HH:mm', 36346 LTS : 'HH:mm:ss', 36347 L : 'DD/MM/YYYY', 36348 LL : 'D MMMM YYYY', 36349 LLL : 'D MMMM YYYY HH:mm', 36350 LLLL : 'dddd D MMMM YYYY HH:mm' 36351 }, 36352 calendar : { 36353 sameDay: '[اÙÙÙ٠عÙ٠اÙساعة] LT', 36354 nextDay: '[غدا عÙ٠اÙساعة] LT', 36355 nextWeek: 'dddd [عÙ٠اÙساعة] LT', 36356 lastDay: '[أ٠س عÙ٠اÙساعة] LT', 36357 lastWeek: 'dddd [عÙ٠اÙساعة] LT', 36358 sameElse: 'L' 36359 }, 36360 relativeTime : { 36361 future : 'ÙÙ %s', 36362 past : 'Ù ÙØ° %s', 36363 s : 'Ø«ÙاÙ', 36364 ss : '%d ثاÙÙØ©', 36365 m : 'دÙÙÙØ©', 36366 mm : '%d دÙائÙ', 36367 h : 'ساعة', 36368 hh : '%d ساعات', 36369 d : 'ÙÙÙ ', 36370 dd : '%d Ø£Ùا٠', 36371 M : 'Ø´Ùر', 36372 MM : '%d أشÙر', 36373 y : 'سÙØ©', 36374 yy : '%d سÙÙات' 36375 }, 36376 week : { 36377 dow : 0, // Sunday is the first day of the week. 36378 doy : 12 // The week that contains Jan 1st is the first week of the year. 36379 } 36380 }); 36381 36382 return arKw; 36383 36384}))); 36385 36386 36387/***/ }), 36388/* 35 */ 36389/***/ (function(module, exports, __webpack_require__) { 36390 36391//! moment.js locale configuration 36392 36393;(function (global, factory) { 36394 true ? factory(__webpack_require__(0)) : 36395 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 36396 factory(global.moment) 36397}(this, (function (moment) { 'use strict'; 36398 36399 36400 var symbolMap = { 36401 '1': '1', 36402 '2': '2', 36403 '3': '3', 36404 '4': '4', 36405 '5': '5', 36406 '6': '6', 36407 '7': '7', 36408 '8': '8', 36409 '9': '9', 36410 '0': '0' 36411 }, pluralForm = function (n) { 36412 return n === 0 ? 0 : n === 1 ? 1 : n === 2 ? 2 : n % 100 >= 3 && n % 100 <= 10 ? 3 : n % 100 >= 11 ? 4 : 5; 36413 }, plurals = { 36414 s : ['Ø£Ù٠٠٠ثاÙÙØ©', 'ثاÙÙØ© ÙاØدة', ['ثاÙÙتاÙ', 'ثاÙÙتÙÙ'], '%d Ø«ÙاÙ', '%d ثاÙÙØ©', '%d ثاÙÙØ©'], 36415 m : ['Ø£Ù٠٠٠دÙÙÙØ©', 'دÙÙÙØ© ÙاØدة', ['دÙÙÙتاÙ', 'دÙÙÙتÙÙ'], '%d دÙائÙ', '%d دÙÙÙØ©', '%d دÙÙÙØ©'],
vendor: 52,588 bytes, lines 36416-37905
36416 h : ['Ø£Ù٠٠٠ساعة', 'ساعة ÙاØدة', ['ساعتاÙ', 'ساعتÙÙ'], '%d ساعات', '%d ساعة', '%d ساعة'], 36417 d : ['Ø£ÙÙ Ù Ù ÙÙÙ ', 'ÙÙÙ ÙاØد', ['ÙÙ٠اÙ', 'ÙÙÙ ÙÙ'], '%d Ø£Ùا٠', '%d ÙÙÙ Ùا', '%d ÙÙÙ '], 36418 M : ['Ø£ÙÙ Ù Ù Ø´Ùر', 'Ø´Ùر ÙاØد', ['Ø´ÙراÙ', 'Ø´ÙرÙÙ'], '%d أشÙر', '%d Ø´Ùرا', '%d Ø´Ùر'], 36419 y : ['Ø£Ù٠٠٠عا٠', 'عا٠ÙاØد', ['عا٠اÙ', 'عا٠ÙÙ'], '%d أعÙا٠', '%d عا٠Ùا', '%d عا٠'] 36420 }, pluralize = function (u) { 36421 return function (number, withoutSuffix, string, isFuture) { 36422 var f = pluralForm(number), 36423 str = plurals[u][pluralForm(number)]; 36424 if (f === 2) { 36425 str = str[withoutSuffix ? 0 : 1]; 36426 } 36427 return str.replace(/%d/i, number); 36428 }; 36429 }, months = [ 36430 'ÙÙاÙر', 36431 'ÙبراÙر', 36432 '٠ارس', 36433 'أبرÙÙ', 36434 '٠اÙÙ', 36435 'ÙÙÙÙÙ', 36436 'ÙÙÙÙÙ', 36437 'أغسطس', 36438 'سبت٠بر', 36439 'Ø£ÙتÙبر', 36440 'ÙÙÙ٠بر', 36441 'دÙس٠بر' 36442 ]; 36443 36444 var arLy = moment.defineLocale('ar-ly', { 36445 months : months, 36446 monthsShort : months, 36447 weekdays : 'اÙØ£Øد_اÙإثÙÙÙ_اÙØ«Ùاثاء_اÙأربعاء_اÙخ٠Ùس_اÙج٠عة_اÙسبت'.split('_'), 36448 weekdaysShort : 'Ø£Øد_إثÙÙÙ_Ø«Ùاثاء_أربعاء_خ٠Ùس_ج٠عة_سبت'.split('_'), 36449 weekdaysMin : 'Ø_Ù_Ø«_ر_Ø®_ج_س'.split('_'), 36450 weekdaysParseExact : true, 36451 longDateFormat : { 36452 LT : 'HH:mm', 36453 LTS : 'HH:mm:ss', 36454 L : 'D/\u200FM/\u200FYYYY', 36455 LL : 'D MMMM YYYY', 36456 LLL : 'D MMMM YYYY HH:mm', 36457 LLLL : 'dddd D MMMM YYYY HH:mm' 36458 }, 36459 meridiemParse: /ص|Ù /, 36460 isPM : function (input) { 36461 return 'Ù ' === input; 36462 }, 36463 meridiem : function (hour, minute, isLower) { 36464 if (hour < 12) { 36465 return 'ص'; 36466 } else { 36467 return 'Ù '; 36468 } 36469 }, 36470 calendar : { 36471 sameDay: '[اÙÙÙ٠عÙد اÙساعة] LT', 36472 nextDay: '[غدÙا عÙد اÙساعة] LT', 36473 nextWeek: 'dddd [عÙد اÙساعة] LT', 36474 lastDay: '[أ٠س عÙد اÙساعة] LT', 36475 lastWeek: 'dddd [عÙد اÙساعة] LT', 36476 sameElse: 'L' 36477 }, 36478 relativeTime : { 36479 future : 'بعد %s', 36480 past : 'Ù ÙØ° %s', 36481 s : pluralize('s'), 36482 ss : pluralize('s'), 36483 m : pluralize('m'), 36484 mm : pluralize('m'), 36485 h : pluralize('h'), 36486 hh : pluralize('h'), 36487 d : pluralize('d'), 36488 dd : pluralize('d'), 36489 M : pluralize('M'), 36490 MM : pluralize('M'), 36491 y : pluralize('y'), 36492 yy : pluralize('y') 36493 }, 36494 preparse: function (string) { 36495 return string.replace(/Ø/g, ','); 36496 }, 36497 postformat: function (string) { 36498 return string.replace(/\d/g, function (match) { 36499 return symbolMap[match]; 36500 }).replace(/,/g, 'Ø'); 36501 }, 36502 week : { 36503 dow : 6, // Saturday is the first day of the week. 36504 doy : 12 // The week that contains Jan 1st is the first week of the year. 36505 } 36506 }); 36507 36508 return arLy; 36509 36510}))); 36511 36512 36513/***/ }), 36514/* 36 */ 36515/***/ (function(module, exports, __webpack_require__) { 36516 36517//! moment.js locale configuration 36518 36519;(function (global, factory) { 36520 true ? factory(__webpack_require__(0)) : 36521 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 36522 factory(global.moment) 36523}(this, (function (moment) { 'use strict'; 36524 36525 36526 var arMa = moment.defineLocale('ar-ma', { 36527 months : 'ÙÙاÙر_ÙبراÙر_٠ارس_أبرÙÙ_٠اÙ_ÙÙÙÙÙ_ÙÙÙÙÙز_غشت_شتÙبر_Ø£ÙتÙبر_ÙÙÙبر_دجÙبر'.split('_'), 36528 monthsShort : 'ÙÙاÙر_ÙبراÙر_٠ارس_أبرÙÙ_٠اÙ_ÙÙÙÙÙ_ÙÙÙÙÙز_غشت_شتÙبر_Ø£ÙتÙبر_ÙÙÙبر_دجÙبر'.split('_'), 36529 weekdays : 'اÙØ£Øد_اÙإتÙÙÙ_اÙØ«Ùاثاء_اÙأربعاء_اÙخ٠Ùس_اÙج٠عة_اÙسبت'.split('_'), 36530 weekdaysShort : 'اØد_اتÙÙÙ_Ø«Ùاثاء_اربعاء_خ٠Ùس_ج٠عة_سبت'.split('_'), 36531 weekdaysMin : 'Ø_Ù_Ø«_ر_Ø®_ج_س'.split('_'), 36532 weekdaysParseExact : true, 36533 longDateFormat : { 36534 LT : 'HH:mm', 36535 LTS : 'HH:mm:ss', 36536 L : 'DD/MM/YYYY', 36537 LL : 'D MMMM YYYY', 36538 LLL : 'D MMMM YYYY HH:mm', 36539 LLLL : 'dddd D MMMM YYYY HH:mm' 36540 }, 36541 calendar : { 36542 sameDay: '[اÙÙÙ٠عÙ٠اÙساعة] LT', 36543 nextDay: '[غدا عÙ٠اÙساعة] LT', 36544 nextWeek: 'dddd [عÙ٠اÙساعة] LT', 36545 lastDay: '[أ٠س عÙ٠اÙساعة] LT', 36546 lastWeek: 'dddd [عÙ٠اÙساعة] LT', 36547 sameElse: 'L' 36548 }, 36549 relativeTime : { 36550 future : 'ÙÙ %s', 36551 past : 'Ù ÙØ° %s', 36552 s : 'Ø«ÙاÙ', 36553 ss : '%d ثاÙÙØ©', 36554 m : 'دÙÙÙØ©', 36555 mm : '%d دÙائÙ', 36556 h : 'ساعة', 36557 hh : '%d ساعات', 36558 d : 'ÙÙÙ ', 36559 dd : '%d Ø£Ùا٠', 36560 M : 'Ø´Ùر', 36561 MM : '%d أشÙر', 36562 y : 'سÙØ©', 36563 yy : '%d سÙÙات' 36564 }, 36565 week : { 36566 dow : 6, // Saturday is the first day of the week. 36567 doy : 12 // The week that contains Jan 1st is the first week of the year. 36568 } 36569 }); 36570 36571 return arMa; 36572 36573}))); 36574 36575 36576/***/ }), 36577/* 37 */ 36578/***/ (function(module, exports, __webpack_require__) { 36579 36580//! moment.js locale configuration 36581 36582;(function (global, factory) { 36583 true ? factory(__webpack_require__(0)) : 36584 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 36585 factory(global.moment) 36586}(this, (function (moment) { 'use strict'; 36587 36588 36589 var symbolMap = { 36590 '1': 'Ù¡', 36591 '2': 'Ù¢', 36592 '3': 'Ù£', 36593 '4': 'Ù¤', 36594 '5': 'Ù¥', 36595 '6': 'Ù¦', 36596 '7': 'Ù§', 36597 '8': 'Ù¨', 36598 '9': 'Ù©', 36599 '0': 'Ù ' 36600 }, numberMap = { 36601 'Ù¡': '1', 36602 'Ù¢': '2', 36603 'Ù£': '3', 36604 'Ù¤': '4', 36605 'Ù¥': '5', 36606 'Ù¦': '6', 36607 'Ù§': '7', 36608 'Ù¨': '8', 36609 'Ù©': '9', 36610 'Ù ': '0' 36611 }; 36612 36613 var arSa = moment.defineLocale('ar-sa', { 36614 months : 'ÙÙاÙر_ÙبراÙر_٠ارس_أبرÙÙ_٠اÙÙ_ÙÙÙÙÙ_ÙÙÙÙÙ_أغسطس_سبت٠بر_Ø£ÙتÙبر_ÙÙÙ٠بر_دÙس٠بر'.split('_'), 36615 monthsShort : 'ÙÙاÙر_ÙبراÙر_٠ارس_أبرÙÙ_٠اÙÙ_ÙÙÙÙÙ_ÙÙÙÙÙ_أغسطس_سبت٠بر_Ø£ÙتÙبر_ÙÙÙ٠بر_دÙس٠بر'.split('_'), 36616 weekdays : 'اÙØ£Øد_اÙإثÙÙÙ_اÙØ«Ùاثاء_اÙأربعاء_اÙخ٠Ùس_اÙج٠عة_اÙسبت'.split('_'), 36617 weekdaysShort : 'Ø£Øد_إثÙÙÙ_Ø«Ùاثاء_أربعاء_خ٠Ùس_ج٠عة_سبت'.split('_'), 36618 weekdaysMin : 'Ø_Ù_Ø«_ر_Ø®_ج_س'.split('_'), 36619 weekdaysParseExact : true, 36620 longDateFormat : { 36621 LT : 'HH:mm', 36622 LTS : 'HH:mm:ss', 36623 L : 'DD/MM/YYYY', 36624 LL : 'D MMMM YYYY', 36625 LLL : 'D MMMM YYYY HH:mm', 36626 LLLL : 'dddd D MMMM YYYY HH:mm' 36627 }, 36628 meridiemParse: /ص|Ù /, 36629 isPM : function (input) { 36630 return 'Ù ' === input; 36631 }, 36632 meridiem : function (hour, minute, isLower) { 36633 if (hour < 12) { 36634 return 'ص'; 36635 } else { 36636 return 'Ù '; 36637 } 36638 }, 36639 calendar : { 36640 sameDay: '[اÙÙÙ٠عÙ٠اÙساعة] LT', 36641 nextDay: '[غدا عÙ٠اÙساعة] LT', 36642 nextWeek: 'dddd [عÙ٠اÙساعة] LT', 36643 lastDay: '[أ٠س عÙ٠اÙساعة] LT', 36644 lastWeek: 'dddd [عÙ٠اÙساعة] LT', 36645 sameElse: 'L' 36646 }, 36647 relativeTime : { 36648 future : 'ÙÙ %s', 36649 past : 'Ù ÙØ° %s', 36650 s : 'Ø«ÙاÙ', 36651 ss : '%d ثاÙÙØ©', 36652 m : 'دÙÙÙØ©', 36653 mm : '%d دÙائÙ', 36654 h : 'ساعة', 36655 hh : '%d ساعات', 36656 d : 'ÙÙÙ ', 36657 dd : '%d Ø£Ùا٠', 36658 M : 'Ø´Ùر', 36659 MM : '%d أشÙر', 36660 y : 'سÙØ©', 36661 yy : '%d سÙÙات' 36662 }, 36663 preparse: function (string) { 36664 return string.replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) { 36665 return numberMap[match]; 36666 }).replace(/Ø/g, ','); 36667 }, 36668 postformat: function (string) { 36669 return string.replace(/\d/g, function (match) { 36670 return symbolMap[match]; 36671 }).replace(/,/g, 'Ø'); 36672 }, 36673 week : { 36674 dow : 0, // Sunday is the first day of the week. 36675 doy : 6 // The week that contains Jan 1st is the first week of the year. 36676 } 36677 }); 36678 36679 return arSa; 36680 36681}))); 36682 36683 36684/***/ }), 36685/* 38 */ 36686/***/ (function(module, exports, __webpack_require__) { 36687 36688//! moment.js locale configuration 36689 36690;(function (global, factory) { 36691 true ? factory(__webpack_require__(0)) : 36692 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 36693 factory(global.moment) 36694}(this, (function (moment) { 'use strict'; 36695 36696 36697 var arTn = moment.defineLocale('ar-tn', { 36698 months: 'جاÙÙÙ_ÙÙÙرÙ_٠ارس_Ø£ÙرÙÙ_٠اÙ_جÙاÙ_جÙÙÙÙØ©_Ø£Ùت_سبت٠بر_Ø£ÙتÙبر_ÙÙÙ٠بر_دÙس٠بر'.split('_'), 36699 monthsShort: 'جاÙÙÙ_ÙÙÙرÙ_٠ارس_Ø£ÙرÙÙ_٠اÙ_جÙاÙ_جÙÙÙÙØ©_Ø£Ùت_سبت٠بر_Ø£ÙتÙبر_ÙÙÙ٠بر_دÙس٠بر'.split('_'), 36700 weekdays: 'اÙØ£Øد_اÙإثÙÙÙ_اÙØ«Ùاثاء_اÙأربعاء_اÙخ٠Ùس_اÙج٠عة_اÙسبت'.split('_'), 36701 weekdaysShort: 'Ø£Øد_إثÙÙÙ_Ø«Ùاثاء_أربعاء_خ٠Ùس_ج٠عة_سبت'.split('_'), 36702 weekdaysMin: 'Ø_Ù_Ø«_ر_Ø®_ج_س'.split('_'), 36703 weekdaysParseExact : true, 36704 longDateFormat: { 36705 LT: 'HH:mm', 36706 LTS: 'HH:mm:ss', 36707 L: 'DD/MM/YYYY', 36708 LL: 'D MMMM YYYY', 36709 LLL: 'D MMMM YYYY HH:mm', 36710 LLLL: 'dddd D MMMM YYYY HH:mm' 36711 }, 36712 calendar: { 36713 sameDay: '[اÙÙÙ٠عÙ٠اÙساعة] LT', 36714 nextDay: '[غدا عÙ٠اÙساعة] LT', 36715 nextWeek: 'dddd [عÙ٠اÙساعة] LT', 36716 lastDay: '[أ٠س عÙ٠اÙساعة] LT', 36717 lastWeek: 'dddd [عÙ٠اÙساعة] LT', 36718 sameElse: 'L' 36719 }, 36720 relativeTime: { 36721 future: 'ÙÙ %s', 36722 past: 'Ù ÙØ° %s', 36723 s: 'Ø«ÙاÙ', 36724 ss : '%d ثاÙÙØ©', 36725 m: 'دÙÙÙØ©', 36726 mm: '%d دÙائÙ', 36727 h: 'ساعة', 36728 hh: '%d ساعات', 36729 d: 'ÙÙÙ ', 36730 dd: '%d Ø£Ùا٠', 36731 M: 'Ø´Ùر', 36732 MM: '%d أشÙر', 36733 y: 'سÙØ©', 36734 yy: '%d سÙÙات' 36735 }, 36736 week: { 36737 dow: 1, // Monday is the first day of the week. 36738 doy: 4 // The week that contains Jan 4th is the first week of the year. 36739 } 36740 }); 36741 36742 return arTn; 36743 36744}))); 36745 36746 36747/***/ }), 36748/* 39 */ 36749/***/ (function(module, exports, __webpack_require__) { 36750 36751//! moment.js locale configuration 36752 36753;(function (global, factory) { 36754 true ? factory(__webpack_require__(0)) : 36755 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 36756 factory(global.moment) 36757}(this, (function (moment) { 'use strict'; 36758 36759 36760 var symbolMap = { 36761 '1': 'Ù¡', 36762 '2': 'Ù¢', 36763 '3': 'Ù£', 36764 '4': 'Ù¤', 36765 '5': 'Ù¥', 36766 '6': 'Ù¦', 36767 '7': 'Ù§', 36768 '8': 'Ù¨', 36769 '9': 'Ù©', 36770 '0': 'Ù ' 36771 }, numberMap = { 36772 'Ù¡': '1', 36773 'Ù¢': '2', 36774 'Ù£': '3', 36775 'Ù¤': '4', 36776 'Ù¥': '5', 36777 'Ù¦': '6', 36778 'Ù§': '7', 36779 'Ù¨': '8', 36780 'Ù©': '9', 36781 'Ù ': '0' 36782 }, pluralForm = function (n) { 36783 return n === 0 ? 0 : n === 1 ? 1 : n === 2 ? 2 : n % 100 >= 3 && n % 100 <= 10 ? 3 : n % 100 >= 11 ? 4 : 5; 36784 }, plurals = { 36785 s : ['Ø£Ù٠٠٠ثاÙÙØ©', 'ثاÙÙØ© ÙاØدة', ['ثاÙÙتاÙ', 'ثاÙÙتÙÙ'], '%d Ø«ÙاÙ', '%d ثاÙÙØ©', '%d ثاÙÙØ©'], 36786 m : ['Ø£Ù٠٠٠دÙÙÙØ©', 'دÙÙÙØ© ÙاØدة', ['دÙÙÙتاÙ', 'دÙÙÙتÙÙ'], '%d دÙائÙ', '%d دÙÙÙØ©', '%d دÙÙÙØ©'], 36787 h : ['Ø£Ù٠٠٠ساعة', 'ساعة ÙاØدة', ['ساعتاÙ', 'ساعتÙÙ'], '%d ساعات', '%d ساعة', '%d ساعة'], 36788 d : ['Ø£ÙÙ Ù Ù ÙÙÙ ', 'ÙÙÙ ÙاØد', ['ÙÙ٠اÙ', 'ÙÙÙ ÙÙ'], '%d Ø£Ùا٠', '%d ÙÙÙ Ùا', '%d ÙÙÙ '], 36789 M : ['Ø£ÙÙ Ù Ù Ø´Ùر', 'Ø´Ùر ÙاØد', ['Ø´ÙراÙ', 'Ø´ÙرÙÙ'], '%d أشÙر', '%d Ø´Ùرا', '%d Ø´Ùر'], 36790 y : ['Ø£Ù٠٠٠عا٠', 'عا٠ÙاØد', ['عا٠اÙ', 'عا٠ÙÙ'], '%d أعÙا٠', '%d عا٠Ùا', '%d عا٠'] 36791 }, pluralize = function (u) { 36792 return function (number, withoutSuffix, string, isFuture) { 36793 var f = pluralForm(number), 36794 str = plurals[u][pluralForm(number)]; 36795 if (f === 2) { 36796 str = str[withoutSuffix ? 0 : 1]; 36797 } 36798 return str.replace(/%d/i, number); 36799 }; 36800 }, months = [ 36801 'ÙÙاÙر', 36802 'ÙبراÙر', 36803 '٠ارس', 36804 'أبرÙÙ', 36805 '٠اÙÙ', 36806 'ÙÙÙÙÙ', 36807 'ÙÙÙÙÙ', 36808 'أغسطس', 36809 'سبت٠بر', 36810 'Ø£ÙتÙبر', 36811 'ÙÙÙ٠بر', 36812 'دÙس٠بر' 36813 ]; 36814 36815 var ar = moment.defineLocale('ar', { 36816 months : months, 36817 monthsShort : months, 36818 weekdays : 'اÙØ£Øد_اÙإثÙÙÙ_اÙØ«Ùاثاء_اÙأربعاء_اÙخ٠Ùس_اÙج٠عة_اÙسبت'.split('_'), 36819 weekdaysShort : 'Ø£Øد_إثÙÙÙ_Ø«Ùاثاء_أربعاء_خ٠Ùس_ج٠عة_سبت'.split('_'), 36820 weekdaysMin : 'Ø_Ù_Ø«_ر_Ø®_ج_س'.split('_'), 36821 weekdaysParseExact : true, 36822 longDateFormat : { 36823 LT : 'HH:mm', 36824 LTS : 'HH:mm:ss', 36825 L : 'D/\u200FM/\u200FYYYY', 36826 LL : 'D MMMM YYYY', 36827 LLL : 'D MMMM YYYY HH:mm', 36828 LLLL : 'dddd D MMMM YYYY HH:mm' 36829 }, 36830 meridiemParse: /ص|Ù /, 36831 isPM : function (input) { 36832 return 'Ù ' === input; 36833 }, 36834 meridiem : function (hour, minute, isLower) { 36835 if (hour < 12) { 36836 return 'ص'; 36837 } else { 36838 return 'Ù '; 36839 } 36840 }, 36841 calendar : { 36842 sameDay: '[اÙÙÙ٠عÙد اÙساعة] LT', 36843 nextDay: '[غدÙا عÙد اÙساعة] LT', 36844 nextWeek: 'dddd [عÙد اÙساعة] LT', 36845 lastDay: '[أ٠س عÙد اÙساعة] LT', 36846 lastWeek: 'dddd [عÙد اÙساعة] LT', 36847 sameElse: 'L' 36848 }, 36849 relativeTime : { 36850 future : 'بعد %s', 36851 past : 'Ù ÙØ° %s', 36852 s : pluralize('s'), 36853 ss : pluralize('s'), 36854 m : pluralize('m'), 36855 mm : pluralize('m'), 36856 h : pluralize('h'), 36857 hh : pluralize('h'), 36858 d : pluralize('d'), 36859 dd : pluralize('d'), 36860 M : pluralize('M'), 36861 MM : pluralize('M'), 36862 y : pluralize('y'), 36863 yy : pluralize('y') 36864 }, 36865 preparse: function (string) { 36866 return string.replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) { 36867 return numberMap[match]; 36868 }).replace(/Ø/g, ','); 36869 }, 36870 postformat: function (string) { 36871 return string.replace(/\d/g, function (match) { 36872 return symbolMap[match]; 36873 }).replace(/,/g, 'Ø'); 36874 }, 36875 week : { 36876 dow : 6, // Saturday is the first day of the week. 36877 doy : 12 // The week that contains Jan 1st is the first week of the year. 36878 } 36879 }); 36880 36881 return ar; 36882 36883}))); 36884 36885 36886/***/ }), 36887/* 40 */ 36888/***/ (function(module, exports, __webpack_require__) { 36889 36890//! moment.js locale configuration 36891 36892;(function (global, factory) { 36893 true ? factory(__webpack_require__(0)) : 36894 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 36895 factory(global.moment) 36896}(this, (function (moment) { 'use strict'; 36897 36898 36899 var suffixes = { 36900 1: '-inci', 36901 5: '-inci', 36902 8: '-inci', 36903 70: '-inci', 36904 80: '-inci', 36905 2: '-nci', 36906 7: '-nci', 36907 20: '-nci', 36908 50: '-nci', 36909 3: '-üncü', 36910 4: '-üncü', 36911 100: '-üncü', 36912 6: '-ncı', 36913 9: '-uncu', 36914 10: '-uncu', 36915 30: '-uncu', 36916 60: '-ıncı', 36917 90: '-ıncı' 36918 }; 36919 36920 var az = moment.defineLocale('az', { 36921 months : 'yanvar_fevral_mart_aprel_may_iyun_iyul_avqust_sentyabr_oktyabr_noyabr_dekabr'.split('_'), 36922 monthsShort : 'yan_fev_mar_apr_may_iyn_iyl_avq_sen_okt_noy_dek'.split('_'), 36923 weekdays : 'Bazar_Bazar ertÉsi_ÃÉrÅÉnbÉ axÅamı_ÃÉrÅÉnbÉ_CümÉ axÅamı_CümÉ_ÅÉnbÉ'.split('_'), 36924 weekdaysShort : 'Baz_BzE_ÃAx_ÃÉr_CAx_Cüm_ÅÉn'.split('_'), 36925 weekdaysMin : 'Bz_BE_ÃA_ÃÉ_CA_Cü_ÅÉ'.split('_'), 36926 weekdaysParseExact : true, 36927 longDateFormat : { 36928 LT : 'HH:mm', 36929 LTS : 'HH:mm:ss', 36930 L : 'DD.MM.YYYY', 36931 LL : 'D MMMM YYYY', 36932 LLL : 'D MMMM YYYY HH:mm', 36933 LLLL : 'dddd, D MMMM YYYY HH:mm' 36934 }, 36935 calendar : { 36936 sameDay : '[bugün saat] LT', 36937 nextDay : '[sabah saat] LT', 36938 nextWeek : '[gÉlÉn hÉftÉ] dddd [saat] LT', 36939 lastDay : '[dünÉn] LT', 36940 lastWeek : '[keçÉn hÉftÉ] dddd [saat] LT', 36941 sameElse : 'L' 36942 }, 36943 relativeTime : { 36944 future : '%s sonra', 36945 past : '%s ÉvvÉl', 36946 s : 'birneÃ§É saniyÉ', 36947 ss : '%d saniyÉ', 36948 m : 'bir dÉqiqÉ', 36949 mm : '%d dÉqiqÉ', 36950 h : 'bir saat', 36951 hh : '%d saat', 36952 d : 'bir gün', 36953 dd : '%d gün', 36954 M : 'bir ay', 36955 MM : '%d ay', 36956 y : 'bir il', 36957 yy : '%d il' 36958 }, 36959 meridiemParse: /gecÉ|sÉhÉr|gündüz|axÅam/, 36960 isPM : function (input) { 36961 return /^(gündüz|axÅam)$/.test(input); 36962 }, 36963 meridiem : function (hour, minute, isLower) { 36964 if (hour < 4) { 36965 return 'gecÉ'; 36966 } else if (hour < 12) { 36967 return 'sÉhÉr'; 36968 } else if (hour < 17) { 36969 return 'gündüz'; 36970 } else { 36971 return 'axÅam'; 36972 } 36973 }, 36974 dayOfMonthOrdinalParse: /\d{1,2}-(ıncı|inci|nci|üncü|ncı|uncu)/, 36975 ordinal : function (number) { 36976 if (number === 0) { // special case for zero 36977 return number + '-ıncı'; 36978 } 36979 var a = number % 10, 36980 b = number % 100 - a, 36981 c = number >= 100 ? 100 : null; 36982 return number + (suffixes[a] || suffixes[b] || suffixes[c]); 36983 }, 36984 week : { 36985 dow : 1, // Monday is the first day of the week. 36986 doy : 7 // The week that contains Jan 1st is the first week of the year. 36987 } 36988 }); 36989 36990 return az; 36991 36992}))); 36993 36994 36995/***/ }), 36996/* 41 */ 36997/***/ (function(module, exports, __webpack_require__) { 36998 36999//! moment.js locale configuration 37000 37001;(function (global, factory) { 37002 true ? factory(__webpack_require__(0)) : 37003 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 37004 factory(global.moment) 37005}(this, (function (moment) { 'use strict'; 37006 37007 37008 function plural(word, num) { 37009 var forms = word.split('_'); 37010 return num % 10 === 1 && num % 100 !== 11 ? forms[0] : (num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]); 37011 } 37012 function relativeTimeWithPlural(number, withoutSuffix, key) { 37013 var format = { 37014 'ss': withoutSuffix ? 'ÑекÑнда_ÑекÑндÑ_ÑекÑнд' : 'ÑекÑндÑ_ÑекÑндÑ_ÑекÑнд', 37015 'mm': withoutSuffix ? 'Ñ Ð²ÑлÑна_Ñ Ð²ÑлÑнÑ_Ñ Ð²ÑлÑн' : 'Ñ Ð²ÑлÑнÑ_Ñ Ð²ÑлÑнÑ_Ñ Ð²ÑлÑн', 37016 'hh': withoutSuffix ? 'гадзÑна_гадзÑнÑ_гадзÑн' : 'гадзÑнÑ_гадзÑнÑ_гадзÑн', 37017 'dd': 'дзенÑ_днÑ_дзÑн', 37018 'MM': 'меÑÑÑ_меÑÑÑÑ_меÑÑÑаÑ', 37019 'yy': 'год_гадÑ_гадоÑ' 37020 }; 37021 if (key === 'm') { 37022 return withoutSuffix ? 'Ñ Ð²ÑлÑна' : 'Ñ Ð²ÑлÑнÑ'; 37023 } 37024 else if (key === 'h') { 37025 return withoutSuffix ? 'гадзÑна' : 'гадзÑнÑ'; 37026 } 37027 else { 37028 return number + ' ' + plural(format[key], +number); 37029 } 37030 } 37031 37032 var be = moment.defineLocale('be', { 37033 months : { 37034 format: 'ÑÑÑдзенÑ_лÑÑага_ÑакавÑка_кÑаÑавÑка_ÑÑаÑнÑ_ÑÑÑвенÑ_лÑпенÑ_жнÑÑнÑ_веÑаÑнÑ_каÑÑÑÑÑнÑка_лÑÑÑапада_ÑнежнÑ'.split('_'), 37035 standalone: 'ÑÑÑдзенÑ_лÑÑÑ_ÑакавÑк_кÑаÑавÑк_ÑÑавенÑ_ÑÑÑвенÑ_лÑпенÑ_жнÑвенÑ_веÑаÑенÑ_каÑÑÑÑÑнÑк_лÑÑÑапад_ÑнежанÑ'.split('_') 37036 }, 37037 monthsShort : 'ÑÑÑд_лÑÑ_Ñак_кÑаÑ_ÑÑав_ÑÑÑв_лÑп_жнÑв_веÑ_каÑÑ_лÑÑÑ_Ñнеж'.split('_'), 37038 weekdays : { 37039 format: 'нÑдзелÑ_панÑдзелак_аÑÑоÑак_ÑеÑадÑ_ÑаÑвеÑ_пÑÑнÑÑÑ_ÑÑбоÑÑ'.split('_'), 37040 standalone: 'нÑдзелÑ_панÑдзелак_аÑÑоÑак_ÑеÑада_ÑаÑвеÑ_пÑÑнÑÑа_ÑÑбоÑа'.split('_'), 37041 isFormat: /\[ ?[УÑÑ] ?(?:мÑнÑлÑÑ|наÑÑÑпнÑÑ)? ?\] ?dddd/ 37042 }, 37043 weekdaysShort : 'нд_пн_аÑ_ÑÑ_ÑÑ_пÑ_Ñб'.split('_'), 37044 weekdaysMin : 'нд_пн_аÑ_ÑÑ_ÑÑ_пÑ_Ñб'.split('_'), 37045 longDateFormat : { 37046 LT : 'HH:mm', 37047 LTS : 'HH:mm:ss', 37048 L : 'DD.MM.YYYY', 37049 LL : 'D MMMM YYYY г.', 37050 LLL : 'D MMMM YYYY г., HH:mm', 37051 LLLL : 'dddd, D MMMM YYYY г., HH:mm' 37052 }, 37053 calendar : { 37054 sameDay: '[СÑÐ½Ð½Ñ Ñ] LT', 37055 nextDay: '[ÐаÑÑÑа Ñ] LT', 37056 lastDay: '[УÑоÑа Ñ] LT', 37057 nextWeek: function () { 37058 return '[У] dddd [Ñ] LT'; 37059 }, 37060 lastWeek: function () { 37061 switch (this.day()) { 37062 case 0: 37063 case 3: 37064 case 5: 37065 case 6: 37066 return '[У мÑнÑлÑÑ] dddd [Ñ] LT'; 37067 case 1: 37068 case 2: 37069 case 4: 37070 return '[У мÑнÑлÑ] dddd [Ñ] LT'; 37071 } 37072 }, 37073 sameElse: 'L' 37074 }, 37075 relativeTime : { 37076 future : 'пÑаз %s', 37077 past : '%s ÑамÑ', 37078 s : 'некалÑÐºÑ ÑекÑнд', 37079 m : relativeTimeWithPlural, 37080 mm : relativeTimeWithPlural, 37081 h : relativeTimeWithPlural, 37082 hh : relativeTimeWithPlural, 37083 d : 'дзенÑ', 37084 dd : relativeTimeWithPlural, 37085 M : 'меÑÑÑ', 37086 MM : relativeTimeWithPlural, 37087 y : 'год', 37088 yy : relativeTimeWithPlural 37089 }, 37090 meridiemParse: /ноÑÑ|ÑанÑÑÑ|днÑ|веÑаÑа/, 37091 isPM : function (input) { 37092 return /^(днÑ|веÑаÑа)$/.test(input); 37093 }, 37094 meridiem : function (hour, minute, isLower) { 37095 if (hour < 4) { 37096 return 'ноÑÑ'; 37097 } else if (hour < 12) { 37098 return 'ÑанÑÑÑ'; 37099 } else if (hour < 17) { 37100 return 'днÑ'; 37101 } else { 37102 return 'веÑаÑа'; 37103 } 37104 }, 37105 dayOfMonthOrdinalParse: /\d{1,2}-(Ñ|Ñ|га)/, 37106 ordinal: function (number, period) { 37107 switch (period) { 37108 case 'M': 37109 case 'd': 37110 case 'DDD': 37111 case 'w': 37112 case 'W': 37113 return (number % 10 === 2 || number % 10 === 3) && (number % 100 !== 12 && number % 100 !== 13) ? number + '-Ñ' : number + '-Ñ'; 37114 case 'D': 37115 return number + '-га'; 37116 default: 37117 return number; 37118 } 37119 }, 37120 week : { 37121 dow : 1, // Monday is the first day of the week. 37122 doy : 7 // The week that contains Jan 1st is the first week of the year. 37123 } 37124 }); 37125 37126 return be; 37127 37128}))); 37129 37130 37131/***/ }), 37132/* 42 */ 37133/***/ (function(module, exports, __webpack_require__) { 37134 37135//! moment.js locale configuration 37136 37137;(function (global, factory) { 37138 true ? factory(__webpack_require__(0)) : 37139 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 37140 factory(global.moment) 37141}(this, (function (moment) { 'use strict'; 37142 37143 37144 var bg = moment.defineLocale('bg', { 37145 months : 'ÑнÑаÑи_ÑевÑÑаÑи_маÑÑ_апÑил_май_Ñни_Ñли_авгÑÑÑ_ÑепÑемвÑи_окÑомвÑи_ноемвÑи_декемвÑи'.split('_'), 37146 monthsShort : 'ÑнÑ_Ñев_маÑ_апÑ_май_Ñни_Ñли_авг_Ñеп_окÑ_ное_дек'.split('_'), 37147 weekdays : 'неделÑ_понеделник_вÑоÑник_ÑÑÑда_ÑеÑвÑÑÑÑк_пеÑÑк_ÑÑбоÑа'.split('_'), 37148 weekdaysShort : 'нед_пон_вÑо_ÑÑÑ_ÑеÑ_пеÑ_ÑÑб'.split('_'), 37149 weekdaysMin : 'нд_пн_вÑ_ÑÑ_ÑÑ_пÑ_Ñб'.split('_'), 37150 longDateFormat : { 37151 LT : 'H:mm', 37152 LTS : 'H:mm:ss', 37153 L : 'D.MM.YYYY', 37154 LL : 'D MMMM YYYY', 37155 LLL : 'D MMMM YYYY H:mm', 37156 LLLL : 'dddd, D MMMM YYYY H:mm' 37157 }, 37158 calendar : { 37159 sameDay : '[ÐÐ½ÐµÑ Ð²] LT', 37160 nextDay : '[УÑÑе в] LT', 37161 nextWeek : 'dddd [в] LT', 37162 lastDay : '[ÐÑеÑа в] LT', 37163 lastWeek : function () { 37164 switch (this.day()) { 37165 case 0: 37166 case 3: 37167 case 6: 37168 return '[РизминалаÑа] dddd [в] LT'; 37169 case 1: 37170 case 2: 37171 case 4: 37172 case 5: 37173 return '[РизминалиÑ] dddd [в] LT'; 37174 } 37175 }, 37176 sameElse : 'L' 37177 }, 37178 relativeTime : { 37179 future : 'Ñлед %s', 37180 past : 'пÑеди %s', 37181 s : 'нÑколко ÑекÑнди', 37182 ss : '%d ÑекÑнди', 37183 m : 'минÑÑа', 37184 mm : '%d минÑÑи', 37185 h : 'ÑаÑ', 37186 hh : '%d ÑаÑа', 37187 d : 'ден', 37188 dd : '%d дни', 37189 M : 'меÑеÑ', 37190 MM : '%d меÑеÑа', 37191 y : 'година', 37192 yy : '%d години' 37193 }, 37194 dayOfMonthOrdinalParse: /\d{1,2}-(ев|ен|Ñи|ви|Ñи|ми)/, 37195 ordinal : function (number) { 37196 var lastDigit = number % 10, 37197 last2Digits = number % 100; 37198 if (number === 0) { 37199 return number + '-ев'; 37200 } else if (last2Digits === 0) { 37201 return number + '-ен'; 37202 } else if (last2Digits > 10 && last2Digits < 20) { 37203 return number + '-Ñи'; 37204 } else if (lastDigit === 1) { 37205 return number + '-ви'; 37206 } else if (lastDigit === 2) { 37207 return number + '-Ñи'; 37208 } else if (lastDigit === 7 || lastDigit === 8) { 37209 return number + '-ми'; 37210 } else { 37211 return number + '-Ñи'; 37212 } 37213 }, 37214 week : { 37215 dow : 1, // Monday is the first day of the week. 37216 doy : 7 // The week that contains Jan 1st is the first week of the year. 37217 } 37218 }); 37219 37220 return bg; 37221 37222}))); 37223 37224 37225/***/ }), 37226/* 43 */ 37227/***/ (function(module, exports, __webpack_require__) { 37228 37229//! moment.js locale configuration 37230 37231;(function (global, factory) { 37232 true ? factory(__webpack_require__(0)) : 37233 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 37234 factory(global.moment) 37235}(this, (function (moment) { 'use strict'; 37236 37237 37238 var bm = moment.defineLocale('bm', { 37239 months : 'Zanwuyekalo_Fewuruyekalo_Marisikalo_Awirilikalo_MÉkalo_ZuwÉnkalo_Zuluyekalo_Utikalo_SÉtanburukalo_ÉkutÉburukalo_Nowanburukalo_Desanburukalo'.split('_'), 37240 monthsShort : 'Zan_Few_Mar_Awi_MÉ_Zuw_Zul_Uti_SÉt_Éku_Now_Des'.split('_'), 37241 weekdays : 'Kari_NtÉnÉn_Tarata_Araba_Alamisa_Juma_Sibiri'.split('_'), 37242 weekdaysShort : 'Kar_NtÉ_Tar_Ara_Ala_Jum_Sib'.split('_'), 37243 weekdaysMin : 'Ka_Nt_Ta_Ar_Al_Ju_Si'.split('_'), 37244 longDateFormat : { 37245 LT : 'HH:mm', 37246 LTS : 'HH:mm:ss', 37247 L : 'DD/MM/YYYY', 37248 LL : 'MMMM [tile] D [san] YYYY', 37249 LLL : 'MMMM [tile] D [san] YYYY [lÉrÉ] HH:mm', 37250 LLLL : 'dddd MMMM [tile] D [san] YYYY [lÉrÉ] HH:mm' 37251 }, 37252 calendar : { 37253 sameDay : '[Bi lÉrÉ] LT', 37254 nextDay : '[Sini lÉrÉ] LT', 37255 nextWeek : 'dddd [don lÉrÉ] LT', 37256 lastDay : '[Kunu lÉrÉ] LT', 37257 lastWeek : 'dddd [tÉmÉnen lÉrÉ] LT', 37258 sameElse : 'L' 37259 }, 37260 relativeTime : { 37261 future : '%s kÉnÉ', 37262 past : 'a bÉ %s bÉ', 37263 s : 'sanga dama dama', 37264 ss : 'sekondi %d', 37265 m : 'miniti kelen', 37266 mm : 'miniti %d', 37267 h : 'lÉrÉ kelen', 37268 hh : 'lÉrÉ %d', 37269 d : 'tile kelen', 37270 dd : 'tile %d', 37271 M : 'kalo kelen', 37272 MM : 'kalo %d', 37273 y : 'san kelen', 37274 yy : 'san %d' 37275 }, 37276 week : { 37277 dow : 1, // Monday is the first day of the week. 37278 doy : 4 // The week that contains Jan 4th is the first week of the year. 37279 } 37280 }); 37281 37282 return bm; 37283 37284}))); 37285 37286 37287/***/ }), 37288/* 44 */ 37289/***/ (function(module, exports, __webpack_require__) { 37290 37291//! moment.js locale configuration 37292 37293;(function (global, factory) { 37294 true ? factory(__webpack_require__(0)) : 37295 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 37296 factory(global.moment) 37297}(this, (function (moment) { 'use strict'; 37298 37299 37300 var symbolMap = { 37301 '1': '১', 37302 '2': '২', 37303 '3': '৩', 37304 '4': '৪', 37305 '5': '৫', 37306 '6': '৬', 37307 '7': 'à§', 37308 '8': '৮', 37309 '9': '৯', 37310 '0': '০' 37311 }, 37312 numberMap = { 37313 '১': '1', 37314 '২': '2', 37315 '৩': '3', 37316 '৪': '4', 37317 '৫': '5', 37318 '৬': '6', 37319 'à§': '7', 37320 '৮': '8', 37321 '৯': '9', 37322 '০': '0' 37323 }; 37324 37325 var bn = moment.defineLocale('bn', { 37326 months : 'à¦à¦¾à¦¨à§à§à¦¾à¦°à§_ফà§à¦¬à§à¦°à§à§à¦¾à¦°à¦¿_মারà§à¦_à¦à¦ªà§à¦°à¦¿à¦²_মà§_à¦à§à¦¨_à¦à§à¦²à¦¾à¦_à¦à¦à¦¸à§à¦_সà§à¦ªà§à¦à§à¦®à§à¦¬à¦°_ঠà¦à§à¦à§à¦¬à¦°_নà¦à§à¦®à§à¦¬à¦°_ডিসà§à¦®à§à¦¬à¦°'.split('_'), 37327 monthsShort : 'à¦à¦¾à¦¨à§_ফà§à¦¬_মারà§à¦_à¦à¦ªà§à¦°_মà§_à¦à§à¦¨_à¦à§à¦²_à¦à¦_সà§à¦ªà§à¦_ঠà¦à§à¦à§_নà¦à§_ডিসà§'.split('_'), 37328 weekdays : 'রবিবার_সà§à¦®à¦¬à¦¾à¦°_মà¦à§à¦à¦²à¦¬à¦¾à¦°_বà§à¦§à¦¬à¦¾à¦°_বà§à¦¹à¦¸à§à¦ªà¦¤à¦¿à¦¬à¦¾à¦°_শà§à¦à§à¦°à¦¬à¦¾à¦°_শনিবার'.split('_'), 37329 weekdaysShort : 'রবি_সà§à¦®_মà¦à§à¦à¦²_বà§à¦§_বà§à¦¹à¦¸à§à¦ªà¦¤à¦¿_শà§à¦à§à¦°_শনি'.split('_'), 37330 weekdaysMin : 'রবি_সà§à¦®_মà¦à§à¦_বà§à¦§_বà§à¦¹à¦_শà§à¦à§à¦°_শনি'.split('_'), 37331 longDateFormat : { 37332 LT : 'A h:mm সমà§', 37333 LTS : 'A h:mm:ss সমà§', 37334 L : 'DD/MM/YYYY', 37335 LL : 'D MMMM YYYY', 37336 LLL : 'D MMMM YYYY, A h:mm সমà§', 37337 LLLL : 'dddd, D MMMM YYYY, A h:mm সমà§' 37338 }, 37339 calendar : { 37340 sameDay : '[à¦à¦] LT', 37341 nextDay : '[à¦à¦à¦¾à¦®à§à¦à¦¾à¦²] LT', 37342 nextWeek : 'dddd, LT', 37343 lastDay : '[à¦à¦¤à¦à¦¾à¦²] LT', 37344 lastWeek : '[à¦à¦¤] dddd, LT', 37345 sameElse : 'L' 37346 }, 37347 relativeTime : { 37348 future : '%s পরà§', 37349 past : '%s à¦à¦à§', 37350 s : 'à¦à§à§à¦ সà§à¦à§à¦¨à§à¦¡', 37351 ss : '%d সà§à¦à§à¦¨à§à¦¡', 37352 m : 'à¦à¦ মিনিà¦', 37353 mm : '%d মিনিà¦', 37354 h : 'à¦à¦ à¦à¦¨à§à¦à¦¾', 37355 hh : '%d à¦à¦¨à§à¦à¦¾', 37356 d : 'à¦à¦ দিন', 37357 dd : '%d দিন', 37358 M : 'à¦à¦ মাস', 37359 MM : '%d মাস', 37360 y : 'à¦à¦ বà¦à¦°', 37361 yy : '%d বà¦à¦°' 37362 }, 37363 preparse: function (string) { 37364 return string.replace(/[১২৩৪৫৬à§à§®à§¯à§¦]/g, function (match) { 37365 return numberMap[match]; 37366 }); 37367 }, 37368 postformat: function (string) { 37369 return string.replace(/\d/g, function (match) { 37370 return symbolMap[match]; 37371 }); 37372 }, 37373 meridiemParse: /রাত|সà¦à¦¾à¦²|দà§à¦ªà§à¦°|বিà¦à¦¾à¦²|রাত/, 37374 meridiemHour : function (hour, meridiem) { 37375 if (hour === 12) { 37376 hour = 0; 37377 } 37378 if ((meridiem === 'রাত' && hour >= 4) || 37379 (meridiem === 'দà§à¦ªà§à¦°' && hour < 5) || 37380 meridiem === 'বিà¦à¦¾à¦²') { 37381 return hour + 12; 37382 } else { 37383 return hour; 37384 } 37385 }, 37386 meridiem : function (hour, minute, isLower) { 37387 if (hour < 4) { 37388 return 'রাত'; 37389 } else if (hour < 10) { 37390 return 'সà¦à¦¾à¦²'; 37391 } else if (hour < 17) { 37392 return 'দà§à¦ªà§à¦°'; 37393 } else if (hour < 20) { 37394 return 'বিà¦à¦¾à¦²'; 37395 } else { 37396 return 'রাত'; 37397 } 37398 }, 37399 week : { 37400 dow : 0, // Sunday is the first day of the week. 37401 doy : 6 // The week that contains Jan 1st is the first week of the year. 37402 } 37403 }); 37404 37405 return bn; 37406 37407}))); 37408 37409 37410/***/ }), 37411/* 45 */ 37412/***/ (function(module, exports, __webpack_require__) { 37413 37414//! moment.js locale configuration 37415 37416;(function (global, factory) { 37417 true ? factory(__webpack_require__(0)) : 37418 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 37419 factory(global.moment) 37420}(this, (function (moment) { 'use strict'; 37421 37422 37423 var symbolMap = { 37424 '1': '༡', 37425 '2': '༢', 37426 '3': '༣', 37427 '4': '༤', 37428 '5': '༥', 37429 '6': '༦', 37430 '7': '༧', 37431 '8': '༨', 37432 '9': '༩', 37433 '0': '༠' 37434 }, 37435 numberMap = { 37436 '༡': '1', 37437 '༢': '2', 37438 '༣': '3', 37439 '༤': '4', 37440 '༥': '5', 37441 '༦': '6', 37442 '༧': '7', 37443 '༨': '8', 37444 '༩': '9', 37445 '༠': '0' 37446 }; 37447 37448 var bo = moment.defineLocale('bo', { 37449 months : 'à½à¾³à¼à½à¼à½à½à¼à½à½¼_à½à¾³à¼à½à¼à½à½à½²à½¦à¼à½_à½à¾³à¼à½à¼à½à½¦à½´à½à¼à½_à½à¾³à¼à½à¼à½à½à½²à¼à½_à½à¾³à¼à½à¼à½£à¾à¼à½_à½à¾³à¼à½à¼à½à¾²à½´à½à¼à½_à½à¾³à¼à½à¼à½à½à½´à½à¼à½_à½à¾³à¼à½à¼à½à½¢à¾à¾±à½à¼à½_à½à¾³à¼à½à¼à½à½à½´à¼à½_à½à¾³à¼à½à¼à½à½ ུà¼à½_à½à¾³à¼à½à¼à½à½ ུà¼à½à½ ིà½à¼à½_à½à¾³à¼à½à¼à½à½ ུà¼à½à½à½²à½¦à¼à½'.split('_'), 37450 monthsShort : 'à½à¾³à¼à½à¼à½à½à¼à½à½¼_à½à¾³à¼à½à¼à½à½à½²à½¦à¼à½_à½à¾³à¼à½à¼à½à½¦à½´à½à¼à½_à½à¾³à¼à½à¼à½à½à½²à¼à½_à½à¾³à¼à½à¼à½£à¾à¼à½_à½à¾³à¼à½à¼à½à¾²à½´à½à¼à½_à½à¾³à¼à½à¼à½à½à½´à½à¼à½_à½à¾³à¼à½à¼à½à½¢à¾à¾±à½à¼à½_à½à¾³à¼à½à¼à½à½à½´à¼à½_à½à¾³à¼à½à¼à½à½ ུà¼à½_à½à¾³à¼à½à¼à½à½ ུà¼à½à½ ིà½à¼à½_à½à¾³à¼à½à¼à½à½ ུà¼à½à½à½²à½¦à¼à½'.split('_'), 37451 weekdays : 'à½à½à½ à¼à½à½²à¼à½à¼_à½à½à½ à¼à½à¾³à¼à½à¼_à½à½à½ à¼à½à½²à½à¼à½à½à½¢à¼_à½à½à½ à¼à½£à¾·à½à¼à½à¼_à½à½à½ à¼à½à½´à½¢à¼à½à½´_à½à½à½ à¼à½à¼à½¦à½à½¦à¼_à½à½à½ à¼à½¦à¾¤à½ºà½à¼à½à¼'.split('_'), 37452 weekdaysShort : 'à½à½²à¼à½à¼_à½à¾³à¼à½à¼_à½à½²à½à¼à½à½à½¢à¼_ལྷà½à¼à½à¼_à½à½´à½¢à¼à½à½´_à½à¼à½¦à½à½¦à¼_སྤེà½à¼à½à¼'.split('_'), 37453 weekdaysMin : 'à½à½²à¼à½à¼_à½à¾³à¼à½à¼_à½à½²à½à¼à½à½à½¢à¼_ལྷà½à¼à½à¼_à½à½´à½¢à¼à½à½´_à½à¼à½¦à½à½¦à¼_སྤེà½à¼à½à¼'.split('_'), 37454 longDateFormat : { 37455 LT : 'A h:mm', 37456 LTS : 'A h:mm:ss', 37457 L : 'DD/MM/YYYY', 37458 LL : 'D MMMM YYYY', 37459 LLL : 'D MMMM YYYY, A h:mm', 37460 LLLL : 'dddd, D MMMM YYYY, A h:mm' 37461 }, 37462 calendar : { 37463 sameDay : '[à½à½²à¼à½¢à½²à½] LT', 37464 nextDay : '[སà½à¼à½à½²à½] LT', 37465 nextWeek : '[à½à½à½´à½à¼à½à¾²à½à¼à½¢à¾à½ºà½¦à¼à½], LT', 37466 lastDay : '[à½à¼à½¦à½] LT', 37467 lastWeek : '[à½à½à½´à½à¼à½à¾²à½à¼à½à½à½ à¼à½] dddd, LT', 37468 sameElse : 'L' 37469 }, 37470 relativeTime : { 37471 future : '%s ལà¼', 37472 past : '%s སà¾à½à¼à½£', 37473 s : 'ལà½à¼à½¦à½', 37474 ss : '%d སà¾à½¢à¼à½à¼', 37475 m : 'སà¾à½¢à¼à½à¼à½à½ ིà½', 37476 mm : '%d སà¾à½¢à¼à½', 37477 h : 'à½à½´à¼à½à½¼à½à¼à½à½ ིà½', 37478 hh : '%d à½à½´à¼à½à½¼à½', 37479 d : 'à½à½²à½à¼à½à½ ིà½', 37480 dd : '%d à½à½²à½à¼', 37481 M : 'à½à¾³à¼à½à¼à½à½ ིà½', 37482 MM : '%d à½à¾³à¼à½', 37483 y : 'ལོà¼à½à½ ིà½', 37484 yy : '%d ལོ' 37485 }, 37486 preparse: function (string) { 37487 return string.replace(/[༡༢༣༤༥༦༧༨༩༠]/g, function (match) { 37488 return numberMap[match]; 37489 }); 37490 }, 37491 postformat: function (string) { 37492 return string.replace(/\d/g, function (match) { 37493 return symbolMap[match]; 37494 }); 37495 }, 37496 meridiemParse: /à½à½à½à¼à½à½¼|à½à½¼à½à½¦à¼à½à½¦|à½à½²à½à¼à½à½´à½|à½à½à½¼à½à¼à½à½|à½à½à½à¼à½à½¼/, 37497 meridiemHour : function (hour, meridiem) { 37498 if (hour === 12) { 37499 hour = 0; 37500 } 37501 if ((meridiem === 'à½à½à½à¼à½à½¼' && hour >= 4) || 37502 (meridiem === 'à½à½²à½à¼à½à½´à½' && hour < 5) || 37503 meridiem === 'à½à½à½¼à½à¼à½à½') { 37504 return hour + 12; 37505 } else { 37506 return hour; 37507 } 37508 }, 37509 meridiem : function (hour, minute, isLower) { 37510 if (hour < 4) { 37511 return 'à½à½à½à¼à½à½¼'; 37512 } else if (hour < 10) { 37513 return 'à½à½¼à½à½¦à¼à½à½¦'; 37514 } else if (hour < 17) { 37515 return 'à½à½²à½à¼à½à½´à½'; 37516 } else if (hour < 20) { 37517 return 'à½à½à½¼à½à¼à½à½'; 37518 } else { 37519 return 'à½à½à½à¼à½à½¼'; 37520 } 37521 }, 37522 week : { 37523 dow : 0, // Sunday is the first day of the week. 37524 doy : 6 // The week that contains Jan 1st is the first week of the year. 37525 } 37526 }); 37527 37528 return bo; 37529 37530}))); 37531 37532 37533/***/ }), 37534/* 46 */ 37535/***/ (function(module, exports, __webpack_require__) { 37536 37537//! moment.js locale configuration 37538 37539;(function (global, factory) { 37540 true ? factory(__webpack_require__(0)) : 37541 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 37542 factory(global.moment) 37543}(this, (function (moment) { 'use strict'; 37544 37545 37546 function relativeTimeWithMutation(number, withoutSuffix, key) { 37547 var format = { 37548 'mm': 'munutenn', 37549 'MM': 'miz', 37550 'dd': 'devezh' 37551 }; 37552 return number + ' ' + mutation(format[key], number); 37553 } 37554 function specialMutationForYears(number) { 37555 switch (lastNumber(number)) { 37556 case 1: 37557 case 3: 37558 case 4: 37559 case 5: 37560 case 9: 37561 return number + ' bloaz'; 37562 default: 37563 return number + ' vloaz'; 37564 } 37565 } 37566 function lastNumber(number) { 37567 if (number > 9) { 37568 return lastNumber(number % 10); 37569 } 37570 return number; 37571 } 37572 function mutation(text, number) { 37573 if (number === 2) { 37574 return softMutation(text); 37575 } 37576 return text; 37577 } 37578 function softMutation(text) { 37579 var mutationTable = { 37580 'm': 'v', 37581 'b': 'v', 37582 'd': 'z' 37583 }; 37584 if (mutationTable[text.charAt(0)] === undefined) { 37585 return text; 37586 } 37587 return mutationTable[text.charAt(0)] + text.substring(1); 37588 } 37589 37590 var br = moment.defineLocale('br', { 37591 months : 'Genver_C\'hwevrer_Meurzh_Ebrel_Mae_Mezheven_Gouere_Eost_Gwengolo_Here_Du_Kerzu'.split('_'), 37592 monthsShort : 'Gen_C\'hwe_Meu_Ebr_Mae_Eve_Gou_Eos_Gwe_Her_Du_Ker'.split('_'), 37593 weekdays : 'Sul_Lun_Meurzh_Merc\'her_Yaou_Gwener_Sadorn'.split('_'), 37594 weekdaysShort : 'Sul_Lun_Meu_Mer_Yao_Gwe_Sad'.split('_'), 37595 weekdaysMin : 'Su_Lu_Me_Mer_Ya_Gw_Sa'.split('_'), 37596 weekdaysParseExact : true, 37597 longDateFormat : { 37598 LT : 'h[e]mm A', 37599 LTS : 'h[e]mm:ss A', 37600 L : 'DD/MM/YYYY', 37601 LL : 'D [a viz] MMMM YYYY', 37602 LLL : 'D [a viz] MMMM YYYY h[e]mm A', 37603 LLLL : 'dddd, D [a viz] MMMM YYYY h[e]mm A' 37604 }, 37605 calendar : { 37606 sameDay : '[Hiziv da] LT', 37607 nextDay : '[Warc\'hoazh da] LT', 37608 nextWeek : 'dddd [da] LT', 37609 lastDay : '[Dec\'h da] LT', 37610 lastWeek : 'dddd [paset da] LT', 37611 sameElse : 'L' 37612 }, 37613 relativeTime : { 37614 future : 'a-benn %s', 37615 past : '%s \'zo', 37616 s : 'un nebeud segondennoù', 37617 ss : '%d eilenn', 37618 m : 'ur vunutenn', 37619 mm : relativeTimeWithMutation, 37620 h : 'un eur', 37621 hh : '%d eur', 37622 d : 'un devezh', 37623 dd : relativeTimeWithMutation, 37624 M : 'ur miz', 37625 MM : relativeTimeWithMutation, 37626 y : 'ur bloaz', 37627 yy : specialMutationForYears 37628 }, 37629 dayOfMonthOrdinalParse: /\d{1,2}(añ|vet)/, 37630 ordinal : function (number) { 37631 var output = (number === 1) ? 'añ' : 'vet'; 37632 return number + output; 37633 }, 37634 week : { 37635 dow : 1, // Monday is the first day of the week. 37636 doy : 4 // The week that contains Jan 4th is the first week of the year. 37637 } 37638 }); 37639 37640 return br; 37641 37642}))); 37643 37644 37645/***/ }), 37646/* 47 */ 37647/***/ (function(module, exports, __webpack_require__) { 37648 37649//! moment.js locale configuration 37650 37651;(function (global, factory) { 37652 true ? factory(__webpack_require__(0)) : 37653 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 37654 factory(global.moment) 37655}(this, (function (moment) { 'use strict'; 37656 37657 37658 function translate(number, withoutSuffix, key) { 37659 var result = number + ' '; 37660 switch (key) { 37661 case 'ss': 37662 if (number === 1) { 37663 result += 'sekunda'; 37664 } else if (number === 2 || number === 3 || number === 4) { 37665 result += 'sekunde'; 37666 } else { 37667 result += 'sekundi'; 37668 } 37669 return result; 37670 case 'm': 37671 return withoutSuffix ? 'jedna minuta' : 'jedne minute'; 37672 case 'mm': 37673 if (number === 1) { 37674 result += 'minuta'; 37675 } else if (number === 2 || number === 3 || number === 4) { 37676 result += 'minute'; 37677 } else { 37678 result += 'minuta'; 37679 } 37680 return result; 37681 case 'h': 37682 return withoutSuffix ? 'jedan sat' : 'jednog sata'; 37683 case 'hh': 37684 if (number === 1) { 37685 result += 'sat'; 37686 } else if (number === 2 || number === 3 || number === 4) { 37687 result += 'sata'; 37688 } else { 37689 result += 'sati'; 37690 } 37691 return result; 37692 case 'dd': 37693 if (number === 1) { 37694 result += 'dan'; 37695 } else { 37696 result += 'dana'; 37697 } 37698 return result; 37699 case 'MM': 37700 if (number === 1) { 37701 result += 'mjesec'; 37702 } else if (number === 2 || number === 3 || number === 4) { 37703 result += 'mjeseca'; 37704 } else { 37705 result += 'mjeseci'; 37706 } 37707 return result; 37708 case 'yy': 37709 if (number === 1) { 37710 result += 'godina'; 37711 } else if (number === 2 || number === 3 || number === 4) { 37712 result += 'godine'; 37713 } else { 37714 result += 'godina'; 37715 } 37716 return result; 37717 } 37718 } 37719 37720 var bs = moment.defineLocale('bs', { 37721 months : 'januar_februar_mart_april_maj_juni_juli_august_septembar_oktobar_novembar_decembar'.split('_'), 37722 monthsShort : 'jan._feb._mar._apr._maj._jun._jul._aug._sep._okt._nov._dec.'.split('_'), 37723 monthsParseExact: true, 37724 weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_Äetvrtak_petak_subota'.split('_'), 37725 weekdaysShort : 'ned._pon._uto._sri._Äet._pet._sub.'.split('_'), 37726 weekdaysMin : 'ne_po_ut_sr_Äe_pe_su'.split('_'), 37727 weekdaysParseExact : true, 37728 longDateFormat : { 37729 LT : 'H:mm', 37730 LTS : 'H:mm:ss', 37731 L : 'DD.MM.YYYY', 37732 LL : 'D. MMMM YYYY', 37733 LLL : 'D. MMMM YYYY H:mm', 37734 LLLL : 'dddd, D. MMMM YYYY H:mm' 37735 }, 37736 calendar : { 37737 sameDay : '[danas u] LT', 37738 nextDay : '[sutra u] LT', 37739 nextWeek : function () { 37740 switch (this.day()) { 37741 case 0: 37742 return '[u] [nedjelju] [u] LT'; 37743 case 3: 37744 return '[u] [srijedu] [u] LT'; 37745 case 6: 37746 return '[u] [subotu] [u] LT'; 37747 case 1: 37748 case 2: 37749 case 4: 37750 case 5: 37751 return '[u] dddd [u] LT'; 37752 } 37753 }, 37754 lastDay : '[juÄer u] LT', 37755 lastWeek : function () { 37756 switch (this.day()) { 37757 case 0: 37758 case 3: 37759 return '[proÅ¡lu] dddd [u] LT'; 37760 case 6: 37761 return '[proÅ¡le] [subote] [u] LT'; 37762 case 1: 37763 case 2: 37764 case 4: 37765 case 5: 37766 return '[proÅ¡li] dddd [u] LT'; 37767 } 37768 }, 37769 sameElse : 'L' 37770 }, 37771 relativeTime : { 37772 future : 'za %s', 37773 past : 'prije %s', 37774 s : 'par sekundi', 37775 ss : translate, 37776 m : translate, 37777 mm : translate, 37778 h : translate, 37779 hh : translate, 37780 d : 'dan', 37781 dd : translate, 37782 M : 'mjesec', 37783 MM : translate, 37784 y : 'godinu', 37785 yy : translate 37786 }, 37787 dayOfMonthOrdinalParse: /\d{1,2}\./, 37788 ordinal : '%d.', 37789 week : { 37790 dow : 1, // Monday is the first day of the week. 37791 doy : 7 // The week that contains Jan 1st is the first week of the year. 37792 } 37793 }); 37794 37795 return bs; 37796 37797}))); 37798 37799 37800/***/ }), 37801/* 48 */ 37802/***/ (function(module, exports, __webpack_require__) { 37803 37804//! moment.js locale configuration 37805 37806;(function (global, factory) { 37807 true ? factory(__webpack_require__(0)) : 37808 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 37809 factory(global.moment) 37810}(this, (function (moment) { 'use strict'; 37811 37812 37813 var ca = moment.defineLocale('ca', { 37814 months : { 37815 standalone: 'gener_febrer_març_abril_maig_juny_juliol_agost_setembre_octubre_novembre_desembre'.split('_'), 37816 format: 'de gener_de febrer_de març_d\'abril_de maig_de juny_de juliol_d\'agost_de setembre_d\'octubre_de novembre_de desembre'.split('_'), 37817 isFormat: /D[oD]?(\s)+MMMM/ 37818 }, 37819 monthsShort : 'gen._febr._març_abr._maig_juny_jul._ag._set._oct._nov._des.'.split('_'), 37820 monthsParseExact : true, 37821 weekdays : 'diumenge_dilluns_dimarts_dimecres_dijous_divendres_dissabte'.split('_'), 37822 weekdaysShort : 'dg._dl._dt._dc._dj._dv._ds.'.split('_'), 37823 weekdaysMin : 'dg_dl_dt_dc_dj_dv_ds'.split('_'), 37824 weekdaysParseExact : true, 37825 longDateFormat : { 37826 LT : 'H:mm', 37827 LTS : 'H:mm:ss', 37828 L : 'DD/MM/YYYY', 37829 LL : 'D MMMM [de] YYYY', 37830 ll : 'D MMM YYYY', 37831 LLL : 'D MMMM [de] YYYY [a les] H:mm', 37832 lll : 'D MMM YYYY, H:mm', 37833 LLLL : 'dddd D MMMM [de] YYYY [a les] H:mm', 37834 llll : 'ddd D MMM YYYY, H:mm' 37835 }, 37836 calendar : { 37837 sameDay : function () { 37838 return '[avui a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT'; 37839 }, 37840 nextDay : function () { 37841 return '[demà a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT'; 37842 }, 37843 nextWeek : function () { 37844 return 'dddd [a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT'; 37845 }, 37846 lastDay : function () { 37847 return '[ahir a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT'; 37848 }, 37849 lastWeek : function () { 37850 return '[el] dddd [passat a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT'; 37851 }, 37852 sameElse : 'L' 37853 }, 37854 relativeTime : { 37855 future : 'd\'aquà %s', 37856 past : 'fa %s', 37857 s : 'uns segons', 37858 ss : '%d segons', 37859 m : 'un minut', 37860 mm : '%d minuts', 37861 h : 'una hora', 37862 hh : '%d hores', 37863 d : 'un dia', 37864 dd : '%d dies', 37865 M : 'un mes', 37866 MM : '%d mesos', 37867 y : 'un any', 37868 yy : '%d anys' 37869 }, 37870 dayOfMonthOrdinalParse: /\d{1,2}(r|n|t|è|a)/, 37871 ordinal : function (number, period) { 37872 var output = (number === 1) ? 'r' : 37873 (number === 2) ? 'n' : 37874 (number === 3) ? 'r' : 37875 (number === 4) ? 't' : 'è'; 37876 if (period === 'w' || period === 'W') { 37877 output = 'a'; 37878 } 37879 return number + output; 37880 }, 37881 week : { 37882 dow : 1, // Monday is the first day of the week. 37883 doy : 4 // The week that contains Jan 4th is the first week of the year. 37884 } 37885 }); 37886 37887 return ca; 37888 37889}))); 37890 37891 37892/***/ }), 37893/* 49 */ 37894/***/ (function(module, exports, __webpack_require__) { 37895 37896//! moment.js locale configuration 37897 37898;(function (global, factory) { 37899 true ? factory(__webpack_require__(0)) : 37900 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 37901 factory(global.moment) 37902}(this, (function (moment) { 'use strict'; 37903 37904 37905 var months = 'leden_únor_bÅezen_duben_kvÄten_Äerven_Äervenec_srpen_záÅÃ_ÅÃjen_listopad_prosinec'.
37905split('_'), 37906 monthsShort = 'led_úno_bÅe_dub_kvÄ_Ävn_Ävc_srp_záÅ_ÅÃj_lis_pro'.split('_'); 37907 function plural(n) { 37908 return (n > 1) && (n < 5) && (~~(n / 10) !== 1); 37909 } 37910 function translate(number, withoutSuffix, key, isFuture) { 37911 var result = number + ' '; 37912 switch (key) { 37913 case 's': // a few seconds / in a few seconds / a few seconds ago 37914 return (withoutSuffix || isFuture) ? 'pár sekund' : 'pár sekundami'; 37915 case 'ss': // 9 seconds / in 9 seconds / 9 seconds ago 37916 if (withoutSuffix || isFuture) { 37917 return result + (plural(number) ? 'sekundy' : 'sekund'); 37918 } else { 37919 return result + 'sekundami'; 37920 } 37921 break; 37922 case 'm': // a minute / in a minute / a minute ago 37923 return withoutSuffix ? 'minuta' : (isFuture ? 'minutu' : 'minutou'); 37924 case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago 37925 if (withoutSuffix || isFuture) { 37926 return result + (plural(number) ? 'minuty' : 'minut'); 37927 } else { 37928 return result + 'minutami'; 37929 } 37930 break; 37931 case 'h': // an hour / in an hour / an hour ago 37932 return withoutSuffix ? 'hodina' : (isFuture ? 'hodinu' : 'hodinou'); 37933 case 'hh': // 9 hours / in 9 hours / 9 hours ago 37934 if (withoutSuffix || isFuture) { 37935 return result + (plural(number) ? 'hodiny' : 'hodin'); 37936 } else { 37937 return result + 'hodinami'; 37938 } 37939 break; 37940 case 'd': // a day / in a day / a day ago 37941 return (withoutSuffix || isFuture) ? 'den' : 'dnem'; 37942 case 'dd': // 9 days / in 9 days / 9 days ago 37943 if (withoutSuffix || isFuture) { 37944 return result + (plural(number) ? 'dny' : 'dnÃ'); 37945 } else { 37946 return result + 'dny'; 37947 } 37948 break; 37949 case 'M': // a month / in a month / a month ago 37950 return (withoutSuffix || isFuture) ? 'mÄsÃc' : 'mÄsÃcem'; 37951 case 'MM': // 9 months / in 9 months / 9 months ago 37952 if (withoutSuffix || isFuture) { 37953 return result + (plural(number) ? 'mÄsÃce' : 'mÄsÃců'); 37954 } else { 37955 return result + 'mÄsÃci'; 37956 } 37957 break; 37958 case 'y': // a year / in a year / a year ago 37959 return (withoutSuffix || isFuture) ? 'rok' : 'rokem'; 37960 case 'yy': // 9 years / in 9 years / 9 years ago 37961 if (withoutSuffix || isFuture) { 37962 return result + (plural(number) ? 'roky' : 'let'); 37963 } else { 37964 return result + 'lety'; 37965 } 37966 break; 37967 } 37968 } 37969 37970 var cs = moment.defineLocale('cs', { 37971 months : months, 37972 monthsShort : monthsShort, 37973 monthsParse : (function (months, monthsShort) { 37974 var i, _monthsParse = []; 37975 for (i = 0; i < 12; i++) { 37976 // use custom parser to solve problem with July (Äervenec) 37977 _monthsParse[i] = new RegExp('^' + months[i] + '$|^' + monthsShort[i] + '$', 'i'); 37978 } 37979 return _monthsParse; 37980 }(months, monthsShort)), 37981 shortMonthsParse : (function (monthsShort) { 37982 var i, _shortMonthsParse = []; 37983 for (i = 0; i < 12; i++) { 37984 _shortMonthsParse[i] = new RegExp('^' + monthsShort[i] + '$', 'i'); 37985 } 37986 return _shortMonthsParse; 37987 }(monthsShort)), 37988 longMonthsParse : (function (months) { 37989 var i, _longMonthsParse = []; 37990 for (i = 0; i < 12; i++) { 37991 _longMonthsParse[i] = new RegExp('^' + months[i] + '$', 'i'); 37992 } 37993 return _longMonthsParse; 37994 }(months)), 37995 weekdays : 'nedÄle_pondÄlÃ_úterý_stÅeda_Ätvrtek_pátek_sobota'.split('_'), 37996 weekdaysShort : 'ne_po_út_st_Ät_pá_so'.split('_'), 37997 weekdaysMin : 'ne_po_út_st_Ät_pá_so'.split('_'), 37998 longDateFormat : { 37999 LT: 'H:mm', 38000 LTS : 'H:mm:ss', 38001 L : 'DD.MM.YYYY', 38002 LL : 'D. MMMM YYYY', 38003 LLL : 'D. MMMM YYYY H:mm', 38004 LLLL : 'dddd D. MMMM YYYY H:mm', 38005 l : 'D. M. YYYY' 38006 }, 38007 calendar : { 38008 sameDay: '[dnes v] LT', 38009 nextDay: '[zÃtra v] LT', 38010 nextWeek: function () { 38011 switch (this.day()) { 38012 case 0: 38013 return '[v nedÄli v] LT'; 38014 case 1: 38015 case 2: 38016 return '[v] dddd [v] LT'; 38017 case 3: 38018 return '[ve stÅedu v] LT'; 38019 case 4: 38020 return '[ve Ätvrtek v] LT'; 38021 case 5: 38022 return '[v pátek v] LT'; 38023 case 6: 38024 return '[v sobotu v] LT'; 38025 } 38026 }, 38027 lastDay: '[vÄera v] LT', 38028 lastWeek: function () { 38029 switch (this.day()) { 38030 case 0: 38031 return '[minulou nedÄli v] LT'; 38032 case 1: 38033 case 2: 38034 return '[minulé] dddd [v] LT'; 38035 case 3: 38036 return '[minulou stÅedu v] LT'; 38037 case 4: 38038 case 5: 38039 return '[minulý] dddd [v] LT'; 38040 case 6: 38041 return '[minulou sobotu v] LT'; 38042 } 38043 }, 38044 sameElse: 'L' 38045 }, 38046 relativeTime : { 38047 future : 'za %s', 38048 past : 'pÅed %s', 38049 s : translate, 38050 ss : translate, 38051 m : translate, 38052 mm : translate, 38053 h : translate, 38054 hh : translate, 38055 d : translate, 38056 dd : translate, 38057 M : translate, 38058 MM : translate, 38059 y : translate, 38060 yy : translate 38061 }, 38062 dayOfMonthOrdinalParse : /\d{1,2}\./, 38063 ordinal : '%d.', 38064 week : { 38065 dow : 1, // Monday is the first day of the week. 38066 doy : 4 // The week that contains Jan 4th is the first week of the year. 38067 } 38068 }); 38069 38070 return cs; 38071 38072}))); 38073 38074 38075/***/ }), 38076/* 50 */ 38077/***/ (function(module, exports, __webpack_require__) { 38078 38079//! moment.js locale configuration 38080 38081;(function (global, factory) { 38082 true ? factory(__webpack_require__(0)) : 38083 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 38084 factory(global.moment) 38085}(this, (function (moment) { 'use strict'; 38086 38087 38088 var cv = moment.defineLocale('cv', { 38089 months : 'кÓÑлаÑ_наÑÓÑ_пÑÑ_ака_май_Ò«ÓÑÑме_ÑÑÓ_Ò«ÑÑла_авÓн_Ñпа_Ñӳк_ÑаÑÑав'.split('_'), 38090 monthsShort : 'кÓÑ_наÑ_пÑÑ_ака_май_Ò«ÓÑ_ÑÑÓ_Ò«ÑÑ_авн_Ñпа_Ñӳк_ÑаÑ'.split('_'), 38091 weekdays : 'вÑÑÑаÑникÑн_ÑÑнÑикÑн_ÑÑлаÑикÑн_ÑнкÑн_кÓҫнеÑникÑн_ÑÑнекÑн_ÑÓмаÑкÑн'.split('_'), 38092 weekdaysShort : 'вÑÑ_ÑÑн_ÑÑл_Ñн_кÓÒ«_ÑÑн_ÑÓм'.split('_'), 38093 weekdaysMin : 'вÑ_Ñн_ÑÑ_Ñн_кҫ_ÑÑ_Ñм'.split('_'), 38094 longDateFormat : { 38095 LT : 'HH:mm', 38096 LTS : 'HH:mm:ss', 38097 L : 'DD-MM-YYYY', 38098 LL : 'YYYY [Ò«ÑÐ»Ñ Ð¸] MMMM [ÑйÓÑ Óн] D[-мÓÑÓ]', 38099 LLL : 'YYYY [Ò«ÑÐ»Ñ Ð¸] MMMM [ÑйÓÑ Óн] D[-мÓÑÓ], HH:mm', 38100 LLLL : 'dddd, YYYY [Ò«ÑÐ»Ñ Ð¸] MMMM [ÑйÓÑ Óн] D[-мÓÑÓ], HH:mm' 38101 }, 38102 calendar : { 38103 sameDay: '[ÐаÑн] LT [ÑÐµÑ ÐµÑÑе]', 38104 nextDay: '[ЫÑан] LT [ÑÐµÑ ÐµÑÑе]', 38105 lastDay: '[ÓнеÑ] LT [ÑÐµÑ ÐµÑÑе]', 38106 nextWeek: '[ҪиÑеÑ] dddd LT [ÑÐµÑ ÐµÑÑе]', 38107 lastWeek: '[ÐÑÑнÓ] dddd LT [ÑÐµÑ ÐµÑÑе]', 38108 sameElse: 'L' 38109 }, 38110 relativeTime : { 38111 future : function (output) {
38112 var affix = /ÑÐµÑ ÐµÑ$/i.exec(output) ? 'Ñен' : /Ò«Ñл$/i.exec(output) ? 'Ñан' : 'Ñан'; 38113 return output + affix; 38114 }, 38115 past : '%s каÑлла', 38116 s : 'пÓÑ-ик ҫеккÑнÑ', 38117 ss : '%d ҫеккÑнÑ', 38118 m : 'пÓÑ Ð¼Ð¸Ð½ÑÑ', 38119 mm : '%d минÑÑ', 38120 h : 'пÓÑ ÑÐµÑ ÐµÑ', 38121 hh : '%d ÑÐµÑ ÐµÑ', 38122 d : 'пÓÑ ÐºÑн', 38123 dd : '%d кÑн', 38124 M : 'пÓÑ ÑйÓÑ ', 38125 MM : '%d ÑйÓÑ ', 38126 y : 'пÓÑ Ò«Ñл', 38127 yy : '%d Ò«Ñл' 38128 }, 38129 dayOfMonthOrdinalParse: /\d{1,2}-мÓÑ/, 38130 ordinal : '%d-мÓÑ', 38131 week : { 38132 dow : 1, // Monday is the first day of the week. 38133 doy : 7 // The week that contains Jan 1st is the first week of the year. 38134 } 38135 }); 38136 38137 return cv; 38138 38139}))); 38140 38141 38142/***/ }), 38143/* 51 */ 38144/***/ (function(module, exports, __webpack_require__) { 38145 38146//! moment.js locale configuration 38147 38148;(function (global, factory) { 38149 true ? factory(__webpack_require__(0)) : 38150 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 38151 factory(global.moment) 38152}(this, (function (moment) { 'use strict'; 38153 38154 38155 var cy = moment.defineLocale('cy', { 38156 months: 'Ionawr_Chwefror_Mawrth_Ebrill_Mai_Mehefin_Gorffennaf_Awst_Medi_Hydref_Tachwedd_Rhagfyr'.split('_'), 38157 monthsShort: 'Ion_Chwe_Maw_Ebr_Mai_Meh_Gor_Aws_Med_Hyd_Tach_Rhag'.split('_'), 38158 weekdays: 'Dydd Sul_Dydd Llun_Dydd Mawrth_Dydd Mercher_Dydd Iau_Dydd Gwener_Dydd Sadwrn'.split('_'), 38159 weekdaysShort: 'Sul_Llun_Maw_Mer_Iau_Gwe_Sad'.split('_'), 38160 weekdaysMin: 'Su_Ll_Ma_Me_Ia_Gw_Sa'.split('_'), 38161 weekdaysParseExact : true, 38162 // time formats are the same as en-gb 38163 longDateFormat: { 38164 LT: 'HH:mm', 38165 LTS : 'HH:mm:ss', 38166 L: 'DD/MM/YYYY', 38167 LL: 'D MMMM YYYY', 38168 LLL: 'D MMMM YYYY HH:mm', 38169 LLLL: 'dddd, D MMMM YYYY HH:mm' 38170 }, 38171 calendar: { 38172 sameDay: '[Heddiw am] LT', 38173 nextDay: '[Yfory am] LT', 38174 nextWeek: 'dddd [am] LT', 38175 lastDay: '[Ddoe am] LT', 38176 lastWeek: 'dddd [diwethaf am] LT', 38177 sameElse: 'L' 38178 }, 38179 relativeTime: { 38180 future: 'mewn %s', 38181 past: '%s yn ôl', 38182 s: 'ychydig eiliadau', 38183 ss: '%d eiliad', 38184 m: 'munud', 38185 mm: '%d munud', 38186 h: 'awr', 38187 hh: '%d awr', 38188 d: 'diwrnod', 38189 dd: '%d diwrnod', 38190 M: 'mis', 38191 MM: '%d mis', 38192 y: 'blwyddyn', 38193 yy: '%d flynedd' 38194 }, 38195 dayOfMonthOrdinalParse: /\d{1,2}(fed|ain|af|il|ydd|ed|eg)/, 38196 // traditional ordinal numbers above 31 are not commonly used in colloquial Welsh 38197 ordinal: function (number) { 38198 var b = number, 38199 output = '', 38200 lookup = [
vendor: 18,044 bytes, lines 38201-38718
38201 '', 'af', 'il', 'ydd', 'ydd', 'ed', 'ed', 'ed', 'fed', 'fed', 'fed', // 1af to 10fed 38202 'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'fed' // 11eg to 20fed 38203 ]; 38204 if (b > 20) { 38205 if (b === 40 || b === 50 || b === 60 || b === 80 || b === 100) { 38206 output = 'fed'; // not 30ain, 70ain or 90ain 38207 } else { 38208 output = 'ain'; 38209 } 38210 } else if (b > 0) { 38211 output = lookup[b]; 38212 } 38213 return number + output; 38214 }, 38215 week : { 38216 dow : 1, // Monday is the first day of the week. 38217 doy : 4 // The week that contains Jan 4th is the first week of the year. 38218 } 38219 }); 38220 38221 return cy; 38222 38223}))); 38224 38225 38226/***/ }), 38227/* 52 */ 38228/***/ (function(module, exports, __webpack_require__) { 38229 38230//! moment.js locale configuration 38231 38232;(function (global, factory) { 38233 true ? factory(__webpack_require__(0)) : 38234 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 38235 factory(global.moment) 38236}(this, (function (moment) { 'use strict'; 38237 38238 38239 var da = moment.defineLocale('da', { 38240 months : 'januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december'.split('_'), 38241 monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'), 38242 weekdays : 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'), 38243 weekdaysShort : 'søn_man_tir_ons_tor_fre_lør'.split('_'), 38244 weekdaysMin : 'sø_ma_ti_on_to_fr_lø'.split('_'), 38245 longDateFormat : { 38246 LT : 'HH:mm', 38247 LTS : 'HH:mm:ss', 38248 L : 'DD.MM.YYYY', 38249 LL : 'D. MMMM YYYY', 38250 LLL : 'D. MMMM YYYY HH:mm', 38251 LLLL : 'dddd [d.] D. MMMM YYYY [kl.] HH:mm' 38252 }, 38253 calendar : { 38254 sameDay : '[i dag kl.] LT', 38255 nextDay : '[i morgen kl.] LT', 38256 nextWeek : 'pÃ¥ dddd [kl.] LT', 38257 lastDay : '[i gÃ¥r kl.] LT', 38258 lastWeek : '[i] dddd[s kl.] LT', 38259 sameElse : 'L' 38260 }, 38261 relativeTime : { 38262 future : 'om %s', 38263 past : '%s siden', 38264 s : 'fÃ¥ sekunder', 38265 ss : '%d sekunder', 38266 m : 'et minut', 38267 mm : '%d minutter', 38268 h : 'en time', 38269 hh : '%d timer', 38270 d : 'en dag', 38271 dd : '%d dage', 38272 M : 'en mÃ¥ned', 38273 MM : '%d mÃ¥neder', 38274 y : 'et Ã¥r', 38275 yy : '%d Ã¥r' 38276 }, 38277 dayOfMonthOrdinalParse: /\d{1,2}\./, 38278 ordinal : '%d.', 38279 week : { 38280 dow : 1, // Monday is the first day of the week. 38281 doy : 4 // The week that contains Jan 4th is the first week of the year. 38282 } 38283 }); 38284 38285 return da; 38286 38287}))); 38288 38289 38290/***/ }), 38291/* 53 */ 38292/***/ (function(module, exports, __webpack_require__) { 38293 38294//! moment.js locale configuration 38295 38296;(function (global, factory) { 38297 true ? factory(__webpack_require__(0)) : 38298 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 38299 factory(global.moment) 38300}(this, (function (moment) { 'use strict'; 38301 38302 38303 function processRelativeTime(number, withoutSuffix, key, isFuture) { 38304 var format = { 38305 'm': ['eine Minute', 'einer Minute'], 38306 'h': ['eine Stunde', 'einer Stunde'], 38307 'd': ['ein Tag', 'einem Tag'], 38308 'dd': [number + ' Tage', number + ' Tagen'], 38309 'M': ['ein Monat', 'einem Monat'], 38310 'MM': [number + ' Monate', number + ' Monaten'], 38311 'y': ['ein Jahr', 'einem Jahr'], 38312 'yy': [number + ' Jahre', number + ' Jahren'] 38313 }; 38314 return withoutSuffix ? format[key][0] : format[key][1]; 38315 } 38316 38317 var deAt = moment.defineLocale('de-at', { 38318 months : 'Jänner_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'), 38319 monthsShort : 'Jän._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split('_'), 38320 monthsParseExact : true, 38321 weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'), 38322 weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'), 38323 weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'), 38324 weekdaysParseExact : true, 38325 longDateFormat : { 38326 LT: 'HH:mm', 38327 LTS: 'HH:mm:ss', 38328 L : 'DD.MM.YYYY', 38329 LL : 'D. MMMM YYYY', 38330 LLL : 'D. MMMM YYYY HH:mm', 38331 LLLL : 'dddd, D. MMMM YYYY HH:mm' 38332 }, 38333 calendar : { 38334 sameDay: '[heute um] LT [Uhr]', 38335 sameElse: 'L', 38336 nextDay: '[morgen um] LT [Uhr]', 38337 nextWeek: 'dddd [um] LT [Uhr]', 38338 lastDay: '[gestern um] LT [Uhr]', 38339 lastWeek: '[letzten] dddd [um] LT [Uhr]' 38340 }, 38341 relativeTime : { 38342 future : 'in %s', 38343 past : 'vor %s', 38344 s : 'ein paar Sekunden', 38345 ss : '%d Sekunden', 38346 m : processRelativeTime, 38347 mm : '%d Minuten', 38348 h : processRelativeTime, 38349 hh : '%d Stunden', 38350 d : processRelativeTime, 38351 dd : processRelativeTime, 38352 M : processRelativeTime, 38353 MM : processRelativeTime, 38354 y : processRelativeTime, 38355 yy : processRelativeTime 38356 }, 38357 dayOfMonthOrdinalParse: /\d{1,2}\./, 38358 ordinal : '%d.', 38359 week : { 38360 dow : 1, // Monday is the first day of the week. 38361 doy : 4 // The week that contains Jan 4th is the first week of the year. 38362 } 38363 }); 38364 38365 return deAt; 38366 38367}))); 38368 38369 38370/***/ }), 38371/* 54 */ 38372/***/ (function(module, exports, __webpack_require__) { 38373 38374//! moment.js locale configuration 38375 38376;(function (global, factory) { 38377 true ? factory(__webpack_require__(0)) : 38378 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 38379 factory(global.moment) 38380}(this, (function (moment) { 'use strict'; 38381 38382 38383 function processRelativeTime(number, withoutSuffix, key, isFuture) { 38384 var format = { 38385 'm': ['eine Minute', 'einer Minute'], 38386 'h': ['eine Stunde', 'einer Stunde'], 38387 'd': ['ein Tag', 'einem Tag'], 38388 'dd': [number + ' Tage', number + ' Tagen'], 38389 'M': ['ein Monat', 'einem Monat'], 38390 'MM': [number + ' Monate', number + ' Monaten'], 38391 'y': ['ein Jahr', 'einem Jahr'], 38392 'yy': [number + ' Jahre', number + ' Jahren'] 38393 }; 38394 return withoutSuffix ? format[key][0] : format[key][1]; 38395 } 38396 38397 var deCh = moment.defineLocale('de-ch', { 38398 months : 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'), 38399 monthsShort : 'Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split('_'), 38400 monthsParseExact : true, 38401 weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'), 38402 weekdaysShort : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'), 38403 weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'), 38404 weekdaysParseExact : true, 38405 longDateFormat : { 38406 LT: 'HH:mm', 38407 LTS: 'HH:mm:ss', 38408 L : 'DD.MM.YYYY', 38409 LL : 'D. MMMM YYYY', 38410 LLL : 'D. MMMM YYYY HH:mm', 38411 LLLL : 'dddd, D. MMMM YYYY HH:mm' 38412 }, 38413 calendar : { 38414 sameDay: '[heute um] LT [Uhr]', 38415 sameElse: 'L', 38416 nextDay: '[morgen um] LT [Uhr]', 38417 nextWeek: 'dddd [um] LT [Uhr]', 38418 lastDay: '[gestern um] LT [Uhr]', 38419 lastWeek: '[letzten] dddd [um] LT [Uhr]' 38420 }, 38421 relativeTime : { 38422 future : 'in %s', 38423 past : 'vor %s', 38424 s : 'ein paar Sekunden', 38425 ss : '%d Sekunden', 38426 m : processRelativeTime, 38427 mm : '%d Minuten', 38428 h : processRelativeTime, 38429 hh : '%d Stunden', 38430 d : processRelativeTime, 38431 dd : processRelativeTime, 38432 M : processRelativeTime, 38433 MM : processRelativeTime, 38434 y : processRelativeTime, 38435 yy : processRelativeTime 38436 }, 38437 dayOfMonthOrdinalParse: /\d{1,2}\./, 38438 ordinal : '%d.', 38439 week : { 38440 dow : 1, // Monday is the first day of the week. 38441 doy : 4 // The week that contains Jan 4th is the first week of the year. 38442 } 38443 }); 38444 38445 return deCh; 38446 38447}))); 38448 38449 38450/***/ }), 38451/* 55 */ 38452/***/ (function(module, exports, __webpack_require__) { 38453 38454//! moment.js locale configuration 38455 38456;(function (global, factory) { 38457 true ? factory(__webpack_require__(0)) : 38458 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 38459 factory(global.moment) 38460}(this, (function (moment) { 'use strict'; 38461 38462 38463 function processRelativeTime(number, withoutSuffix, key, isFuture) { 38464 var format = { 38465 'm': ['eine Minute', 'einer Minute'], 38466 'h': ['eine Stunde', 'einer Stunde'], 38467 'd': ['ein Tag', 'einem Tag'], 38468 'dd': [number + ' Tage', number + ' Tagen'], 38469 'M': ['ein Monat', 'einem Monat'], 38470 'MM': [number + ' Monate', number + ' Monaten'], 38471 'y': ['ein Jahr', 'einem Jahr'], 38472 'yy': [number + ' Jahre', number + ' Jahren'] 38473 }; 38474 return withoutSuffix ? format[key][0] : format[key][1]; 38475 } 38476 38477 var de = moment.defineLocale('de', { 38478 months : 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'), 38479 monthsShort : 'Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split('_'), 38480 monthsParseExact : true, 38481 weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'), 38482 weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'), 38483 weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'), 38484 weekdaysParseExact : true, 38485 longDateFormat : { 38486 LT: 'HH:mm', 38487 LTS: 'HH:mm:ss', 38488 L : 'DD.MM.YYYY', 38489 LL : 'D. MMMM YYYY', 38490 LLL : 'D. MMMM YYYY HH:mm', 38491 LLLL : 'dddd, D. MMMM YYYY HH:mm' 38492 }, 38493 calendar : { 38494 sameDay: '[heute um] LT [Uhr]', 38495 sameElse: 'L', 38496 nextDay: '[morgen um] LT [Uhr]', 38497 nextWeek: 'dddd [um] LT [Uhr]', 38498 lastDay: '[gestern um] LT [Uhr]', 38499 lastWeek: '[letzten] dddd [um] LT [Uhr]' 38500 }, 38501 relativeTime : { 38502 future : 'in %s', 38503 past : 'vor %s', 38504 s : 'ein paar Sekunden', 38505 ss : '%d Sekunden', 38506 m : processRelativeTime, 38507 mm : '%d Minuten', 38508 h : processRelativeTime, 38509 hh : '%d Stunden', 38510 d : processRelativeTime, 38511 dd : processRelativeTime, 38512 M : processRelativeTime, 38513 MM : processRelativeTime, 38514 y : processRelativeTime, 38515 yy : processRelativeTime 38516 }, 38517 dayOfMonthOrdinalParse: /\d{1,2}\./, 38518 ordinal : '%d.', 38519 week : { 38520 dow : 1, // Monday is the first day of the week. 38521 doy : 4 // The week that contains Jan 4th is the first week of the year. 38522 } 38523 }); 38524 38525 return de; 38526 38527}))); 38528 38529 38530/***/ }), 38531/* 56 */ 38532/***/ (function(module, exports, __webpack_require__) { 38533 38534//! moment.js locale configuration 38535 38536;(function (global, factory) { 38537 true ? factory(__webpack_require__(0)) : 38538 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 38539 factory(global.moment) 38540}(this, (function (moment) { 'use strict'; 38541 38542 38543 var months = [ 38544 'ÞÞ¬ÞÞªÞÞ¦ÞÞ©', 38545 'ÞÞ¬ÞÞ°ÞÞªÞÞ¦ÞÞ©', 38546 'ÞÞ§ÞÞ¨ÞÞª', 38547 'ÞÞÞÞ°ÞÞ©ÞÞª', 38548 'ÞÞ', 38549 'ÞÞ«ÞÞ°', 38550 'ÞÞªÞÞ¦ÞÞ¨', 38551 'ÞÞ¯ÞÞ¦ÞÞ°ÞÞª', 38552 'ÞÞ¬ÞÞ°ÞÞ¬ÞÞ°ÞÞ¦ÞÞª', 38553 'ÞÞ®ÞÞ°ÞÞ¯ÞÞ¦ÞÞª', 38554 'ÞÞ®ÞÞ¬ÞÞ°ÞÞ¦ÞÞª', 38555 'ÞÞ¨ÞÞ¬ÞÞ°ÞÞ¦ÞÞª' 38556 ], weekdays = [ 38557 'ÞÞ§ÞÞ¨ÞÞ°ÞÞ¦', 38558 'ÞÞ¯ÞÞ¦', 38559 'ÞÞ¦ÞÞ°ÞÞ§ÞÞ¦', 38560 'ÞÞªÞÞ¦', 38561 'ÞÞªÞÞ§ÞÞ°ÞÞ¦ÞÞ¨', 38562 'ÞÞªÞÞªÞÞª', 38563 'ÞÞ®ÞÞ¨ÞÞ¨ÞÞª' 38564 ]; 38565 38566 var dv = moment.defineLocale('dv', { 38567 months : months, 38568 monthsShort : months, 38569 weekdays : weekdays, 38570 weekdaysShort : weekdays, 38571 weekdaysMin : 'ÞÞ§ÞÞ¨_ÞÞ¯ÞÞ¦_ÞÞ¦ÞÞ°_ÞÞªÞÞ¦_ÞÞªÞÞ§_ÞÞªÞÞª_ÞÞ®ÞÞ¨'.split('_'), 38572 longDateFormat : { 38573 38574 LT : 'HH:mm', 38575 LTS : 'HH:mm:ss', 38576 L : 'D/M/YYYY', 38577 LL : 'D MMMM YYYY', 38578 LLL : 'D MMMM YYYY HH:mm', 38579 LLLL : 'dddd D MMMM YYYY HH:mm' 38580 }, 38581 meridiemParse: /ÞÞ|ÞÞ/, 38582 isPM : function (input) { 38583 return 'ÞÞ' === input; 38584 }, 38585 meridiem : function (hour, minute, isLower) { 38586 if (hour < 12) { 38587 return 'ÞÞ'; 38588 } else { 38589 return 'ÞÞ'; 38590 } 38591 }, 38592 calendar : { 38593 sameDay : '[ÞÞ¨ÞÞ¦ÞÞª] LT', 38594 nextDay : '[ÞÞ§ÞÞ¦ÞÞ§] LT', 38595 nextWeek : 'dddd LT', 38596 lastDay : '[ÞÞ¨ÞÞ°ÞÞ¬] LT', 38597 lastWeek : '[ÞÞ§ÞÞ¨ÞÞªÞÞ¨] dddd LT', 38598 sameElse : 'L' 38599 }, 38600 relativeTime : { 38601 future : 'ÞÞ¬ÞÞÞÞ¦ÞÞ¨ %s', 38602 past : 'ÞÞªÞÞ¨ÞÞ° %s', 38603 s : 'ÞÞ¨ÞÞªÞÞ°ÞÞªÞÞ®Þ Þ¬ÞÞ°', 38604 ss : 'd% ÞÞ¨ÞÞªÞÞ°ÞÞª', 38605 m : 'ÞÞ¨ÞÞ¨ÞÞ¬ÞÞ°', 38606 mm : 'ÞÞ¨ÞÞ¨ÞÞª %d', 38607 h : 'ÞÞ¦ÞÞ¨ÞÞ¨ÞÞ¬ÞÞ°', 38608 hh : 'ÞÞ¦ÞÞ¨ÞÞ¨ÞÞª %d', 38609 d : 'ÞÞªÞÞ¦ÞÞ¬ÞÞ°', 38610 dd : 'ÞÞªÞÞ¦ÞÞ° %d', 38611 M : 'ÞÞ¦ÞÞ¬ÞÞ°', 38612 MM : 'ÞÞ¦ÞÞ° %d', 38613 y : 'ÞÞ¦ÞÞ¦ÞÞ¬ÞÞ°', 38614 yy : 'ÞÞ¦ÞÞ¦ÞÞª %d' 38615 }, 38616 preparse: function (string) { 38617 return string.replace(/Ø/g, ','); 38618 }, 38619 postformat: function (string) { 38620 return string.replace(/,/g, 'Ø'); 38621 }, 38622 week : { 38623 dow : 7, // Sunday is the first day of the week. 38624 doy : 12 // The week that contains Jan 1st is the first week of the year. 38625 } 38626 }); 38627 38628 return dv; 38629 38630}))); 38631 38632 38633/***/ }), 38634/* 57 */ 38635/***/ (function(module, exports, __webpack_require__) { 38636 38637//! moment.js locale configuration 38638 38639;(function (global, factory) { 38640 true ? factory(__webpack_require__(0)) : 38641 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 38642 factory(global.moment) 38643}(this, (function (moment) { 'use strict'; 38644 38645 function isFunction(input) { 38646 return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]'; 38647 } 38648 38649 38650 var el = moment.defineLocale('el', { 38651 monthsNominativeEl : 'ÎÎ±Î½Î¿Ï Î¬ÏιοÏ_ΦεβÏÎ¿Ï Î¬ÏιοÏ_ÎάÏÏιοÏ_ÎÏÏίλιοÏ_ÎάιοÏ_ÎοÏνιοÏ_ÎοÏλιοÏ_ÎÏÎ³Î¿Ï ÏÏοÏ_ΣεÏÏÎμβÏιοÏ_ÎκÏÏβÏιοÏ_ÎοÎμβÏιοÏ_ÎεκÎμβÏιοÏ'.split('_'), 38652 monthsGenitiveEl : 'ÎÎ±Î½Î¿Ï Î±ÏÎ¯Î¿Ï _ΦεβÏÎ¿Ï Î±ÏÎ¯Î¿Ï _ÎαÏÏÎ¯Î¿Ï _ÎÏÏÎ¹Î»Î¯Î¿Ï _ÎαÎÎ¿Ï _ÎÎ¿Ï Î½Î¯Î¿Ï _ÎÎ¿Ï Î»Î¯Î¿Ï _ÎÏ Î³Î¿ÏÏÏÎ¿Ï _ΣεÏÏεμβÏÎ¯Î¿Ï _ÎκÏÏβÏÎ¯Î¿Ï _ÎοεμβÏÎ¯Î¿Ï _ÎεκεμβÏÎ¯Î¿Ï '.split('_'), 38653 months : function (momentToFormat, format) { 38654 if (!momentToFormat) { 38655 return this._monthsNominativeEl; 38656 } else if (typeof format === 'string' && /D/.test(format.substring(0, format.indexOf('MMMM')))) { // if there is a day number before 'MMMM' 38657 return this._monthsGenitiveEl[momentToFormat.month()]; 38658 } else { 38659 return this._monthsNominativeEl[momentToFormat.month()]; 38660 } 38661 }, 38662 monthsShort : 'Îαν_Φεβ_ÎαÏ_ÎÏÏ_ÎαÏ_ÎÎ¿Ï Î½_ÎÎ¿Ï Î»_ÎÏ Î³_ΣεÏ_ÎκÏ_Îοε_Îεκ'.split('_'), 38663 weekdays : 'ÎÏ Ïιακή_ÎÎµÏ ÏÎÏα_ΤÏίÏη_ΤεÏάÏÏη_Î ÎμÏÏη_ΠαÏαÏÎºÎµÏ Î®_ΣάββαÏο'.split('_'), 38664 weekdaysShort : 'ÎÏ Ï_ÎÎµÏ _ΤÏι_ΤεÏ_Πεμ_ΠαÏ_Σαβ'.split('_'), 38665 weekdaysMin : 'ÎÏ _Îε_ΤÏ_Τε_Πε_Πα_Σα'.split('_'), 38666 meridiem : function (hours, minutes, isLower) { 38667 if (hours > 11) { 38668 return isLower ? 'μμ' : 'ÎÎ'; 38669 } else { 38670 return isLower ? 'Ïμ' : 'Î Î'; 38671 } 38672 }, 38673 isPM : function (input) { 38674 return ((input + '').toLowerCase()[0] === 'μ'); 38675 }, 38676 meridiemParse : /[Î Î]\.?Î?\.?/i, 38677 longDateFormat : { 38678 LT : 'h:mm A', 38679 LTS : 'h:mm:ss A', 38680 L : 'DD/MM/YYYY', 38681 LL : 'D MMMM YYYY', 38682 LLL : 'D MMMM YYYY h:mm A', 38683 LLLL : 'dddd, D MMMM YYYY h:mm A' 38684 }, 38685 calendarEl : { 38686 sameDay : '[ΣήμεÏα {}] LT', 38687 nextDay : '[ÎÏÏιο {}] LT', 38688 nextWeek : 'dddd [{}] LT', 38689 lastDay : '[Î§Î¸ÎµÏ {}] LT', 38690 lastWeek : function () { 38691 switch (this.day()) { 38692 case 6: 38693 return '[Ïο ÏÏοηγοÏμενο] dddd [{}] LT'; 38694 default: 38695 return '[Ïην ÏÏοηγοÏμενη] dddd [{}] LT'; 38696 } 38697 }, 38698 sameElse : 'L' 38699 }, 38700 calendar : function (key, mom) { 38701 var output = this._calendarEl[key], 38702 hours = mom && mom.hours(); 38703 if (isFunction(output)) { 38704 output = output.apply(mom); 38705 } 38706 return output.replace('{}', (hours % 12 === 1 ? 'ÏÏη' : 'ÏÏιÏ')); 38707 }, 38708 relativeTime : { 38709 future : 'Ïε %s', 38710 past : '%s ÏÏιν', 38711 s : 'λίγα Î´ÎµÏ ÏεÏÏλεÏÏα', 38712 ss : '%d Î´ÎµÏ ÏεÏÏλεÏÏα', 38713 m : 'Îνα λεÏÏÏ', 38714 mm : '%d λεÏÏά', 38715 h : 'μία ÏÏα', 38716 hh : '%d ÏÏεÏ', 38717 d : 'μία μÎÏα', 38718 dd : '%d μÎÏεÏ',
38719 M : 'ÎÎ½Î±Ï Î¼Î®Î½Î±Ï', 38720 MM : '%d μήνεÏ', 38721 y : 'ÎÎ½Î±Ï ÏÏÏνοÏ', 38722 yy : '%d ÏÏÏνια' 38723 }, 38724 dayOfMonthOrdinalParse: /\d{1,2}η/, 38725 ordinal: '%dη', 38726 week : { 38727 dow : 1, // Monday is the first day of the week. 38728 doy : 4 // The week that contains Jan 4st is the first week of the year. 38729 } 38730 }); 38731 38732 return el; 38733 38734}))); 38735 38736 38737/***/ }), 38738/* 58 */ 38739/***/ (function(module, exports, __webpack_require__) { 38740 38741//! moment.js locale configuration 38742 38743;(function (global, factory) { 38744 true ? factory(__webpack_require__(0)) : 38745 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 38746 factory(global.moment) 38747}(this, (function (moment) { 'use strict'; 38748 38749 38750 var enAu = moment.defineLocale('en-au', { 38751 months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'), 38752 monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'), 38753 weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'), 38754 weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'), 38755 weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'), 38756 longDateFormat : { 38757 LT : 'h:mm A', 38758 LTS : 'h:mm:ss A', 38759 L : 'DD/MM/YYYY', 38760 LL : 'D MMMM YYYY', 38761 LLL : 'D MMMM YYYY h:mm A', 38762 LLLL : 'dddd, D MMMM YYYY h:mm A' 38763 }, 38764 calendar : { 38765 sameDay : '[Today at] LT', 38766 nextDay : '[Tomorrow at] LT', 38767 nextWeek : 'dddd [at] LT', 38768 lastDay : '[Yesterday at] LT', 38769 lastWeek : '[Last] dddd [at] LT', 38770 sameElse : 'L' 38771 }, 38772 relativeTime : { 38773 future : 'in %s', 38774 past : '%s ago', 38775 s : 'a few seconds', 38776 ss : '%d seconds', 38777 m : 'a minute', 38778 mm : '%d minutes', 38779 h : 'an hour', 38780 hh : '%d hours', 38781 d : 'a day', 38782 dd : '%d days', 38783 M : 'a month', 38784 MM : '%d months', 38785 y : 'a year', 38786 yy : '%d years' 38787 }, 38788 dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/, 38789 ordinal : function (number) { 38790 var b = number % 10, 38791 output = (~~(number % 100 / 10) === 1) ? 'th' : 38792 (b === 1) ? 'st' : 38793 (b === 2) ? 'nd' : 38794 (b === 3) ? 'rd' : 'th'; 38795 return number + output; 38796 }, 38797 week : { 38798 dow : 1, // Monday is the first day of the week. 38799 doy : 4 // The week that contains Jan 4th is the first week of the year. 38800 } 38801 }); 38802 38803 return enAu; 38804 38805}))); 38806 38807 38808/***/ }), 38809/* 59 */ 38810/***/ (function(module, exports, __webpack_require__) { 38811 38812//! moment.js locale configuration 38813 38814;(function (global, factory) { 38815 true ? factory(__webpack_require__(0)) : 38816 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 38817 factory(global.moment) 38818}(this, (function (moment) { 'use strict'; 38819 38820 38821 var enCa = moment.defineLocale('en-ca', { 38822 months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'), 38823 monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'), 38824 weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'), 38825 weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'), 38826 weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'), 38827 longDateFormat : { 38828 LT : 'h:mm A', 38829 LTS : 'h:mm:ss A', 38830 L : 'YYYY-MM-DD', 38831 LL : 'MMMM D, YYYY', 38832 LLL : 'MMMM D, YYYY h:mm A', 38833 LLLL : 'dddd, MMMM D, YYYY h:mm A' 38834 }, 38835 calendar : { 38836 sameDay : '[Today at] LT', 38837 nextDay : '[Tomorrow at] LT', 38838 nextWeek : 'dddd [at] LT', 38839 lastDay : '[Yesterday at] LT', 38840 lastWeek : '[Last] dddd [at] LT', 38841 sameElse : 'L' 38842 }, 38843 relativeTime : { 38844 future : 'in %s', 38845 past : '%s ago', 38846 s : 'a few seconds', 38847 ss : '%d seconds', 38848 m : 'a minute', 38849 mm : '%d minutes', 38850 h : 'an hour', 38851 hh : '%d hours', 38852 d : 'a day', 38853 dd : '%d days', 38854 M : 'a month', 38855 MM : '%d months', 38856 y : 'a year', 38857 yy : '%d years' 38858 }, 38859 dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/, 38860 ordinal : function (number) { 38861 var b = number % 10, 38862 output = (~~(number % 100 / 10) === 1) ? 'th' : 38863 (b === 1) ? 'st' : 38864 (b === 2) ? 'nd' : 38865 (b === 3) ? 'rd' : 'th'; 38866 return number + output; 38867 } 38868 }); 38869 38870 return enCa; 38871 38872}))); 38873 38874 38875/***/ }), 38876/* 60 */ 38877/***/ (function(module, exports, __webpack_require__) { 38878 38879//! moment.js locale configuration 38880 38881;(function (global, factory) { 38882 true ? factory(__webpack_require__(0)) : 38883 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 38884 factory(global.moment) 38885}(this, (function (moment) { 'use strict'; 38886 38887 38888 var enGb = moment.defineLocale('en-gb', { 38889 months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'), 38890 monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'), 38891 weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'), 38892 weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'), 38893 weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'), 38894 longDateFormat : { 38895 LT : 'HH:mm', 38896 LTS : 'HH:mm:ss', 38897 L : 'DD/MM/YYYY', 38898 LL : 'D MMMM YYYY', 38899 LLL : 'D MMMM YYYY HH:mm', 38900 LLLL : 'dddd, D MMMM YYYY HH:mm' 38901 }, 38902 calendar : { 38903 sameDay : '[Today at] LT', 38904 nextDay : '[Tomorrow at] LT', 38905 nextWeek : 'dddd [at] LT', 38906 lastDay : '[Yesterday at] LT', 38907 lastWeek : '[Last] dddd [at] LT', 38908 sameElse : 'L' 38909 }, 38910 relativeTime : { 38911 future : 'in %s', 38912 past : '%s ago', 38913 s : 'a few seconds', 38914 ss : '%d seconds', 38915 m : 'a minute', 38916 mm : '%d minutes', 38917 h : 'an hour', 38918 hh : '%d hours', 38919 d : 'a day', 38920 dd : '%d days', 38921 M : 'a month', 38922 MM : '%d months', 38923 y : 'a year', 38924 yy : '%d years' 38925 }, 38926 dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/, 38927 ordinal : function (number) { 38928 var b = number % 10, 38929 output = (~~(number % 100 / 10) === 1) ? 'th' : 38930 (b === 1) ? 'st' : 38931 (b === 2) ? 'nd' : 38932 (b === 3) ? 'rd' : 'th'; 38933 return number + output; 38934 }, 38935 week : { 38936 dow : 1, // Monday is the first day of the week. 38937 doy : 4 // The week that contains Jan 4th is the first week of the year. 38938 } 38939 }); 38940 38941 return enGb;
vendor: 282,228 bytes, lines 38942-46867
38942 38943}))); 38944 38945 38946/***/ }), 38947/* 61 */ 38948/***/ (function(module, exports, __webpack_require__) { 38949 38950//! moment.js locale configuration 38951 38952;(function (global, factory) { 38953 true ? factory(__webpack_require__(0)) : 38954 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 38955 factory(global.moment) 38956}(this, (function (moment) { 'use strict'; 38957 38958 38959 var enIe = moment.defineLocale('en-ie', { 38960 months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'), 38961 monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'), 38962 weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'), 38963 weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'), 38964 weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'), 38965 longDateFormat : { 38966 LT : 'HH:mm', 38967 LTS : 'HH:mm:ss', 38968 L : 'DD-MM-YYYY', 38969 LL : 'D MMMM YYYY', 38970 LLL : 'D MMMM YYYY HH:mm', 38971 LLLL : 'dddd D MMMM YYYY HH:mm' 38972 }, 38973 calendar : { 38974 sameDay : '[Today at] LT', 38975 nextDay : '[Tomorrow at] LT', 38976 nextWeek : 'dddd [at] LT', 38977 lastDay : '[Yesterday at] LT', 38978 lastWeek : '[Last] dddd [at] LT', 38979 sameElse : 'L' 38980 }, 38981 relativeTime : { 38982 future : 'in %s', 38983 past : '%s ago', 38984 s : 'a few seconds', 38985 ss : '%d seconds', 38986 m : 'a minute', 38987 mm : '%d minutes', 38988 h : 'an hour', 38989 hh : '%d hours', 38990 d : 'a day', 38991 dd : '%d days', 38992 M : 'a month', 38993 MM : '%d months', 38994 y : 'a year', 38995 yy : '%d years' 38996 }, 38997 dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/, 38998 ordinal : function (number) { 38999 var b = number % 10, 39000 output = (~~(number % 100 / 10) === 1) ? 'th' : 39001 (b === 1) ? 'st' : 39002 (b === 2) ? 'nd' : 39003 (b === 3) ? 'rd' : 'th'; 39004 return number + output; 39005 }, 39006 week : { 39007 dow : 1, // Monday is the first day of the week. 39008 doy : 4 // The week that contains Jan 4th is the first week of the year. 39009 } 39010 }); 39011 39012 return enIe; 39013 39014}))); 39015 39016 39017/***/ }), 39018/* 62 */ 39019/***/ (function(module, exports, __webpack_require__) { 39020 39021//! moment.js locale configuration 39022 39023;(function (global, factory) { 39024 true ? factory(__webpack_require__(0)) : 39025 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 39026 factory(global.moment) 39027}(this, (function (moment) { 'use strict'; 39028 39029 39030 var enIl = moment.defineLocale('en-il', { 39031 months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'), 39032 monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'), 39033 weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'), 39034 weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'), 39035 weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'), 39036 longDateFormat : { 39037 LT : 'HH:mm', 39038 LTS : 'HH:mm:ss', 39039 L : 'DD/MM/YYYY', 39040 LL : 'D MMMM YYYY', 39041 LLL : 'D MMMM YYYY HH:mm', 39042 LLLL : 'dddd, D MMMM YYYY HH:mm' 39043 }, 39044 calendar : { 39045 sameDay : '[Today at] LT', 39046 nextDay : '[Tomorrow at] LT', 39047 nextWeek : 'dddd [at] LT', 39048 lastDay : '[Yesterday at] LT', 39049 lastWeek : '[Last] dddd [at] LT', 39050 sameElse : 'L' 39051 }, 39052 relativeTime : { 39053 future : 'in %s', 39054 past : '%s ago', 39055 s : 'a few seconds', 39056 m : 'a minute', 39057 mm : '%d minutes', 39058 h : 'an hour', 39059 hh : '%d hours', 39060 d : 'a day', 39061 dd : '%d days', 39062 M : 'a month', 39063 MM : '%d months', 39064 y : 'a year', 39065 yy : '%d years' 39066 }, 39067 dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/, 39068 ordinal : function (number) { 39069 var b = number % 10, 39070 output = (~~(number % 100 / 10) === 1) ? 'th' : 39071 (b === 1) ? 'st' : 39072 (b === 2) ? 'nd' : 39073 (b === 3) ? 'rd' : 'th'; 39074 return number + output; 39075 } 39076 }); 39077 39078 return enIl; 39079 39080}))); 39081 39082 39083/***/ }), 39084/* 63 */ 39085/***/ (function(module, exports, __webpack_require__) { 39086 39087//! moment.js locale configuration 39088 39089;(function (global, factory) { 39090 true ? factory(__webpack_require__(0)) : 39091 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 39092 factory(global.moment) 39093}(this, (function (moment) { 'use strict'; 39094 39095 39096 var enNz = moment.defineLocale('en-nz', { 39097 months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'), 39098 monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'), 39099 weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'), 39100 weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'), 39101 weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'), 39102 longDateFormat : { 39103 LT : 'h:mm A', 39104 LTS : 'h:mm:ss A', 39105 L : 'DD/MM/YYYY', 39106 LL : 'D MMMM YYYY', 39107 LLL : 'D MMMM YYYY h:mm A', 39108 LLLL : 'dddd, D MMMM YYYY h:mm A' 39109 }, 39110 calendar : { 39111 sameDay : '[Today at] LT', 39112 nextDay : '[Tomorrow at] LT', 39113 nextWeek : 'dddd [at] LT', 39114 lastDay : '[Yesterday at] LT', 39115 lastWeek : '[Last] dddd [at] LT', 39116 sameElse : 'L' 39117 }, 39118 relativeTime : { 39119 future : 'in %s', 39120 past : '%s ago', 39121 s : 'a few seconds', 39122 ss : '%d seconds', 39123 m : 'a minute', 39124 mm : '%d minutes', 39125 h : 'an hour', 39126 hh : '%d hours', 39127 d : 'a day', 39128 dd : '%d days', 39129 M : 'a month', 39130 MM : '%d months', 39131 y : 'a year', 39132 yy : '%d years' 39133 }, 39134 dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/, 39135 ordinal : function (number) { 39136 var b = number % 10, 39137 output = (~~(number % 100 / 10) === 1) ? 'th' : 39138 (b === 1) ? 'st' : 39139 (b === 2) ? 'nd' : 39140 (b === 3) ? 'rd' : 'th'; 39141 return number + output; 39142 }, 39143 week : { 39144 dow : 1, // Monday is the first day of the week. 39145 doy : 4 // The week that contains Jan 4th is the first week of the year. 39146 } 39147 }); 39148 39149 return enNz; 39150 39151}))); 39152 39153 39154/***/ }), 39155/* 64 */ 39156/***/ (function(module, exports, __webpack_require__) { 39157 39158//! moment.js locale configuration 39159 39160;(function (global, factory) { 39161 true ? factory(__webpack_require__(0)) : 39162 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 39163 factory(global.moment) 39164}(this, (function (moment) { 'use strict'; 39165 39166 39167 var eo = moment.defineLocale('eo', { 39168 months : 'januaro_februaro_marto_aprilo_majo_junio_julio_aÅgusto_septembro_oktobro_novembro_decembro'.split('_'), 39169 monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aÅg_sep_okt_nov_dec'.split('_'), 39170 weekdays : 'dimanÄo_lundo_mardo_merkredo_ĵaÅdo_vendredo_sabato'.split('_'), 39171 weekdaysShort : 'dim_lun_mard_merk_ĵaÅ_ven_sab'.split('_'), 39172 weekdaysMin : 'di_lu_ma_me_ĵa_ve_sa'.split('_'), 39173 longDateFormat : { 39174 LT : 'HH:mm', 39175 LTS : 'HH:mm:ss', 39176 L : 'YYYY-MM-DD', 39177 LL : 'D[-a de] MMMM, YYYY', 39178 LLL : 'D[-a de] MMMM, YYYY HH:mm', 39179 LLLL : 'dddd, [la] D[-a de] MMMM, YYYY HH:mm' 39180 }, 39181 meridiemParse: /[ap]\.t\.m/i, 39182 isPM: function (input) { 39183 return input.charAt(0).toLowerCase() === 'p'; 39184 }, 39185 meridiem : function (hours, minutes, isLower) { 39186 if (hours > 11) { 39187 return isLower ? 'p.t.m.' : 'P.T.M.'; 39188 } else { 39189 return isLower ? 'a.t.m.' : 'A.T.M.'; 39190 } 39191 }, 39192 calendar : { 39193 sameDay : '[HodiaÅ je] LT', 39194 nextDay : '[MorgaÅ je] LT', 39195 nextWeek : 'dddd [je] LT', 39196 lastDay : '[HieraÅ je] LT', 39197 lastWeek : '[pasinta] dddd [je] LT', 39198 sameElse : 'L' 39199 }, 39200 relativeTime : { 39201 future : 'post %s', 39202 past : 'antaÅ %s', 39203 s : 'sekundoj', 39204 ss : '%d sekundoj', 39205 m : 'minuto', 39206 mm : '%d minutoj', 39207 h : 'horo', 39208 hh : '%d horoj', 39209 d : 'tago',//ne 'diurno', Äar estas uzita por proksimumo 39210 dd : '%d tagoj', 39211 M : 'monato', 39212 MM : '%d monatoj', 39213 y : 'jaro', 39214 yy : '%d jaroj' 39215 }, 39216 dayOfMonthOrdinalParse: /\d{1,2}a/, 39217 ordinal : '%da', 39218 week : { 39219 dow : 1, // Monday is the first day of the week. 39220 doy : 7 // The week that contains Jan 1st is the first week of the year. 39221 } 39222 }); 39223 39224 return eo; 39225 39226}))); 39227 39228 39229/***/ }), 39230/* 65 */ 39231/***/ (function(module, exports, __webpack_require__) { 39232 39233//! moment.js locale configuration 39234 39235;(function (global, factory) { 39236 true ? factory(__webpack_require__(0)) : 39237 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 39238 factory(global.moment) 39239}(this, (function (moment) { 'use strict'; 39240 39241 39242 var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_'), 39243 monthsShort = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_'); 39244 39245 var monthsParse = [/^ene/i, /^feb/i, /^mar/i, /^abr/i, /^may/i, /^jun/i, /^jul/i, /^ago/i, /^sep/i, /^oct/i, /^nov/i, /^dic/i]; 39246 var monthsRegex = /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i; 39247 39248 var esDo = moment.defineLocale('es-do', { 39249 months : 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'), 39250 monthsShort : function (m, format) { 39251 if (!m) { 39252 return monthsShortDot; 39253 } else if (/-MMM-/.test(format)) { 39254 return monthsShort[m.month()]; 39255 } else { 39256 return monthsShortDot[m.month()]; 39257 } 39258 }, 39259 monthsRegex: monthsRegex, 39260 monthsShortRegex: monthsRegex, 39261 monthsStrictRegex: /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i, 39262 monthsShortStrictRegex: /^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i, 39263 monthsParse: monthsParse, 39264 longMonthsParse: monthsParse, 39265 shortMonthsParse: monthsParse, 39266 weekdays : 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'), 39267 weekdaysShort : 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'), 39268 weekdaysMin : 'do_lu_ma_mi_ju_vi_sá'.split('_'), 39269 weekdaysParseExact : true, 39270 longDateFormat : { 39271 LT : 'h:mm A', 39272 LTS : 'h:mm:ss A', 39273 L : 'DD/MM/YYYY', 39274 LL : 'D [de] MMMM [de] YYYY', 39275 LLL : 'D [de] MMMM [de] YYYY h:mm A', 39276 LLLL : 'dddd, D [de] MMMM [de] YYYY h:mm A' 39277 }, 39278 calendar : { 39279 sameDay : function () { 39280 return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT'; 39281 }, 39282 nextDay : function () { 39283 return '[mañana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT'; 39284 }, 39285 nextWeek : function () { 39286 return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT'; 39287 }, 39288 lastDay : function () { 39289 return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT'; 39290 }, 39291 lastWeek : function () { 39292 return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT'; 39293 }, 39294 sameElse : 'L' 39295 }, 39296 relativeTime : { 39297 future : 'en %s', 39298 past : 'hace %s', 39299 s : 'unos segundos', 39300 ss : '%d segundos', 39301 m : 'un minuto', 39302 mm : '%d minutos', 39303 h : 'una hora', 39304 hh : '%d horas', 39305 d : 'un dÃa', 39306 dd : '%d dÃas', 39307 M : 'un mes', 39308 MM : '%d meses', 39309 y : 'un año', 39310 yy : '%d años' 39311 }, 39312 dayOfMonthOrdinalParse : /\d{1,2}º/, 39313 ordinal : '%dº', 39314 week : { 39315 dow : 1, // Monday is the first day of the week. 39316 doy : 4 // The week that contains Jan 4th is the first week of the year. 39317 } 39318 }); 39319 39320 return esDo; 39321 39322}))); 39323 39324 39325/***/ }), 39326/* 66 */ 39327/***/ (function(module, exports, __webpack_require__) { 39328 39329//! moment.js locale configuration 39330 39331;(function (global, factory) { 39332 true ? factory(__webpack_require__(0)) : 39333 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 39334 factory(global.moment) 39335}(this, (function (moment) { 'use strict'; 39336 39337 39338 var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_'), 39339 monthsShort = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_'); 39340 39341 var esUs = moment.defineLocale('es-us', { 39342 months : 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'), 39343 monthsShort : function (m, format) { 39344 if (!m) { 39345 return monthsShortDot; 39346 } else if (/-MMM-/.test(format)) { 39347 return monthsShort[m.month()]; 39348 } else { 39349 return monthsShortDot[m.month()]; 39350 } 39351 }, 39352 monthsParseExact : true, 39353 weekdays : 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'), 39354 weekdaysShort : 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'), 39355 weekdaysMin : 'do_lu_ma_mi_ju_vi_sá'.split('_'), 39356 weekdaysParseExact : true, 39357 longDateFormat : { 39358 LT : 'h:mm A', 39359 LTS : 'h:mm:ss A', 39360 L : 'MM/DD/YYYY', 39361 LL : 'MMMM [de] D [de] YYYY', 39362 LLL : 'MMMM [de] D [de] YYYY h:mm A', 39363 LLLL : 'dddd, MMMM [de] D [de] YYYY h:mm A' 39364 }, 39365 calendar : { 39366 sameDay : function () { 39367 return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT'; 39368 }, 39369 nextDay : function () { 39370 return '[mañana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT'; 39371 }, 39372 nextWeek : function () { 39373 return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT'; 39374 }, 39375 lastDay : function () { 39376 return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT'; 39377 }, 39378 lastWeek : function () { 39379 return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT'; 39380 }, 39381 sameElse : 'L' 39382 }, 39383 relativeTime : { 39384 future : 'en %s', 39385 past : 'hace %s', 39386 s : 'unos segundos', 39387 ss : '%d segundos', 39388 m : 'un minuto', 39389 mm : '%d minutos', 39390 h : 'una hora', 39391 hh : '%d horas', 39392 d : 'un dÃa', 39393 dd : '%d dÃas', 39394 M : 'un mes', 39395 MM : '%d meses', 39396 y : 'un año', 39397 yy : '%d años' 39398 }, 39399 dayOfMonthOrdinalParse : /\d{1,2}º/, 39400 ordinal : '%dº', 39401 week : { 39402 dow : 0, // Sunday is the first day of the week. 39403 doy : 6 // The week that contains Jan 1st is the first week of the year. 39404 } 39405 }); 39406 39407 return esUs; 39408 39409}))); 39410 39411 39412/***/ }), 39413/* 67 */ 39414/***/ (function(module, exports, __webpack_require__) { 39415 39416//! moment.js locale configuration 39417 39418;(function (global, factory) { 39419 true ? factory(__webpack_require__(0)) : 39420 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 39421 factory(global.moment) 39422}(this, (function (moment) { 'use strict'; 39423 39424 39425 var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_'), 39426 monthsShort = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_'); 39427 39428 var monthsParse = [/^ene/i, /^feb/i, /^mar/i, /^abr/i, /^may/i, /^jun/i, /^jul/i, /^ago/i, /^sep/i, /^oct/i, /^nov/i, /^dic/i]; 39429 var monthsRegex = /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i; 39430 39431 var es = moment.defineLocale('es', { 39432 months : 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'), 39433 monthsShort : function (m, format) { 39434 if (!m) { 39435 return monthsShortDot; 39436 } else if (/-MMM-/.test(format)) { 39437 return monthsShort[m.month()]; 39438 } else { 39439 return monthsShortDot[m.month()]; 39440 } 39441 }, 39442 monthsRegex : monthsRegex, 39443 monthsShortRegex : monthsRegex, 39444 monthsStrictRegex : /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i, 39445 monthsShortStrictRegex : /^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i, 39446 monthsParse : monthsParse, 39447 longMonthsParse : monthsParse, 39448 shortMonthsParse : monthsParse, 39449 weekdays : 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'), 39450 weekdaysShort : 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'), 39451 weekdaysMin : 'do_lu_ma_mi_ju_vi_sá'.split('_'), 39452 weekdaysParseExact : true, 39453 longDateFormat : { 39454 LT : 'H:mm', 39455 LTS : 'H:mm:ss', 39456 L : 'DD/MM/YYYY', 39457 LL : 'D [de] MMMM [de] YYYY', 39458 LLL : 'D [de] MMMM [de] YYYY H:mm', 39459 LLLL : 'dddd, D [de] MMMM [de] YYYY H:mm' 39460 }, 39461 calendar : { 39462 sameDay : function () { 39463 return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT'; 39464 }, 39465 nextDay : function () { 39466 return '[mañana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT'; 39467 }, 39468 nextWeek : function () { 39469 return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT'; 39470 }, 39471 lastDay : function () { 39472 return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT'; 39473 }, 39474 lastWeek : function () { 39475 return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT'; 39476 }, 39477 sameElse : 'L' 39478 }, 39479 relativeTime : { 39480 future : 'en %s', 39481 past : 'hace %s', 39482 s : 'unos segundos', 39483 ss : '%d segundos', 39484 m : 'un minuto', 39485 mm : '%d minutos', 39486 h : 'una hora', 39487 hh : '%d horas', 39488 d : 'un dÃa', 39489 dd : '%d dÃas', 39490 M : 'un mes', 39491 MM : '%d meses', 39492 y : 'un año', 39493 yy : '%d años' 39494 }, 39495 dayOfMonthOrdinalParse : /\d{1,2}º/, 39496 ordinal : '%dº', 39497 week : { 39498 dow : 1, // Monday is the first day of the week. 39499 doy : 4 // The week that contains Jan 4th is the first week of the year. 39500 } 39501 }); 39502 39503 return es; 39504 39505}))); 39506 39507 39508/***/ }), 39509/* 68 */ 39510/***/ (function(module, exports, __webpack_require__) { 39511 39512//! moment.js locale configuration 39513 39514;(function (global, factory) { 39515 true ? factory(__webpack_require__(0)) : 39516 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 39517 factory(global.moment) 39518}(this, (function (moment) { 'use strict'; 39519 39520 39521 function processRelativeTime(number, withoutSuffix, key, isFuture) { 39522 var format = { 39523 's' : ['mõne sekundi', 'mõni sekund', 'paar sekundit'], 39524 'ss': [number + 'sekundi', number + 'sekundit'], 39525 'm' : ['ühe minuti', 'üks minut'], 39526 'mm': [number + ' minuti', number + ' minutit'], 39527 'h' : ['ühe tunni', 'tund aega', 'üks tund'], 39528 'hh': [number + ' tunni', number + ' tundi'], 39529 'd' : ['ühe päeva', 'üks päev'], 39530 'M' : ['kuu aja', 'kuu aega', 'üks kuu'], 39531 'MM': [number + ' kuu', number + ' kuud'], 39532 'y' : ['ühe aasta', 'aasta', 'üks aasta'], 39533 'yy': [number + ' aasta', number + ' aastat'] 39534 }; 39535 if (withoutSuffix) { 39536 return format[key][2] ? format[key][2] : format[key][1]; 39537 } 39538 return isFuture ? format[key][0] : format[key][1]; 39539 } 39540 39541 var et = moment.defineLocale('et', { 39542 months : 'jaanuar_veebruar_märts_aprill_mai_juuni_juuli_august_september_oktoober_november_detsember'.split('_'), 39543 monthsShort : 'jaan_veebr_märts_apr_mai_juuni_juuli_aug_sept_okt_nov_dets'.split('_'), 39544 weekdays : 'pühapäev_esmaspäev_teisipäev_kolmapäev_neljapäev_reede_laupäev'.split('_'), 39545 weekdaysShort : 'P_E_T_K_N_R_L'.split('_'), 39546 weekdaysMin : 'P_E_T_K_N_R_L'.split('_'), 39547 longDateFormat : { 39548 LT : 'H:mm', 39549 LTS : 'H:mm:ss', 39550 L : 'DD.MM.YYYY', 39551 LL : 'D. MMMM YYYY', 39552 LLL : 'D. MMMM YYYY H:mm', 39553 LLLL : 'dddd, D. MMMM YYYY H:mm' 39554 }, 39555 calendar : { 39556 sameDay : '[Täna,] LT', 39557 nextDay : '[Homme,] LT', 39558 nextWeek : '[Järgmine] dddd LT', 39559 lastDay : '[Eile,] LT', 39560 lastWeek : '[Eelmine] dddd LT', 39561 sameElse : 'L' 39562 }, 39563 relativeTime : { 39564 future : '%s pärast', 39565 past : '%s tagasi', 39566 s : processRelativeTime, 39567 ss : processRelativeTime, 39568 m : processRelativeTime, 39569 mm : processRelativeTime, 39570 h : processRelativeTime, 39571 hh : processRelativeTime, 39572 d : processRelativeTime, 39573 dd : '%d päeva', 39574 M : processRelativeTime, 39575 MM : processRelativeTime, 39576 y : processRelativeTime, 39577 yy : processRelativeTime 39578 }, 39579 dayOfMonthOrdinalParse: /\d{1,2}\./, 39580 ordinal : '%d.', 39581 week : { 39582 dow : 1, // Monday is the first day of the week. 39583 doy : 4 // The week that contains Jan 4th is the first week of the year. 39584 } 39585 }); 39586 39587 return et; 39588 39589}))); 39590 39591 39592/***/ }), 39593/* 69 */ 39594/***/ (function(module, exports, __webpack_require__) { 39595 39596//! moment.js locale configuration 39597 39598;(function (global, factory) { 39599 true ? factory(__webpack_require__(0)) : 39600 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 39601 factory(global.moment) 39602}(this, (function (moment) { 'use strict'; 39603 39604 39605 var eu = moment.defineLocale('eu', { 39606 months : 'urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua'.split('_'), 39607 monthsShort : 'urt._ots._mar._api._mai._eka._uzt._abu._ira._urr._aza._abe.'.split('_'), 39608 monthsParseExact : true, 39609 weekdays : 'igandea_astelehena_asteartea_asteazkena_osteguna_ostirala_larunbata'.split('_'), 39610 weekdaysShort : 'ig._al._ar._az._og._ol._lr.'.split('_'), 39611 weekdaysMin : 'ig_al_ar_az_og_ol_lr'.split('_'), 39612 weekdaysParseExact : true, 39613 longDateFormat : { 39614 LT : 'HH:mm', 39615 LTS : 'HH:mm:ss', 39616 L : 'YYYY-MM-DD', 39617 LL : 'YYYY[ko] MMMM[ren] D[a]', 39618 LLL : 'YYYY[ko] MMMM[ren] D[a] HH:mm', 39619 LLLL : 'dddd, YYYY[ko] MMMM[ren] D[a] HH:mm', 39620 l : 'YYYY-M-D', 39621 ll : 'YYYY[ko] MMM D[a]', 39622 lll : 'YYYY[ko] MMM D[a] HH:mm', 39623 llll : 'ddd, YYYY[ko] MMM D[a] HH:mm' 39624 }, 39625 calendar : { 39626 sameDay : '[gaur] LT[etan]', 39627 nextDay : '[bihar] LT[etan]', 39628 nextWeek : 'dddd LT[etan]', 39629 lastDay : '[atzo] LT[etan]', 39630 lastWeek : '[aurreko] dddd LT[etan]', 39631 sameElse : 'L' 39632 }, 39633 relativeTime : { 39634 future : '%s barru', 39635 past : 'duela %s', 39636 s : 'segundo batzuk', 39637 ss : '%d segundo', 39638 m : 'minutu bat', 39639 mm : '%d minutu', 39640 h : 'ordu bat', 39641 hh : '%d ordu', 39642 d : 'egun bat', 39643 dd : '%d egun', 39644 M : 'hilabete bat', 39645 MM : '%d hilabete', 39646 y : 'urte bat', 39647 yy : '%d urte' 39648 }, 39649 dayOfMonthOrdinalParse: /\d{1,2}\./, 39650 ordinal : '%d.', 39651 week : { 39652 dow : 1, // Monday is the first day of the week. 39653 doy : 7 // The week that contains Jan 1st is the first week of the year. 39654 } 39655 }); 39656 39657 return eu; 39658 39659}))); 39660 39661 39662/***/ }), 39663/* 70 */ 39664/***/ (function(module, exports, __webpack_require__) { 39665 39666//! moment.js locale configuration 39667 39668;(function (global, factory) { 39669 true ? factory(__webpack_require__(0)) : 39670 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 39671 factory(global.moment) 39672}(this, (function (moment) { 'use strict'; 39673 39674 39675 var symbolMap = { 39676 '1': 'Û±', 39677 '2': 'Û²', 39678 '3': 'Û³', 39679 '4': 'Û´', 39680 '5': 'Ûµ', 39681 '6': 'Û¶', 39682 '7': 'Û·', 39683 '8': 'Û¸', 39684 '9': 'Û¹', 39685 '0': 'Û°' 39686 }, numberMap = { 39687 'Û±': '1', 39688 'Û²': '2', 39689 'Û³': '3', 39690 'Û´': '4', 39691 'Ûµ': '5', 39692 'Û¶': '6', 39693 'Û·': '7', 39694 'Û¸': '8', 39695 'Û¹': '9', 39696 'Û°': '0' 39697 }; 39698 39699 var fa = moment.defineLocale('fa', { 39700 months : 'ÚاÙÙÛÙ_ÙÙرÛÙ_٠ارس_Ø¢ÙرÛÙ_Ù Ù_ÚÙئÙ_ÚÙئÛÙ_اÙت_سپتا٠بر_اکتبر_ÙÙا٠بر_دسا٠بر'.split('_'), 39701 monthsShort : 'ÚاÙÙÛÙ_ÙÙرÛÙ_٠ارس_Ø¢ÙرÛÙ_Ù Ù_ÚÙئÙ_ÚÙئÛÙ_اÙت_سپتا٠بر_اکتبر_ÙÙا٠بر_دسا٠بر'.split('_'), 39702 weekdays : 'ÛÚ©\u200cØ´ÙبÙ_دÙØ´ÙبÙ_سÙ\u200cØ´ÙبÙ_ÚÙارشÙبÙ_Ù¾Ùج\u200cØ´ÙبÙ_ج٠عÙ_Ø´ÙبÙ'.split('_'), 39703 weekdaysShort : 'ÛÚ©\u200cØ´ÙبÙ_دÙØ´ÙبÙ_سÙ\u200cØ´ÙبÙ_ÚÙارشÙبÙ_Ù¾Ùج\u200cØ´ÙبÙ_ج٠عÙ_Ø´ÙبÙ'.split('_'), 39704 weekdaysMin : 'Û_د_س_Ú_Ù¾_ج_Ø´'.split('_'), 39705 weekdaysParseExact : true, 39706 longDateFormat : { 39707 LT : 'HH:mm', 39708 LTS : 'HH:mm:ss', 39709 L : 'DD/MM/YYYY', 39710 LL : 'D MMMM YYYY', 39711 LLL : 'D MMMM YYYY HH:mm', 39712 LLLL : 'dddd, D MMMM YYYY HH:mm' 39713 }, 39714 meridiemParse: /Ùب٠از ظÙر|بعد از ظÙر/, 39715 isPM: function (input) { 39716 return /بعد از ظÙر/.test(input); 39717 }, 39718 meridiem : function (hour, minute, isLower) { 39719 if (hour < 12) { 39720 return 'Ùب٠از ظÙر'; 39721 } else { 39722 return 'بعد از ظÙر'; 39723 } 39724 }, 39725 calendar : { 39726 sameDay : '[ا٠رÙز ساعت] LT', 39727 nextDay : '[Ùردا ساعت] LT', 39728 nextWeek : 'dddd [ساعت] LT', 39729 lastDay : '[دÛرÙز ساعت] LT', 39730 lastWeek : 'dddd [Ù¾ÛØ´] [ساعت] LT', 39731 sameElse : 'L' 39732 }, 39733 relativeTime : { 39734 future : 'در %s', 39735 past : '%s Ù¾ÛØ´', 39736 s : 'ÚÙد ثاÙÛÙ', 39737 ss : 'ثاÙÛÙ d%', 39738 m : 'ÛÚ© دÙÛÙÙ', 39739 mm : '%d دÙÛÙÙ', 39740 h : 'ÛÚ© ساعت', 39741 hh : '%d ساعت', 39742 d : 'ÛÚ© رÙز', 39743 dd : '%d رÙز', 39744 M : 'ÛÚ© ٠اÙ', 39745 MM : '%d ٠اÙ', 39746 y : 'ÛÚ© ساÙ', 39747 yy : '%d ساÙ' 39748 }, 39749 preparse: function (string) { 39750 return string.replace(/[Û°-Û¹]/g, function (match) { 39751 return numberMap[match]; 39752 }).replace(/Ø/g, ','); 39753 }, 39754 postformat: function (string) { 39755 return string.replace(/\d/g, function (match) { 39756 return symbolMap[match]; 39757 }).replace(/,/g, 'Ø'); 39758 }, 39759 dayOfMonthOrdinalParse: /\d{1,2}Ù /, 39760 ordinal : '%dÙ ', 39761 week : { 39762 dow : 6, // Saturday is the first day of the week. 39763 doy : 12 // The week that contains Jan 1st is the first week of the year. 39764 } 39765 }); 39766 39767 return fa; 39768 39769}))); 39770 39771 39772/***/ }), 39773/* 71 */ 39774/***/ (function(module, exports, __webpack_require__) { 39775 39776//! moment.js locale configuration 39777 39778;(function (global, factory) { 39779 true ? factory(__webpack_require__(0)) : 39780 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 39781 factory(global.moment) 39782}(this, (function (moment) { 'use strict'; 39783 39784 39785 var numbersPast = 'nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän'.split(' '), 39786 numbersFuture = [ 39787 'nolla', 'yhden', 'kahden', 'kolmen', 'neljän', 'viiden', 'kuuden', 39788 numbersPast[7], numbersPast[8], numbersPast[9] 39789 ]; 39790 function translate(number, withoutSuffix, key, isFuture) { 39791 var result = ''; 39792 switch (key) { 39793 case 's': 39794 return isFuture ? 'muutaman sekunnin' : 'muutama sekunti'; 39795 case 'ss': 39796 return isFuture ? 'sekunnin' : 'sekuntia'; 39797 case 'm': 39798 return isFuture ? 'minuutin' : 'minuutti'; 39799 case 'mm': 39800 result = isFuture ? 'minuutin' : 'minuuttia'; 39801 break; 39802 case 'h': 39803 return isFuture ? 'tunnin' : 'tunti'; 39804 case 'hh': 39805 result = isFuture ? 'tunnin' : 'tuntia'; 39806 break; 39807 case 'd': 39808 return isFuture ? 'päivän' : 'päivä'; 39809 case 'dd': 39810 result = isFuture ? 'päivän' : 'päivää'; 39811 break; 39812 case 'M': 39813 return isFuture ? 'kuukauden' : 'kuukausi'; 39814 case 'MM': 39815 result = isFuture ? 'kuukauden' : 'kuukautta'; 39816 break; 39817 case 'y': 39818 return isFuture ? 'vuoden' : 'vuosi'; 39819 case 'yy': 39820 result = isFuture ? 'vuoden' : 'vuotta'; 39821 break; 39822 } 39823 result = verbalNumber(number, isFuture) + ' ' + result; 39824 return result; 39825 } 39826 function verbalNumber(number, isFuture) { 39827 return number < 10 ? (isFuture ? numbersFuture[number] : numbersPast[number]) : number; 39828 } 39829 39830 var fi = moment.defineLocale('fi', { 39831 months : 'tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesäkuu_heinäkuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu'.split('_'), 39832 monthsShort : 'tammi_helmi_maalis_huhti_touko_kesä_heinä_elo_syys_loka_marras_joulu'.split('_'), 39833 weekdays : 'sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai'.split('_'), 39834 weekdaysShort : 'su_ma_ti_ke_to_pe_la'.split('_'), 39835 weekdaysMin : 'su_ma_ti_ke_to_pe_la'.split('_'), 39836 longDateFormat : { 39837 LT : 'HH.mm', 39838 LTS : 'HH.mm.ss', 39839 L : 'DD.MM.YYYY', 39840 LL : 'Do MMMM[ta] YYYY', 39841 LLL : 'Do MMMM[ta] YYYY, [klo] HH.mm', 39842 LLLL : 'dddd, Do MMMM[ta] YYYY, [klo] HH.mm', 39843 l : 'D.M.YYYY', 39844 ll : 'Do MMM YYYY', 39845 lll : 'Do MMM YYYY, [klo] HH.mm', 39846 llll : 'ddd, Do MMM YYYY, [klo] HH.mm' 39847 }, 39848 calendar : { 39849 sameDay : '[tänään] [klo] LT', 39850 nextDay : '[huomenna] [klo] LT', 39851 nextWeek : 'dddd [klo] LT', 39852 lastDay : '[eilen] [klo] LT', 39853 lastWeek : '[viime] dddd[na] [klo] LT', 39854 sameElse : 'L' 39855 }, 39856 relativeTime : { 39857 future : '%s päästä', 39858 past : '%s sitten', 39859 s : translate, 39860 ss : translate, 39861 m : translate, 39862 mm : translate, 39863 h : translate, 39864 hh : translate, 39865 d : translate, 39866 dd : translate, 39867 M : translate, 39868 MM : translate, 39869 y : translate, 39870 yy : translate 39871 }, 39872 dayOfMonthOrdinalParse: /\d{1,2}\./, 39873 ordinal : '%d.', 39874 week : { 39875 dow : 1, // Monday is the first day of the week. 39876 doy : 4 // The week that contains Jan 4th is the first week of the year. 39877 } 39878 }); 39879 39880 return fi; 39881 39882}))); 39883 39884 39885/***/ }), 39886/* 72 */ 39887/***/ (function(module, exports, __webpack_require__) { 39888 39889//! moment.js locale configuration 39890 39891;(function (global, factory) { 39892 true ? factory(__webpack_require__(0)) : 39893 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 39894 factory(global.moment) 39895}(this, (function (moment) { 'use strict'; 39896 39897 39898 var fo = moment.defineLocale('fo', { 39899 months : 'januar_februar_mars_aprÃl_mai_juni_juli_august_september_oktober_november_desember'.split('_'), 39900 monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'), 39901 weekdays : 'sunnudagur_mánadagur_týsdagur_mikudagur_hósdagur_frÃggjadagur_leygardagur'.split('_'), 39902 weekdaysShort : 'sun_mán_týs_mik_hós_frÃ_ley'.split('_'), 39903 weekdaysMin : 'su_má_tý_mi_hó_fr_le'.split('_'), 39904 longDateFormat : { 39905 LT : 'HH:mm', 39906 LTS : 'HH:mm:ss', 39907 L : 'DD/MM/YYYY', 39908 LL : 'D MMMM YYYY', 39909 LLL : 'D MMMM YYYY HH:mm', 39910 LLLL : 'dddd D. MMMM, YYYY HH:mm' 39911 }, 39912 calendar : { 39913 sameDay : '[à dag kl.] LT', 39914 nextDay : '[à morgin kl.] LT', 39915 nextWeek : 'dddd [kl.] LT', 39916 lastDay : '[à gjár kl.] LT', 39917 lastWeek : '[sÃðstu] dddd [kl] LT', 39918 sameElse : 'L' 39919 }, 39920 relativeTime : { 39921 future : 'um %s', 39922 past : '%s sÃðani', 39923 s : 'fá sekund', 39924 ss : '%d sekundir', 39925 m : 'ein minutt', 39926 mm : '%d minuttir', 39927 h : 'ein tÃmi', 39928 hh : '%d tÃmar', 39929 d : 'ein dagur', 39930 dd : '%d dagar', 39931 M : 'ein mánaði', 39932 MM : '%d mánaðir', 39933 y : 'eitt ár', 39934 yy : '%d ár' 39935 }, 39936 dayOfMonthOrdinalParse: /\d{1,2}\./, 39937 ordinal : '%d.', 39938 week : { 39939 dow : 1, // Monday is the first day of the week. 39940 doy : 4 // The week that contains Jan 4th is the first week of the year. 39941 } 39942 }); 39943 39944 return fo; 39945 39946}))); 39947 39948 39949/***/ }), 39950/* 73 */ 39951/***/ (function(module, exports, __webpack_require__) { 39952 39953//! moment.js locale configuration 39954 39955;(function (global, factory) { 39956 true ? factory(__webpack_require__(0)) : 39957 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 39958 factory(global.moment) 39959}(this, (function (moment) { 'use strict'; 39960 39961 39962 var frCa = moment.defineLocale('fr-ca', { 39963 months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'), 39964 monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'), 39965 monthsParseExact : true, 39966 weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'), 39967 weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'), 39968 weekdaysMin : 'di_lu_ma_me_je_ve_sa'.split('_'), 39969 weekdaysParseExact : true, 39970 longDateFormat : { 39971 LT : 'HH:mm', 39972 LTS : 'HH:mm:ss', 39973 L : 'YYYY-MM-DD', 39974 LL : 'D MMMM YYYY', 39975 LLL : 'D MMMM YYYY HH:mm', 39976 LLLL : 'dddd D MMMM YYYY HH:mm' 39977 }, 39978 calendar : { 39979 sameDay : '[Aujourdâhui à ] LT', 39980 nextDay : '[Demain à ] LT', 39981 nextWeek : 'dddd [à ] LT', 39982 lastDay : '[Hier à ] LT', 39983 lastWeek : 'dddd [dernier à ] LT', 39984 sameElse : 'L' 39985 }, 39986 relativeTime : { 39987 future : 'dans %s', 39988 past : 'il y a %s', 39989 s : 'quelques secondes', 39990 ss : '%d secondes', 39991 m : 'une minute', 39992 mm : '%d minutes', 39993 h : 'une heure', 39994 hh : '%d heures', 39995 d : 'un jour', 39996 dd : '%d jours', 39997 M : 'un mois', 39998 MM : '%d mois', 39999 y : 'un an', 40000 yy : '%d ans' 40001 }, 40002 dayOfMonthOrdinalParse: /\d{1,2}(er|e)/, 40003 ordinal : function (number, period) { 40004 switch (period) { 40005 // Words with masculine grammatical gender: mois, trimestre, jour 40006 default: 40007 case 'M': 40008 case 'Q': 40009 case 'D': 40010 case 'DDD': 40011 case 'd': 40012 return number + (number === 1 ? 'er' : 'e'); 40013 40014 // Words with feminine grammatical gender: semaine 40015 case 'w': 40016 case 'W': 40017 return number + (number === 1 ? 're' : 'e'); 40018 } 40019 } 40020 }); 40021 40022 return frCa; 40023 40024}))); 40025 40026 40027/***/ }), 40028/* 74 */ 40029/***/ (function(module, exports, __webpack_require__) { 40030 40031//! moment.js locale configuration 40032 40033;(function (global, factory) { 40034 true ? factory(__webpack_require__(0)) : 40035 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 40036 factory(global.moment) 40037}(this, (function (moment) { 'use strict'; 40038 40039 40040 var frCh = moment.defineLocale('fr-ch', { 40041 months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'), 40042 monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'), 40043 monthsParseExact : true, 40044 weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'), 40045 weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'), 40046 weekdaysMin : 'di_lu_ma_me_je_ve_sa'.split('_'), 40047 weekdaysParseExact : true, 40048 longDateFormat : { 40049 LT : 'HH:mm', 40050 LTS : 'HH:mm:ss', 40051 L : 'DD.MM.YYYY', 40052 LL : 'D MMMM YYYY', 40053 LLL : 'D MMMM YYYY HH:mm', 40054 LLLL : 'dddd D MMMM YYYY HH:mm' 40055 }, 40056 calendar : { 40057 sameDay : '[Aujourdâhui à ] LT', 40058 nextDay : '[Demain à ] LT', 40059 nextWeek : 'dddd [à ] LT', 40060 lastDay : '[Hier à ] LT', 40061 lastWeek : 'dddd [dernier à ] LT', 40062 sameElse : 'L' 40063 }, 40064 relativeTime : { 40065 future : 'dans %s', 40066 past : 'il y a %s', 40067 s : 'quelques secondes', 40068 ss : '%d secondes', 40069 m : 'une minute', 40070 mm : '%d minutes', 40071 h : 'une heure', 40072 hh : '%d heures', 40073 d : 'un jour', 40074 dd : '%d jours', 40075 M : 'un mois', 40076 MM : '%d mois', 40077 y : 'un an', 40078 yy : '%d ans' 40079 }, 40080 dayOfMonthOrdinalParse: /\d{1,2}(er|e)/, 40081 ordinal : function (number, period) { 40082 switch (period) { 40083 // Words with masculine grammatical gender: mois, trimestre, jour 40084 default: 40085 case 'M': 40086 case 'Q': 40087 case 'D': 40088 case 'DDD': 40089 case 'd': 40090 return number + (number === 1 ? 'er' : 'e'); 40091 40092 // Words with feminine grammatical gender: semaine 40093 case 'w': 40094 case 'W': 40095 return number + (number === 1 ? 're' : 'e'); 40096 } 40097 }, 40098 week : { 40099 dow : 1, // Monday is the first day of the week. 40100 doy : 4 // The week that contains Jan 4th is the first week of the year. 40101 } 40102 }); 40103 40104 return frCh; 40105 40106}))); 40107 40108 40109/***/ }), 40110/* 75 */ 40111/***/ (function(module, exports, __webpack_require__) { 40112 40113//! moment.js locale configuration 40114 40115;(function (global, factory) { 40116 true ? factory(__webpack_require__(0)) : 40117 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 40118 factory(global.moment) 40119}(this, (function (moment) { 'use strict'; 40120 40121 40122 var fr = moment.defineLocale('fr', { 40123 months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'), 40124 monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'), 40125 monthsParseExact : true, 40126 weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'), 40127 weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'), 40128 weekdaysMin : 'di_lu_ma_me_je_ve_sa'.split('_'), 40129 weekdaysParseExact : true, 40130 longDateFormat : { 40131 LT : 'HH:mm', 40132 LTS : 'HH:mm:ss', 40133 L : 'DD/MM/YYYY', 40134 LL : 'D MMMM YYYY', 40135 LLL : 'D MMMM YYYY HH:mm', 40136 LLLL : 'dddd D MMMM YYYY HH:mm' 40137 }, 40138 calendar : { 40139 sameDay : '[Aujourdâhui à ] LT', 40140 nextDay : '[Demain à ] LT', 40141 nextWeek : 'dddd [à ] LT', 40142 lastDay : '[Hier à ] LT', 40143 lastWeek : 'dddd [dernier à ] LT', 40144 sameElse : 'L' 40145 }, 40146 relativeTime : { 40147 future : 'dans %s', 40148 past : 'il y a %s', 40149 s : 'quelques secondes', 40150 ss : '%d secondes', 40151 m : 'une minute', 40152 mm : '%d minutes', 40153 h : 'une heure', 40154 hh : '%d heures', 40155 d : 'un jour', 40156 dd : '%d jours', 40157 M : 'un mois', 40158 MM : '%d mois', 40159 y : 'un an', 40160 yy : '%d ans' 40161 }, 40162 dayOfMonthOrdinalParse: /\d{1,2}(er|)/, 40163 ordinal : function (number, period) { 40164 switch (period) { 40165 // TODO: Return 'e' when day of month > 1. Move this case inside 40166 // block for masculine words below. 40167 // See https://github.com/moment/moment/issues/3375 40168 case 'D': 40169 return number + (number === 1 ? 'er' : ''); 40170 40171 // Words with masculine grammatical gender: mois, trimestre, jour 40172 default: 40173 case 'M': 40174 case 'Q': 40175 case 'DDD': 40176 case 'd': 40177 return number + (number === 1 ? 'er' : 'e'); 40178 40179 // Words with feminine grammatical gender: semaine 40180 case 'w': 40181 case 'W': 40182 return number + (number === 1 ? 're' : 'e'); 40183 } 40184 }, 40185 week : { 40186 dow : 1, // Monday is the first day of the week. 40187 doy : 4 // The week that contains Jan 4th is the first week of the year. 40188 } 40189 }); 40190 40191 return fr; 40192 40193}))); 40194 40195 40196/***/ }), 40197/* 76 */ 40198/***/ (function(module, exports, __webpack_require__) { 40199 40200//! moment.js locale configuration 40201 40202;(function (global, factory) { 40203 true ? factory(__webpack_require__(0)) : 40204 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 40205 factory(global.moment) 40206}(this, (function (moment) { 'use strict'; 40207 40208 40209 var monthsShortWithDots = 'jan._feb._mrt._apr._mai_jun._jul._aug._sep._okt._nov._des.'.split('_'), 40210 monthsShortWithoutDots = 'jan_feb_mrt_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'); 40211 40212 var fy = moment.defineLocale('fy', { 40213 months : 'jannewaris_febrewaris_maart_april_maaie_juny_july_augustus_septimber_oktober_novimber_desimber'.split('_'), 40214 monthsShort : function (m, format) { 40215 if (!m) { 40216 return monthsShortWithDots; 40217 } else if (/-MMM-/.test(format)) { 40218 return monthsShortWithoutDots[m.month()]; 40219 } else { 40220 return monthsShortWithDots[m.month()]; 40221 } 40222 }, 40223 monthsParseExact : true, 40224 weekdays : 'snein_moandei_tiisdei_woansdei_tongersdei_freed_sneon'.split('_'), 40225 weekdaysShort : 'si._mo._ti._wo._to._fr._so.'.split('_'), 40226 weekdaysMin : 'Si_Mo_Ti_Wo_To_Fr_So'.split('_'), 40227 weekdaysParseExact : true, 40228 longDateFormat : { 40229 LT : 'HH:mm', 40230 LTS : 'HH:mm:ss', 40231 L : 'DD-MM-YYYY', 40232 LL : 'D MMMM YYYY', 40233 LLL : 'D MMMM YYYY HH:mm', 40234 LLLL : 'dddd D MMMM YYYY HH:mm' 40235 }, 40236 calendar : { 40237 sameDay: '[hjoed om] LT', 40238 nextDay: '[moarn om] LT', 40239 nextWeek: 'dddd [om] LT', 40240 lastDay: '[juster om] LT', 40241 lastWeek: '[ôfrûne] dddd [om] LT', 40242 sameElse: 'L' 40243 }, 40244 relativeTime : { 40245 future : 'oer %s', 40246 past : '%s lyn', 40247 s : 'in pear sekonden', 40248 ss : '%d sekonden', 40249 m : 'ien minút', 40250 mm : '%d minuten', 40251 h : 'ien oere', 40252 hh : '%d oeren', 40253 d : 'ien dei', 40254 dd : '%d dagen', 40255 M : 'ien moanne', 40256 MM : '%d moannen', 40257 y : 'ien jier', 40258 yy : '%d jierren' 40259 }, 40260 dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/, 40261 ordinal : function (number) { 40262 return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de'); 40263 }, 40264 week : { 40265 dow : 1, // Monday is the first day of the week. 40266 doy : 4 // The week that contains Jan 4th is the first week of the year. 40267 } 40268 }); 40269 40270 return fy; 40271 40272}))); 40273 40274 40275/***/ }), 40276/* 77 */ 40277/***/ (function(module, exports, __webpack_require__) { 40278 40279//! moment.js locale configuration 40280 40281;(function (global, factory) { 40282 true ? factory(__webpack_require__(0)) : 40283 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 40284 factory(global.moment) 40285}(this, (function (moment) { 'use strict'; 40286 40287 40288 var months = [ 40289 'Am Faoilleach', 'An Gearran', 'Am Mà rt', 'An Giblean', 'An Cèitean', 'An t-Ãgmhios', 'An t-Iuchar', 'An Lùnastal', 'An t-Sultain', 'An Dà mhair', 'An t-Samhain', 'An Dùbhlachd' 40290 ]; 40291 40292 var monthsShort = ['Faoi', 'Gear', 'Mà rt', 'Gibl', 'Cèit', 'Ãgmh', 'Iuch', 'Lùn', 'Sult', 'Dà mh', 'Samh', 'Dùbh']; 40293 40294 var weekdays = ['Didòmhnaich', 'Diluain', 'Dimà irt', 'Diciadain', 'Diardaoin', 'Dihaoine', 'Disathairne']; 40295 40296 var weekdaysShort = ['Did', 'Dil', 'Dim', 'Dic', 'Dia', 'Dih', 'Dis']; 40297 40298 var weekdaysMin = ['Dò', 'Lu', 'Mà ', 'Ci', 'Ar', 'Ha', 'Sa']; 40299 40300 var gd = moment.defineLocale('gd', { 40301 months : months, 40302 monthsShort : monthsShort, 40303 monthsParseExact : true, 40304 weekdays : weekdays, 40305 weekdaysShort : weekdaysShort, 40306 weekdaysMin : weekdaysMin, 40307 longDateFormat : { 40308 LT : 'HH:mm', 40309 LTS : 'HH:mm:ss', 40310 L : 'DD/MM/YYYY', 40311 LL : 'D MMMM YYYY', 40312 LLL : 'D MMMM YYYY HH:mm', 40313 LLLL : 'dddd, D MMMM YYYY HH:mm' 40314 }, 40315 calendar : { 40316 sameDay : '[An-diugh aig] LT', 40317 nextDay : '[A-mà ireach aig] LT', 40318 nextWeek : 'dddd [aig] LT', 40319 lastDay : '[An-dè aig] LT', 40320 lastWeek : 'dddd [seo chaidh] [aig] LT', 40321 sameElse : 'L' 40322 }, 40323 relativeTime : { 40324 future : 'ann an %s', 40325 past : 'bho chionn %s', 40326 s : 'beagan diogan', 40327 ss : '%d diogan', 40328 m : 'mionaid', 40329 mm : '%d mionaidean', 40330 h : 'uair', 40331 hh : '%d uairean', 40332 d : 'latha', 40333 dd : '%d latha', 40334 M : 'mìos', 40335 MM : '%d mìosan', 40336 y : 'bliadhna', 40337 yy : '%d bliadhna' 40338 }, 40339 dayOfMonthOrdinalParse : /\d{1,2}(d|na|mh)/, 40340 ordinal : function (number) { 40341 var output = number === 1 ? 'd' : number % 10 === 2 ? 'na' : 'mh'; 40342 return number + output; 40343 }, 40344 week : { 40345 dow : 1, // Monday is the first day of the week. 40346 doy : 4 // The week that contains Jan 4th is the first week of the year. 40347 } 40348 }); 40349 40350 return gd; 40351 40352}))); 40353 40354 40355/***/ }), 40356/* 78 */ 40357/***/ (function(module, exports, __webpack_require__) { 40358 40359//! moment.js locale configuration 40360 40361;(function (global, factory) { 40362 true ? factory(__webpack_require__(0)) : 40363 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 40364 factory(global.moment) 40365}(this, (function (moment) { 'use strict'; 40366 40367 40368 var gl = moment.defineLocale('gl', { 40369 months : 'xaneiro_febreiro_marzo_abril_maio_xuño_xullo_agosto_setembro_outubro_novembro_decembro'.split('_'), 40370 monthsShort : 'xan._feb._mar._abr._mai._xuñ._xul._ago._set._out._nov._dec.'.split('_'), 40371 monthsParseExact: true, 40372 weekdays : 'domingo_luns_martes_mércores_xoves_venres_sábado'.split('_'), 40373 weekdaysShort : 'dom._lun._mar._mér._xov._ven._sáb.'.split('_'), 40374 weekdaysMin : 'do_lu_ma_mé_xo_ve_sá'.split('_'), 40375 weekdaysParseExact : true, 40376 longDateFormat : { 40377 LT : 'H:mm', 40378 LTS : 'H:mm:ss', 40379 L : 'DD/MM/YYYY', 40380 LL : 'D [de] MMMM [de] YYYY', 40381 LLL : 'D [de] MMMM [de] YYYY H:mm', 40382 LLLL : 'dddd, D [de] MMMM [de] YYYY H:mm' 40383 }, 40384 calendar : { 40385 sameDay : function () { 40386 return '[hoxe ' + ((this.hours() !== 1) ? 'ás' : 'á') + '] LT'; 40387 }, 40388 nextDay : function () { 40389 return '[mañá ' + ((this.hours() !== 1) ? 'ás' : 'á') + '] LT'; 40390 }, 40391 nextWeek : function () { 40392 return 'dddd [' + ((this.hours() !== 1) ? 'ás' : 'a') + '] LT'; 40393 }, 40394 lastDay : function () { 40395 return '[onte ' + ((this.hours() !== 1) ? 'á' : 'a') + '] LT'; 40396 }, 40397 lastWeek : function () { 40398 return '[o] dddd [pasado ' + ((this.hours() !== 1) ? 'ás' : 'a') + '] LT'; 40399 }, 40400 sameElse : 'L' 40401 }, 40402 relativeTime : { 40403 future : function (str) { 40404 if (str.indexOf('un') === 0) { 40405 return 'n' + str; 40406 } 40407 return 'en ' + str; 40408 }, 40409 past : 'hai %s', 40410 s : 'uns segundos', 40411 ss : '%d segundos', 40412 m : 'un minuto', 40413 mm : '%d minutos', 40414 h : 'unha hora', 40415 hh : '%d horas', 40416 d : 'un dÃa', 40417 dd : '%d dÃas', 40418 M : 'un mes', 40419 MM : '%d meses', 40420 y : 'un ano', 40421 yy : '%d anos' 40422 }, 40423 dayOfMonthOrdinalParse : /\d{1,2}º/, 40424 ordinal : '%dº', 40425 week : { 40426 dow : 1, // Monday is the first day of the week. 40427 doy : 4 // The week that contains Jan 4th is the first week of the year. 40428 } 40429 }); 40430 40431 return gl; 40432 40433}))); 40434 40435 40436/***/ }), 40437/* 79 */ 40438/***/ (function(module, exports, __webpack_require__) { 40439 40440//! moment.js locale configuration 40441 40442;(function (global, factory) { 40443 true ? factory(__webpack_require__(0)) : 40444 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 40445 factory(global.moment) 40446}(this, (function (moment) { 'use strict'; 40447 40448 40449 function processRelativeTime(number, withoutSuffix, key, isFuture) { 40450 var format = { 40451 's': ['thodde secondanim', 'thodde second'], 40452 'ss': [number + ' secondanim', number + ' second'], 40453 'm': ['eka mintan', 'ek minute'], 40454 'mm': [number + ' mintanim', number + ' mintam'], 40455 'h': ['eka horan', 'ek hor'], 40456 'hh': [number + ' horanim', number + ' horam'], 40457 'd': ['eka disan', 'ek dis'], 40458 'dd': [number + ' disanim', number + ' dis'], 40459 'M': ['eka mhoinean', 'ek mhoino'], 40460 'MM': [number + ' mhoineanim', number + ' mhoine'], 40461 'y': ['eka vorsan', 'ek voros'], 40462 'yy': [number + ' vorsanim', number + ' vorsam'] 40463 }; 40464 return withoutSuffix ? format[key][0] : format[key][1]; 40465 } 40466 40467 var gomLatn = moment.defineLocale('gom-latn', { 40468 months : 'Janer_Febrer_Mars_Abril_Mai_Jun_Julai_Agost_Setembr_Otubr_Novembr_Dezembr'.split('_'), 40469 monthsShort : 'Jan._Feb._Mars_Abr._Mai_Jun_Jul._Ago._Set._Otu._Nov._Dez.'.split('_'), 40470 monthsParseExact : true, 40471 weekdays : 'Aitar_Somar_Mongllar_Budvar_Brestar_Sukrar_Son\'var'.split('_'), 40472 weekdaysShort : 'Ait._Som._Mon._Bud._Bre._Suk._Son.'.split('_'), 40473 weekdaysMin : 'Ai_Sm_Mo_Bu_Br_Su_Sn'.split('_'), 40474 weekdaysParseExact : true, 40475 longDateFormat : { 40476 LT : 'A h:mm [vazta]', 40477 LTS : 'A h:mm:ss [vazta]', 40478 L : 'DD-MM-YYYY', 40479 LL : 'D MMMM YYYY', 40480 LLL : 'D MMMM YYYY A h:mm [vazta]', 40481 LLLL : 'dddd, MMMM[achea] Do, YYYY, A h:mm [vazta]', 40482 llll: 'ddd, D MMM YYYY, A h:mm [vazta]' 40483 }, 40484 calendar : { 40485 sameDay: '[Aiz] LT', 40486 nextDay: '[Faleam] LT', 40487 nextWeek: '[Ieta to] dddd[,] LT', 40488 lastDay: '[Kal] LT', 40489 lastWeek: '[Fatlo] dddd[,] LT', 40490 sameElse: 'L' 40491 }, 40492 relativeTime : { 40493 future : '%s', 40494 past : '%s adim', 40495 s : processRelativeTime, 40496 ss : processRelativeTime, 40497 m : processRelativeTime, 40498 mm : processRelativeTime, 40499 h : processRelativeTime, 40500 hh : processRelativeTime, 40501 d : processRelativeTime, 40502 dd : processRelativeTime, 40503 M : processRelativeTime, 40504 MM : processRelativeTime, 40505 y : processRelativeTime, 40506 yy : processRelativeTime 40507 }, 40508 dayOfMonthOrdinalParse : /\d{1,2}(er)/, 40509 ordinal : function (number, period) { 40510 switch (period) { 40511 // the ordinal 'er' only applies to day of the month 40512 case 'D': 40513 return number + 'er'; 40514 default: 40515 case 'M': 40516 case 'Q': 40517 case 'DDD': 40518 case 'd': 40519 case 'w': 40520 case 'W': 40521 return number; 40522 } 40523 }, 40524 week : { 40525 dow : 1, // Monday is the first day of the week. 40526 doy : 4 // The week that contains Jan 4th is the first week of the year. 40527 }, 40528 meridiemParse: /rati|sokalli|donparam|sanje/, 40529 meridiemHour : function (hour, meridiem) { 40530 if (hour === 12) { 40531 hour = 0; 40532 } 40533 if (meridiem === 'rati') { 40534 return hour < 4 ? hour : hour + 12; 40535 } else if (meridiem === 'sokalli') { 40536 return hour; 40537 } else if (meridiem === 'donparam') { 40538 return hour > 12 ? hour : hour + 12; 40539 } else if (meridiem === 'sanje') { 40540 return hour + 12; 40541 } 40542 }, 40543 meridiem : function (hour, minute, isLower) { 40544 if (hour < 4) { 40545 return 'rati'; 40546 } else if (hour < 12) { 40547 return 'sokalli'; 40548 } else if (hour < 16) { 40549 return 'donparam'; 40550 } else if (hour < 20) { 40551 return 'sanje'; 40552 } else { 40553 return 'rati'; 40554 } 40555 } 40556 }); 40557 40558 return gomLatn; 40559 40560}))); 40561 40562 40563/***/ }), 40564/* 80 */ 40565/***/ (function(module, exports, __webpack_require__) { 40566 40567//! moment.js locale configuration 40568 40569;(function (global, factory) { 40570 true ? factory(__webpack_require__(0)) : 40571 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 40572 factory(global.moment) 40573}(this, (function (moment) { 'use strict'; 40574 40575 40576 var symbolMap = { 40577 '1': '૧', 40578 '2': '૨', 40579 '3': 'à«©', 40580 '4': '૪', 40581 '5': 'à««', 40582 '6': '૬', 40583 '7': 'à«', 40584 '8': 'à«®', 40585 '9': '૯', 40586 '0': '૦' 40587 }, 40588 numberMap = { 40589 '૧': '1', 40590 '૨': '2', 40591 'à«©': '3', 40592 '૪': '4', 40593 'à««': '5', 40594 '૬': '6', 40595 'à«': '7', 40596 'à«®': '8', 40597 '૯': '9', 40598 '૦': '0' 40599 }; 40600 40601 var gu = moment.defineLocale('gu', { 40602 months: 'àªàª¾àª¨à«àª¯à«àªàª°à«_ફà«àª¬à«àª°à«àªàª°à«_મારà«àª_àªàªªà«àª°àª¿àª²_મà«_àªà«àª¨_àªà«àª²àª¾àª_àªàªàª¸à«àª_સપà«àªà«àª®à«àª¬àª°_àªàªà«àªà«àª¬àª°_નવà«àª®à«àª¬àª°_ડિસà«àª®à«àª¬àª°'.split('_'), 40603 monthsShort: 'àªàª¾àª¨à«àª¯à«._ફà«àª¬à«àª°à«._મારà«àª_àªàªªà«àª°àª¿._મà«_àªà«àª¨_àªà«àª²àª¾._àªàª._સપà«àªà«._àªàªà«àªà«._નવà«._ડિસà«.'.split('_'), 40604 monthsParseExact: true, 40605 weekdays: 'રવિવાર_સà«àª®àªµàª¾àª°_મàªàªàª³àªµàª¾àª°_બà«àª§à«àªµàª¾àª°_àªà«àª°à«àªµàª¾àª°_શà«àªà«àª°àªµàª¾àª°_શનિવાર'.split('_'), 40606 weekdaysShort: 'રવિ_સà«àª®_મàªàªàª³_બà«àª§à«_àªà«àª°à«_શà«àªà«àª°_શનિ'.split('_'), 40607 weekdaysMin: 'ર_સà«_મàª_બà«_àªà«_શà«_શ'.split('_'), 40608 longDateFormat: { 40609 LT: 'A h:mm વાàªà«àª¯à«', 40610 LTS: 'A h:mm:ss વાàªà«àª¯à«', 40611 L: 'DD/MM/YYYY', 40612 LL: 'D MMMM YYYY', 40613 LLL: 'D MMMM YYYY, A h:mm વાàªà«àª¯à«', 40614 LLLL: 'dddd, D MMMM YYYY, A h:mm વાàªà«àª¯à«' 40615 }, 40616 calendar: { 40617 sameDay: '[àªàª] LT', 40618 nextDay: '[àªàª¾àª²à«] LT', 40619 nextWeek: 'dddd, LT', 40620 lastDay: '[àªàªàªàª¾àª²à«] LT', 40621 lastWeek: '[પાàªàª²àª¾] dddd, LT', 40622 sameElse: 'L' 40623 }, 40624 relativeTime: { 40625 future: '%s મા', 40626 past: '%s પà«àª¹àª²àª¾', 40627 s: 'ઠમà«àª પળà«', 40628 ss: '%d સà«àªàªàª¡', 40629 m: 'àªàª મિનિàª', 40630 mm: '%d મિનિàª', 40631 h: 'àªàª àªàª²àª¾àª', 40632 hh: '%d àªàª²àª¾àª', 40633 d: 'àªàª દિવસ', 40634 dd: '%d દિવસ', 40635 M: 'àªàª મહિનà«', 40636 MM: '%d મહિનà«', 40637 y: 'àªàª વરà«àª·', 40638 yy: '%d વરà«àª·' 40639 }, 40640 preparse: function (string) { 40641 return string.replace(/[૧૨૩૪૫૬à«à«®à«¯à«¦]/g, function (match) { 40642 return numberMap[match]; 40643 }); 40644 }, 40645 postformat: function (string) { 40646 return string.replace(/\d/g, function (match) { 40647 return symbolMap[match]; 40648 }); 40649 }, 40650 // Gujarati notation for meridiems are quite fuzzy in practice. While there exists 40651 // a rigid notion of a 'Pahar' it is not used as rigidly in modern Gujarati. 40652 meridiemParse: /રાત|બપà«àª°|સવાર|સાàªàª/, 40653 meridiemHour: function (hour, meridiem) { 40654 if (hour === 12) { 40655 hour = 0; 40656 } 40657 if (meridiem === 'રાત') { 40658 return hour < 4 ? hour : hour + 12; 40659 } else if (meridiem === 'સવાર') { 40660 return hour; 40661 } else if (meridiem === 'બપà«àª°') { 40662 return hour >= 10 ? hour : hour + 12; 40663 } else if (meridiem === 'સાàªàª') { 40664 return hour + 12; 40665 } 40666 }, 40667 meridiem: function (hour, minute, isLower) { 40668 if (hour < 4) { 40669 return 'રાત'; 40670 } else if (hour < 10) { 40671 return 'સવાર'; 40672 } else if (hour < 17) { 40673 return 'બપà«àª°'; 40674 } else if (hour < 20) { 40675 return 'સાàªàª'; 40676 } else { 40677 return 'રાત'; 40678 } 40679 }, 40680 week: { 40681 dow: 0, // Sunday is the first day of the week. 40682 doy: 6 // The week that contains Jan 1st is the first week of the year. 40683 } 40684 }); 40685 40686 return gu; 40687 40688}))); 40689 40690 40691/***/ }), 40692/* 81 */ 40693/***/ (function(module, exports, __webpack_require__) { 40694 40695//! moment.js locale configuration 40696 40697;(function (global, factory) { 40698 true ? factory(__webpack_require__(0)) : 40699 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 40700 factory(global.moment) 40701}(this, (function (moment) { 'use strict'; 40702 40703 40704 var he = moment.defineLocale('he', { 40705 months : '×× ××ר_פ×ר××ר_×רץ_×פר××_×××_××× ×_××××_××××ס×_ספ×××ר_××ק×××ר_× ××××ר_×צ××ר'.split('_'), 40706 monthsShort : '×× ×׳_פ×ר׳_×רץ_×פר׳_×××_××× ×_××××_×××׳_ספ×׳_××ק׳_× ××׳_×צ×׳'.split('_'), 40707 weekdays : 'ר×ש××_×©× ×_ש××ש×_ר×××¢×_×××ש×_ש×ש×_ש×ת'.split('_'), 40708 weekdaysShort : '×׳_×׳_×׳_×׳_×׳_×׳_ש׳'.split('_'), 40709 weekdaysMin : '×_×_×_×_×_×_ש'.split('_'), 40710 longDateFormat : { 40711 LT : 'HH:mm', 40712 LTS : 'HH:mm:ss', 40713 L : 'DD/MM/YYYY', 40714 LL : 'D [×]MMMM YYYY', 40715 LLL : 'D [×]MMMM YYYY HH:mm', 40716 LLLL : 'dddd, D [×]MMMM YYYY HH:mm', 40717 l : 'D/M/YYYY', 40718 ll : 'D MMM YYYY', 40719 lll : 'D MMM YYYY HH:mm', 40720 llll : 'ddd, D MMM YYYY HH:mm' 40721 }, 40722 calendar : { 40723 sameDay : '[×××× ×Ö¾]LT', 40724 nextDay : '[××ר ×Ö¾]LT', 40725 nextWeek : 'dddd [×שע×] LT', 40726 lastDay : '[×ת××× ×Ö¾]LT', 40727 lastWeek : '[××××] dddd [×××ר×× ×שע×] LT', 40728 sameElse : 'L' 40729 }, 40730 relativeTime : { 40731 future : '××¢×× %s', 40732 past : '××¤× × %s', 40733 s : '×ספר ×©× ××ת', 40734 ss : '%d ×©× ××ת', 40735 m : '×ק×', 40736 mm : '%d ×ק×ת', 40737 h : 'שע×', 40738 hh : function (number) { 40739 if (number === 2) { 40740 return 'שעת×××'; 40741 } 40742 return number + ' שע×ת'; 40743 }, 40744 d : '×××', 40745 dd : function (number) { 40746 if (number === 2) { 40747 return '××××××'; 40748 } 40749 return number + ' ××××'; 40750 }, 40751 M : '×××ש', 40752 MM : function (number) { 40753 if (number === 2) { 40754 return '×××ש×××'; 40755 } 40756 return number + ' ×××ש××'; 40757 }, 40758 y : '×©× ×', 40759 yy : function (number) { 40760 if (number === 2) { 40761 return '×©× ×ª×××'; 40762 } else if (number % 10 === 0 && number !== 10) { 40763 return number + ' ×©× ×'; 40764 } 40765 return number + ' ×©× ××'; 40766 } 40767 }, 40768 meridiemParse: /×××"צ|××¤× ×"צ|×××¨× ×צ×ר×××|××¤× × ×צ×ר×××|××¤× ×ת ××קר|×××קר|×ער×/i, 40769 isPM : function (input) { 40770 return /^(×××"צ|×××¨× ×צ×ר×××|×ער×)$/.test(input); 40771 }, 40772 meridiem : function (hour, minute, isLower) { 40773 if (hour < 5) { 40774 return '××¤× ×ת ××קר'; 40775 } else if (hour < 10) { 40776 return '×××קר'; 40777 } else if (hour < 12) { 40778 return isLower ? '××¤× ×"צ' : '××¤× × ×צ×ר×××'; 40779 } else if (hour < 18) { 40780 return isLower ? '×××"צ' : '×××¨× ×צ×ר×××'; 40781 } else { 40782 return '×ער×'; 40783 } 40784 } 40785 }); 40786 40787 return he; 40788 40789}))); 40790 40791 40792/***/ }), 40793/* 82 */ 40794/***/ (function(module, exports, __webpack_require__) { 40795 40796//! moment.js locale configuration 40797 40798;(function (global, factory) { 40799 true ? factory(__webpack_require__(0)) : 40800 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 40801 factory(global.moment) 40802}(this, (function (moment) { 'use strict'; 40803 40804 40805 var symbolMap = { 40806 '1': '१', 40807 '2': '२', 40808 '3': '३', 40809 '4': '४', 40810 '5': '५', 40811 '6': '६', 40812 '7': 'à¥', 40813 '8': '८', 40814 '9': '९', 40815 '0': '०' 40816 }, 40817 numberMap = { 40818 '१': '1', 40819 '२': '2', 40820 '३': '3', 40821 '४': '4', 40822 '५': '5', 40823 '६': '6', 40824 'à¥': '7', 40825 '८': '8', 40826 '९': '9', 40827 '०': '0' 40828 }; 40829 40830 var hi = moment.defineLocale('hi', { 40831 months : 'à¤à¤¨à¤µà¤°à¥_फ़रवरà¥_मारà¥à¤_ठपà¥à¤°à¥à¤²_मà¤_à¤à¥à¤¨_à¤à¥à¤²à¤¾à¤_ठà¤à¤¸à¥à¤¤_सितमà¥à¤¬à¤°_ठà¤à¥à¤à¥à¤¬à¤°_नवमà¥à¤¬à¤°_दिसमà¥à¤¬à¤°'.split('_'), 40832 monthsShort : 'à¤à¤¨._फ़र._मारà¥à¤_ठपà¥à¤°à¥._मà¤_à¤à¥à¤¨_à¤à¥à¤²._ठà¤._सित._ठà¤à¥à¤à¥._नव._दिस.'.split('_'), 40833 monthsParseExact: true, 40834 weekdays : 'रविवार_सà¥à¤®à¤µà¤¾à¤°_मà¤à¤à¤²à¤µà¤¾à¤°_बà¥à¤§à¤µà¤¾à¤°_à¤à¥à¤°à¥à¤µà¤¾à¤°_शà¥à¤à¥à¤°à¤µà¤¾à¤°_शनिवार'.split('_'), 40835 weekdaysShort : 'रवि_सà¥à¤®_मà¤à¤à¤²_बà¥à¤§_à¤à¥à¤°à¥_शà¥à¤à¥à¤°_शनि'.split('_'), 40836 weekdaysMin : 'र_सà¥_मà¤_बà¥_à¤à¥_शà¥_श'.split('_'), 40837 longDateFormat : { 40838 LT : 'A h:mm बà¤à¥', 40839 LTS : 'A h:mm:ss बà¤à¥', 40840 L : 'DD/MM/YYYY', 40841 LL : 'D MMMM YYYY', 40842 LLL : 'D MMMM YYYY, A h:mm बà¤à¥', 40843 LLLL : 'dddd, D MMMM YYYY, A h:mm बà¤à¥' 40844 }, 40845 calendar : { 40846 sameDay : '[à¤à¤] LT', 40847 nextDay : '[à¤à¤²] LT', 40848 nextWeek : 'dddd, LT', 40849 lastDay : '[à¤à¤²] LT', 40850 lastWeek : '[पिà¤à¤²à¥] dddd, LT', 40851 sameElse : 'L' 40852 }, 40853 relativeTime : { 40854 future : '%s मà¥à¤', 40855 past : '%s पहलà¥', 40856 s : 'à¤à¥à¤ हॠà¤à¥à¤·à¤£', 40857 ss : '%d सà¥à¤à¤à¤¡', 40858 m : 'à¤à¤ मिनà¤', 40859 mm : '%d मिनà¤', 40860 h : 'à¤à¤ à¤à¤à¤à¤¾', 40861 hh : '%d à¤à¤à¤à¥', 40862 d : 'à¤à¤ दिन', 40863 dd : '%d दिन', 40864 M : 'à¤à¤ महà¥à¤¨à¥', 40865 MM : '%d महà¥à¤¨à¥', 40866 y : 'à¤à¤ वरà¥à¤·', 40867 yy : '%d वरà¥à¤·' 40868 }, 40869 preparse: function (string) { 40870 return string.replace(/[१२३४५६à¥à¥®à¥¯à¥¦]/g, function (match) { 40871 return numberMap[match]; 40872 }); 40873 }, 40874 postformat: function (string) { 40875 return string.replace(/\d/g, function (match) { 40876 return symbolMap[match]; 40877 }); 40878 }, 40879 // Hindi notation for meridiems are quite fuzzy in practice. While there exists 40880 // a rigid notion of a 'Pahar' it is not used as rigidly in modern Hindi. 40881 meridiemParse: /रात|सà¥à¤¬à¤¹|दà¥à¤ªà¤¹à¤°|शाम/, 40882 meridiemHour : function (hour, meridiem) { 40883 if (hour === 12) { 40884 hour = 0; 40885 } 40886 if (meridiem === 'रात') { 40887 return hour < 4 ? hour : hour + 12; 40888 } else if (meridiem === 'सà¥à¤¬à¤¹') { 40889 return hour; 40890 } else if (meridiem === 'दà¥à¤ªà¤¹à¤°') { 40891 return hour >= 10 ? hour : hour + 12; 40892 } else if (meridiem === 'शाम') { 40893 return hour + 12; 40894 } 40895 }, 40896 meridiem : function (hour, minute, isLower) { 40897 if (hour < 4) { 40898 return 'रात'; 40899 } else if (hour < 10) { 40900 return 'सà¥à¤¬à¤¹'; 40901 } else if (hour < 17) { 40902 return 'दà¥à¤ªà¤¹à¤°'; 40903 } else if (hour < 20) { 40904 return 'शाम'; 40905 } else { 40906 return 'रात'; 40907 } 40908 }, 40909 week : { 40910 dow : 0, // Sunday is the first day of the week. 40911 doy : 6 // The week that contains Jan 1st is the first week of the year. 40912 } 40913 }); 40914 40915 return hi; 40916 40917}))); 40918 40919 40920/***/ }), 40921/* 83 */ 40922/***/ (function(module, exports, __webpack_require__) { 40923 40924//! moment.js locale configuration 40925 40926;(function (global, factory) { 40927 true ? factory(__webpack_require__(0)) : 40928 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 40929 factory(global.moment) 40930}(this, (function (moment) { 'use strict'; 40931 40932 40933 function translate(number, withoutSuffix, key) { 40934 var result = number + ' '; 40935 switch (key) { 40936 case 'ss': 40937 if (number === 1) { 40938 result += 'sekunda'; 40939 } else if (number === 2 || number === 3 || number === 4) { 40940 result += 'sekunde'; 40941 } else { 40942 result += 'sekundi'; 40943 } 40944 return result; 40945 case 'm': 40946 return withoutSuffix ? 'jedna minuta' : 'jedne minute'; 40947 case 'mm': 40948 if (number === 1) { 40949 result += 'minuta'; 40950 } else if (number === 2 || number === 3 || number === 4) { 40951 result += 'minute'; 40952 } else { 40953 result += 'minuta'; 40954 } 40955 return result; 40956 case 'h': 40957 return withoutSuffix ? 'jedan sat' : 'jednog sata'; 40958 case 'hh': 40959 if (number === 1) { 40960 result += 'sat'; 40961 } else if (number === 2 || number === 3 || number === 4) { 40962 result += 'sata'; 40963 } else { 40964 result += 'sati'; 40965 } 40966 return result; 40967 case 'dd': 40968 if (number === 1) { 40969 result += 'dan'; 40970 } else { 40971 result += 'dana'; 40972 } 40973 return result; 40974 case 'MM': 40975 if (number === 1) { 40976 result += 'mjesec'; 40977 } else if (number === 2 || number === 3 || number === 4) { 40978 result += 'mjeseca'; 40979 } else { 40980 result += 'mjeseci'; 40981 } 40982 return result; 40983 case 'yy': 40984 if (number === 1) { 40985 result += 'godina'; 40986 } else if (number === 2 || number === 3 || number === 4) { 40987 result += 'godine'; 40988 } else { 40989 result += 'godina'; 40990 } 40991 return result; 40992 } 40993 } 40994 40995 var hr = moment.defineLocale('hr', { 40996 months : { 40997 format: 'sijeÄnja_veljaÄe_ožujka_travnja_svibnja_lipnja_srpnja_kolovoza_rujna_listopada_studenoga_prosinca'.split('_'), 40998 standalone: 'sijeÄanj_veljaÄa_ožujak_travanj_svibanj_lipanj_srpanj_kolovoz_rujan_listopad_studeni_prosinac'.split('_') 40999 }, 41000 monthsShort : 'sij._velj._ožu._tra._svi._lip._srp._kol._ruj._lis._stu._pro.'.split('_'), 41001 monthsParseExact: true, 41002 weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_Äetvrtak_petak_subota'.split('_'), 41003 weekdaysShort : 'ned._pon._uto._sri._Äet._pet._sub.'.split('_'), 41004 weekdaysMin : 'ne_po_ut_sr_Äe_pe_su'.split('_'), 41005 weekdaysParseExact : true, 41006 longDateFormat : { 41007 LT : 'H:mm', 41008 LTS : 'H:mm:ss', 41009 L : 'DD.MM.YYYY', 41010 LL : 'D. MMMM YYYY', 41011 LLL : 'D. MMMM YYYY H:mm', 41012 LLLL : 'dddd, D. MMMM YYYY H:mm' 41013 }, 41014 calendar : { 41015 sameDay : '[danas u] LT', 41016 nextDay : '[sutra u] LT', 41017 nextWeek : function () { 41018 switch (this.day()) { 41019 case 0: 41020 return '[u] [nedjelju] [u] LT'; 41021 case 3: 41022 return '[u] [srijedu] [u] LT'; 41023 case 6: 41024 return '[u] [subotu] [u] LT'; 41025 case 1: 41026 case 2: 41027 case 4: 41028 case 5: 41029 return '[u] dddd [u] LT'; 41030 } 41031 }, 41032 lastDay : '[juÄer u] LT', 41033 lastWeek : function () { 41034 switch (this.day()) { 41035 case 0: 41036 case 3: 41037 return '[proÅ¡lu] dddd [u] LT'; 41038 case 6: 41039 return '[proÅ¡le] [subote] [u] LT'; 41040 case 1: 41041 case 2: 41042 case 4: 41043 case 5: 41044 return '[proÅ¡li] dddd [u] LT'; 41045 } 41046 }, 41047 sameElse : 'L' 41048 }, 41049 relativeTime : { 41050 future : 'za %s', 41051 past : 'prije %s', 41052 s : 'par sekundi', 41053 ss : translate, 41054 m : translate, 41055 mm : translate, 41056 h : translate, 41057 hh : translate, 41058 d : 'dan', 41059 dd : translate, 41060 M : 'mjesec', 41061 MM : translate, 41062 y : 'godinu', 41063 yy : translate 41064 }, 41065 dayOfMonthOrdinalParse: /\d{1,2}\./, 41066 ordinal : '%d.', 41067 week : { 41068 dow : 1, // Monday is the first day of the week. 41069 doy : 7 // The week that contains Jan 1st is the first week of the year. 41070 } 41071 }); 41072 41073 return hr; 41074 41075}))); 41076 41077 41078/***/ }), 41079/* 84 */ 41080/***/ (function(module, exports, __webpack_require__) { 41081 41082//! moment.js locale configuration 41083 41084;(function (global, factory) { 41085 true ? factory(__webpack_require__(0)) : 41086 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 41087 factory(global.moment) 41088}(this, (function (moment) { 'use strict'; 41089 41090 41091 var weekEndings = 'vasárnap hétfÅn kedden szerdán csütörtökön pénteken szombaton'.split(' '); 41092 function translate(number, withoutSuffix, key, isFuture) { 41093 var num = number; 41094 switch (key) { 41095 case 's': 41096 return (isFuture || withoutSuffix) ? 'néhány másodperc' : 'néhány másodperce'; 41097 case 'ss': 41098 return num + (isFuture || withoutSuffix) ? ' másodperc' : ' másodperce'; 41099 case 'm': 41100 return 'egy' + (isFuture || withoutSuffix ? ' perc' : ' perce'); 41101 case 'mm': 41102 return num + (isFuture || withoutSuffix ? ' perc' : ' perce'); 41103 case 'h': 41104 return 'egy' + (isFuture || withoutSuffix ? ' óra' : ' órája'); 41105 case 'hh': 41106 return num + (isFuture || withoutSuffix ? ' óra' : ' órája'); 41107 case 'd': 41108 return 'egy' + (isFuture || withoutSuffix ? ' nap' : ' napja'); 41109 case 'dd': 41110 return num + (isFuture || withoutSuffix ? ' nap' : ' napja'); 41111 case 'M': 41112 return 'egy' + (isFuture || withoutSuffix ? ' hónap' : ' hónapja'); 41113 case 'MM': 41114 return num + (isFuture || withoutSuffix ? ' hónap' : ' hónapja'); 41115 case 'y': 41116 return 'egy' + (isFuture || withoutSuffix ? ' év' : ' éve'); 41117 case 'yy': 41118 return num + (isFuture || withoutSuffix ? ' év' : ' éve'); 41119 } 41120 return ''; 41121 } 41122 function week(isFuture) { 41123 return (isFuture ? '' : '[múlt] ') + '[' + weekEndings[this.day()] + '] LT[-kor]'; 41124 } 41125 41126 var hu = moment.defineLocale('hu', { 41127 months : 'január_február_március_április_május_június_július_augusztus_szeptember_október_november_december'.split('_'), 41128 monthsShort : 'jan_feb_márc_ápr_máj_jún_júl_aug_szept_okt_nov_dec'.split('_'), 41129 weekdays : 'vasárnap_hétfÅ_kedd_szerda_csütörtök_péntek_szombat'.split('_'), 41130 weekdaysShort : 'vas_hét_kedd_sze_csüt_pén_szo'.split('_'), 41131 weekdaysMin : 'v_h_k_sze_cs_p_szo'.split('_'), 41132 longDateFormat : { 41133 LT : 'H:mm', 41134 LTS : 'H:mm:ss', 41135 L : 'YYYY.MM.DD.', 41136 LL : 'YYYY. MMMM D.', 41137 LLL : 'YYYY. MMMM D. H:mm', 41138 LLLL : 'YYYY. MMMM D., dddd H:mm' 41139 }, 41140 meridiemParse: /de|du/i, 41141 isPM: function (input) { 41142 return input.charAt(1).toLowerCase() === 'u'; 41143 }, 41144 meridiem : function (hours, minutes, isLower) { 41145 if (hours < 12) { 41146 return isLower === true ? 'de' : 'DE'; 41147 } else { 41148 return isLower === true ? 'du' : 'DU'; 41149 } 41150 }, 41151 calendar : { 41152 sameDay : '[ma] LT[-kor]', 41153 nextDay : '[holnap] LT[-kor]', 41154 nextWeek : function () { 41155 return week.call(this, true); 41156 }, 41157 lastDay : '[tegnap] LT[-kor]', 41158 lastWeek : function () { 41159 return week.call(this, false); 41160 }, 41161 sameElse : 'L' 41162 }, 41163 relativeTime : { 41164 future : '%s múlva', 41165 past : '%s', 41166 s : translate, 41167 ss : translate, 41168 m : translate, 41169 mm : translate, 41170 h : translate, 41171 hh : translate, 41172 d : translate, 41173 dd : translate, 41174 M : translate, 41175 MM : translate, 41176 y : translate, 41177 yy : translate 41178 }, 41179 dayOfMonthOrdinalParse: /\d{1,2}\./, 41180 ordinal : '%d.', 41181 week : { 41182 dow : 1, // Monday is the first day of the week. 41183 doy : 4 // The week that contains Jan 4th is the first week of the year. 41184 } 41185 }); 41186 41187 return hu; 41188 41189}))); 41190 41191 41192/***/ }), 41193/* 85 */ 41194/***/ (function(module, exports, __webpack_require__) { 41195 41196//! moment.js locale configuration 41197 41198;(function (global, factory) { 41199 true ? factory(__webpack_require__(0)) : 41200 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 41201 factory(global.moment) 41202}(this, (function (moment) { 'use strict'; 41203 41204 41205 var hyAm = moment.defineLocale('hy-am', { 41206 months : { 41207 format: 'Õ°Õ¸ÖÕ¶Õ¾Õ¡ÖÕ«_ÖÕ¥Õ¿ÖÕ¾Õ¡ÖÕ«_Õ´Õ¡ÖÕ¿Õ«_Õ¡ÕºÖÕ«Õ¬Õ«_Õ´Õ¡ÕµÕ«Õ½Õ«_Õ°Õ¸ÖÕ¶Õ«Õ½Õ«_Õ°Õ¸ÖÕ¬Õ«Õ½Õ«_Ö Õ£Õ¸Õ½Õ¿Õ¸Õ½Õ«_Õ½Õ¥ÕºÕ¿Õ¥Õ´Õ¢Õ¥ÖÕ«_Õ°Õ¸Õ¯Õ¿Õ¥Õ´Õ¢Õ¥ÖÕ«_Õ¶Õ¸ÕµÕ¥Õ´Õ¢Õ¥ÖÕ«_Õ¤Õ¥Õ¯Õ¿Õ¥Õ´Õ¢Õ¥ÖÕ«'.split('_'), 41208 standalone: 'Õ°Õ¸ÖÕ¶Õ¾Õ¡Ö_ÖÕ¥Õ¿ÖÕ¾Õ¡Ö_Õ´Õ¡ÖÕ¿_Õ¡ÕºÖÕ«Õ¬_Õ´Õ¡ÕµÕ«Õ½_Õ°Õ¸ÖÕ¶Õ«Õ½_Õ°Õ¸ÖÕ¬Õ«Õ½_Ö Õ£Õ¸Õ½Õ¿Õ¸Õ½_Õ½Õ¥ÕºÕ¿Õ¥Õ´Õ¢Õ¥Ö_Õ°Õ¸Õ¯Õ¿Õ¥Õ´Õ¢Õ¥Ö_Õ¶Õ¸ÕµÕ¥Õ´Õ¢Õ¥Ö_Õ¤Õ¥Õ¯Õ¿Õ¥Õ´Õ¢Õ¥Ö'.split('_') 41209 }, 41210 monthsShort : 'Õ°Õ¶Õ¾_ÖÕ¿Ö_Õ´ÖÕ¿_Õ¡ÕºÖ_Õ´ÕµÕ½_Õ°Õ¶Õ½_Õ°Õ¬Õ½_Ö Õ£Õ½_Õ½ÕºÕ¿_Õ°Õ¯Õ¿_Õ¶Õ´Õ¢_Õ¤Õ¯Õ¿'.split('_'), 41211 weekdays : 'Õ¯Õ«ÖÕ¡Õ¯Õ«_Õ¥ÖÕ¯Õ¸ÖÕ·Õ¡Õ¢Õ©Õ«_Õ¥ÖÕ¥ÖÕ·Õ¡Õ¢Õ©Õ«_Õ¹Õ¸ÖÕ¥ÖÕ·Õ¡Õ¢Õ©Õ«_Õ°Õ«Õ¶Õ£Õ·Õ¡Õ¢Õ©Õ«_Õ¸ÖÖÕ¢Õ¡Õ©_Õ·Õ¡Õ¢Õ¡Õ©'.split('_'), 41212 weekdaysShort : 'Õ¯ÖÕ¯_Õ¥ÖÕ¯_Õ¥ÖÖ_Õ¹ÖÖ_Õ°Õ¶Õ£_Õ¸ÖÖÕ¢_Õ·Õ¢Õ©'.split('_'), 41213 weekdaysMin : 'Õ¯ÖÕ¯_Õ¥ÖÕ¯_Õ¥ÖÖ_Õ¹ÖÖ_Õ°Õ¶Õ£_Õ¸ÖÖÕ¢_Õ·Õ¢Õ©'.split('_'), 41214 longDateFormat : { 41215 LT : 'HH:mm', 41216 LTS : 'HH:mm:ss', 41217 L : 'DD.MM.YYYY', 41218 LL : 'D MMMM YYYY Õ©.', 41219 LLL : 'D MMMM YYYY Õ©., HH:mm', 41220 LLLL : 'dddd, D MMMM YYYY Õ©., HH:mm' 41221 }, 41222 calendar : { 41223 sameDay: '[Õ¡ÕµÕ½Ö Ö] LT', 41224 nextDay: '[Õ¾Õ¡Õ²Õ¨] LT', 41225 lastDay: '[Õ¥ÖÕ¥Õ¯] LT', 41226 nextWeek: function () { 41227 return 'dddd [Ö ÖÕ¨ ÕªÕ¡Õ´Õ¨] LT'; 41228 }, 41229 lastWeek: function () { 41230 return '[Õ¡Õ¶ÖÕ¡Õ®] dddd [Ö ÖÕ¨ ÕªÕ¡Õ´Õ¨] LT'; 41231 }, 41232 sameElse: 'L' 41233 }, 41234 relativeTime : { 41235 future : '%s Õ°Õ¥Õ¿Õ¸', 41236 past : '%s Õ¡Õ¼Õ¡Õ»', 41237 s : 'Õ´Õ« ÖÕ¡Õ¶Õ« Õ¾Õ¡ÕµÖÕ¯ÕµÕ¡Õ¶', 41238 ss : '%d Õ¾Õ¡ÕµÖÕ¯ÕµÕ¡Õ¶', 41239 m : 'ÖÕ¸ÕºÕ¥', 41240 mm : '%d ÖÕ¸ÕºÕ¥', 41241 h : 'ÕªÕ¡Õ´', 41242 hh : '%d ÕªÕ¡Õ´', 41243 d : 'Ö Ö', 41244 dd : '%d Ö Ö', 41245 M : 'Õ¡Õ´Õ«Õ½', 41246 MM : '%d Õ¡Õ´Õ«Õ½', 41247 y : 'Õ¿Õ¡ÖÕ«', 41248 yy : '%d Õ¿Õ¡ÖÕ«' 41249 }, 41250 meridiemParse: /Õ£Õ«Õ·Õ¥ÖÕ¾Õ¡|Õ¡Õ¼Õ¡Õ¾Õ¸Õ¿Õ¾Õ¡|ÖÕ¥ÖÕ¥Õ¯Õ¾Õ¡|Õ¥ÖÕ¥Õ¯Õ¸ÕµÕ¡Õ¶/, 41251 isPM: function (input) { 41252 return /^(ÖÕ¥ÖÕ¥Õ¯Õ¾Õ¡|Õ¥ÖÕ¥Õ¯Õ¸ÕµÕ¡Õ¶)$/.test(input); 41253 }, 41254 meridiem : function (hour) { 41255 if (hour < 4) { 41256 return 'Õ£Õ«Õ·Õ¥ÖÕ¾Õ¡'; 41257 } else if (hour < 12) { 41258 return 'Õ¡Õ¼Õ¡Õ¾Õ¸Õ¿Õ¾Õ¡'; 41259 } else if (hour < 17) { 41260 return 'ÖÕ¥ÖÕ¥Õ¯Õ¾Õ¡'; 41261 } else { 41262 return 'Õ¥ÖÕ¥Õ¯Õ¸ÕµÕ¡Õ¶'; 41263 } 41264 }, 41265 dayOfMonthOrdinalParse: /\d{1,2}|\d{1,2}-(Õ«Õ¶|ÖÕ¤)/, 41266 ordinal: function (number, period) { 41267 switch (period) { 41268 case 'DDD': 41269 case 'w': 41270 case 'W': 41271 case 'DDDo': 41272 if (number === 1) { 41273 return number + '-Õ«Õ¶'; 41274 } 41275 return number + '-ÖÕ¤'; 41276 default: 41277 return number; 41278 } 41279 }, 41280 week : { 41281 dow : 1, // Monday is the first day of the week. 41282 doy : 7 // The week that contains Jan 1st is the first week of the year. 41283 } 41284 }); 41285 41286 return hyAm; 41287 41288}))); 41289 41290 41291/***/ }), 41292/* 86 */ 41293/***/ (function(module, exports, __webpack_require__) { 41294 41295//! moment.js locale configuration 41296 41297;(function (global, factory) { 41298 true ? factory(__webpack_require__(0)) : 41299 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 41300 factory(global.moment) 41301}(this, (function (moment) { 'use strict'; 41302 41303 41304 var id = moment.defineLocale('id', { 41305 months : 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_November_Desember'.split('_'), 41306 monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Agt_Sep_Okt_Nov_Des'.split('_'), 41307 weekdays : 'Minggu_Senin_Selasa_Rabu_Kamis_Jumat_Sabtu'.split('_'), 41308 weekdaysShort : 'Min_Sen_Sel_Rab_Kam_Jum_Sab'.split('_'), 41309 weekdaysMin : 'Mg_Sn_Sl_Rb_Km_Jm_Sb'.split('_'), 41310 longDateFormat : { 41311 LT : 'HH.mm', 41312 LTS : 'HH.mm.ss', 41313 L : 'DD/MM/YYYY', 41314 LL : 'D MMMM YYYY', 41315 LLL : 'D MMMM YYYY [pukul] HH.mm', 41316 LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm' 41317 }, 41318 meridiemParse: /pagi|siang|sore|malam/, 41319 meridiemHour : function (hour, meridiem) { 41320 if (hour === 12) { 41321 hour = 0; 41322 } 41323 if (meridiem === 'pagi') { 41324 return hour; 41325 } else if (meridiem === 'siang') { 41326 return hour >= 11 ? hour : hour + 12; 41327 } else if (meridiem === 'sore' || meridiem === 'malam') { 41328 return hour + 12; 41329 } 41330 }, 41331 meridiem : function (hours, minutes, isLower) { 41332 if (hours < 11) { 41333 return 'pagi'; 41334 } else if (hours < 15) { 41335 return 'siang'; 41336 } else if (hours < 19) { 41337 return 'sore'; 41338 } else { 41339 return 'malam'; 41340 } 41341 }, 41342 calendar : { 41343 sameDay : '[Hari ini pukul] LT', 41344 nextDay : '[Besok pukul] LT', 41345 nextWeek : 'dddd [pukul] LT', 41346 lastDay : '[Kemarin pukul] LT', 41347 lastWeek : 'dddd [lalu pukul] LT', 41348 sameElse : 'L' 41349 }, 41350 relativeTime : { 41351 future : 'dalam %s', 41352 past : '%s yang lalu', 41353 s : 'beberapa detik', 41354 ss : '%d detik', 41355 m : 'semenit', 41356 mm : '%d menit', 41357 h : 'sejam', 41358 hh : '%d jam', 41359 d : 'sehari', 41360 dd : '%d hari', 41361 M : 'sebulan', 41362 MM : '%d bulan', 41363 y : 'setahun', 41364 yy : '%d tahun' 41365 }, 41366 week : { 41367 dow : 1, // Monday is the first day of the week. 41368 doy : 7 // The week that contains Jan 1st is the first week of the year. 41369 } 41370 }); 41371 41372 return id; 41373 41374}))); 41375 41376 41377/***/ }), 41378/* 87 */ 41379/***/ (function(module, exports, __webpack_require__) { 41380 41381//! moment.js locale configuration 41382 41383;(function (global, factory) { 41384 true ? factory(__webpack_require__(0)) : 41385 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 41386 factory(global.moment) 41387}(this, (function (moment) { 'use strict'; 41388 41389 41390 function plural(n) { 41391 if (n % 100 === 11) { 41392 return true; 41393 } else if (n % 10 === 1) { 41394 return false; 41395 } 41396 return true; 41397 } 41398 function translate(number, withoutSuffix, key, isFuture) { 41399 var result = number + ' '; 41400 switch (key) { 41401 case 's': 41402 return withoutSuffix || isFuture ? 'nokkrar sekúndur' : 'nokkrum sekúndum'; 41403 case 'ss': 41404 if (plural(number)) { 41405 return result + (withoutSuffix || isFuture ? 'sekúndur' : 'sekúndum'); 41406 } 41407 return result + 'sekúnda'; 41408 case 'm': 41409 return withoutSuffix ? 'mÃnúta' : 'mÃnútu'; 41410 case 'mm': 41411 if (plural(number)) { 41412 return result + (withoutSuffix || isFuture ? 'mÃnútur' : 'mÃnútum'); 41413 } else if (withoutSuffix) { 41414 return result + 'mÃnúta'; 41415 } 41416 return result + 'mÃnútu'; 41417 case 'hh': 41418 if (plural(number)) { 41419 return result + (withoutSuffix || isFuture ? 'klukkustundir' : 'klukkustundum'); 41420 } 41421 return result + 'klukkustund'; 41422 case 'd': 41423 if (withoutSuffix) { 41424 return 'dagur'; 41425 } 41426 return isFuture ? 'dag' : 'degi'; 41427 case 'dd': 41428 if (plural(number)) { 41429 if (withoutSuffix) { 41430 return result + 'dagar'; 41431 } 41432 return result + (isFuture ? 'daga' : 'dögum'); 41433 } else if (withoutSuffix) { 41434 return result + 'dagur'; 41435 } 41436 return result + (isFuture ? 'dag' : 'degi'); 41437 case 'M': 41438 if (withoutSuffix) { 41439 return 'mánuður'; 41440 } 41441 return isFuture ? 'mánuð' : 'mánuði'; 41442 case 'MM': 41443 if (plural(number)) { 41444 if (withoutSuffix) { 41445 return result + 'mánuðir'; 41446 } 41447 return result + (isFuture ? 'mánuði' : 'mánuðum'); 41448 } else if (withoutSuffix) { 41449 return result + 'mánuður'; 41450 } 41451 return result + (isFuture ? 'mánuð' : 'mánuði'); 41452 case 'y': 41453 return withoutSuffix || isFuture ? 'ár' : 'ári'; 41454 case 'yy': 41455 if (plural(number)) { 41456 return result + (withoutSuffix || isFuture ? 'ár' : 'árum'); 41457 } 41458 return result + (withoutSuffix || isFuture ? 'ár' : 'ári'); 41459 } 41460 } 41461 41462 var is = moment.defineLocale('is', { 41463 months : 'janúar_febrúar_mars_aprÃl_maÃ_júnÃ_júlÃ_ágúst_september_október_nóvember_desember'.split('_'), 41464 monthsShort : 'jan_feb_mar_apr_maÃ_jún_júl_ágú_sep_okt_nóv_des'.split('_'), 41465 weekdays : 'sunnudagur_mánudagur_þriðjudagur_miðvikudagur_fimmtudagur_föstudagur_laugardagur'.split('_'), 41466 weekdaysShort : 'sun_mán_þri_mið_fim_fös_lau'.split('_'), 41467 weekdaysMin : 'Su_Má_Ãr_Mi_Fi_Fö_La'.split('_'), 41468 longDateFormat : { 41469 LT : 'H:mm', 41470 LTS : 'H:mm:ss', 41471 L : 'DD.MM.YYYY', 41472 LL : 'D. MMMM YYYY', 41473 LLL : 'D. MMMM YYYY [kl.] H:mm', 41474 LLLL : 'dddd, D. MMMM YYYY [kl.] H:mm' 41475 }, 41476 calendar : { 41477 sameDay : '[à dag kl.] LT', 41478 nextDay : '[á morgun kl.] LT', 41479 nextWeek : 'dddd [kl.] LT', 41480 lastDay : '[à gær kl.] LT', 41481 lastWeek : '[sÃðasta] dddd [kl.] LT', 41482 sameElse : 'L' 41483 }, 41484 relativeTime : { 41485 future : 'eftir %s', 41486 past : 'fyrir %s sÃðan', 41487 s : translate, 41488 ss : translate, 41489 m : translate, 41490 mm : translate, 41491 h : 'klukkustund', 41492 hh : translate, 41493 d : translate, 41494 dd : translate, 41495 M : translate, 41496 MM : translate, 41497 y : translate, 41498 yy : translate 41499 }, 41500 dayOfMonthOrdinalParse: /\d{1,2}\./, 41501 ordinal : '%d.', 41502 week : { 41503 dow : 1, // Monday is the first day of the week. 41504 doy : 4 // The week that contains Jan 4th is the first week of the year. 41505 } 41506 }); 41507 41508 return is; 41509 41510}))); 41511 41512 41513/***/ }), 41514/* 88 */ 41515/***/ (function(module, exports, __webpack_require__) { 41516 41517//! moment.js locale configuration 41518 41519;(function (global, factory) { 41520 true ? factory(__webpack_require__(0)) : 41521 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 41522 factory(global.moment) 41523}(this, (function (moment) { 'use strict'; 41524 41525 41526 var it = moment.defineLocale('it', { 41527 months : 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split('_'), 41528 monthsShort : 'gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic'.split('_'), 41529 weekdays : 'domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato'.split('_'), 41530 weekdaysShort : 'dom_lun_mar_mer_gio_ven_sab'.split('_'), 41531 weekdaysMin : 'do_lu_ma_me_gi_ve_sa'.split('_'), 41532 longDateFormat : { 41533 LT : 'HH:mm', 41534 LTS : 'HH:mm:ss', 41535 L : 'DD/MM/YYYY', 41536 LL : 'D MMMM YYYY', 41537 LLL : 'D MMMM YYYY HH:mm', 41538 LLLL : 'dddd D MMMM YYYY HH:mm' 41539 }, 41540 calendar : { 41541 sameDay: '[Oggi alle] LT', 41542 nextDay: '[Domani alle] LT', 41543 nextWeek: 'dddd [alle] LT', 41544 lastDay: '[Ieri alle] LT', 41545 lastWeek: function () { 41546 switch (this.day()) { 41547 case 0: 41548 return '[la scorsa] dddd [alle] LT'; 41549 default: 41550 return '[lo scorso] dddd [alle] LT'; 41551 } 41552 }, 41553 sameElse: 'L' 41554 }, 41555 relativeTime : { 41556 future : function (s) { 41557 return ((/^[0-9].+$/).test(s) ? 'tra' : 'in') + ' ' + s; 41558 }, 41559 past : '%s fa', 41560 s : 'alcuni secondi', 41561 ss : '%d secondi', 41562 m : 'un minuto', 41563 mm : '%d minuti', 41564 h : 'un\'ora', 41565 hh : '%d ore', 41566 d : 'un giorno', 41567 dd : '%d giorni', 41568 M : 'un mese', 41569 MM : '%d mesi', 41570 y : 'un anno', 41571 yy : '%d anni' 41572 }, 41573 dayOfMonthOrdinalParse : /\d{1,2}º/, 41574 ordinal: '%dº', 41575 week : { 41576 dow : 1, // Monday is the first day of the week. 41577 doy : 4 // The week that contains Jan 4th is the first week of the year. 41578 } 41579 }); 41580 41581 return it; 41582 41583}))); 41584 41585 41586/***/ }), 41587/* 89 */ 41588/***/ (function(module, exports, __webpack_require__) { 41589 41590//! moment.js locale configuration 41591 41592;(function (global, factory) { 41593 true ? factory(__webpack_require__(0)) : 41594 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 41595 factory(global.moment) 41596}(this, (function (moment) { 'use strict'; 41597 41598 41599 var ja = moment.defineLocale('ja', { 41600 months : '1æ_2æ_3æ_4æ_5æ_6æ_7æ_8æ_9æ_10æ_11æ_12æ'.split('_'), 41601 monthsShort : '1æ_2æ_3æ_4æ_5æ_6æ_7æ_8æ_9æ_10æ_11æ_12æ'.split('_'), 41602 weekdays : 'æ¥ææ¥_æææ¥_ç«ææ¥_æ°´ææ¥_æ¨ææ¥_éææ¥_åææ¥'.split('_'), 41603 weekdaysShort : 'æ¥_æ_ç«_æ°´_æ¨_é_å'.split('_'), 41604 weekdaysMin : 'æ¥_æ_ç«_æ°´_æ¨_é_å'.split('_'), 41605 longDateFormat : { 41606 LT : 'HH:mm', 41607 LTS : 'HH:mm:ss', 41608 L : 'YYYY/MM/DD', 41609 LL : 'YYYYå¹´MæDæ¥', 41610 LLL : 'YYYYå¹´MæDæ¥ HH:mm', 41611 LLLL : 'YYYYå¹´MæDæ¥ dddd HH:mm', 41612 l : 'YYYY/MM/DD', 41613 ll : 'YYYYå¹´MæDæ¥', 41614 lll : 'YYYYå¹´MæDæ¥ HH:mm', 41615 llll : 'YYYYå¹´MæDæ¥(ddd) HH:mm' 41616 }, 41617 meridiemParse: /åå|åå¾/i, 41618 isPM : function (input) { 41619 return input === 'åå¾'; 41620 }, 41621 meridiem : function (hour, minute, isLower) { 41622 if (hour < 12) { 41623 return 'åå'; 41624 } else { 41625 return 'åå¾'; 41626 } 41627 }, 41628 calendar : { 41629 sameDay : '[ä»æ¥] LT', 41630 nextDay : '[ææ¥] LT', 41631 nextWeek : function (now) { 41632 if (now.week() < this.week()) { 41633 return '[æ¥é±]dddd LT'; 41634 } else { 41635 return 'dddd LT'; 41636 } 41637 }, 41638 lastDay : '[æ¨æ¥] LT', 41639 lastWeek : function (now) { 41640 if (this.week() < now.week()) { 41641 return '[å é±]dddd LT'; 41642 } else { 41643 return 'dddd LT'; 41644 } 41645 }, 41646 sameElse : 'L' 41647 }, 41648 dayOfMonthOrdinalParse : /\d{1,2}æ¥/, 41649 ordinal : function (number, period) { 41650 switch (period) { 41651 case 'd': 41652 case 'D': 41653 case 'DDD': 41654 return number + 'æ¥'; 41655 default: 41656 return number; 41657 } 41658 }, 41659 relativeTime : { 41660 future : '%så¾', 41661 past : '%så', 41662 s : 'æ°ç§', 41663 ss : '%dç§', 41664 m : '1å', 41665 mm : '%då', 41666 h : '1æé', 41667 hh : '%dæé', 41668 d : '1æ¥', 41669 dd : '%dæ¥', 41670 M : '1ã¶æ', 41671 MM : '%dã¶æ', 41672 y : '1å¹´', 41673 yy : '%då¹´' 41674 } 41675 }); 41676 41677 return ja; 41678 41679}))); 41680 41681 41682/***/ }), 41683/* 90 */ 41684/***/ (function(module, exports, __webpack_require__) { 41685 41686//! moment.js locale configuration 41687 41688;(function (global, factory) { 41689 true ? factory(__webpack_require__(0)) : 41690 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 41691 factory(global.moment) 41692}(this, (function (moment) { 'use strict'; 41693 41694 41695 var jv = moment.defineLocale('jv', { 41696 months : 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_Nopember_Desember'.split('_'), 41697 monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nop_Des'.split('_'), 41698 weekdays : 'Minggu_Senen_Seloso_Rebu_Kemis_Jemuwah_Septu'.split('_'), 41699 weekdaysShort : 'Min_Sen_Sel_Reb_Kem_Jem_Sep'.split('_'), 41700 weekdaysMin : 'Mg_Sn_Sl_Rb_Km_Jm_Sp'.split('_'), 41701 longDateFormat : { 41702 LT : 'HH.mm', 41703 LTS : 'HH.mm.ss', 41704 L : 'DD/MM/YYYY', 41705 LL : 'D MMMM YYYY', 41706 LLL : 'D MMMM YYYY [pukul] HH.mm', 41707 LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm' 41708 }, 41709 meridiemParse: /enjing|siyang|sonten|ndalu/, 41710 meridiemHour : function (hour, meridiem) { 41711 if (hour === 12) { 41712 hour = 0; 41713 } 41714 if (meridiem === 'enjing') { 41715 return hour; 41716 } else if (meridiem === 'siyang') { 41717 return hour >= 11 ? hour : hour + 12; 41718 } else if (meridiem === 'sonten' || meridiem === 'ndalu') { 41719 return hour + 12; 41720 } 41721 }, 41722 meridiem : function (hours, minutes, isLower) { 41723 if (hours < 11) { 41724 return 'enjing'; 41725 } else if (hours < 15) { 41726 return 'siyang'; 41727 } else if (hours < 19) { 41728 return 'sonten'; 41729 } else { 41730 return 'ndalu'; 41731 } 41732 }, 41733 calendar : { 41734 sameDay : '[Dinten puniko pukul] LT', 41735 nextDay : '[Mbenjang pukul] LT', 41736 nextWeek : 'dddd [pukul] LT', 41737 lastDay : '[Kala wingi pukul] LT', 41738 lastWeek : 'dddd [kepengker pukul] LT', 41739 sameElse : 'L' 41740 }, 41741 relativeTime : { 41742 future : 'wonten ing %s', 41743 past : '%s ingkang kepengker', 41744 s : 'sawetawis detik', 41745 ss : '%d detik', 41746 m : 'setunggal menit', 41747 mm : '%d menit', 41748 h : 'setunggal jam', 41749 hh : '%d jam', 41750 d : 'sedinten', 41751 dd : '%d dinten', 41752 M : 'sewulan', 41753 MM : '%d wulan', 41754 y : 'setaun', 41755 yy : '%d taun' 41756 }, 41757 week : { 41758 dow : 1, // Monday is the first day of the week. 41759 doy : 7 // The week that contains Jan 1st is the first week of the year. 41760 } 41761 }); 41762 41763 return jv; 41764 41765}))); 41766 41767 41768/***/ }), 41769/* 91 */ 41770/***/ (function(module, exports, __webpack_require__) { 41771 41772//! moment.js locale configuration 41773 41774;(function (global, factory) { 41775 true ? factory(__webpack_require__(0)) : 41776 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 41777 factory(global.moment) 41778}(this, (function (moment) { 'use strict'; 41779 41780 41781 var ka = moment.defineLocale('ka', { 41782 months : { 41783 standalone: 'áááááá á_ááááá áááá_ááá á¢á_ááá ááá_áááá¡á_ááááá¡á_ááááá¡á_ááááá¡á¢á_á¡áá¥á¢ááááá á_áá¥á¢ááááá á_ááááááá á_áááááááá á'.split('_'), 41784 format: 'áááááá á¡_ááááá áááá¡_ááá á¢á¡_ááá áááá¡_áááá¡á¡_ááááá¡á¡_ááááá¡á¡_ááááá¡á¢á¡_á¡áá¥á¢ááááá á¡_áá¥á¢ááááá á¡_ááááááá á¡_áááááááá á¡'.split('_') 41785 }, 41786 monthsShort : 'ááá_ááá_ááá _ááá _ááá_ááá_ááá_ááá_á¡áá¥_áá¥á¢_ááá_ááá'.split('_'), 41787 weekdays : { 41788 standalone: 'áááá á_áá á¨ááááá_á¡ááá¨ááááá_ááá®á¨ááááá_á®á£áá¨ááááá_ááá áá¡áááá_á¨ááááá'.split('_'), 41789 format: 'áááá áá¡_áá á¨ááááá¡_á¡ááá¨ááááá¡_ááá®á¨ááááá¡_á®á£áá¨ááááá¡_ááá áá¡áááá¡_á¨ááááá¡'.split('_'), 41790 isFormat: /(á¬ááá|á¨ááááá)/ 41791 }, 41792 weekdaysShort : 'ááá_áá á¨_á¡áá_ááá®_á®á£á_ááá _á¨áá'.split('_'), 41793 weekdaysMin : 'áá_áá _á¡á_áá_á®á£_áá_á¨á'.split('_'), 41794 longDateFormat : { 41795 LT : 'h:mm A', 41796 LTS : 'h:mm:ss A', 41797 L : 'DD/MM/YYYY', 41798 LL : 'D MMMM YYYY', 41799 LLL : 'D MMMM YYYY h:mm A', 41800 LLLL : 'dddd, D MMMM YYYY h:mm A' 41801 }, 41802 calendar : { 41803 sameDay : '[áá¦áá¡] LT[-áá]', 41804 nextDay : '[á®ááá] LT[-áá]', 41805 lastDay : '[áá£á¨áá] LT[-áá]', 41806 nextWeek : '[á¨ááááá] dddd LT[-áá]', 41807 lastWeek : '[á¬ááá] dddd LT-áá', 41808 sameElse : 'L' 41809 }, 41810 relativeTime : { 41811 future : function (s) { 41812 return (/(á¬ááá|á¬á£áá|á¡áááá|á¬ááá)/).test(s) ? 41813 s.replace(/á$/, 'á¨á') : 41814 s + 'á¨á'; 41815 }, 41816 past : function (s) { 41817 if ((/(á¬ááá|á¬á£áá|á¡áááá|áá¦á|ááá)/).test(s)) { 41818 return s.replace(/(á|á)$/, 'áá¡ á¬áá'); 41819 } 41820 if ((/á¬ááá/).test(s)) { 41821 return s.replace(/á¬ááá$/, 'á¬ááá¡ á¬áá'); 41822 } 41823 }, 41824 s : 'á áááááááá á¬ááá', 41825 ss : '%d á¬ááá', 41826 m : 'á¬á£áá', 41827 mm : '%d á¬á£áá', 41828 h : 'á¡áááá', 41829 hh : '%d á¡áááá', 41830 d : 'áá¦á', 41831 dd : '%d áá¦á', 41832 M : 'ááá', 41833 MM : '%d ááá', 41834 y : 'á¬ááá', 41835 yy : '%d á¬ááá' 41836 }, 41837 dayOfMonthOrdinalParse: /0|1-áá|áá-\d{1,2}|\d{1,2}-á/, 41838 ordinal : function (number) { 41839 if (number === 0) { 41840 return number; 41841 } 41842 if (number === 1) { 41843 return number + '-áá'; 41844 } 41845 if ((number < 20) || (number <= 100 && (number % 20 === 0)) || (number % 100 === 0)) { 41846 return 'áá-' + number; 41847 } 41848 return number + '-á'; 41849 }, 41850 week : { 41851 dow : 1, 41852 doy : 7 41853 } 41854 }); 41855 41856 return ka; 41857 41858}))); 41859 41860 41861/***/ }), 41862/* 92 */ 41863/***/ (function(module, exports, __webpack_require__) { 41864 41865//! moment.js locale configuration 41866 41867;(function (global, factory) { 41868 true ? factory(__webpack_require__(0)) : 41869 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 41870 factory(global.moment) 41871}(this, (function (moment) { 'use strict'; 41872 41873 41874 var suffixes = { 41875 0: '-ÑÑ', 41876 1: '-ÑÑ', 41877 2: '-ÑÑ', 41878 3: '-ÑÑ', 41879 4: '-ÑÑ', 41880 5: '-ÑÑ', 41881 6: '-ÑÑ', 41882 7: '-ÑÑ', 41883 8: '-ÑÑ', 41884 9: '-ÑÑ', 41885 10: '-ÑÑ', 41886 20: '-ÑÑ', 41887 30: '-ÑÑ', 41888 40: '-ÑÑ', 41889 50: '-ÑÑ', 41890 60: '-ÑÑ', 41891 70: '-ÑÑ', 41892 80: '-ÑÑ', 41893 90: '-ÑÑ', 41894 100: '-ÑÑ' 41895 }; 41896 41897 var kk = moment.defineLocale('kk', { 41898 months : 'ÒаңÑаÑ_аÒпан_наÑÑÑз_ÑÓÑÑÑ_мамÑÑ_маÑÑÑм_ÑÑлде_ÑамÑз_ÒÑÑкүйек_Òазан_ÒаÑаÑа_желÑоÒÑан'.split('_'), 41899 monthsShort : 'Òаң_аÒп_наÑ_ÑÓÑ_мам_маÑ_ÑÑл_Ñам_ÒÑÑ_Òаз_ÒаÑ_жел'.split('_'), 41900 weekdays : 'жекÑенбÑ_дүйÑенбÑ_ÑейÑенбÑ_ÑÓÑÑенбÑ_бейÑенбÑ_жұма_ÑенбÑ'.split('_'), 41901 weekdaysShort : 'жек_дүй_Ñей_ÑÓÑ_бей_жұм_Ñен'.split('_'), 41902 weekdaysMin : 'жк_дй_Ñй_ÑÑ_бй_жм_Ñн'.split('_'), 41903 longDateFormat : { 41904 LT : 'HH:mm', 41905 LTS : 'HH:mm:ss', 41906 L : 'DD.MM.YYYY', 41907 LL : 'D MMMM YYYY', 41908 LLL : 'D MMMM YYYY HH:mm', 41909 LLLL : 'dddd, D MMMM YYYY HH:mm' 41910 }, 41911 calendar : { 41912 sameDay : '[ÐүгÑн ÑаÒаÑ] LT', 41913 nextDay : '[ÐÑÑең ÑаÒаÑ] LT', 41914 nextWeek : 'dddd [ÑаÒаÑ] LT', 41915 lastDay : '[ÐеÑе ÑаÒаÑ] LT', 41916 lastWeek : '[Ó¨Ñкен апÑанÑÒ£] dddd [ÑаÒаÑ] LT', 41917 sameElse : 'L' 41918 }, 41919 relativeTime : { 41920 future : '%s ÑÑÑнде', 41921 past : '%s бұÑÑн', 41922 s : 'бÑÑнеÑе ÑекÑнд', 41923 ss : '%d ÑекÑнд', 41924 m : 'бÑÑ Ð¼Ð¸Ð½ÑÑ', 41925 mm : '%d минÑÑ', 41926 h : 'бÑÑ ÑаÒаÑ', 41927 hh : '%d ÑаÒаÑ', 41928 d : 'бÑÑ ÐºÒ¯Ð½', 41929 dd : '%d күн', 41930 M : 'бÑÑ Ð°Ð¹', 41931 MM : '%d ай', 41932 y : 'бÑÑ Ð¶Ñл', 41933 yy : '%d жÑл' 41934 }, 41935 dayOfMonthOrdinalParse: /\d{1,2}-(ÑÑ|ÑÑ)/, 41936 ordinal : function (number) { 41937 var a = number % 10, 41938 b = number >= 100 ? 100 : null; 41939 return number + (suffixes[number] || suffixes[a] || suffixes[b]); 41940 }, 41941 week : { 41942 dow : 1, // Monday is the first day of the week. 41943 doy : 7 // The week that contains Jan 1st is the first week of the year. 41944 } 41945 }); 41946 41947 return kk; 41948 41949}))); 41950 41951 41952/***/ }), 41953/* 93 */ 41954/***/ (function(module, exports, __webpack_require__) { 41955 41956//! moment.js locale configuration 41957 41958;(function (global, factory) { 41959 true ? factory(__webpack_require__(0)) : 41960 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 41961 factory(global.moment) 41962}(this, (function (moment) { 'use strict'; 41963 41964 41965 var symbolMap = { 41966 '1': 'á¡', 41967 '2': 'á¢', 41968 '3': 'á£', 41969 '4': 'á¤', 41970 '5': 'á¥', 41971 '6': 'á¦', 41972 '7': 'á§', 41973 '8': 'á¨', 41974 '9': 'á©', 41975 '0': 'á ' 41976 }, numberMap = { 41977 'á¡': '1', 41978 'á¢': '2', 41979 'á£': '3', 41980 'á¤': '4', 41981 'á¥': '5', 41982 'á¦': '6', 41983 'á§': '7', 41984 'á¨': '8', 41985 'á©': '9', 41986 'á ': '0' 41987 }; 41988 41989 var km = moment.defineLocale('km', { 41990 months: 'áááá¶_áá»áááá_áá¸áá¶_áááá¶_á§ááá¶_áá·áá»áá¶_áááááá¶_áá¸á á¶_ááááá¶_áá»áá¶_áá·á ááá·áá¶_áááá¼'.split( 41991 '_' 41992 ), 41993 monthsShort: 'áááá¶_áá»áááá_áá¸áá¶_áááá¶_á§ááá¶_áá·áá»áá¶_áááááá¶_áá¸á á¶_ááááá¶_áá»áá¶_áá·á ááá·áá¶_áááá¼'.split( 41994 '_' 41995 ), 41996 weekdays: 'á¢á¶áá·ááá_á áááá_á¢áááá¶á_áá»á_áááá ááááá·á_áá»ááá_áá áá'.split('_'), 41997 weekdaysShort: 'á¢á¶_á _á¢_á_ááá_áá»_á'.split('_'), 41998 weekdaysMin: 'á¢á¶_á _á¢_á_ááá_áá»_á'.split('_'), 41999 weekdaysParseExact: true, 42000 longDateFormat: { 42001 LT: 'HH:mm', 42002 LTS: 'HH:mm:ss', 42003 L: 'DD/MM/YYYY', 42004 LL: 'D MMMM YYYY', 42005 LLL: 'D MMMM YYYY HH:mm', 42006 LLLL: 'dddd, D MMMM YYYY HH:mm' 42007 }, 42008 meridiemParse: /áááá¹á|áááá¶á /, 42009 isPM: function (input) { 42010 return input === 'áááá¶á '; 42011 }, 42012 meridiem: function (hour, minute, isLower) { 42013 if (hour < 12) { 42014 return 'áááá¹á'; 42015 } else { 42016 return 'áááá¶á '; 42017 } 42018 }, 42019 calendar: { 42020 sameDay: '[ááááááá áááá] LT', 42021 nextDay: '[ááá¢áá áááá] LT', 42022 nextWeek: 'dddd [áááá] LT', 42023 lastDay: '[áááá·ááá·á áááá] LT', 42024 lastWeek: 'dddd [ááááá¶á ááá»á] [áááá] LT', 42025 sameElse: 'L' 42026 }, 42027 relativeTime: { 42028 future: '%sááá', 42029 past: '%sáá»á', 42030 s: 'ááá»áááá¶ááá·áá¶áá¸', 42031 ss: '%d áá·áá¶áá¸', 42032 m: 'áá½ááá¶áá¸', 42033 mm: '%d áá¶áá¸', 42034 h: 'áá½ááááá', 42035 hh: '%d áááá', 42036 d: 'áá½ááááá', 42037 dd: '%d áááá', 42038 M: 'áá½ááá', 42039 MM: '%d áá', 42040 y: 'áá½ááááá¶á', 42041 yy: '%d áááá¶á' 42042 }, 42043 dayOfMonthOrdinalParse : /áá¸\d{1,2}/, 42044 ordinal : 'áá¸%d', 42045 preparse: function (string) { 42046 return string.replace(/[á¡á¢á£á¤á¥á¦á§á¨á©á ]/g, function (match) { 42047 return numberMap[match]; 42048 }); 42049 }, 42050 postformat: function (string) { 42051 return string.replace(/\d/g, function (match) { 42052 return symbolMap[match]; 42053 }); 42054 }, 42055 week: { 42056 dow: 1, // Monday is the first day of the week. 42057 doy: 4 // The week that contains Jan 4th is the first week of the year. 42058 } 42059 }); 42060 42061 return km; 42062 42063}))); 42064 42065 42066/***/ }), 42067/* 94 */ 42068/***/ (function(module, exports, __webpack_require__) { 42069 42070//! moment.js locale configuration 42071 42072;(function (global, factory) { 42073 true ? factory(__webpack_require__(0)) : 42074 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 42075 factory(global.moment) 42076}(this, (function (moment) { 'use strict'; 42077 42078 42079 var symbolMap = { 42080 '1': '೧', 42081 '2': '೨', 42082 '3': '೩', 42083 '4': '೪', 42084 '5': '೫', 42085 '6': '೬', 42086 '7': 'à³', 42087 '8': 'à³®', 42088 '9': '೯', 42089 '0': '೦' 42090 }, 42091 numberMap = { 42092 '೧': '1', 42093 '೨': '2', 42094 '೩': '3', 42095 '೪': '4', 42096 '೫': '5', 42097 '೬': '6', 42098 'à³': '7', 42099 'à³®': '8', 42100 '೯': '9', 42101 '೦': '0' 42102 }; 42103 42104 var kn = moment.defineLocale('kn', { 42105 months : 'à²à²¨à²µà²°à²¿_ಫà³à²¬à³à²°à²µà²°à²¿_ಮಾರà³à²à³_à²à²ªà³à²°à²¿à²²à³_ಮà³à³_à²à³à²¨à³_à²à³à²²à³à³_à²à²à²¸à³à²à³_ಸà³à²ªà³à²à³à²à²¬à²°à³_ಠà²à³à²à³à³à³à²¬à²°à³_ನವà³à²à²¬à²°à³_ಡಿಸà³à²à²¬à²°à³'.split('_'), 42106 monthsShort : 'à²à²¨_ಫà³à²¬à³à²°_ಮಾರà³à²à³_à²à²ªà³à²°à²¿à²²à³_ಮà³à³_à²à³à²¨à³_à²à³à²²à³à³_à²à²à²¸à³à²à³_ಸà³à²ªà³à²à³à²_ಠà²à³à²à³à³à³_ನವà³à²_ಡಿಸà³à²'.split('_'), 42107 monthsParseExact: true, 42108 weekdays : 'à²à²¾à²¨à³à²µà²¾à²°_ಸà³à³à³à²®à²µà²¾à²°_ಮà²à²à²³à²µà²¾à²°_ಬà³à²§à²µà²¾à²°_à²à³à²°à³à²µà²¾à²°_ಶà³à²à³à²°à²µà²¾à²°_ಶನಿವಾರ'.split('_'), 42109 weekdaysShort : 'à²à²¾à²¨à³_ಸà³à³à³à²®_ಮà²à²à²³_ಬà³à²§_à²à³à²°à³_ಶà³à²à³à²°_ಶನಿ'.split('_'), 42110 weekdaysMin : 'à²à²¾_ಸà³à³à³_ಮà²_ಬà³_à²à³_ಶà³_ಶ'.split('_'), 42111 longDateFormat : { 42112 LT : 'A h:mm', 42113 LTS : 'A h:mm:ss', 42114 L : 'DD/MM/YYYY', 42115 LL : 'D MMMM YYYY', 42116 LLL : 'D MMMM YYYY, A h:mm', 42117 LLLL : 'dddd, D MMMM YYYY, A h:mm' 42118 }, 42119 calendar : { 42120 sameDay : '[à²à²à²¦à³] LT', 42121 nextDay : '[ನಾಳà³] LT', 42122 nextWeek : 'dddd, LT', 42123 lastDay : '[ನಿನà³à²¨à³] LT', 42124 lastWeek : '[à²à³à³à²¨à³à²¯] dddd, LT', 42125 sameElse : 'L' 42126 }, 42127 relativeTime : { 42128 future : '%s ನà²à²¤à²°', 42129 past : '%s ಹಿà²à²¦à³', 42130 s : 'à²à³à²²à²µà³ à²à³à²·à²£à²à²³à³', 42131 ss : '%d ಸà³à²à³à²à²¡à³à²à²³à³', 42132 m : 'à²à²à²¦à³ ನಿಮಿಷ', 42133 mm : '%d ನಿಮಿಷ', 42134 h : 'à²à²à²¦à³ à²à²à²à³', 42135 hh : '%d à²à²à²à³', 42136 d : 'à²à²à²¦à³ ದಿನ', 42137 dd : '%d ದಿನ', 42138 M : 'à²à²à²¦à³ ತಿà²à²à²³à³', 42139 MM : '%d ತಿà²à²à²³à³', 42140 y : 'à²à²à²¦à³ ವರà³à²·', 42141 yy : '%d ವರà³à²·' 42142 }, 42143 preparse: function (string) { 42144 return string.replace(/[೧೨೩೪೫೬à³à³®à³¯à³¦]/g, function (match) { 42145 return numberMap[match]; 42146 }); 42147 }, 42148 postformat: function (string) { 42149 return string.replace(/\d/g, function (match) { 42150 return symbolMap[match]; 42151 }); 42152 }, 42153 meridiemParse: /ರಾತà³à²°à²¿|ಬà³à²³à²¿à²à³à²à³|ಮಧà³à²¯à²¾à²¹à³à²¨|ಸà²à²à³/, 42154 meridiemHour : function (hour, meridiem) { 42155 if (hour === 12) { 42156 hour = 0; 42157 } 42158 if (meridiem === 'ರಾತà³à²°à²¿') { 42159 return hour < 4 ? hour : hour + 12; 42160 } else if (meridiem === 'ಬà³à²³à²¿à²à³à²à³') { 42161 return hour; 42162 } else if (meridiem === 'ಮಧà³à²¯à²¾à²¹à³à²¨') { 42163 return hour >= 10 ? hour : hour + 12; 42164 } else if (meridiem === 'ಸà²à²à³') { 42165 return hour + 12; 42166 } 42167 }, 42168 meridiem : function (hour, minute, isLower) { 42169 if (hour < 4) { 42170 return 'ರಾತà³à²°à²¿'; 42171 } else if (hour < 10) { 42172 return 'ಬà³à²³à²¿à²à³à²à³'; 42173 } else if (hour < 17) { 42174 return 'ಮಧà³à²¯à²¾à²¹à³à²¨'; 42175 } else if (hour < 20) { 42176 return 'ಸà²à²à³'; 42177 } else { 42178 return 'ರಾತà³à²°à²¿'; 42179 } 42180 }, 42181 dayOfMonthOrdinalParse: /\d{1,2}(ನà³à³)/, 42182 ordinal : function (number) { 42183 return number + 'ನà³à³'; 42184 }, 42185 week : { 42186 dow : 0, // Sunday is the first day of the week. 42187 doy : 6 // The week that contains Jan 1st is the first week of the year. 42188 } 42189 }); 42190 42191 return kn; 42192 42193}))); 42194 42195 42196/***/ }), 42197/* 95 */ 42198/***/ (function(module, exports, __webpack_require__) { 42199 42200//! moment.js locale configuration 42201 42202;(function (global, factory) { 42203 true ? factory(__webpack_require__(0)) : 42204 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 42205 factory(global.moment) 42206}(this, (function (moment) { 'use strict'; 42207 42208 42209 var ko = moment.defineLocale('ko', { 42210 months : '1ì_2ì_3ì_4ì_5ì_6ì_7ì_8ì_9ì_10ì_11ì_12ì'.split('_'), 42211 monthsShort : '1ì_2ì_3ì_4ì_5ì_6ì_7ì_8ì_9ì_10ì_11ì_12ì'.split('_'), 42212 weekdays : 'ì¼ìì¼_ììì¼_íìì¼_ììì¼_목ìì¼_ê¸ìì¼_í ìì¼'.split('_'), 42213 weekdaysShort : 'ì¼_ì_í_ì_목_ê¸_í '.split('_'), 42214 weekdaysMin : 'ì¼_ì_í_ì_목_ê¸_í '.split('_'), 42215 longDateFormat : { 42216 LT : 'A h:mm', 42217 LTS : 'A h:mm:ss', 42218 L : 'YYYY.MM.DD.', 42219 LL : 'YYYYë MMMM Dì¼', 42220 LLL : 'YYYYë MMMM Dì¼ A h:mm', 42221 LLLL : 'YYYYë MMMM Dì¼ dddd A h:mm', 42222 l : 'YYYY.MM.DD.', 42223 ll : 'YYYYë MMMM Dì¼', 42224 lll : 'YYYYë MMMM Dì¼ A h:mm', 42225 llll : 'YYYYë MMMM Dì¼ dddd A h:mm' 42226 }, 42227 calendar : { 42228 sameDay : 'ì¤ë LT', 42229 nextDay : 'ë´ì¼ LT', 42230 nextWeek : 'dddd LT', 42231 lastDay : 'ì´ì LT', 42232 lastWeek : 'ì§ë주 dddd LT', 42233 sameElse : 'L' 42234 }, 42235 relativeTime : { 42236 future : '%s í', 42237 past : '%s ì ', 42238 s : 'ëª ì´', 42239 ss : '%dì´', 42240 m : '1ë¶', 42241 mm : '%dë¶', 42242 h : 'í ìê°', 42243 hh : '%dìê°', 42244 d : 'í루', 42245 dd : '%dì¼', 42246 M : 'í ë¬', 42247 MM : '%dë¬', 42248 y : 'ì¼ ë ', 42249 yy : '%dë ' 42250 }, 42251 dayOfMonthOrdinalParse : /\d{1,2}(ì¼|ì|주)/, 42252 ordinal : function (number, period) { 42253 switch (period) { 42254 case 'd': 42255 case 'D': 42256 case 'DDD': 42257 return number + 'ì¼'; 42258 case 'M': 42259 return number + 'ì'; 42260 case 'w': 42261 case 'W': 42262 return number + '주'; 42263 default: 42264 return number; 42265 } 42266 }, 42267 meridiemParse : /ì¤ì |ì¤í/, 42268 isPM : function (token) { 42269 return token === 'ì¤í'; 42270 }, 42271 meridiem : function (hour, minute, isUpper) { 42272 return hour < 12 ? 'ì¤ì ' : 'ì¤í'; 42273 } 42274 }); 42275 42276 return ko; 42277 42278}))); 42279 42280 42281/***/ }), 42282/* 96 */ 42283/***/ (function(module, exports, __webpack_require__) { 42284 42285//! moment.js locale configuration 42286 42287;(function (global, factory) { 42288 true ? factory(__webpack_require__(0)) : 42289 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 42290 factory(global.moment) 42291}(this, (function (moment) { 'use strict'; 42292 42293 42294 var suffixes = { 42295 0: '-ÑÒ¯', 42296 1: '-Ñи', 42297 2: '-Ñи', 42298 3: '-ÑÒ¯', 42299 4: '-ÑÒ¯', 42300 5: '-Ñи', 42301 6: '-ÑÑ', 42302 7: '-Ñи', 42303 8: '-Ñи', 42304 9: '-ÑÑ', 42305 10: '-ÑÑ', 42306 20: '-ÑÑ', 42307 30: '-ÑÑ', 42308 40: '-ÑÑ', 42309 50: '-ÑÒ¯', 42310 60: '-ÑÑ', 42311 70: '-Ñи', 42312 80: '-Ñи', 42313 90: '-ÑÑ', 42314 100: '-ÑÒ¯' 42315 }; 42316 42317 var ky = moment.defineLocale('ky', { 42318 months : 'ÑнваÑÑ_ÑевÑалÑ_маÑÑ_апÑелÑ_май_иÑнÑ_иÑлÑ_авгÑÑÑ_ÑенÑÑбÑÑ_окÑÑбÑÑ_ноÑбÑÑ_декабÑÑ'.split('_'), 42319 monthsShort : 'Ñнв_Ñев_маÑÑ_апÑ_май_иÑнÑ_иÑлÑ_авг_Ñен_окÑ_ноÑ_дек'.split('_'), 42320 weekdays : 'ÐекÑемби_ÐүйÑөмбү_ШейÑемби_ШаÑÑемби_ÐейÑемби_ÐÑма_ÐÑемби'.split('_'), 42321 weekdaysShort : 'Ðек_Ðүй_Шей_ШаÑ_Ðей_ÐÑм_ÐÑе'.split('_'), 42322 weekdaysMin : 'Ðк_Ðй_Шй_ШÑ_Ðй_Ðм_ÐÑ'.split('_'), 42323 longDateFormat : { 42324 LT : 'HH:mm', 42325 LTS : 'HH:mm:ss', 42326 L : 'DD.MM.YYYY', 42327 LL : 'D MMMM YYYY', 42328 LLL : 'D MMMM YYYY HH:mm', 42329 LLLL : 'dddd, D MMMM YYYY HH:mm' 42330 }, 42331 calendar : { 42332 sameDay : '[Ðүгүн ÑааÑ] LT', 42333 nextDay : '[ÐÑÑең ÑааÑ] LT', 42334 nextWeek : 'dddd [ÑааÑ] LT', 42335 lastDay : '[ÐеÑе ÑааÑ] LT', 42336 lastWeek : '[Ó¨Ñкен апÑанÑн] dddd [күнү] [ÑааÑ] LT', 42337 sameElse : 'L' 42338 }, 42339 relativeTime : { 42340 future : '%s иÑинде', 42341 past : '%s мÑÑÑн', 42342 s : 'биÑнеÑе ÑекÑнд', 42343 ss : '%d ÑекÑнд', 42344 m : 'Ð±Ð¸Ñ Ð¼Ò¯Ð½Ó©Ñ', 42345 mm : '%d мүнөÑ', 42346 h : 'Ð±Ð¸Ñ ÑааÑ', 42347 hh : '%d ÑааÑ', 42348 d : 'Ð±Ð¸Ñ ÐºÒ¯Ð½', 42349 dd : '%d күн', 42350 M : 'Ð±Ð¸Ñ Ð°Ð¹', 42351 MM : '%d ай', 42352 y : 'Ð±Ð¸Ñ Ð¶Ñл', 42353 yy : '%d жÑл' 42354 }, 42355 dayOfMonthOrdinalParse: /\d{1,2}-(Ñи|ÑÑ|ÑÒ¯|ÑÑ)/, 42356 ordinal : function (number) { 42357 var a = number % 10, 42358 b = number >= 100 ? 100 : null; 42359 return number + (suffixes[number] || suffixes[a] || suffixes[b]); 42360 }, 42361 week : { 42362 dow : 1, // Monday is the first day of the week. 42363 doy : 7 // The week that contains Jan 1st is the first week of the year. 42364 } 42365 }); 42366 42367 return ky; 42368 42369}))); 42370 42371 42372/***/ }), 42373/* 97 */ 42374/***/ (function(module, exports, __webpack_require__) { 42375 42376//! moment.js locale configuration 42377 42378;(function (global, factory) { 42379 true ? factory(__webpack_require__(0)) : 42380 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 42381 factory(global.moment) 42382}(this, (function (moment) { 'use strict'; 42383 42384 42385 function processRelativeTime(number, withoutSuffix, key, isFuture) { 42386 var format = { 42387 'm': ['eng Minutt', 'enger Minutt'], 42388 'h': ['eng Stonn', 'enger Stonn'], 42389 'd': ['een Dag', 'engem Dag'], 42390 'M': ['ee Mount', 'engem Mount'], 42391 'y': ['ee Joer', 'engem Joer'] 42392 }; 42393 return withoutSuffix ? format[key][0] : format[key][1]; 42394 } 42395 function processFutureTime(string) { 42396 var number = string.substr(0, string.indexOf(' ')); 42397 if (eifelerRegelAppliesToNumber(number)) { 42398 return 'a ' + string; 42399 } 42400 return 'an ' + string; 42401 } 42402 function processPastTime(string) { 42403 var number = string.substr(0, string.indexOf(' ')); 42404 if (eifelerRegelAppliesToNumber(number)) { 42405 return 'viru ' + string; 42406 } 42407 return 'virun ' + string; 42408 } 42409 /** 42410 * Returns true if the word before the given number loses the '-n' ending. 42411 * e.g. 'an 10 Deeg' but 'a 5 Deeg' 42412 * 42413 * @param number {integer} 42414 * @returns {boolean} 42415 */ 42416 function eifelerRegelAppliesToNumber(number) { 42417 number = parseInt(number, 10); 42418 if (isNaN(number)) { 42419 return false; 42420 } 42421 if (number < 0) { 42422 // Negative Number --> always true 42423 return true; 42424 } else if (number < 10) { 42425 // Only 1 digit 42426 if (4 <= number && number <= 7) { 42427 return true; 42428 } 42429 return false; 42430 } else if (number < 100) { 42431 // 2 digits 42432 var lastDigit = number % 10, firstDigit = number / 10; 42433 if (lastDigit === 0) { 42434 return eifelerRegelAppliesToNumber(firstDigit); 42435 } 42436 return eifelerRegelAppliesToNumber(lastDigit); 42437 } else if (number < 10000) { 42438 // 3 or 4 digits --> recursively check first digit 42439 while (number >= 10) { 42440 number = number / 10; 42441 } 42442 return eifelerRegelAppliesToNumber(number); 42443 } else { 42444 // Anything larger than 4 digits: recursively check first n-3 digits 42445 number = number / 1000; 42446 return eifelerRegelAppliesToNumber(number); 42447 } 42448 } 42449 42450 var lb = moment.defineLocale('lb', { 42451 months: 'Januar_Februar_Mäerz_Abrëll_Mee_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'), 42452 monthsShort: 'Jan._Febr._Mrz._Abr._Mee_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'), 42453 monthsParseExact : true, 42454 weekdays: 'Sonndeg_Méindeg_Dënschdeg_Mëttwoch_Donneschdeg_Freideg_Samschdeg'.split('_'), 42455 weekdaysShort: 'So._Mé._Dë._Më._Do._Fr._Sa.'.split('_'), 42456 weekdaysMin: 'So_Mé_Dë_Më_Do_Fr_Sa'.split('_'), 42457 weekdaysParseExact : true, 42458 longDateFormat: { 42459 LT: 'H:mm [Auer]', 42460 LTS: 'H:mm:ss [Auer]', 42461 L: 'DD.MM.YYYY', 42462 LL: 'D. MMMM YYYY', 42463 LLL: 'D. MMMM YYYY H:mm [Auer]', 42464 LLLL: 'dddd, D. MMMM YYYY H:mm [Auer]' 42465 }, 42466 calendar: { 42467 sameDay: '[Haut um] LT', 42468 sameElse: 'L', 42469 nextDay: '[Muer um] LT', 42470 nextWeek: 'dddd [um] LT', 42471 lastDay: '[Gëschter um] LT', 42472 lastWeek: function () { 42473 // Different date string for 'Dënschdeg' (Tuesday) and 'Donneschdeg' (Thursday) due to phonological rule 42474 switch (this.day()) { 42475 case 2: 42476 case 4: 42477 return '[Leschten] dddd [um] LT'; 42478 default: 42479 return '[Leschte] dddd [um] LT'; 42480 } 42481 } 42482 }, 42483 relativeTime : { 42484 future : processFutureTime, 42485 past : processPastTime, 42486 s : 'e puer Sekonnen', 42487 ss : '%d Sekonnen', 42488 m : processRelativeTime, 42489 mm : '%d Minutten', 42490 h : processRelativeTime, 42491 hh : '%d Stonnen', 42492 d : processRelativeTime, 42493 dd : '%d Deeg', 42494 M : processRelativeTime, 42495 MM : '%d Méint', 42496 y : processRelativeTime, 42497 yy : '%d Joer' 42498 }, 42499 dayOfMonthOrdinalParse: /\d{1,2}\./, 42500 ordinal: '%d.', 42501 week: { 42502 dow: 1, // Monday is the first day of the week. 42503 doy: 4 // The week that contains Jan 4th is the first week of the year. 42504 } 42505 }); 42506 42507 return lb; 42508 42509}))); 42510 42511 42512/***/ }), 42513/* 98 */ 42514/***/ (function(module, exports, __webpack_require__) { 42515 42516//! moment.js locale configuration 42517 42518;(function (global, factory) { 42519 true ? factory(__webpack_require__(0)) : 42520 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 42521 factory(global.moment) 42522}(this, (function (moment) { 'use strict'; 42523 42524 42525 var lo = moment.defineLocale('lo', { 42526 months : 'ມັàºàºàºàº_àºàº¸àº¡àºàº²_ມີàºàº²_à»àº¡àºªàº²_àºàº¶àºàºªàº°àºàº²_ມິàºàº¸àºàº²_àºà»àº¥àº°àºàº»àº_ສິàºàº«àº²_àºàº±àºàºàº²_àºàº¸àº¥àº²_àºàº°àºàº´àº_àºàº±àºàº§àº²'.split('_'), 42527 monthsShort : 'ມັàºàºàºàº_àºàº¸àº¡àºàº²_ມີàºàº²_à»àº¡àºªàº²_àºàº¶àºàºªàº°àºàº²_ມິàºàº¸àºàº²_àºà»àº¥àº°àºàº»àº_ສິàºàº«àº²_àºàº±àºàºàº²_àºàº¸àº¥àº²_àºàº°àºàº´àº_àºàº±àºàº§àº²'.split('_'), 42528 weekdays : 'àºàº²àºàº´àº_àºàº±àº_àºàº±àºàºàº²àº_àºàº¸àº_àºàº°àº«àº±àº_ສຸàº_à»àºªàº»àº²'.split('_'), 42529 weekdaysShort : 'àºàº´àº_àºàº±àº_àºàº±àºàºàº²àº_àºàº¸àº_àºàº°àº«àº±àº_ສຸàº_à»àºªàº»àº²'.split('_'), 42530 weekdaysMin : 'àº_àº_àºàº_àº_àºàº«_ສàº_ສ'.split('_'), 42531 weekdaysParseExact : true, 42532 longDateFormat : { 42533 LT : 'HH:mm', 42534 LTS : 'HH:mm:ss', 42535 L : 'DD/MM/YYYY', 42536 LL : 'D MMMM YYYY', 42537 LLL : 'D MMMM YYYY HH:mm', 42538 LLLL : 'ວັàºdddd D MMMM YYYY HH:mm' 42539 }, 42540 meridiemParse: /àºàºàºà»àºàº»à»àº²|àºàºàºà»àº¥àº/, 42541 isPM: function (input) { 42542 return input === 'àºàºàºà»àº¥àº'; 42543 }, 42544 meridiem : function (hour, minute, isLower) { 42545 if (hour < 12) { 42546 return 'àºàºàºà»àºàº»à»àº²'; 42547 } else { 42548 return 'àºàºàºà»àº¥àº'; 42549 } 42550 }, 42551 calendar : { 42552 sameDay : '[ມືà»àºàºµà»à»àº§àº¥àº²] LT', 42553 nextDay : '[ມືà»àºàº·à»àºà»àº§àº¥àº²] LT', 42554 nextWeek : '[ວັàº]dddd[à»à»àº²à»àº§àº¥àº²] LT', 42555 lastDay : '[ມືà»àº§àº²àºàºàºµà»à»àº§àº¥àº²] LT', 42556 lastWeek : '[ວັàº]dddd[à»àº¥à»àº§àºàºµà»à»àº§àº¥àº²] LT', 42557 sameElse : 'L' 42558 }, 42559 relativeTime : { 42560 future : 'àºàºµàº %s', 42561 past : '%sàºà»àº²àºàº¡àº²', 42562 s : 'àºà»à»à»àºàº»à»àº²à»àºàº§àº´àºàº²àºàºµ', 42563 ss : '%d ວິàºàº²àºàºµ' , 42564 m : '1 àºàº²àºàºµ', 42565 mm : '%d àºàº²àºàºµ', 42566 h : '1 àºàº»à»àº§à»àº¡àº', 42567 hh : '%d àºàº»à»àº§à»àº¡àº', 42568 d : '1 ມືà»', 42569 dd : '%d ມືà»', 42570 M : '1 à»àºàº·àºàº', 42571 MM : '%d à»àºàº·àºàº', 42572 y : '1 àºàºµ', 42573 yy : '%d àºàºµ' 42574 }, 42575 dayOfMonthOrdinalParse: /(àºàºµà»)\d{1,2}/, 42576 ordinal : function (number) { 42577 return 'àºàºµà»' + number; 42578 } 42579 }); 42580 42581 return lo; 42582 42583}))); 42584 42585 42586/***/ }), 42587/* 99 */ 42588/***/ (function(module, exports, __webpack_require__) { 42589 42590//! moment.js locale configuration 42591 42592;(function (global, factory) { 42593 true ? factory(__webpack_require__(0)) : 42594 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 42595 factory(global.moment) 42596}(this, (function (moment) { 'use strict'; 42597 42598 42599 var units = { 42600 'ss' : 'sekundÄ_sekundžių_sekundes', 42601 'm' : 'minutÄ_minutÄs_minutÄ', 42602 'mm': 'minutÄs_minuÄių_minutes', 42603 'h' : 'valanda_valandos_valandÄ ', 42604 'hh': 'valandos_valandų_valandas', 42605 'd' : 'diena_dienos_dienÄ ', 42606 'dd': 'dienos_dienų_dienas', 42607 'M' : 'mÄnuo_mÄnesio_mÄnesį', 42608 'MM': 'mÄnesiai_mÄnesių_mÄnesius', 42609 'y' : 'metai_metų_metus', 42610 'yy': 'metai_metų_metus' 42611 }; 42612 function translateSeconds(number, withoutSuffix, key, isFuture) { 42613 if (withoutSuffix) { 42614 return 'kelios sekundÄs'; 42615 } else { 42616 return isFuture ? 'kelių sekundžių' : 'kelias sekundes'; 42617 } 42618 } 42619 function translateSingular(number, withoutSuffix, key, isFuture) { 42620 return withoutSuffix ? forms(key)[0] : (isFuture ? forms(key)[1] : forms(key)[2]); 42621 } 42622 function special(number) { 42623 return number % 10 === 0 || (number > 10 && number < 20); 42624 } 42625 function forms(key) { 42626 return units[key].split('_'); 42627 } 42628 function translate(number, withoutSuffix, key, isFuture) { 42629 var result = number + ' '; 42630 if (number === 1) { 42631 return result + translateSingular(number, withoutSuffix, key[0], isFuture); 42632 } else if (withoutSuffix) { 42633 return result + (special(number) ? forms(key)[1] : forms(key)[0]); 42634 } else { 42635 if (isFuture) { 42636 return result + forms(key)[1]; 42637 } else { 42638 return result + (special(number) ? forms(key)[1] : forms(key)[2]); 42639 } 42640 } 42641 } 42642 var lt = moment.defineLocale('lt', { 42643 months : { 42644 format: 'sausio_vasario_kovo_balandžio_gegužÄs_birželio_liepos_rugpjÅ«Äio_rugsÄjo_spalio_lapkriÄio_gruodžio'.split('_'), 42645 standalone: 'sausis_vasaris_kovas_balandis_gegužÄ_birželis_liepa_rugpjÅ«tis_rugsÄjis_spalis_lapkritis_gruodis'.split('_'), 42646 isFormat: /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?|MMMM?(\[[^\[\]]*\]|\s)+D[oD]?/ 42647 }, 42648 monthsShort : 'sau_vas_kov_bal_geg_bir_lie_rgp_rgs_spa_lap_grd'.split('_'), 42649 weekdays : { 42650 format: 'sekmadienį_pirmadienį_antradienį_treÄiadienį_ketvirtadienį_penktadienį_Å¡eÅ¡tadienį'.split('_'), 42651 standalone: 'sekmadienis_pirmadienis_antradienis_treÄiadienis_ketvirtadienis_penktadienis_Å¡eÅ¡tadienis'.split('_'), 42652 isFormat: /dddd HH:mm/ 42653 }, 42654 weekdaysShort : 'Sek_Pir_Ant_Tre_Ket_Pen_Å eÅ¡'.split('_'), 42655 weekdaysMin : 'S_P_A_T_K_Pn_Å '.split('_'), 42656 weekdaysParseExact : true, 42657 longDateFormat : { 42658 LT : 'HH:mm', 42659 LTS : 'HH:mm:ss', 42660 L : 'YYYY-MM-DD', 42661 LL : 'YYYY [m.] MMMM D [d.]', 42662 LLL : 'YYYY [m.] MMMM D [d.], HH:mm [val.]', 42663 LLLL : 'YYYY [m.] MMMM D [d.], dddd, HH:mm [val.]', 42664 l : 'YYYY-MM-DD', 42665 ll : 'YYYY [m.] MMMM D [d.]', 42666 lll : 'YYYY [m.] MMMM D [d.], HH:mm [val.]', 42667 llll : 'YYYY [m.] MMMM D [d.], ddd, HH:mm [val.]' 42668 }, 42669 calendar : { 42670 sameDay : '[Å iandien] LT', 42671 nextDay : '[Rytoj] LT', 42672 nextWeek : 'dddd LT', 42673 lastDay : '[Vakar] LT', 42674 lastWeek : '[PraÄjusį] dddd LT', 42675 sameElse : 'L' 42676 }, 42677 relativeTime : { 42678 future : 'po %s', 42679 past : 'prieÅ¡ %s', 42680 s : translateSeconds, 42681 ss : translate, 42682 m : translateSingular, 42683 mm : translate, 42684 h : translateSingular, 42685 hh : translate, 42686 d : translateSingular, 42687 dd : translate, 42688 M : translateSingular, 42689 MM : translate, 42690 y : translateSingular, 42691 yy : translate 42692 }, 42693 dayOfMonthOrdinalParse: /\d{1,2}-oji/, 42694 ordinal : function (number) { 42695 return number + '-oji'; 42696 }, 42697 week : { 42698 dow : 1, // Monday is the first day of the week. 42699 doy : 4 // The week that contains Jan 4th is the first week of the year. 42700 } 42701 }); 42702 42703 return lt; 42704 42705}))); 42706 42707 42708/***/ }), 42709/* 100 */ 42710/***/ (function(module, exports, __webpack_require__) { 42711 42712//! moment.js locale configuration 42713 42714;(function (global, factory) { 42715 true ? factory(__webpack_require__(0)) : 42716 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 42717 factory(global.moment) 42718}(this, (function (moment) { 'use strict'; 42719 42720 42721 var units = { 42722 'ss': 'sekundes_sekundÄm_sekunde_sekundes'.split('_'), 42723 'm': 'minÅ«tes_minÅ«tÄm_minÅ«te_minÅ«tes'.split('_'), 42724 'mm': 'minÅ«tes_minÅ«tÄm_minÅ«te_minÅ«tes'.split('_'), 42725 'h': 'stundas_stundÄm_stunda_stundas'.split('_'), 42726 'hh': 'stundas_stundÄm_stunda_stundas'.split('_'), 42727 'd': 'dienas_dienÄm_diena_dienas'.split('_'), 42728 'dd': 'dienas_dienÄm_diena_dienas'.split('_'), 42729 'M': 'mÄneÅ¡a_mÄneÅ¡iem_mÄnesis_mÄneÅ¡i'.split('_'), 42730 'MM': 'mÄneÅ¡a_mÄneÅ¡iem_mÄnesis_mÄneÅ¡i'.split('_'), 42731 'y': 'gada_gadiem_gads_gadi'.split('_'), 42732 'yy': 'gada_gadiem_gads_gadi'.split('_') 42733 }; 42734 /** 42735 * @param withoutSuffix boolean true = a length of time; false = before/after a period of time. 42736 */ 42737 function format(forms, number, withoutSuffix) { 42738 if (withoutSuffix) { 42739 // E.g. "21 minÅ«te", "3 minÅ«tes". 42740 return number % 10 === 1 && number % 100 !== 11 ? forms[2] : forms[3]; 42741 } else { 42742 // E.g. "21 minÅ«tes" as in "pÄc 21 minÅ«tes". 42743 // E.g. "3 minÅ«tÄm" as in "pÄc 3 minÅ«tÄm". 42744 return number % 10 === 1 && number % 100 !== 11 ? forms[0] : forms[1]; 42745 } 42746 } 42747 function relativeTimeWithPlural(number, withoutSuffix, key) { 42748 return number + ' ' + format(units[key], number, withoutSuffix); 42749 } 42750 function relativeTimeWithSingular(number, withoutSuffix, key) { 42751 return format(units[key], number, withoutSuffix); 42752 } 42753 function relativeSeconds(number, withoutSuffix) { 42754 return withoutSuffix ? 'dažas sekundes' : 'dažÄm sekundÄm'; 42755 } 42756 42757 var lv = moment.defineLocale('lv', { 42758 months : 'janvÄris_februÄris_marts_aprÄ«lis_maijs_jÅ«nijs_jÅ«lijs_augusts_septembris_oktobris_novembris_decembris'.split('_'), 42759 monthsShort : 'jan_feb_mar_apr_mai_jÅ«n_jÅ«l_aug_sep_okt_nov_dec'.split('_'), 42760 weekdays : 'svÄtdiena_pirmdiena_otrdiena_treÅ¡diena_ceturtdiena_piektdiena_sestdiena'.split('_'), 42761 weekdaysShort : 'Sv_P_O_T_C_Pk_S'.split('_'), 42762 weekdaysMin : 'Sv_P_O_T_C_Pk_S'.split('_'), 42763 weekdaysParseExact : true, 42764 longDateFormat : { 42765 LT : 'HH:mm', 42766 LTS : 'HH:mm:ss', 42767 L : 'DD.MM.YYYY.', 42768 LL : 'YYYY. [gada] D. MMMM', 42769 LLL : 'YYYY. [gada] D. MMMM, HH:mm', 42770 LLLL : 'YYYY. [gada] D. MMMM, dddd, HH:mm' 42771 }, 42772 calendar : { 42773 sameDay : '[Å odien pulksten] LT', 42774 nextDay : '[RÄ«t pulksten] LT', 42775 nextWeek : 'dddd [pulksten] LT', 42776 lastDay : '[Vakar pulksten] LT', 42777 lastWeek : '[PagÄjuÅ¡Ä] dddd [pulksten] LT', 42778 sameElse : 'L' 42779 }, 42780 relativeTime : { 42781 future : 'pÄc %s', 42782 past : 'pirms %s', 42783 s : relativeSeconds, 42784 ss : relativeTimeWithPlural, 42785 m : relativeTimeWithSingular, 42786 mm : relativeTimeWithPlural, 42787 h : relativeTimeWithSingular, 42788 hh : relativeTimeWithPlural, 42789 d : relativeTimeWithSingular, 42790 dd : relativeTimeWithPlural, 42791 M : relativeTimeWithSingular, 42792 MM : relativeTimeWithPlural, 42793 y : relativeTimeWithSingular, 42794 yy : relativeTimeWithPlural 42795 }, 42796 dayOfMonthOrdinalParse: /\d{1,2}\./, 42797 ordinal : '%d.', 42798 week : { 42799 dow : 1, // Monday is the first day of the week. 42800 doy : 4 // The week that contains Jan 4th is the first week of the year. 42801 } 42802 }); 42803 42804 return lv; 42805 42806}))); 42807 42808 42809/***/ }), 42810/* 101 */ 42811/***/ (function(module, exports, __webpack_require__) { 42812 42813//! moment.js locale configuration 42814 42815;(function (global, factory) { 42816 true ? factory(__webpack_require__(0)) : 42817 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 42818 factory(global.moment) 42819}(this, (function (moment) { 'use strict'; 42820 42821 42822 var translator = { 42823 words: { //Different grammatical cases 42824 ss: ['sekund', 'sekunda', 'sekundi'], 42825 m: ['jedan minut', 'jednog minuta'], 42826 mm: ['minut', 'minuta', 'minuta'], 42827 h: ['jedan sat', 'jednog sata'], 42828 hh: ['sat', 'sata', 'sati'], 42829 dd: ['dan', 'dana', 'dana'], 42830 MM: ['mjesec', 'mjeseca', 'mjeseci'], 42831 yy: ['godina', 'godine', 'godina'] 42832 }, 42833 correctGrammaticalCase: function (number, wordKey) { 42834 return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]); 42835 }, 42836 translate: function (number, withoutSuffix, key) { 42837 var wordKey = translator.words[key]; 42838 if (key.length === 1) { 42839 return withoutSuffix ? wordKey[0] : wordKey[1]; 42840 } else { 42841 return number + ' ' + translator.correctGrammaticalCase(number, wordKey); 42842 } 42843 } 42844 }; 42845 42846 var me = moment.defineLocale('me', { 42847 months: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split('_'), 42848 monthsShort: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split('_'), 42849 monthsParseExact : true, 42850 weekdays: 'nedjelja_ponedjeljak_utorak_srijeda_Äetvrtak_petak_subota'.split('_'), 42851 weekdaysShort: 'ned._pon._uto._sri._Äet._pet._sub.'.split('_'), 42852 weekdaysMin: 'ne_po_ut_sr_Äe_pe_su'.split('_'), 42853 weekdaysParseExact : true, 42854 longDateFormat: { 42855 LT: 'H:mm', 42856 LTS : 'H:mm:ss', 42857 L: 'DD.MM.YYYY', 42858 LL: 'D. MMMM YYYY', 42859 LLL: 'D. MMMM YYYY H:mm', 42860 LLLL: 'dddd, D. MMMM YYYY H:mm' 42861 }, 42862 calendar: { 42863 sameDay: '[danas u] LT', 42864 nextDay: '[sjutra u] LT', 42865 42866 nextWeek: function () { 42867 switch (this.day()) { 42868 case 0: 42869 return '[u] [nedjelju] [u] LT'; 42870 case 3: 42871 return '[u] [srijedu] [u] LT'; 42872 case 6: 42873 return '[u] [subotu] [u] LT'; 42874 case 1: 42875 case 2: 42876 case 4: 42877 case 5: 42878 return '[u] dddd [u] LT'; 42879 } 42880 }, 42881 lastDay : '[juÄe u] LT', 42882 lastWeek : function () { 42883 var lastWeekDays = [ 42884 '[proÅ¡le] [nedjelje] [u] LT', 42885 '[proÅ¡log] [ponedjeljka] [u] LT', 42886 '[proÅ¡log] [utorka] [u] LT', 42887 '[proÅ¡le] [srijede] [u] LT', 42888 '[proÅ¡log] [Äetvrtka] [u] LT', 42889 '[proÅ¡log] [petka] [u] LT', 42890 '[proÅ¡le] [subote] [u] LT' 42891 ]; 42892 return lastWeekDays[this.day()]; 42893 }, 42894 sameElse : 'L' 42895 }, 42896 relativeTime : { 42897 future : 'za %s', 42898 past : 'prije %s', 42899 s : 'nekoliko sekundi', 42900 ss : translator.translate, 42901 m : translator.translate, 42902 mm : translator.translate, 42903 h : translator.translate, 42904 hh : translator.translate, 42905 d : 'dan', 42906 dd : translator.translate, 42907 M : 'mjesec', 42908 MM : translator.translate, 42909 y : 'godinu', 42910 yy : translator.translate 42911 }, 42912 dayOfMonthOrdinalParse: /\d{1,2}\./, 42913 ordinal : '%d.', 42914 week : { 42915 dow : 1, // Monday is the first day of the week. 42916 doy : 7 // The week that contains Jan 1st is the first week of the year. 42917 } 42918 }); 42919 42920 return me; 42921 42922}))); 42923 42924 42925/***/ }), 42926/* 102 */ 42927/***/ (function(module, exports, __webpack_require__) { 42928 42929//! moment.js locale configuration 42930 42931;(function (global, factory) { 42932 true ? factory(__webpack_require__(0)) : 42933 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 42934 factory(global.moment) 42935}(this, (function (moment) { 'use strict'; 42936 42937 42938 var mi = moment.defineLocale('mi', { 42939 months: 'Kohi-tÄte_Hui-tanguru_PoutÅ«-te-rangi_Paenga-whÄwhÄ_Haratua_Pipiri_HÅngoingoi_Here-turi-kÅkÄ_Mahuru_Whiringa-Ä-nuku_Whiringa-Ä-rangi_Hakihea'.split('_'), 42940 monthsShort: 'Kohi_Hui_Pou_Pae_Hara_Pipi_HÅngoi_Here_Mahu_Whi-nu_Whi-ra_Haki'.split('_'), 42941 monthsRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i, 42942 monthsStrictRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i, 42943 monthsShortRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i, 42944 monthsShortStrictRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,2}/i, 42945 weekdays: 'RÄtapu_Mane_TÅ«rei_Wenerei_TÄite_Paraire_HÄtarei'.split('_'), 42946 weekdaysShort: 'Ta_Ma_TÅ«_We_TÄi_Pa_HÄ'.split('_'), 42947 weekdaysMin: 'Ta_Ma_TÅ«_We_TÄi_Pa_HÄ'.split('_'), 42948 longDateFormat: { 42949 LT: 'HH:mm', 42950 LTS: 'HH:mm:ss', 42951 L: 'DD/MM/YYYY', 42952 LL: 'D MMMM YYYY', 42953 LLL: 'D MMMM YYYY [i] HH:mm', 42954 LLLL: 'dddd, D MMMM YYYY [i] HH:mm' 42955 }, 42956 calendar: { 42957 sameDay: '[i teie mahana, i] LT', 42958 nextDay: '[apopo i] LT', 42959 nextWeek: 'dddd [i] LT', 42960 lastDay: '[inanahi i] LT', 42961 lastWeek: 'dddd [whakamutunga i] LT', 42962 sameElse: 'L' 42963 }, 42964 relativeTime: { 42965 future: 'i roto i %s', 42966 past: '%s i mua', 42967 s: 'te hÄkona ruarua', 42968 ss: '%d hÄkona', 42969 m: 'he meneti', 42970 mm: '%d meneti', 42971 h: 'te haora', 42972 hh: '%d haora', 42973 d: 'he ra', 42974 dd: '%d ra', 42975 M: 'he marama', 42976 MM: '%d marama', 42977 y: 'he tau', 42978 yy: '%d tau' 42979 }, 42980 dayOfMonthOrdinalParse: /\d{1,2}º/, 42981 ordinal: '%dº', 42982 week : { 42983 dow : 1, // Monday is the first day of the week. 42984 doy : 4 // The week that contains Jan 4th is the first week of the year. 42985 } 42986 }); 42987 42988 return mi; 42989 42990}))); 42991 42992 42993/***/ }), 42994/* 103 */ 42995/***/ (function(module, exports, __webpack_require__) { 42996 42997//! moment.js locale configuration 42998 42999;(function (global, factory) { 43000 true ? factory(__webpack_require__(0)) : 43001 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 43002 factory(global.moment) 43003}(this, (function (moment) { 'use strict'; 43004 43005 43006 var mk = moment.defineLocale('mk', { 43007 months : 'ÑанÑаÑи_ÑевÑÑаÑи_маÑÑ_апÑил_маÑ_ÑÑни_ÑÑли_авгÑÑÑ_ÑепÑемвÑи_окÑомвÑи_ноемвÑи_декемвÑи'.split('_'), 43008 monthsShort : 'Ñан_Ñев_маÑ_апÑ_маÑ_ÑÑн_ÑÑл_авг_Ñеп_окÑ_ное_дек'.split('_'), 43009 weekdays : 'недела_понеделник_вÑоÑник_ÑÑеда_ÑеÑвÑÑок_пеÑок_ÑабоÑа'.split('_'), 43010 weekdaysShort : 'нед_пон_вÑо_ÑÑе_ÑеÑ_пеÑ_Ñаб'.split('_'), 43011 weekdaysMin : 'нe_пo_вÑ_ÑÑ_Ñе_пе_Ña'.split('_'), 43012 longDateFormat : { 43013 LT : 'H:mm', 43014 LTS : 'H:mm:ss', 43015 L : 'D.MM.YYYY', 43016 LL : 'D MMMM YYYY', 43017 LLL : 'D MMMM YYYY H:mm', 43018 LLLL : 'dddd, D MMMM YYYY H:mm' 43019 }, 43020 calendar : { 43021 sameDay : '[ÐÐµÐ½ÐµÑ Ð²Ð¾] LT', 43022 nextDay : '[УÑÑе во] LT', 43023 nextWeek : '[Ðо] dddd [во] LT', 43024 lastDay : '[ÐÑеÑа во] LT', 43025 lastWeek : function () { 43026 switch (this.day()) { 43027 case 0: 43028 case 3: 43029 case 6: 43030 return '[ÐзминаÑаÑа] dddd [во] LT'; 43031 case 1: 43032 case 2: 43033 case 4: 43034 case 5: 43035 return '[ÐзминаÑиоÑ] dddd [во] LT'; 43036 } 43037 }, 43038 sameElse : 'L' 43039 }, 43040 relativeTime : { 43041 future : 'поÑле %s', 43042 past : 'пÑед %s', 43043 s : 'Ð½ÐµÐºÐ¾Ð»ÐºÑ ÑекÑнди', 43044 ss : '%d ÑекÑнди', 43045 m : 'минÑÑа', 43046 mm : '%d минÑÑи', 43047 h : 'ÑаÑ', 43048 hh : '%d ÑаÑа', 43049 d : 'ден', 43050 dd : '%d дена', 43051 M : 'меÑеÑ', 43052 MM : '%d меÑеÑи', 43053 y : 'година', 43054 yy : '%d години' 43055 }, 43056 dayOfMonthOrdinalParse: /\d{1,2}-(ев|ен|Ñи|ви|Ñи|ми)/, 43057 ordinal : function (number) { 43058 var lastDigit = number % 10, 43059 last2Digits = number % 100; 43060 if (number === 0) { 43061 return number + '-ев'; 43062 } else if (last2Digits === 0) { 43063 return number + '-ен'; 43064 } else if (last2Digits > 10 && last2Digits < 20) { 43065 return number + '-Ñи'; 43066 } else if (lastDigit === 1) { 43067 return number + '-ви'; 43068 } else if (lastDigit === 2) { 43069 return number + '-Ñи'; 43070 } else if (lastDigit === 7 || lastDigit === 8) { 43071 return number + '-ми'; 43072 } else { 43073 return number + '-Ñи'; 43074 } 43075 }, 43076 week : { 43077 dow : 1, // Monday is the first day of the week. 43078 doy : 7 // The week that contains Jan 1st is the first week of the year. 43079 } 43080 }); 43081 43082 return mk; 43083 43084}))); 43085 43086 43087/***/ }), 43088/* 104 */ 43089/***/ (function(module, exports, __webpack_require__) { 43090 43091//! moment.js locale configuration 43092 43093;(function (global, factory) { 43094 true ? factory(__webpack_require__(0)) : 43095 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 43096 factory(global.moment) 43097}(this, (function (moment) { 'use strict'; 43098 43099 43100 var ml = moment.defineLocale('ml', { 43101 months : 'à´à´¨àµà´µà´°à´¿_à´«àµà´¬àµà´°àµà´µà´°à´¿_മാർà´àµà´àµ_à´à´ªàµà´°à´¿àµ½_à´®àµà´¯àµ_à´àµàµº_à´àµà´²àµ_à´à´à´¸àµà´±àµà´±àµ_à´¸àµà´ªàµà´±àµà´±à´à´¬àµ¼_à´à´àµà´àµà´¬àµ¼_നവà´à´¬àµ¼_à´¡à´¿à´¸à´à´¬àµ¼'.split('_'), 43102 monthsShort : 'à´à´¨àµ._à´«àµà´¬àµà´°àµ._മാർ._à´à´ªàµà´°à´¿._à´®àµà´¯àµ_à´àµàµº_à´àµà´²àµ._à´à´._à´¸àµà´ªàµà´±àµà´±._à´à´àµà´àµ._നവà´._à´¡à´¿à´¸à´.'.split('_'), 43103 monthsParseExact : true, 43104 weekdays : 'à´à´¾à´¯à´±à´¾à´´àµà´_തിà´àµà´à´³à´¾à´´àµà´_à´àµà´µàµà´µà´¾à´´àµà´_à´¬àµà´§à´¨à´¾à´´àµà´_à´µàµà´¯à´¾à´´à´¾à´´àµà´_à´µàµà´³àµà´³à´¿à´¯à´¾à´´àµà´_ശനിയാഴàµà´'.split('_'), 43105 weekdaysShort : 'à´à´¾à´¯àµ¼_തിà´àµà´àµ¾_à´àµà´µàµà´µ_à´¬àµà´§àµ»_à´µàµà´¯à´¾à´´à´_à´µàµà´³àµà´³à´¿_ശനി'.split('_'), 43106 weekdaysMin : 'à´à´¾_തി_à´àµ_à´¬àµ_à´µàµà´¯à´¾_à´µàµ_à´¶'.split('_'), 43107 longDateFormat : { 43108 LT : 'A h:mm -à´¨àµ', 43109 LTS : 'A h:mm:ss -à´¨àµ', 43110 L : 'DD/MM/YYYY', 43111 LL : 'D MMMM YYYY', 43112 LLL : 'D MMMM YYYY, A h:mm -à´¨àµ', 43113 LLLL : 'dddd, D MMMM YYYY, A h:mm -à´¨àµ' 43114 }, 43115 calendar : { 43116 sameDay : '[à´à´¨àµà´¨àµ] LT', 43117 nextDay : '[നാളàµ] LT', 43118 nextWeek : 'dddd, LT', 43119 lastDay : '[à´à´¨àµà´¨à´²àµ] LT', 43120 lastWeek : '[à´à´´à´¿à´àµà´] dddd, LT', 43121 sameElse : 'L' 43122 }, 43123 relativeTime : { 43124 future : '%s à´à´´à´¿à´àµà´àµ', 43125 past : '%s à´®àµàµ»à´ªàµ', 43126 s : 'ഠൽപ നിമിഷà´àµà´àµ¾', 43127 ss : '%d à´¸àµà´àµà´àµ»à´¡àµ', 43128 m : 'à´à´°àµ മിനിറàµà´±àµ', 43129 mm : '%d മിനിറàµà´±àµ', 43130 h : 'à´à´°àµ മണിà´àµà´àµàµ¼', 43131 hh : '%d മണിà´àµà´àµàµ¼', 43132 d : 'à´à´°àµ ദിവസà´', 43133 dd : '%d ദിവസà´', 43134 M : 'à´à´°àµ മാസà´', 43135 MM : '%d മാസà´', 43136 y : 'à´à´°àµ വർഷà´', 43137 yy : '%d വർഷà´' 43138 }, 43139 meridiemParse: /രാതàµà´°à´¿|രാവിലàµ|à´à´àµà´ à´à´´à´¿à´àµà´àµ|à´µàµà´àµà´¨àµà´¨àµà´°à´|രാതàµà´°à´¿/i, 43140 meridiemHour : function (hour, meridiem) { 43141 if (hour === 12) { 43142 hour = 0; 43143 } 43144 if ((meridiem === 'രാതàµà´°à´¿' && hour >= 4) || 43145 meridiem === 'à´à´àµà´ à´à´´à´¿à´àµà´àµ' || 43146 meridiem === 'à´µàµà´àµà´¨àµà´¨àµà´°à´') { 43147 return hour + 12; 43148 } else { 43149 return hour; 43150 } 43151 }, 43152 meridiem : function (hour, minute, isLower) { 43153 if (hour < 4) { 43154 return 'രാതàµà´°à´¿'; 43155 } else if (hour < 12) { 43156 return 'രാവിലàµ'; 43157 } else if (hour < 17) { 43158 return 'à´à´àµà´ à´à´´à´¿à´àµà´àµ'; 43159 } else if (hour < 20) { 43160 return 'à´µàµà´àµà´¨àµà´¨àµà´°à´'; 43161 } else { 43162 return 'രാതàµà´°à´¿'; 43163 } 43164 } 43165 }); 43166 43167 return ml; 43168 43169}))); 43170 43171 43172/***/ }), 43173/* 105 */ 43174/***/ (function(module, exports, __webpack_require__) { 43175 43176//! moment.js locale configuration 43177 43178;(function (global, factory) { 43179 true ? factory(__webpack_require__(0)) : 43180 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 43181 factory(global.moment) 43182}(this, (function (moment) { 'use strict'; 43183 43184 43185 function translate(number, withoutSuffix, key, isFuture) { 43186 switch (key) { 43187 case 's': 43188 return withoutSuffix ? 'Ñ ÑÐ´Ñ Ñн ÑекÑнд' : 'Ñ ÑÐ´Ñ Ñн ÑекÑндÑн'; 43189 case 'ss': 43190 return number + (withoutSuffix ? ' ÑекÑнд' : ' ÑекÑндÑн'); 43191 case 'm': 43192 case 'mm': 43193 return number + (withoutSuffix ? ' минÑÑ' : ' минÑÑÑн'); 43194 case 'h': 43195 case 'hh': 43196 return number + (withoutSuffix ? ' Ñаг' : ' Ñагийн'); 43197 case 'd': 43198 case 'dd': 43199 return number + (withoutSuffix ? ' өдөÑ' : ' өдÑийн'); 43200 case 'M': 43201 case 'MM': 43202 return number + (withoutSuffix ? ' ÑаÑ' : ' ÑаÑÑн'); 43203 case 'y': 43204 case 'yy': 43205 return number + (withoutSuffix ? ' жил' : ' жилийн'); 43206 default: 43207 return number; 43208 } 43209 } 43210 43211 var mn = moment.defineLocale('mn', { 43212 months : 'ÐÑгдүгÑÑÑ ÑаÑ_ХоÑÑдÑÐ³Ð°Ð°Ñ ÑаÑ_ÐÑÑавдÑÐ³Ð°Ð°Ñ ÑаÑ_ÐÓ©ÑөвдүгÑÑÑ ÑаÑ_ТавдÑÐ³Ð°Ð°Ñ ÑаÑ_ÐÑÑгадÑÐ³Ð°Ð°Ñ ÑаÑ_ÐолдÑÐ³Ð°Ð°Ñ ÑаÑ_ÐаймдÑÐ³Ð°Ð°Ñ ÑаÑ_ÐÑдүгÑÑÑ ÑаÑ_ÐÑавдÑÐ³Ð°Ð°Ñ ÑаÑ_ÐÑван нÑгдүгÑÑÑ ÑаÑ_ÐÑван Ñ Ð¾ÑÑдÑÐ³Ð°Ð°Ñ ÑаÑ'.split('_'), 43213 monthsShort : '1 ÑаÑ_2 ÑаÑ_3 ÑаÑ_4 ÑаÑ_5 ÑаÑ_6 ÑаÑ_7 ÑаÑ_8 ÑаÑ_9 ÑаÑ_10 ÑаÑ_11 ÑаÑ_12 ÑаÑ'.split('_'), 43214 monthsParseExact : true, 43215 weekdays : 'ÐÑм_Ðаваа_ÐÑгмаÑ_ÐÑ Ð°Ð³Ð²Ð°_ÐÒ¯ÑÑв_ÐааÑан_ÐÑмба'.split('_'), 43216 weekdaysShort : 'ÐÑм_Ðав_ÐÑг_ÐÑ Ð°_ÐÒ¯Ñ_Ðаа_ÐÑм'.split('_'), 43217 weekdaysMin : 'ÐÑ_Ðа_ÐÑ_ÐÑ _ÐÒ¯_Ðа_ÐÑ'.split('_'), 43218 weekdaysParseExact : true, 43219 longDateFormat : { 43220 LT : 'HH:mm', 43221 LTS : 'HH:mm:ss', 43222 L : 'YYYY-MM-DD', 43223 LL : 'YYYY Ð¾Ð½Ñ MMMMÑн D', 43224 LLL : 'YYYY Ð¾Ð½Ñ MMMMÑн D HH:mm', 43225 LLLL : 'dddd, YYYY Ð¾Ð½Ñ MMMMÑн D HH:mm' 43226 }, 43227 meridiemParse: /Ò®Ó¨|ҮХ/i, 43228 isPM : function (input) { 43229 return input === 'ҮХ'; 43230 }, 43231 meridiem : function (hour, minute, isLower) { 43232 if (hour < 12) { 43233 return 'Ò®Ó¨'; 43234 } else { 43235 return 'ҮХ'; 43236 } 43237 }, 43238 calendar : { 43239 sameDay : '[ӨнөөдөÑ] LT', 43240 nextDay : '[ÐаÑгааÑ] LT', 43241 nextWeek : '[ÐÑÑÑ ] dddd LT', 43242 lastDay : '[Ó¨ÑигдөÑ] LT', 43243 lastWeek : '[ӨнгөÑÑөн] dddd LT', 43244 sameElse : 'L' 43245 }, 43246 relativeTime : { 43247 future : '%s даÑаа', 43248 past : '%s өмнө', 43249 s : translate, 43250 ss : translate, 43251 m : translate, 43252 mm : translate, 43253 h : translate, 43254 hh : translate, 43255 d : translate, 43256 dd : translate, 43257 M : translate, 43258 MM : translate, 43259 y : translate, 43260 yy : translate 43261 }, 43262 dayOfMonthOrdinalParse: /\d{1,2} өдөÑ/, 43263 ordinal : function (number, period) { 43264 switch (period) { 43265 case 'd': 43266 case 'D': 43267 case 'DDD': 43268 return number + ' өдөÑ'; 43269 default: 43270 return number; 43271 } 43272 } 43273 }); 43274 43275 return mn; 43276 43277}))); 43278 43279 43280/***/ }), 43281/* 106 */ 43282/***/ (function(module, exports, __webpack_require__) { 43283 43284//! moment.js locale configuration 43285 43286;(function (global, factory) { 43287 true ? factory(__webpack_require__(0)) : 43288 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 43289 factory(global.moment) 43290}(this, (function (moment) { 'use strict'; 43291 43292 43293 var symbolMap = { 43294 '1': '१', 43295 '2': '२', 43296 '3': '३', 43297 '4': '४', 43298 '5': '५', 43299 '6': '६', 43300 '7': 'à¥', 43301 '8': '८', 43302 '9': '९', 43303 '0': '०' 43304 }, 43305 numberMap = { 43306 '१': '1', 43307 '२': '2', 43308 '३': '3', 43309 '४': '4', 43310 '५': '5', 43311 '६': '6', 43312 'à¥': '7', 43313 '८': '8', 43314 '९': '9', 43315 '०': '0' 43316 }; 43317 43318 function relativeTimeMr(number, withoutSuffix, string, isFuture) 43319 { 43320 var output = ''; 43321 if (withoutSuffix) { 43322 switch (string) { 43323 case 's': output = 'à¤à¤¾à¤¹à¥ सà¥à¤à¤à¤¦'; break; 43324 case 'ss': output = '%d सà¥à¤à¤à¤¦'; break; 43325 case 'm': output = 'à¤à¤ मिनिà¤'; break; 43326 case 'mm': output = '%d मिनिà¤à¥'; break; 43327 case 'h': output = 'à¤à¤ तास'; break; 43328 case 'hh': output = '%d तास'; break; 43329 case 'd': output = 'à¤à¤ दिवस'; break; 43330 case 'dd': output = '%d दिवस'; break; 43331 case 'M': output = 'à¤à¤ महिना'; break; 43332 case 'MM': output = '%d महिनà¥'; break; 43333 case 'y': output = 'à¤à¤ वरà¥à¤·'; break; 43334 case 'yy': output = '%d वरà¥à¤·à¥'; break; 43335 } 43336 } 43337 else { 43338 switch (string) { 43339 case 's': output = 'à¤à¤¾à¤¹à¥ सà¥à¤à¤à¤¦à¤¾à¤'; break; 43340 case 'ss': output = '%d सà¥à¤à¤à¤¦à¤¾à¤'; break; 43341 case 'm': output = 'à¤à¤à¤¾ मिनिà¤à¤¾'; break; 43342 case 'mm': output = '%d मिनिà¤à¤¾à¤'; break; 43343 case 'h': output = 'à¤à¤à¤¾ तासा'; break; 43344 case 'hh': output = '%d तासाà¤'; break; 43345 case 'd': output = 'à¤à¤à¤¾ दिवसा'; break; 43346 case 'dd': output = '%d दिवसाà¤'; break; 43347 case 'M': output = 'à¤à¤à¤¾ महिनà¥à¤¯à¤¾'; break; 43348 case 'MM': output = '%d महिनà¥à¤¯à¤¾à¤'; break; 43349 case 'y': output = 'à¤à¤à¤¾ वरà¥à¤·à¤¾'; break; 43350 case 'yy': output = '%d वरà¥à¤·à¤¾à¤'; break; 43351 } 43352 } 43353 return output.replace(/%d/i, number); 43354 } 43355 43356 var mr = moment.defineLocale('mr', { 43357 months : 'à¤à¤¾à¤¨à¥à¤µà¤¾à¤°à¥_फà¥à¤¬à¥à¤°à¥à¤µà¤¾à¤°à¥_मारà¥à¤_à¤à¤ªà¥à¤°à¤¿à¤²_मà¥_à¤à¥à¤¨_à¤à¥à¤²à¥_à¤à¤à¤¸à¥à¤_सपà¥à¤à¥à¤à¤¬à¤°_à¤à¤à¥à¤à¥à¤¬à¤°_नà¥à¤µà¥à¤¹à¥à¤à¤¬à¤°_डिसà¥à¤à¤¬à¤°'.split('_'), 43358 monthsShort: 'à¤à¤¾à¤¨à¥._फà¥à¤¬à¥à¤°à¥._मारà¥à¤._à¤à¤ªà¥à¤°à¤¿._मà¥._à¤à¥à¤¨._à¤à¥à¤²à¥._à¤à¤._सपà¥à¤à¥à¤._à¤à¤à¥à¤à¥._नà¥à¤µà¥à¤¹à¥à¤._डिसà¥à¤.'.split('_'), 43359 monthsParseExact : true, 43360 weekdays : 'रविवार_सà¥à¤®à¤µà¤¾à¤°_मà¤à¤à¤³à¤µà¤¾à¤°_बà¥à¤§à¤µà¤¾à¤°_à¤à¥à¤°à¥à¤µà¤¾à¤°_शà¥à¤à¥à¤°à¤µà¤¾à¤°_शनिवार'.split('_'), 43361 weekdaysShort : 'रवि_सà¥à¤®_मà¤à¤à¤³_बà¥à¤§_à¤à¥à¤°à¥_शà¥à¤à¥à¤°_शनि'.split('_'), 43362 weekdaysMin : 'र_सà¥_मà¤_बà¥_à¤à¥_शà¥_श'.split('_'), 43363 longDateFormat : { 43364 LT : 'A h:mm वाà¤à¤¤à¤¾', 43365 LTS : 'A h:mm:ss वाà¤à¤¤à¤¾', 43366 L : 'DD/MM/YYYY', 43367 LL : 'D MMMM YYYY', 43368 LLL : 'D MMMM YYYY, A h:mm वाà¤à¤¤à¤¾', 43369 LLLL : 'dddd, D MMMM YYYY, A h:mm वाà¤à¤¤à¤¾' 43370 }, 43371 calendar : { 43372 sameDay : '[à¤à¤] LT', 43373 nextDay : '[à¤à¤¦à¥à¤¯à¤¾] LT', 43374 nextWeek : 'dddd, LT', 43375 lastDay : '[à¤à¤¾à¤²] LT', 43376 lastWeek: '[माà¤à¥à¤²] dddd, LT', 43377 sameElse : 'L' 43378 }, 43379 relativeTime : { 43380 future: '%sमधà¥à¤¯à¥', 43381 past: '%sपà¥à¤°à¥à¤µà¥', 43382 s: relativeTimeMr, 43383 ss: relativeTimeMr, 43384 m: relativeTimeMr, 43385 mm: relativeTimeMr, 43386 h: relativeTimeMr, 43387 hh: relativeTimeMr, 43388 d: relativeTimeMr, 43389 dd: relativeTimeMr, 43390 M: relativeTimeMr, 43391 MM: relativeTimeMr, 43392 y: relativeTimeMr, 43393 yy: relativeTimeMr 43394 }, 43395 preparse: function (string) { 43396 return string.replace(/[१२३४५६à¥à¥®à¥¯à¥¦]/g, function (match) { 43397 return numberMap[match]; 43398 }); 43399 }, 43400 postformat: function (string) { 43401 return string.replace(/\d/g, function (match) { 43402 return symbolMap[match]; 43403 }); 43404 }, 43405 meridiemParse: /रातà¥à¤°à¥|सà¤à¤¾à¤³à¥|दà¥à¤ªà¤¾à¤°à¥|सायà¤à¤à¤¾à¤³à¥/, 43406 meridiemHour : function (hour, meridiem) { 43407 if (hour === 12) { 43408 hour = 0; 43409 } 43410 if (meridiem === 'रातà¥à¤°à¥') { 43411 return hour < 4 ? hour : hour + 12; 43412 } else if (meridiem === 'सà¤à¤¾à¤³à¥') { 43413 return hour; 43414 } else if (meridiem === 'दà¥à¤ªà¤¾à¤°à¥') { 43415 return hour >= 10 ? hour : hour + 12; 43416 } else if (meridiem === 'सायà¤à¤à¤¾à¤³à¥') { 43417 return hour + 12; 43418 } 43419 }, 43420 meridiem: function (hour, minute, isLower) { 43421 if (hour < 4) { 43422 return 'रातà¥à¤°à¥'; 43423 } else if (hour < 10) { 43424 return 'सà¤à¤¾à¤³à¥'; 43425 } else if (hour < 17) { 43426 return 'दà¥à¤ªà¤¾à¤°à¥'; 43427 } else if (hour < 20) { 43428 return 'सायà¤à¤à¤¾à¤³à¥'; 43429 } else { 43430 return 'रातà¥à¤°à¥'; 43431 } 43432 }, 43433 week : { 43434 dow : 0, // Sunday is the first day of the week. 43435 doy : 6 // The week that contains Jan 1st is the first week of the year. 43436 } 43437 }); 43438 43439 return mr; 43440 43441}))); 43442 43443 43444/***/ }), 43445/* 107 */ 43446/***/ (function(module, exports, __webpack_require__) { 43447 43448//! moment.js locale configuration 43449 43450;(function (global, factory) { 43451 true ? factory(__webpack_require__(0)) : 43452 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 43453 factory(global.moment) 43454}(this, (function (moment) { 'use strict'; 43455 43456 43457 var msMy = moment.defineLocale('ms-my', { 43458 months : 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'), 43459 monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'), 43460 weekdays : 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'), 43461 weekdaysShort : 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'), 43462 weekdaysMin : 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'), 43463 longDateFormat : { 43464 LT : 'HH.mm', 43465 LTS : 'HH.mm.ss', 43466 L : 'DD/MM/YYYY', 43467 LL : 'D MMMM YYYY', 43468 LLL : 'D MMMM YYYY [pukul] HH.mm', 43469 LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm' 43470 }, 43471 meridiemParse: /pagi|tengahari|petang|malam/, 43472 meridiemHour: function (hour, meridiem) { 43473 if (hour === 12) { 43474 hour = 0; 43475 } 43476 if (meridiem === 'pagi') { 43477 return hour; 43478 } else if (meridiem === 'tengahari') { 43479 return hour >= 11 ? hour : hour + 12; 43480 } else if (meridiem === 'petang' || meridiem === 'malam') { 43481 return hour + 12; 43482 } 43483 }, 43484 meridiem : function (hours, minutes, isLower) { 43485 if (hours < 11) { 43486 return 'pagi'; 43487 } else if (hours < 15) { 43488 return 'tengahari'; 43489 } else if (hours < 19) { 43490 return 'petang'; 43491 } else { 43492 return 'malam'; 43493 } 43494 }, 43495 calendar : { 43496 sameDay : '[Hari ini pukul] LT', 43497 nextDay : '[Esok pukul] LT', 43498 nextWeek : 'dddd [pukul] LT', 43499 lastDay : '[Kelmarin pukul] LT', 43500 lastWeek : 'dddd [lepas pukul] LT', 43501 sameElse : 'L' 43502 }, 43503 relativeTime : { 43504 future : 'dalam %s', 43505 past : '%s yang lepas', 43506 s : 'beberapa saat', 43507 ss : '%d saat', 43508 m : 'seminit', 43509 mm : '%d minit', 43510 h : 'sejam', 43511 hh : '%d jam', 43512 d : 'sehari', 43513 dd : '%d hari', 43514 M : 'sebulan', 43515 MM : '%d bulan', 43516 y : 'setahun', 43517 yy : '%d tahun' 43518 }, 43519 week : { 43520 dow : 1, // Monday is the first day of the week. 43521 doy : 7 // The week that contains Jan 1st is the first week of the year. 43522 } 43523 }); 43524 43525 return msMy; 43526 43527}))); 43528 43529 43530/***/ }), 43531/* 108 */ 43532/***/ (function(module, exports, __webpack_require__) { 43533 43534//! moment.js locale configuration 43535 43536;(function (global, factory) { 43537 true ? factory(__webpack_require__(0)) : 43538 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 43539 factory(global.moment) 43540}(this, (function (moment) { 'use strict'; 43541 43542 43543 var ms = moment.defineLocale('ms', { 43544 months : 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'), 43545 monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'), 43546 weekdays : 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'), 43547 weekdaysShort : 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'), 43548 weekdaysMin : 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'), 43549 longDateFormat : { 43550 LT : 'HH.mm', 43551 LTS : 'HH.mm.ss', 43552 L : 'DD/MM/YYYY', 43553 LL : 'D MMMM YYYY', 43554 LLL : 'D MMMM YYYY [pukul] HH.mm', 43555 LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm' 43556 }, 43557 meridiemParse: /pagi|tengahari|petang|malam/, 43558 meridiemHour: function (hour, meridiem) { 43559 if (hour === 12) { 43560 hour = 0; 43561 } 43562 if (meridiem === 'pagi') { 43563 return hour; 43564 } else if (meridiem === 'tengahari') { 43565 return hour >= 11 ? hour : hour + 12; 43566 } else if (meridiem === 'petang' || meridiem === 'malam') { 43567 return hour + 12; 43568 } 43569 }, 43570 meridiem : function (hours, minutes, isLower) { 43571 if (hours < 11) { 43572 return 'pagi'; 43573 } else if (hours < 15) { 43574 return 'tengahari'; 43575 } else if (hours < 19) { 43576 return 'petang'; 43577 } else { 43578 return 'malam'; 43579 } 43580 }, 43581 calendar : { 43582 sameDay : '[Hari ini pukul] LT', 43583 nextDay : '[Esok pukul] LT', 43584 nextWeek : 'dddd [pukul] LT', 43585 lastDay : '[Kelmarin pukul] LT', 43586 lastWeek : 'dddd [lepas pukul] LT', 43587 sameElse : 'L' 43588 }, 43589 relativeTime : { 43590 future : 'dalam %s', 43591 past : '%s yang lepas', 43592 s : 'beberapa saat', 43593 ss : '%d saat', 43594 m : 'seminit', 43595 mm : '%d minit', 43596 h : 'sejam', 43597 hh : '%d jam', 43598 d : 'sehari', 43599 dd : '%d hari', 43600 M : 'sebulan', 43601 MM : '%d bulan', 43602 y : 'setahun', 43603 yy : '%d tahun' 43604 }, 43605 week : { 43606 dow : 1, // Monday is the first day of the week. 43607 doy : 7 // The week that contains Jan 1st is the first week of the year. 43608 } 43609 }); 43610 43611 return ms; 43612 43613}))); 43614 43615 43616/***/ }), 43617/* 109 */ 43618/***/ (function(module, exports, __webpack_require__) { 43619 43620//! moment.js locale configuration 43621 43622;(function (global, factory) { 43623 true ? factory(__webpack_require__(0)) : 43624 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 43625 factory(global.moment) 43626}(this, (function (moment) { 'use strict'; 43627 43628 43629 var mt = moment.defineLocale('mt', { 43630 months : 'Jannar_Frar_Marzu_April_Mejju_Ä unju_Lulju_Awwissu_Settembru_Ottubru_Novembru_DiÄembru'.split('_'), 43631 monthsShort : 'Jan_Fra_Mar_Apr_Mej_Ä un_Lul_Aww_Set_Ott_Nov_DiÄ'.split('_'), 43632 weekdays : 'Il-Ħadd_It-Tnejn_It-Tlieta_L-Erbgħa_Il-Ħamis_Il-Ä imgħa_Is-Sibt'.split('_'), 43633 weekdaysShort : 'Ħad_Tne_Tli_Erb_Ħam_Ä im_Sib'.split('_'), 43634 weekdaysMin : 'Ħa_Tn_Tl_Er_Ħa_Ä i_Si'.split('_'), 43635 longDateFormat : { 43636 LT : 'HH:mm', 43637 LTS : 'HH:mm:ss', 43638 L : 'DD/MM/YYYY', 43639 LL : 'D MMMM YYYY', 43640 LLL : 'D MMMM YYYY HH:mm', 43641 LLLL : 'dddd, D MMMM YYYY HH:mm' 43642 }, 43643 calendar : { 43644 sameDay : '[Illum fil-]LT', 43645 nextDay : '[Għada fil-]LT', 43646 nextWeek : 'dddd [fil-]LT', 43647 lastDay : '[Il-bieraħ fil-]LT', 43648 lastWeek : 'dddd [li għadda] [fil-]LT', 43649 sameElse : 'L' 43650 }, 43651 relativeTime : { 43652 future : 'fâ %s', 43653 past : '%s ilu', 43654 s : 'ftit sekondi', 43655 ss : '%d sekondi', 43656 m : 'minuta', 43657 mm : '%d minuti', 43658 h : 'siegħa', 43659 hh : '%d siegħat', 43660 d : 'Ä¡urnata', 43661 dd : '%d Ä¡ranet', 43662 M : 'xahar', 43663 MM : '%d xhur', 43664 y : 'sena', 43665 yy : '%d sni' 43666 }, 43667 dayOfMonthOrdinalParse : /\d{1,2}º/, 43668 ordinal: '%dº', 43669 week : { 43670 dow : 1, // Monday is the first day of the week. 43671 doy : 4 // The week that contains Jan 4th is the first week of the year. 43672 } 43673 }); 43674 43675 return mt; 43676 43677}))); 43678 43679 43680/***/ }), 43681/* 110 */ 43682/***/ (function(module, exports, __webpack_require__) { 43683 43684//! moment.js locale configuration 43685 43686;(function (global, factory) { 43687 true ? factory(__webpack_require__(0)) : 43688 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 43689 factory(global.moment) 43690}(this, (function (moment) { 'use strict'; 43691 43692 43693 var symbolMap = { 43694 '1': 'á', 43695 '2': 'á', 43696 '3': 'á', 43697 '4': 'á', 43698 '5': 'á ', 43699 '6': 'á', 43700 '7': 'á', 43701 '8': 'á', 43702 '9': 'á', 43703 '0': 'á' 43704 }, numberMap = { 43705 'á': '1', 43706 'á': '2', 43707 'á': '3', 43708 'á': '4', 43709 'á ': '5', 43710 'á': '6', 43711 'á': '7', 43712 'á': '8', 43713 'á': '9', 43714 'á': '0' 43715 }; 43716 43717 var my = moment.defineLocale('my', { 43718 months: 'áááºááá«áá®_áá±áá±á¬áºáá«áá®_áááº_á§áá¼á®_áá±_áá½ááº_áá°ááá¯ááº_áá¼áá¯ááº_á ááºáááºáá¬_á¡á±á¬ááºááá¯áá¬_ááá¯áááºáá¬_áá®áááºáá¬'.split('_'), 43719 monthsShort: 'áááº_áá±_áááº_áá¼á®_áá±_áá½ááº_ááá¯ááº_áá¼_á ááº_á¡á±á¬ááº_ááá¯_áá®'.split('_'), 43720 weekdays: 'ááááºá¹ááá½á±_ááááºá¹áá¬_á¡ááºá¹áá«_áá¯áá¹ááá°á¸_áá¼á¬áááá±á¸_áá±á¬áá¼á¬_á áá±'.split('_'), 43721 weekdaysShort: 'áá½á±_áá¬_áá«_áá°á¸_áá¼á¬_áá±á¬_áá±'.split('_'), 43722 weekdaysMin: 'áá½á±_áá¬_áá«_áá°á¸_áá¼á¬_áá±á¬_áá±'.split('_'), 43723 43724 longDateFormat: { 43725 LT: 'HH:mm', 43726 LTS: 'HH:mm:ss', 43727 L: 'DD/MM/YYYY', 43728 LL: 'D MMMM YYYY', 43729 LLL: 'D MMMM YYYY HH:mm', 43730 LLLL: 'dddd D MMMM YYYY HH:mm' 43731 }, 43732 calendar: { 43733 sameDay: '[ááá±.] LT [áá¾á¬]', 43734 nextDay: '[ááááºáá¼ááº] LT [áá¾á¬]', 43735 nextWeek: 'dddd LT [áá¾á¬]', 43736 lastDay: '[ááá±.á] LT [áá¾á¬]', 43737 lastWeek: '[áá¼á®á¸áá²á·áá±á¬] dddd LT [áá¾á¬]', 43738 sameElse: 'L' 43739 }, 43740 relativeTime: { 43741 future: 'áá¬áááºá· %s áá¾á¬', 43742 past: 'áá½ááºáá²á·áá±á¬ %s á', 43743 s: 'á áá¹áááº.á¡áááºá¸áááº', 43744 ss : '%d á áá¹ááá·áº', 43745 m: 'áá áºáááá áº', 43746 mm: '%d áááá áº', 43747 h: 'áá áºáá¬áá®', 43748 hh: '%d áá¬áá®', 43749 d: 'áá áºáááº', 43750 dd: '%d áááº', 43751 M: 'áá áºá', 43752 MM: '%d á', 43753 y: 'áá áºáá¾á áº', 43754 yy: '%d áá¾á áº' 43755 }, 43756 preparse: function (string) { 43757 return string.replace(/[ááááá ááááá]/g, function (match) { 43758 return numberMap[match]; 43759 }); 43760 }, 43761 postformat: function (string) { 43762 return string.replace(/\d/g, function (match) { 43763 return symbolMap[match]; 43764 }); 43765 }, 43766 week: { 43767 dow: 1, // Monday is the first day of the week. 43768 doy: 4 // The week that contains Jan 1st is the first week of the year. 43769 } 43770 }); 43771 43772 return my; 43773 43774}))); 43775 43776 43777/***/ }), 43778/* 111 */ 43779/***/ (function(module, exports, __webpack_require__) { 43780 43781//! moment.js locale configuration 43782 43783;(function (global, factory) { 43784 true ? factory(__webpack_require__(0)) : 43785 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 43786 factory(global.moment) 43787}(this, (function (moment) { 'use strict'; 43788 43789 43790 var nb = moment.defineLocale('nb', { 43791 months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'), 43792 monthsShort : 'jan._feb._mars_april_mai_juni_juli_aug._sep._okt._nov._des.'.split('_'), 43793 monthsParseExact : true, 43794 weekdays : 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'), 43795 weekdaysShort : 'sø._ma._ti._on._to._fr._lø.'.split('_'), 43796 weekdaysMin : 'sø_ma_ti_on_to_fr_lø'.split('_'), 43797 weekdaysParseExact : true, 43798 longDateFormat : { 43799 LT : 'HH:mm', 43800 LTS : 'HH:mm:ss', 43801 L : 'DD.MM.YYYY', 43802 LL : 'D. MMMM YYYY', 43803 LLL : 'D. MMMM YYYY [kl.] HH:mm', 43804 LLLL : 'dddd D. MMMM YYYY [kl.] HH:mm' 43805 }, 43806 calendar : { 43807 sameDay: '[i dag kl.] LT', 43808 nextDay: '[i morgen kl.] LT', 43809 nextWeek: 'dddd [kl.] LT', 43810 lastDay: '[i gÃ¥r kl.] LT', 43811 lastWeek: '[forrige] dddd [kl.] LT', 43812 sameElse: 'L' 43813 }, 43814 relativeTime : { 43815 future : 'om %s', 43816 past : '%s siden', 43817 s : 'noen sekunder', 43818 ss : '%d sekunder', 43819 m : 'ett minutt', 43820 mm : '%d minutter', 43821 h : 'en time', 43822 hh : '%d timer', 43823 d : 'en dag', 43824 dd : '%d dager', 43825 M : 'en mÃ¥ned', 43826 MM : '%d mÃ¥neder', 43827 y : 'ett Ã¥r', 43828 yy : '%d Ã¥r' 43829 }, 43830 dayOfMonthOrdinalParse: /\d{1,2}\./, 43831 ordinal : '%d.', 43832 week : { 43833 dow : 1, // Monday is the first day of the week. 43834 doy : 4 // The week that contains Jan 4th is the first week of the year. 43835 } 43836 }); 43837 43838 return nb; 43839 43840}))); 43841 43842 43843/***/ }), 43844/* 112 */ 43845/***/ (function(module, exports, __webpack_require__) { 43846 43847//! moment.js locale configuration 43848 43849;(function (global, factory) { 43850 true ? factory(__webpack_require__(0)) : 43851 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 43852 factory(global.moment) 43853}(this, (function (moment) { 'use strict'; 43854 43855 43856 var symbolMap = { 43857 '1': '१', 43858 '2': '२', 43859 '3': '३', 43860 '4': '४', 43861 '5': '५', 43862 '6': '६', 43863 '7': 'à¥', 43864 '8': '८', 43865 '9': '९', 43866 '0': '०' 43867 }, 43868 numberMap = { 43869 '१': '1', 43870 '२': '2', 43871 '३': '3', 43872 '४': '4', 43873 '५': '5', 43874 '६': '6', 43875 'à¥': '7', 43876 '८': '8', 43877 '९': '9', 43878 '०': '0' 43879 }; 43880 43881 var ne = moment.defineLocale('ne', { 43882 months : 'à¤à¤¨à¤µà¤°à¥_फà¥à¤¬à¥à¤°à¥à¤µà¤°à¥_मारà¥à¤_ठपà¥à¤°à¤¿à¤²_मà¤_à¤à¥à¤¨_à¤à¥à¤²à¤¾à¤_ठà¤à¤·à¥à¤_सà¥à¤ªà¥à¤à¥à¤®à¥à¤¬à¤°_ठà¤à¥à¤à¥à¤¬à¤°_नà¥à¤à¥à¤®à¥à¤¬à¤°_डिसà¥à¤®à¥à¤¬à¤°'.split('_'), 43883 monthsShort : 'à¤à¤¨._फà¥à¤¬à¥à¤°à¥._मारà¥à¤_ठपà¥à¤°à¤¿._मà¤_à¤à¥à¤¨_à¤à¥à¤²à¤¾à¤._ठà¤._सà¥à¤ªà¥à¤._ठà¤à¥à¤à¥._नà¥à¤à¥._डिसà¥.'.split('_'), 43884 monthsParseExact : true, 43885 weekdays : 'à¤à¤à¤¤à¤¬à¤¾à¤°_सà¥à¤®à¤¬à¤¾à¤°_मà¤à¥à¤à¤²à¤¬à¤¾à¤°_बà¥à¤§à¤¬à¤¾à¤°_बिहिबार_शà¥à¤à¥à¤°à¤¬à¤¾à¤°_शनिबार'.split('_'), 43886 weekdaysShort : 'à¤à¤à¤¤._सà¥à¤®._मà¤à¥à¤à¤²._बà¥à¤§._बिहि._शà¥à¤à¥à¤°._शनि.'.split('_'), 43887 weekdaysMin : 'à¤._सà¥._मà¤._बà¥._बि._शà¥._श.'.split('_'), 43888 weekdaysParseExact : true, 43889 longDateFormat : { 43890 LT : 'Aà¤à¥ h:mm बà¤à¥', 43891 LTS : 'Aà¤à¥ h:mm:ss बà¤à¥', 43892 L : 'DD/MM/YYYY', 43893 LL : 'D MMMM YYYY', 43894 LLL : 'D MMMM YYYY, Aà¤à¥ h:mm बà¤à¥', 43895 LLLL : 'dddd, D MMMM YYYY, Aà¤à¥ h:mm बà¤à¥' 43896 }, 43897 preparse: function (string) { 43898 return string.replace(/[१२३४५६à¥à¥®à¥¯à¥¦]/g, function (match) { 43899 return numberMap[match]; 43900 }); 43901 }, 43902 postformat: function (string) { 43903 return string.replace(/\d/g, function (match) { 43904 return symbolMap[match]; 43905 }); 43906 }, 43907 meridiemParse: /राति|बिहान|दिà¤à¤à¤¸à¥|साà¤à¤/, 43908 meridiemHour : function (hour, meridiem) { 43909 if (hour === 12) { 43910 hour = 0; 43911 } 43912 if (meridiem === 'राति') { 43913 return hour < 4 ? hour : hour + 12; 43914 } else if (meridiem === 'बिहान') { 43915 return hour; 43916 } else if (meridiem === 'दिà¤à¤à¤¸à¥') { 43917 return hour >= 10 ? hour : hour + 12; 43918 } else if (meridiem === 'साà¤à¤') { 43919 return hour + 12; 43920 } 43921 }, 43922 meridiem : function (hour, minute, isLower) { 43923 if (hour < 3) { 43924 return 'राति'; 43925 } else if (hour < 12) { 43926 return 'बिहान'; 43927 } else if (hour < 16) { 43928 return 'दिà¤à¤à¤¸à¥'; 43929 } else if (hour < 20) { 43930 return 'साà¤à¤'; 43931 } else { 43932 return 'राति'; 43933 } 43934 }, 43935 calendar : { 43936 sameDay : '[à¤à¤] LT', 43937 nextDay : '[à¤à¥à¤²à¤¿] LT', 43938 nextWeek : '[à¤à¤à¤à¤¦à¥] dddd[,] LT', 43939 lastDay : '[हिà¤à¥] LT', 43940 lastWeek : '[à¤à¤à¤à¥] dddd[,] LT', 43941 sameElse : 'L' 43942 }, 43943 relativeTime : { 43944 future : '%sमा', 43945 past : '%s ठà¤à¤¾à¤¡à¤¿', 43946 s : 'à¤à¥à¤¹à¥ à¤à¥à¤·à¤£', 43947 ss : '%d सà¥à¤à¥à¤£à¥à¤¡', 43948 m : 'à¤à¤ मिनà¥à¤', 43949 mm : '%d मिनà¥à¤', 43950 h : 'à¤à¤ à¤à¤£à¥à¤à¤¾', 43951 hh : '%d à¤à¤£à¥à¤à¤¾', 43952 d : 'à¤à¤ दिन', 43953 dd : '%d दिन', 43954 M : 'à¤à¤ महिना', 43955 MM : '%d महिना', 43956 y : 'à¤à¤ बरà¥à¤·', 43957 yy : '%d बरà¥à¤·' 43958 }, 43959 week : { 43960 dow : 0, // Sunday is the first day of the week. 43961 doy : 6 // The week that contains Jan 1st is the first week of the year. 43962 } 43963 }); 43964 43965 return ne; 43966 43967}))); 43968 43969 43970/***/ }), 43971/* 113 */ 43972/***/ (function(module, exports, __webpack_require__) { 43973 43974//! moment.js locale configuration 43975 43976;(function (global, factory) { 43977 true ? factory(__webpack_require__(0)) : 43978 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 43979 factory(global.moment) 43980}(this, (function (moment) { 'use strict'; 43981 43982 43983 var monthsShortWithDots = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split('_'), 43984 monthsShortWithoutDots = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_'); 43985 43986 var monthsParse = [/^jan/i, /^feb/i, /^maart|mrt.?$/i, /^apr/i, /^mei$/i, /^jun[i.]?$/i, /^jul[i.]?$/i, /^aug/i, /^sep/i, /^okt/i, /^nov/i, /^dec/i]; 43987 var monthsRegex = /^(januari|februari|maart|april|mei|april|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i; 43988 43989 var nlBe = moment.defineLocale('nl-be', { 43990 months : 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split('_'), 43991 monthsShort : function (m, format) { 43992 if (!m) { 43993 return monthsShortWithDots; 43994 } else if (/-MMM-/.test(format)) { 43995 return monthsShortWithoutDots[m.month()]; 43996 } else { 43997 return monthsShortWithDots[m.month()]; 43998 } 43999 }, 44000 44001 monthsRegex: monthsRegex, 44002 monthsShortRegex: monthsRegex, 44003 monthsStrictRegex: /^(januari|februari|maart|mei|ju[nl]i|april|augustus|september|oktober|november|december)/i, 44004 monthsShortStrictRegex: /^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i, 44005 44006 monthsParse : monthsParse, 44007 longMonthsParse : monthsParse, 44008 shortMonthsParse : monthsParse, 44009 44010 weekdays : 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split('_'), 44011 weekdaysShort : 'zo._ma._di._wo._do._vr._za.'.split('_'), 44012 weekdaysMin : 'zo_ma_di_wo_do_vr_za'.split('_'), 44013 weekdaysParseExact : true, 44014 longDateFormat : { 44015 LT : 'HH:mm', 44016 LTS : 'HH:mm:ss', 44017 L : 'DD/MM/YYYY', 44018 LL : 'D MMMM YYYY', 44019 LLL : 'D MMMM YYYY HH:mm', 44020 LLLL : 'dddd D MMMM YYYY HH:mm' 44021 }, 44022 calendar : { 44023 sameDay: '[vandaag om] LT', 44024 nextDay: '[morgen om] LT', 44025 nextWeek: 'dddd [om] LT', 44026 lastDay: '[gisteren om] LT', 44027 lastWeek: '[afgelopen] dddd [om] LT', 44028 sameElse: 'L' 44029 }, 44030 relativeTime : { 44031 future : 'over %s', 44032 past : '%s geleden', 44033 s : 'een paar seconden', 44034 ss : '%d seconden', 44035 m : 'één minuut', 44036 mm : '%d minuten', 44037 h : 'één uur', 44038 hh : '%d uur', 44039 d : 'één dag', 44040 dd : '%d dagen', 44041 M : 'één maand', 44042 MM : '%d maanden', 44043 y : 'één jaar', 44044 yy : '%d jaar' 44045 }, 44046 dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/, 44047 ordinal : function (number) { 44048 return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de'); 44049 }, 44050 week : { 44051 dow : 1, // Monday is the first day of the week. 44052 doy : 4 // The week that contains Jan 4th is the first week of the year. 44053 } 44054 }); 44055 44056 return nlBe; 44057 44058}))); 44059 44060 44061/***/ }), 44062/* 114 */ 44063/***/ (function(module, exports, __webpack_require__) { 44064 44065//! moment.js locale configuration 44066 44067;(function (global, factory) { 44068 true ? factory(__webpack_require__(0)) : 44069 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 44070 factory(global.moment) 44071}(this, (function (moment) { 'use strict'; 44072 44073 44074 var monthsShortWithDots = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split('_'), 44075 monthsShortWithoutDots = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_'); 44076 44077 var monthsParse = [/^jan/i, /^feb/i, /^maart|mrt.?$/i, /^apr/i, /^mei$/i, /^jun[i.]?$/i, /^jul[i.]?$/i, /^aug/i, /^sep/i, /^okt/i, /^nov/i, /^dec/i]; 44078 var monthsRegex = /^(januari|februari|maart|april|mei|april|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i; 44079 44080 var nl = moment.defineLocale('nl', { 44081 months : 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split('_'), 44082 monthsShort : function (m, format) { 44083 if (!m) { 44084 return monthsShortWithDots; 44085 } else if (/-MMM-/.test(format)) { 44086 return monthsShortWithoutDots[m.month()]; 44087 } else { 44088 return monthsShortWithDots[m.month()]; 44089 } 44090 }, 44091 44092 monthsRegex: monthsRegex, 44093 monthsShortRegex: monthsRegex, 44094 monthsStrictRegex: /^(januari|februari|maart|mei|ju[nl]i|april|augustus|september|oktober|november|december)/i, 44095 monthsShortStrictRegex: /^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i, 44096 44097 monthsParse : monthsParse, 44098 longMonthsParse : monthsParse, 44099 shortMonthsParse : monthsParse, 44100 44101 weekdays : 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split('_'), 44102 weekdaysShort : 'zo._ma._di._wo._do._vr._za.'.split('_'), 44103 weekdaysMin : 'zo_ma_di_wo_do_vr_za'.split('_'), 44104 weekdaysParseExact : true, 44105 longDateFormat : { 44106 LT : 'HH:mm', 44107 LTS : 'HH:mm:ss', 44108 L : 'DD-MM-YYYY', 44109 LL : 'D MMMM YYYY', 44110 LLL : 'D MMMM YYYY HH:mm', 44111 LLLL : 'dddd D MMMM YYYY HH:mm' 44112 }, 44113 calendar : { 44114 sameDay: '[vandaag om] LT', 44115 nextDay: '[morgen om] LT', 44116 nextWeek: 'dddd [om] LT', 44117 lastDay: '[gisteren om] LT', 44118 lastWeek: '[afgelopen] dddd [om] LT', 44119 sameElse: 'L' 44120 }, 44121 relativeTime : { 44122 future : 'over %s', 44123 past : '%s geleden', 44124 s : 'een paar seconden', 44125 ss : '%d seconden', 44126 m : 'één minuut', 44127 mm : '%d minuten', 44128 h : 'één uur', 44129 hh : '%d uur', 44130 d : 'één dag', 44131 dd : '%d dagen', 44132 M : 'één maand', 44133 MM : '%d maanden', 44134 y : 'één jaar', 44135 yy : '%d jaar' 44136 }, 44137 dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/, 44138 ordinal : function (number) { 44139 return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de'); 44140 }, 44141 week : { 44142 dow : 1, // Monday is the first day of the week. 44143 doy : 4 // The week that contains Jan 4th is the first week of the year. 44144 } 44145 }); 44146 44147 return nl; 44148 44149}))); 44150 44151 44152/***/ }), 44153/* 115 */ 44154/***/ (function(module, exports, __webpack_require__) { 44155 44156//! moment.js locale configuration 44157 44158;(function (global, factory) { 44159 true ? factory(__webpack_require__(0)) : 44160 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 44161 factory(global.moment) 44162}(this, (function (moment) { 'use strict'; 44163 44164 44165 var nn = moment.defineLocale('nn', { 44166 months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'), 44167 monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'), 44168 weekdays : 'sundag_mÃ¥ndag_tysdag_onsdag_torsdag_fredag_laurdag'.split('_'), 44169 weekdaysShort : 'sun_mÃ¥n_tys_ons_tor_fre_lau'.split('_'), 44170 weekdaysMin : 'su_mÃ¥_ty_on_to_fr_lø'.split('_'), 44171 longDateFormat : { 44172 LT : 'HH:mm', 44173 LTS : 'HH:mm:ss', 44174 L : 'DD.MM.YYYY', 44175 LL : 'D. MMMM YYYY', 44176 LLL : 'D. MMMM YYYY [kl.] H:mm', 44177 LLLL : 'dddd D. MMMM YYYY [kl.] HH:mm' 44178 }, 44179 calendar : { 44180 sameDay: '[I dag klokka] LT', 44181 nextDay: '[I morgon klokka] LT', 44182 nextWeek: 'dddd [klokka] LT', 44183 lastDay: '[I gÃ¥r klokka] LT', 44184 lastWeek: '[FøregÃ¥ande] dddd [klokka] LT', 44185 sameElse: 'L' 44186 }, 44187 relativeTime : { 44188 future : 'om %s', 44189 past : '%s sidan', 44190 s : 'nokre sekund', 44191 ss : '%d sekund', 44192 m : 'eit minutt', 44193 mm : '%d minutt', 44194 h : 'ein time', 44195 hh : '%d timar', 44196 d : 'ein dag', 44197 dd : '%d dagar', 44198 M : 'ein mÃ¥nad', 44199 MM : '%d mÃ¥nader', 44200 y : 'eit Ã¥r', 44201 yy : '%d Ã¥r' 44202 }, 44203 dayOfMonthOrdinalParse: /\d{1,2}\./, 44204 ordinal : '%d.', 44205 week : { 44206 dow : 1, // Monday is the first day of the week. 44207 doy : 4 // The week that contains Jan 4th is the first week of the year. 44208 } 44209 }); 44210 44211 return nn; 44212 44213}))); 44214 44215 44216/***/ }), 44217/* 116 */ 44218/***/ (function(module, exports, __webpack_require__) { 44219 44220//! moment.js locale configuration 44221 44222;(function (global, factory) { 44223 true ? factory(__webpack_require__(0)) : 44224 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 44225 factory(global.moment) 44226}(this, (function (moment) { 'use strict'; 44227 44228 44229 var symbolMap = { 44230 '1': '੧', 44231 '2': '੨', 44232 '3': 'à©©', 44233 '4': '੪', 44234 '5': 'à©«', 44235 '6': '੬', 44236 '7': 'à©', 44237 '8': 'à©®', 44238 '9': '੯', 44239 '0': '੦' 44240 }, 44241 numberMap = { 44242 '੧': '1', 44243 '੨': '2', 44244 'à©©': '3', 44245 '੪': '4', 44246 'à©«': '5', 44247 '੬': '6', 44248 'à©': '7', 44249 'à©®': '8', 44250 '੯': '9', 44251 '੦': '0' 44252 }; 44253 44254 var paIn = moment.defineLocale('pa-in', { 44255 // There are months name as per Nanakshahi Calender but they are not used as rigidly in modern Punjabi. 44256 months : 'à¨à¨¨à¨µà¨°à©_ਫ਼ਰਵਰà©_ਮਾਰà¨_ਠਪà©à¨°à©à¨²_ਮà¨_à¨à©à¨¨_à¨à©à¨²à¨¾à¨_ਠà¨à¨¸à¨¤_ਸਤੰਬਰ_ਠà¨à¨¤à©à¨¬à¨°_ਨਵੰਬਰ_ਦਸੰਬਰ'.split('_'), 44257 monthsShort : 'à¨à¨¨à¨µà¨°à©_ਫ਼ਰਵਰà©_ਮਾਰà¨_ਠਪà©à¨°à©à¨²_ਮà¨_à¨à©à¨¨_à¨à©à¨²à¨¾à¨_ਠà¨à¨¸à¨¤_ਸਤੰਬਰ_ਠà¨à¨¤à©à¨¬à¨°_ਨਵੰਬਰ_ਦਸੰਬਰ'.split('_'), 44258 weekdays : 'à¨à¨¤à¨µà¨¾à¨°_ਸà©à¨®à¨µà¨¾à¨°_ਮੰà¨à¨²à¨µà¨¾à¨°_ਬà©à¨§à¨µà¨¾à¨°_ਵà©à¨°à¨µà¨¾à¨°_ਸ਼à©à©±à¨à¨°à¨µà¨¾à¨°_ਸ਼ਨà©à¨à¨°à¨µà¨¾à¨°'.split('_'), 44259 weekdaysShort : 'à¨à¨¤_ਸà©à¨®_ਮੰà¨à¨²_ਬà©à¨§_ਵà©à¨°_ਸ਼à©à¨à¨°_ਸ਼ਨà©'.split('_'), 44260 weekdaysMin : 'à¨à¨¤_ਸà©à¨®_ਮੰà¨à¨²_ਬà©à¨§_ਵà©à¨°_ਸ਼à©à¨à¨°_ਸ਼ਨà©'.split('_'), 44261 longDateFormat : { 44262 LT : 'A h:mm ਵà¨à©', 44263 LTS : 'A h:mm:ss ਵà¨à©', 44264 L : 'DD/MM/YYYY', 44265 LL : 'D MMMM YYYY', 44266 LLL : 'D MMMM YYYY, A h:mm ਵà¨à©', 44267 LLLL : 'dddd, D MMMM YYYY, A h:mm ਵà¨à©' 44268 }, 44269 calendar : { 44270 sameDay : '[ਠà¨] LT', 44271 nextDay : '[à¨à¨²] LT', 44272 nextWeek : '[ਠà¨à¨²à¨¾] dddd, LT', 44273 lastDay : '[à¨à¨²] LT', 44274 lastWeek : '[ਪਿà¨à¨²à©] dddd, LT', 44275 sameElse : 'L' 44276 }, 44277 relativeTime : { 44278 future : '%s ਵਿੱà¨', 44279 past : '%s ਪਿà¨à¨²à©', 44280 s : 'à¨à©à¨ ਸà¨à¨¿à©°à¨', 44281 ss : '%d ਸà¨à¨¿à©°à¨', 44282 m : 'à¨à¨ ਮਿੰà¨', 44283 mm : '%d ਮਿੰà¨', 44284 h : 'à¨à©±à¨ à¨à©°à¨à¨¾', 44285 hh : '%d à¨à©°à¨à©', 44286 d : 'à¨à©±à¨ ਦਿਨ', 44287 dd : '%d ਦਿਨ', 44288 M : 'à¨à©±à¨ ਮਹà©à¨¨à¨¾', 44289 MM : '%d ਮਹà©à¨¨à©', 44290 y : 'à¨à©±à¨ ਸਾਲ', 44291 yy : '%d ਸਾਲ' 44292 }, 44293 preparse: function (string) { 44294 return string.replace(/[੧੨੩੪੫੬à©à©®à©¯à©¦]/g, function (match) { 44295 return numberMap[match]; 44296 }); 44297 }, 44298 postformat: function (string) { 44299 return string.replace(/\d/g, function (match) { 44300 return symbolMap[match]; 44301 }); 44302 }, 44303 // Punjabi notation for meridiems are quite fuzzy in practice. While there exists 44304 // a rigid notion of a 'Pahar' it is not used as rigidly in modern Punjabi. 44305 meridiemParse: /ਰਾਤ|ਸਵà©à¨°|ਦà©à¨ªà¨¹à¨¿à¨°|ਸ਼ਾਮ/, 44306 meridiemHour : function (hour, meridiem) { 44307 if (hour === 12) { 44308 hour = 0; 44309 } 44310 if (meridiem === 'ਰਾਤ') { 44311 return hour < 4 ? hour : hour + 12; 44312 } else if (meridiem === 'ਸਵà©à¨°') { 44313 return hour; 44314 } else if (meridiem === 'ਦà©à¨ªà¨¹à¨¿à¨°') { 44315 return hour >= 10 ? hour : hour + 12; 44316 } else if (meridiem === 'ਸ਼ਾਮ') { 44317 return hour + 12; 44318 } 44319 }, 44320 meridiem : function (hour, minute, isLower) { 44321 if (hour < 4) { 44322 return 'ਰਾਤ'; 44323 } else if (hour < 10) { 44324 return 'ਸਵà©à¨°'; 44325 } else if (hour < 17) { 44326 return 'ਦà©à¨ªà¨¹à¨¿à¨°'; 44327 } else if (hour < 20) { 44328 return 'ਸ਼ਾਮ'; 44329 } else { 44330 return 'ਰਾਤ'; 44331 } 44332 }, 44333 week : { 44334 dow : 0, // Sunday is the first day of the week. 44335 doy : 6 // The week that contains Jan 1st is the first week of the year. 44336 } 44337 }); 44338 44339 return paIn; 44340 44341}))); 44342 44343 44344/***/ }), 44345/* 117 */ 44346/***/ (function(module, exports, __webpack_require__) { 44347 44348//! moment.js locale configuration 44349 44350;(function (global, factory) { 44351 true ? factory(__webpack_require__(0)) : 44352 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 44353 factory(global.moment) 44354}(this, (function (moment) { 'use strict'; 44355 44356 44357 var monthsNominative = 'styczeÅ_luty_marzec_kwiecieÅ_maj_czerwiec_lipiec_sierpieÅ_wrzesieÅ_październik_listopad_grudzieÅ'.split('_'), 44358 monthsSubjective = 'stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_wrzeÅnia_października_listopada_grudnia'.split('_'); 44359 function plural(n) { 44360 return (n % 10 < 5) && (n % 10 > 1) && ((~~(n / 10) % 10) !== 1); 44361 } 44362 function translate(number, withoutSuffix, key) { 44363 var result = number + ' '; 44364 switch (key) { 44365 case 'ss': 44366 return result + (plural(number) ? 'sekundy' : 'sekund'); 44367 case 'm': 44368 return withoutSuffix ? 'minuta' : 'minutÄ'; 44369 case 'mm': 44370 return result + (plural(number) ? 'minuty' : 'minut'); 44371 case 'h': 44372 return withoutSuffix ? 'godzina' : 'godzinÄ'; 44373 case 'hh': 44374 return result + (plural(number) ? 'godziny' : 'godzin'); 44375 case 'MM': 44376 return result + (plural(number) ? 'miesiÄ ce' : 'miesiÄcy'); 44377 case 'yy': 44378 return result + (plural(number) ? 'lata' : 'lat'); 44379 } 44380 } 44381 44382 var pl = moment.defineLocale('pl', { 44383 months : function (momentToFormat, format) { 44384 if (!momentToFormat) { 44385 return monthsNominative; 44386 } else if (format === '') { 44387 // Hack: if format empty we know this is used to generate 44388 // RegExp by moment. Give then back both valid forms of months 44389 // in RegExp ready format. 44390 return '(' + monthsSubjective[momentToFormat.month()] + '|' + monthsNominative[momentToFormat.month()] + ')'; 44391 } else if (/D MMMM/.test(format)) { 44392 return monthsSubjective[momentToFormat.month()]; 44393 } else { 44394 return monthsNominative[momentToFormat.month()]; 44395 } 44396 }, 44397 monthsShort : 'sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paź_lis_gru'.split('_'), 44398 weekdays : 'niedziela_poniedziaÅek_wtorek_Åroda_czwartek_piÄ tek_sobota'.split('_'), 44399 weekdaysShort : 'ndz_pon_wt_År_czw_pt_sob'.split('_'), 44400 weekdaysMin : 'Nd_Pn_Wt_År_Cz_Pt_So'.split('_'), 44401 longDateFormat : { 44402 LT : 'HH:mm', 44403 LTS : 'HH:mm:ss', 44404 L : 'DD.MM.YYYY', 44405 LL : 'D MMMM YYYY', 44406 LLL : 'D MMMM YYYY HH:mm', 44407 LLLL : 'dddd, D MMMM YYYY HH:mm' 44408 }, 44409 calendar : { 44410 sameDay: '[DziÅ o] LT', 44411 nextDay: '[Jutro o] LT', 44412 nextWeek: function () { 44413 switch (this.day()) { 44414 case 0: 44415 return '[W niedzielÄ o] LT'; 44416 44417 case 2: 44418 return '[We wtorek o] LT'; 44419 44420 case 3: 44421 return '[W ÅrodÄ o] LT'; 44422 44423 case 6: 44424 return '[W sobotÄ o] LT'; 44425 44426 default: 44427 return '[W] dddd [o] LT'; 44428 } 44429 }, 44430 lastDay: '[Wczoraj o] LT', 44431 lastWeek: function () { 44432 switch (this.day()) { 44433 case 0: 44434 return '[W zeszÅÄ niedzielÄ o] LT'; 44435 case 3: 44436 return '[W zeszÅÄ ÅrodÄ o] LT'; 44437 case 6: 44438 return '[W zeszÅÄ sobotÄ o] LT'; 44439 default: 44440 return '[W zeszÅy] dddd [o] LT'; 44441 } 44442 }, 44443 sameElse: 'L' 44444 }, 44445 relativeTime : { 44446 future : 'za %s', 44447 past : '%s temu', 44448 s : 'kilka sekund', 44449 ss : translate, 44450 m : translate, 44451 mm : translate, 44452 h : translate, 44453 hh : translate, 44454 d : '1 dzieÅ', 44455 dd : '%d dni', 44456 M : 'miesiÄ c', 44457 MM : translate, 44458 y : 'rok', 44459 yy : translate 44460 }, 44461 dayOfMonthOrdinalParse: /\d{1,2}\./, 44462 ordinal : '%d.', 44463 week : { 44464 dow : 1, // Monday is the first day of the week. 44465 doy : 4 // The week that contains Jan 4th is the first week of the year. 44466 } 44467 }); 44468 44469 return pl; 44470 44471}))); 44472 44473 44474/***/ }), 44475/* 118 */ 44476/***/ (function(module, exports, __webpack_require__) { 44477 44478//! moment.js locale configuration 44479 44480;(function (global, factory) { 44481 true ? factory(__webpack_require__(0)) : 44482 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 44483 factory(global.moment) 44484}(this, (function (moment) { 'use strict'; 44485 44486 44487 var ptBr = moment.defineLocale('pt-br', { 44488 months : 'janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro'.split('_'), 44489 monthsShort : 'jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez'.split('_'), 44490 weekdays : 'Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado'.split('_'), 44491 weekdaysShort : 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'), 44492 weekdaysMin : 'Do_2ª_3ª_4ª_5ª_6ª_Sá'.split('_'), 44493 weekdaysParseExact : true, 44494 longDateFormat : { 44495 LT : 'HH:mm', 44496 LTS : 'HH:mm:ss', 44497 L : 'DD/MM/YYYY', 44498 LL : 'D [de] MMMM [de] YYYY', 44499 LLL : 'D [de] MMMM [de] YYYY [à s] HH:mm', 44500 LLLL : 'dddd, D [de] MMMM [de] YYYY [à s] HH:mm' 44501 }, 44502 calendar : { 44503 sameDay: '[Hoje à s] LT', 44504 nextDay: '[Amanhã à s] LT', 44505 nextWeek: 'dddd [à s] LT', 44506 lastDay: '[Ontem à s] LT', 44507 lastWeek: function () { 44508 return (this.day() === 0 || this.day() === 6) ? 44509 '[Ãltimo] dddd [à s] LT' : // Saturday + Sunday 44510 '[Ãltima] dddd [à s] LT'; // Monday - Friday 44511 }, 44512 sameElse: 'L' 44513 }, 44514 relativeTime : { 44515 future : 'em %s', 44516 past : 'há %s', 44517 s : 'poucos segundos', 44518 ss : '%d segundos', 44519 m : 'um minuto', 44520 mm : '%d minutos', 44521 h : 'uma hora', 44522 hh : '%d horas', 44523 d : 'um dia', 44524 dd : '%d dias', 44525 M : 'um mês', 44526 MM : '%d meses', 44527 y : 'um ano', 44528 yy : '%d anos' 44529 }, 44530 dayOfMonthOrdinalParse: /\d{1,2}º/, 44531 ordinal : '%dº' 44532 }); 44533 44534 return ptBr; 44535 44536}))); 44537 44538 44539/***/ }), 44540/* 119 */ 44541/***/ (function(module, exports, __webpack_require__) { 44542 44543//! moment.js locale configuration 44544 44545;(function (global, factory) { 44546 true ? factory(__webpack_require__(0)) : 44547 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 44548 factory(global.moment) 44549}(this, (function (moment) { 'use strict'; 44550 44551 44552 var pt = moment.defineLocale('pt', { 44553 months : 'janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro'.split('_'), 44554 monthsShort : 'jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez'.split('_'), 44555 weekdays : 'Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado'.split('_'), 44556 weekdaysShort : 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'), 44557 weekdaysMin : 'Do_2ª_3ª_4ª_5ª_6ª_Sá'.split('_'), 44558 weekdaysParseExact : true, 44559 longDateFormat : { 44560 LT : 'HH:mm', 44561 LTS : 'HH:mm:ss', 44562 L : 'DD/MM/YYYY', 44563 LL : 'D [de] MMMM [de] YYYY', 44564 LLL : 'D [de] MMMM [de] YYYY HH:mm', 44565 LLLL : 'dddd, D [de] MMMM [de] YYYY HH:mm' 44566 }, 44567 calendar : { 44568 sameDay: '[Hoje à s] LT', 44569 nextDay: '[Amanhã à s] LT', 44570 nextWeek: 'dddd [à s] LT', 44571 lastDay: '[Ontem à s] LT', 44572 lastWeek: function () { 44573 return (this.day() === 0 || this.day() === 6) ? 44574 '[Ãltimo] dddd [à s] LT' : // Saturday + Sunday 44575 '[Ãltima] dddd [à s] LT'; // Monday - Friday 44576 }, 44577 sameElse: 'L' 44578 }, 44579 relativeTime : { 44580 future : 'em %s', 44581 past : 'há %s', 44582 s : 'segundos', 44583 ss : '%d segundos', 44584 m : 'um minuto', 44585 mm : '%d minutos', 44586 h : 'uma hora', 44587 hh : '%d horas', 44588 d : 'um dia', 44589 dd : '%d dias', 44590 M : 'um mês', 44591 MM : '%d meses', 44592 y : 'um ano', 44593 yy : '%d anos' 44594 }, 44595 dayOfMonthOrdinalParse: /\d{1,2}º/, 44596 ordinal : '%dº', 44597 week : { 44598 dow : 1, // Monday is the first day of the week. 44599 doy : 4 // The week that contains Jan 4th is the first week of the year. 44600 } 44601 }); 44602 44603 return pt; 44604 44605}))); 44606 44607 44608/***/ }), 44609/* 120 */ 44610/***/ (function(module, exports, __webpack_require__) { 44611 44612//! moment.js locale configuration 44613 44614;(function (global, factory) { 44615 true ? factory(__webpack_require__(0)) : 44616 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 44617 factory(global.moment) 44618}(this, (function (moment) { 'use strict'; 44619 44620 44621 function relativeTimeWithPlural(number, withoutSuffix, key) { 44622 var format = { 44623 'ss': 'secunde', 44624 'mm': 'minute', 44625 'hh': 'ore', 44626 'dd': 'zile', 44627 'MM': 'luni', 44628 'yy': 'ani' 44629 }, 44630 separator = ' '; 44631 if (number % 100 >= 20 || (number >= 100 && number % 100 === 0)) { 44632 separator = ' de '; 44633 } 44634 return number + separator + format[key]; 44635 } 44636 44637 var ro = moment.defineLocale('ro', { 44638 months : 'ianuarie_februarie_martie_aprilie_mai_iunie_iulie_august_septembrie_octombrie_noiembrie_decembrie'.split('_'), 44639 monthsShort : 'ian._febr._mart._apr._mai_iun._iul._aug._sept._oct._nov._dec.'.split('_'), 44640 monthsParseExact: true, 44641 weekdays : 'duminicÄ_luni_marÈi_miercuri_joi_vineri_sâmbÄtÄ'.split('_'), 44642 weekdaysShort : 'Dum_Lun_Mar_Mie_Joi_Vin_Sâm'.split('_'), 44643 weekdaysMin : 'Du_Lu_Ma_Mi_Jo_Vi_Sâ'.split('_'), 44644 longDateFormat : { 44645 LT : 'H:mm', 44646 LTS : 'H:mm:ss', 44647 L : 'DD.MM.YYYY', 44648 LL : 'D MMMM YYYY', 44649 LLL : 'D MMMM YYYY H:mm', 44650 LLLL : 'dddd, D MMMM YYYY H:mm' 44651 }, 44652 calendar : { 44653 sameDay: '[azi la] LT', 44654 nextDay: '[mâine la] LT', 44655 nextWeek: 'dddd [la] LT', 44656 lastDay: '[ieri la] LT', 44657 lastWeek: '[fosta] dddd [la] LT', 44658 sameElse: 'L' 44659 }, 44660 relativeTime : { 44661 future : 'peste %s', 44662 past : '%s în urmÄ', 44663 s : 'câteva secunde', 44664 ss : relativeTimeWithPlural, 44665 m : 'un minut', 44666 mm : relativeTimeWithPlural, 44667 h : 'o orÄ', 44668 hh : relativeTimeWithPlural, 44669 d : 'o zi', 44670 dd : relativeTimeWithPlural, 44671 M : 'o lunÄ', 44672 MM : relativeTimeWithPlural, 44673 y : 'un an', 44674 yy : relativeTimeWithPlural 44675 }, 44676 week : { 44677 dow : 1, // Monday is the first day of the week. 44678 doy : 7 // The week that contains Jan 1st is the first week of the year. 44679 } 44680 }); 44681 44682 return ro; 44683 44684}))); 44685 44686 44687/***/ }), 44688/* 121 */ 44689/***/ (function(module, exports, __webpack_require__) { 44690 44691//! moment.js locale configuration 44692 44693;(function (global, factory) { 44694 true ? factory(__webpack_require__(0)) : 44695 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 44696 factory(global.moment) 44697}(this, (function (moment) { 'use strict'; 44698 44699 44700 function plural(word, num) { 44701 var forms = word.split('_'); 44702 return num % 10 === 1 && num % 100 !== 11 ? forms[0] : (num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]); 44703 } 44704 function relativeTimeWithPlural(number, withoutSuffix, key) { 44705 var format = { 44706 'ss': withoutSuffix ? 'ÑекÑнда_ÑекÑндÑ_ÑекÑнд' : 'ÑекÑндÑ_ÑекÑндÑ_ÑекÑнд', 44707 'mm': withoutSuffix ? 'минÑÑа_минÑÑÑ_минÑÑ' : 'минÑÑÑ_минÑÑÑ_минÑÑ', 44708 'hh': 'ÑаÑ_ÑаÑа_ÑаÑов', 44709 'dd': 'денÑ_днÑ_дней', 44710 'MM': 'меÑÑÑ_меÑÑÑа_меÑÑÑев', 44711 'yy': 'год_года_леÑ' 44712 }; 44713 if (key === 'm') { 44714 return withoutSuffix ? 'минÑÑа' : 'минÑÑÑ'; 44715 } 44716 else { 44717 return number + ' ' + plural(format[key], +number); 44718 } 44719 } 44720 var monthsParse = [/^Ñнв/i, /^Ñев/i, /^маÑ/i, /^апÑ/i, /^ма[йÑ]/i, /^иÑн/i, /^иÑл/i, /^авг/i, /^Ñен/i, /^окÑ/i, /^ноÑ/i, /^дек/i]; 44721 44722 // http://new.gramota.ru/spravka/rules/139-prop : § 103 44723 // СокÑаÑÐµÐ½Ð¸Ñ Ð¼ÐµÑÑÑев: http://new.gramota.ru/spravka/buro/search-answer?s=242637 44724 // CLDR data: http://www.unicode.org/cldr/charts/28/summary/ru.html#1753 44725 var ru = moment.defineLocale('ru', { 44726 months : { 44727 format: 'ÑнваÑÑ_ÑевÑалÑ_маÑÑа_апÑелÑ_маÑ_иÑнÑ_иÑлÑ_авгÑÑÑа_ÑенÑÑбÑÑ_окÑÑбÑÑ_ноÑбÑÑ_декабÑÑ'.split('_'), 44728 standalone: 'ÑнваÑÑ_ÑевÑалÑ_маÑÑ_апÑелÑ_май_иÑнÑ_иÑлÑ_авгÑÑÑ_ÑенÑÑбÑÑ_окÑÑбÑÑ_ноÑбÑÑ_декабÑÑ'.split('_') 44729 }, 44730 monthsShort : { 44731 // по CLDR именно "иÑл." и "иÑн.", но какой ÑмÑÑл менÑÑÑ Ð±ÑÐºÐ²Ñ Ð½Ð° ÑоÑÐºÑ ? 44732 format: 'Ñнв._ÑевÑ._маÑ._апÑ._маÑ_иÑнÑ_иÑлÑ_авг._ÑенÑ._окÑ._ноÑб._дек.'.split('_'), 44733 standalone: 'Ñнв._ÑевÑ._маÑÑ_апÑ._май_иÑнÑ_иÑлÑ_авг._ÑенÑ._окÑ._ноÑб._дек.'.split('_') 44734 }, 44735 weekdays : { 44736 standalone: 'воÑкÑеÑенÑе_понеделÑник_вÑоÑник_ÑÑеда_ÑеÑвеÑг_пÑÑниÑа_ÑÑббоÑа'.split('_'), 44737 format: 'воÑкÑеÑенÑе_понеделÑник_вÑоÑник_ÑÑедÑ_ÑеÑвеÑг_пÑÑниÑÑ_ÑÑббоÑÑ'.split('_'), 44738 isFormat: /\[ ?[Ðв] ?(?:пÑоÑлÑÑ|ÑледÑÑÑÑÑ|ÑÑÑ)? ?\] ?dddd/ 44739 }, 44740 weekdaysShort : 'вÑ_пн_вÑ_ÑÑ_ÑÑ_пÑ_Ñб'.split('_'), 44741 weekdaysMin : 'вÑ_пн_вÑ_ÑÑ_ÑÑ_пÑ_Ñб'.split('_'), 44742 monthsParse : monthsParse, 44743 longMonthsParse : monthsParse, 44744 shortMonthsParse : monthsParse, 44745 44746 // полнÑе Ð½Ð°Ð·Ð²Ð°Ð½Ð¸Ñ Ñ Ð¿Ð°Ð´ÐµÐ¶Ð°Ð¼Ð¸, по ÑÑи бÑквÑ, Ð´Ð»Ñ Ð½ÐµÐºÐ¾ÑоÑÑÑ , по 4 бÑквÑ, ÑокÑаÑÐµÐ½Ð¸Ñ Ñ ÑоÑкой и без ÑоÑки 44747 monthsRegex: /^(ÑнваÑ[ÑÑ]|Ñнв\.?|ÑевÑал[ÑÑ]|ÑевÑ?\.?|маÑÑа?|маÑ\.?|апÑел[ÑÑ]|апÑ\.?|ма[йÑ]|иÑн[ÑÑ]|иÑн\.?|иÑл[ÑÑ]|иÑл\.?|авгÑÑÑа?|авг\.?|ÑенÑÑбÑ[ÑÑ]|ÑенÑ?\.?|окÑÑбÑ[ÑÑ]|окÑ\.?|ноÑбÑ[ÑÑ]|ноÑб?\.?|декабÑ[ÑÑ]|дек\.?)/i, 44748 44749 // ÐºÐ¾Ð¿Ð¸Ñ Ð¿ÑедÑдÑÑего 44750 monthsShortRegex: /^(ÑнваÑ[ÑÑ]|Ñнв\.?|ÑевÑал[ÑÑ]|ÑевÑ?\.?|маÑÑа?|маÑ\.?|апÑел[ÑÑ]|апÑ\.?|ма[йÑ]|иÑн[ÑÑ]|иÑн\.?|иÑл[ÑÑ]|иÑл\.?|авгÑÑÑа?|авг\.?|ÑенÑÑбÑ[ÑÑ]|ÑенÑ?\.?|окÑÑбÑ[ÑÑ]|окÑ\.?|ноÑбÑ[ÑÑ]|ноÑб?\.?|декабÑ[ÑÑ]|дек\.?)/i, 44751 44752 // полнÑе Ð½Ð°Ð·Ð²Ð°Ð½Ð¸Ñ Ñ Ð¿Ð°Ð´ÐµÐ¶Ð°Ð¼Ð¸ 44753 monthsStrictRegex: /^(ÑнваÑ[ÑÑ]|ÑевÑал[ÑÑ]|маÑÑа?|апÑел[ÑÑ]|ма[Ñй]|иÑн[ÑÑ]|иÑл[ÑÑ]|авгÑÑÑа?|ÑенÑÑбÑ[ÑÑ]|окÑÑбÑ[ÑÑ]|ноÑбÑ[ÑÑ]|декабÑ[ÑÑ])/i, 44754 44755 // ÐÑÑажение, коÑоÑое ÑооÑвеÑÑвÑÐµÑ ÑолÑко ÑокÑаÑÑннÑм ÑоÑмам 44756 monthsShortStrictRegex: /^(Ñнв\.|ÑевÑ?\.|маÑ[Ñ.]|апÑ\.|ма[Ñй]|иÑн[ÑÑ.]|иÑл[ÑÑ.]|авг\.|ÑенÑ?\.|окÑ\.|ноÑб?\.|дек\.)/i, 44757 longDateFormat : { 44758 LT : 'H:mm', 44759 LTS : 'H:mm:ss', 44760 L : 'DD.MM.YYYY', 44761 LL : 'D MMMM YYYY г.', 44762 LLL : 'D MMMM YYYY г., H:mm', 44763 LLLL : 'dddd, D MMMM YYYY г., H:mm' 44764 }, 44765 calendar : { 44766 sameDay: '[СегоднÑ, в] LT', 44767 nextDay: '[ÐавÑÑа, в] LT', 44768 lastDay: '[ÐÑеÑа, в] LT', 44769 nextWeek: function (now) { 44770 if (now.week() !== this.week()) { 44771 switch (this.day()) { 44772 case 0: 44773 return '[Ð ÑледÑÑÑее] dddd, [в] LT'; 44774 case 1: 44775 case 2: 44776 case 4: 44777 return '[Ð ÑледÑÑÑий] dddd, [в] LT'; 44778 case 3: 44779 case 5: 44780 case 6: 44781 return '[Ð ÑледÑÑÑÑÑ] dddd, [в] LT'; 44782 } 44783 } else { 44784 if (this.day() === 2) { 44785 return '[Ðо] dddd, [в] LT'; 44786 } else { 44787 return '[Ð] dddd, [в] LT'; 44788 } 44789 } 44790 }, 44791 lastWeek: function (now) { 44792 if (now.week() !== this.week()) { 44793 switch (this.day()) { 44794 case 0: 44795 return '[РпÑоÑлое] dddd, [в] LT'; 44796 case 1: 44797 case 2: 44798 case 4: 44799 return '[РпÑоÑлÑй] dddd, [в] LT'; 44800 case 3: 44801 case 5: 44802 case 6: 44803 return '[РпÑоÑлÑÑ] dddd, [в] LT'; 44804 } 44805 } else { 44806 if (this.day() === 2) { 44807 return '[Ðо] dddd, [в] LT'; 44808 } else { 44809 return '[Ð] dddd, [в] LT'; 44810 } 44811 } 44812 }, 44813 sameElse: 'L' 44814 }, 44815 relativeTime : { 44816 future : 'ÑеÑез %s', 44817 past : '%s назад', 44818 s : 'неÑколÑко ÑекÑнд', 44819 ss : relativeTimeWithPlural, 44820 m : relativeTimeWithPlural, 44821 mm : relativeTimeWithPlural, 44822 h : 'ÑаÑ', 44823 hh : relativeTimeWithPlural, 44824 d : 'денÑ', 44825 dd : relativeTimeWithPlural, 44826 M : 'меÑÑÑ', 44827 MM : relativeTimeWithPlural, 44828 y : 'год', 44829 yy : relativeTimeWithPlural 44830 }, 44831 meridiemParse: /ноÑи|ÑÑÑа|днÑ|веÑеÑа/i, 44832 isPM : function (input) { 44833 return /^(днÑ|веÑеÑа)$/.test(input); 44834 }, 44835 meridiem : function (hour, minute, isLower) { 44836 if (hour < 4) { 44837 return 'ноÑи'; 44838 } else if (hour < 12) { 44839 return 'ÑÑÑа'; 44840 } else if (hour < 17) { 44841 return 'днÑ'; 44842 } else { 44843 return 'веÑеÑа'; 44844 } 44845 }, 44846 dayOfMonthOrdinalParse: /\d{1,2}-(й|го|Ñ)/, 44847 ordinal: function (number, period) { 44848 switch (period) { 44849 case 'M': 44850 case 'd': 44851 case 'DDD': 44852 return number + '-й'; 44853 case 'D': 44854 return number + '-го'; 44855 case 'w': 44856 case 'W': 44857 return number + '-Ñ'; 44858 default: 44859 return number; 44860 } 44861 }, 44862 week : { 44863 dow : 1, // Monday is the first day of the week. 44864 doy : 4 // The week that contains Jan 4th is the first week of the year. 44865 } 44866 }); 44867 44868 return ru; 44869 44870}))); 44871 44872 44873/***/ }), 44874/* 122 */ 44875/***/ (function(module, exports, __webpack_require__) { 44876 44877//! moment.js locale configuration 44878 44879;(function (global, factory) { 44880 true ? factory(__webpack_require__(0)) : 44881 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 44882 factory(global.moment) 44883}(this, (function (moment) { 'use strict'; 44884 44885 44886 var months = [ 44887 'جÙÙرÙ', 44888 'ÙÙبرÙرÙ', 44889 '٠ارÚ', 44890 'اپرÙÙ', 44891 '٠ئÙ', 44892 'جÙÙ', 44893 'جÙÙاءÙ', 44894 'آگسٽ', 44895 'سÙپٽ٠بر', 44896 'Ø¢ÚªÙ½Ùبر', 44897 'ÙÙ٠بر', 44898 'Úس٠بر' 44899 ]; 44900 var days = [ 44901 'Ø¢Úر', 44902 'سÙ٠ر', 44903 'اڱارÙ', 44904 'اربع', 44905 'خ٠Ùس', 44906 'ج٠ع', 44907 'ÚÙÚر' 44908 ]; 44909 44910 var sd = moment.defineLocale('sd', { 44911 months : months, 44912 monthsShort : months, 44913 weekdays : days, 44914 weekdaysShort : days, 44915 weekdaysMin : days, 44916 longDateFormat : { 44917 LT : 'HH:mm', 44918 LTS : 'HH:mm:ss', 44919 L : 'DD/MM/YYYY', 44920 LL : 'D MMMM YYYY', 44921 LLL : 'D MMMM YYYY HH:mm', 44922 LLLL : 'ddddØ D MMMM YYYY HH:mm' 44923 }, 44924 meridiemParse: /صبØ|شا٠/, 44925 isPM : function (input) { 44926 return 'شا٠' === input; 44927 }, 44928 meridiem : function (hour, minute, isLower) { 44929 if (hour < 12) { 44930 return 'صبØ'; 44931 } 44932 return 'شا٠'; 44933 }, 44934 calendar : { 44935 sameDay : '[اÚ] LT', 44936 nextDay : '[سÚاڻÙ] LT', 44937 nextWeek : 'dddd [اڳÙÙ ÙÙت٠تÙ] LT', 44938 lastDay : '[ڪاÙÙÙ] LT', 44939 lastWeek : '[گزرÙÙ ÙÙتÙ] dddd [تÙ] LT', 44940 sameElse : 'L' 44941 }, 44942 relativeTime : { 44943 future : '%s Ù¾ÙØ¡', 44944 past : '%s اڳ', 44945 s : 'ÚÙد سÙÚªÙÚ', 44946 ss : '%d سÙÚªÙÚ', 44947 m : 'ÙÚª Ù ÙÙ½', 44948 mm : '%d Ù ÙÙ½', 44949 h : 'ÙÚª ÚªÙاڪ', 44950 hh : '%d ÚªÙاڪ', 44951 d : 'ÙÚª ÚÙÙÙÙ', 44952 dd : '%d ÚÙÙÙÙ', 44953 M : 'ÙÚª Ù ÙÙÙÙ', 44954 MM : '%d Ù ÙÙÙا', 44955 y : 'ÙÚª ساÙ', 44956 yy : '%d ساÙ' 44957 }, 44958 preparse: function (string) { 44959 return string.replace(/Ø/g, ','); 44960 }, 44961 postformat: function (string) { 44962 return string.replace(/,/g, 'Ø'); 44963 }, 44964 week : { 44965 dow : 1, // Monday is the first day of the week. 44966 doy : 4 // The week that contains Jan 4th is the first week of the year. 44967 } 44968 }); 44969 44970 return sd; 44971 44972}))); 44973 44974 44975/***/ }), 44976/* 123 */ 44977/***/ (function(module, exports, __webpack_require__) { 44978 44979//! moment.js locale configuration 44980 44981;(function (global, factory) { 44982 true ? factory(__webpack_require__(0)) : 44983 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 44984 factory(global.moment) 44985}(this, (function (moment) { 'use strict'; 44986 44987 44988 var se = moment.defineLocale('se', { 44989 months : 'oÄÄajagemánnu_guovvamánnu_njukÄamánnu_cuoÅománnu_miessemánnu_geassemánnu_suoidnemánnu_borgemánnu_ÄakÄamánnu_golggotmánnu_skábmamánnu_juovlamánnu'.split('_'), 44990 monthsShort : 'oÄÄj_guov_njuk_cuo_mies_geas_suoi_borg_ÄakÄ_golg_skáb_juov'.split('_'), 44991 weekdays : 'sotnabeaivi_vuossárga_maÅÅebárga_gaskavahkku_duorastat_bearjadat_lávvardat'.split('_'), 44992 weekdaysShort : 'sotn_vuos_maÅ_gask_duor_bear_láv'.split('_'), 44993 weekdaysMin : 's_v_m_g_d_b_L'.split('_'), 44994 longDateFormat : { 44995 LT : 'HH:mm', 44996 LTS : 'HH:mm:ss', 44997 L : 'DD.MM.YYYY', 44998 LL : 'MMMM D. [b.] YYYY', 44999 LLL : 'MMMM D. [b.] YYYY [ti.] HH:mm', 45000 LLLL : 'dddd, MMMM D. [b.] YYYY [ti.] HH:mm' 45001 }, 45002 calendar : { 45003 sameDay: '[otne ti] LT', 45004 nextDay: '[ihttin ti] LT', 45005 nextWeek: 'dddd [ti] LT', 45006 lastDay: '[ikte ti] LT', 45007 lastWeek: '[ovddit] dddd [ti] LT', 45008 sameElse: 'L' 45009 }, 45010 relativeTime : { 45011 future : '%s geažes', 45012 past : 'maÅit %s', 45013 s : 'moadde sekunddat', 45014 ss: '%d sekunddat', 45015 m : 'okta minuhta', 45016 mm : '%d minuhtat', 45017 h : 'okta diimmu', 45018 hh : '%d diimmut', 45019 d : 'okta beaivi', 45020 dd : '%d beaivvit', 45021 M : 'okta mánnu', 45022 MM : '%d mánut', 45023 y : 'okta jahki', 45024 yy : '%d jagit' 45025 }, 45026 dayOfMonthOrdinalParse: /\d{1,2}\./, 45027 ordinal : '%d.', 45028 week : { 45029 dow : 1, // Monday is the first day of the week. 45030 doy : 4 // The week that contains Jan 4th is the first week of the year. 45031 } 45032 }); 45033 45034 return se; 45035 45036}))); 45037 45038 45039/***/ }), 45040/* 124 */ 45041/***/ (function(module, exports, __webpack_require__) { 45042 45043//! moment.js locale configuration 45044 45045;(function (global, factory) { 45046 true ? factory(__webpack_require__(0)) : 45047 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 45048 factory(global.moment) 45049}(this, (function (moment) { 'use strict'; 45050 45051 45052 /*jshint -W100*/ 45053 var si = moment.defineLocale('si', { 45054 months : 'ජනà·à·à¶»à·_පà·à¶¶à¶»à·à·à¶»à·_මà·à¶»à·à¶à·_චපà·âරà·à¶½à·_මà·à¶ºà·_ජà·à¶±à·_ජà·à¶½à·_චà¶à·à·à·à¶à·_à·à·à¶´à·à¶à·à¶¸à·à¶¶à¶»à·_à¶à¶à·à¶à·à¶¶à¶»à·_නà·à·à·à¶¸à·à¶¶à¶»à·_දà·à·à·à¶¸à·à¶¶à¶»à·'.split('_'), 45055 monthsShort : 'ජන_පà·à¶¶_මà·à¶»à·_චපà·_මà·à¶ºà·_ජà·à¶±à·_ජà·à¶½à·_චà¶à·_à·à·à¶´à·_à¶à¶à·_නà·à·à·_දà·à·à·'.split('_'), 45056 weekdays : 'à¶à¶»à·à¶¯à·_à·à¶³à·à¶¯à·_චà¶à·à¶»à·à·à·à¶¯à·_බදà·à¶¯à·_බà·âරà·à·à·à¶´à¶à·à¶±à·à¶¯à·_à·à·à¶à·à¶»à·à¶¯à·_à·à·à¶±à·à·à¶»à·à¶¯à·'.split('_'), 45057 weekdaysShort : 'à¶à¶»à·_à·à¶³à·_චà¶_බදà·_බà·âරà·_à·à·à¶à·_à·à·à¶±'.split('_'), 45058 weekdaysMin : 'à¶_à·_ච_බ_බà·âර_à·à·_à·à·'.split('_'), 45059 weekdaysParseExact : true, 45060 longDateFormat : { 45061 LT : 'a h:mm', 45062 LTS : 'a h:mm:ss', 45063 L : 'YYYY/MM/DD', 45064 LL : 'YYYY MMMM D', 45065 LLL : 'YYYY MMMM D, a h:mm', 45066 LLLL : 'YYYY MMMM D [à·à·à¶±à·] dddd, a h:mm:ss' 45067 }, 45068 calendar : { 45069 sameDay : '[චද] LT[ට]', 45070 nextDay : '[à·à·à¶§] LT[ට]', 45071 nextWeek : 'dddd LT[ට]', 45072 lastDay : '[à¶à¶ºà·] LT[ට]', 45073 lastWeek : '[පà·à·à¶à·à¶º] dddd LT[ට]', 45074 sameElse : 'L' 45075 }, 45076 relativeTime : { 45077 future : '%sà¶à·à¶±à·', 45078 past : '%sà¶à¶§ පà·à¶»', 45079 s : 'à¶à¶à·à¶´à¶» à¶à·à·à·à¶´à¶º', 45080 ss : 'à¶à¶à·à¶´à¶» %d', 45081 m : 'මà·à¶±à·à¶à·à¶à·à·', 45082 mm : 'මà·à¶±à·à¶à·à¶à· %d', 45083 h : 'පà·à¶º', 45084 hh : 'පà·à¶º %d', 45085 d : 'දà·à¶±à¶º', 45086 dd : 'දà·à¶± %d', 45087 M : 'මà·à·à¶º', 45088 MM : 'මà·à· %d', 45089 y : 'à·à·à¶»', 45090 yy : 'à·à·à¶» %d' 45091 }, 45092 dayOfMonthOrdinalParse: /\d{1,2} à·à·à¶±à·/, 45093 ordinal : function (number) { 45094 return number + ' à·à·à¶±à·'; 45095 }, 45096 meridiemParse : /පà·à¶» à·à¶»à·|පà·à· à·à¶»à·|පà·.à·|ප.à·./, 45097 isPM : function (input) { 45098 return input === 'ප.à·.' || input === 'පà·à· à·à¶»à·'; 45099 }, 45100 meridiem : function (hours, minutes, isLower) { 45101 if (hours > 11) { 45102 return isLower ? 'ප.à·.' : 'පà·à· à·à¶»à·'; 45103 } else { 45104 return isLower ? 'පà·.à·.' : 'පà·à¶» à·à¶»à·'; 45105 } 45106 } 45107 }); 45108 45109 return si; 45110 45111}))); 45112 45113 45114/***/ }), 45115/* 125 */ 45116/***/ (function(module, exports, __webpack_require__) { 45117 45118//! moment.js locale configuration 45119 45120;(function (global, factory) { 45121 true ? factory(__webpack_require__(0)) : 45122 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 45123 factory(global.moment) 45124}(this, (function (moment) { 'use strict'; 45125 45126 45127 var months = 'január_február_marec_aprÃl_máj_jún_júl_august_september_október_november_december'.split('_'), 45128 monthsShort = 'jan_feb_mar_apr_máj_jún_júl_aug_sep_okt_nov_dec'.split('_'); 45129 function plural(n) { 45130 return (n > 1) && (n < 5); 45131 } 45132 function translate(number, withoutSuffix, key, isFuture) { 45133 var result = number + ' '; 45134 switch (key) { 45135 case 's': // a few seconds / in a few seconds / a few seconds ago 45136 return (withoutSuffix || isFuture) ? 'pár sekúnd' : 'pár sekundami'; 45137 case 'ss': // 9 seconds / in 9 seconds / 9 seconds ago 45138 if (withoutSuffix || isFuture) { 45139 return result + (plural(number) ? 'sekundy' : 'sekúnd'); 45140 } else { 45141 return result + 'sekundami'; 45142 } 45143 break; 45144 case 'm': // a minute / in a minute / a minute ago 45145 return withoutSuffix ? 'minúta' : (isFuture ? 'minútu' : 'minútou'); 45146 case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago 45147 if (withoutSuffix || isFuture) { 45148 return result + (plural(number) ? 'minúty' : 'minút'); 45149 } else { 45150 return result + 'minútami'; 45151 } 45152 break; 45153 case 'h': // an hour / in an hour / an hour ago 45154 return withoutSuffix ? 'hodina' : (isFuture ? 'hodinu' : 'hodinou'); 45155 case 'hh': // 9 hours / in 9 hours / 9 hours ago 45156 if (withoutSuffix || isFuture) { 45157 return result + (plural(number) ? 'hodiny' : 'hodÃn'); 45158 } else { 45159 return result + 'hodinami'; 45160 } 45161 break; 45162 case 'd': // a day / in a day / a day ago 45163 return (withoutSuffix || isFuture) ? 'deÅ' : 'dÅom'; 45164 case 'dd': // 9 days / in 9 days / 9 days ago 45165 if (withoutSuffix || isFuture) { 45166 return result + (plural(number) ? 'dni' : 'dnÃ'); 45167 } else { 45168 return result + 'dÅami'; 45169 } 45170 break; 45171 case 'M': // a month / in a month / a month ago 45172 return (withoutSuffix || isFuture) ? 'mesiac' : 'mesiacom'; 45173 case 'MM': // 9 months / in 9 months / 9 months ago 45174 if (withoutSuffix || isFuture) { 45175 return result + (plural(number) ? 'mesiace' : 'mesiacov'); 45176 } else { 45177 return result + 'mesiacmi'; 45178 } 45179 break; 45180 case 'y': // a year / in a year / a year ago 45181 return (withoutSuffix || isFuture) ? 'rok' : 'rokom'; 45182 case 'yy': // 9 years / in 9 years / 9 years ago 45183 if (withoutSuffix || isFuture) { 45184 return result + (plural(number) ? 'roky' : 'rokov'); 45185 } else { 45186 return result + 'rokmi'; 45187 } 45188 break; 45189 } 45190 } 45191 45192 var sk = moment.defineLocale('sk', { 45193 months : months, 45194 monthsShort : monthsShort, 45195 weekdays : 'nedeľa_pondelok_utorok_streda_Å¡tvrtok_piatok_sobota'.split('_'), 45196 weekdaysShort : 'ne_po_ut_st_Å¡t_pi_so'.split('_'), 45197 weekdaysMin : 'ne_po_ut_st_Å¡t_pi_so'.split('_'), 45198 longDateFormat : { 45199 LT: 'H:mm', 45200 LTS : 'H:mm:ss', 45201 L : 'DD.MM.YYYY', 45202 LL : 'D. MMMM YYYY', 45203 LLL : 'D. MMMM YYYY H:mm', 45204 LLLL : 'dddd D. MMMM YYYY H:mm' 45205 }, 45206 calendar : { 45207 sameDay: '[dnes o] LT', 45208 nextDay: '[zajtra o] LT', 45209 nextWeek: function () { 45210 switch (this.day()) { 45211 case 0: 45212 return '[v nedeľu o] LT'; 45213 case 1: 45214 case 2: 45215 return '[v] dddd [o] LT'; 45216 case 3: 45217 return '[v stredu o] LT'; 45218 case 4: 45219 return '[vo Å¡tvrtok o] LT'; 45220 case 5: 45221 return '[v piatok o] LT'; 45222 case 6: 45223 return '[v sobotu o] LT'; 45224 } 45225 }, 45226 lastDay: '[vÄera o] LT', 45227 lastWeek: function () { 45228 switch (this.day()) { 45229 case 0: 45230 return '[minulú nedeľu o] LT'; 45231 case 1: 45232 case 2: 45233 return '[minulý] dddd [o] LT'; 45234 case 3: 45235 return '[minulú stredu o] LT'; 45236 case 4: 45237 case 5: 45238 return '[minulý] dddd [o] LT'; 45239 case 6: 45240 return '[minulú sobotu o] LT'; 45241 } 45242 }, 45243 sameElse: 'L' 45244 }, 45245 relativeTime : { 45246 future : 'za %s', 45247 past : 'pred %s', 45248 s : translate, 45249 ss : translate, 45250 m : translate, 45251 mm : translate, 45252 h : translate, 45253 hh : translate, 45254 d : translate, 45255 dd : translate, 45256 M : translate, 45257 MM : translate, 45258 y : translate, 45259 yy : translate 45260 }, 45261 dayOfMonthOrdinalParse: /\d{1,2}\./, 45262 ordinal : '%d.', 45263 week : { 45264 dow : 1, // Monday is the first day of the week. 45265 doy : 4 // The week that contains Jan 4th is the first week of the year. 45266 } 45267 }); 45268 45269 return sk; 45270 45271}))); 45272 45273 45274/***/ }), 45275/* 126 */ 45276/***/ (function(module, exports, __webpack_require__) { 45277 45278//! moment.js locale configuration 45279 45280;(function (global, factory) { 45281 true ? factory(__webpack_require__(0)) : 45282 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 45283 factory(global.moment) 45284}(this, (function (moment) { 'use strict'; 45285 45286 45287 function processRelativeTime(number, withoutSuffix, key, isFuture) { 45288 var result = number + ' '; 45289 switch (key) { 45290 case 's': 45291 return withoutSuffix || isFuture ? 'nekaj sekund' : 'nekaj sekundami'; 45292 case 'ss': 45293 if (number === 1) { 45294 result += withoutSuffix ? 'sekundo' : 'sekundi'; 45295 } else if (number === 2) { 45296 result += withoutSuffix || isFuture ? 'sekundi' : 'sekundah'; 45297 } else if (number < 5) { 45298 result += withoutSuffix || isFuture ? 'sekunde' : 'sekundah'; 45299 } else { 45300 result += withoutSuffix || isFuture ? 'sekund' : 'sekund'; 45301 } 45302 return result; 45303 case 'm': 45304 return withoutSuffix ? 'ena minuta' : 'eno minuto'; 45305 case 'mm': 45306 if (number === 1) { 45307 result += withoutSuffix ? 'minuta' : 'minuto'; 45308 } else if (number === 2) { 45309 result += withoutSuffix || isFuture ? 'minuti' : 'minutama'; 45310 } else if (number < 5) { 45311 result += withoutSuffix || isFuture ? 'minute' : 'minutami'; 45312 } else { 45313 result += withoutSuffix || isFuture ? 'minut' : 'minutami'; 45314 } 45315 return result; 45316 case 'h': 45317 return withoutSuffix ? 'ena ura' : 'eno uro'; 45318 case 'hh': 45319 if (number === 1) { 45320 result += withoutSuffix ? 'ura' : 'uro'; 45321 } else if (number === 2) { 45322 result += withoutSuffix || isFuture ? 'uri' : 'urama'; 45323 } else if (number < 5) { 45324 result += withoutSuffix || isFuture ? 'ure' : 'urami'; 45325 } else { 45326 result += withoutSuffix || isFuture ? 'ur' : 'urami'; 45327 } 45328 return result; 45329 case 'd': 45330 return withoutSuffix || isFuture ? 'en dan' : 'enim dnem'; 45331 case 'dd': 45332 if (number === 1) { 45333 result += withoutSuffix || isFuture ? 'dan' : 'dnem'; 45334 } else if (number === 2) { 45335 result += withoutSuffix || isFuture ? 'dni' : 'dnevoma'; 45336 } else { 45337 result += withoutSuffix || isFuture ? 'dni' : 'dnevi'; 45338 } 45339 return result; 45340 case 'M': 45341 return withoutSuffix || isFuture ? 'en mesec' : 'enim mesecem'; 45342 case 'MM': 45343 if (number === 1) { 45344 result += withoutSuffix || isFuture ? 'mesec' : 'mesecem'; 45345 } else if (number === 2) { 45346 result += withoutSuffix || isFuture ? 'meseca' : 'mesecema'; 45347 } else if (number < 5) { 45348 result += withoutSuffix || isFuture ? 'mesece' : 'meseci'; 45349 } else { 45350 result += withoutSuffix || isFuture ? 'mesecev' : 'meseci'; 45351 } 45352 return result; 45353 case 'y': 45354 return withoutSuffix || isFuture ? 'eno leto' : 'enim letom'; 45355 case 'yy': 45356 if (number === 1) { 45357 result += withoutSuffix || isFuture ? 'leto' : 'letom'; 45358 } else if (number === 2) { 45359 result += withoutSuffix || isFuture ? 'leti' : 'letoma'; 45360 } else if (number < 5) { 45361 result += withoutSuffix || isFuture ? 'leta' : 'leti'; 45362 } else { 45363 result += withoutSuffix || isFuture ? 'let' : 'leti'; 45364 } 45365 return result; 45366 } 45367 } 45368 45369 var sl = moment.defineLocale('sl', { 45370 months : 'januar_februar_marec_april_maj_junij_julij_avgust_september_oktober_november_december'.split('_'), 45371 monthsShort : 'jan._feb._mar._apr._maj._jun._jul._avg._sep._okt._nov._dec.'.split('_'), 45372 monthsParseExact: true, 45373 weekdays : 'nedelja_ponedeljek_torek_sreda_Äetrtek_petek_sobota'.split('_'), 45374 weekdaysShort : 'ned._pon._tor._sre._Äet._pet._sob.'.split('_'), 45375 weekdaysMin : 'ne_po_to_sr_Äe_pe_so'.split('_'), 45376 weekdaysParseExact : true, 45377 longDateFormat : { 45378 LT : 'H:mm', 45379 LTS : 'H:mm:ss', 45380 L : 'DD.MM.YYYY', 45381 LL : 'D. MMMM YYYY', 45382 LLL : 'D. MMMM YYYY H:mm', 45383 LLLL : 'dddd, D. MMMM YYYY H:mm' 45384 }, 45385 calendar : { 45386 sameDay : '[danes ob] LT', 45387 nextDay : '[jutri ob] LT', 45388 45389 nextWeek : function () { 45390 switch (this.day()) { 45391 case 0: 45392 return '[v] [nedeljo] [ob] LT'; 45393 case 3: 45394 return '[v] [sredo] [ob] LT'; 45395 case 6: 45396 return '[v] [soboto] [ob] LT'; 45397 case 1: 45398 case 2: 45399 case 4: 45400 case 5: 45401 return '[v] dddd [ob] LT'; 45402 } 45403 }, 45404 lastDay : '[vÄeraj ob] LT', 45405 lastWeek : function () { 45406 switch (this.day()) { 45407 case 0: 45408 return '[prejÅ¡njo] [nedeljo] [ob] LT'; 45409 case 3: 45410 return '[prejÅ¡njo] [sredo] [ob] LT'; 45411 case 6: 45412 return '[prejÅ¡njo] [soboto] [ob] LT'; 45413 case 1: 45414 case 2: 45415 case 4: 45416 case 5: 45417 return '[prejÅ¡nji] dddd [ob] LT'; 45418 } 45419 }, 45420 sameElse : 'L' 45421 }, 45422 relativeTime : { 45423 future : 'Äez %s', 45424 past : 'pred %s', 45425 s : processRelativeTime, 45426 ss : processRelativeTime, 45427 m : processRelativeTime, 45428 mm : processRelativeTime, 45429 h : processRelativeTime, 45430 hh : processRelativeTime, 45431 d : processRelativeTime, 45432 dd : processRelativeTime, 45433 M : processRelativeTime, 45434 MM : processRelativeTime, 45435 y : processRelativeTime, 45436 yy : processRelativeTime 45437 }, 45438 dayOfMonthOrdinalParse: /\d{1,2}\./, 45439 ordinal : '%d.', 45440 week : { 45441 dow : 1, // Monday is the first day of the week. 45442 doy : 7 // The week that contains Jan 1st is the first week of the year. 45443 } 45444 }); 45445 45446 return sl; 45447 45448}))); 45449 45450 45451/***/ }), 45452/* 127 */ 45453/***/ (function(module, exports, __webpack_require__) { 45454 45455//! moment.js locale configuration 45456 45457;(function (global, factory) { 45458 true ? factory(__webpack_require__(0)) : 45459 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 45460 factory(global.moment) 45461}(this, (function (moment) { 'use strict'; 45462 45463 45464 var sq = moment.defineLocale('sq', { 45465 months : 'Janar_Shkurt_Mars_Prill_Maj_Qershor_Korrik_Gusht_Shtator_Tetor_Nëntor_Dhjetor'.split('_'), 45466 monthsShort : 'Jan_Shk_Mar_Pri_Maj_Qer_Kor_Gus_Sht_Tet_Nën_Dhj'.split('_'), 45467 weekdays : 'E Diel_E Hënë_E Martë_E Mërkurë_E Enjte_E Premte_E Shtunë'.split('_'), 45468 weekdaysShort : 'Die_Hën_Mar_Mër_Enj_Pre_Sht'.split('_'), 45469 weekdaysMin : 'D_H_Ma_Më_E_P_Sh'.split('_'), 45470 weekdaysParseExact : true, 45471 meridiemParse: /PD|MD/, 45472 isPM: function (input) { 45473 return input.charAt(0) === 'M'; 45474 }, 45475 meridiem : function (hours, minutes, isLower) { 45476 return hours < 12 ? 'PD' : 'MD'; 45477 }, 45478 longDateFormat : { 45479 LT : 'HH:mm', 45480 LTS : 'HH:mm:ss', 45481 L : 'DD/MM/YYYY', 45482 LL : 'D MMMM YYYY', 45483 LLL : 'D MMMM YYYY HH:mm', 45484 LLLL : 'dddd, D MMMM YYYY HH:mm' 45485 }, 45486 calendar : { 45487 sameDay : '[Sot në] LT', 45488 nextDay : '[Nesër në] LT', 45489 nextWeek : 'dddd [në] LT', 45490 lastDay : '[Dje në] LT', 45491 lastWeek : 'dddd [e kaluar në] LT', 45492 sameElse : 'L' 45493 }, 45494 relativeTime : { 45495 future : 'në %s', 45496 past : '%s më parë', 45497 s : 'disa sekonda', 45498 ss : '%d sekonda', 45499 m : 'një minutë', 45500 mm : '%d minuta', 45501 h : 'një orë', 45502 hh : '%d orë', 45503 d : 'një ditë', 45504 dd : '%d ditë', 45505 M : 'një muaj', 45506 MM : '%d muaj', 45507 y : 'një vit', 45508 yy : '%d vite' 45509 }, 45510 dayOfMonthOrdinalParse: /\d{1,2}\./, 45511 ordinal : '%d.', 45512 week : { 45513 dow : 1, // Monday is the first day of the week. 45514 doy : 4 // The week that contains Jan 4th is the first week of the year. 45515 } 45516 }); 45517 45518 return sq; 45519 45520}))); 45521 45522 45523/***/ }), 45524/* 128 */ 45525/***/ (function(module, exports, __webpack_require__) { 45526 45527//! moment.js locale configuration 45528 45529;(function (global, factory) { 45530 true ? factory(__webpack_require__(0)) : 45531 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 45532 factory(global.moment) 45533}(this, (function (moment) { 'use strict'; 45534 45535 45536 var translator = { 45537 words: { //Different grammatical cases 45538 ss: ['ÑекÑнда', 'ÑекÑнде', 'ÑекÑнди'], 45539 m: ['Ñедан минÑÑ', 'Ñедне минÑÑе'], 45540 mm: ['минÑÑ', 'минÑÑе', 'минÑÑа'], 45541 h: ['Ñедан ÑаÑ', 'Ñедног ÑаÑа'], 45542 hh: ['ÑаÑ', 'ÑаÑа', 'ÑаÑи'], 45543 dd: ['дан', 'дана', 'дана'], 45544 MM: ['меÑеÑ', 'меÑеÑа', 'меÑеÑи'], 45545 yy: ['година', 'године', 'година'] 45546 }, 45547 correctGrammaticalCase: function (number, wordKey) { 45548 return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]); 45549 }, 45550 translate: function (number, withoutSuffix, key) { 45551 var wordKey = translator.words[key]; 45552 if (key.length === 1) { 45553 return withoutSuffix ? wordKey[0] : wordKey[1]; 45554 } else { 45555 return number + ' ' + translator.correctGrammaticalCase(number, wordKey); 45556 } 45557 } 45558 }; 45559 45560 var srCyrl = moment.defineLocale('sr-cyrl', { 45561 months: 'ÑанÑаÑ_ÑебÑÑаÑ_маÑÑ_апÑил_маÑ_ÑÑн_ÑÑл_авгÑÑÑ_ÑепÑембаÑ_окÑобаÑ_новембаÑ_деÑембаÑ'.split('_'), 45562 monthsShort: 'Ñан._Ñеб._маÑ._апÑ._маÑ_ÑÑн_ÑÑл_авг._Ñеп._окÑ._нов._деÑ.'.split('_'), 45563 monthsParseExact: true, 45564 weekdays: 'недеÑа_понедеÑак_ÑÑоÑак_ÑÑеда_ÑеÑвÑÑак_пеÑак_ÑÑбоÑа'.split('_'), 45565 weekdaysShort: 'нед._пон._ÑÑо._ÑÑе._ÑеÑ._пеÑ._ÑÑб.'.split('_'), 45566 weekdaysMin: 'не_по_ÑÑ_ÑÑ_Ñе_пе_ÑÑ'.split('_'), 45567 weekdaysParseExact : true, 45568 longDateFormat: { 45569 LT: 'H:mm', 45570 LTS : 'H:mm:ss', 45571 L: 'DD.MM.YYYY', 45572 LL: 'D. MMMM YYYY', 45573 LLL: 'D. MMMM YYYY H:mm', 45574 LLLL: 'dddd, D. MMMM YYYY H:mm' 45575 }, 45576 calendar: { 45577 sameDay: '[Ð´Ð°Ð½Ð°Ñ Ñ] LT', 45578 nextDay: '[ÑÑÑÑа Ñ] LT', 45579 nextWeek: function () { 45580 switch (this.day()) { 45581 case 0: 45582 return '[Ñ] [недеÑÑ] [Ñ] LT'; 45583 case 3: 45584 return '[Ñ] [ÑÑедÑ] [Ñ] LT'; 45585 case 6: 45586 return '[Ñ] [ÑÑбоÑÑ] [Ñ] LT'; 45587 case 1: 45588 case 2: 45589 case 4: 45590 case 5: 45591 return '[Ñ] dddd [Ñ] LT'; 45592 } 45593 }, 45594 lastDay : '[ÑÑÑе Ñ] LT', 45595 lastWeek : function () { 45596 var lastWeekDays = [ 45597 '[пÑоÑле] [недеÑе] [Ñ] LT', 45598 '[пÑоÑлог] [понедеÑка] [Ñ] LT', 45599 '[пÑоÑлог] [ÑÑоÑка] [Ñ] LT', 45600 '[пÑоÑле] [ÑÑеде] [Ñ] LT', 45601 '[пÑоÑлог] [ÑеÑвÑÑка] [Ñ] LT', 45602 '[пÑоÑлог] [пеÑка] [Ñ] LT', 45603 '[пÑоÑле] [ÑÑбоÑе] [Ñ] LT' 45604 ]; 45605 return lastWeekDays[this.day()]; 45606 }, 45607 sameElse : 'L' 45608 }, 45609 relativeTime : { 45610 future : 'за %s', 45611 past : 'пÑе %s', 45612 s : 'неколико ÑекÑнди', 45613 ss : translator.translate, 45614 m : translator.translate, 45615 mm : translator.translate, 45616 h : translator.translate, 45617 hh : translator.translate, 45618 d : 'дан', 45619 dd : translator.translate, 45620 M : 'меÑеÑ', 45621 MM : translator.translate, 45622 y : 'годинÑ', 45623 yy : translator.translate 45624 }, 45625 dayOfMonthOrdinalParse: /\d{1,2}\./, 45626 ordinal : '%d.', 45627 week : { 45628 dow : 1, // Monday is the first day of the week. 45629 doy : 7 // The week that contains Jan 1st is the first week of the year. 45630 } 45631 }); 45632 45633 return srCyrl; 45634 45635}))); 45636 45637 45638/***/ }), 45639/* 129 */ 45640/***/ (function(module, exports, __webpack_require__) { 45641 45642//! moment.js locale configuration 45643 45644;(function (global, factory) { 45645 true ? factory(__webpack_require__(0)) : 45646 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 45647 factory(global.moment) 45648}(this, (function (moment) { 'use strict'; 45649 45650 45651 var translator = { 45652 words: { //Different grammatical cases 45653 ss: ['sekunda', 'sekunde', 'sekundi'], 45654 m: ['jedan minut', 'jedne minute'], 45655 mm: ['minut', 'minute', 'minuta'], 45656 h: ['jedan sat', 'jednog sata'], 45657 hh: ['sat', 'sata', 'sati'], 45658 dd: ['dan', 'dana', 'dana'], 45659 MM: ['mesec', 'meseca', 'meseci'], 45660 yy: ['godina', 'godine', 'godina'] 45661 }, 45662 correctGrammaticalCase: function (number, wordKey) { 45663 return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]); 45664 }, 45665 translate: function (number, withoutSuffix, key) { 45666 var wordKey = translator.words[key]; 45667 if (key.length === 1) { 45668 return withoutSuffix ? wordKey[0] : wordKey[1]; 45669 } else { 45670 return number + ' ' + translator.correctGrammaticalCase(number, wordKey); 45671 } 45672 } 45673 }; 45674 45675 var sr = moment.defineLocale('sr', { 45676 months: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split('_'), 45677 monthsShort: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split('_'), 45678 monthsParseExact: true, 45679 weekdays: 'nedelja_ponedeljak_utorak_sreda_Äetvrtak_petak_subota'.split('_'), 45680 weekdaysShort: 'ned._pon._uto._sre._Äet._pet._sub.'.split('_'), 45681 weekdaysMin: 'ne_po_ut_sr_Äe_pe_su'.split('_'), 45682 weekdaysParseExact : true, 45683 longDateFormat: { 45684 LT: 'H:mm', 45685 LTS : 'H:mm:ss', 45686 L: 'DD.MM.YYYY', 45687 LL: 'D. MMMM YYYY', 45688 LLL: 'D. MMMM YYYY H:mm', 45689 LLLL: 'dddd, D. MMMM YYYY H:mm' 45690 }, 45691 calendar: { 45692 sameDay: '[danas u] LT', 45693 nextDay: '[sutra u] LT', 45694 nextWeek: function () { 45695 switch (this.day()) { 45696 case 0: 45697 return '[u] [nedelju] [u] LT'; 45698 case 3: 45699 return '[u] [sredu] [u] LT'; 45700 case 6: 45701 return '[u] [subotu] [u] LT'; 45702 case 1: 45703 case 2: 45704 case 4: 45705 case 5: 45706 return '[u] dddd [u] LT'; 45707 } 45708 }, 45709 lastDay : '[juÄe u] LT', 45710 lastWeek : function () { 45711 var lastWeekDays = [ 45712 '[proÅ¡le] [nedelje] [u] LT', 45713 '[proÅ¡log] [ponedeljka] [u] LT', 45714 '[proÅ¡log] [utorka] [u] LT', 45715 '[proÅ¡le] [srede] [u] LT', 45716 '[proÅ¡log] [Äetvrtka] [u] LT', 45717 '[proÅ¡log] [petka] [u] LT', 45718 '[proÅ¡le] [subote] [u] LT' 45719 ]; 45720 return lastWeekDays[this.day()]; 45721 }, 45722 sameElse : 'L' 45723 }, 45724 relativeTime : { 45725 future : 'za %s', 45726 past : 'pre %s', 45727 s : 'nekoliko sekundi', 45728 ss : translator.translate, 45729 m : translator.translate, 45730 mm : translator.translate, 45731 h : translator.translate, 45732 hh : translator.translate, 45733 d : 'dan', 45734 dd : translator.translate, 45735 M : 'mesec', 45736 MM : translator.translate, 45737 y : 'godinu', 45738 yy : translator.translate 45739 }, 45740 dayOfMonthOrdinalParse: /\d{1,2}\./, 45741 ordinal : '%d.', 45742 week : { 45743 dow : 1, // Monday is the first day of the week. 45744 doy : 7 // The week that contains Jan 1st is the first week of the year. 45745 } 45746 }); 45747 45748 return sr; 45749 45750}))); 45751 45752 45753/***/ }), 45754/* 130 */ 45755/***/ (function(module, exports, __webpack_require__) { 45756 45757//! moment.js locale configuration 45758 45759;(function (global, factory) { 45760 true ? factory(__webpack_require__(0)) : 45761 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 45762 factory(global.moment) 45763}(this, (function (moment) { 'use strict'; 45764 45765 45766 var ss = moment.defineLocale('ss', { 45767 months : "Bhimbidvwane_Indlovana_Indlov'lenkhulu_Mabasa_Inkhwekhweti_Inhlaba_Kholwane_Ingci_Inyoni_Imphala_Lweti_Ingongoni".split('_'), 45768 monthsShort : 'Bhi_Ina_Inu_Mab_Ink_Inh_Kho_Igc_Iny_Imp_Lwe_Igo'.split('_'), 45769 weekdays : 'Lisontfo_Umsombuluko_Lesibili_Lesitsatfu_Lesine_Lesihlanu_Umgcibelo'.split('_'), 45770 weekdaysShort : 'Lis_Umb_Lsb_Les_Lsi_Lsh_Umg'.split('_'), 45771 weekdaysMin : 'Li_Us_Lb_Lt_Ls_Lh_Ug'.split('_'), 45772 weekdaysParseExact : true, 45773 longDateFormat : { 45774 LT : 'h:mm A', 45775 LTS : 'h:mm:ss A', 45776 L : 'DD/MM/YYYY', 45777 LL : 'D MMMM YYYY', 45778 LLL : 'D MMMM YYYY h:mm A', 45779 LLLL : 'dddd, D MMMM YYYY h:mm A' 45780 }, 45781 calendar : { 45782 sameDay : '[Namuhla nga] LT', 45783 nextDay : '[Kusasa nga] LT', 45784 nextWeek : 'dddd [nga] LT', 45785 lastDay : '[Itolo nga] LT', 45786 lastWeek : 'dddd [leliphelile] [nga] LT', 45787 sameElse : 'L' 45788 }, 45789 relativeTime : { 45790 future : 'nga %s', 45791 past : 'wenteka nga %s', 45792 s : 'emizuzwana lomcane', 45793 ss : '%d mzuzwana', 45794 m : 'umzuzu', 45795 mm : '%d emizuzu', 45796 h : 'lihora', 45797 hh : '%d emahora', 45798 d : 'lilanga', 45799 dd : '%d emalanga', 45800 M : 'inyanga', 45801 MM : '%d tinyanga', 45802 y : 'umnyaka', 45803 yy : '%d iminyaka' 45804 }, 45805 meridiemParse: /ekuseni|emini|entsambama|ebusuku/, 45806 meridiem : function (hours, minutes, isLower) { 45807 if (hours < 11) { 45808 return 'ekuseni'; 45809 } else if (hours < 15) { 45810 return 'emini'; 45811 } else if (hours < 19) { 45812 return 'entsambama'; 45813 } else { 45814 return 'ebusuku'; 45815 } 45816 }, 45817 meridiemHour : function (hour, meridiem) { 45818 if (hour === 12) { 45819 hour = 0; 45820 } 45821 if (meridiem === 'ekuseni') { 45822 return hour; 45823 } else if (meridiem === 'emini') { 45824 return hour >= 11 ? hour : hour + 12; 45825 } else if (meridiem === 'entsambama' || meridiem === 'ebusuku') { 45826 if (hour === 0) { 45827 return 0; 45828 } 45829 return hour + 12; 45830 } 45831 }, 45832 dayOfMonthOrdinalParse: /\d{1,2}/, 45833 ordinal : '%d', 45834 week : { 45835 dow : 1, // Monday is the first day of the week. 45836 doy : 4 // The week that contains Jan 4th is the first week of the year. 45837 } 45838 }); 45839 45840 return ss; 45841 45842}))); 45843 45844 45845/***/ }), 45846/* 131 */ 45847/***/ (function(module, exports, __webpack_require__) { 45848 45849//! moment.js locale configuration 45850 45851;(function (global, factory) { 45852 true ? factory(__webpack_require__(0)) : 45853 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 45854 factory(global.moment) 45855}(this, (function (moment) { 'use strict'; 45856 45857 45858 var sv = moment.defineLocale('sv', { 45859 months : 'januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december'.split('_'), 45860 monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'), 45861 weekdays : 'söndag_mÃ¥ndag_tisdag_onsdag_torsdag_fredag_lördag'.split('_'), 45862 weekdaysShort : 'sön_mÃ¥n_tis_ons_tor_fre_lör'.split('_'), 45863 weekdaysMin : 'sö_mÃ¥_ti_on_to_fr_lö'.split('_'), 45864 longDateFormat : { 45865 LT : 'HH:mm', 45866 LTS : 'HH:mm:ss', 45867 L : 'YYYY-MM-DD', 45868 LL : 'D MMMM YYYY', 45869 LLL : 'D MMMM YYYY [kl.] HH:mm', 45870 LLLL : 'dddd D MMMM YYYY [kl.] HH:mm', 45871 lll : 'D MMM YYYY HH:mm', 45872 llll : 'ddd D MMM YYYY HH:mm' 45873 }, 45874 calendar : { 45875 sameDay: '[Idag] LT', 45876 nextDay: '[Imorgon] LT', 45877 lastDay: '[IgÃ¥r] LT', 45878 nextWeek: '[PÃ¥] dddd LT', 45879 lastWeek: '[I] dddd[s] LT', 45880 sameElse: 'L' 45881 }, 45882 relativeTime : { 45883 future : 'om %s', 45884 past : 'för %s sedan', 45885 s : 'nÃ¥gra sekunder', 45886 ss : '%d sekunder', 45887 m : 'en minut', 45888 mm : '%d minuter', 45889 h : 'en timme', 45890 hh : '%d timmar', 45891 d : 'en dag', 45892 dd : '%d dagar', 45893 M : 'en mÃ¥nad', 45894 MM : '%d mÃ¥nader', 45895 y : 'ett Ã¥r', 45896 yy : '%d Ã¥r' 45897 }, 45898 dayOfMonthOrdinalParse: /\d{1,2}(e|a)/, 45899 ordinal : function (number) { 45900 var b = number % 10, 45901 output = (~~(number % 100 / 10) === 1) ? 'e' : 45902 (b === 1) ? 'a' : 45903 (b === 2) ? 'a' : 45904 (b === 3) ? 'e' : 'e'; 45905 return number + output; 45906 }, 45907 week : { 45908 dow : 1, // Monday is the first day of the week. 45909 doy : 4 // The week that contains Jan 4th is the first week of the year. 45910 } 45911 }); 45912 45913 return sv; 45914 45915}))); 45916 45917 45918/***/ }), 45919/* 132 */ 45920/***/ (function(module, exports, __webpack_require__) { 45921 45922//! moment.js locale configuration 45923 45924;(function (global, factory) { 45925 true ? factory(__webpack_require__(0)) : 45926 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 45927 factory(global.moment) 45928}(this, (function (moment) { 'use strict'; 45929 45930 45931 var sw = moment.defineLocale('sw', { 45932 months : 'Januari_Februari_Machi_Aprili_Mei_Juni_Julai_Agosti_Septemba_Oktoba_Novemba_Desemba'.split('_'), 45933 monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ago_Sep_Okt_Nov_Des'.split('_'), 45934 weekdays : 'Jumapili_Jumatatu_Jumanne_Jumatano_Alhamisi_Ijumaa_Jumamosi'.split('_'), 45935 weekdaysShort : 'Jpl_Jtat_Jnne_Jtan_Alh_Ijm_Jmos'.split('_'), 45936 weekdaysMin : 'J2_J3_J4_J5_Al_Ij_J1'.split('_'), 45937 weekdaysParseExact : true, 45938 longDateFormat : { 45939 LT : 'HH:mm', 45940 LTS : 'HH:mm:ss', 45941 L : 'DD.MM.YYYY', 45942 LL : 'D MMMM YYYY', 45943 LLL : 'D MMMM YYYY HH:mm', 45944 LLLL : 'dddd, D MMMM YYYY HH:mm' 45945 }, 45946 calendar : { 45947 sameDay : '[leo saa] LT', 45948 nextDay : '[kesho saa] LT', 45949 nextWeek : '[wiki ijayo] dddd [saat] LT', 45950 lastDay : '[jana] LT', 45951 lastWeek : '[wiki iliyopita] dddd [saat] LT', 45952 sameElse : 'L' 45953 }, 45954 relativeTime : { 45955 future : '%s baadaye', 45956 past : 'tokea %s', 45957 s : 'hivi punde', 45958 ss : 'sekunde %d', 45959 m : 'dakika moja', 45960 mm : 'dakika %d', 45961 h : 'saa limoja', 45962 hh : 'masaa %d', 45963 d : 'siku moja', 45964 dd : 'masiku %d', 45965 M : 'mwezi mmoja', 45966 MM : 'miezi %d', 45967 y : 'mwaka mmoja', 45968 yy : 'miaka %d' 45969 }, 45970 week : { 45971 dow : 1, // Monday is the first day of the week. 45972 doy : 7 // The week that contains Jan 1st is the first week of the year. 45973 } 45974 }); 45975 45976 return sw; 45977 45978}))); 45979 45980 45981/***/ }), 45982/* 133 */ 45983/***/ (function(module, exports, __webpack_require__) { 45984 45985//! moment.js locale configuration 45986 45987;(function (global, factory) { 45988 true ? factory(__webpack_require__(0)) : 45989 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 45990 factory(global.moment) 45991}(this, (function (moment) { 'use strict'; 45992 45993 45994 var symbolMap = { 45995 '1': '௧', 45996 '2': '௨', 45997 '3': '௩', 45998 '4': '௪', 45999 '5': '௫', 46000 '6': '௬', 46001 '7': 'à¯', 46002 '8': '௮', 46003 '9': '௯', 46004 '0': '௦' 46005 }, numberMap = { 46006 '௧': '1', 46007 '௨': '2', 46008 '௩': '3', 46009 '௪': '4', 46010 '௫': '5', 46011 '௬': '6', 46012 'à¯': '7', 46013 '௮': '8', 46014 '௯': '9', 46015 '௦': '0' 46016 }; 46017 46018 var ta = moment.defineLocale('ta', { 46019 months : 'à®à®©à®µà®°à®¿_பிபà¯à®°à®µà®°à®¿_மாரà¯à®à¯_à®à®ªà¯à®°à®²à¯_à®®à¯_à®à¯à®©à¯_à®à¯à®²à¯_à®à®à®¸à¯à®à¯_à®à¯à®ªà¯à®à¯à®®à¯à®ªà®°à¯_à® à®à¯à®à¯à®¾à®ªà®°à¯_நவமà¯à®ªà®°à¯_à®à®¿à®à®®à¯à®ªà®°à¯'.split('_'), 46020 monthsShort : 'à®à®©à®µà®°à®¿_பிபà¯à®°à®µà®°à®¿_மாரà¯à®à¯_à®à®ªà¯à®°à®²à¯_à®®à¯_à®à¯à®©à¯_à®à¯à®²à¯_à®à®à®¸à¯à®à¯_à®à¯à®ªà¯à®à¯à®®à¯à®ªà®°à¯_à® à®à¯à®à¯à®¾à®ªà®°à¯_நவமà¯à®ªà®°à¯_à®à®¿à®à®®à¯à®ªà®°à¯'.split('_'), 46021 weekdays : 'à®à®¾à®¯à®¿à®±à¯à®±à¯à®à¯à®à®¿à®´à®®à¯_திà®à¯à®à®à¯à®à®¿à®´à®®à¯_à®à¯à®µà¯à®µà®¾à®¯à¯à®à®¿à®´à®®à¯_பà¯à®¤à®©à¯à®à®¿à®´à®®à¯_வியாழà®à¯à®à®¿à®´à®®à¯_வà¯à®³à¯à®³à®¿à®à¯à®à®¿à®´à®®à¯_à®à®©à®¿à®à¯à®à®¿à®´à®®à¯'.split('_'), 46022 weekdaysShort : 'à®à®¾à®¯à®¿à®±à¯_திà®à¯à®à®³à¯_à®à¯à®µà¯à®µà®¾à®¯à¯_பà¯à®¤à®©à¯_வியாழனà¯_வà¯à®³à¯à®³à®¿_à®à®©à®¿'.split('_'), 46023 weekdaysMin : 'à®à®¾_தி_à®à¯_பà¯_வி_வà¯_à®'.split('_'), 46024 longDateFormat : { 46025 LT : 'HH:mm', 46026 LTS : 'HH:mm:ss', 46027 L : 'DD/MM/YYYY', 46028 LL : 'D MMMM YYYY', 46029 LLL : 'D MMMM YYYY, HH:mm', 46030 LLLL : 'dddd, D MMMM YYYY, HH:mm' 46031 }, 46032 calendar : { 46033 sameDay : '[à®à®©à¯à®±à¯] LT', 46034 nextDay : '[நாளà¯] LT', 46035 nextWeek : 'dddd, LT', 46036 lastDay : '[நà¯à®±à¯à®±à¯] LT', 46037 lastWeek : '[à®à®à®¨à¯à®¤ வாரமà¯] dddd, LT', 46038 sameElse : 'L' 46039 }, 46040 relativeTime : { 46041 future : '%s à®à®²à¯', 46042 past : '%s à®®à¯à®©à¯', 46043 s : 'à®à®°à¯ à®à®¿à®² விநாà®à®¿à®à®³à¯', 46044 ss : '%d விநாà®à®¿à®à®³à¯', 46045 m : 'à®à®°à¯ நிமிà®à®®à¯', 46046 mm : '%d நிமிà®à®à¯à®à®³à¯', 46047 h : 'à®à®°à¯ மணி நà¯à®°à®®à¯', 46048 hh : '%d மணி நà¯à®°à®®à¯', 46049 d : 'à®à®°à¯ நாளà¯', 46050 dd : '%d நாà®à¯à®à®³à¯', 46051 M : 'à®à®°à¯ மாதமà¯', 46052 MM : '%d மாதà®à¯à®à®³à¯', 46053 y : 'à®à®°à¯ வரà¯à®à®®à¯', 46054 yy : '%d à®à®£à¯à®à¯à®à®³à¯' 46055 }, 46056 dayOfMonthOrdinalParse: /\d{1,2}வதà¯/, 46057 ordinal : function (number) { 46058 return number + 'வதà¯'; 46059 }, 46060 preparse: function (string) { 46061 return string.replace(/[௧௨௩௪௫௬à¯à¯®à¯¯à¯¦]/g, function (match) { 46062 return numberMap[match]; 46063 }); 46064 }, 46065 postformat: function (string) { 46066 return string.replace(/\d/g, function (match) { 46067 return symbolMap[match]; 46068 }); 46069 }, 46070 // refer http://ta.wikipedia.org/s/1er1 46071 meridiemParse: /யாமமà¯|வà¯à®à®±à¯|à®à®¾à®²à¯|நணà¯à®ªà®à®²à¯|à®à®±à¯à®ªà®¾à®à¯|மாலà¯/, 46072 meridiem : function (hour, minute, isLower) { 46073 if (hour < 2) { 46074 return ' யாமமà¯'; 46075 } else if (hour < 6) { 46076 return ' வà¯à®à®±à¯'; // வà¯à®à®±à¯ 46077 } else if (hour < 10) { 46078 return ' à®à®¾à®²à¯'; // à®à®¾à®²à¯ 46079 } else if (hour < 14) { 46080 return ' நணà¯à®ªà®à®²à¯'; // நணà¯à®ªà®à®²à¯ 46081 } else if (hour < 18) { 46082 return ' à®à®±à¯à®ªà®¾à®à¯'; // à®à®±à¯à®ªà®¾à®à¯ 46083 } else if (hour < 22) { 46084 return ' மாலà¯'; // மால௠46085 } else { 46086 return ' யாமமà¯'; 46087 } 46088 }, 46089 meridiemHour : function (hour, meridiem) { 46090 if (hour === 12) { 46091 hour = 0; 46092 } 46093 if (meridiem === 'யாமமà¯') { 46094 return hour < 2 ? hour : hour + 12; 46095 } else if (meridiem === 'வà¯à®à®±à¯' || meridiem === 'à®à®¾à®²à¯') { 46096 return hour; 46097 } else if (meridiem === 'நணà¯à®ªà®à®²à¯') { 46098 return hour >= 10 ? hour : hour + 12; 46099 } else { 46100 return hour + 12; 46101 } 46102 }, 46103 week : { 46104 dow : 0, // Sunday is the first day of the week. 46105 doy : 6 // The week that contains Jan 1st is the first week of the year. 46106 } 46107 }); 46108 46109 return ta; 46110 46111}))); 46112 46113 46114/***/ }), 46115/* 134 */ 46116/***/ (function(module, exports, __webpack_require__) { 46117 46118//! moment.js locale configuration 46119 46120;(function (global, factory) { 46121 true ? factory(__webpack_require__(0)) : 46122 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 46123 factory(global.moment) 46124}(this, (function (moment) { 'use strict'; 46125 46126 46127 var te = moment.defineLocale('te', { 46128 months : 'à°à°¨à°µà°°à°¿_à°«à°¿à°¬à±à°°à°µà°°à°¿_మారà±à°à°¿_à°à°ªà±à°°à°¿à°²à±_à°®à±_à°à±à°¨à±_à°à±à°²à±à±_à°à°à°¸à±à°à±_à°¸à±à°ªà±à°à±à°à°¬à°°à±_à° à°à±à°à±à°¬à°°à±_నవà°à°¬à°°à±_à°¡à°¿à°¸à±à°à°¬à°°à±'.split('_'), 46129 monthsShort : 'à°à°¨._à°«à°¿à°¬à±à°°._మారà±à°à°¿_à°à°ªà±à°°à°¿._à°®à±_à°à±à°¨à±_à°à±à°²à±à±_à°à°._à°¸à±à°ªà±._à° à°à±à°à±._నవ._à°¡à°¿à°¸à±.'.split('_'), 46130 monthsParseExact : true, 46131 weekdays : 'à°à°¦à°¿à°µà°¾à°°à°_à°¸à±à°®à°µà°¾à°°à°_à°®à°à°à°³à°µà°¾à°°à°_à°¬à±à°§à°µà°¾à°°à°_à°à±à°°à±à°µà°¾à°°à°_à°¶à±à°à±à°°à°µà°¾à°°à°_శనివారà°'.split('_'), 46132 weekdaysShort : 'à°à°¦à°¿_à°¸à±à°®_à°®à°à°à°³_à°¬à±à°§_à°à±à°°à±_à°¶à±à°à±à°°_శని'.split('_'), 46133 weekdaysMin : 'à°_à°¸à±_à°®à°_à°¬à±_à°à±_à°¶à±_à°¶'.split('_'), 46134 longDateFormat : { 46135 LT : 'A h:mm', 46136 LTS : 'A h:mm:ss', 46137 L : 'DD/MM/YYYY', 46138 LL : 'D MMMM YYYY', 46139 LLL : 'D MMMM YYYY, A h:mm', 46140 LLLL : 'dddd, D MMMM YYYY, A h:mm' 46141 }, 46142 calendar : { 46143 sameDay : '[à°¨à±à°¡à±] LT', 46144 nextDay : '[à°°à±à°ªà±] LT', 46145 nextWeek : 'dddd, LT', 46146 lastDay : '[నినà±à°¨] LT', 46147 lastWeek : '[à°à°¤] dddd, LT', 46148 sameElse : 'L' 46149 }, 46150 relativeTime : { 46151 future : '%s à°²à±', 46152 past : '%s à°à±à°°à°¿à°¤à°', 46153 s : 'à°à±à°¨à±à°¨à°¿ à°à±à°·à°£à°¾à°²à±', 46154 ss : '%d à°¸à±à°à°¨à±à°²à±', 46155 m : 'à°à° నిమిషà°', 46156 mm : '%d నిమిషాలà±', 46157 h : 'à°à° à°à°à°', 46158 hh : '%d à°à°à°à°²à±', 46159 d : 'à°à° à°°à±à°à±', 46160 dd : '%d à°°à±à°à±à°²à±', 46161 M : 'à°à° à°¨à±à°²', 46162 MM : '%d à°¨à±à°²à°²à±', 46163 y : 'à°à° à°¸à°à°µà°¤à±à°¸à°°à°', 46164 yy : '%d à°¸à°à°µà°¤à±à°¸à°°à°¾à°²à±' 46165 }, 46166 dayOfMonthOrdinalParse : /\d{1,2}à°µ/, 46167 ordinal : '%dà°µ', 46168 meridiemParse: /రాతà±à°°à°¿|à°à°¦à°¯à°|మధà±à°¯à°¾à°¹à±à°¨à°|సాయà°à°¤à±à°°à°/, 46169 meridiemHour : function (hour, meridiem) { 46170 if (hour === 12) { 46171 hour = 0; 46172 } 46173 if (meridiem === 'రాతà±à°°à°¿') { 46174 return hour < 4 ? hour : hour + 12; 46175 } else if (meridiem === 'à°à°¦à°¯à°') { 46176 return hour; 46177 } else if (meridiem === 'మధà±à°¯à°¾à°¹à±à°¨à°') { 46178 return hour >= 10 ? hour : hour + 12; 46179 } else if (meridiem === 'సాయà°à°¤à±à°°à°') { 46180 return hour + 12; 46181 } 46182 }, 46183 meridiem : function (hour, minute, isLower) { 46184 if (hour < 4) { 46185 return 'రాతà±à°°à°¿'; 46186 } else if (hour < 10) { 46187 return 'à°à°¦à°¯à°'; 46188 } else if (hour < 17) { 46189 return 'మధà±à°¯à°¾à°¹à±à°¨à°'; 46190 } else if (hour < 20) { 46191 return 'సాయà°à°¤à±à°°à°'; 46192 } else { 46193 return 'రాతà±à°°à°¿'; 46194 } 46195 }, 46196 week : { 46197 dow : 0, // Sunday is the first day of the week. 46198 doy : 6 // The week that contains Jan 1st is the first week of the year. 46199 } 46200 }); 46201 46202 return te; 46203 46204}))); 46205 46206 46207/***/ }), 46208/* 135 */ 46209/***/ (function(module, exports, __webpack_require__) { 46210 46211//! moment.js locale configuration 46212 46213;(function (global, factory) { 46214 true ? factory(__webpack_require__(0)) : 46215 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 46216 factory(global.moment) 46217}(this, (function (moment) { 'use strict'; 46218 46219 46220 var tet = moment.defineLocale('tet', { 46221 months : 'Janeiru_Fevereiru_Marsu_Abril_Maiu_Juñu_Jullu_Agustu_Setembru_Outubru_Novembru_Dezembru'.split('_'), 46222 monthsShort : 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split('_'), 46223 weekdays : 'Domingu_Segunda_Tersa_Kuarta_Kinta_Sesta_Sabadu'.split('_'), 46224 weekdaysShort : 'Dom_Seg_Ters_Kua_Kint_Sest_Sab'.split('_'), 46225 weekdaysMin : 'Do_Seg_Te_Ku_Ki_Ses_Sa'.split('_'), 46226 longDateFormat : { 46227 LT : 'HH:mm', 46228 LTS : 'HH:mm:ss', 46229 L : 'DD/MM/YYYY', 46230 LL : 'D MMMM YYYY', 46231 LLL : 'D MMMM YYYY HH:mm', 46232 LLLL : 'dddd, D MMMM YYYY HH:mm' 46233 }, 46234 calendar : { 46235 sameDay: '[Ohin iha] LT', 46236 nextDay: '[Aban iha] LT', 46237 nextWeek: 'dddd [iha] LT', 46238 lastDay: '[Horiseik iha] LT', 46239 lastWeek: 'dddd [semana kotuk] [iha] LT', 46240 sameElse: 'L' 46241 }, 46242 relativeTime : { 46243 future : 'iha %s', 46244 past : '%s liuba', 46245 s : 'minutu balun', 46246 ss : 'minutu %d', 46247 m : 'minutu ida', 46248 mm : 'minutu %d', 46249 h : 'oras ida', 46250 hh : 'oras %d', 46251 d : 'loron ida', 46252 dd : 'loron %d', 46253 M : 'fulan ida', 46254 MM : 'fulan %d', 46255 y : 'tinan ida', 46256 yy : 'tinan %d' 46257 }, 46258 dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/, 46259 ordinal : function (number) { 46260 var b = number % 10, 46261 output = (~~(number % 100 / 10) === 1) ? 'th' : 46262 (b === 1) ? 'st' : 46263 (b === 2) ? 'nd' : 46264 (b === 3) ? 'rd' : 'th'; 46265 return number + output; 46266 }, 46267 week : { 46268 dow : 1, // Monday is the first day of the week. 46269 doy : 4 // The week that contains Jan 4th is the first week of the year. 46270 } 46271 }); 46272 46273 return tet; 46274 46275}))); 46276 46277 46278/***/ }), 46279/* 136 */ 46280/***/ (function(module, exports, __webpack_require__) { 46281 46282//! moment.js locale configuration 46283 46284;(function (global, factory) { 46285 true ? factory(__webpack_require__(0)) : 46286 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 46287 factory(global.moment) 46288}(this, (function (moment) { 'use strict'; 46289 46290 46291 var suffixes = { 46292 0: '-Ñм', 46293 1: '-Ñм', 46294 2: '-Ñм', 46295 3: '-Ñм', 46296 4: '-Ñм', 46297 5: '-Ñм', 46298 6: '-Ñм', 46299 7: '-Ñм', 46300 8: '-Ñм', 46301 9: '-Ñм', 46302 10: '-Ñм', 46303 12: '-Ñм', 46304 13: '-Ñм', 46305 20: '-Ñм', 46306 30: '-Ñм', 46307 40: '-Ñм', 46308 50: '-Ñм', 46309 60: '-Ñм', 46310 70: '-Ñм', 46311 80: '-Ñм', 46312 90: '-Ñм', 46313 100: '-Ñм' 46314 }; 46315 46316 var tg = moment.defineLocale('tg', { 46317 months : 'ÑнваÑ_ÑевÑал_маÑÑ_апÑел_май_иÑн_иÑл_авгÑÑÑ_ÑенÑÑбÑ_окÑÑбÑ_ноÑбÑ_декабÑ'.split('_'), 46318 monthsShort : 'Ñнв_Ñев_маÑ_апÑ_май_иÑн_иÑл_авг_Ñен_окÑ_ноÑ_дек'.split('_'), 46319 weekdays : 'ÑкÑанбе_дÑÑанбе_ÑеÑанбе_ÑоÑÑанбе_панҷÑанбе_Ò·ÑмÑа_Ñанбе'.split('_'), 46320 weekdaysShort : 'ÑÑб_дÑб_ÑÑб_ÑÑб_пÑб_Ò·Ñм_Ñнб'.split('_'), 46321 weekdaysMin : 'ÑÑ_дÑ_ÑÑ_ÑÑ_пÑ_ҷм_Ñб'.split('_'), 46322 longDateFormat : { 46323 LT : 'HH:mm', 46324 LTS : 'HH:mm:ss', 46325 L : 'DD/MM/YYYY', 46326 LL : 'D MMMM YYYY', 46327 LLL : 'D MMMM YYYY HH:mm', 46328 LLLL : 'dddd, D MMMM YYYY HH:mm' 46329 }, 46330 calendar : { 46331 sameDay : '[ÐмÑӯз ÑоаÑи] LT', 46332 nextDay : '[Ðагоҳ ÑоаÑи] LT', 46333 lastDay : '[ÐиÑӯз ÑоаÑи] LT', 46334 nextWeek : 'dddd[и] [ҳаÑÑаи оÑнда ÑоаÑи] LT', 46335 lastWeek : 'dddd[и] [ҳаÑÑаи гÑзаÑÑа ÑоаÑи] LT', 46336 sameElse : 'L' 46337 }, 46338 relativeTime : { 46339 future : 'баÑди %s', 46340 past : '%s пеÑ', 46341 s : 'ÑкÑанд ÑониÑ', 46342 m : 'Ñк даÒиÒа', 46343 mm : '%d даÒиÒа', 46344 h : 'Ñк ÑоаÑ', 46345 hh : '%d ÑоаÑ', 46346 d : 'Ñк Ñӯз', 46347 dd : '%d Ñӯз', 46348 M : 'Ñк моҳ', 46349 MM : '%d моҳ', 46350 y : 'Ñк Ñол', 46351 yy : '%d Ñол' 46352 }, 46353 meridiemParse: /Ñаб|ÑÑбҳ|Ñӯз|бегоҳ/, 46354 meridiemHour: function (hour, meridiem) { 46355 if (hour === 12) { 46356 hour = 0; 46357 } 46358 if (meridiem === 'Ñаб') { 46359 return hour < 4 ? hour : hour + 12; 46360 } else if (meridiem === 'ÑÑбҳ') { 46361 return hour; 46362 } else if (meridiem === 'Ñӯз') { 46363 return hour >= 11 ? hour : hour + 12; 46364 } else if (meridiem === 'бегоҳ') { 46365 return hour + 12; 46366 } 46367 }, 46368 meridiem: function (hour, minute, isLower) { 46369 if (hour < 4) { 46370 return 'Ñаб'; 46371 } else if (hour < 11) { 46372 return 'ÑÑбҳ'; 46373 } else if (hour < 16) { 46374 return 'Ñӯз'; 46375 } else if (hour < 19) { 46376 return 'бегоҳ'; 46377 } else { 46378 return 'Ñаб'; 46379 } 46380 }, 46381 dayOfMonthOrdinalParse: /\d{1,2}-(Ñм|Ñм)/, 46382 ordinal: function (number) { 46383 var a = number % 10, 46384 b = number >= 100 ? 100 : null; 46385 return number + (suffixes[number] || suffixes[a] || suffixes[b]); 46386 }, 46387 week : { 46388 dow : 1, // Monday is the first day of the week. 46389 doy : 7 // The week that contains Jan 1th is the first week of the year. 46390 } 46391 }); 46392 46393 return tg; 46394 46395}))); 46396 46397 46398/***/ }), 46399/* 137 */ 46400/***/ (function(module, exports, __webpack_require__) { 46401 46402//! moment.js locale configuration 46403 46404;(function (global, factory) { 46405 true ? factory(__webpack_require__(0)) : 46406 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 46407 factory(global.moment) 46408}(this, (function (moment) { 'use strict'; 46409 46410 46411 var th = moment.defineLocale('th', { 46412 months : 'มà¸à¸£à¸²à¸à¸¡_à¸à¸¸à¸¡à¸ าà¸à¸±à¸à¸à¹_มีà¸à¸²à¸à¸¡_à¹à¸¡à¸©à¸²à¸¢à¸_à¸à¸¤à¸©à¸ าà¸à¸¡_มิà¸à¸¸à¸à¸²à¸¢à¸_à¸à¸£à¸à¸à¸²à¸à¸¡_สิà¸à¸«à¸²à¸à¸¡_à¸à¸±à¸à¸¢à¸²à¸¢à¸_à¸à¸¸à¸¥à¸²à¸à¸¡_à¸à¸¤à¸¨à¸à¸´à¸à¸²à¸¢à¸_à¸à¸±à¸à¸§à¸²à¸à¸¡'.split('_'), 46413 monthsShort : 'ม.à¸._à¸.à¸._มี.à¸._à¹à¸¡.ย._à¸.à¸._มิ.ย._à¸.à¸._ส.à¸._à¸.ย._à¸.à¸._à¸.ย._à¸.à¸.'.split('_'), 46414 monthsParseExact: true, 46415 weekdays : 'à¸à¸²à¸à¸´à¸à¸¢à¹_à¸à¸±à¸à¸à¸£à¹_à¸à¸±à¸à¸à¸²à¸£_à¸à¸¸à¸_à¸à¸¤à¸«à¸±à¸ªà¸à¸à¸µ_ศุà¸à¸£à¹_à¹à¸ªà¸²à¸£à¹'.split('_'), 46416 weekdaysShort : 'à¸à¸²à¸à¸´à¸à¸¢à¹_à¸à¸±à¸à¸à¸£à¹_à¸à¸±à¸à¸à¸²à¸£_à¸à¸¸à¸_à¸à¸¤à¸«à¸±à¸ª_ศุà¸à¸£à¹_à¹à¸ªà¸²à¸£à¹'.split('_'), // yes, three characters difference 46417 weekdaysMin : 'à¸à¸²._à¸._à¸._à¸._à¸à¸¤._ศ._ส.'.split('_'), 46418 weekdaysParseExact : true, 46419 longDateFormat : { 46420 LT : 'H:mm', 46421 LTS : 'H:mm:ss', 46422 L : 'DD/MM/YYYY', 46423 LL : 'D MMMM YYYY', 46424 LLL : 'D MMMM YYYY à¹à¸§à¸¥à¸² H:mm', 46425 LLLL : 'วัà¸ddddà¸à¸µà¹ D MMMM YYYY à¹à¸§à¸¥à¸² H:mm' 46426 }, 46427 meridiemParse: /à¸à¹à¸à¸à¹à¸à¸µà¹à¸¢à¸|หลัà¸à¹à¸à¸µà¹à¸¢à¸/, 46428 isPM: function (input) { 46429 return input === 'หลัà¸à¹à¸à¸µà¹à¸¢à¸'; 46430 }, 46431 meridiem : function (hour, minute, isLower) { 46432 if (hour < 12) { 46433 return 'à¸à¹à¸à¸à¹à¸à¸µà¹à¸¢à¸'; 46434 } else { 46435 return 'หลัà¸à¹à¸à¸µà¹à¸¢à¸'; 46436 } 46437 }, 46438 calendar : { 46439 sameDay : '[วัà¸à¸à¸µà¹ à¹à¸§à¸¥à¸²] LT', 46440 nextDay : '[à¸à¸£à¸¸à¹à¸à¸à¸µà¹ à¹à¸§à¸¥à¸²] LT', 46441 nextWeek : 'dddd[หà¸à¹à¸² à¹à¸§à¸¥à¸²] LT', 46442 lastDay : '[à¹à¸¡à¸·à¹à¸à¸§à¸²à¸à¸à¸µà¹ à¹à¸§à¸¥à¸²] LT', 46443 lastWeek : '[วัà¸]dddd[à¸à¸µà¹à¹à¸¥à¹à¸§ à¹à¸§à¸¥à¸²] LT', 46444 sameElse : 'L' 46445 }, 46446 relativeTime : { 46447 future : 'à¸à¸µà¸ %s', 46448 past : '%sà¸à¸µà¹à¹à¸¥à¹à¸§', 46449 s : 'à¹à¸¡à¹à¸à¸µà¹à¸§à¸´à¸à¸²à¸à¸µ', 46450 ss : '%d วิà¸à¸²à¸à¸µ', 46451 m : '1 à¸à¸²à¸à¸µ', 46452 mm : '%d à¸à¸²à¸à¸µ', 46453 h : '1 à¸à¸±à¹à¸§à¹à¸¡à¸', 46454 hh : '%d à¸à¸±à¹à¸§à¹à¸¡à¸', 46455 d : '1 วัà¸', 46456 dd : '%d วัà¸', 46457 M : '1 à¹à¸à¸·à¸à¸', 46458 MM : '%d à¹à¸à¸·à¸à¸', 46459 y : '1 à¸à¸µ', 46460 yy : '%d à¸à¸µ' 46461 } 46462 }); 46463 46464 return th; 46465 46466}))); 46467 46468 46469/***/ }), 46470/* 138 */ 46471/***/ (function(module, exports, __webpack_require__) { 46472 46473//! moment.js locale configuration 46474 46475;(function (global, factory) { 46476 true ? factory(__webpack_require__(0)) : 46477 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 46478 factory(global.moment) 46479}(this, (function (moment) { 'use strict'; 46480 46481 46482 var tlPh = moment.defineLocale('tl-ph', { 46483 months : 'Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre'.split('_'), 46484 monthsShort : 'Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis'.split('_'), 46485 weekdays : 'Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado'.split('_'), 46486 weekdaysShort : 'Lin_Lun_Mar_Miy_Huw_Biy_Sab'.split('_'), 46487 weekdaysMin : 'Li_Lu_Ma_Mi_Hu_Bi_Sab'.split('_'), 46488 longDateFormat : { 46489 LT : 'HH:mm', 46490 LTS : 'HH:mm:ss', 46491 L : 'MM/D/YYYY', 46492 LL : 'MMMM D, YYYY', 46493 LLL : 'MMMM D, YYYY HH:mm', 46494 LLLL : 'dddd, MMMM DD, YYYY HH:mm' 46495 }, 46496 calendar : { 46497 sameDay: 'LT [ngayong araw]', 46498 nextDay: '[Bukas ng] LT', 46499 nextWeek: 'LT [sa susunod na] dddd', 46500 lastDay: 'LT [kahapon]', 46501 lastWeek: 'LT [noong nakaraang] dddd', 46502 sameElse: 'L' 46503 }, 46504 relativeTime : { 46505 future : 'sa loob ng %s', 46506 past : '%s ang nakalipas', 46507 s : 'ilang segundo', 46508 ss : '%d segundo', 46509 m : 'isang minuto', 46510 mm : '%d minuto', 46511 h : 'isang oras', 46512 hh : '%d oras', 46513 d : 'isang araw', 46514 dd : '%d araw', 46515 M : 'isang buwan', 46516 MM : '%d buwan', 46517 y : 'isang taon', 46518 yy : '%d taon' 46519 }, 46520 dayOfMonthOrdinalParse: /\d{1,2}/, 46521 ordinal : function (number) { 46522 return number; 46523 }, 46524 week : { 46525 dow : 1, // Monday is the first day of the week. 46526 doy : 4 // The week that contains Jan 4th is the first week of the year. 46527 } 46528 }); 46529 46530 return tlPh; 46531 46532}))); 46533 46534 46535/***/ }), 46536/* 139 */ 46537/***/ (function(module, exports, __webpack_require__) { 46538 46539//! moment.js locale configuration 46540 46541;(function (global, factory) { 46542 true ? factory(__webpack_require__(0)) : 46543 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 46544 factory(global.moment) 46545}(this, (function (moment) { 'use strict'; 46546 46547 46548 var numbersNouns = 'pagh_waâ_chaâ_wej_loS_vagh_jav_Soch_chorgh_Hut'.split('_'); 46549 46550 function translateFuture(output) { 46551 var time = output; 46552 time = (output.indexOf('jaj') !== -1) ? 46553 time.slice(0, -3) + 'leS' : 46554 (output.indexOf('jar') !== -1) ? 46555 time.slice(0, -3) + 'waQ' : 46556 (output.indexOf('DIS') !== -1) ? 46557 time.slice(0, -3) + 'nem' : 46558 time + ' pIq'; 46559 return time; 46560 } 46561 46562 function translatePast(output) { 46563 var time = output; 46564 time = (output.indexOf('jaj') !== -1) ? 46565 time.slice(0, -3) + 'Huâ' : 46566 (output.indexOf('jar') !== -1) ? 46567 time.slice(0, -3) + 'wen' : 46568 (output.indexOf('DIS') !== -1) ? 46569 time.slice(0, -3) + 'ben' : 46570 time + ' ret'; 46571 return time; 46572 } 46573 46574 function translate(number, withoutSuffix, string, isFuture) { 46575 var numberNoun = numberAsNoun(number); 46576 switch (string) { 46577 case 'ss': 46578 return numberNoun + ' lup'; 46579 case 'mm': 46580 return numberNoun + ' tup'; 46581 case 'hh': 46582 return numberNoun + ' rep'; 46583 case 'dd': 46584 return numberNoun + ' jaj'; 46585 case 'MM': 46586 return numberNoun + ' jar'; 46587 case 'yy': 46588 return numberNoun + ' DIS'; 46589 } 46590 } 46591 46592 function numberAsNoun(number) { 46593 var hundred = Math.floor((number % 1000) / 100), 46594 ten = Math.floor((number % 100) / 10), 46595 one = number % 10, 46596 word = ''; 46597 if (hundred > 0) { 46598 word += numbersNouns[hundred] + 'vatlh'; 46599 } 46600 if (ten > 0) { 46601 word += ((word !== '') ? ' ' : '') + numbersNouns[ten] + 'maH'; 46602 } 46603 if (one > 0) { 46604 word += ((word !== '') ? ' ' : '') + numbersNouns[one]; 46605 } 46606 return (word === '') ? 'pagh' : word; 46607 } 46608 46609 var tlh = moment.defineLocale('tlh', { 46610 months : 'teraâ jar waâ_teraâ jar chaâ_teraâ jar wej_teraâ jar loS_teraâ jar vagh_teraâ jar jav_teraâ jar Soch_teraâ jar chorgh_teraâ jar Hut_teraâ jar waâmaH_teraâ jar waâmaH waâ_teraâ jar waâmaH chaâ'.split('_'), 46611 monthsShort : 'jar waâ_jar chaâ_jar wej_jar loS_jar vagh_jar jav_jar Soch_jar chorgh_jar Hut_jar waâmaH_jar waâmaH waâ_jar waâmaH chaâ'.split('_'), 46612 monthsParseExact : true, 46613 weekdays : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'), 46614 weekdaysShort : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'), 46615 weekdaysMin : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'), 46616 longDateFormat : { 46617 LT : 'HH:mm', 46618 LTS : 'HH:mm:ss', 46619 L : 'DD.MM.YYYY', 46620 LL : 'D MMMM YYYY', 46621 LLL : 'D MMMM YYYY HH:mm', 46622 LLLL : 'dddd, D MMMM YYYY HH:mm' 46623 }, 46624 calendar : { 46625 sameDay: '[DaHjaj] LT', 46626 nextDay: '[waâleS] LT', 46627 nextWeek: 'LLL', 46628 lastDay: '[waâHuâ] LT', 46629 lastWeek: 'LLL', 46630 sameElse: 'L' 46631 }, 46632 relativeTime : { 46633 future : translateFuture, 46634 past : translatePast, 46635 s : 'puS lup', 46636 ss : translate, 46637 m : 'waâ tup', 46638 mm : translate, 46639 h : 'waâ rep', 46640 hh : translate, 46641 d : 'waâ jaj', 46642 dd : translate, 46643 M : 'waâ jar', 46644 MM : translate, 46645 y : 'waâ DIS', 46646 yy : translate 46647 }, 46648 dayOfMonthOrdinalParse: /\d{1,2}\./, 46649 ordinal : '%d.', 46650 week : { 46651 dow : 1, // Monday is the first day of the week. 46652 doy : 4 // The week that contains Jan 4th is the first week of the year. 46653 } 46654 }); 46655 46656 return tlh; 46657 46658}))); 46659 46660 46661/***/ }), 46662/* 140 */ 46663/***/ (function(module, exports, __webpack_require__) { 46664 46665 46666;(function (global, factory) { 46667 true ? factory(__webpack_require__(0)) : 46668 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 46669 factory(global.moment) 46670}(this, (function (moment) { 'use strict'; 46671 46672 var suffixes = { 46673 1: '\'inci', 46674 5: '\'inci', 46675 8: '\'inci', 46676 70: '\'inci', 46677 80: '\'inci', 46678 2: '\'nci', 46679 7: '\'nci', 46680 20: '\'nci', 46681 50: '\'nci', 46682 3: '\'üncü', 46683 4: '\'üncü', 46684 100: '\'üncü', 46685 6: '\'ncı', 46686 9: '\'uncu', 46687 10: '\'uncu', 46688 30: '\'uncu', 46689 60: '\'ıncı', 46690 90: '\'ıncı' 46691 }; 46692 46693 var tr = moment.defineLocale('tr', { 46694 months : 'Ocak_Åubat_Mart_Nisan_Mayıs_Haziran_Temmuz_AÄustos_Eylül_Ekim_Kasım_Aralık'.split('_'), 46695 monthsShort : 'Oca_Åub_Mar_Nis_May_Haz_Tem_AÄu_Eyl_Eki_Kas_Ara'.split('_'), 46696 weekdays : 'Pazar_Pazartesi_Salı_ÃarÅamba_PerÅembe_Cuma_Cumartesi'.split('_'), 46697 weekdaysShort : 'Paz_Pts_Sal_Ãar_Per_Cum_Cts'.split('_'), 46698 weekdaysMin : 'Pz_Pt_Sa_Ãa_Pe_Cu_Ct'.split('_'), 46699 longDateFormat : { 46700 LT : 'HH:mm', 46701 LTS : 'HH:mm:ss', 46702 L : 'DD.MM.YYYY', 46703 LL : 'D MMMM YYYY', 46704 LLL : 'D MMMM YYYY HH:mm', 46705 LLLL : 'dddd, D MMMM YYYY HH:mm' 46706 }, 46707 calendar : { 46708 sameDay : '[bugün saat] LT', 46709 nextDay : '[yarın saat] LT', 46710 nextWeek : '[gelecek] dddd [saat] LT', 46711 lastDay : '[dün] LT', 46712 lastWeek : '[geçen] dddd [saat] LT', 46713 sameElse : 'L' 46714 }, 46715 relativeTime : { 46716 future : '%s sonra', 46717 past : '%s önce', 46718 s : 'birkaç saniye', 46719 ss : '%d saniye', 46720 m : 'bir dakika', 46721 mm : '%d dakika', 46722 h : 'bir saat', 46723 hh : '%d saat', 46724 d : 'bir gün', 46725 dd : '%d gün', 46726 M : 'bir ay', 46727 MM : '%d ay', 46728 y : 'bir yıl', 46729 yy : '%d yıl' 46730 }, 46731 ordinal: function (number, period) { 46732 switch (period) { 46733 case 'd': 46734 case 'D': 46735 case 'Do': 46736 case 'DD': 46737 return number; 46738 default: 46739 if (number === 0) { // special case for zero 46740 return number + '\'ıncı'; 46741 } 46742 var a = number % 10, 46743 b = number % 100 - a, 46744 c = number >= 100 ? 100 : null; 46745 return number + (suffixes[a] || suffixes[b] || suffixes[c]); 46746 } 46747 }, 46748 week : { 46749 dow : 1, // Monday is the first day of the week. 46750 doy : 7 // The week that contains Jan 1st is the first week of the year. 46751 } 46752 }); 46753 46754 return tr; 46755 46756}))); 46757 46758 46759/***/ }), 46760/* 141 */ 46761/***/ (function(module, exports, __webpack_require__) { 46762 46763//! moment.js locale configuration 46764 46765;(function (global, factory) { 46766 true ? factory(__webpack_require__(0)) : 46767 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 46768 factory(global.moment) 46769}(this, (function (moment) { 'use strict'; 46770 46771 46772 // After the year there should be a slash and the amount of years since December 26, 1979 in Roman numerals. 46773 // This is currently too difficult (maybe even impossible) to add. 46774 var tzl = moment.defineLocale('tzl', { 46775 months : 'Januar_Fevraglh_Març_Avrïu_Mai_Gün_Julia_Guscht_Setemvar_Listopäts_Noemvar_Zecemvar'.split('_'), 46776 monthsShort : 'Jan_Fev_Mar_Avr_Mai_Gün_Jul_Gus_Set_Lis_Noe_Zec'.split('_'), 46777 weekdays : 'Súladi_Lúneçi_Maitzi_Márcuri_Xhúadi_Viénerçi_Sáturi'.split('_'), 46778 weekdaysShort : 'Súl_Lún_Mai_Már_Xhú_Vié_Sát'.split('_'), 46779 weekdaysMin : 'Sú_Lú_Ma_Má_Xh_Vi_Sá'.split('_'), 46780 longDateFormat : { 46781 LT : 'HH.mm', 46782 LTS : 'HH.mm.ss', 46783 L : 'DD.MM.YYYY', 46784 LL : 'D. MMMM [dallas] YYYY', 46785 LLL : 'D. MMMM [dallas] YYYY HH.mm', 46786 LLLL : 'dddd, [li] D. MMMM [dallas] YYYY HH.mm' 46787 }, 46788 meridiemParse: /d\'o|d\'a/i, 46789 isPM : function (input) { 46790 return 'd\'o' === input.toLowerCase(); 46791 }, 46792 meridiem : function (hours, minutes, isLower) { 46793 if (hours > 11) { 46794 return isLower ? 'd\'o' : 'D\'O'; 46795 } else { 46796 return isLower ? 'd\'a' : 'D\'A'; 46797 } 46798 }, 46799 calendar : { 46800 sameDay : '[oxhi à ] LT', 46801 nextDay : '[demà à ] LT', 46802 nextWeek : 'dddd [à ] LT', 46803 lastDay : '[ieiri à ] LT', 46804 lastWeek : '[sür el] dddd [lasteu à ] LT', 46805 sameElse : 'L' 46806 }, 46807 relativeTime : { 46808 future : 'osprei %s', 46809 past : 'ja%s', 46810 s : processRelativeTime, 46811 ss : processRelativeTime, 46812 m : processRelativeTime, 46813 mm : processRelativeTime, 46814 h : processRelativeTime, 46815 hh : processRelativeTime, 46816 d : processRelativeTime, 46817 dd : processRelativeTime, 46818 M : processRelativeTime, 46819 MM : processRelativeTime, 46820 y : processRelativeTime, 46821 yy : processRelativeTime 46822 }, 46823 dayOfMonthOrdinalParse: /\d{1,2}\./, 46824 ordinal : '%d.', 46825 week : { 46826 dow : 1, // Monday is the first day of the week. 46827 doy : 4 // The week that contains Jan 4th is the first week of the year. 46828 } 46829 }); 46830 46831 function processRelativeTime(number, withoutSuffix, key, isFuture) { 46832 var format = { 46833 's': ['viensas secunds', '\'iensas secunds'], 46834 'ss': [number + ' secunds', '' + number + ' secunds'], 46835 'm': ['\'n mÃut', '\'iens mÃut'], 46836 'mm': [number + ' mÃuts', '' + number + ' mÃuts'], 46837 'h': ['\'n þora', '\'iensa þora'], 46838 'hh': [number + ' þoras', '' + number + ' þoras'], 46839 'd': ['\'n ziua', '\'iensa ziua'], 46840 'dd': [number + ' ziuas', '' + number + ' ziuas'], 46841 'M': ['\'n mes', '\'iens mes'], 46842 'MM': [number + ' mesen', '' + number + ' mesen'], 46843 'y': ['\'n ar', '\'iens ar'], 46844 'yy': [number + ' ars', '' + number + ' ars'] 46845 }; 46846 return isFuture ? format[key][0] : (withoutSuffix ? format[key][0] : format[key][1]); 46847 } 46848 46849 return tzl; 46850 46851}))); 46852 46853 46854/***/ }), 46855/* 142 */ 46856/***/ (function(module, exports, __webpack_require__) { 46857 46858//! moment.js locale configuration 46859 46860;(function (global, factory) { 46861 true ? factory(__webpack_require__(0)) : 46862 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 46863 factory(global.moment) 46864}(this, (function (moment) { 'use strict'; 46865 46866 46867 var tzmLatn = moment.defineLocale('tzm-latn', {
46868 months : 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_É£wÅ¡t_Å¡wtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'), 46869 monthsShort : 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_É£wÅ¡t_Å¡wtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'), 46870 weekdays : 'asamas_aynas_asinas_akras_akwas_asimwas_asiá¸yas'.split('_'), 46871 weekdaysShort : 'asamas_aynas_asinas_akras_akwas_asimwas_asiá¸yas'.split('_'), 46872 weekdaysMin : 'asamas_aynas_asinas_akras_akwas_asimwas_asiá¸yas'.split('_'), 46873 longDateFormat : { 46874 LT : 'HH:mm', 46875 LTS : 'HH:mm:ss', 46876 L : 'DD/MM/YYYY', 46877 LL : 'D MMMM YYYY', 46878 LLL : 'D MMMM YYYY HH:mm', 46879 LLLL : 'dddd D MMMM YYYY HH:mm' 46880 }, 46881 calendar : { 46882 sameDay: '[asdkh g] LT', 46883 nextDay: '[aska g] LT', 46884 nextWeek: 'dddd [g] LT', 46885 lastDay: '[assant g] LT', 46886 lastWeek: 'dddd [g] LT', 46887 sameElse: 'L' 46888 }, 46889 relativeTime : { 46890 future : 'dadkh s yan %s', 46891 past : 'yan %s', 46892 s : 'imik', 46893 ss : '%d imik', 46894 m : 'minuá¸', 46895 mm : '%d minuá¸', 46896 h : 'saÉa', 46897 hh : '%d tassaÉin', 46898 d : 'ass', 46899 dd : '%d ossan', 46900 M : 'ayowr', 46901 MM : '%d iyyirn', 46902 y : 'asgas', 46903 yy : '%d isgasn' 46904 }, 46905 week : { 46906 dow : 6, // Saturday is the first day of the week. 46907 doy : 12 // The week that contains Jan 1st is the first week of the year. 46908 } 46909 }); 46910 46911 return tzmLatn; 46912 46913}))); 46914 46915 46916/***/ }), 46917/* 143 */ 46918/***/ (function(module, exports, __webpack_require__) { 46919 46920//! moment.js locale configuration 46921 46922;(function (global, factory) { 46923 true ? factory(__webpack_require__(0)) : 46924 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 46925 factory(global.moment) 46926}(this, (function (moment) { 'use strict'; 46927 46928 46929 var tzm = moment.defineLocale('tzm', { 46930 months : 'âµâµâµâ´°âµ¢âµ_â´±âµâ´°âµ¢âµ_âµâ´°âµâµ_âµâ´±âµâµâµ_âµâ´°âµ¢âµ¢âµ_âµ¢âµâµâµ¢âµ_âµ¢âµâµâµ¢âµâµ£_âµâµâµâµ_âµâµâµâ´°âµâ´±âµâµ_â´½âµâµâ´±âµ_âµâµâµ¡â´°âµâ´±âµâµ_â´·âµâµâµâ´±âµâµ'.split('_'), 46931 monthsShort : 'âµâµâµâ´°âµ¢âµ_â´±âµâ´°âµ¢âµ_âµâ´°âµâµ_âµâ´±âµâµâµ_âµâ´°âµ¢âµ¢âµ_âµ¢âµâµâµ¢âµ_âµ¢âµâµâµ¢âµâµ£_âµâµâµâµ_âµâµâµâ´°âµâ´±âµâµ_â´½âµâµâ´±âµ_âµâµâµ¡â´°âµâ´±âµâµ_â´·âµâµâµâ´±âµâµ'.split('_'), 46932 weekdays : 'â´°âµâ´°âµâ´°âµ_â´°âµ¢âµâ´°âµ_â´°âµâµâµâ´°âµ_â´°â´½âµâ´°âµ_ⴰⴽⵡⴰâµ_â´°âµâµâµâµ¡â´°âµ_â´°âµâµâ´¹âµ¢â´°âµ'.split('_'), 46933 weekdaysShort : 'â´°âµâ´°âµâ´°âµ_â´°âµ¢âµâ´°âµ_â´°âµâµâµâ´°âµ_â´°â´½âµâ´°âµ_ⴰⴽⵡⴰâµ_â´°âµâµâµâµ¡â´°âµ_â´°âµâµâ´¹âµ¢â´°âµ'.split('_'), 46934 weekdaysMin : 'â´°âµâ´°âµâ´°âµ_â´°âµ¢âµâ´°âµ_â´°âµâµâµâ´°âµ_â´°â´½âµâ´°âµ_ⴰⴽⵡⴰâµ_â´°âµâµâµâµ¡â´°âµ_â´°âµâµâ´¹âµ¢â´°âµ'.split('_'), 46935 longDateFormat : { 46936 LT : 'HH:mm', 46937 LTS: 'HH:mm:ss', 46938 L : 'DD/MM/YYYY', 46939 LL : 'D MMMM YYYY', 46940 LLL : 'D MMMM YYYY HH:mm', 46941 LLLL : 'dddd D MMMM YYYY HH:mm' 46942 }, 46943 calendar : { 46944 sameDay: '[â´°âµâ´·âµ â´´] LT', 46945 nextDay: '[â´°âµâ´½â´° â´´] LT', 46946 nextWeek: 'dddd [â´´] LT', 46947 lastDay: '[â´°âµâ´°âµâµ â´´] LT', 46948 lastWeek: 'dddd [â´´] LT', 46949 sameElse: 'L' 46950 }, 46951 relativeTime : { 46952 future : 'ⴷⴰⴷⵠⵠⵢⴰⵠ%s', 46953 past : 'ⵢⴰⵠ%s', 46954 s : 'âµâµâµâ´½', 46955 ss : '%d âµâµâµâ´½', 46956 m : 'âµâµâµâµâ´º', 46957 mm : '%d âµâµâµâµâ´º', 46958 h : 'âµâ´°âµâ´°', 46959 hh : '%d âµâ´°âµâµâ´°âµâµâµ', 46960 d : 'â´°âµâµ', 46961 dd : '%d oâµâµâ´°âµ', 46962 M : 'â´°âµ¢oâµâµ', 46963 MM : '%d âµâµ¢âµ¢âµâµâµ', 46964 y : 'â´°âµâ´³â´°âµ', 46965 yy : '%d âµâµâ´³â´°âµâµ' 46966 }, 46967 week : { 46968 dow : 6, // Saturday is the first day of the week. 46969 doy : 12 // The week that contains Jan 1st is the first week of the year. 46970 } 46971 }); 46972 46973 return tzm; 46974 46975}))); 46976 46977 46978/***/ }), 46979/* 144 */ 46980/***/ (function(module, exports, __webpack_require__) { 46981 46982//! moment.js language configuration 46983 46984;(function (global, factory) { 46985 true ? factory(__webpack_require__(0)) : 46986 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 46987 factory(global.moment) 46988}(this, (function (moment) { 'use strict'; 46989 46990 46991 var ugCn = moment.defineLocale('ug-cn', { 46992 months: 'ÙاÙÛار_ÙÛÛراÙ_٠ارت_ئاپرÛÙ_٠اÙ_ئÙÙÛÙ_ئÙÙÛÙ_ئاÛغÛست_سÛÙتÛبÙر_ئÛÙتÛبÙر_ÙÙÙابÙر_دÛÙابÙر'.split( 46993 '_' 46994 ), 46995 monthsShort: 'ÙاÙÛار_ÙÛÛراÙ_٠ارت_ئاپرÛÙ_٠اÙ_ئÙÙÛÙ_ئÙÙÛÙ_ئاÛغÛست_سÛÙتÛبÙر_ئÛÙتÛبÙر_ÙÙÙابÙر_دÛÙابÙر'.split( 46996 '_' 46997 ), 46998 weekdays: 'ÙÛÙØ´ÛÙبÛ_دÛØ´ÛÙبÛ_سÛÙØ´ÛÙبÛ_ÚارشÛÙبÛ_Ù¾ÛÙØ´ÛÙبÛ_جÛÙ Û_Ø´ÛÙبÛ'.split( 46999 '_' 47000 ), 47001 weekdaysShort: 'ÙÛ_دÛ_سÛ_Úا_Ù¾Û_جÛ_Ø´Û'.split('_'), 47002 weekdaysMin: 'ÙÛ_دÛ_سÛ_Úا_Ù¾Û_جÛ_Ø´Û'.split('_'), 47003 longDateFormat: { 47004 LT: 'HH:mm', 47005 LTS: 'HH:mm:ss', 47006 L: 'YYYY-MM-DD', 47007 LL: 'YYYY-ÙÙÙÙM-ئاÙÙÙÚD-ÙÛÙÙ',
vendor: 19,876 bytes, lines 47008-47580
47008 LLL: 'YYYY-ÙÙÙÙM-ئاÙÙÙÚD-ÙÛÙÙØ HH:mm', 47009 LLLL: 'ddddØ YYYY-ÙÙÙÙM-ئاÙÙÙÚD-ÙÛÙÙØ HH:mm' 47010 }, 47011 meridiemParse: /ÙÛرÙÙ ÙÛÚÛ|سÛÚ¾Ûر|ÚÛشتÙ٠بÛرÛÙ|ÚÛØ´|ÚÛشتÙÙ ÙÛÙÙÙ|ÙÛÚ/, 47012 meridiemHour: function (hour, meridiem) { 47013 if (hour === 12) { 47014 hour = 0; 47015 } 47016 if ( 47017 meridiem === 'ÙÛرÙÙ ÙÛÚÛ' || 47018 meridiem === 'سÛÚ¾Ûر' || 47019 meridiem === 'ÚÛشتÙ٠بÛرÛÙ' 47020 ) { 47021 return hour; 47022 } else if (meridiem === 'ÚÛشتÙÙ ÙÛÙÙÙ' || meridiem === 'ÙÛÚ') { 47023 return hour + 12; 47024 } else { 47025 return hour >= 11 ? hour : hour + 12; 47026 } 47027 }, 47028 meridiem: function (hour, minute, isLower) { 47029 var hm = hour * 100 + minute; 47030 if (hm < 600) { 47031 return 'ÙÛرÙÙ ÙÛÚÛ'; 47032 } else if (hm < 900) { 47033 return 'سÛÚ¾Ûر'; 47034 } else if (hm < 1130) { 47035 return 'ÚÛشتÙ٠بÛرÛÙ'; 47036 } else if (hm < 1230) { 47037 return 'ÚÛØ´'; 47038 } else if (hm < 1800) { 47039 return 'ÚÛشتÙÙ ÙÛÙÙÙ'; 47040 } else { 47041 return 'ÙÛÚ'; 47042 } 47043 }, 47044 calendar: { 47045 sameDay: '[بÛÚ¯Û٠سائÛت] LT', 47046 nextDay: '[ئÛØªÛ Ø³Ø§Ø¦Ûت] LT', 47047 nextWeek: '[ÙÛÙÛرÙÙ] dddd [سائÛت] LT', 47048 lastDay: '[تÛÙÛÚ¯ÛÙ] LT', 47049 lastWeek: '[ئاÙدÙÙÙÙ] dddd [سائÛت] LT', 47050 sameElse: 'L' 47051 }, 47052 relativeTime: { 47053 future: '%s ÙÛÙÙÙ', 47054 past: '%s بÛرÛÙ', 47055 s: 'ÙÛÚÚÛ Ø³ÛÙÙÙت', 47056 ss: '%d سÛÙÙÙت', 47057 m: 'بÙر Ù ÙÙÛت', 47058 mm: '%d Ù ÙÙÛت', 47059 h: 'بÙر سائÛت', 47060 hh: '%d سائÛت', 47061 d: 'بÙر ÙÛÙ', 47062 dd: '%d ÙÛÙ', 47063 M: 'بÙر ئاÙ', 47064 MM: '%d ئاÙ', 47065 y: 'بÙر ÙÙÙ', 47066 yy: '%d ÙÙÙ' 47067 }, 47068 47069 dayOfMonthOrdinalParse: /\d{1,2}(-ÙÛÙÙ|-ئاÙ|-Ú¾ÛپتÛ)/, 47070 ordinal: function (number, period) { 47071 switch (period) { 47072 case 'd': 47073 case 'D': 47074 case 'DDD': 47075 return number + '-ÙÛÙÙ'; 47076 case 'w': 47077 case 'W': 47078 return number + '-Ú¾ÛپتÛ'; 47079 default: 47080 return number; 47081 } 47082 }, 47083 preparse: function (string) { 47084 return string.replace(/Ø/g, ','); 47085 }, 47086 postformat: function (string) { 47087 return string.replace(/,/g, 'Ø'); 47088 }, 47089 week: { 47090 // GB/T 7408-1994ãæ°æ®å å交æ¢æ ¼å¼Â·ä¿¡æ¯äº¤æ¢Â·æ¥æåæ¶é´è¡¨ç¤ºæ³ãä¸ISO 8601:1988çæ 47091 dow: 1, // Monday is the first day of the week. 47092 doy: 7 // The week that contains Jan 1st is the first week of the year. 47093 } 47094 }); 47095 47096 return ugCn; 47097 47098}))); 47099 47100 47101/***/ }), 47102/* 145 */ 47103/***/ (function(module, exports, __webpack_require__) { 47104 47105//! moment.js locale configuration 47106 47107;(function (global, factory) { 47108 true ? factory(__webpack_require__(0)) : 47109 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 47110 factory(global.moment) 47111}(this, (function (moment) { 'use strict'; 47112 47113 47114 function plural(word, num) { 47115 var forms = word.split('_'); 47116 return num % 10 === 1 && num % 100 !== 11 ? forms[0] : (num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]); 47117 } 47118 function relativeTimeWithPlural(number, withoutSuffix, key) { 47119 var format = { 47120 'ss': withoutSuffix ? 'ÑекÑнда_ÑекÑнди_ÑекÑнд' : 'ÑекÑндÑ_ÑекÑнди_ÑекÑнд', 47121 'mm': withoutSuffix ? 'Ñ Ð²Ð¸Ð»Ð¸Ð½Ð°_Ñ Ð²Ð¸Ð»Ð¸Ð½Ð¸_Ñ Ð²Ð¸Ð»Ð¸Ð½' : 'Ñ Ð²Ð¸Ð»Ð¸Ð½Ñ_Ñ Ð²Ð¸Ð»Ð¸Ð½Ð¸_Ñ Ð²Ð¸Ð»Ð¸Ð½', 47122 'hh': withoutSuffix ? 'година_години_годин' : 'годинÑ_години_годин', 47123 'dd': 'денÑ_днÑ_днÑв', 47124 'MM': 'мÑÑÑÑÑ_мÑÑÑÑÑ_мÑÑÑÑÑв', 47125 'yy': 'ÑÑк_Ñоки_ÑокÑв' 47126 }; 47127 if (key === 'm') { 47128 return withoutSuffix ? 'Ñ Ð²Ð¸Ð»Ð¸Ð½Ð°' : 'Ñ Ð²Ð¸Ð»Ð¸Ð½Ñ'; 47129 } 47130 else if (key === 'h') { 47131 return withoutSuffix ? 'година' : 'годинÑ'; 47132 } 47133 else { 47134 return number + ' ' + plural(format[key], +number); 47135 } 47136 } 47137 function weekdaysCaseReplace(m, format) { 47138 var weekdays = { 47139 'nominative': 'недÑлÑ_понедÑлок_вÑвÑоÑок_ÑеÑеда_ÑеÑвеÑ_пâÑÑниÑÑ_ÑÑбоÑа'.split('_'), 47140 'accusative': 'недÑлÑ_понедÑлок_вÑвÑоÑок_ÑеÑедÑ_ÑеÑвеÑ_пâÑÑниÑÑ_ÑÑбоÑÑ'.split('_'), 47141 'genitive': 'недÑлÑ_понедÑлка_вÑвÑоÑка_ÑеÑеди_ÑеÑвеÑга_пâÑÑниÑÑ_ÑÑбоÑи'.split('_') 47142 }; 47143 47144 if (!m) { 47145 return weekdays['nominative']; 47146 } 47147 47148 var nounCase = (/(\[[ÐвУÑ]\]) ?dddd/).test(format) ? 47149 'accusative' : 47150 ((/\[?(?:минÑлоÑ|наÑÑÑпноÑ)? ?\] ?dddd/).test(format) ? 47151 'genitive' : 47152 'nominative'); 47153 return weekdays[nounCase][m.day()]; 47154 } 47155 function processHoursFunction(str) { 47156 return function () { 47157 return str + 'о' + (this.hours() === 11 ? 'б' : '') + '] LT'; 47158 }; 47159 } 47160 47161 var uk = moment.defineLocale('uk', { 47162 months : { 47163 'format': 'ÑÑÑнÑ_лÑÑого_беÑезнÑ_квÑÑнÑ_ÑÑавнÑ_ÑеÑвнÑ_липнÑ_ÑеÑпнÑ_веÑеÑнÑ_жовÑнÑ_лиÑÑопада_гÑÑднÑ'.split('_'), 47164 'standalone': 'ÑÑÑенÑ_лÑÑий_беÑезенÑ_квÑÑенÑ_ÑÑавенÑ_ÑеÑвенÑ_липенÑ_ÑеÑпенÑ_веÑеÑенÑ_жовÑенÑ_лиÑÑопад_гÑÑденÑ'.split('_') 47165 }, 47166 monthsShort : 'ÑÑÑ_лÑÑ_беÑ_квÑÑ_ÑÑав_ÑеÑв_лип_ÑеÑп_веÑ_жовÑ_лиÑÑ_гÑÑд'.split('_'), 47167 weekdays : weekdaysCaseReplace, 47168 weekdaysShort : 'нд_пн_вÑ_ÑÑ_ÑÑ_пÑ_Ñб'.split('_'), 47169 weekdaysMin : 'нд_пн_вÑ_ÑÑ_ÑÑ_пÑ_Ñб'.split('_'), 47170 longDateFormat : { 47171 LT : 'HH:mm', 47172 LTS : 'HH:mm:ss', 47173 L : 'DD.MM.YYYY', 47174 LL : 'D MMMM YYYY Ñ.', 47175 LLL : 'D MMMM YYYY Ñ., HH:mm', 47176 LLLL : 'dddd, D MMMM YYYY Ñ., HH:mm' 47177 }, 47178 calendar : { 47179 sameDay: processHoursFunction('[СÑÐ¾Ð³Ð¾Ð´Ð½Ñ '), 47180 nextDay: processHoursFunction('[ÐавÑÑа '), 47181 lastDay: processHoursFunction('[ÐÑоÑа '), 47182 nextWeek: processHoursFunction('[У] dddd ['), 47183 lastWeek: function () { 47184 switch (this.day()) { 47185 case 0: 47186 case 3: 47187 case 5: 47188 case 6: 47189 return processHoursFunction('[ÐинÑлоÑ] dddd [').call(this); 47190 case 1: 47191 case 2: 47192 case 4: 47193 return processHoursFunction('[ÐинÑлого] dddd [').call(this); 47194 } 47195 }, 47196 sameElse: 'L' 47197 }, 47198 relativeTime : { 47199 future : 'за %s', 47200 past : '%s ÑомÑ', 47201 s : 'декÑлÑка ÑекÑнд', 47202 ss : relativeTimeWithPlural, 47203 m : relativeTimeWithPlural, 47204 mm : relativeTimeWithPlural, 47205 h : 'годинÑ', 47206 hh : relativeTimeWithPlural, 47207 d : 'денÑ', 47208 dd : relativeTimeWithPlural, 47209 M : 'мÑÑÑÑÑ', 47210 MM : relativeTimeWithPlural, 47211 y : 'ÑÑк', 47212 yy : relativeTimeWithPlural 47213 }, 47214 // M. E.: those two are virtually unused but a user might want to implement them for his/her website for some reason 47215 meridiemParse: /ноÑÑ|ÑанкÑ|днÑ|веÑоÑа/, 47216 isPM: function (input) { 47217 return /^(днÑ|веÑоÑа)$/.test(input); 47218 }, 47219 meridiem : function (hour, minute, isLower) { 47220 if (hour < 4) { 47221 return 'ноÑÑ'; 47222 } else if (hour < 12) { 47223 return 'ÑанкÑ'; 47224 } else if (hour < 17) { 47225 return 'днÑ'; 47226 } else { 47227 return 'веÑоÑа'; 47228 } 47229 }, 47230 dayOfMonthOrdinalParse: /\d{1,2}-(й|го)/, 47231 ordinal: function (number, period) { 47232 switch (period) { 47233 case 'M': 47234 case 'd': 47235 case 'DDD': 47236 case 'w': 47237 case 'W': 47238 return number + '-й'; 47239 case 'D': 47240 return number + '-го'; 47241 default: 47242 return number; 47243 } 47244 }, 47245 week : { 47246 dow : 1, // Monday is the first day of the week. 47247 doy : 7 // The week that contains Jan 1st is the first week of the year. 47248 } 47249 }); 47250 47251 return uk; 47252 47253}))); 47254 47255 47256/***/ }), 47257/* 146 */ 47258/***/ (function(module, exports, __webpack_require__) { 47259 47260//! moment.js locale configuration 47261 47262;(function (global, factory) { 47263 true ? factory(__webpack_require__(0)) : 47264 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 47265 factory(global.moment) 47266}(this, (function (moment) { 'use strict'; 47267 47268 47269 var months = [ 47270 'جÙÙرÛ', 47271 'ÙرÙرÛ', 47272 '٠ارÚ', 47273 'اپرÛÙ', 47274 '٠ئÛ', 47275 'جÙÙ', 47276 'جÙÙائÛ', 47277 'اگست', 47278 'ست٠بر', 47279 'اکتÙبر', 47280 'ÙÙ٠بر', 47281 'دس٠بر' 47282 ]; 47283 var days = [ 47284 'اتÙار', 47285 'Ù¾Ûر', 47286 'Ù ÙÚ¯Ù', 47287 'بدھ', 47288 'ج٠عرات', 47289 'ج٠عÛ', 47290 'ÛÙتÛ' 47291 ]; 47292 47293 var ur = moment.defineLocale('ur', { 47294 months : months, 47295 monthsShort : months, 47296 weekdays : days, 47297 weekdaysShort : days, 47298 weekdaysMin : days, 47299 longDateFormat : { 47300 LT : 'HH:mm', 47301 LTS : 'HH:mm:ss', 47302 L : 'DD/MM/YYYY', 47303 LL : 'D MMMM YYYY', 47304 LLL : 'D MMMM YYYY HH:mm', 47305 LLLL : 'ddddØ D MMMM YYYY HH:mm' 47306 }, 47307 meridiemParse: /صبØ|شا٠/, 47308 isPM : function (input) { 47309 return 'شا٠' === input; 47310 }, 47311 meridiem : function (hour, minute, isLower) { 47312 if (hour < 12) { 47313 return 'صبØ'; 47314 } 47315 return 'شا٠'; 47316 }, 47317 calendar : { 47318 sameDay : '[آج بÙÙت] LT', 47319 nextDay : '[ک٠بÙÙت] LT', 47320 nextWeek : 'dddd [بÙÙت] LT', 47321 lastDay : '[Ú¯Ø°Ø´ØªÛ Ø±Ùز بÙÙت] LT', 47322 lastWeek : '[گذشتÛ] dddd [بÙÙت] LT', 47323 sameElse : 'L' 47324 }, 47325 relativeTime : { 47326 future : '%s بعد', 47327 past : '%s ÙبÙ', 47328 s : 'ÚÙد سÛÚ©ÙÚ', 47329 ss : '%d سÛÚ©ÙÚ', 47330 m : 'اÛÚ© Ù ÙÙ¹', 47331 mm : '%d Ù ÙÙ¹', 47332 h : 'اÛÚ© Ú¯Ú¾ÙÙ¹Û', 47333 hh : '%d Ú¯Ú¾ÙÙ¹Û', 47334 d : 'اÛÚ© دÙ', 47335 dd : '%d دÙ', 47336 M : 'اÛÚ© ٠اÛ', 47337 MM : '%d ٠اÛ', 47338 y : 'اÛÚ© ساÙ', 47339 yy : '%d ساÙ' 47340 }, 47341 preparse: function (string) { 47342 return string.replace(/Ø/g, ','); 47343 }, 47344 postformat: function (string) { 47345 return string.replace(/,/g, 'Ø'); 47346 }, 47347 week : { 47348 dow : 1, // Monday is the first day of the week. 47349 doy : 4 // The week that contains Jan 4th is the first week of the year. 47350 } 47351 }); 47352 47353 return ur; 47354 47355}))); 47356 47357 47358/***/ }), 47359/* 147 */ 47360/***/ (function(module, exports, __webpack_require__) { 47361 47362//! moment.js locale configuration 47363 47364;(function (global, factory) { 47365 true ? factory(__webpack_require__(0)) : 47366 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 47367 factory(global.moment) 47368}(this, (function (moment) { 'use strict'; 47369 47370 47371 var uzLatn = moment.defineLocale('uz-latn', { 47372 months : 'Yanvar_Fevral_Mart_Aprel_May_Iyun_Iyul_Avgust_Sentabr_Oktabr_Noyabr_Dekabr'.split('_'), 47373 monthsShort : 'Yan_Fev_Mar_Apr_May_Iyun_Iyul_Avg_Sen_Okt_Noy_Dek'.split('_'), 47374 weekdays : 'Yakshanba_Dushanba_Seshanba_Chorshanba_Payshanba_Juma_Shanba'.split('_'), 47375 weekdaysShort : 'Yak_Dush_Sesh_Chor_Pay_Jum_Shan'.split('_'), 47376 weekdaysMin : 'Ya_Du_Se_Cho_Pa_Ju_Sha'.split('_'), 47377 longDateFormat : { 47378 LT : 'HH:mm', 47379 LTS : 'HH:mm:ss', 47380 L : 'DD/MM/YYYY', 47381 LL : 'D MMMM YYYY', 47382 LLL : 'D MMMM YYYY HH:mm', 47383 LLLL : 'D MMMM YYYY, dddd HH:mm' 47384 }, 47385 calendar : { 47386 sameDay : '[Bugun soat] LT [da]', 47387 nextDay : '[Ertaga] LT [da]', 47388 nextWeek : 'dddd [kuni soat] LT [da]', 47389 lastDay : '[Kecha soat] LT [da]', 47390 lastWeek : '[O\'tgan] dddd [kuni soat] LT [da]', 47391 sameElse : 'L' 47392 }, 47393 relativeTime : { 47394 future : 'Yaqin %s ichida', 47395 past : 'Bir necha %s oldin', 47396 s : 'soniya', 47397 ss : '%d soniya', 47398 m : 'bir daqiqa', 47399 mm : '%d daqiqa', 47400 h : 'bir soat', 47401 hh : '%d soat', 47402 d : 'bir kun', 47403 dd : '%d kun', 47404 M : 'bir oy', 47405 MM : '%d oy', 47406 y : 'bir yil', 47407 yy : '%d yil' 47408 }, 47409 week : { 47410 dow : 1, // Monday is the first day of the week. 47411 doy : 7 // The week that contains Jan 1st is the first week of the year. 47412 } 47413 }); 47414 47415 return uzLatn; 47416 47417}))); 47418 47419 47420/***/ }), 47421/* 148 */ 47422/***/ (function(module, exports, __webpack_require__) { 47423 47424//! moment.js locale configuration 47425 47426;(function (global, factory) { 47427 true ? factory(__webpack_require__(0)) : 47428 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 47429 factory(global.moment) 47430}(this, (function (moment) { 'use strict'; 47431 47432 47433 var uz = moment.defineLocale('uz', { 47434 months : 'ÑнваÑ_ÑевÑал_маÑÑ_апÑел_май_иÑн_иÑл_авгÑÑÑ_ÑенÑÑбÑ_окÑÑбÑ_ноÑбÑ_декабÑ'.split('_'), 47435 monthsShort : 'Ñнв_Ñев_маÑ_апÑ_май_иÑн_иÑл_авг_Ñен_окÑ_ноÑ_дек'.split('_'), 47436 weekdays : 'ЯкÑанба_ÐÑÑанба_СеÑанба_ЧоÑÑанба_ÐайÑанба_ÐÑма_Шанба'.split('_'), 47437 weekdaysShort : 'ЯкÑ_ÐÑÑ_СеÑ_ЧоÑ_Ðай_ÐÑм_Шан'.split('_'), 47438 weekdaysMin : 'Як_ÐÑ_Се_Чо_Ðа_ÐÑ_Ша'.split('_'), 47439 longDateFormat : { 47440 LT : 'HH:mm', 47441 LTS : 'HH:mm:ss', 47442 L : 'DD/MM/YYYY', 47443 LL : 'D MMMM YYYY', 47444 LLL : 'D MMMM YYYY HH:mm', 47445 LLLL : 'D MMMM YYYY, dddd HH:mm' 47446 }, 47447 calendar : { 47448 sameDay : '[ÐÑгÑн ÑоаÑ] LT [да]', 47449 nextDay : '[ÐÑÑага] LT [да]', 47450 nextWeek : 'dddd [кÑни ÑоаÑ] LT [да]', 47451 lastDay : '[ÐеÑа ÑоаÑ] LT [да]', 47452 lastWeek : '[УÑган] dddd [кÑни ÑоаÑ] LT [да]', 47453 sameElse : 'L' 47454 }, 47455 relativeTime : { 47456 future : 'Якин %s иÑида', 47457 past : 'ÐÐ¸Ñ Ð½ÐµÑа %s олдин', 47458 s : 'ÑÑÑÑаÑ', 47459 ss : '%d ÑÑÑÑаÑ', 47460 m : 'Ð±Ð¸Ñ Ð´Ð°ÐºÐ¸ÐºÐ°', 47461 mm : '%d дакика', 47462 h : 'Ð±Ð¸Ñ ÑоаÑ', 47463 hh : '%d ÑоаÑ', 47464 d : 'Ð±Ð¸Ñ ÐºÑн', 47465 dd : '%d кÑн', 47466 M : 'Ð±Ð¸Ñ Ð¾Ð¹', 47467 MM : '%d ой', 47468 y : 'Ð±Ð¸Ñ Ð¹Ð¸Ð»', 47469 yy : '%d йил' 47470 }, 47471 week : { 47472 dow : 1, // Monday is the first day of the week. 47473 doy : 7 // The week that contains Jan 4th is the first week of the year. 47474 } 47475 }); 47476 47477 return uz; 47478 47479}))); 47480 47481 47482/***/ }), 47483/* 149 */ 47484/***/ (function(module, exports, __webpack_require__) { 47485 47486//! moment.js locale configuration 47487 47488;(function (global, factory) { 47489 true ? factory(__webpack_require__(0)) : 47490 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 47491 factory(global.moment) 47492}(this, (function (moment) { 'use strict'; 47493 47494 47495 var vi = moment.defineLocale('vi', { 47496 months : 'tháng 1_tháng 2_tháng 3_tháng 4_tháng 5_tháng 6_tháng 7_tháng 8_tháng 9_tháng 10_tháng 11_tháng 12'.split('_'), 47497 monthsShort : 'Th01_Th02_Th03_Th04_Th05_Th06_Th07_Th08_Th09_Th10_Th11_Th12'.split('_'), 47498 monthsParseExact : true, 47499 weekdays : 'chủ nháºt_thứ hai_thứ ba_thứ tÆ°_thứ nÄm_thứ sáu_thứ bảy'.split('_'), 47500 weekdaysShort : 'CN_T2_T3_T4_T5_T6_T7'.split('_'), 47501 weekdaysMin : 'CN_T2_T3_T4_T5_T6_T7'.split('_'), 47502 weekdaysParseExact : true, 47503 meridiemParse: /sa|ch/i, 47504 isPM : function (input) { 47505 return /^ch$/i.test(input); 47506 }, 47507 meridiem : function (hours, minutes, isLower) { 47508 if (hours < 12) { 47509 return isLower ? 'sa' : 'SA'; 47510 } else { 47511 return isLower ? 'ch' : 'CH'; 47512 } 47513 }, 47514 longDateFormat : { 47515 LT : 'HH:mm', 47516 LTS : 'HH:mm:ss', 47517 L : 'DD/MM/YYYY', 47518 LL : 'D MMMM [nÄm] YYYY', 47519 LLL : 'D MMMM [nÄm] YYYY HH:mm', 47520 LLLL : 'dddd, D MMMM [nÄm] YYYY HH:mm', 47521 l : 'DD/M/YYYY', 47522 ll : 'D MMM YYYY', 47523 lll : 'D MMM YYYY HH:mm', 47524 llll : 'ddd, D MMM YYYY HH:mm' 47525 }, 47526 calendar : { 47527 sameDay: '[Hôm nay lúc] LT', 47528 nextDay: '[Ngà y mai lúc] LT', 47529 nextWeek: 'dddd [tuần tá»i lúc] LT', 47530 lastDay: '[Hôm qua lúc] LT', 47531 lastWeek: 'dddd [tuần rá»i lúc] LT', 47532 sameElse: 'L' 47533 }, 47534 relativeTime : { 47535 future : '%s tá»i', 47536 past : '%s trÆ°á»c', 47537 s : 'và i giây', 47538 ss : '%d giây' , 47539 m : 'má»t phút', 47540 mm : '%d phút', 47541 h : 'má»t giá»', 47542 hh : '%d giá»', 47543 d : 'má»t ngà y', 47544 dd : '%d ngà y', 47545 M : 'má»t tháng', 47546 MM : '%d tháng', 47547 y : 'má»t nÄm', 47548 yy : '%d nÄm' 47549 }, 47550 dayOfMonthOrdinalParse: /\d{1,2}/, 47551 ordinal : function (number) { 47552 return number; 47553 }, 47554 week : { 47555 dow : 1, // Monday is the first day of the week. 47556 doy : 4 // The week that contains Jan 4th is the first week of the year. 47557 } 47558 }); 47559 47560 return vi; 47561 47562}))); 47563 47564 47565/***/ }), 47566/* 150 */ 47567/***/ (function(module, exports, __webpack_require__) { 47568 47569//! moment.js locale configuration 47570 47571;(function (global, factory) { 47572 true ? factory(__webpack_require__(0)) : 47573 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 47574 factory(global.moment) 47575}(this, (function (moment) { 'use strict'; 47576 47577 47578 var xPseudo = moment.defineLocale('x-pseudo', { 47579 months : 'J~áñúá~rý_F~ébrú~árý_~Márc~h_Ãp~rÃl_~Máý_~Júñé~_Júl~ý_Ãú~gúst~_Sép~témb~ér_Ã~ctób~ér_Ã~óvém~bér_~Décé~mbér'.split('_'), 47580 monthsShort : 'J~áñ_~Féb_~Már_~Ãpr_~Máý_~Júñ_~Júl_~Ãúg_~Sép_~Ãct_~Ãóv_~Déc'.
47580split('_'), 47581 monthsParseExact : true, 47582 weekdays : 'S~úñdá~ý_Mó~ñdáý~_Túé~sdáý~_Wéd~ñésd~áý_T~húrs~dáý_~FrÃd~áý_S~átúr~dáý'.split('_'), 47583 weekdaysShort : 'S~úñ_~Móñ_~Túé_~Wéd_~Thú_~FrÃ_~Sát'.split('_'), 47584 weekdaysMin : 'S~ú_Mó~_Tú_~Wé_T~h_Fr~_Sá'.split('_'), 47585 weekdaysParseExact : true, 47586 longDateFormat : { 47587 LT : 'HH:mm', 47588 L : 'DD/MM/YYYY', 47589 LL : 'D MMMM YYYY', 47590 LLL : 'D MMMM YYYY HH:mm', 47591 LLLL : 'dddd, D MMMM YYYY HH:mm' 47592 }, 47593 calendar : { 47594 sameDay : '[T~ódá~ý át] LT', 47595 nextDay : '[T~ómó~rró~w át] LT', 47596 nextWeek : 'dddd [át] LT', 47597 lastDay : '[Ã~ést~érdá~ý át] LT', 47598 lastWeek : '[L~ást] dddd [át] LT', 47599 sameElse : 'L' 47600 }, 47601 relativeTime : { 47602 future : 'Ã~ñ %s', 47603 past : '%s á~gó', 47604 s : 'á ~féw ~sécó~ñds', 47605 ss : '%d s~écóñ~ds',
vendor: 14,258 bytes, lines 47606-48033
47606 m : 'á ~mÃñ~úté', 47607 mm : '%d m~Ãñú~tés', 47608 h : 'á~ñ hó~úr', 47609 hh : '%d h~óúrs', 47610 d : 'á ~dáý', 47611 dd : '%d d~áýs', 47612 M : 'á ~móñ~th', 47613 MM : '%d m~óñt~hs', 47614 y : 'á ~ýéár', 47615 yy : '%d ý~éárs' 47616 }, 47617 dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/, 47618 ordinal : function (number) { 47619 var b = number % 10, 47620 output = (~~(number % 100 / 10) === 1) ? 'th' : 47621 (b === 1) ? 'st' : 47622 (b === 2) ? 'nd' : 47623 (b === 3) ? 'rd' : 'th'; 47624 return number + output; 47625 }, 47626 week : { 47627 dow : 1, // Monday is the first day of the week. 47628 doy : 4 // The week that contains Jan 4th is the first week of the year. 47629 } 47630 }); 47631 47632 return xPseudo; 47633 47634}))); 47635 47636 47637/***/ }), 47638/* 151 */ 47639/***/ (function(module, exports, __webpack_require__) { 47640 47641//! moment.js locale configuration 47642 47643;(function (global, factory) { 47644 true ? factory(__webpack_require__(0)) : 47645 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 47646 factory(global.moment) 47647}(this, (function (moment) { 'use strict'; 47648 47649 47650 var yo = moment.defineLocale('yo', { 47651 months : 'SẹÌrẹÌ_EÌreÌleÌ_ẸrẹÌnaÌ_IÌgbeÌ_EÌbibi_OÌkuÌdu_Agẹmo_OÌguÌn_Owewe_á»ÌwaÌraÌ_BeÌluÌ_á»ÌpẹÌÌ'.split('_'), 47652 monthsShort : 'SẹÌr_EÌrl_Ẹrn_IÌgb_EÌbi_OÌkuÌ_Agẹ_OÌguÌ_Owe_á»ÌwaÌ_BeÌl_á»ÌpẹÌÌ'.split('_'), 47653 weekdays : 'AÌiÌkuÌ_AjeÌ_IÌsẹÌgun_á»já»ÌruÌ_á»já»Ìbá»_ẸtiÌ_AÌbaÌmẹÌta'.split('_'), 47654 weekdaysShort : 'AÌiÌk_AjeÌ_IÌsẹÌ_á»jr_á»jb_ẸtiÌ_AÌbaÌ'.split('_'), 47655 weekdaysMin : 'AÌiÌ_Aj_IÌs_á»r_á»b_Ẹt_AÌb'.split('_'), 47656 longDateFormat : { 47657 LT : 'h:mm A', 47658 LTS : 'h:mm:ss A', 47659 L : 'DD/MM/YYYY', 47660 LL : 'D MMMM YYYY', 47661 LLL : 'D MMMM YYYY h:mm A', 47662 LLLL : 'dddd, D MMMM YYYY h:mm A' 47663 }, 47664 calendar : { 47665 sameDay : '[OÌniÌ ni] LT', 47666 nextDay : '[á»Ìla ni] LT', 47667 nextWeek : 'dddd [á»sáº¹Ì toÌn\'bá»] [ni] LT', 47668 lastDay : '[AÌna ni] LT', 47669 lastWeek : 'dddd [á»sáº¹Ì toÌlá»Ì] [ni] LT', 47670 sameElse : 'L' 47671 }, 47672 relativeTime : { 47673 future : 'niÌ %s', 47674 past : '%s ká»jaÌ', 47675 s : 'iÌsẹjuÌ aayaÌ die', 47676 ss :'aayaÌ %d', 47677 m : 'iÌsẹjuÌ kan', 47678 mm : 'iÌsẹjuÌ %d', 47679 h : 'waÌkati kan', 47680 hh : 'waÌkati %d', 47681 d : 'á»já»Ì kan', 47682 dd : 'á»já»Ì %d', 47683 M : 'osuÌ kan', 47684 MM : 'osuÌ %d', 47685 y : 'á»duÌn kan', 47686 yy : 'á»duÌn %d' 47687 }, 47688 dayOfMonthOrdinalParse : /á»já»Ì\s\d{1,2}/, 47689 ordinal : 'á»já»Ì %d', 47690 week : { 47691 dow : 1, // Monday is the first day of the week. 47692 doy : 4 // The week that contains Jan 4th is the first week of the year. 47693 } 47694 }); 47695 47696 return yo; 47697 47698}))); 47699 47700 47701/***/ }), 47702/* 152 */ 47703/***/ (function(module, exports, __webpack_require__) { 47704 47705//! moment.js locale configuration 47706 47707;(function (global, factory) { 47708 true ? factory(__webpack_require__(0)) : 47709 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 47710 factory(global.moment) 47711}(this, (function (moment) { 'use strict'; 47712 47713 47714 var zhCn = moment.defineLocale('zh-cn', { 47715 months : 'ä¸æ_äºæ_ä¸æ_åæ_äºæ_å æ_ä¸æ_å «æ_ä¹æ_åæ_åä¸æ_åäºæ'.split('_'), 47716 monthsShort : '1æ_2æ_3æ_4æ_5æ_6æ_7æ_8æ_9æ_10æ_11æ_12æ'.split('_'), 47717 weekdays : 'æææ¥_ææä¸_ææäº_ææä¸_ææå_ææäº_ææå '.split('_'), 47718 weekdaysShort : 'å¨æ¥_å¨ä¸_å¨äº_å¨ä¸_å¨å_å¨äº_å¨å '.split('_'), 47719 weekdaysMin : 'æ¥_ä¸_äº_ä¸_å_äº_å '.split('_'), 47720 longDateFormat : { 47721 LT : 'HH:mm', 47722 LTS : 'HH:mm:ss', 47723 L : 'YYYY/MM/DD', 47724 LL : 'YYYYå¹´MæDæ¥', 47725 LLL : 'YYYYå¹´MæDæ¥Ahç¹mmå', 47726 LLLL : 'YYYYå¹´MæDæ¥ddddAhç¹mmå', 47727 l : 'YYYY/M/D', 47728 ll : 'YYYYå¹´MæDæ¥', 47729 lll : 'YYYYå¹´MæDæ¥ HH:mm', 47730 llll : 'YYYYå¹´MæDæ¥dddd HH:mm' 47731 }, 47732 meridiemParse: /åæ¨|æ©ä¸|ä¸å|ä¸å|ä¸å|æä¸/, 47733 meridiemHour: function (hour, meridiem) { 47734 if (hour === 12) { 47735 hour = 0; 47736 } 47737 if (meridiem === 'åæ¨' || meridiem === 'æ©ä¸' || 47738 meridiem === 'ä¸å') { 47739 return hour; 47740 } else if (meridiem === 'ä¸å' || meridiem === 'æä¸') { 47741 return hour + 12; 47742 } else { 47743 // 'ä¸å' 47744 return hour >= 11 ? hour : hour + 12; 47745 } 47746 }, 47747 meridiem : function (hour, minute, isLower) { 47748 var hm = hour * 100 + minute; 47749 if (hm < 600) { 47750 return 'åæ¨'; 47751 } else if (hm < 900) { 47752 return 'æ©ä¸'; 47753 } else if (hm < 1130) { 47754 return 'ä¸å'; 47755 } else if (hm < 1230) { 47756 return 'ä¸å'; 47757 } else if (hm < 1800) { 47758 return 'ä¸å'; 47759 } else { 47760 return 'æä¸'; 47761 } 47762 }, 47763 calendar : { 47764 sameDay : '[ä»å¤©]LT', 47765 nextDay : '[æ天]LT', 47766 nextWeek : '[ä¸]ddddLT', 47767 lastDay : '[æ¨å¤©]LT', 47768 lastWeek : '[ä¸]ddddLT', 47769 sameElse : 'L' 47770 }, 47771 dayOfMonthOrdinalParse: /\d{1,2}(æ¥|æ|å¨)/, 47772 ordinal : function (number, period) { 47773 switch (period) { 47774 case 'd': 47775 case 'D': 47776 case 'DDD': 47777 return number + 'æ¥'; 47778 case 'M': 47779 return number + 'æ'; 47780 case 'w': 47781 case 'W': 47782 return number + 'å¨'; 47783 default: 47784 return number; 47785 } 47786 }, 47787 relativeTime : { 47788 future : '%så ', 47789 past : '%så', 47790 s : 'å ç§', 47791 ss : '%d ç§', 47792 m : '1 åé', 47793 mm : '%d åé', 47794 h : '1 å°æ¶', 47795 hh : '%d å°æ¶', 47796 d : '1 天', 47797 dd : '%d 天', 47798 M : '1 个æ', 47799 MM : '%d 个æ', 47800 y : '1 å¹´', 47801 yy : '%d å¹´' 47802 }, 47803 week : { 47804 // GB/T 7408-1994ãæ°æ®å å交æ¢æ ¼å¼Â·ä¿¡æ¯äº¤æ¢Â·æ¥æåæ¶é´è¡¨ç¤ºæ³ãä¸ISO 8601:1988çæ 47805 dow : 1, // Monday is the first day of the week. 47806 doy : 4 // The week that contains Jan 4th is the first week of the year. 47807 } 47808 }); 47809 47810 return zhCn; 47811 47812}))); 47813 47814 47815/***/ }), 47816/* 153 */ 47817/***/ (function(module, exports, __webpack_require__) { 47818 47819//! moment.js locale configuration 47820 47821;(function (global, factory) { 47822 true ? factory(__webpack_require__(0)) : 47823 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 47824 factory(global.moment) 47825}(this, (function (moment) { 'use strict'; 47826 47827 47828 var zhHk = moment.defineLocale('zh-hk', { 47829 months : 'ä¸æ_äºæ_ä¸æ_åæ_äºæ_å æ_ä¸æ_å «æ_ä¹æ_åæ_åä¸æ_åäºæ'.split('_'), 47830 monthsShort : '1æ_2æ_3æ_4æ_5æ_6æ_7æ_8æ_9æ_10æ_11æ_12æ'.split('_'), 47831 weekdays : 'æææ¥_ææä¸_ææäº_ææä¸_ææå_ææäº_ææå '.split('_'), 47832 weekdaysShort : 'é±æ¥_é±ä¸_é±äº_é±ä¸_é±å_é±äº_é±å '.split('_'), 47833 weekdaysMin : 'æ¥_ä¸_äº_ä¸_å_äº_å '.split('_'), 47834 longDateFormat : { 47835 LT : 'HH:mm', 47836 LTS : 'HH:mm:ss', 47837 L : 'YYYY/MM/DD', 47838 LL : 'YYYYå¹´MæDæ¥', 47839 LLL : 'YYYYå¹´MæDæ¥ HH:mm', 47840 LLLL : 'YYYYå¹´MæDæ¥dddd HH:mm', 47841 l : 'YYYY/M/D', 47842 ll : 'YYYYå¹´MæDæ¥', 47843 lll : 'YYYYå¹´MæDæ¥ HH:mm', 47844 llll : 'YYYYå¹´MæDæ¥dddd HH:mm' 47845 }, 47846 meridiemParse: /åæ¨|æ©ä¸|ä¸å|ä¸å|ä¸å|æä¸/, 47847 meridiemHour : function (hour, meridiem) { 47848 if (hour === 12) { 47849 hour = 0; 47850 } 47851 if (meridiem === 'åæ¨' || meridiem === 'æ©ä¸' || meridiem === 'ä¸å') { 47852 return hour; 47853 } else if (meridiem === 'ä¸å') { 47854 return hour >= 11 ? hour : hour + 12; 47855 } else if (meridiem === 'ä¸å' || meridiem === 'æä¸') { 47856 return hour + 12; 47857 } 47858 }, 47859 meridiem : function (hour, minute, isLower) { 47860 var hm = hour * 100 + minute; 47861 if (hm < 600) { 47862 return 'åæ¨'; 47863 } else if (hm < 900) { 47864 return 'æ©ä¸'; 47865 } else if (hm < 1130) { 47866 return 'ä¸å'; 47867 } else if (hm < 1230) { 47868 return 'ä¸å'; 47869 } else if (hm < 1800) { 47870 return 'ä¸å'; 47871 } else { 47872 return 'æä¸'; 47873 } 47874 }, 47875 calendar : { 47876 sameDay : '[ä»å¤©]LT', 47877 nextDay : '[æ天]LT', 47878 nextWeek : '[ä¸]ddddLT', 47879 lastDay : '[æ¨å¤©]LT', 47880 lastWeek : '[ä¸]ddddLT', 47881 sameElse : 'L' 47882 }, 47883 dayOfMonthOrdinalParse: /\d{1,2}(æ¥|æ|é±)/, 47884 ordinal : function (number, period) { 47885 switch (period) { 47886 case 'd' : 47887 case 'D' : 47888 case 'DDD' : 47889 return number + 'æ¥'; 47890 case 'M' : 47891 return number + 'æ'; 47892 case 'w' : 47893 case 'W' : 47894 return number + 'é±'; 47895 default : 47896 return number; 47897 } 47898 }, 47899 relativeTime : { 47900 future : '%så §', 47901 past : '%så', 47902 s : 'å¹¾ç§', 47903 ss : '%d ç§', 47904 m : '1 åé', 47905 mm : '%d åé', 47906 h : '1 å°æ', 47907 hh : '%d å°æ', 47908 d : '1 天', 47909 dd : '%d 天', 47910 M : '1 åæ', 47911 MM : '%d åæ', 47912 y : '1 å¹´', 47913 yy : '%d å¹´' 47914 } 47915 }); 47916 47917 return zhHk; 47918 47919}))); 47920 47921 47922/***/ }), 47923/* 154 */ 47924/***/ (function(module, exports, __webpack_require__) { 47925 47926//! moment.js locale configuration 47927 47928;(function (global, factory) { 47929 true ? factory(__webpack_require__(0)) : 47930 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 47931 factory(global.moment) 47932}(this, (function (moment) { 'use strict'; 47933 47934 47935 var zhTw = moment.defineLocale('zh-tw', { 47936 months : 'ä¸æ_äºæ_ä¸æ_åæ_äºæ_å æ_ä¸æ_å «æ_ä¹æ_åæ_åä¸æ_åäºæ'.split('_'), 47937 monthsShort : '1æ_2æ_3æ_4æ_5æ_6æ_7æ_8æ_9æ_10æ_11æ_12æ'.split('_'), 47938 weekdays : 'æææ¥_ææä¸_ææäº_ææä¸_ææå_ææäº_ææå '.split('_'), 47939 weekdaysShort : 'é±æ¥_é±ä¸_é±äº_é±ä¸_é±å_é±äº_é±å '.split('_'), 47940 weekdaysMin : 'æ¥_ä¸_äº_ä¸_å_äº_å '.split('_'), 47941 longDateFormat : { 47942 LT : 'HH:mm', 47943 LTS : 'HH:mm:ss', 47944 L : 'YYYY/MM/DD', 47945 LL : 'YYYYå¹´MæDæ¥', 47946 LLL : 'YYYYå¹´MæDæ¥ HH:mm', 47947 LLLL : 'YYYYå¹´MæDæ¥dddd HH:mm', 47948 l : 'YYYY/M/D', 47949 ll : 'YYYYå¹´MæDæ¥', 47950 lll : 'YYYYå¹´MæDæ¥ HH:mm', 47951 llll : 'YYYYå¹´MæDæ¥dddd HH:mm' 47952 }, 47953 meridiemParse: /åæ¨|æ©ä¸|ä¸å|ä¸å|ä¸å|æä¸/, 47954 meridiemHour : function (hour, meridiem) { 47955 if (hour === 12) { 47956 hour = 0; 47957 } 47958 if (meridiem === 'åæ¨' || meridiem === 'æ©ä¸' || meridiem === 'ä¸å') { 47959 return hour; 47960 } else if (meridiem === 'ä¸å') { 47961 return hour >= 11 ? hour : hour + 12; 47962 } else if (meridiem === 'ä¸å' || meridiem === 'æä¸') { 47963 return hour + 12; 47964 } 47965 }, 47966 meridiem : function (hour, minute, isLower) { 47967 var hm = hour * 100 + minute; 47968 if (hm < 600) { 47969 return 'åæ¨'; 47970 } else if (hm < 900) { 47971 return 'æ©ä¸'; 47972 } else if (hm < 1130) { 47973 return 'ä¸å'; 47974 } else if (hm < 1230) { 47975 return 'ä¸å'; 47976 } else if (hm < 1800) { 47977 return 'ä¸å'; 47978 } else { 47979 return 'æä¸'; 47980 } 47981 }, 47982 calendar : { 47983 sameDay : '[ä»å¤©] LT', 47984 nextDay : '[æ天] LT', 47985 nextWeek : '[ä¸]dddd LT', 47986 lastDay : '[æ¨å¤©] LT', 47987 lastWeek : '[ä¸]dddd LT', 47988 sameElse : 'L' 47989 }, 47990 dayOfMonthOrdinalParse: /\d{1,2}(æ¥|æ|é±)/, 47991 ordinal : function (number, period) { 47992 switch (period) { 47993 case 'd' : 47994 case 'D' : 47995 case 'DDD' : 47996 return number + 'æ¥'; 47997 case 'M' : 47998 return number + 'æ'; 47999 case 'w' : 48000 case 'W' : 48001 return number + 'é±'; 48002 default : 48003 return number; 48004 } 48005 }, 48006 relativeTime : { 48007 future : '%så §', 48008 past : '%så', 48009 s : 'å¹¾ç§', 48010 ss : '%d ç§', 48011 m : '1 åé', 48012 mm : '%d åé', 48013 h : '1 å°æ', 48014 hh : '%d å°æ', 48015 d : '1 天', 48016 dd : '%d 天', 48017 M : '1 åæ', 48018 MM : '%d åæ', 48019 y : '1 å¹´', 48020 yy : '%d å¹´' 48021 } 48022 }); 48023 48024 return zhTw; 48025 48026}))); 48027 48028 48029/***/ }), 48030/* 155 */ 48031/***/ (function(module, exports, __webpack_require__) { 48032 48033/* WEBPACK VAR INJECTION */(function(__webpack_provided_window_dot_jQuery, jQuery) {
vendor: 23,216 bytes, lines 48033-48979
48033/** 48034 * Owl Carousel v2.3.4 48035 * Copyright 2013-2018 David Deutsch 48036 * Licensed under: SEE LICENSE IN https://github.com/OwlCarousel2/OwlCarousel2/blob/master/LICENSE 48037 */ 48038/** 48039 * Owl carousel 48040 * @version 2.3.4 48041 * @author Bartosz Wojciechowski 48042 * @author David Deutsch 48043 * @license The MIT License (MIT) 48044 * @todo Lazy Load Icon 48045 * @todo prevent animationend bubling 48046 * @todo itemsScaleUp 48047 * @todo Test Zepto 48048 * @todo stagePadding calculate wrong active classes 48049 */ 48050;(function($, window, document, undefined) { 48051 48052 /** 48053 * Creates a carousel. 48054 * @class The Owl Carousel. 48055 * @public 48056 * @param {HTMLElement|jQuery} element - The element to create the carousel for. 48057 * @param {Object} [options] - The options 48058 */ 48059 function Owl(element, options) { 48060 48061 /** 48062 * Current settings for the carousel. 48063 * @public 48064 */ 48065 this.settings = null; 48066 48067 /** 48068 * Current options set by the caller including defaults. 48069 * @public 48070 */ 48071 this.options = $.extend({}, Owl.Defaults, options); 48072 48073 /** 48074 * Plugin element. 48075 * @public 48076 */ 48077 this.$element = $(element); 48078 48079 /** 48080 * Proxied event handlers. 48081 * @protected 48082 */ 48083 this._handlers = {}; 48084 48085 /** 48086 * References to the running plugins of this carousel. 48087 * @protected 48088 */ 48089 this._plugins = {}; 48090 48091 /** 48092 * Currently suppressed events to prevent them from being retriggered. 48093 * @protected 48094 */ 48095 this._supress = {}; 48096 48097 /** 48098 * Absolute current position. 48099 * @protected 48100 */ 48101 this._current = null; 48102 48103 /** 48104 * Animation speed in milliseconds. 48105 * @protected 48106 */ 48107 this._speed = null; 48108 48109 /** 48110 * Coordinates of all items in pixel. 48111 * @todo The name of this member is missleading. 48112 * @protected 48113 */ 48114 this._coordinates = []; 48115 48116 /** 48117 * Current breakpoint. 48118 * @todo Real media queries would be nice. 48119 * @protected 48120 */ 48121 this._breakpoint = null; 48122 48123 /** 48124 * Current width of the plugin element. 48125 */ 48126 this._width = null; 48127 48128 /** 48129 * All real items. 48130 * @protected 48131 */ 48132 this._items = []; 48133 48134 /** 48135 * All cloned items. 48136 * @protected 48137 */ 48138 this._clones = []; 48139 48140 /** 48141 * Merge values of all items. 48142 * @todo Maybe this could be part of a plugin. 48143 * @protected 48144 */ 48145 this._mergers = []; 48146 48147 /** 48148 * Widths of all items. 48149 */ 48150 this._widths = []; 48151 48152 /** 48153 * Invalidated parts within the update process. 48154 * @protected 48155 */ 48156 this._invalidated = {}; 48157 48158 /** 48159 * Ordered list of workers for the update process. 48160 * @protected 48161 */ 48162 this._pipe = []; 48163 48164 /** 48165 * Current state information for the drag operation. 48166 * @todo #261 48167 * @protected 48168 */ 48169 this._drag = { 48170 time: null, 48171 target: null, 48172 pointer: null, 48173 stage: { 48174 start: null, 48175 current: null 48176 }, 48177 direction: null 48178 }; 48179 48180 /** 48181 * Current state information and their tags. 48182 * @type {Object} 48183 * @protected 48184 */ 48185 this._states = { 48186 current: {}, 48187 tags: { 48188 'initializing': [ 'busy' ], 48189 'animating': [ 'busy' ], 48190 'dragging': [ 'interacting' ] 48191 } 48192 }; 48193 48194 $.each([ 'onResize', 'onThrottledResize' ], $.proxy(function(i, handler) { 48195 this._handlers[handler] = $.proxy(this[handler], this); 48196 }, this)); 48197 48198 $.each(Owl.Plugins, $.proxy(function(key, plugin) { 48199 this._plugins[key.charAt(0).toLowerCase() + key.slice(1)] 48200 = new plugin(this); 48201 }, this)); 48202 48203 $.each(Owl.Workers, $.proxy(function(priority, worker) { 48204 this._pipe.push({ 48205 'filter': worker.filter, 48206 'run': $.proxy(worker.run, this) 48207 }); 48208 }, this)); 48209 48210 this.setup(); 48211 this.initialize(); 48212 } 48213 48214 /** 48215 * Default options for the carousel. 48216 * @public 48217 */ 48218 Owl.Defaults = { 48219 items: 3, 48220 loop: false, 48221 center: false, 48222 rewind: false, 48223 checkVisibility: true, 48224 48225 mouseDrag: true, 48226 touchDrag: true, 48227 pullDrag: true, 48228 freeDrag: false, 48229 48230 margin: 0, 48231 stagePadding: 0, 48232 48233 merge: false, 48234 mergeFit: true, 48235 autoWidth: false, 48236 48237 startPosition: 0, 48238 rtl: false, 48239 48240 smartSpeed: 250, 48241 fluidSpeed: false, 48242 dragEndSpeed: false, 48243 48244 responsive: {}, 48245 responsiveRefreshRate: 200, 48246 responsiveBaseElement: window, 48247 48248 fallbackEasing: 'swing', 48249 slideTransition: '', 48250 48251 info: false, 48252 48253 nestedItemSelector: false, 48254 itemElement: 'div', 48255 stageElement: 'div', 48256 48257 refreshClass: 'owl-refresh', 48258 loadedClass: 'owl-loaded', 48259 loadingClass: 'owl-loading', 48260 rtlClass: 'owl-rtl', 48261 responsiveClass: 'owl-responsive', 48262 dragClass: 'owl-drag', 48263 itemClass: 'owl-item', 48264 stageClass: 'owl-stage', 48265 stageOuterClass: 'owl-stage-outer', 48266 grabClass: 'owl-grab' 48267 }; 48268 48269 /** 48270 * Enumeration for width. 48271 * @public 48272 * @readonly 48273 * @enum {String} 48274 */ 48275 Owl.Width = { 48276 Default: 'default', 48277 Inner: 'inner', 48278 Outer: 'outer' 48279 }; 48280 48281 /** 48282 * Enumeration for types. 48283 * @public 48284 * @readonly 48285 * @enum {String} 48286 */ 48287 Owl.Type = { 48288 Event: 'event', 48289 State: 'state' 48290 }; 48291 48292 /** 48293 * Contains all registered plugins. 48294 * @public 48295 */ 48296 Owl.Plugins = {}; 48297 48298 /** 48299 * List of workers involved in the update process. 48300 */ 48301 Owl.Workers = [ { 48302 filter: [ 'width', 'settings' ], 48303 run: function() { 48304 this._width = this.$element.width(); 48305 } 48306 }, { 48307 filter: [ 'width', 'items', 'settings' ], 48308 run: function(cache) { 48309 cache.current = this._items && this._items[this.relative(this._current)]; 48310 } 48311 }, { 48312 filter: [ 'items', 'settings' ], 48313 run: function() { 48314 this.$stage.children('.cloned').remove(); 48315 } 48316 }, { 48317 filter: [ 'width', 'items', 'settings' ], 48318 run: function(cache) { 48319 var margin = this.settings.margin || '', 48320 grid = !this.settings.autoWidth, 48321 rtl = this.settings.rtl, 48322 css = { 48323 'width': 'auto', 48324 'margin-left': rtl ? margin : '', 48325 'margin-right': rtl ? '' : margin 48326 }; 48327 48328 !grid && this.$stage.children().css(css); 48329 48330 cache.css = css; 48331 } 48332 }, { 48333 filter: [ 'width', 'items', 'settings' ], 48334 run: function(cache) { 48335 var width = (this.width() / this.settings.items).toFixed(3) - this.settings.margin, 48336 merge = null, 48337 iterator = this._items.length, 48338 grid = !this.settings.autoWidth, 48339 widths = []; 48340 48341 cache.items = { 48342 merge: false, 48343 width: width 48344 }; 48345 48346 while (iterator--) { 48347 merge = this._mergers[iterator]; 48348 merge = this.settings.mergeFit && Math.min(merge, this.settings.items) || merge; 48349 48350 cache.items.merge = merge > 1 || cache.items.merge; 48351 48352 widths[iterator] = !grid ? this._items[iterator].width() : width * merge; 48353 } 48354 48355 this._widths = widths; 48356 } 48357 }, { 48358 filter: [ 'items', 'settings' ], 48359 run: function() { 48360 var clones = [], 48361 items = this._items, 48362 settings = this.settings, 48363 // TODO: Should be computed from number of min width items in stage 48364 view = Math.max(settings.items * 2, 4), 48365 size = Math.ceil(items.length / 2) * 2, 48366 repeat = settings.loop && items.length ? settings.rewind ? view : Math.max(view, size) : 0, 48367 append = '', 48368 prepend = ''; 48369 48370 repeat /= 2; 48371 48372 while (repeat > 0) { 48373 // Switch to only using appended clones 48374 clones.push(this.normalize(clones.length / 2, true)); 48375 append = append + items[clones[clones.length - 1]][0].outerHTML; 48376 clones.push(this.normalize(items.length - 1 - (clones.length - 1) / 2, true)); 48377 prepend = items[clones[clones.length - 1]][0].outerHTML + prepend; 48378 repeat -= 1; 48379 } 48380 48381 this._clones = clones; 48382 48383 $(append).addClass('cloned').appendTo(this.$stage); 48384 $(prepend).addClass('cloned').prependTo(this.$stage); 48385 } 48386 }, { 48387 filter: [ 'width', 'items', 'settings' ], 48388 run: function() { 48389 var rtl = this.settings.rtl ? 1 : -1, 48390 size = this._clones.length + this._items.length, 48391 iterator = -1, 48392 previous = 0, 48393 current = 0, 48394 coordinates = []; 48395 48396 while (++iterator < size) { 48397 previous = coordinates[iterator - 1] || 0; 48398 current = this._widths[this.relative(iterator)] + this.settings.margin; 48399 coordinates.push(previous + current * rtl); 48400 } 48401 48402 this._coordinates = coordinates; 48403 } 48404 }, { 48405 filter: [ 'width', 'items', 'settings' ], 48406 run: function() { 48407 var padding = this.settings.stagePadding, 48408 coordinates = this._coordinates, 48409 css = { 48410 'width': Math.ceil(Math.abs(coordinates[coordinates.length - 1])) + padding * 2, 48411 'padding-left': padding || '', 48412 'padding-right': padding || '' 48413 }; 48414 48415 this.$stage.css(css); 48416 } 48417 }, { 48418 filter: [ 'width', 'items', 'settings' ], 48419 run: function(cache) { 48420 var iterator = this._coordinates.length, 48421 grid = !this.settings.autoWidth, 48422 items = this.$stage.children(); 48423 48424 if (grid && cache.items.merge) { 48425 while (iterator--) { 48426 cache.css.width = this._widths[this.relative(iterator)]; 48427 items.eq(iterator).css(cache.css); 48428 } 48429 } else if (grid) { 48430 cache.css.width = cache.items.width; 48431 items.css(cache.css); 48432 } 48433 } 48434 }, { 48435 filter: [ 'items' ], 48436 run: function() { 48437 this._coordinates.length < 1 && this.$stage.removeAttr('style'); 48438 } 48439 }, { 48440 filter: [ 'width', 'items', 'settings' ], 48441 run: function(cache) { 48442 cache.current = cache.current ? this.$stage.children().index(cache.current) : 0; 48443 cache.current = Math.max(this.minimum(), Math.min(this.maximum(), cache.current)); 48444 this.reset(cache.current); 48445 } 48446 }, { 48447 filter: [ 'position' ], 48448 run: function() { 48449 this.animate(this.coordinates(this._current)); 48450 } 48451 }, { 48452 filter: [ 'width', 'position', 'items', 'settings' ], 48453 run: function() { 48454 var rtl = this.settings.rtl ? 1 : -1, 48455 padding = this.settings.stagePadding * 2, 48456 begin = this.coordinates(this.current()) + padding, 48457 end = begin + this.width() * rtl, 48458 inner, outer, matches = [], i, n; 48459 48460 for (i = 0, n = this._coordinates.length; i < n; i++) { 48461 inner = this._coordinates[i - 1] || 0; 48462 outer = Math.abs(this._coordinates[i]) + padding * rtl; 48463 48464 if ((this.op(inner, '<=', begin) && (this.op(inner, '>', end))) 48465 || (this.op(outer, '<', begin) && this.op(outer, '>', end))) { 48466 matches.push(i); 48467 } 48468 } 48469 48470 this.$stage.children('.active').removeClass('active'); 48471 this.$stage.children(':eq(' + matches.join('), :eq(') + ')').addClass('active'); 48472 48473 this.$stage.children('.center').removeClass('center'); 48474 if (this.settings.center) { 48475 this.$stage.children().eq(this.current()).addClass('center'); 48476 } 48477 } 48478 } ]; 48479 48480 /** 48481 * Create the stage DOM element 48482 */ 48483 Owl.prototype.initializeStage = function() { 48484 this.$stage = this.$element.find('.' + this.settings.stageClass); 48485 48486 // if the stage is already in the DOM, grab it and skip stage initialization 48487 if (this.$stage.length) { 48488 return; 48489 } 48490 48491 this.$element.addClass(this.options.loadingClass); 48492 48493 // create stage 48494 this.$stage = $('<' + this.settings.stageElement + '>', { 48495 "class": this.settings.stageClass 48496 }).wrap( $( '<div/>', { 48497 "class": this.settings.stageOuterClass 48498 })); 48499 48500 // append stage 48501 this.$element.append(this.$stage.parent()); 48502 }; 48503 48504 /** 48505 * Create item DOM elements 48506 */ 48507 Owl.prototype.initializeItems = function() { 48508 var $items = this.$element.find('.owl-item'); 48509 48510 // if the items are already in the DOM, grab them and skip item initialization 48511 if ($items.length) { 48512 this._items = $items.get().map(function(item) { 48513 return $(item); 48514 }); 48515 48516 this._mergers = this._items.map(function() { 48517 return 1; 48518 }); 48519 48520 this.refresh(); 48521 48522 return; 48523 } 48524 48525 // append content 48526 this.replace(this.$element.children().not(this.$stage.parent())); 48527 48528 // check visibility 48529 if (this.isVisible()) { 48530 // update view 48531 this.refresh(); 48532 } else { 48533 // invalidate width 48534 this.invalidate('width'); 48535 } 48536 48537 this.$element 48538 .removeClass(this.options.loadingClass) 48539 .addClass(this.options.loadedClass); 48540 }; 48541 48542 /** 48543 * Initializes the carousel. 48544 * @protected 48545 */ 48546 Owl.prototype.initialize = function() { 48547 this.enter('initializing'); 48548 this.trigger('initialize'); 48549 48550 this.$element.toggleClass(this.settings.rtlClass, this.settings.rtl); 48551 48552 if (this.settings.autoWidth && !this.is('pre-loading')) { 48553 var imgs, nestedSelector, width; 48554 imgs = this.$element.find('img'); 48555 nestedSelector = this.settings.nestedItemSelector ? '.' + this.settings.nestedItemSelector : undefined; 48556 width = this.$element.children(nestedSelector).width(); 48557 48558 if (imgs.length && width <= 0) { 48559 this.preloadAutoWidthImages(imgs); 48560 } 48561 } 48562 48563 this.initializeStage(); 48564 this.initializeItems(); 48565 48566 // register event handlers 48567 this.registerEventHandlers(); 48568 48569 this.leave('initializing'); 48570 this.trigger('initialized'); 48571 }; 48572 48573 /** 48574 * @returns {Boolean} visibility of $element 48575 * if you know the carousel will always be visible you can set `checkVisibility` to `false` to 48576 * prevent the expensive browser layout forced reflow the $element.is(':visible') does 48577 */ 48578 Owl.prototype.isVisible = function() { 48579 return this.settings.checkVisibility 48580 ? this.$element.is(':visible') 48581 : true; 48582 }; 48583 48584 /** 48585 * Setups the current settings. 48586 * @todo Remove responsive classes. Why should adaptive designs be brought into IE8? 48587 * @todo Support for media queries by using `matchMedia` would be nice. 48588 * @public 48589 */ 48590 Owl.prototype.setup = function() { 48591 var viewport = this.viewport(), 48592 overwrites = this.options.responsive, 48593 match = -1, 48594 settings = null; 48595 48596 if (!overwrites) { 48597 settings = $.extend({}, this.options); 48598 } else { 48599 $.each(overwrites, function(breakpoint) { 48600 if (breakpoint <= viewport && breakpoint > match) { 48601 match = Number(breakpoint); 48602 } 48603 }); 48604 48605 settings = $.extend({}, this.options, overwrites[match]); 48606 if (typeof settings.stagePadding === 'function') { 48607 settings.stagePadding = settings.stagePadding(); 48608 } 48609 delete settings.responsive; 48610 48611 // responsive class 48612 if (settings.responsiveClass) { 48613 this.$element.attr('class', 48614 this.$element.attr('class').replace(new RegExp('(' + this.options.responsiveClass + '-)\\S+\\s', 'g'), '$1' + match) 48615 ); 48616 } 48617 } 48618 48619 this.trigger('change', { property: { name: 'settings', value: settings } }); 48620 this._breakpoint = match; 48621 this.settings = settings; 48622 this.invalidate('settings'); 48623 this.trigger('changed', { property: { name: 'settings', value: this.settings } }); 48624 }; 48625 48626 /** 48627 * Updates option logic if necessery. 48628 * @protected 48629 */ 48630 Owl.prototype.optionsLogic = function() { 48631 if (this.settings.autoWidth) { 48632 this.settings.stagePadding = false; 48633 this.settings.merge = false; 48634 } 48635 }; 48636 48637 /** 48638 * Prepares an item before add. 48639 * @todo Rename event parameter `content` to `item`. 48640 * @protected 48641 * @returns {jQuery|HTMLElement} - The item container. 48642 */ 48643 Owl.prototype.prepare = function(item) { 48644 var event = this.trigger('prepare', { content: item }); 48645 48646 if (!event.data) { 48647 event.data = $('<' + this.settings.itemElement + '/>') 48648 .addClass(this.options.itemClass).append(item) 48649 } 48650 48651 this.trigger('prepared', { content: event.data }); 48652 48653 return event.data; 48654 }; 48655 48656 /** 48657 * Updates the view. 48658 * @public 48659 */ 48660 Owl.prototype.update = function() { 48661 var i = 0, 48662 n = this._pipe.length, 48663 filter = $.proxy(function(p) { return this[p] }, this._invalidated), 48664 cache = {}; 48665 48666 while (i < n) { 48667 if (this._invalidated.all || $.grep(this._pipe[i].filter, filter).length > 0) { 48668 this._pipe[i].run(cache); 48669 } 48670 i++; 48671 } 48672 48673 this._invalidated = {}; 48674 48675 !this.is('valid') && this.enter('valid'); 48676 }; 48677 48678 /** 48679 * Gets the width of the view. 48680 * @public 48681 * @param {Owl.Width} [dimension=Owl.Width.Default] - The dimension to return. 48682 * @returns {Number} - The width of the view in pixel. 48683 */ 48684 Owl.prototype.width = function(dimension) { 48685 dimension = dimension || Owl.Width.Default; 48686 switch (dimension) { 48687 case Owl.Width.Inner: 48688 case Owl.Width.Outer: 48689 return this._width; 48690 default: 48691 return this._width - this.settings.stagePadding * 2 + this.settings.margin; 48692 } 48693 }; 48694 48695 /** 48696 * Refreshes the carousel primarily for adaptive purposes. 48697 * @public 48698 */ 48699 Owl.prototype.refresh = function() { 48700 this.enter('refreshing'); 48701 this.trigger('refresh'); 48702 48703 this.setup(); 48704 48705 this.optionsLogic(); 48706 48707 this.$element.addClass(this.options.refreshClass); 48708 48709 this.update(); 48710 48711 this.$element.removeClass(this.options.refreshClass); 48712 48713 this.leave('refreshing'); 48714 this.trigger('refreshed'); 48715 }; 48716 48717 /** 48718 * Checks window `resize` event. 48719 * @protected 48720 */ 48721 Owl.prototype.onThrottledResize = function() { 48722 window.clearTimeout(this.resizeTimer); 48723 this.resizeTimer = window.setTimeout(this._handlers.onResize, this.settings.responsiveRefreshRate); 48724 }; 48725 48726 /** 48727 * Checks window `resize` event. 48728 * @protected 48729 */ 48730 Owl.prototype.onResize = function() { 48731 if (!this._items.length) { 48732 return false; 48733 } 48734 48735 if (this._width === this.$element.width()) { 48736 return false; 48737 } 48738 48739 if (!this.isVisible()) { 48740 return false; 48741 } 48742 48743 this.enter('resizing'); 48744 48745 if (this.trigger('resize').isDefaultPrevented()) { 48746 this.leave('resizing'); 48747 return false; 48748 } 48749 48750 this.invalidate('width'); 48751 48752 this.refresh(); 48753 48754 this.leave('resizing'); 48755 this.trigger('resized'); 48756 }; 48757 48758 /** 48759 * Registers event handlers. 48760 * @todo Check `msPointerEnabled` 48761 * @todo #261 48762 * @protected 48763 */ 48764 Owl.prototype.registerEventHandlers = function() { 48765 if ($.support.transition) { 48766 this.$stage.on($.support.transition.end + '.owl.core', $.proxy(this.onTransitionEnd, this)); 48767 } 48768 48769 if (this.settings.responsive !== false) { 48770 this.on(window, 'resize', this._handlers.onThrottledResize); 48771 } 48772 48773 if (this.settings.mouseDrag) { 48774 this.$element.addClass(this.options.dragClass); 48775 this.$stage.on('mousedown.owl.core', $.proxy(this.onDragStart, this)); 48776 this.$stage.on('dragstart.owl.core selectstart.owl.core', function() { return false }); 48777 } 48778 48779 if (this.settings.touchDrag){ 48780 this.$stage.on('touchstart.owl.core', $.proxy(this.onDragStart, this)); 48781 this.$stage.on('touchcancel.owl.core', $.proxy(this.onDragEnd, this)); 48782 } 48783 }; 48784 48785 /** 48786 * Handles `touchstart` and `mousedown` events. 48787 * @todo Horizontal swipe threshold as option 48788 * @todo #261 48789 * @protected 48790 * @param {Event} event - The event arguments. 48791 */ 48792 Owl.prototype.onDragStart = function(event) { 48793 var stage = null; 48794 48795 if (event.which === 3) { 48796 return; 48797 } 48798 48799 if ($.support.transform) { 48800 stage = this.$stage.css('transform').replace(/.*\(|\)| /g, '').split(','); 48801 stage = { 48802 x: stage[stage.length === 16 ? 12 : 4], 48803 y: stage[stage.length === 16 ? 13 : 5] 48804 }; 48805 } else { 48806 stage = this.$stage.position(); 48807 stage = { 48808 x: this.settings.rtl ? 48809 stage.left + this.$stage.width() - this.width() + this.settings.margin : 48810 stage.left, 48811 y: stage.top 48812 }; 48813 } 48814 48815 if (this.is('animating')) { 48816 $.support.transform ? this.animate(stage.x) : this.$stage.stop() 48817 this.invalidate('position'); 48818 } 48819 48820 this.$element.toggleClass(this.options.grabClass, event.type === 'mousedown'); 48821 48822 this.speed(0); 48823 48824 this._drag.time = new Date().getTime(); 48825 this._drag.target = $(event.target); 48826 this._drag.stage.start = stage; 48827 this._drag.stage.current = stage; 48828 this._drag.pointer = this.pointer(event); 48829 48830 $(document).on('mouseup.owl.core touchend.owl.core', $.proxy(this.onDragEnd, this)); 48831 48832 $(document).one('mousemove.owl.core touchmove.owl.core', $.proxy(function(event) { 48833 var delta = this.difference(this._drag.pointer, this.pointer(event)); 48834 48835 $(document).on('mousemove.owl.core touchmove.owl.core', $.proxy(this.onDragMove, this)); 48836 48837 if (Math.abs(delta.x) < Math.abs(delta.y) && this.is('valid')) { 48838 return; 48839 } 48840 48841 event.preventDefault(); 48842 48843 this.enter('dragging'); 48844 this.trigger('drag'); 48845 }, this)); 48846 }; 48847 48848 /** 48849 * Handles the `touchmove` and `mousemove` events. 48850 * @todo #261 48851 * @protected 48852 * @param {Event} event - The event arguments. 48853 */ 48854 Owl.prototype.onDragMove = function(event) { 48855 var minimum = null, 48856 maximum = null, 48857 pull = null, 48858 delta = this.difference(this._drag.pointer, this.pointer(event)), 48859 stage = this.difference(this._drag.stage.start, delta); 48860 48861 if (!this.is('dragging')) { 48862 return; 48863 } 48864 48865 event.preventDefault(); 48866 48867 if (this.settings.loop) { 48868 minimum = this.coordinates(this.minimum()); 48869 maximum = this.coordinates(this.maximum() + 1) - minimum; 48870 stage.x = (((stage.x - minimum) % maximum + maximum) % maximum) + minimum; 48871 } else { 48872 minimum = this.settings.rtl ? this.coordinates(this.maximum()) : this.coordinates(this.minimum()); 48873 maximum = this.settings.rtl ? this.coordinates(this.minimum()) : this.coordinates(this.maximum()); 48874 pull = this.settings.pullDrag ? -1 * delta.x / 5 : 0; 48875 stage.x = Math.max(Math.min(stage.x, minimum + pull), maximum + pull); 48876 } 48877 48878 this._drag.stage.current = stage; 48879 48880 this.animate(stage.x); 48881 }; 48882 48883 /** 48884 * Handles the `touchend` and `mouseup` events. 48885 * @todo #261 48886 * @todo Threshold for click event 48887 * @protected 48888 * @param {Event} event - The event arguments. 48889 */ 48890 Owl.prototype.onDragEnd = function(event) { 48891 var delta = this.difference(this._drag.pointer, this.pointer(event)), 48892 stage = this._drag.stage.current, 48893 direction = delta.x > 0 ^ this.settings.rtl ? 'left' : 'right'; 48894 48895 $(document).off('.owl.core'); 48896 48897 this.$element.removeClass(this.options.grabClass); 48898 48899 if (delta.x !== 0 && this.is('dragging') || !this.is('valid')) { 48900 this.speed(this.settings.dragEndSpeed || this.settings.smartSpeed); 48901 this.current(this.closest(stage.x, delta.x !== 0 ? direction : this._drag.direction)); 48902 this.invalidate('position'); 48903 this.update(); 48904 48905 this._drag.direction = direction; 48906 48907 if (Math.abs(delta.x) > 3 || new Date().getTime() - this._drag.time > 300) { 48908 this._drag.target.one('click.owl.core', function() { return false; }); 48909 } 48910 } 48911 48912 if (!this.is('dragging')) { 48913 return; 48914 } 48915 48916 this.leave('dragging'); 48917 this.trigger('dragged'); 48918 }; 48919 48920 /** 48921 * Gets absolute position of the closest item for a coordinate. 48922 * @todo Setting `freeDrag` makes `closest` not reusable. See #165. 48923 * @protected 48924 * @param {Number} coordinate - The coordinate in pixel. 48925 * @param {String} direction - The direction to check for the closest item. Ether `left` or `right`. 48926 * @return {Number} - The absolute position of the closest item. 48927 */ 48928 Owl.prototype.closest = function(coordinate, direction) { 48929 var position = -1, 48930 pull = 30, 48931 width = this.width(), 48932 coordinates = this.coordinates(); 48933 48934 if (!this.settings.freeDrag) { 48935 // check closest item 48936 $.each(coordinates, $.proxy(function(index, value) { 48937 // on a left pull, check on current index 48938 if (direction === 'left' && coordinate > value - pull && coordinate < value + pull) { 48939 position = index; 48940 // on a right pull, check on previous index 48941 // to do so, subtract width from value and set position = index + 1 48942 } else if (direction === 'right' && coordinate > value - width - pull && coordinate < value - width + pull) { 48943 position = index + 1; 48944 } else if (this.op(coordinate, '<', value) 48945 && this.op(coordinate, '>', coordinates[index + 1] !== undefined ? coordinates[index + 1] : value - width)) { 48946 position = direction === 'left' ? index + 1 : index; 48947 } 48948 return position === -1; 48949 }, this)); 48950 } 48951 48952 if (!this.settings.loop) { 48953 // non loop boundries 48954 if (this.op(coordinate, '>', coordinates[this.minimum()])) { 48955 position = coordinate = this.minimum(); 48956 } else if (this.op(coordinate, '<', coordinates[this.maximum()])) { 48957 position = coordinate = this.maximum(); 48958 } 48959 } 48960 48961 return position; 48962 }; 48963 48964 /** 48965 * Animates the stage. 48966 * @todo #270 48967 * @public 48968 * @param {Number} coordinate - The coordinate in pixels. 48969 */ 48970 Owl.prototype.animate = function(coordinate) { 48971 var animate = this.speed() > 0; 48972 48973 this.is('animating') && this.onTransitionEnd(); 48974 48975 if (animate) { 48976 this.enter('animating'); 48977 this.trigger('translate'); 48978 } 48979
vendor: 10,524 bytes, lines 48980-49347
48980 if ($.support.transform3d && $.support.transition) { 48981 this.$stage.css({ 48982 transform: 'translate3d(' + coordinate + 'px,0px,0px)', 48983 transition: (this.speed() / 1000) + 's' + ( 48984 this.settings.slideTransition ? ' ' + this.settings.slideTransition : '' 48985 ) 48986 }); 48987 } else if (animate) { 48988 this.$stage.animate({ 48989 left: coordinate + 'px' 48990 }, this.speed(), this.settings.fallbackEasing, $.proxy(this.onTransitionEnd, this)); 48991 } else { 48992 this.$stage.css({ 48993 left: coordinate + 'px' 48994 }); 48995 } 48996 }; 48997 48998 /** 48999 * Checks whether the carousel is in a specific state or not. 49000 * @param {String} state - The state to check. 49001 * @returns {Boolean} - The flag which indicates if the carousel is busy. 49002 */ 49003 Owl.prototype.is = function(state) { 49004 return this._states.current[state] && this._states.current[state] > 0; 49005 }; 49006 49007 /** 49008 * Sets the absolute position of the current item. 49009 * @public 49010 * @param {Number} [position] - The new absolute position or nothing to leave it unchanged. 49011 * @returns {Number} - The absolute position of the current item. 49012 */ 49013 Owl.prototype.current = function(position) { 49014 if (position === undefined) { 49015 return this._current; 49016 } 49017 49018 if (this._items.length === 0) { 49019 return undefined; 49020 } 49021 49022 position = this.normalize(position); 49023 49024 if (this._current !== position) { 49025 var event = this.trigger('change', { property: { name: 'position', value: position } }); 49026 49027 if (event.data !== undefined) { 49028 position = this.normalize(event.data); 49029 } 49030 49031 this._current = position; 49032 49033 this.invalidate('position'); 49034 49035 this.trigger('changed', { property: { name: 'position', value: this._current } }); 49036 } 49037 49038 return this._current; 49039 }; 49040 49041 /** 49042 * Invalidates the given part of the update routine. 49043 * @param {String} [part] - The part to invalidate. 49044 * @returns {Array.<String>} - The invalidated parts. 49045 */ 49046 Owl.prototype.invalidate = function(part) { 49047 if ($.type(part) === 'string') { 49048 this._invalidated[part] = true; 49049 this.is('valid') && this.leave('valid'); 49050 } 49051 return $.map(this._invalidated, function(v, i) { return i }); 49052 }; 49053 49054 /** 49055 * Resets the absolute position of the current item. 49056 * @public 49057 * @param {Number} position - The absolute position of the new item. 49058 */ 49059 Owl.prototype.reset = function(position) { 49060 position = this.normalize(position); 49061 49062 if (position === undefined) { 49063 return; 49064 } 49065 49066 this._speed = 0; 49067 this._current = position; 49068 49069 this.suppress([ 'translate', 'translated' ]); 49070 49071 this.animate(this.coordinates(position)); 49072 49073 this.release([ 'translate', 'translated' ]); 49074 }; 49075 49076 /** 49077 * Normalizes an absolute or a relative position of an item. 49078 * @public 49079 * @param {Number} position - The absolute or relative position to normalize. 49080 * @param {Boolean} [relative=false] - Whether the given position is relative or not. 49081 * @returns {Number} - The normalized position. 49082 */ 49083 Owl.prototype.normalize = function(position, relative) { 49084 var n = this._items.length, 49085 m = relative ? 0 : this._clones.length; 49086 49087 if (!this.isNumeric(position) || n < 1) { 49088 position = undefined; 49089 } else if (position < 0 || position >= n + m) { 49090 position = ((position - m / 2) % n + n) % n + m / 2; 49091 } 49092 49093 return position; 49094 }; 49095 49096 /** 49097 * Converts an absolute position of an item into a relative one. 49098 * @public 49099 * @param {Number} position - The absolute position to convert. 49100 * @returns {Number} - The converted position. 49101 */ 49102 Owl.prototype.relative = function(position) { 49103 position -= this._clones.length / 2; 49104 return this.normalize(position, true); 49105 }; 49106 49107 /** 49108 * Gets the maximum position for the current item. 49109 * @public 49110 * @param {Boolean} [relative=false] - Whether to return an absolute position or a relative position. 49111 * @returns {Number} 49112 */ 49113 Owl.prototype.maximum = function(relative) { 49114 var settings = this.settings, 49115 maximum = this._coordinates.length, 49116 iterator, 49117 reciprocalItemsWidth, 49118 elementWidth; 49119 49120 if (settings.loop) { 49121 maximum = this._clones.length / 2 + this._items.length - 1; 49122 } else if (settings.autoWidth || settings.merge) { 49123 iterator = this._items.length; 49124 if (iterator) { 49125 reciprocalItemsWidth = this._items[--iterator].width(); 49126 elementWidth = this.$element.width(); 49127 while (iterator--) { 49128 reciprocalItemsWidth += this._items[iterator].width() + this.settings.margin; 49129 if (reciprocalItemsWidth > elementWidth) { 49130 break; 49131 } 49132 } 49133 } 49134 maximum = iterator + 1; 49135 } else if (settings.center) { 49136 maximum = this._items.length - 1; 49137 } else { 49138 maximum = this._items.length - settings.items; 49139 } 49140 49141 if (relative) { 49142 maximum -= this._clones.length / 2; 49143 } 49144 49145 return Math.max(maximum, 0); 49146 }; 49147 49148 /** 49149 * Gets the minimum position for the current item. 49150 * @public 49151 * @param {Boolean} [relative=false] - Whether to return an absolute position or a relative position. 49152 * @returns {Number} 49153 */ 49154 Owl.prototype.minimum = function(relative) { 49155 return relative ? 0 : this._clones.length / 2; 49156 }; 49157 49158 /** 49159 * Gets an item at the specified relative position. 49160 * @public 49161 * @param {Number} [position] - The relative position of the item. 49162 * @return {jQuery|Array.<jQuery>} - The item at the given position or all items if no position was given. 49163 */ 49164 Owl.prototype.items = function(position) { 49165 if (position === undefined) { 49166 return this._items.slice(); 49167 } 49168 49169 position = this.normalize(position, true); 49170 return this._items[position]; 49171 }; 49172 49173 /** 49174 * Gets an item at the specified relative position. 49175 * @public 49176 * @param {Number} [position] - The relative position of the item. 49177 * @return {jQuery|Array.<jQuery>} - The item at the given position or all items if no position was given. 49178 */ 49179 Owl.prototype.mergers = function(position) { 49180 if (position === undefined) { 49181 return this._mergers.slice(); 49182 } 49183 49184 position = this.normalize(position, true); 49185 return this._mergers[position]; 49186 }; 49187 49188 /** 49189 * Gets the absolute positions of clones for an item. 49190 * @public 49191 * @param {Number} [position] - The relative position of the item. 49192 * @returns {Array.<Number>} - The absolute positions of clones for the item or all if no position was given. 49193 */ 49194 Owl.prototype.clones = function(position) { 49195 var odd = this._clones.length / 2, 49196 even = odd + this._items.length, 49197 map = function(index) { return index % 2 === 0 ? even + index / 2 : odd - (index + 1) / 2 }; 49198 49199 if (position === undefined) { 49200 return $.map(this._clones, function(v, i) { return map(i) }); 49201 } 49202 49203 return $.map(this._clones, function(v, i) { return v === position ? map(i) : null }); 49204 }; 49205 49206 /** 49207 * Sets the current animation speed. 49208 * @public 49209 * @param {Number} [speed] - The animation speed in milliseconds or nothing to leave it unchanged. 49210 * @returns {Number} - The current animation speed in milliseconds. 49211 */ 49212 Owl.prototype.speed = function(speed) { 49213 if (speed !== undefined) { 49214 this._speed = speed; 49215 } 49216 49217 return this._speed; 49218 }; 49219 49220 /** 49221 * Gets the coordinate of an item. 49222 * @todo The name of this method is missleanding. 49223 * @public 49224 * @param {Number} position - The absolute position of the item within `minimum()` and `maximum()`. 49225 * @returns {Number|Array.<Number>} - The coordinate of the item in pixel or all coordinates. 49226 */ 49227 Owl.prototype.coordinates = function(position) { 49228 var multiplier = 1, 49229 newPosition = position - 1, 49230 coordinate; 49231 49232 if (position === undefined) { 49233 return $.map(this._coordinates, $.proxy(function(coordinate, index) { 49234 return this.coordinates(index); 49235 }, this)); 49236 } 49237 49238 if (this.settings.center) { 49239 if (this.settings.rtl) { 49240 multiplier = -1; 49241 newPosition = position + 1; 49242 } 49243 49244 coordinate = this._coordinates[position]; 49245 coordinate += (this.width() - coordinate + (this._coordinates[newPosition] || 0)) / 2 * multiplier; 49246 } else { 49247 coordinate = this._coordinates[newPosition] || 0; 49248 } 49249 49250 coordinate = Math.ceil(coordinate); 49251 49252 return coordinate; 49253 }; 49254 49255 /** 49256 * Calculates the speed for a translation. 49257 * @protected 49258 * @param {Number} from - The absolute position of the start item. 49259 * @param {Number} to - The absolute position of the target item. 49260 * @param {Number} [factor=undefined] - The time factor in milliseconds. 49261 * @returns {Number} - The time in milliseconds for the translation. 49262 */ 49263 Owl.prototype.duration = function(from, to, factor) { 49264 if (factor === 0) { 49265 return 0; 49266 } 49267 49268 return Math.min(Math.max(Math.abs(to - from), 1), 6) * Math.abs((factor || this.settings.smartSpeed)); 49269 }; 49270 49271 /** 49272 * Slides to the specified item. 49273 * @public 49274 * @param {Number} position - The position of the item. 49275 * @param {Number} [speed] - The time in milliseconds for the transition. 49276 */ 49277 Owl.prototype.to = function(position, speed) { 49278 var current = this.current(), 49279 revert = null, 49280 distance = position - this.relative(current), 49281 direction = (distance > 0) - (distance < 0), 49282 items = this._items.length, 49283 minimum = this.minimum(), 49284 maximum = this.maximum(); 49285 49286 if (this.settings.loop) { 49287 if (!this.settings.rewind && Math.abs(distance) > items / 2) { 49288 distance += direction * -1 * items; 49289 } 49290 49291 position = current + distance; 49292 revert = ((position - minimum) % items + items) % items + minimum; 49293 49294 if (revert !== position && revert - distance <= maximum && revert - distance > 0) { 49295 current = revert - distance; 49296 position = revert; 49297 this.reset(current); 49298 } 49299 } else if (this.settings.rewind) { 49300 maximum += 1; 49301 position = (position % maximum + maximum) % maximum; 49302 } else { 49303 position = Math.max(minimum, Math.min(maximum, position)); 49304 } 49305 49306 this.speed(this.duration(current, position, speed)); 49307 this.current(position); 49308 49309 if (this.isVisible()) { 49310 this.update(); 49311 } 49312 }; 49313 49314 /** 49315 * Slides to the next item. 49316 * @public 49317 * @param {Number} [speed] - The time in milliseconds for the transition. 49318 */ 49319 Owl.prototype.next = function(speed) { 49320 speed = speed || false; 49321 this.to(this.relative(this.current()) + 1, speed); 49322 }; 49323 49324 /** 49325 * Slides to the previous item. 49326 * @public 49327 * @param {Number} [speed] - The time in milliseconds for the transition. 49328 */ 49329 Owl.prototype.prev = function(speed) { 49330 speed = speed || false; 49331 this.to(this.relative(this.current()) - 1, speed); 49332 }; 49333 49334 /** 49335 * Handles the end of an animation. 49336 * @protected 49337 * @param {Event} event - The event arguments. 49338 */ 49339 Owl.prototype.onTransitionEnd = function(event) { 49340 49341 // if css2 animation then event object is undefined 49342 if (event !== undefined) { 49343 event.stopPropagation(); 49344 49345 // Catch only owl-stage transitionEnd event 49346 if ((event.target || event.srcElement || event.originalTarget) !== this.$stage.get(0)) { 49347 return false;
vendor: 12,874 bytes, lines 49348-49787
49348 } 49349 } 49350 49351 this.leave('animating'); 49352 this.trigger('translated'); 49353 }; 49354 49355 /** 49356 * Gets viewport width. 49357 * @protected 49358 * @return {Number} - The width in pixel. 49359 */ 49360 Owl.prototype.viewport = function() { 49361 var width; 49362 if (this.options.responsiveBaseElement !== window) { 49363 width = $(this.options.responsiveBaseElement).width(); 49364 } else if (window.innerWidth) { 49365 width = window.innerWidth; 49366 } else if (document.documentElement && document.documentElement.clientWidth) { 49367 width = document.documentElement.clientWidth; 49368 } else { 49369 console.warn('Can not detect viewport width.'); 49370 } 49371 return width; 49372 }; 49373 49374 /** 49375 * Replaces the current content. 49376 * @public 49377 * @param {HTMLElement|jQuery|String} content - The new content. 49378 */ 49379 Owl.prototype.replace = function(content) { 49380 this.$stage.empty(); 49381 this._items = []; 49382 49383 if (content) { 49384 content = (content instanceof jQuery) ? content : $(content); 49385 } 49386 49387 if (this.settings.nestedItemSelector) { 49388 content = content.find('.' + this.settings.nestedItemSelector); 49389 } 49390 49391 content.filter(function() { 49392 return this.nodeType === 1; 49393 }).each($.proxy(function(index, item) { 49394 item = this.prepare(item); 49395 this.$stage.append(item); 49396 this._items.push(item); 49397 this._mergers.push(item.find('[data-merge]').addBack('[data-merge]').attr('data-merge') * 1 || 1); 49398 }, this)); 49399 49400 this.reset(this.isNumeric(this.settings.startPosition) ? this.settings.startPosition : 0); 49401 49402 this.invalidate('items'); 49403 }; 49404 49405 /** 49406 * Adds an item. 49407 * @todo Use `item` instead of `content` for the event arguments. 49408 * @public 49409 * @param {HTMLElement|jQuery|String} content - The item content to add. 49410 * @param {Number} [position] - The relative position at which to insert the item otherwise the item will be added to the end. 49411 */ 49412 Owl.prototype.add = function(content, position) { 49413 var current = this.relative(this._current); 49414 49415 position = position === undefined ? this._items.length : this.normalize(position, true); 49416 content = content instanceof jQuery ? content : $(content); 49417 49418 this.trigger('add', { content: content, position: position }); 49419 49420 content = this.prepare(content); 49421 49422 if (this._items.length === 0 || position === this._items.length) { 49423 this._items.length === 0 && this.$stage.append(content); 49424 this._items.length !== 0 && this._items[position - 1].after(content); 49425 this._items.push(content); 49426 this._mergers.push(content.find('[data-merge]').addBack('[data-merge]').attr('data-merge') * 1 || 1); 49427 } else { 49428 this._items[position].before(content); 49429 this._items.splice(position, 0, content); 49430 this._mergers.splice(position, 0, content.find('[data-merge]').addBack('[data-merge]').attr('data-merge') * 1 || 1); 49431 } 49432 49433 this._items[current] && this.reset(this._items[current].index()); 49434 49435 this.invalidate('items'); 49436 49437 this.trigger('added', { content: content, position: position }); 49438 }; 49439 49440 /** 49441 * Removes an item by its position. 49442 * @todo Use `item` instead of `content` for the event arguments. 49443 * @public 49444 * @param {Number} position - The relative position of the item to remove. 49445 */ 49446 Owl.prototype.remove = function(position) { 49447 position = this.normalize(position, true); 49448 49449 if (position === undefined) { 49450 return; 49451 } 49452 49453 this.trigger('remove', { content: this._items[position], position: position }); 49454 49455 this._items[position].remove(); 49456 this._items.splice(position, 1); 49457 this._mergers.splice(position, 1); 49458 49459 this.invalidate('items'); 49460 49461 this.trigger('removed', { content: null, position: position }); 49462 }; 49463 49464 /** 49465 * Preloads images with auto width. 49466 * @todo Replace by a more generic approach 49467 * @protected 49468 */ 49469 Owl.prototype.preloadAutoWidthImages = function(images) { 49470 images.each($.proxy(function(i, element) { 49471 this.enter('pre-loading'); 49472 element = $(element); 49473 $(new Image()).one('load', $.proxy(function(e) { 49474 element.attr('src', e.target.src); 49475 element.css('opacity', 1); 49476 this.leave('pre-loading'); 49477 !this.is('pre-loading') && !this.is('initializing') && this.refresh(); 49478 }, this)).attr('src', element.attr('src') || element.attr('data-src') || element.attr('data-src-retina')); 49479 }, this)); 49480 }; 49481 49482 /** 49483 * Destroys the carousel. 49484 * @public 49485 */ 49486 Owl.prototype.destroy = function() { 49487 49488 this.$element.off('.owl.core'); 49489 this.$stage.off('.owl.core'); 49490 $(document).off('.owl.core'); 49491 49492 if (this.settings.responsive !== false) { 49493 window.clearTimeout(this.resizeTimer); 49494 this.off(window, 'resize', this._handlers.onThrottledResize); 49495 } 49496 49497 for (var i in this._plugins) { 49498 this._plugins[i].destroy(); 49499 } 49500 49501 this.$stage.children('.cloned').remove(); 49502 49503 this.$stage.unwrap(); 49504 this.$stage.children().contents().unwrap(); 49505 this.$stage.children().unwrap(); 49506 this.$stage.remove(); 49507 this.$element 49508 .removeClass(this.options.refreshClass) 49509 .removeClass(this.options.loadingClass) 49510 .removeClass(this.options.loadedClass) 49511 .removeClass(this.options.rtlClass) 49512 .removeClass(this.options.dragClass) 49513 .removeClass(this.options.grabClass) 49514 .attr('class', this.$element.attr('class').replace(new RegExp(this.options.responsiveClass + '-\\S+\\s', 'g'), '')) 49515 .removeData('owl.carousel'); 49516 }; 49517 49518 /** 49519 * Operators to calculate right-to-left and left-to-right. 49520 * @protected 49521 * @param {Number} [a] - The left side operand. 49522 * @param {String} [o] - The operator. 49523 * @param {Number} [b] - The right side operand. 49524 */ 49525 Owl.prototype.op = function(a, o, b) { 49526 var rtl = this.settings.rtl; 49527 switch (o) { 49528 case '<': 49529 return rtl ? a > b : a < b; 49530 case '>': 49531 return rtl ? a < b : a > b; 49532 case '>=': 49533 return rtl ? a <= b : a >= b; 49534 case '<=': 49535 return rtl ? a >= b : a <= b; 49536 default: 49537 break; 49538 } 49539 }; 49540 49541 /** 49542 * Attaches to an internal event. 49543 * @protected 49544 * @param {HTMLElement} element - The event source. 49545 * @param {String} event - The event name. 49546 * @param {Function} listener - The event handler to attach. 49547 * @param {Boolean} capture - Wether the event should be handled at the capturing phase or not. 49548 */ 49549 Owl.prototype.on = function(element, event, listener, capture) { 49550 if (element.addEventListener) { 49551 element.addEventListener(event, listener, capture); 49552 } else if (element.attachEvent) { 49553 element.attachEvent('on' + event, listener); 49554 } 49555 }; 49556 49557 /** 49558 * Detaches from an internal event. 49559 * @protected 49560 * @param {HTMLElement} element - The event source. 49561 * @param {String} event - The event name. 49562 * @param {Function} listener - The attached event handler to detach. 49563 * @param {Boolean} capture - Wether the attached event handler was registered as a capturing listener or not. 49564 */ 49565 Owl.prototype.off = function(element, event, listener, capture) { 49566 if (element.removeEventListener) { 49567 element.removeEventListener(event, listener, capture); 49568 } else if (element.detachEvent) { 49569 element.detachEvent('on' + event, listener); 49570 } 49571 }; 49572 49573 /** 49574 * Triggers a public event. 49575 * @todo Remove `status`, `relatedTarget` should be used instead. 49576 * @protected 49577 * @param {String} name - The event name. 49578 * @param {*} [data=null] - The event data. 49579 * @param {String} [namespace=carousel] - The event namespace. 49580 * @param {String} [state] - The state which is associated with the event. 49581 * @param {Boolean} [enter=false] - Indicates if the call enters the specified state or not. 49582 * @returns {Event} - The event arguments. 49583 */ 49584 Owl.prototype.trigger = function(name, data, namespace, state, enter) { 49585 var status = { 49586 item: { count: this._items.length, index: this.current() } 49587 }, handler = $.camelCase( 49588 $.grep([ 'on', name, namespace ], function(v) { return v }) 49589 .join('-').toLowerCase() 49590 ), event = $.Event( 49591 [ name, 'owl', namespace || 'carousel' ].join('.').toLowerCase(), 49592 $.extend({ relatedTarget: this }, status, data) 49593 ); 49594 49595 if (!this._supress[name]) { 49596 $.each(this._plugins, function(name, plugin) { 49597 if (plugin.onTrigger) { 49598 plugin.onTrigger(event); 49599 } 49600 }); 49601 49602 this.register({ type: Owl.Type.Event, name: name }); 49603 this.$element.trigger(event); 49604 49605 if (this.settings && typeof this.settings[handler] === 'function') { 49606 this.settings[handler].call(this, event); 49607 } 49608 } 49609 49610 return event; 49611 }; 49612 49613 /** 49614 * Enters a state. 49615 * @param name - The state name. 49616 */ 49617 Owl.prototype.enter = function(name) { 49618 $.each([ name ].concat(this._states.tags[name] || []), $.proxy(function(i, name) { 49619 if (this._states.current[name] === undefined) { 49620 this._states.current[name] = 0; 49621 } 49622 49623 this._states.current[name]++; 49624 }, this)); 49625 }; 49626 49627 /** 49628 * Leaves a state. 49629 * @param name - The state name. 49630 */ 49631 Owl.prototype.leave = function(name) { 49632 $.each([ name ].concat(this._states.tags[name] || []), $.proxy(function(i, name) { 49633 this._states.current[name]--; 49634 }, this)); 49635 }; 49636 49637 /** 49638 * Registers an event or state. 49639 * @public 49640 * @param {Object} object - The event or state to register. 49641 */ 49642 Owl.prototype.register = function(object) { 49643 if (object.type === Owl.Type.Event) { 49644 if (!$.event.special[object.name]) { 49645 $.event.special[object.name] = {}; 49646 } 49647 49648 if (!$.event.special[object.name].owl) { 49649 var _default = $.event.special[object.name]._default; 49650 $.event.special[object.name]._default = function(e) { 49651 if (_default && _default.apply && (!e.namespace || e.namespace.indexOf('owl') === -1)) { 49652 return _default.apply(this, arguments); 49653 } 49654 return e.namespace && e.namespace.indexOf('owl') > -1; 49655 }; 49656 $.event.special[object.name].owl = true; 49657 } 49658 } else if (object.type === Owl.Type.State) { 49659 if (!this._states.tags[object.name]) { 49660 this._states.tags[object.name] = object.tags; 49661 } else { 49662 this._states.tags[object.name] = this._states.tags[object.name].concat(object.tags); 49663 } 49664 49665 this._states.tags[object.name] = $.grep(this._states.tags[object.name], $.proxy(function(tag, i) { 49666 return $.inArray(tag, this._states.tags[object.name]) === i; 49667 }, this)); 49668 } 49669 }; 49670 49671 /** 49672 * Suppresses events. 49673 * @protected 49674 * @param {Array.<String>} events - The events to suppress. 49675 */ 49676 Owl.prototype.suppress = function(events) { 49677 $.each(events, $.proxy(function(index, event) { 49678 this._supress[event] = true; 49679 }, this)); 49680 }; 49681 49682 /** 49683 * Releases suppressed events. 49684 * @protected 49685 * @param {Array.<String>} events - The events to release. 49686 */ 49687 Owl.prototype.release = function(events) { 49688 $.each(events, $.proxy(function(index, event) { 49689 delete this._supress[event]; 49690 }, this)); 49691 }; 49692 49693 /** 49694 * Gets unified pointer coordinates from event. 49695 * @todo #261 49696 * @protected 49697 * @param {Event} - The `mousedown` or `touchstart` event. 49698 * @returns {Object} - Contains `x` and `y` coordinates of current pointer position. 49699 */ 49700 Owl.prototype.pointer = function(event) { 49701 var result = { x: null, y: null }; 49702 49703 event = event.originalEvent || event || window.event; 49704 49705 event = event.touches && event.touches.length ? 49706 event.touches[0] : event.changedTouches && event.changedTouches.length ? 49707 event.changedTouches[0] : event; 49708 49709 if (event.pageX) { 49710 result.x = event.pageX; 49711 result.y = event.pageY; 49712 } else { 49713 result.x = event.clientX; 49714 result.y = event.clientY; 49715 } 49716 49717 return result; 49718 }; 49719 49720 /** 49721 * Determines if the input is a Number or something that can be coerced to a Number 49722 * @protected 49723 * @param {Number|String|Object|Array|Boolean|RegExp|Function|Symbol} - The input to be tested 49724 * @returns {Boolean} - An indication if the input is a Number or can be coerced to a Number 49725 */ 49726 Owl.prototype.isNumeric = function(number) { 49727 return !isNaN(parseFloat(number)); 49728 }; 49729 49730 /** 49731 * Gets the difference of two vectors. 49732 * @todo #261 49733 * @protected 49734 * @param {Object} - The first vector. 49735 * @param {Object} - The second vector. 49736 * @returns {Object} - The difference. 49737 */ 49738 Owl.prototype.difference = function(first, second) { 49739 return { 49740 x: first.x - second.x, 49741 y: first.y - second.y 49742 }; 49743 }; 49744 49745 /** 49746 * The jQuery Plugin for the Owl Carousel 49747 * @todo Navigation plugin `next` and `prev` 49748 * @public 49749 */ 49750 $.fn.owlCarousel = function(option) { 49751 var args = Array.prototype.slice.call(arguments, 1); 49752 49753 return this.each(function() { 49754 var $this = $(this), 49755 data = $this.data('owl.carousel'); 49756 49757 if (!data) { 49758 data = new Owl(this, typeof option == 'object' && option); 49759 $this.data('owl.carousel', data); 49760 49761 $.each([ 49762 'next', 'prev', 'to', 'destroy', 'refresh', 'replace', 'add', 'remove' 49763 ], function(i, event) { 49764 data.register({ type: Owl.Type.Event, name: event }); 49765 data.$element.on(event + '.owl.carousel.core', $.proxy(function(e) { 49766 if (e.namespace && e.relatedTarget !== this) { 49767 this.suppress([ event ]); 49768 data[event].apply(this, [].slice.call(arguments, 1)); 49769 this.release([ event ]); 49770 } 49771 }, data)); 49772 }); 49773 } 49774 49775 if (typeof option == 'string' && option.charAt(0) !== '_') { 49776 data[option].apply(data, args); 49777 } 49778 }); 49779 }; 49780 49781 /** 49782 * The constructor for the jQuery Plugin 49783 * @public 49784 */ 49785 $.fn.owlCarousel.Constructor = Owl; 49786 49787})(window.Zepto ||
vendor: 9,859 bytes, lines 49787-50182
49787__webpack_provided_window_dot_jQuery, window, document); 49788 49789/** 49790 * AutoRefresh Plugin 49791 * @version 2.3.4 49792 * @author Artus Kolanowski 49793 * @author David Deutsch 49794 * @license The MIT License (MIT) 49795 */ 49796;(function($, window, document, undefined) { 49797 49798 /** 49799 * Creates the auto refresh plugin. 49800 * @class The Auto Refresh Plugin 49801 * @param {Owl} carousel - The Owl Carousel 49802 */ 49803 var AutoRefresh = function(carousel) { 49804 /** 49805 * Reference to the core. 49806 * @protected 49807 * @type {Owl} 49808 */ 49809 this._core = carousel; 49810 49811 /** 49812 * Refresh interval. 49813 * @protected 49814 * @type {number} 49815 */ 49816 this._interval = null; 49817 49818 /** 49819 * Whether the element is currently visible or not. 49820 * @protected 49821 * @type {Boolean} 49822 */ 49823 this._visible = null; 49824 49825 /** 49826 * All event handlers. 49827 * @protected 49828 * @type {Object} 49829 */ 49830 this._handlers = { 49831 'initialized.owl.carousel': $.proxy(function(e) { 49832 if (e.namespace && this._core.settings.autoRefresh) { 49833 this.watch(); 49834 } 49835 }, this) 49836 }; 49837 49838 // set default options 49839 this._core.options = $.extend({}, AutoRefresh.Defaults, this._core.options); 49840 49841 // register event handlers 49842 this._core.$element.on(this._handlers); 49843 }; 49844 49845 /** 49846 * Default options. 49847 * @public 49848 */ 49849 AutoRefresh.Defaults = { 49850 autoRefresh: true, 49851 autoRefreshInterval: 500 49852 }; 49853 49854 /** 49855 * Watches the element. 49856 */ 49857 AutoRefresh.prototype.watch = function() { 49858 if (this._interval) { 49859 return; 49860 } 49861 49862 this._visible = this._core.isVisible(); 49863 this._interval = window.setInterval($.proxy(this.refresh, this), this._core.settings.autoRefreshInterval); 49864 }; 49865 49866 /** 49867 * Refreshes the element. 49868 */ 49869 AutoRefresh.prototype.refresh = function() { 49870 if (this._core.isVisible() === this._visible) { 49871 return; 49872 } 49873 49874 this._visible = !this._visible; 49875 49876 this._core.$element.toggleClass('owl-hidden', !this._visible); 49877 49878 this._visible && (this._core.invalidate('width') && this._core.refresh()); 49879 }; 49880 49881 /** 49882 * Destroys the plugin. 49883 */ 49884 AutoRefresh.prototype.destroy = function() { 49885 var handler, property; 49886 49887 window.clearInterval(this._interval); 49888 49889 for (handler in this._handlers) { 49890 this._core.$element.off(handler, this._handlers[handler]); 49891 } 49892 for (property in Object.getOwnPropertyNames(this)) { 49893 typeof this[property] != 'function' && (this[property] = null); 49894 } 49895 }; 49896 49897 $.fn.owlCarousel.Constructor.Plugins.AutoRefresh = AutoRefresh; 49898 49899})(window.Zepto || __webpack_provided_window_dot_jQuery, window, document); 49900 49901/** 49902 * Lazy Plugin 49903 * @version 2.3.4 49904 * @author Bartosz Wojciechowski 49905 * @author David Deutsch 49906 * @license The MIT License (MIT) 49907 */ 49908;(function($, window, document, undefined) { 49909 49910 /** 49911 * Creates the lazy plugin. 49912 * @class The Lazy Plugin 49913 * @param {Owl} carousel - The Owl Carousel 49914 */ 49915 var Lazy = function(carousel) { 49916 49917 /** 49918 * Reference to the core. 49919 * @protected 49920 * @type {Owl} 49921 */ 49922 this._core = carousel; 49923 49924 /** 49925 * Already loaded items. 49926 * @protected 49927 * @type {Array.<jQuery>} 49928 */ 49929 this._loaded = []; 49930 49931 /** 49932 * Event handlers. 49933 * @protected 49934 * @type {Object} 49935 */ 49936 this._handlers = { 49937 'initialized.owl.carousel change.owl.carousel resized.owl.carousel': $.proxy(function(e) { 49938 if (!e.namespace) { 49939 return; 49940 } 49941 49942 if (!this._core.settings || !this._core.settings.lazyLoad) { 49943 return; 49944 } 49945 49946 if ((e.property && e.property.name == 'position') || e.type == 'initialized') { 49947 var settings = this._core.settings, 49948 n = (settings.center && Math.ceil(settings.items / 2) || settings.items), 49949 i = ((settings.center && n * -1) || 0), 49950 position = (e.property && e.property.value !== undefined ? e.property.value : this._core.current()) + i, 49951 clones = this._core.clones().length, 49952 load = $.proxy(function(i, v) { this.load(v) }, this); 49953 //TODO: Need documentation for this new option 49954 if (settings.lazyLoadEager > 0) { 49955 n += settings.lazyLoadEager; 49956 // If the carousel is looping also preload images that are to the "left" 49957 if (settings.loop) { 49958 position -= settings.lazyLoadEager; 49959 n++; 49960 } 49961 } 49962 49963 while (i++ < n) { 49964 this.load(clones / 2 + this._core.relative(position)); 49965 clones && $.each(this._core.clones(this._core.relative(position)), load); 49966 position++; 49967 } 49968 } 49969 }, this) 49970 }; 49971 49972 // set the default options 49973 this._core.options = $.extend({}, Lazy.Defaults, this._core.options); 49974 49975 // register event handler 49976 this._core.$element.on(this._handlers); 49977 }; 49978 49979 /** 49980 * Default options. 49981 * @public 49982 */ 49983 Lazy.Defaults = { 49984 lazyLoad: false, 49985 lazyLoadEager: 0 49986 }; 49987 49988 /** 49989 * Loads all resources of an item at the specified position. 49990 * @param {Number} position - The absolute position of the item. 49991 * @protected 49992 */ 49993 Lazy.prototype.load = function(position) { 49994 var $item = this._core.$stage.children().eq(position), 49995 $elements = $item && $item.find('.owl-lazy'); 49996 49997 if (!$elements || $.inArray($item.get(0), this._loaded) > -1) { 49998 return; 49999 } 50000 50001 $elements.each($.proxy(function(index, element) { 50002 var $element = $(element), image, 50003 url = (window.devicePixelRatio > 1 && $element.attr('data-src-retina')) || $element.attr('data-src') || $element.attr('data-srcset'); 50004 50005 this._core.trigger('load', { element: $element, url: url }, 'lazy'); 50006 50007 if ($element.is('img')) { 50008 $element.one('load.owl.lazy', $.proxy(function() { 50009 $element.css('opacity', 1); 50010 this._core.trigger('loaded', { element: $element, url: url }, 'lazy'); 50011 }, this)).attr('src', url); 50012 } else if ($element.is('source')) { 50013 $element.one('load.owl.lazy', $.proxy(function() { 50014 this._core.trigger('loaded', { element: $element, url: url }, 'lazy'); 50015 }, this)).attr('srcset', url); 50016 } else { 50017 image = new Image(); 50018 image.onload = $.proxy(function() { 50019 $element.css({ 50020 'background-image': 'url("' + url + '")', 50021 'opacity': '1' 50022 }); 50023 this._core.trigger('loaded', { element: $element, url: url }, 'lazy'); 50024 }, this); 50025 image.src = url; 50026 } 50027 }, this)); 50028 50029 this._loaded.push($item.get(0)); 50030 }; 50031 50032 /** 50033 * Destroys the plugin. 50034 * @public 50035 */ 50036 Lazy.prototype.destroy = function() { 50037 var handler, property; 50038 50039 for (handler in this.handlers) { 50040 this._core.$element.off(handler, this.handlers[handler]); 50041 } 50042 for (property in Object.getOwnPropertyNames(this)) { 50043 typeof this[property] != 'function' && (this[property] = null); 50044 } 50045 }; 50046 50047 $.fn.owlCarousel.Constructor.Plugins.Lazy = Lazy; 50048 50049})(window.Zepto || __webpack_provided_window_dot_jQuery, window, document); 50050 50051/** 50052 * AutoHeight Plugin 50053 * @version 2.3.4 50054 * @author Bartosz Wojciechowski 50055 * @author David Deutsch 50056 * @license The MIT License (MIT) 50057 */ 50058;(function($, window, document, undefined) { 50059 50060 /** 50061 * Creates the auto height plugin. 50062 * @class The Auto Height Plugin 50063 * @param {Owl} carousel - The Owl Carousel 50064 */ 50065 var AutoHeight = function(carousel) { 50066 /** 50067 * Reference to the core. 50068 * @protected 50069 * @type {Owl} 50070 */ 50071 this._core = carousel; 50072 50073 this._previousHeight = null; 50074 50075 /** 50076 * All event handlers. 50077 * @protected 50078 * @type {Object} 50079 */ 50080 this._handlers = { 50081 'initialized.owl.carousel refreshed.owl.carousel': $.proxy(function(e) { 50082 if (e.namespace && this._core.settings.autoHeight) { 50083 this.update(); 50084 } 50085 }, this), 50086 'changed.owl.carousel': $.proxy(function(e) { 50087 if (e.namespace && this._core.settings.autoHeight && e.property.name === 'position'){ 50088 this.update(); 50089 } 50090 }, this), 50091 'loaded.owl.lazy': $.proxy(function(e) { 50092 if (e.namespace && this._core.settings.autoHeight 50093 && e.element.closest('.' + this._core.settings.itemClass).index() === this._core.current()) { 50094 this.update(); 50095 } 50096 }, this) 50097 }; 50098 50099 // set default options 50100 this._core.options = $.extend({}, AutoHeight.Defaults, this._core.options); 50101 50102 // register event handlers 50103 this._core.$element.on(this._handlers); 50104 this._intervalId = null; 50105 var refThis = this; 50106 50107 // These changes have been taken from a PR by gavrochelegnou proposed in #1575 50108 // and have been made compatible with the latest jQuery version 50109 $(window).on('load', function() { 50110 if (refThis._core.settings.autoHeight) { 50111 refThis.update(); 50112 } 50113 }); 50114 50115 // Autoresize the height of the carousel when window is resized 50116 // When carousel has images, the height is dependent on the width 50117 // and should also change on resize 50118 $(window).resize(function() { 50119 if (refThis._core.settings.autoHeight) { 50120 if (refThis._intervalId != null) { 50121 clearTimeout(refThis._intervalId); 50122 } 50123 50124 refThis._intervalId = setTimeout(function() { 50125 refThis.update(); 50126 }, 250); 50127 } 50128 }); 50129 50130 }; 50131 50132 /** 50133 * Default options. 50134 * @public 50135 */ 50136 AutoHeight.Defaults = { 50137 autoHeight: false, 50138 autoHeightClass: 'owl-height' 50139 }; 50140 50141 /** 50142 * Updates the view. 50143 */ 50144 AutoHeight.prototype.update = function() { 50145 var start = this._core._current, 50146 end = start + this._core.settings.items, 50147 lazyLoadEnabled = this._core.settings.lazyLoad, 50148 visible = this._core.$stage.children().toArray().slice(start, end), 50149 heights = [], 50150 maxheight = 0; 50151 50152 $.each(visible, function(index, item) { 50153 heights.push($(item).height()); 50154 }); 50155 50156 maxheight = Math.max.apply(null, heights); 50157 50158 if (maxheight <= 1 && lazyLoadEnabled && this._previousHeight) { 50159 maxheight = this._previousHeight; 50160 } 50161 50162 this._previousHeight = maxheight; 50163 50164 this._core.$stage.parent() 50165 .height(maxheight) 50166 .addClass(this._core.settings.autoHeightClass); 50167 }; 50168 50169 AutoHeight.prototype.destroy = function() { 50170 var handler, property; 50171 50172 for (handler in this._handlers) { 50173 this._core.$element.off(handler, this._handlers[handler]); 50174 } 50175 for (property in Object.getOwnPropertyNames(this)) { 50176 typeof this[property] !== 'function' && (this[property] = null); 50177 } 50178 }; 50179 50180 $.fn.owlCarousel.Constructor.Plugins.AutoHeight = AutoHeight; 50181 50182})(window.Zepto || __webpack_provided_window_dot_
vendor: 8,863 bytes, lines 50182-50510
50182jQuery, window, document); 50183 50184/** 50185 * Video Plugin 50186 * @version 2.3.4 50187 * @author Bartosz Wojciechowski 50188 * @author David Deutsch 50189 * @license The MIT License (MIT) 50190 */ 50191;(function($, window, document, undefined) { 50192 50193 /** 50194 * Creates the video plugin. 50195 * @class The Video Plugin 50196 * @param {Owl} carousel - The Owl Carousel 50197 */ 50198 var Video = function(carousel) { 50199 /** 50200 * Reference to the core. 50201 * @protected 50202 * @type {Owl} 50203 */ 50204 this._core = carousel; 50205 50206 /** 50207 * Cache all video URLs. 50208 * @protected 50209 * @type {Object} 50210 */ 50211 this._videos = {}; 50212 50213 /** 50214 * Current playing item. 50215 * @protected 50216 * @type {jQuery} 50217 */ 50218 this._playing = null; 50219 50220 /** 50221 * All event handlers. 50222 * @todo The cloned content removale is too late 50223 * @protected 50224 * @type {Object} 50225 */ 50226 this._handlers = { 50227 'initialized.owl.carousel': $.proxy(function(e) { 50228 if (e.namespace) { 50229 this._core.register({ type: 'state', name: 'playing', tags: [ 'interacting' ] }); 50230 } 50231 }, this), 50232 'resize.owl.carousel': $.proxy(function(e) { 50233 if (e.namespace && this._core.settings.video && this.isInFullScreen()) { 50234 e.preventDefault(); 50235 } 50236 }, this), 50237 'refreshed.owl.carousel': $.proxy(function(e) { 50238 if (e.namespace && this._core.is('resizing')) { 50239 this._core.$stage.find('.cloned .owl-video-frame').remove(); 50240 } 50241 }, this), 50242 'changed.owl.carousel': $.proxy(function(e) { 50243 if (e.namespace && e.property.name === 'position' && this._playing) { 50244 this.stop(); 50245 } 50246 }, this), 50247 'prepared.owl.carousel': $.proxy(function(e) { 50248 if (!e.namespace) { 50249 return; 50250 } 50251 50252 var $element = $(e.content).find('.owl-video'); 50253 50254 if ($element.length) { 50255 $element.css('display', 'none'); 50256 this.fetch($element, $(e.content)); 50257 } 50258 }, this) 50259 }; 50260 50261 // set default options 50262 this._core.options = $.extend({}, Video.Defaults, this._core.options); 50263 50264 // register event handlers 50265 this._core.$element.on(this._handlers); 50266 50267 this._core.$element.on('click.owl.video', '.owl-video-play-icon', $.proxy(function(e) { 50268 this.play(e); 50269 }, this)); 50270 }; 50271 50272 /** 50273 * Default options. 50274 * @public 50275 */ 50276 Video.Defaults = { 50277 video: false, 50278 videoHeight: false, 50279 videoWidth: false 50280 }; 50281 50282 /** 50283 * Gets the video ID and the type (YouTube/Vimeo/vzaar only). 50284 * @protected 50285 * @param {jQuery} target - The target containing the video data. 50286 * @param {jQuery} item - The item containing the video. 50287 */ 50288 Video.prototype.fetch = function(target, item) { 50289 var type = (function() { 50290 if (target.attr('data-vimeo-id')) { 50291 return 'vimeo'; 50292 } else if (target.attr('data-vzaar-id')) { 50293 return 'vzaar' 50294 } else { 50295 return 'youtube'; 50296 } 50297 })(), 50298 id = target.attr('data-vimeo-id') || target.attr('data-youtube-id') || target.attr('data-vzaar-id'), 50299 width = target.attr('data-width') || this._core.settings.videoWidth, 50300 height = target.attr('data-height') || this._core.settings.videoHeight, 50301 url = target.attr('href'); 50302 50303 if (url) { 50304 50305 /* 50306 Parses the id's out of the following urls (and probably more): 50307 https://www.youtube.com/watch?v=:id 50308 https://youtu.be/:id 50309 https://vimeo.com/:id 50310 https://vimeo.com/channels/:channel/:id 50311 https://vimeo.com/groups/:group/videos/:id 50312 https://app.vzaar.com/videos/:id 50313 50314 Visual example: https://regexper.com/#(http%3A%7Chttps%3A%7C)%5C%2F%5C%2F(player.%7Cwww.%7Capp.)%3F(vimeo%5C.com%7Cyoutu(be%5C.com%7C%5C.be%7Cbe%5C.googleapis%5C.com)%7Cvzaar%5C.com)%5C%2F(video%5C%2F%7Cvideos%5C%2F%7Cembed%5C%2F%7Cchannels%5C%2F.%2B%5C%2F%7Cgroups%5C%2F.%2B%5C%2F%7Cwatch%5C%3Fv%3D%7Cv%5C%2F)%3F(%5BA-Za-z0-9._%25-%5D*)(%5C%26%5CS%2B)%3F 50315 */ 50316 50317 id = url.match(/(http:|https:|)\/\/(player.|www.|app.)?(vimeo\.com|youtu(be\.com|\.be|be\.googleapis\.com|be\-nocookie\.com)|vzaar\.com)\/(video\/|videos\/|embed\/|channels\/.+\/|groups\/.+\/|watch\?v=|v\/)?([A-Za-z0-9._%-]*)(\&\S+)?/); 50318 50319 if (id[3].indexOf('youtu') > -1) { 50320 type = 'youtube'; 50321 } else if (id[3].indexOf('vimeo') > -1) { 50322 type = 'vimeo'; 50323 } else if (id[3].indexOf('vzaar') > -1) { 50324 type = 'vzaar'; 50325 } else { 50326 throw new Error('Video URL not supported.'); 50327 } 50328 id = id[6]; 50329 } else { 50330 throw new Error('Missing video URL.'); 50331 } 50332 50333 this._videos[url] = { 50334 type: type, 50335 id: id, 50336 width: width, 50337 height: height 50338 }; 50339 50340 item.attr('data-video', url); 50341 50342 this.thumbnail(target, this._videos[url]); 50343 }; 50344 50345 /** 50346 * Creates video thumbnail. 50347 * @protected 50348 * @param {jQuery} target - The target containing the video data. 50349 * @param {Object} info - The video info object. 50350 * @see `fetch` 50351 */ 50352 Video.prototype.thumbnail = function(target, video) { 50353 var tnLink, 50354 icon, 50355 path, 50356 dimensions = video.width && video.height ? 'width:' + video.width + 'px;height:' + video.height + 'px;' : '', 50357 customTn = target.find('img'), 50358 srcType = 'src', 50359 lazyClass = '', 50360 settings = this._core.settings, 50361 create = function(path) { 50362 icon = '<div class="owl-video-play-icon"></div>'; 50363 50364 if (settings.lazyLoad) { 50365 tnLink = $('<div/>',{ 50366 "class": 'owl-video-tn ' + lazyClass, 50367 "srcType": path 50368 }); 50369 } else { 50370 tnLink = $( '<div/>', { 50371 "class": "owl-video-tn", 50372 "style": 'opacity:1;background-image:url(' + path + ')' 50373 }); 50374 } 50375 target.after(tnLink); 50376 target.after(icon); 50377 }; 50378 50379 // wrap video content into owl-video-wrapper div 50380 target.wrap( $( '<div/>', { 50381 "class": "owl-video-wrapper", 50382 "style": dimensions 50383 })); 50384 50385 if (this._core.settings.lazyLoad) { 50386 srcType = 'data-src'; 50387 lazyClass = 'owl-lazy'; 50388 } 50389 50390 // custom thumbnail 50391 if (customTn.length) { 50392 create(customTn.attr(srcType)); 50393 customTn.remove(); 50394 return false; 50395 } 50396 50397 if (video.type === 'youtube') { 50398 path = "//img.youtube.com/vi/" + video.id + "/hqdefault.jpg"; 50399 create(path); 50400 } else if (video.type === 'vimeo') { 50401 $.ajax({ 50402 type: 'GET', 50403 url: '//vimeo.com/api/v2/video/' + video.id + '.json', 50404 jsonp: 'callback', 50405 dataType: 'jsonp', 50406 success: function(data) { 50407 path = data[0].thumbnail_large; 50408 create(path); 50409 } 50410 }); 50411 } else if (video.type === 'vzaar') { 50412 $.ajax({ 50413 type: 'GET', 50414 url: '//vzaar.com/api/videos/' + video.id + '.json', 50415 jsonp: 'callback', 50416 dataType: 'jsonp', 50417 success: function(data) { 50418 path = data.framegrab_url; 50419 create(path); 50420 } 50421 }); 50422 } 50423 }; 50424 50425 /** 50426 * Stops the current video. 50427 * @public 50428 */ 50429 Video.prototype.stop = function() { 50430 this._core.trigger('stop', null, 'video'); 50431 this._playing.find('.owl-video-frame').remove(); 50432 this._playing.removeClass('owl-video-playing'); 50433 this._playing = null; 50434 this._core.leave('playing'); 50435 this._core.trigger('stopped', null, 'video'); 50436 }; 50437 50438 /** 50439 * Starts the current video. 50440 * @public 50441 * @param {Event} event - The event arguments. 50442 */ 50443 Video.prototype.play = function(event) { 50444 var target = $(event.target), 50445 item = target.closest('.' + this._core.settings.itemClass), 50446 video = this._videos[item.attr('data-video')], 50447 width = video.width || '100%', 50448 height = video.height || this._core.$stage.height(), 50449 html, 50450 iframe; 50451 50452 if (this._playing) { 50453 return; 50454 } 50455 50456 this._core.enter('playing'); 50457 this._core.trigger('play', null, 'video'); 50458 50459 item = this._core.items(this._core.relative(item.index())); 50460 50461 this._core.reset(item.index()); 50462 50463 html = $( '<iframe frameborder="0" allowfullscreen mozallowfullscreen webkitAllowFullScreen ></iframe>' ); 50464 html.attr( 'height', height ); 50465 html.attr( 'width', width ); 50466 if (video.type === 'youtube') { 50467 html.attr( 'src', '//www.youtube.com/embed/' + video.id + '?autoplay=1&rel=0&v=' + video.id ); 50468 } else if (video.type === 'vimeo') { 50469 html.attr( 'src', '//player.vimeo.com/video/' + video.id + '?autoplay=1' ); 50470 } else if (video.type === 'vzaar') { 50471 html.attr( 'src', '//view.vzaar.com/' + video.id + '/player?autoplay=true' ); 50472 } 50473 50474 iframe = $(html).wrap( '<div class="owl-video-frame" />' ).insertAfter(item.find('.owl-video')); 50475 50476 this._playing = item.addClass('owl-video-playing'); 50477 }; 50478 50479 /** 50480 * Checks whether an video is currently in full screen mode or not. 50481 * @todo Bad style because looks like a readonly method but changes members. 50482 * @protected 50483 * @returns {Boolean} 50484 */ 50485 Video.prototype.isInFullScreen = function() { 50486 var element = document.fullscreenElement || document.mozFullScreenElement || 50487 document.webkitFullscreenElement; 50488 50489 return element && $(element).parent().hasClass('owl-video-frame'); 50490 }; 50491 50492 /** 50493 * Destroys the plugin. 50494 */ 50495 Video.prototype.destroy = function() { 50496 var handler, property; 50497 50498 this._core.$element.off('click.owl.video'); 50499 50500 for (handler in this._handlers) { 50501 this._core.$element.off(handler, this._handlers[handler]); 50502 } 50503 for (property in Object.getOwnPropertyNames(this)) { 50504 typeof this[property] != 'function' && (this[property] = null); 50505 } 50506 }; 50507 50508 $.fn.owlCarousel.Constructor.Plugins.Video = Video; 50509 50510})(
vendor: 8,763 bytes, lines 50510-50866
50510window.Zepto || __webpack_provided_window_dot_jQuery, window, document); 50511 50512/** 50513 * Animate Plugin 50514 * @version 2.3.4 50515 * @author Bartosz Wojciechowski 50516 * @author David Deutsch 50517 * @license The MIT License (MIT) 50518 */ 50519;(function($, window, document, undefined) { 50520 50521 /** 50522 * Creates the animate plugin. 50523 * @class The Navigation Plugin 50524 * @param {Owl} scope - The Owl Carousel 50525 */ 50526 var Animate = function(scope) { 50527 this.core = scope; 50528 this.core.options = $.extend({}, Animate.Defaults, this.core.options); 50529 this.swapping = true; 50530 this.previous = undefined; 50531 this.next = undefined; 50532 50533 this.handlers = { 50534 'change.owl.carousel': $.proxy(function(e) { 50535 if (e.namespace && e.property.name == 'position') { 50536 this.previous = this.core.current(); 50537 this.next = e.property.value; 50538 } 50539 }, this), 50540 'drag.owl.carousel dragged.owl.carousel translated.owl.carousel': $.proxy(function(e) { 50541 if (e.namespace) { 50542 this.swapping = e.type == 'translated'; 50543 } 50544 }, this), 50545 'translate.owl.carousel': $.proxy(function(e) { 50546 if (e.namespace && this.swapping && (this.core.options.animateOut || this.core.options.animateIn)) { 50547 this.swap(); 50548 } 50549 }, this) 50550 }; 50551 50552 this.core.$element.on(this.handlers); 50553 }; 50554 50555 /** 50556 * Default options. 50557 * @public 50558 */ 50559 Animate.Defaults = { 50560 animateOut: false, 50561 animateIn: false 50562 }; 50563 50564 /** 50565 * Toggles the animation classes whenever an translations starts. 50566 * @protected 50567 * @returns {Boolean|undefined} 50568 */ 50569 Animate.prototype.swap = function() { 50570 50571 if (this.core.settings.items !== 1) { 50572 return; 50573 } 50574 50575 if (!$.support.animation || !$.support.transition) { 50576 return; 50577 } 50578 50579 this.core.speed(0); 50580 50581 var left, 50582 clear = $.proxy(this.clear, this), 50583 previous = this.core.$stage.children().eq(this.previous), 50584 next = this.core.$stage.children().eq(this.next), 50585 incoming = this.core.settings.animateIn, 50586 outgoing = this.core.settings.animateOut; 50587 50588 if (this.core.current() === this.previous) { 50589 return; 50590 } 50591 50592 if (outgoing) { 50593 left = this.core.coordinates(this.previous) - this.core.coordinates(this.next); 50594 previous.one($.support.animation.end, clear) 50595 .css( { 'left': left + 'px' } ) 50596 .addClass('animated owl-animated-out') 50597 .addClass(outgoing); 50598 } 50599 50600 if (incoming) { 50601 next.one($.support.animation.end, clear) 50602 .addClass('animated owl-animated-in') 50603 .addClass(incoming); 50604 } 50605 }; 50606 50607 Animate.prototype.clear = function(e) { 50608 $(e.target).css( { 'left': '' } ) 50609 .removeClass('animated owl-animated-out owl-animated-in') 50610 .removeClass(this.core.settings.animateIn) 50611 .removeClass(this.core.settings.animateOut); 50612 this.core.onTransitionEnd(); 50613 }; 50614 50615 /** 50616 * Destroys the plugin. 50617 * @public 50618 */ 50619 Animate.prototype.destroy = function() { 50620 var handler, property; 50621 50622 for (handler in this.handlers) { 50623 this.core.$element.off(handler, this.handlers[handler]); 50624 } 50625 for (property in Object.getOwnPropertyNames(this)) { 50626 typeof this[property] != 'function' && (this[property] = null); 50627 } 50628 }; 50629 50630 $.fn.owlCarousel.Constructor.Plugins.Animate = Animate; 50631 50632})(window.Zepto || __webpack_provided_window_dot_jQuery, window, document); 50633 50634/** 50635 * Autoplay Plugin 50636 * @version 2.3.4 50637 * @author Bartosz Wojciechowski 50638 * @author Artus Kolanowski 50639 * @author David Deutsch 50640 * @author Tom De Caluwé 50641 * @license The MIT License (MIT) 50642 */ 50643;(function($, window, document, undefined) { 50644 50645 /** 50646 * Creates the autoplay plugin. 50647 * @class The Autoplay Plugin 50648 * @param {Owl} scope - The Owl Carousel 50649 */ 50650 var Autoplay = function(carousel) { 50651 /** 50652 * Reference to the core. 50653 * @protected 50654 * @type {Owl} 50655 */ 50656 this._core = carousel; 50657 50658 /** 50659 * The autoplay timeout id. 50660 * @type {Number} 50661 */ 50662 this._call = null; 50663 50664 /** 50665 * Depending on the state of the plugin, this variable contains either 50666 * the start time of the timer or the current timer value if it's 50667 * paused. Since we start in a paused state we initialize the timer 50668 * value. 50669 * @type {Number} 50670 */ 50671 this._time = 0; 50672 50673 /** 50674 * Stores the timeout currently used. 50675 * @type {Number} 50676 */ 50677 this._timeout = 0; 50678 50679 /** 50680 * Indicates whenever the autoplay is paused. 50681 * @type {Boolean} 50682 */ 50683 this._paused = true; 50684 50685 /** 50686 * All event handlers. 50687 * @protected 50688 * @type {Object} 50689 */ 50690 this._handlers = { 50691 'changed.owl.carousel': $.proxy(function(e) { 50692 if (e.namespace && e.property.name === 'settings') { 50693 if (this._core.settings.autoplay) { 50694 this.play(); 50695 } else { 50696 this.stop(); 50697 } 50698 } else if (e.namespace && e.property.name === 'position' && this._paused) { 50699 // Reset the timer. This code is triggered when the position 50700 // of the carousel was changed through user interaction. 50701 this._time = 0; 50702 } 50703 }, this), 50704 'initialized.owl.carousel': $.proxy(function(e) { 50705 if (e.namespace && this._core.settings.autoplay) { 50706 this.play(); 50707 } 50708 }, this), 50709 'play.owl.autoplay': $.proxy(function(e, t, s) { 50710 if (e.namespace) { 50711 this.play(t, s); 50712 } 50713 }, this), 50714 'stop.owl.autoplay': $.proxy(function(e) { 50715 if (e.namespace) { 50716 this.stop(); 50717 } 50718 }, this), 50719 'mouseover.owl.autoplay': $.proxy(function() { 50720 if (this._core.settings.autoplayHoverPause && this._core.is('rotating')) { 50721 this.pause(); 50722 } 50723 }, this), 50724 'mouseleave.owl.autoplay': $.proxy(function() { 50725 if (this._core.settings.autoplayHoverPause && this._core.is('rotating')) { 50726 this.play(); 50727 } 50728 }, this), 50729 'touchstart.owl.core': $.proxy(function() { 50730 if (this._core.settings.autoplayHoverPause && this._core.is('rotating')) { 50731 this.pause(); 50732 } 50733 }, this), 50734 'touchend.owl.core': $.proxy(function() { 50735 if (this._core.settings.autoplayHoverPause) { 50736 this.play(); 50737 } 50738 }, this) 50739 }; 50740 50741 // register event handlers 50742 this._core.$element.on(this._handlers); 50743 50744 // set default options 50745 this._core.options = $.extend({}, Autoplay.Defaults, this._core.options); 50746 }; 50747 50748 /** 50749 * Default options. 50750 * @public 50751 */ 50752 Autoplay.Defaults = { 50753 autoplay: false, 50754 autoplayTimeout: 5000, 50755 autoplayHoverPause: false, 50756 autoplaySpeed: false 50757 }; 50758 50759 /** 50760 * Transition to the next slide and set a timeout for the next transition. 50761 * @private 50762 * @param {Number} [speed] - The animation speed for the animations. 50763 */ 50764 Autoplay.prototype._next = function(speed) { 50765 this._call = window.setTimeout( 50766 $.proxy(this._next, this, speed), 50767 this._timeout * (Math.round(this.read() / this._timeout) + 1) - this.read() 50768 ); 50769 50770 if (this._core.is('interacting') || document.hidden) { 50771 return; 50772 } 50773 this._core.next(speed || this._core.settings.autoplaySpeed); 50774 } 50775 50776 /** 50777 * Reads the current timer value when the timer is playing. 50778 * @public 50779 */ 50780 Autoplay.prototype.read = function() { 50781 return new Date().getTime() - this._time; 50782 }; 50783 50784 /** 50785 * Starts the autoplay. 50786 * @public 50787 * @param {Number} [timeout] - The interval before the next animation starts. 50788 * @param {Number} [speed] - The animation speed for the animations. 50789 */ 50790 Autoplay.prototype.play = function(timeout, speed) { 50791 var elapsed; 50792 50793 if (!this._core.is('rotating')) { 50794 this._core.enter('rotating'); 50795 } 50796 50797 timeout = timeout || this._core.settings.autoplayTimeout; 50798 50799 // Calculate the elapsed time since the last transition. If the carousel 50800 // wasn't playing this calculation will yield zero. 50801 elapsed = Math.min(this._time % (this._timeout || timeout), timeout); 50802 50803 if (this._paused) { 50804 // Start the clock. 50805 this._time = this.read(); 50806 this._paused = false; 50807 } else { 50808 // Clear the active timeout to allow replacement. 50809 window.clearTimeout(this._call); 50810 } 50811 50812 // Adjust the origin of the timer to match the new timeout value. 50813 this._time += this.read() % timeout - elapsed; 50814 50815 this._timeout = timeout; 50816 this._call = window.setTimeout($.proxy(this._next, this, speed), timeout - elapsed); 50817 }; 50818 50819 /** 50820 * Stops the autoplay. 50821 * @public 50822 */ 50823 Autoplay.prototype.stop = function() { 50824 if (this._core.is('rotating')) { 50825 // Reset the clock. 50826 this._time = 0; 50827 this._paused = true; 50828 50829 window.clearTimeout(this._call); 50830 this._core.leave('rotating'); 50831 } 50832 }; 50833 50834 /** 50835 * Pauses the autoplay. 50836 * @public 50837 */ 50838 Autoplay.prototype.pause = function() { 50839 if (this._core.is('rotating') && !this._paused) { 50840 // Pause the clock. 50841 this._time = this.read(); 50842 this._paused = true; 50843 50844 window.clearTimeout(this._call); 50845 } 50846 }; 50847 50848 /** 50849 * Destroys the plugin. 50850 */ 50851 Autoplay.prototype.destroy = function() { 50852 var handler, property; 50853 50854 this.stop(); 50855 50856 for (handler in this._handlers) { 50857 this._core.$element.off(handler, this._handlers[handler]); 50858 } 50859 for (property in Object.getOwnPropertyNames(this)) { 50860 typeof this[property] != 'function' && (this[property] = null); 50861 } 50862 }; 50863 50864 $.fn.owlCarousel.Constructor.Plugins.autoplay = Autoplay; 50865 50866})(window.Zepto || __webpack_provided_window_dot_
vendor: 11,156 bytes, lines 50866-51273
50866jQuery, window, document); 50867 50868/** 50869 * Navigation Plugin 50870 * @version 2.3.4 50871 * @author Artus Kolanowski 50872 * @author David Deutsch 50873 * @license The MIT License (MIT) 50874 */ 50875;(function($, window, document, undefined) { 50876 'use strict'; 50877 50878 /** 50879 * Creates the navigation plugin. 50880 * @class The Navigation Plugin 50881 * @param {Owl} carousel - The Owl Carousel. 50882 */ 50883 var Navigation = function(carousel) { 50884 /** 50885 * Reference to the core. 50886 * @protected 50887 * @type {Owl} 50888 */ 50889 this._core = carousel; 50890 50891 /** 50892 * Indicates whether the plugin is initialized or not. 50893 * @protected 50894 * @type {Boolean} 50895 */ 50896 this._initialized = false; 50897 50898 /** 50899 * The current paging indexes. 50900 * @protected 50901 * @type {Array} 50902 */ 50903 this._pages = []; 50904 50905 /** 50906 * All DOM elements of the user interface. 50907 * @protected 50908 * @type {Object} 50909 */ 50910 this._controls = {}; 50911 50912 /** 50913 * Markup for an indicator. 50914 * @protected 50915 * @type {Array.<String>} 50916 */ 50917 this._templates = []; 50918 50919 /** 50920 * The carousel element. 50921 * @type {jQuery} 50922 */ 50923 this.$element = this._core.$element; 50924 50925 /** 50926 * Overridden methods of the carousel. 50927 * @protected 50928 * @type {Object} 50929 */ 50930 this._overrides = { 50931 next: this._core.next, 50932 prev: this._core.prev, 50933 to: this._core.to 50934 }; 50935 50936 /** 50937 * All event handlers. 50938 * @protected 50939 * @type {Object} 50940 */ 50941 this._handlers = { 50942 'prepared.owl.carousel': $.proxy(function(e) { 50943 if (e.namespace && this._core.settings.dotsData) { 50944 this._templates.push('<div class="' + this._core.settings.dotClass + '">' + 50945 $(e.content).find('[data-dot]').addBack('[data-dot]').attr('data-dot') + '</div>'); 50946 } 50947 }, this), 50948 'added.owl.carousel': $.proxy(function(e) { 50949 if (e.namespace && this._core.settings.dotsData) { 50950 this._templates.splice(e.position, 0, this._templates.pop()); 50951 } 50952 }, this), 50953 'remove.owl.carousel': $.proxy(function(e) { 50954 if (e.namespace && this._core.settings.dotsData) { 50955 this._templates.splice(e.position, 1); 50956 } 50957 }, this), 50958 'changed.owl.carousel': $.proxy(function(e) { 50959 if (e.namespace && e.property.name == 'position') { 50960 this.draw(); 50961 } 50962 }, this), 50963 'initialized.owl.carousel': $.proxy(function(e) { 50964 if (e.namespace && !this._initialized) { 50965 this._core.trigger('initialize', null, 'navigation'); 50966 this.initialize(); 50967 this.update(); 50968 this.draw(); 50969 this._initialized = true; 50970 this._core.trigger('initialized', null, 'navigation'); 50971 } 50972 }, this), 50973 'refreshed.owl.carousel': $.proxy(function(e) { 50974 if (e.namespace && this._initialized) { 50975 this._core.trigger('refresh', null, 'navigation'); 50976 this.update(); 50977 this.draw(); 50978 this._core.trigger('refreshed', null, 'navigation'); 50979 } 50980 }, this) 50981 }; 50982 50983 // set default options 50984 this._core.options = $.extend({}, Navigation.Defaults, this._core.options); 50985 50986 // register event handlers 50987 this.$element.on(this._handlers); 50988 }; 50989 50990 /** 50991 * Default options. 50992 * @public 50993 * @todo Rename `slideBy` to `navBy` 50994 */ 50995 Navigation.Defaults = { 50996 nav: false, 50997 navText: [ 50998 '<span aria-label="' + 'Previous' + '">‹</span>', 50999 '<span aria-label="' + 'Next' + '">›</span>' 51000 ], 51001 navSpeed: false, 51002 navElement: 'button type="button" role="presentation"', 51003 navContainer: false, 51004 navContainerClass: 'owl-nav', 51005 navClass: [ 51006 'owl-prev', 51007 'owl-next' 51008 ], 51009 slideBy: 1, 51010 dotClass: 'owl-dot', 51011 dotsClass: 'owl-dots', 51012 dots: true, 51013 dotsEach: false, 51014 dotsData: false, 51015 dotsSpeed: false, 51016 dotsContainer: false 51017 }; 51018 51019 /** 51020 * Initializes the layout of the plugin and extends the carousel. 51021 * @protected 51022 */ 51023 Navigation.prototype.initialize = function() { 51024 var override, 51025 settings = this._core.settings; 51026 51027 // create DOM structure for relative navigation 51028 this._controls.$relative = (settings.navContainer ? $(settings.navContainer) 51029 : $('<div>').addClass(settings.navContainerClass).appendTo(this.$element)).addClass('disabled'); 51030 51031 this._controls.$previous = $('<' + settings.navElement + '>') 51032 .addClass(settings.navClass[0]) 51033 .html(settings.navText[0]) 51034 .prependTo(this._controls.$relative) 51035 .on('click', $.proxy(function(e) { 51036 this.prev(settings.navSpeed); 51037 }, this)); 51038 this._controls.$next = $('<' + settings.navElement + '>') 51039 .addClass(settings.navClass[1]) 51040 .html(settings.navText[1]) 51041 .appendTo(this._controls.$relative) 51042 .on('click', $.proxy(function(e) { 51043 this.next(settings.navSpeed); 51044 }, this)); 51045 51046 // create DOM structure for absolute navigation 51047 if (!settings.dotsData) { 51048 this._templates = [ $('<button role="button">') 51049 .addClass(settings.dotClass) 51050 .append($('<span>')) 51051 .prop('outerHTML') ]; 51052 } 51053 51054 this._controls.$absolute = (settings.dotsContainer ? $(settings.dotsContainer) 51055 : $('<div>').addClass(settings.dotsClass).appendTo(this.$element)).addClass('disabled'); 51056 51057 this._controls.$absolute.on('click', 'button', $.proxy(function(e) { 51058 var index = $(e.target).parent().is(this._controls.$absolute) 51059 ? $(e.target).index() : $(e.target).parent().index(); 51060 51061 e.preventDefault(); 51062 51063 this.to(index, settings.dotsSpeed); 51064 }, this)); 51065 51066 /*$el.on('focusin', function() { 51067 $(document).off(".carousel"); 51068 51069 $(document).on('keydown.carousel', function(e) { 51070 if(e.keyCode == 37) { 51071 $el.trigger('prev.owl') 51072 } 51073 if(e.keyCode == 39) { 51074 $el.trigger('next.owl') 51075 } 51076 }); 51077 });*/ 51078 51079 // override public methods of the carousel 51080 for (override in this._overrides) { 51081 this._core[override] = $.proxy(this[override], this); 51082 } 51083 }; 51084 51085 /** 51086 * Destroys the plugin. 51087 * @protected 51088 */ 51089 Navigation.prototype.destroy = function() { 51090 var handler, control, property, override, settings; 51091 settings = this._core.settings; 51092 51093 for (handler in this._handlers) { 51094 this.$element.off(handler, this._handlers[handler]); 51095 } 51096 for (control in this._controls) { 51097 if (control === '$relative' && settings.navContainer) { 51098 this._controls[control].html(''); 51099 } else { 51100 this._controls[control].remove(); 51101 } 51102 } 51103 for (override in this.overides) { 51104 this._core[override] = this._overrides[override]; 51105 } 51106 for (property in Object.getOwnPropertyNames(this)) { 51107 typeof this[property] != 'function' && (this[property] = null); 51108 } 51109 }; 51110 51111 /** 51112 * Updates the internal state. 51113 * @protected 51114 */ 51115 Navigation.prototype.update = function() { 51116 var i, j, k, 51117 lower = this._core.clones().length / 2, 51118 upper = lower + this._core.items().length, 51119 maximum = this._core.maximum(true), 51120 settings = this._core.settings, 51121 size = settings.center || settings.autoWidth || settings.dotsData 51122 ? 1 : settings.dotsEach || settings.items; 51123 51124 if (settings.slideBy !== 'page') { 51125 settings.slideBy = Math.min(settings.slideBy, settings.items); 51126 } 51127 51128 if (settings.dots || settings.slideBy == 'page') { 51129 this._pages = []; 51130 51131 for (i = lower, j = 0, k = 0; i < upper; i++) { 51132 if (j >= size || j === 0) { 51133 this._pages.push({ 51134 start: Math.min(maximum, i - lower), 51135 end: i - lower + size - 1 51136 }); 51137 if (Math.min(maximum, i - lower) === maximum) { 51138 break; 51139 } 51140 j = 0, ++k; 51141 } 51142 j += this._core.mergers(this._core.relative(i)); 51143 } 51144 } 51145 }; 51146 51147 /** 51148 * Draws the user interface. 51149 * @todo The option `dotsData` wont work. 51150 * @protected 51151 */ 51152 Navigation.prototype.draw = function() { 51153 var difference, 51154 settings = this._core.settings, 51155 disabled = this._core.items().length <= settings.items, 51156 index = this._core.relative(this._core.current()), 51157 loop = settings.loop || settings.rewind; 51158 51159 this._controls.$relative.toggleClass('disabled', !settings.nav || disabled); 51160 51161 if (settings.nav) { 51162 this._controls.$previous.toggleClass('disabled', !loop && index <= this._core.minimum(true)); 51163 this._controls.$next.toggleClass('disabled', !loop && index >= this._core.maximum(true)); 51164 } 51165 51166 this._controls.$absolute.toggleClass('disabled', !settings.dots || disabled); 51167 51168 if (settings.dots) { 51169 difference = this._pages.length - this._controls.$absolute.children().length; 51170 51171 if (settings.dotsData && difference !== 0) { 51172 this._controls.$absolute.html(this._templates.join('')); 51173 } else if (difference > 0) { 51174 this._controls.$absolute.append(new Array(difference + 1).join(this._templates[0])); 51175 } else if (difference < 0) { 51176 this._controls.$absolute.children().slice(difference).remove(); 51177 } 51178 51179 this._controls.$absolute.find('.active').removeClass('active'); 51180 this._controls.$absolute.children().eq($.inArray(this.current(), this._pages)).addClass('active'); 51181 } 51182 }; 51183 51184 /** 51185 * Extends event data. 51186 * @protected 51187 * @param {Event} event - The event object which gets thrown. 51188 */ 51189 Navigation.prototype.onTrigger = function(event) { 51190 var settings = this._core.settings; 51191 51192 event.page = { 51193 index: $.inArray(this.current(), this._pages), 51194 count: this._pages.length, 51195 size: settings && (settings.center || settings.autoWidth || settings.dotsData 51196 ? 1 : settings.dotsEach || settings.items) 51197 }; 51198 }; 51199 51200 /** 51201 * Gets the current page position of the carousel. 51202 * @protected 51203 * @returns {Number} 51204 */ 51205 Navigation.prototype.current = function() { 51206 var current = this._core.relative(this._core.current()); 51207 return $.grep(this._pages, $.proxy(function(page, index) { 51208 return page.start <= current && page.end >= current; 51209 }, this)).pop(); 51210 }; 51211 51212 /** 51213 * Gets the current succesor/predecessor position. 51214 * @protected 51215 * @returns {Number} 51216 */ 51217 Navigation.prototype.getPosition = function(successor) { 51218 var position, length, 51219 settings = this._core.settings; 51220 51221 if (settings.slideBy == 'page') { 51222 position = $.inArray(this.current(), this._pages); 51223 length = this._pages.length; 51224 successor ? ++position : --position; 51225 position = this._pages[((position % length) + length) % length].start; 51226 } else { 51227 position = this._core.relative(this._core.current()); 51228 length = this._core.items().length; 51229 successor ? position += settings.slideBy : position -= settings.slideBy; 51230 } 51231 51232 return position; 51233 }; 51234 51235 /** 51236 * Slides to the next item or page. 51237 * @public 51238 * @param {Number} [speed=false] - The time in milliseconds for the transition. 51239 */ 51240 Navigation.prototype.next = function(speed) { 51241 $.proxy(this._overrides.to, this._core)(this.getPosition(true), speed); 51242 }; 51243 51244 /** 51245 * Slides to the previous item or page. 51246 * @public 51247 * @param {Number} [speed=false] - The time in milliseconds for the transition. 51248 */ 51249 Navigation.prototype.prev = function(speed) { 51250 $.proxy(this._overrides.to, this._core)(this.getPosition(false), speed); 51251 }; 51252 51253 /** 51254 * Slides to the specified item or page. 51255 * @public 51256 * @param {Number} position - The position of the item or page. 51257 * @param {Number} [speed] - The time in milliseconds for the transition. 51258 * @param {Boolean} [standard=false] - Whether to use the standard behaviour or not. 51259 */ 51260 Navigation.prototype.to = function(position, speed, standard) { 51261 var length; 51262 51263 if (!standard && this._pages.length) { 51264 length = this._pages.length; 51265 $.proxy(this._overrides.to, this._core)(this._pages[((position % length) + length) % length].start, speed); 51266 } else { 51267 $.proxy(this._overrides.to, this._core)(position, speed); 51268 } 51269 }; 51270 51271 $.fn.owlCarousel.Constructor.Plugins.Navigation = Navigation; 51272 51273})(
vendor: 4,249 bytes, lines 51273-51451
51273window.Zepto || __webpack_provided_window_dot_jQuery, window, document); 51274 51275/** 51276 * Hash Plugin 51277 * @version 2.3.4 51278 * @author Artus Kolanowski 51279 * @author David Deutsch 51280 * @license The MIT License (MIT) 51281 */ 51282;(function($, window, document, undefined) { 51283 'use strict'; 51284 51285 /** 51286 * Creates the hash plugin. 51287 * @class The Hash Plugin 51288 * @param {Owl} carousel - The Owl Carousel 51289 */ 51290 var Hash = function(carousel) { 51291 /** 51292 * Reference to the core. 51293 * @protected 51294 * @type {Owl} 51295 */ 51296 this._core = carousel; 51297 51298 /** 51299 * Hash index for the items. 51300 * @protected 51301 * @type {Object} 51302 */ 51303 this._hashes = {}; 51304 51305 /** 51306 * The carousel element. 51307 * @type {jQuery} 51308 */ 51309 this.$element = this._core.$element; 51310 51311 /** 51312 * All event handlers. 51313 * @protected 51314 * @type {Object} 51315 */ 51316 this._handlers = { 51317 'initialized.owl.carousel': $.proxy(function(e) { 51318 if (e.namespace && this._core.settings.startPosition === 'URLHash') { 51319 $(window).trigger('hashchange.owl.navigation'); 51320 } 51321 }, this), 51322 'prepared.owl.carousel': $.proxy(function(e) { 51323 if (e.namespace) { 51324 var hash = $(e.content).find('[data-hash]').addBack('[data-hash]').attr('data-hash'); 51325 51326 if (!hash) { 51327 return; 51328 } 51329 51330 this._hashes[hash] = e.content; 51331 } 51332 }, this), 51333 'changed.owl.carousel': $.proxy(function(e) { 51334 if (e.namespace && e.property.name === 'position') { 51335 var current = this._core.items(this._core.relative(this._core.current())), 51336 hash = $.map(this._hashes, function(item, hash) { 51337 return item === current ? hash : null; 51338 }).join(); 51339 51340 if (!hash || window.location.hash.slice(1) === hash) { 51341 return; 51342 } 51343 51344 window.location.hash = hash; 51345 } 51346 }, this) 51347 }; 51348 51349 // set default options 51350 this._core.options = $.extend({}, Hash.Defaults, this._core.options); 51351 51352 // register the event handlers 51353 this.$element.on(this._handlers); 51354 51355 // register event listener for hash navigation 51356 $(window).on('hashchange.owl.navigation', $.proxy(function(e) { 51357 var hash = window.location.hash.substring(1), 51358 items = this._core.$stage.children(), 51359 position = this._hashes[hash] && items.index(this._hashes[hash]); 51360 51361 if (position === undefined || position === this._core.current()) { 51362 return; 51363 } 51364 51365 this._core.to(this._core.relative(position), false, true); 51366 }, this)); 51367 }; 51368 51369 /** 51370 * Default options. 51371 * @public 51372 */ 51373 Hash.Defaults = { 51374 URLhashListener: false 51375 }; 51376 51377 /** 51378 * Destroys the plugin. 51379 * @public 51380 */ 51381 Hash.prototype.destroy = function() { 51382 var handler, property; 51383 51384 $(window).off('hashchange.owl.navigation'); 51385 51386 for (handler in this._handlers) { 51387 this._core.$element.off(handler, this._handlers[handler]); 51388 } 51389 for (property in Object.getOwnPropertyNames(this)) { 51390 typeof this[property] != 'function' && (this[property] = null); 51391 } 51392 }; 51393 51394 $.fn.owlCarousel.Constructor.Plugins.Hash = Hash; 51395 51396})(window.Zepto || __webpack_provided_window_dot_jQuery, window, document); 51397 51398/** 51399 * Support Plugin 51400 * 51401 * @version 2.3.4 51402 * @author Vivid Planet Software GmbH 51403 * @author Artus Kolanowski 51404 * @author David Deutsch 51405 * @license The MIT License (MIT) 51406 */ 51407;(function($, window, document, undefined) { 51408 51409 var style = $('<support>').get(0).style, 51410 prefixes = 'Webkit Moz O ms'.split(' '), 51411 events = { 51412 transition: { 51413 end: { 51414 WebkitTransition: 'webkitTransitionEnd', 51415 MozTransition: 'transitionend', 51416 OTransition: 'oTransitionEnd', 51417 transition: 'transitionend' 51418 } 51419 }, 51420 animation: { 51421 end: { 51422 WebkitAnimation: 'webkitAnimationEnd', 51423 MozAnimation: 'animationend', 51424 OAnimation: 'oAnimationEnd', 51425 animation: 'animationend' 51426 } 51427 } 51428 }, 51429 tests = { 51430 csstransforms: function() { 51431 return !!test('transform'); 51432 }, 51433 csstransforms3d: function() { 51434 return !!test('perspective'); 51435 }, 51436 csstransitions: function() { 51437 return !!test('transition'); 51438 }, 51439 cssanimations: function() { 51440 return !!test('animation'); 51441 } 51442 }; 51443 51444 function test(property, prefixed) { 51445 var result = false, 51446 upper = property.charAt(0).toUpperCase() + property.slice(1); 51447 51448 $.each((property + ' ' + prefixes.join(upper + ' ') + upper).split(' '), function(i, property) { 51449 if (style[property] !== undefined) { 51450 result = prefixed ? property : true; 51451 return false;
51452 } 51453 }); 51454 51455 return result; 51456 } 51457 51458 function prefixed(property) { 51459 return test(property, true); 51460 } 51461 51462 if (tests.csstransitions()) { 51463 /* jshint -W053 */ 51464 $.support.transition = new String(prefixed('transition')) 51465 $.support.transition.end = events.transition.end[ $.support.transition ]; 51466 } 51467 51468 if (tests.cssanimations()) { 51469 /* jshint -W053 */ 51470 $.support.animation = new String(prefixed('animation')) 51471 $.support.animation.end = events.animation.end[ $.support.animation ]; 51472 } 51473 51474 if (tests.csstransforms()) { 51475 /* jshint -W053 */ 51476 $.support.transform = new String(prefixed('transform')); 51477 $.support.transform3d = tests.csstransforms3d(); 51478 } 51479 51480})(window.Zepto || __webpack_provided_window_dot_jQuery, window, document); 51481 51482/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4), __webpack_require__(4))) 51483 51484/***/ }), 51485/* 156 */ 51486/***/ (function(module, exports) { 51487 51488module.exports = function(module) { 51489 if(!module.webpackPolyfill) { 51490 module.deprecate = function() {}; 51491 module.paths = []; 51492 // module.parent = undefined by default 51493 if(!module.children) module.children = []; 51494 Object.defineProperty(module, "loaded", { 51495 enumerable: true, 51496 get: function() { 51497 return module.l; 51498 } 51499 }); 51500 Object.defineProperty(module, "id", { 51501 enumerable: true, 51502 get: function() { 51503 return module.i; 51504 } 51505 }); 51506 module.webpackPolyfill = 1; 51507 } 51508 return module; 51509}; 51510 51511 51512/***/ }), 51513/* 157 */ 51514/***/ (function(module, exports, __webpack_require__) { 51515 51516"use strict"; 51517 51518 51519__webpack_require__(183); 51520__webpack_require__(18); 51521__webpack_require__(184); 51522__webpack_require__(179); 51523__webpack_require__(172); 51524__webpack_require__(164); 51525__webpack_require__(166); 51526__webpack_require__(167); 51527__webpack_require__(175); 51528__webpack_require__(171); 51529__webpack_require__(169); 51530__webpack_require__(176); 51531__webpack_require__(170); 51532__webpack_require__(177); 51533__webpack_require__(168); 51534__webpack_require__(165); 51535__webpack_require__(173); 51536__webpack_require__(174); 51537 51538/***/ }), 51539/* 158 */ 51540/***/ (function(module, exports) { 51541 51542// removed by extract-text-webpack-plugin 51543 51544/***/ }), 51545/* 159 */ 51546/***/ (function(module, exports, __webpack_require__) { 51547 51548"use strict"; 51549 51550 51551Object.defineProperty(exports, "__esModule", { 51552 value: true 51553}); 51554 51555var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 51556 51557function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 51558 51559var Snap = __webpack_require__(16); 51560 51561var Accordion = function () { 51562 function Accordion(options) { 51563 _classCallCheck(this, Accordion); 51564 51565 this.options = options || {}; 51566 this.container = this.options.container; 51567 this.tab = this.options.tab || this.container.querySelector('.accordion_tab'); 51568 this.content = this.options.content || this.container.querySelector('.accordion_content'); 51569 this.switch = this.options.switch || this.container.querySelector('.accordion_switch'); 51570 this.switch_icon = this.options.switch_icon || false; 51571 this.init(); 51572 } 51573 51574 _createClass(Accordion, [{ 51575 key: 'init', 51576 value: function init() { 51577 var _this = this; 51578 51579 this.opened = false; 51580 51581 if (this.content) { 51582 setTimeout(function () { 51583 _this.scroll_height = _this.content.scrollHeight + 50; 51584 }, 1000); 51585 } else { 51586 this.switch_icon = false; 51587 } 51588 51589 this.init_events(); 51590 this.add_switch_icon(); 51591 } 51592 }, { 51593 key: 'init_events', 51594 value: function init_events() { 51595 var _this2 = this; 51596 51597 this.tab.addEventListener('click', function () { 51598 51599 if (_this2.opened) { 51600 _this2.close(); 51601 } else { 51602 _this2.open(); 51603 } 51604 51605 _this2.opened = !_this2.opened; 51606 }); 51607 } 51608 }, {
51609 key: 'open', 51610 value: function open() { 51611 51612 this.content.style.maxHeight = this.scroll_height + 'px'; 51613 this.container.classList.add('active'); 51614 } 51615 }, { 51616 key: 'close', 51617 value: function close() { 51618 51619 this.content.style.maxHeight = '0px'; 51620 this.container.classList.remove('active'); 51621 } 51622 }, { 51623 key: 'add_switch_icon', 51624 value: function add_switch_icon() { 51625 51626 if (this.switch_icon !== false) { 51627 51628 var svg_container = Snap(this.switch); 51629 51630 Snap.load(this.switch_icon, function (e) { 51631 51632 svg_container.append(e); 51633 }); 51634 } 51635 } 51636 }]); 51637 51638 return Accordion; 51639}(); 51640 51641exports.default = Accordion; 51642 51643/***/ }), 51644/* 160 */ 51645/***/ (function(module, exports, __webpack_require__) { 51646 51647"use strict"; 51648 51649 51650Object.defineProperty(exports, "__esModule", { 51651 value: true 51652}); 51653 51654var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 51655 51656var _gsap = __webpack_require__(8); 51657 51658var _utils = __webpack_require__(6); 51659 51660function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } 51661 51662function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 51663 51664__webpack_require__(14); 51665 51666var ApparitionManager = function () { 51667 function ApparitionManager(options) { 51668 _classCallCheck(this, ApparitionManager); 51669 51670 this.options = options || {}; 51671 this.element = this.options.element; 51672 this.type = this.options.type || null; 51673 this.init(); 51674 } 51675 51676 _createClass(ApparitionManager, [{ 51677 key: 'init', 51678 value: function init() { 51679 var _this = this; 51680 51681 this.has_appeared = false; 51682 this.timeline_options = { 51683 paused: true, 51684 autoRemoveChildren: true, 51685 onComplete: function onComplete() { 51686 _this.has_appeared = true; 51687 } 51688 }; 51689 51690 this.setup(this.element); 51691 this.init_events(); 51692 } 51693 }, { 51694 key: 'init_events', 51695 value: function init_events() { 51696 var _this2 = this; 51697 51698 document.addEventListener('DOMContentLoaded', function () { 51699 51700 if (!_this2.has_appeared) { 51701 _this2.appear(_this2.element); 51702 } 51703 }); 51704 51705 window.addEventListener('scroll', function () { 51706 51707 if (!_this2.has_appeared) { 51708 _this2.appear(_this2.element); 51709 } 51710 }); 51711 } 51712 }, { 51713 key: 'setup', 51714 value: function setup(el) { 51715 switch (this.type) { 51716 case 'title': 51717 this._setup_title(el); 51718 break; 51719 case 'header': 51720 this._setup_header(el); 51721 break; 51722 case 'mask': 51723 break; 51724 case 'text': 51725 break; 51726 case 'number': 51727 break; 51728 case 'letter': 51729 this._setup_letter(el); 51730 break; 51731 default: 51732 throw new Error('Element type must be defined'); 51733 } 51734 } 51735 }, { 51736 key: 'appear', 51737 value: function appear(el) { 51738 51739 switch (this.type) { 51740 case 'title': 51741 this._appear_title(el); 51742 break; 51743 case 'header': 51744 this._appear_header(el); 51745 break; 51746 case 'mask': 51747 this._appear_mask(el); 51748 break; 51749 case 'text': 51750 this._appear_text(el); 51751 break; 51752 case 'number': 51753 this._appear_number(el); 51754 break; 51755 case 'letter': 51756 this._appear_letter(el); 51757 break; 51758 default: 51759 throw new Error('Element type must be defined'); 51760 } 51761 } 51762 }, {
51763 key: '_setup_title', 51764 value: function _setup_title(el) { 51765 51766 var split = new SplitText(el, { 51767 type: 'words, lines', 51768 linesClass: 'content_title_line', 51769 wordsClass: 'content_title_word' 51770 }); 51771 } 51772 }, { 51773 key: '_setup_header', 51774 value: function _setup_header(el) { 51775 51776 var split = new SplitText(el.querySelector('.page_header_title'), { 51777 type: 'words, lines', 51778 linesClass: 'page_header_title_line', 51779 wordsClass: 'page_header_title_word' 51780 }); 51781 } 51782 }, { 51783 key: '_setup_letter', 51784 value: function _setup_letter(el) { 51785 51786 var split = new SplitText(el, { 51787 type: 'chars', 51788 charsClass: 'content_character' 51789 }); 51790 } 51791 }, { 51792 key: '_appear_title', 51793 value: function _appear_title(el) { 51794 51795 var title_TL = new _gsap.TimelineMax(this.timeline_options); 51796 51797 var words = [].concat(_toConsumableArray(el.querySelectorAll('.content_title_word')), _toConsumableArray(el.querySelectorAll('img'))); 51798 51799 title_TL.add(_gsap.TweenMax.staggerTo(words, 0.6, { 51800 y: 0, 51801 ease: Power2.easeOut 51802 }, 0.05)); 51803 51804 if ((0, _utils.is_in_view)(el, 750)) { 51805 title_TL.play(); 51806 } 51807 } 51808 }, { 51809 key: '_appear_header', 51810 value: function _appear_header(el) { 51811 51812 var header_tl = new _gsap.TimelineMax(this.timeline_options); 51813 51814 var words = el.querySelectorAll('.page_header_title_word'); 51815 var backgrounds = [el].concat(_toConsumableArray(document.querySelectorAll('.page_header_donut_inner'))); 51816 51817 header_tl.add(_gsap.TweenMax.staggerTo(words, 0.6, { 51818 y: 0, 51819 ease: Power2.easeOut, 51820 delay: 0.2 51821 }, 0.05)); 51822 51823 header_tl.add(_gsap.TweenMax.to(backgrounds, 0.6, { 51824 backgroundPosition: '50% 60%', 51825 ease: Power2.easeOut, 51826 delay: 0.2 51827 }), 0); 51828 51829 if ((0, _utils.is_in_view)(el, 750)) { 51830 header_tl.play(); 51831 } 51832 } 51833 }, { 51834 key: '_appear_mask', 51835 value: function _appear_mask(el) { 51836 51837 var mask_tl = new _gsap.TimelineMax(this.timeline_options); 51838 51839 mask_tl.add(_gsap.TweenMax.to(el, 0.6, { 51840 scaleX: 0, 51841 ease: Expo.easeInOut 51842 })); 51843 51844 if ((0, _utils.is_in_view)(el, 750)) { 51845 mask_tl.play(); 51846 } 51847 } 51848 }, { 51849 key: '_appear_text', 51850 value: function _appear_text(el) { 51851 51852 var text_tl = new _gsap.TimelineMax(this.timeline_options); 51853 51854 text_tl.add(_gsap.TweenMax.to(el, 1, { 51855 opacity: 1, 51856 y: 0, 51857 ease: Power2.easeInOut 51858 })); 51859 51860 if ((0, _utils.is_in_view)(el, 800)) { 51861 text_tl.play(); 51862 } 51863 } 51864 }, { 51865 key: '_appear_number', 51866 value: function _appear_number(el) { 51867 51868 var number_tl = new _gsap.TimelineMax(this.timeline_options); 51869 51870 var text = el.innerHTML; 51871 var last_character = text.substr(-1, 1); 51872 var unit = ''; 51873 51874 if (last_character === '%') { 51875 unit = last_character; 51876 } 51877 51878 var final_number = el.getAttribute('data-number'); 51879 var counter = { value: 0 }; 51880 51881 var update_value = function update_value() { 51882 el.innerHTML = counter.value + unit; 51883 }; 51884 51885 number_tl.add(_gsap.TweenMax.to(counter, 1.5, { 51886 value: '+=' + final_number, 51887 roundProps: "value", 51888 onUpdate: update_value, 51889 ease: Linear.easeNone 51890 })); 51891 51892 if ((0, _utils.is_in_view)(el, 750)) { 51893 setTimeout(function () { 51894 number_tl.play(); 51895 }, 500); 51896 } 51897 } 51898 }, { 51899 key: '_appear_letter', 51900 value: function _appear_letter(el) { 51901 51902 var letter_tl = new _gsap.TimelineMax(this.timeline_options); 51903 51904 letter_tl.add(_gsap.TweenMax.staggerTo(el.querySelectorAll('.content_character'), 0.6, { 51905 y: 0, 51906 ease: Expo.easeOut 51907 }
51907, 0.05)); 51908 51909 if ((0, _utils.is_in_view)(el, 750)) { 51910 letter_tl.play(); 51911 } 51912 } 51913 }]); 51914 51915 return ApparitionManager; 51916}(); 51917 51918exports.default = ApparitionManager; 51919 51920/***/ }), 51921/* 161 */ 51922/***/ (function(module, exports, __webpack_require__) { 51923 51924"use strict"; 51925 51926 51927Object.defineProperty(exports, "__esModule", { 51928 value: true 51929}); 51930 51931var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 51932 51933var _gsap = __webpack_require__(8); 51934 51935var _utils = __webpack_require__(6); 51936 51937function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 51938 51939var Graph = function () { 51940 function Graph(options) { 51941 _classCallCheck(this, Graph); 51942 51943 this.options = options || {}; 51944 this.container = this.options.container; 51945 this.bars = this.options.bars; 51946 this.value = this.options.value; 51947 this.init(); 51948 } 51949 51950 _createClass(Graph, [{ 51951 key: 'init', 51952 value: function init() { 51953 51954 this.is_playing = false; 51955 this.animated = false; 51956 51957 this.apply_values(); 51958 this.init_events(); 51959 } 51960 }, { 51961 key: 'apply_values', 51962 value: function apply_values() { 51963 51964 var value = parseInt(this.value); 51965 51966 if (this.value > 100 || this.value < 0) { 51967 throw new Error('Please, choose a value between 0 and 100. It\'s supposed to represent percentage'); 51968 } else if (this.bars.length !== 2) { 51969 throw new Error('This graph only works for 2 bars, be sure to have the correct number or "bar item"'); 51970 } 51971 51972 var main_value = value; 51973 var sub_value = 100 - value; 51974 51975 this.bars[0].setAttribute('data-value', main_value); 51976 this.bars[1].setAttribute('data-value', sub_value); 51977 } 51978 }, { 51979 key: 'init_events', 51980 value: function init_events() { 51981 var _this = this; 51982 51983 window.addEventListener('scroll', function () { 51984 if ((0, _utils.is_in_view)(_this.container) && !_this.animated && !_this.is_playing) { 51985 _this.animate_graph(); 51986 } 51987 }); 51988 } 51989 }, { 51990 key: 'animate_graph', 51991 value: function animate_graph() { 51992 var _this2 = this; 51993 51994 this.is_playing = true; 51995 51996 this.bars.forEach(function (bar) { 51997 51998 var value = bar.getAttribute('data-value'); 51999 var $text = bar.querySelector('.graph_bar_text'); 52000 var counter = { value: 0 }; 52001 52002 _gsap.TweenMax.to(bar, 2, { 52003 height: value + '%', 52004 ease: Expo.easeInOut 52005 }); 52006 52007 var update_value = function update_value() { 52008 $text.innerHTML = counter.value + '%'; 52009 }; 52010 52011 _gsap.TweenMax.to(counter, 2, { 52012 value: '+=' + value, 52013 roundProps: "value", 52014 onUpdate: update_value, 52015 onComplete: function onComplete() { 52016 _this2.animated = true; 52017 }, 52018 ease: Expo.easeInOut 52019 }); 52020 }); 52021 } 52022 }]); 52023 52024 return Graph; 52025}(); 52026 52027exports.default = Graph; 52028 52029/***/ }), 52030/* 162 */ 52031/***/ (function(module, exports, __webpack_require__) { 52032 52033"use strict"; 52034 52035 52036Object.defineProperty(exports, "__esModule", { 52037 value: true 52038}); 52039 52040var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 52041 52042var _gsap = __webpack_require__(8); 52043 52044function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 52045 52046__webpack_require__(14); 52047 52048var Homeslider = function () { 52049 function Homeslider(options) { 52050 _classCallCheck(this, Homeslider); 52051 52052 this.options = options || {}; 52053 this.container = this.options.container; 52054 this.slides = this.options.slides; 52055 this.titles = this.options.titles; 52056 this.dots = this.options.dots || null; 52057 this.interval = this.options.interval || 8000; 52058 this.loading_bar = this.options.loading_bar; 52059 this.init(); 52060 } 52061 52062 _createClass(Homeslider, [{ 52063 key: 'init',
52064 value: function init() { 52065 var _this = this; 52066 52067 this.transitionTL = new _gsap.TimelineMax({ 52068 paused: true, 52069 autoRemoveChildren: true, 52070 onComplete: function onComplete() { 52071 _this.transitionTL.clear(); 52072 } 52073 }); 52074 52075 this.active_index = 0; 52076 this.active_slide = this.slides[this.active_index]; 52077 this.is_playing = false; 52078 this.split_titles(); 52079 this.init_events(); 52080 this.start_loop(); 52081 } 52082 }, { 52083 key: 'split_titles', 52084 value: function split_titles() { 52085 52086 this.titles.forEach(function (title) { 52087 52088 var splitted = new SplitText(title, { 52089 type: 'words, lines', 52090 wordsClass: 'home_slider_slide_title_word', 52091 linesClass: 'home_slider_slide_title_line' 52092 }); 52093 }); 52094 } 52095 }, { 52096 key: 'init_events', 52097 value: function init_events() { 52098 var _this2 = this; 52099 52100 this.dots.forEach(function (dot) { 52101 52102 dot.addEventListener('click', function (event) { 52103 52104 if (_this2.is_playing) return; 52105 52106 _this2.reset_loop(); 52107 var dot_index = event.target.getAttribute('data-slide'); 52108 _this2.go_to(dot_index); 52109 }); 52110 }); 52111 } 52112 }, { 52113 key: 'loop', 52114 value: function loop() { 52115 52116 var index = this.active_index; 52117 52118 _gsap.TweenMax.set(this.loading_bar, { scaleX: 0 }); 52119 _gsap.TweenMax.to(this.loading_bar, this.interval / 1000, { scaleX: 1, ease: Linear.easeNone }); 52120 52121 if (index + 1 === this.slides.length) { 52122 index = 0; 52123 } else { 52124 index++; 52125 } 52126 52127 this.go_to(index); 52128 } 52129 }, { 52130 key: 'start_loop', 52131 value: function start_loop() { 52132 _gsap.TweenMax.set(this.loading_bar, { scaleX: 0 }); 52133 _gsap.TweenMax.to(this.loading_bar, this.interval / 1000, { scaleX: 1, ease: Linear.easeNone }); 52134 this.loop_interval = setInterval(this.loop.bind(this), this.interval); 52135 } 52136 }, { 52137 key: 'reset_loop', 52138 value: function reset_loop() { 52139 clearInterval(this.loop_interval); 52140 this.start_loop(); 52141 } 52142 }, { 52143 key: 'go_to', 52144 value: function go_to(slide) { 52145 var _this3 = this; 52146 52147 if (parseInt(slide) === this.active_index) return; 52148 52149 this.is_playing = true; 52150 52151 var previous_slide = this.active_slide; 52152 52153 this.active_index = parseInt(slide); 52154 this.active_slide = this.slides[this.active_index]; 52155 52156 this.dots.forEach(function (dot) { 52157 return dot.classList.remove('active'); 52158 }); 52159 this.dots[this.active_index].classList.add('active'); 52160 52161 var previous_words = previous_slide.querySelectorAll('.home_slider_slide_title_word'); 52162 var words = this.active_slide.querySelectorAll('.home_slider_slide_title_word'); 52163 52164 this.transitionTL.add(_gsap.TweenMax.set([this.active_slide, this.active_slide.querySelectorAll('.home_slider_slide_donut_inner')], { 52165 backgroundPosition: '50% 50%' 52166 })); 52167 52168 this.transitionTL.add(_gsap.TweenMax.set(words, { 52169 y: '100%' 52170 })); 52171 52172 this.transitionTL.add(_gsap.TweenMax.staggerTo(previous_words, 1, { 52173 y: '-100%', 52174 ease: Expo.easeInOut 52175 }, 0.05), 0); 52176 52177 this.transitionTL.add(_gsap.TweenMax.to([previous_slide, previous_slide.querySelectorAll('.home_slider_slide_donut_inner')], 1, { 52178 backgroundPosition: '50% 50%', 52179 ease: Expo.easeInOut 52180 }), 0); 52181 52182 this.transitionTL.add(_gsap.TweenMax.to(previous_slide, .6, { 52183 opacity: 0 52184 }), 0.5); 52185 52186 this.transitionTL.add(_gsap.TweenMax.to(this.active_slide, .6, { 52187 opacity: 1 52188 }), 0.5); 52189 52190 this.transitionTL.add(_gsap.TweenMax.staggerTo(words, 1, { 52191 y: '0%', 52192 ease: Expo.easeInOut 52193 }, 0.05), 1); 52194 52195 this.transitionTL.add(_gsap.TweenMax.to([this.active_slide, this.active_slide.querySelectorAll('.home_slider_slide_donut_inner')], 1, { 52196 backgroundPosition: '50% 60%', 52197 ease: Expo.easeInOut 52198 }), 1); 52199 52200 this.transitionTL.play().call(function () { 52201 _gsap.TweenMax.set([previous_slide, previous_slide.querySelectorAll('.home_slider_slide_donut_inner')], { 52202 backgroundPosition: '50% 60%' 52203 }); 52204 _this3.is_playing = false;
52205 }); 52206 } 52207 }]); 52208 52209 return Homeslider; 52210}(); 52211 52212exports.default = Homeslider; 52213 52214/***/ }), 52215/* 163 */ 52216/***/ (function(module, exports, __webpack_require__) { 52217 52218"use strict"; 52219/* WEBPACK VAR INJECTION */(function($) { 52220 52221Object.defineProperty(exports, "__esModule", { 52222 value: true 52223}); 52224 52225var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 52226 52227var _navigation = __webpack_require__(13); 52228 52229var _navigation2 = _interopRequireDefault(_navigation); 52230 52231function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 52232 52233function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 52234 52235var Search = function () { 52236 function Search(options) { 52237 _classCallCheck(this, Search); 52238 52239 this.options = options; 52240 // this.container = this.options.container 52241 this.form = document.querySelector('#search-form'); 52242 this.open_btns = document.querySelectorAll('[data-icon="search"]'); 52243 this.input_container = document.querySelector('.header_nav_search'); 52244 this.input = document.querySelector('.header_nav_search_input'); 52245 this.submit_btn = document.querySelector('.header_nav_search_button'); 52246 this.spinner = document.querySelector('.header_nav_search_spinner'); 52247 this.result_container = document.querySelector('.header_nav_search_result'); 52248 52249 this.init(); 52250 } 52251 52252 _createClass(Search, [{ 52253 key: 'init', 52254 value: function init() { 52255 52256 this.init_events(); 52257 52258 this.debounce_timer = null; 52259 } 52260 }, { 52261 key: 'init_events', 52262 value: function init_events() { 52263 var _this = this; 52264 52265 this.open_btns.forEach(function (open_btn) { 52266 open_btn.addEventListener('click', function () { 52267 52268 _navigation2.default.open(); 52269 52270 setTimeout(function () { 52271 document.getElementById('search-input').focus(); 52272 }, 100); 52273 52274 _this.display_results(); 52275 }); 52276 }); 52277 52278 this.form.addEventListener('submit', function (e) { 52279 e.preventDefault(); 52280 clearInterval(_this.debounce_timer); 52281 _this.send_request(_this.input.value); 52282 return false; 52283 }); 52284 52285 this.input_container.addEventListener('scroll', function () { 52286 return true; 52287 }); 52288 52289 this.input.addEventListener('keyup', function () { 52290 52291 clearInterval(_this.debounce_timer); 52292 52293 var timeout = 0; 52294 52295 if (_this.input.value === '') { 52296 // this.hide_results() 52297 } else { 52298 _this.display_results(); 52299 } 52300 52301 _this.debounce_timer = setInterval(function () { 52302 52303 if (timeout > 1) { 52304 _this.send_request(_this.input.value); 52305 clearInterval(_this.debounce_timer); 52306 } 52307 timeout++; 52308 }, 400); 52309 }); 52310 } 52311 }, { 52312 key: 'send_request', 52313 value: function send_request(value) { 52314 var _this2 = this; 52315 52316 document.querySelector('.header_nav_search_result_container').classList.add('loading'); 52317 52318 setTimeout(function () { 52319 $.post({ 52320 url: walor_ajax.url, 52321 data: { 52322 action: 'walor_search_results', 52323 query: value 52324 }, 52325 success: function success(response) { 52326 var response_html = response; 52327 52328 if (_this2.input.value === '') { 52329 response_html = ''; 52330 } 52331 52332 _this2.result_container.innerHTML = response_html.slice(0, -1); // Remove last trailing '0' comes from nowhere 52333 _this2.input_container.classList.add('translated'); 52334 document.querySelector('.header_nav_search_result_container').classList.remove('loading'); 52335 }, 52336 error: function error(response) { 52337 document.querySelector('.header_nav_search_result_container').classList.remove('loading'); 52338 } 52339 }); 52340 }, 1000); 52341 52342 return false;
52343 } 52344 }, { 52345 key: 'display_results', 52346 value: function display_results() { 52347 52348 document.querySelector('.header_nav_search_result_container').classList.add('open'); 52349 document.querySelector('body').classList.add('results-displayed'); 52350 } 52351 }, { 52352 key: 'hide_results', 52353 value: function hide_results() { 52354 52355 document.querySelector('.header_nav_search_result_container').classList.remove('open'); 52356 document.querySelector('body').classList.remove('results-displayed'); 52357 } 52358 }]); 52359 52360 return Search; 52361}(); 52362 52363exports.default = Search; 52364/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4))) 52365 52366/***/ }), 52367/* 164 */ 52368/***/ (function(module, exports, __webpack_require__) { 52369 52370"use strict"; 52371/* WEBPACK VAR INJECTION */(function($) { 52372 52373var _utils = __webpack_require__(6); 52374 52375document.addEventListener('DOMContentLoaded', function () { 52376 52377 var container_404 = $('.content-404'); 52378 52379 if (container_404.length) { 52380 52381 var elements_count = 50; 52382 52383 for (var i = 0; i < elements_count; i++) { 52384 52385 var el = $(container_404).append('<span class="decorator-404">+</span>'); 52386 52387 // 52388 // el.css({ 52389 // 52390 // fontSize: fontSize, 52391 // left: x_pos, 52392 // top: y_pos 52393 // 52394 // }) 52395 } 52396 52397 $('.decorator-404').each(function (i, e) { 52398 52399 var fontSize = (0, _utils.get_random_int)(10, 20); 52400 var x_pos = (0, _utils.get_random_int)(0, 100); 52401 var y_pos = (0, _utils.get_random_int)(0, 100); 52402 52403 $(e).css({ 52404 fontSize: fontSize, 52405 left: x_pos + '%', 52406 top: y_pos + '%' 52407 }); 52408 }); 52409 } 52410}); 52411/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4))) 52412 52413/***/ }), 52414/* 165 */ 52415/***/ (function(module, exports, __webpack_require__) { 52416 52417"use strict"; 52418 52419 52420var _apparitionManager = __webpack_require__(160); 52421 52422var _apparitionManager2 = _interopRequireDefault(_apparitionManager); 52423 52424function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 52425 52426function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } 52427 52428var titles = document.querySelectorAll('.content_title'); 52429var subtitles = document.querySelectorAll('.content_subtitle'); 52430var appear_titles = document.querySelectorAll('.appear--title'); 52431 52432var all_titles = [].concat(_toConsumableArray(titles), _toConsumableArray(subtitles), _toConsumableArray(appear_titles)); 52433
52434all_titles.forEach(function (title) { 52435 new _apparitionManager2.default({ 52436 type: 'title', 52437 element: title 52438 }); 52439}); 52440 52441if (!document.querySelector('.home')) { 52442 var page_header = document.querySelector('.page_header'); 52443 52444 new _apparitionManager2.default({ 52445 type: 'header', 52446 element: page_header 52447 }); 52448} 52449 52450var image_masks = document.querySelectorAll('.image_mask'); 52451 52452image_masks.forEach(function (mask) { 52453 new _apparitionManager2.default({ 52454 type: 'mask', 52455 element: mask 52456 }); 52457}); 52458 52459var texts = document.querySelectorAll('.appear--text'); 52460 52461texts.forEach(function (text) { 52462 new _apparitionManager2.default({ 52463 type: 'text', 52464 element: text 52465 }); 52466}); 52467 52468var numbers = document.querySelectorAll('.key-figure_number'); 52469 52470numbers.forEach(function (number) { 52471 new _apparitionManager2.default({ 52472 type: 'number', 52473 element: number 52474 }); 52475}); 52476 52477var letters = document.querySelectorAll('.appear--letter'); 52478 52479letters.forEach(function (letter) { 52480 new _apparitionManager2.default({ 52481 type: 'letter', 52482 element: letter 52483 }); 52484}); 52485 52486/***/ }), 52487/* 166 */ 52488/***/ (function(module, exports, __webpack_require__) { 52489 52490"use strict"; 52491/* WEBPACK VAR INJECTION */(function($) { 52492 52493var _utils = __webpack_require__(6); 52494 52495var get_scroll_percent = function get_scroll_percent() { 52496 52497 var w_height = window.innerHeight; 52498 var w_scroll = window.scrollY; 52499 var doc_height = document.documentElement.scrollHeight; 52500 52501 return w_scroll / (doc_height - w_height); 52502}; 52503 52504var change_back_top_state = function change_back_top_state(el, percent) { 52505 52506 if (percent > 0.9) { 52507 el.classList.add('--end'); 52508 } else if (percent > 0.15) { 52509 el.classList.add('--visible'); 52510 el.classList.remove('--end'); 52511 } else { 52512 el.classList.remove('--visible'); 52513 el.classList.remove('--end'); 52514 } 52515}; 52516 52517document.addEventListener('DOMContentLoaded', function () { 52518 52519 var $back_to_top = document.querySelector('.footer_back-to-top'); 52520 52521 var scroll_percent = get_scroll_percent(); 52522 52523 change_back_top_state($back_to_top, scroll_percent); 52524 52525 $back_to_top.addEventListener('click', function () { 52526 52527 $('html, body').animate({ 52528 scrollTop: 0 52529 }, 1000); 52530 }); 52531 52532 window.addEventListener('resize', function () { 52533 scroll_percent = get_scroll_percent(); 52534 change_back_top_state($back_to_top, scroll_percent); 52535 }); 52536 52537 window.addEventListener('scroll', function () { 52538 scroll_percent = get_scroll_percent(); 52539 change_back_top_state($back_to_top, scroll_percent); 52540 }); 52541}); 52542/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4))) 52543 52544/***/ }), 52545/* 167 */ 52546/***/ (function(module, exports, __webpack_require__) { 52547 52548"use strict"; 52549 52550 52551var _accordion = __webpack_require__(159); 52552 52553var _accordion2 = _interopRequireDefault(_accordion); 52554 52555function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 52556 52557document.addEventListener('DOMContentLoaded', function () { 52558 52559 var certifications = document.querySelectorAll('.certification'); 52560 52561 certifications.forEach(function (certification) { 52562 52563 var walor_certification = new _accordion2.default({ 52564 container: certification, 52565 tab: certification.querySelector('.certification_tab'), 52566 content: certification.querySelector('.certification_content'), 52567 switch: certification.querySelector('.certification_switch'), 52568 switch_icon: templateURL + '/dist/images/icons/down-arrow.svg' 52569 }); 52570 }); 52571}); 52572 52573/***/ }), 52574/* 168 */ 52575/***/ (function(module, exports, __webpack_require__) { 52576 52577"use strict"; 52578/* WEBPACK VAR INJECTION */(function($) { 52579 52580__webpack_require__(155); 52581 52582document.addEventListener('DOMContentLoaded', function () { 52583 52584 var $slider = false;
52585 52586 var build = function build() { 52587 52588 $slider = $('.client_slider'); 52589 $slider.addClass('owl-carousel'); 52590 52591 $slider.owlCarousel({ 52592 items: 5, 52593 slideBy: 1, 52594 nav: true, 52595 navText: ['<img src="' + templateURL + '/dist/images/icons/thin-left-arrow.svg">', '<img src="' + templateURL + '/dist/images/icons/thin-right-arrow.svg">'], 52596 dots: false 52597 }); 52598 }; 52599 52600 var destroy = function destroy() { 52601 52602 $slider.trigger('destroy.owl.carousel'); 52603 $slider = false; 52604 $('.client_slider').removeClass('owl-carousel'); 52605 }; 52606 52607 var manage_slider = function manage_slider() { 52608 52609 var is_mobile = window.innerWidth < 1024; 52610 52611 if (is_mobile && $slider) { 52612 destroy(); 52613 } else if (!is_mobile && !$slider) { 52614 build(); 52615 } 52616 }; 52617 52618 manage_slider(); 52619 52620 window.addEventListener('resize', function () { 52621 52622 manage_slider(); 52623 }); 52624}); 52625/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4))) 52626 52627/***/ }), 52628/* 169 */ 52629/***/ (function(module, exports, __webpack_require__) { 52630 52631"use strict"; 52632 52633 52634var _navigation = __webpack_require__(13); 52635 52636var _navigation2 = _interopRequireDefault(_navigation); 52637 52638function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 52639 52640document.addEventListener('DOMContentLoaded', function () { 52641 52642 var $open_contact_btn = document.querySelector('.open-contact'); 52643 52644 $open_contact_btn.addEventListener('click', function (e) { 52645 52646 e.preventDefault(); 52647 52648 _navigation2.default.open(); 52649 _navigation2.default.open_contact(); 52650 }); 52651}); 52652 52653/***/ }), 52654/* 170 */ 52655/***/ (function(module, exports, __webpack_require__) { 52656 52657"use strict"; 52658 52659 52660var _graph = __webpack_require__(161); 52661 52662var _graph2 = _interopRequireDefault(_graph); 52663 52664function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 52665 52666document.addEventListener('DOMContentLoaded', function () { 52667 52668 var graphs = document.querySelectorAll('.graph_item'); 52669 52670 graphs.forEach(function (graph) { 52671 new _graph2.default({ 52672 container: graph, 52673 bars: graph.querySelectorAll('.graph_bar'), 52674 value: graph.getAttribute('data-value') 52675 }); 52676 }); 52677}); 52678 52679/***/ }), 52680/* 171 */ 52681/***/ (function(module, exports, __webpack_require__) { 52682 52683"use strict"; 52684/* WEBPACK VAR INJECTION */(function(global) { 52685 52686var _homeslider = __webpack_require__(162); 52687 52688var _homeslider2 = _interopRequireDefault(_homeslider); 52689 52690var _search = __webpack_require__(163); 52691 52692var _search2 = _interopRequireDefault(_search); 52693 52694function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 52695 52696document.addEventListener('DOMContentLoaded', function () { 52697 52698 if (document.querySelector('.home_slider')) { 52699 52700 var home_slider = new _homeslider2.default({ 52701 container: document.querySelector('.home_slider'), 52702 slides: document.querySelectorAll('.home_slider_slide'), 52703 titles: document.querySelectorAll('.home_slider_slide_title'), 52704 dots: document.querySelectorAll('.home_slider_dot'), 52705 loading_bar: document.querySelector('.home_slider_loading-bar') 52706 }); 52707 52708 global.slider = home_slider; 52709 } 52710 52711 var $prevented = document.querySelectorAll('.preventDefault'); 52712 52713 $prevented.forEach(function (prevented) { 52714 prevented.addEventListener('click', function (e) { 52715 e.preventDefault(); 52716 }); 52717 }); 52718 52719 var search = new _search2.default(); 52720}); 52721/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(12))) 52722 52723/***/ }), 52724/* 172 */ 52725/***/ (function(module, exports, __webpack_require__) { 52726 52727"use strict"; 52728/* WEBPACK VAR INJECTION */(function($) { 52729 52730var _googleMaps = __webpack_require__(234); 52731 52732var _googleMaps2 = _interopRequireDefault(_googleMaps); 52733 52734var _mapstyles = __webpack_require__(181); 52735 52736var _mapplaces = __webpack_require__(180); 52737 52738var _translations = __webpack_require__(19); 52739 52740var _utils = __webpack_require__(6); 52741 52742function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 52743 52744var geocoder = __webpack_require__(232); 52745 52746_googleMaps2.default.KEY = 'AIzaSyBdfL3ciXW94h6r5m4nJpRyeplgdbgZh_c'; 52747_googleMaps2.default.LANGUAGE = 'fr'; 52748_googleMaps2.default.VERSION = '3.31'; 52749 52750var geo = geocoder({ 52751 key: 'AIzaSyBdfL3ciXW94h6r5m4nJpRyeplgdbgZh_c' 52752}); 52753 52754var marker, 52755 map, 52756 infoBox, 52757 markers = []; 52758 52759$(document).ready(function () { 52760 52761 var language = (0, _utils.get_language)(); 52762 52763 var $map = $('#map'); 52764 52765 var $anchor = $('#' + _translations.TRANSLATIONS.map_anchor[language]); 52766 52767 if ($anchor.length && window.location.href.substring(window.location.href.indexOf("#") + 1) === _translations.TRANSLATIONS.map_anchor[language]) { 52768 52769 setTimeout(function () { 52770 52771 $('html, body').animate({ 52772 scrollTop: $anchor.offset().top - 150 52773 }, 800); 52774 }, 500); 52775 } 52776 52777 // // @Google map initialization 52778 if ($map.length) { 52779 52780 var address = $map.data('address'); 52781 var center = { lat: 45.9328418, lng: 4.1002923 }; 52782 52783 var initial_zoom = 0; 52784 52785 if ($(window).width() < 768) { 52786 initial_zoom = 1; 52787 } else if ($(window).width() < 1366) { 52788 initial_zoom = 2; 52789 } else { 52790 initial_zoom = 3; 52791 } 52792 52793 // new google.maps.LatLng(place.location.lat, place.location.lng) 52794 var zoom = $map.data('zoom') ? parseInt($map.data('zoom')) : initial_zoom; 52795 52796 _googleMaps2.default.load(function (google) { 52797 52798 var markerLabel = __webpack_require__(182); 52799 52800 var marker, 52801 markers = []; 52802 52803 var map = new google.maps.Map(document.getElementById('map'), { 52804 center: center, 52805 zoom: zoom, 52806 scrollwheel: false, 52807 panControl: false, 52808 mapTypeControl: false, 52809 disableDefaultUI: false, 52810 draggable: true 52811 }); 52812 52813 var styles = _mapstyles.map_styles; 52814 var $sites = document.querySelectorAll('.site'); 52815 52816 if ($sites.length > 0) {
52817 $sites.forEach(function (site) { 52818 52819 var name = site.getAttribute('data-name'); 52820 var address = site.getAttribute('data-address'); 52821 var id = site.getAttribute('data-id'); 52822 52823 geo.find(address, function (err, res) { 52824 52825 if (err !== null) { 52826 return; 52827 } 52828 52829 var response = res[0]; 52830 var marker = null; 52831 52832 var location = response.location; 52833 52834 marker = new markerLabel.MarkerWithLabel({ 52835 id: id, 52836 position: new google.maps.LatLng(location.lat, location.lng), 52837 icon: { 52838 path: google.maps.SymbolPath.CIRCLE, 52839 scale: 0 //tamaño 0 52840 }, 52841 map: map, 52842 labelAnchor: new google.maps.Point(10, 10), 52843 labelClass: "custom-marker", // the CSS class for the label 52844 labelContent: '<div class="custom-marker_name">' + name + '</div>' 52845 }); 52846 52847 google.maps.event.addListener(marker, 'mouseover', function (e) { 52848 52849 this.label.labelDiv_.classList.add('hover'); 52850 }); 52851 52852 google.maps.event.addListener(marker, 'mouseout', function (e) { 52853 52854 this.label.labelDiv_.classList.remove('hover'); 52855 }); 52856 52857 google.maps.event.addListener(marker, 'click', function (e) { 52858 var id = this.id; 52859 var selected_site = $('.site[data-id="' + id + '"]'); 52860 52861 $('.site_container').addClass('site-selected'); 52862 $('.site').removeClass('selected'); 52863 selected_site.addClass('selected'); 52864 52865 $('html, body').animate({ 52866 scrollTop: selected_site.offset().top - 120 52867 }, 800); 52868 }); 52869 52870 marker.setMap(map); 52871 }); 52872 52873 $(document).on('click', function (event) { 52874 if (!$(event.target).closest('.site.selected').length) { 52875 $('.site_container').removeClass('site-selected'); 52876 $('.site').removeClass('selected'); 52877 } 52878 }); 52879 }); 52880 } 52881 52882 if (address) { 52883 52884 geo.find(address, function (err, res) { 52885 52886 if (err !== null) { 52887 return; 52888 } 52889 52890 var location = res[0].location; 52891 52892 center = { lat: location.lat, lng: location.lng }; 52893 52894 map.setCenter(center); 52895 52896 var marker = null; 52897 52898 marker = new markerLabel.MarkerWithLabel({ 52899 id: 1, 52900 position: new google.maps.LatLng(center.lat, center.lng), 52901 icon: { 52902 path: google.maps.SymbolPath.CIRCLE, 52903 scale: 0 //tamaño 0 52904 }, 52905 map: map, 52906 labelAnchor: new google.maps.Point(10, 10), 52907 labelClass: "custom-marker" // the CSS class for the label 52908 }); 52909 52910 if (document.querySelector('body').classList.contains('single-site')) { 52911 52912 google.maps.event.addListener(marker, 'click', function (e) { 52913 52914 window.open('https://www.google.fr/maps/search/' + address); 52915 }); 52916 } 52917 52918 marker.setMap(map); 52919 }); 52920 } 52921 52922 map.setOptions({ styles: styles });
52923 // marker.setMap(map); 52924 }); 52925 } 52926}); 52927/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4))) 52928 52929/***/ }), 52930/* 173 */ 52931/***/ (function(module, exports, __webpack_require__) { 52932 52933"use strict"; 52934 52935 52936var _navigation = __webpack_require__(13); 52937 52938var _navigation2 = _interopRequireDefault(_navigation); 52939 52940function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 52941 52942/***/ }), 52943/* 174 */ 52944/***/ (function(module, exports, __webpack_require__) { 52945 52946"use strict"; 52947/* WEBPACK VAR INJECTION */(function($) { 52948 52949document.addEventListener('DOMContentLoaded', function () { 52950 52951 if (document.querySelector('.page-template-template-actualites') && window.location.hash.length) { 52952 52953 $('html, body').animate({ 52954 scrollTop: $(window.location.hash).offset().top - 120 52955 }, 800); 52956 } 52957}); 52958/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4))) 52959 52960/***/ }), 52961/* 175 */ 52962/***/ (function(module, exports, __webpack_require__) { 52963 52964"use strict"; 52965/* WEBPACK VAR INJECTION */(function($) { 52966 52967var _utils = __webpack_require__(6); 52968 52969document.addEventListener('DOMContentLoaded', function () { 52970 52971 var negative_offset = get_negative_offset(); 52972 52973 var anchors = document.querySelectorAll('.product-anchor'); 52974 52975 anchors.forEach(function (anchor) { 52976 52977 var data = anchor.getAttribute('data-anchor'); 52978 52979 anchor.addEventListener('click', function () { 52980 52981 var to = $('.product-family[data-anchor="' + data + '"]').offset().top - negative_offset; 52982 52983 $('html, body').animate({ 52984 scrollTop: to 52985 }, 1000); 52986 }); 52987 }); 52988 52989 window.addEventListener('resize', function () { 52990 52991 negative_offset = get_negative_offset(); 52992 }); 52993}); 52994 52995var get_negative_offset = function get_negative_offset() { 52996 52997 var offset = null; 52998 52999 if (window.innerWidth < 1024) { 53000 offset = 100; 53001 } else { 53002 offset = 150; 53003 } 53004 53005 return offset; 53006}; 53007/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4))) 53008 53009/***/ }), 53010/* 176 */ 53011/***/ (function(module, exports, __webpack_require__) { 53012 53013"use strict"; 53014/* WEBPACK VAR INJECTION */(function($) { 53015 53016__webpack_require__(155); 53017 53018document.addEventListener('DOMContentLoaded', function () { 53019 53020 var $testimonial_sliders = $('.testimonial-slider'); 53021 53022 $testimonial_sliders.each(function (i, e) { 53023 53024 var $slides = $(e).find('.testimonial'); 53025 var slider_has_padding = false; 53026 53027 $slides.each(function (i, e) { 53028 53029 if ($(e).hasClass('--rounded-picture')) { 53030 slider_has_padding = true; 53031 } 53032 }); 53033 53034 if (!slider_has_padding) { 53035 $(e).addClass('no-padding'); 53036 } 53037 53038 $(e).owlCarousel({ 53039 items: 1, 53040 dots: false, 53041 nav: true, 53042 loop: $slides.length > 1, 53043 autoplay: $slides.length > 1 && $(window).width() >= 1024, 53044 autoplayTimeout: 15000, 53045 autoplayHoverPause: true, 53046 autoHeight: true, 53047 navText: ['<div><img src="' + templateURL + '/dist/images/icons/left-slider-arrow.svg" alt=""></div>', '<div><img src="' + templateURL + '/dist/images/icons/right-slider-arrow.svg" alt=""></div>'] 53048 }); 53049 }); 53050}); 53051/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4))) 53052 53053/***/ }), 53054/* 177 */ 53055/***/ (function(module, exports, __webpack_require__) { 53056 53057"use strict"; 53058 53059 53060var _chart = __webpack_require__(185); 53061 53062var _chart2 = _interopRequireDefault(_chart); 53063 53064var _variables = __webpack_require__(20); 53065 53066var _utils = __webpack_require__(6); 53067 53068var _translations = __webpack_require__(19); 53069 53070function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 53071 53072document.addEventListener('DOMContentLoaded', function () { 53073 53074 var current_language = (0, _utils.get_language)(); 53075 var $turnover_chart = document.getElementById('chart-turnover'); 53076 var context = null; 53077 var easting = void 0; 53078 var northing = void 0; 53079 53080 if ($turnover_chart) { 53081 context = $turnover_chart.getContext('2d'); 53082 53083 var data_eastings = $turnover_chart.getAttribute('data-easting'); 53084 var data_northings = $turnover_chart.getAttribute('data-northing'); 53085 53086 easting = data_eastings.split(', '); 53087 northing = data_northings.split(', '); 53088 } 53089 53090 var chart_is_append = false;
53091 53092 var opt = { 53093 events: false, 53094 defaultFontSize: 16, 53095 tooltips: { 53096 enabled: false 53097 }, 53098 hover: { 53099 animationDuration: 0 53100 }, 53101 scales: { 53102 yAxes: [{ 53103 ticks: { 53104 stepSize: 10 53105 } 53106 }] 53107 }, 53108 animation: { 53109 // duration: 1, 53110 onComplete: function onComplete() { 53111 var chartInstance = this.chart; 53112 var ctx = chartInstance.ctx; 53113 ctx.font = _chart2.default.helpers.fontString(16, 'bold', 'Helvetica'); 53114 ctx.textAlign = 'center'; 53115 ctx.textBaseline = 'bottom'; 53116 53117 this.data.datasets.forEach(function (dataset, i) { 53118 var meta = chartInstance.controller.getDatasetMeta(i); 53119 meta.data.forEach(function (bar, index) { 53120 var data = dataset.data[index]; 53121 ctx.fillText(data, bar._model.x, bar._model.y - 15); 53122 }); 53123 }); 53124 } 53125 } 53126 }; 53127 53128 var append_chart = function append_chart() { 53129 53130 if (chart_is_append) return; 53131 53132 if ((0, _utils.is_in_view)(document.getElementById('chart-turnover'))) { 53133 chart_is_append = true; 53134 53135 setTimeout(function () { 53136 var chart = new _chart2.default(context, { 53137 type: 'line', 53138 data: { 53139 labels: easting, 53140 datasets: [{ 53141 label: _translations.TRANSLATIONS.turnover[current_language], 53142 data: northing, 53143 backgroundColor: _variables.COLORS.blue, 53144 borderColor: _variables.COLORS.blue, 53145 pointBorderWidth: 10, 53146 fill: false 53147 }] 53148 }, 53149 options: opt 53150 }); 53151 }, 250); 53152 } 53153 }; 53154 53155 window.addEventListener('scroll', function () { 53156 if (document.getElementById('chart-turnover')) { 53157 append_chart(); 53158 } 53159 }); 53160}); 53161 53162/***/ }), 53163/* 178 */ 53164/***/ (function(module, exports, __webpack_require__) { 53165 53166"use strict"; 53167/* WEBPACK VAR INJECTION */(function(global) {var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__; 53168 53169/*! 53170 * VERSION: 0.1.4 53171 * DATE: 2017-06-19 53172 * UPDATES AND DOCS AT: http://greensock.com 53173 * 53174 * @license Copyright (c) 2008-2017, GreenSock. All rights reserved. 53175 * DrawSVGPlugin is a Club GreenSock membership benefit; You must have a valid membership to use 53176 * this code without violating the terms of use. Visit http://greensock.com/club/ to sign up or get more details. 53177 * This work is subject to the software agreement that was issued with your membership. 53178 * 53179 * @author: Jack Doyle, [email protected] 53180 */ 53181var _gsScope = typeof module !== "undefined" && module.exports && typeof global !== "undefined" ? global : undefined || window; //helps ensure compatibility with AMD/RequireJS and CommonJS/Node 53182(_gsScope._gsQueue || (_gsScope._gsQueue = [])).push(function () { 53183 53184 "use strict"; 53185 53186 var _doc = _gsScope.document, 53187 _getComputedStyle = _doc.defaultView ? _doc.defaultView.getComputedStyle : function () {}, 53188 _numbersExp = /(?:(-|-=|\+=)?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/ig, 53189 _isEdge = ((_gsScope.navigator || {}).userAgent || "").indexOf("Edge") !== -1, 53190 //Microsoft Edge has a bug that causes it not to redraw the path correctly if the stroke-linecap is anything other than "butt" (like "round") and it doesn't match the stroke-linejoin. A way to trigger it is to change the stroke-miterlimit, so we'll only do that if/when we have to (to maximize performance) 53191 DrawSVGPlugin; 53192 53193 function getDistance(x1, y1, x2, y2, scaleX, scaleY) { 53194 x2 = (parseFloat(x2 || 0) - parseFloat(x1 || 0)) * scaleX; 53195 y2 = (parseFloat(y2 || 0) - parseFloat(y1 || 0)) * scaleY; 53196 return Math.sqrt(x2 * x2 + y2 * y2); 53197 } 53198 53199 function unwrap(element) { 53200 if (typeof element === "string" || !element.nodeType) { 53201 element = _gsScope.TweenLite.selector(element); 53202 if (element.length) { 53203 element = element[0]; 53204 } 53205 } 53206 return element; 53207 } 53208 53209 //accepts values like "100%" or "20% 80%" or "20 50" and parses it into an absolute start and end position on the line/stroke based on its length. Returns an an array with the start and end values, like [0, 243] 53210 function parse(value, length, defaultStart) { 53211 var i = value.indexOf(" "), 53212 s, 53213 e; 53214 if (i === -1) { 53215 s = defaultStart !== undefined ? defaultStart + "" : value; 53216 e = value; 53217 } else { 53218 s = value.substr(0, i); 53219 e = value.substr(i + 1); 53220 } 53221 s = s.indexOf("%") !== -1 ? parseFloat(s) / 100 * length : parseFloat(s); 53222 e = e.indexOf("%") !== -1 ? parseFloat(e) / 100 * length : parseFloat(e); 53223 return s > e ? [e, s] : [s, e]; 53224 } 53225 53226 function getLength(element) { 53227 if (!element) { 53228 return 0; 53229 } 53230 element = unwrap(element); 53231 var type = element.tagName.toLowerCase(), 53232 scaleX = 1, 53233 scaleY = 1, 53234 length, 53235 bbox, 53236 points, 53237 prevPoint, 53238 i, 53239 rx, 53240 ry; 53241 if (element.getAttribute("vector-effect") === "non-scaling-stroke") { 53242 //non-scaling-stroke basically scales the shape and then strokes it at the screen-level (after transforms), thus we need to adjust the length accordingly. 53243 scaleY = element.getScreenCTM(); 53244 scaleX = scaleY.a; 53245 scaleY = scaleY.d; 53246 } 53247 try { 53248 //IE bug: calling <path>.getTotalLength() locks the repaint area of the stroke to whatever its current dimensions are on that frame/tick. To work around that, we must call getBBox() to force IE to recalculate things. 53249 bbox = element.getBBox(); //solely for fixing bug in IE - we don't actually use the bbox. 53250 } catch (e) { 53251 //firefox has a bug that throws an error if the element isn't visible. 53252 } 53253 if ((!bbox || !bbox.width && !bbox.height) && (type === "rect" || type === "circle" || type === "ellipse")) { 53254 //if the element isn't visible, try to discern width/height using its attributes. 53255 bbox = { 53256 width: parseFloat(element.getAttribute(type === "rect" ? "width" : type === "circle" ? "r" : "rx")), 53257 height: parseFloat(element.getAttribute(type === "rect" ? "height" : type === "circle" ? "r" : "ry")) 53258 }; 53259 if (type !== "rect") { 53260 bbox.width *= 2; 53261 bbox.height *= 2; 53262 } 53263 } 53264 if (type === "path") { 53265 prevPoint = element.style.strokeDasharray; 53266 element.style.strokeDasharray = "none"; 53267 length = element.getTotalLength() || 0; 53268 if (scaleX !== scaleY) { 53269 console.log("Warning: <path> length cannot be measured accurately when vector-effect is non-scaling-stroke and the element isn't proportionally scaled."); 53270 }
53271 length *= (scaleX + scaleY) / 2; 53272 element.style.strokeDasharray = prevPoint; 53273 } else if (type === "rect") { 53274 length = bbox.width * 2 * scaleX + bbox.height * 2 * scaleY; 53275 } else if (type === "line") { 53276 length = getDistance(element.getAttribute("x1"), element.getAttribute("y1"), element.getAttribute("x2"), element.getAttribute("y2"), scaleX, scaleY); 53277 } else if (type === "polyline" || type === "polygon") { 53278 points = element.getAttribute("points").match(_numbersExp) || []; 53279 if (type === "polygon") { 53280 points.push(points[0], points[1]); 53281 } 53282 length = 0; 53283 for (i = 2; i < points.length; i += 2) { 53284 length += getDistance(points[i - 2], points[i - 1], points[i], points[i + 1], scaleX, scaleY) || 0; 53285 } 53286 } else if (type === "circle" || type === "ellipse") { 53287 rx = bbox.width / 2 * scaleX; 53288 ry = bbox.height / 2 * scaleY; 53289 length = Math.PI * (3 * (rx + ry) - Math.sqrt((3 * rx + ry) * (rx + 3 * ry))); 53290 } 53291 return length || 0; 53292 } 53293 53294 function getPosition(element, length) { 53295 if (!element) { 53296 return [0, 0]; 53297 } 53298 element = unwrap(element); 53299 length = length || getLength(element) + 1; 53300 var cs = _getComputedStyle(element), 53301 dash = cs.strokeDasharray || "", 53302 offset = parseFloat(cs.strokeDashoffset), 53303 i = dash.indexOf(","); 53304 if (i < 0) { 53305 i = dash.indexOf(" "); 53306 }
53307 dash = i < 0 ? length : parseFloat(dash.substr(0, i)) || 0.00001; 53308 if (dash > length) { 53309 dash = length; 53310 } 53311 return [Math.max(0, -offset), Math.max(0, dash - offset)]; 53312 } 53313 53314 DrawSVGPlugin = _gsScope._gsDefine.plugin({ 53315 propName: "drawSVG", 53316 API: 2, 53317 version: "0.1.4", 53318 global: true, 53319 overwriteProps: ["drawSVG"], 53320 53321 init: function init(target, value, tween, index) { 53322 if (!target.getBBox) { 53323 return false; 53324 } 53325 var length = getLength(target) + 1, 53326 start, 53327 end, 53328 overage, 53329 cs; 53330 this._style = target.style; 53331 if (typeof value === "function") { 53332 value = value(index, target); 53333 } 53334 if (value === true || value === "true") { 53335 value = "0 100%"; 53336 } else if (!value) { 53337 value = "0 0"; 53338 } else if ((value + "").indexOf(" ") === -1) { 53339 value = "0 " + value; 53340 } 53341 start = getPosition(target, length); 53342 end = parse(value, length, start[0]); 53343 this._length = length + 10; 53344 if (start[0] === 0 && end[0] === 0) { 53345 overage = Math.max(0.00001, end[1] - length); //allow people to go past the end, like values of 105% because for some paths, Firefox doesn't return an accurate getTotalLength(), so it could end up coming up short. 53346 this._dash = length + overage; 53347 this._offset = length - start[1] + overage; 53348 this._addTween(this, "_offset", this._offset, length - end[1] + overage, "drawSVG"); 53349 } else { 53350 this._dash = start[1] - start[0] || 0.000001; //some browsers render artifacts if dash is 0, so we use a very small number in that case. 53351 this._offset = -start[0]; 53352 this._addTween(this, "_dash", this._dash, end[1] - end[0] || 0.00001, "drawSVG"); 53353 this._addTween(this, "_offset", this._offset, -end[0], "drawSVG"); 53354 } 53355 if (_isEdge) { 53356 //to work around a bug in Microsoft Edge, animate the stroke-miterlimit by 0.0001 just to trigger the repaint (only necessary if stroke-linecap isn't "butt"; also unnecessary if it's "round" and stroke-linejoin is also "round"). Imperceptible, relatively high-performance, and effective. Another option was to set the "d" <path> attribute to its current value on every tick, but that seems like it'd be much less performant. 53357 cs = _getComputedStyle(target); 53358 end = cs.strokeLinecap; 53359 if (end !== "butt" && end !== cs.strokeLinejoin) { 53360 end = parseFloat(cs.strokeMiterlimit); 53361 this._addTween(target.style, "strokeMiterlimit", end, end + 0.0001, "strokeMiterlimit"); 53362 } 53363 } 53364 return true; 53365 }, 53366 53367 //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.) 53368 set: function set(ratio) { 53369 if (this._firstPT) { 53370 this._super.setRatio.call(this, ratio); 53371 this._style.strokeDashoffset = this._offset; 53372 if (ratio === 1 || ratio === 0) { 53373 this._style.strokeDasharray = this._offset < 0.001 && this._length - this._dash <= 10 ? "none" : this._offset === this._dash ? "0px, 999999px" : this._dash + "px," + this._length + "px"; 53374 } else { 53375 this._style.strokeDasharray = this._dash + "px," + this._length + "px"; 53376 } 53377 } 53378 } 53379 53380 }); 53381 53382 DrawSVGPlugin.getLength = getLength; 53383 DrawSVGPlugin.getPosition = getPosition; 53384});if (_gsScope._gsDefine) { 53385 _gsScope._gsQueue.pop()(); 53386} 53387//export to AMD/RequireJS and CommonJS/Node (precursor to full modular build system coming at a later date) 53388(function (name) { 53389 "use strict"; 53390 53391 var getGlobal = function getGlobal() { 53392 return (_gsScope.GreenSockGlobals || _gsScope)[name]; 53393 }; 53394 if (typeof module !== "undefined" && module.exports) { 53395 //node 53396 __webpack_require__(3); 53397 module.exports = getGlobal(); 53398 } else if (true) { 53399 //AMD 53400 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(3)], __WEBPACK_AMD_DEFINE_FACTORY__ = (getGlobal), 53401 __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? 53402 (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), 53403 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 53404 } 53405})("DrawSVGPlugin");
53406/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(12))) 53407 53408/***/ }), 53409/* 179 */ 53410/***/ (function(module, exports, __webpack_require__) { 53411 53412"use strict"; 53413 53414 53415document.addEventListener('DOMContentLoaded', function () { 53416 53417 var $images = document.querySelectorAll('img'); 53418 53419 $images.forEach(function (img) { 53420 53421 img.addEventListener('contextmenu', function (e) { 53422 e.preventDefault(); 53423 }); 53424 }); 53425}); 53426 53427/***/ }), 53428/* 180 */ 53429/***/ (function(module, exports, __webpack_require__) { 53430 53431"use strict"; 53432 53433 53434Object.defineProperty(exports, "__esModule", { 53435 value: true 53436}); 53437var map_places = [{ 53438 id: 1, 53439 name: 'WALOR Legé', 53440 address: '1 Rue du Champs Fleuri 44650 Legé France' 53441}, { 53442 id: 2, 53443 name: 'WALOR Sf. Gheroghe', 53444 address: 'Street Constructorilor nr.2 52077 Sfantu Gheorge ROMANIA' 53445}, { 53446 id: 3, 53447 name: 'WALOR Irapuato', 53448 address: 'Parque Industrial CIG C.P. 36835 Irapuato Guanajuato - México' 53449}, { 53450 id: 4, 53451 name: 'WALOR Saint-Pierre', 53452 address: '386 avenue des Jourdies 74800 Saint Pierre en Faucigny FRANCE' 53453}, { 53454 id: 5, 53455 name: 'WALOR Le Chambon', 53456 address: 'Zone d\'activité Le Bec 42500 Le Chambon Feugerolles France' 53457}, { 53458 id: 6, 53459 name: 'WALOR Extrusion', 53460 address: '6 Bd Bineau 92532 Levallois-Perret' 53461}, { 53462 id: 7, 53463 name: 'WALOR CTD', 53464 address: '92 Rue St-Melaine 53004 Laval' 53465}, { 53466 id: 8, 53467 name: 'WALOR Offranville', 53468 address: 'Le Doux Mesnil 76550 Offranville' 53469}, { 53470 id: 9, 53471 name: 'WALOR Toucy', 53472 address: 'Route Champeau 89130 Toucy' 53473}, { 53474 id: 10, 53475 name: 'WALOR Vöhrenbach', 53476 address: 'Langenbacher Strasse 17-19 78147 Vöhrenbach' 53477}, { 53478 id: 11, 53479 name: 'WALOR Suzhou', 53480 address: 'Zhong Lu Ecological Park, Lu Zhong Road, Pingwang Town, Wujiang, Suzhou' 53481}, { 53482 id: 12, 53483 name: 'WALOR Laval', 53484 address: '94 Rue St-Melaine 53004 Laval' 53485}]; 53486 53487exports.map_places = map_places; 53488 53489/***/ }), 53490/* 181 */ 53491/***/ (function(module, exports, __webpack_require__) { 53492 53493"use strict"; 53494 53495 53496Object.defineProperty(exports, "__esModule", { 53497 value: true 53498}); 53499var map_styles = [{ 53500 "elementType": "geometry", 53501 "stylers": [{ 53502 "color": "#f5f5f5" 53503 }] 53504}, { 53505 "elementType": "labels.icon", 53506 "stylers": [{ 53507 "visibility": "off" 53508 }] 53509}, { 53510 "elementType": "labels.text.fill", 53511 "stylers": [{ 53512 "color": "#616161" 53513 }] 53514}, { 53515 "elementType": "labels.text.stroke", 53516 "stylers": [{ 53517 "color": "#f5f5f5" 53518 }] 53519}, { 53520 "featureType": "administrative.land_parcel", 53521 "elementType": "labels.text.fill", 53522 "stylers": [{ 53523 "color": "#bdbdbd" 53524 }] 53525}, { 53526 "featureType": "poi", 53527 "elementType": "geometry", 53528 "stylers": [{ 53529 "color": "#eeeeee" 53530 }] 53531}, { 53532 "featureType": "poi", 53533 "elementType": "labels.text.fill", 53534 "stylers": [{ 53535 "color": "#757575" 53536 }] 53537}, { 53538 "featureType": "poi.park", 53539 "elementType": "geometry", 53540 "stylers": [{ 53541 "color": "#e5e5e5" 53542 }] 53543}, { 53544 "featureType": "poi.park", 53545 "elementType": "labels.text.fill", 53546 "stylers": [{ 53547 "color": "#9e9e9e" 53548 }] 53549}, { 53550 "featureType": "road", 53551 "stylers": [{ 53552 "visibility": "on" 53553 }] 53554}, { 53555 "featureType": "road", 53556 "elementType": "geometry", 53557 "stylers": [{ 53558 "color": "#ffffff" 53559 }] 53560}, { 53561 "featureType": "road.arterial", 53562 "elementType": "labels.text.fill", 53563 "stylers": [{ 53564 "color": "#757575" 53565 }] 53566}, { 53567 "featureType": "road.highway", 53568 "elementType": "geometry", 53569 "stylers": [{ 53570 "color": "#dadada" 53571 }] 53572}, { 53573 "featureType": "road.highway", 53574 "elementType": "labels.text.fill", 53575 "stylers": [{ 53576 "color": "#616161" 53577 }] 53578}, { 53579 "featureType": "road.local", 53580 "elementType": "labels.text.fill", 53581 "stylers": [{ 53582 "color": "#9e9e9e" 53583 }] 53584}, { 53585 "featureType": "transit.line", 53586 "elementType": "geometry", 53587 "stylers": [{ 53588 "color": "#e5e5e5" 53589 }] 53590}, { 53591 "featureType": "transit.station", 53592 "elementType": "geometry", 53593 "stylers": [{ 53594 "color": "#eeeeee" 53595 }] 53596}, { 53597 "featureType": "water", 53598 "elementType": "geometry", 53599 "stylers": [{ 53600 "color": "#eaebe9" 53601 }] 53602}, { 53603 "featureType": "water", 53604 "elementType": "labels.text.fill", 53605 "stylers": [{ 53606 "color": "#9e9e9e" 53607 }] 53608}]; 53609 53610exports.map_styles = map_styles; 53611 53612/***/ }), 53613/* 182 */ 53614/***/ (function(module, exports, __webpack_require__) { 53615 53616"use strict"; 53617 53618 53619/** 53620 * @name MarkerWithLabel for V3 53621 * @version 1.1.6 [January 9, 2012]
53622 * @author Gary Little (inspired by code from Marc Ridey of Google). 53623 * @copyright Copyright 2012 Gary Little [gary at luxcentral.com] 53624 * @fileoverview MarkerWithLabel extends the Google Maps JavaScript API V3 53625 * <code>google.maps.Marker</code> class. 53626 * <p> 53627 * MarkerWithLabel allows you to define markers with associated labels. As you would expect, 53628 * if the marker is draggable, so too will be the label. In addition, a marker with a label 53629 * responds to all mouse events in the same manner as a regular marker. It also fires mouse 53630 * events and "property changed" events just as a regular marker would. Version 1.1 adds 53631 * support for the raiseOnDrag feature introduced in API V3.3. 53632 * <p> 53633 * If you drag a marker by its label, you can cancel the drag and return the marker to its 53634 * original position by pressing the <code>Esc</code> key. This doesn't work if you drag the marker 53635 * itself because this feature is not (yet) supported in the <code>google.maps.Marker</code> class. 53636 */ 53637 53638/*! 53639 * 53640 * Licensed under the Apache License, Version 2.0 (the "License"); 53641 * you may not use this file except in compliance with the License. 53642 * You may obtain a copy of the License at 53643 * 53644 * http://www.apache.org/licenses/LICENSE-2.0 53645 * 53646 * Unless required by applicable law or agreed to in writing, software 53647 * distributed under the License is distributed on an "AS IS" BASIS, 53648 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 53649 * See the License for the specific language governing permissions and 53650 * limitations under the License. 53651 */ 53652 53653/*jslint browser:true */ 53654/*global document,google */ 53655 53656/** 53657 * This constructor creates a label and associates it with a marker. 53658 * It is for the private use of the MarkerWithLabel class. 53659 * @constructor 53660 * @param {Marker} marker The marker with which the label is to be associated. 53661 * @param {string} crossURL The URL of the cross image =. 53662 * @param {string} handCursor The URL of the hand cursor. 53663 * @private 53664 */ 53665function MarkerLabel_(marker, crossURL, handCursorURL) { 53666 this.marker_ = marker; 53667 this.handCursorURL_ = marker.handCursorURL; 53668 53669 this.labelDiv_ = document.createElement("div"); 53670 this.labelDiv_.style.cssText = "position: absolute; overflow: hidden;"; 53671 53672 // Set up the DIV for handling mouse events in the label. This DIV forms a transparent veil 53673 // in the "overlayMouseTarget" pane, a veil that covers just the label. This is done so that 53674 // events can be captured even if the label is in the shadow of a google.maps.InfoWindow. 53675 // Code is included here to ensure the veil is always exactly the same size as the label. 53676 this.eventDiv_ = document.createElement("div"); 53677 this.eventDiv_.style.cssText = this.labelDiv_.style.cssText; 53678 53679 // This is needed for proper behavior on MSIE: 53680 this.eventDiv_.setAttribute("onselectstart", "return false;"); 53681 this.eventDiv_.setAttribute("ondragstart", "return false;"); 53682 53683 // Get the DIV for the "X" to be displayed when the marker is raised. 53684 this.crossDiv_ = MarkerLabel_.getSharedCross(crossURL); 53685} 53686 53687// MarkerLabel_ inherits from OverlayView: 53688MarkerLabel_.prototype = new google.maps.OverlayView(); 53689 53690/** 53691 * Returns the DIV for the cross used when dragging a marker when the 53692 * raiseOnDrag parameter set to true. One cross is shared with all markers. 53693 * @param {string} crossURL The URL of the cross image =. 53694 * @private 53695 */ 53696MarkerLabel_.getSharedCross = function (crossURL) { 53697 var div; 53698 if (typeof MarkerLabel_.getSharedCross.crossDiv === "undefined") { 53699 div = document.createElement("img"); 53700 div.style.cssText = "position: absolute; z-index: 1000002; display: none;"; 53701 // Hopefully Google never changes the standard "X" attributes: 53702 div.style.marginLeft = "-8px"; 53703 div.style.marginTop = "-9px"; 53704 div.src = crossURL; 53705 MarkerLabel_.getSharedCross.crossDiv = div; 53706 } 53707 return MarkerLabel_.getSharedCross.crossDiv; 53708}; 53709 53710/** 53711 * Adds the DIV representing the label to the DOM. This method is called 53712 * automatically when the marker's <code>setMap</code> method is called. 53713 * @private 53714 */ 53715MarkerLabel_.prototype.onAdd = function () { 53716 var me = this; 53717 var cMouseIsDown = false;
vendor: 17,228 bytes, lines 53718-54105
53718 var cDraggingLabel = false; 53719 var cSavedZIndex; 53720 var cLatOffset, cLngOffset; 53721 var cIgnoreClick; 53722 var cRaiseEnabled; 53723 var cStartPosition; 53724 var cStartCenter; 53725 // Constants: 53726 var cRaiseOffset = 20; 53727 var cDraggingCursor = "url(" + this.handCursorURL_ + ")"; 53728 53729 // Stops all processing of an event. 53730 // 53731 var cAbortEvent = function cAbortEvent(e) { 53732 if (e.preventDefault) { 53733 e.preventDefault(); 53734 } 53735 e.cancelBubble = true; 53736 if (e.stopPropagation) { 53737 e.stopPropagation(); 53738 } 53739 }; 53740 53741 var cStopBounce = function cStopBounce() { 53742 me.marker_.setAnimation(null); 53743 }; 53744 53745 this.getPanes().overlayImage.appendChild(this.labelDiv_); 53746 this.getPanes().overlayMouseTarget.appendChild(this.eventDiv_); 53747 // One cross is shared with all markers, so only add it once: 53748 if (typeof MarkerLabel_.getSharedCross.processed === "undefined") { 53749 this.getPanes().overlayImage.appendChild(this.crossDiv_); 53750 MarkerLabel_.getSharedCross.processed = true; 53751 } 53752 53753 this.listeners_ = [google.maps.event.addDomListener(this.eventDiv_, "mouseover", function (e) { 53754 if (me.marker_.getDraggable() || me.marker_.getClickable()) { 53755 this.style.cursor = "pointer"; 53756 google.maps.event.trigger(me.marker_, "mouseover", e); 53757 } 53758 }), google.maps.event.addDomListener(this.eventDiv_, "mouseout", function (e) { 53759 if ((me.marker_.getDraggable() || me.marker_.getClickable()) && !cDraggingLabel) { 53760 this.style.cursor = me.marker_.getCursor(); 53761 google.maps.event.trigger(me.marker_, "mouseout", e); 53762 } 53763 }), google.maps.event.addDomListener(this.eventDiv_, "mousedown", function (e) { 53764 cDraggingLabel = false; 53765 if (me.marker_.getDraggable()) { 53766 cMouseIsDown = true; 53767 this.style.cursor = cDraggingCursor; 53768 } 53769 if (me.marker_.getDraggable() || me.marker_.getClickable()) { 53770 google.maps.event.trigger(me.marker_, "mousedown", e); 53771 cAbortEvent(e); // Prevent map pan when starting a drag on a label 53772 } 53773 }), google.maps.event.addDomListener(document, "mouseup", function (mEvent) { 53774 var position; 53775 if (cMouseIsDown) { 53776 cMouseIsDown = false; 53777 me.eventDiv_.style.cursor = "pointer"; 53778 google.maps.event.trigger(me.marker_, "mouseup", mEvent); 53779 } 53780 if (cDraggingLabel) { 53781 if (cRaiseEnabled) { 53782 // Lower the marker & label 53783 position = me.getProjection().fromLatLngToDivPixel(me.marker_.getPosition()); 53784 position.y += cRaiseOffset; 53785 me.marker_.setPosition(me.getProjection().fromDivPixelToLatLng(position)); 53786 // This is not the same bouncing style as when the marker portion is dragged, 53787 // but it will have to do: 53788 try { 53789 // Will fail if running Google Maps API earlier than V3.3 53790 me.marker_.setAnimation(google.maps.Animation.BOUNCE); 53791 setTimeout(cStopBounce, 1406); 53792 } catch (e) {} 53793 } 53794 me.crossDiv_.style.display = "none"; 53795 me.marker_.setZIndex(cSavedZIndex); 53796 cIgnoreClick = true; // Set flag to ignore the click event reported after a label drag 53797 cDraggingLabel = false; 53798 mEvent.latLng = me.marker_.getPosition(); 53799 google.maps.event.trigger(me.marker_, "dragend", mEvent); 53800 } 53801 }), google.maps.event.addListener(me.marker_.getMap(), "mousemove", function (mEvent) { 53802 var position; 53803 if (cMouseIsDown) { 53804 if (cDraggingLabel) { 53805 // Change the reported location from the mouse position to the marker position: 53806 mEvent.latLng = new google.maps.LatLng(mEvent.latLng.lat() - cLatOffset, mEvent.latLng.lng() - cLngOffset); 53807 position = me.getProjection().fromLatLngToDivPixel(mEvent.latLng); 53808 if (cRaiseEnabled) { 53809 me.crossDiv_.style.left = position.x + "px"; 53810 me.crossDiv_.style.top = position.y + "px"; 53811 me.crossDiv_.style.display = ""; 53812 position.y -= cRaiseOffset; 53813 } 53814 me.marker_.setPosition(me.getProjection().fromDivPixelToLatLng(position)); 53815 if (cRaiseEnabled) { 53816 // Don't raise the veil; this hack needed to make MSIE act properly 53817 me.eventDiv_.style.top = position.y + cRaiseOffset + "px"; 53818 } 53819 google.maps.event.trigger(me.marker_, "drag", mEvent); 53820 } else { 53821 // Calculate offsets from the click point to the marker position: 53822 cLatOffset = mEvent.latLng.lat() - me.marker_.getPosition().lat(); 53823 cLngOffset = mEvent.latLng.lng() - me.marker_.getPosition().lng(); 53824 cSavedZIndex = me.marker_.getZIndex(); 53825 cStartPosition = me.marker_.getPosition(); 53826 cStartCenter = me.marker_.getMap().getCenter(); 53827 cRaiseEnabled = me.marker_.get("raiseOnDrag"); 53828 cDraggingLabel = true; 53829 me.marker_.setZIndex(1000000); // Moves the marker & label to the foreground during a drag 53830 mEvent.latLng = me.marker_.getPosition(); 53831 google.maps.event.trigger(me.marker_, "dragstart", mEvent); 53832 } 53833 } 53834 }), google.maps.event.addDomListener(document, "keydown", function (e) { 53835 if (cDraggingLabel) { 53836 if (e.keyCode === 27) { 53837 // Esc key 53838 cRaiseEnabled = false; 53839 me.marker_.setPosition(cStartPosition); 53840 me.marker_.getMap().setCenter(cStartCenter); 53841 google.maps.event.trigger(document, "mouseup", e); 53842 } 53843 } 53844 }), google.maps.event.addDomListener(this.eventDiv_, "click", function (e) { 53845 if (me.marker_.getDraggable() || me.marker_.getClickable()) { 53846 if (cIgnoreClick) { 53847 // Ignore the click reported when a label drag ends 53848 cIgnoreClick = false; 53849 } else { 53850 google.maps.event.trigger(me.marker_, "click", e); 53851 cAbortEvent(e); // Prevent click from being passed on to map 53852 } 53853 } 53854 }), google.maps.event.addDomListener(this.eventDiv_, "dblclick", function (e) { 53855 if (me.marker_.getDraggable() || me.marker_.getClickable()) { 53856 google.maps.event.trigger(me.marker_, "dblclick", e); 53857 cAbortEvent(e); // Prevent map zoom when double-clicking on a label 53858 } 53859 }), google.maps.event.addListener(this.marker_, "dragstart", function (mEvent) { 53860 if (!cDraggingLabel) { 53861 cRaiseEnabled = this.get("raiseOnDrag"); 53862 } 53863 }), google.maps.event.addListener(this.marker_, "drag", function (mEvent) { 53864 if (!cDraggingLabel) { 53865 if (cRaiseEnabled) { 53866 me.setPosition(cRaiseOffset); 53867 // During a drag, the marker's z-index is temporarily set to 1000000 to 53868 // ensure it appears above all other markers. Also set the label's z-index 53869 // to 1000000 (plus or minus 1 depending on whether the label is supposed 53870 // to be above or below the marker). 53871 me.labelDiv_.style.zIndex = 1000000 + (this.get("labelInBackground") ? -1 : +1); 53872 } 53873 } 53874 }), google.maps.event.addListener(this.marker_, "dragend", function (mEvent) { 53875 if (!cDraggingLabel) { 53876 if (cRaiseEnabled) { 53877 me.setPosition(0); // Also restores z-index of label 53878 } 53879 } 53880 }), google.maps.event.addListener(this.marker_, "position_changed", function () { 53881 me.setPosition(); 53882 }), google.maps.event.addListener(this.marker_, "zindex_changed", function () { 53883 me.setZIndex(); 53884 }), google.maps.event.addListener(this.marker_, "visible_changed", function () { 53885 me.setVisible(); 53886 }), google.maps.event.addListener(this.marker_, "labelvisible_changed", function () { 53887 me.setVisible(); 53888 }), google.maps.event.addListener(this.marker_, "title_changed", function () { 53889 me.setTitle(); 53890 }), google.maps.event.addListener(this.marker_, "labelcontent_changed", function () { 53891 me.setContent(); 53892 }), google.maps.event.addListener(this.marker_, "labelanchor_changed", function () { 53893 me.setAnchor(); 53894 }), google.maps.event.addListener(this.marker_, "labelclass_changed", function () { 53895 me.setStyles(); 53896 }), google.maps.event.addListener(this.marker_, "labelstyle_changed", function () { 53897 me.setStyles(); 53898 })]; 53899}; 53900 53901/** 53902 * Removes the DIV for the label from the DOM. It also removes all event handlers. 53903 * This method is called automatically when the marker's <code>setMap(null)</code> 53904 * method is called. 53905 * @private 53906 */ 53907MarkerLabel_.prototype.onRemove = function () { 53908 var i; 53909 this.labelDiv_.parentNode.removeChild(this.labelDiv_); 53910 this.eventDiv_.parentNode.removeChild(this.eventDiv_); 53911 53912 // Remove event listeners: 53913 for (i = 0; i < this.listeners_.length; i++) { 53914 google.maps.event.removeListener(this.listeners_[i]); 53915 } 53916}; 53917 53918/** 53919 * Draws the label on the map. 53920 * @private 53921 */ 53922MarkerLabel_.prototype.draw = function () { 53923 this.setContent(); 53924 this.setTitle(); 53925 this.setStyles(); 53926 this.setData(); 53927}; 53928 53929/** 53930 * Sets the content of the label. 53931 * The content can be plain text or an HTML DOM node. 53932 * @private 53933 */ 53934MarkerLabel_.prototype.setContent = function () { 53935 var content = this.marker_.get("labelContent"); 53936 if (typeof content.nodeType === "undefined") { 53937 this.labelDiv_.innerHTML = content; 53938 this.eventDiv_.innerHTML = this.labelDiv_.innerHTML; 53939 } else { 53940 this.labelDiv_.innerHTML = ""; // Remove current content 53941 this.labelDiv_.appendChild(content); 53942 content = content.cloneNode(true); 53943 this.eventDiv_.appendChild(content); 53944 } 53945}; 53946 53947/** 53948 * Sets the data of the label. 53949 * The content can be plain text or an HTML DOM node. 53950 * @private 53951 */ 53952MarkerLabel_.prototype.setData = function () { 53953 var dataLabel = this.marker_.get("labelData"); 53954 this.eventDiv_.setAttribute("data-label", dataLabel); 53955}; 53956 53957/** 53958 * Sets the content of the tool tip for the label. It is 53959 * always set to be the same as for the marker itself. 53960 * @private 53961 */ 53962MarkerLabel_.prototype.setTitle = function () { 53963 this.eventDiv_.title = this.marker_.getTitle() || ""; 53964}; 53965 53966/** 53967 * Sets the style of the label by setting the style sheet and applying 53968 * other specific styles requested. 53969 * @private 53970 */ 53971MarkerLabel_.prototype.setStyles = function () { 53972 var i, labelStyle; 53973 53974 // Apply style values from the style sheet defined in the labelClass parameter: 53975 this.labelDiv_.className = this.marker_.get("labelClass"); 53976 this.eventDiv_.className = this.labelDiv_.className; 53977 53978 // Clear existing inline style values: 53979 this.labelDiv_.style.cssText = ""; 53980 this.eventDiv_.style.cssText = ""; 53981 // Apply style values defined in the labelStyle parameter: 53982 labelStyle = this.marker_.get("labelStyle"); 53983 for (i in labelStyle) { 53984 if (labelStyle.hasOwnProperty(i)) { 53985 this.labelDiv_.style[i] = labelStyle[i]; 53986 this.eventDiv_.style[i] = labelStyle[i]; 53987 } 53988 } 53989 this.setMandatoryStyles(); 53990}; 53991 53992/** 53993 * Sets the mandatory styles to the DIV representing the label as well as to the 53994 * associated event DIV. This includes setting the DIV position, z-index, and visibility. 53995 * @private 53996 */ 53997MarkerLabel_.prototype.setMandatoryStyles = function () { 53998 this.labelDiv_.style.position = "absolute"; 53999 this.labelDiv_.style.overflow = "hidden"; 54000 // Make sure the opacity setting causes the desired effect on MSIE: 54001 if (typeof this.labelDiv_.style.opacity !== "undefined" && this.labelDiv_.style.opacity !== "") { 54002 this.labelDiv_.style.filter = "alpha(opacity=" + this.labelDiv_.style.opacity * 100 + ")"; 54003 } 54004 54005 this.eventDiv_.style.position = this.labelDiv_.style.position; 54006 this.eventDiv_.style.overflow = this.labelDiv_.style.overflow; 54007 this.eventDiv_.style.opacity = 0.01; // Don't use 0; DIV won't be clickable on MSIE 54008 this.eventDiv_.style.filter = "alpha(opacity=1)"; // For MSIE 54009 54010 this.setAnchor(); 54011 this.setPosition(); // This also updates z-index, if necessary. 54012 this.setVisible(); 54013}; 54014 54015/** 54016 * Sets the anchor point of the label. 54017 * @private 54018 */ 54019MarkerLabel_.prototype.setAnchor = function () { 54020 var anchor = this.marker_.get("labelAnchor"); 54021 this.labelDiv_.style.marginLeft = -anchor.x + "px"; 54022 this.labelDiv_.style.marginTop = -anchor.y + "px"; 54023 this.eventDiv_.style.marginLeft = -anchor.x + "px"; 54024 this.eventDiv_.style.marginTop = -anchor.y + "px"; 54025}; 54026 54027/** 54028 * Sets the position of the label. The z-index is also updated, if necessary. 54029 * @private 54030 */ 54031MarkerLabel_.prototype.setPosition = function (yOffset) { 54032 var position = this.getProjection().fromLatLngToDivPixel(this.marker_.getPosition()); 54033 if (typeof yOffset === "undefined") { 54034 yOffset = 0; 54035 } 54036 this.labelDiv_.style.left = Math.round(position.x) + "px"; 54037 this.labelDiv_.style.top = Math.round(position.y - yOffset) + "px"; 54038 this.eventDiv_.style.left = this.labelDiv_.style.left; 54039 this.eventDiv_.style.top = this.labelDiv_.style.top; 54040 54041 this.setZIndex(); 54042}; 54043 54044/** 54045 * Sets the z-index of the label. If the marker's z-index property has not been defined, the z-index 54046 * of the label is set to the vertical coordinate of the label. This is in keeping with the default 54047 * stacking order for Google Maps: markers to the south are in front of markers to the north. 54048 * @private 54049 */ 54050MarkerLabel_.prototype.setZIndex = function () { 54051 var zAdjust = this.marker_.get("labelInBackground") ? -1 : +1; 54052 if (typeof this.marker_.getZIndex() === "undefined") { 54053 this.labelDiv_.style.zIndex = parseInt(this.labelDiv_.style.top, 10) + zAdjust; 54054 this.eventDiv_.style.zIndex = this.labelDiv_.style.zIndex; 54055 } else { 54056 this.labelDiv_.style.zIndex = this.marker_.getZIndex() + zAdjust; 54057 this.eventDiv_.style.zIndex = this.labelDiv_.style.zIndex; 54058 } 54059}; 54060 54061/** 54062 * Sets the visibility of the label. The label is visible only if the marker itself is 54063 * visible (i.e., its visible property is true) and the labelVisible property is true. 54064 * @private 54065 */ 54066MarkerLabel_.prototype.setVisible = function () { 54067 if (this.marker_.get("labelVisible")) { 54068 this.labelDiv_.style.display = this.marker_.getVisible() ? "block" : "none"; 54069 } else { 54070 this.labelDiv_.style.display = "none"; 54071 } 54072 this.eventDiv_.style.display = this.labelDiv_.style.display; 54073}; 54074 54075/** 54076 * @name MarkerWithLabelOptions 54077 * @class This class represents the optional parameter passed to the {@link MarkerWithLabel} constructor. 54078 * The properties available are the same as for <code>google.maps.Marker</code> with the addition 54079 * of the properties listed below. To change any of these additional properties after the labeled 54080 * marker has been created, call <code>google.maps.Marker.set(propertyName, propertyValue)</code>. 54081 * <p> 54082 * When any of these properties changes, a property changed event is fired. The names of these 54083 * events are derived from the name of the property and are of the form <code>propertyname_changed</code>. 54084 * For example, if the content of the label changes, a <code>labelcontent_changed</code> event 54085 * is fired. 54086 * <p> 54087 * @property {string|Node} [labelContent] The content of the label (plain text or an HTML DOM node). 54088 * @property {Point} [labelAnchor] By default, a label is drawn with its anchor point at (0,0) so 54089 * that its top left corner is positioned at the anchor point of the associated marker. Use this 54090 * property to change the anchor point of the label. For example, to center a 50px-wide label 54091 * beneath a marker, specify a <code>labelAnchor</code> of <code>google.maps.Point(25, 0)</code>. 54092 * (Note: x-values increase to the right and y-values increase to the top.) 54093 * @property {string} [labelClass] The name of the CSS class defining the styles for the label. 54094 * Note that style values for <code>position</code>, <code>overflow</code>, <code>top</code>, 54095 * <code>left</code>, <code>zIndex</code>, <code>display</code>, <code>marginLeft</code>, and 54096 * <code>marginTop</code> are ignored; these styles are for internal use only. 54097 * @property {Object} [labelStyle] An object literal whose properties define specific CSS 54098 * style values to be applied to the label. Style values defined here override those that may 54099 * be defined in the <code>labelClass</code> style sheet. If this property is changed after the 54100 * label has been created, all previously set styles (except those defined in the style sheet) 54101 * are removed from the label before the new style values are applied. 54102 * Note that style values for <code>position</code>, <code>overflow</code>, <code>top</code>, 54103 * <code>left</code>, <code>zIndex</code>, <code>display</code>, <code>marginLeft</code>, and 54104 * <code>marginTop</code> are ignored; these styles are for internal use only. 54105 * @property {boolean}
54105 [labelInBackground] A flag indicating whether a label that overlaps its 54106 * associated marker should appear in the background (i.e., in a plane below the marker). 54107 * The default is <code>false</code>, which causes the label to appear in the foreground. 54108 * @property {boolean} [labelVisible] A flag indicating whether the label is to be visible. 54109 * The default is <code>true</code>. Note that even if <code>labelVisible</code> is 54110 * <code>true</code>, the label will <i>not</i> be visible unless the associated marker is also 54111 * visible (i.e., unless the marker's <code>visible</code> property is <code>true</code>). 54112 * @property {boolean} [raiseOnDrag] A flag indicating whether the label and marker are to be 54113 * raised when the marker is dragged. The default is <code>true</code>. If a draggable marker is 54114 * being created and a version of Google Maps API earlier than V3.3 is being used, this property 54115 * must be set to <code>false</code>. 54116 * @property {boolean} [optimized] A flag indicating whether rendering is to be optimized for the 54117 * marker. <b>Important: The optimized rendering technique is not supported by MarkerWithLabel, 54118 * so the value of this parameter is always forced to <code>false</code>. 54119 * @property {string} [crossImage="http://maps.gstatic.com/intl/en_us/mapfiles/drag_cross_67_16.png"] 54120 * The URL of the cross image to be displayed while dragging a marker. 54121 * @property {string} [handCursor="http://maps.gstatic.com/intl/en_us/mapfiles/closedhand_8_8.cur"] 54122 * The URL of the cursor to be displayed while dragging a marker. 54123 */ 54124/** 54125 * Creates a MarkerWithLabel with the options specified in {@link MarkerWithLabelOptions}. 54126 * @constructor 54127 * @param {MarkerWithLabelOptions} [opt_options] The optional parameters. 54128 */ 54129function MarkerWithLabel(opt_options) { 54130 opt_options = opt_options || {}; 54131 opt_options.labelContent = opt_options.labelContent || ""; 54132 opt_options.labelAnchor = opt_options.labelAnchor || new google.maps.Point(0, 0); 54133 opt_options.labelClass = opt_options.labelClass || "markerLabels"; 54134 opt_options.labelStyle = opt_options.labelStyle || {}; 54135 opt_options.labelInBackground = opt_options.labelInBackground || false; 54136 if (typeof opt_options.labelVisible === "undefined") { 54137 opt_options.labelVisible = true; 54138 } 54139 if (typeof opt_options.raiseOnDrag === "undefined") { 54140 opt_options.raiseOnDrag = true; 54141 } 54142 if (typeof opt_options.clickable === "undefined") { 54143 opt_options.clickable = true; 54144 } 54145 if (typeof opt_options.draggable === "undefined") { 54146 opt_options.draggable = false; 54147 } 54148 if (typeof opt_options.optimized === "undefined") { 54149 opt_options.optimized = false; 54150 } 54151 opt_options.crossImage = opt_options.crossImage || "http" + (document.location.protocol === "https:" ? "s" : "") + "://maps.gstatic.com/intl/en_us/mapfiles/drag_cross_67_16.png"; 54152 opt_options.handCursor = opt_options.handCursor || "http" + (document.location.protocol === "https:" ? "s" : "") + "://maps.gstatic.com/intl/en_us/mapfiles/closedhand_8_8.cur"; 54153 opt_options.optimized = false; // Optimized rendering is not supported 54154 54155 this.label = new MarkerLabel_(this, opt_options.crossImage, opt_options.handCursor); // Bind the label to the marker 54156 54157 // Call the parent constructor. It calls Marker.setValues to initialize, so all 54158 // the new parameters are conveniently saved and can be accessed with get/set. 54159 // Marker.set triggers a property changed event (called "propertyname_changed") 54160 // that the marker label listens for in order to react to state changes. 54161 google.maps.Marker.apply(this, arguments); 54162} 54163 54164// MarkerWithLabel inherits from <code>Marker</code>: 54165MarkerWithLabel.prototype = new google.maps.Marker(); 54166 54167/** 54168 * Overrides the standard Marker setMap function. 54169 * @param {Map} theMap The map to which the marker is to be added. 54170 * @private 54171 */ 54172MarkerWithLabel.prototype.setMap = function (theMap) { 54173 54174 // Call the inherited function... 54175 google.maps.Marker.prototype.setMap.apply(this, arguments); 54176 54177 // ... then deal with the label: 54178 this.label.setMap(theMap); 54179}; 54180exports.MarkerWithLabel = MarkerWithLabel; 54181 54182/***/ }), 54183/* 183 */ 54184/***/ (function(module, exports, __webpack_require__) { 54185 54186"use strict"; 54187/* WEBPACK VAR INJECTION */(function(module) { 54188 54189var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; 54190 54191/*! modernizr 3.3.1 (Custom Build) | MIT * 54192 * https://modernizr.com/download/?-applicationcache-audio-backgroundsize-borderimage-borderradiu
54192s-boxshadow-canvas-canvastext-cookies-cors-cssanimations-csscolumns-cssgradients-cssreflections-csstransforms-csstransforms3d-csstransitions-flexbox-fontface-generatedcontent-geolocation-hashchange-history-hsla-imgcrossorigin-indexeddb-inlinesvg-input-inputtypes-localstorage-multiplebgs-opacity-postmessage-rgba-sessionstorage-smil-svg-svgclippaths-textshadow-video-webgl-webglextensions-websockets-websqldatabase-webworkers-addtest-domprefixes-hasevent-mq-prefixed-prefixes-setclasses-shiv-testallprops-testprop-teststyles !*/ 54193!function (e, t, n) { 54194 function r(e, t) { 54195 return (typeof e === "undefined" ? "undefined" : _typeof(e)) === t; 54196 }function a() { 54197 var e, t, n, a, o, i, s;for (var c in x) { 54198 if (x.hasOwnProperty(c)) { 54199 if (e = [], t = x[c], t.name && (e.push(t.name.toLowerCase()), t.options && t.options.aliases && t.options.aliases.length)) for (n = 0; n < t.options.aliases.length; n++) { 54200 e.push(t.options.aliases[n].toLowerCase()); 54201 }for (a = r(t.fn, "function") ? t.fn() : t.fn, o = 0; o < e.length; o++) { 54202 i = e[o], s = i.split("."), 1 === s.length ? Modernizr[s[0]] = a : (!Modernizr[s[0]] || Modernizr[s[0]] instanceof Boolean || (Modernizr[s[0]] = new Boolean(Modernizr[s[0]])), Modernizr[s[0]][s[1]] = a), b.push((a ? "" : "no-") + s.join("-")); 54203 } 54204 } 54205 } 54206 }function o(e) { 54207 var t = k.className, 54208 n = Modernizr._config.classPrefix || "";if (E && (t = t.baseVal), Modernizr._config.enableJSClass) { 54209 var r = new RegExp("(^|\\s)" + n + "no-js(\\s|$)");t = t.replace(r, "$1" + n + "js$2"); 54210 }Modernizr._config.enableClasses && (t += " " + n + e.join(" " + n), E ? k.className.baseVal = t : k.className = t); 54211 }function i(e, t) { 54212 if ("object" == (typeof e === "undefined" ? "undefined" : _typeof(e))) for (var n in e) { 54213 N(e, n) && i(n, e[n]); 54214 } else { 54215 e = e.toLowerCase();var r = e.split("."), 54216 a = Modernizr[r[0]];if (2 == r.length && (a = a[r[1]]), "undefined" != typeof a) return Modernizr;t = "function" == typeof t ? t() : t, 1 == r.length ? Modernizr[r[0]] = t : (!Modernizr[r[0]] || Modernizr[r[0]] instanceof Boolean || (Modernizr[r[0]] = new Boolean(Modernizr[r[0]])), Modernizr[r[0]][r[1]] = t), o([(t && 0 != t ? "" : "no-") + r.join("-")]), Modernizr._trigger(e, t); 54217 }return Modernizr; 54218 }function s() { 54219 return "function" != typeof t.createElement ? t.createElement(arguments[0]) : E ? t.createElementNS.call(t, "http://www.w3.org/2000/svg", arguments[0]) : t.createElement.apply(t, arguments); 54220 }function c(e) { 54221 return e.replace(/([a-z])-([a-z])/g, function (e, t, n) { 54222 return t + n.toUpperCase(); 54223 }).replace(/^-/, ""); 54224 }function l(e, t) { 54225 return !!~("" + e).indexOf(t); 54226 }function d() { 54227 var e = t.body;return e || (e = s(E ? "svg" : "body"), e.fake = !0), e; 54228 }function u(e, n, r, a) { 54229 var o, 54230 i, 54231 c, 54232 l, 54233 u = "modernizr", 54234 f = s("div"), 54235 p = d();if (parseInt(r, 10)) for (; r--;) { 54236 c = s("div"), c.id = a ? a[r] : u + (r + 1), f.appendChild(c); 54237 }return o = s("style"), o.type = "text/css", o.id = "s" + u, (p.fake ? p : f).appendChild(o), p.appendChild(f), o.styleSheet ? o.styleSheet.cssText = e : o.appendChild(t.createTextNode(e)), f.id = u, p.fake && (p.style.background = "", p.style.overflow = "hidden", l = k.style.overflow, k.style.overflow = "hidden", k.appendChild(p)), i = n(f, e), p.fake ? (p.parentNode.removeChild(p), k.style.overflow = l, k.offsetHeight) : f.parentNode.removeChild(f), !!i; 54238 }function f(e, t) { 54239 return function () { 54240 return e.apply(t, arguments); 54241 }; 54242 }function p(e, t, n) { 54243 var a;for (var o in e) { 54244 if (e[o] in t) return n === !1 ? e[o] : (a = t[e[o]], r(a, "function") ? f(a, n || t) : a); 54245 }return !1; 54246 }function m(e) { 54247 return e.replace(/([A-Z])/g, function (e, t) { 54248 return "-" + t.toLowerCase(); 54249 }).replace(/^ms-/, "-ms-"); 54250 }function g(t, r) { 54251 var a = t.length;if ("CSS" in e && "supports" in e.CSS) { 54252 for (; a--;) { 54253 if (e.CSS.supports(m(t[a]), r)) return !0; 54254 }return !1; 54255 }if ("CSSSupportsRule" in e) { 54256 for (var o = []; a--;) { 54257 o.push("(" + m(t[a]) + ":" + r + ")"); 54258 }return o = o.join(" or "), u("@supports (" + o + ") { #modernizr { position: absolute; } }", function (e) { 54259 return "absolute" == getComputedStyle(e, null).position; 54260 }); 54261 }return n; 54262 }function h(e, t, a, o) { 54263 function i() { 54264 u && (delete V.style, delete V.modElem); 54265 }if (o = r(o, "undefined") ? !1 : o, !r(a, "undefined")) { 54266 var d = g(e, a);if (!r(d, "undefined")) return d; 54267 }for (var u, f, p, m, h, v = ["modernizr", "tspan", "samp"]; !V.style && v.length;) { 54268 u = !0, V.modElem = s(v.shift()), V.style = V.modElem.style; 54269 }for (p = e.length, f = 0; p > f; f++) { 54270 if (m = e[f], h = V.style[m], l(m, "-") && (m = c(m)), V.style[m] !== n) { 54271 if (o || r(a, "undefined")) return i(), "pfx" == t ? m : !0;try { 54272 V.style[m] = a; 54273 } catch (y) {}if (V.style[m] != h) return i(), "pfx" == t ? m : !0; 54274 } 54275 }return i(), !1; 54276 }function v(e, t, n, a, o) { 54277 var i = e.charAt(0).toUpperCase() + e.slice(1), 54278 s = (e + " " + D.join(i + " ") + i).split(" ");return r(t, "string") || r(t, "undefined") ? h(s, t, a, o) : (s = (e + " " + P.join(i + " ") + i).split(" "), p(s, t, n)); 54279 }function y(e, t, r) { 54280 return v(e, n, n, t, r); 54281 }var b = [], 54282 x = [], 54283 w = { _version: "3.3.1", _config: { classPrefix: "", enableClasses: !0, enableJSClass: !0, usePrefixes: !0 }, _q: [], on: function on(e, t) { 54284 var n = this;setTimeout(function () { 54285 t(n[e]); 54286 }, 0); 54287 }, addTest: function addTest(e, t, n) { 54288 x.push({ name: e, fn: t, options: n }); 54289 }, addAsyncTest: function addAsyncTest(e) { 54290 x.push({ name: null, fn: e }); 54291 } }, 54292 Modernizr = function Modernizr() {};Modernizr.prototype = w, Modernizr = new Modernizr(), Modernizr.addTest("applicationcache", "applicationCache" in e), Modernizr.addTest("cookies", function () { 54293 try { 54294 t.cookie = "cookietest=1";var e = -1 != t.cookie.indexOf("cookietest=");return t.cookie = "cookietest=1; expires=Thu, 01-Jan-1970 00:00:01 GMT", e; 54295 } catch (n) { 54296 return !1; 54297 } 54298 }), Modernizr.addTest("cors", "XMLHttpRequest" in e && "withCredentials" in new XMLHttpRequest()), Modernizr.addTest("geolocation", "geolocation" in navigator), Modernizr.addTest("history", function () { 54299 var t = navigator.userAgent;return -1 === t.indexOf("Android 2.") && -1 === t.indexOf("Android 4.0") || -1 === t.indexOf("Mobile Safari") || -1 !== t.indexOf("Chrome") || -1 !== t.indexOf("Windows Phone") ? e.history && "pushState" in e.history : !1; 54300 }), Modernizr.addTest("postmessage", "postMessage" in e), Modernizr.addTest("svg", !!t.createElementNS && !!t.createElementNS("http://www.w3.org/2000/svg", "svg").createSVGRect);var T = !1;try { 54301 T = "WebSocket" in e && 2 === e.WebSocket.CLOSING; 54302 } catch (S) {}Modernizr.addTest("websockets", T), Modernizr.addTest("localstorage", function () { 54303 var e = "modernizr";try { 54304 return localStorage.setItem(e, e), localStorage.removeItem(e), !0; 54305 } catch (t) { 54306 return !1; 54307 } 54308 }), Modernizr.addTest("sessionstorage", function () { 54309 var e = "modernizr";try { 54310 return sessionStorage.setItem(e, e), sessionStorage.removeItem(e), !0; 54311 } catch (t) { 54312 return !1; 54313 } 54314 }), Modernizr.addTest("websqldatabase", "openDatabase" in e), Modernizr.addTest("webworkers", "Worker" in e);var C = w._config.usePrefixes ? " -webkit- -moz- -o- -ms- ".split(" ") : ["", ""];w._prefixes = C;var k = t.documentElement, 54315 E = "svg" === k.nodeName.toLowerCase();E || !function (e, t) { 54316 function n(e, t) { 54317 var n = e.createElement("p"), 54318 r = e.getElementsByTagName("head")[0] || e.documentElement;return n.innerHTML = "x<style>" + t + "</style>", r.insertBefore(n.lastChild, r.firstChild); 54319 }function r() { 54320 var e = b.elements;return "string" == typeof e ? e.split(" ") : e; 54321 }function a(e, t) { 54322 var n = b.elements;"string" != typeof n && (n = n.join(" ")), "string" != typeof e && (e = e.join(" ")), b.elements = n + " " + e, l(t); 54323 }function o(e) { 54324 var t = y[e[h]];return t || (t = {}, v++, e[h] = v, y[v] = t), t; 54325 }function i(e, n, r) { 54326 if (n || (n = t), u) return n.createElement(e);r || (r = o(n));var a;return a = r.cache[e] ? r.cache[e].cloneNode() : g.test(e) ? (r.cache[e] = r.createElem(e)).cloneNode() : r.createElem(e), !a.canHaveChildren || m.test(e) || a.tagUrn ? a : r.frag.appendChild(a); 54327 }function s(e, n) { 54328 if (e || (e = t), u) return e.createDocumentFragment();n = n || o(e);for (var a = n.frag.cloneNode(), i = 0, s = r(), c = s.length; c > i; i++) { 54329 a.createElement(s[i]); 54330 }return a; 54331 }function c(e, t) {
54332 t.cache || (t.cache = {}, t.createElem = e.createElement, t.createFrag = e.createDocumentFragment, t.frag = t.createFrag()), e.createElement = function (n) { 54333 return b.shivMethods ? i(n, e, t) : t.createElem(n); 54334 }, e.createDocumentFragment = Function("h,f", "return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&(" + r().join().replace(/[\w\-:]+/g, function (e) { 54335 return t.createElem(e), t.frag.createElement(e), 'c("' + e + '")'; 54336 }) + ");return n}")(b, t.frag); 54337 }function l(e) { 54338 e || (e = t);var r = o(e);return !b.shivCSS || d || r.hasCSS || (r.hasCSS = !!n(e, "article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}")), u || c(e, r), e; 54339 }var d, 54340 u, 54341 f = "3.7.3", 54342 p = e.html5 || {}, 54343 m = /^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i, 54344 g = /^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i, 54345 h = "_html5shiv", 54346 v = 0, 54347 y = {};!function () { 54348 try { 54349 var e = t.createElement("a");e.innerHTML = "<xyz></xyz>", d = "hidden" in e, u = 1 == e.childNodes.length || function () { 54350 t.createElement("a");var e = t.createDocumentFragment();return "undefined" == typeof e.cloneNode || "undefined" == typeof e.createDocumentFragment || "undefined" == typeof e.createElement; 54351 }(); 54352 } catch (n) { 54353 d = !0, u = !0; 54354 } 54355 }();var b = { elements: p.elements || "abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video", version: f, shivCSS: p.shivCSS !== !1, supportsUnknownElements: u, shivMethods: p.shivMethods !== !1, type: "default", shivDocument: l, createElement: i, createDocumentFragment: s, addElements: a };e.html5 = b, l(t), "object" == ( false ? "undefined" : _typeof(module)) && module.exports && (module.exports = b); 54356 }("undefined" != typeof e ? e : this, t);var _ = "Moz O ms Webkit", 54357 P = w._config.usePrefixes ? _.toLowerCase().split(" ") : [];w._domPrefixes = P;var N;!function () { 54358 var e = {}.hasOwnProperty;N = r(e, "undefined") || r(e.call, "undefined") ? function (e, t) { 54359 return t in e && r(e.constructor.prototype[t], "undefined"); 54360 } : function (t, n) { 54361 return e.call(t, n); 54362 }; 54363 }(), w._l = {}, w.on = function (e, t) { 54364 this._l[e] || (this._l[e] = []), this._l[e].push(t), Modernizr.hasOwnProperty(e) && setTimeout(function () { 54365 Modernizr._trigger(e, Modernizr[e]); 54366 }, 0); 54367 }, w._trigger = function (e, t) { 54368 if (this._l[e]) { 54369 var n = this._l[e];setTimeout(function () { 54370 var e, r;for (e = 0; e < n.length; e++) { 54371 (r = n[e])(t); 54372 } 54373 }, 0), delete this._l[e]; 54374 } 54375 }, Modernizr._q.push(function () { 54376 w.addTest = i; 54377 });var R = function () { 54378 function e(e, t) { 54379 var a;return e ? (t && "string" != typeof t || (t = s(t || "div")), e = "on" + e, a = e in t, !a && r && (t.setAttribute || (t = s("div")), t.setAttribute(e, ""), a = "function" == typeof t[e], t[e] !== n && (t[e] = n), t.removeAttribute(e)), a) : !1; 54380 }var r = !("onblur" in t.documentElement);return e; 54381 }();w.hasEvent = R, Modernizr.addTest("hashchange", function () { 54382 return R("hashchange", e) === !1 ? !1 : t.documentMode === n || t.documentMode > 7; 54383 }), Modernizr.addTest("audio", function () { 54384 var e = s("audio"), 54385 t = !1;try { 54386 (t = !!e.canPlayType) && (t = new Boolean(t), t.ogg = e.canPlayType('audio/ogg; codecs="vorbis"').replace(/^no$/, ""), t.mp3 = e.canPlayType('audio/mpeg; codecs="mp3"').replace(/^no$/, ""), t.opus = e.canPlayType('audio/ogg; codecs="opus"') || e.canPlayType('audio/webm; codecs="opus"').replace(/^no$/, ""), t.wav = e.canPlayType('audio/wav; codecs="1"').replace(/^no$/, ""), t.m4a = (e.canPlayType("audio/x-m4a;") || e.canPlayType("audio/aac;")).replace(/^no$/, "")); 54387 } catch (n) {}return t; 54388 }), Modernizr.addTest("canvas", function () { 54389 var e = s("canvas");return !(!e.getContext || !e.getContext("2d")); 54390 }), Modernizr.addTest("canvastext", function () { 54391 return Modernizr.canvas === !1 ? !1 : "function" == typeof s("canvas").getContext("2d").fillText; 54392 }), Modernizr.addTest("video", function () { 54393 var e = s("video"), 54394 t = !1;try { 54395 (t = !!e.canPlayType) && (t = new Boolean(t), t.ogg = e.canPlayType('video/ogg; codecs="theora"').replace(/^no$/, ""), t.h264 = e.canPlayType('video/mp4; codecs="avc1.42E01E"').replace(/^no$/, ""), t.webm = e.canPlayType('video/webm; codecs="vp8, vorbis"').replace(/^no$/, ""), t.vp9 = e.canPlayType('video/webm; codecs="vp9"').replace(/^no$/, ""), t.hls = e.canPlayType('application/x-mpegURL; codecs="avc1.42E01E"').replace(/^no$/, "")); 54396 } catch (n) {}return t; 54397 }), Modernizr.addTest("webgl", function () { 54398 var t = s("canvas"), 54399 n = "probablySupportsContext" in t ? "probablySupportsContext" : "supportsContext";return n in t ? t[n]("webgl") || t[n]("experimental-webgl") : "WebGLRenderingContext" in e; 54400 }), Modernizr.addTest("cssgradients", function () { 54401 for (var e, t = "background-image:", n = "gradient(linear,left top,right bottom,from(#9f9),to(white));", r = "", a = 0, o = C.length - 1; o > a; a++) { 54402 e = 0 === a ? "to " : "", r += t + C[a] + "linear-gradient(" + e + "left top, #9f9, white);"; 54403 }Modernizr._config.usePrefixes && (r += t + "-webkit-" + n);var i = s("a"),
54404 c = i.style;return c.cssText = r, ("" + c.backgroundImage).indexOf("gradient") > -1; 54405 }), Modernizr.addTest("multiplebgs", function () { 54406 var e = s("a").style;return e.cssText = "background:url(https://),url(https://),red url(https://)", /(url\s*\(.*?){3}/.test(e.background); 54407 }), Modernizr.addTest("opacity", function () { 54408 var e = s("a").style;return e.cssText = C.join("opacity:.55;"), /^0.55$/.test(e.opacity); 54409 }), Modernizr.addTest("rgba", function () { 54410 var e = s("a").style;return e.cssText = "background-color:rgba(150,255,150,.5)", ("" + e.backgroundColor).indexOf("rgba") > -1; 54411 }), Modernizr.addTest("imgcrossorigin", "crossOrigin" in s("img")), Modernizr.addTest("inlinesvg", function () { 54412 var e = s("div");return e.innerHTML = "<svg/>", "http://www.w3.org/2000/svg" == ("undefined" != typeof SVGRect && e.firstChild && e.firstChild.namespaceURI); 54413 }), Modernizr.addAsyncTest(function () { 54414 if (Modernizr.webglextensions = new Boolean(!1), Modernizr.webgl) { 54415 var e, t, r;try { 54416 e = s("canvas"), t = e.getContext("webgl") || e.getContext("experimental-webgl"), r = t.getSupportedExtensions(); 54417 } catch (a) { 54418 return; 54419 }t !== n && (Modernizr.webglextensions = new Boolean(!0));for (var o = -1, i = r.length; ++o < i;) { 54420 Modernizr.webglextensions[r[o]] = !0; 54421 }e = n; 54422 } 54423 });var z = s("input"), 54424 A = "autocomplete autofocus list placeholder max min multiple pattern required step".split(" "), 54425 $ = {};Modernizr.input = function (t) { 54426 for (var n = 0, r = t.length; r > n; n++) { 54427 $[t[n]] = !!(t[n] in z); 54428 }return $.list && ($.list = !(!s("datalist") || !e.HTMLDataListElement)), $; 54429 }(A);var M = "search tel url email datetime date month week time datetime-local number range color".split(" "), 54430 O = {};Modernizr.inputtypes = function (e) { 54431 for (var r, a, o, i = e.length, s = "1)", c = 0; i > c; c++) { 54432 z.setAttribute("type", r = e[c]), o = "text" !== z.type && "style" in z, o && (z.value = s, z.style.cssText = "position:absolute;visibility:hidden;", /^range$/.test(r) && z.style.WebkitAppearance !== n ? (k.appendChild(z), a = t.defaultView, o = a.getComputedStyle && "textfield" !== a.getComputedStyle(z, null).WebkitAppearance && 0 !== z.offsetHeight, k.removeChild(z)) : /^(search|tel)$/.test(r) || (o = /^(url|email)$/.test(r) ? z.checkValidity && z.checkValidity() === !1 : z.value != s)), O[e[c]] = !!o; 54433 }return O; 54434 }(M), Modernizr.addTest("hsla", function () { 54435 var e = s("a").style;return e.cssText = "background-color:hsla(120,40%,100%,.5)", l(e.backgroundColor, "rgba") || l(e.backgroundColor, "hsla"); 54436 });var L = "CSS" in e && "supports" in e.CSS, 54437 B = "supportsCSS" in e;Modernizr.addTest("supports", L || B);var j = {}.toString;Modernizr.addTest("svgclippaths", function () { 54438 return !!t.createElementNS && /SVGClipPath/.test(j.call(t.createElementNS("http://www.w3.org/2000/svg", "clipPath"))); 54439 }), Modernizr.addTest("smil", function () { 54440 return !!t.createElementNS && /SVGAnimate/.test(j.call(t.createElementNS("http://www.w3.org/2000/svg", "animate"))); 54441 });var F = function () { 54442 var t = e.matchMedia || e.msMatchMedia;return t ? function (e) { 54443 var n = t(e);return n && n.matches || !1; 54444 } : function (t) { 54445 var n = !1;return u("@media " + t + " { #modernizr { position: absolute; } }", function (t) { 54446 n = "absolute" == (e.getComputedStyle ? e.getComputedStyle(t, null) : t.currentStyle).position; 54447 }), n; 54448 }; 54449 }();w.mq = F;var q = w.testStyles = u, 54450 I = function () { 54451 var e = navigator.userAgent, 54452 t = e.match(/applewebkit\/([0-9]+)/gi) && parseFloat(RegExp.$1), 54453 n = e.match(/w(eb)?osbrowser/gi), 54454 r = e.match(/windows phone/gi) && e.match(/iemobile\/([0-9])+/gi) && parseFloat(RegExp.$1) >= 9, 54455 a = 533 > t && e.match(/android/gi);return n || a || r; 54456 }();I ? Modernizr.addTest("fontface", !1) : q('@font-face {font-family:"font";src:url("https://")}', function (e, n) { 54457 var r = t.getElementById("smodernizr"), 54458 a = r.sheet || r.styleSheet, 54459 o = a ? a.cssRules && a.cssRules[0] ? a.cssRules[0].cssText : a.cssText || "" : "", 54460 i = /src/i.test(o) && 0 === o.indexOf(n.split(" ")[0]);Modernizr.addTest("fontface", i); 54461 }), q('#modernizr{font:0/0 a}#modernizr:after{content:":)";visibility:hidden;font:7px/1 a}', function (e) { 54462 Modernizr.addTest("generatedcontent", e.offsetHeight >= 7); 54463 });var D = w._config.usePrefixes ? _.split(" ") : [];w._cssomPrefixes = D;var H = function H(t) { 54464 var r, 54465 a = C.length, 54466 o = e.CSSRule;if ("undefined" == typeof o) return n;if (!t) return !1;if (t = t.replace(/^@/, ""), r = t.replace(/-/g, "_").toUpperCase() + "_RULE", r in o) return "@" + t;for (var i = 0; a > i; i++) { 54467 var s = C[i], 54468 c = s.toUpperCase() + "_" + r;if (c in o) return "@-" + s.toLowerCase() + "-" + t; 54469 }return !1; 54470 };w.atRule = H;var W = { elem: s("modernizr") };Modernizr._q.push(function () { 54471 delete W.elem; 54472 });var V = { style: W.elem.style };Modernizr._q.unshift(function () { 54473 delete V.style; 54474 });var U = w.testProp = function (e, t, r) { 54475 return h([e], n, t, r); 54476 };Modernizr.addTest("textshadow", U("textShadow", "1px 1px")), w.testAllProps = v;var G, 54477 J = w.prefixed = function (e, t, n) { 54478 return 0 === e.indexOf("@") ? H(e) : (-1 != e.indexOf("-") && (e = c(e)), t ? v(e, t, n) : v(e, "pfx")); 54479 };try { 54480 G = J("indexedDB", e); 54481 } catch (S) {}Modernizr.addTest("indexeddb", !!G), G && Modernizr.addTest("indexeddb.deletedatabase", "deleteDatabase" in G), w.testAllProps = y, Modernizr.addTest("cssanimations", y("animationName", "a", !0)), Modernizr.addTest("backgroundsize", y("backgroundSize", "100%", !0)), Modernizr.addTest("borderimage", y("borderImage", "url() 1", !0)), Modernizr.addTest("borderradiu
54481s", y("borderRadius", "0px", !0)), Modernizr.addTest("boxshadow", y("boxShadow", "1px 1px", !0)), function () { 54482 Modernizr.addTest("csscolumns", function () { 54483 var e = !1, 54484 t = y("columnCount");try { 54485 (e = !!t) && (e = new Boolean(e)); 54486 } catch (n) {}return e; 54487 });for (var e, t, n = ["Width", "Span", "Fill", "Gap", "Rule", "RuleColor", "RuleStyle", "RuleWidth", "BreakBefore", "BreakAfter", "BreakInside"], r = 0; r < n.length; r++) { 54488 e = n[r].toLowerCase(), t = y("column" + n[r]), ("breakbefore" === e || "breakafter" === e || "breakinside" == e) && (t = t || y(n[r])), Modernizr.addTest("csscolumns." + e, t); 54489 } 54490 }(), Modernizr.addTest("flexbox", y("flexBasis", "1px", !0)), Modernizr.addTest("cssreflections", y("boxReflect", "above", !0)), Modernizr.addTest("csstransforms", function () { 54491 return -1 === navigator.userAgent.indexOf("Android 2.") && y("transform", "scale(1)", !0); 54492 }), Modernizr.addTest("csstransforms3d", function () { 54493 var e = !!y("perspective", "1px", !0), 54494 t = Modernizr._config.usePrefixes;if (e && (!t || "webkitPerspective" in k.style)) { 54495 var n, 54496 r = "#modernizr{width:0;height:0}";Modernizr.supports ? n = "@supports (perspective: 1px)" : (n = "@media (transform-3d)", t && (n += ",(-webkit-transform-3d)")), n += "{#modernizr{width:7px;height:18px;margin:0;padding:0;border:0}}", q(r + n, function (t) { 54497 e = 7 === t.offsetWidth && 18 === t.offsetHeight; 54498 }); 54499 }return e; 54500 }), Modernizr.addTest("csstransitions", y("transition", "all", !0)), a(), o(b), delete w.addTest, delete w.addAsyncTest;for (var X = 0; X < Modernizr._q.length; X++) { 54501 Modernizr._q[X](); 54502 }e.Modernizr = Modernizr; 54503}(window, document);
54504/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(156)(module))) 54505 54506/***/ }), 54507/* 184 */ 54508/***/ (function(module, exports, __webpack_require__) { 54509 54510"use strict"; 54511/* WEBPACK VAR INJECTION */(function($) { 54512 54513var _MorphSVGPlugin = __webpack_require__(17); 54514 54515var _variables = __webpack_require__(20); 54516 54517var _gsap = __webpack_require__(8); 54518 54519function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } 54520 54521var Snap = __webpack_require__(16); 54522 54523__webpack_require__(17); 54524document.addEventListener('DOMContentLoaded', function () { 54525 54526 var icon_header = document.querySelector('.header_band_search-icon'); 54527 54528 var icon_header_container = Snap(icon_header); 54529 var icon_search = icon_header.getAttribute('data-icon'); 54530 54531 Snap.load(templateURL + "/dist/images/icons/" + icon_search + ".svg", function (e) { 54532 54533 icon_header_container.append(e); 54534 var paths = e.selectAll('path'); 54535 var groups = e.selectAll('g'); 54536 54537 groups.forEach(function (group) { 54538 group.node.classList.remove('cls-1'); 54539 }); 54540 54541 paths.forEach(function (path) { 54542 path.node.classList.remove('cls-2'); 54543 path.attr({ 54544 fill: _variables.COLORS.blue 54545 }); 54546 }); 54547 }); 54548 54549 var icons_nav = document.querySelectorAll('.header_nav_social_icon'); 54550 54551 icons_nav.forEach(function (icon_container) { 54552 54553 var container = Snap(icon_container.querySelector('a')); 54554 var icon = icon_container.getAttribute('data-icon'); 54555 54556 Snap.load(templateURL + "/dist/images/icons/" + icon + ".svg", function (e) { 54557 54558 var paths = e.selectAll('path'); 54559 container.append(e); 54560 54561 paths.forEach(function (path) { 54562 path.attr({ 54563 fill: _variables.COLORS.greyblue 54564 }); 54565 }); 54566 }); 54567 }); 54568 54569 var icons_header = document.querySelectorAll('.header_band_icon'); 54570 54571 icons_header.forEach(function (icon_container) { 54572 54573 var container = Snap(icon_container); 54574 var icon = icon_container.getAttribute('data-icon'); 54575 54576 Snap.load(templateURL + "/dist/images/icons/" + icon + ".svg", function (e) { 54577 54578 var paths = e.selectAll('path'); 54579 var groups = e.selectAll('g'); 54580 var circle = e.select('#path-circle'); 54581 var polygon = e.select('polygon'); 54582 54583 groups.forEach(function (group) { 54584 $(group.node).removeClass('cls-1'); 54585 }); 54586 54587 paths.forEach(function (path) { 54588 $(path.node).removeClass('cls-2'); 54589 path.attr({ 54590 fill: _variables.COLORS.blue 54591 }); 54592 }); 54593 54594 container.append(e); 54595 54596 icon_container.addEventListener('mouseenter', function () { 54597 _gsap.TweenMax.to(circle.node, 0.4, { morphSVG: "#path-polygon" }); 54598 }); 54599 54600 icon_container.addEventListener('mouseleave', function () { 54601 _gsap.TweenMax.to(circle.node, 0.4, { morphSVG: "#path-circle" }); 54602 }); 54603 }); 54604 }); 54605 54606 var CTAs = document.querySelectorAll('.cta-plus'); 54607 54608 CTAs.forEach(function (cta) { 54609 54610 var container = Snap(cta); 54611 54612 Snap.load(templateURL + '/dist/images/icons/add.svg', function (e) { 54613 container.append(e); 54614 }); 54615 }); 54616 54617 var download_icons = document.querySelectorAll('.certification_item_icon'); 54618 54619 download_icons.forEach(function (icon) { 54620 54621 var container = Snap(icon); 54622 54623 Snap.load(templateURL + '/dist/images/icons/download.svg', function (e) { 54624 container.append(e); 54625 }); 54626 }); 54627 54628 var media_icons = document.querySelectorAll('.media_cta'); 54629 54630 media_icons.forEach(function (icon) { 54631 54632 var container = Snap(icon); 54633 54634 Snap.load(templateURL + '/dist/images/icons/download-media.svg', function (e) { 54635 container.append(e); 54636 }); 54637 }); 54638 54639 var footer_icons = document.querySelectorAll('.footer_icon a'); 54640 54641 footer_icons.forEach(function (icon) { 54642 54643 var container = Snap(icon); 54644 var svg_file = icon.getAttribute('data-icon'); 54645 54646 Snap.load(templateURL + "/dist/images/icons/" + svg_file + ".svg", function (e) { 54647 container.append(e); 54648 var paths = e.selectAll('path'); 54649 var groups = e.selectAll('g'); 54650 54651 groups.forEach(function (group) { 54652 $(group.node).removeClass('cls-1'); 54653 }); 54654 54655 paths.forEach(function (path) { 54656 return path.attr({ 54657 fill: _variables.COLORS.white 54658 }); 54659 }); 54660 }); 54661 }); 54662 54663 var back_to_top_container = Snap('.footer_back-to-top'); 54664 54665 if (back_to_top_container) { 54666 Snap.load(templateURL + '/dist/images/icons/back-to-top.svg', function (e) { 54667 54668 back_to_top_container.append(e); 54669 }); 54670 } 54671 54672 var key_figures = document.querySelectorAll('.key-figure'); 54673
54674 key_figures.forEach(function (key_figure) { 54675 54676 var bg = key_figure.querySelector('.key-figure_background a'); 54677 54678 var key_figure_container = Snap(bg); 54679 54680 Snap.load(templateURL + '/dist/images/icons/key-figure.svg', function (e) { 54681 54682 var circle = e.select('#path-key-circle'); 54683 54684 key_figure_container.append(e); 54685 54686 key_figure.addEventListener('mouseenter', function () { 54687 _gsap.TweenMax.to(circle.node, 0.4, { morphSVG: '#path-key-polygon' }); 54688 _gsap.TweenMax.to(circle.node, 0.4, { 54689 css: { 'stroke': '#C3987A' } 54690 }); 54691 _gsap.TweenMax.to(circle.node, 0.4, { 54692 opacity: 1 54693 }); 54694 }); 54695 54696 key_figure.addEventListener('mouseleave', function () { 54697 _gsap.TweenMax.to(circle.node, 0.4, { morphSVG: '#path-key-circle' }); 54698 _gsap.TweenMax.to(circle.node, 0.4, { 54699 css: { 'stroke': 'transparent' } 54700 }); 54701 _gsap.TweenMax.to(circle.node, 0.4, { 54702 opacity: 0.4 54703 }); 54704 }); 54705 }); 54706 }); 54707 54708 var search_icons = document.querySelectorAll('.header_nav_search_icon'); 54709 54710 search_icons.forEach(function (search_icon) { 54711 54712 var container = Snap(search_icon); 54713 54714 Snap.load(templateURL + '/dist/images/icons/search.svg', function (e) { 54715 54716 var paths = e.selectAll('path'); 54717 var groups = e.selectAll('g'); 54718 54719 groups.forEach(function (group) { 54720 group.node.classList.remove('cls-1'); 54721 }); 54722 54723 paths.forEach(function (path) { 54724 path.node.classList.remove('cls-2'); 54725 path.attr({ 54726 fill: _variables.COLORS.blue 54727 }); 54728 }); 54729 container.append(e); 54730 }); 54731 }); 54732 54733 var $product_families = document.querySelectorAll('.product-family_icon'); 54734 54735 $product_families.forEach(function (family) { 54736 54737 var data = family.getAttribute('data-icon'); 54738 var container = Snap(family); 54739 54740 Snap.load(data, function (e) { 54741 54742 var icon = e.select('svg'); 54743 var elements = [].concat(_toConsumableArray(icon.selectAll('path')), _toConsumableArray(icon.selectAll('rect')), _toConsumableArray(icon.selectAll('circle'))); 54744 54745 elements.forEach(function (element) { 54746 element.attr({ 54747 fill: _variables.COLORS.blue 54748 }); 54749 }); 54750 54751 container.append(icon); 54752 }); 54753 }); 54754 54755 var $product_anchors = document.querySelectorAll('.product-anchor_image'); 54756 54757 $product_anchors.forEach(function (anchor) { 54758 54759 var data = anchor.getAttribute('data-icon'); 54760 var container = Snap(anchor); 54761 54762 Snap.load(data, function (e) { 54763 54764 var icon = e.select('svg'); 54765 var elements = [].concat(_toConsumableArray(icon.selectAll('path')), _toConsumableArray(icon.selectAll('rect')), _toConsumableArray(icon.selectAll('circle'))); 54766 54767 elements.forEach(function (element) { 54768 54769 element.attr({ 54770 fill: _variables.COLORS.blue 54771 }); 54772 }); 54773 54774 anchor.addEventListener('mouseenter', function () { 54775 54776 elements.forEach(function (element) { 54777 if (element.type !== 'set') { 54778 _gsap.TweenMax.to(element.node, 0.6, { 54779 css: { fill: _variables.COLORS.gold } 54780 }); 54781 } 54782 }); 54783 }); 54784 54785 anchor.addEventListener('mouseleave', function () { 54786 54787 elements.forEach(function (element) { 54788 if (element.type !== 'set') { 54789 _gsap.TweenMax.to(element.node, 0.6, { 54790 css: { fill: _variables.COLORS.blue } 54791 }); 54792 } 54793 }); 54794 }); 54795 54796 container.append(icon); 54797 }); 54798 }); 54799 54800 var $header_decorator = document.querySelector('.header_nav_decorator.--blue'); 54801 54802 if ($header_decorator) { 54803 var container = Snap($header_decorator); 54804 Snap.load(templateURL + '/dist/images/icons/decorator-arc.svg', function (e) { 54805 54806 var svg = e.select('svg'); 54807 54808 container.append(svg); 54809 }); 54810 } 54811 54812 var $header_decorator_gold = document.querySelector('.header_nav_decorator.--gold'); 54813 54814 if ($header_decorator_gold) { 54815 var container_gold = Snap($header_decorator_gold); 54816 54817 Snap.load(templateURL + '/dist/images/icons/decorator-arc-gold.svg', function (e) { 54818 54819 var svg = e.select('svg'); 54820 54821 container_gold.append(svg); 54822 }); 54823 } 54824}); 54825/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4))) 54826 54827/***/ }), 54828/* 185 */ 54829/***/ (function(module, exports, __webpack_require__) { 54830 54831/** 54832 * @namespace Chart 54833 */ 54834var Chart = __webpack_require__(204)(); 54835 54836Chart.helpers = __webpack_require__(1); 54837 54838// @todo dispatch these helpers into appropriated helpers/helpers.* file and write unit tests! 54839__webpack_require__(203)(Chart); 54840 54841Chart.defaults = __webpack_require__(2); 54842Chart.Element = __webpack_require__(5); 54843Chart.elements = __webpack_require__(7); 54844Chart.Interaction = __webpack_require__(21); 54845Chart.layouts = __webpack_require__(9); 54846Chart.platform = __webpack_require__(23); 54847Chart.plugins = __webpack_require__(22); 54848Chart.Ticks = __webpack_require__(10); 54849 54850__webpack_require__(200)(Chart); 54851__webpack_require__(201)(Chart); 54852__webpack_require__(202)(Chart); 54853__webpack_require__(206)(Chart);
54854__webpack_require__(205)(Chart); 54855__webpack_require__(207)(Chart); 54856 54857__webpack_require__(223)(Chart); 54858__webpack_require__(221)(Chart); 54859__webpack_require__(222)(Chart); 54860__webpack_require__(224)(Chart); 54861__webpack_require__(225)(Chart); 54862__webpack_require__(226)(Chart); 54863 54864// Controllers must be loaded after elements 54865// See Chart.core.datasetController.dataElementType 54866__webpack_require__(193)(Chart); 54867__webpack_require__(194)(Chart); 54868__webpack_require__(195)(Chart); 54869__webpack_require__(196)(Chart); 54870__webpack_require__(197)(Chart); 54871__webpack_require__(198)(Chart); 54872__webpack_require__(199)(Chart); 54873 54874__webpack_require__(186)(Chart); 54875__webpack_require__(187)(Chart); 54876__webpack_require__(188)(Chart); 54877__webpack_require__(189)(Chart); 54878__webpack_require__(190)(Chart); 54879__webpack_require__(191)(Chart); 54880__webpack_require__(192)(Chart); 54881 54882// Loading built-it plugins 54883var plugins = __webpack_require__(217); 54884for (var k in plugins) { 54885 if (plugins.hasOwnProperty(k)) { 54886 Chart.plugins.register(plugins[k]); 54887 } 54888} 54889 54890Chart.platform.initialize(); 54891 54892module.exports = Chart; 54893if (typeof window !== 'undefined') { 54894 window.Chart = Chart; 54895} 54896 54897// DEPRECATIONS 54898 54899/** 54900 * Provided for backward compatibility, not available anymore 54901 * @namespace Chart.Legend 54902 * @deprecated since version 2.1.5 54903 * @todo remove at version 3 54904 * @private 54905 */ 54906Chart.Legend = plugins.legend._element; 54907 54908/** 54909 * Provided for backward compatibility, not available anymore 54910 * @namespace Chart.Title 54911 * @deprecated since version 2.1.5 54912 * @todo remove at version 3 54913 * @private 54914 */ 54915Chart.Title = plugins.title._element; 54916 54917/** 54918 * Provided for backward compatibility, use Chart.plugins instead
54919 * @namespace Chart.pluginService 54920 * @deprecated since version 2.1.5 54921 * @todo remove at version 3 54922 * @private 54923 */ 54924Chart.pluginService = Chart.plugins; 54925 54926/** 54927 * Provided for backward compatibility, inheriting from Chart.PlugingBase has no 54928 * effect, instead simply create/register plugins via plain JavaScript objects. 54929 * @interface Chart.PluginBase 54930 * @deprecated since version 2.5.0 54931 * @todo remove at version 3 54932 * @private 54933 */ 54934Chart.PluginBase = Chart.Element.extend({}); 54935 54936/** 54937 * Provided for backward compatibility, use Chart.helpers.canvas instead. 54938 * @namespace Chart.canvasHelpers 54939 * @deprecated since version 2.6.0 54940 * @todo remove at version 3 54941 * @private 54942 */ 54943Chart.canvasHelpers = Chart.helpers.canvas; 54944 54945/** 54946 * Provided for backward compatibility, use Chart.layouts instead. 54947 * @namespace Chart.layoutService 54948 * @deprecated since version 2.8.0 54949 * @todo remove at version 3 54950 * @private 54951 */ 54952Chart.layoutService = Chart.layouts; 54953 54954 54955/***/ }), 54956/* 186 */ 54957/***/ (function(module, exports, __webpack_require__) { 54958 54959"use strict"; 54960 54961 54962module.exports = function(Chart) { 54963 54964 Chart.Bar = function(context, config) { 54965 config.type = 'bar'; 54966 54967 return new Chart(context, config); 54968 }; 54969 54970}; 54971 54972 54973/***/ }), 54974/* 187 */ 54975/***/ (function(module, exports, __webpack_require__) { 54976 54977"use strict"; 54978 54979 54980module.exports = function(Chart) { 54981 54982 Chart.Bubble = function(context, config) { 54983 config.type = 'bubble'; 54984 return new Chart(context, config); 54985 }; 54986 54987}; 54988 54989 54990/***/ }), 54991/* 188 */ 54992/***/ (function(module, exports, __webpack_require__) { 54993 54994"use strict"; 54995 54996 54997module.exports = function(Chart) { 54998 54999 Chart.Doughnut = function(context, config) { 55000 config.type = 'doughnut'; 55001 55002 return new Chart(context, config); 55003 }; 55004 55005}; 55006 55007 55008/***/ }), 55009/* 189 */ 55010/***/ (function(module, exports, __webpack_require__) { 55011 55012"use strict"; 55013 55014 55015module.exports = function(Chart) { 55016 55017 Chart.Line = function(context, config) { 55018 config.type = 'line'; 55019 55020 return new Chart(context, config); 55021 }; 55022 55023}; 55024 55025 55026/***/ }), 55027/* 190 */ 55028/***/ (function(module, exports, __webpack_require__) { 55029 55030"use strict"; 55031 55032 55033module.exports = function(Chart) { 55034 55035 Chart.PolarArea = function(context, config) { 55036 config.type = 'polarArea'; 55037 55038 return new Chart(context, config); 55039 }; 55040 55041}; 55042 55043 55044/***/ }), 55045/* 191 */ 55046/***/ (function(module, exports, __webpack_require__) { 55047 55048"use strict"; 55049 55050 55051module.exports = function(Chart) { 55052 55053 Chart.Radar = function(context, config) { 55054 config.type = 'radar'; 55055 55056 return new Chart(context, config); 55057 }; 55058 55059}; 55060 55061 55062/***/ }), 55063/* 192 */ 55064/***/ (function(module, exports, __webpack_require__) { 55065 55066"use strict"; 55067 55068 55069module.exports = function(Chart) { 55070 Chart.Scatter = function(context, config) { 55071 config.type = 'scatter'; 55072 return new Chart(context, config); 55073 }; 55074}; 55075 55076 55077/***/ }), 55078/* 193 */ 55079/***/ (function(module, exports, __webpack_require__) { 55080 55081"use strict"; 55082 55083 55084var defaults = __webpack_require__(2); 55085var elements = __webpack_require__(7); 55086var helpers = __webpack_require__(1); 55087 55088defaults._set('bar', { 55089 hover: { 55090 mode: 'label' 55091 }, 55092 55093 scales: { 55094 xAxes: [{ 55095 type: 'category', 55096 55097 // Specific to Bar Controller 55098 categoryPercentage: 0.8, 55099 barPercentage: 0.9, 55100 55101 // offset settings 55102 offset: true, 55103 55104 // grid line settings 55105 gridLines: { 55106 offsetGridLines: true 55107 } 55108 }], 55109 55110 yAxes: [{ 55111 type: 'linear' 55112 }] 55113 } 55114}); 55115 55116defaults._set('horizontalBar', { 55117 hover: { 55118 mode: 'index', 55119 axis: 'y' 55120 }, 55121 55122 scales: { 55123 xAxes: [{ 55124 type: 'linear', 55125 position: 'bottom' 55126 }], 55127 55128 yAxes: [{ 55129 position: 'left', 55130 type: 'category', 55131 55132 // Specific to Horizontal Bar Controller 55133 categoryPercentage: 0.8, 55134 barPercentage: 0.9, 55135 55136 // offset settings 55137 offset: true, 55138 55139 // grid line settings 55140 gridLines: { 55141 offsetGridLines: true 55142 } 55143 }] 55144 }, 55145 55146 elements: { 55147 rectangle: { 55148 borderSkipped: 'left' 55149 } 55150 }, 55151 55152 tooltips: { 55153 callbacks: { 55154 title: function(item, data) { 55155 // Pick first xLabel for now 55156 var title = ''; 55157 55158 if (item.length > 0) { 55159 if (item[0].yLabel) { 55160 title = item[0].yLabel; 55161 } else if (data.labels.length > 0 && item[0].index < data.labels.length) { 55162 title = data.labels[item[0].index]; 55163 } 55164 } 55165 55166 return title; 55167 }, 55168 55169 label: function(item, data) { 55170 var datasetLabel = data.datasets[item.datasetIndex].label || ''; 55171 return datasetLabel + ': ' + item.xLabel; 55172 } 55173 }, 55174 mode: 'index', 55175 axis: 'y' 55176 } 55177}); 55178 55179/** 55180 * Computes the "optimal" sample size to maintain bars equally sized while preventing overlap. 55181 * @private 55182 */ 55183function computeMinSampleSize(scale, pixels) { 55184 var min = scale.isHorizontal() ? scale.width : scale.height; 55185 var ticks = scale.getTicks(); 55186 var prev, curr, i, ilen; 55187 55188 for (i = 1, ilen = pixels.length; i < ilen; ++i) { 55189 min = Math.min(min, pixels[i] - pixels[i - 1]); 55190 } 55191 55192 for (i = 0, ilen = ticks.length; i < ilen; ++i) { 55193 curr = scale.getPixelForTick(i); 55194 min = i > 0 ? Math.min(min, curr - prev) : min; 55195 prev = curr; 55196 } 55197 55198 return min; 55199} 55200 55201/** 55202 * Computes an "ideal" category based on the absolute bar thickness or, if undefined or null, 55203 * uses the smallest interval (see computeMinSampleSize) that prevents bar overlapping. This 55204 * mode currently always generates bars equally sized (until we introduce scriptable options?). 55205 * @private 55206 */ 55207function computeFitCategoryTraits(index, ruler, options) { 55208 var thickness = options.barThickness; 55209 var count = ruler.stackCount; 55210 var curr = ruler.pixels[index]; 55211 var size, ratio; 55212 55213 if (helpers.isNullOrUndef(thickness)) { 55214 size = ruler.min * options.categoryPercentage; 55215 ratio = options.barPercentage; 55216 } else { 55217 // When bar thickness is enforced, category and bar percentages are ignored. 55218 // Note(SB): we could add support for relative bar thickness (e.g. barThickness: '50%') 55219 // and deprecate barPercentage since this value is ignored when thickness is absolute. 55220 size = thickness * count; 55221 ratio = 1; 55222 } 55223 55224 return { 55225 chunk: size / count, 55226 ratio: ratio, 55227 start: curr - (size / 2) 55228 }; 55229} 55230 55231/** 55232 * Computes an "optimal" category that globally arranges bars side by side (no gap when 55233 * percentage options are 1), based on the previous and following categories. This mode 55234 * generates bars with different widths when data are not evenly spaced. 55235 * @private 55236 */ 55237function computeFlexCategoryTraits(index, ruler, options) { 55238 var pixels = ruler.pixels; 55239 var curr = pixels[index]; 55240 var prev = index > 0 ? pixels[index - 1] : null; 55241 var next = index < pixels.length - 1 ? pixels[index + 1] : null; 55242 var percent = options.categoryPercentage; 55243 var start, size; 55244 55245 if (prev === null) { 55246 // first data: its size is double based on the next point or, 55247 // if it's also the last data, we use the scale end extremity. 55248 prev = curr - (next === null ? ruler.end - curr : next - curr); 55249 } 55250 55251 if (next === null) { 55252 // last data: its size is also double based on the previous point. 55253 next = curr + curr - prev; 55254 } 55255 55256 start = curr - ((curr - prev) / 2) * percent; 55257 size = ((next - prev) / 2) * percent; 55258 55259 return { 55260 chunk: size / ruler.stackCount, 55261 ratio: options.barPercentage, 55262 start: start 55263 }; 55264} 55265 55266module.exports = function(Chart) { 55267 55268 Chart.controllers.bar = Chart.DatasetController.extend({ 55269 55270 dataElementType: elements.Rectangle, 55271 55272 initialize: function() { 55273 var me = this; 55274 var meta; 55275 55276 Chart.DatasetController.prototype.initialize.apply(me, arguments); 55277 55278 meta = me.getMeta(); 55279 meta.stack = me.getDataset().stack; 55280 meta.bar = true; 55281 }, 55282 55283 update: function(reset) { 55284 var me = this; 55285 var rects = me.getMeta().data; 55286 var i, ilen; 55287 55288 me._ruler = me.getRuler(); 55289 55290 for (i = 0, ilen = rects.length; i < ilen; ++i) { 55291 me.updateElement(rects[i], i, reset); 55292 } 55293 }, 55294 55295 updateElement: function(rectangle, index, reset) { 55296 var me = this; 55297 var chart = me.chart; 55298 var meta = me.getMeta(); 55299 var dataset = me.getDataset(); 55300 var custom = rectangle.custom || {}; 55301 var rectangleOptions = chart.options.elements.rectangle; 55302 55303 rectangle._xScale = me.getScaleForId(meta.xAxisID); 55304 rectangle._yScale = me.getScaleForId(meta.yAxisID); 55305 rectangle._datasetIndex = me.index; 55306 rectangle._index = index; 55307 55308 rectangle._model = { 55309 datasetLabel: dataset.label, 55310 label: chart.data.labels[index], 55311 borderSkipped: custom.borderSkipped ? custom.borderSkipped : rectangleOptions.borderSkipped, 55312 backgroundColor: custom.backgroundColor ? custom.backgroundColor : helpers.valueAtIndexOrDefault(dataset.backgroundColor, index, rectangleOptions.backgroundColor), 55313 borderColor: custom.borderColor ? custom.borderColor : helpers.valueAtIndexOrDefault(dataset.borderColor, index, rectangleOptions.borderColor), 55314 borderWidth: custom.borderWidth ? custom.borderWidth : helpers.valueAtIndexOrDefault(dataset.borderWidth, index, rectangleOptions.borderWidth) 55315 }; 55316 55317 me.updateElementGeometry(rectangle, index, reset); 55318 55319 rectangle.pivot(); 55320 }, 55321 55322 /** 55323 * @private 55324 */ 55325 updateElementGeometry: function(rectangle, index, reset) { 55326 var me = this; 55327 var model = rectangle._model; 55328 var vscale = me.getValueScale(); 55329 var base = vscale.getBasePixel(); 55330 var horizontal = vscale.isHorizontal(); 55331 var ruler = me._ruler || me.getRuler(); 55332 var vpixels = me.calculateBarValuePixels(me.index, index); 55333 var ipixels = me.calculateBarIndexPixels(me.index, index, ruler); 55334 55335 model.horizontal = horizontal; 55336 model.base = reset ? base : vpixels.base; 55337 model.x = horizontal ? reset ? base : vpixels.head : ipixels.center; 55338 model.y = horizontal ? ipixels.center : reset ? base : vpixels.head; 55339 model.height = horizontal ? ipixels.size : undefined; 55340 model.width = horizontal ? undefined : ipixels.size; 55341 }, 55342 55343 /** 55344 * @private 55345 */ 55346 getValueScaleId: function() { 55347 return this.getMeta().yAxisID; 55348 }, 55349 55350 /** 55351 * @private 55352 */ 55353 getIndexScaleId: function() { 55354 return this.getMeta().xAxisID; 55355 }, 55356 55357 /** 55358 * @private 55359 */ 55360 getValueScale: function() {
55361 return this.getScaleForId(this.getValueScaleId()); 55362 }, 55363 55364 /** 55365 * @private 55366 */ 55367 getIndexScale: function() { 55368 return this.getScaleForId(this.getIndexScaleId()); 55369 }, 55370 55371 /** 55372 * Returns the stacks based on groups and bar visibility. 55373 * @param {Number} [last] - The dataset index 55374 * @returns {Array} The stack list 55375 * @private 55376 */ 55377 _getStacks: function(last) { 55378 var me = this; 55379 var chart = me.chart; 55380 var scale = me.getIndexScale(); 55381 var stacked = scale.options.stacked; 55382 var ilen = last === undefined ? chart.data.datasets.length : last + 1; 55383 var stacks = []; 55384 var i, meta; 55385 55386 for (i = 0; i < ilen; ++i) { 55387 meta = chart.getDatasetMeta(i); 55388 if (meta.bar && chart.isDatasetVisible(i) && 55389 (stacked === false || 55390 (stacked === true && stacks.indexOf(meta.stack) === -1) || 55391 (stacked === undefined && (meta.stack === undefined || stacks.indexOf(meta.stack) === -1)))) { 55392 stacks.push(meta.stack); 55393 } 55394 } 55395 55396 return stacks; 55397 }, 55398 55399 /** 55400 * Returns the effective number of stacks based on groups and bar visibility. 55401 * @private 55402 */ 55403 getStackCount: function() { 55404 return this._getStacks().length; 55405 }, 55406 55407 /** 55408 * Returns the stack index for the given dataset based on groups and bar visibility. 55409 * @param {Number} [datasetIndex] - The dataset index 55410 * @param {String} [name] - The stack name to find 55411 * @returns {Number} The stack index 55412 * @private 55413 */ 55414 getStackIndex: function(datasetIndex, name) { 55415 var stacks = this._getStacks(datasetIndex); 55416 var index = (name !== undefined) 55417 ? stacks.indexOf(name) 55418 : -1; // indexOf returns -1 if element is not present 55419 55420 return (index === -1) 55421 ? stacks.length - 1 55422 : index; 55423 }, 55424 55425 /** 55426 * @private 55427 */ 55428 getRuler: function() { 55429 var me = this; 55430 var scale = me.getIndexScale(); 55431 var stackCount = me.getStackCount(); 55432 var datasetIndex = me.index; 55433 var isHorizontal = scale.isHorizontal(); 55434 var start = isHorizontal ? scale.left : scale.top; 55435 var end = start + (isHorizontal ? scale.width : scale.height); 55436 var pixels = []; 55437 var i, ilen, min; 55438 55439 for (i = 0, ilen = me.getMeta().data.length; i < ilen; ++i) { 55440 pixels.push(scale.getPixelForValue(null, i, datasetIndex)); 55441 } 55442 55443 min = helpers.isNullOrUndef(scale.options.barThickness) 55444 ? computeMinSampleSize(scale, pixels) 55445 : -1; 55446 55447 return { 55448 min: min, 55449 pixels: pixels, 55450 start: start, 55451 end: end, 55452 stackCount: stackCount, 55453 scale: scale 55454 }; 55455 }, 55456 55457 /** 55458 * Note: pixel values are not clamped to the scale area. 55459 * @private 55460 */ 55461 calculateBarValuePixels: function(datasetIndex, index) { 55462 var me = this; 55463 var chart = me.chart; 55464 var meta = me.getMeta(); 55465 var scale = me.getValueScale(); 55466 var datasets = chart.data.datasets; 55467 var value = scale.getRightValue(datasets[datasetIndex].data[index]); 55468 var stacked = scale.options.stacked; 55469 var stack = meta.stack; 55470 var start = 0; 55471 var i, imeta, ivalue, base, head, size; 55472 55473 if (stacked || (stacked === undefined && stack !== undefined)) { 55474 for (i = 0; i < datasetIndex; ++i) { 55475 imeta = chart.getDatasetMeta(i); 55476 55477 if (imeta.bar && 55478 imeta.stack === stack && 55479 imeta.controller.getValueScaleId() === scale.id && 55480 chart.isDatasetVisible(i)) { 55481 55482 ivalue = scale.getRightValue(datasets[i].data[index]); 55483 if ((value < 0 && ivalue < 0) || (value >= 0 && ivalue > 0)) { 55484 start += ivalue; 55485 } 55486 } 55487 } 55488 } 55489 55490 base = scale.getPixelForValue(start); 55491 head = scale.getPixelForValue(start + value); 55492 size = (head - base) / 2; 55493 55494 return { 55495 size: size, 55496 base: base, 55497 head: head, 55498 center: head + size / 2 55499 }; 55500 }, 55501 55502 /** 55503 * @private 55504 */ 55505 calculateBarIndexPixels: function(datasetIndex, index, ruler) { 55506 var me = this; 55507 var options = ruler.scale.options; 55508 var range = options.barThickness === 'flex' 55509 ? computeFlexCategoryTraits(index, ruler, options) 55510 : computeFitCategoryTraits(index, ruler, options); 55511 55512 var stackIndex = me.getStackIndex(datasetIndex, me.getMeta().stack); 55513 var center = range.start + (range.chunk * stackIndex) + (range.chunk / 2); 55514 var size = Math.min( 55515 helpers.valueOrDefault(options.maxBarThickness, Infinity), 55516 range.chunk * range.ratio); 55517 55518 return { 55519 base: center - size / 2, 55520 head: center + size / 2, 55521 center: center, 55522 size: size 55523 }; 55524 }, 55525 55526 draw: function() { 55527 var me = this; 55528 var chart = me.chart; 55529 var scale = me.getValueScale(); 55530 var rects = me.getMeta().data; 55531 var dataset = me.getDataset(); 55532 var ilen = rects.length; 55533 var i = 0; 55534 55535 helpers.canvas.clipArea(chart.ctx, chart.chartArea); 55536 55537 for (; i < ilen; ++i) { 55538 if (!isNaN(scale.getRightValue(dataset.data[i]))) { 55539 rects[i].draw(); 55540 } 55541 } 55542 55543 helpers.canvas.unclipArea(chart.ctx); 55544 }, 55545 55546 setHoverStyle: function(rectangle) { 55547 var dataset = this.chart.data.datasets[rectangle._datasetIndex]; 55548 var index = rectangle._index; 55549 var custom = rectangle.custom || {}; 55550 var model = rectangle._model; 55551
vendor: 4,312 bytes, lines 55552-55698
55552 model.backgroundColor = custom.hoverBackgroundColor ? custom.hoverBackgroundColor : helpers.valueAtIndexOrDefault(dataset.hoverBackgroundColor, index, helpers.getHoverColor(model.backgroundColor)); 55553 model.borderColor = custom.hoverBorderColor ? custom.hoverBorderColor : helpers.valueAtIndexOrDefault(dataset.hoverBorderColor, index, helpers.getHoverColor(model.borderColor)); 55554 model.borderWidth = custom.hoverBorderWidth ? custom.hoverBorderWidth : helpers.valueAtIndexOrDefault(dataset.hoverBorderWidth, index, model.borderWidth); 55555 }, 55556 55557 removeHoverStyle: function(rectangle) { 55558 var dataset = this.chart.data.datasets[rectangle._datasetIndex]; 55559 var index = rectangle._index; 55560 var custom = rectangle.custom || {}; 55561 var model = rectangle._model; 55562 var rectangleElementOptions = this.chart.options.elements.rectangle; 55563 55564 model.backgroundColor = custom.backgroundColor ? custom.backgroundColor : helpers.valueAtIndexOrDefault(dataset.backgroundColor, index, rectangleElementOptions.backgroundColor); 55565 model.borderColor = custom.borderColor ? custom.borderColor : helpers.valueAtIndexOrDefault(dataset.borderColor, index, rectangleElementOptions.borderColor); 55566 model.borderWidth = custom.borderWidth ? custom.borderWidth : helpers.valueAtIndexOrDefault(dataset.borderWidth, index, rectangleElementOptions.borderWidth); 55567 } 55568 }); 55569 55570 Chart.controllers.horizontalBar = Chart.controllers.bar.extend({ 55571 /** 55572 * @private 55573 */ 55574 getValueScaleId: function() { 55575 return this.getMeta().xAxisID; 55576 }, 55577 55578 /** 55579 * @private 55580 */ 55581 getIndexScaleId: function() { 55582 return this.getMeta().yAxisID; 55583 } 55584 }); 55585}; 55586 55587 55588/***/ }), 55589/* 194 */ 55590/***/ (function(module, exports, __webpack_require__) { 55591 55592"use strict"; 55593 55594 55595var defaults = __webpack_require__(2); 55596var elements = __webpack_require__(7); 55597var helpers = __webpack_require__(1); 55598 55599defaults._set('bubble', { 55600 hover: { 55601 mode: 'single' 55602 }, 55603 55604 scales: { 55605 xAxes: [{ 55606 type: 'linear', // bubble should probably use a linear scale by default 55607 position: 'bottom', 55608 id: 'x-axis-0' // need an ID so datasets can reference the scale 55609 }], 55610 yAxes: [{ 55611 type: 'linear', 55612 position: 'left', 55613 id: 'y-axis-0' 55614 }] 55615 }, 55616 55617 tooltips: { 55618 callbacks: { 55619 title: function() { 55620 // Title doesn't make sense for scatter since we format the data as a point 55621 return ''; 55622 }, 55623 label: function(item, data) { 55624 var datasetLabel = data.datasets[item.datasetIndex].label || ''; 55625 var dataPoint = data.datasets[item.datasetIndex].data[item.index]; 55626 return datasetLabel + ': (' + item.xLabel + ', ' + item.yLabel + ', ' + dataPoint.r + ')'; 55627 } 55628 } 55629 } 55630}); 55631 55632 55633module.exports = function(Chart) { 55634 55635 Chart.controllers.bubble = Chart.DatasetController.extend({ 55636 /** 55637 * @protected 55638 */ 55639 dataElementType: elements.Point, 55640 55641 /** 55642 * @protected 55643 */ 55644 update: function(reset) { 55645 var me = this; 55646 var meta = me.getMeta(); 55647 var points = meta.data; 55648 55649 // Update Points 55650 helpers.each(points, function(point, index) { 55651 me.updateElement(point, index, reset); 55652 }); 55653 }, 55654 55655 /** 55656 * @protected 55657 */ 55658 updateElement: function(point, index, reset) { 55659 var me = this; 55660 var meta = me.getMeta(); 55661 var custom = point.custom || {}; 55662 var xScale = me.getScaleForId(meta.xAxisID); 55663 var yScale = me.getScaleForId(meta.yAxisID); 55664 var options = me._resolveElementOptions(point, index); 55665 var data = me.getDataset().data[index]; 55666 var dsIndex = me.index; 55667 55668 var x = reset ? xScale.getPixelForDecimal(0.5) : xScale.getPixelForValue(typeof data === 'object' ? data : NaN, index, dsIndex); 55669 var y = reset ? yScale.getBasePixel() : yScale.getPixelForValue(data, index, dsIndex); 55670 55671 point._xScale = xScale; 55672 point._yScale = yScale; 55673 point._options = options; 55674 point._datasetIndex = dsIndex; 55675 point._index = index; 55676 point._model = { 55677 backgroundColor: options.backgroundColor, 55678 borderColor: options.borderColor, 55679 borderWidth: options.borderWidth, 55680 hitRadius: options.hitRadius, 55681 pointStyle: options.pointStyle, 55682 radius: reset ? 0 : options.radius, 55683 skip: custom.skip || isNaN(x) || isNaN(y), 55684 x: x, 55685 y: y, 55686 }; 55687 55688 point.pivot(); 55689 }, 55690 55691 /** 55692 * @protected 55693 */ 55694 setHoverStyle: function(point) { 55695 var model = point._model; 55696 var options = point._options; 55697 55698 model.backgroundColor = helpers.valueOrDefault(options.hoverBackgroun
55698dColor, helpers.getHoverColor(options.backgroundColor)); 55699 model.borderColor = helpers.valueOrDefault(options.hoverBorderColor, helpers.getHoverColor(options.borderColor)); 55700 model.borderWidth = helpers.valueOrDefault(options.hoverBorderWidth, options.borderWidth); 55701 model.radius = options.radius + options.hoverRadius; 55702 }, 55703 55704 /** 55705 * @protected 55706 */ 55707 removeHoverStyle: function(point) { 55708 var model = point._model; 55709 var options = point._options; 55710 55711 model.backgroundColor = options.backgroundColor; 55712 model.borderColor = options.borderColor; 55713 model.borderWidth = options.borderWidth; 55714 model.radius = options.radius; 55715 }, 55716 55717 /** 55718 * @private 55719 */ 55720 _resolveElementOptions: function(point, index) { 55721 var me = this; 55722 var chart = me.chart; 55723 var datasets = chart.data.datasets; 55724 var dataset = datasets[me.index]; 55725 var custom = point.custom || {}; 55726 var options = chart.options.elements.point; 55727 var resolve = helpers.options.resolve; 55728 var data = dataset.data[index]; 55729 var values = {}; 55730 var i, ilen, key; 55731 55732 // Scriptable options 55733 var context = { 55734 chart: chart, 55735 dataIndex: index, 55736 dataset: dataset, 55737 datasetIndex: me.index 55738 }; 55739 55740 var keys = [ 55741 'backgroundColor', 55742 'borderColor', 55743 'borderWidth', 55744 'hoverBackgroundColor', 55745 'hoverBorderColor', 55746 'hoverBorderWidth', 55747 'hoverRadius', 55748 'hitRadius', 55749 'pointStyle' 55750 ]; 55751 55752 for (i = 0, ilen = keys.length; i < ilen; ++i) { 55753 key = keys[i]; 55754 values[key] = resolve([ 55755 custom[key], 55756 dataset[key], 55757 options[key] 55758 ], context, index); 55759 } 55760 55761 // Custom radius resolution 55762 values.radius = resolve([ 55763 custom.radius, 55764 data ? data.r : undefined, 55765 dataset.radius, 55766 options.radius 55767 ], context, index); 55768 55769 return values; 55770 } 55771 }); 55772}; 55773 55774 55775/***/ }), 55776/* 195 */ 55777/***/ (function(module, exports, __webpack_require__) { 55778 55779"use strict"; 55780 55781 55782var defaults = __webpack_require__(2); 55783var elements = __webpack_require__(7); 55784var helpers = __webpack_require__(1); 55785 55786defaults._set('doughnut', { 55787 animation: { 55788 // Boolean - Whether we animate the rotation of the Doughnut 55789 animateRotate: true, 55790 // Boolean - Whether we animate scaling the Doughnut from the centre 55791 animateScale: false 55792 }, 55793 hover: { 55794 mode: 'single' 55795 }, 55796 legendCallback: function(chart) { 55797 var text = []; 55798 text.push('<ul class="' + chart.id + '-legend">'); 55799 55800 var data = chart.data; 55801 var datasets = data.datasets; 55802 var labels = data.labels; 55803 55804 if (datasets.length) { 55805 for (var i = 0; i < datasets[0].data.length; ++i) { 55806 text.push('<li><span style="background-color:' + datasets[0].backgroundColor[i] + '"></span>'); 55807 if (labels[i]) { 55808 text.push(labels[i]); 55809 } 55810 text.push('</li>'); 55811 } 55812 } 55813 55814 text.push('</ul>'); 55815 return text.join(''); 55816 }, 55817 legend: { 55818 labels: { 55819 generateLabels: function(chart) { 55820 var data = chart.data; 55821 if (data.labels.length && data.datasets.length) { 55822 return data.labels.map(function(label, i) { 55823 var meta = chart.getDatasetMeta(0); 55824 var ds = data.datasets[0]; 55825 var arc = meta.data[i]; 55826 var custom = arc && arc.custom || {}; 55827 var valueAtIndexOrDefault = helpers.valueAtIndexOrDefault; 55828 var arcOpts = chart.options.elements.arc; 55829 var fill = custom.backgroundColor ? custom.backgroundColor : valueAtIndexOrDefault(ds.backgroundColor, i, arcOpts.backgroundColor); 55830 var stroke = custom.borderColor ? custom.borderColor : valueAtIndexOrDefault(ds.borderColor, i, arcOpts.borderColor); 55831 var bw = custom.borderWidth ? custom.borderWidth : valueAtIndexOrDefault(ds.borderWidth, i, arcOpts.borderWidth); 55832 55833 return { 55834 text: label, 55835 fillStyle: fill, 55836 strokeStyle: stroke, 55837 lineWidth: bw, 55838 hidden: isNaN(ds.data[i]) || meta.data[i].hidden, 55839 55840 // Extra data used for toggling the correct item 55841 index: i 55842 }; 55843 }); 55844 } 55845 return []; 55846 } 55847 }, 55848 55849 onClick: function(e, legendItem) { 55850 var index = legendItem.index; 55851 var chart = this.chart; 55852 var i, ilen, meta; 55853 55854 for (i = 0, ilen = (chart.data.datasets || []).length; i < ilen; ++i) { 55855 meta = chart.getDatasetMeta(i); 55856 // toggle visibility of index if exists 55857 if (meta.data[index]) { 55858 meta.data[index].hidden = !meta.data[index].hidden; 55859 } 55860 } 55861
55862 chart.update(); 55863 } 55864 }, 55865 55866 // The percentage of the chart that we cut out of the middle. 55867 cutoutPercentage: 50, 55868 55869 // The rotation of the chart, where the first data arc begins. 55870 rotation: Math.PI * -0.5, 55871 55872 // The total circumference of the chart. 55873 circumference: Math.PI * 2.0, 55874 55875 // Need to override these to give a nice default 55876 tooltips: { 55877 callbacks: { 55878 title: function() { 55879 return ''; 55880 }, 55881 label: function(tooltipItem, data) { 55882 var dataLabel = data.labels[tooltipItem.index]; 55883 var value = ': ' + data.datasets[tooltipItem.datasetIndex].data[tooltipItem.index]; 55884 55885 if (helpers.isArray(dataLabel)) { 55886 // show value on first line of multiline label 55887 // need to clone because we are changing the value 55888 dataLabel = dataLabel.slice(); 55889 dataLabel[0] += value; 55890 } else { 55891 dataLabel += value; 55892 } 55893 55894 return dataLabel; 55895 } 55896 } 55897 } 55898}); 55899 55900defaults._set('pie', helpers.clone(defaults.doughnut)); 55901defaults._set('pie', { 55902 cutoutPercentage: 0 55903}); 55904 55905module.exports = function(Chart) { 55906 55907 Chart.controllers.doughnut = Chart.controllers.pie = Chart.DatasetController.extend({ 55908 55909 dataElementType: elements.Arc, 55910 55911 linkScales: helpers.noop, 55912 55913 // Get index of the dataset in relation to the visible datasets. This allows determining the inner and outer radius correctly 55914 getRingIndex: function(datasetIndex) { 55915 var ringIndex = 0; 55916 55917 for (var j = 0; j < datasetIndex; ++j) { 55918 if (this.chart.isDatasetVisible(j)) { 55919 ++ringIndex; 55920 } 55921 } 55922 55923 return ringIndex; 55924 }, 55925 55926 update: function(reset) { 55927 var me = this; 55928 var chart = me.chart; 55929 var chartArea = chart.chartArea; 55930 var opts = chart.options; 55931 var arcOpts = opts.elements.arc; 55932 var availableWidth = chartArea.right - chartArea.left - arcOpts.borderWidth; 55933 var availableHeight = chartArea.bottom - chartArea.top - arcOpts.borderWidth; 55934 var minSize = Math.min(availableWidth, availableHeight); 55935 var offset = {x: 0, y: 0}; 55936 var meta = me.getMeta(); 55937 var cutoutPercentage = opts.cutoutPercentage; 55938 var circumference = opts.circumference; 55939 55940 // If the chart's circumference isn't a full circle, calculate minSize as a ratio of the width/height of the arc 55941 if (circumference < Math.PI * 2.0) { 55942 var startAngle = opts.rotation % (Math.PI * 2.0); 55943 startAngle += Math.PI * 2.0 * (startAngle >= Math.PI ? -1 : startAngle < -Math.PI ? 1 : 0); 55944 var endAngle = startAngle + circumference; 55945 var start = {x: Math.cos(startAngle), y: Math.sin(startAngle)}; 55946 var end = {x: Math.cos(endAngle), y: Math.sin(endAngle)}; 55947 var contains0 = (startAngle <= 0 && endAngle >= 0) || (startAngle <= Math.PI * 2.0 && Math.PI * 2.0 <= endAngle); 55948 var contains90 = (startAngle <= Math.PI * 0.5 && Math.PI * 0.5 <= endAngle) || (startAngle <= Math.PI * 2.5 && Math.PI * 2.5 <= endAngle); 55949 var contains180 = (startAngle <= -Math.PI && -Math.PI <= endAngle) || (startAngle <= Math.PI && Math.PI <= endAngle); 55950 var contains270 = (startAngle <= -Math.PI * 0.5 && -Math.PI * 0.5 <= endAngle) || (startAngle <= Math.PI * 1.5 && Math.PI * 1.5 <= endAngle); 55951 var cutout = cutoutPercentage / 100.0; 55952 var min = {x: contains180 ? -1 : Math.min(start.x * (start.x < 0 ? 1 : cutout), end.x * (end.x < 0 ? 1 : cutout)), y: contains270 ? -1 : Math.min(start.y * (start.y < 0 ? 1 : cutout), end.y * (end.y < 0 ? 1 : cutout))}; 55953 var max = {x: contains0 ? 1 : Math.max(start.x * (start.x > 0 ? 1 : cutout), end.x * (end.x > 0 ? 1 : cutout)), y: contains90 ? 1 : Math.max(start.y * (start.y > 0 ? 1 : cutout), end.y * (end.y > 0 ? 1 : cutout))}; 55954 var size = {width: (max.x - min.x) * 0.5, height: (max.y - min.y) * 0.5}; 55955 minSize = Math.min(availableWidth / size.width, availableHeight / size.height); 55956 offset = {x: (max.x + min.x) * -0.5, y: (max.y + min.y) * -0.5}; 55957 } 55958 55959 chart.borderWidth = me.getMaxBorderWidth(meta.data); 55960 chart.outerRadius = Math.max((minSize - chart.borderWidth) / 2, 0); 55961 chart.innerRadius = Math.max(cutoutPercentage ? (chart.outerRadius / 100) * (cutoutPercentage) : 0, 0); 55962 chart.radiusLength = (chart.outerRadius - chart.innerRadius) / chart.getVisibleDatasetCount(); 55963 chart.offsetX = offset.x * chart.outerRadius; 55964 chart.offsetY = offset.y * chart.outerRadius; 55965 55966 meta.total = me.calculateTotal(); 55967
55968 me.outerRadius = chart.outerRadius - (chart.radiusLength * me.getRingIndex(me.index)); 55969 me.innerRadius = Math.max(me.outerRadius - chart.radiusLength, 0); 55970 55971 helpers.each(meta.data, function(arc, index) { 55972 me.updateElement(arc, index, reset); 55973 }); 55974 }, 55975 55976 updateElement: function(arc, index, reset) { 55977 var me = this; 55978 var chart = me.chart; 55979 var chartArea = chart.chartArea; 55980 var opts = chart.options; 55981 var animationOpts = opts.animation; 55982 var centerX = (chartArea.left + chartArea.right) / 2; 55983 var centerY = (chartArea.top + chartArea.bottom) / 2; 55984 var startAngle = opts.rotation; // non reset case handled later 55985 var endAngle = opts.rotation; // non reset case handled later 55986 var dataset = me.getDataset(); 55987 var circumference = reset && animationOpts.animateRotate ? 0 : arc.hidden ? 0 : me.calculateCircumference(dataset.data[index]) * (opts.circumference / (2.0 * Math.PI)); 55988 var innerRadius = reset && animationOpts.animateScale ? 0 : me.innerRadius; 55989 var outerRadius = reset && animationOpts.animateScale ? 0 : me.outerRadius; 55990 var valueAtIndexOrDefault = helpers.valueAtIndexOrDefault; 55991 55992 helpers.extend(arc, { 55993 // Utility 55994 _datasetIndex: me.index, 55995 _index: index, 55996 55997 // Desired view properties 55998 _model: { 55999 x: centerX + chart.offsetX, 56000 y: centerY + chart.offsetY, 56001 startAngle: startAngle, 56002 endAngle: endAngle, 56003 circumference: circumference, 56004 outerRadius: outerRadius, 56005 innerRadius: innerRadius, 56006 label: valueAtIndexOrDefault(dataset.label, index, chart.data.labels[index]) 56007 } 56008 }); 56009 56010 var model = arc._model; 56011 // Resets the visual styles 56012 this.removeHoverStyle(arc); 56013 56014 // Set correct angles if not resetting 56015 if (!reset || !animationOpts.animateRotate) { 56016 if (index === 0) { 56017 model.startAngle = opts.rotation; 56018 } else { 56019 model.startAngle = me.getMeta().data[index - 1]._model.endAngle; 56020 } 56021 56022 model.endAngle = model.startAngle + model.circumference; 56023 } 56024 56025 arc.pivot(); 56026 }, 56027 56028 removeHoverStyle: function(arc) { 56029 Chart.DatasetController.prototype.removeHoverStyle.call(this, arc, this.chart.options.elements.arc); 56030 }, 56031 56032 calculateTotal: function() { 56033 var dataset = this.getDataset(); 56034 var meta = this.getMeta(); 56035 var total = 0; 56036 var value; 56037 56038 helpers.each(meta.data, function(element, index) { 56039 value = dataset.data[index]; 56040 if (!isNaN(value) && !element.hidden) { 56041 total += Math.abs(value); 56042 } 56043 }); 56044 56045 /* if (total === 0) { 56046 total = NaN; 56047 }*/ 56048 56049 return total; 56050 }, 56051 56052 calculateCircumference: function(value) { 56053 var total = this.getMeta().total; 56054 if (total > 0 && !isNaN(value)) { 56055 return (Math.PI * 2.0) * (Math.abs(value) / total); 56056 } 56057 return 0; 56058 }, 56059 56060 // gets the max border or hover width to properly scale pie charts 56061 getMaxBorderWidth: function(arcs) { 56062 var max = 0; 56063 var index = this.index; 56064 var length = arcs.length; 56065 var borderWidth; 56066 var hoverWidth; 56067 56068 for (var i = 0; i < length; i++) { 56069 borderWidth = arcs[i]._model ? arcs[i]._model.borderWidth : 0; 56070 hoverWidth = arcs[i]._chart ? arcs[i]._chart.config.data.datasets[index].hoverBorderWidth : 0; 56071 56072 max = borderWidth > max ? borderWidth : max; 56073 max = hoverWidth > max ? hoverWidth : max; 56074 } 56075 return max; 56076 } 56077 }); 56078}; 56079 56080 56081/***/ }), 56082/* 196 */ 56083/***/ (function(module, exports, __webpack_require__) { 56084 56085"use strict"; 56086 56087 56088var defaults = __webpack_require__(2); 56089var elements = __webpack_require__(7); 56090var helpers = __webpack_require__(1); 56091 56092defaults._set('line', { 56093 showLines: true, 56094 spanGaps: false, 56095 56096 hover: { 56097 mode: 'label' 56098 }, 56099 56100 scales: { 56101 xAxes: [{ 56102 type: 'category', 56103 id: 'x-axis-0' 56104 }], 56105 yAxes: [{ 56106 type: 'linear', 56107 id: 'y-axis-0' 56108 }] 56109 } 56110}); 56111 56112module.exports = function(Chart) { 56113 56114 function lineEnabled(dataset, options) { 56115 return helpers.valueOrDefault(dataset.showLine, options.showLines); 56116 } 56117 56118 Chart.controllers.line = Chart.DatasetController.extend({ 56119 56120 datasetElementType: elements.Line, 56121 56122 dataElementType: elements.Point, 56123 56124 update: function(reset) { 56125 var me = this; 56126 var meta = me.getMeta(); 56127 var line = meta.dataset; 56128 var points = meta.data || []; 56129 var options = me.chart.options; 56130 var lineElementOptions = options.elements.line; 56131 var scale = me.getScaleForId(meta.yAxisID); 56132 var i, ilen, custom; 56133 var dataset = me.getDataset(); 56134 var showLine = lineEnabled(dataset, options); 56135 56136 // Update Line 56137 if (showLine) { 56138 custom = line.custom || {}; 56139 56140 // Compatibility: If the properties are defined with only the old name, use those values 56141 if ((dataset.tension !== undefined) && (dataset.lineTension === undefined)) { 56142 dataset.lineTension = dataset.tension; 56143 } 56144 56145 // Utility 56146 line._scale = scale; 56147 line._datasetIndex = me.index; 56148 // Data 56149 line._children = points; 56150 // Model 56151 line._model = { 56152 // Appearance 56153 // The default behavior of lines is to break at null values, according 56154 // to https://github.com/chartjs/Chart.js/issues/2435#issuecomment-216718158 56155 // This option gives lines the ability to span gaps 56156 spanGaps: dataset.spanGaps ? dataset.spanGaps : options.spanGaps, 56157 tension: custom.tension ? custom.tension : helpers.valueOrDefault(dataset.lineTension, lineElementOptions.tension), 56158 backgroundColor: custom.backgroundColor ? custom.backgroundColor : (dataset.backgroundColor || lineElementOptions.backgroundColor), 56159 borderWidth: custom.borderWidth ? custom.borderWidth : (dataset.borderWidth || lineElementOptions.borderWidth), 56160 borderColor: custom.borderColor ? custom.borderColor : (dataset.borderColor || lineElementOptions.borderColor), 56161 borderCapStyle: custom.borderCapStyle ? custom.borderCapStyle : (dataset.borderCapStyle || lineElementOptions.borderCapStyle), 56162 borderDash: custom.borderDash ? custom.borderDash : (dataset.borderDash || lineElementOptions.borderDash), 56163 borderDashOffset: custom.borderDashOffset ? custom.borderDashOffset : (dataset.borderDashOffset || lineElementOptions.borderDashOffset), 56164 borderJoinStyle: custom.borderJoinStyle ? custom.borderJoinStyle : (dataset.borderJoinStyle || lineElementOptions.borderJoinStyle),
56165 fill: custom.fill ? custom.fill : (dataset.fill !== undefined ? dataset.fill : lineElementOptions.fill), 56166 steppedLine: custom.steppedLine ? custom.steppedLine : helpers.valueOrDefault(dataset.steppedLine, lineElementOptions.stepped), 56167 cubicInterpolationMode: custom.cubicInterpolationMode ? custom.cubicInterpolationMode : helpers.valueOrDefault(dataset.cubicInterpolationMode, lineElementOptions.cubicInterpolationMode), 56168 }; 56169 56170 line.pivot(); 56171 } 56172 56173 // Update Points 56174 for (i = 0, ilen = points.length; i < ilen; ++i) { 56175 me.updateElement(points[i], i, reset); 56176 } 56177 56178 if (showLine && line._model.tension !== 0) { 56179 me.updateBezierControlPoints(); 56180 } 56181 56182 // Now pivot the point for animation 56183 for (i = 0, ilen = points.length; i < ilen; ++i) { 56184 points[i].pivot(); 56185 } 56186 }, 56187 56188 getPointBackgroundColor: function(point, index) { 56189 var backgroundColor = this.chart.options.elements.point.backgroundColor; 56190 var dataset = this.getDataset(); 56191 var custom = point.custom || {}; 56192 56193 if (custom.backgroundColor) { 56194 backgroundColor = custom.backgroundColor; 56195 }
56195 else if (dataset.pointBackgroundColor) { 56196 backgroundColor = helpers.valueAtIndexOrDefault(dataset.pointBackgroundColor, index, backgroundColor); 56197 } else if (dataset.backgroundColor) { 56198 backgroundColor = dataset.backgroundColor; 56199 } 56200 56201 return backgroundColor; 56202 }, 56203 56204 getPointBorderColor: function(point, index) { 56205 var borderColor = this.chart.options.elements.point.borderColor; 56206 var dataset = this.getDataset(); 56207 var custom = point.custom || {}; 56208 56209 if (custom.borderColor) { 56210 borderColor = custom.borderColor; 56211 } else if (dataset.pointBorderColor) { 56212 borderColor = helpers.valueAtIndexOrDefault(dataset.pointBorderColor, index, borderColor); 56213 } else if (dataset.borderColor) { 56214 borderColor = dataset.borderColor; 56215 } 56216 56217 return borderColor; 56218 }, 56219 56220 getPointBorderWidth: function(point, index) { 56221 var borderWidth = this.chart.options.elements.point.borderWidth; 56222 var dataset = this.getDataset(); 56223 var custom = point.custom || {}; 56224 56225 if (!isNaN(custom.borderWidth)) { 56226 borderWidth = custom.borderWidth; 56227 } else if (!isNaN(dataset.pointBorderWidth) || helpers.isArray(dataset.pointBorderWidth)) { 56228 borderWidth = helpers.valueAtIndexOrDefault(dataset.pointBorderWidth, index, borderWidth); 56229 } else if (!isNaN(dataset.borderWidth)) { 56230 borderWidth = dataset.borderWidth; 56231 } 56232 56233 return borderWidth; 56234 }, 56235 56236 updateElement: function(point, index, reset) { 56237 var me = this; 56238 var meta = me.getMeta(); 56239 var custom = point.custom || {}; 56240 var dataset = me.getDataset(); 56241 var datasetIndex = me.index; 56242 var value = dataset.data[index]; 56243 var yScale = me.getScaleForId(meta.yAxisID); 56244 var xScale = me.getScaleForId(meta.xAxisID); 56245 var pointOptions = me.chart.options.elements.point; 56246 var x, y; 56247 56248 // Compatibility: If the properties are defined with only the old name, use those values 56249 if ((dataset.radius !== undefined) && (dataset.pointRadius === undefined)) { 56250 dataset.pointRadius = dataset.radius; 56251 } 56252 if ((dataset.hitRadius !== undefined) && (dataset.pointHitRadius === undefined)) { 56253 dataset.pointHitRadius = dataset.hitRadius; 56254 } 56255 56256 x = xScale.getPixelForValue(typeof value === 'object' ? value : NaN, index, datasetIndex); 56257 y = reset ? yScale.getBasePixel() : me.calculatePointY(value, index, datasetIndex); 56258 56259 // Utility 56260 point._xScale = xScale; 56261 point._yScale = yScale; 56262 point._datasetIndex = datasetIndex; 56263 point._index = index; 56264 56265 // Desired view properties 56266 point._model = { 56267 x: x, 56268 y: y, 56269 skip: custom.skip || isNaN(x) || isNaN(y), 56270 // Appearance 56271 radius: custom.radius || helpers.valueAtIndexOrDefault(dataset.pointRadius, index, pointOptions.radius), 56272 pointStyle: custom.pointStyle || helpers.valueAtIndexOrDefault(dataset.pointStyle, index, pointOptions.pointStyle),
56273 backgroundColor: me.getPointBackgroundColor(point, index), 56274 borderColor: me.getPointBorderColor(point, index), 56275 borderWidth: me.getPointBorderWidth(point, index), 56276 tension: meta.dataset._model ? meta.dataset._model.tension : 0, 56277 steppedLine: meta.dataset._model ? meta.dataset._model.steppedLine : false, 56278 // Tooltip 56279 hitRadius: custom.hitRadius || helpers.valueAtIndexOrDefault(dataset.pointHitRadius, index, pointOptions.hitRadius) 56280 }; 56281 }, 56282 56283 calculatePointY: function(value, index, datasetIndex) { 56284 var me = this; 56285 var chart = me.chart; 56286 var meta = me.getMeta(); 56287 var yScale = me.getScaleForId(meta.yAxisID); 56288 var sumPos = 0; 56289 var sumNeg = 0; 56290 var i, ds, dsMeta; 56291 56292 if (yScale.options.stacked) { 56293 for (i = 0; i < datasetIndex; i++) { 56294 ds = chart.data.datasets[i]; 56295 dsMeta = chart.getDatasetMeta(i); 56296 if (dsMeta.type === 'line' && dsMeta.yAxisID === yScale.id && chart.isDatasetVisible(i)) { 56297 var stackedRightValue = Number(yScale.getRightValue(ds.data[index])); 56298 if (stackedRightValue < 0) { 56299 sumNeg += stackedRightValue || 0; 56300 } else { 56301 sumPos += stackedRightValue || 0; 56302 } 56303 } 56304 } 56305 56306 var rightValue = Number(yScale.getRightValue(value)); 56307 if (rightValue < 0) { 56308 return yScale.getPixelForValue(sumNeg + rightValue); 56309 } 56310 return yScale.getPixelForValue(sumPos + rightValue); 56311 } 56312 56313 return yScale.getPixelForValue(value); 56314 }, 56315 56316 updateBezierControlPoints: function() { 56317 var me = this; 56318 var meta = me.getMeta(); 56319 var area = me.chart.chartArea; 56320 var points = (meta.data || []); 56321 var i, ilen, point, model, controlPoints; 56322 56323 // Only consider points that are drawn in case the spanGaps option is used 56324 if (meta.dataset._model.spanGaps) { 56325 points = points.filter(function(pt) { 56326 return !pt._model.skip; 56327 }); 56328 } 56329 56330 function capControlPoint(pt, min, max) { 56331 return Math.max(Math.min(pt, max), min); 56332 } 56333 56334 if (meta.dataset._model.cubicInterpolationMode === 'monotone') { 56335 helpers.splineCurveMonotone(points); 56336 } else { 56337 for (i = 0, ilen = points.length; i < ilen; ++i) { 56338 point = points[i]; 56339 model = point._model; 56340 controlPoints = helpers.splineCurve( 56341 helpers.previousItem(points, i)._model, 56342 model, 56343 helpers.nextItem(points, i)._model, 56344 meta.dataset._model.tension 56345 ); 56346 model.controlPointPreviousX = controlPoints.previous.x; 56347 model.controlPointPreviousY = controlPoints.previous.y; 56348 model.controlPointNextX = controlPoints.next.x; 56349 model.controlPointNextY = controlPoints.next.y; 56350 } 56351 } 56352 56353 if (me.chart.options.elements.line.capBezierPoints) { 56354 for (i = 0, ilen = points.length; i < ilen; ++i) { 56355 model = points[i]._model; 56356 model.controlPointPreviousX = capControlPoint(model.controlPointPreviousX, area.left, area.right); 56357 model.controlPointPreviousY = capControlPoint(model.controlPointPreviousY, area.top, area.bottom); 56358 model.controlPointNextX = capControlPoint(model.controlPointNextX, area.left, area.right); 56359 model.controlPointNextY = capControlPoint(model.controlPointNextY, area.top, area.bottom); 56360 } 56361 } 56362 }, 56363 56364 draw: function() { 56365 var me = this; 56366 var chart = me.chart; 56367 var meta = me.getMeta(); 56368 var points = meta.data || []; 56369 var area = chart.chartArea; 56370 var ilen = points.length; 56371 var i = 0; 56372 56373 helpers.canvas.clipArea(chart.ctx, area); 56374 56375 if (lineEnabled(me.getDataset(), chart.options)) { 56376 meta.dataset.draw(); 56377 } 56378 56379 helpers.canvas.unclipArea(chart.ctx); 56380 56381 // Draw the points 56382 for (; i < ilen; ++i) { 56383 points[i].draw(area); 56384 } 56385 }, 56386 56387 setHoverStyle: function(point) { 56388 // Point 56389 var dataset = this.chart.data.datasets[point._datasetIndex]; 56390 var index = point._index; 56391 var custom = point.custom || {}; 56392 var model = point._model; 56393 56394 model.radius = custom.hoverRadius || helpers.valueAtIndexOrDefault(dataset.pointHoverRadius, index, this.chart.options.elements.point.hoverRadius); 56395 model.backgroundColor = custom.hoverBackgroundColor || helpers.valueAtIndexOrDefault(dataset.pointHoverBackgroundColor, index, helpers.getHoverColor(model.backgroundColor)); 56396 model.borderColor = custom.hoverBorderColor || helpers.valueAtIndexOrDefault(dataset.pointHoverBorderColor, index, helpers.getHoverColor(model.borderColor)); 56397 model.borderWidth = custom.hoverBorderWidth || helpers.valueAtIndexOrDefault(dataset.pointHoverBorderWidth, index, model.borderWidth); 56398 }, 56399 56400 removeHoverStyle: function(point) { 56401 var me = this; 56402 var dataset = me.chart.data.datasets[point._datasetIndex]; 56403 var index = point._index; 56404 var custom = point.custom || {}; 56405 var model = point._model; 56406 56407 // Compatibility: If the properties are defined with only the old name, use those values 56408 if ((dataset.radius !== undefined) && (dataset.pointRadius === undefined)) { 56409 dataset.pointRadius = dataset.radius; 56410 } 56411 56412 model.radius = custom.radius || helpers.valueAtIndexOrDefault(dataset.pointRadius, index, me.chart.options.elements.point.radius);
56413 model.backgroundColor = me.getPointBackgroundColor(point, index); 56414 model.borderColor = me.getPointBorderColor(point, index); 56415 model.borderWidth = me.getPointBorderWidth(point, index); 56416 } 56417 }); 56418}; 56419 56420 56421/***/ }), 56422/* 197 */ 56423/***/ (function(module, exports, __webpack_require__) { 56424 56425"use strict"; 56426 56427 56428var defaults = __webpack_require__(2); 56429var elements = __webpack_require__(7); 56430var helpers = __webpack_require__(1); 56431 56432defaults._set('polarArea', { 56433 scale: { 56434 type: 'radialLinear', 56435 angleLines: { 56436 display: false 56437 }, 56438 gridLines: { 56439 circular: true 56440 }, 56441 pointLabels: { 56442 display: false 56443 }, 56444 ticks: { 56445 beginAtZero: true 56446 } 56447 }, 56448 56449 // Boolean - Whether to animate the rotation of the chart 56450 animation: { 56451 animateRotate: true, 56452 animateScale: true 56453 }, 56454 56455 startAngle: -0.5 * Math.PI, 56456 legendCallback: function(chart) { 56457 var text = []; 56458 text.push('<ul class="' + chart.id + '-legend">'); 56459 56460 var data = chart.data; 56461 var datasets = data.datasets; 56462 var labels = data.labels; 56463 56464 if (datasets.length) { 56465 for (var i = 0; i < datasets[0].data.length; ++i) { 56466 text.push('<li><span style="background-color:' + datasets[0].backgroundColor[i] + '"></span>'); 56467 if (labels[i]) { 56468 text.push(labels[i]); 56469 } 56470 text.push('</li>'); 56471 } 56472 } 56473 56474 text.push('</ul>'); 56475 return text.join(''); 56476 }, 56477 legend: { 56478 labels: { 56479 generateLabels: function(chart) { 56480 var data = chart.data; 56481 if (data.labels.length && data.datasets.length) { 56482 return data.labels.map(function(label, i) { 56483 var meta = chart.getDatasetMeta(0); 56484 var ds = data.datasets[0]; 56485 var arc = meta.data[i]; 56486 var custom = arc.custom || {}; 56487 var valueAtIndexOrDefault = helpers.valueAtIndexOrDefault; 56488 var arcOpts = chart.options.elements.arc; 56489 var fill = custom.backgroundColor ? custom.backgroundColor : valueAtIndexOrDefault(ds.backgroundColor, i, arcOpts.backgroundColor); 56490 var stroke = custom.borderColor ? custom.borderColor : valueAtIndexOrDefault(ds.borderColor, i, arcOpts.borderColor); 56491 var bw = custom.borderWidth ? custom.borderWidth : valueAtIndexOrDefault(ds.borderWidth, i, arcOpts.borderWidth); 56492 56493 return { 56494 text: label, 56495 fillStyle: fill, 56496 strokeStyle: stroke, 56497 lineWidth: bw, 56498 hidden: isNaN(ds.data[i]) || meta.data[i].hidden, 56499 56500 // Extra data used for toggling the correct item 56501 index: i 56502 }; 56503 }); 56504 } 56505 return []; 56506 } 56507 }, 56508 56509 onClick: function(e, legendItem) { 56510 var index = legendItem.index; 56511 var chart = this.chart; 56512 var i, ilen, meta; 56513 56514 for (i = 0, ilen = (chart.data.datasets || []).length; i < ilen; ++i) { 56515 meta = chart.getDatasetMeta(i); 56516 meta.data[index].hidden = !meta.data[index].hidden; 56517 } 56518 56519 chart.update(); 56520 } 56521 }, 56522 56523 // Need to override these to give a nice default 56524 tooltips: { 56525 callbacks: { 56526 title: function() { 56527 return ''; 56528 }, 56529 label: function(item, data) { 56530 return data.labels[item.index] + ': ' + item.yLabel; 56531 } 56532 } 56533 } 56534}); 56535 56536module.exports = function(Chart) { 56537 56538 Chart.controllers.polarArea = Chart.DatasetController.extend({ 56539 56540 dataElementType: elements.Arc, 56541 56542 linkScales: helpers.noop, 56543 56544 update: function(reset) { 56545 var me = this; 56546 var chart = me.chart; 56547 var chartArea = chart.chartArea; 56548 var meta = me.getMeta(); 56549 var opts = chart.options; 56550 var arcOpts = opts.elements.arc; 56551 var minSize = Math.min(chartArea.right - chartArea.left, chartArea.bottom - chartArea.top); 56552 chart.outerRadius = Math.max((minSize - arcOpts.borderWidth / 2) / 2, 0); 56553 chart.innerRadius = Math.max(opts.cutoutPercentage ? (chart.outerRadius / 100) * (opts.cutoutPercentage) : 1, 0); 56554 chart.radiusLength = (chart.outerRadius - chart.innerRadius) / chart.getVisibleDatasetCount(); 56555 56556 me.outerRadius = chart.outerRadius - (chart.radiusLength * me.index);
56557 me.innerRadius = me.outerRadius - chart.radiusLength; 56558 56559 meta.count = me.countVisibleElements(); 56560 56561 helpers.each(meta.data, function(arc, index) { 56562 me.updateElement(arc, index, reset); 56563 }); 56564 }, 56565 56566 updateElement: function(arc, index, reset) { 56567 var me = this; 56568 var chart = me.chart; 56569 var dataset = me.getDataset(); 56570 var opts = chart.options; 56571 var animationOpts = opts.animation; 56572 var scale = chart.scale; 56573 var labels = chart.data.labels; 56574 56575 var circumference = me.calculateCircumference(dataset.data[index]); 56576 var centerX = scale.xCenter; 56577 var centerY = scale.yCenter; 56578 56579 // If there is NaN data before us, we need to calculate the starting angle correctly. 56580 // We could be way more efficient here, but its unlikely that the polar area chart will have a lot of data 56581 var visibleCount = 0; 56582 var meta = me.getMeta(); 56583 for (var i = 0; i < index; ++i) { 56584 if (!isNaN(dataset.data[i]) && !meta.data[i].hidden) { 56585 ++visibleCount; 56586 } 56587 } 56588 56589 // var negHalfPI = -0.5 * Math.PI; 56590 var datasetStartAngle = opts.startAngle; 56591 var distance = arc.hidden ? 0 : scale.getDistanceFromCenterForValue(dataset.data[index]); 56592 var startAngle = datasetStartAngle + (circumference * visibleCount); 56593 var endAngle = startAngle + (arc.hidden ? 0 : circumference); 56594 56595 var resetRadius = animationOpts.animateScale ? 0 : scale.getDistanceFromCenterForValue(dataset.data[index]); 56596 56597 helpers.extend(arc, { 56598 // Utility 56599 _datasetIndex: me.index, 56600 _index: index, 56601 _scale: scale, 56602 56603 // Desired view properties 56604 _model: { 56605 x: centerX, 56606 y: centerY, 56607 innerRadius: 0, 56608 outerRadius: reset ? resetRadius : distance, 56609 startAngle: reset && animationOpts.animateRotate ? datasetStartAngle : startAngle, 56610 endAngle: reset && animationOpts.animateRotate ? datasetStartAngle : endAngle, 56611 label: helpers.valueAtIndexOrDefault(labels, index, labels[index]) 56612 } 56613 }); 56614 56615 // Apply border and fill style 56616 me.removeHoverStyle(arc); 56617 56618 arc.pivot(); 56619 }, 56620 56621 removeHoverStyle: function(arc) { 56622 Chart.DatasetController.prototype.removeHoverStyle.call(this, arc, this.chart.options.elements.arc); 56623 }, 56624 56625 countVisibleElements: function() { 56626 var dataset = this.getDataset(); 56627 var meta = this.getMeta(); 56628 var count = 0; 56629 56630 helpers.each(meta.data, function(element, index) { 56631 if (!isNaN(dataset.data[index]) && !element.hidden) { 56632 count++; 56633 } 56634 }); 56635 56636 return count; 56637 }, 56638 56639 calculateCircumference: function(value) { 56640 var count = this.getMeta().count; 56641 if (count > 0 && !isNaN(value)) { 56642 return (2 * Math.PI) / count; 56643 } 56644 return 0; 56645 } 56646 }); 56647}; 56648 56649 56650/***/ }), 56651/* 198 */ 56652/***/ (function(module, exports, __webpack_require__) { 56653 56654"use strict"; 56655 56656 56657var defaults = __webpack_require__(2); 56658var elements = __webpack_require__(7); 56659var helpers = __webpack_require__(1); 56660 56661defaults._set('radar', { 56662 scale: { 56663 type: 'radialLinear' 56664 }, 56665 elements: { 56666 line: { 56667 tension: 0 // no bezier in radar 56668 } 56669 } 56670}); 56671 56672module.exports = function(Chart) { 56673 56674 Chart.controllers.radar = Chart.DatasetController.extend({ 56675 56676 datasetElementType: elements.Line, 56677 56678 dataElementType: elements.Point, 56679 56680 linkScales: helpers.noop, 56681 56682 update: function(reset) { 56683 var me = this; 56684 var meta = me.getMeta(); 56685 var line = meta.dataset; 56686 var points = meta.data; 56687 var custom = line.custom || {}; 56688 var dataset = me.getDataset(); 56689 var lineElementOptions = me.chart.options.elements.line; 56690 var scale = me.chart.scale; 56691 56692 // Compatibility: If the properties are defined with only the old name, use those values 56693 if ((dataset.tension !== undefined) && (dataset.lineTension === undefined)) { 56694 dataset.lineTension = dataset.tension; 56695 } 56696 56697 helpers.extend(meta.dataset, { 56698 // Utility 56699 _datasetIndex: me.index, 56700 _scale: scale, 56701 // Data 56702 _children: points, 56703 _loop: true, 56704 // Model 56705 _model: { 56706 // Appearance 56707 tension: custom.tension ? custom.tension : helpers.valueOrDefault(dataset.lineTension, lineElementOptions.tension), 56708 backgroundColor: custom.backgroundColor ? custom.backgroundColor : (dataset.backgroundColor || lineElementOptions.backgroundColor), 56709 borderWidth: custom.borderWidth ? custom.borderWidth : (dataset.borderWidth || lineElementOptions.borderWidth), 56710 borderColor: custom.borderColor ? custom.borderColor : (dataset.borderColor || lineElementOptions.borderColor),
56711 fill: custom.fill ? custom.fill : (dataset.fill !== undefined ? dataset.fill : lineElementOptions.fill), 56712 borderCapStyle: custom.borderCapStyle ? custom.borderCapStyle : (dataset.borderCapStyle || lineElementOptions.borderCapStyle), 56713 borderDash: custom.borderDash ? custom.borderDash : (dataset.borderDash || lineElementOptions.borderDash), 56714 borderDashOffset: custom.borderDashOffset ? custom.borderDashOffset : (dataset.borderDashOffset || lineElementOptions.borderDashOffset), 56715 borderJoinStyle: custom.borderJoinStyle ? custom.borderJoinStyle : (dataset.borderJoinStyle || lineElementOptions.borderJoinStyle), 56716 } 56717 }); 56718 56719 meta.dataset.pivot(); 56720 56721 // Update Points 56722 helpers.each(points, function(point, index) { 56723 me.updateElement(point, index, reset); 56724 }, me); 56725 56726 // Update bezier control points 56727 me.updateBezierControlPoints(); 56728 }, 56729 updateElement: function(point, index, reset) { 56730 var me = this; 56731 var custom = point.custom || {}; 56732 var dataset = me.getDataset(); 56733 var scale = me.chart.scale; 56734 var pointElementOptions = me.chart.options.elements.point; 56735 var pointPosition = scale.getPointPositionForValue(index, dataset.data[index]); 56736 56737 // Compatibility: If the properties are defined with only the old name, use those values 56738 if ((dataset.radius !== undefined) && (dataset.pointRadius === undefined)) { 56739 dataset.pointRadius = dataset.radius; 56740 } 56741 if ((dataset.hitRadius !== undefined) && (dataset.pointHitRadius === undefined)) { 56742 dataset.pointHitRadius = dataset.hitRadius; 56743 } 56744 56745 helpers.extend(point, { 56746 // Utility 56747 _datasetIndex: me.index, 56748 _index: index, 56749 _scale: scale, 56750 56751 // Desired view properties 56752 _model: { 56753 x: reset ? scale.xCenter : pointPosition.x, // value not used in dataset scale, but we want a consistent API between scales 56754 y: reset ? scale.yCenter : pointPosition.y, 56755 56756 // Appearance 56757 tension: custom.tension ? custom.tension : helpers.valueOrDefault(dataset.lineTension, me.chart.options.elements.line.tension), 56758 radius: custom.radius ? custom.radius : helpers.valueAtIndexOrDefault(dataset.pointRadius, index, pointElementOptions.radius), 56759 backgroundColor: custom.backgroundColor ? custom.backgroundColor : helpers.valueAtIndexOrDefault(dataset.pointBackgroun
56759dColor, index, pointElementOptions.backgroundColor), 56760 borderColor: custom.borderColor ? custom.borderColor : helpers.valueAtIndexOrDefault(dataset.pointBorderColor, index, pointElementOptions.borderColor), 56761 borderWidth: custom.borderWidth ? custom.borderWidth : helpers.valueAtIndexOrDefault(dataset.pointBorderWidth, index, pointElementOptions.borderWidth), 56762 pointStyle: custom.pointStyle ? custom.pointStyle : helpers.valueAtIndexOrDefault(dataset.pointStyle, index, pointElementOptions.pointStyle), 56763 56764 // Tooltip 56765 hitRadius: custom.hitRadius ? custom.hitRadius : helpers.valueAtIndexOrDefault(dataset.pointHitRadius, index, pointElementOptions.hitRadius) 56766 } 56767 }); 56768 56769 point._model.skip = custom.skip ? custom.skip : (isNaN(point._model.x) || isNaN(point._model.y)); 56770 }, 56771 updateBezierControlPoints: function() { 56772 var chartArea = this.chart.chartArea; 56773 var meta = this.getMeta(); 56774 56775 helpers.each(meta.data, function(point, index) { 56776 var model = point._model; 56777 var controlPoints = helpers.splineCurve( 56778 helpers.previousItem(meta.data, index, true)._model, 56779 model, 56780 helpers.nextItem(meta.data, index, true)._model, 56781 model.tension 56782 ); 56783 56784 // Prevent the bezier going outside of the bounds of the graph 56785 model.controlPointPreviousX = Math.max(Math.min(controlPoints.previous.x, chartArea.right), chartArea.left); 56786 model.controlPointPreviousY = Math.max(Math.min(controlPoints.previous.y, chartArea.bottom), chartArea.top); 56787 56788 model.controlPointNextX = Math.max(Math.min(controlPoints.next.x, chartArea.right), chartArea.left); 56789 model.controlPointNextY = Math.max(Math.min(controlPoints.next.y, chartArea.bottom), chartArea.top); 56790 56791 // Now pivot the point for animation 56792 point.pivot(); 56793 }); 56794 }, 56795 56796 setHoverStyle: function(point) { 56797 // Point 56798 var dataset = this.chart.data.datasets[point._datasetIndex]; 56799 var custom = point.custom || {}; 56800 var index = point._index; 56801 var model = point._model; 56802 56803 model.radius = custom.hoverRadius ? custom.hoverRadius : helpers.valueAtIndexOrDefault(dataset.pointHoverRadius, index, this.chart.options.elements.point.hoverRadius); 56804 model.backgroundColor = custom.hoverBackgroundColor ? custom.hoverBackgroundColor : helpers.valueAtIndexOrDefault(dataset.pointHoverBackgroundColor, index, helpers.getHoverColor(model.backgroundColor)); 56805 model.borderColor = custom.hoverBorderColor ? custom.hoverBorderColor : helpers.valueAtIndexOrDefault(dataset.pointHoverBorderColor, index, helpers.getHoverColor(model.borderColor)); 56806 model.borderWidth = custom.hoverBorderWidth ? custom.hoverBorderWidth : helpers.valueAtIndexOrDefault(dataset.pointHoverBorderWidth, index, model.borderWidth); 56807 }, 56808 56809 removeHoverStyle: function(point) { 56810 var dataset = this.chart.data.datasets[point._datasetIndex]; 56811 var custom = point.custom || {}; 56812 var index = point._index; 56813 var model = point._model; 56814 var pointElementOptions = this.chart.options.elements.point; 56815 56816 model.radius = custom.radius ? custom.radius : helpers.valueAtIndexOrDefault(dataset.pointRadius, index, pointElementOptions.radius); 56817 model.backgroundColor = custom.backgroundColor ? custom.backgroundColor : helpers.valueAtIndexOrDefault(dataset.pointBackgroun
56817dColor, index, pointElementOptions.backgroundColor); 56818 model.borderColor = custom.borderColor ? custom.borderColor : helpers.valueAtIndexOrDefault(dataset.pointBorderColor, index, pointElementOptions.borderColor); 56819 model.borderWidth = custom.borderWidth ? custom.borderWidth : helpers.valueAtIndexOrDefault(dataset.pointBorderWidth, index, pointElementOptions.borderWidth); 56820 } 56821 }); 56822}; 56823 56824 56825/***/ }), 56826/* 199 */ 56827/***/ (function(module, exports, __webpack_require__) { 56828 56829"use strict"; 56830 56831 56832var defaults = __webpack_require__(2); 56833 56834defaults._set('scatter', { 56835 hover: { 56836 mode: 'single' 56837 }, 56838 56839 scales: { 56840 xAxes: [{ 56841 id: 'x-axis-1', // need an ID so datasets can reference the scale 56842 type: 'linear', // scatter should not use a category axis 56843 position: 'bottom' 56844 }], 56845 yAxes: [{ 56846 id: 'y-axis-1', 56847 type: 'linear', 56848 position: 'left' 56849 }] 56850 }, 56851 56852 showLines: false, 56853 56854 tooltips: { 56855 callbacks: { 56856 title: function() { 56857 return ''; // doesn't make sense for scatter since data are formatted as a point 56858 }, 56859 label: function(item) { 56860 return '(' + item.xLabel + ', ' + item.yLabel + ')'; 56861 } 56862 } 56863 } 56864}); 56865 56866module.exports = function(Chart) { 56867 56868 // Scatter charts use line controllers 56869 Chart.controllers.scatter = Chart.controllers.line; 56870 56871}; 56872 56873 56874/***/ }), 56875/* 200 */ 56876/***/ (function(module, exports, __webpack_require__) { 56877 56878"use strict"; 56879/* global window: false */ 56880 56881 56882var defaults = __webpack_require__(2); 56883var Element = __webpack_require__(5); 56884var helpers = __webpack_require__(1); 56885 56886defaults._set('global', { 56887 animation: { 56888 duration: 1000, 56889 easing: 'easeOutQuart', 56890 onProgress: helpers.noop, 56891 onComplete: helpers.noop 56892 } 56893}); 56894 56895module.exports = function(Chart) { 56896 56897 Chart.Animation = Element.extend({ 56898 chart: null, // the animation associated chart instance 56899 currentStep: 0, // the current animation step 56900 numSteps: 60, // default number of steps 56901 easing: '', // the easing to use for this animation 56902 render: null, // render function used by the animation service 56903 56904 onAnimationProgress: null, // user specified callback to fire on each step of the animation 56905 onAnimationComplete: null, // user specified callback to fire when the animation finishes 56906 }); 56907 56908 Chart.animationService = { 56909 frameDuration: 17, 56910 animations: [], 56911 dropFrames: 0, 56912 request: null, 56913 56914 /** 56915 * @param {Chart} chart - The chart to animate. 56916 * @param {Chart.Animation} animation - The animation that we will animate. 56917 * @param {Number} duration - The animation duration in ms. 56918 * @param {Boolean} lazy - if true, the chart is not marked as animating to enable more responsive interactions 56919 */ 56920 addAnimation: function(chart, animation, duration, lazy) { 56921 var animations = this.animations; 56922 var i, ilen; 56923 56924 animation.chart = chart; 56925 56926 if (!lazy) { 56927 chart.animating = true; 56928 } 56929 56930 for (i = 0, ilen = animations.length; i < ilen; ++i) { 56931 if (animations[i].chart === chart) { 56932 animations[i] = animation; 56933 return; 56934 } 56935 } 56936 56937 animations.push(animation); 56938 56939 // If there are no animations queued, manually kickstart a digest, for lack of a better word 56940 if (animations.length === 1) { 56941 this.requestAnimationFrame(); 56942 } 56943 }, 56944 56945 cancelAnimation: function(chart) { 56946 var index = helpers.findIndex(this.animations, function(animation) { 56947 return animation.chart === chart; 56948 }); 56949 56950 if (index !== -1) { 56951 this.animations.splice(index, 1); 56952 chart.animating = false; 56953 } 56954 }, 56955 56956 requestAnimationFrame: function() { 56957 var me = this; 56958 if (me.request === null) { 56959 // Skip animation frame requests until the active one is executed. 56960 // This can happen when processing mouse events, e.g. 'mousemove' 56961 // and 'mouseout' events will trigger multiple renders. 56962 me.request = helpers.requestAnimFrame.call(window, function() { 56963 me.request = null; 56964 me.startDigest(); 56965 }); 56966 } 56967 }, 56968 56969 /** 56970 * @private 56971 */ 56972 startDigest: function() { 56973 var me = this; 56974 var startTime = Date.now(); 56975 var framesToDrop = 0; 56976 56977 if (me.dropFrames > 1) { 56978 framesToDrop = Math.floor(me.dropFrames); 56979 me.dropFrames = me.dropFrames % 1; 56980 } 56981 56982 me.advance(1 + framesToDrop); 56983 56984 var endTime = Date.now(); 56985 56986 me.dropFrames += (endTime - startTime) / me.frameDuration; 56987 56988 // Do we have more stuff to animate? 56989 if (me.animations.length > 0) { 56990 me.requestAnimationFrame(); 56991 } 56992 }, 56993 56994 /** 56995 * @private 56996 */ 56997 advance: function(count) { 56998 var animations = this.animations; 56999 var animation, chart; 57000 var i = 0; 57001 57002 while (i < animations.length) { 57003 animation = animations[i]; 57004 chart = animation.chart; 57005 57006 animation.currentStep = (animation.currentStep || 0) + count; 57007 animation.currentStep = Math.min(animation.currentStep, animation.numSteps); 57008 57009 helpers.callback(animation.render, [chart, animation], chart); 57010 helpers.callback(animation.onAnimationProgress, [animation], chart); 57011 57012 if (animation.currentStep >= animation.numSteps) { 57013 helpers.callback(animation.onAnimationComplete, [animation], chart); 57014 chart.animating = false;
57015 animations.splice(i, 1); 57016 } else { 57017 ++i; 57018 } 57019 } 57020 } 57021 }; 57022 57023 /** 57024 * Provided for backward compatibility, use Chart.Animation instead 57025 * @prop Chart.Animation#animationObject 57026 * @deprecated since version 2.6.0 57027 * @todo remove at version 3 57028 */ 57029 Object.defineProperty(Chart.Animation.prototype, 'animationObject', { 57030 get: function() { 57031 return this; 57032 } 57033 }); 57034 57035 /** 57036 * Provided for backward compatibility, use Chart.Animation#chart instead 57037 * @prop Chart.Animation#chartInstance 57038 * @deprecated since version 2.6.0 57039 * @todo remove at version 3 57040 */ 57041 Object.defineProperty(Chart.Animation.prototype, 'chartInstance', { 57042 get: function() { 57043 return this.chart; 57044 }, 57045 set: function(value) { 57046 this.chart = value; 57047 } 57048 }); 57049 57050}; 57051 57052 57053/***/ }), 57054/* 201 */ 57055/***/ (function(module, exports, __webpack_require__) { 57056 57057"use strict"; 57058 57059 57060var defaults = __webpack_require__(2); 57061var helpers = __webpack_require__(1); 57062var Interaction = __webpack_require__(21); 57063var layouts = __webpack_require__(9); 57064var platform = __webpack_require__(23); 57065var plugins = __webpack_require__(22); 57066 57067module.exports = function(Chart) { 57068 57069 // Create a dictionary of chart types, to allow for extension of existing types 57070 Chart.types = {}; 57071 57072 // Store a reference to each instance - allowing us to globally resize chart instances on window resize. 57073 // Destroy method on the chart will remove the instance of the chart from this reference. 57074 Chart.instances = {}; 57075 57076 // Controllers available for dataset visualization eg. bar, line, slice, etc. 57077 Chart.controllers = {}; 57078 57079 /** 57080 * Initializes the given config with global and chart default values. 57081 */ 57082 function initConfig(config) { 57083 config = config || {}; 57084 57085 // Do NOT use configMerge() for the data object because this method merges arrays 57086 // and so would change references to labels and datasets, preventing data updates. 57087 var data = config.data = config.data || {}; 57088 data.datasets = data.datasets || []; 57089 data.labels = data.labels || []; 57090 57091 config.options = helpers.configMerge( 57092 defaults.global, 57093 defaults[config.type], 57094 config.options || {}); 57095 57096 return config; 57097 } 57098 57099 /** 57100 * Updates the config of the chart 57101 * @param chart {Chart} chart to update the options for 57102 */ 57103 function updateConfig(chart) { 57104 var newOptions = chart.options; 57105 57106 helpers.each(chart.scales, function(scale) { 57107 layouts.removeBox(chart, scale); 57108 }); 57109 57110 newOptions = helpers.configMerge( 57111 Chart.defaults.global, 57112 Chart.defaults[chart.config.type], 57113 newOptions); 57114 57115 chart.options = chart.config.options = newOptions; 57116 chart.ensureScalesHaveIDs(); 57117 chart.buildOrUpdateScales(); 57118 // Tooltip 57119 chart.tooltip._options = newOptions.tooltips; 57120 chart.tooltip.initialize(); 57121 } 57122 57123 function positionIsHorizontal(position) { 57124 return position === 'top' || position === 'bottom'; 57125 } 57126 57127 helpers.extend(Chart.prototype, /** @lends Chart */ { 57128 /** 57129 * @private 57130 */ 57131 construct: function(item, config) { 57132 var me = this; 57133 57134 config = initConfig(config); 57135 57136 var context = platform.acquireContext(item, config); 57137 var canvas = context && context.canvas; 57138 var height = canvas && canvas.height; 57139 var width = canvas && canvas.width; 57140 57141 me.id = helpers.uid(); 57142 me.ctx = context; 57143 me.canvas = canvas; 57144 me.config = config; 57145 me.width = width; 57146 me.height = height; 57147 me.aspectRatio = height ? width / height : null; 57148 me.options = config.options; 57149 me._bufferedRender = false;
vendor: 10,788 bytes, lines 57150-57548
57150 57151 /** 57152 * Provided for backward compatibility, Chart and Chart.Controller have been merged, 57153 * the "instance" still need to be defined since it might be called from plugins. 57154 * @prop Chart#chart 57155 * @deprecated since version 2.6.0 57156 * @todo remove at version 3 57157 * @private 57158 */ 57159 me.chart = me; 57160 me.controller = me; // chart.chart.controller #inception 57161 57162 // Add the chart instance to the global namespace 57163 Chart.instances[me.id] = me; 57164 57165 // Define alias to the config data: `chart.data === chart.config.data` 57166 Object.defineProperty(me, 'data', { 57167 get: function() { 57168 return me.config.data; 57169 }, 57170 set: function(value) { 57171 me.config.data = value; 57172 } 57173 }); 57174 57175 if (!context || !canvas) { 57176 // The given item is not a compatible context2d element, let's return before finalizing 57177 // the chart initialization but after setting basic chart / controller properties that 57178 // can help to figure out that the chart is not valid (e.g chart.canvas !== null); 57179 // https://github.com/chartjs/Chart.js/issues/2807 57180 console.error("Failed to create chart: can't acquire context from the given item"); 57181 return; 57182 } 57183 57184 me.initialize(); 57185 me.update(); 57186 }, 57187 57188 /** 57189 * @private 57190 */ 57191 initialize: function() { 57192 var me = this; 57193 57194 // Before init plugin notification 57195 plugins.notify(me, 'beforeInit'); 57196 57197 helpers.retinaScale(me, me.options.devicePixelRatio); 57198 57199 me.bindEvents(); 57200 57201 if (me.options.responsive) { 57202 // Initial resize before chart draws (must be silent to preserve initial animations). 57203 me.resize(true); 57204 } 57205 57206 // Make sure scales have IDs and are built before we build any controllers. 57207 me.ensureScalesHaveIDs(); 57208 me.buildOrUpdateScales(); 57209 me.initToolTip(); 57210 57211 // After init plugin notification 57212 plugins.notify(me, 'afterInit'); 57213 57214 return me; 57215 }, 57216 57217 clear: function() { 57218 helpers.canvas.clear(this); 57219 return this; 57220 }, 57221 57222 stop: function() { 57223 // Stops any current animation loop occurring 57224 Chart.animationService.cancelAnimation(this); 57225 return this; 57226 }, 57227 57228 resize: function(silent) { 57229 var me = this; 57230 var options = me.options; 57231 var canvas = me.canvas; 57232 var aspectRatio = (options.maintainAspectRatio && me.aspectRatio) || null; 57233 57234 // the canvas render width and height will be casted to integers so make sure that 57235 // the canvas display style uses the same integer values to avoid blurring effect. 57236 57237 // Set to 0 instead of canvas.size because the size defaults to 300x150 if the element is collased 57238 var newWidth = Math.max(0, Math.floor(helpers.getMaximumWidth(canvas))); 57239 var newHeight = Math.max(0, Math.floor(aspectRatio ? newWidth / aspectRatio : helpers.getMaximumHeight(canvas))); 57240 57241 if (me.width === newWidth && me.height === newHeight) { 57242 return; 57243 } 57244 57245 canvas.width = me.width = newWidth; 57246 canvas.height = me.height = newHeight; 57247 canvas.style.width = newWidth + 'px'; 57248 canvas.style.height = newHeight + 'px'; 57249 57250 helpers.retinaScale(me, options.devicePixelRatio); 57251 57252 if (!silent) { 57253 // Notify any plugins about the resize 57254 var newSize = {width: newWidth, height: newHeight}; 57255 plugins.notify(me, 'resize', [newSize]); 57256 57257 // Notify of resize 57258 if (me.options.onResize) { 57259 me.options.onResize(me, newSize); 57260 } 57261 57262 me.stop(); 57263 me.update(me.options.responsiveAnimationDuration); 57264 } 57265 }, 57266 57267 ensureScalesHaveIDs: function() { 57268 var options = this.options; 57269 var scalesOptions = options.scales || {}; 57270 var scaleOptions = options.scale; 57271 57272 helpers.each(scalesOptions.xAxes, function(xAxisOptions, index) { 57273 xAxisOptions.id = xAxisOptions.id || ('x-axis-' + index); 57274 }); 57275 57276 helpers.each(scalesOptions.yAxes, function(yAxisOptions, index) { 57277 yAxisOptions.id = yAxisOptions.id || ('y-axis-' + index); 57278 }); 57279 57280 if (scaleOptions) { 57281 scaleOptions.id = scaleOptions.id || 'scale'; 57282 } 57283 }, 57284 57285 /** 57286 * Builds a map of scale ID to scale object for future lookup. 57287 */ 57288 buildOrUpdateScales: function() { 57289 var me = this; 57290 var options = me.options; 57291 var scales = me.scales || {}; 57292 var items = []; 57293 var updated = Object.keys(scales).reduce(function(obj, id) { 57294 obj[id] = false; 57295 return obj; 57296 }, {}); 57297 57298 if (options.scales) { 57299 items = items.concat( 57300 (options.scales.xAxes || []).map(function(xAxisOptions) { 57301 return {options: xAxisOptions, dtype: 'category', dposition: 'bottom'}; 57302 }), 57303 (options.scales.yAxes || []).map(function(yAxisOptions) { 57304 return {options: yAxisOptions, dtype: 'linear', dposition: 'left'}; 57305 }) 57306 ); 57307 } 57308 57309 if (options.scale) { 57310 items.push({ 57311 options: options.scale, 57312 dtype: 'radialLinear', 57313 isDefault: true, 57314 dposition: 'chartArea' 57315 }); 57316 } 57317 57318 helpers.each(items, function(item) { 57319 var scaleOptions = item.options; 57320 var id = scaleOptions.id; 57321 var scaleType = helpers.valueOrDefault(scaleOptions.type, item.dtype); 57322 57323 if (positionIsHorizontal(scaleOptions.position) !== positionIsHorizontal(item.dposition)) { 57324 scaleOptions.position = item.dposition; 57325 } 57326 57327 updated[id] = true; 57328 var scale = null; 57329 if (id in scales && scales[id].type === scaleType) { 57330 scale = scales[id]; 57331 scale.options = scaleOptions; 57332 scale.ctx = me.ctx; 57333 scale.chart = me; 57334 } else { 57335 var scaleClass = Chart.scaleService.getScaleConstructor(scaleType); 57336 if (!scaleClass) { 57337 return; 57338 } 57339 scale = new scaleClass({ 57340 id: id, 57341 type: scaleType, 57342 options: scaleOptions, 57343 ctx: me.ctx, 57344 chart: me 57345 }); 57346 scales[scale.id] = scale; 57347 } 57348 57349 scale.mergeTicksOptions(); 57350 57351 // TODO(SB): I think we should be able to remove this custom case (options.scale) 57352 // and consider it as a regular scale part of the "scales"" map only! This would 57353 // make the logic easier and remove some useless? custom code. 57354 if (item.isDefault) { 57355 me.scale = scale; 57356 } 57357 }); 57358 // clear up discarded scales 57359 helpers.each(updated, function(hasUpdated, id) { 57360 if (!hasUpdated) { 57361 delete scales[id]; 57362 } 57363 }); 57364 57365 me.scales = scales; 57366 57367 Chart.scaleService.addScalesToLayout(this); 57368 }, 57369 57370 buildOrUpdateControllers: function() { 57371 var me = this; 57372 var types = []; 57373 var newControllers = []; 57374 57375 helpers.each(me.data.datasets, function(dataset, datasetIndex) { 57376 var meta = me.getDatasetMeta(datasetIndex); 57377 var type = dataset.type || me.config.type; 57378 57379 if (meta.type && meta.type !== type) { 57380 me.destroyDatasetMeta(datasetIndex); 57381 meta = me.getDatasetMeta(datasetIndex); 57382 } 57383 meta.type = type; 57384 57385 types.push(meta.type); 57386 57387 if (meta.controller) { 57388 meta.controller.updateIndex(datasetIndex); 57389 meta.controller.linkScales(); 57390 } else { 57391 var ControllerClass = Chart.controllers[meta.type]; 57392 if (ControllerClass === undefined) { 57393 throw new Error('"' + meta.type + '" is not a chart type.'); 57394 } 57395 57396 meta.controller = new ControllerClass(me, datasetIndex); 57397 newControllers.push(meta.controller); 57398 } 57399 }, me); 57400 57401 return newControllers; 57402 }, 57403 57404 /** 57405 * Reset the elements of all datasets 57406 * @private 57407 */ 57408 resetElements: function() { 57409 var me = this; 57410 helpers.each(me.data.datasets, function(dataset, datasetIndex) { 57411 me.getDatasetMeta(datasetIndex).controller.reset(); 57412 }, me); 57413 }, 57414 57415 /** 57416 * Resets the chart back to it's state before the initial animation 57417 */ 57418 reset: function() { 57419 this.resetElements(); 57420 this.tooltip.initialize(); 57421 }, 57422 57423 update: function(config) { 57424 var me = this; 57425 57426 if (!config || typeof config !== 'object') { 57427 // backwards compatibility 57428 config = { 57429 duration: config, 57430 lazy: arguments[1] 57431 }; 57432 } 57433 57434 updateConfig(me); 57435 57436 // plugins options references might have change, let's invalidate the cache 57437 // https://github.com/chartjs/Chart.js/issues/5111#issuecomment-355934167 57438 plugins._invalidate(me); 57439 57440 if (plugins.notify(me, 'beforeUpdate') === false) { 57441 return; 57442 } 57443 57444 // In case the entire data object changed 57445 me.tooltip._data = me.data; 57446 57447 // Make sure dataset controllers are updated and new controllers are reset 57448 var newControllers = me.buildOrUpdateControllers(); 57449 57450 // Make sure all dataset controllers have correct meta data counts 57451 helpers.each(me.data.datasets, function(dataset, datasetIndex) { 57452 me.getDatasetMeta(datasetIndex).controller.buildOrUpdateElements(); 57453 }, me); 57454 57455 me.updateLayout(); 57456 57457 // Can only reset the new controllers after the scales have been updated 57458 if (me.options.animation && me.options.animation.duration) { 57459 helpers.each(newControllers, function(controller) { 57460 controller.reset(); 57461 }); 57462 } 57463 57464 me.updateDatasets(); 57465 57466 // Need to reset tooltip in case it is displayed with elements that are removed 57467 // after update. 57468 me.tooltip.initialize(); 57469 57470 // Last active contains items that were previously in the tooltip. 57471 // When we reset the tooltip, we need to clear it 57472 me.lastActive = []; 57473 57474 // Do this before render so that any plugins that need final scale updates can use it 57475 plugins.notify(me, 'afterUpdate'); 57476 57477 if (me._bufferedRender) { 57478 me._bufferedRequest = { 57479 duration: config.duration, 57480 easing: config.easing, 57481 lazy: config.lazy 57482 }; 57483 } else { 57484 me.render(config); 57485 } 57486 }, 57487 57488 /** 57489 * Updates the chart layout unless a plugin returns `false` to the `beforeLayout` 57490 * hook, in which case, plugins will not be called on `afterLayout`. 57491 * @private 57492 */ 57493 updateLayout: function() { 57494 var me = this; 57495 57496 if (plugins.notify(me, 'beforeLayout') === false) { 57497 return; 57498 } 57499 57500 layouts.update(this, this.width, this.height); 57501 57502 /** 57503 * Provided for backward compatibility, use `afterLayout` instead. 57504 * @method IPlugin#afterScaleUpdate 57505 * @deprecated since version 2.5.0 57506 * @todo remove at version 3 57507 * @private 57508 */ 57509 plugins.notify(me, 'afterScaleUpdate'); 57510 plugins.notify(me, 'afterLayout'); 57511 }, 57512 57513 /** 57514 * Updates all datasets unless a plugin returns `false` to the `beforeDatasetsUpdate` 57515 * hook, in which case, plugins will not be called on `afterDatasetsUpdate`. 57516 * @private 57517 */ 57518 updateDatasets: function() { 57519 var me = this; 57520 57521 if (plugins.notify(me, 'beforeDatasetsUpdate') === false) { 57522 return; 57523 } 57524 57525 for (var i = 0, ilen = me.data.datasets.length; i < ilen; ++i) { 57526 me.updateDataset(i); 57527 } 57528 57529 plugins.notify(me, 'afterDatasetsUpdate'); 57530 }, 57531 57532 /** 57533 * Updates dataset at index unless a plugin returns `false` to the `beforeDatasetUpdate` 57534 * hook, in which case, plugins will not be called on `afterDatasetUpdate`. 57535 * @private 57536 */ 57537 updateDataset: function(index) { 57538 var me = this; 57539 var meta = me.getDatasetMeta(index); 57540 var args = { 57541 meta: meta, 57542 index: index 57543 }; 57544 57545 if (plugins.notify(me, 'beforeDatasetUpdate', [args]) === false) { 57546 return; 57547 } 57548
57549 meta.controller.update(); 57550 57551 plugins.notify(me, 'afterDatasetUpdate', [args]); 57552 }, 57553 57554 render: function(config) { 57555 var me = this; 57556 57557 if (!config || typeof config !== 'object') { 57558 // backwards compatibility 57559 config = { 57560 duration: config, 57561 lazy: arguments[1] 57562 }; 57563 } 57564 57565 var duration = config.duration; 57566 var lazy = config.lazy; 57567 57568 if (plugins.notify(me, 'beforeRender') === false) { 57569 return; 57570 } 57571 57572 var animationOptions = me.options.animation; 57573 var onComplete = function(animation) { 57574 plugins.notify(me, 'afterRender'); 57575 helpers.callback(animationOptions && animationOptions.onComplete, [animation], me); 57576 }; 57577 57578 if (animationOptions && ((typeof duration !== 'undefined' && duration !== 0) || (typeof duration === 'undefined' && animationOptions.duration !== 0))) { 57579 var animation = new Chart.Animation({ 57580 numSteps: (duration || animationOptions.duration) / 16.66, // 60 fps 57581 easing: config.easing || animationOptions.easing, 57582 57583 render: function(chart, animationObject) { 57584 var easingFunction = helpers.easing.effects[animationObject.easing]; 57585 var currentStep = animationObject.currentStep; 57586 var stepDecimal = currentStep / animationObject.numSteps; 57587 57588 chart.draw(easingFunction(stepDecimal), stepDecimal, currentStep); 57589 }, 57590 57591 onAnimationProgress: animationOptions.onProgress, 57592 onAnimationComplete: onComplete 57593 }); 57594 57595 Chart.animationService.addAnimation(me, animation, duration, lazy); 57596 } else { 57597 me.draw(); 57598 57599 // See https://github.com/chartjs/Chart.js/issues/3781 57600 onComplete(new Chart.Animation({numSteps: 0, chart: me})); 57601 } 57602 57603 return me; 57604 }, 57605 57606 draw: function(easingValue) { 57607 var me = this; 57608 57609 me.clear(); 57610 57611 if (helpers.isNullOrUndef(easingValue)) { 57612 easingValue = 1; 57613 } 57614 57615 me.transition(easingValue); 57616 57617 if (plugins.notify(me, 'beforeDraw', [easingValue]) === false) { 57618 return; 57619 } 57620 57621 // Draw all the scales 57622 helpers.each(me.boxes, function(box) { 57623 box.draw(me.chartArea); 57624 }, me); 57625 57626 if (me.scale) { 57627 me.scale.draw(); 57628 } 57629 57630 me.drawDatasets(easingValue); 57631 me._drawTooltip(easingValue); 57632 57633 plugins.notify(me, 'afterDraw', [easingValue]); 57634 }, 57635 57636 /** 57637 * @private 57638 */ 57639 transition: function(easingValue) { 57640 var me = this; 57641 57642 for (var i = 0, ilen = (me.data.datasets || []).length; i < ilen; ++i) { 57643 if (me.isDatasetVisible(i)) { 57644 me.getDatasetMeta(i).controller.transition(easingValue); 57645 } 57646 } 57647 57648 me.tooltip.transition(easingValue); 57649 }, 57650 57651 /** 57652 * Draws all datasets unless a plugin returns `false` to the `beforeDatasetsDraw` 57653 * hook, in which case, plugins will not be called on `afterDatasetsDraw`. 57654 * @private 57655 */ 57656 drawDatasets: function(easingValue) { 57657 var me = this; 57658 57659 if (plugins.notify(me, 'beforeDatasetsDraw', [easingValue]) === false) { 57660 return; 57661 } 57662 57663 // Draw datasets reversed to support proper line stacking 57664 for (var i = (me.data.datasets || []).length - 1; i >= 0; --i) { 57665 if (me.isDatasetVisible(i)) { 57666 me.drawDataset(i, easingValue); 57667 } 57668 } 57669 57670 plugins.notify(me, 'afterDatasetsDraw', [easingValue]); 57671 }, 57672 57673 /** 57674 * Draws dataset at index unless a plugin returns `false` to the `beforeDatasetDraw` 57675 * hook, in which case, plugins will not be called on `afterDatasetDraw`. 57676 * @private 57677 */ 57678 drawDataset: function(index, easingValue) { 57679 var me = this; 57680 var meta = me.getDatasetMeta(index); 57681 var args = { 57682 meta: meta, 57683 index: index, 57684 easingValue: easingValue 57685 }; 57686 57687 if (plugins.notify(me, 'beforeDatasetDraw', [args]) === false) { 57688 return; 57689 } 57690 57691 meta.controller.draw(easingValue); 57692 57693 plugins.notify(me, 'afterDatasetDraw', [args]); 57694 }, 57695 57696 /** 57697 * Draws tooltip unless a plugin returns `false` to the `beforeTooltipDraw` 57698 * hook, in which case, plugins will not be called on `afterTooltipDraw`. 57699 * @private 57700 */ 57701 _drawTooltip: function(easingValue) { 57702 var me = this; 57703 var tooltip = me.tooltip; 57704 var args = { 57705 tooltip: tooltip, 57706 easingValue: easingValue 57707 }; 57708 57709 if (plugins.notify(me, 'beforeTooltipDraw', [args]) === false) { 57710 return; 57711 } 57712 57713 tooltip.draw(); 57714 57715 plugins.notify(me, 'afterTooltipDraw', [args]); 57716 }, 57717 57718 // Get the single element that was clicked on
vendor: 32,357 bytes, lines 57719-58842
57719 // @return : An object containing the dataset index and element index of the matching element. Also contains the rectangle that was draw 57720 getElementAtEvent: function(e) { 57721 return Interaction.modes.single(this, e); 57722 }, 57723 57724 getElementsAtEvent: function(e) { 57725 return Interaction.modes.label(this, e, {intersect: true}); 57726 }, 57727 57728 getElementsAtXAxis: function(e) { 57729 return Interaction.modes['x-axis'](this, e, {intersect: true}); 57730 }, 57731 57732 getElementsAtEventForMode: function(e, mode, options) { 57733 var method = Interaction.modes[mode]; 57734 if (typeof method === 'function') { 57735 return method(this, e, options); 57736 } 57737 57738 return []; 57739 }, 57740 57741 getDatasetAtEvent: function(e) { 57742 return Interaction.modes.dataset(this, e, {intersect: true}); 57743 }, 57744 57745 getDatasetMeta: function(datasetIndex) { 57746 var me = this; 57747 var dataset = me.data.datasets[datasetIndex]; 57748 if (!dataset._meta) { 57749 dataset._meta = {}; 57750 } 57751 57752 var meta = dataset._meta[me.id]; 57753 if (!meta) { 57754 meta = dataset._meta[me.id] = { 57755 type: null, 57756 data: [], 57757 dataset: null, 57758 controller: null, 57759 hidden: null, // See isDatasetVisible() comment 57760 xAxisID: null, 57761 yAxisID: null 57762 }; 57763 } 57764 57765 return meta; 57766 }, 57767 57768 getVisibleDatasetCount: function() { 57769 var count = 0; 57770 for (var i = 0, ilen = this.data.datasets.length; i < ilen; ++i) { 57771 if (this.isDatasetVisible(i)) { 57772 count++; 57773 } 57774 } 57775 return count; 57776 }, 57777 57778 isDatasetVisible: function(datasetIndex) { 57779 var meta = this.getDatasetMeta(datasetIndex); 57780 57781 // meta.hidden is a per chart dataset hidden flag override with 3 states: if true or false, 57782 // the dataset.hidden value is ignored, else if null, the dataset hidden state is returned. 57783 return typeof meta.hidden === 'boolean' ? !meta.hidden : !this.data.datasets[datasetIndex].hidden; 57784 }, 57785 57786 generateLegend: function() { 57787 return this.options.legendCallback(this); 57788 }, 57789 57790 /** 57791 * @private 57792 */ 57793 destroyDatasetMeta: function(datasetIndex) { 57794 var id = this.id; 57795 var dataset = this.data.datasets[datasetIndex]; 57796 var meta = dataset._meta && dataset._meta[id]; 57797 57798 if (meta) { 57799 meta.controller.destroy(); 57800 delete dataset._meta[id]; 57801 } 57802 }, 57803 57804 destroy: function() { 57805 var me = this; 57806 var canvas = me.canvas; 57807 var i, ilen; 57808 57809 me.stop(); 57810 57811 // dataset controllers need to cleanup associated data 57812 for (i = 0, ilen = me.data.datasets.length; i < ilen; ++i) { 57813 me.destroyDatasetMeta(i); 57814 } 57815 57816 if (canvas) { 57817 me.unbindEvents(); 57818 helpers.canvas.clear(me); 57819 platform.releaseContext(me.ctx); 57820 me.canvas = null; 57821 me.ctx = null; 57822 } 57823 57824 plugins.notify(me, 'destroy'); 57825 57826 delete Chart.instances[me.id]; 57827 }, 57828 57829 toBase64Image: function() { 57830 return this.canvas.toDataURL.apply(this.canvas, arguments); 57831 }, 57832 57833 initToolTip: function() { 57834 var me = this; 57835 me.tooltip = new Chart.Tooltip({ 57836 _chart: me, 57837 _chartInstance: me, // deprecated, backward compatibility 57838 _data: me.data, 57839 _options: me.options.tooltips 57840 }, me); 57841 }, 57842 57843 /** 57844 * @private 57845 */ 57846 bindEvents: function() { 57847 var me = this; 57848 var listeners = me._listeners = {}; 57849 var listener = function() { 57850 me.eventHandler.apply(me, arguments); 57851 }; 57852 57853 helpers.each(me.options.events, function(type) { 57854 platform.addEventListener(me, type, listener); 57855 listeners[type] = listener; 57856 }); 57857 57858 // Elements used to detect size change should not be injected for non responsive charts. 57859 // See https://github.com/chartjs/Chart.js/issues/2210 57860 if (me.options.responsive) { 57861 listener = function() { 57862 me.resize(); 57863 }; 57864 57865 platform.addEventListener(me, 'resize', listener); 57866 listeners.resize = listener; 57867 } 57868 }, 57869 57870 /** 57871 * @private 57872 */ 57873 unbindEvents: function() { 57874 var me = this; 57875 var listeners = me._listeners; 57876 if (!listeners) { 57877 return; 57878 } 57879 57880 delete me._listeners; 57881 helpers.each(listeners, function(listener, type) { 57882 platform.removeEventListener(me, type, listener); 57883 }); 57884 }, 57885 57886 updateHoverStyle: function(elements, mode, enabled) { 57887 var method = enabled ? 'setHoverStyle' : 'removeHoverStyle'; 57888 var element, i, ilen; 57889 57890 for (i = 0, ilen = elements.length; i < ilen; ++i) { 57891 element = elements[i]; 57892 if (element) { 57893 this.getDatasetMeta(element._datasetIndex).controller[method](element); 57894 } 57895 } 57896 }, 57897 57898 /** 57899 * @private 57900 */ 57901 eventHandler: function(e) { 57902 var me = this; 57903 var tooltip = me.tooltip; 57904 57905 if (plugins.notify(me, 'beforeEvent', [e]) === false) { 57906 return; 57907 } 57908 57909 // Buffer any update calls so that renders do not occur 57910 me._bufferedRender = true; 57911 me._bufferedRequest = null; 57912 57913 var changed = me.handleEvent(e); 57914 // for smooth tooltip animations issue #4989 57915 // the tooltip should be the source of change 57916 // Animation check workaround: 57917 // tooltip._start will be null when tooltip isn't animating 57918 if (tooltip) { 57919 changed = tooltip._start 57920 ? tooltip.handleEvent(e) 57921 : changed | tooltip.handleEvent(e); 57922 } 57923 57924 plugins.notify(me, 'afterEvent', [e]); 57925 57926 var bufferedRequest = me._bufferedRequest; 57927 if (bufferedRequest) { 57928 // If we have an update that was triggered, we need to do a normal render 57929 me.render(bufferedRequest); 57930 } else if (changed && !me.animating) { 57931 // If entering, leaving, or changing elements, animate the change via pivot 57932 me.stop(); 57933 57934 // We only need to render at this point. Updating will cause scales to be 57935 // recomputed generating flicker & using more memory than necessary. 57936 me.render(me.options.hover.animationDuration, true); 57937 } 57938 57939 me._bufferedRender = false; 57940 me._bufferedRequest = null; 57941 57942 return me; 57943 }, 57944 57945 /** 57946 * Handle an event 57947 * @private 57948 * @param {IEvent} event the event to handle 57949 * @return {Boolean} true if the chart needs to re-render 57950 */ 57951 handleEvent: function(e) { 57952 var me = this; 57953 var options = me.options || {}; 57954 var hoverOptions = options.hover; 57955 var changed = false; 57956 57957 me.lastActive = me.lastActive || []; 57958 57959 // Find Active Elements for hover and tooltips 57960 if (e.type === 'mouseout') { 57961 me.active = []; 57962 } else { 57963 me.active = me.getElementsAtEventForMode(e, hoverOptions.mode, hoverOptions); 57964 } 57965 57966 // Invoke onHover hook 57967 // Need to call with native event here to not break backwards compatibility 57968 helpers.callback(options.onHover || options.hover.onHover, [e.native, me.active], me); 57969 57970 if (e.type === 'mouseup' || e.type === 'click') { 57971 if (options.onClick) { 57972 // Use e.native here for backwards compatibility 57973 options.onClick.call(me, e.native, me.active); 57974 } 57975 } 57976 57977 // Remove styling for last active (even if it may still be active) 57978 if (me.lastActive.length) { 57979 me.updateHoverStyle(me.lastActive, hoverOptions.mode, false); 57980 } 57981 57982 // Built in hover styling 57983 if (me.active.length && hoverOptions.mode) { 57984 me.updateHoverStyle(me.active, hoverOptions.mode, true); 57985 } 57986 57987 changed = !helpers.arrayEquals(me.active, me.lastActive); 57988 57989 // Remember Last Actives 57990 me.lastActive = me.active; 57991 57992 return changed; 57993 } 57994 }); 57995 57996 /** 57997 * Provided for backward compatibility, use Chart instead. 57998 * @class Chart.Controller 57999 * @deprecated since version 2.6.0 58000 * @todo remove at version 3 58001 * @private 58002 */ 58003 Chart.Controller = Chart; 58004}; 58005 58006 58007/***/ }), 58008/* 202 */ 58009/***/ (function(module, exports, __webpack_require__) { 58010 58011"use strict"; 58012 58013 58014var helpers = __webpack_require__(1); 58015 58016module.exports = function(Chart) { 58017 58018 var arrayEvents = ['push', 'pop', 'shift', 'splice', 'unshift']; 58019 58020 /** 58021 * Hooks the array methods that add or remove values ('push', pop', 'shift', 'splice', 58022 * 'unshift') and notify the listener AFTER the array has been altered. Listeners are 58023 * called on the 'onData*' callbacks (e.g. onDataPush, etc.) with same arguments. 58024 */ 58025 function listenArrayEvents(array, listener) { 58026 if (array._chartjs) { 58027 array._chartjs.listeners.push(listener); 58028 return; 58029 } 58030 58031 Object.defineProperty(array, '_chartjs', { 58032 configurable: true, 58033 enumerable: false, 58034 value: { 58035 listeners: [listener] 58036 } 58037 }); 58038 58039 arrayEvents.forEach(function(key) { 58040 var method = 'onData' + key.charAt(0).toUpperCase() + key.slice(1); 58041 var base = array[key]; 58042 58043 Object.defineProperty(array, key, { 58044 configurable: true, 58045 enumerable: false, 58046 value: function() { 58047 var args = Array.prototype.slice.call(arguments); 58048 var res = base.apply(this, args); 58049 58050 helpers.each(array._chartjs.listeners, function(object) { 58051 if (typeof object[method] === 'function') { 58052 object[method].apply(object, args); 58053 } 58054 }); 58055 58056 return res; 58057 } 58058 }); 58059 }); 58060 } 58061 58062 /** 58063 * Removes the given array event listener and cleanup extra attached properties (such as 58064 * the _chartjs stub and overridden methods) if array doesn't have any more listeners. 58065 */ 58066 function unlistenArrayEvents(array, listener) { 58067 var stub = array._chartjs; 58068 if (!stub) { 58069 return; 58070 } 58071 58072 var listeners = stub.listeners; 58073 var index = listeners.indexOf(listener); 58074 if (index !== -1) { 58075 listeners.splice(index, 1); 58076 } 58077 58078 if (listeners.length > 0) { 58079 return; 58080 } 58081 58082 arrayEvents.forEach(function(key) { 58083 delete array[key]; 58084 }); 58085 58086 delete array._chartjs; 58087 } 58088 58089 // Base class for all dataset controllers (line, bar, etc) 58090 Chart.DatasetController = function(chart, datasetIndex) { 58091 this.initialize(chart, datasetIndex); 58092 }; 58093 58094 helpers.extend(Chart.DatasetController.prototype, { 58095 58096 /** 58097 * Element type used to generate a meta dataset (e.g. Chart.element.Line). 58098 * @type {Chart.core.element} 58099 */ 58100 datasetElementType: null, 58101 58102 /** 58103 * Element type used to generate a meta data (e.g. Chart.element.Point). 58104 * @type {Chart.core.element} 58105 */ 58106 dataElementType: null, 58107 58108 initialize: function(chart, datasetIndex) { 58109 var me = this; 58110 me.chart = chart; 58111 me.index = datasetIndex; 58112 me.linkScales(); 58113 me.addElements(); 58114 }, 58115 58116 updateIndex: function(datasetIndex) { 58117 this.index = datasetIndex; 58118 }, 58119 58120 linkScales: function() { 58121 var me = this; 58122 var meta = me.getMeta(); 58123 var dataset = me.getDataset(); 58124 58125 if (meta.xAxisID === null || !(meta.xAxisID in me.chart.scales)) { 58126 meta.xAxisID = dataset.xAxisID || me.chart.options.scales.xAxes[0].id; 58127 } 58128 if (meta.yAxisID === null || !(meta.yAxisID in me.chart.scales)) { 58129 meta.yAxisID = dataset.yAxisID || me.chart.options.scales.yAxes[0].id; 58130 } 58131 }, 58132 58133 getDataset: function() { 58134 return this.chart.data.datasets[this.index]; 58135 }, 58136 58137 getMeta: function() { 58138 return this.chart.getDatasetMeta(this.index); 58139 }, 58140 58141 getScaleForId: function(scaleID) { 58142 return this.chart.scales[scaleID]; 58143 }, 58144 58145 reset: function() { 58146 this.update(true); 58147 }, 58148 58149 /** 58150 * @private 58151 */ 58152 destroy: function() { 58153 if (this._data) { 58154 unlistenArrayEvents(this._data, this); 58155 } 58156 }, 58157 58158 createMetaDataset: function() { 58159 var me = this; 58160 var type = me.datasetElementType; 58161 return type && new type({ 58162 _chart: me.chart, 58163 _datasetIndex: me.index 58164 }); 58165 }, 58166 58167 createMetaData: function(index) { 58168 var me = this; 58169 var type = me.dataElementType; 58170 return type && new type({ 58171 _chart: me.chart, 58172 _datasetIndex: me.index, 58173 _index: index 58174 }); 58175 }, 58176 58177 addElements: function() { 58178 var me = this; 58179 var meta = me.getMeta(); 58180 var data = me.getDataset().data || []; 58181 var metaData = meta.data; 58182 var i, ilen; 58183 58184 for (i = 0, ilen = data.length; i < ilen; ++i) { 58185 metaData[i] = metaData[i] || me.createMetaData(i); 58186 } 58187 58188 meta.dataset = meta.dataset || me.createMetaDataset(); 58189 }, 58190 58191 addElementAndReset: function(index) { 58192 var element = this.createMetaData(index); 58193 this.getMeta().data.splice(index, 0, element); 58194 this.updateElement(element, index, true); 58195 }, 58196 58197 buildOrUpdateElements: function() { 58198 var me = this; 58199 var dataset = me.getDataset(); 58200 var data = dataset.data || (dataset.data = []); 58201 58202 // In order to correctly handle data addition/deletion animation (an thus simulate 58203 // real-time charts), we need to monitor these data modifications and synchronize 58204 // the internal meta data accordingly. 58205 if (me._data !== data) { 58206 if (me._data) { 58207 // This case happens when the user replaced the data array instance. 58208 unlistenArrayEvents(me._data, me); 58209 } 58210 58211 listenArrayEvents(data, me); 58212 me._data = data; 58213 } 58214 58215 // Re-sync meta data in case the user replaced the data array or if we missed 58216 // any updates and so make sure that we handle number of datapoints changing. 58217 me.resyncElements(); 58218 }, 58219 58220 update: helpers.noop, 58221 58222 transition: function(easingValue) { 58223 var meta = this.getMeta(); 58224 var elements = meta.data || []; 58225 var ilen = elements.length; 58226 var i = 0; 58227 58228 for (; i < ilen; ++i) { 58229 elements[i].transition(easingValue); 58230 } 58231 58232 if (meta.dataset) { 58233 meta.dataset.transition(easingValue); 58234 } 58235 }, 58236 58237 draw: function() { 58238 var meta = this.getMeta(); 58239 var elements = meta.data || []; 58240 var ilen = elements.length; 58241 var i = 0; 58242 58243 if (meta.dataset) { 58244 meta.dataset.draw(); 58245 } 58246 58247 for (; i < ilen; ++i) { 58248 elements[i].draw(); 58249 } 58250 }, 58251 58252 removeHoverStyle: function(element, elementOpts) { 58253 var dataset = this.chart.data.datasets[element._datasetIndex]; 58254 var index = element._index; 58255 var custom = element.custom || {}; 58256 var valueOrDefault = helpers.valueAtIndexOrDefault; 58257 var model = element._model; 58258 58259 model.backgroundColor = custom.backgroundColor ? custom.backgroundColor : valueOrDefault(dataset.backgroundColor, index, elementOpts.backgroundColor); 58260 model.borderColor = custom.borderColor ? custom.borderColor : valueOrDefault(dataset.borderColor, index, elementOpts.borderColor); 58261 model.borderWidth = custom.borderWidth ? custom.borderWidth : valueOrDefault(dataset.borderWidth, index, elementOpts.borderWidth); 58262 }, 58263 58264 setHoverStyle: function(element) { 58265 var dataset = this.chart.data.datasets[element._datasetIndex]; 58266 var index = element._index; 58267 var custom = element.custom || {}; 58268 var valueOrDefault = helpers.valueAtIndexOrDefault; 58269 var getHoverColor = helpers.getHoverColor; 58270 var model = element._model; 58271 58272 model.backgroundColor = custom.hoverBackgroundColor ? custom.hoverBackgroundColor : valueOrDefault(dataset.hoverBackgroundColor, index, getHoverColor(model.backgroundColor)); 58273 model.borderColor = custom.hoverBorderColor ? custom.hoverBorderColor : valueOrDefault(dataset.hoverBorderColor, index, getHoverColor(model.borderColor)); 58274 model.borderWidth = custom.hoverBorderWidth ? custom.hoverBorderWidth : valueOrDefault(dataset.hoverBorderWidth, index, model.borderWidth); 58275 }, 58276 58277 /** 58278 * @private 58279 */ 58280 resyncElements: function() { 58281 var me = this; 58282 var meta = me.getMeta(); 58283 var data = me.getDataset().data; 58284 var numMeta = meta.data.length; 58285 var numData = data.length; 58286 58287 if (numData < numMeta) { 58288 meta.data.splice(numData, numMeta - numData); 58289 } else if (numData > numMeta) { 58290 me.insertElements(numMeta, numData - numMeta); 58291 } 58292 }, 58293 58294 /** 58295 * @private 58296 */ 58297 insertElements: function(start, count) { 58298 for (var i = 0; i < count; ++i) { 58299 this.addElementAndReset(start + i); 58300 } 58301 }, 58302 58303 /** 58304 * @private 58305 */ 58306 onDataPush: function() { 58307 this.insertElements(this.getDataset().data.length - 1, arguments.length); 58308 }, 58309 58310 /** 58311 * @private 58312 */ 58313 onDataPop: function() { 58314 this.getMeta().data.pop(); 58315 }, 58316 58317 /** 58318 * @private 58319 */ 58320 onDataShift: function() { 58321 this.getMeta().data.shift(); 58322 }, 58323 58324 /** 58325 * @private 58326 */ 58327 onDataSplice: function(start, count) { 58328 this.getMeta().data.splice(start, count); 58329 this.insertElements(start, arguments.length - 2); 58330 }, 58331 58332 /** 58333 * @private 58334 */ 58335 onDataUnshift: function() { 58336 this.insertElements(0, arguments.length); 58337 } 58338 }); 58339 58340 Chart.DatasetController.extend = helpers.inherits; 58341}; 58342 58343 58344/***/ }), 58345/* 203 */ 58346/***/ (function(module, exports, __webpack_require__) { 58347 58348"use strict"; 58349/* global window: false */ 58350/* global document: false */ 58351 58352 58353var color = __webpack_require__(24); 58354var defaults = __webpack_require__(2); 58355var helpers = __webpack_require__(1); 58356 58357module.exports = function(Chart) { 58358 58359 // -- Basic js utility methods 58360 58361 helpers.configMerge = function(/* objects ... */) { 58362 return helpers.merge(helpers.clone(arguments[0]), [].slice.call(arguments, 1), { 58363 merger: function(key, target, source, options) { 58364 var tval = target[key] || {}; 58365 var sval = source[key]; 58366 58367 if (key === 'scales') { 58368 // scale config merging is complex. Add our own function here for that 58369 target[key] = helpers.scaleMerge(tval, sval); 58370 } else if (key === 'scale') { 58371 // used in polar area & radar charts since there is only one scale 58372 target[key] = helpers.merge(tval, [Chart.scaleService.getScaleDefaults(sval.type), sval]); 58373 } else { 58374 helpers._merger(key, target, source, options); 58375 } 58376 } 58377 }); 58378 }; 58379 58380 helpers.scaleMerge = function(/* objects ... */) { 58381 return helpers.merge(helpers.clone(arguments[0]), [].slice.call(arguments, 1), { 58382 merger: function(key, target, source, options) { 58383 if (key === 'xAxes' || key === 'yAxes') { 58384 var slen = source[key].length; 58385 var i, type, scale; 58386 58387 if (!target[key]) { 58388 target[key] = []; 58389 } 58390 58391 for (i = 0; i < slen; ++i) { 58392 scale = source[key][i]; 58393 type = helpers.valueOrDefault(scale.type, key === 'xAxes' ? 'category' : 'linear'); 58394 58395 if (i >= target[key].length) { 58396 target[key].push({}); 58397 } 58398 58399 if (!target[key][i].type || (scale.type && scale.type !== target[key][i].type)) { 58400 // new/untyped scale or type changed: let's apply the new defaults 58401 // then merge source scale to correctly overwrite the defaults. 58402 helpers.merge(target[key][i], [Chart.scaleService.getScaleDefaults(type), scale]); 58403 } else { 58404 // scales type are the same 58405 helpers.merge(target[key][i], scale); 58406 } 58407 } 58408 } else { 58409 helpers._merger(key, target, source, options); 58410 } 58411 } 58412 }); 58413 }; 58414 58415 helpers.where = function(collection, filterCallback) { 58416 if (helpers.isArray(collection) && Array.prototype.filter) { 58417 return collection.filter(filterCallback); 58418 } 58419 var filtered = []; 58420 58421 helpers.each(collection, function(item) { 58422 if (filterCallback(item)) { 58423 filtered.push(item); 58424 } 58425 }); 58426 58427 return filtered; 58428 }; 58429 helpers.findIndex = Array.prototype.findIndex ? 58430 function(array, callback, scope) { 58431 return array.findIndex(callback, scope); 58432 } : 58433 function(array, callback, scope) { 58434 scope = scope === undefined ? array : scope; 58435 for (var i = 0, ilen = array.length; i < ilen; ++i) { 58436 if (callback.call(scope, array[i], i, array)) { 58437 return i; 58438 } 58439 } 58440 return -1; 58441 }; 58442 helpers.findNextWhere = function(arrayToSearch, filterCallback, startIndex) { 58443 // Default to start of the array 58444 if (helpers.isNullOrUndef(startIndex)) { 58445 startIndex = -1; 58446 } 58447 for (var i = startIndex + 1; i < arrayToSearch.length; i++) { 58448 var currentItem = arrayToSearch[i]; 58449 if (filterCallback(currentItem)) { 58450 return currentItem; 58451 } 58452 } 58453 }; 58454 helpers.findPreviousWhere = function(arrayToSearch, filterCallback, startIndex) { 58455 // Default to end of the array 58456 if (helpers.isNullOrUndef(startIndex)) { 58457 startIndex = arrayToSearch.length; 58458 } 58459 for (var i = startIndex - 1; i >= 0; i--) { 58460 var currentItem = arrayToSearch[i]; 58461 if (filterCallback(currentItem)) { 58462 return currentItem; 58463 } 58464 } 58465 }; 58466 58467 // -- Math methods 58468 helpers.isNumber = function(n) { 58469 return !isNaN(parseFloat(n)) && isFinite(n); 58470 }; 58471 helpers.almostEquals = function(x, y, epsilon) { 58472 return Math.abs(x - y) < epsilon; 58473 }; 58474 helpers.almostWhole = function(x, epsilon) { 58475 var rounded = Math.round(x); 58476 return (((rounded - epsilon) < x) && ((rounded + epsilon) > x)); 58477 }; 58478 helpers.max = function(array) { 58479 return array.reduce(function(max, value) { 58480 if (!isNaN(value)) { 58481 return Math.max(max, value); 58482 } 58483 return max; 58484 }, Number.NEGATIVE_INFINITY); 58485 }; 58486 helpers.min = function(array) { 58487 return array.reduce(function(min, value) { 58488 if (!isNaN(value)) { 58489 return Math.min(min, value); 58490 } 58491 return min; 58492 }, Number.POSITIVE_INFINITY); 58493 }; 58494 helpers.sign = Math.sign ? 58495 function(x) { 58496 return Math.sign(x); 58497 } : 58498 function(x) { 58499 x = +x; // convert to a number 58500 if (x === 0 || isNaN(x)) { 58501 return x; 58502 } 58503 return x > 0 ? 1 : -1; 58504 }; 58505 helpers.log10 = Math.log10 ? 58506 function(x) { 58507 return Math.log10(x); 58508 } : 58509 function(x) { 58510 var exponent = Math.log(x) * Math.LOG10E; // Math.LOG10E = 1 / Math.LN10. 58511 // Check for whole powers of 10, 58512 // which due to floating point rounding error should be corrected. 58513 var powerOf10 = Math.round(exponent); 58514 var isPowerOf10 = x === Math.pow(10, powerOf10); 58515 58516 return isPowerOf10 ? powerOf10 : exponent; 58517 }; 58518 helpers.toRadians = function(degrees) { 58519 return degrees * (Math.PI / 180); 58520 }; 58521 helpers.toDegrees = function(radians) { 58522 return radians * (180 / Math.PI); 58523 }; 58524 // Gets the angle from vertical upright to the point about a centre. 58525 helpers.getAngleFromPoint = function(centrePoint, anglePoint) { 58526 var distanceFromXCenter = anglePoint.x - centrePoint.x; 58527 var distanceFromYCenter = anglePoint.y - centrePoint.y; 58528 var radialDistanceFromCenter = Math.sqrt(distanceFromXCenter * distanceFromXCenter + distanceFromYCenter * distanceFromYCenter); 58529 58530 var angle = Math.atan2(distanceFromYCenter, distanceFromXCenter); 58531 58532 if (angle < (-0.5 * Math.PI)) { 58533 angle += 2.0 * Math.PI; // make sure the returned angle is in the range of (-PI/2, 3PI/2] 58534 } 58535 58536 return { 58537 angle: angle, 58538 distance: radialDistanceFromCenter 58539 }; 58540 }; 58541 helpers.distanceBetweenPoints = function(pt1, pt2) { 58542 return Math.sqrt(Math.pow(pt2.x - pt1.x, 2) + Math.pow(pt2.y - pt1.y, 2)); 58543 }; 58544 helpers.aliasPixel = function(pixelWidth) { 58545 return (pixelWidth % 2 === 0) ? 0 : 0.5; 58546 }; 58547 helpers.splineCurve = function(firstPoint, middlePoint, afterPoint, t) { 58548 // Props to Rob Spencer at scaled innovation for his post on splining between points 58549 // http://scaledinnovation.com/analytics/splines/aboutSplines.html 58550 58551 // This function must also respect "skipped" points 58552 58553 var previous = firstPoint.skip ? middlePoint : firstPoint; 58554 var current = middlePoint; 58555 var next = afterPoint.skip ? middlePoint : afterPoint; 58556 58557 var d01 = Math.sqrt(Math.pow(current.x - previous.x, 2) + Math.pow(current.y - previous.y, 2)); 58558 var d12 = Math.sqrt(Math.pow(next.x - current.x, 2) + Math.pow(next.y - current.y, 2)); 58559 58560 var s01 = d01 / (d01 + d12); 58561 var s12 = d12 / (d01 + d12); 58562 58563 // If all points are the same, s01 & s02 will be inf 58564 s01 = isNaN(s01) ? 0 : s01; 58565 s12 = isNaN(s12) ? 0 : s12; 58566 58567 var fa = t * s01; // scaling factor for triangle Ta 58568 var fb = t * s12; 58569 58570 return { 58571 previous: { 58572 x: current.x - fa * (next.x - previous.x), 58573 y: current.y - fa * (next.y - previous.y) 58574 }, 58575 next: { 58576 x: current.x + fb * (next.x - previous.x), 58577 y: current.y + fb * (next.y - previous.y) 58578 } 58579 }; 58580 }; 58581 helpers.EPSILON = Number.EPSILON || 1e-14; 58582 helpers.splineCurveMonotone = function(points) { 58583 // This function calculates Bézier control points in a similar way than |splineCurve|, 58584 // but preserves monotonicity of the provided data and ensures no local extremums are added 58585 // between the dataset discrete points due to the interpolation. 58586 // See : https://en.wikipedia.org/wiki/Monotone_cubic_interpolation 58587 58588 var pointsWithTangents = (points || []).map(function(point) { 58589 return { 58590 model: point._model, 58591 deltaK: 0, 58592 mK: 0 58593 }; 58594 }); 58595 58596 // Calculate slopes (deltaK) and initialize tangents (mK) 58597 var pointsLen = pointsWithTangents.length; 58598 var i, pointBefore, pointCurrent, pointAfter; 58599 for (i = 0; i < pointsLen; ++i) { 58600 pointCurrent = pointsWithTangents[i]; 58601 if (pointCurrent.model.skip) { 58602 continue; 58603 } 58604 58605 pointBefore = i > 0 ? pointsWithTangents[i - 1] : null; 58606 pointAfter = i < pointsLen - 1 ? pointsWithTangents[i + 1] : null; 58607 if (pointAfter && !pointAfter.model.skip) { 58608 var slopeDeltaX = (pointAfter.model.x - pointCurrent.model.x); 58609 58610 // In the case of two points that appear at the same x pixel, slopeDeltaX is 0 58611 pointCurrent.deltaK = slopeDeltaX !== 0 ? (pointAfter.model.y - pointCurrent.model.y) / slopeDeltaX : 0; 58612 } 58613 58614 if (!pointBefore || pointBefore.model.skip) { 58615 pointCurrent.mK = pointCurrent.deltaK; 58616 } else if (!pointAfter || pointAfter.model.skip) { 58617 pointCurrent.mK = pointBefore.deltaK; 58618 } else if (this.sign(pointBefore.deltaK) !== this.sign(pointCurrent.deltaK)) { 58619 pointCurrent.mK = 0; 58620 } else { 58621 pointCurrent.mK = (pointBefore.deltaK + pointCurrent.deltaK) / 2; 58622 } 58623 } 58624 58625 // Adjust tangents to ensure monotonic properties 58626 var alphaK, betaK, tauK, squaredMagnitude; 58627 for (i = 0; i < pointsLen - 1; ++i) { 58628 pointCurrent = pointsWithTangents[i]; 58629 pointAfter = pointsWithTangents[i + 1]; 58630 if (pointCurrent.model.skip || pointAfter.model.skip) { 58631 continue; 58632 } 58633 58634 if (helpers.almostEquals(pointCurrent.deltaK, 0, this.EPSILON)) { 58635 pointCurrent.mK = pointAfter.mK = 0; 58636 continue; 58637 } 58638 58639 alphaK = pointCurrent.mK / pointCurrent.deltaK; 58640 betaK = pointAfter.mK / pointCurrent.deltaK; 58641 squaredMagnitude = Math.pow(alphaK, 2) + Math.pow(betaK, 2); 58642 if (squaredMagnitude <= 9) { 58643 continue; 58644 } 58645 58646 tauK = 3 / Math.sqrt(squaredMagnitude); 58647 pointCurrent.mK = alphaK * tauK * pointCurrent.deltaK; 58648 pointAfter.mK = betaK * tauK * pointCurrent.deltaK; 58649 } 58650 58651 // Compute control points 58652 var deltaX; 58653 for (i = 0; i < pointsLen; ++i) { 58654 pointCurrent = pointsWithTangents[i]; 58655 if (pointCurrent.model.skip) { 58656 continue; 58657 } 58658 58659 pointBefore = i > 0 ? pointsWithTangents[i - 1] : null; 58660 pointAfter = i < pointsLen - 1 ? pointsWithTangents[i + 1] : null; 58661 if (pointBefore && !pointBefore.model.skip) { 58662 deltaX = (pointCurrent.model.x - pointBefore.model.x) / 3; 58663 pointCurrent.model.controlPointPreviousX = pointCurrent.model.x - deltaX; 58664 pointCurrent.model.controlPointPreviousY = pointCurrent.model.y - deltaX * pointCurrent.mK; 58665 } 58666 if (pointAfter && !pointAfter.model.skip) { 58667 deltaX = (pointAfter.model.x - pointCurrent.model.x) / 3; 58668 pointCurrent.model.controlPointNextX = pointCurrent.model.x + deltaX; 58669 pointCurrent.model.controlPointNextY = pointCurrent.model.y + deltaX * pointCurrent.mK; 58670 } 58671 } 58672 }; 58673 helpers.nextItem = function(collection, index, loop) { 58674 if (loop) { 58675 return index >= collection.length - 1 ? collection[0] : collection[index + 1]; 58676 } 58677 return index >= collection.length - 1 ? collection[collection.length - 1] : collection[index + 1]; 58678 }; 58679 helpers.previousItem = function(collection, index, loop) { 58680 if (loop) { 58681 return index <= 0 ? collection[collection.length - 1] : collection[index - 1]; 58682 } 58683 return index <= 0 ? collection[0] : collection[index - 1]; 58684 }; 58685 // Implementation of the nice number algorithm used in determining where axis labels will go 58686 helpers.niceNum = function(range, round) { 58687 var exponent = Math.floor(helpers.log10(range)); 58688 var fraction = range / Math.pow(10, exponent); 58689 var niceFraction; 58690 58691 if (round) { 58692 if (fraction < 1.5) { 58693 niceFraction = 1; 58694 } else if (fraction < 3) { 58695 niceFraction = 2; 58696 } else if (fraction < 7) { 58697 niceFraction = 5; 58698 } else { 58699 niceFraction = 10; 58700 } 58701 } else if (fraction <= 1.0) { 58702 niceFraction = 1; 58703 } else if (fraction <= 2) { 58704 niceFraction = 2; 58705 } else if (fraction <= 5) { 58706 niceFraction = 5; 58707 } else { 58708 niceFraction = 10; 58709 } 58710 58711 return niceFraction * Math.pow(10, exponent); 58712 }; 58713 // Request animation polyfill - http://www.paulirish.com/2011/requestanimationframe-for-smart-animating/ 58714 helpers.requestAnimFrame = (function() { 58715 if (typeof window === 'undefined') { 58716 return function(callback) { 58717 callback(); 58718 }; 58719 } 58720 return window.requestAnimationFrame || 58721 window.webkitRequestAnimationFrame || 58722 window.mozRequestAnimationFrame || 58723 window.oRequestAnimationFrame || 58724 window.msRequestAnimationFrame || 58725 function(callback) { 58726 return window.setTimeout(callback, 1000 / 60); 58727 }; 58728 }()); 58729 // -- DOM methods 58730 helpers.getRelativePosition = function(evt, chart) { 58731 var mouseX, mouseY; 58732 var e = evt.originalEvent || evt; 58733 var canvas = evt.currentTarget || evt.srcElement; 58734 var boundingRect = canvas.getBoundingClientRect(); 58735 58736 var touches = e.touches; 58737 if (touches && touches.length > 0) { 58738 mouseX = touches[0].clientX; 58739 mouseY = touches[0].clientY; 58740 58741 } else { 58742 mouseX = e.clientX; 58743 mouseY = e.clientY; 58744 } 58745 58746 // Scale mouse coordinates into canvas coordinates 58747 // by following the pattern laid out by 'jerryj' in the comments of 58748 // http://www.html5canvastutorials.com/advanced/html5-canvas-mouse-coordinates/ 58749 var paddingLeft = parseFloat(helpers.getStyle(canvas, 'padding-left')); 58750 var paddingTop = parseFloat(helpers.getStyle(canvas, 'padding-top')); 58751 var paddingRight = parseFloat(helpers.getStyle(canvas, 'padding-right')); 58752 var paddingBottom = parseFloat(helpers.getStyle(canvas, 'padding-bottom')); 58753 var width = boundingRect.right - boundingRect.left - paddingLeft - paddingRight; 58754 var height = boundingRect.bottom - boundingRect.top - paddingTop - paddingBottom; 58755 58756 // We divide by the current device pixel ratio, because the canvas is scaled up by that amount in each direction. However 58757 // the backend model is in unscaled coordinates. Since we are going to deal with our model coordinates, we go back here 58758 mouseX = Math.round((mouseX - boundingRect.left - paddingLeft) / (width) * canvas.width / chart.currentDevicePixelRatio); 58759 mouseY = Math.round((mouseY - boundingRect.top - paddingTop) / (height) * canvas.height / chart.currentDevicePixelRatio); 58760 58761 return { 58762 x: mouseX, 58763 y: mouseY 58764 }; 58765 58766 }; 58767 58768 // Private helper function to convert max-width/max-height values that may be percentages into a number 58769 function parseMaxStyle(styleValue, node, parentProperty) { 58770 var valueInPixels; 58771 if (typeof styleValue === 'string') { 58772 valueInPixels = parseInt(styleValue, 10); 58773 58774 if (styleValue.indexOf('%') !== -1) { 58775 // percentage * size in dimension 58776 valueInPixels = valueInPixels / 100 * node.parentNode[parentProperty]; 58777 } 58778 } else { 58779 valueInPixels = styleValue; 58780 } 58781 58782 return valueInPixels; 58783 } 58784 58785 /** 58786 * Returns if the given value contains an effective constraint. 58787 * @private 58788 */ 58789 function isConstrainedValue(value) { 58790 return value !== undefined && value !== null && value !== 'none'; 58791 } 58792 58793 // Private helper to get a constraint dimension 58794 // @param domNode : the node to check the constraint on 58795 // @param maxStyle : the style that defines the maximum for the direction we are using (maxWidth / maxHeight) 58796 // @param percentageProperty : property of parent to use when calculating width as a percentage 58797 // @see http://www.nathanaeljones.com/blog/2013/reading-max-width-cross-browser 58798 function getConstraintDimension(domNode, maxStyle, percentageProperty) { 58799 var view = document.defaultView; 58800 var parentNode = domNode.parentNode; 58801 var constrainedNode = view.getComputedStyle(domNode)[maxStyle]; 58802 var constrainedContainer = view.getComputedStyle(parentNode)[maxStyle]; 58803 var hasCNode = isConstrainedValue(constrainedNode); 58804 var hasCContainer = isConstrainedValue(constrainedContainer); 58805 var infinity = Number.POSITIVE_INFINITY; 58806 58807 if (hasCNode || hasCContainer) { 58808 return Math.min( 58809 hasCNode ? parseMaxStyle(constrainedNode, domNode, percentageProperty) : infinity, 58810 hasCContainer ? parseMaxStyle(constrainedContainer, parentNode, percentageProperty) : infinity); 58811 } 58812 58813 return 'none'; 58814 } 58815 // returns Number or undefined if no constraint 58816 helpers.getConstraintWidth = function(domNode) { 58817 return getConstraintDimension(domNode, 'max-width', 'clientWidth'); 58818 }; 58819 // returns Number or undefined if no constraint 58820 helpers.getConstraintHeight = function(domNode) { 58821 return getConstraintDimension(domNode, 'max-height', 'clientHeight'); 58822 }; 58823 helpers.getMaximumWidth = function(domNode) { 58824 var container = domNode.parentNode; 58825 if (!container) { 58826 return domNode.clientWidth; 58827 } 58828 58829 var paddingLeft = parseInt(helpers.getStyle(container, 'padding-left'), 10); 58830 var paddingRight = parseInt(helpers.getStyle(container, 'padding-right'), 10); 58831 var w = container.clientWidth - paddingLeft - paddingRight; 58832 var cw = helpers.getConstraintWidth(domNode); 58833 return isNaN(cw) ? w : Math.min(w, cw); 58834 }; 58835 helpers.getMaximumHeight = function(domNode) { 58836 var container = domNode.parentNode; 58837 if (!container) { 58838 return domNode.clientHeight; 58839 } 58840 58841 var paddingTop = parseInt(helpers.getStyle(container, 'padding-top'), 10); 58842 var paddingBottom = parseInt(helpers.getStyle(container, 'padding-bottom'), 10);
58843 var h = container.clientHeight - paddingTop - paddingBottom; 58844 var ch = helpers.getConstraintHeight(domNode); 58845 return isNaN(ch) ? h : Math.min(h, ch); 58846 }; 58847 helpers.getStyle = function(el, property) { 58848 return el.currentStyle ? 58849 el.currentStyle[property] : 58850 document.defaultView.getComputedStyle(el, null).getPropertyValue(property); 58851 }; 58852 helpers.retinaScale = function(chart, forceRatio) { 58853 var pixelRatio = chart.currentDevicePixelRatio = forceRatio || window.devicePixelRatio || 1; 58854 if (pixelRatio === 1) { 58855 return; 58856 } 58857 58858 var canvas = chart.canvas; 58859 var height = chart.height; 58860 var width = chart.width; 58861 58862 canvas.height = height * pixelRatio; 58863 canvas.width = width * pixelRatio; 58864 chart.ctx.scale(pixelRatio, pixelRatio); 58865 58866 // If no style has been set on the canvas, the render size is used as display size, 58867 // making the chart visually bigger, so let's enforce it to the "correct" values. 58868 // See https://github.com/chartjs/Chart.js/issues/3575 58869 if (!canvas.style.height && !canvas.style.width) { 58870 canvas.style.height = height + 'px'; 58871 canvas.style.width = width + 'px'; 58872 } 58873 }; 58874 // -- Canvas methods 58875 helpers.fontString = function(pixelSize, fontStyle, fontFamily) { 58876 return fontStyle + ' ' + pixelSize + 'px ' + fontFamily; 58877 }; 58878 helpers.longestText = function(ctx, font, arrayOfThings, cache) { 58879 cache = cache || {}; 58880 var data = cache.data = cache.data || {}; 58881 var gc = cache.garbageCollect = cache.garbageCollect || []; 58882 58883 if (cache.font !== font) { 58884 data = cache.data = {}; 58885 gc = cache.garbageCollect = []; 58886 cache.font = font; 58887 } 58888 58889 ctx.font = font; 58890 var longest = 0; 58891 helpers.each(arrayOfThings, function(thing) { 58892 // Undefined strings and arrays should not be measured 58893 if (thing !== undefined && thing !== null && helpers.isArray(thing) !== true) { 58894 longest = helpers.measureText(ctx, data, gc, longest, thing); 58895 } else if (helpers.isArray(thing)) { 58896 // if it is an array lets measure each element 58897 // to do maybe simplify this function a bit so we can do this more recursively? 58898 helpers.each(thing, function(nestedThing) { 58899 // Undefined strings and arrays should not be measured 58900 if (nestedThing !== undefined && nestedThing !== null && !helpers.isArray(nestedThing)) { 58901 longest = helpers.measureText(ctx, data, gc, longest, nestedThing); 58902 } 58903 }); 58904 } 58905 }); 58906 58907 var gcLen = gc.length / 2; 58908 if (gcLen > arrayOfThings.length) { 58909 for (var i = 0; i < gcLen; i++) { 58910 delete data[gc[i]]; 58911 } 58912 gc.splice(0, gcLen); 58913 } 58914 return longest; 58915 }; 58916 helpers.measureText = function(ctx, data, gc, longest, string) { 58917 var textWidth = data[string]; 58918 if (!textWidth) { 58919 textWidth = data[string] = ctx.measureText(string).width; 58920 gc.push(string); 58921 } 58922 if (textWidth > longest) { 58923 longest = textWidth; 58924 } 58925 return longest; 58926 }; 58927 helpers.numberOfLabelLines = function(arrayOfThings) { 58928 var numberOfLines = 1; 58929 helpers.each(arrayOfThings, function(thing) { 58930 if (helpers.isArray(thing)) { 58931 if (thing.length > numberOfLines) { 58932 numberOfLines = thing.length; 58933 } 58934 } 58935 }); 58936 return numberOfLines; 58937 }; 58938 58939 helpers.color = !color ? 58940 function(value) { 58941 console.error('Color.js not found!'); 58942 return value; 58943 } : 58944 function(value) { 58945 /* global CanvasGradient */ 58946 if (value instanceof CanvasGradient) { 58947 value = defaults.global.defaultColor; 58948 } 58949 58950 return color(value); 58951 }; 58952 58953 helpers.getHoverColor = function(colorValue) { 58954 /* global CanvasPattern */ 58955 return (colorValue instanceof CanvasPattern) ? 58956 colorValue : 58957 helpers.color(colorValue).saturate(0.5).darken(0.1).rgbString(); 58958 }; 58959}; 58960 58961 58962/***/ }), 58963/* 204 */ 58964/***/ (function(module, exports, __webpack_require__) { 58965 58966"use strict"; 58967 58968 58969var defaults = __webpack_require__(2); 58970 58971defaults._set('global', { 58972 responsive: true, 58973 responsiveAnimationDuration: 0, 58974 maintainAspectRatio: true, 58975 events: ['mousemove', 'mouseout', 'click', 'touchstart', 'touchmove'], 58976 hover: { 58977 onHover: null, 58978 mode: 'nearest', 58979 intersect: true, 58980 animationDuration: 400 58981 }, 58982 onClick: null, 58983 defaultColor: 'rgba(0,0,0,0.1)', 58984 defaultFontColor: '#666', 58985 defaultFontFamily: "'Helvetica Neue', 'Helvetica', 'Arial', sans-serif", 58986 defaultFontSize: 12, 58987 defaultFontStyle: 'normal', 58988 showLines: true, 58989 58990 // Element defaults defined in element extensions 58991 elements: {}, 58992 58993 // Layout options such as padding 58994 layout: { 58995 padding: { 58996 top: 0, 58997 right: 0, 58998 bottom: 0, 58999 left: 0 59000 } 59001 } 59002}); 59003 59004module.exports = function() { 59005 59006 // Occupy the global variable of Chart, and create a simple base class 59007 var Chart = function(item, config) { 59008 this.construct(item, config); 59009 return this; 59010 }; 59011 59012 Chart.Chart = Chart; 59013 59014 return Chart; 59015}; 59016 59017 59018/***/ }), 59019/* 205 */ 59020/***/ (function(module, exports, __webpack_require__) { 59021 59022"use strict"; 59023 59024 59025var defaults = __webpack_require__(2); 59026var Element = __webpack_require__(5); 59027var helpers = __webpack_require__(1); 59028var Ticks = __webpack_require__(10); 59029 59030defaults._set('scale', { 59031 display: true, 59032 position: 'left', 59033 offset: false, 59034 59035 // grid line settings 59036 gridLines: { 59037 display: true, 59038 color: 'rgba(0, 0, 0, 0.1)', 59039 lineWidth: 1, 59040 drawBorder: true, 59041 drawOnChartArea: true, 59042 drawTicks: true, 59043 tickMarkLength: 10,
59044 zeroLineWidth: 1, 59045 zeroLineColor: 'rgba(0,0,0,0.25)', 59046 zeroLineBorderDash: [], 59047 zeroLineBorderDashOffset: 0.0, 59048 offsetGridLines: false, 59049 borderDash: [], 59050 borderDashOffset: 0.0 59051 }, 59052 59053 // scale label 59054 scaleLabel: { 59055 // display property 59056 display: false, 59057 59058 // actual label 59059 labelString: '', 59060 59061 // line height 59062 lineHeight: 1.2, 59063 59064 // top/bottom padding 59065 padding: { 59066 top: 4, 59067 bottom: 4 59068 } 59069 }, 59070 59071 // label settings 59072 ticks: { 59073 beginAtZero: false, 59074 minRotation: 0, 59075 maxRotation: 50, 59076 mirror: false, 59077 padding: 0, 59078 reverse: false, 59079 display: true, 59080 autoSkip: true, 59081 autoSkipPadding: 0, 59082 labelOffset: 0, 59083 // We pass through arrays to be rendered as multiline labels, we convert Others to strings here. 59084 callback: Ticks.formatters.values, 59085 minor: {}, 59086 major: {} 59087 } 59088}); 59089 59090function labelsFromTicks(ticks) { 59091 var labels = []; 59092 var i, ilen; 59093 59094 for (i = 0, ilen = ticks.length; i < ilen; ++i) { 59095 labels.push(ticks[i].label); 59096 } 59097 59098 return labels; 59099} 59100 59101function getLineValue(scale, index, offsetGridLines) { 59102 var lineValue = scale.getPixelForTick(index); 59103 59104 if (offsetGridLines) { 59105 if (index === 0) { 59106 lineValue -= (scale.getPixelForTick(1) - lineValue) / 2; 59107 } else { 59108 lineValue -= (lineValue - scale.getPixelForTick(index - 1)) / 2; 59109 } 59110 } 59111 return lineValue; 59112} 59113 59114module.exports = function(Chart) { 59115 59116 function computeTextSize(context, tick, font) { 59117 return helpers.isArray(tick) ? 59118 helpers.longestText(context, font, tick) : 59119 context.measureText(tick).width; 59120 } 59121 59122 function parseFontOptions(options) { 59123 var valueOrDefault = helpers.valueOrDefault; 59124 var globalDefaults = defaults.global; 59125 var size = valueOrDefault(options.fontSize, globalDefaults.defaultFontSize); 59126 var style = valueOrDefault(options.fontStyle, globalDefaults.defaultFontStyle); 59127 var family = valueOrDefault(options.fontFamily, globalDefaults.defaultFontFamily); 59128 59129 return { 59130 size: size, 59131 style: style, 59132 family: family, 59133 font: helpers.fontString(size, style, family) 59134 }; 59135 } 59136 59137 function parseLineHeight(options) { 59138 return helpers.options.toLineHeight( 59139 helpers.valueOrDefault(options.lineHeight, 1.2), 59140 helpers.valueOrDefault(options.fontSize, defaults.global.defaultFontSize)); 59141 } 59142 59143 Chart.Scale = Element.extend({ 59144 /** 59145 * Get the padding needed for the scale 59146 * @method getPadding 59147 * @private 59148 * @returns {Padding} the necessary padding 59149 */ 59150 getPadding: function() { 59151 var me = this; 59152 return { 59153 left: me.paddingLeft || 0, 59154 top: me.paddingTop || 0, 59155 right: me.paddingRight || 0, 59156 bottom: me.paddingBottom || 0 59157 }; 59158 }, 59159 59160 /** 59161 * Returns the scale tick objects ({label, major}) 59162 * @since 2.7 59163 */ 59164 getTicks: function() { 59165 return this._ticks; 59166 }, 59167 59168 // These methods are ordered by lifecyle. Utilities then follow. 59169 // Any function defined here is inherited by all scale types. 59170 // Any function can be extended by the scale type 59171 59172 mergeTicksOptions: function() { 59173 var ticks = this.options.ticks; 59174 if (ticks.minor === false) { 59175 ticks.minor = { 59176 display: false 59177 }; 59178 } 59179 if (ticks.major === false) { 59180 ticks.major = { 59181 display: false 59182 }; 59183 } 59184 for (var key in ticks) { 59185 if (key !== 'major' && key !== 'minor') { 59186 if (typeof ticks.minor[key] === 'undefined') { 59187 ticks.minor[key] = ticks[key]; 59188 } 59189 if (typeof ticks.major[key] === 'undefined') { 59190 ticks.major[key] = ticks[key]; 59191 } 59192 } 59193 } 59194 }, 59195 beforeUpdate: function() { 59196 helpers.callback(this.options.beforeUpdate, [this]); 59197 }, 59198 update: function(maxWidth, maxHeight, margins) { 59199 var me = this; 59200 var i, ilen, labels, label, ticks, tick; 59201 59202 // Update Lifecycle - Probably don't want to ever extend or overwrite this function ;) 59203 me.beforeUpdate(); 59204 59205 // Absorb the master measurements 59206 me.maxWidth = maxWidth; 59207 me.maxHeight = maxHeight; 59208 me.margins = helpers.extend({ 59209 left: 0, 59210 right: 0, 59211 top: 0, 59212 bottom: 0 59213 }, margins); 59214 me.longestTextCache = me.longestTextCache || {}; 59215 59216 // Dimensions 59217 me.beforeSetDimensions(); 59218 me.setDimensions(); 59219 me.afterSetDimensions(); 59220 59221 // Data min/max 59222 me.beforeDataLimits(); 59223 me.determineDataLimits(); 59224 me.afterDataLimits(); 59225 59226 // Ticks - `this.ticks` is now DEPRECATED! 59227 // Internal ticks are now stored as objects in the PRIVATE `this._ticks` member 59228 // and must not be accessed directly from outside this class. `this.ticks` being 59229 // around for long time and not marked as private, we can't change its structure 59230 // without unexpected breaking changes. If you need to access the scale ticks, 59231 // use scale.getTicks() instead. 59232 59233 me.beforeBuildTicks(); 59234 59235 // New implementations should return an array of objects but for BACKWARD COMPAT, 59236 // we still support no return (`this.ticks` internally set by calling this method). 59237 ticks = me.buildTicks() || []; 59238 59239 me.afterBuildTicks(); 59240 59241 me.beforeTickToLabelConversion(); 59242 59243 // New implementations should return the formatted tick labels but for BACKWARD 59244 // COMPAT, we still support no return (`this.ticks` internally changed by calling 59245 // this method and supposed to contain only string values). 59246 labels = me.convertTicksToLabels(ticks) || me.ticks; 59247 59248 me.afterTickToLabelConversion(); 59249 59250 me.ticks = labels; // BACKWARD COMPATIBILITY 59251 59252 // IMPORTANT: from this point, we consider that `this.ticks` will NEVER change! 59253 59254 // BACKWARD COMPAT: synchronize `_ticks` with labels (so potentially `this.ticks`) 59255 for (i = 0, ilen = labels.length; i < ilen; ++i) { 59256 label = labels[i]; 59257 tick = ticks[i]; 59258 if (!tick) { 59259 ticks.push(tick = { 59260 label: label, 59261 major: false 59262 }); 59263 } else { 59264 tick.label = label; 59265 } 59266 } 59267 59268 me._ticks = ticks; 59269 59270 // Tick Rotation 59271 me.beforeCalculateTickRotation(); 59272 me.calculateTickRotation(); 59273 me.afterCalculateTickRotation(); 59274 // Fit 59275 me.beforeFit(); 59276 me.fit(); 59277 me.afterFit(); 59278 // 59279 me.afterUpdate(); 59280 59281 return me.minSize; 59282 59283 }, 59284 afterUpdate: function() { 59285 helpers.callback(this.options.afterUpdate, [this]); 59286 }, 59287 59288 // 59289 59290 beforeSetDimensions: function() { 59291 helpers.callback(this.options.beforeSetDimensions, [this]); 59292 }, 59293 setDimensions: function() { 59294 var me = this; 59295 // Set the unconstrained dimension before label rotation 59296 if (me.isHorizontal()) { 59297 // Reset position before calculating rotation 59298 me.width = me.maxWidth; 59299 me.left = 0; 59300 me.right = me.width; 59301 } else { 59302 me.height = me.maxHeight; 59303 59304 // Reset position before calculating rotation 59305 me.top = 0; 59306 me.bottom = me.height; 59307 } 59308 59309 // Reset padding 59310 me.paddingLeft = 0; 59311 me.paddingTop = 0; 59312 me.paddingRight = 0; 59313 me.paddingBottom = 0; 59314 }, 59315 afterSetDimensions: function() { 59316 helpers.callback(this.options.afterSetDimensions, [this]); 59317 }, 59318 59319 // Data limits 59320 beforeDataLimits: function() { 59321 helpers.callback(this.options.beforeDataLimits, [this]); 59322 }, 59323 determineDataLimits: helpers.noop, 59324 afterDataLimits: function() { 59325 helpers.callback(this.options.afterDataLimits, [this]); 59326 }, 59327 59328 // 59329 beforeBuildTicks: function() { 59330 helpers.callback(this.options.beforeBuildTicks, [this]); 59331 }, 59332 buildTicks: helpers.noop, 59333 afterBuildTicks: function() { 59334 helpers.callback(this.options.afterBuildTicks, [this]); 59335 }, 59336 59337 beforeTickToLabelConversion: function() { 59338 helpers.callback(this.options.beforeTickToLabelConversion, [this]); 59339 }, 59340 convertTicksToLabels: function() { 59341 var me = this; 59342 // Convert ticks to strings 59343 var tickOpts = me.options.ticks; 59344 me.ticks = me.ticks.map(tickOpts.userCallback || tickOpts.callback, this); 59345 }, 59346 afterTickToLabelConversion: function() { 59347 helpers.callback(this.options.afterTickToLabelConversion, [this]); 59348 }, 59349 59350 // 59351 59352 beforeCalculateTickRotation: function() { 59353 helpers.callback(this.options.beforeCalculateTickRotation, [this]); 59354 }, 59355 calculateTickRotation: function() { 59356 var me = this; 59357 var context = me.ctx; 59358 var tickOpts = me.options.ticks; 59359 var labels = labelsFromTicks(me._ticks); 59360 59361 // Get the width of each grid by calculating the difference 59362 // between x offsets between 0 and 1.
59363 var tickFont = parseFontOptions(tickOpts); 59364 context.font = tickFont.font; 59365 59366 var labelRotation = tickOpts.minRotation || 0; 59367 59368 if (labels.length && me.options.display && me.isHorizontal()) { 59369 var originalLabelWidth = helpers.longestText(context, tickFont.font, labels, me.longestTextCache); 59370 var labelWidth = originalLabelWidth; 59371 var cosRotation, sinRotation; 59372 59373 // Allow 3 pixels x2 padding either side for label readability 59374 var tickWidth = me.getPixelForTick(1) - me.getPixelForTick(0) - 6; 59375 59376 // Max label rotation can be set or default to 90 - also act as a loop counter 59377 while (labelWidth > tickWidth && labelRotation < tickOpts.maxRotation) { 59378 var angleRadians = helpers.toRadians(labelRotation); 59379 cosRotation = Math.cos(angleRadians); 59380 sinRotation = Math.sin(angleRadians); 59381 59382 if (sinRotation * originalLabelWidth > me.maxHeight) { 59383 // go back one step 59384 labelRotation--; 59385 break; 59386 } 59387 59388 labelRotation++; 59389 labelWidth = cosRotation * originalLabelWidth; 59390 } 59391 } 59392 59393 me.labelRotation = labelRotation; 59394 }, 59395 afterCalculateTickRotation: function() { 59396 helpers.callback(this.options.afterCalculateTickRotation, [this]); 59397 }, 59398 59399 // 59400 59401 beforeFit: function() { 59402 helpers.callback(this.options.beforeFit, [this]); 59403 }, 59404 fit: function() { 59405 var me = this; 59406 // Reset 59407 var minSize = me.minSize = { 59408 width: 0, 59409 height: 0 59410 }; 59411 59412 var labels = labelsFromTicks(me._ticks); 59413 59414 var opts = me.options; 59415 var tickOpts = opts.ticks; 59416 var scaleLabelOpts = opts.scaleLabel; 59417 var gridLineOpts = opts.gridLines; 59418 var display = opts.display; 59419 var isHorizontal = me.isHorizontal(); 59420 59421 var tickFont = parseFontOptions(tickOpts); 59422 var tickMarkLength = opts.gridLines.tickMarkLength; 59423 59424 // Width 59425 if (isHorizontal) { 59426 // subtract the margins to line up with the chartArea if we are a full width scale 59427 minSize.width = me.isFullWidth() ? me.maxWidth - me.margins.left - me.margins.right : me.maxWidth; 59428 } else { 59429 minSize.width = display && gridLineOpts.drawTicks ? tickMarkLength : 0; 59430 } 59431 59432 // height 59433 if (isHorizontal) { 59434 minSize.height = display && gridLineOpts.drawTicks ? tickMarkLength : 0; 59435 } else { 59436 minSize.height = me.maxHeight; // fill all the height 59437 } 59438 59439 // Are we showing a title for the scale? 59440 if (scaleLabelOpts.display && display) { 59441 var scaleLabelLineHeight = parseLineHeight(scaleLabelOpts); 59442 var scaleLabelPadding = helpers.options.toPadding(scaleLabelOpts.padding); 59443 var deltaHeight = scaleLabelLineHeight + scaleLabelPadding.height; 59444 59445 if (isHorizontal) { 59446 minSize.height += deltaHeight; 59447 } else { 59448 minSize.width += deltaHeight; 59449 } 59450 } 59451 59452 // Don't bother fitting the ticks if we are not showing them 59453 if (tickOpts.display && display) { 59454 var largestTextWidth = helpers.longestText(me.ctx, tickFont.font, labels, me.longestTextCache); 59455 var tallestLabelHeightInLines = helpers.numberOfLabelLines(labels); 59456 var lineSpace = tickFont.size * 0.5; 59457 var tickPadding = me.options.ticks.padding; 59458 59459 if (isHorizontal) { 59460 // A horizontal axis is more constrained by the height. 59461 me.longestLabelWidth = largestTextWidth; 59462 59463 var angleRadians = helpers.toRadians(me.labelRotation); 59464 var cosRotation = Math.cos(angleRadians); 59465 var sinRotation = Math.sin(angleRadians); 59466 59467 // TODO - improve this calculation 59468 var labelHeight = (sinRotation * largestTextWidth) 59469 + (tickFont.size * tallestLabelHeightInLines) 59470 + (lineSpace * (tallestLabelHeightInLines - 1)) 59471 + lineSpace; // padding 59472 59473 minSize.height = Math.min(me.maxHeight, minSize.height + labelHeight + tickPadding); 59474 59475 me.ctx.font = tickFont.font; 59476 var firstLabelWidth = computeTextSize(me.ctx, labels[0], tickFont.font); 59477 var lastLabelWidth = computeTextSize(me.ctx, labels[labels.length - 1], tickFont.font); 59478 59479 // Ensure that our ticks are always inside the canvas. When rotated, ticks are right aligned 59480 // which means that the right padding is dominated by the font height 59481 if (me.labelRotation !== 0) { 59482 me.paddingLeft = opts.position === 'bottom' ? (cosRotation * firstLabelWidth) + 3 : (cosRotation * lineSpace) + 3; // add 3 px to move away from canvas edges 59483 me.paddingRight = opts.position === 'bottom' ? (cosRotation * lineSpace) + 3 : (cosRotation * lastLabelWidth) + 3; 59484 } else {
59485 me.paddingLeft = firstLabelWidth / 2 + 3; // add 3 px to move away from canvas edges 59486 me.paddingRight = lastLabelWidth / 2 + 3; 59487 } 59488 } else { 59489 // A vertical axis is more constrained by the width. Labels are the 59490 // dominant factor here, so get that length first and account for padding 59491 if (tickOpts.mirror) { 59492 largestTextWidth = 0; 59493 } else { 59494 // use lineSpace for consistency with horizontal axis 59495 // tickPadding is not implemented for horizontal 59496 largestTextWidth += tickPadding + lineSpace; 59497 } 59498 59499 minSize.width = Math.min(me.maxWidth, minSize.width + largestTextWidth); 59500 59501 me.paddingTop = tickFont.size / 2; 59502 me.paddingBottom = tickFont.size / 2; 59503 } 59504 } 59505 59506 me.handleMargins(); 59507 59508 me.width = minSize.width; 59509 me.height = minSize.height; 59510 }, 59511 59512 /** 59513 * Handle margins and padding interactions 59514 * @private 59515 */ 59516 handleMargins: function() { 59517 var me = this; 59518 if (me.margins) { 59519 me.paddingLeft = Math.max(me.paddingLeft - me.margins.left, 0); 59520 me.paddingTop = Math.max(me.paddingTop - me.margins.top, 0); 59521 me.paddingRight = Math.max(me.paddingRight - me.margins.right, 0); 59522 me.paddingBottom = Math.max(me.paddingBottom - me.margins.bottom, 0); 59523 } 59524 }, 59525 59526 afterFit: function() { 59527 helpers.callback(this.options.afterFit, [this]); 59528 }, 59529 59530 // Shared Methods 59531 isHorizontal: function() { 59532 return this.options.position === 'top' || this.options.position === 'bottom'; 59533 }, 59534 isFullWidth: function() { 59535 return (this.options.fullWidth); 59536 }, 59537 59538 // Get the correct value. NaN bad inputs, If the value type is object get the x or y based on whether we are horizontal or not 59539 getRightValue: function(rawValue) { 59540 // Null and undefined values first 59541 if (helpers.isNullOrUndef(rawValue)) { 59542 return NaN; 59543 } 59544 // isNaN(object) returns true, so make sure NaN is checking for a number; Discard Infinite values 59545 if (typeof rawValue === 'number' && !isFinite(rawValue)) { 59546 return NaN; 59547 } 59548 // If it is in fact an object, dive in one more level 59549 if (rawValue) { 59550 if (this.isHorizontal()) { 59551 if (rawValue.x !== undefined) { 59552 return this.getRightValue(rawValue.x); 59553 } 59554 } else if (rawValue.y !== undefined) { 59555 return this.getRightValue(rawValue.y); 59556 } 59557 } 59558 59559 // Value is good, return it 59560 return rawValue; 59561 }, 59562 59563 /** 59564 * Used to get the value to display in the tooltip for the data at the given index 59565 * @param index 59566 * @param datasetIndex 59567 */ 59568 getLabelForIndex: helpers.noop, 59569 59570 /** 59571 * Returns the location of the given data point. Value can either be an index or a numerical value 59572 * The coordinate (0, 0) is at the upper-left corner of the canvas 59573 * @param value 59574 * @param index 59575 * @param datasetIndex 59576 */ 59577 getPixelForValue: helpers.noop, 59578 59579 /** 59580 * Used to get the data value from a given pixel. This is the inverse of getPixelForValue 59581 * The coordinate (0, 0) is at the upper-left corner of the canvas 59582 * @param pixel 59583 */ 59584 getValueForPixel: helpers.noop, 59585 59586 /** 59587 * Returns the location of the tick at the given index 59588 * The coordinate (0, 0) is at the upper-left corner of the canvas 59589 */ 59590 getPixelForTick: function(index) { 59591 var me = this; 59592 var offset = me.options.offset; 59593 if (me.isHorizontal()) { 59594 var innerWidth = me.width - (me.paddingLeft + me.paddingRight); 59595 var tickWidth = innerWidth / Math.max((me._ticks.length - (offset ? 0 : 1)), 1); 59596 var pixel = (tickWidth * index) + me.paddingLeft; 59597 59598 if (offset) { 59599 pixel += tickWidth / 2; 59600 } 59601 59602 var finalVal = me.left + Math.round(pixel); 59603 finalVal += me.isFullWidth() ? me.margins.left : 0; 59604 return finalVal; 59605 } 59606 var innerHeight = me.height - (me.paddingTop + me.paddingBottom); 59607 return me.top + (index * (innerHeight / (me._ticks.length - 1))); 59608 }, 59609 59610 /** 59611 * Utility for getting the pixel location of a percentage of scale 59612 * The coordinate (0, 0) is at the upper-left corner of the canvas 59613 */ 59614 getPixelForDecimal: function(decimal) { 59615 var me = this; 59616 if (me.isHorizontal()) { 59617 var innerWidth = me.width - (me.paddingLeft + me.paddingRight); 59618 var valueOffset = (innerWidth * decimal) + me.paddingLeft; 59619 59620 var finalVal = me.left + Math.round(valueOffset); 59621 finalVal += me.isFullWidth() ? me.margins.left : 0; 59622 return finalVal; 59623 } 59624 return me.top + (decimal * me.height); 59625 }, 59626 59627 /** 59628 * Returns the pixel for the minimum chart value 59629 * The coordinate (0, 0) is at the upper-left corner of the canvas 59630 */ 59631 getBasePixel: function() { 59632 return this.getPixelForValue(this.getBaseValue()); 59633 }, 59634 59635 getBaseValue: function() { 59636 var me = this; 59637 var min = me.min; 59638 var max = me.max; 59639 59640 return me.beginAtZero ? 0 : 59641 min < 0 && max < 0 ? max : 59642 min > 0 && max > 0 ? min : 59643 0; 59644 }, 59645 59646 /** 59647 * Returns a subset of ticks to be plotted to avoid overlapping labels. 59648 * @private 59649 */ 59650 _autoSkip: function(ticks) { 59651 var skipRatio; 59652 var me = this; 59653 var isHorizontal = me.isHorizontal(); 59654 var optionTicks = me.options.ticks.minor; 59655 var tickCount = ticks.length; 59656 var labelRotationRadians = helpers.toRadians(me.labelRotation); 59657 var cosRotation = Math.cos(labelRotationRadians); 59658 var longestRotatedLabel = me.longestLabelWidth * cosRotation; 59659 var result = []; 59660 var i, tick, shouldSkip; 59661
59662 // figure out the maximum number of gridlines to show 59663 var maxTicks; 59664 if (optionTicks.maxTicksLimit) { 59665 maxTicks = optionTicks.maxTicksLimit; 59666 } 59667 59668 if (isHorizontal) { 59669 skipRatio = false; 59670 59671 if ((longestRotatedLabel + optionTicks.autoSkipPadding) * tickCount > (me.width - (me.paddingLeft + me.paddingRight))) { 59672 skipRatio = 1 + Math.floor(((longestRotatedLabel + optionTicks.autoSkipPadding) * tickCount) / (me.width - (me.paddingLeft + me.paddingRight))); 59673 } 59674 59675 // if they defined a max number of optionTicks, 59676 // increase skipRatio until that number is met 59677 if (maxTicks && tickCount > maxTicks) { 59678 skipRatio = Math.max(skipRatio, Math.floor(tickCount / maxTicks)); 59679 } 59680 } 59681 59682 for (i = 0; i < tickCount; i++) { 59683 tick = ticks[i]; 59684 59685 // Since we always show the last tick,we need may need to hide the last shown one before 59686 shouldSkip = (skipRatio > 1 && i % skipRatio > 0) || (i % skipRatio === 0 && i + skipRatio >= tickCount); 59687 if (shouldSkip && i !== tickCount - 1) { 59688 // leave tick in place but make sure it's not displayed (#4635) 59689 delete tick.label; 59690 } 59691 result.push(tick); 59692 } 59693 return result; 59694 }, 59695 59696 // Actually draw the scale on the canvas 59697 // @param {rectangle} chartArea : the area of the chart to draw full grid lines on 59698 draw: function(chartArea) { 59699 var me = this; 59700 var options = me.options; 59701 if (!options.display) { 59702 return; 59703 } 59704 59705 var context = me.ctx; 59706 var globalDefaults = defaults.global; 59707 var optionTicks = options.ticks.minor; 59708 var optionMajorTicks = options.ticks.major || optionTicks; 59709 var gridLines = options.gridLines; 59710 var scaleLabel = options.scaleLabel; 59711 59712 var isRotated = me.labelRotation !== 0; 59713 var isHorizontal = me.isHorizontal(); 59714 59715 var ticks = optionTicks.autoSkip ? me._autoSkip(me.getTicks()) : me.getTicks(); 59716 var tickFontColor = helpers.valueOrDefault(optionTicks.fontColor, globalDefaults.defaultFontColor); 59717 var tickFont = parseFontOptions(optionTicks); 59718 var majorTickFontColor = helpers.valueOrDefault(optionMajorTicks.fontColor, globalDefaults.defaultFontColor); 59719 var majorTickFont = parseFontOptions(optionMajorTicks); 59720 59721 var tl = gridLines.drawTicks ? gridLines.tickMarkLength : 0; 59722 59723 var scaleLabelFontColor = helpers.valueOrDefault(scaleLabel.fontColor, globalDefaults.defaultFontColor); 59724 var scaleLabelFont = parseFontOptions(scaleLabel); 59725 var scaleLabelPadding = helpers.options.toPadding(scaleLabel.padding); 59726 var labelRotationRadians = helpers.toRadians(me.labelRotation); 59727 59728 var itemsToDraw = []; 59729 59730 var axisWidth = me.options.gridLines.lineWidth; 59731 var xTickStart = options.position === 'right' ? me.right : me.right - axisWidth - tl; 59732 var xTickEnd = options.position === 'right' ? me.right + tl : me.right; 59733 var yTickStart = options.position === 'bottom' ? me.top + axisWidth : me.bottom - tl - axisWidth; 59734 var yTickEnd = options.position === 'bottom' ? me.top + axisWidth + tl : me.bottom + axisWidth; 59735 59736 helpers.each(ticks, function(tick, index) { 59737 // autoskipper skipped this tick (#4635) 59738 if (helpers.isNullOrUndef(tick.label)) { 59739 return; 59740 } 59741 59742 var label = tick.label; 59743 var lineWidth, lineColor, borderDash, borderDashOffset; 59744 if (index === me.zeroLineIndex && options.offset === gridLines.offsetGridLines) { 59745 // Draw the first index specially 59746 lineWidth = gridLines.zeroLineWidth; 59747 lineColor = gridLines.zeroLineColor; 59748 borderDash = gridLines.zeroLineBorderDash; 59749 borderDashOffset = gridLines.zeroLineBorderDashOffset; 59750 } else { 59751 lineWidth = helpers.valueAtIndexOrDefault(gridLines.lineWidth, index); 59752 lineColor = helpers.valueAtIndexOrDefault(gridLines.color, index); 59753 borderDash = helpers.valueOrDefault(gridLines.borderDash, globalDefaults.borderDash); 59754 borderDashOffset = helpers.valueOrDefault(gridLines.borderDashOffset, globalDefaults.borderDashOffset); 59755 } 59756 59757 // Common properties 59758 var tx1, ty1, tx2, ty2, x1, y1, x2, y2, labelX, labelY; 59759 var textAlign = 'middle'; 59760 var textBaseline = 'middle'; 59761 var tickPadding = optionTicks.padding; 59762 59763 if (isHorizontal) { 59764 var labelYOffset = tl + tickPadding; 59765 59766 if (options.position === 'bottom') { 59767 // bottom 59768 textBaseline = !isRotated ? 'top' : 'middle'; 59769 textAlign = !isRotated ? 'center' : 'right'; 59770 labelY = me.top + labelYOffset; 59771 } else { 59772 // top 59773 textBaseline = !isRotated ? 'bottom' : 'middle'; 59774 textAlign = !isRotated ? 'center' : 'left'; 59775 labelY = me.bottom - labelYOffset; 59776 } 59777 59778 var xLineValue = getLineValue(me, index, gridLines.offsetGridLines && ticks.length > 1); 59779 if (xLineValue < me.left) { 59780 lineColor = 'rgba(0,0,0,0)'; 59781 } 59782 xLineValue += helpers.aliasPixel(lineWidth); 59783 59784 labelX = me.getPixelForTick(index) + optionTicks.labelOffset; // x values for optionTicks (need to consider offsetLabel option) 59785 59786 tx1 = tx2 = x1 = x2 = xLineValue; 59787 ty1 = yTickStart; 59788 ty2 = yTickEnd; 59789 y1 = chartArea.top; 59790 y2 = chartArea.bottom + axisWidth; 59791 } else { 59792 var isLeft = options.position === 'left'; 59793 var labelXOffset; 59794 59795 if (optionTicks.mirror) { 59796 textAlign = isLeft ? 'left' : 'right'; 59797 labelXOffset = tickPadding; 59798 } else { 59799 textAlign = isLeft ? 'right' : 'left'; 59800 labelXOffset = tl + tickPadding; 59801 } 59802 59803 labelX = isLeft ? me.right - labelXOffset : me.left + labelXOffset; 59804 59805 var yLineValue = getLineValue(me, index, gridLines.offsetGridLines && ticks.length > 1); 59806 if (yLineValue < me.top) { 59807 lineColor = 'rgba(0,0,0,0)'; 59808 } 59809 yLineValue += helpers.aliasPixel(lineWidth); 59810 59811 labelY = me.getPixelForTick(index) + optionTicks.labelOffset; 59812 59813 tx1 = xTickStart; 59814 tx2 = xTickEnd; 59815 x1 = chartArea.left; 59816 x2 = chartArea.right + axisWidth; 59817 ty1 = ty2 = y1 = y2 = yLineValue; 59818 } 59819 59820 itemsToDraw.push({ 59821 tx1: tx1, 59822 ty1: ty1, 59823 tx2: tx2, 59824 ty2: ty2, 59825 x1: x1, 59826 y1: y1, 59827 x2: x2, 59828 y2: y2, 59829 labelX: labelX, 59830 labelY: labelY, 59831 glWidth: lineWidth, 59832 glColor: lineColor, 59833 glBorderDash: borderDash, 59834 glBorderDashOffset: borderDashOffset, 59835 rotation: -1 * labelRotationRadians, 59836 label: label, 59837 major: tick.major, 59838 textBaseline: textBaseline, 59839 textAlign: textAlign 59840 }); 59841 }); 59842 59843 // Draw all of the tick labels, tick marks, and grid lines at the correct places 59844 helpers.each(itemsToDraw, function(itemToDraw) { 59845 if (gridLines.display) { 59846 context.save(); 59847 context.lineWidth = itemToDraw.glWidth; 59848 context.strokeStyle = itemToDraw.glColor; 59849 if (context.setLineDash) { 59850 context.setLineDash(itemToDraw.glBorderDash); 59851 context.lineDashOffset = itemToDraw.glBorderDashOffset; 59852 } 59853 59854 context.beginPath(); 59855 59856 if (gridLines.drawTicks) { 59857 context.moveTo(itemToDraw.tx1, itemToDraw.ty1); 59858 context.lineTo(itemToDraw.tx2, itemToDraw.ty2); 59859 } 59860 59861 if (gridLines.drawOnChartArea) { 59862 context.moveTo(itemToDraw.x1, itemToDraw.y1); 59863 context.lineTo(itemToDraw.x2, itemToDraw.y2); 59864 } 59865 59866 context.stroke();
59867 context.restore(); 59868 } 59869 59870 if (optionTicks.display) { 59871 // Make sure we draw text in the correct color and font 59872 context.save(); 59873 context.translate(itemToDraw.labelX, itemToDraw.labelY); 59874 context.rotate(itemToDraw.rotation); 59875 context.font = itemToDraw.major ? majorTickFont.font : tickFont.font; 59876 context.fillStyle = itemToDraw.major ? majorTickFontColor : tickFontColor; 59877 context.textBaseline = itemToDraw.textBaseline; 59878 context.textAlign = itemToDraw.textAlign; 59879 59880 var label = itemToDraw.label; 59881 if (helpers.isArray(label)) { 59882 var lineCount = label.length; 59883 var lineHeight = tickFont.size * 1.5; 59884 var y = me.isHorizontal() ? 0 : -lineHeight * (lineCount - 1) / 2; 59885 59886 for (var i = 0; i < lineCount; ++i) { 59887 // We just make sure the multiline element is a string here.. 59888 context.fillText('' + label[i], 0, y); 59889 // apply same lineSpacing as calculated @ L#320 59890 y += lineHeight; 59891 } 59892 } else { 59893 context.fillText(label, 0, 0); 59894 } 59895 context.restore(); 59896 } 59897 }); 59898 59899 if (scaleLabel.display) { 59900 // Draw the scale label 59901 var scaleLabelX; 59902 var scaleLabelY; 59903 var rotation = 0; 59904 var halfLineHeight = parseLineHeight(scaleLabel) / 2; 59905 59906 if (isHorizontal) { 59907 scaleLabelX = me.left + ((me.right - me.left) / 2); // midpoint of the width 59908 scaleLabelY = options.position === 'bottom' 59909 ? me.bottom - halfLineHeight - scaleLabelPadding.bottom 59910 : me.top + halfLineHeight + scaleLabelPadding.top; 59911 } else { 59912 var isLeft = options.position === 'left'; 59913 scaleLabelX = isLeft 59914 ? me.left + halfLineHeight + scaleLabelPadding.top 59915 : me.right - halfLineHeight - scaleLabelPadding.top; 59916 scaleLabelY = me.top + ((me.bottom - me.top) / 2); 59917 rotation = isLeft ? -0.5 * Math.PI : 0.5 * Math.PI; 59918 } 59919 59920 context.save(); 59921 context.translate(scaleLabelX, scaleLabelY); 59922 context.rotate(rotation); 59923 context.textAlign = 'center'; 59924 context.textBaseline = 'middle'; 59925 context.fillStyle = scaleLabelFontColor; // render in correct colour 59926 context.font = scaleLabelFont.font;
59927 context.fillText(scaleLabel.labelString, 0, 0); 59928 context.restore(); 59929 } 59930 59931 if (gridLines.drawBorder) { 59932 // Draw the line at the edge of the axis 59933 context.lineWidth = helpers.valueAtIndexOrDefault(gridLines.lineWidth, 0); 59934 context.strokeStyle = helpers.valueAtIndexOrDefault(gridLines.color, 0); 59935 var x1 = me.left; 59936 var x2 = me.right + axisWidth; 59937 var y1 = me.top; 59938 var y2 = me.bottom + axisWidth; 59939 59940 var aliasPixel = helpers.aliasPixel(context.lineWidth); 59941 if (isHorizontal) { 59942 y1 = y2 = options.position === 'top' ? me.bottom : me.top; 59943 y1 += aliasPixel; 59944 y2 += aliasPixel; 59945 } else { 59946 x1 = x2 = options.position === 'left' ? me.right : me.left; 59947 x1 += aliasPixel; 59948 x2 += aliasPixel; 59949 } 59950 59951 context.beginPath(); 59952 context.moveTo(x1, y1); 59953 context.lineTo(x2, y2); 59954 context.stroke(); 59955 } 59956 } 59957 }); 59958}; 59959 59960 59961/***/ }), 59962/* 206 */ 59963/***/ (function(module, exports, __webpack_require__) { 59964 59965"use strict"; 59966 59967 59968var defaults = __webpack_require__(2); 59969var helpers = __webpack_require__(1); 59970var layouts = __webpack_require__(9); 59971 59972module.exports = function(Chart) { 59973 59974 Chart.scaleService = { 59975 // Scale registration object. Extensions can register new scale types (such as log or DB scales) and then 59976 // use the new chart options to grab the correct scale 59977 constructors: {}, 59978 // Use a registration function so that we can move to an ES6 map when we no longer need to support 59979 // old browsers 59980 59981 // Scale config defaults 59982 defaults: {}, 59983 registerScaleType: function(type, scaleConstructor, scaleDefaults) { 59984 this.constructors[type] = scaleConstructor; 59985 this.defaults[type] = helpers.clone(scaleDefaults); 59986 }, 59987 getScaleConstructor: function(type) { 59988 return this.constructors.hasOwnProperty(type) ? this.constructors[type] : undefined; 59989 }, 59990 getScaleDefaults: function(type) { 59991 // Return the scale defaults merged with the global settings so that we always use the latest ones 59992 return this.defaults.hasOwnProperty(type) ? helpers.merge({}, [defaults.scale, this.defaults[type]]) : {}; 59993 }, 59994 updateScaleDefaults: function(type, additions) { 59995 var me = this; 59996 if (me.defaults.hasOwnProperty(type)) { 59997 me.defaults[type] = helpers.extend(me.defaults[type], additions); 59998 } 59999 }, 60000 addScalesToLayout: function(chart) { 60001 // Adds each scale to the chart.boxes array to be sized accordingly 60002 helpers.each(chart.scales, function(scale) { 60003 // Set ILayoutItem parameters for backwards compatibility 60004 scale.fullWidth = scale.options.fullWidth; 60005 scale.position = scale.options.position; 60006 scale.weight = scale.options.weight; 60007 layouts.addBox(chart, scale); 60008 }); 60009 } 60010 }; 60011}; 60012 60013 60014/***/ }), 60015/* 207 */ 60016/***/ (function(module, exports, __webpack_require__) { 60017 60018"use strict"; 60019 60020 60021var defaults = __webpack_require__(2); 60022var Element = __webpack_require__(5); 60023var helpers = __webpack_require__(1); 60024 60025defaults._set('global', { 60026 tooltips: { 60027 enabled: true, 60028 custom: null, 60029 mode: 'nearest', 60030 position: 'average', 60031 intersect: true, 60032 backgroundColor: 'rgba(0,0,0,0.8)', 60033 titleFontStyle: 'bold', 60034 titleSpacing: 2, 60035 titleMarginBottom: 6, 60036 titleFontColor: '#fff', 60037 titleAlign: 'left', 60038 bodySpacing: 2, 60039 bodyFontColor: '#fff', 60040 bodyAlign: 'left', 60041 footerFontStyle: 'bold', 60042 footerSpacing: 2, 60043 footerMarginTop: 6, 60044 footerFontColor: '#fff', 60045 footerAlign: 'left', 60046 yPadding: 6, 60047 xPadding: 6, 60048 caretPadding: 2, 60049 caretSize: 5, 60050 cornerRadius: 6, 60051 multiKeyBackground: '#fff', 60052 displayColors: true, 60053 borderColor: 'rgba(0,0,0,0)', 60054 borderWidth: 0, 60055 callbacks: { 60056 // Args are: (tooltipItems, data) 60057 beforeTitle: helpers.noop, 60058 title: function(tooltipItems, data) { 60059 // Pick first xLabel for now 60060 var title = ''; 60061 var labels = data.labels; 60062 var labelCount = labels ? labels.length : 0; 60063 60064 if (tooltipItems.length > 0) { 60065 var item = tooltipItems[0]; 60066 60067 if (item.xLabel) { 60068 title = item.xLabel; 60069 } else if (labelCount > 0 && item.index < labelCount) { 60070 title = labels[item.index]; 60071 } 60072 } 60073 60074 return title; 60075 }, 60076 afterTitle: helpers.noop, 60077 60078 // Args are: (tooltipItems, data) 60079 beforeBody: helpers.noop, 60080 60081 // Args are: (tooltipItem, data) 60082 beforeLabel: helpers.noop, 60083 label: function(tooltipItem, data) { 60084 var label = data.datasets[tooltipItem.datasetIndex].label || ''; 60085 60086 if (label) { 60087 label += ': '; 60088 } 60089 label += tooltipItem.yLabel; 60090 return label; 60091 }, 60092 labelColor: function(tooltipItem, chart) { 60093 var meta = chart.getDatasetMeta(tooltipItem.datasetIndex); 60094 var activeElement = meta.data[tooltipItem.index]; 60095 var view = activeElement._view; 60096 return { 60097 borderColor: view.borderColor, 60098 backgroundColor: view.backgroundColor 60099 }; 60100 }, 60101 labelTextColor: function() { 60102 return this._options.bodyFontColor; 60103 }, 60104 afterLabel: helpers.noop, 60105 60106 // Args are: (tooltipItems, data) 60107 afterBody: helpers.noop, 60108 60109 // Args are: (tooltipItems, data) 60110 beforeFooter: helpers.noop, 60111 footer: helpers.noop, 60112 afterFooter: helpers.noop 60113 } 60114 } 60115}); 60116 60117module.exports = function(Chart) { 60118 60119 /** 60120 * Helper method to merge the opacity into a color 60121 */
vendor: 9,332 bytes, lines 60122-60425
60122 function mergeOpacity(colorString, opacity) { 60123 var color = helpers.color(colorString); 60124 return color.alpha(opacity * color.alpha()).rgbaString(); 60125 } 60126 60127 // Helper to push or concat based on if the 2nd parameter is an array or not 60128 function pushOrConcat(base, toPush) { 60129 if (toPush) { 60130 if (helpers.isArray(toPush)) { 60131 // base = base.concat(toPush); 60132 Array.prototype.push.apply(base, toPush); 60133 } else { 60134 base.push(toPush); 60135 } 60136 } 60137 60138 return base; 60139 } 60140 60141 // Private helper to create a tooltip item model 60142 // @param element : the chart element (point, arc, bar) to create the tooltip item for 60143 // @return : new tooltip item 60144 function createTooltipItem(element) { 60145 var xScale = element._xScale; 60146 var yScale = element._yScale || element._scale; // handle radar || polarArea charts 60147 var index = element._index; 60148 var datasetIndex = element._datasetIndex; 60149 60150 return { 60151 xLabel: xScale ? xScale.getLabelForIndex(index, datasetIndex) : '', 60152 yLabel: yScale ? yScale.getLabelForIndex(index, datasetIndex) : '', 60153 index: index, 60154 datasetIndex: datasetIndex, 60155 x: element._model.x, 60156 y: element._model.y 60157 }; 60158 } 60159 60160 /** 60161 * Helper to get the reset model for the tooltip 60162 * @param tooltipOpts {Object} the tooltip options 60163 */ 60164 function getBaseModel(tooltipOpts) { 60165 var globalDefaults = defaults.global; 60166 var valueOrDefault = helpers.valueOrDefault; 60167 60168 return { 60169 // Positioning 60170 xPadding: tooltipOpts.xPadding, 60171 yPadding: tooltipOpts.yPadding, 60172 xAlign: tooltipOpts.xAlign, 60173 yAlign: tooltipOpts.yAlign, 60174 60175 // Body 60176 bodyFontColor: tooltipOpts.bodyFontColor, 60177 _bodyFontFamily: valueOrDefault(tooltipOpts.bodyFontFamily, globalDefaults.defaultFontFamily), 60178 _bodyFontStyle: valueOrDefault(tooltipOpts.bodyFontStyle, globalDefaults.defaultFontStyle), 60179 _bodyAlign: tooltipOpts.bodyAlign, 60180 bodyFontSize: valueOrDefault(tooltipOpts.bodyFontSize, globalDefaults.defaultFontSize), 60181 bodySpacing: tooltipOpts.bodySpacing, 60182 60183 // Title 60184 titleFontColor: tooltipOpts.titleFontColor, 60185 _titleFontFamily: valueOrDefault(tooltipOpts.titleFontFamily, globalDefaults.defaultFontFamily), 60186 _titleFontStyle: valueOrDefault(tooltipOpts.titleFontStyle, globalDefaults.defaultFontStyle), 60187 titleFontSize: valueOrDefault(tooltipOpts.titleFontSize, globalDefaults.defaultFontSize), 60188 _titleAlign: tooltipOpts.titleAlign, 60189 titleSpacing: tooltipOpts.titleSpacing, 60190 titleMarginBottom: tooltipOpts.titleMarginBottom, 60191 60192 // Footer 60193 footerFontColor: tooltipOpts.footerFontColor, 60194 _footerFontFamily: valueOrDefault(tooltipOpts.footerFontFamily, globalDefaults.defaultFontFamily), 60195 _footerFontStyle: valueOrDefault(tooltipOpts.footerFontStyle, globalDefaults.defaultFontStyle), 60196 footerFontSize: valueOrDefault(tooltipOpts.footerFontSize, globalDefaults.defaultFontSize), 60197 _footerAlign: tooltipOpts.footerAlign, 60198 footerSpacing: tooltipOpts.footerSpacing, 60199 footerMarginTop: tooltipOpts.footerMarginTop, 60200 60201 // Appearance 60202 caretSize: tooltipOpts.caretSize, 60203 cornerRadius: tooltipOpts.cornerRadius, 60204 backgroundColor: tooltipOpts.backgroundColor, 60205 opacity: 0, 60206 legendColorBackground: tooltipOpts.multiKeyBackground, 60207 displayColors: tooltipOpts.displayColors, 60208 borderColor: tooltipOpts.borderColor, 60209 borderWidth: tooltipOpts.borderWidth 60210 }; 60211 } 60212 60213 /** 60214 * Get the size of the tooltip 60215 */ 60216 function getTooltipSize(tooltip, model) { 60217 var ctx = tooltip._chart.ctx; 60218 60219 var height = model.yPadding * 2; // Tooltip Padding 60220 var width = 0; 60221 60222 // Count of all lines in the body 60223 var body = model.body; 60224 var combinedBodyLength = body.reduce(function(count, bodyItem) { 60225 return count + bodyItem.before.length + bodyItem.lines.length + bodyItem.after.length; 60226 }, 0); 60227 combinedBodyLength += model.beforeBody.length + model.afterBody.length; 60228 60229 var titleLineCount = model.title.length; 60230 var footerLineCount = model.footer.length; 60231 var titleFontSize = model.titleFontSize; 60232 var bodyFontSize = model.bodyFontSize; 60233 var footerFontSize = model.footerFontSize; 60234 60235 height += titleLineCount * titleFontSize; // Title Lines 60236 height += titleLineCount ? (titleLineCount - 1) * model.titleSpacing : 0; // Title Line Spacing 60237 height += titleLineCount ? model.titleMarginBottom : 0; // Title's bottom Margin 60238 height += combinedBodyLength * bodyFontSize; // Body Lines 60239 height += combinedBodyLength ? (combinedBodyLength - 1) * model.bodySpacing : 0; // Body Line Spacing 60240 height += footerLineCount ? model.footerMarginTop : 0; // Footer Margin 60241 height += footerLineCount * (footerFontSize); // Footer Lines 60242 height += footerLineCount ? (footerLineCount - 1) * model.footerSpacing : 0; // Footer Line Spacing 60243 60244 // Title width 60245 var widthPadding = 0; 60246 var maxLineWidth = function(line) { 60247 width = Math.max(width, ctx.measureText(line).width + widthPadding); 60248 }; 60249 60250 ctx.font = helpers.fontString(titleFontSize, model._titleFontStyle, model._titleFontFamily); 60251 helpers.each(model.title, maxLineWidth); 60252 60253 // Body width 60254 ctx.font = helpers.fontString(bodyFontSize, model._bodyFontStyle, model._bodyFontFamily); 60255 helpers.each(model.beforeBody.concat(model.afterBody), maxLineWidth); 60256 60257 // Body lines may include some extra width due to the color box 60258 widthPadding = model.displayColors ? (bodyFontSize + 2) : 0; 60259 helpers.each(body, function(bodyItem) { 60260 helpers.each(bodyItem.before, maxLineWidth); 60261 helpers.each(bodyItem.lines, maxLineWidth); 60262 helpers.each(bodyItem.after, maxLineWidth); 60263 }); 60264 60265 // Reset back to 0 60266 widthPadding = 0; 60267 60268 // Footer width 60269 ctx.font = helpers.fontString(footerFontSize, model._footerFontStyle, model._footerFontFamily); 60270 helpers.each(model.footer, maxLineWidth); 60271 60272 // Add padding 60273 width += 2 * model.xPadding; 60274 60275 return { 60276 width: width, 60277 height: height 60278 }; 60279 } 60280 60281 /** 60282 * Helper to get the alignment of a tooltip given the size 60283 */ 60284 function determineAlignment(tooltip, size) { 60285 var model = tooltip._model; 60286 var chart = tooltip._chart; 60287 var chartArea = tooltip._chart.chartArea; 60288 var xAlign = 'center'; 60289 var yAlign = 'center'; 60290 60291 if (model.y < size.height) { 60292 yAlign = 'top'; 60293 } else if (model.y > (chart.height - size.height)) { 60294 yAlign = 'bottom'; 60295 } 60296 60297 var lf, rf; // functions to determine left, right alignment 60298 var olf, orf; // functions to determine if left/right alignment causes tooltip to go outside chart 60299 var yf; // function to get the y alignment if the tooltip goes outside of the left or right edges 60300 var midX = (chartArea.left + chartArea.right) / 2; 60301 var midY = (chartArea.top + chartArea.bottom) / 2; 60302 60303 if (yAlign === 'center') { 60304 lf = function(x) { 60305 return x <= midX; 60306 }; 60307 rf = function(x) { 60308 return x > midX; 60309 }; 60310 } else { 60311 lf = function(x) { 60312 return x <= (size.width / 2); 60313 }; 60314 rf = function(x) { 60315 return x >= (chart.width - (size.width / 2)); 60316 }; 60317 } 60318 60319 olf = function(x) { 60320 return x + size.width + model.caretSize + model.caretPadding > chart.width; 60321 }; 60322 orf = function(x) { 60323 return x - size.width - model.caretSize - model.caretPadding < 0; 60324 }; 60325 yf = function(y) { 60326 return y <= midY ? 'top' : 'bottom'; 60327 }; 60328 60329 if (lf(model.x)) { 60330 xAlign = 'left'; 60331 60332 // Is tooltip too wide and goes over the right side of the chart.? 60333 if (olf(model.x)) { 60334 xAlign = 'center'; 60335 yAlign = yf(model.y); 60336 } 60337 } else if (rf(model.x)) { 60338 xAlign = 'right'; 60339 60340 // Is tooltip too wide and goes outside left edge of canvas? 60341 if (orf(model.x)) { 60342 xAlign = 'center'; 60343 yAlign = yf(model.y); 60344 } 60345 } 60346 60347 var opts = tooltip._options; 60348 return { 60349 xAlign: opts.xAlign ? opts.xAlign : xAlign, 60350 yAlign: opts.yAlign ? opts.yAlign : yAlign 60351 }; 60352 } 60353 60354 /** 60355 * @Helper to get the location a tooltip needs to be placed at given the initial position (via the vm) and the size and alignment 60356 */ 60357 function getBackgroundPoint(vm, size, alignment, chart) { 60358 // Background Position 60359 var x = vm.x; 60360 var y = vm.y; 60361 60362 var caretSize = vm.caretSize; 60363 var caretPadding = vm.caretPadding; 60364 var cornerRadius = vm.cornerRadius; 60365 var xAlign = alignment.xAlign; 60366 var yAlign = alignment.yAlign; 60367 var paddingAndSize = caretSize + caretPadding; 60368 var radiusAndPadding = cornerRadius + caretPadding; 60369 60370 if (xAlign === 'right') { 60371 x -= size.width; 60372 } else if (xAlign === 'center') { 60373 x -= (size.width / 2); 60374 if (x + size.width > chart.width) { 60375 x = chart.width - size.width; 60376 } 60377 if (x < 0) { 60378 x = 0; 60379 } 60380 } 60381 60382 if (yAlign === 'top') { 60383 y += paddingAndSize; 60384 } else if (yAlign === 'bottom') { 60385 y -= size.height + paddingAndSize; 60386 } else { 60387 y -= (size.height / 2); 60388 } 60389 60390 if (yAlign === 'center') { 60391 if (xAlign === 'left') { 60392 x += paddingAndSize; 60393 } else if (xAlign === 'right') { 60394 x -= paddingAndSize; 60395 } 60396 } else if (xAlign === 'left') { 60397 x -= radiusAndPadding; 60398 } else if (xAlign === 'right') { 60399 x += radiusAndPadding; 60400 } 60401 60402 return { 60403 x: x, 60404 y: y 60405 }; 60406 } 60407 60408 Chart.Tooltip = Element.extend({ 60409 initialize: function() { 60410 this._model = getBaseModel(this._options); 60411 this._lastActive = []; 60412 }, 60413 60414 // Get the title 60415 // Args are: (tooltipItem, data) 60416 getTitle: function() { 60417 var me = this; 60418 var opts = me._options; 60419 var callbacks = opts.callbacks; 60420 60421 var beforeTitle = callbacks.beforeTitle.apply(me, arguments); 60422 var title = callbacks.title.apply(me, arguments); 60423 var afterTitle = callbacks.afterTitle.apply(me, arguments); 60424 60425 var lines = [];
60426 lines = pushOrConcat(lines, beforeTitle); 60427 lines = pushOrConcat(lines, title); 60428 lines = pushOrConcat(lines, afterTitle); 60429 60430 return lines; 60431 }, 60432 60433 // Args are: (tooltipItem, data) 60434 getBeforeBody: function() { 60435 var lines = this._options.callbacks.beforeBody.apply(this, arguments); 60436 return helpers.isArray(lines) ? lines : lines !== undefined ? [lines] : []; 60437 }, 60438 60439 // Args are: (tooltipItem, data) 60440 getBody: function(tooltipItems, data) { 60441 var me = this; 60442 var callbacks = me._options.callbacks; 60443 var bodyItems = []; 60444 60445 helpers.each(tooltipItems, function(tooltipItem) { 60446 var bodyItem = { 60447 before: [], 60448 lines: [], 60449 after: [] 60450 }; 60451 pushOrConcat(bodyItem.before, callbacks.beforeLabel.call(me, tooltipItem, data)); 60452 pushOrConcat(bodyItem.lines, callbacks.label.call(me, tooltipItem, data)); 60453 pushOrConcat(bodyItem.after, callbacks.afterLabel.call(me, tooltipItem, data)); 60454 60455 bodyItems.push(bodyItem); 60456 }); 60457 60458 return bodyItems; 60459 }, 60460 60461 // Args are: (tooltipItem, data) 60462 getAfterBody: function() { 60463 var lines = this._options.callbacks.afterBody.apply(this, arguments); 60464 return helpers.isArray(lines) ? lines : lines !== undefined ? [lines] : []; 60465 }, 60466 60467 // Get the footer and beforeFooter and afterFooter lines 60468 // Args are: (tooltipItem, data) 60469 getFooter: function() { 60470 var me = this; 60471 var callbacks = me._options.callbacks; 60472 60473 var beforeFooter = callbacks.beforeFooter.apply(me, arguments); 60474 var footer = callbacks.footer.apply(me, arguments); 60475 var afterFooter = callbacks.afterFooter.apply(me, arguments); 60476 60477 var lines = []; 60478 lines = pushOrConcat(lines, beforeFooter); 60479 lines = pushOrConcat(lines, footer); 60480 lines = pushOrConcat(lines, afterFooter); 60481 60482 return lines; 60483 }, 60484 60485 update: function(changed) { 60486 var me = this; 60487 var opts = me._options; 60488 60489 // Need to regenerate the model because its faster than using extend and it is necessary due to the optimization in Chart.Element.transition 60490 // that does _view = _model if ease === 1. This causes the 2nd tooltip update to set properties in both the view and model at the same time 60491 // which breaks any animations. 60492 var existingModel = me._model; 60493 var model = me._model = getBaseModel(opts); 60494 var active = me._active; 60495 60496 var data = me._data; 60497 60498 // In the case where active.length === 0 we need to keep these at existing values for good animations 60499 var alignment = { 60500 xAlign: existingModel.xAlign, 60501 yAlign: existingModel.yAlign 60502 }; 60503 var backgroundPoint = { 60504 x: existingModel.x, 60505 y: existingModel.y 60506 }; 60507 var tooltipSize = { 60508 width: existingModel.width, 60509 height: existingModel.height 60510 }; 60511 var tooltipPosition = { 60512 x: existingModel.caretX, 60513 y: existingModel.caretY 60514 }; 60515 60516 var i, len; 60517 60518 if (active.length) { 60519 model.opacity = 1; 60520 60521 var labelColors = []; 60522 var labelTextColors = []; 60523 tooltipPosition = Chart.Tooltip.positioners[opts.position].call(me, active, me._eventPosition); 60524 60525 var tooltipItems = []; 60526 for (i = 0, len = active.length; i < len; ++i) { 60527 tooltipItems.push(createTooltipItem(active[i])); 60528 } 60529 60530 // If the user provided a filter function, use it to modify the tooltip items 60531 if (opts.filter) { 60532 tooltipItems = tooltipItems.filter(function(a) { 60533 return opts.filter(a, data); 60534 }); 60535 } 60536 60537 // If the user provided a sorting function, use it to modify the tooltip items 60538 if (opts.itemSort) { 60539 tooltipItems = tooltipItems.sort(function(a, b) { 60540 return opts.itemSort(a, b, data); 60541 }); 60542 } 60543 60544 // Determine colors for boxes 60545 helpers.each(tooltipItems, function(tooltipItem) { 60546 labelColors.push(opts.callbacks.labelColor.call(me, tooltipItem, me._chart)); 60547 labelTextColors.push(opts.callbacks.labelTextColor.call(me, tooltipItem, me._chart)); 60548 }); 60549 60550 60551 // Build the Text Lines 60552 model.title = me.getTitle(tooltipItems, data); 60553 model.beforeBody = me.getBeforeBody(tooltipItems, data); 60554 model.body = me.getBody(tooltipItems, data); 60555 model.afterBody = me.getAfterBody(tooltipItems, data); 60556 model.footer = me.getFooter(tooltipItems, data); 60557 60558 // Initial positioning and colors 60559 model.x = Math.round(tooltipPosition.x); 60560 model.y = Math.round(tooltipPosition.y); 60561 model.caretPadding = opts.caretPadding; 60562 model.labelColors = labelColors; 60563 model.labelTextColors = labelTextColors; 60564 60565 // data points 60566 model.dataPoints = tooltipItems; 60567 60568 // We need to determine alignment of the tooltip 60569 tooltipSize = getTooltipSize(this, model); 60570 alignment = determineAlignment(this, tooltipSize); 60571 // Final Size and Position
60572 backgroundPoint = getBackgroundPoint(model, tooltipSize, alignment, me._chart); 60573 } else { 60574 model.opacity = 0; 60575 } 60576 60577 model.xAlign = alignment.xAlign; 60578 model.yAlign = alignment.yAlign; 60579 model.x = backgroundPoint.x; 60580 model.y = backgroundPoint.y; 60581 model.width = tooltipSize.width; 60582 model.height = tooltipSize.height; 60583 60584 // Point where the caret on the tooltip points to 60585 model.caretX = tooltipPosition.x; 60586 model.caretY = tooltipPosition.y; 60587 60588 me._model = model; 60589 60590 if (changed && opts.custom) { 60591 opts.custom.call(me, model); 60592 } 60593 60594 return me; 60595 }, 60596 drawCaret: function(tooltipPoint, size) { 60597 var ctx = this._chart.ctx; 60598 var vm = this._view; 60599 var caretPosition = this.getCaretPosition(tooltipPoint, size, vm); 60600 60601 ctx.lineTo(caretPosition.x1, caretPosition.y1); 60602 ctx.lineTo(caretPosition.x2, caretPosition.y2); 60603 ctx.lineTo(caretPosition.x3, caretPosition.y3); 60604 }, 60605 getCaretPosition: function(tooltipPoint, size, vm) { 60606 var x1, x2, x3, y1, y2, y3; 60607 var caretSize = vm.caretSize; 60608 var cornerRadius = vm.cornerRadius; 60609 var xAlign = vm.xAlign; 60610 var yAlign = vm.yAlign; 60611 var ptX = tooltipPoint.x; 60612 var ptY = tooltipPoint.y; 60613 var width = size.width; 60614 var height = size.height; 60615 60616 if (yAlign === 'center') { 60617 y2 = ptY + (height / 2); 60618 60619 if (xAlign === 'left') { 60620 x1 = ptX; 60621 x2 = x1 - caretSize; 60622 x3 = x1; 60623 60624 y1 = y2 + caretSize; 60625 y3 = y2 - caretSize; 60626 } else { 60627 x1 = ptX + width; 60628 x2 = x1 + caretSize; 60629 x3 = x1; 60630 60631 y1 = y2 - caretSize; 60632 y3 = y2 + caretSize; 60633 } 60634 } else { 60635 if (xAlign === 'left') { 60636 x2 = ptX + cornerRadius + (caretSize); 60637 x1 = x2 - caretSize; 60638 x3 = x2 + caretSize; 60639 } else if (xAlign === 'right') { 60640 x2 = ptX + width - cornerRadius - caretSize; 60641 x1 = x2 - caretSize; 60642 x3 = x2 + caretSize; 60643 } else { 60644 x2 = vm.caretX; 60645 x1 = x2 - caretSize; 60646 x3 = x2 + caretSize; 60647 } 60648 if (yAlign === 'top') { 60649 y1 = ptY; 60650 y2 = y1 - caretSize; 60651 y3 = y1; 60652 } else { 60653 y1 = ptY + height; 60654 y2 = y1 + caretSize; 60655 y3 = y1; 60656 // invert drawing order 60657 var tmp = x3; 60658 x3 = x1; 60659 x1 = tmp; 60660 } 60661 } 60662 return {x1: x1, x2: x2, x3: x3, y1: y1, y2: y2, y3: y3}; 60663 }, 60664 drawTitle: function(pt, vm, ctx, opacity) { 60665 var title = vm.title; 60666 60667 if (title.length) { 60668 ctx.textAlign = vm._titleAlign; 60669 ctx.textBaseline = 'top'; 60670 60671 var titleFontSize = vm.titleFontSize; 60672 var titleSpacing = vm.titleSpacing; 60673 60674 ctx.fillStyle = mergeOpacity(vm.titleFontColor, opacity); 60675 ctx.font = helpers.fontString(titleFontSize, vm._titleFontStyle, vm._titleFontFamily); 60676 60677 var i, len; 60678 for (i = 0, len = title.length; i < len; ++i) { 60679 ctx.fillText(title[i], pt.x, pt.y); 60680 pt.y += titleFontSize + titleSpacing; // Line Height and spacing 60681 60682 if (i + 1 === title.length) { 60683 pt.y += vm.titleMarginBottom - titleSpacing; // If Last, add margin, remove spacing 60684 } 60685 } 60686 } 60687 }, 60688 drawBody: function(pt, vm, ctx, opacity) { 60689 var bodyFontSize = vm.bodyFontSize; 60690 var bodySpacing = vm.bodySpacing; 60691 var body = vm.body; 60692 60693 ctx.textAlign = vm._bodyAlign; 60694 ctx.textBaseline = 'top'; 60695 ctx.font = helpers.fontString(bodyFontSize, vm._bodyFontStyle, vm._bodyFontFamily); 60696 60697 // Before Body 60698 var xLinePadding = 0; 60699 var fillLineOfText = function(line) { 60700 ctx.fillText(line, pt.x + xLinePadding, pt.y); 60701 pt.y += bodyFontSize + bodySpacing; 60702 }; 60703 60704 // Before body lines 60705 ctx.fillStyle = mergeOpacity(vm.bodyFontColor, opacity); 60706 helpers.each(vm.beforeBody, fillLineOfText); 60707 60708 var drawColorBoxes = vm.displayColors; 60709 xLinePadding = drawColorBoxes ? (bodyFontSize + 2) : 0; 60710 60711 // Draw body lines now 60712 helpers.each(body, function(bodyItem, i) { 60713 var textColor = mergeOpacity(vm.labelTextColors[i], opacity); 60714 ctx.fillStyle = textColor; 60715 helpers.each(bodyItem.before, fillLineOfText); 60716 60717 helpers.each(bodyItem.lines, function(line) { 60718 // Draw Legend-like boxes if needed 60719 if (drawColorBoxes) { 60720 // Fill a white rect so that colours merge nicely if the opacity is < 1
60721 ctx.fillStyle = mergeOpacity(vm.legendColorBackground, opacity); 60722 ctx.fillRect(pt.x, pt.y, bodyFontSize, bodyFontSize); 60723 60724 // Border 60725 ctx.lineWidth = 1; 60726 ctx.strokeStyle = mergeOpacity(vm.labelColors[i].borderColor, opacity); 60727 ctx.strokeRect(pt.x, pt.y, bodyFontSize, bodyFontSize); 60728 60729 // Inner square 60730 ctx.fillStyle = mergeOpacity(vm.labelColors[i].backgroundColor, opacity); 60731 ctx.fillRect(pt.x + 1, pt.y + 1, bodyFontSize - 2, bodyFontSize - 2); 60732 ctx.fillStyle = textColor; 60733 } 60734 60735 fillLineOfText(line); 60736 }); 60737 60738 helpers.each(bodyItem.after, fillLineOfText); 60739 }); 60740 60741 // Reset back to 0 for after body 60742 xLinePadding = 0; 60743 60744 // After body lines 60745 helpers.each(vm.afterBody, fillLineOfText); 60746 pt.y -= bodySpacing; // Remove last body spacing 60747 }, 60748 drawFooter: function(pt, vm, ctx, opacity) { 60749 var footer = vm.footer; 60750 60751 if (footer.length) { 60752 pt.y += vm.footerMarginTop; 60753 60754 ctx.textAlign = vm._footerAlign; 60755 ctx.textBaseline = 'top'; 60756 60757 ctx.fillStyle = mergeOpacity(vm.footerFontColor, opacity); 60758 ctx.font = helpers.fontString(vm.footerFontSize, vm._footerFontStyle, vm._footerFontFamily); 60759 60760 helpers.each(footer, function(line) { 60761 ctx.fillText(line, pt.x, pt.y); 60762 pt.y += vm.footerFontSize + vm.footerSpacing; 60763 }); 60764 } 60765 }, 60766 drawBackground: function(pt, vm, ctx, tooltipSize, opacity) { 60767 ctx.fillStyle = mergeOpacity(vm.backgroundColor, opacity); 60768 ctx.strokeStyle = mergeOpacity(vm.borderColor, opacity); 60769 ctx.lineWidth = vm.borderWidth; 60770 var xAlign = vm.xAlign; 60771 var yAlign = vm.yAlign; 60772 var x = pt.x; 60773 var y = pt.y; 60774 var width = tooltipSize.width; 60775 var height = tooltipSize.height; 60776 var radius = vm.cornerRadius; 60777 60778 ctx.beginPath(); 60779 ctx.moveTo(x + radius, y); 60780 if (yAlign === 'top') { 60781 this.drawCaret(pt, tooltipSize); 60782 } 60783 ctx.lineTo(x + width - radius, y); 60784 ctx.quadraticCurveTo(x + width, y, x + width, y + radius); 60785 if (yAlign === 'center' && xAlign === 'right') { 60786 this.drawCaret(pt, tooltipSize); 60787 } 60788 ctx.lineTo(x + width, y + height - radius); 60789 ctx.quadraticCurveTo(x + width, y + height, x + width - radius, y + height); 60790 if (yAlign === 'bottom') { 60791 this.drawCaret(pt, tooltipSize); 60792 } 60793 ctx.lineTo(x + radius, y + height); 60794 ctx.quadraticCurveTo(x, y + height, x, y + height - radius); 60795 if (yAlign === 'center' && xAlign === 'left') { 60796 this.drawCaret(pt, tooltipSize); 60797 } 60798 ctx.lineTo(x, y + radius); 60799 ctx.quadraticCurveTo(x, y, x + radius, y); 60800 ctx.closePath(); 60801 60802 ctx.fill(); 60803 60804 if (vm.borderWidth > 0) { 60805 ctx.stroke(); 60806 } 60807 }, 60808 draw: function() { 60809 var ctx = this._chart.ctx; 60810 var vm = this._view; 60811 60812 if (vm.opacity === 0) { 60813 return; 60814 } 60815 60816 var tooltipSize = { 60817 width: vm.width, 60818 height: vm.height 60819 }; 60820 var pt = { 60821 x: vm.x, 60822 y: vm.y 60823 }; 60824 60825 // IE11/Edge does not like very small opacities, so snap to 0 60826 var opacity = Math.abs(vm.opacity < 1e-3) ? 0 : vm.opacity; 60827 60828 // Truthy/falsey value for empty tooltip 60829 var hasTooltipContent = vm.title.length || vm.beforeBody.length || vm.body.length || vm.afterBody.length || vm.footer.length; 60830 60831 if (this._options.enabled && hasTooltipContent) { 60832 // Draw Background 60833 this.drawBackground(pt, vm, ctx, tooltipSize, opacity); 60834 60835 // Draw Title, Body, and Footer 60836 pt.x += vm.xPadding; 60837 pt.y += vm.yPadding; 60838 60839 // Titles 60840 this.drawTitle(pt, vm, ctx, opacity); 60841 60842 // Body 60843 this.drawBody(pt, vm, ctx, opacity); 60844 60845 // Footer 60846 this.drawFooter(pt, vm, ctx, opacity); 60847 } 60848 }, 60849 60850 /** 60851 * Handle an event 60852 * @private 60853 * @param {IEvent} event - The event to handle 60854 * @returns {Boolean} true if the tooltip changed 60855 */ 60856 handleEvent: function(e) { 60857 var me = this; 60858 var options = me._options; 60859 var changed = false; 60860 60861 me._lastActive = me._lastActive || []; 60862 60863 // Find Active Elements for tooltips 60864 if (e.type === 'mouseout') { 60865 me._active = []; 60866 } else { 60867 me._active = me._chart.getElementsAtEventForMode(e, options.mode, options); 60868 } 60869 60870 // Remember Last Actives 60871 changed = !helpers.arrayEquals(me._active, me._lastActive); 60872 60873 // Only handle target event on tooltip change 60874 if (changed) { 60875 me._lastActive = me._active; 60876 60877 if (options.enabled || options.custom) { 60878 me._eventPosition = { 60879 x: e.x, 60880 y: e.y 60881 }; 60882 60883 me.update(true); 60884 me.pivot(); 60885 } 60886 } 60887 60888 return changed; 60889 } 60890 }); 60891 60892 /** 60893 * @namespace Chart.Tooltip.positioners 60894 */ 60895 Chart.Tooltip.positioners = { 60896 /** 60897 * Average mode places the tooltip at the average position of the elements shown 60898 * @function Chart.Tooltip.positioners.average 60899 * @param elements {ChartElement[]} the elements being displayed in the tooltip 60900 * @returns {Point} tooltip position 60901 */ 60902 average: function(elements) { 60903 if (!elements.length) { 60904 return false;
vendor: 5,690 bytes, lines 60905-61144
60905 } 60906 60907 var i, len; 60908 var x = 0; 60909 var y = 0; 60910 var count = 0; 60911 60912 for (i = 0, len = elements.length; i < len; ++i) { 60913 var el = elements[i]; 60914 if (el && el.hasValue()) { 60915 var pos = el.tooltipPosition(); 60916 x += pos.x; 60917 y += pos.y; 60918 ++count; 60919 } 60920 } 60921 60922 return { 60923 x: Math.round(x / count), 60924 y: Math.round(y / count) 60925 }; 60926 }, 60927 60928 /** 60929 * Gets the tooltip position nearest of the item nearest to the event position 60930 * @function Chart.Tooltip.positioners.nearest 60931 * @param elements {Chart.Element[]} the tooltip elements 60932 * @param eventPosition {Point} the position of the event in canvas coordinates 60933 * @returns {Point} the tooltip position 60934 */ 60935 nearest: function(elements, eventPosition) { 60936 var x = eventPosition.x; 60937 var y = eventPosition.y; 60938 var minDistance = Number.POSITIVE_INFINITY; 60939 var i, len, nearestElement; 60940 60941 for (i = 0, len = elements.length; i < len; ++i) { 60942 var el = elements[i]; 60943 if (el && el.hasValue()) { 60944 var center = el.getCenterPoint(); 60945 var d = helpers.distanceBetweenPoints(eventPosition, center); 60946 60947 if (d < minDistance) { 60948 minDistance = d; 60949 nearestElement = el; 60950 } 60951 } 60952 } 60953 60954 if (nearestElement) { 60955 var tp = nearestElement.tooltipPosition(); 60956 x = tp.x; 60957 y = tp.y; 60958 } 60959 60960 return { 60961 x: x, 60962 y: y 60963 }; 60964 } 60965 }; 60966}; 60967 60968 60969/***/ }), 60970/* 208 */ 60971/***/ (function(module, exports, __webpack_require__) { 60972 60973"use strict"; 60974 60975 60976var defaults = __webpack_require__(2); 60977var Element = __webpack_require__(5); 60978var helpers = __webpack_require__(1); 60979 60980defaults._set('global', { 60981 elements: { 60982 arc: { 60983 backgroundColor: defaults.global.defaultColor, 60984 borderColor: '#fff', 60985 borderWidth: 2 60986 } 60987 } 60988}); 60989 60990module.exports = Element.extend({ 60991 inLabelRange: function(mouseX) { 60992 var vm = this._view; 60993 60994 if (vm) { 60995 return (Math.pow(mouseX - vm.x, 2) < Math.pow(vm.radius + vm.hoverRadius, 2)); 60996 } 60997 return false; 60998 }, 60999 61000 inRange: function(chartX, chartY) { 61001 var vm = this._view; 61002 61003 if (vm) { 61004 var pointRelativePosition = helpers.getAngleFromPoint(vm, {x: chartX, y: chartY}); 61005 var angle = pointRelativePosition.angle; 61006 var distance = pointRelativePosition.distance; 61007 61008 // Sanitise angle range 61009 var startAngle = vm.startAngle; 61010 var endAngle = vm.endAngle; 61011 while (endAngle < startAngle) { 61012 endAngle += 2.0 * Math.PI; 61013 } 61014 while (angle > endAngle) { 61015 angle -= 2.0 * Math.PI; 61016 } 61017 while (angle < startAngle) { 61018 angle += 2.0 * Math.PI; 61019 } 61020 61021 // Check if within the range of the open/close angle 61022 var betweenAngles = (angle >= startAngle && angle <= endAngle); 61023 var withinRadius = (distance >= vm.innerRadius && distance <= vm.outerRadius); 61024 61025 return (betweenAngles && withinRadius); 61026 } 61027 return false; 61028 }, 61029 61030 getCenterPoint: function() { 61031 var vm = this._view; 61032 var halfAngle = (vm.startAngle + vm.endAngle) / 2; 61033 var halfRadius = (vm.innerRadius + vm.outerRadius) / 2; 61034 return { 61035 x: vm.x + Math.cos(halfAngle) * halfRadius, 61036 y: vm.y + Math.sin(halfAngle) * halfRadius 61037 }; 61038 }, 61039 61040 getArea: function() { 61041 var vm = this._view; 61042 return Math.PI * ((vm.endAngle - vm.startAngle) / (2 * Math.PI)) * (Math.pow(vm.outerRadius, 2) - Math.pow(vm.innerRadius, 2)); 61043 }, 61044 61045 tooltipPosition: function() { 61046 var vm = this._view; 61047 var centreAngle = vm.startAngle + ((vm.endAngle - vm.startAngle) / 2); 61048 var rangeFromCentre = (vm.outerRadius - vm.innerRadius) / 2 + vm.innerRadius; 61049 61050 return { 61051 x: vm.x + (Math.cos(centreAngle) * rangeFromCentre), 61052 y: vm.y + (Math.sin(centreAngle) * rangeFromCentre) 61053 }; 61054 }, 61055 61056 draw: function() { 61057 var ctx = this._chart.ctx; 61058 var vm = this._view; 61059 var sA = vm.startAngle; 61060 var eA = vm.endAngle; 61061 61062 ctx.beginPath(); 61063 61064 ctx.arc(vm.x, vm.y, vm.outerRadius, sA, eA); 61065 ctx.arc(vm.x, vm.y, vm.innerRadius, eA, sA, true); 61066 61067 ctx.closePath(); 61068 ctx.strokeStyle = vm.borderColor; 61069 ctx.lineWidth = vm.borderWidth; 61070 61071 ctx.fillStyle = vm.backgroundColor; 61072 61073 ctx.fill(); 61074 ctx.lineJoin = 'bevel'; 61075 61076 if (vm.borderWidth) { 61077 ctx.stroke(); 61078 } 61079 } 61080}); 61081 61082 61083/***/ }), 61084/* 209 */ 61085/***/ (function(module, exports, __webpack_require__) { 61086 61087"use strict"; 61088 61089 61090var defaults = __webpack_require__(2); 61091var Element = __webpack_require__(5); 61092var helpers = __webpack_require__(1); 61093 61094var globalDefaults = defaults.global; 61095 61096defaults._set('global', { 61097 elements: { 61098 line: { 61099 tension: 0.4, 61100 backgroundColor: globalDefaults.defaultColor, 61101 borderWidth: 3, 61102 borderColor: globalDefaults.defaultColor, 61103 borderCapStyle: 'butt', 61104 borderDash: [], 61105 borderDashOffset: 0.0, 61106 borderJoinStyle: 'miter', 61107 capBezierPoints: true, 61108 fill: true, // do we fill in the area between the line and its base axis 61109 } 61110 } 61111}); 61112 61113module.exports = Element.extend({ 61114 draw: function() { 61115 var me = this; 61116 var vm = me._view; 61117 var ctx = me._chart.ctx; 61118 var spanGaps = vm.spanGaps; 61119 var points = me._children.slice(); // clone array 61120 var globalOptionLineElements = globalDefaults.elements.line; 61121 var lastDrawnIndex = -1; 61122 var index, current, previous, currentVM; 61123 61124 // If we are looping, adding the first point again 61125 if (me._loop && points.length) { 61126 points.push(points[0]); 61127 } 61128 61129 ctx.save(); 61130 61131 // Stroke Line Options 61132 ctx.lineCap = vm.borderCapStyle || globalOptionLineElements.borderCapStyle; 61133 61134 // IE 9 and 10 do not support line dash 61135 if (ctx.setLineDash) { 61136 ctx.setLineDash(vm.borderDash || globalOptionLineElements.borderDash); 61137 } 61138 61139 ctx.lineDashOffset = vm.borderDashOffset || globalOptionLineElements.borderDashOffset; 61140 ctx.lineJoin = vm.borderJoinStyle || globalOptionLineElements.borderJoinStyle; 61141 ctx.lineWidth = vm.borderWidth || globalOptionLineElements.borderWidth; 61142 ctx.strokeStyle = vm.borderColor || globalDefaults.defaultColor; 61143 61144 // Stroke Line
61145 ctx.beginPath(); 61146 lastDrawnIndex = -1; 61147 61148 for (index = 0; index < points.length; ++index) { 61149 current = points[index]; 61150 previous = helpers.previousItem(points, index); 61151 currentVM = current._view; 61152 61153 // First point moves to it's starting position no matter what 61154 if (index === 0) { 61155 if (!currentVM.skip) { 61156 ctx.moveTo(currentVM.x, currentVM.y); 61157 lastDrawnIndex = index; 61158 } 61159 } else { 61160 previous = lastDrawnIndex === -1 ? previous : points[lastDrawnIndex]; 61161 61162 if (!currentVM.skip) { 61163 if ((lastDrawnIndex !== (index - 1) && !spanGaps) || lastDrawnIndex === -1) { 61164 // There was a gap and this is the first point after the gap 61165 ctx.moveTo(currentVM.x, currentVM.y); 61166 } else { 61167 // Line to next point 61168 helpers.canvas.lineTo(ctx, previous._view, current._view); 61169 } 61170 lastDrawnIndex = index; 61171 } 61172 } 61173 } 61174 61175 ctx.stroke(); 61176 ctx.restore(); 61177 } 61178}); 61179 61180 61181/***/ }), 61182/* 210 */ 61183/***/ (function(module, exports, __webpack_require__) { 61184 61185"use strict"; 61186 61187 61188var defaults = __webpack_require__(2); 61189var Element = __webpack_require__(5); 61190var helpers = __webpack_require__(1); 61191 61192var defaultColor = defaults.global.defaultColor; 61193 61194defaults._set('global', { 61195 elements: { 61196 point: { 61197 radius: 3, 61198 pointStyle: 'circle', 61199 backgroundColor: defaultColor, 61200 borderColor: defaultColor, 61201 borderWidth: 1, 61202 // Hover 61203 hitRadius: 1, 61204 hoverRadius: 4, 61205 hoverBorderWidth: 1 61206 } 61207 } 61208}); 61209 61210function xRange(mouseX) { 61211 var vm = this._view; 61212 return vm ? (Math.abs(mouseX - vm.x) < vm.radius + vm.hitRadius) : false; 61213} 61214 61215function yRange(mouseY) { 61216 var vm = this._view; 61217 return vm ? (Math.abs(mouseY - vm.y) < vm.radius + vm.hitRadius) : false; 61218} 61219 61220module.exports = Element.extend({ 61221 inRange: function(mouseX, mouseY) { 61222 var vm = this._view; 61223 return vm ? ((Math.pow(mouseX - vm.x, 2) + Math.pow(mouseY - vm.y, 2)) < Math.pow(vm.hitRadius + vm.radius, 2)) : false; 61224 }, 61225 61226 inLabelRange: xRange, 61227 inXRange: xRange, 61228 inYRange: yRange, 61229 61230 getCenterPoint: function() { 61231 var vm = this._view; 61232 return { 61233 x: vm.x, 61234 y: vm.y 61235 }; 61236 }, 61237 61238 getArea: function() { 61239 return Math.PI * Math.pow(this._view.radius, 2); 61240 }, 61241 61242 tooltipPosition: function() { 61243 var vm = this._view; 61244 return { 61245 x: vm.x, 61246 y: vm.y, 61247 padding: vm.radius + vm.borderWidth 61248 }; 61249 }, 61250 61251 draw: function(chartArea) { 61252 var vm = this._view; 61253 var model = this._model; 61254 var ctx = this._chart.ctx; 61255 var pointStyle = vm.pointStyle; 61256 var radius = vm.radius; 61257 var x = vm.x; 61258 var y = vm.y; 61259 var color = helpers.color; 61260 var errMargin = 1.01; // 1.01 is margin for Accumulated error. (Especially Edge, IE.) 61261 var ratio = 0; 61262 61263 if (vm.skip) { 61264 return; 61265 } 61266 61267 ctx.strokeStyle = vm.borderColor || defaultColor; 61268 ctx.lineWidth = helpers.valueOrDefault(vm.borderWidth, defaults.global.elements.point.borderWidth); 61269 ctx.fillStyle = vm.backgroundColor || defaultColor; 61270 61271 // Cliping for Points. 61272 // going out from inner charArea? 61273 if ((chartArea !== undefined) && ((model.x < chartArea.left) || (chartArea.right * errMargin < model.x) || (model.y < chartArea.top) || (chartArea.bottom * errMargin < model.y))) { 61274 // Point fade out 61275 if (model.x < chartArea.left) { 61276 ratio = (x - model.x) / (chartArea.left - model.x); 61277 } else if (chartArea.right * errMargin < model.x) { 61278 ratio = (model.x - x) / (model.x - chartArea.right); 61279 } else if (model.y < chartArea.top) { 61280 ratio = (y - model.y) / (chartArea.top - model.y); 61281 } else if (chartArea.bottom * errMargin < model.y) { 61282 ratio = (model.y - y) / (model.y - chartArea.bottom); 61283 } 61284 ratio = Math.round(ratio * 100) / 100; 61285 ctx.strokeStyle = color(ctx.strokeStyle).alpha(ratio).rgbString(); 61286 ctx.fillStyle = color(ctx.fillStyle).alpha(ratio).rgbString(); 61287 } 61288 61289 helpers.canvas.drawPoint(ctx, pointStyle, radius, x, y); 61290 } 61291}); 61292 61293 61294/***/ }), 61295/* 211 */ 61296/***/ (function(module, exports, __webpack_require__) { 61297 61298"use strict"; 61299 61300 61301var defaults = __webpack_require__(2); 61302var Element = __webpack_require__(5); 61303 61304defaults._set('global', { 61305 elements: { 61306 rectangle: { 61307 backgroundColor: defaults.global.defaultColor, 61308 borderColor: defaults.global.defaultColor, 61309 borderSkipped: 'bottom', 61310 borderWidth: 0 61311 } 61312 } 61313}); 61314 61315function isVertical(bar) { 61316 return bar._view.width !== undefined; 61317} 61318 61319/** 61320 * Helper function to get the bounds of the bar regardless of the orientation 61321 * @param bar {Chart.Element.Rectangle} the bar 61322 * @return {Bounds} bounds of the bar 61323 * @private 61324 */ 61325function getBarBounds(bar) { 61326 var vm = bar._view; 61327 var x1, x2, y1, y2; 61328 61329 if (isVertical(bar)) { 61330 // vertical 61331 var halfWidth = vm.width / 2; 61332 x1 = vm.x - halfWidth; 61333 x2 = vm.x + halfWidth; 61334 y1 = Math.min(vm.y, vm.base); 61335 y2 = Math.max(vm.y, vm.base); 61336 } else { 61337 // horizontal bar 61338 var halfHeight = vm.height / 2; 61339 x1 = Math.min(vm.x, vm.base); 61340 x2 = Math.max(vm.x, vm.base); 61341 y1 = vm.y - halfHeight; 61342 y2 = vm.y + halfHeight; 61343 } 61344 61345 return { 61346 left: x1, 61347 top: y1, 61348 right: x2, 61349 bottom: y2 61350 }; 61351} 61352 61353module.exports = Element.extend({ 61354 draw: function() { 61355 var ctx = this._chart.ctx; 61356 var vm = this._view; 61357 var left, right, top, bottom, signX, signY, borderSkipped; 61358 var borderWidth = vm.borderWidth; 61359 61360 if (!vm.horizontal) { 61361 // bar 61362 left = vm.x - vm.width / 2; 61363 right = vm.x + vm.width / 2; 61364 top = vm.y; 61365 bottom = vm.base; 61366 signX = 1; 61367 signY = bottom > top ? 1 : -1; 61368 borderSkipped = vm.borderSkipped || 'bottom'; 61369 } else { 61370 // horizontal bar 61371 left = vm.base; 61372 right = vm.x; 61373 top = vm.y - vm.height / 2; 61374 bottom = vm.y + vm.height / 2; 61375 signX = right > left ? 1 : -1; 61376 signY = 1; 61377 borderSkipped = vm.borderSkipped || 'left'; 61378 } 61379 61380 // Canvas doesn't allow us to stroke inside the width so we can 61381 // adjust the sizes to fit if we're setting a stroke on the line 61382 if (borderWidth) { 61383 // borderWidth shold be less than bar width and bar height. 61384 var barSize = Math.min(Math.abs(left - right), Math.abs(top - bottom)); 61385 borderWidth = borderWidth > barSize ? barSize : borderWidth; 61386 var halfStroke = borderWidth / 2; 61387 // Adjust borderWidth when bar top position is near vm.base(zero). 61388 var borderLeft = left + (borderSkipped !== 'left' ? halfStroke * signX : 0); 61389 var borderRight = right + (borderSkipped !== 'right' ? -halfStroke * signX : 0); 61390 var borderTop = top + (borderSkipped !== 'top' ? halfStroke * signY : 0); 61391 var borderBottom = bottom + (borderSkipped !== 'bottom' ? -halfStroke * signY : 0); 61392 // not become a vertical line? 61393 if (borderLeft !== borderRight) { 61394 top = borderTop; 61395 bottom = borderBottom; 61396 } 61397 // not become a horizontal line? 61398 if (borderTop !== borderBottom) { 61399 left = borderLeft; 61400 right = borderRight; 61401 } 61402 } 61403 61404 ctx.beginPath(); 61405 ctx.fillStyle = vm.backgroundColor; 61406 ctx.strokeStyle = vm.borderColor; 61407 ctx.lineWidth = borderWidth; 61408 61409 // Corner points, from bottom-left to bottom-right clockwise 61410 // | 1 2 | 61411 // | 0 3 | 61412 var corners = [ 61413 [left, bottom], 61414 [left, top], 61415 [right, top], 61416 [right, bottom] 61417 ]; 61418 61419 // Find first (starting) corner with fallback to 'bottom' 61420 var borders = ['bottom', 'left', 'top', 'right']; 61421 var startCorner = borders.indexOf(borderSkipped, 0); 61422 if (startCorner === -1) { 61423 startCorner = 0; 61424 } 61425 61426 function cornerAt(index) { 61427 return corners[(startCorner + index) % 4]; 61428 } 61429 61430 // Draw rectangle from 'startCorner' 61431 var corner = cornerAt(0); 61432 ctx.moveTo(corner[0], corner[1]); 61433 61434 for (var i = 1; i < 4; i++) { 61435 corner = cornerAt(i); 61436 ctx.lineTo(corner[0], corner[1]); 61437 } 61438 61439 ctx.fill(); 61440 if (borderWidth) { 61441 ctx.stroke(); 61442 } 61443 }, 61444 61445 height: function() { 61446 var vm = this._view; 61447 return vm.base - vm.y; 61448 }, 61449 61450 inRange: function(mouseX, mouseY) { 61451 var inRange = false;
61452 61453 if (this._view) { 61454 var bounds = getBarBounds(this); 61455 inRange = mouseX >= bounds.left && mouseX <= bounds.right && mouseY >= bounds.top && mouseY <= bounds.bottom; 61456 } 61457 61458 return inRange; 61459 }, 61460 61461 inLabelRange: function(mouseX, mouseY) { 61462 var me = this; 61463 if (!me._view) { 61464 return false; 61465 } 61466 61467 var inRange = false; 61468 var bounds = getBarBounds(me); 61469 61470 if (isVertical(me)) { 61471 inRange = mouseX >= bounds.left && mouseX <= bounds.right; 61472 } else { 61473 inRange = mouseY >= bounds.top && mouseY <= bounds.bottom; 61474 } 61475 61476 return inRange; 61477 }, 61478 61479 inXRange: function(mouseX) { 61480 var bounds = getBarBounds(this); 61481 return mouseX >= bounds.left && mouseX <= bounds.right; 61482 }, 61483 61484 inYRange: function(mouseY) { 61485 var bounds = getBarBounds(this); 61486 return mouseY >= bounds.top && mouseY <= bounds.bottom; 61487 }, 61488 61489 getCenterPoint: function() { 61490 var vm = this._view; 61491 var x, y; 61492 if (isVertical(this)) { 61493 x = vm.x; 61494 y = (vm.y + vm.base) / 2; 61495 } else { 61496 x = (vm.x + vm.base) / 2; 61497 y = vm.y; 61498 } 61499 61500 return {x: x, y: y}; 61501 }, 61502 61503 getArea: function() { 61504 var vm = this._view; 61505 return vm.width * Math.abs(vm.y - vm.base); 61506 }, 61507 61508 tooltipPosition: function() { 61509 var vm = this._view; 61510 return { 61511 x: vm.x, 61512 y: vm.y 61513 }; 61514 } 61515}); 61516 61517 61518/***/ }), 61519/* 212 */ 61520/***/ (function(module, exports, __webpack_require__) { 61521 61522"use strict"; 61523 61524 61525var helpers = __webpack_require__(11); 61526 61527/** 61528 * @namespace Chart.helpers.canvas 61529 */ 61530var exports = module.exports = { 61531 /** 61532 * Clears the entire canvas associated to the given `chart`. 61533 * @param {Chart} chart - The chart for which to clear the canvas. 61534 */ 61535 clear: function(chart) { 61536 chart.ctx.clearRect(0, 0, chart.width, chart.height); 61537 }, 61538 61539 /** 61540 * Creates a "path" for a rectangle with rounded corners at position (x, y) with a 61541 * given size (width, height) and the same `radius` for all corners. 61542 * @param {CanvasRenderingContext2D} ctx - The canvas 2D Context. 61543 * @param {Number} x - The x axis of the coordinate for the rectangle starting point. 61544 * @param {Number} y - The y axis of the coordinate for the rectangle starting point. 61545 * @param {Number} width - The rectangle's width. 61546 * @param {Number} height - The rectangle's height. 61547 * @param {Number} radius - The rounded amount (in pixels) for the four corners. 61548 * @todo handle `radius` as top-left, top-right, bottom-right, bottom-left array/object? 61549 */ 61550 roundedRect: function(ctx, x, y, width, height, radius) { 61551 if (radius) { 61552 var rx = Math.min(radius, width / 2); 61553 var ry = Math.min(radius, height / 2); 61554 61555 ctx.moveTo(x + rx, y); 61556 ctx.lineTo(x + width - rx, y); 61557 ctx.quadraticCurveTo(x + width, y, x + width, y + ry); 61558 ctx.lineTo(x + width, y + height - ry); 61559 ctx.quadraticCurveTo(x + width, y + height, x + width - rx, y + height); 61560 ctx.lineTo(x + rx, y + height); 61561 ctx.quadraticCurveTo(x, y + height, x, y + height - ry); 61562 ctx.lineTo(x, y + ry); 61563 ctx.quadraticCurveTo(x, y, x + rx, y); 61564 } else { 61565 ctx.rect(x, y, width, height); 61566 } 61567 }, 61568 61569 drawPoint: function(ctx, style, radius, x, y) { 61570 var type, edgeLength, xOffset, yOffset, height, size; 61571 61572 if (style && typeof style === 'object') { 61573 type = style.toString(); 61574 if (type === '[object HTMLImageElement]' || type === '[object HTMLCanvasElement]') { 61575 ctx.drawImage(style, x - style.width / 2, y - style.height / 2, style.width, style.height); 61576 return; 61577 } 61578 } 61579 61580 if (isNaN(radius) || radius <= 0) { 61581 return; 61582 } 61583 61584 switch (style) { 61585 // Default includes circle 61586 default: 61587 ctx.beginPath(); 61588 ctx.arc(x, y, radius, 0, Math.PI * 2); 61589 ctx.closePath(); 61590 ctx.fill(); 61591 break; 61592 case 'triangle': 61593 ctx.beginPath(); 61594 edgeLength = 3 * radius / Math.sqrt(3); 61595 height = edgeLength * Math.sqrt(3) / 2; 61596 ctx.moveTo(x - edgeLength / 2, y + height / 3); 61597 ctx.lineTo(x + edgeLength / 2, y + height / 3); 61598 ctx.lineTo(x, y - 2 * height / 3); 61599 ctx.closePath(); 61600 ctx.fill(); 61601 break; 61602 case 'rect': 61603 size = 1 / Math.SQRT2 * radius; 61604 ctx.beginPath(); 61605 ctx.fillRect(x - size, y - size, 2 * size, 2 * size); 61606 ctx.strokeRect(x - size, y - size, 2 * size, 2 * size); 61607 break; 61608 case 'rectRounded': 61609 var offset = radius / Math.SQRT2; 61610 var leftX = x - offset; 61611 var topY = y - offset; 61612 var sideSize = Math.SQRT2 * radius; 61613 ctx.beginPath(); 61614 this.roundedRect(ctx, leftX, topY, sideSize, sideSize, radius / 2); 61615 ctx.closePath(); 61616 ctx.fill(); 61617 break; 61618 case 'rectRot': 61619 size = 1 / Math.SQRT2 * radius; 61620 ctx.beginPath(); 61621 ctx.moveTo(x - size, y); 61622 ctx.lineTo(x, y + size); 61623 ctx.lineTo(x + size, y); 61624 ctx.lineTo(x, y - size); 61625 ctx.closePath(); 61626 ctx.fill(); 61627 break; 61628 case 'cross': 61629 ctx.beginPath(); 61630 ctx.moveTo(x, y + radius);
vendor: 10,918 bytes, lines 61631-62136
61631 ctx.lineTo(x, y - radius); 61632 ctx.moveTo(x - radius, y); 61633 ctx.lineTo(x + radius, y); 61634 ctx.closePath(); 61635 break; 61636 case 'crossRot': 61637 ctx.beginPath(); 61638 xOffset = Math.cos(Math.PI / 4) * radius; 61639 yOffset = Math.sin(Math.PI / 4) * radius; 61640 ctx.moveTo(x - xOffset, y - yOffset); 61641 ctx.lineTo(x + xOffset, y + yOffset); 61642 ctx.moveTo(x - xOffset, y + yOffset); 61643 ctx.lineTo(x + xOffset, y - yOffset); 61644 ctx.closePath(); 61645 break; 61646 case 'star': 61647 ctx.beginPath(); 61648 ctx.moveTo(x, y + radius); 61649 ctx.lineTo(x, y - radius); 61650 ctx.moveTo(x - radius, y); 61651 ctx.lineTo(x + radius, y); 61652 xOffset = Math.cos(Math.PI / 4) * radius; 61653 yOffset = Math.sin(Math.PI / 4) * radius; 61654 ctx.moveTo(x - xOffset, y - yOffset); 61655 ctx.lineTo(x + xOffset, y + yOffset); 61656 ctx.moveTo(x - xOffset, y + yOffset); 61657 ctx.lineTo(x + xOffset, y - yOffset); 61658 ctx.closePath(); 61659 break; 61660 case 'line': 61661 ctx.beginPath(); 61662 ctx.moveTo(x - radius, y); 61663 ctx.lineTo(x + radius, y); 61664 ctx.closePath(); 61665 break; 61666 case 'dash': 61667 ctx.beginPath(); 61668 ctx.moveTo(x, y); 61669 ctx.lineTo(x + radius, y); 61670 ctx.closePath(); 61671 break; 61672 } 61673 61674 ctx.stroke(); 61675 }, 61676 61677 clipArea: function(ctx, area) { 61678 ctx.save(); 61679 ctx.beginPath(); 61680 ctx.rect(area.left, area.top, area.right - area.left, area.bottom - area.top); 61681 ctx.clip(); 61682 }, 61683 61684 unclipArea: function(ctx) { 61685 ctx.restore(); 61686 }, 61687 61688 lineTo: function(ctx, previous, target, flip) { 61689 if (target.steppedLine) { 61690 if ((target.steppedLine === 'after' && !flip) || (target.steppedLine !== 'after' && flip)) { 61691 ctx.lineTo(previous.x, target.y); 61692 } else { 61693 ctx.lineTo(target.x, previous.y); 61694 } 61695 ctx.lineTo(target.x, target.y); 61696 return; 61697 } 61698 61699 if (!target.tension) { 61700 ctx.lineTo(target.x, target.y); 61701 return; 61702 } 61703 61704 ctx.bezierCurveTo( 61705 flip ? previous.controlPointPreviousX : previous.controlPointNextX, 61706 flip ? previous.controlPointPreviousY : previous.controlPointNextY, 61707 flip ? target.controlPointNextX : target.controlPointPreviousX, 61708 flip ? target.controlPointNextY : target.controlPointPreviousY, 61709 target.x, 61710 target.y); 61711 } 61712}; 61713 61714// DEPRECATIONS 61715 61716/** 61717 * Provided for backward compatibility, use Chart.helpers.canvas.clear instead. 61718 * @namespace Chart.helpers.clear 61719 * @deprecated since version 2.7.0 61720 * @todo remove at version 3 61721 * @private 61722 */ 61723helpers.clear = exports.clear; 61724 61725/** 61726 * Provided for backward compatibility, use Chart.helpers.canvas.roundedRect instead. 61727 * @namespace Chart.helpers.drawRoundedRectangle 61728 * @deprecated since version 2.7.0 61729 * @todo remove at version 3 61730 * @private 61731 */ 61732helpers.drawRoundedRectangle = function(ctx) { 61733 ctx.beginPath(); 61734 exports.roundedRect.apply(exports, arguments); 61735 ctx.closePath(); 61736}; 61737 61738 61739/***/ }), 61740/* 213 */ 61741/***/ (function(module, exports, __webpack_require__) { 61742 61743"use strict"; 61744 61745 61746var helpers = __webpack_require__(11); 61747 61748/** 61749 * Easing functions adapted from Robert Penner's easing equations. 61750 * @namespace Chart.helpers.easingEffects 61751 * @see http://www.robertpenner.com/easing/ 61752 */ 61753var effects = { 61754 linear: function(t) { 61755 return t; 61756 }, 61757 61758 easeInQuad: function(t) { 61759 return t * t; 61760 }, 61761 61762 easeOutQuad: function(t) { 61763 return -t * (t - 2); 61764 }, 61765 61766 easeInOutQuad: function(t) { 61767 if ((t /= 0.5) < 1) { 61768 return 0.5 * t * t; 61769 } 61770 return -0.5 * ((--t) * (t - 2) - 1); 61771 }, 61772 61773 easeInCubic: function(t) { 61774 return t * t * t; 61775 }, 61776 61777 easeOutCubic: function(t) { 61778 return (t = t - 1) * t * t + 1; 61779 }, 61780 61781 easeInOutCubic: function(t) { 61782 if ((t /= 0.5) < 1) { 61783 return 0.5 * t * t * t; 61784 } 61785 return 0.5 * ((t -= 2) * t * t + 2); 61786 }, 61787 61788 easeInQuart: function(t) { 61789 return t * t * t * t; 61790 }, 61791 61792 easeOutQuart: function(t) { 61793 return -((t = t - 1) * t * t * t - 1); 61794 }, 61795 61796 easeInOutQuart: function(t) { 61797 if ((t /= 0.5) < 1) { 61798 return 0.5 * t * t * t * t; 61799 } 61800 return -0.5 * ((t -= 2) * t * t * t - 2); 61801 }, 61802 61803 easeInQuint: function(t) { 61804 return t * t * t * t * t; 61805 }, 61806 61807 easeOutQuint: function(t) { 61808 return (t = t - 1) * t * t * t * t + 1; 61809 }, 61810 61811 easeInOutQuint: function(t) { 61812 if ((t /= 0.5) < 1) { 61813 return 0.5 * t * t * t * t * t; 61814 } 61815 return 0.5 * ((t -= 2) * t * t * t * t + 2); 61816 }, 61817 61818 easeInSine: function(t) { 61819 return -Math.cos(t * (Math.PI / 2)) + 1; 61820 }, 61821 61822 easeOutSine: function(t) { 61823 return Math.sin(t * (Math.PI / 2)); 61824 }, 61825 61826 easeInOutSine: function(t) { 61827 return -0.5 * (Math.cos(Math.PI * t) - 1); 61828 }, 61829 61830 easeInExpo: function(t) { 61831 return (t === 0) ? 0 : Math.pow(2, 10 * (t - 1)); 61832 }, 61833 61834 easeOutExpo: function(t) { 61835 return (t === 1) ? 1 : -Math.pow(2, -10 * t) + 1; 61836 }, 61837 61838 easeInOutExpo: function(t) { 61839 if (t === 0) { 61840 return 0; 61841 } 61842 if (t === 1) { 61843 return 1; 61844 } 61845 if ((t /= 0.5) < 1) { 61846 return 0.5 * Math.pow(2, 10 * (t - 1)); 61847 } 61848 return 0.5 * (-Math.pow(2, -10 * --t) + 2); 61849 }, 61850 61851 easeInCirc: function(t) { 61852 if (t >= 1) { 61853 return t; 61854 } 61855 return -(Math.sqrt(1 - t * t) - 1); 61856 }, 61857 61858 easeOutCirc: function(t) { 61859 return Math.sqrt(1 - (t = t - 1) * t); 61860 }, 61861 61862 easeInOutCirc: function(t) { 61863 if ((t /= 0.5) < 1) { 61864 return -0.5 * (Math.sqrt(1 - t * t) - 1); 61865 } 61866 return 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1); 61867 }, 61868 61869 easeInElastic: function(t) { 61870 var s = 1.70158; 61871 var p = 0; 61872 var a = 1; 61873 if (t === 0) { 61874 return 0; 61875 } 61876 if (t === 1) { 61877 return 1; 61878 } 61879 if (!p) { 61880 p = 0.3; 61881 } 61882 if (a < 1) { 61883 a = 1; 61884 s = p / 4; 61885 } else { 61886 s = p / (2 * Math.PI) * Math.asin(1 / a); 61887 } 61888 return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * (2 * Math.PI) / p)); 61889 }, 61890 61891 easeOutElastic: function(t) { 61892 var s = 1.70158; 61893 var p = 0; 61894 var a = 1; 61895 if (t === 0) { 61896 return 0; 61897 } 61898 if (t === 1) { 61899 return 1; 61900 } 61901 if (!p) { 61902 p = 0.3; 61903 } 61904 if (a < 1) { 61905 a = 1; 61906 s = p / 4; 61907 } else { 61908 s = p / (2 * Math.PI) * Math.asin(1 / a); 61909 } 61910 return a * Math.pow(2, -10 * t) * Math.sin((t - s) * (2 * Math.PI) / p) + 1; 61911 }, 61912 61913 easeInOutElastic: function(t) { 61914 var s = 1.70158; 61915 var p = 0; 61916 var a = 1; 61917 if (t === 0) { 61918 return 0; 61919 } 61920 if ((t /= 0.5) === 2) { 61921 return 1; 61922 } 61923 if (!p) { 61924 p = 0.45; 61925 } 61926 if (a < 1) { 61927 a = 1; 61928 s = p / 4; 61929 } else { 61930 s = p / (2 * Math.PI) * Math.asin(1 / a); 61931 } 61932 if (t < 1) { 61933 return -0.5 * (a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * (2 * Math.PI) / p)); 61934 } 61935 return a * Math.pow(2, -10 * (t -= 1)) * Math.sin((t - s) * (2 * Math.PI) / p) * 0.5 + 1; 61936 }, 61937 easeInBack: function(t) { 61938 var s = 1.70158; 61939 return t * t * ((s + 1) * t - s); 61940 }, 61941 61942 easeOutBack: function(t) { 61943 var s = 1.70158; 61944 return (t = t - 1) * t * ((s + 1) * t + s) + 1; 61945 }, 61946 61947 easeInOutBack: function(t) { 61948 var s = 1.70158; 61949 if ((t /= 0.5) < 1) { 61950 return 0.5 * (t * t * (((s *= (1.525)) + 1) * t - s)); 61951 } 61952 return 0.5 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2); 61953 }, 61954 61955 easeInBounce: function(t) { 61956 return 1 - effects.easeOutBounce(1 - t); 61957 }, 61958 61959 easeOutBounce: function(t) { 61960 if (t < (1 / 2.75)) { 61961 return 7.5625 * t * t; 61962 } 61963 if (t < (2 / 2.75)) { 61964 return 7.5625 * (t -= (1.5 / 2.75)) * t + 0.75; 61965 } 61966 if (t < (2.5 / 2.75)) { 61967 return 7.5625 * (t -= (2.25 / 2.75)) * t + 0.9375; 61968 } 61969 return 7.5625 * (t -= (2.625 / 2.75)) * t + 0.984375; 61970 }, 61971 61972 easeInOutBounce: function(t) { 61973 if (t < 0.5) { 61974 return effects.easeInBounce(t * 2) * 0.5; 61975 } 61976 return effects.easeOutBounce(t * 2 - 1) * 0.5 + 0.5; 61977 } 61978}; 61979 61980module.exports = { 61981 effects: effects 61982}; 61983 61984// DEPRECATIONS 61985 61986/** 61987 * Provided for backward compatibility, use Chart.helpers.easing.effects instead. 61988 * @function Chart.helpers.easingEffects 61989 * @deprecated since version 2.7.0 61990 * @todo remove at version 3 61991 * @private 61992 */ 61993helpers.easingEffects = effects; 61994 61995 61996/***/ }), 61997/* 214 */ 61998/***/ (function(module, exports, __webpack_require__) { 61999 62000"use strict"; 62001 62002 62003var helpers = __webpack_require__(11); 62004 62005/** 62006 * @alias Chart.helpers.options 62007 * @namespace 62008 */ 62009module.exports = { 62010 /** 62011 * Converts the given line height `value` in pixels for a specific font `size`. 62012 * @param {Number|String} value - The lineHeight to parse (eg. 1.6, '14px', '75%', '1.6em'). 62013 * @param {Number} size - The font size (in pixels) used to resolve relative `value`. 62014 * @returns {Number} The effective line height in pixels (size * 1.2 if value is invalid). 62015 * @see https://developer.mozilla.org/en-US/docs/Web/CSS/line-height 62016 * @since 2.7.0 62017 */ 62018 toLineHeight: function(value, size) { 62019 var matches = ('' + value).match(/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/); 62020 if (!matches || matches[1] === 'normal') { 62021 return size * 1.2; 62022 } 62023 62024 value = +matches[2]; 62025 62026 switch (matches[3]) { 62027 case 'px': 62028 return value; 62029 case '%': 62030 value /= 100; 62031 break; 62032 default: 62033 break; 62034 } 62035 62036 return size * value; 62037 }, 62038 62039 /** 62040 * Converts the given value into a padding object with pre-computed width/height. 62041 * @param {Number|Object} value - If a number, set the value to all TRBL component, 62042 * else, if and object, use defined properties and sets undefined ones to 0. 62043 * @returns {Object} The padding values (top, right, bottom, left, width, height) 62044 * @since 2.7.0 62045 */ 62046 toPadding: function(value) { 62047 var t, r, b, l; 62048 62049 if (helpers.isObject(value)) { 62050 t = +value.top || 0; 62051 r = +value.right || 0; 62052 b = +value.bottom || 0; 62053 l = +value.left || 0; 62054 } else { 62055 t = r = b = l = +value || 0; 62056 } 62057 62058 return { 62059 top: t, 62060 right: r, 62061 bottom: b, 62062 left: l, 62063 height: t + b, 62064 width: l + r 62065 }; 62066 }, 62067 62068 /** 62069 * Evaluates the given `inputs` sequentially and returns the first defined value. 62070 * @param {Array[]} inputs - An array of values, falling back to the last value. 62071 * @param {Object} [context] - If defined and the current value is a function, the value 62072 * is called with `context` as first argument and the result becomes the new input. 62073 * @param {Number} [index] - If defined and the current value is an array, the value 62074 * at `index` become the new input. 62075 * @since 2.7.0 62076 */ 62077 resolve: function(inputs, context, index) { 62078 var i, ilen, value; 62079 62080 for (i = 0, ilen = inputs.length; i < ilen; ++i) { 62081 value = inputs[i]; 62082 if (value === undefined) { 62083 continue; 62084 } 62085 if (context !== undefined && typeof value === 'function') { 62086 value = value(context); 62087 } 62088 if (index !== undefined && helpers.isArray(value)) { 62089 value = value[index]; 62090 } 62091 if (value !== undefined) { 62092 return value; 62093 } 62094 } 62095 } 62096}; 62097 62098 62099/***/ }), 62100/* 215 */ 62101/***/ (function(module, exports) { 62102 62103/** 62104 * Platform fallback implementation (minimal). 62105 * @see https://github.com/chartjs/Chart.js/pull/4591#issuecomment-319575939 62106 */ 62107 62108module.exports = { 62109 acquireContext: function(item) { 62110 if (item && item.canvas) { 62111 // Support for any object associated to a canvas (including a context2d) 62112 item = item.canvas; 62113 } 62114 62115 return item && item.getContext('2d') || null; 62116 } 62117}; 62118 62119 62120/***/ }), 62121/* 216 */ 62122/***/ (function(module, exports, __webpack_require__) { 62123 62124"use strict"; 62125/** 62126 * Chart.Platform implementation for targeting a web browser 62127 */ 62128 62129 62130 62131var helpers = __webpack_require__(1); 62132 62133var EXPANDO_KEY = '$chartjs'; 62134var CSS_PREFIX = 'chartjs-'; 62135var CSS_RENDER_MONITOR = CSS_PREFIX + 'render-monitor'; 62136var CSS_RENDER_ANIMATION = CSS_PREFIX + 'render-animation';
62137var ANIMATION_START_EVENTS = ['animationstart', 'webkitAnimationStart']; 62138 62139/** 62140 * DOM event types -> Chart.js event types. 62141 * Note: only events with different types are mapped. 62142 * @see https://developer.mozilla.org/en-US/docs/Web/Events 62143 */ 62144var EVENT_TYPES = { 62145 touchstart: 'mousedown', 62146 touchmove: 'mousemove', 62147 touchend: 'mouseup', 62148 pointerenter: 'mouseenter', 62149 pointerdown: 'mousedown', 62150 pointermove: 'mousemove', 62151 pointerup: 'mouseup', 62152 pointerleave: 'mouseout', 62153 pointerout: 'mouseout' 62154}; 62155 62156/** 62157 * The "used" size is the final value of a dimension property after all calculations have 62158 * been performed. This method uses the computed style of `element` but returns undefined 62159 * if the computed style is not expressed in pixels. That can happen in some cases where 62160 * `element` has a size relative to its parent and this last one is not yet displayed, 62161 * for example because of `display: none` on a parent node. 62162 * @see https://developer.mozilla.org/en-US/docs/Web/CSS/used_value 62163 * @returns {Number} Size in pixels or undefined if unknown. 62164 */ 62165function readUsedSize(element, property) { 62166 var value = helpers.getStyle(element, property); 62167 var matches = value && value.match(/^(\d+)(\.\d+)?px$/); 62168 return matches ? Number(matches[1]) : undefined; 62169} 62170 62171/** 62172 * Initializes the canvas style and render size without modifying the canvas display size, 62173 * since responsiveness is handled by the controller.resize() method. The config is used 62174 * to determine the aspect ratio to apply in case no explicit height has been specified. 62175 */ 62176function initCanvas(canvas, config) { 62177 var style = canvas.style; 62178 62179 // NOTE(SB) canvas.getAttribute('width') !== canvas.width: in the first case it 62180 // returns null or '' if no explicit value has been set to the canvas attribute. 62181 var renderHeight = canvas.getAttribute('height'); 62182 var renderWidth = canvas.getAttribute('width'); 62183 62184 // Chart.js modifies some canvas values that we want to restore on de
vendor: 4,559 bytes, lines 62184-62358
62184stroy 62185 canvas[EXPANDO_KEY] = { 62186 initial: { 62187 height: renderHeight, 62188 width: renderWidth, 62189 style: { 62190 display: style.display, 62191 height: style.height, 62192 width: style.width 62193 } 62194 } 62195 }; 62196 62197 // Force canvas to display as block to avoid extra space caused by inline 62198 // elements, which would interfere with the responsive resize process. 62199 // https://github.com/chartjs/Chart.js/issues/2538 62200 style.display = style.display || 'block'; 62201 62202 if (renderWidth === null || renderWidth === '') { 62203 var displayWidth = readUsedSize(canvas, 'width'); 62204 if (displayWidth !== undefined) { 62205 canvas.width = displayWidth; 62206 } 62207 } 62208 62209 if (renderHeight === null || renderHeight === '') { 62210 if (canvas.style.height === '') { 62211 // If no explicit render height and style height, let's apply the aspect ratio, 62212 // which one can be specified by the user but also by charts as default option 62213 // (i.e. options.aspectRatio). If not specified, use canvas aspect ratio of 2. 62214 canvas.height = canvas.width / (config.options.aspectRatio || 2); 62215 } else { 62216 var displayHeight = readUsedSize(canvas, 'height'); 62217 if (displayWidth !== undefined) { 62218 canvas.height = displayHeight; 62219 } 62220 } 62221 } 62222 62223 return canvas; 62224} 62225 62226/** 62227 * Detects support for options object argument in addEventListener. 62228 * https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support 62229 * @private 62230 */ 62231var supportsEventListenerOptions = (function() { 62232 var supports = false; 62233 try { 62234 var options = Object.defineProperty({}, 'passive', { 62235 get: function() { 62236 supports = true; 62237 } 62238 }); 62239 window.addEventListener('e', null, options); 62240 } catch (e) { 62241 // continue regardless of error 62242 } 62243 return supports; 62244}()); 62245 62246// Default passive to true as expected by Chrome for 'touchstart' and 'touchend' events. 62247// https://github.com/chartjs/Chart.js/issues/4287 62248var eventListenerOptions = supportsEventListenerOptions ? {passive: true} : false; 62249 62250function addEventListener(node, type, listener) { 62251 node.addEventListener(type, listener, eventListenerOptions); 62252} 62253 62254function removeEventListener(node, type, listener) { 62255 node.removeEventListener(type, listener, eventListenerOptions); 62256} 62257 62258function createEvent(type, chart, x, y, nativeEvent) { 62259 return { 62260 type: type, 62261 chart: chart, 62262 native: nativeEvent || null, 62263 x: x !== undefined ? x : null, 62264 y: y !== undefined ? y : null, 62265 }; 62266} 62267 62268function fromNativeEvent(event, chart) { 62269 var type = EVENT_TYPES[event.type] || event.type; 62270 var pos = helpers.getRelativePosition(event, chart); 62271 return createEvent(type, chart, pos.x, pos.y, event); 62272} 62273 62274function throttled(fn, thisArg) { 62275 var ticking = false; 62276 var args = []; 62277 62278 return function() { 62279 args = Array.prototype.slice.call(arguments); 62280 thisArg = thisArg || this; 62281 62282 if (!ticking) { 62283 ticking = true; 62284 helpers.requestAnimFrame.call(window, function() { 62285 ticking = false; 62286 fn.apply(thisArg, args); 62287 }); 62288 } 62289 }; 62290} 62291 62292// Implementation based on https://github.com/marcj/css-element-queries 62293function createResizer(handler) { 62294 var resizer = document.createElement('div'); 62295 var cls = CSS_PREFIX + 'size-monitor'; 62296 var maxSize = 1000000; 62297 var style = 62298 'position:absolute;' + 62299 'left:0;' + 62300 'top:0;' + 62301 'right:0;' + 62302 'bottom:0;' + 62303 'overflow:hidden;' + 62304 'pointer-events:none;' + 62305 'visibility:hidden;' + 62306 'z-index:-1;'; 62307 62308 resizer.style.cssText = style; 62309 resizer.className = cls; 62310 resizer.innerHTML = 62311 '<div class="' + cls + '-expand" style="' + style + '">' + 62312 '<div style="' + 62313 'position:absolute;' + 62314 'width:' + maxSize + 'px;' + 62315 'height:' + maxSize + 'px;' + 62316 'left:0;' + 62317 'top:0">' + 62318 '</div>' + 62319 '</div>' + 62320 '<div class="' + cls + '-shrink" style="' + style + '">' + 62321 '<div style="' + 62322 'position:absolute;' + 62323 'width:200%;' + 62324 'height:200%;' + 62325 'left:0; ' + 62326 'top:0">' + 62327 '</div>' + 62328 '</div>'; 62329 62330 var expand = resizer.childNodes[0]; 62331 var shrink = resizer.childNodes[1]; 62332 62333 resizer._reset = function() { 62334 expand.scrollLeft = maxSize; 62335 expand.scrollTop = maxSize; 62336 shrink.scrollLeft = maxSize; 62337 shrink.scrollTop = maxSize; 62338 }; 62339 var onScroll = function() { 62340 resizer._reset(); 62341 handler(); 62342 }; 62343 62344 addEventListener(expand, 'scroll', onScroll.bind(expand, 'expand')); 62345 addEventListener(shrink, 'scroll', onScroll.bind(shrink, 'shrink')); 62346 62347 return resizer; 62348} 62349 62350// https://davidwalsh.name/detect-node-insertion 62351function watchForRender(node, handler) { 62352 var expando = node[EXPANDO_KEY] || (node[EXPANDO_KEY] = {}); 62353 var proxy = expando.renderProxy = function(e) { 62354 if (e.animationName === CSS_RENDER_ANIMATION) { 62355 handler(); 62356 } 62357 }; 62358
62359 helpers.each(ANIMATION_START_EVENTS, function(type) { 62360 addEventListener(node, type, proxy); 62361 }); 62362 62363 // #4737: Chrome might skip the CSS animation when the CSS_RENDER_MONITOR class 62364 // is removed then added back immediately (same animation frame?). Accessing the 62365 // `offsetParent` property will force a reflow and re-evaluate the CSS animation. 62366 // https://gist.github.com/paulirish/5d52fb081b3570c81e3a#box-metrics 62367 // https://github.com/chartjs/Chart.js/issues/4737 62368 expando.reflow = !!node.offsetParent; 62369 62370 node.classList.add(CSS_RENDER_MONITOR); 62371} 62372 62373function unwatchForRender(node) { 62374 var expando = node[EXPANDO_KEY] || {}; 62375 var proxy = expando.renderProxy; 62376 62377 if (proxy) { 62378 helpers.each(ANIMATION_START_EVENTS, function(type) { 62379 removeEventListener(node, type, proxy); 62380 }); 62381 62382 delete expando.renderProxy; 62383 } 62384 62385 node.classList.remove(CSS_RENDER_MONITOR); 62386} 62387 62388function addResizeListener(node, listener, chart) { 62389 var expando = node[EXPANDO_KEY] || (node[EXPANDO_KEY] = {}); 62390 62391 // Let's keep track of this added resizer and thus avoid DOM query when removing it. 62392 var resizer = expando.resizer = createResizer(throttled(function() { 62393 if (expando.resizer) { 62394 return listener(createEvent('resize', chart)); 62395 } 62396 })); 62397 62398 // The resizer needs to be attached to the node parent, so we first need to be 62399 // sure that `node` is attached to the DOM before injecting the resizer element. 62400 watchForRender(node, function() { 62401 if (expando.resizer) { 62402 var container = node.parentNode; 62403 if (container && container !== resizer.parentNode) { 62404 container.insertBefore(resizer, container.firstChild); 62405 } 62406 62407 // The container size might have changed, let's reset the resizer state. 62408 resizer._reset(); 62409 } 62410 }); 62411} 62412 62413function removeResizeListener(node) { 62414 var expando = node[EXPANDO_KEY] || {}; 62415 var resizer = expando.resizer; 62416 62417 delete expando.resizer; 62418 unwatchForRender(node); 62419 62420 if (resizer && resizer.parentNode) { 62421 resizer.parentNode.removeChild(resizer); 62422 } 62423} 62424 62425function injectCSS(platform, css) { 62426 // http://stackoverflow.com/q/3922139 62427 var style = platform._style || document.createElement('style'); 62428 if (!platform._style) { 62429 platform._style = style; 62430 css = '/* Chart.js */\n' + css; 62431 style.setAttribute('type', 'text/css'); 62432 document.getElementsByTagName('head')[0].appendChild(style); 62433 } 62434 62435 style.appendChild(document.createTextNode(css)); 62436} 62437 62438module.exports = { 62439 /** 62440 * This property holds whether this platform is enabled for the current environment. 62441 * Currently used by platform.js to select the proper implementation. 62442 * @private 62443 */ 62444 _enabled: typeof window !== 'undefined' && typeof document !== 'undefined', 62445 62446 initialize: function() { 62447 var keyframes = 'from{opacity:0.99}to{opacity:1}'; 62448 62449 injectCSS(this, 62450 // DOM rendering detection 62451 // https://davidwalsh.name/detect-node-insertion 62452 '@-webkit-keyframes ' + CSS_RENDER_ANIMATION + '{' + keyframes + '}' + 62453 '@keyframes ' + CSS_RENDER_ANIMATION + '{' + keyframes + '}' + 62454 '.' + CSS_RENDER_MONITOR + '{' + 62455 '-webkit-animation:' + CSS_RENDER_ANIMATION + ' 0.001s;' + 62456 'animation:' + CSS_RENDER_ANIMATION + ' 0.001s;' + 62457 '}' 62458 ); 62459 }, 62460 62461 acquireContext: function(item, config) { 62462 if (typeof item === 'string') { 62463 item = document.getElementById(item); 62464 } else if (item.length) { 62465 // Support for array based queries (such as jQuery) 62466 item = item[0]; 62467 } 62468 62469 if (item && item.canvas) { 62470 // Support for any object associated to a canvas (including a context2d) 62471 item = item.canvas; 62472 } 62473 62474 // To prevent canvas fingerprinting, some add-ons undefine the getContext 62475 // method, for example: https://github.com/kkapsner/CanvasBlocker 62476 // https://github.com/chartjs/Chart.js/issues/2807 62477 var context = item && item.getContext && item.getContext('2d'); 62478 62479 // `instanceof HTMLCanvasElement/CanvasRenderingContext2D` fails when the item is 62480 // inside an iframe or when running in a protected environment. We could guess the 62481 // types from their toString() value but let's keep things flexible and assume it's 62482 // a sufficient condition if the item has a context2D which has item as `canvas`. 62483 // https://github.com/chartjs/Chart.js/issues/3887 62484 // https://github.com/chartjs/Chart.js/issues/4102 62485 // https://github.com/chartjs/Chart.js/issues/4152 62486 if (context && context.canvas === item) { 62487 initCanvas(item, config); 62488 return context; 62489 } 62490 62491 return null; 62492 }, 62493 62494 releaseContext: function(context) { 62495 var canvas = context.canvas; 62496 if (!canvas[EXPANDO_KEY]) { 62497 return; 62498 } 62499 62500 var initial = canvas[EXPANDO_KEY].initial; 62501 ['height', 'width'].forEach(function(prop) { 62502 var value = initial[prop]; 62503 if (helpers.isNullOrUndef(value)) { 62504 canvas.removeAttribute(prop); 62505 } else { 62506 canvas.setAttribute(prop, value); 62507 } 62508 }); 62509 62510 helpers.each(initial.style || {}, function(value, key) { 62511 canvas.style[key] = value; 62512 }); 62513 62514 // The canvas render size might have been changed (and thus the state stack discarded),
62515 // we can't use save() and restore() to restore the initial state. So make sure that at 62516 // least the canvas context is reset to the default state by setting the canvas width. 62517 // https://www.w3.org/TR/2011/WD-html5-20110525/the-canvas-element.html 62518 canvas.width = canvas.width; 62519 62520 delete canvas[EXPANDO_KEY]; 62521 }, 62522 62523 addEventListener: function(chart, type, listener) { 62524 var canvas = chart.canvas; 62525 if (type === 'resize') { 62526 // Note: the resize event is not supported on all browsers. 62527 addResizeListener(canvas, listener, chart); 62528 return; 62529 } 62530 62531 var expando = listener[EXPANDO_KEY] || (listener[EXPANDO_KEY] = {}); 62532 var proxies = expando.proxies || (expando.proxies = {}); 62533 var proxy = proxies[chart.id + '_' + type] = function(event) { 62534 listener(fromNativeEvent(event, chart)); 62535 }; 62536 62537 addEventListener(canvas, type, proxy); 62538 }, 62539 62540 removeEventListener: function(chart, type, listener) { 62541 var canvas = chart.canvas; 62542 if (type === 'resize') { 62543 // Note: the resize event is not supported on all browsers. 62544 removeResizeListener(canvas, listener); 62545 return; 62546 } 62547 62548 var expando = listener[EXPANDO_KEY] || {}; 62549 var proxies = expando.proxies || {}; 62550 var proxy = proxies[chart.id + '_' + type]; 62551 if (!proxy) { 62552 return; 62553 } 62554 62555 removeEventListener(canvas, type, proxy); 62556 } 62557}; 62558 62559// DEPRECATIONS 62560 62561/** 62562 * Provided for backward compatibility, use EventTarget.addEventListener instead. 62563 * EventTarget.addEventListener compatibility: Chrome, Opera 7, Safari, FF1.5+, IE9+ 62564 * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener 62565 * @function Chart.helpers.addEvent 62566 * @deprecated since version 2.7.0 62567 * @todo remove at version 3 62568 * @private 62569 */ 62570helpers.addEvent = addEventListener; 62571 62572/** 62573 * Provided for backward compatibility, use EventTarget.removeEventListener instead. 62574 * EventTarget.removeEventListener compatibility: Chrome, Opera 7, Safari, FF1.5+, IE9+ 62575 * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/removeEventListener 62576 * @function Chart.helpers.removeEvent 62577 * @deprecated since version 2.7.0 62578 * @todo remove at version 3 62579 * @private 62580 */ 62581helpers.removeEvent = removeEventListener; 62582 62583 62584/***/ }), 62585/* 217 */ 62586/***/ (function(module, exports, __webpack_require__) { 62587 62588"use strict"; 62589 62590 62591module.exports = {}; 62592module.exports.filler = __webpack_require__(218); 62593module.exports.legend = __webpack_require__(219); 62594module.exports.title = __webpack_require__(220); 62595 62596 62597/***/ }), 62598/* 218 */ 62599/***/ (function(module, exports, __webpack_require__) { 62600 62601"use strict"; 62602/**
vendor: 5,260 bytes, lines 62603-62863
62603 * Plugin based on discussion from the following Chart.js issues: 62604 * @see https://github.com/chartjs/Chart.js/issues/2380#issuecomment-279961569 62605 * @see https://github.com/chartjs/Chart.js/issues/2440#issuecomment-256461897 62606 */ 62607 62608 62609 62610var defaults = __webpack_require__(2); 62611var elements = __webpack_require__(7); 62612var helpers = __webpack_require__(1); 62613 62614defaults._set('global', { 62615 plugins: { 62616 filler: { 62617 propagate: true 62618 } 62619 } 62620}); 62621 62622var mappers = { 62623 dataset: function(source) { 62624 var index = source.fill; 62625 var chart = source.chart; 62626 var meta = chart.getDatasetMeta(index); 62627 var visible = meta && chart.isDatasetVisible(index); 62628 var points = (visible && meta.dataset._children) || []; 62629 var length = points.length || 0; 62630 62631 return !length ? null : function(point, i) { 62632 return (i < length && points[i]._view) || null; 62633 }; 62634 }, 62635 62636 boundary: function(source) { 62637 var boundary = source.boundary; 62638 var x = boundary ? boundary.x : null; 62639 var y = boundary ? boundary.y : null; 62640 62641 return function(point) { 62642 return { 62643 x: x === null ? point.x : x, 62644 y: y === null ? point.y : y, 62645 }; 62646 }; 62647 } 62648}; 62649 62650// @todo if (fill[0] === '#') 62651function decodeFill(el, index, count) { 62652 var model = el._model || {}; 62653 var fill = model.fill; 62654 var target; 62655 62656 if (fill === undefined) { 62657 fill = !!model.backgroundColor; 62658 } 62659 62660 if (fill === false || fill === null) { 62661 return false; 62662 } 62663 62664 if (fill === true) { 62665 return 'origin'; 62666 } 62667 62668 target = parseFloat(fill, 10); 62669 if (isFinite(target) && Math.floor(target) === target) { 62670 if (fill[0] === '-' || fill[0] === '+') { 62671 target = index + target; 62672 } 62673 62674 if (target === index || target < 0 || target >= count) { 62675 return false; 62676 } 62677 62678 return target; 62679 } 62680 62681 switch (fill) { 62682 // compatibility 62683 case 'bottom': 62684 return 'start'; 62685 case 'top': 62686 return 'end'; 62687 case 'zero': 62688 return 'origin'; 62689 // supported boundaries 62690 case 'origin': 62691 case 'start': 62692 case 'end': 62693 return fill; 62694 // invalid fill values 62695 default: 62696 return false; 62697 } 62698} 62699 62700function computeBoundary(source) { 62701 var model = source.el._model || {}; 62702 var scale = source.el._scale || {}; 62703 var fill = source.fill; 62704 var target = null; 62705 var horizontal; 62706 62707 if (isFinite(fill)) { 62708 return null; 62709 } 62710 62711 // Backward compatibility: until v3, we still need to support boundary values set on 62712 // the model (scaleTop, scaleBottom and scaleZero) because some external plugins and 62713 // controllers might still use it (e.g. the Smith chart). 62714 62715 if (fill === 'start') { 62716 target = model.scaleBottom === undefined ? scale.bottom : model.scaleBottom; 62717 } else if (fill === 'end') { 62718 target = model.scaleTop === undefined ? scale.top : model.scaleTop; 62719 } else if (model.scaleZero !== undefined) { 62720 target = model.scaleZero; 62721 } else if (scale.getBasePosition) { 62722 target = scale.getBasePosition(); 62723 } else if (scale.getBasePixel) { 62724 target = scale.getBasePixel(); 62725 } 62726 62727 if (target !== undefined && target !== null) { 62728 if (target.x !== undefined && target.y !== undefined) { 62729 return target; 62730 } 62731 62732 if (typeof target === 'number' && isFinite(target)) { 62733 horizontal = scale.isHorizontal(); 62734 return { 62735 x: horizontal ? target : null, 62736 y: horizontal ? null : target 62737 }; 62738 } 62739 } 62740 62741 return null; 62742} 62743 62744function resolveTarget(sources, index, propagate) { 62745 var source = sources[index]; 62746 var fill = source.fill; 62747 var visited = [index]; 62748 var target; 62749 62750 if (!propagate) { 62751 return fill; 62752 } 62753 62754 while (fill !== false && visited.indexOf(fill) === -1) { 62755 if (!isFinite(fill)) { 62756 return fill; 62757 } 62758 62759 target = sources[fill]; 62760 if (!target) { 62761 return false; 62762 } 62763 62764 if (target.visible) { 62765 return fill; 62766 } 62767 62768 visited.push(fill); 62769 fill = target.fill; 62770 } 62771 62772 return false; 62773} 62774 62775function createMapper(source) { 62776 var fill = source.fill; 62777 var type = 'dataset'; 62778 62779 if (fill === false) { 62780 return null; 62781 } 62782 62783 if (!isFinite(fill)) { 62784 type = 'boundary'; 62785 } 62786 62787 return mappers[type](source); 62788} 62789 62790function isDrawable(point) { 62791 return point && !point.skip; 62792} 62793 62794function drawArea(ctx, curve0, curve1, len0, len1) { 62795 var i; 62796 62797 if (!len0 || !len1) { 62798 return; 62799 } 62800 62801 // building first area curve (normal) 62802 ctx.moveTo(curve0[0].x, curve0[0].y); 62803 for (i = 1; i < len0; ++i) { 62804 helpers.canvas.lineTo(ctx, curve0[i - 1], curve0[i]); 62805 } 62806 62807 // joining the two area curves 62808 ctx.lineTo(curve1[len1 - 1].x, curve1[len1 - 1].y); 62809 62810 // building opposite area curve (reverse) 62811 for (i = len1 - 1; i > 0; --i) { 62812 helpers.canvas.lineTo(ctx, curve1[i], curve1[i - 1], true); 62813 } 62814} 62815 62816function doFill(ctx, points, mapper, view, color, loop) { 62817 var count = points.length; 62818 var span = view.spanGaps; 62819 var curve0 = []; 62820 var curve1 = []; 62821 var len0 = 0; 62822 var len1 = 0; 62823 var i, ilen, index, p0, p1, d0, d1; 62824 62825 ctx.beginPath(); 62826 62827 for (i = 0, ilen = (count + !!loop); i < ilen; ++i) { 62828 index = i % count; 62829 p0 = points[index]._view; 62830 p1 = mapper(p0, index, view); 62831 d0 = isDrawable(p0); 62832 d1 = isDrawable(p1); 62833 62834 if (d0 && d1) { 62835 len0 = curve0.push(p0); 62836 len1 = curve1.push(p1); 62837 } else if (len0 && len1) { 62838 if (!span) { 62839 drawArea(ctx, curve0, curve1, len0, len1); 62840 len0 = len1 = 0; 62841 curve0 = []; 62842 curve1 = []; 62843 } else { 62844 if (d0) { 62845 curve0.push(p0); 62846 } 62847 if (d1) { 62848 curve1.push(p1); 62849 } 62850 } 62851 } 62852 } 62853 62854 drawArea(ctx, curve0, curve1, len0, len1); 62855 62856 ctx.closePath(); 62857 ctx.fillStyle = color; 62858 ctx.fill(); 62859} 62860 62861module.exports = { 62862 id: 'filler', 62863
62864 afterDatasetsUpdate: function(chart, options) { 62865 var count = (chart.data.datasets || []).length; 62866 var propagate = options.propagate; 62867 var sources = []; 62868 var meta, i, el, source; 62869 62870 for (i = 0; i < count; ++i) { 62871 meta = chart.getDatasetMeta(i); 62872 el = meta.dataset; 62873 source = null; 62874 62875 if (el && el._model && el instanceof elements.Line) { 62876 source = { 62877 visible: chart.isDatasetVisible(i), 62878 fill: decodeFill(el, i, count), 62879 chart: chart, 62880 el: el 62881 }; 62882 } 62883 62884 meta.$filler = source; 62885 sources.push(source); 62886 } 62887 62888 for (i = 0; i < count; ++i) { 62889 source = sources[i]; 62890 if (!source) { 62891 continue; 62892 } 62893 62894 source.fill = resolveTarget(sources, i, propagate); 62895 source.boundary = computeBoundary(source); 62896 source.mapper = createMapper(source); 62897 } 62898 }, 62899 62900 beforeDatasetDraw: function(chart, args) { 62901 var meta = args.meta.$filler; 62902 if (!meta) { 62903 return; 62904 } 62905 62906 var ctx = chart.ctx; 62907 var el = meta.el; 62908 var view = el._view; 62909 var points = el._children || []; 62910 var mapper = meta.mapper; 62911 var color = view.backgroundColor || defaults.global.defaultColor; 62912 62913 if (mapper && color && points.length) { 62914 helpers.canvas.clipArea(ctx, chart.chartArea); 62915 doFill(ctx, points, mapper, view, color, el._loop); 62916 helpers.canvas.unclipArea(ctx); 62917 } 62918 } 62919}; 62920 62921 62922/***/ }), 62923/* 219 */ 62924/***/ (function(module, exports, __webpack_require__) { 62925 62926"use strict"; 62927 62928 62929var defaults = __webpack_require__(2); 62930var Element = __webpack_require__(5); 62931var helpers = __webpack_require__(1); 62932var layouts = __webpack_require__(9); 62933 62934var noop = helpers.noop; 62935 62936defaults._set('global', { 62937 legend: { 62938 display: true, 62939 position: 'top', 62940 fullWidth: true, 62941 reverse: false, 62942 weight: 1000, 62943 62944 // a callback that will handle 62945 onClick: function(e, legendItem) { 62946 var index = legendItem.datasetIndex; 62947 var ci = this.chart; 62948 var meta = ci.getDatasetMeta(index); 62949 62950 // See controller.isDatasetVisible comment 62951 meta.hidden = meta.hidden === null ? !ci.data.datasets[index].hidden : null; 62952 62953 // We hid a dataset ... rerender the chart 62954 ci.update(); 62955 }, 62956 62957 onHover: null, 62958 62959 labels: { 62960 boxWidth: 40, 62961 padding: 10, 62962 // Generates labels shown in the legend 62963 // Valid properties to return: 62964 // text : text to display 62965 // fillStyle : fill of coloured box 62966 // strokeStyle: stroke of coloured box 62967 // hidden : if this legend item refers to a hidden item 62968 // lineCap : cap style for line 62969 // lineDash 62970 // lineDashOffset : 62971 // lineJoin : 62972 // lineWidth : 62973 generateLabels: function(chart) { 62974 var data = chart.data; 62975 return helpers.isArray(data.datasets) ? data.datasets.map(function(dataset, i) { 62976 return { 62977 text: dataset.label, 62978 fillStyle: (!helpers.isArray(dataset.backgroundColor) ? dataset.backgroundColor : dataset.backgroundColor[0]), 62979 hidden: !chart.isDatasetVisible(i), 62980 lineCap: dataset.borderCapStyle, 62981 lineDash: dataset.borderDash, 62982 lineDashOffset: dataset.borderDashOffset, 62983 lineJoin: dataset.borderJoinStyle, 62984 lineWidth: dataset.borderWidth, 62985 strokeStyle: dataset.borderColor, 62986 pointStyle: dataset.pointStyle, 62987 62988 // Below is extra data used for toggling the datasets 62989 datasetIndex: i 62990 }; 62991 }, this) : []; 62992 } 62993 } 62994 }, 62995 62996 legendCallback: function(chart) { 62997 var text = []; 62998 text.push('<ul class="' + chart.id + '-legend">'); 62999 for (var i = 0; i < chart.data.datasets.length; i++) { 63000 text.push('<li><span style="background-color:' + chart.data.datasets[i].backgroundColor + '"></span>'); 63001 if (chart.data.datasets[i].label) { 63002 text.push(chart.data.datasets[i].label); 63003 } 63004 text.push('</li>'); 63005 } 63006 text.push('</ul>'); 63007 return text.join(''); 63008 } 63009}); 63010 63011/** 63012 * Helper function to get the box width based on the usePointStyle option 63013 * @param labelopts {Object} the label options on the legend 63014 * @param fontSize {Number} the label font size 63015 * @return {Number} width of the color box area 63016 */ 63017function getBoxWidth(labelOpts, fontSize) { 63018 return labelOpts.usePointStyle ? 63019 fontSize * Math.SQRT2 : 63020 labelOpts.boxWidth; 63021} 63022 63023/** 63024 * IMPORTANT: this class is exposed publicly as Chart.Legend, backward compatibility required! 63025 */ 63026var Legend = Element.extend({ 63027 63028 initialize: function(config) { 63029 helpers.extend(this, config); 63030 63031 // Contains hit boxes for each dataset (in dataset order) 63032 this.legendHitBoxes = []; 63033 63034 // Are we in doughnut mode which has a different data type 63035 this.doughnutMode = false;
63036 }, 63037 63038 // These methods are ordered by lifecycle. Utilities then follow. 63039 // Any function defined here is inherited by all legend types. 63040 // Any function can be extended by the legend type 63041 63042 beforeUpdate: noop, 63043 update: function(maxWidth, maxHeight, margins) { 63044 var me = this; 63045 63046 // Update Lifecycle - Probably don't want to ever extend or overwrite this function ;) 63047 me.beforeUpdate(); 63048 63049 // Absorb the master measurements 63050 me.maxWidth = maxWidth; 63051 me.maxHeight = maxHeight; 63052 me.margins = margins; 63053 63054 // Dimensions 63055 me.beforeSetDimensions(); 63056 me.setDimensions(); 63057 me.afterSetDimensions(); 63058 // Labels 63059 me.beforeBuildLabels(); 63060 me.buildLabels(); 63061 me.afterBuildLabels(); 63062 63063 // Fit 63064 me.beforeFit(); 63065 me.fit(); 63066 me.afterFit(); 63067 // 63068 me.afterUpdate(); 63069 63070 return me.minSize; 63071 }, 63072 afterUpdate: noop, 63073 63074 // 63075 63076 beforeSetDimensions: noop, 63077 setDimensions: function() { 63078 var me = this; 63079 // Set the unconstrained dimension before label rotation 63080 if (me.isHorizontal()) { 63081 // Reset position before calculating rotation 63082 me.width = me.maxWidth; 63083 me.left = 0; 63084 me.right = me.width; 63085 } else { 63086 me.height = me.maxHeight; 63087 63088 // Reset position before calculating rotation 63089 me.top = 0; 63090 me.bottom = me.height; 63091 } 63092 63093 // Reset padding 63094 me.paddingLeft = 0; 63095 me.paddingTop = 0; 63096 me.paddingRight = 0; 63097 me.paddingBottom = 0; 63098 63099 // Reset minSize 63100 me.minSize = { 63101 width: 0, 63102 height: 0 63103 }; 63104 }, 63105 afterSetDimensions: noop, 63106 63107 // 63108 63109 beforeBuildLabels: noop, 63110 buildLabels: function() { 63111 var me = this; 63112 var labelOpts = me.options.labels || {}; 63113 var legendItems = helpers.callback(labelOpts.generateLabels, [me.chart], me) || []; 63114 63115 if (labelOpts.filter) { 63116 legendItems = legendItems.filter(function(item) { 63117 return labelOpts.filter(item, me.chart.data); 63118 }); 63119 } 63120 63121 if (me.options.reverse) { 63122 legendItems.reverse(); 63123 } 63124 63125 me.legendItems = legendItems; 63126 }, 63127 afterBuildLabels: noop, 63128 63129 // 63130 63131 beforeFit: noop, 63132 fit: function() { 63133 var me = this; 63134 var opts = me.options; 63135 var labelOpts = opts.labels; 63136 var display = opts.display; 63137 63138 var ctx = me.ctx; 63139 63140 var globalDefault = defaults.global; 63141 var valueOrDefault = helpers.valueOrDefault; 63142 var fontSize = valueOrDefault(labelOpts.fontSize, globalDefault.defaultFontSize); 63143 var fontStyle = valueOrDefault(labelOpts.fontStyle, globalDefault.defaultFontStyle); 63144 var fontFamily = valueOrDefault(labelOpts.fontFamily, globalDefault.defaultFontFamily); 63145 var labelFont = helpers.fontString(fontSize, fontStyle, fontFamily); 63146 63147 // Reset hit boxes 63148 var hitboxes = me.legendHitBoxes = []; 63149 63150 var minSize = me.minSize; 63151 var isHorizontal = me.isHorizontal(); 63152 63153 if (isHorizontal) { 63154 minSize.width = me.maxWidth; // fill all the width 63155 minSize.height = display ? 10 : 0; 63156 } else { 63157 minSize.width = display ? 10 : 0; 63158 minSize.height = me.maxHeight; // fill all the height 63159 } 63160 63161 // Increase sizes here 63162 if (display) { 63163 ctx.font = labelFont; 63164 63165 if (isHorizontal) { 63166 // Labels 63167 63168 // Width of each line of legend boxes. Labels wrap onto multiple lines when there are too many to fit on one 63169 var lineWidths = me.lineWidths = [0]; 63170 var totalHeight = me.legendItems.length ? fontSize + (labelOpts.padding) : 0; 63171 63172 ctx.textAlign = 'left'; 63173 ctx.textBaseline = 'top'; 63174 63175 helpers.each(me.legendItems, function(legendItem, i) { 63176 var boxWidth = getBoxWidth(labelOpts, fontSize); 63177 var width = boxWidth + (fontSize / 2) + ctx.measureText(legendItem.text).width; 63178 63179 if (lineWidths[lineWidths.length - 1] + width + labelOpts.padding >= me.width) { 63180 totalHeight += fontSize + (labelOpts.padding); 63181 lineWidths[lineWidths.length] = me.left; 63182 } 63183 63184 // Store the hitbox width and height here. Final position will be updated in `draw` 63185 hitboxes[i] = { 63186 left: 0, 63187 top: 0, 63188 width: width, 63189 height: fontSize 63190 }; 63191 63192 lineWidths[lineWidths.length - 1] += width + labelOpts.padding; 63193 }); 63194 63195 minSize.height += totalHeight; 63196 63197 } else { 63198 var vPadding = labelOpts.padding; 63199 var columnWidths = me.columnWidths = []; 63200 var totalWidth = labelOpts.padding; 63201 var currentColWidth = 0; 63202 var currentColHeight = 0; 63203 var itemHeight = fontSize + vPadding; 63204 63205 helpers.each(me.legendItems, function(legendItem, i) { 63206 var boxWidth = getBoxWidth(labelOpts, fontSize); 63207 var itemWidth = boxWidth + (fontSize / 2) + ctx.measureText(legendItem.text).width; 63208 63209 // If too tall, go to new column 63210 if (currentColHeight + itemHeight > minSize.height) { 63211 totalWidth += currentColWidth + labelOpts.padding; 63212 columnWidths.push(currentColWidth); // previous column width 63213 63214 currentColWidth = 0; 63215 currentColHeight = 0; 63216 } 63217 63218 // Get max width 63219 currentColWidth = Math.max(currentColWidth, itemWidth); 63220 currentColHeight += itemHeight; 63221 63222 // Store the hitbox width and height here. Final position will be updated in `draw` 63223 hitboxes[i] = { 63224 left: 0, 63225 top: 0, 63226 width: itemWidth, 63227 height: fontSize 63228 }; 63229 }); 63230 63231 totalWidth += currentColWidth; 63232 columnWidths.push(currentColWidth); 63233 minSize.width += totalWidth; 63234 } 63235 } 63236 63237 me.width = minSize.width; 63238 me.height = minSize.height; 63239 }, 63240 afterFit: noop, 63241 63242 // Shared Methods
63243 isHorizontal: function() { 63244 return this.options.position === 'top' || this.options.position === 'bottom'; 63245 }, 63246 63247 // Actually draw the legend on the canvas 63248 draw: function() { 63249 var me = this; 63250 var opts = me.options; 63251 var labelOpts = opts.labels; 63252 var globalDefault = defaults.global; 63253 var lineDefault = globalDefault.elements.line; 63254 var legendWidth = me.width; 63255 var lineWidths = me.lineWidths; 63256 63257 if (opts.display) { 63258 var ctx = me.ctx; 63259 var valueOrDefault = helpers.valueOrDefault; 63260 var fontColor = valueOrDefault(labelOpts.fontColor, globalDefault.defaultFontColor); 63261 var fontSize = valueOrDefault(labelOpts.fontSize, globalDefault.defaultFontSize); 63262 var fontStyle = valueOrDefault(labelOpts.fontStyle, globalDefault.defaultFontStyle); 63263 var fontFamily = valueOrDefault(labelOpts.fontFamily, globalDefault.defaultFontFamily); 63264 var labelFont = helpers.fontString(fontSize, fontStyle, fontFamily); 63265 var cursor; 63266 63267 // Canvas setup 63268 ctx.textAlign = 'left'; 63269 ctx.textBaseline = 'middle'; 63270 ctx.lineWidth = 0.5; 63271 ctx.strokeStyle = fontColor; // for strikethrough effect 63272 ctx.fillStyle = fontColor; // render in correct colour 63273 ctx.font = labelFont; 63274 63275 var boxWidth = getBoxWidth(labelOpts, fontSize); 63276 var hitboxes = me.legendHitBoxes; 63277 63278 // current position 63279 var drawLegendBox = function(x, y, legendItem) { 63280 if (isNaN(boxWidth) || boxWidth <= 0) { 63281 return; 63282 } 63283 63284 // Set the ctx for the box 63285 ctx.save(); 63286 63287 ctx.fillStyle = valueOrDefault(legendItem.fillStyle, globalDefault.defaultColor); 63288 ctx.lineCap = valueOrDefault(legendItem.lineCap, lineDefault.borderCapStyle); 63289 ctx.lineDashOffset = valueOrDefault(legendItem.lineDashOffset, lineDefault.borderDashOffset); 63290 ctx.lineJoin = valueOrDefault(legendItem.lineJoin, lineDefault.borderJoinStyle); 63291 ctx.lineWidth = valueOrDefault(legendItem.lineWidth, lineDefault.borderWidth); 63292 ctx.strokeStyle = valueOrDefault(legendItem.strokeStyle, globalDefault.defaultColor); 63293 var isLineWidthZero = (valueOrDefault(legendItem.lineWidth, lineDefault.borderWidth) === 0); 63294 63295 if (ctx.setLineDash) { 63296 // IE 9 and 10 do not support line dash 63297 ctx.setLineDash(valueOrDefault(legendItem.lineDash, lineDefault.borderDash)); 63298 } 63299 63300 if (opts.labels && opts.labels.usePointStyle) { 63301 // Recalculate x and y for drawPoint() because its expecting 63302 // x and y to be center of figure (instead of top left) 63303 var radius = fontSize * Math.SQRT2 / 2; 63304 var offSet = radius / Math.SQRT2; 63305 var centerX = x + offSet; 63306 var centerY = y + offSet; 63307 63308 // Draw pointStyle as legend symbol 63309 helpers.canvas.drawPoint(ctx, legendItem.pointStyle, radius, centerX, centerY); 63310 } else { 63311 // Draw box as legend symbol 63312 if (!isLineWidthZero) { 63313 ctx.strokeRect(x, y, boxWidth, fontSize); 63314 } 63315 ctx.fillRect(x, y, boxWidth, fontSize); 63316 } 63317 63318 ctx.restore(); 63319 }; 63320 var fillText = function(x, y, legendItem, textWidth) { 63321 var halfFontSize = fontSize / 2; 63322 var xLeft = boxWidth + halfFontSize + x; 63323 var yMiddle = y + halfFontSize; 63324 63325 ctx.fillText(legendItem.text, xLeft, yMiddle); 63326 63327 if (legendItem.hidden) { 63328 // Strikethrough the text if hidden 63329 ctx.beginPath(); 63330 ctx.lineWidth = 2; 63331 ctx.moveTo(xLeft, yMiddle); 63332 ctx.lineTo(xLeft + textWidth, yMiddle); 63333 ctx.stroke(); 63334 } 63335 }; 63336 63337 // Horizontal 63338 var isHorizontal = me.isHorizontal(); 63339 if (isHorizontal) { 63340 cursor = { 63341 x: me.left + ((legendWidth - lineWidths[0]) / 2), 63342 y: me.top + labelOpts.padding, 63343 line: 0 63344 }; 63345 } else { 63346 cursor = { 63347 x: me.left + labelOpts.padding, 63348 y: me.top + labelOpts.padding, 63349 line: 0 63350 }; 63351 } 63352 63353 var itemHeight = fontSize + labelOpts.padding; 63354 helpers.each(me.legendItems, function(legendItem, i) { 63355 var textWidth = ctx.measureText(legendItem.text).width; 63356 var width = boxWidth + (fontSize / 2) + textWidth; 63357 var x = cursor.x; 63358 var y = cursor.y; 63359 63360 if (isHorizontal) { 63361 if (x + width >= legendWidth) { 63362 y = cursor.y += itemHeight; 63363 cursor.line++; 63364 x = cursor.x = me.left + ((legendWidth - lineWidths[cursor.line]) / 2); 63365 } 63366 } else if (y + itemHeight > me.bottom) { 63367 x = cursor.x = x + me.columnWidths[cursor.line] + labelOpts.padding; 63368 y = cursor.y = me.top + labelOpts.padding; 63369 cursor.line++; 63370 } 63371 63372 drawLegendBox(x, y, legendItem); 63373 63374 hitboxes[i].left = x; 63375 hitboxes[i].top = y; 63376 63377 // Fill the actual label 63378 fillText(x, y, legendItem, textWidth); 63379 63380 if (isHorizontal) { 63381 cursor.x += width + (labelOpts.padding); 63382 } else { 63383 cursor.y += itemHeight; 63384 } 63385 63386 }); 63387 } 63388 }, 63389 63390 /** 63391 * Handle an event 63392 * @private 63393 * @param {IEvent} event - The event to handle 63394 * @return {Boolean} true if a change occured 63395 */ 63396 handleEvent: function(e) { 63397 var me = this; 63398 var opts = me.options; 63399 var type = e.type === 'mouseup' ? 'click' : e.type; 63400 var changed = false;
63401 63402 if (type === 'mousemove') { 63403 if (!opts.onHover) { 63404 return; 63405 } 63406 } else if (type === 'click') { 63407 if (!opts.onClick) { 63408 return; 63409 } 63410 } else { 63411 return; 63412 } 63413 63414 // Chart event already has relative position in it 63415 var x = e.x; 63416 var y = e.y; 63417 63418 if (x >= me.left && x <= me.right && y >= me.top && y <= me.bottom) { 63419 // See if we are touching one of the dataset boxes 63420 var lh = me.legendHitBoxes; 63421 for (var i = 0; i < lh.length; ++i) { 63422 var hitBox = lh[i]; 63423 63424 if (x >= hitBox.left && x <= hitBox.left + hitBox.width && y >= hitBox.top && y <= hitBox.top + hitBox.height) { 63425 // Touching an element 63426 if (type === 'click') { 63427 // use e.native for backwards compatibility 63428 opts.onClick.call(me, e.native, me.legendItems[i]); 63429 changed = true; 63430 break; 63431 } else if (type === 'mousemove') { 63432 // use e.native for backwards compatibility 63433 opts.onHover.call(me, e.native, me.legendItems[i]); 63434 changed = true; 63435 break; 63436 } 63437 } 63438 } 63439 } 63440 63441 return changed; 63442 } 63443}); 63444 63445function createNewLegendAndAttach(chart, legendOpts) { 63446 var legend = new Legend({ 63447 ctx: chart.ctx, 63448 options: legendOpts, 63449 chart: chart 63450 }); 63451 63452 layouts.configure(chart, legend, legendOpts); 63453 layouts.addBox(chart, legend); 63454 chart.legend = legend; 63455} 63456 63457module.exports = { 63458 id: 'legend', 63459 63460 /** 63461 * Backward compatibility: since 2.1.5, the legend is registered as a plugin, making 63462 * Chart.Legend obsolete. To avoid a breaking change, we export the Legend as part of 63463 * the plugin, which one will be re-exposed in the chart.js file. 63464 * https://github.com/chartjs/Chart.js/pull/2640 63465 * @private 63466 */ 63467 _element: Legend, 63468 63469 beforeInit: function(chart) { 63470 var legendOpts = chart.options.legend; 63471 63472 if (legendOpts) { 63473 createNewLegendAndAttach(chart, legendOpts); 63474 } 63475 }, 63476 63477 beforeUpdate: function(chart) { 63478 var legendOpts = chart.options.legend; 63479 var legend = chart.legend; 63480 63481 if (legendOpts) { 63482 helpers.mergeIf(legendOpts, defaults.global.legend); 63483 63484 if (legend) { 63485 layouts.configure(chart, legend, legendOpts); 63486 legend.options = legendOpts; 63487 } else { 63488 createNewLegendAndAttach(chart, legendOpts); 63489 } 63490 } else if (legend) { 63491 layouts.removeBox(chart, legend); 63492 delete chart.legend; 63493 } 63494 }, 63495 63496 afterEvent: function(chart, e) { 63497 var legend = chart.legend; 63498 if (legend) { 63499 legend.handleEvent(e); 63500 } 63501 } 63502}; 63503 63504 63505/***/ }), 63506/* 220 */ 63507/***/ (function(module, exports, __webpack_require__) { 63508 63509"use strict"; 63510 63511 63512var defaults = __webpack_require__(2); 63513var Element = __webpack_require__(5); 63514var helpers = __webpack_require__(1); 63515var layouts = __webpack_require__(9); 63516 63517var noop = helpers.noop; 63518 63519defaults._set('global', { 63520 title: { 63521 display: false, 63522 fontStyle: 'bold', 63523 fullWidth: true, 63524 lineHeight: 1.2, 63525 padding: 10, 63526 position: 'top', 63527 text: '', 63528 weight: 2000 // by default greater than legend (1000) to be above 63529 } 63530}); 63531 63532/** 63533 * IMPORTANT: this class is exposed publicly as Chart.Legend, backward compatibility required! 63534 */ 63535var Title = Element.extend({ 63536 initialize: function(config) { 63537 var me = this; 63538 helpers.extend(me, config); 63539 63540 // Contains hit boxes for each dataset (in dataset order) 63541 me.legendHitBoxes = []; 63542 }, 63543 63544 // These methods are ordered by lifecycle. Utilities then follow. 63545 63546 beforeUpdate: noop, 63547 update: function(maxWidth, maxHeight, margins) { 63548 var me = this; 63549 63550 // Update Lifecycle - Probably don't want to ever extend or overwrite this function ;) 63551 me.beforeUpdate(); 63552 63553 // Absorb the master measurements 63554 me.maxWidth = maxWidth; 63555 me.maxHeight = maxHeight; 63556 me.margins = margins; 63557 63558 // Dimensions 63559 me.beforeSetDimensions(); 63560 me.setDimensions(); 63561 me.afterSetDimensions(); 63562 // Labels 63563 me.beforeBuildLabels(); 63564 me.buildLabels(); 63565 me.afterBuildLabels(); 63566 63567 // Fit 63568 me.beforeFit(); 63569 me.fit(); 63570 me.afterFit(); 63571 // 63572 me.afterUpdate(); 63573 63574 return me.minSize; 63575 63576 }, 63577 afterUpdate: noop, 63578 63579 // 63580 63581 beforeSetDimensions: noop, 63582 setDimensions: function() { 63583 var me = this; 63584 // Set the unconstrained dimension before label rotation 63585 if (me.isHorizontal()) { 63586 // Reset position before calculating rotation 63587 me.width = me.maxWidth; 63588 me.left = 0; 63589 me.right = me.width; 63590 } else { 63591 me.height = me.maxHeight; 63592 63593 // Reset position before calculating rotation 63594 me.top = 0; 63595 me.bottom = me.height; 63596 } 63597 63598 // Reset padding 63599 me.paddingLeft = 0; 63600 me.paddingTop = 0; 63601 me.paddingRight = 0; 63602 me.paddingBottom = 0; 63603 63604 // Reset minSize 63605 me.minSize = { 63606 width: 0, 63607 height: 0 63608 }; 63609 }, 63610 afterSetDimensions: noop, 63611 63612 // 63613 63614 beforeBuildLabels: noop, 63615 buildLabels: noop, 63616 afterBuildLabels: noop, 63617 63618 // 63619 63620 beforeFit: noop, 63621 fit: function() { 63622 var me = this; 63623 var valueOrDefault = helpers.valueOrDefault; 63624 var opts = me.options; 63625 var display = opts.display; 63626 var fontSize = valueOrDefault(opts.fontSize, defaults.global.defaultFontSize); 63627 var minSize = me.minSize; 63628 var lineCount = helpers.isArray(opts.text) ? opts.text.length : 1; 63629 var lineHeight = helpers.options.toLineHeight(opts.lineHeight, fontSize); 63630 var textSize = display ? (lineCount * lineHeight) + (opts.padding * 2) : 0; 63631 63632 if (me.isHorizontal()) { 63633 minSize.width = me.maxWidth; // fill all the width 63634 minSize.height = textSize; 63635 } else { 63636 minSize.width = textSize; 63637 minSize.height = me.maxHeight; // fill all the height 63638 } 63639 63640 me.width = minSize.width; 63641 me.height = minSize.height; 63642 63643 }, 63644 afterFit: noop, 63645 63646 // Shared Methods
63647 isHorizontal: function() { 63648 var pos = this.options.position; 63649 return pos === 'top' || pos === 'bottom'; 63650 }, 63651 63652 // Actually draw the title block on the canvas 63653 draw: function() { 63654 var me = this; 63655 var ctx = me.ctx; 63656 var valueOrDefault = helpers.valueOrDefault; 63657 var opts = me.options; 63658 var globalDefaults = defaults.global; 63659 63660 if (opts.display) { 63661 var fontSize = valueOrDefault(opts.fontSize, globalDefaults.defaultFontSize); 63662 var fontStyle = valueOrDefault(opts.fontStyle, globalDefaults.defaultFontStyle); 63663 var fontFamily = valueOrDefault(opts.fontFamily, globalDefaults.defaultFontFamily); 63664 var titleFont = helpers.fontString(fontSize, fontStyle, fontFamily); 63665 var lineHeight = helpers.options.toLineHeight(opts.lineHeight, fontSize); 63666 var offset = lineHeight / 2 + opts.padding; 63667 var rotation = 0; 63668 var top = me.top; 63669 var left = me.left; 63670 var bottom = me.bottom; 63671 var right = me.right; 63672 var maxWidth, titleX, titleY; 63673 63674 ctx.fillStyle = valueOrDefault(opts.fontColor, globalDefaults.defaultFontColor); // render in correct colour 63675 ctx.font = titleFont; 63676 63677 // Horizontal 63678 if (me.isHorizontal()) { 63679 titleX = left + ((right - left) / 2); // midpoint of the width 63680 titleY = top + offset; 63681 maxWidth = right - left; 63682 } else { 63683 titleX = opts.position === 'left' ? left + offset : right - offset; 63684 titleY = top + ((bottom - top) / 2); 63685 maxWidth = bottom - top; 63686 rotation = Math.PI * (opts.position === 'left' ? -0.5 : 0.5); 63687 } 63688 63689 ctx.save(); 63690 ctx.translate(titleX, titleY); 63691 ctx.rotate(rotation); 63692 ctx.textAlign = 'center'; 63693 ctx.textBaseline = 'middle'; 63694 63695 var text = opts.text; 63696 if (helpers.isArray(text)) { 63697 var y = 0; 63698 for (var i = 0; i < text.length; ++i) { 63699 ctx.fillText(text[i], 0, y, maxWidth); 63700 y += lineHeight; 63701 } 63702 } else { 63703 ctx.fillText(text, 0, 0, maxWidth); 63704 } 63705 63706 ctx.restore(); 63707 } 63708 } 63709}); 63710 63711function createNewTitleBlockAndAttach(chart, titleOpts) { 63712 var title = new Title({ 63713 ctx: chart.ctx, 63714 options: titleOpts, 63715 chart: chart 63716 }); 63717 63718 layouts.configure(chart, title, titleOpts); 63719 layouts.addBox(chart, title); 63720 chart.titleBlock = title; 63721} 63722 63723module.exports = { 63724 id: 'title', 63725 63726 /** 63727 * Backward compatibility: since 2.1.5, the title is registered as a plugin, making 63728 * Chart.Title obsolete. To avoid a breaking change, we export the Title as part of 63729 * the plugin, which one will be re-exposed in the chart.js file. 63730 * https://github.com/chartjs/Chart.js/pull/2640 63731 * @private 63732 */ 63733 _element: Title, 63734 63735 beforeInit: function(chart) { 63736 var titleOpts = chart.options.title; 63737 63738 if (titleOpts) { 63739 createNewTitleBlockAndAttach(chart, titleOpts); 63740 } 63741 }, 63742 63743 beforeUpdate: function(chart) { 63744 var titleOpts = chart.options.title; 63745 var titleBlock = chart.titleBlock; 63746 63747 if (titleOpts) { 63748 helpers.mergeIf(titleOpts, defaults.global.title); 63749 63750 if (titleBlock) { 63751 layouts.configure(chart, titleBlock, titleOpts); 63752 titleBlock.options = titleOpts; 63753 } else { 63754 createNewTitleBlockAndAttach(chart, titleOpts); 63755 } 63756 } else if (titleBlock) { 63757 layouts.removeBox(chart, titleBlock); 63758 delete chart.titleBlock; 63759 } 63760 } 63761}; 63762 63763 63764/***/ }), 63765/* 221 */ 63766/***/ (function(module, exports, __webpack_require__) { 63767 63768"use strict"; 63769 63770 63771module.exports = function(Chart) { 63772 63773 // Default config for a category scale 63774 var defaultConfig = { 63775 position: 'bottom' 63776 }; 63777 63778 var DatasetScale = Chart.Scale.extend({ 63779 /** 63780 * Internal function to get the correct labels. If data.xLabels or data.yLabels are defined, use those 63781 * else fall back to data.labels 63782 * @private 63783 */ 63784 getLabels: function() { 63785 var data = this.chart.data; 63786 return this.options.labels || (this.isHorizontal() ? data.xLabels : data.yLabels) || data.labels; 63787 }, 63788 63789 determineDataLimits: function() { 63790 var me = this; 63791 var labels = me.getLabels(); 63792 me.minIndex = 0; 63793 me.maxIndex = labels.length - 1; 63794 var findIndex; 63795 63796 if (me.options.ticks.min !== undefined) { 63797 // user specified min value 63798 findIndex = labels.indexOf(me.options.ticks.min); 63799 me.minIndex = findIndex !== -1 ? findIndex : me.minIndex; 63800 } 63801 63802 if (me.options.ticks.max !== undefined) { 63803 // user specified max value 63804 findIndex = labels.indexOf(me.options.ticks.max); 63805 me.maxIndex = findIndex !== -1 ? findIndex : me.maxIndex; 63806 } 63807 63808 me.min = labels[me.minIndex]; 63809 me.max = labels[me.maxIndex]; 63810 }, 63811 63812 buildTicks: function() { 63813 var me = this; 63814 var labels = me.getLabels(); 63815 // If we are viewing some subset of labels, slice the original array 63816 me.ticks = (me.minIndex === 0 && me.maxIndex === labels.length - 1) ? labels : labels.slice(me.minIndex, me.maxIndex + 1); 63817 }, 63818 63819 getLabelForIndex: function(index, datasetIndex) { 63820 var me = this; 63821 var data = me.chart.data; 63822 var isHorizontal = me.isHorizontal(); 63823 63824 if (data.yLabels && !isHorizontal) { 63825 return me.getRightValue(data.datasets[datasetIndex].data[index]); 63826 } 63827 return me.ticks[index - me.minIndex]; 63828 }, 63829 63830 // Used to get data value locations. Value can either be an index or a numerical value 63831 getPixelForValue: function(value, index) { 63832 var me = this; 63833 var offset = me.options.offset; 63834 // 1 is added because we need the length but we have the indexes 63835 var offsetAmt = Math.max((me.maxIndex + 1 - me.minIndex - (offset ? 0 : 1)), 1); 63836 63837 // If value is a data object, then index is the index in the data array, 63838 // not the index of the scale. We need to change that. 63839 var valueCategory; 63840 if (value !== undefined && value !== null) { 63841 valueCategory = me.isHorizontal() ? value.x : value.y; 63842 }
63843 if (valueCategory !== undefined || (value !== undefined && isNaN(index))) { 63844 var labels = me.getLabels(); 63845 value = valueCategory || value; 63846 var idx = labels.indexOf(value); 63847 index = idx !== -1 ? idx : index; 63848 } 63849 63850 if (me.isHorizontal()) { 63851 var valueWidth = me.width / offsetAmt; 63852 var widthOffset = (valueWidth * (index - me.minIndex)); 63853 63854 if (offset) { 63855 widthOffset += (valueWidth / 2); 63856 } 63857 63858 return me.left + Math.round(widthOffset); 63859 } 63860 var valueHeight = me.height / offsetAmt; 63861 var heightOffset = (valueHeight * (index - me.minIndex)); 63862 63863 if (offset) { 63864 heightOffset += (valueHeight / 2); 63865 } 63866 63867 return me.top + Math.round(heightOffset); 63868 }, 63869 getPixelForTick: function(index) { 63870 return this.getPixelForValue(this.ticks[index], index + this.minIndex, null); 63871 }, 63872 getValueForPixel: function(pixel) { 63873 var me = this; 63874 var offset = me.options.offset; 63875 var value; 63876 var offsetAmt = Math.max((me._ticks.length - (offset ? 0 : 1)), 1); 63877 var horz = me.isHorizontal(); 63878 var valueDimension = (horz ? me.width : me.height) / offsetAmt; 63879 63880 pixel -= horz ? me.left : me.top; 63881 63882 if (offset) { 63883 pixel -= (valueDimension / 2); 63884 } 63885 63886 if (pixel <= 0) { 63887 value = 0; 63888 } else { 63889 value = Math.round(pixel / valueDimension); 63890 } 63891 63892 return value + me.minIndex; 63893 }, 63894 getBasePixel: function() { 63895 return this.bottom; 63896 } 63897 }); 63898 63899 Chart.scaleService.registerScaleType('category', DatasetScale, defaultConfig); 63900 63901}; 63902 63903 63904/***/ }), 63905/* 222 */ 63906/***/ (function(module, exports, __webpack_require__) { 63907 63908"use strict"; 63909 63910 63911var defaults = __webpack_require__(2); 63912var helpers = __webpack_require__(1); 63913var Ticks = __webpack_require__(10); 63914 63915module.exports = function(Chart) { 63916 63917 var defaultConfig = { 63918 position: 'left', 63919 ticks: { 63920 callback: Ticks.formatters.linear 63921 } 63922 }; 63923 63924 var LinearScale = Chart.LinearScaleBase.extend({ 63925 63926 determineDataLimits: function() { 63927 var me = this; 63928 var opts = me.options; 63929 var chart = me.chart; 63930 var data = chart.data; 63931 var datasets = data.datasets; 63932 var isHorizontal = me.isHorizontal(); 63933 var DEFAULT_MIN = 0; 63934 var DEFAULT_MAX = 1; 63935 63936 function IDMatches(meta) { 63937 return isHorizontal ? meta.xAxisID === me.id : meta.yAxisID === me.id; 63938 } 63939 63940 // First Calculate the range 63941 me.min = null; 63942 me.max = null; 63943 63944 var hasStacks = opts.stacked; 63945 if (hasStacks === undefined) { 63946 helpers.each(datasets, function(dataset, datasetIndex) { 63947 if (hasStacks) { 63948 return; 63949 } 63950 63951 var meta = chart.getDatasetMeta(datasetIndex); 63952 if (chart.isDatasetVisible(datasetIndex) && IDMatches(meta) && 63953 meta.stack !== undefined) { 63954 hasStacks = true; 63955 } 63956 }); 63957 } 63958 63959 if (opts.stacked || hasStacks) { 63960 var valuesPerStack = {}; 63961 63962 helpers.each(datasets, function(dataset, datasetIndex) { 63963 var meta = chart.getDatasetMeta(datasetIndex); 63964 var key = [ 63965 meta.type, 63966 // we have a separate stack for stack=undefined datasets when the opts.stacked is undefined 63967 ((opts.stacked === undefined && meta.stack === undefined) ? datasetIndex : ''), 63968 meta.stack 63969 ].join('.'); 63970 63971 if (valuesPerStack[key] === undefined) { 63972 valuesPerStack[key] = { 63973 positiveValues: [], 63974 negativeValues: [] 63975 }; 63976 } 63977 63978 // Store these per type 63979 var positiveValues = valuesPerStack[key].positiveValues; 63980 var negativeValues = valuesPerStack[key].negativeValues; 63981 63982 if (chart.isDatasetVisible(datasetIndex) && IDMatches(meta)) { 63983 helpers.each(dataset.data, function(rawValue, index) { 63984 var value = +me.getRightValue(rawValue); 63985 if (isNaN(value) || meta.data[index].hidden) { 63986 return; 63987 } 63988 63989 positiveValues[index] = positiveValues[index] || 0; 63990 negativeValues[index] = negativeValues[index] || 0; 63991 63992 if (opts.relativePoints) { 63993 positiveValues[index] = 100; 63994 } else if (value < 0) { 63995 negativeValues[index] += value; 63996 } else { 63997 positiveValues[index] += value; 63998 } 63999 }); 64000 } 64001 }); 64002 64003 helpers.each(valuesPerStack, function(valuesForType) { 64004 var values = valuesForType.positiveValues.concat(valuesForType.negativeValues); 64005 var minVal = helpers.min(values); 64006 var maxVal = helpers.max(values); 64007 me.min = me.min === null ? minVal : Math.min(me.min, minVal); 64008 me.max = me.max === null ? maxVal : Math.max(me.max, maxVal); 64009 }); 64010 64011 } else { 64012 helpers.each(datasets, function(dataset, datasetIndex) { 64013 var meta = chart.getDatasetMeta(datasetIndex); 64014 if (chart.isDatasetVisible(datasetIndex) && IDMatches(meta)) { 64015 helpers.each(dataset.data, function(rawValue, index) { 64016 var value = +me.getRightValue(rawValue); 64017 if (isNaN(value) || meta.data[index].hidden) { 64018 return; 64019 } 64020 64021 if (me.min === null) { 64022 me.min = value; 64023 } else if (value < me.min) { 64024 me.min = value; 64025 } 64026 64027 if (me.max === null) { 64028 me.max = value; 64029 } else if (value > me.max) { 64030 me.max = value; 64031 } 64032 }); 64033 } 64034 }); 64035 } 64036 64037 me.min = isFinite(me.min) && !isNaN(me.min) ? me.min : DEFAULT_MIN; 64038 me.max = isFinite(me.max) && !isNaN(me.max) ? me.max : DEFAULT_MAX; 64039 64040 // Common base implementation to handle ticks.min, ticks.max, ticks.beginAtZero 64041 this.handleTickRangeOptions(); 64042 }, 64043 getTickLimit: function() { 64044 var maxTicks; 64045 var me = this; 64046 var tickOpts = me.options.ticks; 64047 64048 if (me.isHorizontal()) { 64049 maxTicks = Math.min(tickOpts.maxTicksLimit ? tickOpts.maxTicksLimit : 11, Math.ceil(me.width / 50)); 64050 } else { 64051 // The factor of 2 used to scale the font size has been experimentally determined.
64052 var tickFontSize = helpers.valueOrDefault(tickOpts.fontSize, defaults.global.defaultFontSize); 64053 maxTicks = Math.min(tickOpts.maxTicksLimit ? tickOpts.maxTicksLimit : 11, Math.ceil(me.height / (2 * tickFontSize))); 64054 } 64055 64056 return maxTicks; 64057 }, 64058 // Called after the ticks are built. We need 64059 handleDirectionalChanges: function() { 64060 if (!this.isHorizontal()) { 64061 // We are in a vertical orientation. The top value is the highest. So reverse the array 64062 this.ticks.reverse(); 64063 } 64064 }, 64065 getLabelForIndex: function(index, datasetIndex) { 64066 return +this.getRightValue(this.chart.data.datasets[datasetIndex].data[index]); 64067 }, 64068 // Utils 64069 getPixelForValue: function(value) { 64070 // This must be called after fit has been run so that 64071 // this.left, this.top, this.right, and this.bottom have been defined 64072 var me = this; 64073 var start = me.start; 64074 64075 var rightValue = +me.getRightValue(value); 64076 var pixel; 64077 var range = me.end - start; 64078 64079 if (me.isHorizontal()) { 64080 pixel = me.left + (me.width / range * (rightValue - start)); 64081 } else { 64082 pixel = me.bottom - (me.height / range * (rightValue - start)); 64083 } 64084 return pixel; 64085 }, 64086 getValueForPixel: function(pixel) { 64087 var me = this; 64088 var isHorizontal = me.isHorizontal(); 64089 var innerDimension = isHorizontal ? me.width : me.height; 64090 var offset = (isHorizontal ? pixel - me.left : me.bottom - pixel) / innerDimension; 64091 return me.start + ((me.end - me.start) * offset); 64092 }, 64093 getPixelForTick: function(index) { 64094 return this.getPixelForValue(this.ticksAsNumbers[index]); 64095 } 64096 }); 64097 Chart.scaleService.registerScaleType('linear', LinearScale, defaultConfig); 64098 64099}; 64100 64101 64102/***/ }), 64103/* 223 */ 64104/***/ (function(module, exports, __webpack_require__) { 64105 64106"use strict"; 64107 64108 64109var helpers = __webpack_require__(1); 64110 64111/** 64112 * Generate a set of linear ticks 64113 * @param generationOptions the options used to generate the ticks 64114 * @param dataRange the range of the data 64115 * @returns {Array<Number>} array of tick values 64116 */ 64117function generateTicks(generationOptions, dataRange) { 64118 var ticks = []; 64119 // To get a "nice" value for the tick spacing, we will use the appropriately named 64120 // "nice number" algorithm. See http://stackoverflow.com/questions/8506881/nice-label-algorithm-for-charts-with-minimum-ticks 64121 // for details. 64122 64123 var spacing; 64124 if (generationOptions.stepSize && generationOptions.stepSize > 0) { 64125 spacing = generationOptions.stepSize; 64126 } else { 64127 var niceRange = helpers.niceNum(dataRange.max - dataRange.min, false); 64128 spacing = helpers.niceNum(niceRange / (generationOptions.maxTicks - 1), true); 64129 } 64130 var niceMin = Math.floor(dataRange.min / spacing) * spacing; 64131 var niceMax = Math.ceil(dataRange.max / spacing) * spacing; 64132 64133 // If min, max and stepSize is set and they make an evenly spaced scale use it. 64134 if (generationOptions.min && generationOptions.max && generationOptions.stepSize) { 64135 // If very close to our whole number, use it. 64136 if (helpers.almostWhole((generationOptions.max - generationOptions.min) / generationOptions.stepSize, spacing / 1000)) { 64137 niceMin = generationOptions.min; 64138 niceMax = generationOptions.max; 64139 } 64140 } 64141 64142 var numSpaces = (niceMax - niceMin) / spacing; 64143 // If very close to our rounded value, use it. 64144 if (helpers.almostEquals(numSpaces, Math.round(numSpaces), spacing / 1000)) { 64145 numSpaces = Math.round(numSpaces); 64146 } else { 64147 numSpaces = Math.ceil(numSpaces); 64148 } 64149 64150 var precision = 1; 64151 if (spacing < 1) { 64152 precision = Math.pow(10, spacing.toString().length - 2); 64153 niceMin = Math.round(niceMin * precision) / precision; 64154 niceMax = Math.round(niceMax * precision) / precision; 64155 } 64156 ticks.push(generationOptions.min !== undefined ? generationOptions.min : niceMin); 64157 for (var j = 1; j < numSpaces; ++j) { 64158 ticks.push(Math.round((niceMin + j * spacing) * precision) / precision); 64159 } 64160 ticks.push(generationOptions.max !== undefined ? generationOptions.max : niceMax); 64161 64162 return ticks; 64163} 64164 64165 64166module.exports = function(Chart) { 64167 64168 var noop = helpers.noop; 64169 64170 Chart.LinearScaleBase = Chart.Scale.extend({ 64171 getRightValue: function(value) { 64172 if (typeof value === 'string') { 64173 return +value; 64174 } 64175 return Chart.Scale.prototype.getRightValue.call(this, value); 64176 }, 64177 64178 handleTickRangeOptions: function() { 64179 var me = this; 64180 var opts = me.options; 64181 var tickOpts = opts.ticks; 64182 64183 // If we are forcing it to begin at 0, but 0 will already be rendered on the chart, 64184 // do nothing since that would make the chart weird. If the user really wants a weird chart 64185 // axis, they can manually override it 64186 if (tickOpts.beginAtZero) { 64187 var minSign = helpers.sign(me.min); 64188 var maxSign = helpers.sign(me.max); 64189 64190 if (minSign < 0 && maxSign < 0) { 64191 // move the top up to 0 64192 me.max = 0; 64193 } else if (minSign > 0 && maxSign > 0) { 64194 // move the bottom down to 0 64195 me.min = 0; 64196 } 64197 } 64198 64199 var setMin = tickOpts.min !== undefined || tickOpts.suggestedMin !== undefined; 64200 var setMax = tickOpts.max !== undefined || tickOpts.suggestedMax !== undefined; 64201 64202 if (tickOpts.min !== undefined) { 64203 me.min = tickOpts.min; 64204 } else if (tickOpts.suggestedMin !== undefined) { 64205 if (me.min === null) { 64206 me.min = tickOpts.suggestedMin; 64207 } else { 64208 me.min = Math.min(me.min, tickOpts.suggestedMin); 64209 } 64210 } 64211 64212 if (tickOpts.max !== undefined) { 64213 me.max = tickOpts.max; 64214 } else if (tickOpts.suggestedMax !== undefined) { 64215 if (me.max === null) { 64216 me.max = tickOpts.suggestedMax; 64217 } else { 64218 me.max = Math.max(me.max, tickOpts.suggestedMax); 64219 } 64220 } 64221 64222 if (setMin !== setMax) { 64223 // We set the min or the max but not both. 64224 // So ensure that our range is good 64225 // Inverted or 0 length range can happen when
64226 // ticks.min is set, and no datasets are visible 64227 if (me.min >= me.max) { 64228 if (setMin) { 64229 me.max = me.min + 1; 64230 } else { 64231 me.min = me.max - 1; 64232 } 64233 } 64234 } 64235 64236 if (me.min === me.max) { 64237 me.max++; 64238 64239 if (!tickOpts.beginAtZero) { 64240 me.min--; 64241 } 64242 } 64243 }, 64244 getTickLimit: noop, 64245 handleDirectionalChanges: noop, 64246 64247 buildTicks: function() { 64248 var me = this; 64249 var opts = me.options; 64250 var tickOpts = opts.ticks; 64251 64252 // Figure out what the max number of ticks we can support it is based on the size of 64253 // the axis area. For now, we say that the minimum tick spacing in pixels must be 50 64254 // We also limit the maximum number of ticks to 11 which gives a nice 10 squares on 64255 // the graph. Make sure we always have at least 2 ticks 64256 var maxTicks = me.getTickLimit(); 64257 maxTicks = Math.max(2, maxTicks); 64258 64259 var numericGeneratorOptions = { 64260 maxTicks: maxTicks, 64261 min: tickOpts.min, 64262 max: tickOpts.max, 64263 stepSize: helpers.valueOrDefault(tickOpts.fixedStepSize, tickOpts.stepSize) 64264 }; 64265 var ticks = me.ticks = generateTicks(numericGeneratorOptions, me); 64266 64267 me.handleDirectionalChanges(); 64268 64269 // At this point, we need to update our max and min given the tick values since we have expanded the 64270 // range of the scale 64271 me.max = helpers.max(ticks); 64272 me.min = helpers.min(ticks); 64273 64274 if (tickOpts.reverse) { 64275 ticks.reverse(); 64276 64277 me.start = me.max; 64278 me.end = me.min; 64279 } else { 64280 me.start = me.min; 64281 me.end = me.max; 64282 } 64283 }, 64284 convertTicksToLabels: function() { 64285 var me = this; 64286 me.ticksAsNumbers = me.ticks.slice(); 64287 me.zeroLineIndex = me.ticks.indexOf(0); 64288 64289 Chart.Scale.prototype.convertTicksToLabels.call(me); 64290 } 64291 }); 64292}; 64293 64294 64295/***/ }), 64296/* 224 */ 64297/***/ (function(module, exports, __webpack_require__) { 64298 64299"use strict"; 64300 64301 64302var helpers = __webpack_require__(1); 64303var Ticks = __webpack_require__(10); 64304 64305/** 64306 * Generate a set of logarithmic ticks 64307 * @param generationOptions the options used to generate the ticks 64308 * @param dataRange the range of the data 64309 * @returns {Array<Number>} array of tick values 64310 */ 64311function generateTicks(generationOptions, dataRange) { 64312 var ticks = []; 64313 var valueOrDefault = helpers.valueOrDefault; 64314 64315 // Figure out what the max number of ticks we can support it is based on the size of 64316 // the axis area. For now, we say that the minimum tick spacing in pixels must be 50 64317 // We also limit the maximum number of ticks to 11 which gives a nice 10 squares on 64318 // the graph 64319 var tickVal = valueOrDefault(generationOptions.min, Math.pow(10, Math.floor(helpers.log10(dataRange.min)))); 64320 64321 var endExp = Math.floor(helpers.log10(dataRange.max)); 64322 var endSignificand = Math.ceil(dataRange.max / Math.pow(10, endExp)); 64323 var exp, significand; 64324 64325 if (tickVal === 0) { 64326 exp = Math.floor(helpers.log10(dataRange.minNotZero)); 64327 significand = Math.floor(dataRange.minNotZero / Math.pow(10, exp)); 64328 64329 ticks.push(tickVal); 64330 tickVal = significand * Math.pow(10, exp); 64331 } else { 64332 exp = Math.floor(helpers.log10(tickVal)); 64333 significand = Math.floor(tickVal / Math.pow(10, exp)); 64334 } 64335 var precision = exp < 0 ? Math.pow(10, Math.abs(exp)) : 1; 64336 64337 do { 64338 ticks.push(tickVal); 64339 64340 ++significand; 64341 if (significand === 10) { 64342 significand = 1; 64343 ++exp; 64344 precision = exp >= 0 ? 1 : precision; 64345 } 64346 64347 tickVal = Math.round(significand * Math.pow(10, exp) * precision) / precision; 64348 } while (exp < endExp || (exp === endExp && significand < endSignificand)); 64349 64350 var lastTick = valueOrDefault(generationOptions.max, tickVal); 64351 ticks.push(lastTick); 64352 64353 return ticks; 64354} 64355 64356 64357module.exports = function(Chart) { 64358 64359 var defaultConfig = { 64360 position: 'left', 64361 64362 // label settings 64363 ticks: { 64364 callback: Ticks.formatters.logarithmic 64365 } 64366 }; 64367 64368 var LogarithmicScale = Chart.Scale.extend({ 64369 determineDataLimits: function() { 64370 var me = this; 64371 var opts = me.options; 64372 var chart = me.chart; 64373 var data = chart.data; 64374 var datasets = data.datasets; 64375 var isHorizontal = me.isHorizontal(); 64376 function IDMatches(meta) { 64377 return isHorizontal ? meta.xAxisID === me.id : meta.yAxisID === me.id; 64378 } 64379 64380 // Calculate Range 64381 me.min = null; 64382 me.max = null; 64383 me.minNotZero = null; 64384 64385 var hasStacks = opts.stacked; 64386 if (hasStacks === undefined) { 64387 helpers.each(datasets, function(dataset, datasetIndex) { 64388 if (hasStacks) { 64389 return; 64390 } 64391 64392 var meta = chart.getDatasetMeta(datasetIndex); 64393 if (chart.isDatasetVisible(datasetIndex) && IDMatches(meta) && 64394 meta.stack !== undefined) { 64395 hasStacks = true; 64396 } 64397 }); 64398 } 64399 64400 if (opts.stacked || hasStacks) { 64401 var valuesPerStack = {}; 64402 64403 helpers.each(datasets, function(dataset, datasetIndex) { 64404 var meta = chart.getDatasetMeta(datasetIndex); 64405 var key = [ 64406 meta.type, 64407 // we have a separate stack for stack=undefined datasets when the opts.stacked is undefined 64408 ((opts.stacked === undefined && meta.stack === undefined) ? datasetIndex : ''), 64409 meta.stack 64410 ].join('.'); 64411 64412 if (chart.isDatasetVisible(datasetIndex) && IDMatches(meta)) { 64413 if (valuesPerStack[key] === undefined) { 64414 valuesPerStack[key] = []; 64415 } 64416 64417 helpers.each(dataset.data, function(rawValue, index) { 64418 var values = valuesPerStack[key]; 64419 var value = +me.getRightValue(rawValue); 64420 // invalid, hidden and negative values are ignored 64421 if (isNaN(value) || meta.data[index].hidden || value < 0) { 64422 return; 64423 } 64424 values[index] = values[index] || 0; 64425 values[index] += value; 64426 }); 64427 } 64428 }); 64429 64430 helpers.each(valuesPerStack, function(valuesForType) { 64431 if (valuesForType.length > 0) { 64432 var minVal = helpers.min(valuesForType); 64433 var maxVal = helpers.max(valuesForType); 64434 me.min = me.min === null ? minVal : Math.min(me.min, minVal); 64435 me.max = me.max === null ? maxVal : Math.max(me.max, maxVal); 64436 } 64437 }); 64438 64439 } else { 64440 helpers.each(datasets, function(dataset, datasetIndex) { 64441 var meta = chart.getDatasetMeta(datasetIndex); 64442 if (chart.isDatasetVisible(datasetIndex) && IDMatches(meta)) { 64443 helpers.each(dataset.data, function(rawValue, index) { 64444 var value = +me.getRightValue(rawValue); 64445 // invalid, hidden and negative values are ignored 64446 if (isNaN(value) || meta.data[index].hidden || value < 0) { 64447 return; 64448 } 64449 64450 if (me.min === null) { 64451 me.min = value; 64452 } else if (value < me.min) { 64453 me.min = value; 64454 } 64455 64456 if (me.max === null) { 64457 me.max = value; 64458 } else if (value > me.max) { 64459 me.max = value; 64460 } 64461 64462 if (value !== 0 && (me.minNotZero === null || value < me.minNotZero)) { 64463 me.minNotZero = value; 64464 } 64465 }); 64466 } 64467 }); 64468 } 64469 64470 // Common base implementation to handle ticks.min, ticks.max 64471 this.handleTickRangeOptions(); 64472 }, 64473 handleTickRangeOptions: function() { 64474 var me = this; 64475 var opts = me.options; 64476 var tickOpts = opts.ticks; 64477 var valueOrDefault = helpers.valueOrDefault; 64478 var DEFAULT_MIN = 1; 64479 var DEFAULT_MAX = 10; 64480 64481 me.min = valueOrDefault(tickOpts.min, me.min); 64482 me.max = valueOrDefault(tickOpts.max, me.max); 64483 64484 if (me.min === me.max) { 64485 if (me.min !== 0 && me.min !== null) {
64486 me.min = Math.pow(10, Math.floor(helpers.log10(me.min)) - 1); 64487 me.max = Math.pow(10, Math.floor(helpers.log10(me.max)) + 1); 64488 } else { 64489 me.min = DEFAULT_MIN; 64490 me.max = DEFAULT_MAX; 64491 } 64492 } 64493 if (me.min === null) { 64494 me.min = Math.pow(10, Math.floor(helpers.log10(me.max)) - 1); 64495 } 64496 if (me.max === null) { 64497 me.max = me.min !== 0 64498 ? Math.pow(10, Math.floor(helpers.log10(me.min)) + 1) 64499 : DEFAULT_MAX; 64500 } 64501 if (me.minNotZero === null) { 64502 if (me.min > 0) { 64503 me.minNotZero = me.min; 64504 } else if (me.max < 1) { 64505 me.minNotZero = Math.pow(10, Math.floor(helpers.log10(me.max))); 64506 } else { 64507 me.minNotZero = DEFAULT_MIN; 64508 } 64509 } 64510 }, 64511 buildTicks: function() { 64512 var me = this; 64513 var opts = me.options; 64514 var tickOpts = opts.ticks; 64515 var reverse = !me.isHorizontal(); 64516 64517 var generationOptions = { 64518 min: tickOpts.min, 64519 max: tickOpts.max 64520 }; 64521 var ticks = me.ticks = generateTicks(generationOptions, me); 64522 64523 // At this point, we need to update our max and min given the tick values since we have expanded the 64524 // range of the scale 64525 me.max = helpers.max(ticks); 64526 me.min = helpers.min(ticks); 64527 64528 if (tickOpts.reverse) { 64529 reverse = !reverse; 64530 me.start = me.max; 64531 me.end = me.min; 64532 } else { 64533 me.start = me.min; 64534 me.end = me.max; 64535 } 64536 if (reverse) { 64537 ticks.reverse(); 64538 } 64539 }, 64540 convertTicksToLabels: function() { 64541 this.tickValues = this.ticks.slice(); 64542 64543 Chart.Scale.prototype.convertTicksToLabels.call(this); 64544 }, 64545 // Get the correct tooltip label 64546 getLabelForIndex: function(index, datasetIndex) { 64547 return +this.getRightValue(this.chart.data.datasets[datasetIndex].data[index]); 64548 }, 64549 getPixelForTick: function(index) { 64550 return this.getPixelForValue(this.tickValues[index]); 64551 }, 64552 /** 64553 * Returns the value of the first tick. 64554 * @param {Number} value - The minimum not zero value. 64555 * @return {Number} The first tick value. 64556 * @private 64557 */ 64558 _getFirstTickValue: function(value) { 64559 var exp = Math.floor(helpers.log10(value)); 64560 var significand = Math.floor(value / Math.pow(10, exp)); 64561 64562 return significand * Math.pow(10, exp); 64563 }, 64564 getPixelForValue: function(value) { 64565 var me = this; 64566 var reverse = me.options.ticks.reverse; 64567 var log10 = helpers.log10; 64568 var firstTickValue = me._getFirstTickValue(me.minNotZero); 64569 var offset = 0; 64570 var innerDimension, pixel, start, end, sign; 64571 64572 value = +me.getRightValue(value); 64573 if (reverse) { 64574 start = me.end; 64575 end = me.start; 64576 sign = -1; 64577 } else { 64578 start = me.start; 64579 end = me.end; 64580 sign = 1; 64581 } 64582 if (me.isHorizontal()) { 64583 innerDimension = me.width; 64584 pixel = reverse ? me.right : me.left; 64585 } else { 64586 innerDimension = me.height; 64587 sign *= -1; // invert, since the upper-left corner of the canvas is at pixel (0, 0) 64588 pixel = reverse ? me.top : me.bottom; 64589 } 64590 if (value !== start) { 64591 if (start === 0) { // include zero tick 64592 offset = helpers.getValueOrDefault( 64593 me.options.ticks.fontSize, 64594 Chart.defaults.global.defaultFontSize 64595 ); 64596 innerDimension -= offset; 64597 start = firstTickValue; 64598 } 64599 if (value !== 0) { 64600 offset += innerDimension / (log10(end) - log10(start)) * (log10(value) - log10(start)); 64601 } 64602 pixel += sign * offset; 64603 } 64604 return pixel; 64605 }, 64606 getValueForPixel: function(pixel) { 64607 var me = this; 64608 var reverse = me.options.ticks.reverse; 64609 var log10 = helpers.log10; 64610 var firstTickValue = me._getFirstTickValue(me.minNotZero); 64611 var innerDimension, start, end, value; 64612 64613 if (reverse) { 64614 start = me.end; 64615 end = me.start; 64616 } else { 64617 start = me.start; 64618 end = me.end; 64619 } 64620 if (me.isHorizontal()) { 64621 innerDimension = me.width; 64622 value = reverse ? me.right - pixel : pixel - me.left; 64623 } else { 64624 innerDimension = me.height; 64625 value = reverse ? pixel - me.top : me.bottom - pixel; 64626 } 64627 if (value !== start) { 64628 if (start === 0) { // include zero tick 64629 var offset = helpers.getValueOrDefault( 64630 me.options.ticks.fontSize, 64631 Chart.defaults.global.defaultFontSize 64632 ); 64633 value -= offset; 64634 innerDimension -= offset; 64635 start = firstTickValue; 64636 } 64637 value *= log10(end) - log10(start); 64638 value /= innerDimension; 64639 value = Math.pow(10, log10(start) + value); 64640 } 64641 return value; 64642 } 64643 }); 64644 Chart.scaleService.registerScaleType('logarithmic', LogarithmicScale, defaultConfig); 64645 64646}; 64647 64648 64649/***/ }), 64650/* 225 */ 64651/***/ (function(module, exports, __webpack_require__) { 64652 64653"use strict"; 64654 64655 64656var defaults = __webpack_require__(2); 64657var helpers = __webpack_require__(1); 64658var Ticks = __webpack_require__(10); 64659 64660module.exports = function(Chart) { 64661 64662 var globalDefaults = defaults.global; 64663 64664 var defaultConfig = { 64665 display: true, 64666 64667 // Boolean - Whether to animate scaling the chart from the centre 64668 animate: true, 64669 position: 'chartArea', 64670 64671 angleLines: { 64672 display: true, 64673 color: 'rgba(0, 0, 0, 0.1)', 64674 lineWidth: 1 64675 }, 64676 64677 gridLines: { 64678 circular: false 64679 }, 64680 64681 // label settings 64682 ticks: { 64683 // Boolean - Show a backdrop to the scale label 64684 showLabelBackdrop: true, 64685 64686 // String - The colour of the label backdrop 64687 backdropColor: 'rgba(255,255,255,0.75)', 64688 64689 // Number - The backdrop padding above & below the label in pixels 64690 backdropPaddingY: 2, 64691 64692 // Number - The backdrop padding to the side of the label in pixels 64693 backdropPaddingX: 2, 64694 64695 callback: Ticks.formatters.linear 64696 }, 64697 64698 pointLabels: { 64699 // Boolean - if true, show point labels 64700 display: true, 64701 64702 // Number - Point label font size in pixels 64703 fontSize: 10, 64704 64705 // Function - Used to convert point labels 64706 callback: function(label) { 64707 return label; 64708 } 64709 } 64710 }; 64711 64712 function getValueCount(scale) { 64713 var opts = scale.options; 64714 return opts.angleLines.display || opts.pointLabels.display ? scale.chart.data.labels.length : 0; 64715 } 64716 64717 function getPointLabelFontOptions(scale) { 64718 var pointLabelOptions = scale.options.pointLabels; 64719 var fontSize = helpers.valueOrDefault(pointLabelOptions.fontSize, globalDefaults.defaultFontSize); 64720 var fontStyle = helpers.valueOrDefault(pointLabelOptions.fontStyle, globalDefaults.defaultFontStyle); 64721 var fontFamily = helpers.valueOrDefault(pointLabelOptions.fontFamily, globalDefaults.defaultFontFamily); 64722 var font = helpers.fontString(fontSize, fontStyle, fontFamily); 64723 64724 return { 64725 size: fontSize, 64726 style: fontStyle, 64727 family: fontFamily, 64728 font: font 64729 }; 64730 } 64731 64732 function measureLabelSize(ctx, fontSize, label) { 64733 if (helpers.isArray(label)) { 64734 return { 64735 w: helpers.longestText(ctx, ctx.font, label), 64736 h: (label.length * fontSize) + ((label.length - 1) * 1.5 * fontSize) 64737 }; 64738 } 64739 64740 return { 64741 w: ctx.measureText(label).width, 64742 h: fontSize 64743 }; 64744 } 64745 64746 function determineLimits(angle, pos, size, min, max) { 64747 if (angle === min || angle === max) { 64748 return { 64749 start: pos - (size / 2), 64750 end: pos + (size / 2) 64751 }; 64752 } else if (angle < min || angle > max) { 64753 return { 64754 start: pos - size - 5, 64755 end: pos 64756 }; 64757 } 64758 64759 return { 64760 start: pos, 64761 end: pos + size + 5 64762 }; 64763 } 64764 64765 /** 64766 * Helper function to fit a radial linear scale with point labels 64767 */ 64768 function fitWithPointLabels(scale) { 64769 /* 64770 * Right, this is really confusing and there is a lot of maths going on here 64771 * The gist of the problem is here: https://gist.github.com/nnnick/696cc9c55f4b0beb8fe9 64772 * 64773 * Reaction: https://dl.dropboxusercontent.com/u/34601363/toomuchscience.gif 64774 * 64775 * Solution: 64776 * 64777 * We assume the radius of the polygon is half the size of the canvas at first 64778 * at each index we check if the text overlaps. 64779 * 64780 * Where it does, we store that angle and that index. 64781 * 64782 * After finding the largest index and angle we calculate how much we need to remove 64783 * from the shape radius to move the point inwards by that x. 64784 * 64785 * We average the left and right distances to get the maximum shape radius that can fit in the box 64786 * along with labels. 64787 * 64788 * Once we have that, we can find the centre point for the chart, by taking the x text protrusion 64789 * on each side, removing that from the size, halving it and adding the left x protrusion width. 64790 * 64791 * This will mean we have a shape fitted to the canvas, as large as it can be with the labels 64792 * and position it in the most space efficient manner 64793 * 64794 * https://dl.dropboxusercontent.com/u/34601363/yeahscience.gif 64795 */ 64796 64797 var plFont = getPointLabelFontOptions(scale); 64798 64799 // Get maximum radius of the polygon. Either half the height (minus the text width) or half the width. 64800 // Use this to calculate the offset + change. - Make sure L/R protrusion is at least 0 to stop issues with centre points 64801 var largestPossibleRadius = Math.min(scale.height / 2, scale.width / 2); 64802 var furthestLimits = { 64803 r: scale.width, 64804 l: 0, 64805 t: scale.height, 64806 b: 0 64807 }; 64808 var furthestAngles = {}; 64809 var i, textSize, pointPosition; 64810 64811 scale.ctx.font = plFont.font; 64812 scale._pointLabelSizes = []; 64813 64814 var valueCount = getValueCount(scale); 64815 for (i = 0; i < valueCount; i++) { 64816 pointPosition = scale.getPointPosition(i, largestPossibleRadius); 64817 textSize = measureLabelSize(scale.ctx, plFont.size, scale.pointLabels[i] || ''); 64818 scale._pointLabelSizes[i] = textSize; 64819 64820 // Add quarter circle to make degree 0 mean top of circle 64821 var angleRadians = scale.getIndexAngle(i); 64822 var angle = helpers.toDegrees(angleRadians) % 360; 64823 var hLimits = determineLimits(angle, pointPosition.x, textSize.w, 0, 180); 64824 var vLimits = determineLimits(angle, pointPosition.y, textSize.h, 90, 270); 64825 64826 if (hLimits.start < furthestLimits.l) { 64827 furthestLimits.l = hLimits.start; 64828 furthestAngles.l = angleRadians; 64829 } 64830 64831 if (hLimits.end > furthestLimits.r) { 64832 furthestLimits.r = hLimits.end; 64833 furthestAngles.r = angleRadians; 64834 } 64835 64836 if (vLimits.start < furthestLimits.t) { 64837 furthestLimits.t = vLimits.start; 64838 furthestAngles.t = angleRadians; 64839 } 64840 64841 if (vLimits.end > furthestLimits.b) { 64842 furthestLimits.b = vLimits.end; 64843 furthestAngles.b = angleRadians; 64844 } 64845 } 64846 64847 scale.setReductions(largestPossibleRadius, furthestLimits, furthestAngles); 64848 } 64849 64850 /** 64851 * Helper function to fit a radial linear scale with no point labels 64852 */ 64853 function fit(scale) { 64854 var largestPossibleRadius = Math.min(scale.height / 2, scale.width / 2); 64855 scale.drawingArea = Math.round(largestPossibleRadius); 64856 scale.setCenterPoint(0, 0, 0, 0); 64857 } 64858 64859 function getTextAlignForAngle(angle) { 64860 if (angle === 0 || angle === 180) { 64861 return 'center'; 64862 } else if (angle < 180) { 64863 return 'left'; 64864 } 64865 64866 return 'right'; 64867 } 64868 64869 function fillText(ctx, text, position, fontSize) { 64870 if (helpers.isArray(text)) { 64871 var y = position.y; 64872 var spacing = 1.5 * fontSize; 64873 64874 for (var i = 0; i < text.length; ++i) { 64875 ctx.fillText(text[i], position.x, y); 64876 y += spacing; 64877 } 64878 } else { 64879 ctx.fillText(text, position.x, position.y); 64880 } 64881 } 64882 64883 function adjustPointPositionForLabelHeight(angle, textSize, position) { 64884 if (angle === 90 || angle === 270) { 64885 position.y -= (textSize.h / 2); 64886 } else if (angle > 270 || angle < 90) { 64887 position.y -= textSize.h; 64888 } 64889 } 64890 64891 function drawPointLabels(scale) { 64892 var ctx = scale.ctx; 64893 var opts = scale.options; 64894 var angleLineOpts = opts.angleLines; 64895 var pointLabelOpts = opts.pointLabels; 64896 64897 ctx.lineWidth = angleLineOpts.lineWidth; 64898 ctx.strokeStyle = angleLineOpts.color; 64899 64900 var outerDistance = scale.getDistanceFromCenterForValue(opts.ticks.reverse ? scale.min : scale.max); 64901 64902 // Point Label Font 64903 var plFont = getPointLabelFontOptions(scale); 64904 64905 ctx.textBaseline = 'top'; 64906 64907 for (var i = getValueCount(scale) - 1; i >= 0; i--) { 64908 if (angleLineOpts.display) { 64909 var outerPosition = scale.getPointPosition(i, outerDistance); 64910 ctx.beginPath(); 64911 ctx.moveTo(scale.xCenter, scale.yCenter); 64912 ctx.lineTo(outerPosition.x, outerPosition.y); 64913 ctx.stroke(); 64914 ctx.closePath(); 64915 } 64916 64917 if (pointLabelOpts.display) { 64918 // Extra 3px out for some label spacing 64919 var pointLabelPosition = scale.getPointPosition(i, outerDistance + 5); 64920 64921 // Keep this in loop since we may support array properties here 64922 var pointLabelFontColor = helpers.valueAtIndexOrDefault(pointLabelOpts.fontColor, i, globalDefaults.defaultFontColor); 64923 ctx.font = plFont.font; 64924 ctx.fillStyle = pointLabelFontColor; 64925 64926 var angleRadians = scale.getIndexAngle(i); 64927 var angle = helpers.toDegrees(angleRadians); 64928 ctx.textAlign = getTextAlignForAngle(angle); 64929 adjustPointPositionForLabelHeight(angle, scale._pointLabelSizes[i], pointLabelPosition); 64930 fillText(ctx, scale.pointLabels[i] || '', pointLabelPosition, plFont.size); 64931 } 64932 } 64933 } 64934 64935 function drawRadiusLine(scale, gridLineOpts, radius, index) { 64936 var ctx = scale.ctx; 64937 ctx.strokeStyle = helpers.valueAtIndexOrDefault(gridLineOpts.color, index - 1); 64938 ctx.lineWidth = helpers.valueAtIndexOrDefault(gridLineOpts.lineWidth, index - 1); 64939 64940 if (scale.options.gridLines.circular) { 64941 // Draw circular arcs between the points 64942 ctx.beginPath(); 64943 ctx.arc(scale.xCenter, scale.yCenter, radius, 0, Math.PI * 2); 64944 ctx.closePath(); 64945 ctx.stroke(); 64946 } else { 64947 // Draw straight lines connecting each index 64948 var valueCount = getValueCount(scale); 64949
64950 if (valueCount === 0) { 64951 return; 64952 } 64953 64954 ctx.beginPath(); 64955 var pointPosition = scale.getPointPosition(0, radius); 64956 ctx.moveTo(pointPosition.x, pointPosition.y); 64957 64958 for (var i = 1; i < valueCount; i++) { 64959 pointPosition = scale.getPointPosition(i, radius); 64960 ctx.lineTo(pointPosition.x, pointPosition.y); 64961 } 64962 64963 ctx.closePath(); 64964 ctx.stroke(); 64965 } 64966 } 64967 64968 function numberOrZero(param) { 64969 return helpers.isNumber(param) ? param : 0; 64970 } 64971 64972 var LinearRadialScale = Chart.LinearScaleBase.extend({ 64973 setDimensions: function() { 64974 var me = this; 64975 var opts = me.options; 64976 var tickOpts = opts.ticks; 64977 // Set the unconstrained dimension before label rotation 64978 me.width = me.maxWidth; 64979 me.height = me.maxHeight; 64980 me.xCenter = Math.round(me.width / 2); 64981 me.yCenter = Math.round(me.height / 2); 64982 64983 var minSize = helpers.min([me.height, me.width]); 64984 var tickFontSize = helpers.valueOrDefault(tickOpts.fontSize, globalDefaults.defaultFontSize); 64985 me.drawingArea = opts.display ? (minSize / 2) - (tickFontSize / 2 + tickOpts.backdropPaddingY) : (minSize / 2); 64986 }, 64987 determineDataLimits: function() { 64988 var me = this; 64989 var chart = me.chart; 64990 var min = Number.POSITIVE_INFINITY; 64991 var max = Number.NEGATIVE_INFINITY; 64992 64993 helpers.each(chart.data.datasets, function(dataset, datasetIndex) { 64994 if (chart.isDatasetVisible(datasetIndex)) { 64995 var meta = chart.getDatasetMeta(datasetIndex); 64996 64997 helpers.each(dataset.data, function(rawValue, index) { 64998 var value = +me.getRightValue(rawValue); 64999 if (isNaN(value) || meta.data[index].hidden) { 65000 return; 65001 } 65002 65003 min = Math.min(value, min); 65004 max = Math.max(value, max); 65005 }); 65006 } 65007 }); 65008 65009 me.min = (min === Number.POSITIVE_INFINITY ? 0 : min); 65010 me.max = (max === Number.NEGATIVE_INFINITY ? 0 : max); 65011 65012 // Common base implementation to handle ticks.min, ticks.max, ticks.beginAtZero 65013 me.handleTickRangeOptions(); 65014 }, 65015 getTickLimit: function() { 65016 var tickOpts = this.options.ticks; 65017 var tickFontSize = helpers.valueOrDefault(tickOpts.fontSize, globalDefaults.defaultFontSize); 65018 return Math.min(tickOpts.maxTicksLimit ? tickOpts.maxTicksLimit : 11, Math.ceil(this.drawingArea / (1.5 * tickFontSize))); 65019 }, 65020 convertTicksToLabels: function() { 65021 var me = this; 65022 65023 Chart.LinearScaleBase.prototype.convertTicksToLabels.call(me); 65024 65025 // Point labels 65026 me.pointLabels = me.chart.data.labels.map(me.options.pointLabels.callback, me); 65027 }, 65028 getLabelForIndex: function(index, datasetIndex) { 65029 return +this.getRightValue(this.chart.data.datasets[datasetIndex].data[index]); 65030 }, 65031 fit: function() { 65032 if (this.options.pointLabels.display) { 65033 fitWithPointLabels(this); 65034 } else { 65035 fit(this); 65036 } 65037 }, 65038 /** 65039 * Set radius reductions and determine new radius and center point 65040 * @private 65041 */ 65042 setReductions: function(largestPossibleRadius, furthestLimits, furthestAngles) { 65043 var me = this; 65044 var radiusReductionLeft = furthestLimits.l / Math.sin(furthestAngles.l); 65045 var radiusReductionRight = Math.max(furthestLimits.r - me.width, 0) / Math.sin(furthestAngles.r); 65046 var radiusReductionTop = -furthestLimits.t / Math.cos(furthestAngles.t); 65047 var radiusReductionBottom = -Math.max(furthestLimits.b - me.height, 0) / Math.cos(furthestAngles.b); 65048 65049 radiusReductionLeft = numberOrZero(radiusReductionLeft); 65050 radiusReductionRight = numberOrZero(radiusReductionRight); 65051 radiusReductionTop = numberOrZero(radiusReductionTop); 65052 radiusReductionBottom = numberOrZero(radiusReductionBottom); 65053 65054 me.drawingArea = Math.min( 65055 Math.round(largestPossibleRadius - (radiusReductionLeft + radiusReductionRight) / 2), 65056 Math.round(largestPossibleRadius - (radiusReductionTop + radiusReductionBottom) / 2)); 65057 me.setCenterPoint(radiusReductionLeft, radiusReductionRight, radiusReductionTop, radiusReductionBottom); 65058 }, 65059 setCenterPoint: function(leftMovement, rightMovement, topMovement, bottomMovement) { 65060 var me = this; 65061 var maxRight = me.width - rightMovement - me.drawingArea; 65062 var maxLeft = leftMovement + me.drawingArea; 65063 var maxTop = topMovement + me.drawingArea; 65064 var maxBottom = me.height - bottomMovement - me.drawingArea; 65065 65066 me.xCenter = Math.round(((maxLeft + maxRight) / 2) + me.left); 65067 me.yCenter = Math.round(((maxTop + maxBottom) / 2) + me.top); 65068 }, 65069 65070 getIndexAngle: function(index) { 65071 var angleMultiplier = (Math.PI * 2) / getValueCount(this); 65072 var startAngle = this.chart.options && this.chart.options.startAngle ? 65073 this.chart.options.startAngle : 65074 0; 65075 65076 var startAngleRadians = startAngle * Math.PI * 2 / 360; 65077 65078 // Start from the top instead of right, so remove a quarter of the circle 65079 return index * angleMultiplier + startAngleRadians; 65080 }, 65081 getDistanceFromCenterForValue: function(value) { 65082 var me = this; 65083 65084 if (value === null) { 65085 return 0; // null always in center 65086 } 65087 65088 // Take into account half font size + the yPadding of the top value 65089 var scalingFactor = me.drawingArea / (me.max - me.min); 65090 if (me.options.ticks.reverse) { 65091 return (me.max - value) * scalingFactor; 65092 } 65093 return (value - me.min) * scalingFactor; 65094 }, 65095 getPointPosition: function(index, distanceFromCenter) { 65096 var me = this; 65097 var thisAngle = me.getIndexAngle(index) - (Math.PI / 2); 65098 return { 65099 x: Math.round(Math.cos(thisAngle) * distanceFromCenter) + me.xCenter, 65100 y: Math.round(Math.sin(thisAngle) * distanceFromCenter) + me.yCenter 65101 }; 65102 }, 65103 getPointPositionForValue: function(index, value) { 65104 return this.getPointPosition(index, this.getDistanceFromCenterForValue(value)); 65105 }, 65106 65107 getBasePosition: function() { 65108 var me = this; 65109 var min = me.min; 65110 var max = me.max; 65111 65112 return me.getPointPositionForValue(0, 65113 me.beginAtZero ? 0 : 65114 min < 0 && max < 0 ? max : 65115 min > 0 && max > 0 ? min : 65116 0); 65117 }, 65118 65119 draw: function() { 65120 var me = this; 65121 var opts = me.options; 65122 var gridLineOpts = opts.gridLines; 65123 var tickOpts = opts.ticks; 65124 var valueOrDefault = helpers.valueOrDefault; 65125 65126 if (opts.display) { 65127 var ctx = me.ctx; 65128 var startAngle = this.getIndexAngle(0); 65129 65130 // Tick Font
65131 var tickFontSize = valueOrDefault(tickOpts.fontSize, globalDefaults.defaultFontSize); 65132 var tickFontStyle = valueOrDefault(tickOpts.fontStyle, globalDefaults.defaultFontStyle); 65133 var tickFontFamily = valueOrDefault(tickOpts.fontFamily, globalDefaults.defaultFontFamily); 65134 var tickLabelFont = helpers.fontString(tickFontSize, tickFontStyle, tickFontFamily); 65135 65136 helpers.each(me.ticks, function(label, index) { 65137 // Don't draw a centre value (if it is minimum) 65138 if (index > 0 || tickOpts.reverse) { 65139 var yCenterOffset = me.getDistanceFromCenterForValue(me.ticksAsNumbers[index]); 65140 65141 // Draw circular lines around the scale 65142 if (gridLineOpts.display && index !== 0) { 65143 drawRadiusLine(me, gridLineOpts, yCenterOffset, index); 65144 } 65145 65146 if (tickOpts.display) { 65147 var tickFontColor = valueOrDefault(tickOpts.fontColor, globalDefaults.defaultFontColor); 65148 ctx.font = tickLabelFont; 65149 65150 ctx.save(); 65151 ctx.translate(me.xCenter, me.yCenter); 65152 ctx.rotate(startAngle); 65153 65154 if (tickOpts.showLabelBackdrop) { 65155 var labelWidth = ctx.measureText(label).width; 65156 ctx.fillStyle = tickOpts.backdropColor; 65157 ctx.fillRect( 65158 -labelWidth / 2 - tickOpts.backdropPaddingX, 65159 -yCenterOffset - tickFontSize / 2 - tickOpts.backdropPaddingY, 65160 labelWidth + tickOpts.backdropPaddingX * 2, 65161 tickFontSize + tickOpts.backdropPaddingY * 2 65162 ); 65163 } 65164 65165 ctx.textAlign = 'center'; 65166 ctx.textBaseline = 'middle'; 65167 ctx.fillStyle = tickFontColor; 65168 ctx.fillText(label, 0, -yCenterOffset); 65169 ctx.restore(); 65170 } 65171 } 65172 }); 65173 65174 if (opts.angleLines.display || opts.pointLabels.display) { 65175 drawPointLabels(me); 65176 } 65177 } 65178 } 65179 }); 65180 Chart.scaleService.registerScaleType('radialLinear', LinearRadialScale, defaultConfig); 65181 65182}; 65183 65184 65185/***/ }), 65186/* 226 */ 65187/***/ (function(module, exports, __webpack_require__) { 65188 65189"use strict"; 65190/* global window: false */ 65191 65192 65193var moment = __webpack_require__(0); 65194moment = typeof moment === 'function' ? moment : window.moment; 65195 65196var defaults = __webpack_require__(2); 65197var helpers = __webpack_require__(1); 65198 65199// Integer constants are from the ES6 spec. 65200var MIN_INTEGER = Number.MIN_SAFE_INTEGER || -9007199254740991; 65201var MAX_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991; 65202 65203var INTERVALS = { 65204 millisecond: { 65205 common: true, 65206 size: 1, 65207 steps: [1, 2, 5, 10, 20, 50, 100, 250, 500] 65208 }, 65209 second: { 65210 common: true, 65211 size: 1000, 65212 steps: [1, 2, 5, 10, 30] 65213 }, 65214 minute: { 65215 common: true, 65216 size: 60000, 65217 steps: [1, 2, 5, 10, 30] 65218 }, 65219 hour: { 65220 common: true, 65221 size: 3600000, 65222 steps: [1, 2, 3, 6, 12] 65223 }, 65224 day: { 65225 common: true, 65226 size: 86400000, 65227 steps: [1, 2, 5] 65228 }, 65229 week: { 65230 common: false, 65231 size: 604800000, 65232 steps: [1, 2, 3, 4] 65233 }, 65234 month: { 65235 common: true, 65236 size: 2.628e9, 65237 steps: [1, 2, 3] 65238 }, 65239 quarter: { 65240 common: false, 65241 size: 7.884e9, 65242 steps: [1, 2, 3, 4] 65243 }, 65244 year: { 65245 common: true, 65246 size: 3.154e10 65247 } 65248}; 65249 65250var UNITS = Object.keys(INTERVALS); 65251 65252function sorter(a, b) { 65253 return a - b; 65254} 65255 65256function arrayUnique(items) { 65257 var hash = {}; 65258 var out = []; 65259 var i, ilen, item; 65260 65261 for (i = 0, ilen = items.length; i < ilen; ++i) { 65262 item = items[i]; 65263 if (!hash[item]) { 65264 hash[item] = true; 65265 out.push(item); 65266 } 65267 } 65268 65269 return out; 65270} 65271 65272/** 65273 * Returns an array of {time, pos} objects used to interpolate a specific `time` or position 65274 * (`pos`) on the scale, by searching entries before and after the requested value. `pos` is 65275 * a decimal between 0 and 1: 0 being the start of the scale (left or top) and 1 the other 65276 * extremity (left + width or top + height). Note that it would be more optimized to directly 65277 * store pre-computed pixels, but the scale dimensions are not guaranteed at the time we need 65278 * to create the lookup table. The table ALWAYS contains at least two items: min and max. 65279 * 65280 * @param {Number[]} timestamps - timestamps sorted from lowest to highest. 65281 * @param {String} distribution - If 'linear', timestamps will be spread linearly along the min 65282 * and max range, so basically, the table will contains only two items: {min, 0} and {max, 1}. 65283 * If 'series', timestamps will be positioned at the same distance from each other. In this 65284 * case, only timestamps that break the time linearity are registered, meaning that in the 65285 * best case, all timestamps are linear, the table contains only min and max. 65286 */ 65287function buildLookupTable(timestamps, min, max, distribution) { 65288 if (distribution === 'linear' || !timestamps.length) { 65289 return [ 65290 {time: min, pos: 0}, 65291 {time: max, pos: 1} 65292 ]; 65293 } 65294 65295 var table = []; 65296 var items = [min]; 65297 var i, ilen, prev, curr, next; 65298 65299 for (i = 0, ilen = timestamps.length; i < ilen; ++i) { 65300 curr = timestamps[i]; 65301 if (curr > min && curr < max) { 65302 items.push(curr); 65303 } 65304 } 65305 65306 items.push(max); 65307 65308 for (i = 0, ilen = items.length; i < ilen; ++i) { 65309 next = items[i + 1]; 65310 prev = items[i - 1]; 65311 curr = items[i]; 65312 65313 // only add points that breaks the scale linearity 65314 if (prev === undefined || next === undefined || Math.round((next + prev) / 2) !== curr) { 65315 table.push({time: curr, pos: i / (ilen - 1)}); 65316 } 65317 } 65318 65319 return table; 65320} 65321 65322// @see adapted from http://www.anujgakhar.com/2014/03/01/binary-search-in-javascript/ 65323function lookup(table, key, value) { 65324 var lo = 0; 65325 var hi = table.length - 1; 65326 var mid, i0, i1; 65327 65328 while (lo >= 0 && lo <= hi) { 65329 mid = (lo + hi) >> 1; 65330 i0 = table[mid - 1] || null; 65331 i1 = table[mid]; 65332 65333 if (!i0) { 65334 // given value is outside table (before first item) 65335 return {lo: null, hi: i1}; 65336 } else if (i1[key] < value) { 65337 lo = mid + 1; 65338 } else if (i0[key] > value) {
65339 hi = mid - 1; 65340 } else { 65341 return {lo: i0, hi: i1}; 65342 } 65343 } 65344 65345 // given value is outside table (after last item) 65346 return {lo: i1, hi: null}; 65347} 65348 65349/** 65350 * Linearly interpolates the given source `value` using the table items `skey` values and 65351 * returns the associated `tkey` value. For example, interpolate(table, 'time', 42, 'pos') 65352 * returns the position for a timestamp equal to 42. If value is out of bounds, values at 65353 * index [0, 1] or [n - 1, n] are used for the interpolation. 65354 */ 65355function interpolate(table, skey, sval, tkey) { 65356 var range = lookup(table, skey, sval); 65357 65358 // Note: the lookup table ALWAYS contains at least 2 items (min and max) 65359 var prev = !range.lo ? table[0] : !range.hi ? table[table.length - 2] : range.lo; 65360 var next = !range.lo ? table[1] : !range.hi ? table[table.length - 1] : range.hi; 65361 65362 var span = next[skey] - prev[skey]; 65363 var ratio = span ? (sval - prev[skey]) / span : 0; 65364 var offset = (next[tkey] - prev[tkey]) * ratio; 65365 65366 return prev[tkey] + offset; 65367} 65368 65369/** 65370 * Convert the given value to a moment object using the given time options. 65371 * @see http://momentjs.com/docs/#/parsing/ 65372 */ 65373function momentify(value, options) { 65374 var parser = options.parser; 65375 var format = options.parser || options.format; 65376 65377 if (typeof parser === 'function') { 65378 return parser(value); 65379 } 65380 65381 if (typeof value === 'string' && typeof format === 'string') { 65382 return moment(value, format); 65383 } 65384 65385 if (!(value instanceof moment)) { 65386 value = moment(value); 65387 } 65388 65389 if (value.isValid()) { 65390 return value; 65391 } 65392 65393 // Labels are in an incompatible moment format and no `parser` has been provided. 65394 // The user might still use the deprecated `format` option to convert his inputs. 65395 if (typeof format === 'function') { 65396 return format(value); 65397 } 65398 65399 return value; 65400} 65401 65402function parse(input, scale) { 65403 if (helpers.isNullOrUndef(input)) { 65404 return null; 65405 } 65406 65407 var options = scale.options.time; 65408 var value = momentify(scale.getRightValue(input), options); 65409 if (!value.isValid()) { 65410 return null; 65411 } 65412 65413 if (options.round) { 65414 value.startOf(options.round); 65415 } 65416 65417 return value.valueOf(); 65418} 65419 65420/** 65421 * Returns the number of unit to skip to be able to display up to `capacity` number of ticks 65422 * in `unit` for the given `min` / `max` range and respecting the interval steps constraints. 65423 */ 65424function determineStepSize(min, max, unit, capacity) { 65425 var range = max - min; 65426 var interval = INTERVALS[unit]; 65427 var milliseconds = interval.size; 65428 var steps = interval.steps; 65429 var i, ilen, factor; 65430 65431 if (!steps) { 65432 return Math.ceil(range / (capacity * milliseconds)); 65433 } 65434 65435 for (i = 0, ilen = steps.length; i < ilen; ++i) { 65436 factor = steps[i]; 65437 if (Math.ceil(range / (milliseconds * factor)) <= capacity) { 65438 break; 65439 } 65440 } 65441 65442 return factor; 65443} 65444 65445/** 65446 * Figures out what unit results in an appropriate number of auto-generated ticks 65447 */ 65448function determineUnitForAutoTicks(minUnit, min, max, capacity) { 65449 var ilen = UNITS.length; 65450 var i, interval, factor; 65451 65452 for (i = UNITS.indexOf(minUnit); i < ilen - 1; ++i) { 65453 interval = INTERVALS[UNITS[i]]; 65454 factor = interval.steps ? interval.steps[interval.steps.length - 1] : MAX_INTEGER; 65455 65456 if (interval.common && Math.ceil((max - min) / (factor * interval.size)) <= capacity) { 65457 return UNITS[i]; 65458 } 65459 } 65460 65461 return UNITS[ilen - 1]; 65462} 65463 65464/** 65465 * Figures out what unit to format a set of ticks with 65466 */ 65467function determineUnitForFormatting(ticks, minUnit, min, max) { 65468 var duration = moment.duration(moment(max).diff(moment(min))); 65469 var ilen = UNITS.length; 65470 var i, unit; 65471 65472 for (i = ilen - 1; i >= UNITS.indexOf(minUnit); i--) { 65473 unit = UNITS[i]; 65474 if (INTERVALS[unit].common && duration.as(unit) >= ticks.length) { 65475 return unit; 65476 } 65477 } 65478 65479 return UNITS[minUnit ? UNITS.indexOf(minUnit) : 0]; 65480} 65481 65482function determineMajorUnit(unit) { 65483 for (var i = UNITS.indexOf(unit) + 1, ilen = UNITS.length; i < ilen; ++i) { 65484 if (INTERVALS[UNITS[i]].common) { 65485 return UNITS[i]; 65486 } 65487 } 65488} 65489 65490/** 65491 * Generates a maximum of `capacity` timestamps between min and max, rounded to the 65492 * `minor` unit, aligned on the `major` unit and using the given scale time `options`. 65493 * Important: this method can return ticks outside the min and max range, it's the 65494 * responsibility of the calling code to clamp values if needed. 65495 */ 65496function generate(min, max, capacity, options) { 65497 var timeOpts = options.time; 65498 var minor = timeOpts.unit || determineUnitForAutoTicks(timeOpts.minUnit, min, max, capacity); 65499 var major = determineMajorUnit(minor); 65500 var stepSize = helpers.valueOrDefault(timeOpts.stepSize, timeOpts.unitStepSize); 65501 var weekday = minor === 'week' ? timeOpts.isoWeekday : false;
65502 var majorTicksEnabled = options.ticks.major.enabled; 65503 var interval = INTERVALS[minor]; 65504 var first = moment(min); 65505 var last = moment(max); 65506 var ticks = []; 65507 var time; 65508 65509 if (!stepSize) { 65510 stepSize = determineStepSize(min, max, minor, capacity); 65511 } 65512 65513 // For 'week' unit, handle the first day of week option 65514 if (weekday) { 65515 first = first.isoWeekday(weekday); 65516 last = last.isoWeekday(weekday); 65517 } 65518 65519 // Align first/last ticks on unit 65520 first = first.startOf(weekday ? 'day' : minor); 65521 last = last.startOf(weekday ? 'day' : minor); 65522 65523 // Make sure that the last tick include max 65524 if (last < max) { 65525 last.add(1, minor); 65526 } 65527 65528 time = moment(first); 65529 65530 if (majorTicksEnabled && major && !weekday && !timeOpts.round) { 65531 // Align the first tick on the previous `minor` unit aligned on the `major` unit: 65532 // we first aligned time on the previous `major` unit then add the number of full 65533 // stepSize there is between first and the previous major time. 65534 time.startOf(major); 65535 time.add(~~((first - time) / (interval.size * stepSize)) * stepSize, minor); 65536 } 65537 65538 for (; time < last; time.add(stepSize, minor)) { 65539 ticks.push(+time); 65540 } 65541 65542 ticks.push(+time); 65543 65544 return ticks; 65545} 65546 65547/** 65548 * Returns the right and left offsets from edges in the form of {left, right}. 65549 * Offsets are added when the `offset` option is true. 65550 */ 65551function computeOffsets(table, ticks, min, max, options) { 65552 var left = 0; 65553 var right = 0; 65554 var upper, lower; 65555 65556 if (options.offset && ticks.length) { 65557 if (!options.time.min) { 65558 upper = ticks.length > 1 ? ticks[1] : max; 65559 lower = ticks[0]; 65560 left = ( 65561 interpolate(table, 'time', upper, 'pos') - 65562 interpolate(table, 'time', lower, 'pos') 65563 ) / 2; 65564 } 65565 if (!options.time.max) { 65566 upper = ticks[ticks.length - 1]; 65567 lower = ticks.length > 1 ? ticks[ticks.length - 2] : min; 65568 right = ( 65569 interpolate(table, 'time', upper, 'pos') - 65570 interpolate(table, 'time', lower, 'pos') 65571 ) / 2; 65572 } 65573 } 65574 65575 return {left: left, right: right}; 65576} 65577 65578function ticksFromTimestamps(values, majorUnit) { 65579 var ticks = []; 65580 var i, ilen, value, major; 65581 65582 for (i = 0, ilen = values.length; i < ilen; ++i) { 65583 value = values[i]; 65584 major = majorUnit ? value === +moment(value).startOf(majorUnit) : false; 65585 65586 ticks.push({ 65587 value: value, 65588 major: major 65589 }); 65590 } 65591 65592 return ticks; 65593} 65594 65595function determineLabelFormat(data, timeOpts) { 65596 var i, momentDate, hasTime; 65597 var ilen = data.length; 65598 65599 // find the label with the most parts (milliseconds, minutes, etc.) 65600 // format all labels with the same level of detail as the most specific label 65601 for (i = 0; i < ilen; i++) { 65602 momentDate = momentify(data[i], timeOpts); 65603 if (momentDate.millisecond() !== 0) { 65604 return 'MMM D, YYYY h:mm:ss.SSS a'; 65605 } 65606 if (momentDate.second() !== 0 || momentDate.minute() !== 0 || momentDate.hour() !== 0) { 65607 hasTime = true; 65608 } 65609 } 65610 if (hasTime) { 65611 return 'MMM D, YYYY h:mm:ss a'; 65612 } 65613 return 'MMM D, YYYY'; 65614} 65615 65616module.exports = function(Chart) { 65617 65618 var defaultConfig = { 65619 position: 'bottom', 65620 65621 /** 65622 * Data distribution along the scale: 65623 * - 'linear': data are spread according to their time (distances can vary), 65624 * - 'series': data are spread at the same distance from each other. 65625 * @see https://github.com/chartjs/Chart.js/pull/4507 65626 * @since 2.7.0 65627 */ 65628 distribution: 'linear', 65629 65630 /** 65631 * Scale boundary strategy (bypassed by min/max time options) 65632 * - `data`: make sure data are fully visible, ticks outside are removed 65633 * - `ticks`: make sure ticks are fully visible, data outside are truncated 65634 * @see https://github.com/chartjs/Chart.js/pull/4556 65635 * @since 2.7.0 65636 */ 65637 bounds: 'data', 65638 65639 time: { 65640 parser: false, // false == a pattern string from http://momentjs.com/docs/#/parsing/string-format/ or a custom callback that converts its argument to a moment 65641 format: false, // DEPRECATED false == date objects, moment object, callback or a pattern string from http://momentjs.com/docs/#/parsing/string-format/ 65642 unit: false, // false == automatic or override with week, month, year, etc. 65643 round: false, // none, or override with week, month, year, etc. 65644 displayFormat: false, // DEPRECATED 65645 isoWeekday: false, // override week start day - see http://momentjs.com/docs/#/get-set/iso-weekday/ 65646 minUnit: 'millisecond', 65647 65648 // defaults to unit's corresponding unitFormat below or override using pattern string from http://momentjs.com/docs/#/displaying/format/ 65649 displayFormats: { 65650 millisecond: 'h:mm:ss.SSS a', // 11:20:01.123 AM, 65651 second: 'h:mm:ss a', // 11:20:01 AM 65652 minute: 'h:mm a', // 11:20 AM 65653 hour: 'hA', // 5PM 65654 day: 'MMM D', // Sep 4 65655 week: 'll', // Week 46, or maybe "[W]WW - YYYY" ? 65656 month: 'MMM YYYY', // Sept 2015 65657 quarter: '[Q]Q - YYYY', // Q3 65658 year: 'YYYY' // 2015 65659 }, 65660 }, 65661 ticks: { 65662 autoSkip: false, 65663 65664 /** 65665 * Ticks generation input values: 65666 * - 'auto': generates "optimal" ticks based on scale size and time options. 65667 * - 'data': generates ticks from data (including labels from data {t|x|y} objects). 65668 * - 'labels': generates ticks from user given `data.labels` values ONLY. 65669 * @see https://github.com/chartjs/Chart.js/pull/4507 65670 * @since 2.7.0 65671 */ 65672 source: 'auto', 65673 65674 major: { 65675 enabled: false 65676 } 65677 } 65678 }; 65679 65680 var TimeScale = Chart.Scale.extend({ 65681 initialize: function() { 65682 if (!moment) { 65683 throw new Error('Chart.js - Moment.js could not be found! You must include it before Chart.js to use the time scale. Download at https://momentjs.com'); 65684 } 65685 65686 this.mergeTicksOptions(); 65687 65688 Chart.Scale.prototype.initialize.call(this); 65689 }, 65690 65691 update: function() { 65692 var me = this; 65693 var options = me.options; 65694 65695 // DEPRECATIONS: output a message only one time per update 65696 if (options.time && options.time.format) { 65697 console.warn('options.time.format is deprecated and replaced by options.time.parser.'); 65698 } 65699 65700 return Chart.Scale.prototype.update.apply(me, arguments); 65701 }, 65702 65703 /** 65704 * Allows data to be referenced via 't' attribute 65705 */ 65706 getRightValue: function(rawValue) { 65707 if (rawValue && rawValue.t !== undefined) { 65708 rawValue = rawValue.t; 65709 } 65710 return Chart.Scale.prototype.getRightValue.call(this, rawValue); 65711 }, 65712 65713 determineDataLimits: function() { 65714 var me = this; 65715 var chart = me.chart; 65716 var timeOpts = me.options.time; 65717 var unit = timeOpts.unit || 'day'; 65718 var min = MAX_INTEGER; 65719 var max = MIN_INTEGER; 65720 var timestamps = []; 65721 var datasets = []; 65722 var labels = []; 65723 var i, j, ilen, jlen, data, timestamp; 65724 65725 // Convert labels to timestamps 65726 for (i = 0, ilen = chart.data.labels.length; i < ilen; ++i) { 65727 labels.push(parse(chart.data.labels[i], me)); 65728 } 65729 65730 // Convert data to timestamps 65731 for (i = 0, ilen = (chart.data.datasets || []).length; i < ilen; ++i) { 65732 if (chart.isDatasetVisible(i)) { 65733 data = chart.data.datasets[i].data; 65734 65735 // Let's consider that all data have the same format. 65736 if (helpers.isObject(data[0])) { 65737 datasets[i] = []; 65738 65739 for (j = 0, jlen = data.length; j < jlen; ++j) { 65740 timestamp = parse(data[j], me); 65741 timestamps.push(timestamp); 65742 datasets[i][j] = timestamp; 65743 } 65744 } else { 65745 timestamps.push.apply(timestamps, labels); 65746 datasets[i] = labels.slice(0); 65747 } 65748 } else { 65749 datasets[i] = []; 65750 } 65751 } 65752 65753 if (labels.length) { 65754 // Sort labels **after** data have been converted 65755 labels = arrayUnique(labels).sort(sorter); 65756 min = Math.min(min, labels[0]); 65757 max = Math.max(max, labels[labels.length - 1]); 65758 } 65759 65760 if (timestamps.length) { 65761 timestamps = arrayUnique(timestamps).sort(sorter); 65762 min = Math.min(min, timestamps[0]); 65763 max = Math.max(max, timestamps[timestamps.length - 1]); 65764 } 65765 65766 min = parse(timeOpts.min, me) || min; 65767 max = parse(timeOpts.max, me) || max; 65768 65769 // In case there is no valid min/max, set limits based on unit time option 65770 min = min === MAX_INTEGER ? +moment().startOf(unit) : min; 65771 max = max === MIN_INTEGER ? +moment().endOf(unit) + 1 : max; 65772 65773 // Make sure that max is strictly higher than min (required by the lookup table) 65774 me.min = Math.min(min, max); 65775 me.max = Math.max(min + 1, max); 65776 65777 // PRIVATE 65778 me._horizontal = me.isHorizontal(); 65779 me._table = []; 65780 me._timestamps = { 65781 data: timestamps, 65782 datasets: datasets, 65783 labels: labels 65784 }; 65785 }, 65786 65787 buildTicks: function() { 65788 var me = this; 65789 var min = me.min; 65790 var max = me.max; 65791 var options = me.options; 65792 var timeOpts = options.time; 65793 var timestamps = []; 65794 var ticks = []; 65795 var i, ilen, timestamp; 65796 65797 switch (options.ticks.source) { 65798 case 'data': 65799 timestamps = me._timestamps.data; 65800 break; 65801 case 'labels': 65802 timestamps = me._timestamps.labels; 65803 break; 65804 case 'auto': 65805 default: 65806 timestamps = generate(min, max, me.getLabelCapacity(min), options); 65807 } 65808 65809 if (options.bounds === 'ticks' && timestamps.length) { 65810 min = timestamps[0]; 65811 max = timestamps[timestamps.length - 1]; 65812 } 65813 65814 // Enforce limits with user min/max options 65815 min = parse(timeOpts.min, me) || min; 65816 max = parse(timeOpts.max, me) || max; 65817 65818 // Remove ticks outside the min/max range 65819 for (i = 0, ilen = timestamps.length; i < ilen; ++i) { 65820 timestamp = timestamps[i]; 65821 if (timestamp >= min && timestamp <= max) { 65822 ticks.push(timestamp); 65823 } 65824 } 65825 65826 me.min = min; 65827 me.max = max; 65828 65829 // PRIVATE 65830 me._unit = timeOpts.unit || determineUnitForFormatting(ticks, timeOpts.minUnit, me.min, me.max); 65831 me._majorUnit = determineMajorUnit(me._unit); 65832 me._table = buildLookupTable(me._timestamps.data, min, max, options.distribution); 65833 me._offsets = computeOffsets(me._table, ticks, min, max, options); 65834 me._labelFormat = determineLabelFormat(me._timestamps.data, timeOpts); 65835 65836 return ticksFromTimestamps(ticks, me._majorUnit); 65837 }, 65838 65839 getLabelForIndex: function(index, datasetIndex) { 65840 var me = this; 65841 var data = me.chart.data; 65842 var timeOpts = me.options.time; 65843 var label = data.labels && index < data.labels.length ? data.labels[index] : ''; 65844 var value = data.datasets[datasetIndex].data[index]; 65845 65846 if (helpers.isObject(value)) { 65847 label = me.getRightValue(value); 65848 } 65849 if (timeOpts.tooltipFormat) { 65850 return momentify(label, timeOpts).format(timeOpts.tooltipFormat); 65851 } 65852 if (typeof label === 'string') { 65853 return label; 65854 } 65855 65856 return momentify(label, timeOpts).format(me._labelFormat); 65857 }, 65858 65859 /** 65860 * Function to format an individual tick mark 65861 * @private 65862 */ 65863 tickFormatFunction: function(tick, index, ticks, formatOverride) { 65864 var me = this; 65865 var options = me.options; 65866 var time = tick.valueOf(); 65867 var formats = options.time.displayFormats; 65868 var minorFormat = formats[me._unit]; 65869 var majorUnit = me._majorUnit; 65870 var majorFormat = formats[majorUnit]; 65871 var majorTime = tick.clone().startOf(majorUnit).valueOf(); 65872 var majorTickOpts = options.ticks.major; 65873 var major = majorTickOpts.enabled && majorUnit && majorFormat && time === majorTime; 65874 var label = tick.format(formatOverride ? formatOverride : major ? majorFormat : minorFormat); 65875 var tickOpts = major ? majorTickOpts : options.ticks.minor; 65876 var formatter = helpers.valueOrDefault(tickOpts.callback, tickOpts.userCallback); 65877 65878 return formatter ? formatter(label, index, ticks) : label; 65879 }, 65880 65881 convertTicksToLabels: function(ticks) { 65882 var labels = []; 65883 var i, ilen; 65884 65885 for (i = 0, ilen = ticks.length; i < ilen; ++i) { 65886 labels.push(this.tickFormatFunction(moment(ticks[i].value), i, ticks)); 65887 } 65888 65889 return labels; 65890 }, 65891 65892 /** 65893 * @private 65894 */ 65895 getPixelForOffset: function(time) { 65896 var me = this; 65897 var size = me._horizontal ? me.width : me.height; 65898 var start = me._horizontal ? me.left : me.top; 65899 var pos = interpolate(me._table, 'time', time, 'pos'); 65900 65901 return start + size * (me._offsets.left + pos) / (me._offsets.left + 1 + me._offsets.right); 65902 }, 65903 65904 getPixelForValue: function(value, index, datasetIndex) { 65905 var me = this; 65906 var time = null; 65907 65908 if (index !== undefined && datasetIndex !== undefined) { 65909 time = me._timestamps.datasets[datasetIndex][index]; 65910 } 65911 65912 if (time === null) { 65913 time = parse(value, me); 65914 } 65915 65916 if (time !== null) { 65917 return me.getPixelForOffset(time); 65918 } 65919 }, 65920 65921 getPixelForTick: function(index) { 65922 var ticks = this.getTicks(); 65923 return index >= 0 && index < ticks.length ? 65924 this.getPixelForOffset(ticks[index].value) : 65925 null; 65926 }, 65927 65928 getValueForPixel: function(pixel) { 65929 var me = this; 65930 var size = me._horizontal ? me.width : me.height; 65931 var start = me._horizontal ? me.left : me.top; 65932 var pos = (size ? (pixel - start) / size : 0) * (me._offsets.left + 1 + me._offsets.left) - me._offsets.right; 65933 var time = interpolate(me._table, 'pos', pos, 'time'); 65934 65935 return moment(time); 65936 }, 65937 65938 /** 65939 * Crude approximation of what the label width might be 65940 * @private 65941 */ 65942 getLabelWidth: function(label) { 65943 var me = this; 65944 var ticksOpts = me.options.ticks; 65945 var tickLabelWidth = me.ctx.measureText(label).width; 65946 var angle = helpers.toRadians(ticksOpts.maxRotation); 65947 var cosRotation = Math.cos(angle); 65948 var sinRotation = Math.sin(angle);
vendor: 4,493 bytes, lines 65949-66122
65949 var tickFontSize = helpers.valueOrDefault(ticksOpts.fontSize, defaults.global.defaultFontSize); 65950 65951 return (tickLabelWidth * cosRotation) + (tickFontSize * sinRotation); 65952 }, 65953 65954 /** 65955 * @private 65956 */ 65957 getLabelCapacity: function(exampleTime) { 65958 var me = this; 65959 65960 var formatOverride = me.options.time.displayFormats.millisecond; // Pick the longest format for guestimation 65961 65962 var exampleLabel = me.tickFormatFunction(moment(exampleTime), 0, [], formatOverride); 65963 var tickLabelWidth = me.getLabelWidth(exampleLabel); 65964 var innerWidth = me.isHorizontal() ? me.width : me.height; 65965 65966 var capacity = Math.floor(innerWidth / tickLabelWidth); 65967 return capacity > 0 ? capacity : 1; 65968 } 65969 }); 65970 65971 Chart.scaleService.registerScaleType('time', TimeScale, defaultConfig); 65972}; 65973 65974 65975/***/ }), 65976/* 227 */ 65977/***/ (function(module, exports, __webpack_require__) { 65978 65979/* MIT license */ 65980var colorNames = __webpack_require__(230); 65981 65982module.exports = { 65983 getRgba: getRgba, 65984 getHsla: getHsla, 65985 getRgb: getRgb, 65986 getHsl: getHsl, 65987 getHwb: getHwb, 65988 getAlpha: getAlpha, 65989 65990 hexString: hexString, 65991 rgbString: rgbString, 65992 rgbaString: rgbaString, 65993 percentString: percentString, 65994 percentaString: percentaString, 65995 hslString: hslString, 65996 hslaString: hslaString, 65997 hwbString: hwbString, 65998 keyword: keyword 65999} 66000 66001function getRgba(string) { 66002 if (!string) { 66003 return; 66004 } 66005 var abbr = /^#([a-fA-F0-9]{3})$/i, 66006 hex = /^#([a-fA-F0-9]{6})$/i, 66007 rgba = /^rgba?\(\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i, 66008 per = /^rgba?\(\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i, 66009 keyword = /(\w+)/; 66010 66011 var rgb = [0, 0, 0], 66012 a = 1, 66013 match = string.match(abbr); 66014 if (match) { 66015 match = match[1]; 66016 for (var i = 0; i < rgb.length; i++) { 66017 rgb[i] = parseInt(match[i] + match[i], 16); 66018 } 66019 } 66020 else if (match = string.match(hex)) { 66021 match = match[1]; 66022 for (var i = 0; i < rgb.length; i++) { 66023 rgb[i] = parseInt(match.slice(i * 2, i * 2 + 2), 16); 66024 } 66025 } 66026 else if (match = string.match(rgba)) { 66027 for (var i = 0; i < rgb.length; i++) { 66028 rgb[i] = parseInt(match[i + 1]); 66029 } 66030 a = parseFloat(match[4]); 66031 } 66032 else if (match = string.match(per)) { 66033 for (var i = 0; i < rgb.length; i++) { 66034 rgb[i] = Math.round(parseFloat(match[i + 1]) * 2.55); 66035 } 66036 a = parseFloat(match[4]); 66037 } 66038 else if (match = string.match(keyword)) { 66039 if (match[1] == "transparent") { 66040 return [0, 0, 0, 0]; 66041 } 66042 rgb = colorNames[match[1]]; 66043 if (!rgb) { 66044 return; 66045 } 66046 } 66047 66048 for (var i = 0; i < rgb.length; i++) { 66049 rgb[i] = scale(rgb[i], 0, 255); 66050 } 66051 if (!a && a != 0) { 66052 a = 1; 66053 } 66054 else { 66055 a = scale(a, 0, 1); 66056 } 66057 rgb[3] = a; 66058 return rgb; 66059} 66060 66061function getHsla(string) { 66062 if (!string) { 66063 return; 66064 } 66065 var hsl = /^hsla?\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/; 66066 var match = string.match(hsl); 66067 if (match) { 66068 var alpha = parseFloat(match[4]); 66069 var h = scale(parseInt(match[1]), 0, 360), 66070 s = scale(parseFloat(match[2]), 0, 100), 66071 l = scale(parseFloat(match[3]), 0, 100), 66072 a = scale(isNaN(alpha) ? 1 : alpha, 0, 1); 66073 return [h, s, l, a]; 66074 } 66075} 66076 66077function getHwb(string) { 66078 if (!string) { 66079 return; 66080 } 66081 var hwb = /^hwb\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/; 66082 var match = string.match(hwb); 66083 if (match) { 66084 var alpha = parseFloat(match[4]); 66085 var h = scale(parseInt(match[1]), 0, 360), 66086 w = scale(parseFloat(match[2]), 0, 100), 66087 b = scale(parseFloat(match[3]), 0, 100), 66088 a = scale(isNaN(alpha) ? 1 : alpha, 0, 1); 66089 return [h, w, b, a]; 66090 } 66091} 66092 66093function getRgb(string) { 66094 var rgba = getRgba(string); 66095 return rgba && rgba.slice(0, 3); 66096} 66097 66098function getHsl(string) { 66099 var hsla = getHsla(string); 66100 return hsla && hsla.slice(0, 3); 66101} 66102 66103function getAlpha(string) { 66104 var vals = getRgba(string); 66105 if (vals) { 66106 return vals[3]; 66107 } 66108 else if (vals = getHsla(string)) { 66109 return vals[3]; 66110 } 66111 else if (vals = getHwb(string)) { 66112 return vals[3]; 66113 } 66114} 66115 66116// generators 66117function hexString(rgb) { 66118 return "#" + hexDouble(rgb[0]) + hexDouble(rgb[1]) 66119 + hexDouble(rgb[2]); 66120} 66121 66122function rgbString(rgba, alpha) {
66123 if (alpha < 1 || (rgba[3] && rgba[3] < 1)) { 66124 return rgbaString(rgba, alpha); 66125 } 66126 return "rgb(" + rgba[0] + ", " + rgba[1] + ", " + rgba[2] + ")"; 66127} 66128 66129function rgbaString(rgba, alpha) { 66130 if (alpha === undefined) { 66131 alpha = (rgba[3] !== undefined ? rgba[3] : 1); 66132 } 66133 return "rgba(" + rgba[0] + ", " + rgba[1] + ", " + rgba[2] 66134 + ", " + alpha + ")"; 66135} 66136 66137function percentString(rgba, alpha) { 66138 if (alpha < 1 || (rgba[3] && rgba[3] < 1)) { 66139 return percentaString(rgba, alpha); 66140 } 66141 var r = Math.round(rgba[0]/255 * 100), 66142 g = Math.round(rgba[1]/255 * 100), 66143 b = Math.round(rgba[2]/255 * 100); 66144 66145 return "rgb(" + r + "%, " + g + "%, " + b + "%)"; 66146} 66147 66148function percentaString(rgba, alpha) { 66149 var r = Math.round(rgba[0]/255 * 100), 66150 g = Math.round(rgba[1]/255 * 100), 66151 b = Math.round(rgba[2]/255 * 100); 66152 return "rgba(" + r + "%, " + g + "%, " + b + "%, " + (alpha || rgba[3] || 1) + ")"; 66153} 66154 66155function hslString(hsla, alpha) { 66156 if (alpha < 1 || (hsla[3] && hsla[3] < 1)) { 66157 return hslaString(hsla, alpha); 66158 } 66159 return "hsl(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%)"; 66160} 66161 66162function hslaString(hsla, alpha) { 66163 if (alpha === undefined) { 66164 alpha = (hsla[3] !== undefined ? hsla[3] : 1); 66165 } 66166 return "hsla(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%, " 66167 + alpha + ")"; 66168} 66169 66170// hwb is a bit different than rgb(a) & hsl(a) since there is no alpha specific syntax 66171// (hwb have alpha optional & 1 is default value) 66172function hwbString(hwb, alpha) { 66173 if (alpha === undefined) { 66174 alpha = (hwb[3] !== undefined ? hwb[3] : 1); 66175 } 66176 return "hwb(" + hwb[0] + ", " + hwb[1] + "%, " + hwb[2] + "%" 66177 + (alpha !== undefined && alpha !== 1 ? ", " + alpha : "") + ")"; 66178} 66179 66180function keyword(rgb) { 66181 return reverseNames[rgb.slice(0, 3)]; 66182} 66183 66184// helpers 66185function scale(num, min, max) { 66186 return Math.min(Math.max(min, num), max); 66187} 66188 66189function hexDouble(num) { 66190 var str = num.toString(16).toUpperCase(); 66191 return (str.length < 2) ? "0" + str : str; 66192} 66193 66194 66195//create a list of reverse color names 66196var reverseNames = {}; 66197for (var name in colorNames) { 66198 reverseNames[colorNames[name]] = name; 66199} 66200 66201 66202/***/ }), 66203/* 228 */ 66204/***/ (function(module, exports) { 66205 66206/* MIT license */ 66207 66208module.exports = { 66209 rgb2hsl: rgb2hsl, 66210 rgb2hsv: rgb2hsv, 66211 rgb2hwb: rgb2hwb, 66212 rgb2cmyk: rgb2cmyk, 66213 rgb2keyword: rgb2keyword, 66214 rgb2xyz: rgb2xyz, 66215 rgb2lab: rgb2lab, 66216 rgb2lch: rgb2lch, 66217 66218 hsl2rgb: hsl2rgb, 66219 hsl2hsv: hsl2hsv, 66220 hsl2hwb: hsl2hwb, 66221 hsl2cmyk: hsl2cmyk, 66222 hsl2keyword: hsl2keyword, 66223 66224 hsv2rgb: hsv2rgb, 66225 hsv2hsl: hsv2hsl, 66226 hsv2hwb: hsv2hwb, 66227 hsv2cmyk: hsv2cmyk, 66228 hsv2keyword: hsv2keyword, 66229 66230 hwb2rgb: hwb2rgb, 66231 hwb2hsl: hwb2hsl, 66232 hwb2hsv: hwb2hsv, 66233 hwb2cmyk: hwb2cmyk, 66234 hwb2keyword: hwb2keyword, 66235 66236 cmyk2rgb: cmyk2rgb, 66237 cmyk2hsl: cmyk2hsl, 66238 cmyk2hsv: cmyk2hsv, 66239 cmyk2hwb: cmyk2hwb, 66240 cmyk2keyword: cmyk2keyword, 66241 66242 keyword2rgb: keyword2rgb, 66243 keyword2hsl: keyword2hsl, 66244 keyword2hsv: keyword2hsv, 66245 keyword2hwb: keyword2hwb, 66246 keyword2cmyk: keyword2cmyk, 66247 keyword2lab: keyword2lab, 66248 keyword2xyz: keyword2xyz, 66249 66250 xyz2rgb: xyz2rgb, 66251 xyz2lab: xyz2lab, 66252 xyz2lch: xyz2lch, 66253 66254 lab2xyz: lab2xyz, 66255 lab2rgb: lab2rgb, 66256 lab2lch: lab2lch, 66257 66258 lch2lab: lch2lab, 66259 lch2xyz: lch2xyz, 66260 lch2rgb: lch2rgb 66261} 66262 66263 66264function rgb2hsl(rgb) { 66265 var r = rgb[0]/255, 66266 g = rgb[1]/255, 66267 b = rgb[2]/255, 66268 min = Math.min(r, g, b), 66269 max = Math.max(r, g, b), 66270 delta = max - min, 66271 h, s, l; 66272 66273 if (max == min) 66274 h = 0; 66275 else if (r == max) 66276 h = (g - b) / delta; 66277 else if (g == max) 66278 h = 2 + (b - r) / delta; 66279 else if (b == max) 66280 h = 4 + (r - g)/ delta; 66281 66282 h = Math.min(h * 60, 360); 66283 66284 if (h < 0) 66285 h += 360; 66286 66287 l = (min + max) / 2; 66288 66289 if (max == min) 66290 s = 0; 66291 else if (l <= 0.5) 66292 s = delta / (max + min); 66293 else 66294 s = delta / (2 - max - min); 66295 66296 return [h, s * 100, l * 100]; 66297} 66298 66299function rgb2hsv(rgb) { 66300 var r = rgb[0], 66301 g = rgb[1], 66302 b = rgb[2], 66303 min = Math.min(r, g, b), 66304 max = Math.max(r, g, b), 66305 delta = max - min, 66306 h, s, v; 66307 66308 if (max == 0) 66309 s = 0; 66310 else 66311 s = (delta/max * 1000)/10; 66312 66313 if (max == min) 66314 h = 0; 66315 else if (r == max) 66316 h = (g - b) / delta; 66317 else if (g == max) 66318 h = 2 + (b - r) / delta; 66319 else if (b == max) 66320 h = 4 + (r - g) / delta; 66321 66322 h = Math.min(h * 60, 360); 66323 66324 if (h < 0) 66325 h += 360; 66326 66327 v = ((max / 255) * 1000) / 10; 66328 66329 return [h, s, v]; 66330} 66331 66332function rgb2hwb(rgb) { 66333 var r = rgb[0], 66334 g = rgb[1], 66335 b = rgb[2], 66336 h = rgb2hsl(rgb)[0], 66337 w = 1/255 * Math.min(r, Math.min(g, b)), 66338 b = 1 - 1/255 * Math.max(r, Math.max(g, b)); 66339 66340 return [h, w * 100, b * 100]; 66341} 66342 66343function rgb2cmyk(rgb) {
66344 var r = rgb[0] / 255, 66345 g = rgb[1] / 255, 66346 b = rgb[2] / 255, 66347 c, m, y, k; 66348 66349 k = Math.min(1 - r, 1 - g, 1 - b); 66350 c = (1 - r - k) / (1 - k) || 0; 66351 m = (1 - g - k) / (1 - k) || 0; 66352 y = (1 - b - k) / (1 - k) || 0; 66353 return [c * 100, m * 100, y * 100, k * 100]; 66354} 66355 66356function rgb2keyword(rgb) { 66357 return reverseKeywords[JSON.stringify(rgb)]; 66358} 66359 66360function rgb2xyz(rgb) { 66361 var r = rgb[0] / 255, 66362 g = rgb[1] / 255, 66363 b = rgb[2] / 255; 66364 66365 // assume sRGB 66366 r = r > 0.04045 ? Math.pow(((r + 0.055) / 1.055), 2.4) : (r / 12.92); 66367 g = g > 0.04045 ? Math.pow(((g + 0.055) / 1.055), 2.4) : (g / 12.92); 66368 b = b > 0.04045 ? Math.pow(((b + 0.055) / 1.055), 2.4) : (b / 12.92); 66369 66370 var x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805); 66371 var y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722); 66372 var z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505); 66373 66374 return [x * 100, y *100, z * 100]; 66375} 66376 66377function rgb2lab(rgb) { 66378 var xyz = rgb2xyz(rgb), 66379 x = xyz[0], 66380 y = xyz[1], 66381 z = xyz[2], 66382 l, a, b; 66383 66384 x /= 95.047; 66385 y /= 100; 66386 z /= 108.883; 66387 66388 x = x > 0.008856 ? Math.pow(x, 1/3) : (7.787 * x) + (16 / 116); 66389 y = y > 0.008856 ? Math.pow(y, 1/3) : (7.787 * y) + (16 / 116); 66390 z = z > 0.008856 ? Math.pow(z, 1/3) : (7.787 * z) + (16 / 116); 66391 66392 l = (116 * y) - 16; 66393 a = 500 * (x - y); 66394 b = 200 * (y - z); 66395 66396 return [l, a, b]; 66397} 66398 66399function rgb2lch(args) { 66400 return lab2lch(rgb2lab(args)); 66401} 66402 66403function hsl2rgb(hsl) { 66404 var h = hsl[0] / 360, 66405 s = hsl[1] / 100, 66406 l = hsl[2] / 100, 66407 t1, t2, t3, rgb, val; 66408 66409 if (s == 0) { 66410 val = l * 255; 66411 return [val, val, val]; 66412 } 66413 66414 if (l < 0.5) 66415 t2 = l * (1 + s); 66416 else 66417 t2 = l + s - l * s; 66418 t1 = 2 * l - t2; 66419 66420 rgb = [0, 0, 0]; 66421 for (var i = 0; i < 3; i++) { 66422 t3 = h + 1 / 3 * - (i - 1); 66423 t3 < 0 && t3++; 66424 t3 > 1 && t3--; 66425 66426 if (6 * t3 < 1) 66427 val = t1 + (t2 - t1) * 6 * t3; 66428 else if (2 * t3 < 1) 66429 val = t2; 66430 else if (3 * t3 < 2) 66431 val = t1 + (t2 - t1) * (2 / 3 - t3) * 6; 66432 else 66433 val = t1; 66434 66435 rgb[i] = val * 255; 66436 } 66437 66438 return rgb; 66439} 66440 66441function hsl2hsv(hsl) { 66442 var h = hsl[0], 66443 s = hsl[1] / 100, 66444 l = hsl[2] / 100, 66445 sv, v; 66446 66447 if(l === 0) { 66448 // no need to do calc on black 66449 // also avoids divide by 0 error 66450 return [0, 0, 0]; 66451 } 66452 66453 l *= 2; 66454 s *= (l <= 1) ? l : 2 - l; 66455 v = (l + s) / 2; 66456 sv = (2 * s) / (l + s); 66457 return [h, sv * 100, v * 100]; 66458} 66459 66460function hsl2hwb(args) { 66461 return rgb2hwb(hsl2rgb(args)); 66462} 66463 66464function hsl2cmyk(args) { 66465 return rgb2cmyk(hsl2rgb(args)); 66466} 66467 66468function hsl2keyword(args) { 66469 return rgb2keyword(hsl2rgb(args)); 66470} 66471 66472 66473function hsv2rgb(hsv) { 66474 var h = hsv[0] / 60, 66475 s = hsv[1] / 100, 66476 v = hsv[2] / 100, 66477 hi = Math.floor(h) % 6; 66478 66479 var f = h - Math.floor(h), 66480 p = 255 * v * (1 - s), 66481 q = 255 * v * (1 - (s * f)), 66482 t = 255 * v * (1 - (s * (1 - f))), 66483 v = 255 * v; 66484 66485 switch(hi) { 66486 case 0: 66487 return [v, t, p]; 66488 case 1: 66489 return [q, v, p]; 66490 case 2: 66491 return [p, v, t]; 66492 case 3: 66493 return [p, q, v]; 66494 case 4: 66495 return [t, p, v]; 66496 case 5: 66497 return [v, p, q]; 66498 } 66499} 66500 66501function hsv2hsl(hsv) { 66502 var h = hsv[0], 66503 s = hsv[1] / 100, 66504 v = hsv[2] / 100, 66505 sl, l; 66506 66507 l = (2 - s) * v; 66508 sl = s * v; 66509 sl /= (l <= 1) ? l : 2 - l; 66510 sl = sl || 0; 66511 l /= 2; 66512 return [h, sl * 100, l * 100]; 66513} 66514 66515function hsv2hwb(args) { 66516 return rgb2hwb(hsv2rgb(args)) 66517} 66518 66519function hsv2cmyk(args) { 66520 return rgb2cmyk(hsv2rgb(args)); 66521} 66522 66523function hsv2keyword(args) { 66524 return rgb2keyword(hsv2rgb(args)); 66525} 66526 66527// http://dev.w3.org/csswg/css-color/#hwb-to-rgb 66528function hwb2rgb(hwb) { 66529 var h = hwb[0] / 360, 66530 wh = hwb[1] / 100, 66531 bl = hwb[2] / 100, 66532 ratio = wh + bl, 66533 i, v, f, n; 66534 66535 // wh + bl cant be > 1 66536 if (ratio > 1) { 66537 wh /= ratio; 66538 bl /= ratio; 66539 } 66540 66541 i = Math.floor(6 * h); 66542 v = 1 - bl; 66543 f = 6 * h - i; 66544 if ((i & 0x01) != 0) { 66545 f = 1 - f; 66546 } 66547 n = wh + f * (v - wh); // linear interpolation 66548 66549 switch (i) { 66550 default: 66551 case 6: 66552 case 0: r = v; g = n; b = wh; break; 66553 case 1: r = n; g = v; b = wh; break; 66554 case 2: r = wh; g = v; b = n; break; 66555 case 3: r = wh; g = n; b = v; break; 66556 case 4: r = n; g = wh; b = v; break; 66557 case 5: r = v; g = wh; b = n; break; 66558 } 66559 66560 return [r * 255, g * 255, b * 255]; 66561} 66562 66563function hwb2hsl(args) { 66564 return rgb2hsl(hwb2rgb(args)); 66565} 66566 66567function hwb2hsv(args) { 66568 return rgb2hsv(hwb2rgb(args)); 66569} 66570 66571function hwb2cmyk(args) { 66572 return rgb2cmyk(hwb2rgb(args)); 66573} 66574 66575function hwb2keyword(args) { 66576 return rgb2keyword(hwb2rgb(args)); 66577} 66578 66579function cmyk2rgb(cmyk) { 66580 var c = cmyk[0] / 100, 66581 m = cmyk[1] / 100, 66582 y = cmyk[2] / 100, 66583 k = cmyk[3] / 100, 66584 r, g, b; 66585 66586 r = 1 - Math.min(1, c * (1 - k) + k); 66587 g = 1 - Math.min(1, m * (1 - k) + k); 66588 b = 1 - Math.min(1, y * (1 - k) + k); 66589 return [r * 255, g * 255, b * 255]; 66590} 66591 66592function cmyk2hsl(args) { 66593 return rgb2hsl(cmyk2rgb(args)); 66594} 66595 66596function cmyk2hsv(args) { 66597 return rgb2hsv(cmyk2rgb(args)); 66598} 66599 66600function cmyk2hwb(args) { 66601 return rgb2hwb(cmyk2rgb(args)); 66602} 66603 66604function cmyk2keyword(args) { 66605 return rgb2keyword(cmyk2rgb(args)); 66606} 66607 66608 66609function xyz2rgb(xyz) { 66610 var x = xyz[0] / 100, 66611 y = xyz[1] / 100, 66612 z = xyz[2] / 100, 66613 r, g, b; 66614 66615 r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986); 66616 g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415); 66617 b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570); 66618 66619 // assume sRGB 66620 r = r > 0.0031308 ? ((1.055 * Math.pow(r, 1.0 / 2.4)) - 0.055) 66621 : r = (r * 12.92); 66622 66623 g = g > 0.0031308 ? ((1.055 * Math.pow(g, 1.0 / 2.4)) - 0.055) 66624 : g = (g * 12.92); 66625 66626 b = b > 0.0031308 ? ((1.055 * Math.pow(b, 1.0 / 2.4)) - 0.055) 66627 : b = (b * 12.92); 66628 66629 r = Math.min(Math.max(0, r), 1); 66630 g = Math.min(Math.max(0, g), 1); 66631 b = Math.min(Math.max(0, b), 1); 66632 66633 return [r * 255, g * 255, b * 255]; 66634} 66635 66636function xyz2lab(xyz) { 66637 var x = xyz[0], 66638 y = xyz[1], 66639 z = xyz[2], 66640 l, a, b; 66641 66642 x /= 95.047; 66643 y /= 100; 66644 z /= 108.883; 66645 66646 x = x > 0.008856 ? Math.pow(x, 1/3) : (7.787 * x) + (16 / 116); 66647 y = y > 0.008856 ? Math.pow(y, 1/3) : (7.787 * y) + (16 / 116); 66648 z = z > 0.008856 ? Math.pow(z, 1/3) : (7.787 * z) + (16 / 116); 66649 66650 l = (116 * y) - 16; 66651 a = 500 * (x - y); 66652 b = 200 * (y - z); 66653 66654 return [l, a, b]; 66655} 66656 66657function xyz2lch(args) { 66658 return lab2lch(xyz2lab(args)); 66659} 66660 66661function lab2xyz(lab) { 66662 var l = lab[0], 66663 a = lab[1], 66664 b = lab[2], 66665 x, y, z, y2; 66666 66667 if (l <= 8) { 66668 y = (l * 100) / 903.3; 66669 y2 = (7.787 * (y / 100)) + (16 / 116); 66670 } else { 66671 y = 100 * Math.pow((l + 16) / 116, 3); 66672 y2 = Math.pow(y / 100, 1/3); 66673 } 66674 66675 x = x / 95.047 <= 0.008856 ? x = (95.047 * ((a / 500) + y2 - (16 / 116))) / 7.787 : 95.047 * Math.pow((a / 500) + y2, 3); 66676 66677 z = z / 108.883 <= 0.008859 ? z = (108.883 * (y2 - (b / 200) - (16 / 116))) / 7.787 : 108.883 * Math.pow(y2 - (b / 200), 3); 66678 66679 return [x, y, z]; 66680} 66681 66682function lab2lch(lab) { 66683 var l = lab[0], 66684 a = lab[1], 66685 b = lab[2], 66686 hr, h, c; 66687 66688 hr = Math.atan2(b, a);
66689 h = hr * 360 / 2 / Math.PI; 66690 if (h < 0) { 66691 h += 360; 66692 } 66693 c = Math.sqrt(a * a + b * b); 66694 return [l, c, h]; 66695} 66696 66697function lab2rgb(args) { 66698 return xyz2rgb(lab2xyz(args)); 66699} 66700 66701function lch2lab(lch) { 66702 var l = lch[0], 66703 c = lch[1], 66704 h = lch[2], 66705 a, b, hr; 66706 66707 hr = h / 360 * 2 * Math.PI; 66708 a = c * Math.cos(hr); 66709 b = c * Math.sin(hr); 66710 return [l, a, b]; 66711} 66712 66713function lch2xyz(args) { 66714 return lab2xyz(lch2lab(args)); 66715} 66716 66717function lch2rgb(args) { 66718 return lab2rgb(lch2lab(args)); 66719} 66720 66721function keyword2rgb(keyword) { 66722 return cssKeywords[keyword]; 66723} 66724 66725function keyword2hsl(args) { 66726 return rgb2hsl(keyword2rgb(args)); 66727} 66728 66729function keyword2hsv(args) { 66730 return rgb2hsv(keyword2rgb(args)); 66731} 66732 66733function keyword2hwb(args) { 66734 return rgb2hwb(keyword2rgb(args)); 66735} 66736 66737function keyword2cmyk(args) { 66738 return rgb2cmyk(keyword2rgb(args)); 66739} 66740 66741function keyword2lab(args) { 66742 return rgb2lab(keyword2rgb(args)); 66743} 66744 66745function keyword2xyz(args) { 66746 return rgb2xyz(keyword2rgb(args)); 66747} 66748 66749var cssKeywords = { 66750 aliceblue: [240,248,255], 66751 antiquewhite: [250,235,215], 66752 aqua: [0,255,255], 66753 aquamarine: [127,255,212], 66754 azure: [240,255,255], 66755 beige: [245,245,220], 66756 bisque: [255,228,196], 66757 black: [0,0,0], 66758 blanchedalmond: [255,235,205], 66759 blue: [0,0,255], 66760 blueviolet: [138,43,226], 66761 brown: [165,42,42], 66762 burlywood: [222,184,135], 66763 cadetblue: [95,158,160], 66764 chartreuse: [127,255,0], 66765 chocolate: [210,105,30], 66766 coral: [255,127,80], 66767 cornflowerblue: [100,149,237], 66768 cornsilk: [255,248,220], 66769 crimson: [220,20,60], 66770 cyan: [0,255,255], 66771 darkblue: [0,0,139], 66772 darkcyan: [0,139,139], 66773 darkgoldenrod: [184,134,11], 66774 darkgray: [169,169,169], 66775 darkgreen: [0,100,0], 66776 darkgrey: [169,169,169], 66777 darkkhaki: [189,183,107], 66778 darkmagenta: [139,0,139], 66779 darkolivegreen: [85,107,47], 66780 darkorange: [255,140,0], 66781 darkorchid: [153,50,204], 66782 darkred: [139,0,0], 66783 darksalmon: [233,150,122], 66784 darkseagreen: [143,188,143], 66785 darkslateblue: [72,61,139], 66786 darkslategray: [47,79,79], 66787 darkslategrey: [47,79,79], 66788 darkturquoise: [0,206,209], 66789 darkviolet: [148,0,211], 66790 deeppink: [255,20,147], 66791 deepskyblue: [0,191,255], 66792 dimgray: [105,105,105], 66793 dimgrey: [105,105,105], 66794 dodgerblue: [30,144,255], 66795 firebrick: [178,34,34], 66796 floralwhite: [255,250,240], 66797 forestgreen: [34,139,34], 66798 fuchsia: [255,0,255], 66799 gainsboro: [220,220,220], 66800 ghostwhite: [248,248,255], 66801 gold: [255,215,0], 66802 goldenrod: [218,165,32], 66803 gray: [128,128,128], 66804 green: [0,128,0], 66805 greenyellow: [173,255,47], 66806 grey: [128,128,128], 66807 honeydew: [240,255,240], 66808 hotpink: [255,105,180], 66809 indianred: [205,92,92], 66810 indigo: [75,0,130], 66811 ivory: [255,255,240], 66812 khaki: [240,230,140], 66813 lavender: [230,230,250], 66814 lavenderblush: [255,240,245], 66815 lawngreen: [124,252,0], 66816 lemonchiffon: [255,250,205], 66817 lightblue: [173,216,230], 66818 lightcoral: [240,128,128], 66819 lightcyan: [224,255,255], 66820 lightgoldenrodyellow: [250,250,210], 66821 lightgray: [211,211,211], 66822 lightgreen: [144,238,144], 66823 lightgrey: [211,211,211], 66824 lightpink: [255,182,193], 66825 lightsalmon: [255,160,122], 66826 lightseagreen: [32,178,170], 66827 lightskyblue: [135,206,250], 66828 lightslategray: [119,136,153], 66829 lightslategrey: [119,136,153], 66830 lightsteelblue: [176,196,222], 66831 lightyellow: [255,255,224], 66832 lime: [0,255,0], 66833 limegreen: [50,205,50], 66834 linen: [250,240,230], 66835 magenta: [255,0,255], 66836 maroon: [128,0,0], 66837 mediumaquamarine: [102,205,170], 66838 mediumblue: [0,0,205], 66839 mediumorchid: [186,85,211], 66840 mediumpurple: [147,112,219], 66841 mediumseagreen: [60,179,113], 66842 mediumslateblue: [123,104,238], 66843 mediumspringgreen: [0,250,154], 66844 mediumturquoise: [72,209,204], 66845 mediumvioletred: [199,21,133], 66846 midnightblue: [25,25,112], 66847 mintcream: [245,255,250], 66848 mistyrose: [255,228,225], 66849 moccasin: [255,228,181], 66850 navajowhite: [255,222,173], 66851 navy: [0,0,128], 66852 oldlace: [253,245,230], 66853 olive: [128,128,0], 66854 olivedrab: [107,142,35], 66855 orange: [255,165,0], 66856 orangered: [255,69,0], 66857 orchid: [218,112,214], 66858 palegoldenrod: [238,232,170], 66859 palegreen: [152,251,152], 66860 paleturquoise: [175,238,238], 66861 palevioletred: [219,112,147], 66862 papayawhip: [255,239,213], 66863 peachpuff: [255,218,185], 66864 peru: [205,133,63], 66865 pink: [255,192,203], 66866 plum: [221,160,221], 66867 powderblue: [176,224,230], 66868 purple: [128,0,128], 66869 rebeccapurple: [102, 51, 153], 66870 red: [255,0,0], 66871 rosybrown: [188,143,143], 66872 royalblue: [65,105,225], 66873 saddlebrown: [139,69,19], 66874 salmon: [250,128,114], 66875 sandybrown: [244,164,96],
66876 seagreen: [46,139,87], 66877 seashell: [255,245,238], 66878 sienna: [160,82,45], 66879 silver: [192,192,192], 66880 skyblue: [135,206,235], 66881 slateblue: [106,90,205], 66882 slategray: [112,128,144], 66883 slategrey: [112,128,144], 66884 snow: [255,250,250], 66885 springgreen: [0,255,127], 66886 steelblue: [70,130,180], 66887 tan: [210,180,140], 66888 teal: [0,128,128], 66889 thistle: [216,191,216], 66890 tomato: [255,99,71], 66891 turquoise: [64,224,208], 66892 violet: [238,130,238], 66893 wheat: [245,222,179], 66894 white: [255,255,255], 66895 whitesmoke: [245,245,245], 66896 yellow: [255,255,0], 66897 yellowgreen: [154,205,50] 66898}; 66899 66900var reverseKeywords = {}; 66901for (var key in cssKeywords) { 66902 reverseKeywords[JSON.stringify(cssKeywords[key])] = key; 66903} 66904 66905 66906/***/ }), 66907/* 229 */ 66908/***/ (function(module, exports, __webpack_require__) { 66909 66910var conversions = __webpack_require__(228); 66911 66912var convert = function() { 66913 return new Converter(); 66914} 66915 66916for (var func in conversions) { 66917 // export Raw versions 66918 convert[func + "Raw"] = (function(func) { 66919 // accept array or plain args 66920 return function(arg) { 66921 if (typeof arg == "number") 66922 arg = Array.prototype.slice.call(arguments); 66923 return conversions[func](arg); 66924 } 66925 })(func); 66926 66927 var pair = /(\w+)2(\w+)/.exec(func), 66928 from = pair[1], 66929 to = pair[2]; 66930 66931 // export rgb2hsl and ["rgb"]["hsl"] 66932 convert[from] = convert[from] || {}; 66933 66934 convert[from][to] = convert[func] = (function(func) { 66935 return function(arg) { 66936 if (typeof arg == "number") 66937 arg = Array.prototype.slice.call(arguments); 66938 66939 var val = conversions[func](arg); 66940 if (typeof val == "string" || val === undefined) 66941 return val; // keyword 66942 66943 for (var i = 0; i < val.length; i++) 66944 val[i] = Math.round(val[i]); 66945 return val; 66946 } 66947 })(func); 66948} 66949 66950 66951/* Converter does lazy conversion and caching */ 66952var Converter = function() { 66953 this.convs = {}; 66954}; 66955 66956/* Either get the values for a space or 66957 set the values for a space, depending on args */ 66958Converter.prototype.routeSpace = function(space, args) { 66959 var values = args[0]; 66960 if (values === undefined) { 66961 // color.rgb() 66962 return this.getValues(space); 66963 } 66964 // color.rgb(10, 10, 10) 66965 if (typeof values == "number") { 66966 values = Array.prototype.slice.call(args); 66967 } 66968 66969 return this.setValues(space, values); 66970}; 66971 66972/* Set the values for a space, invalidating cache */ 66973Converter.prototype.setValues = function(space, values) { 66974 this.space = space; 66975 this.convs = {}; 66976 this.convs[space] = values; 66977 return this; 66978}; 66979 66980/* Get the values for a space. If there's already 66981 a conversion for the space, fetch it, otherwise 66982 compute it */ 66983Converter.prototype.getValues = function(space) { 66984 var vals = this.convs[space]; 66985 if (!vals) { 66986 var fspace = this.space, 66987 from = this.convs[fspace]; 66988 vals = convert[fspace][space](from); 66989 66990 this.convs[space] = vals; 66991 } 66992 return vals; 66993}; 66994 66995["rgb", "hsl", "hsv", "cmyk", "keyword"].forEach(function(space) { 66996 Converter.prototype[space] = function(vals) { 66997 return this.routeSpace(space, arguments); 66998 } 66999}); 67000 67001module.exports = convert; 67002 67003/***/ }), 67004/* 230 */ 67005/***/ (function(module, exports, __webpack_require__) { 67006 67007"use strict"; 67008 67009 67010module.exports = { 67011 "aliceblue": [240, 248, 255], 67012 "antiquewhite": [250, 235, 215], 67013 "aqua": [0, 255, 255], 67014 "aquamarine": [127, 255, 212], 67015 "azure": [240, 255, 255], 67016 "beige": [245, 245, 220], 67017 "bisque": [255, 228, 196], 67018 "black": [0, 0, 0], 67019 "blanchedalmond": [255, 235, 205], 67020 "blue": [0, 0, 255], 67021 "blueviolet": [138, 43, 226], 67022 "brown": [165, 42, 42], 67023 "burlywood": [222, 184, 135], 67024 "cadetblue": [95, 158, 160], 67025 "chartreuse": [127, 255, 0], 67026 "chocolate": [210, 105, 30], 67027 "coral": [255, 127, 80], 67028 "cornflowerblue": [100, 149, 237], 67029 "cornsilk": [255, 248, 220], 67030 "crimson": [220, 20, 60], 67031 "cyan": [0, 255, 255], 67032 "darkblue": [0, 0, 139],
67033 "darkcyan": [0, 139, 139], 67034 "darkgoldenrod": [184, 134, 11], 67035 "darkgray": [169, 169, 169], 67036 "darkgreen": [0, 100, 0], 67037 "darkgrey": [169, 169, 169], 67038 "darkkhaki": [189, 183, 107], 67039 "darkmagenta": [139, 0, 139], 67040 "darkolivegreen": [85, 107, 47], 67041 "darkorange": [255, 140, 0], 67042 "darkorchid": [153, 50, 204], 67043 "darkred": [139, 0, 0], 67044 "darksalmon": [233, 150, 122], 67045 "darkseagreen": [143, 188, 143], 67046 "darkslateblue": [72, 61, 139], 67047 "darkslategray": [47, 79, 79], 67048 "darkslategrey": [47, 79, 79], 67049 "darkturquoise": [0, 206, 209], 67050 "darkviolet": [148, 0, 211], 67051 "deeppink": [255, 20, 147], 67052 "deepskyblue": [0, 191, 255], 67053 "dimgray": [105, 105, 105], 67054 "dimgrey": [105, 105, 105], 67055 "dodgerblue": [30, 144, 255], 67056 "firebrick": [178, 34, 34], 67057 "floralwhite": [255, 250, 240], 67058 "forestgreen": [34, 139, 34], 67059 "fuchsia": [255, 0, 255], 67060 "gainsboro": [220, 220, 220], 67061 "ghostwhite": [248, 248, 255], 67062 "gold": [255, 215, 0], 67063 "goldenrod": [218, 165, 32], 67064 "gray": [128, 128, 128], 67065 "green": [0, 128, 0], 67066 "greenyellow": [173, 255, 47], 67067 "grey": [128, 128, 128], 67068 "honeydew": [240, 255, 240], 67069 "hotpink": [255, 105, 180], 67070 "indianred": [205, 92, 92], 67071 "indigo": [75, 0, 130], 67072 "ivory": [255, 255, 240], 67073 "khaki": [240, 230, 140], 67074 "lavender": [230, 230, 250], 67075 "lavenderblush": [255, 240, 245], 67076 "lawngreen": [124, 252, 0], 67077 "lemonchiffon": [255, 250, 205], 67078 "lightblue": [173, 216, 230], 67079 "lightcoral": [240, 128, 128], 67080 "lightcyan": [224, 255, 255], 67081 "lightgoldenrodyellow": [250, 250, 210], 67082 "lightgray": [211, 211, 211], 67083 "lightgreen": [144, 238, 144], 67084 "lightgrey": [211, 211, 211], 67085 "lightpink": [255, 182, 193], 67086 "lightsalmon": [255, 160, 122], 67087 "lightseagreen": [32, 178, 170], 67088 "lightskyblue": [135, 206, 250], 67089 "lightslategray": [119, 136, 153], 67090 "lightslategrey": [119, 136, 153], 67091 "lightsteelblue": [176, 196, 222], 67092 "lightyellow": [255, 255, 224], 67093 "lime": [0, 255, 0], 67094 "limegreen": [50, 205, 50], 67095 "linen": [250, 240, 230], 67096 "magenta": [255, 0, 255], 67097 "maroon": [128, 0, 0], 67098 "mediumaquamarine": [102, 205, 170], 67099 "mediumblue": [0, 0, 205], 67100 "mediumorchid": [186, 85, 211], 67101 "mediumpurple": [147, 112, 219], 67102 "mediumseagreen": [60, 179, 113], 67103 "mediumslateblue": [123, 104, 238], 67104 "mediumspringgreen": [0, 250, 154], 67105 "mediumturquoise": [72, 209, 204], 67106 "mediumvioletred": [199, 21, 133], 67107 "midnightblue": [25, 25, 112], 67108 "mintcream": [245, 255, 250], 67109 "mistyrose": [255, 228, 225], 67110 "moccasin": [255, 228, 181], 67111 "navajowhite": [255, 222, 173], 67112 "navy": [0, 0, 128], 67113 "oldlace": [253, 245, 230], 67114 "olive": [128, 128, 0], 67115 "olivedrab": [107, 142, 35], 67116 "orange": [255, 165, 0], 67117 "orangered": [255, 69, 0], 67118 "orchid": [218, 112, 214], 67119 "palegoldenrod": [238, 232, 170], 67120 "palegreen": [152, 251, 152], 67121 "paleturquoise": [175, 238, 238], 67122 "palevioletred": [219, 112, 147], 67123 "papayawhip": [255, 239, 213], 67124 "peachpuff": [255, 218, 185], 67125 "peru": [205, 133, 63], 67126 "pink": [255, 192, 203], 67127 "plum": [221, 160, 221], 67128 "powderblue": [176, 224, 230], 67129 "purple": [128, 0, 128], 67130 "rebeccapurple": [102, 51, 153], 67131 "red": [255, 0, 0], 67132 "rosybrown": [188, 143, 143], 67133 "royalblue": [65, 105, 225], 67134 "saddlebrown": [139, 69, 19], 67135 "salmon": [250, 128, 114], 67136 "sandybrown": [244, 164, 96], 67137 "seagreen": [46, 139, 87], 67138 "seashell": [255, 245, 238], 67139 "sienna": [160, 82, 45], 67140 "silver": [192, 192, 192], 67141 "skyblue": [135, 206, 235], 67142 "slateblue": [106, 90, 205], 67143 "slategray": [112, 128, 144], 67144 "slategrey": [112, 128, 144], 67145 "snow": [255, 250, 250], 67146 "springgreen": [0, 255, 127], 67147 "steelblue": [70, 130, 180], 67148 "tan": [210, 180, 140], 67149 "teal": [0, 128, 128], 67150 "thistle": [216, 191, 216], 67151 "tomato": [255, 99, 71], 67152 "turquoise": [64, 224, 208], 67153 "violet": [238, 130, 238], 67154 "wheat": [245, 222, 179], 67155 "white": [255, 255, 255], 67156 "whitesmoke": [245, 245, 245], 67157 "yellow": [255, 255, 0], 67158 "yellowgreen": [154, 205, 50] 67159}; 67160 67161 67162/***/ }), 67163/* 231 */ 67164/***/ (function(module, exports) { 67165 67166 67167/** 67168 * Expose `Emitter`. 67169 */ 67170 67171module.exports = Emitter; 67172 67173/** 67174 * Initialize a new `Emitter`. 67175 * 67176 * @api public 67177 */ 67178 67179function Emitter(obj) { 67180 if (obj) return mixin(obj); 67181}; 67182 67183/** 67184 * Mixin the emitter properties. 67185 * 67186 * @param {Object} obj 67187 * @return {Object} 67188 * @api private 67189 */ 67190 67191function mixin(obj) { 67192 for (var key in Emitter.prototype) { 67193 obj[key] = Emitter.prototype[key]; 67194 } 67195 return obj; 67196} 67197 67198/** 67199 * Listen on the given `event` with `fn`. 67200 * 67201 * @param {String} event 67202 * @param {Function} fn 67203 * @return {Emitter} 67204 * @api public 67205 */ 67206 67207Emitter.prototype.on = function(event, fn){ 67208 this._callbacks = this._callbacks || {}; 67209 (this._callbacks[event] = this._callbacks[event] || []) 67210 .push(fn); 67211 return this; 67212}; 67213 67214/**
67215 * Adds an `event` listener that will be invoked a single 67216 * time then automatically removed. 67217 * 67218 * @param {String} event 67219 * @param {Function} fn 67220 * @return {Emitter} 67221 * @api public 67222 */ 67223 67224Emitter.prototype.once = function(event, fn){ 67225 var self = this; 67226 this._callbacks = this._callbacks || {}; 67227 67228 function on() { 67229 self.off(event, on); 67230 fn.apply(this, arguments); 67231 } 67232 67233 fn._off = on; 67234 this.on(event, on); 67235 return this; 67236}; 67237 67238/** 67239 * Remove the given callback for `event` or all 67240 * registered callbacks. 67241 * 67242 * @param {String} event 67243 * @param {Function} fn 67244 * @return {Emitter} 67245 * @api public 67246 */ 67247 67248Emitter.prototype.off = 67249Emitter.prototype.removeListener = 67250Emitter.prototype.removeAllListeners = function(event, fn){ 67251 this._callbacks = this._callbacks || {}; 67252 67253 // all 67254 if (0 == arguments.length) { 67255 this._callbacks = {}; 67256 return this; 67257 } 67258 67259 // specific event 67260 var callbacks = this._callbacks[event]; 67261 if (!callbacks) return this; 67262 67263 // remove all handlers 67264 if (1 == arguments.length) { 67265 delete this._callbacks[event]; 67266 return this; 67267 } 67268 67269 // remove specific handler 67270 var i = callbacks.indexOf(fn._off || fn); 67271 if (~i) callbacks.splice(i, 1); 67272 return this; 67273}; 67274 67275/** 67276 * Emit `event` with the given args. 67277 * 67278 * @param {String} event 67279 * @param {Mixed} ... 67280 * @return {Emitter} 67281 */ 67282 67283Emitter.prototype.emit = function(event){ 67284 this._callbacks = this._callbacks || {}; 67285 var args = [].slice.call(arguments, 1) 67286 , callbacks = this._callbacks[event]; 67287 67288 if (callbacks) { 67289 callbacks = callbacks.slice(0); 67290 for (var i = 0, len = callbacks.length; i < len; ++i) { 67291 callbacks[i].apply(this, args); 67292 } 67293 } 67294 67295 return this; 67296}; 67297 67298/** 67299 * Return array of callbacks for `event`. 67300 * 67301 * @param {String} event 67302 * @return {Array} 67303 * @api public 67304 */ 67305 67306Emitter.prototype.listeners = function(event){ 67307 this._callbacks = this._callbacks || {}; 67308 return this._callbacks[event] || []; 67309}; 67310 67311/** 67312 * Check if this emitter has `event` handlers. 67313 * 67314 * @param {String} event 67315 * @return {Boolean} 67316 * @api public 67317 */ 67318 67319Emitter.prototype.hasListeners = function(event){ 67320 return !! this.listeners(event).length; 67321}; 67322 67323 67324/***/ }), 67325/* 232 */ 67326/***/ (function(module, exports, __webpack_require__) { 67327 67328module.exports = __webpack_require__(233); 67329 67330 67331/***/ }), 67332/* 233 */ 67333/***/ (function(module, exports, __webpack_require__) { 67334 67335var _ = __webpack_require__(240) 67336 67337 , request = __webpack_require__(239) 67338 67339 , apiUrl = 'https://maps.googleapis.com/maps/api/geocode/json' 67340; 67341 67342 67343function GeoPlace(res){ 67344 67345 Object 67346 .defineProperty( 67347 this, 67348 'googleResponse', { 67349 value : res, 67350 writable : false, 67351 enumerable : false, 67352 configurable : true 67353 }); 67354 67355 Object 67356 .defineProperty( 67357 this, 67358 'city', { 67359 enumerable : true, 67360 get: function(){ 67361 switch(this.country.short_name){ 67362 case 'CA': 67363 case 'US': 67364 return this.locality||this.sublocality; 67365 } 67366 return undefined; 67367 } 67368 }); 67369 67370 67371 Object 67372 .defineProperty( 67373 this, 67374 'province_state', { 67375 enumerable : true, 67376 get: function(){ 67377 switch(this.country.short_name){ 67378 case 'CA': 67379 case 'US': 67380 return this.administrative_area_level_1; 67381 } 67382 return undefined; 67383 } 67384 }); 67385 67386 67387 this.googleResponse = res; 67388 this._parseResult( res); 67389 67390} 67391 67392GeoPlace.prototype._normalizeAddressComponents = function(res){ 67393 var components = {}; 67394 res.address_components.forEach(function(item){ 67395 components[ item.types[0]] = { 67396 long_name: item.long_name, 67397 short_name: item.short_name 67398 }; 67399 }); 67400 return components; 67401}; 67402 67403GeoPlace.prototype._parseResult = function(res){ 67404 67405 var norm = this._normalizeAddressComponents( res); 67406 _.extend(this, norm); 67407 67408 this.formatted_address = res.formatted_address; 67409 67410 var geo = res.geometry; 67411 this.location = geo.location; 67412 this.location_type = geo.location_type; 67413 67414 if( geo.bounds) this.location_bounds = geo.bounds; 67415 67416 return norm; 67417}; 67418 67419GeoPlace.parseAddressResults = function(results){ 67420 var places = []; 67421 results.forEach(function(res){ 67422 places.push( new GeoPlace(res)); 67423 }); 67424 return places; 67425}; 67426 67427 67428function GeoCoder(apiKey){ 67429 67430 this.queryData = { 67431 key: apiKey, 67432 sensor: false 67433 }; 67434 67435 this.lastResults = null; 67436}; 67437 67438 67439GeoCoder.prototype.find = function(place, cb){ 67440 var coder = this; 67441 request 67442 .get(apiUrl) 67443 .query(_.extend({ 67444 address: place 67445 }, this.queryData)) 67446 .end(function(res){ 67447 switch( res.body.status){ 67448 case 'OK': 67449 case 'ZERO_RESULTS': 67450 coder.lastResults = res.body; 67451 cb&&cb(null, 67452 GeoPlace.parseAddressResults( res.body.results), 67453 res.body 67454 ); 67455 break; 67456 default: 67457 cb&&cb(res.body); 67458 } 67459 }); 67460}; 67461 67462GeoCoder.prototype.reverseFind = function(lat, lng, cb){ 67463 var coder = this; 67464 request 67465 .get(apiUrl) 67466 .query(_.extend({ 67467 latlng: lat+','+lng 67468 }, this.queryData)) 67469 .end(function(res){ 67470 switch( res.body.status){ 67471 case 'OK': 67472 case 'ZERO_RESULTS': 67473 coder.lastResults = res.body; 67474 cb&&cb(null, 67475 GeoPlace.parseAddressResults( res.body.results), 67476 res.body 67477 ); 67478 break; 67479 default: 67480 cb&&cb(res.body); 67481 } 67482 }); 67483} 67484 67485 67486module.exports = function(options){ 67487 67488 if( !options || !options.hasOwnProperty('key')){ 67489 throw new Error('Property `key` required. Please register your app with google api and the api key here.'); 67490 } 67491 67492 return new GeoCoder(options.key); 67493}; 67494 67495module.exports.GeoCoder = GeoCoder; 67496module.exports.GeoPlace = GeoPlace; 67497 67498 67499/***/ }), 67500/* 234 */ 67501/***/ (function(module, exports, __webpack_require__) { 67502 67503var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;(function(root, factory) { 67504 67505 if (root === null) { 67506 throw new Error('Google-maps package can be used only in browser'); 67507 } 67508 67509 if (true) { 67510 !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory), 67511 __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? 67512 (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) : 67513 __WEBPACK_AMD_DEFINE_FACTORY__),
67514 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 67515 } else if (typeof exports === 'object') { 67516 module.exports = factory(); 67517 } else { 67518 root.GoogleMapsLoader = factory(); 67519 } 67520 67521})(typeof window !== 'undefined' ? window : null, function() { 67522 67523 67524 'use strict'; 67525 67526 67527 var googleVersion = '3.31'; 67528 67529 var script = null; 67530 67531 var google = null; 67532 67533 var loading = false; 67534 67535 var callbacks = []; 67536 67537 var onLoadEvents = []; 67538 67539 var originalCreateLoaderMethod = null; 67540 67541 67542 var GoogleMapsLoader = {}; 67543 67544 67545 GoogleMapsLoader.URL = 'https://maps.googleapis.com/maps/api/js'; 67546 67547 GoogleMapsLoader.KEY = null; 67548 67549 GoogleMapsLoader.LIBRARIES = []; 67550 67551 GoogleMapsLoader.CLIENT = null; 67552 67553 GoogleMapsLoader.CHANNEL = null; 67554 67555 GoogleMapsLoader.LANGUAGE = null; 67556 67557 GoogleMapsLoader.REGION = null; 67558 67559 GoogleMapsLoader.VERSION = googleVersion; 67560 67561 GoogleMapsLoader.WINDOW_CALLBACK_NAME = '__google_maps_api_provider_initializator__'; 67562 67563 67564 GoogleMapsLoader._googleMockApiObject = {}; 67565 67566 67567 GoogleMapsLoader.load = function(fn) { 67568 if (google === null) { 67569 if (loading === true) { 67570 if (fn) { 67571 callbacks.push(fn); 67572 } 67573 } else { 67574 loading = true; 67575 67576 window[GoogleMapsLoader.WINDOW_CALLBACK_NAME] = function() { 67577 ready(fn); 67578 }; 67579 67580 GoogleMapsLoader.createLoader(); 67581 } 67582 } else if (fn) { 67583 fn(google); 67584 } 67585 }; 67586 67587 67588 GoogleMapsLoader.createLoader = function() { 67589 script = document.createElement('script'); 67590 script.type = 'text/javascript'; 67591 script.src = GoogleMapsLoader.createUrl(); 67592 67593 document.body.appendChild(script); 67594 }; 67595 67596 67597 GoogleMapsLoader.isLoaded = function() { 67598 return google !== null; 67599 }; 67600 67601 67602 GoogleMapsLoader.createUrl = function() { 67603 var url = GoogleMapsLoader.URL; 67604 67605 url += '?callback=' + GoogleMapsLoader.WINDOW_CALLBACK_NAME; 67606 67607 if (GoogleMapsLoader.KEY) { 67608 url += '&key=' + GoogleMapsLoader.KEY; 67609 } 67610 67611 if (GoogleMapsLoader.LIBRARIES.length > 0) { 67612 url += '&libraries=' + GoogleMapsLoader.LIBRARIES.join(','); 67613 } 67614 67615 if (GoogleMapsLoader.CLIENT) { 67616 url += '&client=' + GoogleMapsLoader.CLIENT; 67617 } 67618 67619 if (GoogleMapsLoader.CHANNEL) { 67620 url += '&channel=' + GoogleMapsLoader.CHANNEL; 67621 } 67622 67623 if (GoogleMapsLoader.LANGUAGE) { 67624 url += '&language=' + GoogleMapsLoader.LANGUAGE; 67625 } 67626 67627 if (GoogleMapsLoader.REGION) { 67628 url += '®ion=' + GoogleMapsLoader.REGION; 67629 } 67630 67631 if (GoogleMapsLoader.VERSION) { 67632 url += '&v=' + GoogleMapsLoader.VERSION; 67633 } 67634 67635 return url; 67636 }; 67637 67638 67639 GoogleMapsLoader.release = function(fn) { 67640 var release = function() { 67641 GoogleMapsLoader.KEY = null; 67642 GoogleMapsLoader.LIBRARIES = []; 67643 GoogleMapsLoader.CLIENT = null; 67644 GoogleMapsLoader.CHANNEL = null; 67645 GoogleMapsLoader.LANGUAGE = null; 67646 GoogleMapsLoader.REGION = null; 67647 GoogleMapsLoader.VERSION = googleVersion; 67648 67649 google = null; 67650 loading = false; 67651 callbacks = []; 67652 onLoadEvents = []; 67653 67654 if (typeof window.google !== 'undefined') { 67655 delete window.google; 67656 } 67657 67658 if (typeof window[GoogleMapsLoader.WINDOW_CALLBACK_NAME] !== 'undefined') { 67659 delete window[GoogleMapsLoader.WINDOW_CALLBACK_NAME]; 67660 } 67661 67662 if (originalCreateLoaderMethod !== null) { 67663 GoogleMapsLoader.createLoader = originalCreateLoaderMethod; 67664 originalCreateLoaderMethod = null; 67665 } 67666 67667 if (script !== null) { 67668 script.parentElement.removeChild(script); 67669 script = null; 67670 } 67671 67672 if (fn) { 67673 fn(); 67674 } 67675 }; 67676 67677 if (loading) { 67678 GoogleMapsLoader.load(function() { 67679 release(); 67680 }); 67681 } else { 67682 release(); 67683 } 67684 }; 67685 67686 67687 GoogleMapsLoader.onLoad = function(fn) { 67688 onLoadEvents.push(fn); 67689 }; 67690 67691 67692 GoogleMapsLoader.makeMock = function() { 67693 originalCreateLoaderMethod = GoogleMapsLoader.createLoader; 67694 67695 GoogleMapsLoader.createLoader = function() { 67696 window.google = GoogleMapsLoader._googleMockApiObject; 67697 window[GoogleMapsLoader.WINDOW_CALLBACK_NAME](); 67698 }; 67699 }; 67700 67701 67702 var ready = function(fn) { 67703 var i; 67704 67705 loading = false; 67706 67707 if (google === null) { 67708 google = window.google; 67709 } 67710 67711 for (i = 0; i < onLoadEvents.length; i++) { 67712 onLoadEvents[i](google); 67713 } 67714 67715 if (fn) { 67716 fn(google); 67717 } 67718 67719 for (i = 0; i < callbacks.length; i++) { 67720 callbacks[i](google); 67721 } 67722 67723 callbacks = []; 67724 }; 67725 67726 67727 return GoogleMapsLoader; 67728 67729}); 67730 67731 67732/***/ }), 67733/* 235 */ 67734/***/ (function(module, __webpack_exports__, __webpack_require__) { 67735 67736"use strict"; 67737/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return TweenMax; }); 67738/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__ = __webpack_require__(3); 67739/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__TweenMaxBase_js__ = __webpack_require__(236); 67740/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__CSSPlugin_js__ = __webpack_require__(27); 67741/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__AttrPlugin_js__ = __webpack_require__(25); 67742/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__RoundPropsPlugin_js__ = __webpack_require__(30); 67743/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__DirectionalRotationPlugin_js__ = __webpack_require__(28); 67744/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__TimelineLite_js__ = __webpack_require__(15); 67745/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__TimelineMax_js__ = __webpack_require__(31); 67746/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__BezierPlugin_js__ = __webpack_require__(26); 67747/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__EasePack_js__ = __webpack_require__(29); 67748/* unused harmony reexport TweenLite */ 67749/* unused harmony reexport TimelineLite */ 67750/* unused harmony reexport TimelineMax */ 67751/* unused harmony reexport CSSPlugin */ 67752/* unused harmony reexport AttrPlugin */ 67753/* unused harmony reexport BezierPlugin */ 67754/* unused harmony reexport DirectionalRotationPlugin */ 67755/* unused harmony reexport RoundPropsPlugin */ 67756/* unused harmony reexport TweenPlugin */ 67757/* unused harmony reexport Ease */ 67758/* unused harmony reexport Power0 */ 67759/* unused harmony reexport Power1 */ 67760/* unused harmony reexport Power2 */ 67761/* unused harmony reexport Power3 */ 67762/* unused harmony reexport Power4 */ 67763/* unused harmony reexport Linear */ 67764/* unused harmony reexport Back */ 67765/* unused harmony reexport Elastic */ 67766/* unused harmony reexport Bounce */ 67767/* unused harmony reexport RoughEase */ 67768/* unused harmony reexport SlowMo */ 67769/* unused harmony reexport SteppedEase */ 67770/* unused harmony reexport Circ */ 67771/* unused harmony reexport Expo */ 67772/* unused harmony reexport Sine */ 67773/* unused harmony reexport ExpoScaleEase */ 67774/*! 67775 * VERSION: 2.0.1 67776 * DATE: 2018-05-30 67777 * UPDATES AND DOCS AT: http://greensock.com 67778 * 67779 * @license Copyright (c) 2008-2018, GreenSock. All rights reserved. 67780 * This work is subject to the terms at http://greensock.com/standard-license or for
67781 * Club GreenSock members, the software agreement that was issued with your membership. 67782 * 67783 * @author: Jack Doyle, [email protected] 67784 **/ 67785 67786 67787 67788 67789 67790 67791 67792 67793 67794 67795 67796 67797//the following two lines are designed to prevent tree shaking of the classes that were historically included with TweenMax (otherwise, folks would have to reference CSSPlugin, for example, to ensure their CSS-related animations worked) 67798const TweenMax = __WEBPACK_IMPORTED_MODULE_1__TweenMaxBase_js__["a" /* default */]; 67799/* unused harmony export TweenMax */ 67800 67801TweenMax._autoActivated = [__WEBPACK_IMPORTED_MODULE_6__TimelineLite_js__["a" /* default */], __WEBPACK_IMPORTED_MODULE_7__TimelineMax_js__["a" /* default */], __WEBPACK_IMPORTED_MODULE_2__CSSPlugin_js__["a" /* default */], __WEBPACK_IMPORTED_MODULE_3__AttrPlugin_js__["a" /* default */], __WEBPACK_IMPORTED_MODULE_8__BezierPlugin_js__["a" /* default */], __WEBPACK_IMPORTED_MODULE_4__RoundPropsPlugin_js__["a" /* default */], __WEBPACK_IMPORTED_MODULE_5__DirectionalRotationPlugin_js__["a" /* default */], __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["a" /* Back */], __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["b" /* Elastic */], __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["c" /* Bounce */], __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["d" /* RoughEase */], __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["e" /* SlowMo */], __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["f" /* SteppedEase */], __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["g" /* Circ */], __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["h" /* Expo */], __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["i" /* Sine */], __WEBPACK_IMPORTED_MODULE_9__EasePack_js__["j" /* ExpoScaleEase */]]; 67802 67803 67804 67805 67806 67807/***/ }), 67808/* 236 */ 67809/***/ (function(module, __webpack_exports__, __webpack_require__) { 67810 67811"use strict"; 67812/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return TweenMax; }); 67813/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__ = __webpack_require__(3); 67814/* unused harmony reexport TweenLite */ 67815/* unused harmony reexport Ease */ 67816/* unused harmony reexport Power0 */ 67817/* unused harmony reexport Power1 */ 67818/* unused harmony reexport Power2 */ 67819/* unused harmony reexport Power3 */ 67820/* unused harmony reexport Power4 */ 67821/* unused harmony reexport Linear */ 67822/*! 67823 * VERSION: 2.0.1 67824 * DATE: 2018-05-30 67825 * UPDATES AND DOCS AT: http://greensock.com 67826 * 67827 * @license Copyright (c) 2008-2018, GreenSock. All rights reserved. 67828 * This work is subject to the terms at http://greensock.com/standard-license or for 67829 * Club GreenSock members, the software agreement that was issued with your membership. 67830 * 67831 * @author: Jack Doyle, [email protected] 67832 **/ 67833 67834 67835 67836 67837__WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"]._gsDefine("TweenMax", ["core.Animation","core.SimpleTimeline","TweenLite"], function() { 67838 67839 var _slice = function(a) { //don't use [].slice because that doesn't work in IE8 with a NodeList that's returned by querySelectorAll() 67840 var b = [], 67841 l = a.length, 67842 i; 67843 for (i = 0; i !== l; b.push(a[i++])); 67844 return b; 67845 }, 67846 _applyCycle = function(vars, targets, i) { 67847 var alt = vars.cycle, 67848 p, val; 67849 for (p in alt) { 67850 val = alt[p]; 67851 vars[p] = (typeof(val) === "function") ? val(i, targets[i]) : val[i % val.length]; 67852 } 67853 delete vars.cycle; 67854 }, 67855 TweenMax = function(target, duration, vars) { 67856 __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].call(this, target, duration, vars); 67857 this._cycle = 0; 67858 this._yoyo = (this.vars.yoyo === true || !!this.vars.yoyoEase); 67859 this._repeat = this.vars.repeat || 0; 67860 this._repeatDelay = this.vars.repeatDelay || 0; 67861 if (this._repeat) { 67862 this._uncache(true); //ensures that if there is any repeat, the totalDuration will get recalculated to accurately report it. 67863 } 67864 this.render = TweenMax.prototype.render; //speed optimization (avoid prototype lookup on this "hot" method) 67865 }, 67866 _tinyNum = 0.0000000001, 67867 TweenLiteInternals = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"]._internals, 67868 _isSelector = TweenLiteInternals.isSelector, 67869 _isArray = TweenLiteInternals.isArray, 67870 p = TweenMax.prototype = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].to({}, 0.1, {}), 67871 _blankArray = []; 67872 67873 TweenMax.version = "2.0.1"; 67874 p.constructor = TweenMax; 67875 p.kill()._gc = false;
67876 TweenMax.killTweensOf = TweenMax.killDelayedCallsTo = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].killTweensOf; 67877 TweenMax.getTweensOf = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].getTweensOf; 67878 TweenMax.lagSmoothing = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].lagSmoothing; 67879 TweenMax.ticker = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].ticker; 67880 TweenMax.render = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].render; 67881 67882 p.invalidate = function() { 67883 this._yoyo = (this.vars.yoyo === true || !!this.vars.yoyoEase); 67884 this._repeat = this.vars.repeat || 0; 67885 this._repeatDelay = this.vars.repeatDelay || 0; 67886 this._yoyoEase = null; 67887 this._uncache(true); 67888 return __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].prototype.invalidate.call(this); 67889 }; 67890 67891 p.updateTo = function(vars, resetDuration) { 67892 var curRatio = this.ratio, 67893 immediate = this.vars.immediateRender || vars.immediateRender, 67894 p; 67895 if (resetDuration && this._startTime < this._timeline._time) { 67896 this._startTime = this._timeline._time; 67897 this._uncache(false); 67898 if (this._gc) { 67899 this._enabled(true, false); 67900 } else { 67901 this._timeline.insert(this, this._startTime - this._delay); //ensures that any necessary re-sequencing of Animations in the timeline occurs to make sure the rendering order is correct. 67902 } 67903 } 67904 for (p in vars) { 67905 this.vars[p] = vars[p]; 67906 } 67907 if (this._initted || immediate) { 67908 if (resetDuration) { 67909 this._initted = false; 67910 if (immediate) { 67911 this.render(0, true, true); 67912 } 67913 } else { 67914 if (this._gc) { 67915 this._enabled(true, false); 67916 } 67917 if (this._notifyPluginsOfEnabled && this._firstPT) { 67918 __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"]._onPluginEvent("_onDisable", this); //in case a plugin like MotionBlur must perform some cleanup tasks 67919 } 67920 if (this._time / this._duration > 0.998) { //if the tween has finished (or come extremely close to finishing), we just need to rewind it to 0 and then render it again at the end which forces it to re-initialize (parsing the new vars). We allow tweens that are close to finishing (but haven't quite finished) to work this way too because otherwise, the values are so small when determining where to project the starting values that binary math issues creep in and can make the tween appear to render incorrectly when run backwards. 67921 var prevTime = this._totalTime; 67922 this.render(0, true, false); 67923 this._initted = false; 67924 this.render(prevTime, true, false); 67925 } else { 67926 this._initted = false; 67927 this._init(); 67928 if (this._time > 0 || immediate) { 67929 var inv = 1 / (1 - curRatio), 67930 pt = this._firstPT, endValue; 67931 while (pt) { 67932 endValue = pt.s + pt.c; 67933 pt.c *= inv; 67934 pt.s = endValue - pt.c; 67935 pt = pt._next; 67936 } 67937 } 67938 } 67939 } 67940 } 67941 return this; 67942 }; 67943 67944 p.render = function(time, suppressEvents, force) { 67945 if (!this._initted) if (this._duration === 0 && this.vars.repeat) { //zero duration tweens that render immediately have render() called from TweenLite's constructor, before TweenMax's constructor has finished setting _repeat, _repeatDelay, and _yoyo which are critical in determining totalDuration() so we need to call invalidate() which is a low-kb way to get those set properly. 67946 this.invalidate(); 67947 } 67948 var totalDur = (!this._dirty) ? this._totalDuration : this.totalDuration(), 67949 prevTime = this._time, 67950 prevTotalTime = this._totalTime, 67951 prevCycle = this._cycle, 67952 duration = this._duration, 67953 prevRawPrevTime = this._rawPrevTime, 67954 isComplete, callback, pt, cycleDuration, r, type, pow, rawPrevTime, yoyoEase; 67955 if (time >= totalDur - 0.0000001 && time >= 0) { //to work around occasional floating point math artifacts. 67956 this._totalTime = totalDur; 67957 this._cycle = this._repeat; 67958 if (this._yoyo && (this._cycle & 1) !== 0) { 67959 this._time = 0; 67960 this.ratio = this._ease._calcEnd ? this._ease.getRatio(0) : 0; 67961 } else { 67962 this._time = duration; 67963 this.ratio = this._ease._calcEnd ? this._ease.getRatio(1) : 1; 67964 } 67965 if (!this._reversed) { 67966 isComplete = true; 67967 callback = "onComplete"; 67968 force = (force || this._timeline.autoRemoveChildren); //otherwise, if the animation is unpaused/activated after it's already finished, it doesn't get removed from the parent timeline. 67969 } 67970 if (duration === 0) if (this._initted || !this.vars.lazy || force) { //zero-duration tweens are tricky because we must discern the momentum/direction of time in order to determine whether the starting values should be rendered or the ending values. If the "playhead" of its timeline goes past the zero-duration tween in the forward direction or lands directly on it, the end values should be rendered, but if the timeline's "playhead" moves past it in the backward direction (from a postitive time to a negative time), the starting values must be rendered. 67971 if (this._startTime === this._timeline._duration) { //if a zero-duration tween is at the VERY end of a timeline and that timeline renders at its end, it will typically add a tiny bit of cushion to the render time to prevent roun
67971ding errors from getting in the way of tweens rendering their VERY end. If we then reverse() that timeline, the zero-duration tween will trigger its onReverseComplete even though technically the playhead didn't pass over it again. It's a very specific edge case we must accommodate. 67972 time = 0; 67973 } 67974 if (prevRawPrevTime < 0 || (time <= 0 && time >= -0.0000001) || (prevRawPrevTime === _tinyNum && this.data !== "isPause")) if (prevRawPrevTime !== time) { //note: when this.data is "isPause", it's a callback added by addPause() on a timeline that we should not be triggered when LEAVING its exact start time. In other words, tl.addPause(1).play(1) shouldn't pause. 67975 force = true; 67976 if (prevRawPrevTime > _tinyNum) { 67977 callback = "onReverseComplete"; 67978 } 67979 } 67980 this._rawPrevTime = rawPrevTime = (!suppressEvents || time || prevRawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. 67981 } 67982 67983 } else if (time < 0.0000001) { //to work around occasional floating point math artifacts, round super small values to 0. 67984 this._totalTime = this._time = this._cycle = 0; 67985 this.ratio = this._ease._calcEnd ? this._ease.getRatio(0) : 0; 67986 if (prevTotalTime !== 0 || (duration === 0 && prevRawPrevTime > 0)) { 67987 callback = "onReverseComplete"; 67988 isComplete = this._reversed; 67989 } 67990 if (time < 0) { 67991 this._active = false; 67992 if (duration === 0) if (this._initted || !this.vars.lazy || force) { //zero-duration tweens are tricky because we must discern the momentum/direction of time in order to determine whether the starting values should be rendered or the ending values. If the "playhead" of its timeline goes past the zero-duration tween in the forward direction or lands directly on it, the end values should be rendered, but if the timeline's "playhead" moves past it in the backward direction (from a postitive time to a negative time), the starting values must be rendered. 67993 if (prevRawPrevTime >= 0) { 67994 force = true; 67995 } 67996 this._rawPrevTime = rawPrevTime = (!suppressEvents || time || prevRawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. 67997 } 67998 } 67999 if (!this._initted) { //if we render the very beginning (time == 0) of a fromTo(), we must force the render (normal tweens wouldn't need to render at a time of 0 when the prevTime was also 0). This is also mandatory to make sure overwriting kicks in immediately. 68000 force = true; 68001 } 68002 } else { 68003 this._totalTime = this._time = time; 68004 if (this._repeat !== 0) { 68005 cycleDuration = duration + this._repeatDelay; 68006 this._cycle = (this._totalTime / cycleDuration) >> 0; //originally _totalTime % cycleDuration but floating point errors caused problems, so I normalized it. (4 % 0.8 should be 0 but some browsers report it as 0.79999999!) 68007 if (this._cycle !== 0) if (this._cycle === this._totalTime / cycleDuration && prevTotalTime <= time) { 68008 this._cycle--; //otherwise when rendered exactly at the end time, it will act as though it is repeating (at the beginning) 68009 } 68010 this._time = this._totalTime - (this._cycle * cycleDuration); 68011 if (this._yoyo) if ((this._cycle & 1) !== 0) { 68012 this._time = duration - this._time; 68013 yoyoEase = this._yoyoEase || this.vars.yoyoEase; //note: we don't set this._yoyoEase in _init() like we do other properties because it's TweenMax-specific and doing it here allows us to optimize performance (most tweens don't have a yoyoEase). Note that we also must skip the this.ratio calculation further down right after we _init() in this function, because we're doing it here. 68014 if (yoyoEase) { 68015 if (!this._yoyoEase) { 68016 if (yoyoEase === true && !this._initted) { //if it's not initted and yoyoEase is true, this._ease won't have been populated yet so we must discern it here. 68017 yoyoEase = this.vars.ease; 68018 this._yoyoEase = yoyoEase = !yoyoEase ? __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].defaultEase : (yoyoEase instanceof __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Ease"]) ? yoyoEase : (typeof(yoyoEase) === "function") ? new __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Ease"](yoyoEase, this.vars.easeParams) : __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Ease"].map[yoyoEase] || __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].defaultEase; 68019 } else { 68020 this._yoyoEase = yoyoEase = (yoyoEase === true) ? this._ease : (yoyoEase instanceof __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Ease"]) ? yoyoEase : __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Ease"].map[yoyoEase]; 68021 } 68022 } 68023 this.ratio = yoyoEase ? 1 - yoyoEase.getRatio((duration - this._time) / duration) : 0; 68024 } 68025 } 68026 if (this._time > duration) { 68027 this._time = duration; 68028 } else if (this._time < 0) { 68029 this._time = 0; 68030 } 68031 } 68032 if (this._easeType && !yoyoEase) { 68033 r = this._time / duration; 68034 type = this._easeType; 68035 pow = this._easePower; 68036 if (type === 1 || (type === 3 && r >= 0.5)) { 68037 r = 1 - r; 68038 } 68039 if (type === 3) { 68040 r *= 2; 68041 } 68042 if (pow === 1) { 68043 r *= r; 68044 } else if (pow === 2) { 68045 r *= r * r; 68046 } else if (pow === 3) { 68047 r *= r * r * r; 68048 } else if (pow === 4) { 68049 r *= r * r * r * r; 68050 } 68051 68052 if (type === 1) { 68053 this.ratio = 1 - r; 68054 } else if (type === 2) { 68055 this.ratio = r; 68056 } else if (this._time / duration < 0.5) { 68057 this.ratio = r / 2; 68058 } else { 68059 this.ratio = 1 - (r / 2); 68060 } 68061 68062 } else if (!yoyoEase) { 68063 this.ratio = this._ease.getRatio(this._time / duration); 68064 } 68065 68066 } 68067 68068 if (prevTime === this._time && !force && prevCycle === this._cycle) { 68069 if (prevTotalTime !== this._totalTime) if (this._onUpdate) if (!suppressEvents) { //so that onUp
68069date fires even during the repeatDelay - as long as the totalTime changed, we should trigger onUpdate. 68070 this._callback("onUpdate"); 68071 } 68072 return; 68073 } else if (!this._initted) { 68074 this._init(); 68075 if (!this._initted || this._gc) { //immediateRender tweens typically won't initialize until the playhead advances (_time is greater than 0) in order to ensure that overwriting occurs properly. Also, if all of the tweening properties have been overwritten (which would cause _gc to be true, as set in _init()), we shouldn't continue otherwise an onStart callback could be called for example. 68076 return; 68077 } else if (!force && this._firstPT && ((this.vars.lazy !== false && this._duration) || (this.vars.lazy && !this._duration))) { //we stick it in the queue for rendering at the very end of the tick - this is a performance optimization because browsers invalidate styles and force a recalculation if you read, write, and then read style data (so it's better to read/read/read/write/write/write than read/write/read/write/read/write). The down side, of course, is that usually you WANT things to render immediately because you may have code running right after that which depends on the change. Like imagine running TweenLite.set(...) and then immediately after that, creating a nother tween that animates the same property to another value; the starting values of that 2nd tween wouldn't be accurate if lazy is true. 68078 this._time = prevTime; 68079 this._totalTime = prevTotalTime; 68080 this._rawPrevTime = prevRawPrevTime; 68081 this._cycle = prevCycle; 68082 TweenLiteInternals.lazyTweens.push(this); 68083 this._lazy = [time, suppressEvents]; 68084 return; 68085 } 68086 //_ease is initially set to defaultEase, so now that init() has run, _ease is set properly and we need to recalculate the ratio. Overall this is faster than using conditional logic earlier in the method to avoid having to set ratio twice because we only init() once but renderTime() gets called VERY frequently. 68087 if (this._time && !isComplete && !yoyoEase) { 68088 this.ratio = this._ease.getRatio(this._time / duration); 68089 } else if (isComplete && this._ease._calcEnd && !yoyoEase) { 68090 this.ratio = this._ease.getRatio((this._time === 0) ? 0 : 1); 68091 } 68092 } 68093 if (this._lazy !== false) { 68094 this._lazy = false; 68095 } 68096 68097 if (!this._active) if (!this._paused && this._time !== prevTime && time >= 0) { 68098 this._active = true; //so that if the user renders a tween (as opposed to the timeline rendering it), the timeline is forced to re-render and align it with the proper time/frame on the next rendering cycle. Maybe the tween already finished but the user manually re-renders it as halfway done. 68099 } 68100 if (prevTotalTime === 0) { 68101 if (this._initted === 2 && time > 0) { 68102 //this.invalidate(); 68103 this._init(); //will just apply overwriting since _initted of (2) means it was a from() tween that had immediateRender:true 68104 } 68105 if (this._startAt) { 68106 if (time >= 0) { 68107 this._startAt.render(time, true, force); 68108 } else if (!callback) { 68109 callback = "_dummyGS"; //if no callback is defined, use a dummy value just so that the condition at the end evaluates as true because _startAt should render AFTER the normal render loop when the time is negative. We could handle this in a more intuitive way, of course, but the render loop is the MOST important thing to optimize, so this technique allows us to avoid adding extra conditional logic in a high-frequency area. 68110 } 68111 } 68112 if (this.vars.onStart) if (this._totalTime !== 0 || duration === 0) if (!suppressEvents) { 68113 this._callback("onStart"); 68114 } 68115 } 68116 68117 pt = this._firstPT; 68118 while (pt) { 68119 if (pt.f) { 68120 pt.t[pt.p](pt.c * this.ratio + pt.s); 68121 } else { 68122 pt.t[pt.p] = pt.c * this.ratio + pt.s; 68123 } 68124 pt = pt._next; 68125 } 68126 68127 if (this._onUpdate) { 68128 if (time < 0) if (this._startAt && this._startTime) { //if the tween is positioned at the VERY beginning (_startTime 0) of its parent timeline, it's illegal for the playhead to go back further, so we should not render the recorded startAt values. 68129 this._startAt.render(time, true, force); //note: for performance reasons, we tuck this conditional logic inside less traveled areas (most tweens don't have an onUpdate). We'd just have it at the end before the onComplete, but the values should be updated before any onUpdate is called, so we ALSO put it here and then if it's not called, we do so later near the onComplete. 68130 } 68131 if (!suppressEvents) if (this._totalTime !== prevTotalTime || callback) {
68132 this._callback("onUpdate"); 68133 } 68134 } 68135 if (this._cycle !== prevCycle) if (!suppressEvents) if (!this._gc) if (this.vars.onRepeat) { 68136 this._callback("onRepeat"); 68137 } 68138 if (callback) if (!this._gc || force) { //check gc because there's a chance that kill() could be called in an onUpdate 68139 if (time < 0 && this._startAt && !this._onUpdate && this._startTime) { //if the tween is positioned at the VERY beginning (_startTime 0) of its parent timeline, it's illegal for the playhead to go back further, so we should not render the recorded startAt values. 68140 this._startAt.render(time, true, force); 68141 } 68142 if (isComplete) { 68143 if (this._timeline.autoRemoveChildren) { 68144 this._enabled(false, false); 68145 } 68146 this._active = false; 68147 } 68148 if (!suppressEvents && this.vars[callback]) { 68149 this._callback(callback); 68150 } 68151 if (duration === 0 && this._rawPrevTime === _tinyNum && rawPrevTime !== _tinyNum) { //the onComplete or onReverseComplete could trigger movement of the playhead and for zero-duration tweens (which must discern direction) that land directly back on their start time, we don't want to fire again on the next render. Think of several addPause()'s in a timeline that forces the playhead to a certain spot, but what if it's already paused and another tween is tweening the "time" of the timeline? Each time it moves [forward] past that spot, it would move back, and since suppressEvents is true, it'd reset _rawPrevTime to _tinyNum so that when it begins again, the callback would fire (so ultimately it could bounce back and forth during that tween). Again, this is a very uncommon sce
68151nario, but possible nonetheless. 68152 this._rawPrevTime = 0; 68153 } 68154 } 68155 }; 68156 68157//---- STATIC FUNCTIONS ----------------------------------------------------------------------------------------------------------- 68158 68159 TweenMax.to = function(target, duration, vars) { 68160 return new TweenMax(target, duration, vars); 68161 }; 68162 68163 TweenMax.from = function(target, duration, vars) { 68164 vars.runBackwards = true; 68165 vars.immediateRender = (vars.immediateRender != false); 68166 return new TweenMax(target, duration, vars); 68167 }; 68168 68169 TweenMax.fromTo = function(target, duration, fromVars, toVars) { 68170 toVars.startAt = fromVars; 68171 toVars.immediateRender = (toVars.immediateRender != false && fromVars.immediateRender != false); 68172 return new TweenMax(target, duration, toVars); 68173 }; 68174 68175 TweenMax.staggerTo = TweenMax.allTo = function(targets, duration, vars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope) { 68176 stagger = stagger || 0; 68177 var delay = 0, 68178 a = [], 68179 finalComplete = function() { 68180 if (vars.onComplete) { 68181 vars.onComplete.apply(vars.onCompleteScope || this, arguments); 68182 } 68183 onCompleteAll.apply(onCompleteAllScope || vars.callbackScope || this, onCompleteAllParams || _blankArray); 68184 }, 68185 cycle = vars.cycle, 68186 fromCycle = (vars.startAt && vars.startAt.cycle), 68187 l, copy, i, p; 68188 if (!_isArray(targets)) { 68189 if (typeof(targets) === "string") { 68190 targets = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].selector(targets) || targets; 68191 } 68192 if (_isSelector(targets)) { 68193 targets = _slice(targets); 68194 } 68195 } 68196 targets = targets || []; 68197 if (stagger < 0) { 68198 targets = _slice(targets); 68199 targets.reverse(); 68200 stagger *= -1; 68201 } 68202 l = targets.length - 1; 68203 for (i = 0; i <= l; i++) { 68204 copy = {}; 68205 for (p in vars) { 68206 copy[p] = vars[p]; 68207 } 68208 if (cycle) { 68209 _applyCycle(copy, targets, i); 68210 if (copy.duration != null) { 68211 duration = copy.duration; 68212 delete copy.duration; 68213 } 68214 } 68215 if (fromCycle) { 68216 fromCycle = copy.startAt = {}; 68217 for (p in vars.startAt) { 68218 fromCycle[p] = vars.startAt[p]; 68219 } 68220 _applyCycle(copy.startAt, targets, i); 68221 } 68222 copy.delay = delay + (copy.delay || 0); 68223 if (i === l && onCompleteAll) { 68224 copy.onComplete = finalComplete; 68225 } 68226 a[i] = new TweenMax(targets[i], duration, copy); 68227 delay += stagger; 68228 } 68229 return a; 68230 }; 68231 68232 TweenMax.staggerFrom = TweenMax.allFrom = function(targets, duration, vars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope) { 68233 vars.runBackwards = true; 68234 vars.immediateRender = (vars.immediateRender != false); 68235 return TweenMax.staggerTo(targets, duration, vars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope); 68236 }; 68237 68238 TweenMax.staggerFromTo = TweenMax.allFromTo = function(targets, duration, fromVars, toVars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope) { 68239 toVars.startAt = fromVars; 68240 toVars.immediateRender = (toVars.immediateRender != false && fromVars.immediateRender != false); 68241 return TweenMax.staggerTo(targets, duration, toVars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope); 68242 }; 68243 68244 TweenMax.delayedCall = function(delay, callback, params, scope, useFrames) { 68245 return new TweenMax(callback, 0, {delay:delay, onComplete:callback, onCompleteParams:params, callbackScope:scope, onReverseComplete:callback, onReverseCompleteParams:params, immediateRender:false, useFrames:useFrames, overwrite:0}); 68246 }; 68247 68248 TweenMax.set = function(target, vars) { 68249 return new TweenMax(target, 0, vars); 68250 }; 68251 68252 TweenMax.isTweening = function(target) { 68253 return (__WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].getTweensOf(target, true).length > 0); 68254 }; 68255 68256 var _getChildrenOf = function(timeline, includeTimelines) { 68257 var a = [], 68258 cnt = 0, 68259 tween = timeline._first; 68260 while (tween) { 68261 if (tween instanceof __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"]) { 68262 a[cnt++] = tween; 68263 } else { 68264 if (includeTimelines) { 68265 a[cnt++] = tween; 68266 } 68267 a = a.concat(_getChildrenOf(tween, includeTimelines)); 68268 cnt = a.length; 68269 } 68270 tween = tween._next; 68271 } 68272 return a; 68273 }, 68274 getAllTweens = TweenMax.getAllTweens = function(includeTimelines) { 68275 return _getChildrenOf(__WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Animation"]._rootTimeline, includeTimelines).concat( _getChildrenOf(__WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Animation"]._rootFramesTimeline, includeTimelines) ); 68276 }; 68277 68278 TweenMax.killAll = function(complete, tweens, delayedCalls, timelines) { 68279 if (tweens == null) { 68280 tweens = true; 68281 } 68282 if (delayedCalls == null) { 68283 delayedCalls = true; 68284 } 68285 var a = getAllTweens((timelines != false)), 68286 l = a.length, 68287 allTrue = (tweens && delayedCalls && timelines), 68288 isDC, tween, i; 68289 for (i = 0; i < l; i++) { 68290 tween = a[i]; 68291 if (allTrue || (tween instanceof __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["SimpleTimeline"]) || ((isDC = (tween.target === tween.vars.onComplete)) && delayedCalls) || (tweens && !isDC)) { 68292 if (complete) { 68293 tween.totalTime(tween._reversed ? 0 : tween.totalDuration()); 68294 } else { 68295 tween._enabled(false, false); 68296 } 68297 } 68298 } 68299 }; 68300 68301 TweenMax.killChildTweensOf = function(parent, complete) { 68302 if (parent == null) { 68303 return; 68304 } 68305 var tl = TweenLiteInternals.tweenLookup, 68306 a, curParent, p, i, l; 68307 if (typeof(parent) === "string") { 68308 parent = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].selector(parent) || parent; 68309 } 68310 if (_isSelector(parent)) { 68311 parent = _slice(parent); 68312 } 68313 if (_isArray(parent)) { 68314 i = parent.length; 68315 while (--i > -1) { 68316 TweenMax.killChildTweensOf(parent[i], complete); 68317 } 68318 return; 68319 } 68320 a = []; 68321 for (p in tl) { 68322 curParent = tl[p].target.parentNode; 68323 while (curParent) { 68324 if (curParent === parent) { 68325 a = a.concat(tl[p].tweens); 68326 } 68327 curParent = curParent.parentNode; 68328 } 68329 } 68330 l = a.length; 68331 for (i = 0; i < l; i++) { 68332 if (complete) { 68333 a[i].totalTime(a[i].totalDuration()); 68334 } 68335 a[i]._enabled(false, false); 68336 } 68337 }; 68338 68339 var _changePause = function(pause, tweens, delayedCalls, timelines) { 68340 tweens = (tweens !== false); 68341 delayedCalls = (delayedCalls !== false); 68342 timelines = (timelines !== false); 68343 var a = getAllTweens(timelines), 68344 allTrue = (tweens && delayedCalls && timelines), 68345 i = a.length, 68346 isDC, tween; 68347 while (--i > -1) { 68348 tween = a[i]; 68349 if (allTrue || (tween instanceof __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["SimpleTimeline"]) || ((isDC = (tween.target === tween.vars.onComplete)) && delayedCalls) || (tweens && !isDC)) { 68350 tween.paused(pause); 68351 } 68352 } 68353 }; 68354 68355 TweenMax.pauseAll = function(tweens, delayedCalls, timelines) { 68356 _changePause(true, tweens, delayedCalls, timelines); 68357 }; 68358 68359 TweenMax.resumeAll = function(tweens, delayedCalls, timelines) { 68360 _changePause(false, tweens, delayedCalls, timelines); 68361 }; 68362 68363 TweenMax.globalTimeScale = function(value) { 68364 var tl = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Animation"]._rootTimeline, 68365 t = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].ticker.time; 68366 if (!arguments.length) { 68367 return tl._timeScale; 68368 } 68369 value = value || _tinyNum; //can't allow zero because it'll throw the math off 68370 tl._startTime = t - ((t - tl._startTime) * tl._timeScale / value); 68371 tl = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Animation"]._rootFramesTimeline; 68372 t = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["default"].ticker.frame; 68373 tl._startTime = t - ((t - tl._startTime) * tl._timeScale / value); 68374 tl._timeScale = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Animation"]._rootTimeline._timeScale = value; 68375 return value; 68376 }; 68377 68378 68379//---- GETTERS / SETTERS ---------------------------------------------------------------------------------------------------------- 68380 68381 p.progress = function(value, suppressEvents) { 68382 return (!arguments.length) ? this._time / this.duration() : this.totalTime( this.duration() * ((this._yoyo && (this._cycle & 1) !== 0) ? 1 - value : value) + (this._cycle * (this._duration + this._repeatDelay)), suppressEvents); 68383 }; 68384 68385 p.totalProgress = function(value, suppressEvents) { 68386 return (!arguments.length) ? this._totalTime / this.totalDuration() : this.totalTime( this.totalDuration() * value, suppressEvents); 68387 }; 68388 68389 p.time = function(value, suppressEvents) { 68390 if (!arguments.length) { 68391 return this._time; 68392 } 68393 if (this._dirty) { 68394 this.totalDuration(); 68395 } 68396 if (value > this._duration) { 68397 value = this._duration; 68398 } 68399 if (this._yoyo && (this._cycle & 1) !== 0) { 68400 value = (this._duration - value) + (this._cycle * (this._duration + this._repeatDelay)); 68401 } else if (this._repeat !== 0) { 68402 value += this._cycle * (this._duration + this._repeatDelay); 68403 } 68404 return this.totalTime(value, suppressEvents); 68405 }; 68406 68407 p.duration = function(value) { 68408 if (!arguments.length) { 68409 return this._duration; //don't set _dirty = false because there could be repeats that haven't been factored
68409into the _totalDuration yet. Otherwise, if you create a repeated TweenMax and then immediately check its duration(), it would cache the value and the totalDuration would not be correct, thus repeats wouldn't take effect. 68410 } 68411 return __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["Animation"].prototype.duration.call(this, value); 68412 }; 68413 68414 p.totalDuration = function(value) { 68415 if (!arguments.length) { 68416 if (this._dirty) { 68417 //instead of Infinity, we use 999999999999 so that we can accommodate reverses 68418 this._totalDuration = (this._repeat === -1) ? 999999999999 : this._duration * (this._repeat + 1) + (this._repeatDelay * this._repeat); 68419 this._dirty = false; 68420 } 68421 return this._totalDuration; 68422 } 68423 return (this._repeat === -1) ? this : this.duration( (value - (this._repeat * this._repeatDelay)) / (this._repeat + 1) ); 68424 }; 68425 68426 p.repeat = function(value) { 68427 if (!arguments.length) { 68428 return this._repeat; 68429 } 68430 this._repeat = value; 68431 return this._uncache(true); 68432 }; 68433 68434 p.repeatDelay = function(value) { 68435 if (!arguments.length) { 68436 return this._repeatDelay; 68437 } 68438 this._repeatDelay = value; 68439 return this._uncache(true); 68440 }; 68441 68442 p.yoyo = function(value) { 68443 if (!arguments.length) { 68444 return this._yoyo; 68445 } 68446 this._yoyo = value; 68447 return this; 68448 }; 68449 68450 68451 return TweenMax; 68452 68453 }, true); 68454 68455const TweenMax = __WEBPACK_IMPORTED_MODULE_0__TweenLite_js__["_gsScope"].TweenMax; 68456/* unused harmony export TweenMax */ 68457 68458const TweenMaxBase = TweenMax; 68459/* unused harmony export TweenMaxBase */ 68460 68461 68462 68463 68464 68465/***/ }), 68466/* 237 */ 68467/***/ (function(module, exports, __webpack_require__) { 68468 68469var map = { 68470 "./af": 32, 68471 "./af.js": 32, 68472 "./ar": 39, 68473 "./ar-dz": 33, 68474 "./ar-dz.js": 33, 68475 "./ar-kw": 34, 68476 "./ar-kw.js": 34, 68477 "./ar-ly": 35, 68478 "./ar-ly.js": 35, 68479 "./ar-ma": 36, 68480 "./ar-ma.js": 36, 68481 "./ar-sa": 37, 68482 "./ar-sa.js": 37, 68483 "./ar-tn": 38, 68484 "./ar-tn.js": 38, 68485 "./ar.js": 39, 68486 "./az": 40, 68487 "./az.js": 40, 68488 "./be": 41, 68489 "./be.js": 41, 68490 "./bg": 42, 68491 "./bg.js": 42, 68492 "./bm": 43, 68493 "./bm.js": 43, 68494 "./bn": 44, 68495 "./bn.js": 44, 68496 "./bo": 45, 68497 "./bo.js": 45, 68498 "./br": 46, 68499 "./br.js": 46, 68500 "./bs": 47, 68501 "./bs.js": 47, 68502 "./ca": 48, 68503 "./ca.js": 48, 68504 "./cs": 49, 68505 "./cs.js": 49, 68506 "./cv": 50, 68507 "./cv.js": 50, 68508 "./cy": 51, 68509 "./cy.js": 51, 68510 "./da": 52, 68511 "./da.js": 52, 68512 "./de": 55, 68513 "./de-at": 53, 68514 "./de-at.js": 53, 68515 "./de-ch": 54, 68516 "./de-ch.js": 54, 68517 "./de.js": 55, 68518 "./dv": 56, 68519 "./dv.js": 56, 68520 "./el": 57, 68521 "./el.js": 57, 68522 "./en-au": 58, 68523 "./en-au.js": 58, 68524 "./en-ca": 59, 68525 "./en-ca.js": 59, 68526 "./en-gb": 60, 68527 "./en-gb.js": 60, 68528 "./en-ie": 61, 68529 "./en-ie.js": 61, 68530 "./en-il": 62, 68531 "./en-il.js": 62, 68532 "./en-nz": 63, 68533 "./en-nz.js": 63, 68534 "./eo": 64, 68535 "./eo.js": 64, 68536 "./es": 67, 68537 "./es-do": 65, 68538 "./es-do.js": 65, 68539 "./es-us": 66, 68540 "./es-us.js": 66, 68541 "./es.js": 67, 68542 "./et": 68, 68543 "./et.js": 68, 68544 "./eu": 69, 68545 "./eu.js": 69, 68546 "./fa": 70, 68547 "./fa.js": 70, 68548 "./fi": 71, 68549 "./fi.js": 71, 68550 "./fo": 72, 68551 "./fo.js": 72, 68552 "./fr": 75, 68553 "./fr-ca": 73, 68554 "./fr-ca.js": 73, 68555 "./fr-ch": 74, 68556 "./fr-ch.js": 74, 68557 "./fr.js": 75, 68558 "./fy": 76, 68559 "./fy.js": 76, 68560 "./gd": 77, 68561 "./gd.js": 77, 68562 "./gl": 78, 68563 "./gl.js": 78, 68564 "./gom-latn": 79, 68565 "./gom-latn.js": 79, 68566 "./gu": 80, 68567 "./gu.js": 80, 68568 "./he": 81, 68569 "./he.js": 81, 68570 "./hi": 82, 68571 "./hi.js": 82, 68572 "./hr": 83, 68573 "./hr.js": 83, 68574 "./hu": 84, 68575 "./hu.js": 84, 68576 "./hy-am": 85, 68577 "./hy-am.js": 85, 68578 "./id": 86, 68579 "./id.js": 86, 68580 "./is": 87, 68581 "./is.js": 87, 68582 "./it": 88, 68583 "./it.js": 88, 68584 "./ja": 89, 68585 "./ja.js": 89, 68586 "./jv": 90, 68587 "./jv.js": 90, 68588 "./ka": 91, 68589 "./ka.js": 91, 68590 "./kk": 92, 68591 "./kk.js": 92, 68592 "./km": 93, 68593 "./km.js": 93, 68594 "./kn": 94, 68595 "./kn.js": 94, 68596 "./ko": 95, 68597 "./ko.js": 95, 68598 "./ky": 96, 68599 "./ky.js": 96, 68600 "./lb": 97, 68601 "./lb.js": 97, 68602 "./lo": 98, 68603 "./lo.js": 98, 68604 "./lt": 99, 68605 "./lt.js": 99, 68606 "./lv": 100, 68607 "./lv.js": 100, 68608 "./me": 101, 68609 "./me.js": 101, 68610 "./mi": 102, 68611 "./mi.js": 102, 68612 "./mk": 103, 68613 "./mk.js": 103, 68614 "./ml": 104, 68615 "./ml.js": 104, 68616 "./mn": 105, 68617 "./mn.js": 105, 68618 "./mr": 106, 68619 "./mr.js": 106, 68620 "./ms": 108, 68621 "./ms-my": 107, 68622 "./ms-my.js": 107, 68623 "./ms.js": 108, 68624 "./mt": 109, 68625 "./mt.js": 109, 68626 "./my": 110, 68627 "./my.js": 110, 68628 "./nb": 111, 68629 "./nb.js": 111, 68630 "./ne": 112, 68631 "./ne.js": 112, 68632 "./nl": 114, 68633 "./nl-be": 113, 68634 "./nl-be.js": 113, 68635 "./nl.js": 114, 68636 "./nn": 115, 68637 "./nn.js": 115, 68638 "./pa-in": 116, 68639 "./pa-in.js": 116, 68640 "./pl": 117, 68641 "./pl.js": 117, 68642 "./pt": 119, 68643 "./pt-br": 118, 68644 "./pt-br.js": 118, 68645 "./pt.js": 119, 68646 "./ro": 120, 68647 "./ro.js": 120, 68648 "./ru": 121, 68649 "./ru.js": 121, 68650 "./sd": 122, 68651 "./sd.js": 122, 68652 "./se": 123, 68653 "./se.js": 123, 68654 "./si": 124, 68655 "./si.js": 124, 68656 "./sk": 125, 68657 "./sk.js": 125, 68658 "./sl": 126, 68659 "./sl.js": 126, 68660 "./sq": 127, 68661 "./sq.js": 127, 68662 "./sr": 129, 68663 "./sr-cyrl": 128, 68664 "./sr-cyrl.js": 128, 68665 "./sr.js": 129, 68666 "./ss": 130, 68667 "./ss.js": 130, 68668 "./sv": 131, 68669 "./sv.js": 131, 68670 "./sw": 132, 68671 "./sw.js": 132, 68672 "./ta": 133, 68673 "./ta.js": 133, 68674 "./te": 134, 68675 "./te.js": 134, 68676 "./tet": 135, 68677 "./tet.js": 135, 68678 "./tg": 136, 68679 "./tg.js": 136, 68680 "./th": 137, 68681 "./th.js": 137, 68682 "./tl-ph": 138, 68683 "./tl-ph.js": 138, 68684 "./tlh": 139, 68685 "./tlh.js": 139,
68686 "./tr": 140, 68687 "./tr.js": 140, 68688 "./tzl": 141, 68689 "./tzl.js": 141, 68690 "./tzm": 143, 68691 "./tzm-latn": 142, 68692 "./tzm-latn.js": 142, 68693 "./tzm.js": 143, 68694 "./ug-cn": 144, 68695 "./ug-cn.js": 144, 68696 "./uk": 145, 68697 "./uk.js": 145, 68698 "./ur": 146, 68699 "./ur.js": 146, 68700 "./uz": 148, 68701 "./uz-latn": 147, 68702 "./uz-latn.js": 147, 68703 "./uz.js": 148, 68704 "./vi": 149, 68705 "./vi.js": 149, 68706 "./x-pseudo": 150, 68707 "./x-pseudo.js": 150, 68708 "./yo": 151, 68709 "./yo.js": 151, 68710 "./zh-cn": 152, 68711 "./zh-cn.js": 152, 68712 "./zh-hk": 153, 68713 "./zh-hk.js": 153, 68714 "./zh-tw": 154, 68715 "./zh-tw.js": 154 68716}; 68717function webpackContext(req) { 68718 return __webpack_require__(webpackContextResolve(req)); 68719}; 68720function webpackContextResolve(req) { 68721 var id = map[req]; 68722 if(!(id + 1)) // check for number or string 68723 throw new Error("Cannot find module '" + req + "'."); 68724 return id; 68725}; 68726webpackContext.keys = function webpackContextKeys() { 68727 return Object.keys(map); 68728}; 68729webpackContext.resolve = webpackContextResolve; 68730module.exports = webpackContext; 68731webpackContext.id = 237; 68732 68733/***/ }), 68734/* 238 */ 68735/***/ (function(module, exports
68735) { 68736 68737 68738/** 68739 * Reduce `arr` with `fn`. 68740 * 68741 * @param {Array} arr 68742 * @param {Function} fn 68743 * @param {Mixed} initial 68744 * 68745 * TODO: combatible error handling? 68746 */ 68747 68748module.exports = function(arr, fn, initial){ 68749 var idx = 0; 68750 var len = arr.length; 68751 var curr = arguments.length == 3 68752 ? initial 68753 : arr[idx++]; 68754 68755 while (idx < len) { 68756 curr = fn.call(null, curr, arr[idx], ++idx, arr); 68757 } 68758 68759 return curr; 68760}; 68761 68762/***/ }), 68763/* 239 */ 68764/***/ (function(module, exports, __webpack_require__) { 68765 68766/** 68767 * Module dependencies. 68768 */ 68769 68770var Emitter = __webpack_require__(231); 68771var reduce = __webpack_require__(238); 68772 68773/** 68774 * Root reference for iframes. 68775 */ 68776 68777var root = 'undefined' == typeof window 68778 ? this 68779 : window; 68780 68781/** 68782 * Noop. 68783 */ 68784 68785function noop(){}; 68786 68787/** 68788 * Check if `obj` is a host object, 68789 * we don't want to serialize these :) 68790 * 68791 * TODO: future proof, move to compoent land 68792 * 68793 * @param {Object} obj 68794 * @return {Boolean} 68795 * @api private 68796 */ 68797 68798function isHost(obj) { 68799 var str = {}.toString.call(obj); 68800 68801 switch (str) { 68802 case '[object File]': 68803 case '[object Blob]': 68804 case '[object FormData]': 68805 return true; 68806 default: 68807 return false; 68808 } 68809} 68810 68811/** 68812 * Determine XHR. 68813 */ 68814 68815function getXHR() { 68816 if (root.XMLHttpRequest 68817 && ('file:' != root.location.protocol || !root.ActiveXObject)) { 68818 return new XMLHttpRequest; 68819 } else { 68820 try { return new ActiveXObject('Microsoft.XMLHTTP'); } catch(e) {} 68821 try { return new ActiveXObject('Msxml2.XMLHTTP.6.0'); } catch(e) {} 68822 try { return new ActiveXObject('Msxml2.XMLHTTP.3.0'); } catch(e) {} 68823 try { return new ActiveXObject('Msxml2.XMLHTTP'); } catch(e) {} 68824 } 68825 return false; 68826} 68827 68828/** 68829 * Removes leading and trailing whitespace, added to support IE. 68830 * 68831 * @param {String} s 68832 * @return {String} 68833 * @api private 68834 */ 68835 68836var trim = ''.trim 68837 ? function(s) { return s.trim(); } 68838 : function(s) { return s.replace(/(^\s*|\s*$)/g, ''); }; 68839 68840/** 68841 * Check if `obj` is an object. 68842 * 68843 * @param {Object} obj 68844 * @return {Boolean} 68845 * @api private 68846 */ 68847 68848function isObject(obj) { 68849 return obj === Object(obj); 68850} 68851 68852/** 68853 * Serialize the given `obj`. 68854 * 68855 * @param {Object} obj 68856 * @return {String} 68857 * @api private 68858 */ 68859 68860function serialize(obj) { 68861 if (!isObject(obj)) return obj; 68862 var pairs = []; 68863 for (var key in obj) { 68864 if (null != obj[key]) { 68865 pairs.push(encodeURIComponent(key) 68866 + '=' + encodeURIComponent(obj[key])); 68867 } 68868 } 68869 return pairs.join('&'); 68870} 68871 68872/** 68873 * Expose serialization method. 68874 */ 68875 68876 request.serializeObject = serialize; 68877 68878 /** 68879 * Parse the given x-www-form-urlencoded `str`. 68880 * 68881 * @param {String} str 68882 * @return {Object} 68883 * @api private 68884 */ 68885 68886function parseString(str) { 68887 var obj = {}; 68888 var pairs = str.split('&'); 68889 var parts; 68890 var pair; 68891 68892 for (var i = 0, len = pairs.length; i < len; ++i) { 68893 pair = pairs[i]; 68894 parts = pair.split('='); 68895 obj[decodeURIComponent(parts[0])] = decodeURIComponent(parts[1]); 68896 } 68897 68898 return obj; 68899} 68900 68901/** 68902 * Expose parser. 68903 */ 68904 68905request.parseString = parseString; 68906 68907/** 68908 * Default MIME type map. 68909 * 68910 * superagent.types.xml = 'application/xml'; 68911 * 68912 */ 68913 68914request.types = { 68915 html: 'text/html', 68916 json: 'application/json', 68917 xml: 'application/xml', 68918 urlencoded: 'application/x-www-form-urlencoded', 68919 'form': 'application/x-www-form-urlencoded', 68920 'form-data': 'application/x-www-form-urlencoded' 68921}; 68922 68923/** 68924 * Default serialization map. 68925 * 68926 * superagent.serialize['application/xml'] = function(obj){ 68927 * return 'generated xml here'; 68928 * }; 68929 * 68930 */ 68931 68932 request.serialize = { 68933 'application/x-www-form-urlencoded': serialize, 68934 'application/json': JSON.stringify 68935 }; 68936 68937 /** 68938 * Default parsers. 68939 * 68940 * superagent.parse['application/xml'] = function(str){ 68941 * return { object parsed from str }; 68942 * }; 68943 * 68944 */ 68945 68946request.parse = { 68947 'application/x-www-form-urlencoded': parseString, 68948 'application/json': JSON.parse 68949}; 68950 68951/** 68952 * Parse the given header `str` into
vendor: 4,061 bytes, lines 68953-69135
68953 * an object containing the mapped fields. 68954 * 68955 * @param {String} str 68956 * @return {Object} 68957 * @api private 68958 */ 68959 68960function parseHeader(str) { 68961 var lines = str.split(/\r?\n/); 68962 var fields = {}; 68963 var index; 68964 var line; 68965 var field; 68966 var val; 68967 68968 lines.pop(); // trailing CRLF 68969 68970 for (var i = 0, len = lines.length; i < len; ++i) { 68971 line = lines[i]; 68972 index = line.indexOf(':'); 68973 field = line.slice(0, index).toLowerCase(); 68974 val = trim(line.slice(index + 1)); 68975 fields[field] = val; 68976 } 68977 68978 return fields; 68979} 68980 68981/** 68982 * Return the mime type for the given `str`. 68983 * 68984 * @param {String} str 68985 * @return {String} 68986 * @api private 68987 */ 68988 68989function type(str){ 68990 return str.split(/ *; */).shift(); 68991}; 68992 68993/** 68994 * Return header field parameters. 68995 * 68996 * @param {String} str 68997 * @return {Object} 68998 * @api private 68999 */ 69000 69001function params(str){ 69002 return reduce(str.split(/ *; */), function(obj, str){ 69003 var parts = str.split(/ *= */) 69004 , key = parts.shift() 69005 , val = parts.shift(); 69006 69007 if (key && val) obj[key] = val; 69008 return obj; 69009 }, {}); 69010}; 69011 69012/** 69013 * Initialize a new `Response` with the given `xhr`. 69014 * 69015 * - set flags (.ok, .error, etc) 69016 * - parse header 69017 * 69018 * Examples: 69019 * 69020 * Aliasing `superagent` as `request` is nice: 69021 * 69022 * request = superagent; 69023 * 69024 * We can use the promise-like API, or pass callbacks: 69025 * 69026 * request.get('/').end(function(res){}); 69027 * request.get('/', function(res){}); 69028 * 69029 * Sending data can be chained: 69030 * 69031 * request 69032 * .post('/user') 69033 * .send({ name: 'tj' }) 69034 * .end(function(res){}); 69035 * 69036 * Or passed to `.send()`: 69037 * 69038 * request 69039 * .post('/user') 69040 * .send({ name: 'tj' }, function(res){}); 69041 * 69042 * Or passed to `.post()`: 69043 * 69044 * request 69045 * .post('/user', { name: 'tj' }) 69046 * .end(function(res){}); 69047 * 69048 * Or further reduced to a single call for simple cases: 69049 * 69050 * request 69051 * .post('/user', { name: 'tj' }, function(res){}); 69052 * 69053 * @param {XMLHTTPRequest} xhr 69054 * @param {Object} options 69055 * @api private 69056 */ 69057 69058function Response(req, options) { 69059 options = options || {}; 69060 this.req = req; 69061 this.xhr = this.req.xhr; 69062 this.text = this.xhr.responseText; 69063 this.setStatusProperties(this.xhr.status); 69064 this.header = this.headers = parseHeader(this.xhr.getAllResponseHeaders()); 69065 // getAllResponseHeaders sometimes falsely returns "" for CORS requests, but 69066 // getResponseHeader still works. so we get content-type even if getting 69067 // other headers fails. 69068 this.header['content-type'] = this.xhr.getResponseHeader('content-type'); 69069 this.setHeaderProperties(this.header); 69070 this.body = this.req.method != 'HEAD' 69071 ? this.parseBody(this.text) 69072 : null; 69073} 69074 69075/** 69076 * Get case-insensitive `field` value. 69077 * 69078 * @param {String} field 69079 * @return {String} 69080 * @api public 69081 */ 69082 69083Response.prototype.get = function(field){ 69084 return this.header[field.toLowerCase()]; 69085}; 69086 69087/** 69088 * Set header related properties: 69089 * 69090 * - `.type` the content type without params 69091 * 69092 * A response of "Content-Type: text/plain; charset=utf-8" 69093 * will provide you with a `.type` of "text/plain". 69094 * 69095 * @param {Object} header 69096 * @api private 69097 */ 69098 69099Response.prototype.setHeaderProperties = function(header){ 69100 // content-type 69101 var ct = this.header['content-type'] || ''; 69102 this.type = type(ct); 69103 69104 // params 69105 var obj = params(ct); 69106 for (var key in obj) this[key] = obj[key]; 69107}; 69108 69109/** 69110 * Parse the given body `str`. 69111 * 69112 * Used for auto-parsing of bodies. Parsers 69113 * are defined on the `superagent.parse` object. 69114 * 69115 * @param {String} str 69116 * @return {Mixed} 69117 * @api private 69118 */ 69119 69120Response.prototype.parseBody = function(str){ 69121 var parse = request.parse[this.type]; 69122 return parse 69123 ? parse(str) 69124 : null; 69125}; 69126 69127/** 69128 * Set flags such as `.ok` based on `status`. 69129 * 69130 * For example a 2xx response will give you a `.ok` of __true__ 69131 * whereas 5xx will be __false__ and `.error` will be __true__. The 69132 * `.clientError` and `.serverError` are also available to be more 69133 * specific, and `.statusType` is the class of error ranging from 1..5 69134 * sometimes useful for mapping respond colors etc. 69135 *
69136 * "sugar" properties are also defined for common cases. Currently providing: 69137 * 69138 * - .noContent 69139 * - .badRequest 69140 * - .unauthorized 69141 * - .notAcceptable 69142 * - .notFound 69143 * 69144 * @param {Number} status 69145 * @api private 69146 */ 69147 69148Response.prototype.setStatusProperties = function(status){ 69149 var type = status / 100 | 0; 69150 69151 // status / class 69152 this.status = status; 69153 this.statusType = type; 69154 69155 // basics 69156 this.info = 1 == type; 69157 this.ok = 2 == type; 69158 this.clientError = 4 == type; 69159 this.serverError = 5 == type; 69160 this.error = (4 == type || 5 == type) 69161 ? this.toError() 69162 : false; 69163 69164 // sugar 69165 this.accepted = 202 == status; 69166 this.noContent = 204 == status || 1223 == status; 69167 this.badRequest = 400 == status; 69168 this.unauthorized = 401 == status; 69169 this.notAcceptable = 406 == status; 69170 this.notFound = 404 == status; 69171 this.forbidden = 403 == status; 69172}; 69173 69174/** 69175 * Return an `Error` representative of this response. 69176 * 69177 * @return {Error} 69178 * @api public 69179 */ 69180 69181Response.prototype.toError = function(){ 69182 var req = this.req; 69183 var method = req.method; 69184 var path = req.path; 69185 69186 var msg = 'cannot ' + method + ' ' + path + ' (' + this.status + ')'; 69187 var err = new Error(msg); 69188 err.status = this.status; 69189 err.method = method; 69190 err.path = path; 69191 69192 return err; 69193}; 69194 69195/** 69196 * Expose `Response`. 69197 */ 69198 69199request.Response = Response; 69200 69201/** 69202 * Initialize a new `Request` with the given `method` and `url`. 69203 * 69204 * @param {String} method 69205 * @param {String} url 69206 * @api public 69207 */ 69208
69209function Request(method, url) { 69210 var self = this; 69211 Emitter.call(this); 69212 this._query = this._query || []; 69213 this.method = method; 69214 this.url = url; 69215 this.header = {}; 69216 this._header = {}; 69217 this.on('end', function(){ 69218 var res = new Response(self); 69219 if ('HEAD' == method) res.text = null; 69220 self.callback(null, res); 69221 }); 69222} 69223 69224/** 69225 * Mixin `Emitter`. 69226 */ 69227 69228Emitter(Request.prototype); 69229 69230/** 69231 * Set timeout to `ms`. 69232 * 69233 * @param {Number} ms 69234 * @return {Request} for chaining 69235 * @api public 69236 */ 69237 69238Request.prototype.timeout = function(ms){ 69239 this._timeout = ms; 69240 return this; 69241}; 69242 69243/** 69244 * Clear previous timeout. 69245 * 69246 * @return {Request} for chaining 69247 * @api public 69248 */ 69249 69250Request.prototype.clearTimeout = function(){ 69251 this._timeout = 0; 69252 clearTimeout(this._timer); 69253 return this; 69254}; 69255 69256/** 69257 * Abort the request, and clear potential timeout. 69258 * 69259 * @return {Request} 69260 * @api public 69261 */ 69262 69263Request.prototype.abort = function(){ 69264 if (this.aborted) return; 69265 this.aborted = true; 69266 this.xhr.abort(); 69267 this.clearTimeout(); 69268 this.emit('abort'); 69269 return this; 69270}; 69271 69272/** 69273 * Set header `field` to `val`, or multiple fields with one object. 69274 * 69275 * Examples: 69276 * 69277 * req.get('/') 69278 * .set('Accept', 'application/json') 69279 * .set('X-API-Key', 'foobar') 69280 * .end(callback); 69281 * 69282 * req.get('/') 69283 * .set({ Accept: 'application/json', 'X-API-Key': 'foobar' }) 69284 * .end(callback); 69285 * 69286 * @param {String|Object} field 69287 * @param {String} val 69288 * @return {Request} for chaining 69289 * @api public 69290 */ 69291 69292Request.prototype.set = function(field, val){ 69293 if (isObject(field)) { 69294 for (var key in field) { 69295 this.set(key, field[key]); 69296 } 69297 return this; 69298 } 69299 this._header[field.toLowerCase()] = val; 69300 this.header[field] = val; 69301 return this; 69302}; 69303 69304/** 69305 * Get case-insensitive header `field` value. 69306 * 69307 * @param {String} field 69308 * @return {String} 69309 * @api private 69310 */ 69311 69312Request.prototype.getHeader = function(field){ 69313 return this._header[field.toLowerCase()]; 69314}; 69315 69316/** 69317 * Set Content-Type to `type`, mapping values from `request.types`. 69318 * 69319 * Examples: 69320 * 69321 * superagent.types.xml = 'application/xml'; 69322 * 69323 * request.post('/') 69324 * .type('xml') 69325 * .send(xmlstring) 69326 * .end(callback); 69327 * 69328 * request.post('/') 69329 * .type('application/xml') 69330 * .send(xmlstring) 69331 * .end(callback); 69332 * 69333 * @param {String} type 69334 * @return {Request} for chaining 69335 * @api public 69336 */ 69337 69338Request.prototype.type = function(type){ 69339 this.set('Content-Type', request.types[type] || type); 69340 return this; 69341}; 69342 69343/** 69344 * Set Accept to `type`, mapping values from `request.types`. 69345 * 69346 * Examples: 69347 * 69348 * superagent.types.json = 'application/json'; 69349 * 69350 * request.get('/agent') 69351 * .accept('json') 69352 * .end(callback); 69353 * 69354 * request.get('/agent') 69355 * .accept('application/json') 69356 * .end(callback); 69357 * 69358 * @param {String} accept 69359 * @return {Request} for chaining 69360 * @api public 69361 */ 69362 69363Request.prototype.accept = function(type){ 69364 this.set('Accept', request.types[type] || type); 69365 return this; 69366}; 69367 69368/** 69369 * Set Authorization field value with `user` and `pass`. 69370 * 69371 * @param {String} user 69372 * @param {String} pass 69373 * @return {Request} for chaining 69374 * @api public 69375 */ 69376 69377Request.prototype.auth = function(user, pass){ 69378 var str = btoa(user + ':' + pass); 69379 this.set('Authorization', 'Basic ' + str); 69380 return this; 69381}; 69382 69383/** 69384* Add query-string `val`. 69385* 69386* Examples: 69387* 69388* request.get('/shoes') 69389* .query('size=10') 69390* .query({ color: 'blue' }) 69391* 69392* @param {Object|String} val 69393* @return {Request} for chaining 69394* @api public 69395*/ 69396 69397Request.prototype.query = function(val){ 69398 if ('string' != typeof val) val = serialize(val); 69399 if (val) this._query.push(val); 69400 return this; 69401}; 69402 69403/** 69404 * Send `data`, defaulting the `.type()` to "json" when 69405 * an object is given. 69406 * 69407 * Examples: 69408 * 69409 * // querystring 69410 * request.get('/search') 69411 * .end(callback) 69412 * 69413 * // multiple data "writes" 69414 * request.get('/search') 69415 * .send({ search: 'query' }) 69416 * .send({ range: '1..5' }) 69417 * .send({ order: 'desc' }) 69418 * .end(callback) 69419 * 69420 * // manual json 69421 * request.post('/user') 69422 * .type('json') 69423 * .send('{"name":"tj"}) 69424 * .end(callback) 69425 * 69426 * // auto json 69427 * request.post('/user') 69428 * .send({ name: 'tj' }) 69429 * .end(callback) 69430 * 69431 * // manual x-www-form-urlencoded 69432 * request.post('/user') 69433 * .type('form') 69434 * .send('name=tj') 69435 * .end(callback) 69436 * 69437 * // auto x-www-form-urlencoded 69438 * request.post('/user') 69439 * .type('form') 69440 * .send({ name: 'tj' }) 69441 * .end(callback) 69442 * 69443 * // defaults to x-www-form-urlencoded 69444 * request.post('/user') 69445 * .send('name=tobi') 69446 * .send('species=ferret') 69447 * .end(callback) 69448 * 69449 * @param {String|Object} data 69450 * @return {Request} for chaining 69451 * @api public 69452 */ 69453 69454Request.prototype.send = function(data){ 69455 var obj = isObject(data); 69456 var type = this.getHeader('Content-Type'); 69457 69458 // merge 69459 if (obj && isObject(this._data)) { 69460 for (var key in data) { 69461 this._data[key] = data[key]; 69462 } 69463 } else if ('string' == typeof data) { 69464 if (!type) this.type('form'); 69465 type = this.getHeader('Content-Type'); 69466 if ('application/x-www-form-urlencoded' == type) { 69467 this._data = this._data 69468 ? this._data + '&' + data 69469 : data; 69470 } else { 69471 this._data = (this._data || '') + data; 69472 } 69473 } else { 69474 this._data = data; 69475 } 69476 69477 if (!obj) return this; 69478 if (!type) this.type('json'); 69479 return this; 69480}; 69481 69482/** 69483 * Invoke the callback with `err` and `res` 69484 * and handle arity check. 69485 * 69486 * @param {Error} err 69487 * @param {Response} res 69488 * @api private 69489 */ 69490 69491Request.prototype.callback = function(err, res){ 69492 var fn = this._callback; 69493 if (2 == fn.length) return fn(err, res);
69494 if (err) return this.emit('error', err); 69495 fn(res); 69496}; 69497 69498/** 69499 * Invoke callback with x-domain error. 69500 * 69501 * @api private 69502 */ 69503 69504Request.prototype.crossDomainError = function(){ 69505 var err = new Error('Origin is not allowed by Access-Control-Allow-Origin'); 69506 err.crossDomain = true; 69507 this.callback(err); 69508}; 69509 69510/** 69511 * Invoke callback with timeout error. 69512 * 69513 * @api private 69514 */ 69515 69516Request.prototype.timeoutError = function(){ 69517 var timeout = this._timeout; 69518 var err = new Error('timeout of ' + timeout + 'ms exceeded'); 69519 err.timeout = timeout; 69520 this.callback(err); 69521}; 69522 69523/** 69524 * Enable transmission of cookies with x-domain requests. 69525 * 69526 * Note that for this to work the origin must not be 69527 * using "Access-Control-Allow-Origin" with a wildcard, 69528 * and also must set "Access-Control-Allow-Credentials" 69529 * to "true". 69530 * 69531 * @api public 69532 */ 69533 69534Request.prototype.withCredentials = function(){ 69535 this._withCredentials = true; 69536 return this; 69537}; 69538 69539/** 69540 * Initiate request, invoking callback `fn(res)` 69541 * with an instanceof `Response`. 69542 * 69543 * @param {Function} fn 69544 * @return {Request} for chaining 69545 * @api public 69546 */ 69547 69548Request.prototype.end = function(fn){ 69549 var self = this; 69550 var xhr = this.xhr = getXHR(); 69551 var query = this._query.join('&'); 69552 var timeout = this._timeout; 69553 var data = this._data; 69554 69555 // store callback 69556 this._callback = fn || noop; 69557 69558 // state change 69559 xhr.onreadystatechange = function(){ 69560 if (4 != xhr.readyState) return; 69561 if (0 == xhr.status) { 69562 if (self.aborted) return self.timeoutError(); 69563 return self.crossDomainError(); 69564 } 69565 self.emit('end'); 69566 }; 69567 69568 // progress 69569 if (xhr.upload) { 69570 xhr.upload.onprogress = function(e){ 69571 e.percent = e.loaded / e.total * 100; 69572 self.emit('progress', e); 69573 }; 69574 } 69575 69576 // timeout 69577 if (timeout && !this._timer) { 69578 this._timer = setTimeout(function(){ 69579 self.abort(); 69580 }, timeout); 69581 } 69582 69583 // querystring 69584 if (query) { 69585 query = request.serializeObject(query); 69586 this.url += ~this.url.indexOf('?') 69587 ? '&' + query 69588 : '?' + query; 69589 } 69590 69591 // initiate request 69592 xhr.open(this.method, this.url, true); 69593 69594 // CORS 69595 if (this._withCredentials) xhr.withCredentials = true; 69596 69597 // body 69598 if ('GET' != this.method && 'HEAD' != this.method && 'string' != typeof data && !isHost(data)) { 69599 // serialize stuff 69600 var serialize = request.serialize[this.getHeader('Content-Type')]; 69601 if (serialize) data = serialize(data); 69602 } 69603 69604 // set header fields 69605 for (var field in this.header) { 69606 if (null == this.header[field]) continue; 69607 xhr.setRequestHeader(field, this.header[field]); 69608 } 69609 69610 // send stuff 69611 xhr.send(data); 69612 return this; 69613}; 69614 69615/** 69616 * Expose `Request`. 69617 */ 69618 69619request.Request = Request; 69620 69621/** 69622 * Issue a request: 69623 * 69624 * Examples: 69625 * 69626 * request('GET', '/users').end(callback) 69627 * request('/users').end(callback) 69628 * request('/users', callback) 69629 * 69630 * @param {String} method 69631 * @param {String|Function} url or callback 69632 * @return {Request} 69633 * @api public 69634 */ 69635 69636function request(method, url) { 69637 // callback 69638 if ('function' == typeof url) { 69639 return new Request('GET', method).end(url); 69640 } 69641 69642 // url first 69643 if (1 == arguments.length) { 69644 return new Request('GET', method); 69645 } 69646 69647 return new Request(method, url); 69648} 69649 69650/** 69651 * GET `url` with optional callback `fn(res)`. 69652 * 69653 * @param {String} url 69654 * @param {Mixed|Function} data or fn 69655 * @param {Function} fn 69656 * @return {Request} 69657 * @api public 69658 */ 69659 69660request.get = function(url, data, fn){ 69661 var req = request('GET', url); 69662 if ('function' == typeof data) fn = data, data = null; 69663 if (data) req.query(data); 69664 if (fn) req.end(fn); 69665 return req; 69666}; 69667 69668/** 69669 * HEAD `url` with optional callback `fn(res)`. 69670 * 69671 * @param {String} url 69672 * @param {Mixed|Function} data or fn 69673 * @param {Function} fn 69674 * @return {Request} 69675 * @api public 69676 */ 69677 69678request.head = function(url, data, fn){ 69679 var req = request('HEAD', url); 69680 if ('function' == typeof data) fn = data, data = null; 69681 if (data) req.send(data); 69682 if (fn) req.end(fn); 69683 return req; 69684}; 69685 69686/** 69687 * DELETE `url` with optional callback `fn(res)`. 69688 * 69689 * @param {String} url 69690 * @param {Function} fn 69691 * @return {Request} 69692 * @api public 69693 */ 69694 69695request.del = function(url, fn){ 69696 var req = request('DELETE', url); 69697 if (fn) req.end(fn); 69698 return req; 69699}; 69700 69701/** 69702 * PATCH `url` with optional `data` and callback `fn(res)`. 69703 * 69704 * @param {String} url 69705 * @param {Mixed} data 69706 * @param {Function} fn 69707 * @return {Request} 69708 * @api public 69709 */ 69710 69711request.patch = function(url, data, fn){ 69712 var req = request('PATCH', url); 69713 if ('function' == typeof data) fn = data, data = null; 69714 if (data) req.send(data); 69715 if (fn) req.end(fn); 69716 return req; 69717}; 69718 69719/** 69720 * POST `url` with optional `data` and callback `fn(res)`. 69721 * 69722 * @param {String} url 69723 * @param {Mixed} data 69724 * @param {Function} fn 69725 * @return {Request} 69726 * @api public 69727 */ 69728 69729request.post = function(url, data, fn){ 69730 var req = request('POST', url); 69731 if ('function' == typeof data) fn = data, data = null; 69732 if (data) req.send(data); 69733 if (fn) req.end(fn); 69734 return req; 69735}; 69736 69737/** 69738 * PUT `url` with optional `data` and callback `fn(res)`. 69739 * 69740 * @param {String} url 69741 * @param {Mixed|Function} data or fn 69742 * @param {Function} fn 69743 * @return {Request} 69744 * @api public 69745 */ 69746 69747request.put = function(url, data, fn){ 69748 var req = request('PUT', url); 69749 if ('function' == typeof data) fn = data, data = null; 69750 if (data) req.send(data); 69751 if (fn) req.end(fn); 69752 return req; 69753}; 69754 69755/** 69756 * Expose `request`. 69757 */ 69758 69759module.exports = request; 69760 69761 69762/***/ }), 69763/* 240 */ 69764/***/ (function(module, exports, __webpack_require__) { 69765 69766var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// Underscore.js 1.7.0 69767// http://underscorejs.org
69768// (c) 2009-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors 69769// Underscore may be freely distributed under the MIT license. 69770 69771(function() { 69772 69773 // Baseline setup 69774 // -------------- 69775 69776 // Establish the root object, `window` in the browser, or `exports` on the server. 69777 var root = this; 69778 69779 // Save the previous value of the `_` variable. 69780 var previousUnderscore = root._; 69781 69782 // Save bytes in the minified (but not gzipped) version: 69783 var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype; 69784 69785 // Create quick reference variables for speed access to core prototypes. 69786 var 69787 push = ArrayProto.push, 69788 slice = ArrayProto.slice, 69789 concat = ArrayProto.concat, 69790 toString = ObjProto.toString, 69791 hasOwnProperty = ObjProto.hasOwnProperty; 69792 69793 // All **ECMAScript 5** native function implementations that we hope to use 69794 // are declared here. 69795 var 69796 nativeIsArray = Array.isArray, 69797 nativeKeys = Object.keys, 69798 nativeBind = FuncProto.bind; 69799 69800 // Create a safe reference to the Underscore object for use below. 69801 var _ = function(obj) { 69802 if (obj instanceof _) return obj; 69803 if (!(this instanceof _)) return new _(obj); 69804 this._wrapped = obj; 69805 }; 69806 69807 // Export the Underscore object for **Node.js**, with 69808 // backwards-compatibility for the old `require()` API. If we're in 69809 // the browser, add `_` as a global object. 69810 if (true) { 69811 if (typeof module !== 'undefined' && module.exports) { 69812 exports = module.exports = _; 69813 } 69814 exports._ = _; 69815 } else { 69816 root._ = _; 69817 } 69818 69819 // Current version. 69820 _.VERSION = '1.7.0'; 69821 69822 // Internal function that returns an efficient (for current engines) version 69823 // of the passed-in callback, to be repeatedly applied in other Underscore 69824 // functions. 69825 var createCallback = function(func, context, argCount) { 69826 if (context === void 0) return func; 69827 switch (argCount == null ? 3 : argCount) { 69828 case 1: return function(value) { 69829 return func.call(context, value); 69830 }; 69831 case 2: return function(value, other) { 69832 return func.call(context, value, other); 69833 }; 69834 case 3: return function(value, index, collection) { 69835 return func.call(context, value, index, collection); 69836 }; 69837 case 4: return function(accumulator, value, index, collection) { 69838 return func.call(context, accumulator, value, index, collection); 69839 }; 69840 } 69841 return function() { 69842 return func.apply(context, arguments); 69843 }; 69844 }; 69845 69846 // A mostly-internal function to generate callbacks that can be applied 69847 // to each element in a collection, returning the desired result â either 69848 // identity, an arbitrary callback, a property matcher, or a property accessor. 69849 _.iteratee = function(value, context, argCount) { 69850 if (value == null) return _.identity; 69851 if (_.isFunction(value)) return createCallback(value, context, argCount); 69852 if (_.isObject(value)) return _.matches(value); 69853 return _.property(value); 69854 }; 69855 69856 // Collection Functions 69857 // -------------------- 69858 69859 // The cornerstone, an `each` implementation, aka `forEach`. 69860 // Handles raw objects in addition to array-likes. Treats all 69861 // sparse array-likes as if they were dense. 69862 _.each = _.forEach = function(obj, iteratee, context) { 69863 if (obj == null) return obj; 69864 iteratee = createCallback(iteratee, context); 69865 var i, length = obj.length; 69866 if (length === +length) { 69867 for (i = 0; i < length; i++) { 69868 iteratee(obj[i], i, obj); 69869 } 69870 } else { 69871 var keys = _.keys(obj); 69872 for (i = 0, length = keys.length; i < length; i++) { 69873 iteratee(obj[keys[i]], keys[i], obj); 69874 } 69875 } 69876 return obj; 69877 }; 69878 69879 // Return the results of applying the iteratee to each element. 69880 _.map = _.collect = function(obj, iteratee, context) { 69881 if (obj == null) return []; 69882 iteratee = _.iteratee(iteratee, context); 69883 var keys = obj.length !== +obj.length && _.keys(obj), 69884 length = (keys || obj).length, 69885 results = Array(length), 69886 currentKey; 69887 for (var index = 0; index < length; index++) { 69888 currentKey = keys ? keys[index] : index; 69889 results[index] = iteratee(obj[currentKey], currentKey, obj); 69890 } 69891 return results; 69892 }; 69893
69894 var reduceError = 'Reduce of empty array with no initial value'; 69895 69896 // **Reduce** builds up a single result from a list of values, aka `inject`, 69897 // or `foldl`. 69898 _.reduce = _.foldl = _.inject = function(obj, iteratee, memo, context) { 69899 if (obj == null) obj = []; 69900 iteratee = createCallback(iteratee, context, 4); 69901 var keys = obj.length !== +obj.length && _.keys(obj), 69902 length = (keys || obj).length, 69903 index = 0, currentKey; 69904 if (arguments.length < 3) { 69905 if (!length) throw new TypeError(reduceError); 69906 memo = obj[keys ? keys[index++] : index++]; 69907 } 69908 for (; index < length; index++) { 69909 currentKey = keys ? keys[index] : index; 69910 memo = iteratee(memo, obj[currentKey], currentKey, obj); 69911 } 69912 return memo; 69913 }; 69914 69915 // The right-associative version of reduce, also known as `foldr`. 69916 _.reduceRight = _.foldr = function(obj, iteratee, memo, context) { 69917 if (obj == null) obj = []; 69918 iteratee = createCallback(iteratee, context, 4); 69919 var keys = obj.length !== + obj.length && _.keys(obj), 69920 index = (keys || obj).length, 69921 currentKey; 69922 if (arguments.length < 3) { 69923 if (!index) throw new TypeError(reduceError); 69924 memo = obj[keys ? keys[--index] : --index]; 69925 } 69926 while (index--) { 69927 currentKey = keys ? keys[index] : index; 69928 memo = iteratee(memo, obj[currentKey], currentKey, obj); 69929 } 69930 return memo; 69931 }; 69932 69933 // Return the first value which passes a truth test. Aliased as `detect`. 69934 _.find = _.detect = function(obj, predicate, context) { 69935 var result; 69936 predicate = _.iteratee(predicate, context); 69937 _.some(obj, function(value, index, list) { 69938 if (predicate(value, index, list)) { 69939 result = value; 69940 return true; 69941 } 69942 }); 69943 return result; 69944 }; 69945 69946 // Return all the elements that pass a truth test. 69947 // Aliased as `select`. 69948 _.filter = _.select = function(obj, predicate, context) { 69949 var results = []; 69950 if (obj == null) return results; 69951 predicate = _.iteratee(predicate, context); 69952 _.each(obj, function(value, index, list) { 69953 if (predicate(value, index, list)) results.push(value); 69954 }); 69955 return results; 69956 }; 69957 69958 // Return all the elements for which a truth test fails. 69959 _.reject = function(obj, predicate, context) { 69960 return _.filter(obj, _.negate(_.iteratee(predicate)), context); 69961 }; 69962 69963 // Determine whether all of the elements match a truth test. 69964 // Aliased as `all`. 69965 _.every = _.all = function(obj, predicate, context) { 69966 if (obj == null) return true; 69967 predicate = _.iteratee(predicate, context); 69968 var keys = obj.length !== +obj.length && _.keys(obj), 69969 length = (keys || obj).length, 69970 index, currentKey; 69971 for (index = 0; index < length; index++) { 69972 currentKey = keys ? keys[index] : index; 69973 if (!predicate(obj[currentKey], currentKey, obj)) return false; 69974 } 69975 return true; 69976 }; 69977 69978 // Determine if at least one element in the object matches a truth test. 69979 // Aliased as `any`. 69980 _.some = _.any = function(obj, predicate, context) { 69981 if (obj == null) return false; 69982 predicate = _.iteratee(predicate, context); 69983 var keys = obj.length !== +obj.length && _.keys(obj), 69984 length = (keys || obj).length, 69985 index, currentKey; 69986 for (index = 0; index < length; index++) { 69987 currentKey = keys ? keys[index] : index; 69988 if (predicate(obj[currentKey], currentKey, obj)) return true; 69989 } 69990 return false; 69991 }; 69992 69993 // Determine if the array or object contains a given value (using `===`). 69994 // Aliased as `include`. 69995 _.contains = _.include = function(obj, target) { 69996 if (obj == null) return false; 69997 if (obj.length !== +obj.length) obj = _.values(obj); 69998 return _.indexOf(obj, target) >= 0; 69999 }; 70000 70001 // Invoke a method (with arguments) on every item in a collection. 70002 _.invoke = function(obj, method) { 70003 var args = slice.call(arguments, 2); 70004 var isFunc = _.isFunction(method); 70005 return _.map(obj, function(value) { 70006 return (isFunc ? method : value[method]).apply(value, args); 70007 }); 70008 }; 70009 70010 // Convenience version of a common use case of `map`: fetching a property. 70011 _.pluck = function(obj, key) { 70012 return _.map(obj, _.property(key)); 70013 }; 70014 70015 // Convenience version of a common use case of `filter`: selecting only objects 70016 // containing specific `key:value` pairs. 70017 _.where = function(obj, attrs) { 70018 return _.filter(obj, _.matches(attrs)); 70019 }; 70020 70021 // Convenience version of a common use case of `find`: getting the first object 70022 // containing specific `key:value` pairs. 70023 _.findWhere = function(obj, attrs) { 70024 return _.find(obj, _.matches(attrs)); 70025 }; 70026 70027 // Return the maximum element (or element-based computation). 70028 _.max = function(obj, iteratee, context) { 70029 var result = -Infinity, lastComputed = -Infinity, 70030 value, computed; 70031 if (iteratee == null && obj != null) { 70032 obj = obj.length === +obj.length ? obj : _.values(obj); 70033 for (var i = 0, length = obj.length; i < length; i++) { 70034 value = obj[i]; 70035 if (value > result) { 70036 result = value; 70037 } 70038 } 70039 } else { 70040 iteratee = _.iteratee(iteratee, context); 70041 _.each(obj, function(value, index, list) { 70042 computed = iteratee(value, index, list); 70043 if (computed > lastComputed || computed === -Infinity && result === -Infinity) { 70044 result = value; 70045 lastComputed = computed; 70046 } 70047 }); 70048 } 70049 return result; 70050 }; 70051 70052 // Return the minimum element (or element-based computation). 70053 _.min = function(obj, iteratee, context) { 70054 var result = Infinity, lastComputed = Infinity, 70055 value, computed; 70056 if (iteratee == null && obj != null) { 70057 obj = obj.length === +obj.length ? obj : _.values(obj); 70058 for (var i = 0, length = obj.length; i < length; i++) { 70059 value = obj[i]; 70060 if (value < result) { 70061 result = value; 70062 } 70063 } 70064 } else { 70065 iteratee = _.iteratee(iteratee, context); 70066 _.each(obj, function(value, index, list) { 70067 computed = iteratee(value, index, list);
vendor: 5,915 bytes, lines 70068-70229
70068 if (computed < lastComputed || computed === Infinity && result === Infinity) { 70069 result = value; 70070 lastComputed = computed; 70071 } 70072 }); 70073 } 70074 return result; 70075 }; 70076 70077 // Shuffle a collection, using the modern version of the 70078 // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/FisherâYates_shuffle). 70079 _.shuffle = function(obj) { 70080 var set = obj && obj.length === +obj.length ? obj : _.values(obj); 70081 var length = set.length; 70082 var shuffled = Array(length); 70083 for (var index = 0, rand; index < length; index++) { 70084 rand = _.random(0, index); 70085 if (rand !== index) shuffled[index] = shuffled[rand]; 70086 shuffled[rand] = set[index]; 70087 } 70088 return shuffled; 70089 }; 70090 70091 // Sample **n** random values from a collection. 70092 // If **n** is not specified, returns a single random element. 70093 // The internal `guard` argument allows it to work with `map`. 70094 _.sample = function(obj, n, guard) { 70095 if (n == null || guard) { 70096 if (obj.length !== +obj.length) obj = _.values(obj); 70097 return obj[_.random(obj.length - 1)]; 70098 } 70099 return _.shuffle(obj).slice(0, Math.max(0, n)); 70100 }; 70101 70102 // Sort the object's values by a criterion produced by an iteratee. 70103 _.sortBy = function(obj, iteratee, context) { 70104 iteratee = _.iteratee(iteratee, context); 70105 return _.pluck(_.map(obj, function(value, index, list) { 70106 return { 70107 value: value, 70108 index: index, 70109 criteria: iteratee(value, index, list) 70110 }; 70111 }).sort(function(left, right) { 70112 var a = left.criteria; 70113 var b = right.criteria; 70114 if (a !== b) { 70115 if (a > b || a === void 0) return 1; 70116 if (a < b || b === void 0) return -1; 70117 } 70118 return left.index - right.index; 70119 }), 'value'); 70120 }; 70121 70122 // An internal function used for aggregate "group by" operations. 70123 var group = function(behavior) { 70124 return function(obj, iteratee, context) { 70125 var result = {}; 70126 iteratee = _.iteratee(iteratee, context); 70127 _.each(obj, function(value, index) { 70128 var key = iteratee(value, index, obj); 70129 behavior(result, value, key); 70130 }); 70131 return result; 70132 }; 70133 }; 70134 70135 // Groups the object's values by a criterion. Pass either a string attribute 70136 // to group by, or a function that returns the criterion. 70137 _.groupBy = group(function(result, value, key) { 70138 if (_.has(result, key)) result[key].push(value); else result[key] = [value]; 70139 }); 70140 70141 // Indexes the object's values by a criterion, similar to `groupBy`, but for 70142 // when you know that your index values will be unique. 70143 _.indexBy = group(function(result, value, key) { 70144 result[key] = value; 70145 }); 70146 70147 // Counts instances of an object that group by a certain criterion. Pass 70148 // either a string attribute to count by, or a function that returns the 70149 // criterion. 70150 _.countBy = group(function(result, value, key) { 70151 if (_.has(result, key)) result[key]++; else result[key] = 1; 70152 }); 70153 70154 // Use a comparator function to figure out the smallest index at which 70155 // an object should be inserted so as to maintain order. Uses binary search. 70156 _.sortedIndex = function(array, obj, iteratee, context) { 70157 iteratee = _.iteratee(iteratee, context, 1); 70158 var value = iteratee(obj); 70159 var low = 0, high = array.length; 70160 while (low < high) { 70161 var mid = low + high >>> 1; 70162 if (iteratee(array[mid]) < value) low = mid + 1; else high = mid; 70163 } 70164 return low; 70165 }; 70166 70167 // Safely create a real, live array from anything iterable. 70168 _.toArray = function(obj) { 70169 if (!obj) return []; 70170 if (_.isArray(obj)) return slice.call(obj); 70171 if (obj.length === +obj.length) return _.map(obj, _.identity); 70172 return _.values(obj); 70173 }; 70174 70175 // Return the number of elements in an object. 70176 _.size = function(obj) { 70177 if (obj == null) return 0; 70178 return obj.length === +obj.length ? obj.length : _.keys(obj).length; 70179 }; 70180 70181 // Split a collection into two arrays: one whose elements all satisfy the given 70182 // predicate, and one whose elements all do not satisfy the predicate. 70183 _.partition = function(obj, predicate, context) { 70184 predicate = _.iteratee(predicate, context); 70185 var pass = [], fail = []; 70186 _.each(obj, function(value, key, obj) { 70187 (predicate(value, key, obj) ? pass : fail).push(value); 70188 }); 70189 return [pass, fail]; 70190 }; 70191 70192 // Array Functions 70193 // --------------- 70194 70195 // Get the first element of an array. Passing **n** will return the first N 70196 // values in the array. Aliased as `head` and `take`. The **guard** check 70197 // allows it to work with `_.map`. 70198 _.first = _.head = _.take = function(array, n, guard) { 70199 if (array == null) return void 0; 70200 if (n == null || guard) return array[0]; 70201 if (n < 0) return []; 70202 return slice.call(array, 0, n); 70203 }; 70204 70205 // Returns everything but the last entry of the array. Especially useful on 70206 // the arguments object. Passing **n** will return all the values in 70207 // the array, excluding the last N. The **guard** check allows it to work with 70208 // `_.map`. 70209 _.initial = function(array, n, guard) { 70210 return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n))); 70211 }; 70212 70213 // Get the last element of an array. Passing **n** will return the last N 70214 // values in the array. The **guard** check allows it to work with `_.map`. 70215 _.last = function(array, n, guard) { 70216 if (array == null) return void 0; 70217 if (n == null || guard) return array[array.length - 1]; 70218 return slice.call(array, Math.max(array.length - n, 0)); 70219 }; 70220 70221 // Returns everything but the first entry of the array. Aliased as `tail` and `drop`. 70222 // Especially useful on the arguments object. Passing an **n** will return 70223 // the rest N values in the array. The **guard** 70224 // check allows it to work with `_.map`. 70225 _.rest = _.tail = _.drop = function(array, n, guard) { 70226 return slice.call(array, n == null || guard ? 1 : n); 70227 }; 70228 70229 // Trim out all falsy values from an array.
70230 _.compact = function(array) { 70231 return _.filter(array, _.identity); 70232 }; 70233 70234 // Internal implementation of a recursive `flatten` function. 70235 var flatten = function(input, shallow, strict, output) { 70236 if (shallow && _.every(input, _.isArray)) { 70237 return concat.apply(output, input); 70238 } 70239 for (var i = 0, length = input.length; i < length; i++) { 70240 var value = input[i]; 70241 if (!_.isArray(value) && !_.isArguments(value)) { 70242 if (!strict) output.push(value); 70243 } else if (shallow) { 70244 push.apply(output, value); 70245 } else { 70246 flatten(value, shallow, strict, output); 70247 } 70248 } 70249 return output; 70250 }; 70251 70252 // Flatten out an array, either recursively (by default), or just one level. 70253 _.flatten = function(array, shallow) { 70254 return flatten(array, shallow, false, []); 70255 }; 70256 70257 // Return a version of the array that does not contain the specified value(s). 70258 _.without = function(array) { 70259 return _.difference(array, slice.call(arguments, 1)); 70260 }; 70261 70262 // Produce a duplicate-free version of the array. If the array has already 70263 // been sorted, you have the option of using a faster algorithm. 70264 // Aliased as `unique`. 70265 _.uniq = _.unique = function(array, isSorted, iteratee, context) { 70266 if (array == null) return []; 70267 if (!_.isBoolean(isSorted)) { 70268 context = iteratee; 70269 iteratee = isSorted; 70270 isSorted = false; 70271 } 70272 if (iteratee != null) iteratee = _.iteratee(iteratee, context); 70273 var result = []; 70274 var seen = []; 70275 for (var i = 0, length = array.length; i < length; i++) { 70276 var value = array[i]; 70277 if (isSorted) { 70278 if (!i || seen !== value) result.push(value); 70279 seen = value; 70280 } else if (iteratee) { 70281 var computed = iteratee(value, i, array); 70282 if (_.indexOf(seen, computed) < 0) { 70283 seen.push(computed); 70284 result.push(value); 70285 } 70286 } else if (_.indexOf(result, value) < 0) { 70287 result.push(value); 70288 } 70289 } 70290 return result; 70291 }; 70292 70293 // Produce an array that contains the union: each distinct element from all of 70294 // the passed-in arrays. 70295 _.union = function() { 70296 return _.uniq(flatten(arguments, true, true, [])); 70297 }; 70298 70299 // Produce an array that contains every item shared between all the 70300 // passed-in arrays. 70301 _.intersection = function(array) { 70302 if (array == null) return []; 70303 var result = []; 70304 var argsLength = arguments.length; 70305 for (var i = 0, length = array.length; i < length; i++) { 70306 var item = array[i]; 70307 if (_.contains(result, item)) continue; 70308 for (var j = 1; j < argsLength; j++) { 70309 if (!_.contains(arguments[j], item)) break; 70310 } 70311 if (j === argsLength) result.push(item); 70312 } 70313 return result; 70314 }; 70315 70316 // Take the difference between one array and a number of other arrays. 70317 // Only the elements present in just the first array will remain. 70318 _.difference = function(array) { 70319 var rest = flatten(slice.call(arguments, 1), true, true, []); 70320 return _.filter(array, function(value){ 70321 return !_.contains(rest, value); 70322 }); 70323 }; 70324 70325 // Zip together multiple lists into a single array -- elements that share 70326 // an index go together. 70327 _.zip = function(array) { 70328 if (array == null) return []; 70329 var length = _.max(arguments, 'length').length; 70330 var results = Array(length); 70331 for (var i = 0; i < length; i++) { 70332 results[i] = _.pluck(arguments, i); 70333 } 70334 return results; 70335 }; 70336 70337 // Converts lists into objects. Pass either a single array of `[key, value]` 70338 // pairs, or two parallel arrays of the same length -- one of keys, and one of 70339 // the corresponding values. 70340 _.object = function(list, values) { 70341 if (list == null) return {}; 70342 var result = {}; 70343 for (var i = 0, length = list.length; i < length; i++) { 70344 if (values) { 70345 result[list[i]] = values[i]; 70346 } else { 70347 result[list[i][0]] = list[i][1]; 70348 } 70349 } 70350 return result; 70351 }; 70352 70353 // Return the position of the first occurrence of an item in an array, 70354 // or -1 if the item is not included in the array. 70355 // If the array is large and already in sort order, pass `true` 70356 // for **isSorted** to use binary search. 70357 _.indexOf = function(array, item, isSorted) { 70358 if (array == null) return -1; 70359 var i = 0, length = array.length; 70360 if (isSorted) { 70361 if (typeof isSorted == 'number') { 70362 i = isSorted < 0 ? Math.max(0, length + isSorted) : isSorted; 70363 } else { 70364 i = _.sortedIndex(array, item); 70365 return array[i] === item ? i : -1; 70366 } 70367 } 70368 for (; i < length; i++) if (array[i] === item) return i; 70369 return -1; 70370 }; 70371 70372 _.lastIndexOf = function(array, item, from) { 70373 if (array == null) return -1; 70374 var idx = array.length; 70375 if (typeof from == 'number') { 70376 idx = from < 0 ? idx + from + 1 : Math.min(idx, from + 1); 70377 } 70378 while (--idx >= 0) if (array[idx] === item) return idx; 70379 return -1; 70380 }; 70381 70382 // Generate an integer Array containing an arithmetic progression. A port of 70383 // the native Python `range()` function. See 70384 // [the Python documentation](http://docs.python.org/library/functions.html#range). 70385 _.range = function(start, stop, step) { 70386 if (arguments.length <= 1) { 70387 stop = start || 0; 70388 start = 0; 70389 } 70390 step = step || 1; 70391 70392 var length = Math.max(Math.ceil((stop - start) / step), 0); 70393 var range = Array(length); 70394 70395 for (var idx = 0; idx < length; idx++, start += step) { 70396 range[idx] = start; 70397 } 70398 70399 return range; 70400 }; 70401 70402 // Function (ahem) Functions 70403 // ------------------ 70404 70405 // Reusable constructor function for prototype setting. 70406 var Ctor = function(){}; 70407 70408 // Create a function bound to a given object (assigning `this`, and arguments, 70409 // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if 70410 // available. 70411 _.bind = function(func, context) { 70412 var args, bound; 70413 if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1)); 70414 if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function'); 70415 args = slice.call(arguments, 2); 70416 bound = function() { 70417 if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments))); 70418 Ctor.prototype = func.prototype; 70419 var self = new Ctor; 70420 Ctor.prototype = null; 70421 var result = func.apply(self, args.concat(slice.call(arguments))); 70422 if (_.isObject(result)) return result; 70423 return self; 70424 }; 70425 return bound; 70426 }; 70427 70428 // Partially apply a function by creating a version that has had some of its 70429 // arguments pre-filled, without changing its dynamic `this` context. _ acts 70430 // as a placeholder, allowing any combination of arguments to be pre-filled. 70431 _.partial = function(func) { 70432 var boundArgs = slice.call(arguments, 1); 70433 return function() { 70434 var position = 0; 70435 var args = boundArgs.slice(); 70436 for (var i = 0, length = args.length; i < length; i++) { 70437 if (args[i] === _) args[i] = arguments[position++]; 70438 } 70439 while (position < arguments.length) args.push(arguments[position++]); 70440 return func.apply(this, args); 70441 }; 70442 }; 70443 70444 // Bind a number of an object's methods to that object. Remaining arguments
70445 // are the method names to be bound. Useful for ensuring that all callbacks 70446 // defined on an object belong to it. 70447 _.bindAll = function(obj) { 70448 var i, length = arguments.length, key; 70449 if (length <= 1) throw new Error('bindAll must be passed function names'); 70450 for (i = 1; i < length; i++) { 70451 key = arguments[i]; 70452 obj[key] = _.bind(obj[key], obj); 70453 } 70454 return obj; 70455 }; 70456 70457 // Memoize an expensive function by storing its results. 70458 _.memoize = function(func, hasher) { 70459 var memoize = function(key) { 70460 var cache = memoize.cache; 70461 var address = hasher ? hasher.apply(this, arguments) : key; 70462 if (!_.has(cache, address)) cache[address] = func.apply(this, arguments); 70463 return cache[address]; 70464 }; 70465 memoize.cache = {}; 70466 return memoize; 70467 }; 70468 70469 // Delays a function for the given number of milliseconds, and then calls 70470 // it with the arguments supplied. 70471 _.delay = function(func, wait) { 70472 var args = slice.call(arguments, 2); 70473 return setTimeout(function(){ 70474 return func.apply(null, args); 70475 }, wait); 70476 }; 70477 70478 // Defers a function, scheduling it to run after the current call stack has 70479 // cleared. 70480 _.defer = function(func) { 70481 return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1))); 70482 }; 70483 70484 // Returns a function, that, when invoked, will only be triggered at most once 70485 // during a given window of time. Normally, the throttled function will run 70486 // as much as it can, without ever going more than once per `wait` duration; 70487 // but if you'd like to disable the execution on the leading edge, pass 70488 // `{leading: false}`. To disable execution on the trailing edge, ditto. 70489 _.throttle = function(func, wait, options) { 70490 var context, args, result; 70491 var timeout = null; 70492 var previous = 0; 70493 if (!options) options = {}; 70494 var later = function() { 70495 previous = options.leading === false ? 0 : _.now(); 70496 timeout = null; 70497 result = func.apply(context, args); 70498 if (!timeout) context = args = null; 70499 }; 70500 return function() { 70501 var now = _.now(); 70502 if (!previous && options.leading === false) previous = now; 70503 var remaining = wait - (now - previous); 70504 context = this; 70505 args = arguments; 70506 if (remaining <= 0 || remaining > wait) { 70507 clearTimeout(timeout); 70508 timeout = null; 70509 previous = now; 70510 result = func.apply(context, args); 70511 if (!timeout) context = args = null; 70512 } else if (!timeout && options.trailing !== false) { 70513 timeout = setTimeout(later, remaining); 70514 } 70515 return result; 70516 }; 70517 }; 70518 70519 // Returns a function, that, as long as it continues to be invoked, will not 70520 // be triggered. The function will be called after it stops being called for 70521 // N milliseconds. If `immediate` is passed, trigger the function on the 70522 // leading edge, instead of the trailing. 70523 _.debounce = function(func, wait, immediate) { 70524 var timeout, args, context, timestamp, result; 70525 70526 var later = function() { 70527 var last = _.now() - timestamp; 70528 70529 if (last < wait && last > 0) { 70530 timeout = setTimeout(later, wait - last); 70531 } else { 70532 timeout = null; 70533 if (!immediate) { 70534 result = func.apply(context, args); 70535 if (!timeout) context = args = null; 70536 } 70537 } 70538 }; 70539 70540 return function() { 70541 context = this; 70542 args = arguments; 70543 timestamp = _.now(); 70544 var callNow = immediate && !timeout; 70545 if (!timeout) timeout = setTimeout(later, wait); 70546 if (callNow) { 70547 result = func.apply(context, args); 70548 context = args = null; 70549 } 70550 70551 return result; 70552 }; 70553 }; 70554 70555 // Returns the first function passed as an argument to the second, 70556 // allowing you to adjust arguments, run code before and after, and 70557 // conditionally execute the original function. 70558 _.wrap = function(func, wrapper) { 70559 return _.partial(wrapper, func); 70560 }; 70561
70562 // Returns a negated version of the passed-in predicate. 70563 _.negate = function(predicate) { 70564 return function() { 70565 return !predicate.apply(this, arguments); 70566 }; 70567 }; 70568 70569 // Returns a function that is the composition of a list of functions, each 70570 // consuming the return value of the function that follows. 70571 _.compose = function() { 70572 var args = arguments; 70573 var start = args.length - 1; 70574 return function() { 70575 var i = start; 70576 var result = args[start].apply(this, arguments); 70577 while (i--) result = args[i].call(this, result); 70578 return result; 70579 }; 70580 }; 70581 70582 // Returns a function that will only be executed after being called N times. 70583 _.after = function(times, func) { 70584 return function() { 70585 if (--times < 1) { 70586 return func.apply(this, arguments); 70587 } 70588 }; 70589 }; 70590 70591 // Returns a function that will only be executed before being called N times. 70592 _.before = function(times, func) { 70593 var memo; 70594 return function() { 70595 if (--times > 0) { 70596 memo = func.apply(this, arguments); 70597 } else { 70598 func = null; 70599 } 70600 return memo; 70601 }; 70602 }; 70603 70604 // Returns a function that will be executed at most one time, no matter how 70605 // often you call it. Useful for lazy initialization. 70606 _.once = _.partial(_.before, 2); 70607 70608 // Object Functions 70609 // ---------------- 70610 70611 // Retrieve the names of an object's properties. 70612 // Delegates to **ECMAScript 5**'s native `Object.keys` 70613 _.keys = function(obj) { 70614 if (!_.isObject(obj)) return []; 70615 if (nativeKeys) return nativeKeys(obj); 70616 var keys = []; 70617 for (var key in obj) if (_.has(obj, key)) keys.push(key); 70618 return keys; 70619 }; 70620 70621 // Retrieve the values of an object's properties. 70622 _.values = function(obj) { 70623 var keys = _.keys(obj); 70624 var length = keys.length; 70625 var values = Array(length); 70626 for (var i = 0; i < length; i++) { 70627 values[i] = obj[keys[i]]; 70628 } 70629 return values; 70630 }; 70631 70632 // Convert an object into a list of `[key, value]` pairs. 70633 _.pairs = function(obj) { 70634 var keys = _.keys(obj); 70635 var length = keys.length; 70636 var pairs = Array(length); 70637 for (var i = 0; i < length; i++) { 70638 pairs[i] = [keys[i], obj[keys[i]]]; 70639 } 70640 return pairs; 70641 }; 70642 70643 // Invert the keys and values of an object. The values must be serializable. 70644 _.invert = function(obj) { 70645 var result = {}; 70646 var keys = _.keys(obj); 70647 for (var i = 0, length = keys.length; i < length; i++) { 70648 result[obj[keys[i]]] = keys[i]; 70649 } 70650 return result; 70651 }; 70652 70653 // Return a sorted list of the function names available on the object. 70654 // Aliased as `methods` 70655 _.functions = _.methods = function(obj) { 70656 var names = []; 70657 for (var key in obj) { 70658 if (_.isFunction(obj[key])) names.push(key); 70659 } 70660 return names.sort(); 70661 }; 70662 70663 // Extend a given object with all the properties in passed-in object(s). 70664 _.extend = function(obj) { 70665 if (!_.isObject(obj)) return obj; 70666 var source, prop; 70667 for (var i = 1, length = arguments.length; i < length; i++) { 70668 source = arguments[i]; 70669 for (prop in source) { 70670 if (hasOwnProperty.call(source, prop)) { 70671 obj[prop] = source[prop]; 70672 } 70673 } 70674 } 70675 return obj; 70676 }; 70677 70678 // Return a copy of the object only containing the whitelisted properties. 70679 _.pick = function(obj, iteratee, context) { 70680 var result = {}, key; 70681 if (obj == null) return result; 70682 if (_.isFunction(iteratee)) { 70683 iteratee = createCallback(iteratee, context); 70684 for (key in obj) { 70685 var value = obj[key]; 70686 if (iteratee(value, key, obj)) result[key] = value; 70687 } 70688 } else { 70689 var keys = concat.apply([], slice.call(arguments, 1)); 70690 obj = new Object(obj); 70691 for (var i = 0, length = keys.length; i < length; i++) { 70692 key = keys[i]; 70693 if (key in obj) result[key] = obj[key]; 70694 } 70695 } 70696 return result; 70697 }; 70698 70699 // Return a copy of the object without the blacklisted properties. 70700 _.omit = function(obj, iteratee, context) { 70701 if (_.isFunction(iteratee)) { 70702 iteratee = _.negate(iteratee); 70703 } else { 70704 var keys = _.map(concat.apply([], slice.call(arguments, 1)), String); 70705 iteratee = function(value, key) { 70706 return !_.contains(keys, key); 70707 }; 70708 } 70709 return _.pick(obj, iteratee, context); 70710 }; 70711 70712 // Fill in a given object with default properties. 70713 _.defaults = function(obj) { 70714 if (!_.isObject(obj)) return obj; 70715 for (var i = 1, length = arguments.length; i < length; i++) { 70716 var source = arguments[i]; 70717 for (var prop in source) { 70718 if (obj[prop] === void 0) obj[prop] = source[prop]; 70719 } 70720 } 70721 return obj; 70722 }; 70723 70724 // Create a (shallow-cloned) duplicate of an object. 70725 _.clone = function(obj) { 70726 if (!_.isObject(obj)) return obj; 70727 return _.isArray(obj) ? obj.slice() : _.extend({}, obj); 70728 }; 70729 70730 // Invokes interceptor with the obj, and then returns obj.
70731 // The primary purpose of this method is to "tap into" a method chain, in 70732 // order to perform operations on intermediate results within the chain. 70733 _.tap = function(obj, interceptor) { 70734 interceptor(obj); 70735 return obj; 70736 }; 70737 70738 // Internal recursive comparison function for `isEqual`. 70739 var eq = function(a, b, aStack, bStack) { 70740 // Identical objects are equal. `0 === -0`, but they aren't identical. 70741 // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal). 70742 if (a === b) return a !== 0 || 1 / a === 1 / b; 70743 // A strict comparison is necessary because `null == undefined`. 70744 if (a == null || b == null) return a === b; 70745 // Unwrap any wrapped objects. 70746 if (a instanceof _) a = a._wrapped; 70747 if (b instanceof _) b = b._wrapped; 70748 // Compare `[[Class]]` names. 70749 var className = toString.call(a); 70750 if (className !== toString.call(b)) return false; 70751 switch (className) { 70752 // Strings, numbers, regular expressions, dates, and booleans are compared by value. 70753 case '[object RegExp]': 70754 // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i') 70755 case '[object String]': 70756 // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is 70757 // equivalent to `new String("5")`. 70758 return '' + a === '' + b; 70759 case '[object Number]': 70760 // `NaN`s are equivalent, but non-reflexive. 70761 // Object(NaN) is equivalent to NaN 70762 if (+a !== +a) return +b !== +b; 70763 // An `egal` comparison is performed for other numeric values. 70764 return +a === 0 ? 1 / +a === 1 / b : +a === +b; 70765 case '[object Date]': 70766 case '[object Boolean]': 70767 // Coerce dates and booleans to numeric primitive values. Dates are compared by their 70768 // millisecond representations. Note that invalid dates with millisecond representations 70769 // of `NaN` are not equivalent. 70770 return +a === +b; 70771 } 70772 if (typeof a != 'object' || typeof b != 'object') return false; 70773 // Assume equality for cyclic structures. The algorithm for detecting cyclic 70774 // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`. 70775 var length = aStack.length; 70776 while (length--) { 70777 // Linear search. Performance is inversely proportional to the number of 70778 // unique nested structures. 70779 if (aStack[length] === a) return bStack[length] === b; 70780 } 70781 // Objects with different constructors are not equivalent, but `Object`s 70782 // from different frames are. 70783 var aCtor = a.constructor, bCtor = b.constructor; 70784 if ( 70785 aCtor !== bCtor && 70786 // Handle Object.create(x) cases 70787 'constructor' in a && 'constructor' in b && 70788 !(_.isFunction(aCtor) && aCtor instanceof aCtor && 70789 _.isFunction(bCtor) && bCtor instanceof bCtor) 70790 ) { 70791 return false; 70792 } 70793 // Add the first object to the stack of traversed objects. 70794 aStack.push(a); 70795 bStack.push(b); 70796 var size, result; 70797 // Recursively compare objects and arrays. 70798 if (className === '[object Array]') { 70799 // Compare array lengths to determine if a deep comparison is necessary. 70800 size = a.length; 70801 result = size === b.length; 70802 if (result) { 70803 // Deep compare the contents, ignoring non-numeric properties. 70804 while (size--) { 70805 if (!(result = eq(a[size], b[size], aStack, bStack))) break; 70806 } 70807 } 70808 } else { 70809 // Deep compare objects. 70810 var keys = _.keys(a), key; 70811 size = keys.length; 70812 // Ensure that both objects contain the same number of properties before comparing deep equality. 70813 result = _.keys(b).length === size; 70814 if (result) { 70815 while (size--) { 70816 // Deep compare each member 70817 key = keys[size]; 70818 if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break; 70819 } 70820 } 70821 } 70822 // Remove the first object from the stack of traversed objects. 70823 aStack.pop(); 70824 bStack.pop(); 70825 return result; 70826 }; 70827 70828 // Perform a deep comparison to check if two objects are equal. 70829 _.isEqual = function(a, b) { 70830 return eq(a, b, [], []); 70831 }; 70832 70833 // Is a given array, string, or object empty? 70834 // An "empty" object has no enumerable own-properties. 70835 _.isEmpty = function(obj) { 70836 if (obj == null) return true; 70837 if (_.isArray(obj) || _.isString(obj) || _.isArguments(obj)) return obj.length === 0; 70838 for (var key in obj) if (_.has(obj, key)) return false;
vendor: 10,883 bytes, lines 70839-71185
70839 return true; 70840 }; 70841 70842 // Is a given value a DOM element? 70843 _.isElement = function(obj) { 70844 return !!(obj && obj.nodeType === 1); 70845 }; 70846 70847 // Is a given value an array? 70848 // Delegates to ECMA5's native Array.isArray 70849 _.isArray = nativeIsArray || function(obj) { 70850 return toString.call(obj) === '[object Array]'; 70851 }; 70852 70853 // Is a given variable an object? 70854 _.isObject = function(obj) { 70855 var type = typeof obj; 70856 return type === 'function' || type === 'object' && !!obj; 70857 }; 70858 70859 // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp. 70860 _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) { 70861 _['is' + name] = function(obj) { 70862 return toString.call(obj) === '[object ' + name + ']'; 70863 }; 70864 }); 70865 70866 // Define a fallback version of the method in browsers (ahem, IE), where 70867 // there isn't any inspectable "Arguments" type. 70868 if (!_.isArguments(arguments)) { 70869 _.isArguments = function(obj) { 70870 return _.has(obj, 'callee'); 70871 }; 70872 } 70873 70874 // Optimize `isFunction` if appropriate. Work around an IE 11 bug. 70875 if (true) { 70876 _.isFunction = function(obj) { 70877 return typeof obj == 'function' || false; 70878 }; 70879 } 70880 70881 // Is a given object a finite number? 70882 _.isFinite = function(obj) { 70883 return isFinite(obj) && !isNaN(parseFloat(obj)); 70884 }; 70885 70886 // Is the given value `NaN`? (NaN is the only number which does not equal itself). 70887 _.isNaN = function(obj) { 70888 return _.isNumber(obj) && obj !== +obj; 70889 }; 70890 70891 // Is a given value a boolean? 70892 _.isBoolean = function(obj) { 70893 return obj === true || obj === false || toString.call(obj) === '[object Boolean]'; 70894 }; 70895 70896 // Is a given value equal to null? 70897 _.isNull = function(obj) { 70898 return obj === null; 70899 }; 70900 70901 // Is a given variable undefined? 70902 _.isUndefined = function(obj) { 70903 return obj === void 0; 70904 }; 70905 70906 // Shortcut function for checking if an object has a given property directly 70907 // on itself (in other words, not on a prototype). 70908 _.has = function(obj, key) { 70909 return obj != null && hasOwnProperty.call(obj, key); 70910 }; 70911 70912 // Utility Functions 70913 // ----------------- 70914 70915 // Run Underscore.js in *noConflict* mode, returning the `_` variable to its 70916 // previous owner. Returns a reference to the Underscore object. 70917 _.noConflict = function() { 70918 root._ = previousUnderscore; 70919 return this; 70920 }; 70921 70922 // Keep the identity function around for default iteratees. 70923 _.identity = function(value) { 70924 return value; 70925 }; 70926 70927 _.constant = function(value) { 70928 return function() { 70929 return value; 70930 }; 70931 }; 70932 70933 _.noop = function(){}; 70934 70935 _.property = function(key) { 70936 return function(obj) { 70937 return obj[key]; 70938 }; 70939 }; 70940 70941 // Returns a predicate for checking whether an object has a given set of `key:value` pairs. 70942 _.matches = function(attrs) { 70943 var pairs = _.pairs(attrs), length = pairs.length; 70944 return function(obj) { 70945 if (obj == null) return !length; 70946 obj = new Object(obj); 70947 for (var i = 0; i < length; i++) { 70948 var pair = pairs[i], key = pair[0]; 70949 if (pair[1] !== obj[key] || !(key in obj)) return false; 70950 } 70951 return true; 70952 }; 70953 }; 70954 70955 // Run a function **n** times. 70956 _.times = function(n, iteratee, context) { 70957 var accum = Array(Math.max(0, n)); 70958 iteratee = createCallback(iteratee, context, 1); 70959 for (var i = 0; i < n; i++) accum[i] = iteratee(i); 70960 return accum; 70961 }; 70962 70963 // Return a random integer between min and max (inclusive). 70964 _.random = function(min, max) { 70965 if (max == null) { 70966 max = min; 70967 min = 0; 70968 } 70969 return min + Math.floor(Math.random() * (max - min + 1)); 70970 }; 70971 70972 // A (possibly faster) way to get the current timestamp as an integer. 70973 _.now = Date.now || function() { 70974 return new Date().getTime(); 70975 }; 70976 70977 // List of HTML entities for escaping. 70978 var escapeMap = { 70979 '&': '&', 70980 '<': '<', 70981 '>': '>', 70982 '"': '"', 70983 "'": ''', 70984 '`': '`' 70985 }; 70986 var unescapeMap = _.invert(escapeMap); 70987 70988 // Functions for escaping and unescaping strings to/from HTML interpolation. 70989 var createEscaper = function(map) { 70990 var escaper = function(match) { 70991 return map[match]; 70992 }; 70993 // Regexes for identifying a key that needs to be escaped 70994 var source = '(?:' + _.keys(map).join('|') + ')'; 70995 var testRegexp = RegExp(source); 70996 var replaceRegexp = RegExp(source, 'g'); 70997 return function(string) { 70998 string = string == null ? '' : '' + string; 70999 return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string; 71000 }; 71001 }; 71002 _.escape = createEscaper(escapeMap); 71003 _.unescape = createEscaper(unescapeMap); 71004 71005 // If the value of the named `property` is a function then invoke it with the 71006 // `object` as context; otherwise, return it. 71007 _.result = function(object, property) { 71008 if (object == null) return void 0; 71009 var value = object[property]; 71010 return _.isFunction(value) ? object[property]() : value; 71011 }; 71012 71013 // Generate a unique integer id (unique within the entire client session). 71014 // Useful for temporary DOM ids. 71015 var idCounter = 0; 71016 _.uniqueId = function(prefix) { 71017 var id = ++idCounter + ''; 71018 return prefix ? prefix + id : id; 71019 }; 71020 71021 // By default, Underscore uses ERB-style template delimiters, change the 71022 // following template settings to use alternative delimiters. 71023 _.templateSettings = { 71024 evaluate : /<%([\s\S]+?)%>/g, 71025 interpolate : /<%=([\s\S]+?)%>/g, 71026 escape : /<%-([\s\S]+?)%>/g 71027 }; 71028 71029 // When customizing `templateSettings`, if you don't want to define an 71030 // interpolation, evaluation or escaping regex, we need one that is 71031 // guaranteed not to match. 71032 var noMatch = /(.)^/; 71033 71034 // Certain characters need to be escaped so that they can be put into a 71035 // string literal. 71036 var escapes = { 71037 "'": "'", 71038 '\\': '\\', 71039 '\r': 'r', 71040 '\n': 'n', 71041 '\u2028': 'u2028', 71042 '\u2029': 'u2029' 71043 }; 71044 71045 var escaper = /\\|'|\r|\n|\u2028|\u2029/g; 71046 71047 var escapeChar = function(match) { 71048 return '\\' + escapes[match]; 71049 }; 71050 71051 // JavaScript micro-templating, similar to John Resig's implementation. 71052 // Underscore templating handles arbitrary delimiters, preserves whitespace, 71053 // and correctly escapes quotes within interpolated code. 71054 // NB: `oldSettings` only exists for backwards compatibility. 71055 _.template = function(text, settings, oldSettings) { 71056 if (!settings && oldSettings) settings = oldSettings; 71057 settings = _.defaults({}, settings, _.templateSettings); 71058 71059 // Combine delimiters into one regular expression via alternation. 71060 var matcher = RegExp([ 71061 (settings.escape || noMatch).source, 71062 (settings.interpolate || noMatch).source, 71063 (settings.evaluate || noMatch).source 71064 ].join('|') + '|$', 'g'); 71065 71066 // Compile the template source, escaping string literals appropriately. 71067 var index = 0; 71068 var source = "__p+='"; 71069 text.replace(matcher, function(match, escape, interpolate, evaluate, offset) { 71070 source += text.slice(index, offset).replace(escaper, escapeChar); 71071 index = offset + match.length; 71072 71073 if (escape) { 71074 source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'"; 71075 } else if (interpolate) { 71076 source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'"; 71077 } else if (evaluate) { 71078 source += "';\n" + evaluate + "\n__p+='"; 71079 } 71080 71081 // Adobe VMs need the match returned to produce the correct offest. 71082 return match; 71083 }); 71084 source += "';\n"; 71085 71086 // If a variable is not specified, place data values in local scope. 71087 if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n'; 71088 71089 source = "var __t,__p='',__j=Array.prototype.join," + 71090 "print=function(){__p+=__j.call(arguments,'');};\n" + 71091 source + 'return __p;\n'; 71092 71093 try { 71094 var render = new Function(settings.variable || 'obj', '_', source); 71095 } catch (e) { 71096 e.source = source; 71097 throw e; 71098 } 71099 71100 var template = function(data) { 71101 return render.call(this, data, _); 71102 }; 71103 71104 // Provide the compiled source as a convenience for precompilation. 71105 var argument = settings.variable || 'obj'; 71106 template.source = 'function(' + argument + '){\n' + source + '}'; 71107 71108 return template; 71109 }; 71110 71111 // Add a "chain" function. Start chaining a wrapped Underscore object. 71112 _.chain = function(obj) { 71113 var instance = _(obj); 71114 instance._chain = true; 71115 return instance; 71116 }; 71117 71118 // OOP 71119 // --------------- 71120 // If Underscore is called as a function, it returns a wrapped object that 71121 // can be used OO-style. This wrapper holds altered versions of all the 71122 // underscore functions. Wrapped objects may be chained. 71123 71124 // Helper function to continue chaining intermediate results. 71125 var result = function(obj) { 71126 return this._chain ? _(obj).chain() : obj; 71127 }; 71128 71129 // Add your own custom functions to the Underscore object. 71130 _.mixin = function(obj) { 71131 _.each(_.functions(obj), function(name) { 71132 var func = _[name] = obj[name]; 71133 _.prototype[name] = function() { 71134 var args = [this._wrapped]; 71135 push.apply(args, arguments); 71136 return result.call(this, func.apply(_, args)); 71137 }; 71138 }); 71139 }; 71140 71141 // Add all of the Underscore functions to the wrapper object. 71142 _.mixin(_); 71143 71144 // Add all mutator Array functions to the wrapper. 71145 _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) { 71146 var method = ArrayProto[name]; 71147 _.prototype[name] = function() { 71148 var obj = this._wrapped; 71149 method.apply(obj, arguments); 71150 if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0]; 71151 return result.call(this, obj); 71152 }; 71153 }); 71154 71155 // Add all accessor Array functions to the wrapper. 71156 _.each(['concat', 'join', 'slice'], function(name) { 71157 var method = ArrayProto[name]; 71158 _.prototype[name] = function() { 71159 return result.call(this, method.apply(this._wrapped, arguments)); 71160 }; 71161 }); 71162 71163 // Extracts the result from a wrapped and chained object. 71164 _.prototype.value = function() { 71165 return this._wrapped; 71166 }; 71167 71168 // AMD registration happens at the end for compatibility with AMD loaders 71169 // that may not enforce next-turn semantics on modules. Even though general 71170 // practice for AMD registration is to be anonymous, underscore registers 71171 // as a named module because, like jQuery, it is a base library that is 71172 // popular enough to be bundled in a third party lib, but not be part of 71173 // an AMD load request. Those cases could generate an error when an 71174 // anonymous define() is called outside of a loader request. 71175 if (true) { 71176 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function() { 71177 return _; 71178 }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 71179 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 71180 } 71181}.call(this)); 71182 71183 71184/***/ }), 71185/* 241 */
71186/***/ (function(module, exports) { 71187 71188/* WEBPACK VAR INJECTION */(function(__webpack_amd_options__) {/* globals __webpack_amd_options__ */ 71189module.exports = __webpack_amd_options__; 71190 71191/* WEBPACK VAR INJECTION */}.call(exports, {})) 71192 71193/***/ }), 71194/* 242 */ 71195/***/ (function(module, exports) { 71196 71197module.exports = function(originalModule) { 71198 if(!originalModule.webpackPolyfill) { 71199 var module = Object.create(originalModule); 71200 // module.parent = undefined by default 71201 if(!module.children) module.children = []; 71202 Object.defineProperty(module, "loaded", { 71203 enumerable: true, 71204 get: function() { 71205 return module.l; 71206 } 71207 }); 71208 Object.defineProperty(module, "id", { 71209 enumerable: true, 71210 get: function() { 71211 return module.i; 71212 } 71213 }); 71214 Object.defineProperty(module, "exports", { 71215 enumerable: true, 71216 }); 71217 module.webpackPolyfill = 1; 71218 } 71219 return module; 71220}; 71221 71222 71223/***/ }), 71224/* 243 */ 71225/***/ (function(module, exports, __webpack_require__) { 71226 71227__webpack_require__(157); 71228module.exports = __webpack_require__(158); 71229 71230 71231/***/ }) 71232/******/ ]);
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.