vendor: 173,825 bytes, lines 1-5668
1//! moment.js 2//! version : 2.26.0 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 for (i = 0; i < arr.length; ++i) { 81 res.push(fn(arr[i], i)); 82 } 83 return res; 84 } 85 86 function extend(a, b) { 87 for (var i in b) { 88 if (hasOwnProp(b, i)) { 89 a[i] = b[i]; 90 } 91 } 92 93 if (hasOwnProp(b, 'toString')) { 94 a.toString = b.toString; 95 } 96 97 if (hasOwnProp(b, 'valueOf')) { 98 a.valueOf = b.valueOf; 99 } 100 101 return a; 102 } 103 104 function createUTC(input, format, locale, strict) { 105 return createLocalOrUTC(input, format, locale, strict, true).utc(); 106 } 107 108 function defaultParsingFlags() { 109 // We need to deep clone this object. 110 return { 111 empty: false, 112 unusedTokens: [], 113 unusedInput: [], 114 overflow: -2, 115 charsLeftOver: 0, 116 nullInput: false, 117 invalidEra: null, 118 invalidMonth: null, 119 invalidFormat: false, 120 userInvalidated: false, 121 iso: false, 122 parsedDateParts: [], 123 era: null, 124 meridiem: null, 125 rfc2822: false, 126 weekdayMismatch: false, 127 }; 128 } 129 130 function getParsingFlags(m) { 131 if (m._pf == null) { 132 m._pf = defaultParsingFlags(); 133 } 134 return m._pf; 135 } 136 137 var some; 138 if (Array.prototype.some) { 139 some = Array.prototype.some; 140 } else { 141 some = function (fun) { 142 var t = Object(this), 143 len = t.length >>> 0, 144 i; 145 146 for (i = 0; i < len; i++) { 147 if (i in t && fun.call(this, t[i], i, t)) { 148 return true; 149 } 150 } 151 152 return false; 153 }; 154 } 155 156 function isValid(m) { 157 if (m._isValid == null) { 158 var flags = getParsingFlags(m), 159 parsedParts = some.call(flags.parsedDateParts, function (i) { 160 return i != null; 161 }), 162 isNowValid = 163 !isNaN(m._d.getTime()) && 164 flags.overflow < 0 && 165 !flags.empty && 166 !flags.invalidEra && 167 !flags.invalidMonth && 168 !flags.invalidWeekday && 169 !flags.weekdayMismatch && 170 !flags.nullInput && 171 !flags.invalidFormat && 172 !flags.userInvalidated && 173 (!flags.meridiem || (flags.meridiem && parsedParts)); 174 175 if (m._strict) { 176 isNowValid = 177 isNowValid && 178 flags.charsLeftOver === 0 && 179 flags.unusedTokens.length === 0 && 180 flags.bigHour === undefined; 181 } 182 183 if (Object.isFrozen == null || !Object.isFrozen(m)) { 184 m._isValid = isNowValid; 185 } else { 186 return isNowValid; 187 } 188 } 189 return m._isValid; 190 } 191 192 function createInvalid(flags) { 193 var m = createUTC(NaN); 194 if (flags != null) { 195 extend(getParsingFlags(m), flags); 196 } else { 197 getParsingFlags(m).userInvalidated = true; 198 } 199 200 return m; 201 } 202 203 // Plugins that add properties should also add the key here (null value), 204 // so we can properly clone ourselves. 205 var momentProperties = (hooks.momentProperties = []), 206 updateInProgress = false; 207 208 function copyConfig(to, from) { 209 var i, prop, val; 210 211 if (!isUndefined(from._isAMomentObject)) { 212 to._isAMomentObject = from._isAMomentObject; 213 } 214 if (!isUndefined(from._i)) { 215 to._i = from._i; 216 } 217 if (!isUndefined(from._f)) { 218 to._f = from._f; 219 } 220 if (!isUndefined(from._l)) { 221 to._l = from._l; 222 } 223 if (!isUndefined(from._strict)) { 224 to._strict = from._strict; 225 } 226 if (!isUndefined(from._tzm)) { 227 to._tzm = from._tzm; 228 } 229 if (!isUndefined(from._isUTC)) { 230 to._isUTC = from._isUTC; 231 } 232 if (!isUndefined(from._offset)) { 233 to._offset = from._offset; 234 } 235 if (!isUndefined(from._pf)) { 236 to._pf = getParsingFlags(from); 237 } 238 if (!isUndefined(from._locale)) { 239 to._locale = from._locale; 240 } 241 242 if (momentProperties.length > 0) { 243 for (i = 0; i < momentProperties.length; i++) { 244 prop = momentProperties[i]; 245 val = from[prop]; 246 if (!isUndefined(val)) { 247 to[prop] = val; 248 } 249 } 250 } 251 252 return to; 253 } 254 255 // Moment prototype object 256 function Moment(config) { 257 copyConfig(this, config); 258 this._d = new Date(config._d != null ? config._d.getTime() : NaN); 259 if (!this.isValid()) { 260 this._d = new Date(NaN); 261 } 262 // Prevent infinite loop in case updateOffset creates new moment 263 // objects. 264 if (updateInProgress === false) { 265 updateInProgress = true; 266 hooks.updateOffset(this); 267 updateInProgress = false; 268 } 269 } 270 271 function isMoment(obj) { 272 return ( 273 obj instanceof Moment || (obj != null && obj._isAMomentObject != null) 274 ); 275 } 276 277 function warn(msg) { 278 if ( 279 hooks.suppressDeprecationWarnings === false && 280 typeof console !== 'undefined' && 281 console.warn 282 ) { 283 console.warn('Deprecation warning: ' + msg); 284 } 285 } 286 287 function deprecate(msg, fn) { 288 var firstTime = true; 289 290 return extend(function () { 291 if (hooks.deprecationHandler != null) { 292 hooks.deprecationHandler(null, msg); 293 } 294 if (firstTime) { 295 var args = [], 296 arg, 297 i, 298 key; 299 for (i = 0; i < arguments.length; i++) { 300 arg = ''; 301 if (typeof arguments[i] === 'object') { 302 arg += '\n[' + i + '] '; 303 for (key in arguments[0]) { 304 if (hasOwnProp(arguments[0], key)) { 305 arg += key + ': ' + arguments[0][key] + ', '; 306 } 307 } 308 arg = arg.slice(0, -2); // Remove trailing comma and space 309 } else { 310 arg = arguments[i]; 311 } 312 args.push(arg); 313 } 314 warn( 315 msg + 316 '\nArguments: ' + 317 Array.prototype.slice.call(args).join('') + 318 '\n' + 319 new Error().stack 320 ); 321 firstTime = false; 322 } 323 return fn.apply(this, arguments); 324 }, fn); 325 } 326 327 var deprecations = {}; 328 329 function deprecateSimple(name, msg) { 330 if (hooks.deprecationHandler != null) { 331 hooks.deprecationHandler(name, msg); 332 } 333 if (!deprecations[name]) { 334 warn(msg); 335 deprecations[name] = true; 336 } 337 } 338 339 hooks.suppressDeprecationWarnings = false; 340 hooks.deprecationHandler = null; 341 342 function isFunction(input) { 343 return ( 344 (typeof Function !== 'undefined' && input instanceof Function) || 345 Object.prototype.toString.call(input) === '[object Function]' 346 ); 347 } 348 349 function set(config) { 350 var prop, i; 351 for (i in config) { 352 if (hasOwnProp(config, i)) { 353 prop = config[i]; 354 if (isFunction(prop)) { 355 this[i] = prop; 356 } else { 357 this['_' + i] = prop; 358 } 359 } 360 } 361 this._config = config; 362 // Lenient ordinal parsing accepts just a number in addition to 363 // number + (possibly) stuff coming from _dayOfMonthOrdinalParse. 364 // TODO: Remove "ordinalParse" fallback in next major release. 365 this._dayOfMonthOrdinalParseLenient = new RegExp( 366 (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) + 367 '|' + 368 /\d{1,2}/.source 369 ); 370 } 371 372 function mergeConfigs(parentConfig, childConfig) { 373 var res = extend({}, parentConfig), 374 prop; 375 for (prop in childConfig) { 376 if (hasOwnProp(childConfig, prop)) { 377 if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) { 378 res[prop] = {}; 379 extend(res[prop], parentConfig[prop]); 380 extend(res[prop], childConfig[prop]); 381 } else if (childConfig[prop] != null) { 382 res[prop] = childConfig[prop]; 383 } else { 384 delete res[prop]; 385 } 386 } 387 } 388 for (prop in parentConfig) { 389 if ( 390 hasOwnProp(parentConfig, prop) && 391 !hasOwnProp(childConfig, prop) && 392 isObject(parentConfig[prop]) 393 ) { 394 // make sure changes to properties don't modify parent config 395 res[prop] = extend({}, res[prop]); 396 } 397 } 398 return res; 399 } 400 401 function Locale(config) { 402 if (config != null) { 403 this.set(config); 404 } 405 } 406 407 var keys; 408 409 if (Object.keys) { 410 keys = Object.keys; 411 } else { 412 keys = function (obj) { 413 var i, 414 res = []; 415 for (i in obj) { 416 if (hasOwnProp(obj, i)) { 417 res.push(i); 418 } 419 } 420 return res; 421 }; 422 } 423 424 var defaultCalendar = { 425 sameDay: '[Today at] LT', 426 nextDay: '[Tomorrow at] LT', 427 nextWeek: 'dddd [at] LT', 428 lastDay: '[Yesterday at] LT', 429 lastWeek: '[Last] dddd [at] LT', 430 sameElse: 'L', 431 }; 432 433 function calendar(key, mom, now) { 434 var output = this._calendar[key] || this._calendar['sameElse']; 435 return isFunction(output) ? output.call(mom, now) : output; 436 } 437 438 function zeroFill(number, targetLength, forceSign) { 439 var absNumber = '' + Math.abs(number), 440 zerosToFill = targetLength - absNumber.length, 441 sign = number >= 0; 442 return ( 443 (sign ? (forceSign ? '+' : '') : '-') + 444 Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + 445 absNumber 446 ); 447 } 448 449 var formattingTokens = /(\[[^\[]*\])|(\\)?([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, 450 localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g, 451 formatFunctions = {}, 452 formatTokenFunctions = {}; 453 454 // token: 'M' 455 // padded: ['MM', 2] 456 // ordinal: 'Mo' 457 // callback: function () { this.month() + 1 } 458 function addFormatToken(token, padded, ordinal, callback) { 459 var func = callback; 460 if (typeof callback === 'string') { 461 func = function () { 462 return this[callback](); 463 }; 464 } 465 if (token) { 466 formatTokenFunctions[token] = func; 467 } 468 if (padded) { 469 formatTokenFunctions[padded[0]] = function () { 470 return zeroFill(func.apply(this, arguments), padded[1], padded[2]); 471 }; 472 } 473 if (ordinal) { 474 formatTokenFunctions[ordinal] = function () { 475 return this.localeData().ordinal( 476 func.apply(this, arguments), 477 token 478 ); 479 }; 480 } 481 } 482 483 function removeFormattingTokens(input) { 484 if (input.match(/\[[\s\S]/)) { 485 return input.replace(/^\[|\]$/g, ''); 486 } 487 return input.replace(/\\/g, ''); 488 } 489 490 function makeFormatFunction(format) { 491 var array = format.match(formattingTokens), 492 i, 493 length; 494 495 for (i = 0, length = array.length; i < length; i++) { 496 if (formatTokenFunctions[array[i]]) { 497 array[i] = formatTokenFunctions[array[i]]; 498 } else { 499 array[i] = removeFormattingTokens(array[i]); 500 } 501 } 502 503 return function (mom) { 504 var output = '', 505 i; 506 for (i = 0; i < length; i++) { 507 output += isFunction(array[i]) 508 ? array[i].call(mom, format) 509 : array[i]; 510 } 511 return output; 512 }; 513 } 514 515 // format date using native date object 516 function formatMoment(m, format) { 517 if (!m.isValid()) { 518 return m.localeData().invalidDate(); 519 } 520 521 format = expandFormat(format, m.localeData()); 522 formatFunctions[format] = 523 formatFunctions[format] || makeFormatFunction(format); 524 525 return formatFunctions[format](m); 526 } 527 528 function expandFormat(format, locale) { 529 var i = 5; 530 531 function replaceLongDateFormatTokens(input) { 532 return locale.longDateFormat(input) || input; 533 } 534 535 localFormattingTokens.lastIndex = 0; 536 while (i >= 0 && localFormattingTokens.test(format)) { 537 format = format.replace( 538 localFormattingTokens, 539 replaceLongDateFormatTokens 540 ); 541 localFormattingTokens.lastIndex = 0; 542 i -= 1; 543 } 544 545 return format; 546 } 547 548 var defaultLongDateFormat = { 549 LTS: 'h:mm:ss A', 550 LT: 'h:mm A', 551 L: 'MM/DD/YYYY', 552 LL: 'MMMM D, YYYY', 553 LLL: 'MMMM D, YYYY h:mm A', 554 LLLL: 'dddd, MMMM D, YYYY h:mm A', 555 }; 556 557 function longDateFormat(key) { 558 var format = this._longDateFormat[key], 559 formatUpper = this._longDateFormat[key.toUpperCase()]; 560 561 if (format || !formatUpper) { 562 return format; 563 } 564 565 this._longDateFormat[key] = formatUpper 566 .match(formattingTokens) 567 .map(function (tok) { 568 if ( 569 tok === 'MMMM' || 570 tok === 'MM' || 571 tok === 'DD' || 572 tok === 'dddd' 573 ) { 574 return tok.slice(1); 575 } 576 return tok; 577 }) 578 .join(''); 579 580 return this._longDateFormat[key]; 581 } 582 583 var defaultInvalidDate = 'Invalid date'; 584 585 function invalidDate() { 586 return this._invalidDate; 587 } 588 589 var defaultOrdinal = '%d', 590 defaultDayOfMonthOrdinalParse = /\d{1,2}/; 591 592 function ordinal(number) { 593 return this._ordinal.replace('%d', number); 594 } 595 596 var defaultRelativeTime = { 597 future: 'in %s', 598 past: '%s ago', 599 s: 'a few seconds', 600 ss: '%d seconds', 601 m: 'a minute', 602 mm: '%d minutes', 603 h: 'an hour', 604 hh: '%d hours', 605 d: 'a day', 606 dd: '%d days', 607 w: 'a week', 608 ww: '%d weeks', 609 M: 'a month', 610 MM: '%d months', 611 y: 'a year', 612 yy: '%d years', 613 }; 614 615 function relativeTime(number, withoutSuffix, string, isFuture) { 616 var output = this._relativeTime[string]; 617 return isFunction(output) 618 ? output(number, withoutSuffix, string, isFuture) 619 : output.replace(/%d/i, number); 620 } 621 622 function pastFuture(diff, output) { 623 var format = this._relativeTime[diff > 0 ? 'future' : 'past']; 624 return isFunction(format) ? format(output) : format.replace(/%s/i, output); 625 } 626 627 var aliases = {}; 628 629 function addUnitAlias(unit, shorthand) { 630 var lowerCase = unit.toLowerCase(); 631 aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit; 632 } 633 634 function normalizeUnits(units) { 635 return typeof units === 'string' 636 ? aliases[units] || aliases[units.toLowerCase()] 637 : undefined; 638 } 639 640 function normalizeObjectUnits(inputObject) { 641 var normalizedInput = {}, 642 normalizedProp, 643 prop; 644 645 for (prop in inputObject) { 646 if (hasOwnProp(inputObject, prop)) { 647 normalizedProp = normalizeUnits(prop); 648 if (normalizedProp) { 649 normalizedInput[normalizedProp] = inputObject[prop]; 650 } 651 } 652 } 653 654 return normalizedInput; 655 } 656 657 var priorities = {}; 658 659 function addUnitPriority(unit, priority) { 660 priorities[unit] = priority; 661 } 662 663 function getPrioritizedUnits(unitsObj) { 664 var units = [], 665 u; 666 for (u in unitsObj) { 667 if (hasOwnProp(unitsObj, u)) { 668 units.push({ unit: u, priority: priorities[u] }); 669 } 670 } 671 units.sort(function (a, b) { 672 return a.priority - b.priority; 673 }); 674 return units; 675 } 676 677 function isLeapYear(year) { 678 return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0; 679 } 680 681 function absFloor(number) { 682 if (number < 0) { 683 // -0 -> 0 684 return Math.ceil(number) || 0; 685 } else { 686 return Math.floor(number); 687 } 688 } 689 690 function toInt(argumentForCoercion) { 691 var coercedNumber = +argumentForCoercion, 692 value = 0; 693 694 if (coercedNumber !== 0 && isFinite(coercedNumber)) { 695 value = absFloor(coercedNumber); 696 } 697 698 return value; 699 } 700 701 function makeGetSet(unit, keepTime) { 702 return function (value) { 703 if (value != null) { 704 set$1(this, unit, value); 705 hooks.updateOffset(this, keepTime); 706 return this; 707 } else { 708 return get(this, unit); 709 } 710 }; 711 } 712 713 function get(mom, unit) { 714 return mom.isValid() 715 ? mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() 716 : NaN; 717 } 718 719 function set$1(mom, unit, value) { 720 if (mom.isValid() && !isNaN(value)) { 721 if ( 722 unit === 'FullYear' && 723 isLeapYear(mom.year()) && 724 mom.month() === 1 && 725 mom.date() === 29 726 ) { 727 value = toInt(value); 728 mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit]( 729 value, 730 mom.month(), 731 daysInMonth(value, mom.month()) 732 ); 733 } else { 734 mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value); 735 } 736 } 737 } 738 739 // MOMENTS 740 741 function stringGet(units) { 742 units = normalizeUnits(units); 743 if (isFunction(this[units])) { 744 return this[units](); 745 } 746 return this; 747 } 748 749 function stringSet(units, value) { 750 if (typeof units === 'object') { 751 units = normalizeObjectUnits(units); 752 var prioritized = getPrioritizedUnits(units), 753 i; 754 for (i = 0; i < prioritized.length; i++) { 755 this[prioritized[i].unit](units[prioritized[i].unit]); 756 } 757 } else { 758 units = normalizeUnits(units); 759 if (isFunction(this[units])) { 760 return this[units](value); 761 } 762 } 763 return this; 764 } 765 766 var match1 = /\d/, // 0 - 9 767 match2 = /\d\d/, // 00 - 99 768 match3 = /\d{3}/, // 000 - 999 769 match4 = /\d{4}/, // 0000 - 9999 770 match6 = /[+-]?\d{6}/, // -999999 - 999999 771 match1to2 = /\d\d?/, // 0 - 99 772 match3to4 = /\d\d\d\d?/, // 999 - 9999 773 match5to6 = /\d\d\d\d\d\d?/, // 99999 - 999999 774 match1to3 = /\d{1,3}/, // 0 - 999 775 match1to4 = /\d{1,4}/, // 0 - 9999 776 match1to6 = /[+-]?\d{1,6}/, // -999999 - 999999 777 matchUnsigned = /\d+/, // 0 - inf 778 matchSigned = /[+-]?\d+/, // -inf - inf 779 matchOffset = /Z|[+-]\d\d:?\d\d/gi, // +00:00 -00:00 +0000 -0000 or Z 780 matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi, // +00 -00 +00:00 -00:00 +0000 -0000 or Z 781 matchTimestamp = /[+-]?\d+(\.\d{1,3})?/, // 123456789 123456789.123 782 // any word (or two) characters or numbers including two/three word month in arabic. 783 // includes scottish gaelic two word and hyphenated months 784 matchWord = /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i, 785 regexes; 786 787 regexes = {}; 788 789 function addRegexToken(token, regex, strictRegex) { 790 regexes[token] = isFunction(regex) 791 ? regex 792 : function (isStrict, localeData) { 793 return isStrict && strictRegex ? strictRegex : regex; 794 }; 795 } 796 797 function getParseRegexForToken(token, config) { 798 if (!hasOwnProp(regexes, token)) { 799 return new RegExp(unescapeFormat(token)); 800 } 801 802 return regexes[token](config._strict, config._locale); 803 } 804 805 // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript 806 function unescapeFormat(s) { 807 return regexEscape( 808 s 809 .replace('\\', '') 810 .replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function ( 811 matched, 812 p1, 813 p2, 814 p3, 815 p4 816 ) { 817 return p1 || p2 || p3 || p4; 818 }) 819 ); 820 } 821 822 function regexEscape(s) { 823 return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'); 824 } 825 826 var tokens = {}; 827 828 function addParseToken(token, callback) { 829 var i, 830 func = callback; 831 if (typeof token === 'string') { 832 token = [token]; 833 } 834 if (isNumber(callback)) { 835 func = function (input, array) { 836 array[callback] = toInt(input); 837 }; 838 } 839 for (i = 0; i < token.length; i++) { 840 tokens[token[i]] = func; 841 } 842 } 843 844 function addWeekParseToken(token, callback) { 845 addParseToken(token, function (input, array, config, token) { 846 config._w = config._w || {}; 847 callback(input, config._w, config, token); 848 }); 849 } 850 851 function addTimeToArrayFromToken(token, input, config) { 852 if (input != null && hasOwnProp(tokens, token)) { 853 tokens[token](input, config._a, config, token); 854 } 855 } 856 857 var YEAR = 0, 858 MONTH = 1, 859 DATE = 2, 860 HOUR = 3, 861 MINUTE = 4, 862 SECOND = 5, 863 MILLISECOND = 6, 864 WEEK = 7, 865 WEEKDAY = 8; 866 867 function mod(n, x) { 868 return ((n % x) + x) % x; 869 } 870 871 var indexOf; 872 873 if (Array.prototype.indexOf) { 874 indexOf = Array.prototype.indexOf; 875 } else { 876 indexOf = function (o) { 877 // I know 878 var i; 879 for (i = 0; i < this.length; ++i) { 880 if (this[i] === o) { 881 return i; 882 } 883 } 884 return -1; 885 }; 886 } 887 888 function daysInMonth(year, month) { 889 if (isNaN(year) || isNaN(month)) { 890 return NaN; 891 } 892 var modMonth = mod(month, 12); 893 year += (month - modMonth) / 12; 894 return modMonth === 1 895 ? isLeapYear(year) 896 ? 29 897 : 28 898 : 31 - ((modMonth % 7) % 2); 899 } 900 901 // FORMATTING 902 903 addFormatToken('M', ['MM', 2], 'Mo', function () { 904 return this.month() + 1; 905 }); 906 907 addFormatToken('MMM', 0, 0, function (format) { 908 return this.localeData().monthsShort(this, format); 909 }); 910 911 addFormatToken('MMMM', 0, 0, function (format) { 912 return this.localeData().months(this, format); 913 }); 914 915 // ALIASES 916 917 addUnitAlias('month', 'M'); 918 919 // PRIORITY 920 921 addUnitPriority('month', 8); 922 923 // PARSING 924 925 addRegexToken('M', match1to2); 926 addRegexToken('MM', match1to2, match2); 927 addRegexToken('MMM', function (isStrict, locale) { 928 return locale.monthsShortRegex(isStrict); 929 }); 930 addRegexToken('MMMM', function (isStrict, locale) { 931 return locale.monthsRegex(isStrict); 932 }); 933 934 addParseToken(['M', 'MM'], function (input, array) { 935 array[MONTH] = toInt(input) - 1; 936 }); 937 938 addParseToken(['MMM', 'MMMM'], function (input, array, config, token) { 939 var month = config._locale.monthsParse(input, token, config._strict); 940 // if we didn't find a month name, mark the date as invalid. 941 if (month != null) { 942 array[MONTH] = month; 943 } else { 944 getParsingFlags(config).invalidMonth = input; 945 } 946 }); 947 948 // LOCALES 949 950 var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split( 951 '_' 952 ), 953 defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split( 954 '_' 955 ), 956 MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/, 957 defaultMonthsShortRegex = matchWord, 958 defaultMonthsRegex = matchWord; 959 960 function localeMonths(m, format) { 961 if (!m) { 962 return isArray(this._months) 963 ? this._months 964 : this._months['standalone']; 965 } 966 return isArray(this._months) 967 ? this._months[m.month()] 968 : this._months[ 969 (this._months.isFormat || MONTHS_IN_FORMAT).test(format) 970 ? 'format' 971 : 'standalone' 972 ][m.month()]; 973 } 974 975 function localeMonthsShort(m, format) { 976 if (!m) { 977 return isArray(this._monthsShort) 978 ? this._monthsShort 979 : this._monthsShort['standalone']; 980 } 981 return isArray(this._monthsShort) 982 ? this._monthsShort[m.month()] 983 : this._monthsShort[ 984 MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone' 985 ][m.month()]; 986 } 987 988 function handleStrictParse(monthName, format, strict) { 989 var i, 990 ii, 991 mom, 992 llc = monthName.toLocaleLowerCase(); 993 if (!this._monthsParse) { 994 // this is not used 995 this._monthsParse = []; 996 this._longMonthsParse = []; 997 this._shortMonthsParse = []; 998 for (i = 0; i < 12; ++i) { 999 mom = createUTC([2000, i]); 1000 this._shortMonthsParse[i] = this.monthsShort( 1001 mom, 1002 '' 1003 ).toLocaleLowerCase(); 1004 this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase(); 1005 } 1006 } 1007 1008 if (strict) { 1009 if (format === 'MMM') { 1010 ii = indexOf.call(this._shortMonthsParse, llc); 1011 return ii !== -1 ? ii : null; 1012 } else { 1013 ii = indexOf.call(this._longMonthsParse, llc); 1014 return ii !== -1 ? ii : null; 1015 } 1016 } else { 1017 if (format === 'MMM') { 1018 ii = indexOf.call(this._shortMonthsParse, llc); 1019 if (ii !== -1) { 1020 return ii; 1021 } 1022 ii = indexOf.call(this._longMonthsParse, llc); 1023 return ii !== -1 ? ii : null; 1024 } else { 1025 ii = indexOf.call(this._longMonthsParse, llc); 1026 if (ii !== -1) { 1027 return ii; 1028 } 1029 ii = indexOf.call(this._shortMonthsParse, llc); 1030 return ii !== -1 ? ii : null; 1031 } 1032 } 1033 } 1034 1035 function localeMonthsParse(monthName, format, strict) { 1036 var i, mom, regex; 1037 1038 if (this._monthsParseExact) { 1039 return handleStrictParse.call(this, monthName, format, strict); 1040 } 1041 1042 if (!this._monthsParse) { 1043 this._monthsParse = []; 1044 this._longMonthsParse = []; 1045 this._shortMonthsParse = []; 1046 } 1047 1048 // TODO: add sorting 1049 // Sorting makes sure if one month (or abbr) is a prefix of another 1050 // see sorting in computeMonthsParse 1051 for (i = 0; i < 12; i++) { 1052 // make the regex if we don't have it already 1053 mom = createUTC([2000, i]); 1054 if (strict && !this._longMonthsParse[i]) { 1055 this._longMonthsParse[i] = new RegExp( 1056 '^' + this.months(mom, '').replace('.', '') + '$', 1057 'i' 1058 ); 1059 this._shortMonthsParse[i] = new RegExp( 1060 '^' + this.monthsShort(mom, '').replace('.', '') + '$', 1061 'i' 1062 ); 1063 } 1064 if (!strict && !this._monthsParse[i]) { 1065 regex = 1066 '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, ''); 1067 this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i'); 1068 } 1069 // test the regex 1070 if ( 1071 strict && 1072 format === 'MMMM' && 1073 this._longMonthsParse[i].test(monthName) 1074 ) { 1075 return i; 1076 } else if ( 1077 strict && 1078 format === 'MMM' && 1079 this._shortMonthsParse[i].test(monthName) 1080 ) { 1081 return i; 1082 } else if (!strict && this._monthsParse[i].test(monthName)) { 1083 return i; 1084 } 1085 } 1086 } 1087 1088 // MOMENTS 1089 1090 function setMonth(mom, value) { 1091 var dayOfMonth; 1092 1093 if (!mom.isValid()) { 1094 // No op 1095 return mom; 1096 } 1097 1098 if (typeof value === 'string') { 1099 if (/^\d+$/.test(value)) { 1100 value = toInt(value); 1101 } else { 1102 value = mom.localeData().monthsParse(value); 1103 // TODO: Another silent failure? 1104 if (!isNumber(value)) { 1105 return mom; 1106 } 1107 } 1108 } 1109 1110 dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value)); 1111 mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth); 1112 return mom; 1113 } 1114 1115 function getSetMonth(value) { 1116 if (value != null) { 1117 setMonth(this, value); 1118 hooks.updateOffset(this, true); 1119 return this; 1120 } else { 1121 return get(this, 'Month'); 1122 } 1123 } 1124 1125 function getDaysInMonth() { 1126 return daysInMonth(this.year(), this.month()); 1127 } 1128 1129 function monthsShortRegex(isStrict) { 1130 if (this._monthsParseExact) { 1131 if (!hasOwnProp(this, '_monthsRegex')) { 1132 computeMonthsParse.call(this); 1133 } 1134 if (isStrict) { 1135 return this._monthsShortStrictRegex; 1136 } else { 1137 return this._monthsShortRegex; 1138 } 1139 } else { 1140 if (!hasOwnProp(this, '_monthsShortRegex')) { 1141 this._monthsShortRegex = defaultMonthsShortRegex; 1142 } 1143 return this._monthsShortStrictRegex && isStrict 1144 ? this._monthsShortStrictRegex 1145 : this._monthsShortRegex; 1146 } 1147 } 1148 1149 function monthsRegex(isStrict) { 1150 if (this._monthsParseExact) { 1151 if (!hasOwnProp(this, '_monthsRegex')) { 1152 computeMonthsParse.call(this); 1153 } 1154 if (isStrict) { 1155 return this._monthsStrictRegex; 1156 } else { 1157 return this._monthsRegex; 1158 } 1159 } else { 1160 if (!hasOwnProp(this, '_monthsRegex')) { 1161 this._monthsRegex = defaultMonthsRegex; 1162 } 1163 return this._monthsStrictRegex && isStrict 1164 ? this._monthsStrictRegex 1165 : this._monthsRegex; 1166 } 1167 } 1168 1169 function computeMonthsParse() { 1170 function cmpLenRev(a, b) { 1171 return b.length - a.length; 1172 } 1173 1174 var shortPieces = [], 1175 longPieces = [], 1176 mixedPieces = [], 1177 i, 1178 mom; 1179 for (i = 0; i < 12; i++) { 1180 // make the regex if we don't have it already 1181 mom = createUTC([2000, i]); 1182 shortPieces.push(this.monthsShort(mom, '')); 1183 longPieces.push(this.months(mom, '')); 1184 mixedPieces.push(this.months(mom, '')); 1185 mixedPieces.push(this.monthsShort(mom, '')); 1186 } 1187 // Sorting makes sure if one month (or abbr) is a prefix of another it 1188 // will match the longer piece. 1189 shortPieces.sort(cmpLenRev); 1190 longPieces.sort(cmpLenRev); 1191 mixedPieces.sort(cmpLenRev); 1192 for (i = 0; i < 12; i++) { 1193 shortPieces[i] = regexEscape(shortPieces[i]); 1194 longPieces[i] = regexEscape(longPieces[i]); 1195 } 1196 for (i = 0; i < 24; i++) { 1197 mixedPieces[i] = regexEscape(mixedPieces[i]); 1198 } 1199 1200 this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i'); 1201 this._monthsShortRegex = this._monthsRegex; 1202 this._monthsStrictRegex = new RegExp( 1203 '^(' + longPieces.join('|') + ')', 1204 'i' 1205 ); 1206 this._monthsShortStrictRegex = new RegExp( 1207 '^(' + shortPieces.join('|') + ')', 1208 'i' 1209 ); 1210 } 1211 1212 // FORMATTING 1213 1214 addFormatToken('Y', 0, 0, function () { 1215 var y = this.year(); 1216 return y <= 9999 ? zeroFill(y, 4) : '+' + y; 1217 }); 1218 1219 addFormatToken(0, ['YY', 2], 0, function () { 1220 return this.year() % 100; 1221 }); 1222 1223 addFormatToken(0, ['YYYY', 4], 0, 'year'); 1224 addFormatToken(0, ['YYYYY', 5], 0, 'year'); 1225 addFormatToken(0, ['YYYYYY', 6, true], 0, 'year'); 1226 1227 // ALIASES 1228 1229 addUnitAlias('year', 'y'); 1230 1231 // PRIORITIES 1232 1233 addUnitPriority('year', 1); 1234 1235 // PARSING 1236 1237 addRegexToken('Y', matchSigned); 1238 addRegexToken('YY', match1to2, match2); 1239 addRegexToken('YYYY', match1to4, match4); 1240 addRegexToken('YYYYY', match1to6, match6); 1241 addRegexToken('YYYYYY', match1to6, match6); 1242 1243 addParseToken(['YYYYY', 'YYYYYY'], YEAR); 1244 addParseToken('YYYY', function (input, array) { 1245 array[YEAR] = 1246 input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input); 1247 }); 1248 addParseToken('YY', function (input, array) { 1249 array[YEAR] = hooks.parseTwoDigitYear(input); 1250 }); 1251 addParseToken('Y', function (input, array) { 1252 array[YEAR] = parseInt(input, 10); 1253 }); 1254 1255 // HELPERS 1256 1257 function daysInYear(year) { 1258 return isLeapYear(year) ? 366 : 365; 1259 } 1260 1261 // HOOKS 1262 1263 hooks.parseTwoDigitYear = function (input) { 1264 return toInt(input) + (toInt(input) > 68 ? 1900 : 2000); 1265 }; 1266 1267 // MOMENTS 1268 1269 var getSetYear = makeGetSet('FullYear', true); 1270 1271 function getIsLeapYear() { 1272 return isLeapYear(this.year()); 1273 } 1274 1275 function createDate(y, m, d, h, M, s, ms) { 1276 // can't just apply() to create a date: 1277 // https://stackoverflow.com/q/181348 1278 var date; 1279 // the date constructor remaps years 0-99 to 1900-1999 1280 if (y < 100 && y >= 0) { 1281 // preserve leap years using a full 400 year cycle, then reset 1282 date = new Date(y + 400, m, d, h, M, s, ms); 1283 if (isFinite(date.getFullYear())) { 1284 date.setFullYear(y); 1285 } 1286 } else { 1287 date = new Date(y, m, d, h, M, s, ms); 1288 } 1289 1290 return date; 1291 } 1292 1293 function createUTCDate(y) { 1294 var date, args; 1295 // the Date.UTC function remaps years 0-99 to 1900-1999 1296 if (y < 100 && y >= 0) { 1297 args = Array.prototype.slice.call(arguments); 1298 // preserve leap years using a full 400 year cycle, then reset 1299 args[0] = y + 400; 1300 date = new Date(Date.UTC.apply(null, args)); 1301 if (isFinite(date.getUTCFullYear())) { 1302 date.setUTCFullYear(y); 1303 } 1304 } else { 1305 date = new Date(Date.UTC.apply(null, arguments)); 1306 } 1307 1308 return date; 1309 } 1310 1311 // start-of-first-week - start-of-year 1312 function firstWeekOffset(year, dow, doy) { 1313 var // first-week day -- which january is always in the first week (4 for iso, 1 for other) 1314 fwd = 7 + dow - doy, 1315 // first-week day local weekday -- which local weekday is fwd 1316 fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7; 1317 1318 return -fwdlw + fwd - 1; 1319 } 1320 1321 // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday 1322 function dayOfYearFromWeeks(year, week, weekday, dow, doy) { 1323 var localWeekday = (7 + weekday - dow) % 7, 1324 weekOffset = firstWeekOffset(year, dow, doy), 1325 dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset, 1326 resYear, 1327 resDayOfYear; 1328 1329 if (dayOfYear <= 0) { 1330 resYear = year - 1; 1331 resDayOfYear = daysInYear(resYear) + dayOfYear; 1332 } else if (dayOfYear > daysInYear(year)) { 1333 resYear = year + 1; 1334 resDayOfYear = dayOfYear - daysInYear(year); 1335 } else { 1336 resYear = year; 1337 resDayOfYear = dayOfYear; 1338 } 1339 1340 return { 1341 year: resYear, 1342 dayOfYear: resDayOfYear, 1343 }; 1344 } 1345 1346 function weekOfYear(mom, dow, doy) { 1347 var weekOffset = firstWeekOffset(mom.year(), dow, doy), 1348 week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1, 1349 resWeek, 1350 resYear; 1351 1352 if (week < 1) { 1353 resYear = mom.year() - 1; 1354 resWeek = week + weeksInYear(resYear, dow, doy); 1355 } else if (week > weeksInYear(mom.year(), dow, doy)) { 1356 resWeek = week - weeksInYear(mom.year(), dow, doy); 1357 resYear = mom.year() + 1; 1358 } else { 1359 resYear = mom.year(); 1360 resWeek = week; 1361 } 1362 1363 return { 1364 week: resWeek, 1365 year: resYear, 1366 }; 1367 } 1368 1369 function weeksInYear(year, dow, doy) { 1370 var weekOffset = firstWeekOffset(year, dow, doy), 1371 weekOffsetNext = firstWeekOffset(year + 1, dow, doy); 1372 return (daysInYear(year) - weekOffset + weekOffsetNext) / 7; 1373 } 1374 1375 // FORMATTING 1376 1377 addFormatToken('w', ['ww', 2], 'wo', 'week'); 1378 addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek'); 1379 1380 // ALIASES 1381 1382 addUnitAlias('week', 'w'); 1383 addUnitAlias('isoWeek', 'W'); 1384 1385 // PRIORITIES 1386 1387 addUnitPriority('week', 5); 1388 addUnitPriority('isoWeek', 5); 1389 1390 // PARSING 1391 1392 addRegexToken('w', match1to2); 1393 addRegexToken('ww', match1to2, match2); 1394 addRegexToken('W', match1to2); 1395 addRegexToken('WW', match1to2, match2); 1396 1397 addWeekParseToken(['w', 'ww', 'W', 'WW'], function ( 1398 input, 1399 week, 1400 config, 1401 token 1402 ) { 1403 week[token.substr(0, 1)] = toInt(input); 1404 }); 1405 1406 // HELPERS 1407 1408 // LOCALES 1409 1410 function localeWeek(mom) { 1411 return weekOfYear(mom, this._week.dow, this._week.doy).week; 1412 } 1413 1414 var defaultLocaleWeek = { 1415 dow: 0, // Sunday is the first day of the week. 1416 doy: 6, // The week that contains Jan 6th is the first week of the year. 1417 }; 1418 1419 function localeFirstDayOfWeek() { 1420 return this._week.dow; 1421 } 1422 1423 function localeFirstDayOfYear() { 1424 return this._week.doy; 1425 } 1426 1427 // MOMENTS 1428 1429 function getSetWeek(input) { 1430 var week = this.localeData().week(this); 1431 return input == null ? week : this.add((input - week) * 7, 'd'); 1432 } 1433 1434 function getSetISOWeek(input) { 1435 var week = weekOfYear(this, 1, 4).week; 1436 return input == null ? week : this.add((input - week) * 7, 'd'); 1437 } 1438 1439 // FORMATTING 1440 1441 addFormatToken('d', 0, 'do', 'day'); 1442 1443 addFormatToken('dd', 0, 0, function (format) { 1444 return this.localeData().weekdaysMin(this, format); 1445 }); 1446 1447 addFormatToken('ddd', 0, 0, function (format) { 1448 return this.localeData().weekdaysShort(this, format); 1449 }); 1450 1451 addFormatToken('dddd', 0, 0, function (format) { 1452 return this.localeData().weekdays(this, format); 1453 }); 1454 1455 addFormatToken('e', 0, 0, 'weekday'); 1456 addFormatToken('E', 0, 0, 'isoWeekday'); 1457 1458 // ALIASES 1459 1460 addUnitAlias('day', 'd'); 1461 addUnitAlias('weekday', 'e'); 1462 addUnitAlias('isoWeekday', 'E'); 1463 1464 // PRIORITY 1465 addUnitPriority('day', 11); 1466 addUnitPriority('weekday', 11); 1467 addUnitPriority('isoWeekday', 11); 1468 1469 // PARSING 1470 1471 addRegexToken('d', match1to2); 1472 addRegexToken('e', match1to2); 1473 addRegexToken('E', match1to2); 1474 addRegexToken('dd', function (isStrict, locale) { 1475 return locale.weekdaysMinRegex(isStrict); 1476 }); 1477 addRegexToken('ddd', function (isStrict, locale) { 1478 return locale.weekdaysShortRegex(isStrict); 1479 }); 1480 addRegexToken('dddd', function (isStrict, locale) { 1481 return locale.weekdaysRegex(isStrict); 1482 }); 1483 1484 addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) { 1485 var weekday = config._locale.weekdaysParse(input, token, config._strict); 1486 // if we didn't get a weekday name, mark the date as invalid 1487 if (weekday != null) { 1488 week.d = weekday; 1489 } else { 1490 getParsingFlags(config).invalidWeekday = input; 1491 } 1492 }); 1493 1494 addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) { 1495 week[token] = toInt(input); 1496 }); 1497 1498 // HELPERS 1499 1500 function parseWeekday(input, locale) { 1501 if (typeof input !== 'string') { 1502 return input; 1503 } 1504 1505 if (!isNaN(input)) { 1506 return parseInt(input, 10); 1507 } 1508 1509 input = locale.weekdaysParse(input); 1510 if (typeof input === 'number') { 1511 return input; 1512 } 1513 1514 return null; 1515 } 1516 1517 function parseIsoWeekday(input, locale) { 1518 if (typeof input === 'string') { 1519 return locale.weekdaysParse(input) % 7 || 7; 1520 } 1521 return isNaN(input) ? null : input; 1522 } 1523 1524 // LOCALES 1525 function shiftWeekdays(ws, n) { 1526 return ws.slice(n, 7).concat(ws.slice(0, n)); 1527 } 1528 1529 var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split( 1530 '_' 1531 ), 1532 defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'), 1533 defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'), 1534 defaultWeekdaysRegex = matchWord, 1535 defaultWeekdaysShortRegex = matchWord, 1536 defaultWeekdaysMinRegex = matchWord; 1537 1538 function localeWeekdays(m, format) { 1539 var weekdays = isArray(this._weekdays) 1540 ? this._weekdays 1541 : this._weekdays[ 1542 m && m !== true && this._weekdays.isFormat.test(format) 1543 ? 'format' 1544 : 'standalone' 1545 ]; 1546 return m === true 1547 ? shiftWeekdays(weekdays, this._week.dow) 1548 : m 1549 ? weekdays[m.day()] 1550 : weekdays; 1551 } 1552 1553 function localeWeekdaysShort(m) { 1554 return m === true 1555 ? shiftWeekdays(this._weekdaysShort, this._week.dow) 1556 : m 1557 ? this._weekdaysShort[m.day()] 1558 : this._weekdaysShort; 1559 } 1560 1561 function localeWeekdaysMin(m) { 1562 return m === true 1563 ? shiftWeekdays(this._weekdaysMin, this._week.dow) 1564 : m 1565 ? this._weekdaysMin[m.day()] 1566 : this._weekdaysMin; 1567 } 1568 1569 function handleStrictParse$1(weekdayName, format, strict) { 1570 var i, 1571 ii, 1572 mom, 1573 llc = weekdayName.toLocaleLowerCase(); 1574 if (!this._weekdaysParse) { 1575 this._weekdaysParse = []; 1576 this._shortWeekdaysParse = []; 1577 this._minWeekdaysParse = []; 1578 1579 for (i = 0; i < 7; ++i) { 1580 mom = createUTC([2000, 1]).day(i); 1581 this._minWeekdaysParse[i] = this.weekdaysMin( 1582 mom, 1583 '' 1584 ).toLocaleLowerCase(); 1585 this._shortWeekdaysParse[i] = this.weekdaysShort( 1586 mom, 1587 '' 1588 ).toLocaleLowerCase(); 1589 this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase(); 1590 } 1591 } 1592 1593 if (strict) { 1594 if (format === 'dddd') { 1595 ii = indexOf.call(this._weekdaysParse, llc); 1596 return ii !== -1 ? ii : null; 1597 } else if (format === 'ddd') { 1598 ii = indexOf.call(this._shortWeekdaysParse, llc); 1599 return ii !== -1 ? ii : null; 1600 } else { 1601 ii = indexOf.call(this._minWeekdaysParse, llc); 1602 return ii !== -1 ? ii : null; 1603 } 1604 } else { 1605 if (format === 'dddd') { 1606 ii = indexOf.call(this._weekdaysParse, llc); 1607 if (ii !== -1) { 1608 return ii; 1609 } 1610 ii = indexOf.call(this._shortWeekdaysParse, llc); 1611 if (ii !== -1) { 1612 return ii; 1613 } 1614 ii = indexOf.call(this._minWeekdaysParse, llc); 1615 return ii !== -1 ? ii : null; 1616 } else if (format === 'ddd') { 1617 ii = indexOf.call(this._shortWeekdaysParse, llc); 1618 if (ii !== -1) { 1619 return ii; 1620 } 1621 ii = indexOf.call(this._weekdaysParse, llc); 1622 if (ii !== -1) { 1623 return ii; 1624 } 1625 ii = indexOf.call(this._minWeekdaysParse, llc); 1626 return ii !== -1 ? ii : null; 1627 } else { 1628 ii = indexOf.call(this._minWeekdaysParse, llc); 1629 if (ii !== -1) { 1630 return ii; 1631 } 1632 ii = indexOf.call(this._weekdaysParse, llc); 1633 if (ii !== -1) { 1634 return ii; 1635 } 1636 ii = indexOf.call(this._shortWeekdaysParse, llc); 1637 return ii !== -1 ? ii : null; 1638 } 1639 } 1640 } 1641 1642 function localeWeekdaysParse(weekdayName, format, strict) { 1643 var i, mom, regex; 1644 1645 if (this._weekdaysParseExact) { 1646 return handleStrictParse$1.call(this, weekdayName, format, strict); 1647 } 1648 1649 if (!this._weekdaysParse) { 1650 this._weekdaysParse = []; 1651 this._minWeekdaysParse = []; 1652 this._shortWeekdaysParse = []; 1653 this._fullWeekdaysParse = []; 1654 } 1655 1656 for (i = 0; i < 7; i++) { 1657 // make the regex if we don't have it already 1658 1659 mom = createUTC([2000, 1]).day(i); 1660 if (strict && !this._fullWeekdaysParse[i]) { 1661 this._fullWeekdaysParse[i] = new RegExp( 1662 '^' + this.weekdays(mom, '').replace('.', '\\.?') + '$', 1663 'i' 1664 ); 1665 this._shortWeekdaysParse[i] = new RegExp( 1666 '^' + this.weekdaysShort(mom, '').replace('.', '\\.?') + '$', 1667 'i' 1668 ); 1669 this._minWeekdaysParse[i] = new RegExp( 1670 '^' + this.weekdaysMin(mom, '').replace('.', '\\.?') + '$', 1671 'i' 1672 ); 1673 } 1674 if (!this._weekdaysParse[i]) { 1675 regex = 1676 '^' + 1677 this.weekdays(mom, '') + 1678 '|^' + 1679 this.weekdaysShort(mom, '') + 1680 '|^' + 1681 this.weekdaysMin(mom, ''); 1682 this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i'); 1683 } 1684 // test the regex 1685 if ( 1686 strict && 1687 format === 'dddd' && 1688 this._fullWeekdaysParse[i].test(weekdayName) 1689 ) { 1690 return i; 1691 } else if ( 1692 strict && 1693 format === 'ddd' && 1694 this._shortWeekdaysParse[i].test(weekdayName) 1695 ) { 1696 return i; 1697 } else if ( 1698 strict && 1699 format === 'dd' && 1700 this._minWeekdaysParse[i].test(weekdayName) 1701 ) { 1702 return i; 1703 } else if (!strict && this._weekdaysParse[i].test(weekdayName)) { 1704 return i; 1705 } 1706 } 1707 } 1708 1709 // MOMENTS 1710 1711 function getSetDayOfWeek(input) { 1712 if (!this.isValid()) { 1713 return input != null ? this : NaN; 1714 } 1715 var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay(); 1716 if (input != null) { 1717 input = parseWeekday(input, this.localeData()); 1718 return this.add(input - day, 'd'); 1719 } else { 1720 return day; 1721 } 1722 } 1723 1724 function getSetLocaleDayOfWeek(input) { 1725 if (!this.isValid()) { 1726 return input != null ? this : NaN; 1727 } 1728 var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7; 1729 return input == null ? weekday : this.add(input - weekday, 'd'); 1730 } 1731 1732 function getSetISODayOfWeek(input) { 1733 if (!this.isValid()) { 1734 return input != null ? this : NaN; 1735 } 1736 1737 // behaves the same as moment#day except 1738 // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6) 1739 // as a setter, sunday should belong to the previous week. 1740 1741 if (input != null) { 1742 var weekday = parseIsoWeekday(input, this.localeData()); 1743 return this.day(this.day() % 7 ? weekday : weekday - 7); 1744 } else { 1745 return this.day() || 7; 1746 } 1747 } 1748 1749 function weekdaysRegex(isStrict) { 1750 if (this._weekdaysParseExact) { 1751 if (!hasOwnProp(this, '_weekdaysRegex')) { 1752 computeWeekdaysParse.call(this); 1753 } 1754 if (isStrict) { 1755 return this._weekdaysStrictRegex; 1756 } else { 1757 return this._weekdaysRegex; 1758 } 1759 } else { 1760 if (!hasOwnProp(this, '_weekdaysRegex')) { 1761 this._weekdaysRegex = defaultWeekdaysRegex; 1762 } 1763 return this._weekdaysStrictRegex && isStrict 1764 ? this._weekdaysStrictRegex 1765 : this._weekdaysRegex; 1766 } 1767 } 1768 1769 function weekdaysShortRegex(isStrict) { 1770 if (this._weekdaysParseExact) { 1771 if (!hasOwnProp(this, '_weekdaysRegex')) { 1772 computeWeekdaysParse.call(this); 1773 } 1774 if (isStrict) { 1775 return this._weekdaysShortStrictRegex; 1776 } else { 1777 return this._weekdaysShortRegex; 1778 } 1779 } else { 1780 if (!hasOwnProp(this, '_weekdaysShortRegex')) { 1781 this._weekdaysShortRegex = defaultWeekdaysShortRegex; 1782 } 1783 return this._weekdaysShortStrictRegex && isStrict 1784 ? this._weekdaysShortStrictRegex 1785 : this._weekdaysShortRegex; 1786 } 1787 } 1788 1789 function weekdaysMinRegex(isStrict) { 1790 if (this._weekdaysParseExact) { 1791 if (!hasOwnProp(this, '_weekdaysRegex')) { 1792 computeWeekdaysParse.call(this); 1793 } 1794 if (isStrict) { 1795 return this._weekdaysMinStrictRegex; 1796 } else { 1797 return this._weekdaysMinRegex; 1798 } 1799 } else { 1800 if (!hasOwnProp(this, '_weekdaysMinRegex')) { 1801 this._weekdaysMinRegex = defaultWeekdaysMinRegex; 1802 } 1803 return this._weekdaysMinStrictRegex && isStrict 1804 ? this._weekdaysMinStrictRegex 1805 : this._weekdaysMinRegex; 1806 } 1807 } 1808 1809 function computeWeekdaysParse() { 1810 function cmpLenRev(a, b) { 1811 return b.length - a.length; 1812 } 1813 1814 var minPieces = [], 1815 shortPieces = [], 1816 longPieces = [], 1817 mixedPieces = [], 1818 i, 1819 mom, 1820 minp, 1821 shortp, 1822 longp; 1823 for (i = 0; i < 7; i++) { 1824 // make the regex if we don't have it already 1825 mom = createUTC([2000, 1]).day(i); 1826 minp = regexEscape(this.weekdaysMin(mom, '')); 1827 shortp = regexEscape(this.weekdaysShort(mom, '')); 1828 longp = regexEscape(this.weekdays(mom, '')); 1829 minPieces.push(minp); 1830 shortPieces.push(shortp); 1831 longPieces.push(longp); 1832 mixedPieces.push(minp); 1833 mixedPieces.push(shortp); 1834 mixedPieces.push(longp); 1835 } 1836 // Sorting makes sure if one weekday (or abbr) is a prefix of another it 1837 // will match the longer piece. 1838 minPieces.sort(cmpLenRev); 1839 shortPieces.sort(cmpLenRev); 1840 longPieces.sort(cmpLenRev); 1841 mixedPieces.sort(cmpLenRev); 1842 1843 this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i'); 1844 this._weekdaysShortRegex = this._weekdaysRegex; 1845 this._weekdaysMinRegex = this._weekdaysRegex; 1846 1847 this._weekdaysStrictRegex = new RegExp( 1848 '^(' + longPieces.join('|') + ')', 1849 'i' 1850 ); 1851 this._weekdaysShortStrictRegex = new RegExp( 1852 '^(' + shortPieces.join('|') + ')', 1853 'i' 1854 ); 1855 this._weekdaysMinStrictRegex = new RegExp( 1856 '^(' + minPieces.join('|') + ')', 1857 'i' 1858 ); 1859 } 1860 1861 // FORMATTING 1862 1863 function hFormat() { 1864 return this.hours() % 12 || 12; 1865 } 1866 1867 function kFormat() { 1868 return this.hours() || 24; 1869 } 1870 1871 addFormatToken('H', ['HH', 2], 0, 'hour'); 1872 addFormatToken('h', ['hh', 2], 0, hFormat); 1873 addFormatToken('k', ['kk', 2], 0, kFormat); 1874 1875 addFormatToken('hmm', 0, 0, function () { 1876 return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2); 1877 }); 1878 1879 addFormatToken('hmmss', 0, 0, function () { 1880 return ( 1881 '' + 1882 hFormat.apply(this) + 1883 zeroFill(this.minutes(), 2) + 1884 zeroFill(this.seconds(), 2) 1885 ); 1886 }); 1887 1888 addFormatToken('Hmm', 0, 0, function () { 1889 return '' + this.hours() + zeroFill(this.minutes(), 2); 1890 }); 1891 1892 addFormatToken('Hmmss', 0, 0, function () { 1893 return ( 1894 '' + 1895 this.hours() + 1896 zeroFill(this.minutes(), 2) + 1897 zeroFill(this.seconds(), 2) 1898 ); 1899 }); 1900 1901 function meridiem(token, lowercase) { 1902 addFormatToken(token, 0, 0, function () { 1903 return this.localeData().meridiem( 1904 this.hours(), 1905 this.minutes(), 1906 lowercase 1907 ); 1908 }); 1909 } 1910 1911 meridiem('a', true); 1912 meridiem('A', false); 1913 1914 // ALIASES 1915 1916 addUnitAlias('hour', 'h'); 1917 1918 // PRIORITY 1919 addUnitPriority('hour', 13); 1920 1921 // PARSING 1922 1923 function matchMeridiem(isStrict, locale) { 1924 return locale._meridiemParse; 1925 } 1926 1927 addRegexToken('a', matchMeridiem); 1928 addRegexToken('A', matchMeridiem); 1929 addRegexToken('H', match1to2); 1930 addRegexToken('h', match1to2); 1931 addRegexToken('k', match1to2); 1932 addRegexToken('HH', match1to2, match2); 1933 addRegexToken('hh', match1to2, match2); 1934 addRegexToken('kk', match1to2, match2); 1935 1936 addRegexToken('hmm', match3to4); 1937 addRegexToken('hmmss', match5to6); 1938 addRegexToken('Hmm', match3to4); 1939 addRegexToken('Hmmss', match5to6); 1940 1941 addParseToken(['H', 'HH'], HOUR); 1942 addParseToken(['k', 'kk'], function (input, array, config) { 1943 var kInput = toInt(input); 1944 array[HOUR] = kInput === 24 ? 0 : kInput; 1945 }); 1946 addParseToken(['a', 'A'], function (input, array, config) { 1947 config._isPm = config._locale.isPM(input); 1948 config._meridiem = input; 1949 }); 1950 addParseToken(['h', 'hh'], function (input, array, config) { 1951 array[HOUR] = toInt(input); 1952 getParsingFlags(config).bigHour = true; 1953 }); 1954 addParseToken('hmm', function (input, array, config) { 1955 var pos = input.length - 2; 1956 array[HOUR] = toInt(input.substr(0, pos)); 1957 array[MINUTE] = toInt(input.substr(pos)); 1958 getParsingFlags(config).bigHour = true; 1959 }); 1960 addParseToken('hmmss', function (input, array, config) { 1961 var pos1 = input.length - 4, 1962 pos2 = input.length - 2; 1963 array[HOUR] = toInt(input.substr(0, pos1)); 1964 array[MINUTE] = toInt(input.substr(pos1, 2)); 1965 array[SECOND] = toInt(input.substr(pos2)); 1966 getParsingFlags(config).bigHour = true; 1967 }); 1968 addParseToken('Hmm', function (input, array, config) { 1969 var pos = input.length - 2; 1970 array[HOUR] = toInt(input.substr(0, pos)); 1971 array[MINUTE] = toInt(input.substr(pos)); 1972 }); 1973 addParseToken('Hmmss', function (input, array, config) { 1974 var pos1 = input.length - 4, 1975 pos2 = input.length - 2; 1976 array[HOUR] = toInt(input.substr(0, pos1)); 1977 array[MINUTE] = toInt(input.substr(pos1, 2)); 1978 array[SECOND] = toInt(input.substr(pos2)); 1979 }); 1980 1981 // LOCALES 1982 1983 function localeIsPM(input) { 1984 // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays 1985 // Using charAt should be more compatible. 1986 return (input + '').toLowerCase().charAt(0) === 'p'; 1987 } 1988 1989 var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i, 1990 // Setting the hour should keep the time, because the user explicitly 1991 // specified which hour they want. So trying to maintain the same hour (in 1992 // a new timezone) makes sense. Adding/subtracting hours does not follow 1993 // this rule. 1994 getSetHour = makeGetSet('Hours', true); 1995 1996 function localeMeridiem(hours, minutes, isLower) { 1997 if (hours > 11) { 1998 return isLower ? 'pm' : 'PM'; 1999 } else { 2000 return isLower ? 'am' : 'AM'; 2001 } 2002 } 2003 2004 var baseConfig = { 2005 calendar: defaultCalendar, 2006 longDateFormat: defaultLongDateFormat, 2007 invalidDate: defaultInvalidDate, 2008 ordinal: defaultOrdinal, 2009 dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse, 2010 relativeTime: defaultRelativeTime, 2011 2012 months: defaultLocaleMonths, 2013 monthsShort: defaultLocaleMonthsShort, 2014 2015 week: defaultLocaleWeek, 2016 2017 weekdays: defaultLocaleWeekdays, 2018 weekdaysMin: defaultLocaleWeekdaysMin, 2019 weekdaysShort: defaultLocaleWeekdaysShort, 2020 2021 meridiemParse: defaultLocaleMeridiemParse, 2022 }; 2023 2024 // internal storage for locale config files 2025 var locales = {}, 2026 localeFamilies = {}, 2027 globalLocale; 2028 2029 function commonPrefix(arr1, arr2) { 2030 var i, 2031 minl = Math.min(arr1.length, arr2.length); 2032 for (i = 0; i < minl; i += 1) { 2033 if (arr1[i] !== arr2[i]) { 2034 return i; 2035 } 2036 } 2037 return minl; 2038 } 2039 2040 function normalizeLocale(key) { 2041 return key ? key.toLowerCase().replace('_', '-') : key; 2042 } 2043 2044 // pick the locale from the array 2045 // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each 2046 // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root 2047 function chooseLocale(names) { 2048 var i = 0, 2049 j, 2050 next, 2051 locale, 2052 split; 2053 2054 while (i < names.length) { 2055 split = normalizeLocale(names[i]).split('-'); 2056 j = split.length; 2057 next = normalizeLocale(names[i + 1]); 2058 next = next ? next.split('-') : null; 2059 while (j > 0) { 2060 locale = loadLocale(split.slice(0, j).join('-')); 2061 if (locale) { 2062 return locale; 2063 } 2064 if ( 2065 next && 2066 next.length >= j && 2067 commonPrefix(split, next) >= j - 1 2068 ) { 2069 //the next array item is better than a shallower substring of this one 2070 break; 2071 } 2072 j--; 2073 } 2074 i++; 2075 } 2076 return globalLocale; 2077 } 2078 2079 function loadLocale(name) { 2080 var oldLocale = null, 2081 aliasedRequire; 2082 // TODO: Find a better way to register and load all the locales in Node 2083 if ( 2084 locales[name] === undefined && 2085 typeof module !== 'undefined' && 2086 module && 2087 module.exports 2088 ) { 2089 try { 2090 oldLocale = globalLocale._abbr; 2091 aliasedRequire = require; 2092 aliasedRequire('./locale/' + name); 2093 getSetGlobalLocale(oldLocale); 2094 } catch (e) { 2095 // mark as not found to avoid repeating expensive file require call causing high CPU 2096 // when trying to find en-US, en_US, en-us for every format call 2097 locales[name] = null; // null means not found 2098 } 2099 } 2100 return locales[name]; 2101 } 2102 2103 // This function will load locale and then set the global locale. If 2104 // no arguments are passed in, it will simply return the current global 2105 // locale key. 2106 function getSetGlobalLocale(key, values) { 2107 var data; 2108 if (key) { 2109 if (isUndefined(values)) { 2110 data = getLocale(key); 2111 } else { 2112 data = defineLocale(key, values); 2113 } 2114 2115 if (data) { 2116 // moment.duration._locale = moment._locale = data; 2117 globalLocale = data; 2118 } else { 2119 if (typeof console !== 'undefined' && console.warn) { 2120 //warn user if arguments are passed but the locale could not be set 2121 console.warn( 2122 'Locale ' + key + ' not found. Did you forget to load it?' 2123 ); 2124 } 2125 } 2126 } 2127 2128 return globalLocale._abbr; 2129 } 2130 2131 function defineLocale(name, config) { 2132 if (config !== null) { 2133 var locale, 2134 parentConfig = baseConfig; 2135 config.abbr = name; 2136 if (locales[name] != null) { 2137 deprecateSimple( 2138 'defineLocaleOverride', 2139 'use moment.updateLocale(localeName, config) to change ' + 2140 'an existing locale. moment.defineLocale(localeName, ' + 2141 'config) should only be used for creating a new locale ' + 2142 'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.' 2143 ); 2144 parentConfig = locales[name]._config; 2145 } else if (config.parentLocale != null) { 2146 if (locales[config.parentLocale] != null) { 2147 parentConfig = locales[config.parentLocale]._config; 2148 } else { 2149 locale = loadLocale(config.parentLocale); 2150 if (locale != null) { 2151 parentConfig = locale._config; 2152 } else { 2153 if (!localeFamilies[config.parentLocale]) { 2154 localeFamilies[config.parentLocale] = []; 2155 } 2156 localeFamilies[config.parentLocale].push({ 2157 name: name, 2158 config: config, 2159 }); 2160 return null; 2161 } 2162 } 2163 } 2164 locales[name] = new Locale(mergeConfigs(parentConfig, config)); 2165 2166 if (localeFamilies[name]) { 2167 localeFamilies[name].forEach(function (x) { 2168 defineLocale(x.name, x.config); 2169 }); 2170 } 2171 2172 // backwards compat for now: also set the locale 2173 // make sure we set the locale AFTER all child locales have been 2174 // created, so we won't end up with the child locale set. 2175 getSetGlobalLocale(name); 2176 2177 return locales[name]; 2178 } else { 2179 // useful for testing 2180 delete locales[name]; 2181 return null; 2182 } 2183 } 2184 2185 function updateLocale(name, config) { 2186 if (config != null) { 2187 var locale, 2188 tmpLocale, 2189 parentConfig = baseConfig; 2190 2191 if (locales[name] != null && locales[name].parentLocale != null) { 2192 // Update existing child locale in-place to avoid memory-leaks 2193 locales[name].set(mergeConfigs(locales[name]._config, config)); 2194 } else { 2195 // MERGE 2196 tmpLocale = loadLocale(name); 2197 if (tmpLocale != null) { 2198 parentConfig = tmpLocale._config; 2199 } 2200 config = mergeConfigs(parentConfig, config); 2201 if (tmpLocale == null) { 2202 // updateLocale is called for creating a new locale 2203 // Set abbr so it will have a name (getters return 2204 // undefined otherwise). 2205 config.abbr = name; 2206 } 2207 locale = new Locale(config); 2208 locale.parentLocale = locales[name]; 2209 locales[name] = locale; 2210 } 2211 2212 // backwards compat for now: also set the locale 2213 getSetGlobalLocale(name); 2214 } else { 2215 // pass null for config to unupdate, useful for tests 2216 if (locales[name] != null) { 2217 if (locales[name].parentLocale != null) { 2218 locales[name] = locales[name].parentLocale; 2219 if (name === getSetGlobalLocale()) { 2220 getSetGlobalLocale(name); 2221 } 2222 } else if (locales[name] != null) { 2223 delete locales[name]; 2224 } 2225 } 2226 } 2227 return locales[name]; 2228 } 2229 2230 // returns locale data 2231 function getLocale(key) { 2232 var locale; 2233 2234 if (key && key._locale && key._locale._abbr) { 2235 key = key._locale._abbr; 2236 } 2237 2238 if (!key) { 2239 return globalLocale; 2240 } 2241 2242 if (!isArray(key)) { 2243 //short-circuit everything else 2244 locale = loadLocale(key); 2245 if (locale) { 2246 return locale; 2247 } 2248 key = [key]; 2249 } 2250 2251 return chooseLocale(key); 2252 } 2253 2254 function listLocales() { 2255 return keys(locales); 2256 } 2257 2258 function checkOverflow(m) { 2259 var overflow, 2260 a = m._a; 2261 2262 if (a && getParsingFlags(m).overflow === -2) { 2263 overflow = 2264 a[MONTH] < 0 || a[MONTH] > 11 2265 ? MONTH 2266 : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) 2267 ? DATE 2268 : a[HOUR] < 0 || 2269 a[HOUR] > 24 || 2270 (a[HOUR] === 24 && 2271 (a[MINUTE] !== 0 || 2272 a[SECOND] !== 0 || 2273 a[MILLISECOND] !== 0)) 2274 ? HOUR 2275 : a[MINUTE] < 0 || a[MINUTE] > 59 2276 ? MINUTE 2277 : a[SECOND] < 0 || a[SECOND] > 59 2278 ? SECOND 2279 : a[MILLISECOND] < 0 || a[MILLISECOND] > 999 2280 ? MILLISECOND 2281 : -1; 2282 2283 if ( 2284 getParsingFlags(m)._overflowDayOfYear && 2285 (overflow < YEAR || overflow > DATE) 2286 ) { 2287 overflow = DATE; 2288 } 2289 if (getParsingFlags(m)._overflowWeeks && overflow === -1) { 2290 overflow = WEEK; 2291 } 2292 if (getParsingFlags(m)._overflowWeekday && overflow === -1) { 2293 overflow = WEEKDAY; 2294 } 2295 2296 getParsingFlags(m).overflow = overflow; 2297 } 2298 2299 return m; 2300 } 2301 2302 // iso 8601 regex 2303 // 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) 2304 var extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/, 2305 basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d|))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/, 2306 tzRegex = /Z|[+-]\d\d(?::?\d\d)?/, 2307 isoDates = [ 2308 ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/], 2309 ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/], 2310 ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/], 2311 ['GGGG-[W]WW', /\d{4}-W\d\d/, false], 2312 ['YYYY-DDD', /\d{4}-\d{3}/], 2313 ['YYYY-MM', /\d{4}-\d\d/, false], 2314 ['YYYYYYMMDD', /[+-]\d{10}/], 2315 ['YYYYMMDD', /\d{8}/], 2316 ['GGGG[W]WWE', /\d{4}W\d{3}/], 2317 ['GGGG[W]WW', /\d{4}W\d{2}/, false], 2318 ['YYYYDDD', /\d{7}/], 2319 ['YYYYMM', /\d{6}/, false], 2320 ['YYYY', /\d{4}/, false], 2321 ], 2322 // iso time formats and regexes 2323 isoTimes = [ 2324 ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/], 2325 ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/], 2326 ['HH:mm:ss', /\d\d:\d\d:\d\d/], 2327 ['HH:mm', /\d\d:\d\d/], 2328 ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/], 2329 ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/], 2330 ['HHmmss', /\d\d\d\d\d\d/], 2331 ['HHmm', /\d\d\d\d/], 2332 ['HH', /\d\d/], 2333 ], 2334 aspNetJsonRegex = /^\/?Date\((-?\d+)/i, 2335 // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3 2336 rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/, 2337 obsOffsets = { 2338 UT: 0, 2339 GMT: 0, 2340 EDT: -4 * 60, 2341 EST: -5 * 60, 2342 CDT: -5 * 60, 2343 CST: -6 * 60, 2344 MDT: -6 * 60, 2345 MST: -7 * 60, 2346 PDT: -7 * 60, 2347 PST: -8 * 60, 2348 }; 2349 2350 // date from iso format 2351 function configFromISO(config) { 2352 var i, 2353 l, 2354 string = config._i, 2355 match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string), 2356 allowTime, 2357 dateFormat, 2358 timeFormat, 2359 tzFormat; 2360 2361 if (match) { 2362 getParsingFlags(config).iso = true; 2363 2364 for (i = 0, l = isoDates.length; i < l; i++) { 2365 if (isoDates[i][1].exec(match[1])) { 2366 dateFormat = isoDates[i][0]; 2367 allowTime = isoDates[i][2] !== false; 2368 break; 2369 } 2370 } 2371 if (dateFormat == null) { 2372 config._isValid = false; 2373 return; 2374 } 2375 if (match[3]) { 2376 for (i = 0, l = isoTimes.length; i < l; i++) { 2377 if (isoTimes[i][1].exec(match[3])) { 2378 // match[2] should be 'T' or space 2379 timeFormat = (match[2] || ' ') + isoTimes[i][0]; 2380 break; 2381 } 2382 } 2383 if (timeFormat == null) { 2384 config._isValid = false; 2385 return; 2386 } 2387 } 2388 if (!allowTime && timeFormat != null) { 2389 config._isValid = false; 2390 return; 2391 } 2392 if (match[4]) { 2393 if (tzRegex.exec(match[4])) { 2394 tzFormat = 'Z'; 2395 } else { 2396 config._isValid = false; 2397 return; 2398 } 2399 } 2400 config._f = dateFormat + (timeFormat || '') + (tzFormat || ''); 2401 configFromStringAndFormat(config); 2402 } else { 2403 config._isValid = false; 2404 } 2405 } 2406 2407 function extractFromRFC2822Strings( 2408 yearStr, 2409 monthStr, 2410 dayStr, 2411 hourStr, 2412 minuteStr, 2413 secondStr 2414 ) { 2415 var result = [ 2416 untruncateYear(yearStr), 2417 defaultLocaleMonthsShort.indexOf(monthStr), 2418 parseInt(dayStr, 10), 2419 parseInt(hourStr, 10), 2420 parseInt(minuteStr, 10), 2421 ]; 2422 2423 if (secondStr) { 2424 result.push(parseInt(secondStr, 10)); 2425 } 2426 2427 return result; 2428 } 2429 2430 function untruncateYear(yearStr) { 2431 var year = parseInt(yearStr, 10); 2432 if (year <= 49) { 2433 return 2000 + year; 2434 } else if (year <= 999) { 2435 return 1900 + year; 2436 } 2437 return year; 2438 } 2439 2440 function preprocessRFC2822(s) { 2441 // Remove comments and folding whitespace and replace multiple-spaces with a single space 2442 return s 2443 .replace(/\([^)]*\)|[\n\t]/g, ' ') 2444 .replace(/(\s\s+)/g, ' ') 2445 .replace(/^\s\s*/, '') 2446 .replace(/\s\s*$/, ''); 2447 } 2448 2449 function checkWeekday(weekdayStr, parsedInput, config) { 2450 if (weekdayStr) { 2451 // TODO: Replace the vanilla JS Date object with an independent day-of-week check. 2452 var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr), 2453 weekdayActual = new Date( 2454 parsedInput[0], 2455 parsedInput[1], 2456 parsedInput[2] 2457 ).getDay(); 2458 if (weekdayProvided !== weekdayActual) { 2459 getParsingFlags(config).weekdayMismatch = true; 2460 config._isValid = false; 2461 return false; 2462 } 2463 } 2464 return true; 2465 } 2466 2467 function calculateOffset(obsOffset, militaryOffset, numOffset) { 2468 if (obsOffset) { 2469 return obsOffsets[obsOffset]; 2470 } else if (militaryOffset) { 2471 // the only allowed military tz is Z 2472 return 0; 2473 } else { 2474 var hm = parseInt(numOffset, 10), 2475 m = hm % 100, 2476 h = (hm - m) / 100; 2477 return h * 60 + m; 2478 } 2479 } 2480 2481 // date and time from ref 2822 format 2482 function configFromRFC2822(config) { 2483 var match = rfc2822.exec(preprocessRFC2822(config._i)), 2484 parsedArray; 2485 if (match) { 2486 parsedArray = extractFromRFC2822Strings( 2487 match[4], 2488 match[3], 2489 match[2], 2490 match[5], 2491 match[6], 2492 match[7] 2493 ); 2494 if (!checkWeekday(match[1], parsedArray, config)) { 2495 return; 2496 } 2497 2498 config._a = parsedArray; 2499 config._tzm = calculateOffset(match[8], match[9], match[10]); 2500 2501 config._d = createUTCDate.apply(null, config._a); 2502 config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm); 2503 2504 getParsingFlags(config).rfc2822 = true; 2505 } else { 2506 config._isValid = false; 2507 } 2508 } 2509 2510 // date from 1) ASP.NET, 2) ISO, 3) RFC 2822 formats, or 4) optional fallback if parsing isn't strict 2511 function configFromString(config) { 2512 var matched = aspNetJsonRegex.exec(config._i); 2513 if (matched !== null) { 2514 config._d = new Date(+matched[1]); 2515 return; 2516 } 2517 2518 configFromISO(config); 2519 if (config._isValid === false) { 2520 delete config._isValid; 2521 } else { 2522 return; 2523 } 2524 2525 configFromRFC2822(config); 2526 if (config._isValid === false) { 2527 delete config._isValid; 2528 } else { 2529 return; 2530 } 2531 2532 if (config._strict) { 2533 config._isValid = false; 2534 } else { 2535 // Final attempt, use Input Fallback 2536 hooks.createFromInputFallback(config); 2537 } 2538 } 2539 2540 hooks.createFromInputFallback = deprecate( 2541 'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' + 2542 'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' + 2543 'discouraged and will be removed in an upcoming major release. Please refer to ' + 2544 'http://momentjs.com/guides/#/warnings/js-date/ for more info.', 2545 function (config) { 2546 config._d = new Date(config._i + (config._useUTC ? ' UTC' : '')); 2547 } 2548 ); 2549 2550 // Pick the first defined of two or three arguments. 2551 function defaults(a, b, c) { 2552 if (a != null) { 2553 return a; 2554 } 2555 if (b != null) { 2556 return b; 2557 } 2558 return c; 2559 } 2560 2561 function currentDateArray(config) { 2562 // hooks is actually the exported moment object 2563 var nowValue = new Date(hooks.now()); 2564 if (config._useUTC) { 2565 return [ 2566 nowValue.getUTCFullYear(), 2567 nowValue.getUTCMonth(), 2568 nowValue.getUTCDate(), 2569 ]; 2570 } 2571 return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()]; 2572 } 2573 2574 // convert an array to a date. 2575 // the array should mirror the parameters below 2576 // note: all values past the year are optional and will default to the lowest possible value. 2577 // [year, month, day , hour, minute, second, millisecond] 2578 function configFromArray(config) { 2579 var i, 2580 date, 2581 input = [], 2582 currentDate, 2583 expectedWeekday, 2584 yearToUse; 2585 2586 if (config._d) { 2587 return; 2588 } 2589 2590 currentDate = currentDateArray(config); 2591 2592 //compute day of the year from weeks and weekdays 2593 if (config._w && config._a[DATE] == null && config._a[MONTH] == null) { 2594 dayOfYearFromWeekInfo(config); 2595 } 2596 2597 //if the day of the year is set, figure out what it is 2598 if (config._dayOfYear != null) { 2599 yearToUse = defaults(config._a[YEAR], currentDate[YEAR]); 2600 2601 if ( 2602 config._dayOfYear > daysInYear(yearToUse) || 2603 config._dayOfYear === 0 2604 ) { 2605 getParsingFlags(config)._overflowDayOfYear = true; 2606 } 2607 2608 date = createUTCDate(yearToUse, 0, config._dayOfYear); 2609 config._a[MONTH] = date.getUTCMonth(); 2610 config._a[DATE] = date.getUTCDate(); 2611 } 2612 2613 // Default to current date. 2614 // * if no year, month, day of month are given, default to today 2615 // * if day of month is given, default month and year 2616 // * if month is given, default only year 2617 // * if year is given, don't default anything 2618 for (i = 0; i < 3 && config._a[i] == null; ++i) { 2619 config._a[i] = input[i] = currentDate[i]; 2620 } 2621 2622 // Zero out whatever was not defaulted, including time 2623 for (; i < 7; i++) { 2624 config._a[i] = input[i] = 2625 config._a[i] == null ? (i === 2 ? 1 : 0) : config._a[i]; 2626 } 2627 2628 // Check for 24:00:00.000 2629 if ( 2630 config._a[HOUR] === 24 && 2631 config._a[MINUTE] === 0 && 2632 config._a[SECOND] === 0 && 2633 config._a[MILLISECOND] === 0 2634 ) { 2635 config._nextDay = true; 2636 config._a[HOUR] = 0; 2637 } 2638 2639 config._d = (config._useUTC ? createUTCDate : createDate).apply( 2640 null, 2641 input 2642 ); 2643 expectedWeekday = config._useUTC 2644 ? config._d.getUTCDay() 2645 : config._d.getDay(); 2646 2647 // Apply timezone offset from input. The actual utcOffset can be changed 2648 // with parseZone. 2649 if (config._tzm != null) { 2650 config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm); 2651 } 2652 2653 if (config._nextDay) { 2654 config._a[HOUR] = 24; 2655 } 2656 2657 // check for mismatching day of week 2658 if ( 2659 config._w && 2660 typeof config._w.d !== 'undefined' && 2661 config._w.d !== expectedWeekday 2662 ) { 2663 getParsingFlags(config).weekdayMismatch = true; 2664 } 2665 } 2666 2667 function dayOfYearFromWeekInfo(config) { 2668 var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow, curWeek; 2669 2670 w = config._w; 2671 if (w.GG != null || w.W != null || w.E != null) { 2672 dow = 1; 2673 doy = 4; 2674 2675 // TODO: We need to take the current isoWeekYear, but that depends on 2676 // how we interpret now (local, utc, fixed offset). So create 2677 // a now version of current config (take local/utc/offset flags, and 2678 // create now). 2679 weekYear = defaults( 2680 w.GG, 2681 config._a[YEAR], 2682 weekOfYear(createLocal(), 1, 4).year 2683 ); 2684 week = defaults(w.W, 1); 2685 weekday = defaults(w.E, 1); 2686 if (weekday < 1 || weekday > 7) { 2687 weekdayOverflow = true; 2688 } 2689 } else { 2690 dow = config._locale._week.dow; 2691 doy = config._locale._week.doy; 2692 2693 curWeek = weekOfYear(createLocal(), dow, doy); 2694 2695 weekYear = defaults(w.gg, config._a[YEAR], curWeek.year); 2696 2697 // Default to current week. 2698 week = defaults(w.w, curWeek.week); 2699 2700 if (w.d != null) { 2701 // weekday -- low day numbers are considered next week 2702 weekday = w.d; 2703 if (weekday < 0 || weekday > 6) { 2704 weekdayOverflow = true; 2705 } 2706 } else if (w.e != null) { 2707 // local weekday -- counting starts from beginning of week 2708 weekday = w.e + dow; 2709 if (w.e < 0 || w.e > 6) { 2710 weekdayOverflow = true; 2711 } 2712 } else { 2713 // default to beginning of week 2714 weekday = dow; 2715 } 2716 } 2717 if (week < 1 || week > weeksInYear(weekYear, dow, doy)) { 2718 getParsingFlags(config)._overflowWeeks = true; 2719 } else if (weekdayOverflow != null) { 2720 getParsingFlags(config)._overflowWeekday = true; 2721 } else { 2722 temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy); 2723 config._a[YEAR] = temp.year; 2724 config._dayOfYear = temp.dayOfYear; 2725 } 2726 } 2727 2728 // constant that refers to the ISO standard 2729 hooks.ISO_8601 = function () {}; 2730 2731 // constant that refers to the RFC 2822 form 2732 hooks.RFC_2822 = function () {}; 2733 2734 // date from string and format string 2735 function configFromStringAndFormat(config) { 2736 // TODO: Move this to another part of the creation flow to prevent circular deps 2737 if (config._f === hooks.ISO_8601) { 2738 configFromISO(config); 2739 return; 2740 } 2741 if (config._f === hooks.RFC_2822) { 2742 configFromRFC2822(config); 2743 return; 2744 } 2745 config._a = []; 2746 getParsingFlags(config).empty = true; 2747 2748 // This array is used to make a Date, either with `new Date` or `Date.UTC` 2749 var string = '' + config._i, 2750 i, 2751 parsedInput, 2752 tokens, 2753 token, 2754 skipped, 2755 stringLength = string.length, 2756 totalParsedInputLength = 0, 2757 era; 2758 2759 tokens = 2760 expandFormat(config._f, config._locale).match(formattingTokens) || []; 2761 2762 for (i = 0; i < tokens.length; i++) { 2763 token = tokens[i]; 2764 parsedInput = (string.match(getParseRegexForToken(token, config)) || 2765 [])[0]; 2766 if (parsedInput) { 2767 skipped = string.substr(0, string.indexOf(parsedInput)); 2768 if (skipped.length > 0) { 2769 getParsingFlags(config).unusedInput.push(skipped); 2770 } 2771 string = string.slice( 2772 string.indexOf(parsedInput) + parsedInput.length 2773 ); 2774 totalParsedInputLength += parsedInput.length; 2775 } 2776 // don't parse if it's not a known token 2777 if (formatTokenFunctions[token]) { 2778 if (parsedInput) { 2779 getParsingFlags(config).empty = false; 2780 } else { 2781 getParsingFlags(config).unusedTokens.push(token); 2782 } 2783 addTimeToArrayFromToken(token, parsedInput, config); 2784 } else if (config._strict && !parsedInput) { 2785 getParsingFlags(config).unusedTokens.push(token); 2786 } 2787 } 2788 2789 // add remaining unparsed input length to the string 2790 getParsingFlags(config).charsLeftOver = 2791 stringLength - totalParsedInputLength; 2792 if (string.length > 0) { 2793 getParsingFlags(config).unusedInput.push(string); 2794 } 2795 2796 // clear _12h flag if hour is <= 12 2797 if ( 2798 config._a[HOUR] <= 12 && 2799 getParsingFlags(config).bigHour === true && 2800 config._a[HOUR] > 0 2801 ) { 2802 getParsingFlags(config).bigHour = undefined; 2803 } 2804 2805 getParsingFlags(config).parsedDateParts = config._a.slice(0); 2806 getParsingFlags(config).meridiem = config._meridiem; 2807 // handle meridiem 2808 config._a[HOUR] = meridiemFixWrap( 2809 config._locale, 2810 config._a[HOUR], 2811 config._meridiem 2812 ); 2813 2814 // handle era 2815 era = getParsingFlags(config).era; 2816 if (era !== null) { 2817 config._a[YEAR] = config._locale.erasConvertYear(era, config._a[YEAR]); 2818 } 2819 2820 configFromArray(config); 2821 checkOverflow(config); 2822 } 2823 2824 function meridiemFixWrap(locale, hour, meridiem) { 2825 var isPm; 2826 2827 if (meridiem == null) { 2828 // nothing to do 2829 return hour; 2830 } 2831 if (locale.meridiemHour != null) { 2832 return locale.meridiemHour(hour, meridiem); 2833 } else if (locale.isPM != null) { 2834 // Fallback 2835 isPm = locale.isPM(meridiem); 2836 if (isPm && hour < 12) { 2837 hour += 12; 2838 } 2839 if (!isPm && hour === 12) { 2840 hour = 0; 2841 } 2842 return hour; 2843 } else { 2844 // this is not supposed to happen 2845 return hour; 2846 } 2847 } 2848 2849 // date from string and array of format strings 2850 function configFromStringAndArray(config) { 2851 var tempConfig, 2852 bestMoment, 2853 scoreToBeat, 2854 i, 2855 currentScore, 2856 validFormatFound, 2857 bestFormatIsValid = false; 2858 2859 if (config._f.length === 0) { 2860 getParsingFlags(config).invalidFormat = true; 2861 config._d = new Date(NaN); 2862 return; 2863 } 2864 2865 for (i = 0; i < config._f.length; i++) { 2866 currentScore = 0; 2867 validFormatFound = false; 2868 tempConfig = copyConfig({}, config); 2869 if (config._useUTC != null) { 2870 tempConfig._useUTC = config._useUTC; 2871 } 2872 tempConfig._f = config._f[i]; 2873 configFromStringAndFormat(tempConfig); 2874 2875 if (isValid(tempConfig)) { 2876 validFormatFound = true; 2877 } 2878 2879 // if there is any input that was not parsed add a penalty for that format 2880 currentScore += getParsingFlags(tempConfig).charsLeftOver; 2881 2882 //or tokens 2883 currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10; 2884 2885 getParsingFlags(tempConfig).score = currentScore; 2886 2887 if (!bestFormatIsValid) { 2888 if ( 2889 scoreToBeat == null || 2890 currentScore < scoreToBeat || 2891 validFormatFound 2892 ) { 2893 scoreToBeat = currentScore; 2894 bestMoment = tempConfig; 2895 if (validFormatFound) { 2896 bestFormatIsValid = true; 2897 } 2898 } 2899 } else { 2900 if (currentScore < scoreToBeat) { 2901 scoreToBeat = currentScore; 2902 bestMoment = tempConfig; 2903 } 2904 } 2905 } 2906 2907 extend(config, bestMoment || tempConfig); 2908 } 2909 2910 function configFromObject(config) { 2911 if (config._d) { 2912 return; 2913 } 2914 2915 var i = normalizeObjectUnits(config._i), 2916 dayOrDate = i.day === undefined ? i.date : i.day; 2917 config._a = map( 2918 [i.year, i.month, dayOrDate, i.hour, i.minute, i.second, i.millisecond], 2919 function (obj) { 2920 return obj && parseInt(obj, 10); 2921 } 2922 ); 2923 2924 configFromArray(config); 2925 } 2926 2927 function createFromConfig(config) { 2928 var res = new Moment(checkOverflow(prepareConfig(config))); 2929 if (res._nextDay) { 2930 // Adding is smart enough around DST 2931 res.add(1, 'd'); 2932 res._nextDay = undefined; 2933 } 2934 2935 return res; 2936 } 2937 2938 function prepareConfig(config) { 2939 var input = config._i, 2940 format = config._f; 2941 2942 config._locale = config._locale || getLocale(config._l); 2943 2944 if (input === null || (format === undefined && input === '')) { 2945 return createInvalid({ nullInput: true }); 2946 } 2947 2948 if (typeof input === 'string') { 2949 config._i = input = config._locale.preparse(input); 2950 } 2951 2952 if (isMoment(input)) { 2953 return new Moment(checkOverflow(input)); 2954 } else if (isDate(input)) { 2955 config._d = input; 2956 } else if (isArray(format)) { 2957 configFromStringAndArray(config); 2958 } else if (format) { 2959 configFromStringAndFormat(config); 2960 } else { 2961 configFromInput(config); 2962 } 2963 2964 if (!isValid(config)) { 2965 config._d = null; 2966 } 2967 2968 return config; 2969 } 2970 2971 function configFromInput(config) { 2972 var input = config._i; 2973 if (isUndefined(input)) { 2974 config._d = new Date(hooks.now()); 2975 } else if (isDate(input)) { 2976 config._d = new Date(input.valueOf()); 2977 } else if (typeof input === 'string') { 2978 configFromString(config); 2979 } else if (isArray(input)) { 2980 config._a = map(input.slice(0), function (obj) { 2981 return parseInt(obj, 10); 2982 }); 2983 configFromArray(config); 2984 } else if (isObject(input)) { 2985 configFromObject(config); 2986 } else if (isNumber(input)) { 2987 // from milliseconds 2988 config._d = new Date(input); 2989 } else { 2990 hooks.createFromInputFallback(config); 2991 } 2992 } 2993 2994 function createLocalOrUTC(input, format, locale, strict, isUTC) { 2995 var c = {}; 2996 2997 if (format === true || format === false) { 2998 strict = format; 2999 format = undefined; 3000 } 3001 3002 if (locale === true || locale === false) { 3003 strict = locale; 3004 locale = undefined; 3005 } 3006 3007 if ( 3008 (isObject(input) && isObjectEmpty(input)) || 3009 (isArray(input) && input.length === 0) 3010 ) { 3011 input = undefined; 3012 } 3013 // object construction must be done this way. 3014 // https://github.com/moment/moment/issues/1423 3015 c._isAMomentObject = true; 3016 c._useUTC = c._isUTC = isUTC; 3017 c._l = locale; 3018 c._i = input; 3019 c._f = format; 3020 c._strict = strict; 3021 3022 return createFromConfig(c); 3023 } 3024 3025 function createLocal(input, format, locale, strict) { 3026 return createLocalOrUTC(input, format, locale, strict, false); 3027 } 3028 3029 var prototypeMin = deprecate( 3030 'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/', 3031 function () { 3032 var other = createLocal.apply(null, arguments); 3033 if (this.isValid() && other.isValid()) { 3034 return other < this ? this : other; 3035 } else { 3036 return createInvalid(); 3037 } 3038 } 3039 ), 3040 prototypeMax = deprecate( 3041 'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/', 3042 function () { 3043 var other = createLocal.apply(null, arguments); 3044 if (this.isValid() && other.isValid()) { 3045 return other > this ? this : other; 3046 } else { 3047 return createInvalid(); 3048 } 3049 } 3050 ); 3051 3052 // Pick a moment m from moments so that m[fn](other) is true for all 3053 // other. This relies on the function fn to be transitive. 3054 // 3055 // moments should either be an array of moment objects or an array, whose 3056 // first element is an array of moment objects. 3057 function pickBy(fn, moments) { 3058 var res, i; 3059 if (moments.length === 1 && isArray(moments[0])) { 3060 moments = moments[0]; 3061 } 3062 if (!moments.length) { 3063 return createLocal(); 3064 } 3065 res = moments[0]; 3066 for (i = 1; i < moments.length; ++i) { 3067 if (!moments[i].isValid() || moments[i][fn](res)) { 3068 res = moments[i]; 3069 } 3070 } 3071 return res; 3072 } 3073 3074 // TODO: Use [].sort instead? 3075 function min() { 3076 var args = [].slice.call(arguments, 0); 3077 3078 return pickBy('isBefore', args); 3079 } 3080 3081 function max() { 3082 var args = [].slice.call(arguments, 0); 3083 3084 return pickBy('isAfter', args); 3085 } 3086 3087 var now = function () { 3088 return Date.now ? Date.now() : +new Date(); 3089 }; 3090 3091 var ordering = [ 3092 'year', 3093 'quarter', 3094 'month', 3095 'week', 3096 'day', 3097 'hour', 3098 'minute', 3099 'second', 3100 'millisecond', 3101 ]; 3102 3103 function isDurationValid(m) { 3104 var key, 3105 unitHasDecimal = false, 3106 i; 3107 for (key in m) { 3108 if ( 3109 hasOwnProp(m, key) && 3110 !( 3111 indexOf.call(ordering, key) !== -1 && 3112 (m[key] == null || !isNaN(m[key])) 3113 ) 3114 ) { 3115 return false; 3116 } 3117 } 3118 3119 for (i = 0; i < ordering.length; ++i) { 3120 if (m[ordering[i]]) { 3121 if (unitHasDecimal) { 3122 return false; // only allow non-integers for smallest unit 3123 } 3124 if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) { 3125 unitHasDecimal = true; 3126 } 3127 } 3128 } 3129 3130 return true; 3131 } 3132 3133 function isValid$1() { 3134 return this._isValid; 3135 } 3136 3137 function createInvalid$1() { 3138 return createDuration(NaN); 3139 } 3140 3141 function Duration(duration) { 3142 var normalizedInput = normalizeObjectUnits(duration), 3143 years = normalizedInput.year || 0, 3144 quarters = normalizedInput.quarter || 0, 3145 months = normalizedInput.month || 0, 3146 weeks = normalizedInput.week || normalizedInput.isoWeek || 0, 3147 days = normalizedInput.day || 0, 3148 hours = normalizedInput.hour || 0, 3149 minutes = normalizedInput.minute || 0, 3150 seconds = normalizedInput.second || 0, 3151 milliseconds = normalizedInput.millisecond || 0; 3152 3153 this._isValid = isDurationValid(normalizedInput); 3154 3155 // representation for dateAddRemove 3156 this._milliseconds = 3157 +milliseconds + 3158 seconds * 1e3 + // 1000 3159 minutes * 6e4 + // 1000 * 60 3160 hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978 3161 // Because of dateAddRemove treats 24 hours as different from a 3162 // day when working around DST, we need to store them separately 3163 this._days = +days + weeks * 7; 3164 // It is impossible to translate months into days without knowing 3165 // which months you are are talking about, so we have to store 3166 // it separately. 3167 this._months = +months + quarters * 3 + years * 12; 3168 3169 this._data = {}; 3170 3171 this._locale = getLocale(); 3172 3173 this._bubble(); 3174 } 3175 3176 function isDuration(obj) { 3177 return obj instanceof Duration; 3178 } 3179 3180 function absRound(number) { 3181 if (number < 0) { 3182 return Math.round(-1 * number) * -1; 3183 } else { 3184 return Math.round(number); 3185 } 3186 } 3187 3188 // compare two arrays, return the number of differences 3189 function compareArrays(array1, array2, dontConvert) { 3190 var len = Math.min(array1.length, array2.length), 3191 lengthDiff = Math.abs(array1.length - array2.length), 3192 diffs = 0, 3193 i; 3194 for (i = 0; i < len; i++) { 3195 if ( 3196 (dontConvert && array1[i] !== array2[i]) || 3197 (!dontConvert && toInt(array1[i]) !== toInt(array2[i])) 3198 ) { 3199 diffs++; 3200 } 3201 } 3202 return diffs + lengthDiff; 3203 } 3204 3205 // FORMATTING 3206 3207 function offset(token, separator) { 3208 addFormatToken(token, 0, 0, function () { 3209 var offset = this.utcOffset(), 3210 sign = '+'; 3211 if (offset < 0) { 3212 offset = -offset; 3213 sign = '-'; 3214 } 3215 return ( 3216 sign + 3217 zeroFill(~~(offset / 60), 2) + 3218 separator + 3219 zeroFill(~~offset % 60, 2) 3220 ); 3221 }); 3222 } 3223 3224 offset('Z', ':'); 3225 offset('ZZ', ''); 3226 3227 // PARSING 3228 3229 addRegexToken('Z', matchShortOffset); 3230 addRegexToken('ZZ', matchShortOffset); 3231 addParseToken(['Z', 'ZZ'], function (input, array, config) { 3232 config._useUTC = true; 3233 config._tzm = offsetFromString(matchShortOffset, input); 3234 }); 3235 3236 // HELPERS 3237 3238 // timezone chunker 3239 // '+10:00' > ['10', '00'] 3240 // '-1530' > ['-15', '30'] 3241 var chunkOffset = /([\+\-]|\d\d)/gi; 3242 3243 function offsetFromString(matcher, string) { 3244 var matches = (string || '').match(matcher), 3245 chunk, 3246 parts, 3247 minutes; 3248 3249 if (matches === null) { 3250 return null; 3251 } 3252 3253 chunk = matches[matches.length - 1] || []; 3254 parts = (chunk + '').match(chunkOffset) || ['-', 0, 0]; 3255 minutes = +(parts[1] * 60) + toInt(parts[2]); 3256 3257 return minutes === 0 ? 0 : parts[0] === '+' ? minutes : -minutes; 3258 } 3259 3260 // Return a moment from input, that is local/utc/zone equivalent to model. 3261 function cloneWithOffset(input, model) { 3262 var res, diff; 3263 if (model._isUTC) { 3264 res = model.clone(); 3265 diff = 3266 (isMoment(input) || isDate(input) 3267 ? input.valueOf() 3268 : createLocal(input).valueOf()) - res.valueOf(); 3269 // Use low-level api, because this fn is low-level api. 3270 res._d.setTime(res._d.valueOf() + diff); 3271 hooks.updateOffset(res, false); 3272 return res; 3273 } else { 3274 return createLocal(input).local(); 3275 } 3276 } 3277 3278 function getDateOffset(m) { 3279 // On Firefox.24 Date#getTimezoneOffset returns a floating point. 3280 // https://github.com/moment/moment/pull/1871 3281 return -Math.round(m._d.getTimezoneOffset()); 3282 } 3283 3284 // HOOKS 3285 3286 // This function will be called whenever a moment is mutated. 3287 // It is intended to keep the offset in sync with the timezone. 3288 hooks.updateOffset = function () {}; 3289 3290 // MOMENTS 3291 3292 // keepLocalTime = true means only change the timezone, without 3293 // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]--> 3294 // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset 3295 // +0200, so we adjust the time as needed, to be valid. 3296 // 3297 // Keeping the time actually adds/subtracts (one hour) 3298 // from the actual represented time. That is why we call updateOffset 3299 // a second time. In case it wants us to change the offset again 3300 // _changeInProgress == true case, then we have to adjust, because 3301 // there is no such time in the given timezone. 3302 function getSetOffset(input, keepLocalTime, keepMinutes) { 3303 var offset = this._offset || 0, 3304 localAdjust; 3305 if (!this.isValid()) { 3306 return input != null ? this : NaN; 3307 } 3308 if (input != null) { 3309 if (typeof input === 'string') { 3310 input = offsetFromString(matchShortOffset, input); 3311 if (input === null) { 3312 return this; 3313 } 3314 } else if (Math.abs(input) < 16 && !keepMinutes) { 3315 input = input * 60; 3316 } 3317 if (!this._isUTC && keepLocalTime) { 3318 localAdjust = getDateOffset(this); 3319 } 3320 this._offset = input; 3321 this._isUTC = true; 3322 if (localAdjust != null) { 3323 this.add(localAdjust, 'm'); 3324 } 3325 if (offset !== input) { 3326 if (!keepLocalTime || this._changeInProgress) { 3327 addSubtract( 3328 this, 3329 createDuration(input - offset, 'm'), 3330 1, 3331 false 3332 ); 3333 } else if (!this._changeInProgress) { 3334 this._changeInProgress = true; 3335 hooks.updateOffset(this, true); 3336 this._changeInProgress = null; 3337 } 3338 } 3339 return this; 3340 } else { 3341 return this._isUTC ? offset : getDateOffset(this); 3342 } 3343 } 3344 3345 function getSetZone(input, keepLocalTime) { 3346 if (input != null) { 3347 if (typeof input !== 'string') { 3348 input = -input; 3349 } 3350 3351 this.utcOffset(input, keepLocalTime); 3352 3353 return this; 3354 } else { 3355 return -this.utcOffset(); 3356 } 3357 } 3358 3359 function setOffsetToUTC(keepLocalTime) { 3360 return this.utcOffset(0, keepLocalTime); 3361 } 3362 3363 function setOffsetToLocal(keepLocalTime) { 3364 if (this._isUTC) { 3365 this.utcOffset(0, keepLocalTime); 3366 this._isUTC = false; 3367 3368 if (keepLocalTime) { 3369 this.subtract(getDateOffset(this), 'm'); 3370 } 3371 } 3372 return this; 3373 } 3374 3375 function setOffsetToParsedOffset() { 3376 if (this._tzm != null) { 3377 this.utcOffset(this._tzm, false, true); 3378 } else if (typeof this._i === 'string') { 3379 var tZone = offsetFromString(matchOffset, this._i); 3380 if (tZone != null) { 3381 this.utcOffset(tZone); 3382 } else { 3383 this.utcOffset(0, true); 3384 } 3385 } 3386 return this; 3387 } 3388 3389 function hasAlignedHourOffset(input) { 3390 if (!this.isValid()) { 3391 return false; 3392 } 3393 input = input ? createLocal(input).utcOffset() : 0; 3394 3395 return (this.utcOffset() - input) % 60 === 0; 3396 } 3397 3398 function isDaylightSavingTime() { 3399 return ( 3400 this.utcOffset() > this.clone().month(0).utcOffset() || 3401 this.utcOffset() > this.clone().month(5).utcOffset() 3402 ); 3403 } 3404 3405 function isDaylightSavingTimeShifted() { 3406 if (!isUndefined(this._isDSTShifted)) { 3407 return this._isDSTShifted; 3408 } 3409 3410 var c = {}, 3411 other; 3412 3413 copyConfig(c, this); 3414 c = prepareConfig(c); 3415 3416 if (c._a) { 3417 other = c._isUTC ? createUTC(c._a) : createLocal(c._a); 3418 this._isDSTShifted = 3419 this.isValid() && compareArrays(c._a, other.toArray()) > 0; 3420 } else { 3421 this._isDSTShifted = false; 3422 } 3423 3424 return this._isDSTShifted; 3425 } 3426 3427 function isLocal() { 3428 return this.isValid() ? !this._isUTC : false; 3429 } 3430 3431 function isUtcOffset() { 3432 return this.isValid() ? this._isUTC : false; 3433 } 3434 3435 function isUtc() { 3436 return this.isValid() ? this._isUTC && this._offset === 0 : false; 3437 } 3438 3439 // ASP.NET json date format regex 3440 var aspNetRegex = /^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/, 3441 // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html 3442 // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere 3443 // and further modified to allow for strings containing both week and day 3444 isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/; 3445 3446 function createDuration(input, key) { 3447 var duration = input, 3448 // matching against regexp is expensive, do it on demand 3449 match = null, 3450 sign, 3451 ret, 3452 diffRes; 3453 3454 if (isDuration(input)) { 3455 duration = { 3456 ms: input._milliseconds, 3457 d: input._days, 3458 M: input._months, 3459 }; 3460 } else if (isNumber(input) || !isNaN(+input)) { 3461 duration = {}; 3462 if (key) { 3463 duration[key] = +input; 3464 } else { 3465 duration.milliseconds = +input; 3466 } 3467 } else if ((match = aspNetRegex.exec(input))) { 3468 sign = match[1] === '-' ? -1 : 1; 3469 duration = { 3470 y: 0, 3471 d: toInt(match[DATE]) * sign, 3472 h: toInt(match[HOUR]) * sign, 3473 m: toInt(match[MINUTE]) * sign, 3474 s: toInt(match[SECOND]) * sign, 3475 ms: toInt(absRound(match[MILLISECOND] * 1000)) * sign, // the millisecond decimal point is included in the match 3476 }; 3477 } else if ((match = isoRegex.exec(input))) { 3478 sign = match[1] === '-' ? -1 : 1; 3479 duration = { 3480 y: parseIso(match[2], sign), 3481 M: parseIso(match[3], sign), 3482 w: parseIso(match[4], sign), 3483 d: parseIso(match[5], sign), 3484 h: parseIso(match[6], sign), 3485 m: parseIso(match[7], sign), 3486 s: parseIso(match[8], sign), 3487 }; 3488 } else if (duration == null) { 3489 // checks for null or undefined 3490 duration = {}; 3491 } else if ( 3492 typeof duration === 'object' && 3493 ('from' in duration || 'to' in duration) 3494 ) { 3495 diffRes = momentsDifference( 3496 createLocal(duration.from), 3497 createLocal(duration.to) 3498 ); 3499 3500 duration = {}; 3501 duration.ms = diffRes.milliseconds; 3502 duration.M = diffRes.months; 3503 } 3504 3505 ret = new Duration(duration); 3506 3507 if (isDuration(input) && hasOwnProp(input, '_locale')) { 3508 ret._locale = input._locale; 3509 } 3510 3511 if (isDuration(input) && hasOwnProp(input, '_isValid')) { 3512 ret._isValid = input._isValid; 3513 } 3514 3515 return ret; 3516 } 3517 3518 createDuration.fn = Duration.prototype; 3519 createDuration.invalid = createInvalid$1; 3520 3521 function parseIso(inp, sign) { 3522 // We'd normally use ~~inp for this, but unfortunately it also 3523 // converts floats to ints. 3524 // inp may be undefined, so careful calling replace on it. 3525 var res = inp && parseFloat(inp.replace(',', '.')); 3526 // apply sign while we're at it 3527 return (isNaN(res) ? 0 : res) * sign; 3528 } 3529 3530 function positiveMomentsDifference(base, other) { 3531 var res = {}; 3532 3533 res.months = 3534 other.month() - base.month() + (other.year() - base.year()) * 12; 3535 if (base.clone().add(res.months, 'M').isAfter(other)) { 3536 --res.months; 3537 } 3538 3539 res.milliseconds = +other - +base.clone().add(res.months, 'M'); 3540 3541 return res; 3542 } 3543 3544 function momentsDifference(base, other) { 3545 var res; 3546 if (!(base.isValid() && other.isValid())) { 3547 return { milliseconds: 0, months: 0 }; 3548 } 3549 3550 other = cloneWithOffset(other, base); 3551 if (base.isBefore(other)) { 3552 res = positiveMomentsDifference(base, other); 3553 } else { 3554 res = positiveMomentsDifference(other, base); 3555 res.milliseconds = -res.milliseconds; 3556 res.months = -res.months; 3557 } 3558 3559 return res; 3560 } 3561 3562 // TODO: remove 'name' arg after deprecation is removed 3563 function createAdder(direction, name) { 3564 return function (val, period) { 3565 var dur, tmp; 3566 //invert the arguments, but complain about it 3567 if (period !== null && !isNaN(+period)) { 3568 deprecateSimple( 3569 name, 3570 'moment().' + 3571 name + 3572 '(period, number) is deprecated. Please use moment().' + 3573 name + 3574 '(number, period). ' + 3575 'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.' 3576 ); 3577 tmp = val; 3578 val = period; 3579 period = tmp; 3580 } 3581 3582 dur = createDuration(val, period); 3583 addSubtract(this, dur, direction); 3584 return this; 3585 }; 3586 } 3587 3588 function addSubtract(mom, duration, isAdding, updateOffset) { 3589 var milliseconds = duration._milliseconds, 3590 days = absRound(duration._days), 3591 months = absRound(duration._months); 3592 3593 if (!mom.isValid()) { 3594 // No op 3595 return; 3596 } 3597 3598 updateOffset = updateOffset == null ? true : updateOffset; 3599 3600 if (months) { 3601 setMonth(mom, get(mom, 'Month') + months * isAdding); 3602 } 3603 if (days) { 3604 set$1(mom, 'Date', get(mom, 'Date') + days * isAdding); 3605 } 3606 if (milliseconds) { 3607 mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding); 3608 } 3609 if (updateOffset) { 3610 hooks.updateOffset(mom, days || months); 3611 } 3612 } 3613 3614 var add = createAdder(1, 'add'), 3615 subtract = createAdder(-1, 'subtract'); 3616 3617 function isString(input) { 3618 return typeof input === 'string' || input instanceof String; 3619 } 3620 3621 // type MomentInput = Moment | Date | string | number | (number | string)[] | MomentInputObject | void; // null | undefined 3622 function isMomentInput(input) { 3623 return ( 3624 isMoment(input) || 3625 isDate(input) || 3626 isString(input) || 3627 isNumber(input) || 3628 isNumberOrStringArray(input) || 3629 isMomentInputObject(input) || 3630 input === null || 3631 input === undefined 3632 ); 3633 } 3634 3635 function isMomentInputObject(input) { 3636 var objectTest = isObject(input) && !isObjectEmpty(input), 3637 propertyTest = false, 3638 properties = [ 3639 'years', 3640 'year', 3641 'y', 3642 'months', 3643 'month', 3644 'M', 3645 'days', 3646 'day', 3647 'd', 3648 'dates', 3649 'date', 3650 'D', 3651 'hours', 3652 'hour', 3653 'h', 3654 'minutes', 3655 'minute', 3656 'm', 3657 'seconds', 3658 'second', 3659 's', 3660 'milliseconds', 3661 'millisecond', 3662 'ms', 3663 ], 3664 i, 3665 property; 3666 3667 for (i = 0; i < properties.length; i += 1) { 3668 property = properties[i]; 3669 propertyTest = propertyTest || hasOwnProp(input, property); 3670 } 3671 3672 return objectTest && propertyTest; 3673 } 3674 3675 function isNumberOrStringArray(input) { 3676 var arrayTest = isArray(input), 3677 dataTypeTest = false; 3678 if (arrayTest) { 3679 dataTypeTest = 3680 input.filter(function (item) { 3681 return !isNumber(item) && isString(input); 3682 }).length === 0; 3683 } 3684 return arrayTest && dataTypeTest; 3685 } 3686 3687 function isCalendarSpec(input) { 3688 var objectTest = isObject(input) && !isObjectEmpty(input), 3689 propertyTest = false, 3690 properties = [ 3691 'sameDay', 3692 'nextDay', 3693 'lastDay', 3694 'nextWeek', 3695 'lastWeek', 3696 'sameElse', 3697 ], 3698 i, 3699 property; 3700 3701 for (i = 0; i < properties.length; i += 1) { 3702 property = properties[i]; 3703 propertyTest = propertyTest || hasOwnProp(input, property); 3704 } 3705 3706 return objectTest && propertyTest; 3707 } 3708 3709 function getCalendarFormat(myMoment, now) { 3710 var diff = myMoment.diff(now, 'days', true); 3711 return diff < -6 3712 ? 'sameElse' 3713 : diff < -1 3714 ? 'lastWeek' 3715 : diff < 0 3716 ? 'lastDay' 3717 : diff < 1 3718 ? 'sameDay' 3719 : diff < 2 3720 ? 'nextDay' 3721 : diff < 7 3722 ? 'nextWeek' 3723 : 'sameElse'; 3724 } 3725 3726 function calendar$1(time, formats) { 3727 // Support for single parameter, formats only overload to the calendar function 3728 if (arguments.length === 1) { 3729 if (isMomentInput(arguments[0])) { 3730 time = arguments[0]; 3731 formats = undefined; 3732 } else if (isCalendarSpec(arguments[0])) { 3733 formats = arguments[0]; 3734 time = undefined; 3735 } 3736 } 3737 // We want to compare the start of today, vs this. 3738 // Getting start-of-today depends on whether we're local/utc/offset or not. 3739 var now = time || createLocal(), 3740 sod = cloneWithOffset(now, this).startOf('day'), 3741 format = hooks.calendarFormat(this, sod) || 'sameElse', 3742 output = 3743 formats && 3744 (isFunction(formats[format]) 3745 ? formats[format].call(this, now) 3746 : formats[format]); 3747 3748 return this.format( 3749 output || this.localeData().calendar(format, this, createLocal(now)) 3750 ); 3751 } 3752 3753 function clone() { 3754 return new Moment(this); 3755 } 3756 3757 function isAfter(input, units) { 3758 var localInput = isMoment(input) ? input : createLocal(input); 3759 if (!(this.isValid() && localInput.isValid())) { 3760 return false; 3761 } 3762 units = normalizeUnits(units) || 'millisecond'; 3763 if (units === 'millisecond') { 3764 return this.valueOf() > localInput.valueOf(); 3765 } else { 3766 return localInput.valueOf() < this.clone().startOf(units).valueOf(); 3767 } 3768 } 3769 3770 function isBefore(input, units) { 3771 var localInput = isMoment(input) ? input : createLocal(input); 3772 if (!(this.isValid() && localInput.isValid())) { 3773 return false; 3774 } 3775 units = normalizeUnits(units) || 'millisecond'; 3776 if (units === 'millisecond') { 3777 return this.valueOf() < localInput.valueOf(); 3778 } else { 3779 return this.clone().endOf(units).valueOf() < localInput.valueOf(); 3780 } 3781 } 3782 3783 function isBetween(from, to, units, inclusivity) { 3784 var localFrom = isMoment(from) ? from : createLocal(from), 3785 localTo = isMoment(to) ? to : createLocal(to); 3786 if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) { 3787 return false; 3788 } 3789 inclusivity = inclusivity || '()'; 3790 return ( 3791 (inclusivity[0] === '(' 3792 ? this.isAfter(localFrom, units) 3793 : !this.isBefore(localFrom, units)) && 3794 (inclusivity[1] === ')' 3795 ? this.isBefore(localTo, units) 3796 : !this.isAfter(localTo, units)) 3797 ); 3798 } 3799 3800 function isSame(input, units) { 3801 var localInput = isMoment(input) ? input : createLocal(input), 3802 inputMs; 3803 if (!(this.isValid() && localInput.isValid())) { 3804 return false; 3805 } 3806 units = normalizeUnits(units) || 'millisecond'; 3807 if (units === 'millisecond') { 3808 return this.valueOf() === localInput.valueOf(); 3809 } else { 3810 inputMs = localInput.valueOf(); 3811 return ( 3812 this.clone().startOf(units).valueOf() <= inputMs && 3813 inputMs <= this.clone().endOf(units).valueOf() 3814 ); 3815 } 3816 } 3817 3818 function isSameOrAfter(input, units) { 3819 return this.isSame(input, units) || this.isAfter(input, units); 3820 } 3821 3822 function isSameOrBefore(input, units) { 3823 return this.isSame(input, units) || this.isBefore(input, units); 3824 } 3825 3826 function diff(input, units, asFloat) { 3827 var that, zoneDelta, output; 3828 3829 if (!this.isValid()) { 3830 return NaN; 3831 } 3832 3833 that = cloneWithOffset(input, this); 3834 3835 if (!that.isValid()) { 3836 return NaN; 3837 } 3838 3839 zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4; 3840 3841 units = normalizeUnits(units); 3842 3843 switch (units) { 3844 case 'year': 3845 output = monthDiff(this, that) / 12; 3846 break; 3847 case 'month': 3848 output = monthDiff(this, that); 3849 break; 3850 case 'quarter': 3851 output = monthDiff(this, that) / 3; 3852 break; 3853 case 'second': 3854 output = (this - that) / 1e3; 3855 break; // 1000 3856 case 'minute': 3857 output = (this - that) / 6e4; 3858 break; // 1000 * 60 3859 case 'hour': 3860 output = (this - that) / 36e5; 3861 break; // 1000 * 60 * 60 3862 case 'day': 3863 output = (this - that - zoneDelta) / 864e5; 3864 break; // 1000 * 60 * 60 * 24, negate dst 3865 case 'week': 3866 output = (this - that - zoneDelta) / 6048e5; 3867 break; // 1000 * 60 * 60 * 24 * 7, negate dst 3868 default: 3869 output = this - that; 3870 } 3871 3872 return asFloat ? output : absFloor(output); 3873 } 3874 3875 function monthDiff(a, b) { 3876 if (a.date() < b.date()) { 3877 // end-of-month calculations work correct when the start month has more 3878 // days than the end month. 3879 return -monthDiff(b, a); 3880 } 3881 // difference in months 3882 var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month()), 3883 // b is in (anchor - 1 month, anchor + 1 month) 3884 anchor = a.clone().add(wholeMonthDiff, 'months'), 3885 anchor2, 3886 adjust; 3887 3888 if (b - anchor < 0) { 3889 anchor2 = a.clone().add(wholeMonthDiff - 1, 'months'); 3890 // linear across the month 3891 adjust = (b - anchor) / (anchor - anchor2); 3892 } else { 3893 anchor2 = a.clone().add(wholeMonthDiff + 1, 'months'); 3894 // linear across the month 3895 adjust = (b - anchor) / (anchor2 - anchor); 3896 } 3897 3898 //check for negative zero, return zero if negative zero 3899 return -(wholeMonthDiff + adjust) || 0; 3900 } 3901 3902 hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ'; 3903 hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]'; 3904 3905 function toString() { 3906 return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ'); 3907 } 3908 3909 function toISOString(keepOffset) { 3910 if (!this.isValid()) { 3911 return null; 3912 } 3913 var utc = keepOffset !== true, 3914 m = utc ? this.clone().utc() : this; 3915 if (m.year() < 0 || m.year() > 9999) { 3916 return formatMoment( 3917 m, 3918 utc 3919 ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]' 3920 : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ' 3921 ); 3922 } 3923 if (isFunction(Date.prototype.toISOString)) { 3924 // native implementation is ~50x faster, use it when we can 3925 if (utc) { 3926 return this.toDate().toISOString(); 3927 } else { 3928 return new Date(this.valueOf() + this.utcOffset() * 60 * 1000) 3929 .toISOString() 3930 .replace('Z', formatMoment(m, 'Z')); 3931 } 3932 } 3933 return formatMoment( 3934 m, 3935 utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ' 3936 ); 3937 } 3938 3939 /** 3940 * Return a human readable representation of a moment that can 3941 * also be evaluated to get a new moment which is the same 3942 * 3943 * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects 3944 */ 3945 function inspect() { 3946 if (!this.isValid()) { 3947 return 'moment.invalid(/* ' + this._i + ' */)'; 3948 } 3949 var func = 'moment', 3950 zone = '', 3951 prefix, 3952 year, 3953 datetime, 3954 suffix; 3955 if (!this.isLocal()) { 3956 func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone'; 3957 zone = 'Z'; 3958 } 3959 prefix = '[' + func + '("]'; 3960 year = 0 <= this.year() && this.year() <= 9999 ? 'YYYY' : 'YYYYYY'; 3961 datetime = '-MM-DD[T]HH:mm:ss.SSS'; 3962 suffix = zone + '[")]'; 3963 3964 return this.format(prefix + year + datetime + suffix); 3965 } 3966 3967 function format(inputString) { 3968 if (!inputString) { 3969 inputString = this.isUtc() 3970 ? hooks.defaultFormatUtc 3971 : hooks.defaultFormat; 3972 } 3973 var output = formatMoment(this, inputString); 3974 return this.localeData().postformat(output); 3975 } 3976 3977 function from(time, withoutSuffix) { 3978 if ( 3979 this.isValid() && 3980 ((isMoment(time) && time.isValid()) || createLocal(time).isValid()) 3981 ) { 3982 return createDuration({ to: this, from: time }) 3983 .locale(this.locale()) 3984 .humanize(!withoutSuffix); 3985 } else { 3986 return this.localeData().invalidDate(); 3987 } 3988 } 3989 3990 function fromNow(withoutSuffix) { 3991 return this.from(createLocal(), withoutSuffix); 3992 } 3993 3994 function to(time, withoutSuffix) { 3995 if ( 3996 this.isValid() && 3997 ((isMoment(time) && time.isValid()) || createLocal(time).isValid()) 3998 ) { 3999 return createDuration({ from: this, to: time }) 4000 .locale(this.locale()) 4001 .humanize(!withoutSuffix); 4002 } else { 4003 return this.localeData().invalidDate(); 4004 } 4005 } 4006 4007 function toNow(withoutSuffix) { 4008 return this.to(createLocal(), withoutSuffix); 4009 } 4010 4011 // If passed a locale key, it will set the locale for this 4012 // instance. Otherwise, it will return the locale configuration 4013 // variables for this instance. 4014 function locale(key) { 4015 var newLocaleData; 4016 4017 if (key === undefined) { 4018 return this._locale._abbr; 4019 } else { 4020 newLocaleData = getLocale(key); 4021 if (newLocaleData != null) { 4022 this._locale = newLocaleData; 4023 } 4024 return this; 4025 } 4026 } 4027 4028 var lang = deprecate( 4029 'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.', 4030 function (key) { 4031 if (key === undefined) { 4032 return this.localeData(); 4033 } else { 4034 return this.locale(key); 4035 } 4036 } 4037 ); 4038 4039 function localeData() { 4040 return this._locale; 4041 } 4042 4043 var MS_PER_SECOND = 1000, 4044 MS_PER_MINUTE = 60 * MS_PER_SECOND, 4045 MS_PER_HOUR = 60 * MS_PER_MINUTE, 4046 MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR; 4047 4048 // actual modulo - handles negative numbers (for dates before 1970): 4049 function mod$1(dividend, divisor) { 4050 return ((dividend % divisor) + divisor) % divisor; 4051 } 4052 4053 function localStartOfDate(y, m, d) { 4054 // the date constructor remaps years 0-99 to 1900-1999 4055 if (y < 100 && y >= 0) { 4056 // preserve leap years using a full 400 year cycle, then reset 4057 return new Date(y + 400, m, d) - MS_PER_400_YEARS; 4058 } else { 4059 return new Date(y, m, d).valueOf(); 4060 } 4061 } 4062 4063 function utcStartOfDate(y, m, d) { 4064 // Date.UTC remaps years 0-99 to 1900-1999 4065 if (y < 100 && y >= 0) { 4066 // preserve leap years using a full 400 year cycle, then reset 4067 return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS; 4068 } else { 4069 return Date.UTC(y, m, d); 4070 } 4071 } 4072 4073 function startOf(units) { 4074 var time, startOfDate; 4075 units = normalizeUnits(units); 4076 if (units === undefined || units === 'millisecond' || !this.isValid()) { 4077 return this; 4078 } 4079 4080 startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate; 4081 4082 switch (units) { 4083 case 'year': 4084 time = startOfDate(this.year(), 0, 1); 4085 break; 4086 case 'quarter': 4087 time = startOfDate( 4088 this.year(), 4089 this.month() - (this.month() % 3), 4090 1 4091 ); 4092 break; 4093 case 'month': 4094 time = startOfDate(this.year(), this.month(), 1); 4095 break; 4096 case 'week': 4097 time = startOfDate( 4098 this.year(), 4099 this.month(), 4100 this.date() - this.weekday() 4101 ); 4102 break; 4103 case 'isoWeek': 4104 time = startOfDate( 4105 this.year(), 4106 this.month(), 4107 this.date() - (this.isoWeekday() - 1) 4108 ); 4109 break; 4110 case 'day': 4111 case 'date': 4112 time = startOfDate(this.year(), this.month(), this.date()); 4113 break; 4114 case 'hour': 4115 time = this._d.valueOf(); 4116 time -= mod$1( 4117 time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), 4118 MS_PER_HOUR 4119 ); 4120 break; 4121 case 'minute': 4122 time = this._d.valueOf(); 4123 time -= mod$1(time, MS_PER_MINUTE); 4124 break; 4125 case 'second': 4126 time = this._d.valueOf(); 4127 time -= mod$1(time, MS_PER_SECOND); 4128 break; 4129 } 4130 4131 this._d.setTime(time); 4132 hooks.updateOffset(this, true); 4133 return this; 4134 } 4135 4136 function endOf(units) { 4137 var time, startOfDate; 4138 units = normalizeUnits(units); 4139 if (units === undefined || units === 'millisecond' || !this.isValid()) { 4140 return this; 4141 } 4142 4143 startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate; 4144 4145 switch (units) { 4146 case 'year': 4147 time = startOfDate(this.year() + 1, 0, 1) - 1; 4148 break; 4149 case 'quarter': 4150 time = 4151 startOfDate( 4152 this.year(), 4153 this.month() - (this.month() % 3) + 3, 4154 1 4155 ) - 1; 4156 break; 4157 case 'month': 4158 time = startOfDate(this.year(), this.month() + 1, 1) - 1; 4159 break; 4160 case 'week': 4161 time = 4162 startOfDate( 4163 this.year(), 4164 this.month(), 4165 this.date() - this.weekday() + 7 4166 ) - 1; 4167 break; 4168 case 'isoWeek': 4169 time = 4170 startOfDate( 4171 this.year(), 4172 this.month(), 4173 this.date() - (this.isoWeekday() - 1) + 7 4174 ) - 1; 4175 break; 4176 case 'day': 4177 case 'date': 4178 time = startOfDate(this.year(), this.month(), this.date() + 1) - 1; 4179 break; 4180 case 'hour': 4181 time = this._d.valueOf(); 4182 time += 4183 MS_PER_HOUR - 4184 mod$1( 4185 time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), 4186 MS_PER_HOUR 4187 ) - 4188 1; 4189 break; 4190 case 'minute': 4191 time = this._d.valueOf(); 4192 time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1; 4193 break; 4194 case 'second': 4195 time = this._d.valueOf(); 4196 time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1; 4197 break; 4198 } 4199 4200 this._d.setTime(time); 4201 hooks.updateOffset(this, true); 4202 return this; 4203 } 4204 4205 function valueOf() { 4206 return this._d.valueOf() - (this._offset || 0) * 60000; 4207 } 4208 4209 function unix() { 4210 return Math.floor(this.valueOf() / 1000); 4211 } 4212 4213 function toDate() { 4214 return new Date(this.valueOf()); 4215 } 4216 4217 function toArray() { 4218 var m = this; 4219 return [ 4220 m.year(), 4221 m.month(), 4222 m.date(), 4223 m.hour(), 4224 m.minute(), 4225 m.second(), 4226 m.millisecond(), 4227 ]; 4228 } 4229 4230 function toObject() { 4231 var m = this; 4232 return { 4233 years: m.year(), 4234 months: m.month(), 4235 date: m.date(), 4236 hours: m.hours(), 4237 minutes: m.minutes(), 4238 seconds: m.seconds(), 4239 milliseconds: m.milliseconds(), 4240 }; 4241 } 4242 4243 function toJSON() { 4244 // new Date(NaN).toJSON() === null 4245 return this.isValid() ? this.toISOString() : null; 4246 } 4247 4248 function isValid$2() { 4249 return isValid(this); 4250 } 4251 4252 function parsingFlags() { 4253 return extend({}, getParsingFlags(this)); 4254 } 4255 4256 function invalidAt() { 4257 return getParsingFlags(this).overflow; 4258 } 4259 4260 function creationData() { 4261 return { 4262 input: this._i, 4263 format: this._f, 4264 locale: this._locale, 4265 isUTC: this._isUTC, 4266 strict: this._strict, 4267 }; 4268 } 4269 4270 addFormatToken('N', 0, 0, 'eraAbbr'); 4271 addFormatToken('NN', 0, 0, 'eraAbbr'); 4272 addFormatToken('NNN', 0, 0, 'eraAbbr'); 4273 addFormatToken('NNNN', 0, 0, 'eraName'); 4274 addFormatToken('NNNNN', 0, 0, 'eraNarrow'); 4275 4276 addFormatToken('y', ['y', 1], 'yo', 'eraYear'); 4277 addFormatToken('y', ['yy', 2], 0, 'eraYear'); 4278 addFormatToken('y', ['yyy', 3], 0, 'eraYear'); 4279 addFormatToken('y', ['yyyy', 4], 0, 'eraYear'); 4280 4281 addRegexToken('N', matchEraAbbr); 4282 addRegexToken('NN', matchEraAbbr); 4283 addRegexToken('NNN', matchEraAbbr); 4284 addRegexToken('NNNN', matchEraName); 4285 addRegexToken('NNNNN', matchEraNarrow); 4286 4287 addParseToken(['N', 'NN', 'NNN', 'NNNN', 'NNNNN'], function ( 4288 input, 4289 array, 4290 config, 4291 token 4292 ) { 4293 var era = config._locale.erasParse(input, token, config._strict); 4294 if (era) { 4295 getParsingFlags(config).era = era; 4296 } else { 4297 getParsingFlags(config).invalidEra = input; 4298 } 4299 }); 4300 4301 addRegexToken('y', matchUnsigned); 4302 addRegexToken('yy', matchUnsigned); 4303 addRegexToken('yyy', matchUnsigned); 4304 addRegexToken('yyyy', matchUnsigned); 4305 addRegexToken('yo', matchEraYearOrdinal); 4306 4307 addParseToken(['y', 'yy', 'yyy', 'yyyy'], YEAR); 4308 addParseToken(['yo'], function (input, array, config, token) { 4309 var match; 4310 if (config._locale._eraYearOrdinalRegex) { 4311 match = input.match(config._locale._eraYearOrdinalRegex); 4312 } 4313 4314 if (config._locale.eraYearOrdinalParse) { 4315 array[YEAR] = config._locale.eraYearOrdinalParse(input, match); 4316 } else { 4317 array[YEAR] = parseInt(input, 10); 4318 } 4319 }); 4320 4321 function localeEras(m, format) { 4322 var i, 4323 l, 4324 date, 4325 eras = this._eras || getLocale('en')._eras; 4326 for (i = 0, l = eras.length; i < l; ++i) { 4327 switch (typeof eras[i].since) { 4328 case 'string': 4329 // truncate time 4330 date = hooks(eras[i].since).startOf('day'); 4331 eras[i].since = date.valueOf(); 4332 break; 4333 } 4334 4335 switch (typeof eras[i].until) { 4336 case 'undefined': 4337 eras[i].until = +Infinity; 4338 break; 4339 case 'string': 4340 // truncate time 4341 date = hooks(eras[i].until).startOf('day').valueOf(); 4342 eras[i].until = date.valueOf(); 4343 break; 4344 } 4345 } 4346 return eras; 4347 } 4348 4349 function localeErasParse(eraName, format, strict) { 4350 var i, 4351 l, 4352 eras = this.eras(), 4353 name, 4354 abbr, 4355 narrow; 4356 eraName = eraName.toUpperCase(); 4357 4358 for (i = 0, l = eras.length; i < l; ++i) { 4359 name = eras[i].name.toUpperCase(); 4360 abbr = eras[i].abbr.toUpperCase(); 4361 narrow = eras[i].narrow.toUpperCase(); 4362 4363 if (strict) { 4364 switch (format) { 4365 case 'N': 4366 case 'NN': 4367 case 'NNN': 4368 if (abbr === eraName) { 4369 return eras[i]; 4370 } 4371 break; 4372 4373 case 'NNNN': 4374 if (name === eraName) { 4375 return eras[i]; 4376 } 4377 break; 4378 4379 case 'NNNNN': 4380 if (narrow === eraName) { 4381 return eras[i]; 4382 } 4383 break; 4384 } 4385 } else if ([name, abbr, narrow].indexOf(eraName) >= 0) { 4386 return eras[i]; 4387 } 4388 } 4389 } 4390 4391 function localeErasConvertYear(era, year) { 4392 var dir = era.since <= era.until ? +1 : -1; 4393 if (year === undefined) { 4394 return hooks(era.since).year(); 4395 } else { 4396 return hooks(era.since).year() + (year - era.offset) * dir; 4397 } 4398 } 4399 4400 function getEraName() { 4401 var i, 4402 l, 4403 val, 4404 eras = this.localeData().eras(); 4405 for (i = 0, l = eras.length; i < l; ++i) { 4406 // truncate time 4407 val = this.startOf('day').valueOf(); 4408 4409 if (eras[i].since <= val && val <= eras[i].until) { 4410 return eras[i].name; 4411 } 4412 if (eras[i].until <= val && val <= eras[i].since) { 4413 return eras[i].name; 4414 } 4415 } 4416 4417 return ''; 4418 } 4419 4420 function getEraNarrow() { 4421 var i, 4422 l, 4423 val, 4424 eras = this.localeData().eras(); 4425 for (i = 0, l = eras.length; i < l; ++i) { 4426 // truncate time 4427 val = this.startOf('day').valueOf(); 4428 4429 if (eras[i].since <= val && val <= eras[i].until) { 4430 return eras[i].narrow; 4431 } 4432 if (eras[i].until <= val && val <= eras[i].since) { 4433 return eras[i].narrow; 4434 } 4435 } 4436 4437 return ''; 4438 } 4439 4440 function getEraAbbr() { 4441 var i, 4442 l, 4443 val, 4444 eras = this.localeData().eras(); 4445 for (i = 0, l = eras.length; i < l; ++i) { 4446 // truncate time 4447 val = this.startOf('day').valueOf(); 4448 4449 if (eras[i].since <= val && val <= eras[i].until) { 4450 return eras[i].abbr; 4451 } 4452 if (eras[i].until <= val && val <= eras[i].since) { 4453 return eras[i].abbr; 4454 } 4455 } 4456 4457 return ''; 4458 } 4459 4460 function getEraYear() { 4461 var i, 4462 l, 4463 dir, 4464 val, 4465 eras = this.localeData().eras(); 4466 for (i = 0, l = eras.length; i < l; ++i) { 4467 dir = eras[i].since <= eras[i].until ? +1 : -1; 4468 4469 // truncate time 4470 val = this.startOf('day').valueOf(); 4471 4472 if ( 4473 (eras[i].since <= val && val <= eras[i].until) || 4474 (eras[i].until <= val && val <= eras[i].since) 4475 ) { 4476 return ( 4477 (this.year() - hooks(eras[i].since).year()) * dir + 4478 eras[i].offset 4479 ); 4480 } 4481 } 4482 4483 return this.year(); 4484 } 4485 4486 function erasNameRegex(isStrict) { 4487 if (!hasOwnProp(this, '_erasNameRegex')) { 4488 computeErasParse.call(this); 4489 } 4490 return isStrict ? this._erasNameRegex : this._erasRegex; 4491 } 4492 4493 function erasAbbrRegex(isStrict) { 4494 if (!hasOwnProp(this, '_erasAbbrRegex')) { 4495 computeErasParse.call(this); 4496 } 4497 return isStrict ? this._erasAbbrRegex : this._erasRegex; 4498 } 4499 4500 function erasNarrowRegex(isStrict) { 4501 if (!hasOwnProp(this, '_erasNarrowRegex')) { 4502 computeErasParse.call(this); 4503 } 4504 return isStrict ? this._erasNarrowRegex : this._erasRegex; 4505 } 4506 4507 function matchEraAbbr(isStrict, locale) { 4508 return locale.erasAbbrRegex(isStrict); 4509 } 4510 4511 function matchEraName(isStrict, locale) { 4512 return locale.erasNameRegex(isStrict); 4513 } 4514 4515 function matchEraNarrow(isStrict, locale) { 4516 return locale.erasNarrowRegex(isStrict); 4517 } 4518 4519 function matchEraYearOrdinal(isStrict, locale) { 4520 return locale._eraYearOrdinalRegex || matchUnsigned; 4521 } 4522 4523 function computeErasParse() { 4524 var abbrPieces = [], 4525 namePieces = [], 4526 narrowPieces = [], 4527 mixedPieces = [], 4528 i, 4529 l, 4530 eras = this.eras(); 4531 4532 for (i = 0, l = eras.length; i < l; ++i) { 4533 namePieces.push(regexEscape(eras[i].name)); 4534 abbrPieces.push(regexEscape(eras[i].abbr)); 4535 narrowPieces.push(regexEscape(eras[i].narrow)); 4536 4537 mixedPieces.push(regexEscape(eras[i].name)); 4538 mixedPieces.push(regexEscape(eras[i].abbr)); 4539 mixedPieces.push(regexEscape(eras[i].narrow)); 4540 } 4541 4542 this._erasRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i'); 4543 this._erasNameRegex = new RegExp('^(' + namePieces.join('|') + ')', 'i'); 4544 this._erasAbbrRegex = new RegExp('^(' + abbrPieces.join('|') + ')', 'i'); 4545 this._erasNarrowRegex = new RegExp( 4546 '^(' + narrowPieces.join('|') + ')', 4547 'i' 4548 ); 4549 } 4550 4551 // FORMATTING 4552 4553 addFormatToken(0, ['gg', 2], 0, function () { 4554 return this.weekYear() % 100; 4555 }); 4556 4557 addFormatToken(0, ['GG', 2], 0, function () { 4558 return this.isoWeekYear() % 100; 4559 }); 4560 4561 function addWeekYearFormatToken(token, getter) { 4562 addFormatToken(0, [token, token.length], 0, getter); 4563 } 4564 4565 addWeekYearFormatToken('gggg', 'weekYear'); 4566 addWeekYearFormatToken('ggggg', 'weekYear'); 4567 addWeekYearFormatToken('GGGG', 'isoWeekYear'); 4568 addWeekYearFormatToken('GGGGG', 'isoWeekYear'); 4569 4570 // ALIASES 4571 4572 addUnitAlias('weekYear', 'gg'); 4573 addUnitAlias('isoWeekYear', 'GG'); 4574 4575 // PRIORITY 4576 4577 addUnitPriority('weekYear', 1); 4578 addUnitPriority('isoWeekYear', 1); 4579 4580 // PARSING 4581 4582 addRegexToken('G', matchSigned); 4583 addRegexToken('g', matchSigned); 4584 addRegexToken('GG', match1to2, match2); 4585 addRegexToken('gg', match1to2, match2); 4586 addRegexToken('GGGG', match1to4, match4); 4587 addRegexToken('gggg', match1to4, match4); 4588 addRegexToken('GGGGG', match1to6, match6); 4589 addRegexToken('ggggg', match1to6, match6); 4590 4591 addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function ( 4592 input, 4593 week, 4594 config, 4595 token 4596 ) { 4597 week[token.substr(0, 2)] = toInt(input); 4598 }); 4599 4600 addWeekParseToken(['gg', 'GG'], function (input, week, config, token) { 4601 week[token] = hooks.parseTwoDigitYear(input); 4602 }); 4603 4604 // MOMENTS 4605 4606 function getSetWeekYear(input) { 4607 return getSetWeekYearHelper.call( 4608 this, 4609 input, 4610 this.week(), 4611 this.weekday(), 4612 this.localeData()._week.dow, 4613 this.localeData()._week.doy 4614 ); 4615 } 4616 4617 function getSetISOWeekYear(input) { 4618 return getSetWeekYearHelper.call( 4619 this, 4620 input, 4621 this.isoWeek(), 4622 this.isoWeekday(), 4623 1, 4624 4 4625 ); 4626 } 4627 4628 function getISOWeeksInYear() { 4629 return weeksInYear(this.year(), 1, 4); 4630 } 4631 4632 function getISOWeeksInISOWeekYear() { 4633 return weeksInYear(this.isoWeekYear(), 1, 4); 4634 } 4635 4636 function getWeeksInYear() { 4637 var weekInfo = this.localeData()._week; 4638 return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy); 4639 } 4640 4641 function getWeeksInWeekYear() { 4642 var weekInfo = this.localeData()._week; 4643 return weeksInYear(this.weekYear(), weekInfo.dow, weekInfo.doy); 4644 } 4645 4646 function getSetWeekYearHelper(input, week, weekday, dow, doy) { 4647 var weeksTarget; 4648 if (input == null) { 4649 return weekOfYear(this, dow, doy).year; 4650 } else { 4651 weeksTarget = weeksInYear(input, dow, doy); 4652 if (week > weeksTarget) { 4653 week = weeksTarget; 4654 } 4655 return setWeekAll.call(this, input, week, weekday, dow, doy); 4656 } 4657 } 4658 4659 function setWeekAll(weekYear, week, weekday, dow, doy) { 4660 var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy), 4661 date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear); 4662 4663 this.year(date.getUTCFullYear()); 4664 this.month(date.getUTCMonth()); 4665 this.date(date.getUTCDate()); 4666 return this; 4667 } 4668 4669 // FORMATTING 4670 4671 addFormatToken('Q', 0, 'Qo', 'quarter'); 4672 4673 // ALIASES 4674 4675 addUnitAlias('quarter', 'Q'); 4676 4677 // PRIORITY 4678 4679 addUnitPriority('quarter', 7); 4680 4681 // PARSING 4682 4683 addRegexToken('Q', match1); 4684 addParseToken('Q', function (input, array) { 4685 array[MONTH] = (toInt(input) - 1) * 3; 4686 }); 4687 4688 // MOMENTS 4689 4690 function getSetQuarter(input) { 4691 return input == null 4692 ? Math.ceil((this.month() + 1) / 3) 4693 : this.month((input - 1) * 3 + (this.month() % 3)); 4694 } 4695 4696 // FORMATTING 4697 4698 addFormatToken('D', ['DD', 2], 'Do', 'date'); 4699 4700 // ALIASES 4701 4702 addUnitAlias('date', 'D'); 4703 4704 // PRIORITY 4705 addUnitPriority('date', 9); 4706 4707 // PARSING 4708 4709 addRegexToken('D', match1to2); 4710 addRegexToken('DD', match1to2, match2); 4711 addRegexToken('Do', function (isStrict, locale) { 4712 // TODO: Remove "ordinalParse" fallback in next major release. 4713 return isStrict 4714 ? locale._dayOfMonthOrdinalParse || locale._ordinalParse 4715 : locale._dayOfMonthOrdinalParseLenient; 4716 }); 4717 4718 addParseToken(['D', 'DD'], DATE); 4719 addParseToken('Do', function (input, array) { 4720 array[DATE] = toInt(input.match(match1to2)[0]); 4721 }); 4722 4723 // MOMENTS 4724 4725 var getSetDayOfMonth = makeGetSet('Date', true); 4726 4727 // FORMATTING 4728 4729 addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear'); 4730 4731 // ALIASES 4732 4733 addUnitAlias('dayOfYear', 'DDD'); 4734 4735 // PRIORITY 4736 addUnitPriority('dayOfYear', 4); 4737 4738 // PARSING 4739 4740 addRegexToken('DDD', match1to3); 4741 addRegexToken('DDDD', match3); 4742 addParseToken(['DDD', 'DDDD'], function (input, array, config) { 4743 config._dayOfYear = toInt(input); 4744 }); 4745 4746 // HELPERS 4747 4748 // MOMENTS 4749 4750 function getSetDayOfYear(input) { 4751 var dayOfYear = 4752 Math.round( 4753 (this.clone().startOf('day') - this.clone().startOf('year')) / 864e5 4754 ) + 1; 4755 return input == null ? dayOfYear : this.add(input - dayOfYear, 'd'); 4756 } 4757 4758 // FORMATTING 4759 4760 addFormatToken('m', ['mm', 2], 0, 'minute'); 4761 4762 // ALIASES 4763 4764 addUnitAlias('minute', 'm'); 4765 4766 // PRIORITY 4767 4768 addUnitPriority('minute', 14); 4769 4770 // PARSING 4771 4772 addRegexToken('m', match1to2); 4773 addRegexToken('mm', match1to2, match2); 4774 addParseToken(['m', 'mm'], MINUTE); 4775 4776 // MOMENTS 4777 4778 var getSetMinute = makeGetSet('Minutes', false); 4779 4780 // FORMATTING 4781 4782 addFormatToken('s', ['ss', 2], 0, 'second'); 4783 4784 // ALIASES 4785 4786 addUnitAlias('second', 's'); 4787 4788 // PRIORITY 4789 4790 addUnitPriority('second', 15); 4791 4792 // PARSING 4793 4794 addRegexToken('s', match1to2); 4795 addRegexToken('ss', match1to2, match2); 4796 addParseToken(['s', 'ss'], SECOND); 4797 4798 // MOMENTS 4799 4800 var getSetSecond = makeGetSet('Seconds', false); 4801 4802 // FORMATTING 4803 4804 addFormatToken('S', 0, 0, function () { 4805 return ~~(this.millisecond() / 100); 4806 }); 4807 4808 addFormatToken(0, ['SS', 2], 0, function () { 4809 return ~~(this.millisecond() / 10); 4810 }); 4811 4812 addFormatToken(0, ['SSS', 3], 0, 'millisecond'); 4813 addFormatToken(0, ['SSSS', 4], 0, function () { 4814 return this.millisecond() * 10; 4815 }); 4816 addFormatToken(0, ['SSSSS', 5], 0, function () { 4817 return this.millisecond() * 100; 4818 }); 4819 addFormatToken(0, ['SSSSSS', 6], 0, function () { 4820 return this.millisecond() * 1000; 4821 }); 4822 addFormatToken(0, ['SSSSSSS', 7], 0, function () { 4823 return this.millisecond() * 10000; 4824 }); 4825 addFormatToken(0, ['SSSSSSSS', 8], 0, function () { 4826 return this.millisecond() * 100000; 4827 }); 4828 addFormatToken(0, ['SSSSSSSSS', 9], 0, function () { 4829 return this.millisecond() * 1000000; 4830 }); 4831 4832 // ALIASES 4833 4834 addUnitAlias('millisecond', 'ms'); 4835 4836 // PRIORITY 4837 4838 addUnitPriority('millisecond', 16); 4839 4840 // PARSING 4841 4842 addRegexToken('S', match1to3, match1); 4843 addRegexToken('SS', match1to3, match2); 4844 addRegexToken('SSS', match1to3, match3); 4845 4846 var token, getSetMillisecond; 4847 for (token = 'SSSS'; token.length <= 9; token += 'S') { 4848 addRegexToken(token, matchUnsigned); 4849 } 4850 4851 function parseMs(input, array) { 4852 array[MILLISECOND] = toInt(('0.' + input) * 1000); 4853 } 4854 4855 for (token = 'S'; token.length <= 9; token += 'S') { 4856 addParseToken(token, parseMs); 4857 } 4858 4859 getSetMillisecond = makeGetSet('Milliseconds', false); 4860 4861 // FORMATTING 4862 4863 addFormatToken('z', 0, 0, 'zoneAbbr'); 4864 addFormatToken('zz', 0, 0, 'zoneName'); 4865 4866 // MOMENTS 4867 4868 function getZoneAbbr() { 4869 return this._isUTC ? 'UTC' : ''; 4870 } 4871 4872 function getZoneName() { 4873 return this._isUTC ? 'Coordinated Universal Time' : ''; 4874 } 4875 4876 var proto = Moment.prototype; 4877 4878 proto.add = add; 4879 proto.calendar = calendar$1; 4880 proto.clone = clone; 4881 proto.diff = diff; 4882 proto.endOf = endOf; 4883 proto.format = format; 4884 proto.from = from; 4885 proto.fromNow = fromNow; 4886 proto.to = to; 4887 proto.toNow = toNow; 4888 proto.get = stringGet; 4889 proto.invalidAt = invalidAt; 4890 proto.isAfter = isAfter; 4891 proto.isBefore = isBefore; 4892 proto.isBetween = isBetween; 4893 proto.isSame = isSame; 4894 proto.isSameOrAfter = isSameOrAfter; 4895 proto.isSameOrBefore = isSameOrBefore; 4896 proto.isValid = isValid$2; 4897 proto.lang = lang; 4898 proto.locale = locale; 4899 proto.localeData = localeData; 4900 proto.max = prototypeMax; 4901 proto.min = prototypeMin; 4902 proto.parsingFlags = parsingFlags; 4903 proto.set = stringSet; 4904 proto.startOf = startOf; 4905 proto.subtract = subtract; 4906 proto.toArray = toArray; 4907 proto.toObject = toObject; 4908 proto.toDate = toDate; 4909 proto.toISOString = toISOString; 4910 proto.inspect = inspect; 4911 if (typeof Symbol !== 'undefined' && Symbol.for != null) { 4912 proto[Symbol.for('nodejs.util.inspect.custom')] = function () { 4913 return 'Moment<' + this.format() + '>'; 4914 }; 4915 } 4916 proto.toJSON = toJSON; 4917 proto.toString = toString; 4918 proto.unix = unix; 4919 proto.valueOf = valueOf; 4920 proto.creationData = creationData; 4921 proto.eraName = getEraName; 4922 proto.eraNarrow = getEraNarrow; 4923 proto.eraAbbr = getEraAbbr; 4924 proto.eraYear = getEraYear; 4925 proto.year = getSetYear; 4926 proto.isLeapYear = getIsLeapYear; 4927 proto.weekYear = getSetWeekYear; 4928 proto.isoWeekYear = getSetISOWeekYear; 4929 proto.quarter = proto.quarters = getSetQuarter; 4930 proto.month = getSetMonth; 4931 proto.daysInMonth = getDaysInMonth; 4932 proto.week = proto.weeks = getSetWeek; 4933 proto.isoWeek = proto.isoWeeks = getSetISOWeek; 4934 proto.weeksInYear = getWeeksInYear; 4935 proto.weeksInWeekYear = getWeeksInWeekYear; 4936 proto.isoWeeksInYear = getISOWeeksInYear; 4937 proto.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear; 4938 proto.date = getSetDayOfMonth; 4939 proto.day = proto.days = getSetDayOfWeek; 4940 proto.weekday = getSetLocaleDayOfWeek; 4941 proto.isoWeekday = getSetISODayOfWeek; 4942 proto.dayOfYear = getSetDayOfYear; 4943 proto.hour = proto.hours = getSetHour; 4944 proto.minute = proto.minutes = getSetMinute; 4945 proto.second = proto.seconds = getSetSecond; 4946 proto.millisecond = proto.milliseconds = getSetMillisecond; 4947 proto.utcOffset = getSetOffset; 4948 proto.utc = setOffsetToUTC; 4949 proto.local = setOffsetToLocal; 4950 proto.parseZone = setOffsetToParsedOffset; 4951 proto.hasAlignedHourOffset = hasAlignedHourOffset; 4952 proto.isDST = isDaylightSavingTime; 4953 proto.isLocal = isLocal; 4954 proto.isUtcOffset = isUtcOffset; 4955 proto.isUtc = isUtc; 4956 proto.isUTC = isUtc; 4957 proto.zoneAbbr = getZoneAbbr; 4958 proto.zoneName = getZoneName; 4959 proto.dates = deprecate( 4960 'dates accessor is deprecated. Use date instead.', 4961 getSetDayOfMonth 4962 ); 4963 proto.months = deprecate( 4964 'months accessor is deprecated. Use month instead', 4965 getSetMonth 4966 ); 4967 proto.years = deprecate( 4968 'years accessor is deprecated. Use year instead', 4969 getSetYear 4970 ); 4971 proto.zone = deprecate( 4972 'moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', 4973 getSetZone 4974 ); 4975 proto.isDSTShifted = deprecate( 4976 'isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', 4977 isDaylightSavingTimeShifted 4978 ); 4979 4980 function createUnix(input) { 4981 return createLocal(input * 1000); 4982 } 4983 4984 function createInZone() { 4985 return createLocal.apply(null, arguments).parseZone(); 4986 } 4987 4988 function preParsePostFormat(string) { 4989 return string; 4990 } 4991 4992 var proto$1 = Locale.prototype; 4993 4994 proto$1.calendar = calendar; 4995 proto$1.longDateFormat = longDateFormat; 4996 proto$1.invalidDate = invalidDate; 4997 proto$1.ordinal = ordinal; 4998 proto$1.preparse = preParsePostFormat; 4999 proto$1.postformat = preParsePostFormat; 5000 proto$1.relativeTime = relativeTime; 5001 proto$1.pastFuture = pastFuture; 5002 proto$1.set = set; 5003 proto$1.eras = localeEras; 5004 proto$1.erasParse = localeErasParse; 5005 proto$1.erasConvertYear = localeErasConvertYear; 5006 proto$1.erasAbbrRegex = erasAbbrRegex; 5007 proto$1.erasNameRegex = erasNameRegex; 5008 proto$1.erasNarrowRegex = erasNarrowRegex; 5009 5010 proto$1.months = localeMonths; 5011 proto$1.monthsShort = localeMonthsShort; 5012 proto$1.monthsParse = localeMonthsParse; 5013 proto$1.monthsRegex = monthsRegex; 5014 proto$1.monthsShortRegex = monthsShortRegex; 5015 proto$1.week = localeWeek; 5016 proto$1.firstDayOfYear = localeFirstDayOfYear; 5017 proto$1.firstDayOfWeek = localeFirstDayOfWeek; 5018 5019 proto$1.weekdays = localeWeekdays; 5020 proto$1.weekdaysMin = localeWeekdaysMin; 5021 proto$1.weekdaysShort = localeWeekdaysShort; 5022 proto$1.weekdaysParse = localeWeekdaysParse; 5023 5024 proto$1.weekdaysRegex = weekdaysRegex; 5025 proto$1.weekdaysShortRegex = weekdaysShortRegex; 5026 proto$1.weekdaysMinRegex = weekdaysMinRegex; 5027 5028 proto$1.isPM = localeIsPM; 5029 proto$1.meridiem = localeMeridiem; 5030 5031 function get$1(format, index, field, setter) { 5032 var locale = getLocale(), 5033 utc = createUTC().set(setter, index); 5034 return locale[field](utc, format); 5035 } 5036 5037 function listMonthsImpl(format, index, field) { 5038 if (isNumber(format)) { 5039 index = format; 5040 format = undefined; 5041 } 5042 5043 format = format || ''; 5044 5045 if (index != null) { 5046 return get$1(format, index, field, 'month'); 5047 } 5048 5049 var i, 5050 out = []; 5051 for (i = 0; i < 12; i++) { 5052 out[i] = get$1(format, i, field, 'month'); 5053 } 5054 return out; 5055 } 5056 5057 // () 5058 // (5) 5059 // (fmt, 5) 5060 // (fmt) 5061 // (true) 5062 // (true, 5) 5063 // (true, fmt, 5) 5064 // (true, fmt) 5065 function listWeekdaysImpl(localeSorted, format, index, field) { 5066 if (typeof localeSorted === 'boolean') { 5067 if (isNumber(format)) { 5068 index = format; 5069 format = undefined; 5070 } 5071 5072 format = format || ''; 5073 } else { 5074 format = localeSorted; 5075 index = format; 5076 localeSorted = false; 5077 5078 if (isNumber(format)) { 5079 index = format; 5080 format = undefined; 5081 } 5082 5083 format = format || ''; 5084 } 5085 5086 var locale = getLocale(), 5087 shift = localeSorted ? locale._week.dow : 0, 5088 i, 5089 out = []; 5090 5091 if (index != null) { 5092 return get$1(format, (index + shift) % 7, field, 'day'); 5093 } 5094 5095 for (i = 0; i < 7; i++) { 5096 out[i] = get$1(format, (i + shift) % 7, field, 'day'); 5097 } 5098 return out; 5099 } 5100 5101 function listMonths(format, index) { 5102 return listMonthsImpl(format, index, 'months'); 5103 } 5104 5105 function listMonthsShort(format, index) { 5106 return listMonthsImpl(format, index, 'monthsShort'); 5107 } 5108 5109 function listWeekdays(localeSorted, format, index) { 5110 return listWeekdaysImpl(localeSorted, format, index, 'weekdays'); 5111 } 5112 5113 function listWeekdaysShort(localeSorted, format, index) { 5114 return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort'); 5115 } 5116 5117 function listWeekdaysMin(localeSorted, format, index) { 5118 return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin'); 5119 } 5120 5121 getSetGlobalLocale('en', { 5122 eras: [ 5123 { 5124 since: '0001-01-01', 5125 until: +Infinity, 5126 offset: 1, 5127 name: 'Anno Domini', 5128 narrow: 'AD', 5129 abbr: 'AD', 5130 }, 5131 { 5132 since: '0000-12-31', 5133 until: -Infinity, 5134 offset: 1, 5135 name: 'Before Christ', 5136 narrow: 'BC', 5137 abbr: 'BC', 5138 }, 5139 ], 5140 dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/, 5141 ordinal: function (number) { 5142 var b = number % 10, 5143 output = 5144 toInt((number % 100) / 10) === 1 5145 ? 'th' 5146 : b === 1 5147 ? 'st' 5148 : b === 2 5149 ? 'nd' 5150 : b === 3 5151 ? 'rd' 5152 : 'th'; 5153 return number + output; 5154 }, 5155 }); 5156 5157 // Side effect imports 5158 5159 hooks.lang = deprecate( 5160 'moment.lang is deprecated. Use moment.locale instead.', 5161 getSetGlobalLocale 5162 ); 5163 hooks.langData = deprecate( 5164 'moment.langData is deprecated. Use moment.localeData instead.', 5165 getLocale 5166 ); 5167 5168 var mathAbs = Math.abs; 5169 5170 function abs() { 5171 var data = this._data; 5172 5173 this._milliseconds = mathAbs(this._milliseconds); 5174 this._days = mathAbs(this._days); 5175 this._months = mathAbs(this._months); 5176 5177 data.milliseconds = mathAbs(data.milliseconds); 5178 data.seconds = mathAbs(data.seconds); 5179 data.minutes = mathAbs(data.minutes); 5180 data.hours = mathAbs(data.hours); 5181 data.months = mathAbs(data.months); 5182 data.years = mathAbs(data.years); 5183 5184 return this; 5185 } 5186 5187 function addSubtract$1(duration, input, value, direction) { 5188 var other = createDuration(input, value); 5189 5190 duration._milliseconds += direction * other._milliseconds; 5191 duration._days += direction * other._days; 5192 duration._months += direction * other._months; 5193 5194 return duration._bubble(); 5195 } 5196 5197 // supports only 2.0-style add(1, 's') or add(duration) 5198 function add$1(input, value) { 5199 return addSubtract$1(this, input, value, 1); 5200 } 5201 5202 // supports only 2.0-style subtract(1, 's') or subtract(duration) 5203 function subtract$1(input, value) { 5204 return addSubtract$1(this, input, value, -1); 5205 } 5206 5207 function absCeil(number) { 5208 if (number < 0) { 5209 return Math.floor(number); 5210 } else { 5211 return Math.ceil(number); 5212 } 5213 } 5214 5215 function bubble() { 5216 var milliseconds = this._milliseconds, 5217 days = this._days, 5218 months = this._months, 5219 data = this._data, 5220 seconds, 5221 minutes, 5222 hours, 5223 years, 5224 monthsFromDays; 5225 5226 // if we have a mix of positive and negative values, bubble down first 5227 // check: https://github.com/moment/moment/issues/2166 5228 if ( 5229 !( 5230 (milliseconds >= 0 && days >= 0 && months >= 0) || 5231 (milliseconds <= 0 && days <= 0 && months <= 0) 5232 ) 5233 ) { 5234 milliseconds += absCeil(monthsToDays(months) + days) * 864e5; 5235 days = 0; 5236 months = 0; 5237 } 5238 5239 // The following code bubbles up values, see the tests for 5240 // examples of what that means. 5241 data.milliseconds = milliseconds % 1000; 5242 5243 seconds = absFloor(milliseconds / 1000); 5244 data.seconds = seconds % 60; 5245 5246 minutes = absFloor(seconds / 60); 5247 data.minutes = minutes % 60; 5248 5249 hours = absFloor(minutes / 60); 5250 data.hours = hours % 24; 5251 5252 days += absFloor(hours / 24); 5253 5254 // convert days to months 5255 monthsFromDays = absFloor(daysToMonths(days)); 5256 months += monthsFromDays; 5257 days -= absCeil(monthsToDays(monthsFromDays)); 5258 5259 // 12 months -> 1 year 5260 years = absFloor(months / 12); 5261 months %= 12; 5262 5263 data.days = days; 5264 data.months = months; 5265 data.years = years; 5266 5267 return this; 5268 } 5269 5270 function daysToMonths(days) { 5271 // 400 years have 146097 days (taking into account leap year rules) 5272 // 400 years have 12 months === 4800 5273 return (days * 4800) / 146097; 5274 } 5275 5276 function monthsToDays(months) { 5277 // the reverse of daysToMonths 5278 return (months * 146097) / 4800; 5279 } 5280 5281 function as(units) { 5282 if (!this.isValid()) { 5283 return NaN; 5284 } 5285 var days, 5286 months, 5287 milliseconds = this._milliseconds; 5288 5289 units = normalizeUnits(units); 5290 5291 if (units === 'month' || units === 'quarter' || units === 'year') { 5292 days = this._days + milliseconds / 864e5; 5293 months = this._months + daysToMonths(days); 5294 switch (units) { 5295 case 'month': 5296 return months; 5297 case 'quarter': 5298 return months / 3; 5299 case 'year': 5300 return months / 12; 5301 } 5302 } else { 5303 // handle milliseconds separately because of floating point math errors (issue #1867) 5304 days = this._days + Math.round(monthsToDays(this._months)); 5305 switch (units) { 5306 case 'week': 5307 return days / 7 + milliseconds / 6048e5; 5308 case 'day': 5309 return days + milliseconds / 864e5; 5310 case 'hour': 5311 return days * 24 + milliseconds / 36e5; 5312 case 'minute': 5313 return days * 1440 + milliseconds / 6e4; 5314 case 'second': 5315 return days * 86400 + milliseconds / 1000; 5316 // Math.floor prevents floating point math errors here 5317 case 'millisecond': 5318 return Math.floor(days * 864e5) + milliseconds; 5319 default: 5320 throw new Error('Unknown unit ' + units); 5321 } 5322 } 5323 } 5324 5325 // TODO: Use this.as('ms')? 5326 function valueOf$1() { 5327 if (!this.isValid()) { 5328 return NaN; 5329 } 5330 return ( 5331 this._milliseconds + 5332 this._days * 864e5 + 5333 (this._months % 12) * 2592e6 + 5334 toInt(this._months / 12) * 31536e6 5335 ); 5336 } 5337 5338 function makeAs(alias) { 5339 return function () { 5340 return this.as(alias); 5341 }; 5342 } 5343 5344 var asMilliseconds = makeAs('ms'), 5345 asSeconds = makeAs('s'), 5346 asMinutes = makeAs('m'), 5347 asHours = makeAs('h'), 5348 asDays = makeAs('d'), 5349 asWeeks = makeAs('w'), 5350 asMonths = makeAs('M'), 5351 asQuarters = makeAs('Q'), 5352 asYears = makeAs('y'); 5353 5354 function clone$1() { 5355 return createDuration(this); 5356 } 5357 5358 function get$2(units) { 5359 units = normalizeUnits(units); 5360 return this.isValid() ? this[units + 's']() : NaN; 5361 } 5362 5363 function makeGetter(name) { 5364 return function () { 5365 return this.isValid() ? this._data[name] : NaN; 5366 }; 5367 } 5368 5369 var milliseconds = makeGetter('milliseconds'), 5370 seconds = makeGetter('seconds'), 5371 minutes = makeGetter('minutes'), 5372 hours = makeGetter('hours'), 5373 days = makeGetter('days'), 5374 months = makeGetter('months'), 5375 years = makeGetter('years'); 5376 5377 function weeks() { 5378 return absFloor(this.days() / 7); 5379 } 5380 5381 var round = Math.round, 5382 thresholds = { 5383 ss: 44, // a few seconds to seconds 5384 s: 45, // seconds to minute 5385 m: 45, // minutes to hour 5386 h: 22, // hours to day 5387 d: 26, // days to month/week 5388 w: null, // weeks to month 5389 M: 11, // months to year 5390 }; 5391 5392 // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize 5393 function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) { 5394 return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture); 5395 } 5396 5397 function relativeTime$1(posNegDuration, withoutSuffix, thresholds, locale) { 5398 var duration = createDuration(posNegDuration).abs(), 5399 seconds = round(duration.as('s')), 5400 minutes = round(duration.as('m')), 5401 hours = round(duration.as('h')), 5402 days = round(duration.as('d')), 5403 months = round(duration.as('M')), 5404 weeks = round(duration.as('w')), 5405 years = round(duration.as('y')), 5406 a = 5407 (seconds <= thresholds.ss && ['s', seconds]) || 5408 (seconds < thresholds.s && ['ss', seconds]) || 5409 (minutes <= 1 && ['m']) || 5410 (minutes < thresholds.m && ['mm', minutes]) || 5411 (hours <= 1 && ['h']) || 5412 (hours < thresholds.h && ['hh', hours]) || 5413 (days <= 1 && ['d']) || 5414 (days < thresholds.d && ['dd', days]); 5415 5416 if (thresholds.w != null) { 5417 a = 5418 a || 5419 (weeks <= 1 && ['w']) || 5420 (weeks < thresholds.w && ['ww', weeks]); 5421 } 5422 a = a || 5423 (months <= 1 && ['M']) || 5424 (months < thresholds.M && ['MM', months]) || 5425 (years <= 1 && ['y']) || ['yy', years]; 5426 5427 a[2] = withoutSuffix; 5428 a[3] = +posNegDuration > 0; 5429 a[4] = locale; 5430 return substituteTimeAgo.apply(null, a); 5431 } 5432 5433 // This function allows you to set the rounding function for relative time strings 5434 function getSetRelativeTimeRounding(roundingFunction) { 5435 if (roundingFunction === undefined) { 5436 return round; 5437 } 5438 if (typeof roundingFunction === 'function') { 5439 round = roundingFunction; 5440 return true; 5441 } 5442 return false; 5443 } 5444 5445 // This function allows you to set a threshold for relative time strings 5446 function getSetRelativeTimeThreshold(threshold, limit) { 5447 if (thresholds[threshold] === undefined) { 5448 return false; 5449 } 5450 if (limit === undefined) { 5451 return thresholds[threshold]; 5452 } 5453 thresholds[threshold] = limit; 5454 if (threshold === 's') { 5455 thresholds.ss = limit - 1; 5456 } 5457 return true; 5458 } 5459 5460 function humanize(argWithSuffix, argThresholds) { 5461 if (!this.isValid()) { 5462 return this.localeData().invalidDate(); 5463 } 5464 5465 var withSuffix = false, 5466 th = thresholds, 5467 locale, 5468 output; 5469 5470 if (typeof argWithSuffix === 'object') { 5471 argThresholds = argWithSuffix; 5472 argWithSuffix = false; 5473 } 5474 if (typeof argWithSuffix === 'boolean') { 5475 withSuffix = argWithSuffix; 5476 } 5477 if (typeof argThresholds === 'object') { 5478 th = Object.assign({}, thresholds, argThresholds); 5479 if (argThresholds.s != null && argThresholds.ss == null) { 5480 th.ss = argThresholds.s - 1; 5481 } 5482 } 5483 5484 locale = this.localeData(); 5485 output = relativeTime$1(this, !withSuffix, th, locale); 5486 5487 if (withSuffix) { 5488 output = locale.pastFuture(+this, output); 5489 } 5490 5491 return locale.postformat(output); 5492 } 5493 5494 var abs$1 = Math.abs; 5495 5496 function sign(x) { 5497 return (x > 0) - (x < 0) || +x; 5498 } 5499 5500 function toISOString$1() { 5501 // for ISO strings we do not use the normal bubbling rules: 5502 // * milliseconds bubble up until they become hours 5503 // * days do not bubble at all 5504 // * months bubble up until they become years 5505 // This is because there is no context-free conversion between hours and days 5506 // (think of clock changes) 5507 // and also not between days and months (28-31 days per month) 5508 if (!this.isValid()) { 5509 return this.localeData().invalidDate(); 5510 } 5511 5512 var seconds = abs$1(this._milliseconds) / 1000, 5513 days = abs$1(this._days), 5514 months = abs$1(this._months), 5515 minutes, 5516 hours, 5517 years, 5518 s, 5519 total = this.asSeconds(), 5520 totalSign, 5521 ymSign, 5522 daysSign, 5523 hmsSign; 5524 5525 if (!total) { 5526 // this is the same as C#'s (Noda) and python (isodate)... 5527 // but not other JS (goog.date) 5528 return 'P0D'; 5529 } 5530 5531 // 3600 seconds -> 60 minutes -> 1 hour 5532 minutes = absFloor(seconds / 60); 5533 hours = absFloor(minutes / 60); 5534 seconds %= 60; 5535 minutes %= 60; 5536 5537 // 12 months -> 1 year 5538 years = absFloor(months / 12); 5539 months %= 12; 5540 5541 // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js 5542 s = seconds ? seconds.toFixed(3).replace(/\.?0+$/, '') : ''; 5543 5544 totalSign = total < 0 ? '-' : ''; 5545 ymSign = sign(this._months) !== sign(total) ? '-' : ''; 5546 daysSign = sign(this._days) !== sign(total) ? '-' : ''; 5547 hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : ''; 5548 5549 return ( 5550 totalSign + 5551 'P' + 5552 (years ? ymSign + years + 'Y' : '') + 5553 (months ? ymSign + months + 'M' : '') + 5554 (days ? daysSign + days + 'D' : '') + 5555 (hours || minutes || seconds ? 'T' : '') + 5556 (hours ? hmsSign + hours + 'H' : '') + 5557 (minutes ? hmsSign + minutes + 'M' : '') + 5558 (seconds ? hmsSign + s + 'S' : '') 5559 ); 5560 } 5561 5562 var proto$2 = Duration.prototype; 5563 5564 proto$2.isValid = isValid$1; 5565 proto$2.abs = abs; 5566 proto$2.add = add$1; 5567 proto$2.subtract = subtract$1; 5568 proto$2.as = as; 5569 proto$2.asMilliseconds = asMilliseconds; 5570 proto$2.asSeconds = asSeconds; 5571 proto$2.asMinutes = asMinutes; 5572 proto$2.asHours = asHours; 5573 proto$2.asDays = asDays; 5574 proto$2.asWeeks = asWeeks; 5575 proto$2.asMonths = asMonths; 5576 proto$2.asQuarters = asQuarters; 5577 proto$2.asYears = asYears; 5578 proto$2.valueOf = valueOf$1; 5579 proto$2._bubble = bubble; 5580 proto$2.clone = clone$1; 5581 proto$2.get = get$2; 5582 proto$2.milliseconds = milliseconds; 5583 proto$2.seconds = seconds; 5584 proto$2.minutes = minutes; 5585 proto$2.hours = hours; 5586 proto$2.days = days; 5587 proto$2.weeks = weeks; 5588 proto$2.months = months; 5589 proto$2.years = years; 5590 proto$2.humanize = humanize; 5591 proto$2.toISOString = toISOString$1; 5592 proto$2.toString = toISOString$1; 5593 proto$2.toJSON = toISOString$1; 5594 proto$2.locale = locale; 5595 proto$2.localeData = localeData; 5596 5597 proto$2.toIsoString = deprecate( 5598 'toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', 5599 toISOString$1 5600 ); 5601 proto$2.lang = lang; 5602 5603 // FORMATTING 5604 5605 addFormatToken('X', 0, 0, 'unix'); 5606 addFormatToken('x', 0, 0, 'valueOf'); 5607 5608 // PARSING 5609 5610 addRegexToken('x', matchSigned); 5611 addRegexToken('X', matchTimestamp); 5612 addParseToken('X', function (input, array, config) { 5613 config._d = new Date(parseFloat(input) * 1000); 5614 }); 5615 addParseToken('x', function (input, array, config) { 5616 config._d = new Date(toInt(input)); 5617 }); 5618 5619 //! moment.js 5620 5621 hooks.version = '2.26.0'; 5622 5623 setHookCallback(createLocal); 5624 5625 hooks.fn = proto; 5626 hooks.min = min; 5627 hooks.max = max; 5628 hooks.now = now; 5629 hooks.utc = createUTC; 5630 hooks.unix = createUnix; 5631 hooks.months = listMonths; 5632 hooks.isDate = isDate; 5633 hooks.locale = getSetGlobalLocale; 5634 hooks.invalid = createInvalid; 5635 hooks.duration = createDuration; 5636 hooks.isMoment = isMoment; 5637 hooks.weekdays = listWeekdays; 5638 hooks.parseZone = createInZone; 5639 hooks.localeData = getLocale; 5640 hooks.isDuration = isDuration; 5641 hooks.monthsShort = listMonthsShort; 5642 hooks.weekdaysMin = listWeekdaysMin; 5643 hooks.defineLocale = defineLocale; 5644 hooks.updateLocale = updateLocale; 5645 hooks.locales = listLocales; 5646 hooks.weekdaysShort = listWeekdaysShort; 5647 hooks.normalizeUnits = normalizeUnits; 5648 hooks.relativeTimeRounding = getSetRelativeTimeRounding; 5649 hooks.relativeTimeThreshold = getSetRelativeTimeThreshold; 5650 hooks.calendarFormat = getCalendarFormat; 5651 hooks.prototype = proto; 5652 5653 // currently HTML5 input type only supports 24-hour formats 5654 hooks.HTML5_FMT = { 5655 DATETIME_LOCAL: 'YYYY-MM-DDTHH:mm', // <input type="datetime-local" /> 5656 DATETIME_LOCAL_SECONDS: 'YYYY-MM-DDTHH:mm:ss', // <input type="datetime-local" step="1" /> 5657 DATETIME_LOCAL_MS: 'YYYY-MM-DDTHH:mm:ss.SSS', // <input type="datetime-local" step="0.001" /> 5658 DATE: 'YYYY-MM-DD', // <input type="date" /> 5659 TIME: 'HH:mm', // <input type="time" /> 5660 TIME_SECONDS: 'HH:mm:ss', // <input type="time" step="1" /> 5661 TIME_MS: 'HH:mm:ss.SSS', // <input type="time" step="0.001" /> 5662 WEEK: 'GGGG-[W]WW', // <input type="week" /> 5663 MONTH: 'YYYY-MM', // <input type="month" /> 5664 }; 5665 5666 return hooks; 5667 5668})));
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.