vendor: 5,591 bytes, lines 1-207
1//! moment.js 2//! version : 2.29.4 3//! authors : Tim Wood, Iskren Chernev, Moment.js contributors 4//! license : MIT 5//! momentjs.com 6 7;(function (global, factory) { 8 typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : 9 typeof define === 'function' && define.amd ? define(factory) : 10 global.moment = factory() 11}(this, (function () { 'use strict'; 12 13 var hookCallback; 14 15 function hooks() { 16 return hookCallback.apply(null, arguments); 17 } 18 19 // This is done to register the method called with moment() 20 // without creating circular dependencies. 21 function setHookCallback(callback) { 22 hookCallback = callback; 23 } 24 25 function isArray(input) { 26 return ( 27 input instanceof Array || 28 Object.prototype.toString.call(input) === '[object Array]' 29 ); 30 } 31 32 function isObject(input) { 33 // IE8 will treat undefined and null as object if it wasn't for 34 // input != null 35 return ( 36 input != null && 37 Object.prototype.toString.call(input) === '[object Object]' 38 ); 39 } 40 41 function hasOwnProp(a, b) { 42 return Object.prototype.hasOwnProperty.call(a, b); 43 } 44 45 function isObjectEmpty(obj) { 46 if (Object.getOwnPropertyNames) { 47 return Object.getOwnPropertyNames(obj).length === 0; 48 } else { 49 var k; 50 for (k in obj) { 51 if (hasOwnProp(obj, k)) { 52 return false; 53 } 54 } 55 return true; 56 } 57 } 58 59 function isUndefined(input) { 60 return input === void 0; 61 } 62 63 function isNumber(input) { 64 return ( 65 typeof input === 'number' || 66 Object.prototype.toString.call(input) === '[object Number]' 67 ); 68 } 69 70 function isDate(input) { 71 return ( 72 input instanceof Date || 73 Object.prototype.toString.call(input) === '[object Date]' 74 ); 75 } 76 77 function map(arr, fn) { 78 var res = [], 79 i, 80 arrLen = arr.length; 81 for (i = 0; i < arrLen; ++i) { 82 res.push(fn(arr[i], i)); 83 } 84 return res; 85 } 86 87 function extend(a, b) { 88 for (var i in b) { 89 if (hasOwnProp(b, i)) { 90 a[i] = b[i]; 91 } 92 } 93 94 if (hasOwnProp(b, 'toString')) { 95 a.toString = b.toString; 96 } 97 98 if (hasOwnProp(b, 'valueOf')) { 99 a.valueOf = b.valueOf; 100 } 101 102 return a; 103 } 104 105 function createUTC(input, format, locale, strict) { 106 return createLocalOrUTC(input, format, locale, strict, true).utc(); 107 } 108 109 function defaultParsingFlags() { 110 // We need to deep clone this object. 111 return { 112 empty: false, 113 unusedTokens: [], 114 unusedInput: [], 115 overflow: -2, 116 charsLeftOver: 0, 117 nullInput: false, 118 invalidEra: null, 119 invalidMonth: null, 120 invalidFormat: false, 121 userInvalidated: false, 122 iso: false, 123 parsedDateParts: [], 124 era: null, 125 meridiem: null, 126 rfc2822: false, 127 weekdayMismatch: false, 128 }; 129 } 130 131 function getParsingFlags(m) { 132 if (m._pf == null) { 133 m._pf = defaultParsingFlags(); 134 } 135 return m._pf; 136 } 137 138 var some; 139 if (Array.prototype.some) { 140 some = Array.prototype.some; 141 } else { 142 some = function (fun) { 143 var t = Object(this), 144 len = t.length >>> 0, 145 i; 146 147 for (i = 0; i < len; i++) { 148 if (i in t && fun.call(this, t[i], i, t)) { 149 return true; 150 } 151 } 152 153 return false; 154 }; 155 } 156 157 function isValid(m) { 158 if (m._isValid == null) { 159 var flags = getParsingFlags(m), 160 parsedParts = some.call(flags.parsedDateParts, function (i) { 161 return i != null; 162 }), 163 isNowValid = 164 !isNaN(m._d.getTime()) && 165 flags.overflow < 0 && 166 !flags.empty && 167 !flags.invalidEra && 168 !flags.invalidMonth && 169 !flags.invalidWeekday && 170 !flags.weekdayMismatch && 171 !flags.nullInput && 172 !flags.invalidFormat && 173 !flags.userInvalidated && 174 (!flags.meridiem || (flags.meridiem && parsedParts)); 175 176 if (m._strict) { 177 isNowValid = 178 isNowValid && 179 flags.charsLeftOver === 0 && 180 flags.unusedTokens.length === 0 && 181 flags.bigHour === undefined; 182 } 183 184 if (Object.isFrozen == null || !Object.isFrozen(m)) { 185 m._isValid = isNowValid; 186 } else { 187 return isNowValid; 188 } 189 } 190 return m._isValid; 191 } 192 193 function createInvalid(flags) { 194 var m = createUTC(NaN); 195 if (flags != null) { 196 extend(getParsingFlags(m), flags); 197 } else { 198 getParsingFlags(m).userInvalidated = true; 199 } 200 201 return m; 202 } 203 204 // Plugins that add properties should also add the key here (null value), 205 // so we can properly clone ourselves. 206 var momentProperties = (hooks.momentProperties = []), 207 updateInProgress = false;
vendor: 7,422 bytes, lines 208-455
208 209 function copyConfig(to, from) { 210 var i, 211 prop, 212 val, 213 momentPropertiesLen = momentProperties.length; 214 215 if (!isUndefined(from._isAMomentObject)) { 216 to._isAMomentObject = from._isAMomentObject; 217 } 218 if (!isUndefined(from._i)) { 219 to._i = from._i; 220 } 221 if (!isUndefined(from._f)) { 222 to._f = from._f; 223 } 224 if (!isUndefined(from._l)) { 225 to._l = from._l; 226 } 227 if (!isUndefined(from._strict)) { 228 to._strict = from._strict; 229 } 230 if (!isUndefined(from._tzm)) { 231 to._tzm = from._tzm; 232 } 233 if (!isUndefined(from._isUTC)) { 234 to._isUTC = from._isUTC; 235 } 236 if (!isUndefined(from._offset)) { 237 to._offset = from._offset; 238 } 239 if (!isUndefined(from._pf)) { 240 to._pf = getParsingFlags(from); 241 } 242 if (!isUndefined(from._locale)) { 243 to._locale = from._locale; 244 } 245 246 if (momentPropertiesLen > 0) { 247 for (i = 0; i < momentPropertiesLen; i++) { 248 prop = momentProperties[i]; 249 val = from[prop]; 250 if (!isUndefined(val)) { 251 to[prop] = val; 252 } 253 } 254 } 255 256 return to; 257 } 258 259 // Moment prototype object 260 function Moment(config) { 261 copyConfig(this, config); 262 this._d = new Date(config._d != null ? config._d.getTime() : NaN); 263 if (!this.isValid()) { 264 this._d = new Date(NaN); 265 } 266 // Prevent infinite loop in case updateOffset creates new moment 267 // objects. 268 if (updateInProgress === false) { 269 updateInProgress = true; 270 hooks.updateOffset(this); 271 updateInProgress = false; 272 } 273 } 274 275 function isMoment(obj) { 276 return ( 277 obj instanceof Moment || (obj != null && obj._isAMomentObject != null) 278 ); 279 } 280 281 function warn(msg) { 282 if ( 283 hooks.suppressDeprecationWarnings === false && 284 typeof console !== 'undefined' && 285 console.warn 286 ) { 287 console.warn('Deprecation warning: ' + msg); 288 } 289 } 290 291 function deprecate(msg, fn) { 292 var firstTime = true; 293 294 return extend(function () { 295 if (hooks.deprecationHandler != null) { 296 hooks.deprecationHandler(null, msg); 297 } 298 if (firstTime) { 299 var args = [], 300 arg, 301 i, 302 key, 303 argLen = arguments.length; 304 for (i = 0; i < argLen; i++) { 305 arg = ''; 306 if (typeof arguments[i] === 'object') { 307 arg += '\n[' + i + '] '; 308 for (key in arguments[0]) { 309 if (hasOwnProp(arguments[0], key)) { 310 arg += key + ': ' + arguments[0][key] + ', '; 311 } 312 } 313 arg = arg.slice(0, -2); // Remove trailing comma and space 314 } else { 315 arg = arguments[i]; 316 } 317 args.push(arg); 318 } 319 warn( 320 msg + 321 '\nArguments: ' + 322 Array.prototype.slice.call(args).join('') + 323 '\n' + 324 new Error().stack 325 ); 326 firstTime = false; 327 } 328 return fn.apply(this, arguments); 329 }, fn); 330 } 331 332 var deprecations = {}; 333 334 function deprecateSimple(name, msg) { 335 if (hooks.deprecationHandler != null) { 336 hooks.deprecationHandler(name, msg); 337 } 338 if (!deprecations[name]) { 339 warn(msg); 340 deprecations[name] = true; 341 } 342 } 343 344 hooks.suppressDeprecationWarnings = false; 345 hooks.deprecationHandler = null; 346 347 function isFunction(input) { 348 return ( 349 (typeof Function !== 'undefined' && input instanceof Function) || 350 Object.prototype.toString.call(input) === '[object Function]' 351 ); 352 } 353 354 function set(config) { 355 var prop, i; 356 for (i in config) { 357 if (hasOwnProp(config, i)) { 358 prop = config[i]; 359 if (isFunction(prop)) { 360 this[i] = prop; 361 } else { 362 this['_' + i] = prop; 363 } 364 } 365 } 366 this._config = config; 367 // Lenient ordinal parsing accepts just a number in addition to 368 // number + (possibly) stuff coming from _dayOfMonthOrdinalParse. 369 // TODO: Remove "ordinalParse" fallback in next major release. 370 this._dayOfMonthOrdinalParseLenient = new RegExp( 371 (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) + 372 '|' + 373 /\d{1,2}/.source 374 ); 375 } 376 377 function mergeConfigs(parentConfig, childConfig) { 378 var res = extend({}, parentConfig), 379 prop; 380 for (prop in childConfig) { 381 if (hasOwnProp(childConfig, prop)) { 382 if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) { 383 res[prop] = {}; 384 extend(res[prop], parentConfig[prop]); 385 extend(res[prop], childConfig[prop]); 386 } else if (childConfig[prop] != null) { 387 res[prop] = childConfig[prop]; 388 } else { 389 delete res[prop]; 390 } 391 } 392 } 393 for (prop in parentConfig) { 394 if ( 395 hasOwnProp(parentConfig, prop) && 396 !hasOwnProp(childConfig, prop) && 397 isObject(parentConfig[prop]) 398 ) { 399 // make sure changes to properties don't modify parent config 400 res[prop] = extend({}, res[prop]); 401 } 402 } 403 return res; 404 } 405 406 function Locale(config) { 407 if (config != null) { 408 this.set(config); 409 } 410 } 411 412 var keys; 413 414 if (Object.keys) { 415 keys = Object.keys; 416 } else { 417 keys = function (obj) { 418 var i, 419 res = []; 420 for (i in obj) { 421 if (hasOwnProp(obj, i)) { 422 res.push(i); 423 } 424 } 425 return res; 426 }; 427 } 428 429 var defaultCalendar = { 430 sameDay: '[Today at] LT', 431 nextDay: '[Tomorrow at] LT', 432 nextWeek: 'dddd [at] LT', 433 lastDay: '[Yesterday at] LT', 434 lastWeek: '[Last] dddd [at] LT', 435 sameElse: 'L', 436 }; 437 438 function calendar(key, mom, now) { 439 var output = this._calendar[key] || this._calendar['sameElse']; 440 return isFunction(output) ? output.call(mom, now) : output; 441 } 442 443 function zeroFill(number, targetLength, forceSign) { 444 var absNumber = '' + Math.abs(number), 445 zerosToFill = targetLength - absNumber.length, 446 sign = number >= 0; 447 return ( 448 (sign ? (forceSign ? '+' : '') : '-') + 449 Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + 450 absNumber 451 ); 452 } 453 454 var formattingTokens = 455
vendor: 8,563 bytes, lines 455-759
455 /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g, 456 localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g, 457 formatFunctions = {}, 458 formatTokenFunctions = {}; 459 460 // token: 'M' 461 // padded: ['MM', 2] 462 // ordinal: 'Mo' 463 // callback: function () { this.month() + 1 } 464 function addFormatToken(token, padded, ordinal, callback) { 465 var func = callback; 466 if (typeof callback === 'string') { 467 func = function () { 468 return this[callback](); 469 }; 470 } 471 if (token) { 472 formatTokenFunctions[token] = func; 473 } 474 if (padded) { 475 formatTokenFunctions[padded[0]] = function () { 476 return zeroFill(func.apply(this, arguments), padded[1], padded[2]); 477 }; 478 } 479 if (ordinal) { 480 formatTokenFunctions[ordinal] = function () { 481 return this.localeData().ordinal( 482 func.apply(this, arguments), 483 token 484 ); 485 }; 486 } 487 } 488 489 function removeFormattingTokens(input) { 490 if (input.match(/\[[\s\S]/)) { 491 return input.replace(/^\[|\]$/g, ''); 492 } 493 return input.replace(/\\/g, ''); 494 } 495 496 function makeFormatFunction(format) { 497 var array = format.match(formattingTokens), 498 i, 499 length; 500 501 for (i = 0, length = array.length; i < length; i++) { 502 if (formatTokenFunctions[array[i]]) { 503 array[i] = formatTokenFunctions[array[i]]; 504 } else { 505 array[i] = removeFormattingTokens(array[i]); 506 } 507 } 508 509 return function (mom) { 510 var output = '', 511 i; 512 for (i = 0; i < length; i++) { 513 output += isFunction(array[i]) 514 ? array[i].call(mom, format) 515 : array[i]; 516 } 517 return output; 518 }; 519 } 520 521 // format date using native date object 522 function formatMoment(m, format) { 523 if (!m.isValid()) { 524 return m.localeData().invalidDate(); 525 } 526 527 format = expandFormat(format, m.localeData()); 528 formatFunctions[format] = 529 formatFunctions[format] || makeFormatFunction(format); 530 531 return formatFunctions[format](m); 532 } 533 534 function expandFormat(format, locale) { 535 var i = 5; 536 537 function replaceLongDateFormatTokens(input) { 538 return locale.longDateFormat(input) || input; 539 } 540 541 localFormattingTokens.lastIndex = 0; 542 while (i >= 0 && localFormattingTokens.test(format)) { 543 format = format.replace( 544 localFormattingTokens, 545 replaceLongDateFormatTokens 546 ); 547 localFormattingTokens.lastIndex = 0; 548 i -= 1; 549 } 550 551 return format; 552 } 553 554 var defaultLongDateFormat = { 555 LTS: 'h:mm:ss A', 556 LT: 'h:mm A', 557 L: 'MM/DD/YYYY', 558 LL: 'MMMM D, YYYY', 559 LLL: 'MMMM D, YYYY h:mm A', 560 LLLL: 'dddd, MMMM D, YYYY h:mm A', 561 }; 562 563 function longDateFormat(key) { 564 var format = this._longDateFormat[key], 565 formatUpper = this._longDateFormat[key.toUpperCase()]; 566 567 if (format || !formatUpper) { 568 return format; 569 } 570 571 this._longDateFormat[key] = formatUpper 572 .match(formattingTokens) 573 .map(function (tok) { 574 if ( 575 tok === 'MMMM' || 576 tok === 'MM' || 577 tok === 'DD' || 578 tok === 'dddd' 579 ) { 580 return tok.slice(1); 581 } 582 return tok; 583 }) 584 .join(''); 585 586 return this._longDateFormat[key]; 587 } 588 589 var defaultInvalidDate = 'Invalid date'; 590 591 function invalidDate() { 592 return this._invalidDate; 593 } 594 595 var defaultOrdinal = '%d', 596 defaultDayOfMonthOrdinalParse = /\d{1,2}/; 597 598 function ordinal(number) { 599 return this._ordinal.replace('%d', number); 600 } 601 602 var defaultRelativeTime = { 603 future: 'in %s', 604 past: '%s ago', 605 s: 'a few seconds', 606 ss: '%d seconds', 607 m: 'a minute', 608 mm: '%d minutes', 609 h: 'an hour', 610 hh: '%d hours', 611 d: 'a day', 612 dd: '%d days', 613 w: 'a week', 614 ww: '%d weeks', 615 M: 'a month', 616 MM: '%d months', 617 y: 'a year', 618 yy: '%d years', 619 }; 620 621 function relativeTime(number, withoutSuffix, string, isFuture) { 622 var output = this._relativeTime[string]; 623 return isFunction(output) 624 ? output(number, withoutSuffix, string, isFuture) 625 : output.replace(/%d/i, number); 626 } 627 628 function pastFuture(diff, output) { 629 var format = this._relativeTime[diff > 0 ? 'future' : 'past']; 630 return isFunction(format) ? format(output) : format.replace(/%s/i, output); 631 } 632 633 var aliases = {}; 634 635 function addUnitAlias(unit, shorthand) { 636 var lowerCase = unit.toLowerCase(); 637 aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit; 638 } 639 640 function normalizeUnits(units) { 641 return typeof units === 'string' 642 ? aliases[units] || aliases[units.toLowerCase()] 643 : undefined; 644 } 645 646 function normalizeObjectUnits(inputObject) { 647 var normalizedInput = {}, 648 normalizedProp, 649 prop; 650 651 for (prop in inputObject) { 652 if (hasOwnProp(inputObject, prop)) { 653 normalizedProp = normalizeUnits(prop); 654 if (normalizedProp) { 655 normalizedInput[normalizedProp] = inputObject[prop]; 656 } 657 } 658 } 659 660 return normalizedInput; 661 } 662 663 var priorities = {}; 664 665 function addUnitPriority(unit, priority) { 666 priorities[unit] = priority; 667 } 668 669 function getPrioritizedUnits(unitsObj) { 670 var units = [], 671 u; 672 for (u in unitsObj) { 673 if (hasOwnProp(unitsObj, u)) { 674 units.push({ unit: u, priority: priorities[u] }); 675 } 676 } 677 units.sort(function (a, b) { 678 return a.priority - b.priority; 679 }); 680 return units; 681 } 682 683 function isLeapYear(year) { 684 return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0; 685 } 686 687 function absFloor(number) { 688 if (number < 0) { 689 // -0 -> 0 690 return Math.ceil(number) || 0; 691 } else { 692 return Math.floor(number); 693 } 694 } 695 696 function toInt(argumentForCoercion) { 697 var coercedNumber = +argumentForCoercion, 698 value = 0; 699 700 if (coercedNumber !== 0 && isFinite(coercedNumber)) { 701 value = absFloor(coercedNumber); 702 } 703 704 return value; 705 } 706 707 function makeGetSet(unit, keepTime) { 708 return function (value) { 709 if (value != null) { 710 set$1(this, unit, value); 711 hooks.updateOffset(this, keepTime); 712 return this; 713 } else { 714 return get(this, unit); 715 } 716 }; 717 } 718 719 function get(mom, unit) { 720 return mom.isValid() 721 ? mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() 722 : NaN; 723 } 724 725 function set$1(mom, unit, value) { 726 if (mom.isValid() && !isNaN(value)) { 727 if ( 728 unit === 'FullYear' && 729 isLeapYear(mom.year()) && 730 mom.month() === 1 && 731 mom.date() === 29 732 ) { 733 value = toInt(value); 734 mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit]( 735 value, 736 mom.month(), 737 daysInMonth(value, mom.month()) 738 ); 739 } else { 740 mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value); 741 } 742 } 743 } 744 745 // MOMENTS 746 747 function stringGet(units) { 748 units = normalizeUnits(units); 749 if (isFunction(this[units])) { 750 return this[units](); 751 } 752 return this; 753 } 754 755 function stringSet(units, value) { 756 if (typeof units === 'object') { 757 units = normalizeObjectUnits(units); 758 var prioritized = getPrioritizedUnits(units), 759 i
vendor: 5,547 bytes, lines 759-945
759, 760 prioritizedLen = prioritized.length; 761 for (i = 0; i < prioritizedLen; i++) { 762 this[prioritized[i].unit](units[prioritized[i].unit]); 763 } 764 } else { 765 units = normalizeUnits(units); 766 if (isFunction(this[units])) { 767 return this[units](value); 768 } 769 } 770 return this; 771 } 772 773 var match1 = /\d/, // 0 - 9 774 match2 = /\d\d/, // 00 - 99 775 match3 = /\d{3}/, // 000 - 999 776 match4 = /\d{4}/, // 0000 - 9999 777 match6 = /[+-]?\d{6}/, // -999999 - 999999 778 match1to2 = /\d\d?/, // 0 - 99 779 match3to4 = /\d\d\d\d?/, // 999 - 9999 780 match5to6 = /\d\d\d\d\d\d?/, // 99999 - 999999 781 match1to3 = /\d{1,3}/, // 0 - 999 782 match1to4 = /\d{1,4}/, // 0 - 9999 783 match1to6 = /[+-]?\d{1,6}/, // -999999 - 999999 784 matchUnsigned = /\d+/, // 0 - inf 785 matchSigned = /[+-]?\d+/, // -inf - inf 786 matchOffset = /Z|[+-]\d\d:?\d\d/gi, // +00:00 -00:00 +0000 -0000 or Z 787 matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi, // +00 -00 +00:00 -00:00 +0000 -0000 or Z 788 matchTimestamp = /[+-]?\d+(\.\d{1,3})?/, // 123456789 123456789.123 789 // any word (or two) characters or numbers including two/three word month in arabic. 790 // includes scottish gaelic two word and hyphenated months 791 matchWord = 792 /[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, 793 regexes; 794 795 regexes = {}; 796 797 function addRegexToken(token, regex, strictRegex) { 798 regexes[token] = isFunction(regex) 799 ? regex 800 : function (isStrict, localeData) { 801 return isStrict && strictRegex ? strictRegex : regex; 802 }; 803 } 804 805 function getParseRegexForToken(token, config) { 806 if (!hasOwnProp(regexes, token)) { 807 return new RegExp(unescapeFormat(token)); 808 } 809 810 return regexes[token](config._strict, config._locale); 811 } 812 813 // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript 814 function unescapeFormat(s) { 815 return regexEscape( 816 s 817 .replace('\\', '') 818 .replace( 819 /\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, 820 function (matched, p1, p2, p3, p4) { 821 return p1 || p2 || p3 || p4; 822 } 823 ) 824 ); 825 } 826 827 function regexEscape(s) { 828 return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'); 829 } 830 831 var tokens = {}; 832 833 function addParseToken(token, callback) { 834 var i, 835 func = callback, 836 tokenLen; 837 if (typeof token === 'string') { 838 token = [token]; 839 } 840 if (isNumber(callback)) { 841 func = function (input, array) { 842 array[callback] = toInt(input); 843 }; 844 } 845 tokenLen = token.length; 846 for (i = 0; i < tokenLen; i++) { 847 tokens[token[i]] = func; 848 } 849 } 850 851 function addWeekParseToken(token, callback) { 852 addParseToken(token, function (input, array, config, token) { 853 config._w = config._w || {}; 854 callback(input, config._w, config, token); 855 }); 856 } 857 858 function addTimeToArrayFromToken(token, input, config) { 859 if (input != null && hasOwnProp(tokens, token)) { 860 tokens[token](input, config._a, config, token); 861 } 862 } 863 864 var YEAR = 0, 865 MONTH = 1, 866 DATE = 2, 867 HOUR = 3, 868 MINUTE = 4, 869 SECOND = 5, 870 MILLISECOND = 6, 871 WEEK = 7, 872 WEEKDAY = 8; 873 874 function mod(n, x) { 875 return ((n % x) + x) % x; 876 } 877 878 var indexOf; 879 880 if (Array.prototype.indexOf) { 881 indexOf = Array.prototype.indexOf; 882 } else { 883 indexOf = function (o) { 884 // I know 885 var i; 886 for (i = 0; i < this.length; ++i) { 887 if (this[i] === o) { 888 return i; 889 } 890 } 891 return -1; 892 }; 893 } 894 895 function daysInMonth(year, month) { 896 if (isNaN(year) || isNaN(month)) { 897 return NaN; 898 } 899 var modMonth = mod(month, 12); 900 year += (month - modMonth) / 12; 901 return modMonth === 1 902 ? isLeapYear(year) 903 ? 29 904 : 28 905 : 31 - ((modMonth % 7) % 2); 906 } 907 908 // FORMATTING 909 910 addFormatToken('M', ['MM', 2], 'Mo', function () { 911 return this.month() + 1; 912 }); 913 914 addFormatToken('MMM', 0, 0, function (format) { 915 return this.localeData().monthsShort(this, format); 916 }); 917 918 addFormatToken('MMMM', 0, 0, function (format) { 919 return this.localeData().months(this, format); 920 }); 921 922 // ALIASES 923 924 addUnitAlias('month', 'M'); 925 926 // PRIORITY 927 928 addUnitPriority('month', 8); 929 930 // PARSING 931 932 addRegexToken('M', match1to2); 933 addRegexToken('MM', match1to2, match2); 934 addRegexToken('MMM', function (isStrict, locale) { 935 return locale.monthsShortRegex(isStrict); 936 }); 937 addRegexToken('MMMM', function (isStrict, locale) { 938 return locale.monthsRegex(isStrict); 939 }); 940 941 addParseToken(['M', 'MM'], function (input, array) { 942 array[MONTH] = toInt(input) - 1; 943 }); 944 945 addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
946 var month = config._locale.monthsParse(input, token, config._strict); 947 // if we didn't find a month name, mark the date as invalid. 948 if (month != null) { 949 array[MONTH] = month; 950 } else { 951 getParsingFlags(config).invalidMonth = input; 952 } 953 }); 954 955 // LOCALES 956 957 var defaultLocaleMonths = 958 'January_February_March_April_May_June_July_August_September_October_November_December'.split( 959 '_' 960 ), 961 defaultLocaleMonthsShort = 962 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'
vendor: 13,773 bytes, lines 962-1404
962), 963 MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/, 964 defaultMonthsShortRegex = matchWord, 965 defaultMonthsRegex = matchWord; 966 967 function localeMonths(m, format) { 968 if (!m) { 969 return isArray(this._months) 970 ? this._months 971 : this._months['standalone']; 972 } 973 return isArray(this._months) 974 ? this._months[m.month()] 975 : this._months[ 976 (this._months.isFormat || MONTHS_IN_FORMAT).test(format) 977 ? 'format' 978 : 'standalone' 979 ][m.month()]; 980 } 981 982 function localeMonthsShort(m, format) { 983 if (!m) { 984 return isArray(this._monthsShort) 985 ? this._monthsShort 986 : this._monthsShort['standalone']; 987 } 988 return isArray(this._monthsShort) 989 ? this._monthsShort[m.month()] 990 : this._monthsShort[ 991 MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone' 992 ][m.month()]; 993 } 994 995 function handleStrictParse(monthName, format, strict) { 996 var i, 997 ii, 998 mom, 999 llc = monthName.toLocaleLowerCase(); 1000 if (!this._monthsParse) { 1001 // this is not used 1002 this._monthsParse = []; 1003 this._longMonthsParse = []; 1004 this._shortMonthsParse = []; 1005 for (i = 0; i < 12; ++i) { 1006 mom = createUTC([2000, i]); 1007 this._shortMonthsParse[i] = this.monthsShort( 1008 mom, 1009 '' 1010 ).toLocaleLowerCase(); 1011 this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase(); 1012 } 1013 } 1014 1015 if (strict) { 1016 if (format === 'MMM') { 1017 ii = indexOf.call(this._shortMonthsParse, llc); 1018 return ii !== -1 ? ii : null; 1019 } else { 1020 ii = indexOf.call(this._longMonthsParse, llc); 1021 return ii !== -1 ? ii : null; 1022 } 1023 } else { 1024 if (format === 'MMM') { 1025 ii = indexOf.call(this._shortMonthsParse, llc); 1026 if (ii !== -1) { 1027 return ii; 1028 } 1029 ii = indexOf.call(this._longMonthsParse, llc); 1030 return ii !== -1 ? ii : null; 1031 } else { 1032 ii = indexOf.call(this._longMonthsParse, llc); 1033 if (ii !== -1) { 1034 return ii; 1035 } 1036 ii = indexOf.call(this._shortMonthsParse, llc); 1037 return ii !== -1 ? ii : null; 1038 } 1039 } 1040 } 1041 1042 function localeMonthsParse(monthName, format, strict) { 1043 var i, mom, regex; 1044 1045 if (this._monthsParseExact) { 1046 return handleStrictParse.call(this, monthName, format, strict); 1047 } 1048 1049 if (!this._monthsParse) { 1050 this._monthsParse = []; 1051 this._longMonthsParse = []; 1052 this._shortMonthsParse = []; 1053 } 1054 1055 // TODO: add sorting 1056 // Sorting makes sure if one month (or abbr) is a prefix of another 1057 // see sorting in computeMonthsParse 1058 for (i = 0; i < 12; i++) { 1059 // make the regex if we don't have it already 1060 mom = createUTC([2000, i]); 1061 if (strict && !this._longMonthsParse[i]) { 1062 this._longMonthsParse[i] = new RegExp( 1063 '^' + this.months(mom, '').replace('.', '') + '$', 1064 'i' 1065 ); 1066 this._shortMonthsParse[i] = new RegExp( 1067 '^' + this.monthsShort(mom, '').replace('.', '') + '$', 1068 'i' 1069 ); 1070 } 1071 if (!strict && !this._monthsParse[i]) { 1072 regex = 1073 '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, ''); 1074 this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i'); 1075 } 1076 // test the regex 1077 if ( 1078 strict && 1079 format === 'MMMM' && 1080 this._longMonthsParse[i].test(monthName) 1081 ) { 1082 return i; 1083 } else if ( 1084 strict && 1085 format === 'MMM' && 1086 this._shortMonthsParse[i].test(monthName) 1087 ) { 1088 return i; 1089 } else if (!strict && this._monthsParse[i].test(monthName)) { 1090 return i; 1091 } 1092 } 1093 } 1094 1095 // MOMENTS 1096 1097 function setMonth(mom, value) { 1098 var dayOfMonth; 1099 1100 if (!mom.isValid()) { 1101 // No op 1102 return mom; 1103 } 1104 1105 if (typeof value === 'string') { 1106 if (/^\d+$/.test(value)) { 1107 value = toInt(value); 1108 } else { 1109 value = mom.localeData().monthsParse(value); 1110 // TODO: Another silent failure? 1111 if (!isNumber(value)) { 1112 return mom; 1113 } 1114 } 1115 } 1116 1117 dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value)); 1118 mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth); 1119 return mom; 1120 } 1121 1122 function getSetMonth(value) { 1123 if (value != null) { 1124 setMonth(this, value); 1125 hooks.updateOffset(this, true); 1126 return this; 1127 } else { 1128 return get(this, 'Month'); 1129 } 1130 } 1131 1132 function getDaysInMonth() { 1133 return daysInMonth(this.year(), this.month()); 1134 } 1135 1136 function monthsShortRegex(isStrict) { 1137 if (this._monthsParseExact) { 1138 if (!hasOwnProp(this, '_monthsRegex')) { 1139 computeMonthsParse.call(this); 1140 } 1141 if (isStrict) { 1142 return this._monthsShortStrictRegex; 1143 } else { 1144 return this._monthsShortRegex; 1145 } 1146 } else { 1147 if (!hasOwnProp(this, '_monthsShortRegex')) { 1148 this._monthsShortRegex = defaultMonthsShortRegex; 1149 } 1150 return this._monthsShortStrictRegex && isStrict 1151 ? this._monthsShortStrictRegex 1152 : this._monthsShortRegex; 1153 } 1154 } 1155 1156 function monthsRegex(isStrict) { 1157 if (this._monthsParseExact) { 1158 if (!hasOwnProp(this, '_monthsRegex')) { 1159 computeMonthsParse.call(this); 1160 } 1161 if (isStrict) { 1162 return this._monthsStrictRegex; 1163 } else { 1164 return this._monthsRegex; 1165 } 1166 } else { 1167 if (!hasOwnProp(this, '_monthsRegex')) { 1168 this._monthsRegex = defaultMonthsRegex; 1169 } 1170 return this._monthsStrictRegex && isStrict 1171 ? this._monthsStrictRegex 1172 : this._monthsRegex; 1173 } 1174 } 1175 1176 function computeMonthsParse() { 1177 function cmpLenRev(a, b) { 1178 return b.length - a.length; 1179 } 1180 1181 var shortPieces = [], 1182 longPieces = [], 1183 mixedPieces = [], 1184 i, 1185 mom; 1186 for (i = 0; i < 12; i++) { 1187 // make the regex if we don't have it already 1188 mom = createUTC([2000, i]); 1189 shortPieces.push(this.monthsShort(mom, '')); 1190 longPieces.push(this.months(mom, '')); 1191 mixedPieces.push(this.months(mom, '')); 1192 mixedPieces.push(this.monthsShort(mom, '')); 1193 } 1194 // Sorting makes sure if one month (or abbr) is a prefix of another it 1195 // will match the longer piece. 1196 shortPieces.sort(cmpLenRev); 1197 longPieces.sort(cmpLenRev); 1198 mixedPieces.sort(cmpLenRev); 1199 for (i = 0; i < 12; i++) { 1200 shortPieces[i] = regexEscape(shortPieces[i]); 1201 longPieces[i] = regexEscape(longPieces[i]); 1202 } 1203 for (i = 0; i < 24; i++) { 1204 mixedPieces[i] = regexEscape(mixedPieces[i]); 1205 } 1206 1207 this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i'); 1208 this._monthsShortRegex = this._monthsRegex; 1209 this._monthsStrictRegex = new RegExp( 1210 '^(' + longPieces.join('|') + ')', 1211 'i' 1212 ); 1213 this._monthsShortStrictRegex = new RegExp( 1214 '^(' + shortPieces.join('|') + ')', 1215 'i' 1216 ); 1217 } 1218 1219 // FORMATTING 1220 1221 addFormatToken('Y', 0, 0, function () { 1222 var y = this.year(); 1223 return y <= 9999 ? zeroFill(y, 4) : '+' + y; 1224 }); 1225 1226 addFormatToken(0, ['YY', 2], 0, function () { 1227 return this.year() % 100; 1228 }); 1229 1230 addFormatToken(0, ['YYYY', 4], 0, 'year'); 1231 addFormatToken(0, ['YYYYY', 5], 0, 'year'); 1232 addFormatToken(0, ['YYYYYY', 6, true], 0, 'year'); 1233 1234 // ALIASES 1235 1236 addUnitAlias('year', 'y'); 1237 1238 // PRIORITIES 1239 1240 addUnitPriority('year', 1); 1241 1242 // PARSING 1243 1244 addRegexToken('Y', matchSigned); 1245 addRegexToken('YY', match1to2, match2); 1246 addRegexToken('YYYY', match1to4, match4); 1247 addRegexToken('YYYYY', match1to6, match6); 1248 addRegexToken('YYYYYY', match1to6, match6); 1249 1250 addParseToken(['YYYYY', 'YYYYYY'], YEAR); 1251 addParseToken('YYYY', function (input, array) { 1252 array[YEAR] = 1253 input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input); 1254 }); 1255 addParseToken('YY', function (input, array) { 1256 array[YEAR] = hooks.parseTwoDigitYear(input); 1257 }); 1258 addParseToken('Y', function (input, array) { 1259 array[YEAR] = parseInt(input, 10); 1260 }); 1261 1262 // HELPERS 1263 1264 function daysInYear(year) { 1265 return isLeapYear(year) ? 366 : 365; 1266 } 1267 1268 // HOOKS 1269 1270 hooks.parseTwoDigitYear = function (input) { 1271 return toInt(input) + (toInt(input) > 68 ? 1900 : 2000); 1272 }; 1273 1274 // MOMENTS 1275 1276 var getSetYear = makeGetSet('FullYear', true); 1277 1278 function getIsLeapYear() { 1279 return isLeapYear(this.year()); 1280 } 1281 1282 function createDate(y, m, d, h, M, s, ms) { 1283 // can't just apply() to create a date: 1284 // https://stackoverflow.com/q/181348 1285 var date; 1286 // the date constructor remaps years 0-99 to 1900-1999 1287 if (y < 100 && y >= 0) { 1288 // preserve leap years using a full 400 year cycle, then reset 1289 date = new Date(y + 400, m, d, h, M, s, ms); 1290 if (isFinite(date.getFullYear())) { 1291 date.setFullYear(y); 1292 } 1293 } else { 1294 date = new Date(y, m, d, h, M, s, ms); 1295 } 1296 1297 return date; 1298 } 1299 1300 function createUTCDate(y) { 1301 var date, args; 1302 // the Date.UTC function remaps years 0-99 to 1900-1999 1303 if (y < 100 && y >= 0) { 1304 args = Array.prototype.slice.call(arguments); 1305 // preserve leap years using a full 400 year cycle, then reset 1306 args[0] = y + 400; 1307 date = new Date(Date.UTC.apply(null, args)); 1308 if (isFinite(date.getUTCFullYear())) { 1309 date.setUTCFullYear(y); 1310 } 1311 } else { 1312 date = new Date(Date.UTC.apply(null, arguments)); 1313 } 1314 1315 return date; 1316 } 1317 1318 // start-of-first-week - start-of-year 1319 function firstWeekOffset(year, dow, doy) { 1320 var // first-week day -- which january is always in the first week (4 for iso, 1 for other) 1321 fwd = 7 + dow - doy, 1322 // first-week day local weekday -- which local weekday is fwd 1323 fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7; 1324 1325 return -fwdlw + fwd - 1; 1326 } 1327 1328 // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday 1329 function dayOfYearFromWeeks(year, week, weekday, dow, doy) { 1330 var localWeekday = (7 + weekday - dow) % 7, 1331 weekOffset = firstWeekOffset(year, dow, doy), 1332 dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset, 1333 resYear, 1334 resDayOfYear; 1335 1336 if (dayOfYear <= 0) { 1337 resYear = year - 1; 1338 resDayOfYear = daysInYear(resYear) + dayOfYear; 1339 } else if (dayOfYear > daysInYear(year)) { 1340 resYear = year + 1; 1341 resDayOfYear = dayOfYear - daysInYear(year); 1342 } else { 1343 resYear = year; 1344 resDayOfYear = dayOfYear; 1345 } 1346 1347 return { 1348 year: resYear, 1349 dayOfYear: resDayOfYear, 1350 }; 1351 } 1352 1353 function weekOfYear(mom, dow, doy) { 1354 var weekOffset = firstWeekOffset(mom.year(), dow, doy), 1355 week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1, 1356 resWeek, 1357 resYear; 1358 1359 if (week < 1) { 1360 resYear = mom.year() - 1; 1361 resWeek = week + weeksInYear(resYear, dow, doy); 1362 } else if (week > weeksInYear(mom.year(), dow, doy)) { 1363 resWeek = week - weeksInYear(mom.year(), dow, doy); 1364 resYear = mom.year() + 1; 1365 } else { 1366 resYear = mom.year(); 1367 resWeek = week; 1368 } 1369 1370 return { 1371 week: resWeek, 1372 year: resYear, 1373 }; 1374 } 1375 1376 function weeksInYear(year, dow, doy) { 1377 var weekOffset = firstWeekOffset(year, dow, doy), 1378 weekOffsetNext = firstWeekOffset(year + 1, dow, doy); 1379 return (daysInYear(year) - weekOffset + weekOffsetNext) / 7; 1380 } 1381 1382 // FORMATTING 1383 1384 addFormatToken('w', ['ww', 2], 'wo', 'week'); 1385 addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek'); 1386 1387 // ALIASES 1388 1389 addUnitAlias('week', 'w'); 1390 addUnitAlias('isoWeek', 'W'); 1391 1392 // PRIORITIES 1393 1394 addUnitPriority('week', 5); 1395 addUnitPriority('isoWeek', 5); 1396 1397 // PARSING 1398 1399 addRegexToken('w', match1to2); 1400 addRegexToken('ww', match1to2, match2); 1401 addRegexToken('W', match1to2); 1402 addRegexToken('WW', match1to2, match2); 1403 1404 addWeekParseToken(
vendor: 3,487 bytes, lines 1404-1535
1404 1405 ['w', 'ww', 'W', 'WW'], 1406 function (input, week, config, token) { 1407 week[token.substr(0, 1)] = toInt(input); 1408 } 1409 ); 1410 1411 // HELPERS 1412 1413 // LOCALES 1414 1415 function localeWeek(mom) { 1416 return weekOfYear(mom, this._week.dow, this._week.doy).week; 1417 } 1418 1419 var defaultLocaleWeek = { 1420 dow: 0, // Sunday is the first day of the week. 1421 doy: 6, // The week that contains Jan 6th is the first week of the year. 1422 }; 1423 1424 function localeFirstDayOfWeek() { 1425 return this._week.dow; 1426 } 1427 1428 function localeFirstDayOfYear() { 1429 return this._week.doy; 1430 } 1431 1432 // MOMENTS 1433 1434 function getSetWeek(input) { 1435 var week = this.localeData().week(this); 1436 return input == null ? week : this.add((input - week) * 7, 'd'); 1437 } 1438 1439 function getSetISOWeek(input) { 1440 var week = weekOfYear(this, 1, 4).week; 1441 return input == null ? week : this.add((input - week) * 7, 'd'); 1442 } 1443 1444 // FORMATTING 1445 1446 addFormatToken('d', 0, 'do', 'day'); 1447 1448 addFormatToken('dd', 0, 0, function (format) { 1449 return this.localeData().weekdaysMin(this, format); 1450 }); 1451 1452 addFormatToken('ddd', 0, 0, function (format) { 1453 return this.localeData().weekdaysShort(this, format); 1454 }); 1455 1456 addFormatToken('dddd', 0, 0, function (format) { 1457 return this.localeData().weekdays(this, format); 1458 }); 1459 1460 addFormatToken('e', 0, 0, 'weekday'); 1461 addFormatToken('E', 0, 0, 'isoWeekday'); 1462 1463 // ALIASES 1464 1465 addUnitAlias('day', 'd'); 1466 addUnitAlias('weekday', 'e'); 1467 addUnitAlias('isoWeekday', 'E'); 1468 1469 // PRIORITY 1470 addUnitPriority('day', 11); 1471 addUnitPriority('weekday', 11); 1472 addUnitPriority('isoWeekday', 11); 1473 1474 // PARSING 1475 1476 addRegexToken('d', match1to2); 1477 addRegexToken('e', match1to2); 1478 addRegexToken('E', match1to2); 1479 addRegexToken('dd', function (isStrict, locale) { 1480 return locale.weekdaysMinRegex(isStrict); 1481 }); 1482 addRegexToken('ddd', function (isStrict, locale) { 1483 return locale.weekdaysShortRegex(isStrict); 1484 }); 1485 addRegexToken('dddd', function (isStrict, locale) { 1486 return locale.weekdaysRegex(isStrict); 1487 }); 1488 1489 addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) { 1490 var weekday = config._locale.weekdaysParse(input, token, config._strict); 1491 // if we didn't get a weekday name, mark the date as invalid 1492 if (weekday != null) { 1493 week.d = weekday; 1494 } else { 1495 getParsingFlags(config).invalidWeekday = input; 1496 } 1497 }); 1498 1499 addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) { 1500 week[token] = toInt(input); 1501 }); 1502 1503 // HELPERS 1504 1505 function parseWeekday(input, locale) { 1506 if (typeof input !== 'string') { 1507 return input; 1508 } 1509 1510 if (!isNaN(input)) { 1511 return parseInt(input, 10); 1512 } 1513 1514 input = locale.weekdaysParse(input); 1515 if (typeof input === 'number') { 1516 return input; 1517 } 1518 1519 return null; 1520 } 1521 1522 function parseIsoWeekday(input, locale) { 1523 if (typeof input === 'string') { 1524 return locale.weekdaysParse(input) % 7 || 7; 1525 } 1526 return isNaN(input) ? null : input; 1527 } 1528 1529 // LOCALES 1530 function shiftWeekdays(ws, n) { 1531 return ws.slice(n, 7).concat(ws.slice(0, n)); 1532 } 1533 1534 var defaultLocaleWeekdays = 1535 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'
vendor: 17,864 bytes, lines 1535-2083
1535), 1536 defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'), 1537 defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'), 1538 defaultWeekdaysRegex = matchWord, 1539 defaultWeekdaysShortRegex = matchWord, 1540 defaultWeekdaysMinRegex = matchWord; 1541 1542 function localeWeekdays(m, format) { 1543 var weekdays = isArray(this._weekdays) 1544 ? this._weekdays 1545 : this._weekdays[ 1546 m && m !== true && this._weekdays.isFormat.test(format) 1547 ? 'format' 1548 : 'standalone' 1549 ]; 1550 return m === true 1551 ? shiftWeekdays(weekdays, this._week.dow) 1552 : m 1553 ? weekdays[m.day()] 1554 : weekdays; 1555 } 1556 1557 function localeWeekdaysShort(m) { 1558 return m === true 1559 ? shiftWeekdays(this._weekdaysShort, this._week.dow) 1560 : m 1561 ? this._weekdaysShort[m.day()] 1562 : this._weekdaysShort; 1563 } 1564 1565 function localeWeekdaysMin(m) { 1566 return m === true 1567 ? shiftWeekdays(this._weekdaysMin, this._week.dow) 1568 : m 1569 ? this._weekdaysMin[m.day()] 1570 : this._weekdaysMin; 1571 } 1572 1573 function handleStrictParse$1(weekdayName, format, strict) { 1574 var i, 1575 ii, 1576 mom, 1577 llc = weekdayName.toLocaleLowerCase(); 1578 if (!this._weekdaysParse) { 1579 this._weekdaysParse = []; 1580 this._shortWeekdaysParse = []; 1581 this._minWeekdaysParse = []; 1582 1583 for (i = 0; i < 7; ++i) { 1584 mom = createUTC([2000, 1]).day(i); 1585 this._minWeekdaysParse[i] = this.weekdaysMin( 1586 mom, 1587 '' 1588 ).toLocaleLowerCase(); 1589 this._shortWeekdaysParse[i] = this.weekdaysShort( 1590 mom, 1591 '' 1592 ).toLocaleLowerCase(); 1593 this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase(); 1594 } 1595 } 1596 1597 if (strict) { 1598 if (format === 'dddd') { 1599 ii = indexOf.call(this._weekdaysParse, llc); 1600 return ii !== -1 ? ii : null; 1601 } else if (format === 'ddd') { 1602 ii = indexOf.call(this._shortWeekdaysParse, llc); 1603 return ii !== -1 ? ii : null; 1604 } else { 1605 ii = indexOf.call(this._minWeekdaysParse, llc); 1606 return ii !== -1 ? ii : null; 1607 } 1608 } else { 1609 if (format === 'dddd') { 1610 ii = indexOf.call(this._weekdaysParse, llc); 1611 if (ii !== -1) { 1612 return ii; 1613 } 1614 ii = indexOf.call(this._shortWeekdaysParse, llc); 1615 if (ii !== -1) { 1616 return ii; 1617 } 1618 ii = indexOf.call(this._minWeekdaysParse, llc); 1619 return ii !== -1 ? ii : null; 1620 } else if (format === 'ddd') { 1621 ii = indexOf.call(this._shortWeekdaysParse, llc); 1622 if (ii !== -1) { 1623 return ii; 1624 } 1625 ii = indexOf.call(this._weekdaysParse, llc); 1626 if (ii !== -1) { 1627 return ii; 1628 } 1629 ii = indexOf.call(this._minWeekdaysParse, llc); 1630 return ii !== -1 ? ii : null; 1631 } else { 1632 ii = indexOf.call(this._minWeekdaysParse, llc); 1633 if (ii !== -1) { 1634 return ii; 1635 } 1636 ii = indexOf.call(this._weekdaysParse, llc); 1637 if (ii !== -1) { 1638 return ii; 1639 } 1640 ii = indexOf.call(this._shortWeekdaysParse, llc); 1641 return ii !== -1 ? ii : null; 1642 } 1643 } 1644 } 1645 1646 function localeWeekdaysParse(weekdayName, format, strict) { 1647 var i, mom, regex; 1648 1649 if (this._weekdaysParseExact) { 1650 return handleStrictParse$1.call(this, weekdayName, format, strict); 1651 } 1652 1653 if (!this._weekdaysParse) { 1654 this._weekdaysParse = []; 1655 this._minWeekdaysParse = []; 1656 this._shortWeekdaysParse = []; 1657 this._fullWeekdaysParse = []; 1658 } 1659 1660 for (i = 0; i < 7; i++) { 1661 // make the regex if we don't have it already 1662 1663 mom = createUTC([2000, 1]).day(i); 1664 if (strict && !this._fullWeekdaysParse[i]) { 1665 this._fullWeekdaysParse[i] = new RegExp( 1666 '^' + this.weekdays(mom, '').replace('.', '\\.?') + '$', 1667 'i' 1668 ); 1669 this._shortWeekdaysParse[i] = new RegExp( 1670 '^' + this.weekdaysShort(mom, '').replace('.', '\\.?') + '$', 1671 'i' 1672 ); 1673 this._minWeekdaysParse[i] = new RegExp( 1674 '^' + this.weekdaysMin(mom, '').replace('.', '\\.?') + '$', 1675 'i' 1676 ); 1677 } 1678 if (!this._weekdaysParse[i]) { 1679 regex = 1680 '^' + 1681 this.weekdays(mom, '') + 1682 '|^' + 1683 this.weekdaysShort(mom, '') + 1684 '|^' + 1685 this.weekdaysMin(mom, ''); 1686 this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i'); 1687 } 1688 // test the regex 1689 if ( 1690 strict && 1691 format === 'dddd' && 1692 this._fullWeekdaysParse[i].test(weekdayName) 1693 ) { 1694 return i; 1695 } else if ( 1696 strict && 1697 format === 'ddd' && 1698 this._shortWeekdaysParse[i].test(weekdayName) 1699 ) { 1700 return i; 1701 } else if ( 1702 strict && 1703 format === 'dd' && 1704 this._minWeekdaysParse[i].test(weekdayName) 1705 ) { 1706 return i; 1707 } else if (!strict && this._weekdaysParse[i].test(weekdayName)) { 1708 return i; 1709 } 1710 } 1711 } 1712 1713 // MOMENTS 1714 1715 function getSetDayOfWeek(input) { 1716 if (!this.isValid()) { 1717 return input != null ? this : NaN; 1718 } 1719 var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay(); 1720 if (input != null) { 1721 input = parseWeekday(input, this.localeData()); 1722 return this.add(input - day, 'd'); 1723 } else { 1724 return day; 1725 } 1726 } 1727 1728 function getSetLocaleDayOfWeek(input) { 1729 if (!this.isValid()) { 1730 return input != null ? this : NaN; 1731 } 1732 var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7; 1733 return input == null ? weekday : this.add(input - weekday, 'd'); 1734 } 1735 1736 function getSetISODayOfWeek(input) { 1737 if (!this.isValid()) { 1738 return input != null ? this : NaN; 1739 } 1740 1741 // behaves the same as moment#day except 1742 // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6) 1743 // as a setter, sunday should belong to the previous week. 1744 1745 if (input != null) { 1746 var weekday = parseIsoWeekday(input, this.localeData()); 1747 return this.day(this.day() % 7 ? weekday : weekday - 7); 1748 } else { 1749 return this.day() || 7; 1750 } 1751 } 1752 1753 function weekdaysRegex(isStrict) { 1754 if (this._weekdaysParseExact) { 1755 if (!hasOwnProp(this, '_weekdaysRegex')) { 1756 computeWeekdaysParse.call(this); 1757 } 1758 if (isStrict) { 1759 return this._weekdaysStrictRegex; 1760 } else { 1761 return this._weekdaysRegex; 1762 } 1763 } else { 1764 if (!hasOwnProp(this, '_weekdaysRegex')) { 1765 this._weekdaysRegex = defaultWeekdaysRegex; 1766 } 1767 return this._weekdaysStrictRegex && isStrict 1768 ? this._weekdaysStrictRegex 1769 : this._weekdaysRegex; 1770 } 1771 } 1772 1773 function weekdaysShortRegex(isStrict) { 1774 if (this._weekdaysParseExact) { 1775 if (!hasOwnProp(this, '_weekdaysRegex')) { 1776 computeWeekdaysParse.call(this); 1777 } 1778 if (isStrict) { 1779 return this._weekdaysShortStrictRegex; 1780 } else { 1781 return this._weekdaysShortRegex; 1782 } 1783 } else { 1784 if (!hasOwnProp(this, '_weekdaysShortRegex')) { 1785 this._weekdaysShortRegex = defaultWeekdaysShortRegex; 1786 } 1787 return this._weekdaysShortStrictRegex && isStrict 1788 ? this._weekdaysShortStrictRegex 1789 : this._weekdaysShortRegex; 1790 } 1791 } 1792 1793 function weekdaysMinRegex(isStrict) { 1794 if (this._weekdaysParseExact) { 1795 if (!hasOwnProp(this, '_weekdaysRegex')) { 1796 computeWeekdaysParse.call(this); 1797 } 1798 if (isStrict) { 1799 return this._weekdaysMinStrictRegex; 1800 } else { 1801 return this._weekdaysMinRegex; 1802 } 1803 } else { 1804 if (!hasOwnProp(this, '_weekdaysMinRegex')) { 1805 this._weekdaysMinRegex = defaultWeekdaysMinRegex; 1806 } 1807 return this._weekdaysMinStrictRegex && isStrict 1808 ? this._weekdaysMinStrictRegex 1809 : this._weekdaysMinRegex; 1810 } 1811 } 1812 1813 function computeWeekdaysParse() { 1814 function cmpLenRev(a, b) { 1815 return b.length - a.length; 1816 } 1817 1818 var minPieces = [], 1819 shortPieces = [], 1820 longPieces = [], 1821 mixedPieces = [], 1822 i, 1823 mom, 1824 minp, 1825 shortp, 1826 longp; 1827 for (i = 0; i < 7; i++) { 1828 // make the regex if we don't have it already 1829 mom = createUTC([2000, 1]).day(i); 1830 minp = regexEscape(this.weekdaysMin(mom, '')); 1831 shortp = regexEscape(this.weekdaysShort(mom, '')); 1832 longp = regexEscape(this.weekdays(mom, '')); 1833 minPieces.push(minp); 1834 shortPieces.push(shortp); 1835 longPieces.push(longp); 1836 mixedPieces.push(minp); 1837 mixedPieces.push(shortp); 1838 mixedPieces.push(longp); 1839 } 1840 // Sorting makes sure if one weekday (or abbr) is a prefix of another it 1841 // will match the longer piece. 1842 minPieces.sort(cmpLenRev); 1843 shortPieces.sort(cmpLenRev); 1844 longPieces.sort(cmpLenRev); 1845 mixedPieces.sort(cmpLenRev); 1846 1847 this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i'); 1848 this._weekdaysShortRegex = this._weekdaysRegex; 1849 this._weekdaysMinRegex = this._weekdaysRegex; 1850 1851 this._weekdaysStrictRegex = new RegExp( 1852 '^(' + longPieces.join('|') + ')', 1853 'i' 1854 ); 1855 this._weekdaysShortStrictRegex = new RegExp( 1856 '^(' + shortPieces.join('|') + ')', 1857 'i' 1858 ); 1859 this._weekdaysMinStrictRegex = new RegExp( 1860 '^(' + minPieces.join('|') + ')', 1861 'i' 1862 ); 1863 } 1864 1865 // FORMATTING 1866 1867 function hFormat() { 1868 return this.hours() % 12 || 12; 1869 } 1870 1871 function kFormat() { 1872 return this.hours() || 24; 1873 } 1874 1875 addFormatToken('H', ['HH', 2], 0, 'hour'); 1876 addFormatToken('h', ['hh', 2], 0, hFormat); 1877 addFormatToken('k', ['kk', 2], 0, kFormat); 1878 1879 addFormatToken('hmm', 0, 0, function () { 1880 return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2); 1881 }); 1882 1883 addFormatToken('hmmss', 0, 0, function () { 1884 return ( 1885 '' + 1886 hFormat.apply(this) + 1887 zeroFill(this.minutes(), 2) + 1888 zeroFill(this.seconds(), 2) 1889 ); 1890 }); 1891 1892 addFormatToken('Hmm', 0, 0, function () { 1893 return '' + this.hours() + zeroFill(this.minutes(), 2); 1894 }); 1895 1896 addFormatToken('Hmmss', 0, 0, function () { 1897 return ( 1898 '' + 1899 this.hours() + 1900 zeroFill(this.minutes(), 2) + 1901 zeroFill(this.seconds(), 2) 1902 ); 1903 }); 1904 1905 function meridiem(token, lowercase) { 1906 addFormatToken(token, 0, 0, function () { 1907 return this.localeData().meridiem( 1908 this.hours(), 1909 this.minutes(), 1910 lowercase 1911 ); 1912 }); 1913 } 1914 1915 meridiem('a', true); 1916 meridiem('A', false); 1917 1918 // ALIASES 1919 1920 addUnitAlias('hour', 'h'); 1921 1922 // PRIORITY 1923 addUnitPriority('hour', 13); 1924 1925 // PARSING 1926 1927 function matchMeridiem(isStrict, locale) { 1928 return locale._meridiemParse; 1929 } 1930 1931 addRegexToken('a', matchMeridiem); 1932 addRegexToken('A', matchMeridiem); 1933 addRegexToken('H', match1to2); 1934 addRegexToken('h', match1to2); 1935 addRegexToken('k', match1to2); 1936 addRegexToken('HH', match1to2, match2); 1937 addRegexToken('hh', match1to2, match2); 1938 addRegexToken('kk', match1to2, match2); 1939 1940 addRegexToken('hmm', match3to4); 1941 addRegexToken('hmmss', match5to6); 1942 addRegexToken('Hmm', match3to4); 1943 addRegexToken('Hmmss', match5to6); 1944 1945 addParseToken(['H', 'HH'], HOUR); 1946 addParseToken(['k', 'kk'], function (input, array, config) { 1947 var kInput = toInt(input); 1948 array[HOUR] = kInput === 24 ? 0 : kInput; 1949 }); 1950 addParseToken(['a', 'A'], function (input, array, config) { 1951 config._isPm = config._locale.isPM(input); 1952 config._meridiem = input; 1953 }); 1954 addParseToken(['h', 'hh'], function (input, array, config) { 1955 array[HOUR] = toInt(input); 1956 getParsingFlags(config).bigHour = true; 1957 }); 1958 addParseToken('hmm', function (input, array, config) { 1959 var pos = input.length - 2; 1960 array[HOUR] = toInt(input.substr(0, pos)); 1961 array[MINUTE] = toInt(input.substr(pos)); 1962 getParsingFlags(config).bigHour = true; 1963 }); 1964 addParseToken('hmmss', function (input, array, config) { 1965 var pos1 = input.length - 4, 1966 pos2 = input.length - 2; 1967 array[HOUR] = toInt(input.substr(0, pos1)); 1968 array[MINUTE] = toInt(input.substr(pos1, 2)); 1969 array[SECOND] = toInt(input.substr(pos2)); 1970 getParsingFlags(config).bigHour = true; 1971 }); 1972 addParseToken('Hmm', function (input, array, config) { 1973 var pos = input.length - 2; 1974 array[HOUR] = toInt(input.substr(0, pos)); 1975 array[MINUTE] = toInt(input.substr(pos)); 1976 }); 1977 addParseToken('Hmmss', function (input, array, config) { 1978 var pos1 = input.length - 4, 1979 pos2 = input.length - 2; 1980 array[HOUR] = toInt(input.substr(0, pos1)); 1981 array[MINUTE] = toInt(input.substr(pos1, 2)); 1982 array[SECOND] = toInt(input.substr(pos2)); 1983 }); 1984 1985 // LOCALES 1986 1987 function localeIsPM(input) { 1988 // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays 1989 // Using charAt should be more compatible. 1990 return (input + '').toLowerCase().charAt(0) === 'p'; 1991 } 1992 1993 var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i, 1994 // Setting the hour should keep the time, because the user explicitly 1995 // specified which hour they want. So trying to maintain the same hour (in 1996 // a new timezone) makes sense. Adding/subtracting hours does not follow 1997 // this rule. 1998 getSetHour = makeGetSet('Hours', true); 1999 2000 function localeMeridiem(hours, minutes, isLower) { 2001 if (hours > 11) { 2002 return isLower ? 'pm' : 'PM'; 2003 } else { 2004 return isLower ? 'am' : 'AM'; 2005 } 2006 } 2007 2008 var baseConfig = { 2009 calendar: defaultCalendar, 2010 longDateFormat: defaultLongDateFormat, 2011 invalidDate: defaultInvalidDate, 2012 ordinal: defaultOrdinal, 2013 dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse, 2014 relativeTime: defaultRelativeTime, 2015 2016 months: defaultLocaleMonths, 2017 monthsShort: defaultLocaleMonthsShort, 2018 2019 week: defaultLocaleWeek, 2020 2021 weekdays: defaultLocaleWeekdays, 2022 weekdaysMin: defaultLocaleWeekdaysMin, 2023 weekdaysShort: defaultLocaleWeekdaysShort, 2024 2025 meridiemParse: defaultLocaleMeridiemParse, 2026 }; 2027 2028 // internal storage for locale config files 2029 var locales = {}, 2030 localeFamilies = {}, 2031 globalLocale; 2032 2033 function commonPrefix(arr1, arr2) { 2034 var i, 2035 minl = Math.min(arr1.length, arr2.length); 2036 for (i = 0; i < minl; i += 1) { 2037 if (arr1[i] !== arr2[i]) { 2038 return i; 2039 } 2040 } 2041 return minl; 2042 } 2043 2044 function normalizeLocale(key) { 2045 return key ? key.toLowerCase().replace('_', '-') : key; 2046 } 2047 2048 // pick the locale from the array 2049 // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each 2050 // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root 2051 function chooseLocale(names) { 2052 var i = 0, 2053 j, 2054 next, 2055 locale, 2056 split; 2057 2058 while (i < names.length) { 2059 split = normalizeLocale(names[i]).split('-'); 2060 j = split.length; 2061 next = normalizeLocale(names[i + 1]); 2062 next = next ? next.split('-') : null; 2063 while (j > 0) { 2064 locale = loadLocale(split.slice(0, j).join('-')); 2065 if (locale) { 2066 return locale; 2067 } 2068 if ( 2069 next && 2070 next.length >= j && 2071 commonPrefix(split, next) >= j - 1 2072 ) { 2073 //the next array item is better than a shallower substring of this one 2074 break; 2075 } 2076 j--; 2077 } 2078 i++; 2079 } 2080 return globalLocale; 2081 } 2082 2083 function
vendor: 7,449 bytes, lines 2083-2290
2083isLocaleNameSane(name) { 2084 // Prevent names that look like filesystem paths, i.e contain '/' or '\' 2085 return name.match('^[^/\\\\]*$') != null; 2086 } 2087 2088 function loadLocale(name) { 2089 var oldLocale = null, 2090 aliasedRequire; 2091 // TODO: Find a better way to register and load all the locales in Node 2092 if ( 2093 locales[name] === undefined && 2094 typeof module !== 'undefined' && 2095 module && 2096 module.exports && 2097 isLocaleNameSane(name) 2098 ) { 2099 try { 2100 oldLocale = globalLocale._abbr; 2101 aliasedRequire = require; 2102 aliasedRequire('./locale/' + name); 2103 getSetGlobalLocale(oldLocale); 2104 } catch (e) { 2105 // mark as not found to avoid repeating expensive file require call causing high CPU 2106 // when trying to find en-US, en_US, en-us for every format call 2107 locales[name] = null; // null means not found 2108 } 2109 } 2110 return locales[name]; 2111 } 2112 2113 // This function will load locale and then set the global locale. If 2114 // no arguments are passed in, it will simply return the current global 2115 // locale key. 2116 function getSetGlobalLocale(key, values) { 2117 var data; 2118 if (key) { 2119 if (isUndefined(values)) { 2120 data = getLocale(key); 2121 } else { 2122 data = defineLocale(key, values); 2123 } 2124 2125 if (data) { 2126 // moment.duration._locale = moment._locale = data; 2127 globalLocale = data; 2128 } else { 2129 if (typeof console !== 'undefined' && console.warn) { 2130 //warn user if arguments are passed but the locale could not be set 2131 console.warn( 2132 'Locale ' + key + ' not found. Did you forget to load it?' 2133 ); 2134 } 2135 } 2136 } 2137 2138 return globalLocale._abbr; 2139 } 2140 2141 function defineLocale(name, config) { 2142 if (config !== null) { 2143 var locale, 2144 parentConfig = baseConfig; 2145 config.abbr = name; 2146 if (locales[name] != null) { 2147 deprecateSimple( 2148 'defineLocaleOverride', 2149 'use moment.updateLocale(localeName, config) to change ' + 2150 'an existing locale. moment.defineLocale(localeName, ' + 2151 'config) should only be used for creating a new locale ' + 2152 'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.' 2153 ); 2154 parentConfig = locales[name]._config; 2155 } else if (config.parentLocale != null) { 2156 if (locales[config.parentLocale] != null) { 2157 parentConfig = locales[config.parentLocale]._config; 2158 } else { 2159 locale = loadLocale(config.parentLocale); 2160 if (locale != null) { 2161 parentConfig = locale._config; 2162 } else { 2163 if (!localeFamilies[config.parentLocale]) { 2164 localeFamilies[config.parentLocale] = []; 2165 } 2166 localeFamilies[config.parentLocale].push({ 2167 name: name, 2168 config: config, 2169 }); 2170 return null; 2171 } 2172 } 2173 } 2174 locales[name] = new Locale(mergeConfigs(parentConfig, config)); 2175 2176 if (localeFamilies[name]) { 2177 localeFamilies[name].forEach(function (x) { 2178 defineLocale(x.name, x.config); 2179 }); 2180 } 2181 2182 // backwards compat for now: also set the locale 2183 // make sure we set the locale AFTER all child locales have been 2184 // created, so we won't end up with the child locale set. 2185 getSetGlobalLocale(name); 2186 2187 return locales[name]; 2188 } else { 2189 // useful for testing 2190 delete locales[name]; 2191 return null; 2192 } 2193 } 2194 2195 function updateLocale(name, config) { 2196 if (config != null) { 2197 var locale, 2198 tmpLocale, 2199 parentConfig = baseConfig; 2200 2201 if (locales[name] != null && locales[name].parentLocale != null) { 2202 // Update existing child locale in-place to avoid memory-leaks 2203 locales[name].set(mergeConfigs(locales[name]._config, config)); 2204 } else { 2205 // MERGE 2206 tmpLocale = loadLocale(name); 2207 if (tmpLocale != null) { 2208 parentConfig = tmpLocale._config; 2209 } 2210 config = mergeConfigs(parentConfig, config); 2211 if (tmpLocale == null) { 2212 // updateLocale is called for creating a new locale 2213 // Set abbr so it will have a name (getters return 2214 // undefined otherwise). 2215 config.abbr = name; 2216 } 2217 locale = new Locale(config); 2218 locale.parentLocale = locales[name]; 2219 locales[name] = locale; 2220 } 2221 2222 // backwards compat for now: also set the locale 2223 getSetGlobalLocale(name); 2224 } else { 2225 // pass null for config to unupdate, useful for tests 2226 if (locales[name] != null) { 2227 if (locales[name].parentLocale != null) { 2228 locales[name] = locales[name].parentLocale; 2229 if (name === getSetGlobalLocale()) { 2230 getSetGlobalLocale(name); 2231 } 2232 } else if (locales[name] != null) { 2233 delete locales[name]; 2234 } 2235 } 2236 } 2237 return locales[name]; 2238 } 2239 2240 // returns locale data 2241 function getLocale(key) { 2242 var locale; 2243 2244 if (key && key._locale && key._locale._abbr) { 2245 key = key._locale._abbr; 2246 } 2247 2248 if (!key) { 2249 return globalLocale; 2250 } 2251 2252 if (!isArray(key)) { 2253 //short-circuit everything else 2254 locale = loadLocale(key); 2255 if (locale) { 2256 return locale; 2257 } 2258 key = [key]; 2259 } 2260 2261 return chooseLocale(key); 2262 } 2263 2264 function listLocales() { 2265 return keys(locales); 2266 } 2267 2268 function checkOverflow(m) { 2269 var overflow, 2270 a = m._a; 2271 2272 if (a && getParsingFlags(m).overflow === -2) { 2273 overflow = 2274 a[MONTH] < 0 || a[MONTH] > 11 2275 ? MONTH 2276 : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) 2277 ? DATE 2278 : a[HOUR] < 0 || 2279 a[HOUR] > 24 || 2280 (a[HOUR] === 24 && 2281 (a[MINUTE] !== 0 || 2282 a[SECOND] !== 0 || 2283 a[MILLISECOND] !== 0)) 2284 ? HOUR 2285 : a[MINUTE] < 0 || a[MINUTE] > 59 2286 ? MINUTE 2287 : a[SECOND] < 0 || a[SECOND] > 59 2288 ? SECOND 2289 : a[MILLISECOND] < 0 || a[MILLISECOND] > 999 2290 ? MILLISECOND
vendor: 9,346 bytes, lines 2291-2574
2291 : -1; 2292 2293 if ( 2294 getParsingFlags(m)._overflowDayOfYear && 2295 (overflow < YEAR || overflow > DATE) 2296 ) { 2297 overflow = DATE; 2298 } 2299 if (getParsingFlags(m)._overflowWeeks && overflow === -1) { 2300 overflow = WEEK; 2301 } 2302 if (getParsingFlags(m)._overflowWeekday && overflow === -1) { 2303 overflow = WEEKDAY; 2304 } 2305 2306 getParsingFlags(m).overflow = overflow; 2307 } 2308 2309 return m; 2310 } 2311 2312 // iso 8601 regex 2313 // 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) 2314 var extendedIsoRegex = 2315 /^\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)?)?$/, 2316 basicIsoRegex = 2317 /^\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)?)?$/, 2318 tzRegex = /Z|[+-]\d\d(?::?\d\d)?/, 2319 isoDates = [ 2320 ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/], 2321 ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/], 2322 ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/], 2323 ['GGGG-[W]WW', /\d{4}-W\d\d/, false], 2324 ['YYYY-DDD', /\d{4}-\d{3}/], 2325 ['YYYY-MM', /\d{4}-\d\d/, false], 2326 ['YYYYYYMMDD', /[+-]\d{10}/], 2327 ['YYYYMMDD', /\d{8}/], 2328 ['GGGG[W]WWE', /\d{4}W\d{3}/], 2329 ['GGGG[W]WW', /\d{4}W\d{2}/, false], 2330 ['YYYYDDD', /\d{7}/], 2331 ['YYYYMM', /\d{6}/, false], 2332 ['YYYY', /\d{4}/, false], 2333 ], 2334 // iso time formats and regexes 2335 isoTimes = [ 2336 ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/], 2337 ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/], 2338 ['HH:mm:ss', /\d\d:\d\d:\d\d/], 2339 ['HH:mm', /\d\d:\d\d/], 2340 ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/], 2341 ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/], 2342 ['HHmmss', /\d\d\d\d\d\d/], 2343 ['HHmm', /\d\d\d\d/], 2344 ['HH', /\d\d/], 2345 ], 2346 aspNetJsonRegex = /^\/?Date\((-?\d+)/i, 2347 // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3 2348 rfc2822 = 2349 /^(?:(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}))$/, 2350 obsOffsets = { 2351 UT: 0, 2352 GMT: 0, 2353 EDT: -4 * 60, 2354 EST: -5 * 60, 2355 CDT: -5 * 60, 2356 CST: -6 * 60, 2357 MDT: -6 * 60, 2358 MST: -7 * 60, 2359 PDT: -7 * 60, 2360 PST: -8 * 60, 2361 }; 2362 2363 // date from iso format 2364 function configFromISO(config) { 2365 var i, 2366 l, 2367 string = config._i, 2368 match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string), 2369 allowTime, 2370 dateFormat, 2371 timeFormat, 2372 tzFormat, 2373 isoDatesLen = isoDates.length, 2374 isoTimesLen = isoTimes.length; 2375 2376 if (match) { 2377 getParsingFlags(config).iso = true; 2378 for (i = 0, l = isoDatesLen; i < l; i++) { 2379 if (isoDates[i][1].exec(match[1])) { 2380 dateFormat = isoDates[i][0]; 2381 allowTime = isoDates[i][2] !== false; 2382 break; 2383 } 2384 } 2385 if (dateFormat == null) { 2386 config._isValid = false; 2387 return; 2388 } 2389 if (match[3]) { 2390 for (i = 0, l = isoTimesLen; i < l; i++) { 2391 if (isoTimes[i][1].exec(match[3])) { 2392 // match[2] should be 'T' or space 2393 timeFormat = (match[2] || ' ') + isoTimes[i][0]; 2394 break; 2395 } 2396 } 2397 if (timeFormat == null) { 2398 config._isValid = false; 2399 return; 2400 } 2401 } 2402 if (!allowTime && timeFormat != null) { 2403 config._isValid = false; 2404 return; 2405 } 2406 if (match[4]) { 2407 if (tzRegex.exec(match[4])) { 2408 tzFormat = 'Z'; 2409 } else { 2410 config._isValid = false; 2411 return; 2412 } 2413 } 2414 config._f = dateFormat + (timeFormat || '') + (tzFormat || ''); 2415 configFromStringAndFormat(config); 2416 } else { 2417 config._isValid = false; 2418 } 2419 } 2420 2421 function extractFromRFC2822Strings( 2422 yearStr, 2423 monthStr, 2424 dayStr, 2425 hourStr, 2426 minuteStr, 2427 secondStr 2428 ) { 2429 var result = [ 2430 untruncateYear(yearStr), 2431 defaultLocaleMonthsShort.indexOf(monthStr), 2432 parseInt(dayStr, 10), 2433 parseInt(hourStr, 10), 2434 parseInt(minuteStr, 10), 2435 ]; 2436 2437 if (secondStr) { 2438 result.push(parseInt(secondStr, 10)); 2439 } 2440 2441 return result; 2442 } 2443 2444 function untruncateYear(yearStr) { 2445 var year = parseInt(yearStr, 10); 2446 if (year <= 49) { 2447 return 2000 + year; 2448 } else if (year <= 999) { 2449 return 1900 + year; 2450 } 2451 return year; 2452 } 2453 2454 function preprocessRFC2822(s) { 2455 // Remove comments and folding whitespace and replace multiple-spaces with a single space 2456 return s 2457 .replace(/\([^()]*\)|[\n\t]/g, ' ') 2458 .replace(/(\s\s+)/g, ' ') 2459 .replace(/^\s\s*/, '') 2460 .replace(/\s\s*$/, ''); 2461 } 2462 2463 function checkWeekday(weekdayStr, parsedInput, config) { 2464 if (weekdayStr) { 2465 // TODO: Replace the vanilla JS Date object with an independent day-of-week check. 2466 var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr), 2467 weekdayActual = new Date( 2468 parsedInput[0], 2469 parsedInput[1], 2470 parsedInput[2] 2471 ).getDay(); 2472 if (weekdayProvided !== weekdayActual) { 2473 getParsingFlags(config).weekdayMismatch = true; 2474 config._isValid = false; 2475 return false; 2476 } 2477 } 2478 return true; 2479 } 2480 2481 function calculateOffset(obsOffset, militaryOffset, numOffset) { 2482 if (obsOffset) { 2483 return obsOffsets[obsOffset]; 2484 } else if (militaryOffset) { 2485 // the only allowed military tz is Z 2486 return 0; 2487 } else { 2488 var hm = parseInt(numOffset, 10), 2489 m = hm % 100, 2490 h = (hm - m) / 100; 2491 return h * 60 + m; 2492 } 2493 } 2494 2495 // date and time from ref 2822 format 2496 function configFromRFC2822(config) { 2497 var match = rfc2822.exec(preprocessRFC2822(config._i)), 2498 parsedArray; 2499 if (match) { 2500 parsedArray = extractFromRFC2822Strings( 2501 match[4], 2502 match[3], 2503 match[2], 2504 match[5], 2505 match[6], 2506 match[7] 2507 ); 2508 if (!checkWeekday(match[1], parsedArray, config)) { 2509 return; 2510 } 2511 2512 config._a = parsedArray; 2513 config._tzm = calculateOffset(match[8], match[9], match[10]); 2514 2515 config._d = createUTCDate.apply(null, config._a); 2516 config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm); 2517 2518 getParsingFlags(config).rfc2822 = true; 2519 } else { 2520 config._isValid = false; 2521 } 2522 } 2523 2524 // date from 1) ASP.NET, 2) ISO, 3) RFC 2822 formats, or 4) optional fallback if parsing isn't strict 2525 function configFromString(config) { 2526 var matched = aspNetJsonRegex.exec(config._i); 2527 if (matched !== null) { 2528 config._d = new Date(+matched[1]); 2529 return; 2530 } 2531 2532 configFromISO(config); 2533 if (config._isValid === false) { 2534 delete config._isValid; 2535 } else { 2536 return; 2537 } 2538 2539 configFromRFC2822(config); 2540 if (config._isValid === false) { 2541 delete config._isValid; 2542 } else { 2543 return; 2544 } 2545 2546 if (config._strict) { 2547 config._isValid = false; 2548 } else { 2549 // Final attempt, use Input Fallback 2550 hooks.createFromInputFallback(config); 2551 } 2552 } 2553 2554 hooks.createFromInputFallback = deprecate( 2555 'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' + 2556 'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' + 2557 'discouraged. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.', 2558 function (config) { 2559 config._d = new Date(config._i + (config._useUTC ? ' UTC' : '')); 2560 } 2561 ); 2562 2563 // Pick the first defined of two or three arguments. 2564 function defaults(a, b, c) { 2565 if (a != null) { 2566 return a; 2567 } 2568 if (b != null) { 2569 return b; 2570 } 2571 return c; 2572 } 2573 2574 function currentDateArray(config
vendor: 17,694 bytes, lines 2574-3135
2574) { 2575 // hooks is actually the exported moment object 2576 var nowValue = new Date(hooks.now()); 2577 if (config._useUTC) { 2578 return [ 2579 nowValue.getUTCFullYear(), 2580 nowValue.getUTCMonth(), 2581 nowValue.getUTCDate(), 2582 ]; 2583 } 2584 return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()]; 2585 } 2586 2587 // convert an array to a date. 2588 // the array should mirror the parameters below 2589 // note: all values past the year are optional and will default to the lowest possible value. 2590 // [year, month, day , hour, minute, second, millisecond] 2591 function configFromArray(config) { 2592 var i, 2593 date, 2594 input = [], 2595 currentDate, 2596 expectedWeekday, 2597 yearToUse; 2598 2599 if (config._d) { 2600 return; 2601 } 2602 2603 currentDate = currentDateArray(config); 2604 2605 //compute day of the year from weeks and weekdays 2606 if (config._w && config._a[DATE] == null && config._a[MONTH] == null) { 2607 dayOfYearFromWeekInfo(config); 2608 } 2609 2610 //if the day of the year is set, figure out what it is 2611 if (config._dayOfYear != null) { 2612 yearToUse = defaults(config._a[YEAR], currentDate[YEAR]); 2613 2614 if ( 2615 config._dayOfYear > daysInYear(yearToUse) || 2616 config._dayOfYear === 0 2617 ) { 2618 getParsingFlags(config)._overflowDayOfYear = true; 2619 } 2620 2621 date = createUTCDate(yearToUse, 0, config._dayOfYear); 2622 config._a[MONTH] = date.getUTCMonth(); 2623 config._a[DATE] = date.getUTCDate(); 2624 } 2625 2626 // Default to current date. 2627 // * if no year, month, day of month are given, default to today 2628 // * if day of month is given, default month and year 2629 // * if month is given, default only year 2630 // * if year is given, don't default anything 2631 for (i = 0; i < 3 && config._a[i] == null; ++i) { 2632 config._a[i] = input[i] = currentDate[i]; 2633 } 2634 2635 // Zero out whatever was not defaulted, including time 2636 for (; i < 7; i++) { 2637 config._a[i] = input[i] = 2638 config._a[i] == null ? (i === 2 ? 1 : 0) : config._a[i]; 2639 } 2640 2641 // Check for 24:00:00.000 2642 if ( 2643 config._a[HOUR] === 24 && 2644 config._a[MINUTE] === 0 && 2645 config._a[SECOND] === 0 && 2646 config._a[MILLISECOND] === 0 2647 ) { 2648 config._nextDay = true; 2649 config._a[HOUR] = 0; 2650 } 2651 2652 config._d = (config._useUTC ? createUTCDate : createDate).apply( 2653 null, 2654 input 2655 ); 2656 expectedWeekday = config._useUTC 2657 ? config._d.getUTCDay() 2658 : config._d.getDay(); 2659 2660 // Apply timezone offset from input. The actual utcOffset can be changed 2661 // with parseZone. 2662 if (config._tzm != null) { 2663 config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm); 2664 } 2665 2666 if (config._nextDay) { 2667 config._a[HOUR] = 24; 2668 } 2669 2670 // check for mismatching day of week 2671 if ( 2672 config._w && 2673 typeof config._w.d !== 'undefined' && 2674 config._w.d !== expectedWeekday 2675 ) { 2676 getParsingFlags(config).weekdayMismatch = true; 2677 } 2678 } 2679 2680 function dayOfYearFromWeekInfo(config) { 2681 var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow, curWeek; 2682 2683 w = config._w; 2684 if (w.GG != null || w.W != null || w.E != null) { 2685 dow = 1; 2686 doy = 4; 2687 2688 // TODO: We need to take the current isoWeekYear, but that depends on 2689 // how we interpret now (local, utc, fixed offset). So create 2690 // a now version of current config (take local/utc/offset flags, and 2691 // create now). 2692 weekYear = defaults( 2693 w.GG, 2694 config._a[YEAR], 2695 weekOfYear(createLocal(), 1, 4).year 2696 ); 2697 week = defaults(w.W, 1); 2698 weekday = defaults(w.E, 1); 2699 if (weekday < 1 || weekday > 7) { 2700 weekdayOverflow = true; 2701 } 2702 } else { 2703 dow = config._locale._week.dow; 2704 doy = config._locale._week.doy; 2705 2706 curWeek = weekOfYear(createLocal(), dow, doy); 2707 2708 weekYear = defaults(w.gg, config._a[YEAR], curWeek.year); 2709 2710 // Default to current week. 2711 week = defaults(w.w, curWeek.week); 2712 2713 if (w.d != null) { 2714 // weekday -- low day numbers are considered next week 2715 weekday = w.d; 2716 if (weekday < 0 || weekday > 6) { 2717 weekdayOverflow = true; 2718 } 2719 } else if (w.e != null) { 2720 // local weekday -- counting starts from beginning of week 2721 weekday = w.e + dow; 2722 if (w.e < 0 || w.e > 6) { 2723 weekdayOverflow = true; 2724 } 2725 } else { 2726 // default to beginning of week 2727 weekday = dow; 2728 } 2729 } 2730 if (week < 1 || week > weeksInYear(weekYear, dow, doy)) { 2731 getParsingFlags(config)._overflowWeeks = true; 2732 } else if (weekdayOverflow != null) { 2733 getParsingFlags(config)._overflowWeekday = true; 2734 } else { 2735 temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy); 2736 config._a[YEAR] = temp.year; 2737 config._dayOfYear = temp.dayOfYear; 2738 } 2739 } 2740 2741 // constant that refers to the ISO standard 2742 hooks.ISO_8601 = function () {}; 2743 2744 // constant that refers to the RFC 2822 form 2745 hooks.RFC_2822 = function () {}; 2746 2747 // date from string and format string 2748 function configFromStringAndFormat(config) { 2749 // TODO: Move this to another part of the creation flow to prevent circular deps 2750 if (config._f === hooks.ISO_8601) { 2751 configFromISO(config); 2752 return; 2753 } 2754 if (config._f === hooks.RFC_2822) { 2755 configFromRFC2822(config); 2756 return; 2757 } 2758 config._a = []; 2759 getParsingFlags(config).empty = true; 2760 2761 // This array is used to make a Date, either with `new Date` or `Date.UTC` 2762 var string = '' + config._i, 2763 i, 2764 parsedInput, 2765 tokens, 2766 token, 2767 skipped, 2768 stringLength = string.length, 2769 totalParsedInputLength = 0, 2770 era, 2771 tokenLen; 2772 2773 tokens = 2774 expandFormat(config._f, config._locale).match(formattingTokens) || []; 2775 tokenLen = tokens.length; 2776 for (i = 0; i < tokenLen; i++) { 2777 token = tokens[i]; 2778 parsedInput = (string.match(getParseRegexForToken(token, config)) || 2779 [])[0]; 2780 if (parsedInput) { 2781 skipped = string.substr(0, string.indexOf(parsedInput)); 2782 if (skipped.length > 0) { 2783 getParsingFlags(config).unusedInput.push(skipped); 2784 } 2785 string = string.slice( 2786 string.indexOf(parsedInput) + parsedInput.length 2787 ); 2788 totalParsedInputLength += parsedInput.length; 2789 } 2790 // don't parse if it's not a known token 2791 if (formatTokenFunctions[token]) { 2792 if (parsedInput) { 2793 getParsingFlags(config).empty = false; 2794 } else { 2795 getParsingFlags(config).unusedTokens.push(token); 2796 } 2797 addTimeToArrayFromToken(token, parsedInput, config); 2798 } else if (config._strict && !parsedInput) { 2799 getParsingFlags(config).unusedTokens.push(token); 2800 } 2801 } 2802 2803 // add remaining unparsed input length to the string 2804 getParsingFlags(config).charsLeftOver = 2805 stringLength - totalParsedInputLength; 2806 if (string.length > 0) { 2807 getParsingFlags(config).unusedInput.push(string); 2808 } 2809 2810 // clear _12h flag if hour is <= 12 2811 if ( 2812 config._a[HOUR] <= 12 && 2813 getParsingFlags(config).bigHour === true && 2814 config._a[HOUR] > 0 2815 ) { 2816 getParsingFlags(config).bigHour = undefined; 2817 } 2818 2819 getParsingFlags(config).parsedDateParts = config._a.slice(0); 2820 getParsingFlags(config).meridiem = config._meridiem; 2821 // handle meridiem 2822 config._a[HOUR] = meridiemFixWrap( 2823 config._locale, 2824 config._a[HOUR], 2825 config._meridiem 2826 ); 2827 2828 // handle era 2829 era = getParsingFlags(config).era; 2830 if (era !== null) { 2831 config._a[YEAR] = config._locale.erasConvertYear(era, config._a[YEAR]); 2832 } 2833 2834 configFromArray(config); 2835 checkOverflow(config); 2836 } 2837 2838 function meridiemFixWrap(locale, hour, meridiem) { 2839 var isPm; 2840 2841 if (meridiem == null) { 2842 // nothing to do 2843 return hour; 2844 } 2845 if (locale.meridiemHour != null) { 2846 return locale.meridiemHour(hour, meridiem); 2847 } else if (locale.isPM != null) { 2848 // Fallback 2849 isPm = locale.isPM(meridiem); 2850 if (isPm && hour < 12) { 2851 hour += 12; 2852 } 2853 if (!isPm && hour === 12) { 2854 hour = 0; 2855 } 2856 return hour; 2857 } else { 2858 // this is not supposed to happen 2859 return hour; 2860 } 2861 } 2862 2863 // date from string and array of format strings 2864 function configFromStringAndArray(config) { 2865 var tempConfig, 2866 bestMoment, 2867 scoreToBeat, 2868 i, 2869 currentScore, 2870 validFormatFound, 2871 bestFormatIsValid = false, 2872 configfLen = config._f.length; 2873 2874 if (configfLen === 0) { 2875 getParsingFlags(config).invalidFormat = true; 2876 config._d = new Date(NaN); 2877 return; 2878 } 2879 2880 for (i = 0; i < configfLen; i++) { 2881 currentScore = 0; 2882 validFormatFound = false; 2883 tempConfig = copyConfig({}, config); 2884 if (config._useUTC != null) { 2885 tempConfig._useUTC = config._useUTC; 2886 } 2887 tempConfig._f = config._f[i]; 2888 configFromStringAndFormat(tempConfig); 2889 2890 if (isValid(tempConfig)) { 2891 validFormatFound = true; 2892 } 2893 2894 // if there is any input that was not parsed add a penalty for that format 2895 currentScore += getParsingFlags(tempConfig).charsLeftOver; 2896 2897 //or tokens 2898 currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10; 2899 2900 getParsingFlags(tempConfig).score = currentScore; 2901 2902 if (!bestFormatIsValid) { 2903 if ( 2904 scoreToBeat == null || 2905 currentScore < scoreToBeat || 2906 validFormatFound 2907 ) { 2908 scoreToBeat = currentScore; 2909 bestMoment = tempConfig; 2910 if (validFormatFound) { 2911 bestFormatIsValid = true; 2912 } 2913 } 2914 } else { 2915 if (currentScore < scoreToBeat) { 2916 scoreToBeat = currentScore; 2917 bestMoment = tempConfig; 2918 } 2919 } 2920 } 2921 2922 extend(config, bestMoment || tempConfig); 2923 } 2924 2925 function configFromObject(config) { 2926 if (config._d) { 2927 return; 2928 } 2929 2930 var i = normalizeObjectUnits(config._i), 2931 dayOrDate = i.day === undefined ? i.date : i.day; 2932 config._a = map( 2933 [i.year, i.month, dayOrDate, i.hour, i.minute, i.second, i.millisecond], 2934 function (obj) { 2935 return obj && parseInt(obj, 10); 2936 } 2937 ); 2938 2939 configFromArray(config); 2940 } 2941 2942 function createFromConfig(config) { 2943 var res = new Moment(checkOverflow(prepareConfig(config))); 2944 if (res._nextDay) { 2945 // Adding is smart enough around DST 2946 res.add(1, 'd'); 2947 res._nextDay = undefined; 2948 } 2949 2950 return res; 2951 } 2952 2953 function prepareConfig(config) { 2954 var input = config._i, 2955 format = config._f; 2956 2957 config._locale = config._locale || getLocale(config._l); 2958 2959 if (input === null || (format === undefined && input === '')) { 2960 return createInvalid({ nullInput: true }); 2961 } 2962 2963 if (typeof input === 'string') { 2964 config._i = input = config._locale.preparse(input); 2965 } 2966 2967 if (isMoment(input)) { 2968 return new Moment(checkOverflow(input)); 2969 } else if (isDate(input)) { 2970 config._d = input; 2971 } else if (isArray(format)) { 2972 configFromStringAndArray(config); 2973 } else if (format) { 2974 configFromStringAndFormat(config); 2975 } else { 2976 configFromInput(config); 2977 } 2978 2979 if (!isValid(config)) { 2980 config._d = null; 2981 } 2982 2983 return config; 2984 } 2985 2986 function configFromInput(config) { 2987 var input = config._i; 2988 if (isUndefined(input)) { 2989 config._d = new Date(hooks.now()); 2990 } else if (isDate(input)) { 2991 config._d = new Date(input.valueOf()); 2992 } else if (typeof input === 'string') { 2993 configFromString(config); 2994 } else if (isArray(input)) { 2995 config._a = map(input.slice(0), function (obj) { 2996 return parseInt(obj, 10); 2997 }); 2998 configFromArray(config); 2999 } else if (isObject(input)) { 3000 configFromObject(config); 3001 } else if (isNumber(input)) { 3002 // from milliseconds 3003 config._d = new Date(input); 3004 } else { 3005 hooks.createFromInputFallback(config); 3006 } 3007 } 3008 3009 function createLocalOrUTC(input, format, locale, strict, isUTC) { 3010 var c = {}; 3011 3012 if (format === true || format === false) { 3013 strict = format; 3014 format = undefined; 3015 } 3016 3017 if (locale === true || locale === false) { 3018 strict = locale; 3019 locale = undefined; 3020 } 3021 3022 if ( 3023 (isObject(input) && isObjectEmpty(input)) || 3024 (isArray(input) && input.length === 0) 3025 ) { 3026 input = undefined; 3027 } 3028 // object construction must be done this way. 3029 // https://github.com/moment/moment/issues/1423 3030 c._isAMomentObject = true; 3031 c._useUTC = c._isUTC = isUTC; 3032 c._l = locale; 3033 c._i = input; 3034 c._f = format; 3035 c._strict = strict; 3036 3037 return createFromConfig(c); 3038 } 3039 3040 function createLocal(input, format, locale, strict) { 3041 return createLocalOrUTC(input, format, locale, strict, false); 3042 } 3043 3044 var prototypeMin = deprecate( 3045 'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/', 3046 function () { 3047 var other = createLocal.apply(null, arguments); 3048 if (this.isValid() && other.isValid()) { 3049 return other < this ? this : other; 3050 } else { 3051 return createInvalid(); 3052 } 3053 } 3054 ), 3055 prototypeMax = deprecate( 3056 'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/', 3057 function () { 3058 var other = createLocal.apply(null, arguments); 3059 if (this.isValid() && other.isValid()) { 3060 return other > this ? this : other; 3061 } else { 3062 return createInvalid(); 3063 } 3064 } 3065 ); 3066 3067 // Pick a moment m from moments so that m[fn](other) is true for all 3068 // other. This relies on the function fn to be transitive. 3069 // 3070 // moments should either be an array of moment objects or an array, whose 3071 // first element is an array of moment objects. 3072 function pickBy(fn, moments) { 3073 var res, i; 3074 if (moments.length === 1 && isArray(moments[0])) { 3075 moments = moments[0]; 3076 } 3077 if (!moments.length) { 3078 return createLocal(); 3079 } 3080 res = moments[0]; 3081 for (i = 1; i < moments.length; ++i) { 3082 if (!moments[i].isValid() || moments[i][fn](res)) { 3083 res = moments[i]; 3084 } 3085 } 3086 return res; 3087 } 3088 3089 // TODO: Use [].sort instead? 3090 function min() { 3091 var args = [].slice.call(arguments, 0); 3092 3093 return pickBy('isBefore', args); 3094 } 3095 3096 function max() { 3097 var args = [].slice.call(arguments, 0); 3098 3099 return pickBy('isAfter', args); 3100 } 3101 3102 var now = function () { 3103 return Date.now ? Date.now() : +new Date(); 3104 }; 3105 3106 var ordering = [ 3107 'year', 3108 'quarter', 3109 'month', 3110 'week', 3111 'day', 3112 'hour', 3113 'minute', 3114 'second', 3115 'millisecond', 3116 ]; 3117 3118 function isDurationValid(m) { 3119 var key, 3120 unitHasDecimal = false, 3121 i, 3122 orderLen = ordering.length; 3123 for (key in m) { 3124 if ( 3125 hasOwnProp(m, key) && 3126 !( 3127 indexOf.call(ordering, key) !== -1 && 3128 (m[key] == null || !isNaN(m[key])) 3129 ) 3130 ) { 3131 return false; 3132 } 3133 } 3134 3135 for (i = 0; i < orderLen
vendor: 10,251 bytes, lines 3135-3460
3135; ++i) { 3136 if (m[ordering[i]]) { 3137 if (unitHasDecimal) { 3138 return false; // only allow non-integers for smallest unit 3139 } 3140 if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) { 3141 unitHasDecimal = true; 3142 } 3143 } 3144 } 3145 3146 return true; 3147 } 3148 3149 function isValid$1() { 3150 return this._isValid; 3151 } 3152 3153 function createInvalid$1() { 3154 return createDuration(NaN); 3155 } 3156 3157 function Duration(duration) { 3158 var normalizedInput = normalizeObjectUnits(duration), 3159 years = normalizedInput.year || 0, 3160 quarters = normalizedInput.quarter || 0, 3161 months = normalizedInput.month || 0, 3162 weeks = normalizedInput.week || normalizedInput.isoWeek || 0, 3163 days = normalizedInput.day || 0, 3164 hours = normalizedInput.hour || 0, 3165 minutes = normalizedInput.minute || 0, 3166 seconds = normalizedInput.second || 0, 3167 milliseconds = normalizedInput.millisecond || 0; 3168 3169 this._isValid = isDurationValid(normalizedInput); 3170 3171 // representation for dateAddRemove 3172 this._milliseconds = 3173 +milliseconds + 3174 seconds * 1e3 + // 1000 3175 minutes * 6e4 + // 1000 * 60 3176 hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978 3177 // Because of dateAddRemove treats 24 hours as different from a 3178 // day when working around DST, we need to store them separately 3179 this._days = +days + weeks * 7; 3180 // It is impossible to translate months into days without knowing 3181 // which months you are are talking about, so we have to store 3182 // it separately. 3183 this._months = +months + quarters * 3 + years * 12; 3184 3185 this._data = {}; 3186 3187 this._locale = getLocale(); 3188 3189 this._bubble(); 3190 } 3191 3192 function isDuration(obj) { 3193 return obj instanceof Duration; 3194 } 3195 3196 function absRound(number) { 3197 if (number < 0) { 3198 return Math.round(-1 * number) * -1; 3199 } else { 3200 return Math.round(number); 3201 } 3202 } 3203 3204 // compare two arrays, return the number of differences 3205 function compareArrays(array1, array2, dontConvert) { 3206 var len = Math.min(array1.length, array2.length), 3207 lengthDiff = Math.abs(array1.length - array2.length), 3208 diffs = 0, 3209 i; 3210 for (i = 0; i < len; i++) { 3211 if ( 3212 (dontConvert && array1[i] !== array2[i]) || 3213 (!dontConvert && toInt(array1[i]) !== toInt(array2[i])) 3214 ) { 3215 diffs++; 3216 } 3217 } 3218 return diffs + lengthDiff; 3219 } 3220 3221 // FORMATTING 3222 3223 function offset(token, separator) { 3224 addFormatToken(token, 0, 0, function () { 3225 var offset = this.utcOffset(), 3226 sign = '+'; 3227 if (offset < 0) { 3228 offset = -offset; 3229 sign = '-'; 3230 } 3231 return ( 3232 sign + 3233 zeroFill(~~(offset / 60), 2) + 3234 separator + 3235 zeroFill(~~offset % 60, 2) 3236 ); 3237 }); 3238 } 3239 3240 offset('Z', ':'); 3241 offset('ZZ', ''); 3242 3243 // PARSING 3244 3245 addRegexToken('Z', matchShortOffset); 3246 addRegexToken('ZZ', matchShortOffset); 3247 addParseToken(['Z', 'ZZ'], function (input, array, config) { 3248 config._useUTC = true; 3249 config._tzm = offsetFromString(matchShortOffset, input); 3250 }); 3251 3252 // HELPERS 3253 3254 // timezone chunker 3255 // '+10:00' > ['10', '00'] 3256 // '-1530' > ['-15', '30'] 3257 var chunkOffset = /([\+\-]|\d\d)/gi; 3258 3259 function offsetFromString(matcher, string) { 3260 var matches = (string || '').match(matcher), 3261 chunk, 3262 parts, 3263 minutes; 3264 3265 if (matches === null) { 3266 return null; 3267 } 3268 3269 chunk = matches[matches.length - 1] || []; 3270 parts = (chunk + '').match(chunkOffset) || ['-', 0, 0]; 3271 minutes = +(parts[1] * 60) + toInt(parts[2]); 3272 3273 return minutes === 0 ? 0 : parts[0] === '+' ? minutes : -minutes; 3274 } 3275 3276 // Return a moment from input, that is local/utc/zone equivalent to model. 3277 function cloneWithOffset(input, model) { 3278 var res, diff; 3279 if (model._isUTC) { 3280 res = model.clone(); 3281 diff = 3282 (isMoment(input) || isDate(input) 3283 ? input.valueOf() 3284 : createLocal(input).valueOf()) - res.valueOf(); 3285 // Use low-level api, because this fn is low-level api. 3286 res._d.setTime(res._d.valueOf() + diff); 3287 hooks.updateOffset(res, false); 3288 return res; 3289 } else { 3290 return createLocal(input).local(); 3291 } 3292 } 3293 3294 function getDateOffset(m) { 3295 // On Firefox.24 Date#getTimezoneOffset returns a floating point. 3296 // https://github.com/moment/moment/pull/1871 3297 return -Math.round(m._d.getTimezoneOffset()); 3298 } 3299 3300 // HOOKS 3301 3302 // This function will be called whenever a moment is mutated. 3303 // It is intended to keep the offset in sync with the timezone. 3304 hooks.updateOffset = function () {}; 3305 3306 // MOMENTS 3307 3308 // keepLocalTime = true means only change the timezone, without 3309 // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]--> 3310 // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset 3311 // +0200, so we adjust the time as needed, to be valid. 3312 // 3313 // Keeping the time actually adds/subtracts (one hour) 3314 // from the actual represented time. That is why we call updateOffset 3315 // a second time. In case it wants us to change the offset again 3316 // _changeInProgress == true case, then we have to adjust, because 3317 // there is no such time in the given timezone. 3318 function getSetOffset(input, keepLocalTime, keepMinutes) { 3319 var offset = this._offset || 0, 3320 localAdjust; 3321 if (!this.isValid()) { 3322 return input != null ? this : NaN; 3323 } 3324 if (input != null) { 3325 if (typeof input === 'string') { 3326 input = offsetFromString(matchShortOffset, input); 3327 if (input === null) { 3328 return this; 3329 } 3330 } else if (Math.abs(input) < 16 && !keepMinutes) { 3331 input = input * 60; 3332 } 3333 if (!this._isUTC && keepLocalTime) { 3334 localAdjust = getDateOffset(this); 3335 } 3336 this._offset = input; 3337 this._isUTC = true; 3338 if (localAdjust != null) { 3339 this.add(localAdjust, 'm'); 3340 } 3341 if (offset !== input) { 3342 if (!keepLocalTime || this._changeInProgress) { 3343 addSubtract( 3344 this, 3345 createDuration(input - offset, 'm'), 3346 1, 3347 false 3348 ); 3349 } else if (!this._changeInProgress) { 3350 this._changeInProgress = true; 3351 hooks.updateOffset(this, true); 3352 this._changeInProgress = null; 3353 } 3354 } 3355 return this; 3356 } else { 3357 return this._isUTC ? offset : getDateOffset(this); 3358 } 3359 } 3360 3361 function getSetZone(input, keepLocalTime) { 3362 if (input != null) { 3363 if (typeof input !== 'string') { 3364 input = -input; 3365 } 3366 3367 this.utcOffset(input, keepLocalTime); 3368 3369 return this; 3370 } else { 3371 return -this.utcOffset(); 3372 } 3373 } 3374 3375 function setOffsetToUTC(keepLocalTime) { 3376 return this.utcOffset(0, keepLocalTime); 3377 } 3378 3379 function setOffsetToLocal(keepLocalTime) { 3380 if (this._isUTC) { 3381 this.utcOffset(0, keepLocalTime); 3382 this._isUTC = false; 3383 3384 if (keepLocalTime) { 3385 this.subtract(getDateOffset(this), 'm'); 3386 } 3387 } 3388 return this; 3389 } 3390 3391 function setOffsetToParsedOffset() { 3392 if (this._tzm != null) { 3393 this.utcOffset(this._tzm, false, true); 3394 } else if (typeof this._i === 'string') { 3395 var tZone = offsetFromString(matchOffset, this._i); 3396 if (tZone != null) { 3397 this.utcOffset(tZone); 3398 } else { 3399 this.utcOffset(0, true); 3400 } 3401 } 3402 return this; 3403 } 3404 3405 function hasAlignedHourOffset(input) { 3406 if (!this.isValid()) { 3407 return false; 3408 } 3409 input = input ? createLocal(input).utcOffset() : 0; 3410 3411 return (this.utcOffset() - input) % 60 === 0; 3412 } 3413 3414 function isDaylightSavingTime() { 3415 return ( 3416 this.utcOffset() > this.clone().month(0).utcOffset() || 3417 this.utcOffset() > this.clone().month(5).utcOffset() 3418 ); 3419 } 3420 3421 function isDaylightSavingTimeShifted() { 3422 if (!isUndefined(this._isDSTShifted)) { 3423 return this._isDSTShifted; 3424 } 3425 3426 var c = {}, 3427 other; 3428 3429 copyConfig(c, this); 3430 c = prepareConfig(c); 3431 3432 if (c._a) { 3433 other = c._isUTC ? createUTC(c._a) : createLocal(c._a); 3434 this._isDSTShifted = 3435 this.isValid() && compareArrays(c._a, other.toArray()) > 0; 3436 } else { 3437 this._isDSTShifted = false; 3438 } 3439 3440 return this._isDSTShifted; 3441 } 3442 3443 function isLocal() { 3444 return this.isValid() ? !this._isUTC : false; 3445 } 3446 3447 function isUtcOffset() { 3448 return this.isValid() ? this._isUTC : false; 3449 } 3450 3451 function isUtc() { 3452 return this.isValid() ? this._isUTC && this._offset === 0 : false; 3453 } 3454 3455 // ASP.NET json date format regex 3456 var aspNetRegex = /^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/, 3457 // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html 3458 // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere 3459 // and further modified to allow for strings containing both week and day 3460 isoRegex =
vendor: 9,021 bytes, lines 3460-3750
3460 3461 /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/; 3462 3463 function createDuration(input, key) { 3464 var duration = input, 3465 // matching against regexp is expensive, do it on demand 3466 match = null, 3467 sign, 3468 ret, 3469 diffRes; 3470 3471 if (isDuration(input)) { 3472 duration = { 3473 ms: input._milliseconds, 3474 d: input._days, 3475 M: input._months, 3476 }; 3477 } else if (isNumber(input) || !isNaN(+input)) { 3478 duration = {}; 3479 if (key) { 3480 duration[key] = +input; 3481 } else { 3482 duration.milliseconds = +input; 3483 } 3484 } else if ((match = aspNetRegex.exec(input))) { 3485 sign = match[1] === '-' ? -1 : 1; 3486 duration = { 3487 y: 0, 3488 d: toInt(match[DATE]) * sign, 3489 h: toInt(match[HOUR]) * sign, 3490 m: toInt(match[MINUTE]) * sign, 3491 s: toInt(match[SECOND]) * sign, 3492 ms: toInt(absRound(match[MILLISECOND] * 1000)) * sign, // the millisecond decimal point is included in the match 3493 }; 3494 } else if ((match = isoRegex.exec(input))) { 3495 sign = match[1] === '-' ? -1 : 1; 3496 duration = { 3497 y: parseIso(match[2], sign), 3498 M: parseIso(match[3], sign), 3499 w: parseIso(match[4], sign), 3500 d: parseIso(match[5], sign), 3501 h: parseIso(match[6], sign), 3502 m: parseIso(match[7], sign), 3503 s: parseIso(match[8], sign), 3504 }; 3505 } else if (duration == null) { 3506 // checks for null or undefined 3507 duration = {}; 3508 } else if ( 3509 typeof duration === 'object' && 3510 ('from' in duration || 'to' in duration) 3511 ) { 3512 diffRes = momentsDifference( 3513 createLocal(duration.from), 3514 createLocal(duration.to) 3515 ); 3516 3517 duration = {}; 3518 duration.ms = diffRes.milliseconds; 3519 duration.M = diffRes.months; 3520 } 3521 3522 ret = new Duration(duration); 3523 3524 if (isDuration(input) && hasOwnProp(input, '_locale')) { 3525 ret._locale = input._locale; 3526 } 3527 3528 if (isDuration(input) && hasOwnProp(input, '_isValid')) { 3529 ret._isValid = input._isValid; 3530 } 3531 3532 return ret; 3533 } 3534 3535 createDuration.fn = Duration.prototype; 3536 createDuration.invalid = createInvalid$1; 3537 3538 function parseIso(inp, sign) { 3539 // We'd normally use ~~inp for this, but unfortunately it also 3540 // converts floats to ints. 3541 // inp may be undefined, so careful calling replace on it. 3542 var res = inp && parseFloat(inp.replace(',', '.')); 3543 // apply sign while we're at it 3544 return (isNaN(res) ? 0 : res) * sign; 3545 } 3546 3547 function positiveMomentsDifference(base, other) { 3548 var res = {}; 3549 3550 res.months = 3551 other.month() - base.month() + (other.year() - base.year()) * 12; 3552 if (base.clone().add(res.months, 'M').isAfter(other)) { 3553 --res.months; 3554 } 3555 3556 res.milliseconds = +other - +base.clone().add(res.months, 'M'); 3557 3558 return res; 3559 } 3560 3561 function momentsDifference(base, other) { 3562 var res; 3563 if (!(base.isValid() && other.isValid())) { 3564 return { milliseconds: 0, months: 0 }; 3565 } 3566 3567 other = cloneWithOffset(other, base); 3568 if (base.isBefore(other)) { 3569 res = positiveMomentsDifference(base, other); 3570 } else { 3571 res = positiveMomentsDifference(other, base); 3572 res.milliseconds = -res.milliseconds; 3573 res.months = -res.months; 3574 } 3575 3576 return res; 3577 } 3578 3579 // TODO: remove 'name' arg after deprecation is removed 3580 function createAdder(direction, name) { 3581 return function (val, period) { 3582 var dur, tmp; 3583 //invert the arguments, but complain about it 3584 if (period !== null && !isNaN(+period)) { 3585 deprecateSimple( 3586 name, 3587 'moment().' + 3588 name + 3589 '(period, number) is deprecated. Please use moment().' + 3590 name + 3591 '(number, period). ' + 3592 'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.' 3593 ); 3594 tmp = val; 3595 val = period; 3596 period = tmp; 3597 } 3598 3599 dur = createDuration(val, period); 3600 addSubtract(this, dur, direction); 3601 return this; 3602 }; 3603 } 3604 3605 function addSubtract(mom, duration, isAdding, updateOffset) { 3606 var milliseconds = duration._milliseconds, 3607 days = absRound(duration._days), 3608 months = absRound(duration._months); 3609 3610 if (!mom.isValid()) { 3611 // No op 3612 return; 3613 } 3614 3615 updateOffset = updateOffset == null ? true : updateOffset; 3616 3617 if (months) { 3618 setMonth(mom, get(mom, 'Month') + months * isAdding); 3619 } 3620 if (days) { 3621 set$1(mom, 'Date', get(mom, 'Date') + days * isAdding); 3622 } 3623 if (milliseconds) { 3624 mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding); 3625 } 3626 if (updateOffset) { 3627 hooks.updateOffset(mom, days || months); 3628 } 3629 } 3630 3631 var add = createAdder(1, 'add'), 3632 subtract = createAdder(-1, 'subtract'); 3633 3634 function isString(input) { 3635 return typeof input === 'string' || input instanceof String; 3636 } 3637 3638 // type MomentInput = Moment | Date | string | number | (number | string)[] | MomentInputObject | void; // null | undefined 3639 function isMomentInput(input) { 3640 return ( 3641 isMoment(input) || 3642 isDate(input) || 3643 isString(input) || 3644 isNumber(input) || 3645 isNumberOrStringArray(input) || 3646 isMomentInputObject(input) || 3647 input === null || 3648 input === undefined 3649 ); 3650 } 3651 3652 function isMomentInputObject(input) { 3653 var objectTest = isObject(input) && !isObjectEmpty(input), 3654 propertyTest = false, 3655 properties = [ 3656 'years', 3657 'year', 3658 'y', 3659 'months', 3660 'month', 3661 'M', 3662 'days', 3663 'day', 3664 'd', 3665 'dates', 3666 'date', 3667 'D', 3668 'hours', 3669 'hour', 3670 'h', 3671 'minutes', 3672 'minute', 3673 'm', 3674 'seconds', 3675 'second', 3676 's', 3677 'milliseconds', 3678 'millisecond', 3679 'ms', 3680 ], 3681 i, 3682 property, 3683 propertyLen = properties.length; 3684 3685 for (i = 0; i < propertyLen; i += 1) { 3686 property = properties[i]; 3687 propertyTest = propertyTest || hasOwnProp(input, property); 3688 } 3689 3690 return objectTest && propertyTest; 3691 } 3692 3693 function isNumberOrStringArray(input) { 3694 var arrayTest = isArray(input), 3695 dataTypeTest = false; 3696 if (arrayTest) { 3697 dataTypeTest = 3698 input.filter(function (item) { 3699 return !isNumber(item) && isString(input); 3700 }).length === 0; 3701 } 3702 return arrayTest && dataTypeTest; 3703 } 3704 3705 function isCalendarSpec(input) { 3706 var objectTest = isObject(input) && !isObjectEmpty(input), 3707 propertyTest = false, 3708 properties = [ 3709 'sameDay', 3710 'nextDay', 3711 'lastDay', 3712 'nextWeek', 3713 'lastWeek', 3714 'sameElse', 3715 ], 3716 i, 3717 property; 3718 3719 for (i = 0; i < properties.length; i += 1) { 3720 property = properties[i]; 3721 propertyTest = propertyTest || hasOwnProp(input, property); 3722 } 3723 3724 return objectTest && propertyTest; 3725 } 3726 3727 function getCalendarFormat(myMoment, now) { 3728 var diff = myMoment.diff(now, 'days', true); 3729 return diff < -6 3730 ? 'sameElse' 3731 : diff < -1 3732 ? 'lastWeek' 3733 : diff < 0 3734 ? 'lastDay' 3735 : diff < 1 3736 ? 'sameDay' 3737 : diff < 2 3738 ? 'nextDay' 3739 : diff < 7 3740 ? 'nextWeek' 3741 : 'sameElse'; 3742 } 3743 3744 function calendar$1(time, formats) { 3745 // Support for single parameter, formats only overload to the calendar function 3746 if (arguments.length === 1) { 3747 if (!arguments[0]) { 3748 time = undefined; 3749 formats = undefined; 3750 } else
vendor: 17,627 bytes, lines 3750-4308
3750 if (isMomentInput(arguments[0])) { 3751 time = arguments[0]; 3752 formats = undefined; 3753 } else if (isCalendarSpec(arguments[0])) { 3754 formats = arguments[0]; 3755 time = undefined; 3756 } 3757 } 3758 // We want to compare the start of today, vs this. 3759 // Getting start-of-today depends on whether we're local/utc/offset or not. 3760 var now = time || createLocal(), 3761 sod = cloneWithOffset(now, this).startOf('day'), 3762 format = hooks.calendarFormat(this, sod) || 'sameElse', 3763 output = 3764 formats && 3765 (isFunction(formats[format]) 3766 ? formats[format].call(this, now) 3767 : formats[format]); 3768 3769 return this.format( 3770 output || this.localeData().calendar(format, this, createLocal(now)) 3771 ); 3772 } 3773 3774 function clone() { 3775 return new Moment(this); 3776 } 3777 3778 function isAfter(input, units) { 3779 var localInput = isMoment(input) ? input : createLocal(input); 3780 if (!(this.isValid() && localInput.isValid())) { 3781 return false; 3782 } 3783 units = normalizeUnits(units) || 'millisecond'; 3784 if (units === 'millisecond') { 3785 return this.valueOf() > localInput.valueOf(); 3786 } else { 3787 return localInput.valueOf() < this.clone().startOf(units).valueOf(); 3788 } 3789 } 3790 3791 function isBefore(input, units) { 3792 var localInput = isMoment(input) ? input : createLocal(input); 3793 if (!(this.isValid() && localInput.isValid())) { 3794 return false; 3795 } 3796 units = normalizeUnits(units) || 'millisecond'; 3797 if (units === 'millisecond') { 3798 return this.valueOf() < localInput.valueOf(); 3799 } else { 3800 return this.clone().endOf(units).valueOf() < localInput.valueOf(); 3801 } 3802 } 3803 3804 function isBetween(from, to, units, inclusivity) { 3805 var localFrom = isMoment(from) ? from : createLocal(from), 3806 localTo = isMoment(to) ? to : createLocal(to); 3807 if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) { 3808 return false; 3809 } 3810 inclusivity = inclusivity || '()'; 3811 return ( 3812 (inclusivity[0] === '(' 3813 ? this.isAfter(localFrom, units) 3814 : !this.isBefore(localFrom, units)) && 3815 (inclusivity[1] === ')' 3816 ? this.isBefore(localTo, units) 3817 : !this.isAfter(localTo, units)) 3818 ); 3819 } 3820 3821 function isSame(input, units) { 3822 var localInput = isMoment(input) ? input : createLocal(input), 3823 inputMs; 3824 if (!(this.isValid() && localInput.isValid())) { 3825 return false; 3826 } 3827 units = normalizeUnits(units) || 'millisecond'; 3828 if (units === 'millisecond') { 3829 return this.valueOf() === localInput.valueOf(); 3830 } else { 3831 inputMs = localInput.valueOf(); 3832 return ( 3833 this.clone().startOf(units).valueOf() <= inputMs && 3834 inputMs <= this.clone().endOf(units).valueOf() 3835 ); 3836 } 3837 } 3838 3839 function isSameOrAfter(input, units) { 3840 return this.isSame(input, units) || this.isAfter(input, units); 3841 } 3842 3843 function isSameOrBefore(input, units) { 3844 return this.isSame(input, units) || this.isBefore(input, units); 3845 } 3846 3847 function diff(input, units, asFloat) { 3848 var that, zoneDelta, output; 3849 3850 if (!this.isValid()) { 3851 return NaN; 3852 } 3853 3854 that = cloneWithOffset(input, this); 3855 3856 if (!that.isValid()) { 3857 return NaN; 3858 } 3859 3860 zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4; 3861 3862 units = normalizeUnits(units); 3863 3864 switch (units) { 3865 case 'year': 3866 output = monthDiff(this, that) / 12; 3867 break; 3868 case 'month': 3869 output = monthDiff(this, that); 3870 break; 3871 case 'quarter': 3872 output = monthDiff(this, that) / 3; 3873 break; 3874 case 'second': 3875 output = (this - that) / 1e3; 3876 break; // 1000 3877 case 'minute': 3878 output = (this - that) / 6e4; 3879 break; // 1000 * 60 3880 case 'hour': 3881 output = (this - that) / 36e5; 3882 break; // 1000 * 60 * 60 3883 case 'day': 3884 output = (this - that - zoneDelta) / 864e5; 3885 break; // 1000 * 60 * 60 * 24, negate dst 3886 case 'week': 3887 output = (this - that - zoneDelta) / 6048e5; 3888 break; // 1000 * 60 * 60 * 24 * 7, negate dst 3889 default: 3890 output = this - that; 3891 } 3892 3893 return asFloat ? output : absFloor(output); 3894 } 3895 3896 function monthDiff(a, b) { 3897 if (a.date() < b.date()) { 3898 // end-of-month calculations work correct when the start month has more 3899 // days than the end month. 3900 return -monthDiff(b, a); 3901 } 3902 // difference in months 3903 var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month()), 3904 // b is in (anchor - 1 month, anchor + 1 month) 3905 anchor = a.clone().add(wholeMonthDiff, 'months'), 3906 anchor2, 3907 adjust; 3908 3909 if (b - anchor < 0) { 3910 anchor2 = a.clone().add(wholeMonthDiff - 1, 'months'); 3911 // linear across the month 3912 adjust = (b - anchor) / (anchor - anchor2); 3913 } else { 3914 anchor2 = a.clone().add(wholeMonthDiff + 1, 'months'); 3915 // linear across the month 3916 adjust = (b - anchor) / (anchor2 - anchor); 3917 } 3918 3919 //check for negative zero, return zero if negative zero 3920 return -(wholeMonthDiff + adjust) || 0; 3921 } 3922 3923 hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ'; 3924 hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]'; 3925 3926 function toString() { 3927 return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ'); 3928 } 3929 3930 function toISOString(keepOffset) { 3931 if (!this.isValid()) { 3932 return null; 3933 } 3934 var utc = keepOffset !== true, 3935 m = utc ? this.clone().utc() : this; 3936 if (m.year() < 0 || m.year() > 9999) { 3937 return formatMoment( 3938 m, 3939 utc 3940 ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]' 3941 : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ' 3942 ); 3943 } 3944 if (isFunction(Date.prototype.toISOString)) { 3945 // native implementation is ~50x faster, use it when we can 3946 if (utc) { 3947 return this.toDate().toISOString(); 3948 } else { 3949 return new Date(this.valueOf() + this.utcOffset() * 60 * 1000) 3950 .toISOString() 3951 .replace('Z', formatMoment(m, 'Z')); 3952 } 3953 } 3954 return formatMoment( 3955 m, 3956 utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ' 3957 ); 3958 } 3959 3960 /** 3961 * Return a human readable representation of a moment that can 3962 * also be evaluated to get a new moment which is the same 3963 * 3964 * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects 3965 */ 3966 function inspect() { 3967 if (!this.isValid()) { 3968 return 'moment.invalid(/* ' + this._i + ' */)'; 3969 } 3970 var func = 'moment', 3971 zone = '', 3972 prefix, 3973 year, 3974 datetime, 3975 suffix; 3976 if (!this.isLocal()) { 3977 func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone'; 3978 zone = 'Z'; 3979 } 3980 prefix = '[' + func + '("]'; 3981 year = 0 <= this.year() && this.year() <= 9999 ? 'YYYY' : 'YYYYYY'; 3982 datetime = '-MM-DD[T]HH:mm:ss.SSS'; 3983 suffix = zone + '[")]'; 3984 3985 return this.format(prefix + year + datetime + suffix); 3986 } 3987 3988 function format(inputString) { 3989 if (!inputString) { 3990 inputString = this.isUtc() 3991 ? hooks.defaultFormatUtc 3992 : hooks.defaultFormat; 3993 } 3994 var output = formatMoment(this, inputString); 3995 return this.localeData().postformat(output); 3996 } 3997 3998 function from(time, withoutSuffix) { 3999 if ( 4000 this.isValid() && 4001 ((isMoment(time) && time.isValid()) || createLocal(time).isValid()) 4002 ) { 4003 return createDuration({ to: this, from: time }) 4004 .locale(this.locale()) 4005 .humanize(!withoutSuffix); 4006 } else { 4007 return this.localeData().invalidDate(); 4008 } 4009 } 4010 4011 function fromNow(withoutSuffix) { 4012 return this.from(createLocal(), withoutSuffix); 4013 } 4014 4015 function to(time, withoutSuffix) { 4016 if ( 4017 this.isValid() && 4018 ((isMoment(time) && time.isValid()) || createLocal(time).isValid()) 4019 ) { 4020 return createDuration({ from: this, to: time }) 4021 .locale(this.locale()) 4022 .humanize(!withoutSuffix); 4023 } else { 4024 return this.localeData().invalidDate(); 4025 } 4026 } 4027 4028 function toNow(withoutSuffix) { 4029 return this.to(createLocal(), withoutSuffix); 4030 } 4031 4032 // If passed a locale key, it will set the locale for this 4033 // instance. Otherwise, it will return the locale configuration 4034 // variables for this instance. 4035 function locale(key) { 4036 var newLocaleData; 4037 4038 if (key === undefined) { 4039 return this._locale._abbr; 4040 } else { 4041 newLocaleData = getLocale(key); 4042 if (newLocaleData != null) { 4043 this._locale = newLocaleData; 4044 } 4045 return this; 4046 } 4047 } 4048 4049 var lang = deprecate( 4050 'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.', 4051 function (key) { 4052 if (key === undefined) { 4053 return this.localeData(); 4054 } else { 4055 return this.locale(key); 4056 } 4057 } 4058 ); 4059 4060 function localeData() { 4061 return this._locale; 4062 } 4063 4064 var MS_PER_SECOND = 1000, 4065 MS_PER_MINUTE = 60 * MS_PER_SECOND, 4066 MS_PER_HOUR = 60 * MS_PER_MINUTE, 4067 MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR; 4068 4069 // actual modulo - handles negative numbers (for dates before 1970): 4070 function mod$1(dividend, divisor) { 4071 return ((dividend % divisor) + divisor) % divisor; 4072 } 4073 4074 function localStartOfDate(y, m, d) { 4075 // the date constructor remaps years 0-99 to 1900-1999 4076 if (y < 100 && y >= 0) { 4077 // preserve leap years using a full 400 year cycle, then reset 4078 return new Date(y + 400, m, d) - MS_PER_400_YEARS; 4079 } else { 4080 return new Date(y, m, d).valueOf(); 4081 } 4082 } 4083 4084 function utcStartOfDate(y, m, d) { 4085 // Date.UTC remaps years 0-99 to 1900-1999 4086 if (y < 100 && y >= 0) { 4087 // preserve leap years using a full 400 year cycle, then reset 4088 return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS; 4089 } else { 4090 return Date.UTC(y, m, d); 4091 } 4092 } 4093 4094 function startOf(units) { 4095 var time, startOfDate; 4096 units = normalizeUnits(units); 4097 if (units === undefined || units === 'millisecond' || !this.isValid()) { 4098 return this; 4099 } 4100 4101 startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate; 4102 4103 switch (units) { 4104 case 'year': 4105 time = startOfDate(this.year(), 0, 1); 4106 break; 4107 case 'quarter': 4108 time = startOfDate( 4109 this.year(), 4110 this.month() - (this.month() % 3), 4111 1 4112 ); 4113 break; 4114 case 'month': 4115 time = startOfDate(this.year(), this.month(), 1); 4116 break; 4117 case 'week': 4118 time = startOfDate( 4119 this.year(), 4120 this.month(), 4121 this.date() - this.weekday() 4122 ); 4123 break; 4124 case 'isoWeek': 4125 time = startOfDate( 4126 this.year(), 4127 this.month(), 4128 this.date() - (this.isoWeekday() - 1) 4129 ); 4130 break; 4131 case 'day': 4132 case 'date': 4133 time = startOfDate(this.year(), this.month(), this.date()); 4134 break; 4135 case 'hour': 4136 time = this._d.valueOf(); 4137 time -= mod$1( 4138 time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), 4139 MS_PER_HOUR 4140 ); 4141 break; 4142 case 'minute': 4143 time = this._d.valueOf(); 4144 time -= mod$1(time, MS_PER_MINUTE); 4145 break; 4146 case 'second': 4147 time = this._d.valueOf(); 4148 time -= mod$1(time, MS_PER_SECOND); 4149 break; 4150 } 4151 4152 this._d.setTime(time); 4153 hooks.updateOffset(this, true); 4154 return this; 4155 } 4156 4157 function endOf(units) { 4158 var time, startOfDate; 4159 units = normalizeUnits(units); 4160 if (units === undefined || units === 'millisecond' || !this.isValid()) { 4161 return this; 4162 } 4163 4164 startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate; 4165 4166 switch (units) { 4167 case 'year': 4168 time = startOfDate(this.year() + 1, 0, 1) - 1; 4169 break; 4170 case 'quarter': 4171 time = 4172 startOfDate( 4173 this.year(), 4174 this.month() - (this.month() % 3) + 3, 4175 1 4176 ) - 1; 4177 break; 4178 case 'month': 4179 time = startOfDate(this.year(), this.month() + 1, 1) - 1; 4180 break; 4181 case 'week': 4182 time = 4183 startOfDate( 4184 this.year(), 4185 this.month(), 4186 this.date() - this.weekday() + 7 4187 ) - 1; 4188 break; 4189 case 'isoWeek': 4190 time = 4191 startOfDate( 4192 this.year(), 4193 this.month(), 4194 this.date() - (this.isoWeekday() - 1) + 7 4195 ) - 1; 4196 break; 4197 case 'day': 4198 case 'date': 4199 time = startOfDate(this.year(), this.month(), this.date() + 1) - 1; 4200 break; 4201 case 'hour': 4202 time = this._d.valueOf(); 4203 time += 4204 MS_PER_HOUR - 4205 mod$1( 4206 time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), 4207 MS_PER_HOUR 4208 ) - 4209 1; 4210 break; 4211 case 'minute': 4212 time = this._d.valueOf(); 4213 time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1; 4214 break; 4215 case 'second': 4216 time = this._d.valueOf(); 4217 time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1; 4218 break; 4219 } 4220 4221 this._d.setTime(time); 4222 hooks.updateOffset(this, true); 4223 return this; 4224 } 4225 4226 function valueOf() { 4227 return this._d.valueOf() - (this._offset || 0) * 60000; 4228 } 4229 4230 function unix() { 4231 return Math.floor(this.valueOf() / 1000); 4232 } 4233 4234 function toDate() { 4235 return new Date(this.valueOf()); 4236 } 4237 4238 function toArray() { 4239 var m = this; 4240 return [ 4241 m.year(), 4242 m.month(), 4243 m.date(), 4244 m.hour(), 4245 m.minute(), 4246 m.second(), 4247 m.millisecond(), 4248 ]; 4249 } 4250 4251 function toObject() { 4252 var m = this; 4253 return { 4254 years: m.year(), 4255 months: m.month(), 4256 date: m.date(), 4257 hours: m.hours(), 4258 minutes: m.minutes(), 4259 seconds: m.seconds(), 4260 milliseconds: m.milliseconds(), 4261 }; 4262 } 4263 4264 function toJSON() { 4265 // new Date(NaN).toJSON() === null 4266 return this.isValid() ? this.toISOString() : null; 4267 } 4268 4269 function isValid$2() { 4270 return isValid(this); 4271 } 4272 4273 function parsingFlags() { 4274 return extend({}, getParsingFlags(this)); 4275 } 4276 4277 function invalidAt() { 4278 return getParsingFlags(this).overflow; 4279 } 4280 4281 function creationData() { 4282 return { 4283 input: this._i, 4284 format: this._f, 4285 locale: this._locale, 4286 isUTC: this._isUTC, 4287 strict: this._strict, 4288 }; 4289 } 4290 4291 addFormatToken('N', 0, 0, 'eraAbbr'); 4292 addFormatToken('NN', 0, 0, 'eraAbbr'); 4293 addFormatToken('NNN', 0, 0, 'eraAbbr'); 4294 addFormatToken('NNNN', 0, 0, 'eraName'); 4295 addFormatToken('NNNNN', 0, 0, 'eraNarrow'); 4296 4297 addFormatToken('y', ['y', 1], 'yo', 'eraYear'); 4298 addFormatToken('y', ['yy', 2], 0, 'eraYear'); 4299 addFormatToken('y', ['yyy', 3], 0, 'eraYear'); 4300 addFormatToken('y', ['yyyy', 4], 0, 'eraYear'); 4301 4302 addRegexToken('N', matchEraAbbr); 4303 addRegexToken('NN', matchEraAbbr); 4304 addRegexToken('NNN', matchEraAbbr); 4305 addRegexToken('NNNN', matchEraName); 4306 addRegexToken('NNNNN', matchEraNarrow); 4307 4308 addParseToken(
vendor: 8,145 bytes, lines 4308-4583
4308 4309 ['N', 'NN', 'NNN', 'NNNN', 'NNNNN'], 4310 function (input, array, config, token) { 4311 var era = config._locale.erasParse(input, token, config._strict); 4312 if (era) { 4313 getParsingFlags(config).era = era; 4314 } else { 4315 getParsingFlags(config).invalidEra = input; 4316 } 4317 } 4318 ); 4319 4320 addRegexToken('y', matchUnsigned); 4321 addRegexToken('yy', matchUnsigned); 4322 addRegexToken('yyy', matchUnsigned); 4323 addRegexToken('yyyy', matchUnsigned); 4324 addRegexToken('yo', matchEraYearOrdinal); 4325 4326 addParseToken(['y', 'yy', 'yyy', 'yyyy'], YEAR); 4327 addParseToken(['yo'], function (input, array, config, token) { 4328 var match; 4329 if (config._locale._eraYearOrdinalRegex) { 4330 match = input.match(config._locale._eraYearOrdinalRegex); 4331 } 4332 4333 if (config._locale.eraYearOrdinalParse) { 4334 array[YEAR] = config._locale.eraYearOrdinalParse(input, match); 4335 } else { 4336 array[YEAR] = parseInt(input, 10); 4337 } 4338 }); 4339 4340 function localeEras(m, format) { 4341 var i, 4342 l, 4343 date, 4344 eras = this._eras || getLocale('en')._eras; 4345 for (i = 0, l = eras.length; i < l; ++i) { 4346 switch (typeof eras[i].since) { 4347 case 'string': 4348 // truncate time 4349 date = hooks(eras[i].since).startOf('day'); 4350 eras[i].since = date.valueOf(); 4351 break; 4352 } 4353 4354 switch (typeof eras[i].until) { 4355 case 'undefined': 4356 eras[i].until = +Infinity; 4357 break; 4358 case 'string': 4359 // truncate time 4360 date = hooks(eras[i].until).startOf('day').valueOf(); 4361 eras[i].until = date.valueOf(); 4362 break; 4363 } 4364 } 4365 return eras; 4366 } 4367 4368 function localeErasParse(eraName, format, strict) { 4369 var i, 4370 l, 4371 eras = this.eras(), 4372 name, 4373 abbr, 4374 narrow; 4375 eraName = eraName.toUpperCase(); 4376 4377 for (i = 0, l = eras.length; i < l; ++i) { 4378 name = eras[i].name.toUpperCase(); 4379 abbr = eras[i].abbr.toUpperCase(); 4380 narrow = eras[i].narrow.toUpperCase(); 4381 4382 if (strict) { 4383 switch (format) { 4384 case 'N': 4385 case 'NN': 4386 case 'NNN': 4387 if (abbr === eraName) { 4388 return eras[i]; 4389 } 4390 break; 4391 4392 case 'NNNN': 4393 if (name === eraName) { 4394 return eras[i]; 4395 } 4396 break; 4397 4398 case 'NNNNN': 4399 if (narrow === eraName) { 4400 return eras[i]; 4401 } 4402 break; 4403 } 4404 } else if ([name, abbr, narrow].indexOf(eraName) >= 0) { 4405 return eras[i]; 4406 } 4407 } 4408 } 4409 4410 function localeErasConvertYear(era, year) { 4411 var dir = era.since <= era.until ? +1 : -1; 4412 if (year === undefined) { 4413 return hooks(era.since).year(); 4414 } else { 4415 return hooks(era.since).year() + (year - era.offset) * dir; 4416 } 4417 } 4418 4419 function getEraName() { 4420 var i, 4421 l, 4422 val, 4423 eras = this.localeData().eras(); 4424 for (i = 0, l = eras.length; i < l; ++i) { 4425 // truncate time 4426 val = this.clone().startOf('day').valueOf(); 4427 4428 if (eras[i].since <= val && val <= eras[i].until) { 4429 return eras[i].name; 4430 } 4431 if (eras[i].until <= val && val <= eras[i].since) { 4432 return eras[i].name; 4433 } 4434 } 4435 4436 return ''; 4437 } 4438 4439 function getEraNarrow() { 4440 var i, 4441 l, 4442 val, 4443 eras = this.localeData().eras(); 4444 for (i = 0, l = eras.length; i < l; ++i) { 4445 // truncate time 4446 val = this.clone().startOf('day').valueOf(); 4447 4448 if (eras[i].since <= val && val <= eras[i].until) { 4449 return eras[i].narrow; 4450 } 4451 if (eras[i].until <= val && val <= eras[i].since) { 4452 return eras[i].narrow; 4453 } 4454 } 4455 4456 return ''; 4457 } 4458 4459 function getEraAbbr() { 4460 var i, 4461 l, 4462 val, 4463 eras = this.localeData().eras(); 4464 for (i = 0, l = eras.length; i < l; ++i) { 4465 // truncate time 4466 val = this.clone().startOf('day').valueOf(); 4467 4468 if (eras[i].since <= val && val <= eras[i].until) { 4469 return eras[i].abbr; 4470 } 4471 if (eras[i].until <= val && val <= eras[i].since) { 4472 return eras[i].abbr; 4473 } 4474 } 4475 4476 return ''; 4477 } 4478 4479 function getEraYear() { 4480 var i, 4481 l, 4482 dir, 4483 val, 4484 eras = this.localeData().eras(); 4485 for (i = 0, l = eras.length; i < l; ++i) { 4486 dir = eras[i].since <= eras[i].until ? +1 : -1; 4487 4488 // truncate time 4489 val = this.clone().startOf('day').valueOf(); 4490 4491 if ( 4492 (eras[i].since <= val && val <= eras[i].until) || 4493 (eras[i].until <= val && val <= eras[i].since) 4494 ) { 4495 return ( 4496 (this.year() - hooks(eras[i].since).year()) * dir + 4497 eras[i].offset 4498 ); 4499 } 4500 } 4501 4502 return this.year(); 4503 } 4504 4505 function erasNameRegex(isStrict) { 4506 if (!hasOwnProp(this, '_erasNameRegex')) { 4507 computeErasParse.call(this); 4508 } 4509 return isStrict ? this._erasNameRegex : this._erasRegex; 4510 } 4511 4512 function erasAbbrRegex(isStrict) { 4513 if (!hasOwnProp(this, '_erasAbbrRegex')) { 4514 computeErasParse.call(this); 4515 } 4516 return isStrict ? this._erasAbbrRegex : this._erasRegex; 4517 } 4518 4519 function erasNarrowRegex(isStrict) { 4520 if (!hasOwnProp(this, '_erasNarrowRegex')) { 4521 computeErasParse.call(this); 4522 } 4523 return isStrict ? this._erasNarrowRegex : this._erasRegex; 4524 } 4525 4526 function matchEraAbbr(isStrict, locale) { 4527 return locale.erasAbbrRegex(isStrict); 4528 } 4529 4530 function matchEraName(isStrict, locale) { 4531 return locale.erasNameRegex(isStrict); 4532 } 4533 4534 function matchEraNarrow(isStrict, locale) { 4535 return locale.erasNarrowRegex(isStrict); 4536 } 4537 4538 function matchEraYearOrdinal(isStrict, locale) { 4539 return locale._eraYearOrdinalRegex || matchUnsigned; 4540 } 4541 4542 function computeErasParse() { 4543 var abbrPieces = [], 4544 namePieces = [], 4545 narrowPieces = [], 4546 mixedPieces = [], 4547 i, 4548 l, 4549 eras = this.eras(); 4550 4551 for (i = 0, l = eras.length; i < l; ++i) { 4552 namePieces.push(regexEscape(eras[i].name)); 4553 abbrPieces.push(regexEscape(eras[i].abbr)); 4554 narrowPieces.push(regexEscape(eras[i].narrow)); 4555 4556 mixedPieces.push(regexEscape(eras[i].name)); 4557 mixedPieces.push(regexEscape(eras[i].abbr)); 4558 mixedPieces.push(regexEscape(eras[i].narrow)); 4559 } 4560 4561 this._erasRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i'); 4562 this._erasNameRegex = new RegExp('^(' + namePieces.join('|') + ')', 'i'); 4563 this._erasAbbrRegex = new RegExp('^(' + abbrPieces.join('|') + ')', 'i'); 4564 this._erasNarrowRegex = new RegExp( 4565 '^(' + narrowPieces.join('|') + ')', 4566 'i' 4567 ); 4568 } 4569 4570 // FORMATTING 4571 4572 addFormatToken(0, ['gg', 2], 0, function () { 4573 return this.weekYear() % 100; 4574 }); 4575 4576 addFormatToken(0, ['GG', 2], 0, function () { 4577 return this.isoWeekYear() % 100; 4578 }); 4579 4580 function addWeekYearFormatToken(token, getter) { 4581 addFormatToken(0, [token, token.length], 0, getter); 4582 } 4583
4584 addWeekYearFormatToken('gggg', 'weekYear'); 4585 addWeekYearFormatToken('ggggg', 'weekYear'); 4586 addWeekYearFormatToken('GGGG', 'isoWeekYear'); 4587 addWeekYearFormatToken('GGGGG', 'isoWeekYear'); 4588 4589 // ALIASES 4590 4591 addUnitAlias('weekYear', 'gg'); 4592 addUnitAlias('isoWeekYear', 'GG'); 4593 4594 // PRIORITY 4595 4596 addUnitPriority('weekYear', 1); 4597 addUnitPriority('isoWeekYear', 1); 4598 4599 // PARSING 4600 4601 addRegexToken('G', matchSigned); 4602 addRegexToken('g', matchSigned); 4603 addRegexToken('GG', match1to2, match2); 4604 addRegexToken('gg', match1to2, match2); 4605 addRegexToken('GGGG', match1to4, match4); 4606 addRegexToken('gggg', match1to4, match4); 4607 addRegexToken('GGGGG', match1to6, match6); 4608 addRegexToken('ggggg', match1to6, match6); 4609 4610 addWeekParseToken( 4611 ['gggg', 'ggggg', 'GGGG', 'GGGGG'], 4612 function (input, week, config, token) { 4613 week[token.substr(0, 2)] = toInt(input); 4614 } 4615
vendor: 29,543 bytes, lines 4615-5638
4615); 4616 4617 addWeekParseToken(['gg', 'GG'], function (input, week, config, token) { 4618 week[token] = hooks.parseTwoDigitYear(input); 4619 }); 4620 4621 // MOMENTS 4622 4623 function getSetWeekYear(input) { 4624 return getSetWeekYearHelper.call( 4625 this, 4626 input, 4627 this.week(), 4628 this.weekday(), 4629 this.localeData()._week.dow, 4630 this.localeData()._week.doy 4631 ); 4632 } 4633 4634 function getSetISOWeekYear(input) { 4635 return getSetWeekYearHelper.call( 4636 this, 4637 input, 4638 this.isoWeek(), 4639 this.isoWeekday(), 4640 1, 4641 4 4642 ); 4643 } 4644 4645 function getISOWeeksInYear() { 4646 return weeksInYear(this.year(), 1, 4); 4647 } 4648 4649 function getISOWeeksInISOWeekYear() { 4650 return weeksInYear(this.isoWeekYear(), 1, 4); 4651 } 4652 4653 function getWeeksInYear() { 4654 var weekInfo = this.localeData()._week; 4655 return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy); 4656 } 4657 4658 function getWeeksInWeekYear() { 4659 var weekInfo = this.localeData()._week; 4660 return weeksInYear(this.weekYear(), weekInfo.dow, weekInfo.doy); 4661 } 4662 4663 function getSetWeekYearHelper(input, week, weekday, dow, doy) { 4664 var weeksTarget; 4665 if (input == null) { 4666 return weekOfYear(this, dow, doy).year; 4667 } else { 4668 weeksTarget = weeksInYear(input, dow, doy); 4669 if (week > weeksTarget) { 4670 week = weeksTarget; 4671 } 4672 return setWeekAll.call(this, input, week, weekday, dow, doy); 4673 } 4674 } 4675 4676 function setWeekAll(weekYear, week, weekday, dow, doy) { 4677 var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy), 4678 date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear); 4679 4680 this.year(date.getUTCFullYear()); 4681 this.month(date.getUTCMonth()); 4682 this.date(date.getUTCDate()); 4683 return this; 4684 } 4685 4686 // FORMATTING 4687 4688 addFormatToken('Q', 0, 'Qo', 'quarter'); 4689 4690 // ALIASES 4691 4692 addUnitAlias('quarter', 'Q'); 4693 4694 // PRIORITY 4695 4696 addUnitPriority('quarter', 7); 4697 4698 // PARSING 4699 4700 addRegexToken('Q', match1); 4701 addParseToken('Q', function (input, array) { 4702 array[MONTH] = (toInt(input) - 1) * 3; 4703 }); 4704 4705 // MOMENTS 4706 4707 function getSetQuarter(input) { 4708 return input == null 4709 ? Math.ceil((this.month() + 1) / 3) 4710 : this.month((input - 1) * 3 + (this.month() % 3)); 4711 } 4712 4713 // FORMATTING 4714 4715 addFormatToken('D', ['DD', 2], 'Do', 'date'); 4716 4717 // ALIASES 4718 4719 addUnitAlias('date', 'D'); 4720 4721 // PRIORITY 4722 addUnitPriority('date', 9); 4723 4724 // PARSING 4725 4726 addRegexToken('D', match1to2); 4727 addRegexToken('DD', match1to2, match2); 4728 addRegexToken('Do', function (isStrict, locale) { 4729 // TODO: Remove "ordinalParse" fallback in next major release. 4730 return isStrict 4731 ? locale._dayOfMonthOrdinalParse || locale._ordinalParse 4732 : locale._dayOfMonthOrdinalParseLenient; 4733 }); 4734 4735 addParseToken(['D', 'DD'], DATE); 4736 addParseToken('Do', function (input, array) { 4737 array[DATE] = toInt(input.match(match1to2)[0]); 4738 }); 4739 4740 // MOMENTS 4741 4742 var getSetDayOfMonth = makeGetSet('Date', true); 4743 4744 // FORMATTING 4745 4746 addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear'); 4747 4748 // ALIASES 4749 4750 addUnitAlias('dayOfYear', 'DDD'); 4751 4752 // PRIORITY 4753 addUnitPriority('dayOfYear', 4); 4754 4755 // PARSING 4756 4757 addRegexToken('DDD', match1to3); 4758 addRegexToken('DDDD', match3); 4759 addParseToken(['DDD', 'DDDD'], function (input, array, config) { 4760 config._dayOfYear = toInt(input); 4761 }); 4762 4763 // HELPERS 4764 4765 // MOMENTS 4766 4767 function getSetDayOfYear(input) { 4768 var dayOfYear = 4769 Math.round( 4770 (this.clone().startOf('day') - this.clone().startOf('year')) / 864e5 4771 ) + 1; 4772 return input == null ? dayOfYear : this.add(input - dayOfYear, 'd'); 4773 } 4774 4775 // FORMATTING 4776 4777 addFormatToken('m', ['mm', 2], 0, 'minute'); 4778 4779 // ALIASES 4780 4781 addUnitAlias('minute', 'm'); 4782 4783 // PRIORITY 4784 4785 addUnitPriority('minute', 14); 4786 4787 // PARSING 4788 4789 addRegexToken('m', match1to2); 4790 addRegexToken('mm', match1to2, match2); 4791 addParseToken(['m', 'mm'], MINUTE); 4792 4793 // MOMENTS 4794 4795 var getSetMinute = makeGetSet('Minutes', false); 4796 4797 // FORMATTING 4798 4799 addFormatToken('s', ['ss', 2], 0, 'second'); 4800 4801 // ALIASES 4802 4803 addUnitAlias('second', 's'); 4804 4805 // PRIORITY 4806 4807 addUnitPriority('second', 15); 4808 4809 // PARSING 4810 4811 addRegexToken('s', match1to2); 4812 addRegexToken('ss', match1to2, match2); 4813 addParseToken(['s', 'ss'], SECOND); 4814 4815 // MOMENTS 4816 4817 var getSetSecond = makeGetSet('Seconds', false); 4818 4819 // FORMATTING 4820 4821 addFormatToken('S', 0, 0, function () { 4822 return ~~(this.millisecond() / 100); 4823 }); 4824 4825 addFormatToken(0, ['SS', 2], 0, function () { 4826 return ~~(this.millisecond() / 10); 4827 }); 4828 4829 addFormatToken(0, ['SSS', 3], 0, 'millisecond'); 4830 addFormatToken(0, ['SSSS', 4], 0, function () { 4831 return this.millisecond() * 10; 4832 }); 4833 addFormatToken(0, ['SSSSS', 5], 0, function () { 4834 return this.millisecond() * 100; 4835 }); 4836 addFormatToken(0, ['SSSSSS', 6], 0, function () { 4837 return this.millisecond() * 1000; 4838 }); 4839 addFormatToken(0, ['SSSSSSS', 7], 0, function () { 4840 return this.millisecond() * 10000; 4841 }); 4842 addFormatToken(0, ['SSSSSSSS', 8], 0, function () { 4843 return this.millisecond() * 100000; 4844 }); 4845 addFormatToken(0, ['SSSSSSSSS', 9], 0, function () { 4846 return this.millisecond() * 1000000; 4847 }); 4848 4849 // ALIASES 4850 4851 addUnitAlias('millisecond', 'ms'); 4852 4853 // PRIORITY 4854 4855 addUnitPriority('millisecond', 16); 4856 4857 // PARSING 4858 4859 addRegexToken('S', match1to3, match1); 4860 addRegexToken('SS', match1to3, match2); 4861 addRegexToken('SSS', match1to3, match3); 4862 4863 var token, getSetMillisecond; 4864 for (token = 'SSSS'; token.length <= 9; token += 'S') { 4865 addRegexToken(token, matchUnsigned); 4866 } 4867 4868 function parseMs(input, array) { 4869 array[MILLISECOND] = toInt(('0.' + input) * 1000); 4870 } 4871 4872 for (token = 'S'; token.length <= 9; token += 'S') { 4873 addParseToken(token, parseMs); 4874 } 4875 4876 getSetMillisecond = makeGetSet('Milliseconds', false); 4877 4878 // FORMATTING 4879 4880 addFormatToken('z', 0, 0, 'zoneAbbr'); 4881 addFormatToken('zz', 0, 0, 'zoneName'); 4882 4883 // MOMENTS 4884 4885 function getZoneAbbr() { 4886 return this._isUTC ? 'UTC' : ''; 4887 } 4888 4889 function getZoneName() { 4890 return this._isUTC ? 'Coordinated Universal Time' : ''; 4891 } 4892 4893 var proto = Moment.prototype; 4894 4895 proto.add = add; 4896 proto.calendar = calendar$1; 4897 proto.clone = clone; 4898 proto.diff = diff; 4899 proto.endOf = endOf; 4900 proto.format = format; 4901 proto.from = from; 4902 proto.fromNow = fromNow; 4903 proto.to = to; 4904 proto.toNow = toNow; 4905 proto.get = stringGet; 4906 proto.invalidAt = invalidAt; 4907 proto.isAfter = isAfter; 4908 proto.isBefore = isBefore; 4909 proto.isBetween = isBetween; 4910 proto.isSame = isSame; 4911 proto.isSameOrAfter = isSameOrAfter; 4912 proto.isSameOrBefore = isSameOrBefore; 4913 proto.isValid = isValid$2; 4914 proto.lang = lang; 4915 proto.locale = locale; 4916 proto.localeData = localeData; 4917 proto.max = prototypeMax; 4918 proto.min = prototypeMin; 4919 proto.parsingFlags = parsingFlags; 4920 proto.set = stringSet; 4921 proto.startOf = startOf; 4922 proto.subtract = subtract; 4923 proto.toArray = toArray; 4924 proto.toObject = toObject; 4925 proto.toDate = toDate; 4926 proto.toISOString = toISOString; 4927 proto.inspect = inspect; 4928 if (typeof Symbol !== 'undefined' && Symbol.for != null) { 4929 proto[Symbol.for('nodejs.util.inspect.custom')] = function () { 4930 return 'Moment<' + this.format() + '>'; 4931 }; 4932 } 4933 proto.toJSON = toJSON; 4934 proto.toString = toString; 4935 proto.unix = unix; 4936 proto.valueOf = valueOf; 4937 proto.creationData = creationData; 4938 proto.eraName = getEraName; 4939 proto.eraNarrow = getEraNarrow; 4940 proto.eraAbbr = getEraAbbr; 4941 proto.eraYear = getEraYear; 4942 proto.year = getSetYear; 4943 proto.isLeapYear = getIsLeapYear; 4944 proto.weekYear = getSetWeekYear; 4945 proto.isoWeekYear = getSetISOWeekYear; 4946 proto.quarter = proto.quarters = getSetQuarter; 4947 proto.month = getSetMonth; 4948 proto.daysInMonth = getDaysInMonth; 4949 proto.week = proto.weeks = getSetWeek; 4950 proto.isoWeek = proto.isoWeeks = getSetISOWeek; 4951 proto.weeksInYear = getWeeksInYear; 4952 proto.weeksInWeekYear = getWeeksInWeekYear; 4953 proto.isoWeeksInYear = getISOWeeksInYear; 4954 proto.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear; 4955 proto.date = getSetDayOfMonth; 4956 proto.day = proto.days = getSetDayOfWeek; 4957 proto.weekday = getSetLocaleDayOfWeek; 4958 proto.isoWeekday = getSetISODayOfWeek; 4959 proto.dayOfYear = getSetDayOfYear; 4960 proto.hour = proto.hours = getSetHour; 4961 proto.minute = proto.minutes = getSetMinute; 4962 proto.second = proto.seconds = getSetSecond; 4963 proto.millisecond = proto.milliseconds = getSetMillisecond; 4964 proto.utcOffset = getSetOffset; 4965 proto.utc = setOffsetToUTC; 4966 proto.local = setOffsetToLocal; 4967 proto.parseZone = setOffsetToParsedOffset; 4968 proto.hasAlignedHourOffset = hasAlignedHourOffset; 4969 proto.isDST = isDaylightSavingTime; 4970 proto.isLocal = isLocal; 4971 proto.isUtcOffset = isUtcOffset; 4972 proto.isUtc = isUtc; 4973 proto.isUTC = isUtc; 4974 proto.zoneAbbr = getZoneAbbr; 4975 proto.zoneName = getZoneName; 4976 proto.dates = deprecate( 4977 'dates accessor is deprecated. Use date instead.', 4978 getSetDayOfMonth 4979 ); 4980 proto.months = deprecate( 4981 'months accessor is deprecated. Use month instead', 4982 getSetMonth 4983 ); 4984 proto.years = deprecate( 4985 'years accessor is deprecated. Use year instead', 4986 getSetYear 4987 ); 4988 proto.zone = deprecate( 4989 'moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', 4990 getSetZone 4991 ); 4992 proto.isDSTShifted = deprecate( 4993 'isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', 4994 isDaylightSavingTimeShifted 4995 ); 4996 4997 function createUnix(input) { 4998 return createLocal(input * 1000); 4999 } 5000 5001 function createInZone() { 5002 return createLocal.apply(null, arguments).parseZone(); 5003 } 5004 5005 function preParsePostFormat(string) { 5006 return string; 5007 } 5008 5009 var proto$1 = Locale.prototype; 5010 5011 proto$1.calendar = calendar; 5012 proto$1.longDateFormat = longDateFormat; 5013 proto$1.invalidDate = invalidDate; 5014 proto$1.ordinal = ordinal; 5015 proto$1.preparse = preParsePostFormat; 5016 proto$1.postformat = preParsePostFormat; 5017 proto$1.relativeTime = relativeTime; 5018 proto$1.pastFuture = pastFuture; 5019 proto$1.set = set; 5020 proto$1.eras = localeEras; 5021 proto$1.erasParse = localeErasParse; 5022 proto$1.erasConvertYear = localeErasConvertYear; 5023 proto$1.erasAbbrRegex = erasAbbrRegex; 5024 proto$1.erasNameRegex = erasNameRegex; 5025 proto$1.erasNarrowRegex = erasNarrowRegex; 5026 5027 proto$1.months = localeMonths; 5028 proto$1.monthsShort = localeMonthsShort; 5029 proto$1.monthsParse = localeMonthsParse; 5030 proto$1.monthsRegex = monthsRegex; 5031 proto$1.monthsShortRegex = monthsShortRegex; 5032 proto$1.week = localeWeek; 5033 proto$1.firstDayOfYear = localeFirstDayOfYear; 5034 proto$1.firstDayOfWeek = localeFirstDayOfWeek; 5035 5036 proto$1.weekdays = localeWeekdays; 5037 proto$1.weekdaysMin = localeWeekdaysMin; 5038 proto$1.weekdaysShort = localeWeekdaysShort; 5039 proto$1.weekdaysParse = localeWeekdaysParse; 5040 5041 proto$1.weekdaysRegex = weekdaysRegex; 5042 proto$1.weekdaysShortRegex = weekdaysShortRegex; 5043 proto$1.weekdaysMinRegex = weekdaysMinRegex; 5044 5045 proto$1.isPM = localeIsPM; 5046 proto$1.meridiem = localeMeridiem; 5047 5048 function get$1(format, index, field, setter) { 5049 var locale = getLocale(), 5050 utc = createUTC().set(setter, index); 5051 return locale[field](utc, format); 5052 } 5053 5054 function listMonthsImpl(format, index, field) { 5055 if (isNumber(format)) { 5056 index = format; 5057 format = undefined; 5058 } 5059 5060 format = format || ''; 5061 5062 if (index != null) { 5063 return get$1(format, index, field, 'month'); 5064 } 5065 5066 var i, 5067 out = []; 5068 for (i = 0; i < 12; i++) { 5069 out[i] = get$1(format, i, field, 'month'); 5070 } 5071 return out; 5072 } 5073 5074 // () 5075 // (5) 5076 // (fmt, 5) 5077 // (fmt) 5078 // (true) 5079 // (true, 5) 5080 // (true, fmt, 5) 5081 // (true, fmt) 5082 function listWeekdaysImpl(localeSorted, format, index, field) { 5083 if (typeof localeSorted === 'boolean') { 5084 if (isNumber(format)) { 5085 index = format; 5086 format = undefined; 5087 } 5088 5089 format = format || ''; 5090 } else { 5091 format = localeSorted; 5092 index = format; 5093 localeSorted = false; 5094 5095 if (isNumber(format)) { 5096 index = format; 5097 format = undefined; 5098 } 5099 5100 format = format || ''; 5101 } 5102 5103 var locale = getLocale(), 5104 shift = localeSorted ? locale._week.dow : 0, 5105 i, 5106 out = []; 5107 5108 if (index != null) { 5109 return get$1(format, (index + shift) % 7, field, 'day'); 5110 } 5111 5112 for (i = 0; i < 7; i++) { 5113 out[i] = get$1(format, (i + shift) % 7, field, 'day'); 5114 } 5115 return out; 5116 } 5117 5118 function listMonths(format, index) { 5119 return listMonthsImpl(format, index, 'months'); 5120 } 5121 5122 function listMonthsShort(format, index) { 5123 return listMonthsImpl(format, index, 'monthsShort'); 5124 } 5125 5126 function listWeekdays(localeSorted, format, index) { 5127 return listWeekdaysImpl(localeSorted, format, index, 'weekdays'); 5128 } 5129 5130 function listWeekdaysShort(localeSorted, format, index) { 5131 return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort'); 5132 } 5133 5134 function listWeekdaysMin(localeSorted, format, index) { 5135 return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin'); 5136 } 5137 5138 getSetGlobalLocale('en', { 5139 eras: [ 5140 { 5141 since: '0001-01-01', 5142 until: +Infinity, 5143 offset: 1, 5144 name: 'Anno Domini', 5145 narrow: 'AD', 5146 abbr: 'AD', 5147 }, 5148 { 5149 since: '0000-12-31', 5150 until: -Infinity, 5151 offset: 1, 5152 name: 'Before Christ', 5153 narrow: 'BC', 5154 abbr: 'BC', 5155 }, 5156 ], 5157 dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/, 5158 ordinal: function (number) { 5159 var b = number % 10, 5160 output = 5161 toInt((number % 100) / 10) === 1 5162 ? 'th' 5163 : b === 1 5164 ? 'st' 5165 : b === 2 5166 ? 'nd' 5167 : b === 3 5168 ? 'rd' 5169 : 'th'; 5170 return number + output; 5171 }, 5172 }); 5173 5174 // Side effect imports 5175 5176 hooks.lang = deprecate( 5177 'moment.lang is deprecated. Use moment.locale instead.', 5178 getSetGlobalLocale 5179 ); 5180 hooks.langData = deprecate( 5181 'moment.langData is deprecated. Use moment.localeData instead.', 5182 getLocale 5183 ); 5184 5185 var mathAbs = Math.abs; 5186 5187 function abs() { 5188 var data = this._data; 5189 5190 this._milliseconds = mathAbs(this._milliseconds); 5191 this._days = mathAbs(this._days); 5192 this._months = mathAbs(this._months); 5193 5194 data.milliseconds = mathAbs(data.milliseconds); 5195 data.seconds = mathAbs(data.seconds); 5196 data.minutes = mathAbs(data.minutes); 5197 data.hours = mathAbs(data.hours); 5198 data.months = mathAbs(data.months); 5199 data.years = mathAbs(data.years); 5200 5201 return this; 5202 } 5203 5204 function addSubtract$1(duration, input, value, direction) { 5205 var other = createDuration(input, value); 5206 5207 duration._milliseconds += direction * other._milliseconds; 5208 duration._days += direction * other._days; 5209 duration._months += direction * other._months; 5210 5211 return duration._bubble(); 5212 } 5213 5214 // supports only 2.0-style add(1, 's') or add(duration) 5215 function add$1(input, value) { 5216 return addSubtract$1(this, input, value, 1); 5217 } 5218 5219 // supports only 2.0-style subtract(1, 's') or subtract(duration) 5220 function subtract$1(input, value) { 5221 return addSubtract$1(this, input, value, -1); 5222 } 5223 5224 function absCeil(number) { 5225 if (number < 0) { 5226 return Math.floor(number); 5227 } else { 5228 return Math.ceil(number); 5229 } 5230 } 5231 5232 function bubble() { 5233 var milliseconds = this._milliseconds, 5234 days = this._days, 5235 months = this._months, 5236 data = this._data, 5237 seconds, 5238 minutes, 5239 hours, 5240 years, 5241 monthsFromDays; 5242 5243 // if we have a mix of positive and negative values, bubble down first 5244 // check: https://github.com/moment/moment/issues/2166 5245 if ( 5246 !( 5247 (milliseconds >= 0 && days >= 0 && months >= 0) || 5248 (milliseconds <= 0 && days <= 0 && months <= 0) 5249 ) 5250 ) { 5251 milliseconds += absCeil(monthsToDays(months) + days) * 864e5; 5252 days = 0; 5253 months = 0; 5254 } 5255 5256 // The following code bubbles up values, see the tests for 5257 // examples of what that means. 5258 data.milliseconds = milliseconds % 1000; 5259 5260 seconds = absFloor(milliseconds / 1000); 5261 data.seconds = seconds % 60; 5262 5263 minutes = absFloor(seconds / 60); 5264 data.minutes = minutes % 60; 5265 5266 hours = absFloor(minutes / 60); 5267 data.hours = hours % 24; 5268 5269 days += absFloor(hours / 24); 5270 5271 // convert days to months 5272 monthsFromDays = absFloor(daysToMonths(days)); 5273 months += monthsFromDays; 5274 days -= absCeil(monthsToDays(monthsFromDays)); 5275 5276 // 12 months -> 1 year 5277 years = absFloor(months / 12); 5278 months %= 12; 5279 5280 data.days = days; 5281 data.months = months; 5282 data.years = years; 5283 5284 return this; 5285 } 5286 5287 function daysToMonths(days) { 5288 // 400 years have 146097 days (taking into account leap year rules) 5289 // 400 years have 12 months === 4800 5290 return (days * 4800) / 146097; 5291 } 5292 5293 function monthsToDays(months) { 5294 // the reverse of daysToMonths 5295 return (months * 146097) / 4800; 5296 } 5297 5298 function as(units) { 5299 if (!this.isValid()) { 5300 return NaN; 5301 } 5302 var days, 5303 months, 5304 milliseconds = this._milliseconds; 5305 5306 units = normalizeUnits(units); 5307 5308 if (units === 'month' || units === 'quarter' || units === 'year') { 5309 days = this._days + milliseconds / 864e5; 5310 months = this._months + daysToMonths(days); 5311 switch (units) { 5312 case 'month': 5313 return months; 5314 case 'quarter': 5315 return months / 3; 5316 case 'year': 5317 return months / 12; 5318 } 5319 } else { 5320 // handle milliseconds separately because of floating point math errors (issue #1867) 5321 days = this._days + Math.round(monthsToDays(this._months)); 5322 switch (units) { 5323 case 'week': 5324 return days / 7 + milliseconds / 6048e5; 5325 case 'day': 5326 return days + milliseconds / 864e5; 5327 case 'hour': 5328 return days * 24 + milliseconds / 36e5; 5329 case 'minute': 5330 return days * 1440 + milliseconds / 6e4; 5331 case 'second': 5332 return days * 86400 + milliseconds / 1000; 5333 // Math.floor prevents floating point math errors here 5334 case 'millisecond': 5335 return Math.floor(days * 864e5) + milliseconds; 5336 default: 5337 throw new Error('Unknown unit ' + units); 5338 } 5339 } 5340 } 5341 5342 // TODO: Use this.as('ms')? 5343 function valueOf$1() { 5344 if (!this.isValid()) { 5345 return NaN; 5346 } 5347 return ( 5348 this._milliseconds + 5349 this._days * 864e5 + 5350 (this._months % 12) * 2592e6 + 5351 toInt(this._months / 12) * 31536e6 5352 ); 5353 } 5354 5355 function makeAs(alias) { 5356 return function () { 5357 return this.as(alias); 5358 }; 5359 } 5360 5361 var asMilliseconds = makeAs('ms'), 5362 asSeconds = makeAs('s'), 5363 asMinutes = makeAs('m'), 5364 asHours = makeAs('h'), 5365 asDays = makeAs('d'), 5366 asWeeks = makeAs('w'), 5367 asMonths = makeAs('M'), 5368 asQuarters = makeAs('Q'), 5369 asYears = makeAs('y'); 5370 5371 function clone$1() { 5372 return createDuration(this); 5373 } 5374 5375 function get$2(units) { 5376 units = normalizeUnits(units); 5377 return this.isValid() ? this[units + 's']() : NaN; 5378 } 5379 5380 function makeGetter(name) { 5381 return function () { 5382 return this.isValid() ? this._data[name] : NaN; 5383 }; 5384 } 5385 5386 var milliseconds = makeGetter('milliseconds'), 5387 seconds = makeGetter('seconds'), 5388 minutes = makeGetter('minutes'), 5389 hours = makeGetter('hours'), 5390 days = makeGetter('days'), 5391 months = makeGetter('months'), 5392 years = makeGetter('years'); 5393 5394 function weeks() { 5395 return absFloor(this.days() / 7); 5396 } 5397 5398 var round = Math.round, 5399 thresholds = { 5400 ss: 44, // a few seconds to seconds 5401 s: 45, // seconds to minute 5402 m: 45, // minutes to hour 5403 h: 22, // hours to day 5404 d: 26, // days to month/week 5405 w: null, // weeks to month 5406 M: 11, // months to year 5407 }; 5408 5409 // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize 5410 function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) { 5411 return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture); 5412 } 5413 5414 function relativeTime$1(posNegDuration, withoutSuffix, thresholds, locale) { 5415 var duration = createDuration(posNegDuration).abs(), 5416 seconds = round(duration.as('s')), 5417 minutes = round(duration.as('m')), 5418 hours = round(duration.as('h')), 5419 days = round(duration.as('d')), 5420 months = round(duration.as('M')), 5421 weeks = round(duration.as('w')), 5422 years = round(duration.as('y')), 5423 a = 5424 (seconds <= thresholds.ss && ['s', seconds]) || 5425 (seconds < thresholds.s && ['ss', seconds]) || 5426 (minutes <= 1 && ['m']) || 5427 (minutes < thresholds.m && ['mm', minutes]) || 5428 (hours <= 1 && ['h']) || 5429 (hours < thresholds.h && ['hh', hours]) || 5430 (days <= 1 && ['d']) || 5431 (days < thresholds.d && ['dd', days]); 5432 5433 if (thresholds.w != null) { 5434 a = 5435 a || 5436 (weeks <= 1 && ['w']) || 5437 (weeks < thresholds.w && ['ww', weeks]); 5438 } 5439 a = a || 5440 (months <= 1 && ['M']) || 5441 (months < thresholds.M && ['MM', months]) || 5442 (years <= 1 && ['y']) || ['yy', years]; 5443 5444 a[2] = withoutSuffix; 5445 a[3] = +posNegDuration > 0; 5446 a[4] = locale; 5447 return substituteTimeAgo.apply(null, a); 5448 } 5449 5450 // This function allows you to set the rounding function for relative time strings 5451 function getSetRelativeTimeRounding(roundingFunction) { 5452 if (roundingFunction === undefined) { 5453 return round; 5454 } 5455 if (typeof roundingFunction === 'function') { 5456 round = roundingFunction; 5457 return true; 5458 } 5459 return false; 5460 } 5461 5462 // This function allows you to set a threshold for relative time strings 5463 function getSetRelativeTimeThreshold(threshold, limit) { 5464 if (thresholds[threshold] === undefined) { 5465 return false; 5466 } 5467 if (limit === undefined) { 5468 return thresholds[threshold]; 5469 } 5470 thresholds[threshold] = limit; 5471 if (threshold === 's') { 5472 thresholds.ss = limit - 1; 5473 } 5474 return true; 5475 } 5476 5477 function humanize(argWithSuffix, argThresholds) { 5478 if (!this.isValid()) { 5479 return this.localeData().invalidDate(); 5480 } 5481 5482 var withSuffix = false, 5483 th = thresholds, 5484 locale, 5485 output; 5486 5487 if (typeof argWithSuffix === 'object') { 5488 argThresholds = argWithSuffix; 5489 argWithSuffix = false; 5490 } 5491 if (typeof argWithSuffix === 'boolean') { 5492 withSuffix = argWithSuffix; 5493 } 5494 if (typeof argThresholds === 'object') { 5495 th = Object.assign({}, thresholds, argThresholds); 5496 if (argThresholds.s != null && argThresholds.ss == null) { 5497 th.ss = argThresholds.s - 1; 5498 } 5499 } 5500 5501 locale = this.localeData(); 5502 output = relativeTime$1(this, !withSuffix, th, locale); 5503 5504 if (withSuffix) { 5505 output = locale.pastFuture(+this, output); 5506 } 5507 5508 return locale.postformat(output); 5509 } 5510 5511 var abs$1 = Math.abs; 5512 5513 function sign(x) { 5514 return (x > 0) - (x < 0) || +x; 5515 } 5516 5517 function toISOString$1() { 5518 // for ISO strings we do not use the normal bubbling rules: 5519 // * milliseconds bubble up until they become hours 5520 // * days do not bubble at all 5521 // * months bubble up until they become years 5522 // This is because there is no context-free conversion between hours and days 5523 // (think of clock changes) 5524 // and also not between days and months (28-31 days per month) 5525 if (!this.isValid()) { 5526 return this.localeData().invalidDate(); 5527 } 5528 5529 var seconds = abs$1(this._milliseconds) / 1000, 5530 days = abs$1(this._days), 5531 months = abs$1(this._months), 5532 minutes, 5533 hours, 5534 years, 5535 s, 5536 total = this.asSeconds(), 5537 totalSign, 5538 ymSign, 5539 daysSign, 5540 hmsSign; 5541 5542 if (!total) { 5543 // this is the same as C#'s (Noda) and python (isodate)... 5544 // but not other JS (goog.date) 5545 return 'P0D'; 5546 } 5547 5548 // 3600 seconds -> 60 minutes -> 1 hour 5549 minutes = absFloor(seconds / 60); 5550 hours = absFloor(minutes / 60); 5551 seconds %= 60; 5552 minutes %= 60; 5553 5554 // 12 months -> 1 year 5555 years = absFloor(months / 12); 5556 months %= 12; 5557 5558 // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js 5559 s = seconds ? seconds.toFixed(3).replace(/\.?0+$/, '') : ''; 5560 5561 totalSign = total < 0 ? '-' : ''; 5562 ymSign = sign(this._months) !== sign(total) ? '-' : ''; 5563 daysSign = sign(this._days) !== sign(total) ? '-' : ''; 5564 hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : ''; 5565 5566 return ( 5567 totalSign + 5568 'P' + 5569 (years ? ymSign + years + 'Y' : '') + 5570 (months ? ymSign + months + 'M' : '') + 5571 (days ? daysSign + days + 'D' : '') + 5572 (hours || minutes || seconds ? 'T' : '') + 5573 (hours ? hmsSign + hours + 'H' : '') + 5574 (minutes ? hmsSign + minutes + 'M' : '') + 5575 (seconds ? hmsSign + s + 'S' : '') 5576 ); 5577 } 5578 5579 var proto$2 = Duration.prototype; 5580 5581 proto$2.isValid = isValid$1; 5582 proto$2.abs = abs; 5583 proto$2.add = add$1; 5584 proto$2.subtract = subtract$1; 5585 proto$2.as = as; 5586 proto$2.asMilliseconds = asMilliseconds; 5587 proto$2.asSeconds = asSeconds; 5588 proto$2.asMinutes = asMinutes; 5589 proto$2.asHours = asHours; 5590 proto$2.asDays = asDays; 5591 proto$2.asWeeks = asWeeks; 5592 proto$2.asMonths = asMonths; 5593 proto$2.asQuarters = asQuarters; 5594 proto$2.asYears = asYears; 5595 proto$2.valueOf = valueOf$1; 5596 proto$2._bubble = bubble; 5597 proto$2.clone = clone$1; 5598 proto$2.get = get$2; 5599 proto$2.milliseconds = milliseconds; 5600 proto$2.seconds = seconds; 5601 proto$2.minutes = minutes; 5602 proto$2.hours = hours; 5603 proto$2.days = days; 5604 proto$2.weeks = weeks; 5605 proto$2.months = months; 5606 proto$2.years = years; 5607 proto$2.humanize = humanize; 5608 proto$2.toISOString = toISOString$1; 5609 proto$2.toString = toISOString$1; 5610 proto$2.toJSON = toISOString$1; 5611 proto$2.locale = locale; 5612 proto$2.localeData = localeData; 5613 5614 proto$2.toIsoString = deprecate( 5615 'toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', 5616 toISOString$1 5617 ); 5618 proto$2.lang = lang; 5619 5620 // FORMATTING 5621 5622 addFormatToken('X', 0, 0, 'unix'); 5623 addFormatToken('x', 0, 0, 'valueOf'); 5624 5625 // PARSING 5626 5627 addRegexToken('x', matchSigned); 5628 addRegexToken('X', matchTimestamp); 5629 addParseToken('X', function (input, array, config) { 5630 config._d = new Date(parseFloat(input) * 1000); 5631 }); 5632 addParseToken('x', function (input, array, config) { 5633 config._d = new Date(toInt(input)); 5634 }); 5635 5636 //! moment.js 5637 5638 hooks.version = '2.2
56389.4'; 5639 5640 setHookCallback(createLocal); 5641 5642 hooks.fn = proto; 5643 hooks.min = min; 5644 hooks.max = max; 5645 hooks.now = now; 5646 hooks.utc = createUTC; 5647 hooks.unix = createUnix; 5648 hooks.months = listMonths; 5649 hooks.isDate = isDate; 5650 hooks.locale = getSetGlobalLocale; 5651 hooks.invalid = createInvalid; 5652 hooks.duration = createDuration; 5653 hooks.isMoment = isMoment; 5654 hooks.weekdays = listWeekdays; 5655 hooks.parseZone = createInZone; 5656 hooks.localeData = getLocale; 5657 hooks.isDuration = isDuration; 5658 hooks.monthsShort = listMonthsShort; 5659 hooks.weekdaysMin = listWeekdaysMin; 5660 hooks.defineLocale = defineLocale; 5661 hooks.updateLocale = updateLocale; 5662 hooks.locales = listLocales; 5663 hooks.weekdaysShort = listWeekdaysShort; 5664 hooks.normalizeUnits = normalizeUnits; 5665 hooks.relativeTimeRounding = getSetRelativeTimeRounding; 5666 hooks.relativeTimeThreshold = getSetRelativeTimeThreshold; 5667 hooks.calendarFormat = getCalendarFormat; 5668 hooks.prototype = proto; 5669 5670 // currently HTML5 input type only supports 24-hour formats 5671 hooks.HTML5_FMT = { 5672 DATETIME_LOCAL: 'YYYY-MM-DDTHH:mm', // <input type="datetime-local" /> 5673 DATETIME_LOCAL_SECONDS: 'YYYY-MM-DDTHH:mm:ss', // <input type="datetime-local" step="1" /> 5674 DATETIME_LOCAL_MS: 'YYYY-MM-DDTHH:mm:ss.SSS', // <input type="datetime-local" step="0.001" /> 5675 DATE: 'YYYY-MM-DD', // <input type="date" /> 5676 TIME: 'HH:mm', // <input type="time" /> 5677 TIME_SECONDS: 'HH:mm:ss', // <input type="time" step="1" /> 5678 TIME_MS: 'HH:mm:ss.SSS', // <input type="time" step="0.001" /> 5679 WEEK: 'GGGG-[W]WW', // <input type="week" /> 5680 MONTH: 'YYYY-MM', // <input type="month" /> 5681 }; 5682 5683 return hooks; 5684 5685}))); 5686 5687/* 5688 * ADOBE CONFIDENTIAL 5689 * 5690 * Copyright 2017 Adobe Systems Incorporated 5691 * All Rights Reserved. 5692 *
5693 * NOTICE: All information contained herein is, and remains 5694 * the property of Adobe Systems Incorporated and its suppliers, 5695 * if any. The intellectual and technical concepts contained 5696 * herein are proprietary to Adobe Systems Incorporated and its 5697 * suppliers and may be covered by U.S. and Foreign Patents, 5698 * patents in process, and are protected by trade secret or copyright law. 5699 * Dissemination of this information or reproduction of this material 5700 * is strictly forbidden unless prior written permission is obtained 5701 * from Adobe Systems Incorporated. 5702 * 5703 */ 5704(function(root, factory) { 5705 "use strict"; 5706 5707 if (typeof module === "object" && module.exports) { 5708 module.exports = factory(require("moment")); 5709 } else { 5710 factory(root.moment); 5711 } 5712}(this, function(moment) { 5713 "use strict"; 5714 5715 function normalizeType(type) { 5716 switch (type) { 5717 case "date": 5718 case "time": 5719 case "datetime": 5720 return type; 5721 default: 5722 return "date"; 5723 } 5724 } 5725 5726 function normalizeFormat(format) { 5727 switch (format) { 5728 case "short": 5729 case "medium": 5730 case "long": 5731 case "full": 5732 return format; 5733 default: 5734 return "medium"; 5735 } 5736 } 5737 5738 moment.fn.formatWithPreset = function(type, format) { 5739 var localeData = this.localeData(); 5740 var actualFormat = localeData._presets[normalizeType(type)][normalizeFormat(format)]; 5741 5742 if (typeof actualFormat === "function") { 5743 actualFormat = actualFormat(this); 5744 } 5745 5746 return this.format(actualFormat); 5747 }; 5748 5749 return moment; 5750})); 5751 5752//! moment.js locale configuration 5753 5754;(function (global, factory) { 5755 typeof exports === 'object' && typeof module !== 'undefined' 5756 && typeof require === 'function' ? factory(require('../moment')) : 5757 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 5758 factory(global.moment) 5759}(this, (function (moment) { 'use strict'; 5760 5761 5762 function processRelativeTime$2(number, withoutSuffix, key, isFuture) { 5763 var format = { 5764 m: ['eine Minute', 'einer Minute'], 5765 h: ['eine Stunde', 'einer Stunde'], 5766 d: ['ein Tag', 'einem Tag'], 5767 dd: [number + ' Tage', number + ' Tagen'], 5768 w: ['eine Woche', 'einer Woche'], 5769 M: ['ein Monat', 'einem Monat'], 5770 MM: [number + ' Monate', number + ' Monaten'], 5771 y: ['ein Jahr', 'einem Jahr'], 5772 yy: [number + ' Jahre', number + ' Jahren'], 5773 }; 5774 return withoutSuffix ? format[key][0] : format[key][1]; 5775 } 5776 5777 var de = moment.defineLocale('de', { 5778 months : 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'), 5779 monthsShort : 'Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split('_'), 5780 monthsParseExact : true, 5781 weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'), 5782 weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'), 5783 weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'), 5784 weekdaysParseExact : true, 5785 longDateFormat : { 5786 LT: 'HH:mm', 5787 LTS: 'HH:mm:ss', 5788 L : 'DD.MM.YYYY', 5789 LL : 'D. MMMM YYYY', 5790 LLL : 'D. MMMM YYYY HH:mm', 5791 LLLL : 'dddd, D. MMMM YYYY HH:mm' 5792 }, 5793 calendar : { 5794 sameDay: '[heute um] LT [Uhr]', 5795 sameElse: 'L', 5796 nextDay: '[morgen um] LT [Uhr]', 5797 nextWeek: 'dddd [um] LT [Uhr]', 5798 lastDay: '[gestern um] LT [Uhr]', 5799 lastWeek: '[letzten] dddd [um] LT [Uhr]' 5800 }, 5801 relativeTime : { 5802 future: 'in %s', 5803 past: 'vor %s', 5804 s: 'ein paar Sekunden', 5805 ss: '%d Sekunden', 5806 m: processRelativeTime$2, 5807 mm: '%d Minuten', 5808 h: processRelativeTime$2, 5809 hh: '%d Stunden', 5810 d: processRelativeTime$2, 5811 dd: processRelativeTime$2, 5812 w: processRelativeTime$2, 5813 ww: '%d Wochen', 5814 M: processRelativeTime$2, 5815 MM: processRelativeTime$2, 5816 y: processRelativeTime$2, 5817 yy: processRelativeTime$2, 5818 }, 5819 dayOfMonthOrdinalParse: /\d{1,2}\./, 5820 ordinal : '%d.', 5821 week : { 5822 dow : 1, // Monday is the first day of the week. 5823 doy : 4 // The week that contains Jan 4th is the first week of the year. 5824 } 5825 }); 5826 5827 return de; 5828 5829}))); 5830 5831//! moment.js locale configuration 5832 5833;(function (global, factory) { 5834 typeof exports === 'object' && typeof module !== 'undefined' 5835 && typeof require === 'function' ? factory(require('../moment')) : 5836 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 5837 factory(global.moment) 5838}(this, (function (moment) { 'use strict'; 5839 5840 5841 var monthsShortDot$3 = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_'), 5842 monthsShort$4 = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_'); 5843 5844 var monthsParse$5 = [/^ene/i, /^feb/i, /^mar/i, /^abr/i, /^may/i, /^jun/i, /^jul/i, /^ago/i, /^sep/i, /^oct/i, /^nov/i, /^dic/i]; 5845 var monthsRegex$6 = /^(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; 5846 5847 var es = moment.defineLocale('es', { 5848 months: 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split( 5849 '_' 5850 ), 5851 monthsShort: function (m, format) { 5852 if (!m) { 5853 return monthsShortDot$3; 5854 } else if (/-MMM-/.test(format)) { 5855 return monthsShort$4[m.month()]; 5856 } else { 5857 return monthsShortDot$3[m.month()]; 5858 } 5859 }, 5860 monthsRegex: monthsRegex$6, 5861 monthsShortRegex: monthsRegex$6, 5862 monthsStrictRegex: 5863 /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i, 5864 monthsShortStrictRegex: 5865 /^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i, 5866 monthsParse: monthsParse$5, 5867 longMonthsParse: monthsParse$5, 5868 shortMonthsParse: monthsParse$5, 5869 weekdays: 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'), 5870 weekdaysShort: 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'), 5871 weekdaysMin: 'do_lu_ma_mi_ju_vi_sá'.split('_'), 5872 weekdaysParseExact: true, 5873 longDateFormat: { 5874 LT: 'H:mm', 5875 LTS: 'H:mm:ss', 5876 L: 'DD/MM/YYYY', 5877 LL: 'D [de] MMMM [de] YYYY', 5878 LLL: 'D [de] MMMM [de] YYYY H:mm', 5879 LLLL: 'dddd, D [de] MMMM [de] YYYY H:mm', 5880 }, 5881 calendar: { 5882 sameDay: function () { 5883 return '[hoy a la' + (this.hours() !== 1 ? 's' : '') + '] LT'; 5884 }, 5885 nextDay: function () { 5886 return '[mañana a la' + (this.hours() !== 1 ? 's' : '') + '] LT'; 5887 }, 5888 nextWeek: function () { 5889 return 'dddd [a la' + (this.hours() !== 1 ? 's' : '') + '] LT'; 5890 }, 5891 lastDay: function () { 5892 return '[ayer a la' + (this.hours() !== 1 ? 's' : '') + '] LT'; 5893 }, 5894 lastWeek: function () { 5895 return ( 5896 '[el] dddd [pasado a la' + 5897 (this.hours() !== 1 ? 's' : '') + 5898 '] LT' 5899 ); 5900 }, 5901 sameElse: 'L', 5902 }, 5903 relativeTime: { 5904 future: 'en %s', 5905 past: 'hace %s', 5906 s: 'unos segundos', 5907 ss: '%d segundos', 5908 m: 'un minuto', 5909 mm: '%d minutos', 5910 h: 'una hora', 5911 hh: '%d horas', 5912 d: 'un dÃa', 5913 dd: '%d dÃas', 5914 w: 'una semana', 5915 ww: '%d semanas', 5916 M: 'un mes', 5917 MM: '%d meses', 5918 y: 'un año', 5919 yy: '%d años', 5920 }, 5921 dayOfMonthOrdinalParse: /\d{1,2}º/, 5922 ordinal: '%dº', 5923 week: { 5924 dow: 1, // Monday is the first day of the week. 5925 doy: 4, // The week that contains Jan 4th is the first week of the year. 5926 }, 5927 invalidDate: 'Fecha inválida', 5928 }); 5929 return es; 5930}))); 5931 5932//! moment.js locale configuration 5933 5934;(function (global, factory) { 5935 typeof exports === 'object' && typeof module !== 'undefined' 5936 && typeof require === 'function' ? factory(require('../moment')) : 5937 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 5938 factory(global.moment) 5939}(this, (function (moment) { 'use strict'; 5940 5941 var monthsStrictRegex$1 = 5942 /^(janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)/i, 5943 monthsShortStrictRegex$1 = 5944 /(janv\.?|févr\.?|mars|avr\.?|mai|juin|juil\.?|août|sept\.?|oct\.?|nov\.?|déc\.?)/i,
vendor: 21,826 bytes, lines 5945-6602
5945 monthsRegex$7 = 5946 /(janv\.?|févr\.?|mars|avr\.?|mai|juin|juil\.?|août|sept\.?|oct\.?|nov\.?|déc\.?|janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)/i, 5947 monthsParse$6 = [ 5948 /^janv/i, 5949 /^févr/i, 5950 /^mars/i, 5951 /^avr/i, 5952 /^mai/i, 5953 /^juin/i, 5954 /^juil/i, 5955 /^août/i, 5956 /^sept/i, 5957 /^oct/i, 5958 /^nov/i, 5959 /^déc/i, 5960 ]; 5961 5962 var fr = moment.defineLocale('fr', { 5963 months: 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split( 5964 '_' 5965 ), 5966 monthsShort: 5967 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split( 5968 '_' 5969 ), 5970 monthsRegex: monthsRegex$7, 5971 monthsShortRegex: monthsRegex$7, 5972 monthsStrictRegex: monthsStrictRegex$1, 5973 monthsShortStrictRegex: monthsShortStrictRegex$1, 5974 monthsParse: monthsParse$6, 5975 longMonthsParse: monthsParse$6, 5976 shortMonthsParse: monthsParse$6, 5977 weekdays: 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'), 5978 weekdaysShort: 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'), 5979 weekdaysMin: 'di_lu_ma_me_je_ve_sa'.split('_'), 5980 weekdaysParseExact: true, 5981 longDateFormat: { 5982 LT: 'HH:mm', 5983 LTS: 'HH:mm:ss', 5984 L: 'DD/MM/YYYY', 5985 LL: 'D MMMM YYYY', 5986 LLL: 'D MMMM YYYY HH:mm', 5987 LLLL: 'dddd D MMMM YYYY HH:mm', 5988 }, 5989 calendar: { 5990 sameDay: '[Aujourdâhui à ] LT', 5991 nextDay: '[Demain à ] LT', 5992 nextWeek: 'dddd [à ] LT', 5993 lastDay: '[Hier à ] LT', 5994 lastWeek: 'dddd [dernier à ] LT', 5995 sameElse: 'L', 5996 }, 5997 relativeTime: { 5998 future: 'dans %s', 5999 past: 'il y a %s', 6000 s: 'quelques secondes', 6001 ss: '%d secondes', 6002 m: 'une minute', 6003 mm: '%d minutes', 6004 h: 'une heure', 6005 hh: '%d heures', 6006 d: 'un jour', 6007 dd: '%d jours', 6008 w: 'une semaine', 6009 ww: '%d semaines', 6010 M: 'un mois', 6011 MM: '%d mois', 6012 y: 'un an', 6013 yy: '%d ans', 6014 }, 6015 dayOfMonthOrdinalParse: /\d{1,2}(er|)/, 6016 ordinal: function (number, period) { 6017 switch (period) { 6018 // TODO: Return 'e' when day of month > 1. Move this case inside 6019 // block for masculine words below. 6020 // See https://github.com/moment/moment/issues/3375 6021 case 'D': 6022 return number + (number === 1 ? 'er' : ''); 6023 6024 // Words with masculine grammatical gender: mois, trimestre, jour 6025 default: 6026 case 'M': 6027 case 'Q': 6028 case 'DDD': 6029 case 'd': 6030 return number + (number === 1 ? 'er' : 'e'); 6031 6032 // Words with feminine grammatical gender: semaine 6033 case 'w': 6034 case 'W': 6035 return number + (number === 1 ? 're' : 'e'); 6036 } 6037 }, 6038 week: { 6039 dow: 1, // Monday is the first day of the week. 6040 doy: 4, // The week that contains Jan 4th is the first week of the year. 6041 }, 6042 }); 6043 6044 return fr; 6045 6046}))); 6047 6048//! moment.js locale configuration 6049 6050;(function (global, factory) { 6051 typeof exports === 'object' && typeof module !== 'undefined' 6052 && typeof require === 'function' ? factory(require('../moment')) : 6053 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 6054 factory(global.moment) 6055}(this, (function (moment) { 'use strict'; 6056 6057 6058 var it = moment.defineLocale('it', { 6059 months: 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split( 6060 '_' 6061 ), 6062 monthsShort: 'gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic'.split('_'), 6063 weekdays: 'domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato'.split( 6064 '_' 6065 ), 6066 weekdaysShort: 'dom_lun_mar_mer_gio_ven_sab'.split('_'), 6067 weekdaysMin: 'do_lu_ma_me_gi_ve_sa'.split('_'), 6068 longDateFormat: { 6069 LT: 'HH:mm', 6070 LTS: 'HH:mm:ss', 6071 L: 'DD/MM/YYYY', 6072 LL: 'D MMMM YYYY', 6073 LLL: 'D MMMM YYYY HH:mm', 6074 LLLL: 'dddd D MMMM YYYY HH:mm', 6075 }, 6076 calendar: { 6077 sameDay: function () { 6078 return ( 6079 '[Oggi a' + 6080 (this.hours() > 1 ? 'lle ' : this.hours() === 0 ? ' ' : "ll'") + 6081 ']LT' 6082 ); 6083 }, 6084 nextDay: function () { 6085 return ( 6086 '[Domani a' + 6087 (this.hours() > 1 ? 'lle ' : this.hours() === 0 ? ' ' : "ll'") + 6088 ']LT' 6089 ); 6090 }, 6091 nextWeek: function () { 6092 return ( 6093 'dddd [a' + 6094 (this.hours() > 1 ? 'lle ' : this.hours() === 0 ? ' ' : "ll'") + 6095 ']LT' 6096 ); 6097 }, 6098 lastDay: function () { 6099 return ( 6100 '[Ieri a' + 6101 (this.hours() > 1 ? 'lle ' : this.hours() === 0 ? ' ' : "ll'") + 6102 ']LT' 6103 ); 6104 }, 6105 lastWeek: function () { 6106 switch (this.day()) { 6107 case 0: 6108 return ( 6109 '[La scorsa] dddd [a' + 6110 (this.hours() > 1 6111 ? 'lle ' 6112 : this.hours() === 0 6113 ? ' ' 6114 : "ll'") + 6115 ']LT' 6116 ); 6117 default: 6118 return ( 6119 '[Lo scorso] dddd [a' + 6120 (this.hours() > 1 6121 ? 'lle ' 6122 : this.hours() === 0 6123 ? ' ' 6124 : "ll'") + 6125 ']LT' 6126 ); 6127 } 6128 }, 6129 sameElse: 'L', 6130 }, 6131 relativeTime: { 6132 future: 'tra %s', 6133 past: '%s fa', 6134 s: 'alcuni secondi', 6135 ss: '%d secondi', 6136 m: 'un minuto', 6137 mm: '%d minuti', 6138 h: "un'ora", 6139 hh: '%d ore', 6140 d: 'un giorno', 6141 dd: '%d giorni', 6142 w: 'una settimana', 6143 ww: '%d settimane', 6144 M: 'un mese', 6145 MM: '%d mesi', 6146 y: 'un anno', 6147 yy: '%d anni', 6148 }, 6149 dayOfMonthOrdinalParse: /\d{1,2}º/, 6150 ordinal: '%dº', 6151 week: { 6152 dow: 1, // Monday is the first day of the week. 6153 doy: 4, // The week that contains Jan 4th is the first week of the year. 6154 }, 6155 }); 6156 6157 return it; 6158 6159}))); 6160 6161//! moment.js locale configuration 6162 6163;(function (global, factory) { 6164 typeof exports === 'object' && typeof module !== 'undefined' 6165 && typeof require === 'function' ? factory(require('../moment')) : 6166 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 6167 factory(global.moment) 6168}(this, (function (moment) { 'use strict'; 6169 6170 6171 var ptBr = moment.defineLocale('pt-br', { 6172 months: 'janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro'.split( 6173 '_' 6174 ), 6175 monthsShort: 'jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez'.split('_'), 6176 weekdays: 6177 'domingo_segunda-feira_terça-feira_quarta-feira_quinta-feira_sexta-feira_sábado'.split( 6178 '_' 6179 ), 6180 weekdaysShort: 'dom_seg_ter_qua_qui_sex_sáb'.split('_'), 6181 weekdaysMin: 'do_2ª_3ª_4ª_5ª_6ª_sá'.split('_'), 6182 weekdaysParseExact: true, 6183 longDateFormat: { 6184 LT: 'HH:mm', 6185 LTS: 'HH:mm:ss', 6186 L: 'DD/MM/YYYY', 6187 LL: 'D [de] MMMM [de] YYYY', 6188 LLL: 'D [de] MMMM [de] YYYY [à s] HH:mm', 6189 LLLL: 'dddd, D [de] MMMM [de] YYYY [à s] HH:mm', 6190 }, 6191 calendar: { 6192 sameDay: '[Hoje à s] LT', 6193 nextDay: '[Amanhã à s] LT', 6194 nextWeek: 'dddd [à s] LT', 6195 lastDay: '[Ontem à s] LT', 6196 lastWeek: function () { 6197 return this.day() === 0 || this.day() === 6 6198 ? '[Ãltimo] dddd [à s] LT' // Saturday + Sunday 6199 : '[Ãltima] dddd [à s] LT'; // Monday - Friday 6200 }, 6201 sameElse: 'L', 6202 }, 6203 relativeTime: { 6204 future: 'em %s', 6205 past: 'há %s', 6206 s: 'poucos segundos', 6207 ss: '%d segundos', 6208 m: 'um minuto', 6209 mm: '%d minutos', 6210 h: 'uma hora', 6211 hh: '%d horas', 6212 d: 'um dia', 6213 dd: '%d dias', 6214 M: 'um mês', 6215 MM: '%d meses', 6216 y: 'um ano', 6217 yy: '%d anos', 6218 }, 6219 dayOfMonthOrdinalParse: /\d{1,2}º/, 6220 ordinal: '%dº', 6221 invalidDate: 'Data inválida', 6222 }); 6223 6224 return ptBr; 6225 6226}))); 6227 6228//! moment.js locale configuration 6229 6230;(function (global, factory) { 6231 typeof exports === 'object' && typeof module !== 'undefined' 6232 && typeof require === 'function' ? factory(require('../moment')) : 6233 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 6234 factory(global.moment) 6235}(this, (function (moment) { 'use strict'; 6236 6237 6238 var zhCn = moment.defineLocale('zh-cn', { 6239 months: 'ä¸æ_äºæ_ä¸æ_åæ_äºæ_å æ_ä¸æ_å «æ_ä¹æ_åæ_åä¸æ_åäºæ'.split( 6240 '_' 6241 ), 6242 monthsShort: '1æ_2æ_3æ_4æ_5æ_6æ_7æ_8æ_9æ_10æ_11æ_12æ'.split( 6243 '_' 6244 ), 6245 weekdays: 'æææ¥_ææä¸_ææäº_ææä¸_ææå_ææäº_ææå '.split('_'), 6246 weekdaysShort: 'å¨æ¥_å¨ä¸_å¨äº_å¨ä¸_å¨å_å¨äº_å¨å '.split('_'), 6247 weekdaysMin: 'æ¥_ä¸_äº_ä¸_å_äº_å '.split('_'), 6248 longDateFormat: { 6249 LT: 'HH:mm', 6250 LTS: 'HH:mm:ss', 6251 L: 'YYYY/MM/DD', 6252 LL: 'YYYYå¹´MæDæ¥', 6253 LLL: 'YYYYå¹´MæDæ¥Ahç¹mmå', 6254 LLLL: 'YYYYå¹´MæDæ¥ddddAhç¹mmå', 6255 l: 'YYYY/M/D', 6256 ll: 'YYYYå¹´MæDæ¥', 6257 lll: 'YYYYå¹´MæDæ¥ HH:mm', 6258 llll: 'YYYYå¹´MæDæ¥dddd HH:mm', 6259 }, 6260 meridiemParse: /åæ¨|æ©ä¸|ä¸å|ä¸å|ä¸å|æä¸/, 6261 meridiemHour: function (hour, meridiem) { 6262 if (hour === 12) { 6263 hour = 0; 6264 } 6265 if (meridiem === 'åæ¨' || meridiem === 'æ©ä¸' || meridiem === 'ä¸å') { 6266 return hour; 6267 } else if (meridiem === 'ä¸å' || meridiem === 'æä¸') { 6268 return hour + 12; 6269 } else { 6270 // 'ä¸å' 6271 return hour >= 11 ? hour : hour + 12; 6272 } 6273 }, 6274 meridiem: function (hour, minute, isLower) { 6275 var hm = hour * 100 + minute; 6276 if (hm < 600) { 6277 return 'åæ¨'; 6278 } else if (hm < 900) { 6279 return 'æ©ä¸'; 6280 } else if (hm < 1130) { 6281 return 'ä¸å'; 6282 } else if (hm < 1230) { 6283 return 'ä¸å'; 6284 } else if (hm < 1800) { 6285 return 'ä¸å'; 6286 } else { 6287 return 'æä¸'; 6288 } 6289 }, 6290 calendar: { 6291 sameDay: '[ä»å¤©]LT', 6292 nextDay: '[æ天]LT', 6293 nextWeek: function (now) { 6294 if (now.week() !== this.week()) { 6295 return '[ä¸]dddLT'; 6296 } else { 6297 return '[æ¬]dddLT'; 6298 } 6299 }, 6300 lastDay: '[æ¨å¤©]LT', 6301 lastWeek: function (now) { 6302 if (this.week() !== now.week()) { 6303 return '[ä¸]dddLT'; 6304 } else { 6305 return '[æ¬]dddLT'; 6306 } 6307 }, 6308 sameElse: 'L', 6309 }, 6310 dayOfMonthOrdinalParse: /\d{1,2}(æ¥|æ|å¨)/, 6311 ordinal: function (number, period) { 6312 switch (period) { 6313 case 'd': 6314 case 'D': 6315 case 'DDD': 6316 return number + 'æ¥'; 6317 case 'M': 6318 return number + 'æ'; 6319 case 'w': 6320 case 'W': 6321 return number + 'å¨'; 6322 default: 6323 return number; 6324 } 6325 }, 6326 relativeTime: { 6327 future: '%så', 6328 past: '%så', 6329 s: 'å ç§', 6330 ss: '%d ç§', 6331 m: '1 åé', 6332 mm: '%d åé', 6333 h: '1 å°æ¶', 6334 hh: '%d å°æ¶', 6335 d: '1 天', 6336 dd: '%d 天', 6337 w: '1 å¨', 6338 ww: '%d å¨', 6339 M: '1 个æ', 6340 MM: '%d 个æ', 6341 y: '1 å¹´', 6342 yy: '%d å¹´', 6343 }, 6344 week: { 6345 // GB/T 7408-1994ãæ°æ®å å交æ¢æ ¼å¼Â·ä¿¡æ¯äº¤æ¢Â·æ¥æåæ¶é´è¡¨ç¤ºæ³ãä¸ISO 8601:1988çæ 6346 dow: 1, // Monday is the first day of the week. 6347 doy: 4, // The week that contains Jan 4th is the first week of the year. 6348 }, 6349 }); 6350 6351 return zhCn; 6352 6353}))); 6354 6355//! moment.js locale configuration 6356 6357;(function (global, factory) { 6358 typeof exports === 'object' && typeof module !== 'undefined' 6359 && typeof require === 'function' ? factory(require('../moment')) : 6360 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 6361 factory(global.moment) 6362}(this, (function (moment) { 'use strict'; 6363 6364 6365 var zhTw = moment.defineLocale('zh-tw', { 6366 months: 'ä¸æ_äºæ_ä¸æ_åæ_äºæ_å æ_ä¸æ_å «æ_ä¹æ_åæ_åä¸æ_åäºæ'.split( 6367 '_' 6368 ), 6369 monthsShort: '1æ_2æ_3æ_4æ_5æ_6æ_7æ_8æ_9æ_10æ_11æ_12æ'.split( 6370 '_' 6371 ), 6372 weekdays: 'æææ¥_ææä¸_ææäº_ææä¸_ææå_ææäº_ææå '.split('_'), 6373 weekdaysShort: 'é±æ¥_é±ä¸_é±äº_é±ä¸_é±å_é±äº_é±å '.split('_'), 6374 weekdaysMin: 'æ¥_ä¸_äº_ä¸_å_äº_å '.split('_'), 6375 longDateFormat: { 6376 LT: 'HH:mm', 6377 LTS: 'HH:mm:ss', 6378 L: 'YYYY/MM/DD', 6379 LL: 'YYYYå¹´MæDæ¥', 6380 LLL: 'YYYYå¹´MæDæ¥ HH:mm', 6381 LLLL: 'YYYYå¹´MæDæ¥dddd HH:mm', 6382 l: 'YYYY/M/D', 6383 ll: 'YYYYå¹´MæDæ¥', 6384 lll: 'YYYYå¹´MæDæ¥ HH:mm', 6385 llll: 'YYYYå¹´MæDæ¥dddd HH:mm', 6386 }, 6387 meridiemParse: /åæ¨|æ©ä¸|ä¸å|ä¸å|ä¸å|æä¸/, 6388 meridiemHour: function (hour, meridiem) { 6389 if (hour === 12) { 6390 hour = 0; 6391 } 6392 if (meridiem === 'åæ¨' || meridiem === 'æ©ä¸' || meridiem === 'ä¸å') { 6393 return hour; 6394 } else if (meridiem === 'ä¸å') { 6395 return hour >= 11 ? hour : hour + 12; 6396 } else if (meridiem === 'ä¸å' || meridiem === 'æä¸') { 6397 return hour + 12; 6398 } 6399 }, 6400 meridiem: function (hour, minute, isLower) { 6401 var hm = hour * 100 + minute; 6402 if (hm < 600) { 6403 return 'åæ¨'; 6404 } else if (hm < 900) { 6405 return 'æ©ä¸'; 6406 } else if (hm < 1130) { 6407 return 'ä¸å'; 6408 } else if (hm < 1230) { 6409 return 'ä¸å'; 6410 } else if (hm < 1800) { 6411 return 'ä¸å'; 6412 } else { 6413 return 'æä¸'; 6414 } 6415 }, 6416 calendar: { 6417 sameDay: '[ä»å¤©] LT', 6418 nextDay: '[æ天] LT', 6419 nextWeek: '[ä¸]dddd LT', 6420 lastDay: '[æ¨å¤©] LT', 6421 lastWeek: '[ä¸]dddd LT', 6422 sameElse: 'L', 6423 }, 6424 dayOfMonthOrdinalParse: /\d{1,2}(æ¥|æ|é±)/, 6425 ordinal: function (number, period) { 6426 switch (period) { 6427 case 'd': 6428 case 'D': 6429 case 'DDD': 6430 return number + 'æ¥'; 6431 case 'M': 6432 return number + 'æ'; 6433 case 'w': 6434 case 'W': 6435 return number + 'é±'; 6436 default: 6437 return number; 6438 } 6439 }, 6440 relativeTime: { 6441 future: '%så¾', 6442 past: '%så', 6443 s: 'å¹¾ç§', 6444 ss: '%d ç§', 6445 m: '1 åé', 6446 mm: '%d åé', 6447 h: '1 å°æ', 6448 hh: '%d å°æ', 6449 d: '1 天', 6450 dd: '%d 天', 6451 M: '1 åæ', 6452 MM: '%d åæ', 6453 y: '1 å¹´', 6454 yy: '%d å¹´', 6455 }, 6456 }); 6457 6458 return zhTw; 6459 6460}))); 6461 6462//! moment.js locale configuration 6463 6464;(function (global, factory) { 6465 typeof exports === 'object' && typeof module !== 'undefined' 6466 && typeof require === 'function' ? factory(require('../moment')) : 6467 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 6468 factory(global.moment) 6469}(this, (function (moment) { 'use strict'; 6470 6471 6472 var ja = moment.defineLocale('ja', { 6473 eras: [ 6474 { 6475 since: '2019-05-01', 6476 offset: 1, 6477 name: '令å', 6478 narrow: 'ã¿', 6479 abbr: 'R', 6480 }, 6481 { 6482 since: '1989-01-08', 6483 until: '2019-04-30', 6484 offset: 1, 6485 name: 'å¹³æ', 6486 narrow: 'ã»', 6487 abbr: 'H', 6488 }, 6489 { 6490 since: '1926-12-25', 6491 until: '1989-01-07', 6492 offset: 1, 6493 name: 'æå', 6494 narrow: 'ã¼', 6495 abbr: 'S', 6496 }, 6497 { 6498 since: '1912-07-30', 6499 until: '1926-12-24', 6500 offset: 1, 6501 name: '大æ£', 6502 narrow: 'ã½', 6503 abbr: 'T', 6504 }, 6505 { 6506 since: '1873-01-01', 6507 until: '1912-07-29', 6508 offset: 6, 6509 name: 'ææ²»', 6510 narrow: 'ã¾', 6511 abbr: 'M', 6512 }, 6513 { 6514 since: '0001-01-01', 6515 until: '1873-12-31', 6516 offset: 1, 6517 name: '西æ¦', 6518 narrow: 'AD', 6519 abbr: 'AD', 6520 }, 6521 { 6522 since: '0000-12-31', 6523 until: -Infinity, 6524 offset: 1, 6525 name: 'ç´å å', 6526 narrow: 'BC', 6527 abbr: 'BC', 6528 }, 6529 ], 6530 eraYearOrdinalRegex: /(å |\d+)å¹´/, 6531 eraYearOrdinalParse: function (input, match) { 6532 return match[1] === 'å ' ? 1 : parseInt(match[1] || input, 10); 6533 }, 6534 months: '1æ_2æ_3æ_4æ_5æ_6æ_7æ_8æ_9æ_10æ_11æ_12æ'.split('_'), 6535 monthsShort: '1æ_2æ_3æ_4æ_5æ_6æ_7æ_8æ_9æ_10æ_11æ_12æ'.split( 6536 '_' 6537 ), 6538 weekdays: 'æ¥ææ¥_æææ¥_ç«ææ¥_æ°´ææ¥_æ¨ææ¥_éææ¥_åææ¥'.split('_'), 6539 weekdaysShort: 'æ¥_æ_ç«_æ°´_æ¨_é_å'.split('_'), 6540 weekdaysMin: 'æ¥_æ_ç«_æ°´_æ¨_é_å'.split('_'), 6541 longDateFormat: { 6542 LT: 'HH:mm', 6543 LTS: 'HH:mm:ss', 6544 L: 'YYYY/MM/DD', 6545 LL: 'YYYYå¹´MæDæ¥', 6546 LLL: 'YYYYå¹´MæDæ¥ HH:mm', 6547 LLLL: 'YYYYå¹´MæDæ¥ dddd HH:mm', 6548 l: 'YYYY/MM/DD', 6549 ll: 'YYYYå¹´MæDæ¥', 6550 lll: 'YYYYå¹´MæDæ¥ HH:mm', 6551 llll: 'YYYYå¹´MæDæ¥(ddd) HH:mm', 6552 }, 6553 meridiemParse: /åå|åå¾/i, 6554 isPM: function (input) { 6555 return input === 'åå¾'; 6556 }, 6557 meridiem: function (hour, minute, isLower) { 6558 if (hour < 12) { 6559 return 'åå'; 6560 } else { 6561 return 'åå¾'; 6562 } 6563 }, 6564 calendar: { 6565 sameDay: '[ä»æ¥] LT', 6566 nextDay: '[ææ¥] LT', 6567 nextWeek: function (now) { 6568 if (now.week() !== this.week()) { 6569 return '[æ¥é±]dddd LT'; 6570 } else { 6571 return 'dddd LT'; 6572 } 6573 }, 6574 lastDay: '[æ¨æ¥] LT', 6575 lastWeek: function (now) { 6576 if (this.week() !== now.week()) { 6577 return '[å é±]dddd LT'; 6578 } else { 6579 return 'dddd LT'; 6580 } 6581 }, 6582 sameElse: 'L', 6583 }, 6584 dayOfMonthOrdinalParse: /\d{1,2}æ¥/, 6585 ordinal: function (number, period) { 6586 switch (period) { 6587 case 'y': 6588 return number === 1 ? 'å å¹´' : number + 'å¹´'; 6589 case 'd': 6590 case 'D': 6591 case 'DDD': 6592 return number + 'æ¥'; 6593 default: 6594 return number; 6595 } 6596 }, 6597 relativeTime: { 6598 future: '%så¾', 6599 past: '%så', 6600 s: 'æ°ç§', 6601 ss: '%dç§', 6602 m: '1å',
6603 mm: '%då', 6604 h: '1æé', 6605 hh: '%dæé', 6606 d: '1æ¥', 6607 dd: '%dæ¥', 6608 M: '1ã¶æ', 6609 MM: '%dã¶æ', 6610 y: '1å¹´', 6611 yy: '%då¹´', 6612 }, 6613 }); 6614 6615 return ja; 6616 6617}))); 6618 6619//! moment.js locale configuration 6620 6621;(function (global, factory) { 6622 typeof exports === 'object' && typeof module !== 'undefined' 6623 && typeof require === 'function' ? factory(require('../moment')) : 6624 typeof define === 'function' && define.amd ? define(['../moment'], factory) : 6625 factory(global.moment) 6626}(this, (function (moment) { 'use strict'; 6627 6628 6629 var ko = moment.defineLocale('ko', { 6630 months: '1ì_2ì_3ì_4ì_5ì_6ì_7ì_8ì_9ì_10ì_11ì_12ì'.split('_'), 6631 monthsShort: '1ì_2ì_3ì_4ì_5ì_6ì_7ì_8ì_9ì_10ì_11ì_12ì'.split( 6632 '_' 6633 ), 6634 weekdays: 'ì¼ìì¼_ììì¼_íìì¼_ììì¼_목ìì¼_ê¸ìì¼_í ìì¼'.split('_'), 6635 weekdaysShort: 'ì¼_ì_í_ì_목_ê¸_í '.split('_'), 6636 weekdaysMin: 'ì¼_ì_í_ì_목_ê¸_í '.split('_'), 6637 longDateFormat: { 6638 LT: 'A h:mm', 6639 LTS: 'A h:mm:ss', 6640 L: 'YYYY.MM.DD.', 6641 LL: 'YYYYë MMMM Dì¼', 6642 LLL: 'YYYYë MMMM Dì¼ A h:mm', 6643 LLLL: 'YYYYë MMMM Dì¼ dddd A h:mm', 6644 l: 'YYYY.MM.DD.', 6645 ll: 'YYYYë MMMM Dì¼', 6646 lll: 'YYYYë MMMM Dì¼ A h:mm', 6647 llll: 'YYYYë MMMM Dì¼ dddd A h:mm', 6648 }, 6649 calendar: { 6650 sameDay: 'ì¤ë LT', 6651 nextDay: 'ë´ì¼ LT', 6652 nextWeek: 'dddd LT', 6653 lastDay: 'ì´ì LT', 6654 lastWeek: 'ì§ë주 dddd LT', 6655 sameElse: 'L', 6656 }, 6657 relativeTime: { 6658 future: '%s í', 6659 past: '%s ì ', 6660 s: 'ëª ì´', 6661 ss: '%dì´', 6662 m: '1ë¶', 6663 mm: '%dë¶', 6664 h: 'í ìê°', 6665 hh: '%dìê°', 6666 d: 'í루', 6667 dd: '%dì¼', 6668 M: 'í ë¬', 6669 MM: '%dë¬', 6670 y: 'ì¼ ë ', 6671 yy: '%dë ', 6672 }, 6673 dayOfMonthOrdinalParse: /\d{1,2}(ì¼|ì|주)/, 6674 ordinal: function (number, period) { 6675 switch (period) { 6676 case 'd': 6677 case 'D': 6678 case 'DDD': 6679 return number + 'ì¼'; 6680 case 'M': 6681 return number + 'ì'; 6682 case 'w': 6683 case 'W': 6684 return number + '주'; 6685 default: 6686 return number; 6687 } 6688 }, 6689 meridiemParse: /ì¤ì |ì¤í/, 6690 isPM: function (token) { 6691 return token === 'ì¤í'; 6692 }, 6693 meridiem: function (hour, minute, isUpper) { 6694 return hour < 12 ? 'ì¤ì ' : 'ì¤í'; 6695 }, 6696 }); 6697 6698 return ko; 6699 6700}))); 6701 6702/* 6703 * ADOBE CONFIDENTIAL 6704 * 6705 * Copyright 2017 Adobe Systems Incorporated 6706 * All Rights Reserved. 6707 *
6708 * NOTICE: All information contained herein is, and remains 6709 * the property of Adobe Systems Incorporated and its suppliers, 6710 * if any. The intellectual and technical concepts contained 6711 * herein are proprietary to Adobe Systems Incorporated and its 6712 * suppliers and may be covered by U.S. and Foreign Patents, 6713 * patents in process, and are protected by trade secret or copyright law. 6714 * Dissemination of this information or reproduction of this material 6715 * is strictly forbidden unless prior written permission is obtained 6716 * from Adobe Systems Incorporated. 6717 */ 6718(function(root, factory) { 6719 "use strict"; 6720 6721 if (typeof module === "object" && module.exports) { 6722 module.exports = factory(require("moment")); 6723 } else { 6724 factory(root.moment); 6725 } 6726}(this, function(moment) { 6727 "use strict"; 6728 6729 var shortTimeZoneFormat = new Intl.DateTimeFormat("de", { year: "2-digit", timeZoneName: "short" }); 6730 var longTimeZoneFormat = new Intl.DateTimeFormat("de", { year: "2-digit", timeZoneName: "long" }); 6731 6732 function getShortTimeZone(date) { 6733 var v = shortTimeZoneFormat.format(date); 6734 return v.substring(v.indexOf(" ") + 1); 6735 } 6736 6737 function getLongTimeZone(date) { 6738 var v = longTimeZoneFormat.format(date); 6739 return v.substring(v.indexOf(" ") + 1); 6740 } 6741 6742 // See https://github.com/unicode-cldr/cldr-dates-modern/blob/master/main/de/ca-gregorian.json 6743 moment.updateLocale("de", { 6744 presets: { 6745 date: { 6746 short: "DD.MM.YY", 6747 medium: "DD.MM.Y", 6748 long: "D. MMMM Y", 6749 full: "dddd, D. MMMM Y" 6750 }, 6751 time: { 6752 short: "HH:mm", 6753 medium: "HH:mm:ss", 6754 long: function(moment) { 6755 return "HH:mm:ss [" + getShortTimeZone(moment.toDate()) + "]"; 6756 }, 6757 full: function(moment) { 6758 return "HH:mm:ss [" + getLongTimeZone(moment.toDate()) + "]"; 6759 } 6760 }, 6761 datetime: { 6762 short: "DD.MM.YY, HH:mm", 6763 medium: "DD.MM.Y, HH:mm:ss", 6764 long: function(moment) { 6765 return "D. MMMM Y [um] HH:mm:ss [" + getShortTimeZone(moment.toDate()) + "]"; 6766 }, 6767 full: function(moment) { 6768 return "dddd, D. MMMM Y [um] HH:mm:ss [" + getLongTimeZone(moment.toDate()) + "]"; 6769 } 6770 } 6771 } 6772 }); 6773})); 6774 6775/* 6776 * ADOBE CONFIDENTIAL 6777 * 6778 * Copyright 2017 Adobe Systems Incorporated 6779 * All Rights Reserved. 6780 *
6781 * NOTICE: All information contained herein is, and remains 6782 * the property of Adobe Systems Incorporated and its suppliers, 6783 * if any. The intellectual and technical concepts contained 6784 * herein are proprietary to Adobe Systems Incorporated and its 6785 * suppliers and may be covered by U.S. and Foreign Patents, 6786 * patents in process, and are protected by trade secret or copyright law. 6787 * Dissemination of this information or reproduction of this material 6788 * is strictly forbidden unless prior written permission is obtained 6789 * from Adobe Systems Incorporated. 6790 */ 6791(function(root, factory) { 6792 "use strict"; 6793 6794 if (typeof module === "object" && module.exports) { 6795 module.exports = factory(require("moment")); 6796 } else { 6797 factory(root.moment); 6798 } 6799}(this, function(moment) { 6800 "use strict"; 6801 6802 var shortTimeZoneFormat = new Intl.DateTimeFormat("es", { year: "2-digit", timeZoneName: "short" }); 6803 var longTimeZoneFormat = new Intl.DateTimeFormat("es", { year: "2-digit", timeZoneName: "long" }); 6804 6805 function getShortTimeZone(date) { 6806 var v = shortTimeZoneFormat.format(date); 6807 return v.substring(v.indexOf(" ") + 1); 6808 } 6809 6810 function getLongTimeZone(date) { 6811 var v = longTimeZoneFormat.format(date); 6812 return v.substring(v.indexOf(" ") + 1); 6813 } 6814 6815 // See https://github.com/unicode-cldr/cldr-dates-modern/blob/master/main/es/ca-gregorian.json 6816 moment.updateLocale("es", { 6817 presets: { 6818 date: { 6819 short: "D/M/YY", 6820 medium: "D MMM Y", 6821 long: "D [de] MMMM [de] Y", 6822 full: "dddd, D [de] MMMM [de] Y" 6823 }, 6824 time: { 6825 short: "H:mm", 6826 medium: "H:mm:ss", 6827 long: function(moment) { 6828 return "H:mm:ss [" + getShortTimeZone(moment.toDate()) + "]"; 6829 }, 6830 full: function(moment) { 6831 return "H:mm:ss [(" + getLongTimeZone(moment.toDate()) + ")]"; 6832 } 6833 }, 6834 datetime: { 6835 short: "D/M/YY H:mm", 6836 medium: "D MMM Y H:mm:ss", 6837 long: function(moment) { 6838 return "D [de] MMMM [de] Y, H:mm:ss [" + getShortTimeZone(moment.toDate()) + "]"; 6839 }, 6840 full: function(moment) { 6841 return "dddd, D [de] MMMM [de] Y, H:mm:ss [(" + getLongTimeZone(moment.toDate()) + ")]"; 6842 } 6843 } 6844 } 6845 }); 6846})); 6847 6848/* 6849 * ADOBE CONFIDENTIAL 6850 * 6851 * Copyright 2017 Adobe Systems Incorporated 6852 * All Rights Reserved. 6853 *
6854 * NOTICE: All information contained herein is, and remains 6855 * the property of Adobe Systems Incorporated and its suppliers, 6856 * if any. The intellectual and technical concepts contained 6857 * herein are proprietary to Adobe Systems Incorporated and its 6858 * suppliers and may be covered by U.S. and Foreign Patents, 6859 * patents in process, and are protected by trade secret or copyright law. 6860 * Dissemination of this information or reproduction of this material 6861 * is strictly forbidden unless prior written permission is obtained 6862 * from Adobe Systems Incorporated. 6863 */ 6864(function(root, factory) { 6865 "use strict"; 6866 6867 if (typeof module === "object" && module.exports) { 6868 module.exports = factory(require("moment")); 6869 } else { 6870 factory(root.moment); 6871 } 6872}(this, function(moment) { 6873 "use strict"; 6874 6875 var shortTimeZoneFormat = new Intl.DateTimeFormat("fr", { year: "2-digit", timeZoneName: "short" }); 6876 var longTimeZoneFormat = new Intl.DateTimeFormat("fr", { year: "2-digit", timeZoneName: "long" }); 6877 6878 function getShortTimeZone(date) { 6879 var v = shortTimeZoneFormat.format(date); 6880 return v.substring(v.indexOf(" ") + 1); 6881 } 6882 6883 function getLongTimeZone(date) { 6884 var v = longTimeZoneFormat.format(date); 6885 return v.substring(v.indexOf(" ") + 1); 6886 } 6887 6888 moment.updateLocale("fr", { 6889 presets: { 6890 date: { 6891 short: "DD/MM/Y", 6892 medium: "D MMM Y", 6893 long: "D MMMM Y", 6894 full: "dddd D MMMM Y" 6895 }, 6896 time: { 6897 short: "HH:mm", 6898 medium: "HH:mm:ss", 6899 long: function(moment) { 6900 return "HH:mm:ss [" + getShortTimeZone(moment.toDate()) + "]"; 6901 }, 6902 full: function(moment) { 6903 return "HH:mm:ss [" + getLongTimeZone(moment.toDate()) + "]"; 6904 } 6905 }, 6906 datetime: { 6907 short: "DD/MM/Y HH:mm", 6908 medium: "D MMM Y Ã HH:mm:ss", 6909 long: function(moment) { 6910 return "D MMMM Y Ã HH:mm:ss [" + getShortTimeZone(moment.toDate()) + "]"; 6911 }, 6912 full: function(moment) { 6913 return "dddd D MMMM Y Ã HH:mm:ss [" + getLongTimeZone(moment.toDate()) + "]"; 6914 } 6915 } 6916 } 6917 }); 6918})); 6919 6920/* 6921 * ADOBE CONFIDENTIAL 6922 * 6923 * Copyright 2017 Adobe Systems Incorporated 6924 * All Rights Reserved. 6925 *
6926 * NOTICE: All information contained herein is, and remains 6927 * the property of Adobe Systems Incorporated and its suppliers, 6928 * if any. The intellectual and technical concepts contained 6929 * herein are proprietary to Adobe Systems Incorporated and its 6930 * suppliers and may be covered by U.S. and Foreign Patents, 6931 * patents in process, and are protected by trade secret or copyright law. 6932 * Dissemination of this information or reproduction of this material 6933 * is strictly forbidden unless prior written permission is obtained 6934 * from Adobe Systems Incorporated. 6935 */ 6936(function(root, factory) { 6937 "use strict"; 6938 6939 if (typeof module === "object" && module.exports) { 6940 module.exports = factory(require("moment")); 6941 } else { 6942 factory(root.moment); 6943 } 6944}(this, function(moment) { 6945 "use strict"; 6946 6947 var shortTimeZoneFormat = new Intl.DateTimeFormat("it", { year: "2-digit", timeZoneName: "short" }); 6948 var longTimeZoneFormat = new Intl.DateTimeFormat("it", { year: "2-digit", timeZoneName: "long" }); 6949 6950 function getShortTimeZone(date) { 6951 var v = shortTimeZoneFormat.format(date); 6952 return v.substring(v.indexOf(" ") + 1); 6953 } 6954 6955 function getLongTimeZone(date) { 6956 var v = longTimeZoneFormat.format(date); 6957 return v.substring(v.indexOf(" ") + 1); 6958 } 6959 6960 // See https://github.com/unicode-cldr/cldr-dates-modern/blob/master/main/it/ca-gregorian.json 6961 moment.updateLocale("it", { 6962 presets: { 6963 date: { 6964 short: "DD/MM/YY", 6965 medium: "DD MMM Y", 6966 long: "D MMMM Y", 6967 full: "dddd D MMMM Y" 6968 }, 6969 time: { 6970 short: "HH:mm", 6971 medium: "HH:mm:ss", 6972 long: function(moment) { 6973 return "HH:mm:ss [" + getShortTimeZone(moment.toDate()) + "]"; 6974 }, 6975 full: function(moment) { 6976 return "HH:mm:ss [" + getLongTimeZone(moment.toDate()) + "]"; 6977 } 6978 }, 6979 datetime: { 6980 short: "DD/MM/YY, HH:mm", 6981 medium: "DD MMM Y, HH:mm:ss", 6982 long: function(moment) { 6983 return "D MMMM Y HH:mm:ss [" + getShortTimeZone(moment.toDate()) + "]"; 6984 }, 6985 full: function(moment) { 6986 return "dddd D MMMM Y HH:mm:ss [" + getLongTimeZone(moment.toDate()) + "]"; 6987 } 6988 } 6989 } 6990 }); 6991})); 6992 6993/* 6994 * ADOBE CONFIDENTIAL 6995 * 6996 * Copyright 2017 Adobe Systems Incorporated 6997 * All Rights Reserved. 6998 *
6999 * NOTICE: All information contained herein is, and remains 7000 * the property of Adobe Systems Incorporated and its suppliers, 7001 * if any. The intellectual and technical concepts contained 7002 * herein are proprietary to Adobe Systems Incorporated and its 7003 * suppliers and may be covered by U.S. and Foreign Patents, 7004 * patents in process, and are protected by trade secret or copyright law. 7005 * Dissemination of this information or reproduction of this material 7006 * is strictly forbidden unless prior written permission is obtained 7007 * from Adobe Systems Incorporated. 7008 */ 7009(function(root, factory) { 7010 "use strict"; 7011 7012 if (typeof module === "object" && module.exports) { 7013 module.exports = factory(require("moment")); 7014 } else { 7015 factory(root.moment); 7016 } 7017}(this, function(moment) { 7018 "use strict"; 7019 7020 var shortTimeZoneFormat = new Intl.DateTimeFormat("pt-br", { year: "2-digit", timeZoneName: "short" }); 7021 var longTimeZoneFormat = new Intl.DateTimeFormat("pt-br", { year: "2-digit", timeZoneName: "long" }); 7022 7023 function getShortTimeZone(date) { 7024 var v = shortTimeZoneFormat.format(date); 7025 return v.substring(v.indexOf(" ") + 1); 7026 } 7027 7028 function getLongTimeZone(date) { 7029 var v = longTimeZoneFormat.format(date); 7030 return v.substring(v.indexOf(" ") + 1); 7031 } 7032 7033 // See https://github.com/unicode-cldr/cldr-dates-modern/blob/master/main/pt/ca-gregorian.json 7034 moment.updateLocale("pt-br", { 7035 presets: { 7036 date: { 7037 short: "DD/MM/Y", 7038 medium: "D [de] MMM [de] Y", 7039 long: "D [de] MMMM [de] Y", 7040 full: "dddd, D [de] MMMM [de] Y" 7041 }, 7042 time: { 7043 short: "HH:mm", 7044 medium: "HH:mm:ss", 7045 long: function(moment) { 7046 return "HH:mm:ss [" + getShortTimeZone(moment.toDate()) + "]"; 7047 }, 7048 full: function(moment) { 7049 return "HH:mm:ss [" + getLongTimeZone(moment.toDate()) + "]"; 7050 } 7051 }, 7052 datetime: { 7053 short: "DD/MM/Y HH:mm", 7054 medium: "D [de] MMM [de] Y HH:mm:ss", 7055 long: function(moment) { 7056 return "D [de] MMMM [de] Y HH:mm:ss [" + getShortTimeZone(moment.toDate()) + "]"; 7057 }, 7058 full: function(moment) { 7059 return "dddd, D [de] MMMM [de] Y HH:mm:ss [" + getLongTimeZone(moment.toDate()) + "]"; 7060 } 7061 } 7062 } 7063 }); 7064})); 7065 7066/* 7067 * ADOBE CONFIDENTIAL 7068 * 7069 * Copyright 2017 Adobe Systems Incorporated 7070 * All Rights Reserved. 7071 *
7072 * NOTICE: All information contained herein is, and remains 7073 * the property of Adobe Systems Incorporated and its suppliers, 7074 * if any. The intellectual and technical concepts contained 7075 * herein are proprietary to Adobe Systems Incorporated and its 7076 * suppliers and may be covered by U.S. and Foreign Patents, 7077 * patents in process, and are protected by trade secret or copyright law. 7078 * Dissemination of this information or reproduction of this material 7079 * is strictly forbidden unless prior written permission is obtained 7080 * from Adobe Systems Incorporated. 7081 */ 7082(function(root, factory) { 7083 "use strict"; 7084 7085 if (typeof module === "object" && module.exports) { 7086 module.exports = factory(require("moment")); 7087 } else { 7088 factory(root.moment); 7089 } 7090}(this, function(moment) { 7091 "use strict"; 7092 7093 var shortTimeZoneFormat = new Intl.DateTimeFormat("zh-cn", { year: "2-digit", timeZoneName: "short" }); 7094 var longTimeZoneFormat = new Intl.DateTimeFormat("zh-cn", { year: "2-digit", timeZoneName: "long" }); 7095 7096 function getShortTimeZone(date) { 7097 var v = shortTimeZoneFormat.format(date); 7098 return v.substring(v.indexOf(" ") + 1); 7099 } 7100 7101 function getLongTimeZone(date) { 7102 var v = longTimeZoneFormat.format(date); 7103 return v.substring(v.indexOf(" ") + 1); 7104 } 7105 7106 // See https://github.com/unicode-cldr/cldr-dates-modern/blob/master/main/zh/ca-gregorian.json 7107 moment.updateLocale("zh-cn", { 7108 presets: { 7109 date: { 7110 short: "Y/M/D", 7111 medium: "Yå¹´MæDæ¥", 7112 long: "Yå¹´MæDæ¥", 7113 full: "Yå¹´MæDæ¥dddd" 7114 }, 7115 time: { 7116 short: "ah:mm", 7117 medium: "ah:mm:ss", 7118 long: function(moment) { 7119 return "[" + getShortTimeZone(moment.toDate()) + "] ah:mm:ss"; 7120 }, 7121 full: function(moment) { 7122 return "[" + getLongTimeZone(moment.toDate()) + "] ah:mm:ss"; 7123 } 7124 }, 7125 datetime: { 7126 short: "Y/M/D ah:mm", 7127 medium: "Yå¹´MæDæ¥ ah:mm:ss", 7128 long: function(moment) { 7129 return "Yå¹´MæDæ¥ [" + getShortTimeZone(moment.toDate()) + "] ah:mm:ss"; 7130 }, 7131 full: function(moment) { 7132 return "Yå¹´MæDæ¥dddd [" + getLongTimeZone(moment.toDate()) + "] ah:mm:ss"; 7133 } 7134 } 7135 } 7136 }); 7137})); 7138 7139/* 7140 * ADOBE CONFIDENTIAL 7141 * 7142 * Copyright 2017 Adobe Systems Incorporated 7143 * All Rights Reserved. 7144 *
7145 * NOTICE: All information contained herein is, and remains 7146 * the property of Adobe Systems Incorporated and its suppliers, 7147 * if any. The intellectual and technical concepts contained 7148 * herein are proprietary to Adobe Systems Incorporated and its 7149 * suppliers and may be covered by U.S. and Foreign Patents, 7150 * patents in process, and are protected by trade secret or copyright law. 7151 * Dissemination of this information or reproduction of this material 7152 * is strictly forbidden unless prior written permission is obtained 7153 * from Adobe Systems Incorporated. 7154 */ 7155(function(root, factory) { 7156 "use strict"; 7157 7158 if (typeof module === "object" && module.exports) { 7159 module.exports = factory(require("moment")); 7160 } else { 7161 factory(root.moment); 7162 } 7163}(this, function(moment) { 7164 "use strict"; 7165 7166 var shortTimeZoneFormat = new Intl.DateTimeFormat("zh-tw", { year: "2-digit", timeZoneName: "short" }); 7167 var longTimeZoneFormat = new Intl.DateTimeFormat("zh-tw", { year: "2-digit", timeZoneName: "long" }); 7168 7169 function getShortTimeZone(date) { 7170 var v = shortTimeZoneFormat.format(date); 7171 return v.substring(v.indexOf(" ") + 1); 7172 } 7173 7174 function getLongTimeZone(date) { 7175 var v = longTimeZoneFormat.format(date); 7176 return v.substring(v.indexOf(" ") + 1); 7177 } 7178 7179 // See https://github.com/unicode-cldr/cldr-dates-modern/blob/master/main/zh-Hant/ca-gregorian.json 7180 moment.updateLocale("zh-tw", { 7181 presets: { 7182 date: { 7183 short: "Y/M/D", 7184 medium: "Yå¹´MæDæ¥", 7185 long: "Yå¹´MæDæ¥", 7186 full: "Yå¹´MæDæ¥ dddd" 7187 }, 7188 time: { 7189 short: "ah:mm", 7190 medium: "ah:mm:ss", 7191 long: function(moment) { 7192 return "ah:mm:ss [[" + getShortTimeZone(moment.toDate()) + "]]"; 7193 }, 7194 full: function(moment) { 7195 return "ah:mm:ss [[" + getLongTimeZone(moment.toDate()) + "]]"; 7196 } 7197 }, 7198 datetime: { 7199 short: "Y/M/D ah:mm", 7200 medium: "Yå¹´MæDæ¥ ah:mm:ss", 7201 long: function(moment) { 7202 return "Yå¹´MæDæ¥ ah:mm:ss [[" + getShortTimeZone(moment.toDate()) + "]]"; 7203 }, 7204 full: function(moment) { 7205 return "Yå¹´MæDæ¥ dddd ah:mm:ss [[" + getLongTimeZone(moment.toDate()) + "]]"; 7206 } 7207 } 7208 } 7209 }); 7210})); 7211 7212/* 7213 * ADOBE CONFIDENTIAL 7214 * 7215 * Copyright 2017 Adobe Systems Incorporated 7216 * All Rights Reserved. 7217 *
7218 * NOTICE: All information contained herein is, and remains 7219 * the property of Adobe Systems Incorporated and its suppliers, 7220 * if any. The intellectual and technical concepts contained 7221 * herein are proprietary to Adobe Systems Incorporated and its 7222 * suppliers and may be covered by U.S. and Foreign Patents, 7223 * patents in process, and are protected by trade secret or copyright law. 7224 * Dissemination of this information or reproduction of this material 7225 * is strictly forbidden unless prior written permission is obtained 7226 * from Adobe Systems Incorporated. 7227 */ 7228(function(root, factory) { 7229 "use strict"; 7230 7231 if (typeof module === "object" && module.exports) { 7232 module.exports = factory(require("moment")); 7233 } else { 7234 factory(root.moment); 7235 } 7236}(this, function(moment) { 7237 "use strict"; 7238 7239 var shortTimeZoneFormat = new Intl.DateTimeFormat("ja", { year: "2-digit", timeZoneName: "short" }); 7240 var longTimeZoneFormat = new Intl.DateTimeFormat("ja", { year: "2-digit", timeZoneName: "long" }); 7241 7242 function getShortTimeZone(date) { 7243 var v = shortTimeZoneFormat.format(date); 7244 return v.substring(v.indexOf(" ") + 1); 7245 } 7246 7247 function getLongTimeZone(date) { 7248 var v = longTimeZoneFormat.format(date); 7249 return v.substring(v.indexOf(" ") + 1); 7250 } 7251 7252 // See https://github.com/unicode-cldr/cldr-dates-modern/blob/master/main/ja/ca-gregorian.json 7253 moment.updateLocale("ja", { 7254 presets: { 7255 date: { 7256 short: "Y/MM/DD", 7257 medium: "Y/MM/DD", 7258 long: "Yå¹´MæDæ¥", 7259 full: "Yå¹´MæDæ¥dddd" 7260 }, 7261 time: { 7262 short: "H:mm", 7263 medium: "H:mm:ss", 7264 long: function(moment) { 7265 return "H:mm:ss [" + getShortTimeZone(moment.toDate()) + "]"; 7266 }, 7267 full: function(moment) { 7268 return "Hæmmåssç§ [" + getLongTimeZone(moment.toDate()) + "]"; 7269 } 7270 }, 7271 datetime: { 7272 short: " Y/MM/DD H:mm", 7273 medium: "Y/MM/DD H:mm:ss", 7274 long: function(moment) { 7275 return "Yå¹´MæDæ¥ H:mm:ss [" + getShortTimeZone(moment.toDate()) + "]"; 7276 }, 7277 full: function(moment) { 7278 return "Yå¹´MæDæ¥dddd Hæmmåssç§ [" + getLongTimeZone(moment.toDate()) + "]"; 7279 } 7280 } 7281 } 7282 }); 7283})); 7284 7285/* 7286 * ADOBE CONFIDENTIAL 7287 * 7288 * Copyright 2017 Adobe Systems Incorporated 7289 * All Rights Reserved. 7290 *
7291 * NOTICE: All information contained herein is, and remains 7292 * the property of Adobe Systems Incorporated and its suppliers, 7293 * if any. The intellectual and technical concepts contained 7294 * herein are proprietary to Adobe Systems Incorporated and its 7295 * suppliers and may be covered by U.S. and Foreign Patents, 7296 * patents in process, and are protected by trade secret or copyright law. 7297 * Dissemination of this information or reproduction of this material 7298 * is strictly forbidden unless prior written permission is obtained 7299 * from Adobe Systems Incorporated. 7300 */ 7301(function(root, factory) { 7302 "use strict"; 7303 7304 if (typeof module === "object" && module.exports) { 7305 module.exports = factory(require("moment")); 7306 } else { 7307 factory(root.moment); 7308 } 7309}(this, function(moment) { 7310 "use strict"; 7311 7312 var shortTimeZoneFormat = new Intl.DateTimeFormat("ko", { year: "2-digit", timeZoneName: "short" }); 7313 var longTimeZoneFormat = new Intl.DateTimeFormat("ko", { year: "2-digit", timeZoneName: "long" }); 7314 7315 function getShortTimeZone(date) { 7316 var v = shortTimeZoneFormat.format(date); 7317 return v.substring(v.indexOf(" ") + 1); 7318 } 7319 7320 function getLongTimeZone(date) { 7321 var v = longTimeZoneFormat.format(date); 7322 return v.substring(v.indexOf(" ") + 1); 7323 } 7324 7325 // See https://github.com/unicode-cldr/cldr-dates-modern/blob/master/main/ko/ca-gregorian.json 7326 moment.updateLocale("ko", { 7327 presets: { 7328 date: { 7329 short: "YY. M. D.", 7330 medium: "Y. M. D.", 7331 long: "Yë Mì Dì¼", 7332 full: "Yë Mì Dì¼ dddd" 7333 }, 7334 time: { 7335 short: "a h:mm", 7336 medium: "a h:mm:ss", 7337 long: function(moment) { 7338 return "a hì më¶ sì´ [" + getShortTimeZone(moment.toDate()) + "]"; 7339 }, 7340 full: function(moment) { 7341 return "a hì më¶ sì´ [" + getLongTimeZone(moment.toDate()) + "]"; 7342 } 7343 }, 7344 datetime: { 7345 short: "YY. M. D. a h:mm", 7346 medium: "Y. M. D. a h:mm:ss", 7347 long: function(moment) { 7348 return "Yë Mì Dì¼ a hì më¶ sì´ [" + getShortTimeZone(moment.toDate()) + "]"; 7349 }, 7350 full: function(moment) { 7351 return "Yë Mì Dì¼ dddd a hì më¶ sì´ [" + getLongTimeZone(moment.toDate()) + "]"; 7352 } 7353 } 7354 } 7355 }); 7356})); 7357 7358/* 7359 * ADOBE CONFIDENTIAL 7360 * 7361 * Copyright 2017 Adobe Systems Incorporated 7362 * All Rights Reserved. 7363 *
7364 * NOTICE: All information contained herein is, and remains 7365 * the property of Adobe Systems Incorporated and its suppliers, 7366 * if any. The intellectual and technical concepts contained 7367 * herein are proprietary to Adobe Systems Incorporated and its 7368 * suppliers and may be covered by U.S. and Foreign Patents, 7369 * patents in process, and are protected by trade secret or copyright law. 7370 * Dissemination of this information or reproduction of this material 7371 * is strictly forbidden unless prior written permission is obtained 7372 * from Adobe Systems Incorporated. 7373 */ 7374(function(root, factory) { 7375 "use strict"; 7376 7377 if (typeof module === "object" && module.exports) { 7378 module.exports = factory(require("moment")); 7379 } else { 7380 factory(root.moment); 7381 } 7382}(this, function(moment) { 7383 "use strict"; 7384 7385 var shortTimeZoneFormat = new Intl.DateTimeFormat("en", { year: "2-digit", timeZoneName: "short" }); 7386 var longTimeZoneFormat = new Intl.DateTimeFormat("en", { year: "2-digit", timeZoneName: "long" }); 7387 7388 function getShortTimeZone(date) { 7389 var v = shortTimeZoneFormat.format(date); 7390 return v.substring(v.indexOf(" ") + 1); 7391 } 7392 7393 function getLongTimeZone(date) { 7394 var v = longTimeZoneFormat.format(date); 7395 return v.substring(v.indexOf(" ") + 1); 7396 } 7397 7398 // See https://github.com/unicode-cldr/cldr-dates-modern/blob/master/main/en/ca-gregorian.json 7399 moment.updateLocale("en", { 7400 presets: { 7401 date: { 7402 short: "M/D/YY", 7403 medium: "MMM D, Y", 7404 long: "MMMM D, Y", 7405 full: "dddd, MMMM D, Y" 7406 }, 7407 time: { 7408 short: "h:mm A", 7409 medium: "h:mm:ss A", 7410 long: function(moment) { 7411 return "h:mm:ss A [" + getShortTimeZone(moment.toDate()) + "]"; 7412 }, 7413 full: function(moment) { 7414 return "h:mm:ss A [" + getLongTimeZone(moment.toDate()) + "]"; 7415 } 7416 }, 7417 datetime: { 7418 short: "M/D/YY, h:mm A", 7419 medium: "MMM D, Y, h:mm:ss A", 7420 long: function(moment) { 7421 return "MMMM D, Y [at] h:mm:ss A [" + getShortTimeZone(moment.toDate()) + "]"; 7422 }, 7423 full: function(moment) { 7424 return "dddd, MMMM D, Y [at] h:mm:ss A [" + getLongTimeZone(moment.toDate()) + "]"; 7425 } 7426 } 7427 } 7428 }); 7429})); 7430
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.