| [ Index ] |
PHP Cross Reference of WordPress |
[Summary view] [Print] [Text view]
1 //! moment.js 2 //! version : 2.29.1 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. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.', 2544 function (config) { 2545 config._d = new Date(config._i + (config._useUTC ? ' UTC' : '')); 2546 } 2547 ); 2548 2549 // Pick the first defined of two or three arguments. 2550 function defaults(a, b, c) { 2551 if (a != null) { 2552 return a; 2553 } 2554 if (b != null) { 2555 return b; 2556 } 2557 return c; 2558 } 2559 2560 function currentDateArray(config) { 2561 // hooks is actually the exported moment object 2562 var nowValue = new Date(hooks.now()); 2563 if (config._useUTC) { 2564 return [ 2565 nowValue.getUTCFullYear(), 2566 nowValue.getUTCMonth(), 2567 nowValue.getUTCDate(), 2568 ]; 2569 } 2570 return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()]; 2571 } 2572 2573 // convert an array to a date. 2574 // the array should mirror the parameters below 2575 // note: all values past the year are optional and will default to the lowest possible value. 2576 // [year, month, day , hour, minute, second, millisecond] 2577 function configFromArray(config) { 2578 var i, 2579 date, 2580 input = [], 2581 currentDate, 2582 expectedWeekday, 2583 yearToUse; 2584 2585 if (config._d) { 2586 return; 2587 } 2588 2589 currentDate = currentDateArray(config); 2590 2591 //compute day of the year from weeks and weekdays 2592 if (config._w && config._a[DATE] == null && config._a[MONTH] == null) { 2593 dayOfYearFromWeekInfo(config); 2594 } 2595 2596 //if the day of the year is set, figure out what it is 2597 if (config._dayOfYear != null) { 2598 yearToUse = defaults(config._a[YEAR], currentDate[YEAR]); 2599 2600 if ( 2601 config._dayOfYear > daysInYear(yearToUse) || 2602 config._dayOfYear === 0 2603 ) { 2604 getParsingFlags(config)._overflowDayOfYear = true; 2605 } 2606 2607 date = createUTCDate(yearToUse, 0, config._dayOfYear); 2608 config._a[MONTH] = date.getUTCMonth(); 2609 config._a[DATE] = date.getUTCDate(); 2610 } 2611 2612 // Default to current date. 2613 // * if no year, month, day of month are given, default to today 2614 // * if day of month is given, default month and year 2615 // * if month is given, default only year 2616 // * if year is given, don't default anything 2617 for (i = 0; i < 3 && config._a[i] == null; ++i) { 2618 config._a[i] = input[i] = currentDate[i]; 2619 } 2620 2621 // Zero out whatever was not defaulted, including time 2622 for (; i < 7; i++) { 2623 config._a[i] = input[i] = 2624 config._a[i] == null ? (i === 2 ? 1 : 0) : config._a[i]; 2625 } 2626 2627 // Check for 24:00:00.000 2628 if ( 2629 config._a[HOUR] === 24 && 2630 config._a[MINUTE] === 0 && 2631 config._a[SECOND] === 0 && 2632 config._a[MILLISECOND] === 0 2633 ) { 2634 config._nextDay = true; 2635 config._a[HOUR] = 0; 2636 } 2637 2638 config._d = (config._useUTC ? createUTCDate : createDate).apply( 2639 null, 2640 input 2641 ); 2642 expectedWeekday = config._useUTC 2643 ? config._d.getUTCDay() 2644 : config._d.getDay(); 2645 2646 // Apply timezone offset from input. The actual utcOffset can be changed 2647 // with parseZone. 2648 if (config._tzm != null) { 2649 config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm); 2650 } 2651 2652 if (config._nextDay) { 2653 config._a[HOUR] = 24; 2654 } 2655 2656 // check for mismatching day of week 2657 if ( 2658 config._w && 2659 typeof config._w.d !== 'undefined' && 2660 config._w.d !== expectedWeekday 2661 ) { 2662 getParsingFlags(config).weekdayMismatch = true; 2663 } 2664 } 2665 2666 function dayOfYearFromWeekInfo(config) { 2667 var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow, curWeek; 2668 2669 w = config._w; 2670 if (w.GG != null || w.W != null || w.E != null) { 2671 dow = 1; 2672 doy = 4; 2673 2674 // TODO: We need to take the current isoWeekYear, but that depends on 2675 // how we interpret now (local, utc, fixed offset). So create 2676 // a now version of current config (take local/utc/offset flags, and 2677 // create now). 2678 weekYear = defaults( 2679 w.GG, 2680 config._a[YEAR], 2681 weekOfYear(createLocal(), 1, 4).year 2682 ); 2683 week = defaults(w.W, 1); 2684 weekday = defaults(w.E, 1); 2685 if (weekday < 1 || weekday > 7) { 2686 weekdayOverflow = true; 2687 } 2688 } else { 2689 dow = config._locale._week.dow; 2690 doy = config._locale._week.doy; 2691 2692 curWeek = weekOfYear(createLocal(), dow, doy); 2693 2694 weekYear = defaults(w.gg, config._a[YEAR], curWeek.year); 2695 2696 // Default to current week. 2697 week = defaults(w.w, curWeek.week); 2698 2699 if (w.d != null) { 2700 // weekday -- low day numbers are considered next week 2701 weekday = w.d; 2702 if (weekday < 0 || weekday > 6) { 2703 weekdayOverflow = true; 2704 } 2705 } else if (w.e != null) { 2706 // local weekday -- counting starts from beginning of week 2707 weekday = w.e + dow; 2708 if (w.e < 0 || w.e > 6) { 2709 weekdayOverflow = true; 2710 } 2711 } else { 2712 // default to beginning of week 2713 weekday = dow; 2714 } 2715 } 2716 if (week < 1 || week > weeksInYear(weekYear, dow, doy)) { 2717 getParsingFlags(config)._overflowWeeks = true; 2718 } else if (weekdayOverflow != null) { 2719 getParsingFlags(config)._overflowWeekday = true; 2720 } else { 2721 temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy); 2722 config._a[YEAR] = temp.year; 2723 config._dayOfYear = temp.dayOfYear; 2724 } 2725 } 2726 2727 // constant that refers to the ISO standard 2728 hooks.ISO_8601 = function () {}; 2729 2730 // constant that refers to the RFC 2822 form 2731 hooks.RFC_2822 = function () {}; 2732 2733 // date from string and format string 2734 function configFromStringAndFormat(config) { 2735 // TODO: Move this to another part of the creation flow to prevent circular deps 2736 if (config._f === hooks.ISO_8601) { 2737 configFromISO(config); 2738 return; 2739 } 2740 if (config._f === hooks.RFC_2822) { 2741 configFromRFC2822(config); 2742 return; 2743 } 2744 config._a = []; 2745 getParsingFlags(config).empty = true; 2746 2747 // This array is used to make a Date, either with `new Date` or `Date.UTC` 2748 var string = '' + config._i, 2749 i, 2750 parsedInput, 2751 tokens, 2752 token, 2753 skipped, 2754 stringLength = string.length, 2755 totalParsedInputLength = 0, 2756 era; 2757 2758 tokens = 2759 expandFormat(config._f, config._locale).match(formattingTokens) || []; 2760 2761 for (i = 0; i < tokens.length; i++) { 2762 token = tokens[i]; 2763 parsedInput = (string.match(getParseRegexForToken(token, config)) || 2764 [])[0]; 2765 if (parsedInput) { 2766 skipped = string.substr(0, string.indexOf(parsedInput)); 2767 if (skipped.length > 0) { 2768 getParsingFlags(config).unusedInput.push(skipped); 2769 } 2770 string = string.slice( 2771 string.indexOf(parsedInput) + parsedInput.length 2772 ); 2773 totalParsedInputLength += parsedInput.length; 2774 } 2775 // don't parse if it's not a known token 2776 if (formatTokenFunctions[token]) { 2777 if (parsedInput) { 2778 getParsingFlags(config).empty = false; 2779 } else { 2780 getParsingFlags(config).unusedTokens.push(token); 2781 } 2782 addTimeToArrayFromToken(token, parsedInput, config); 2783 } else if (config._strict && !parsedInput) { 2784 getParsingFlags(config).unusedTokens.push(token); 2785 } 2786 } 2787 2788 // add remaining unparsed input length to the string 2789 getParsingFlags(config).charsLeftOver = 2790 stringLength - totalParsedInputLength; 2791 if (string.length > 0) { 2792 getParsingFlags(config).unusedInput.push(string); 2793 } 2794 2795 // clear _12h flag if hour is <= 12 2796 if ( 2797 config._a[HOUR] <= 12 && 2798 getParsingFlags(config).bigHour === true && 2799 config._a[HOUR] > 0 2800 ) { 2801 getParsingFlags(config).bigHour = undefined; 2802 } 2803 2804 getParsingFlags(config).parsedDateParts = config._a.slice(0); 2805 getParsingFlags(config).meridiem = config._meridiem; 2806 // handle meridiem 2807 config._a[HOUR] = meridiemFixWrap( 2808 config._locale, 2809 config._a[HOUR], 2810 config._meridiem 2811 ); 2812 2813 // handle era 2814 era = getParsingFlags(config).era; 2815 if (era !== null) { 2816 config._a[YEAR] = config._locale.erasConvertYear(era, config._a[YEAR]); 2817 } 2818 2819 configFromArray(config); 2820 checkOverflow(config); 2821 } 2822 2823 function meridiemFixWrap(locale, hour, meridiem) { 2824 var isPm; 2825 2826 if (meridiem == null) { 2827 // nothing to do 2828 return hour; 2829 } 2830 if (locale.meridiemHour != null) { 2831 return locale.meridiemHour(hour, meridiem); 2832 } else if (locale.isPM != null) { 2833 // Fallback 2834 isPm = locale.isPM(meridiem); 2835 if (isPm && hour < 12) { 2836 hour += 12; 2837 } 2838 if (!isPm && hour === 12) { 2839 hour = 0; 2840 } 2841 return hour; 2842 } else { 2843 // this is not supposed to happen 2844 return hour; 2845 } 2846 } 2847 2848 // date from string and array of format strings 2849 function configFromStringAndArray(config) { 2850 var tempConfig, 2851 bestMoment, 2852 scoreToBeat, 2853 i, 2854 currentScore, 2855 validFormatFound, 2856 bestFormatIsValid = false; 2857 2858 if (config._f.length === 0) { 2859 getParsingFlags(config).invalidFormat = true; 2860 config._d = new Date(NaN); 2861 return; 2862 } 2863 2864 for (i = 0; i < config._f.length; i++) { 2865 currentScore = 0; 2866 validFormatFound = false; 2867 tempConfig = copyConfig({}, config); 2868 if (config._useUTC != null) { 2869 tempConfig._useUTC = config._useUTC; 2870 } 2871 tempConfig._f = config._f[i]; 2872 configFromStringAndFormat(tempConfig); 2873 2874 if (isValid(tempConfig)) { 2875 validFormatFound = true; 2876 } 2877 2878 // if there is any input that was not parsed add a penalty for that format 2879 currentScore += getParsingFlags(tempConfig).charsLeftOver; 2880 2881 //or tokens 2882 currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10; 2883 2884 getParsingFlags(tempConfig).score = currentScore; 2885 2886 if (!bestFormatIsValid) { 2887 if ( 2888 scoreToBeat == null || 2889 currentScore < scoreToBeat || 2890 validFormatFound 2891 ) { 2892 scoreToBeat = currentScore; 2893 bestMoment = tempConfig; 2894 if (validFormatFound) { 2895 bestFormatIsValid = true; 2896 } 2897 } 2898 } else { 2899 if (currentScore < scoreToBeat) { 2900 scoreToBeat = currentScore; 2901 bestMoment = tempConfig; 2902 } 2903 } 2904 } 2905 2906 extend(config, bestMoment || tempConfig); 2907 } 2908 2909 function configFromObject(config) { 2910 if (config._d) { 2911 return; 2912 } 2913 2914 var i = normalizeObjectUnits(config._i), 2915 dayOrDate = i.day === undefined ? i.date : i.day; 2916 config._a = map( 2917 [i.year, i.month, dayOrDate, i.hour, i.minute, i.second, i.millisecond], 2918 function (obj) { 2919 return obj && parseInt(obj, 10); 2920 } 2921 ); 2922 2923 configFromArray(config); 2924 } 2925 2926 function createFromConfig(config) { 2927 var res = new Moment(checkOverflow(prepareConfig(config))); 2928 if (res._nextDay) { 2929 // Adding is smart enough around DST 2930 res.add(1, 'd'); 2931 res._nextDay = undefined; 2932 } 2933 2934 return res; 2935 } 2936 2937 function prepareConfig(config) { 2938 var input = config._i, 2939 format = config._f; 2940 2941 config._locale = config._locale || getLocale(config._l); 2942 2943 if (input === null || (format === undefined && input === '')) { 2944 return createInvalid({ nullInput: true }); 2945 } 2946 2947 if (typeof input === 'string') { 2948 config._i = input = config._locale.preparse(input); 2949 } 2950 2951 if (isMoment(input)) { 2952 return new Moment(checkOverflow(input)); 2953 } else if (isDate(input)) { 2954 config._d = input; 2955 } else if (isArray(format)) { 2956 configFromStringAndArray(config); 2957 } else if (format) { 2958 configFromStringAndFormat(config); 2959 } else { 2960 configFromInput(config); 2961 } 2962 2963 if (!isValid(config)) { 2964 config._d = null; 2965 } 2966 2967 return config; 2968 } 2969 2970 function configFromInput(config) { 2971 var input = config._i; 2972 if (isUndefined(input)) { 2973 config._d = new Date(hooks.now()); 2974 } else if (isDate(input)) { 2975 config._d = new Date(input.valueOf()); 2976 } else if (typeof input === 'string') { 2977 configFromString(config); 2978 } else if (isArray(input)) { 2979 config._a = map(input.slice(0), function (obj) { 2980 return parseInt(obj, 10); 2981 }); 2982 configFromArray(config); 2983 } else if (isObject(input)) { 2984 configFromObject(config); 2985 } else if (isNumber(input)) { 2986 // from milliseconds 2987 config._d = new Date(input); 2988 } else { 2989 hooks.createFromInputFallback(config); 2990 } 2991 } 2992 2993 function createLocalOrUTC(input, format, locale, strict, isUTC) { 2994 var c = {}; 2995 2996 if (format === true || format === false) { 2997 strict = format; 2998 format = undefined; 2999 } 3000 3001 if (locale === true || locale === false) { 3002 strict = locale; 3003 locale = undefined; 3004 } 3005 3006 if ( 3007 (isObject(input) && isObjectEmpty(input)) || 3008 (isArray(input) && input.length === 0) 3009 ) { 3010 input = undefined; 3011 } 3012 // object construction must be done this way. 3013 // https://github.com/moment/moment/issues/1423 3014 c._isAMomentObject = true; 3015 c._useUTC = c._isUTC = isUTC; 3016 c._l = locale; 3017 c._i = input; 3018 c._f = format; 3019 c._strict = strict; 3020 3021 return createFromConfig(c); 3022 } 3023 3024 function createLocal(input, format, locale, strict) { 3025 return createLocalOrUTC(input, format, locale, strict, false); 3026 } 3027 3028 var prototypeMin = deprecate( 3029 'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/', 3030 function () { 3031 var other = createLocal.apply(null, arguments); 3032 if (this.isValid() && other.isValid()) { 3033 return other < this ? this : other; 3034 } else { 3035 return createInvalid(); 3036 } 3037 } 3038 ), 3039 prototypeMax = deprecate( 3040 'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/', 3041 function () { 3042 var other = createLocal.apply(null, arguments); 3043 if (this.isValid() && other.isValid()) { 3044 return other > this ? this : other; 3045 } else { 3046 return createInvalid(); 3047 } 3048 } 3049 ); 3050 3051 // Pick a moment m from moments so that m[fn](other) is true for all 3052 // other. This relies on the function fn to be transitive. 3053 // 3054 // moments should either be an array of moment objects or an array, whose 3055 // first element is an array of moment objects. 3056 function pickBy(fn, moments) { 3057 var res, i; 3058 if (moments.length === 1 && isArray(moments[0])) { 3059 moments = moments[0]; 3060 } 3061 if (!moments.length) { 3062 return createLocal(); 3063 } 3064 res = moments[0]; 3065 for (i = 1; i < moments.length; ++i) { 3066 if (!moments[i].isValid() || moments[i][fn](res)) { 3067 res = moments[i]; 3068 } 3069 } 3070 return res; 3071 } 3072 3073 // TODO: Use [].sort instead? 3074 function min() { 3075 var args = [].slice.call(arguments, 0); 3076 3077 return pickBy('isBefore', args); 3078 } 3079 3080 function max() { 3081 var args = [].slice.call(arguments, 0); 3082 3083 return pickBy('isAfter', args); 3084 } 3085 3086 var now = function () { 3087 return Date.now ? Date.now() : +new Date(); 3088 }; 3089 3090 var ordering = [ 3091 'year', 3092 'quarter', 3093 'month', 3094 'week', 3095 'day', 3096 'hour', 3097 'minute', 3098 'second', 3099 'millisecond', 3100 ]; 3101 3102 function isDurationValid(m) { 3103 var key, 3104 unitHasDecimal = false, 3105 i; 3106 for (key in m) { 3107 if ( 3108 hasOwnProp(m, key) && 3109 !( 3110 indexOf.call(ordering, key) !== -1 && 3111 (m[key] == null || !isNaN(m[key])) 3112 ) 3113 ) { 3114 return false; 3115 } 3116 } 3117 3118 for (i = 0; i < ordering.length; ++i) { 3119 if (m[ordering[i]]) { 3120 if (unitHasDecimal) { 3121 return false; // only allow non-integers for smallest unit 3122 } 3123 if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) { 3124 unitHasDecimal = true; 3125 } 3126 } 3127 } 3128 3129 return true; 3130 } 3131 3132 function isValid$1() { 3133 return this._isValid; 3134 } 3135 3136 function createInvalid$1() { 3137 return createDuration(NaN); 3138 } 3139 3140 function Duration(duration) { 3141 var normalizedInput = normalizeObjectUnits(duration), 3142 years = normalizedInput.year || 0, 3143 quarters = normalizedInput.quarter || 0, 3144 months = normalizedInput.month || 0, 3145 weeks = normalizedInput.week || normalizedInput.isoWeek || 0, 3146 days = normalizedInput.day || 0, 3147 hours = normalizedInput.hour || 0, 3148 minutes = normalizedInput.minute || 0, 3149 seconds = normalizedInput.second || 0, 3150 milliseconds = normalizedInput.millisecond || 0; 3151 3152 this._isValid = isDurationValid(normalizedInput); 3153 3154 // representation for dateAddRemove 3155 this._milliseconds = 3156 +milliseconds + 3157 seconds * 1e3 + // 1000 3158 minutes * 6e4 + // 1000 * 60 3159 hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978 3160 // Because of dateAddRemove treats 24 hours as different from a 3161 // day when working around DST, we need to store them separately 3162 this._days = +days + weeks * 7; 3163 // It is impossible to translate months into days without knowing 3164 // which months you are are talking about, so we have to store 3165 // it separately. 3166 this._months = +months + quarters * 3 + years * 12; 3167 3168 this._data = {}; 3169 3170 this._locale = getLocale(); 3171 3172 this._bubble(); 3173 } 3174 3175 function isDuration(obj) { 3176 return obj instanceof Duration; 3177 } 3178 3179 function absRound(number) { 3180 if (number < 0) { 3181 return Math.round(-1 * number) * -1; 3182 } else { 3183 return Math.round(number); 3184 } 3185 } 3186 3187 // compare two arrays, return the number of differences 3188 function compareArrays(array1, array2, dontConvert) { 3189 var len = Math.min(array1.length, array2.length), 3190 lengthDiff = Math.abs(array1.length - array2.length), 3191 diffs = 0, 3192 i; 3193 for (i = 0; i < len; i++) { 3194 if ( 3195 (dontConvert && array1[i] !== array2[i]) || 3196 (!dontConvert && toInt(array1[i]) !== toInt(array2[i])) 3197 ) { 3198 diffs++; 3199 } 3200 } 3201 return diffs + lengthDiff; 3202 } 3203 3204 // FORMATTING 3205 3206 function offset(token, separator) { 3207 addFormatToken(token, 0, 0, function () { 3208 var offset = this.utcOffset(), 3209 sign = '+'; 3210 if (offset < 0) { 3211 offset = -offset; 3212 sign = '-'; 3213 } 3214 return ( 3215 sign + 3216 zeroFill(~~(offset / 60), 2) + 3217 separator + 3218 zeroFill(~~offset % 60, 2) 3219 ); 3220 }); 3221 } 3222 3223 offset('Z', ':'); 3224 offset('ZZ', ''); 3225 3226 // PARSING 3227 3228 addRegexToken('Z', matchShortOffset); 3229 addRegexToken('ZZ', matchShortOffset); 3230 addParseToken(['Z', 'ZZ'], function (input, array, config) { 3231 config._useUTC = true; 3232 config._tzm = offsetFromString(matchShortOffset, input); 3233 }); 3234 3235 // HELPERS 3236 3237 // timezone chunker 3238 // '+10:00' > ['10', '00'] 3239 // '-1530' > ['-15', '30'] 3240 var chunkOffset = /([\+\-]|\d\d)/gi; 3241 3242 function offsetFromString(matcher, string) { 3243 var matches = (string || '').match(matcher), 3244 chunk, 3245 parts, 3246 minutes; 3247 3248 if (matches === null) { 3249 return null; 3250 } 3251 3252 chunk = matches[matches.length - 1] || []; 3253 parts = (chunk + '').match(chunkOffset) || ['-', 0, 0]; 3254 minutes = +(parts[1] * 60) + toInt(parts[2]); 3255 3256 return minutes === 0 ? 0 : parts[0] === '+' ? minutes : -minutes; 3257 } 3258 3259 // Return a moment from input, that is local/utc/zone equivalent to model. 3260 function cloneWithOffset(input, model) { 3261 var res, diff; 3262 if (model._isUTC) { 3263 res = model.clone(); 3264 diff = 3265 (isMoment(input) || isDate(input) 3266 ? input.valueOf() 3267 : createLocal(input).valueOf()) - res.valueOf(); 3268 // Use low-level api, because this fn is low-level api. 3269 res._d.setTime(res._d.valueOf() + diff); 3270 hooks.updateOffset(res, false); 3271 return res; 3272 } else { 3273 return createLocal(input).local(); 3274 } 3275 } 3276 3277 function getDateOffset(m) { 3278 // On Firefox.24 Date#getTimezoneOffset returns a floating point. 3279 // https://github.com/moment/moment/pull/1871 3280 return -Math.round(m._d.getTimezoneOffset()); 3281 } 3282 3283 // HOOKS 3284 3285 // This function will be called whenever a moment is mutated. 3286 // It is intended to keep the offset in sync with the timezone. 3287 hooks.updateOffset = function () {}; 3288 3289 // MOMENTS 3290 3291 // keepLocalTime = true means only change the timezone, without 3292 // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]--> 3293 // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset 3294 // +0200, so we adjust the time as needed, to be valid. 3295 // 3296 // Keeping the time actually adds/subtracts (one hour) 3297 // from the actual represented time. That is why we call updateOffset 3298 // a second time. In case it wants us to change the offset again 3299 // _changeInProgress == true case, then we have to adjust, because 3300 // there is no such time in the given timezone. 3301 function getSetOffset(input, keepLocalTime, keepMinutes) { 3302 var offset = this._offset || 0, 3303 localAdjust; 3304 if (!this.isValid()) { 3305 return input != null ? this : NaN; 3306 } 3307 if (input != null) { 3308 if (typeof input === 'string') { 3309 input = offsetFromString(matchShortOffset, input); 3310 if (input === null) { 3311 return this; 3312 } 3313 } else if (Math.abs(input) < 16 && !keepMinutes) { 3314 input = input * 60; 3315 } 3316 if (!this._isUTC && keepLocalTime) { 3317 localAdjust = getDateOffset(this); 3318 } 3319 this._offset = input; 3320 this._isUTC = true; 3321 if (localAdjust != null) { 3322 this.add(localAdjust, 'm'); 3323 } 3324 if (offset !== input) { 3325 if (!keepLocalTime || this._changeInProgress) { 3326 addSubtract( 3327 this, 3328 createDuration(input - offset, 'm'), 3329 1, 3330 false 3331 ); 3332 } else if (!this._changeInProgress) { 3333 this._changeInProgress = true; 3334 hooks.updateOffset(this, true); 3335 this._changeInProgress = null; 3336 } 3337 } 3338 return this; 3339 } else { 3340 return this._isUTC ? offset : getDateOffset(this); 3341 } 3342 } 3343 3344 function getSetZone(input, keepLocalTime) { 3345 if (input != null) { 3346 if (typeof input !== 'string') { 3347 input = -input; 3348 } 3349 3350 this.utcOffset(input, keepLocalTime); 3351 3352 return this; 3353 } else { 3354 return -this.utcOffset(); 3355 } 3356 } 3357 3358 function setOffsetToUTC(keepLocalTime) { 3359 return this.utcOffset(0, keepLocalTime); 3360 } 3361 3362 function setOffsetToLocal(keepLocalTime) { 3363 if (this._isUTC) { 3364 this.utcOffset(0, keepLocalTime); 3365 this._isUTC = false; 3366 3367 if (keepLocalTime) { 3368 this.subtract(getDateOffset(this), 'm'); 3369 } 3370 } 3371 return this; 3372 } 3373 3374 function setOffsetToParsedOffset() { 3375 if (this._tzm != null) { 3376 this.utcOffset(this._tzm, false, true); 3377 } else if (typeof this._i === 'string') { 3378 var tZone = offsetFromString(matchOffset, this._i); 3379 if (tZone != null) { 3380 this.utcOffset(tZone); 3381 } else { 3382 this.utcOffset(0, true); 3383 } 3384 } 3385 return this; 3386 } 3387 3388 function hasAlignedHourOffset(input) { 3389 if (!this.isValid()) { 3390 return false; 3391 } 3392 input = input ? createLocal(input).utcOffset() : 0; 3393 3394 return (this.utcOffset() - input) % 60 === 0; 3395 } 3396 3397 function isDaylightSavingTime() { 3398 return ( 3399 this.utcOffset() > this.clone().month(0).utcOffset() || 3400 this.utcOffset() > this.clone().month(5).utcOffset() 3401 ); 3402 } 3403 3404 function isDaylightSavingTimeShifted() { 3405 if (!isUndefined(this._isDSTShifted)) { 3406 return this._isDSTShifted; 3407 } 3408 3409 var c = {}, 3410 other; 3411 3412 copyConfig(c, this); 3413 c = prepareConfig(c); 3414 3415 if (c._a) { 3416 other = c._isUTC ? createUTC(c._a) : createLocal(c._a); 3417 this._isDSTShifted = 3418 this.isValid() && compareArrays(c._a, other.toArray()) > 0; 3419 } else { 3420 this._isDSTShifted = false; 3421 } 3422 3423 return this._isDSTShifted; 3424 } 3425 3426 function isLocal() { 3427 return this.isValid() ? !this._isUTC : false; 3428 } 3429 3430 function isUtcOffset() { 3431 return this.isValid() ? this._isUTC : false; 3432 } 3433 3434 function isUtc() { 3435 return this.isValid() ? this._isUTC && this._offset === 0 : false; 3436 } 3437 3438 // ASP.NET json date format regex 3439 var aspNetRegex = /^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/, 3440 // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html 3441 // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere 3442 // and further modified to allow for strings containing both week and day 3443 isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/; 3444 3445 function createDuration(input, key) { 3446 var duration = input, 3447 // matching against regexp is expensive, do it on demand 3448 match = null, 3449 sign, 3450 ret, 3451 diffRes; 3452 3453 if (isDuration(input)) { 3454 duration = { 3455 ms: input._milliseconds, 3456 d: input._days, 3457 M: input._months, 3458 }; 3459 } else if (isNumber(input) || !isNaN(+input)) { 3460 duration = {}; 3461 if (key) { 3462 duration[key] = +input; 3463 } else { 3464 duration.milliseconds = +input; 3465 } 3466 } else if ((match = aspNetRegex.exec(input))) { 3467 sign = match[1] === '-' ? -1 : 1; 3468 duration = { 3469 y: 0, 3470 d: toInt(match[DATE]) * sign, 3471 h: toInt(match[HOUR]) * sign, 3472 m: toInt(match[MINUTE]) * sign, 3473 s: toInt(match[SECOND]) * sign, 3474 ms: toInt(absRound(match[MILLISECOND] * 1000)) * sign, // the millisecond decimal point is included in the match 3475 }; 3476 } else if ((match = isoRegex.exec(input))) { 3477 sign = match[1] === '-' ? -1 : 1; 3478 duration = { 3479 y: parseIso(match[2], sign), 3480 M: parseIso(match[3], sign), 3481 w: parseIso(match[4], sign), 3482 d: parseIso(match[5], sign), 3483 h: parseIso(match[6], sign), 3484 m: parseIso(match[7], sign), 3485 s: parseIso(match[8], sign), 3486 }; 3487 } else if (duration == null) { 3488 // checks for null or undefined 3489 duration = {}; 3490 } else if ( 3491 typeof duration === 'object' && 3492 ('from' in duration || 'to' in duration) 3493 ) { 3494 diffRes = momentsDifference( 3495 createLocal(duration.from), 3496 createLocal(duration.to) 3497 ); 3498 3499 duration = {}; 3500 duration.ms = diffRes.milliseconds; 3501 duration.M = diffRes.months; 3502 } 3503 3504 ret = new Duration(duration); 3505 3506 if (isDuration(input) && hasOwnProp(input, '_locale')) { 3507 ret._locale = input._locale; 3508 } 3509 3510 if (isDuration(input) && hasOwnProp(input, '_isValid')) { 3511 ret._isValid = input._isValid; 3512 } 3513 3514 return ret; 3515 } 3516 3517 createDuration.fn = Duration.prototype; 3518 createDuration.invalid = createInvalid$1; 3519 3520 function parseIso(inp, sign) { 3521 // We'd normally use ~~inp for this, but unfortunately it also 3522 // converts floats to ints. 3523 // inp may be undefined, so careful calling replace on it. 3524 var res = inp && parseFloat(inp.replace(',', '.')); 3525 // apply sign while we're at it 3526 return (isNaN(res) ? 0 : res) * sign; 3527 } 3528 3529 function positiveMomentsDifference(base, other) { 3530 var res = {}; 3531 3532 res.months = 3533 other.month() - base.month() + (other.year() - base.year()) * 12; 3534 if (base.clone().add(res.months, 'M').isAfter(other)) { 3535 --res.months; 3536 } 3537 3538 res.milliseconds = +other - +base.clone().add(res.months, 'M'); 3539 3540 return res; 3541 } 3542 3543 function momentsDifference(base, other) { 3544 var res; 3545 if (!(base.isValid() && other.isValid())) { 3546 return { milliseconds: 0, months: 0 }; 3547 } 3548 3549 other = cloneWithOffset(other, base); 3550 if (base.isBefore(other)) { 3551 res = positiveMomentsDifference(base, other); 3552 } else { 3553 res = positiveMomentsDifference(other, base); 3554 res.milliseconds = -res.milliseconds; 3555 res.months = -res.months; 3556 } 3557 3558 return res; 3559 } 3560 3561 // TODO: remove 'name' arg after deprecation is removed 3562 function createAdder(direction, name) { 3563 return function (val, period) { 3564 var dur, tmp; 3565 //invert the arguments, but complain about it 3566 if (period !== null && !isNaN(+period)) { 3567 deprecateSimple( 3568 name, 3569 'moment().' + 3570 name + 3571 '(period, number) is deprecated. Please use moment().' + 3572 name + 3573 '(number, period). ' + 3574 'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.' 3575 ); 3576 tmp = val; 3577 val = period; 3578 period = tmp; 3579 } 3580 3581 dur = createDuration(val, period); 3582 addSubtract(this, dur, direction); 3583 return this; 3584 }; 3585 } 3586 3587 function addSubtract(mom, duration, isAdding, updateOffset) { 3588 var milliseconds = duration._milliseconds, 3589 days = absRound(duration._days), 3590 months = absRound(duration._months); 3591 3592 if (!mom.isValid()) { 3593 // No op 3594 return; 3595 } 3596 3597 updateOffset = updateOffset == null ? true : updateOffset; 3598 3599 if (months) { 3600 setMonth(mom, get(mom, 'Month') + months * isAdding); 3601 } 3602 if (days) { 3603 set$1(mom, 'Date', get(mom, 'Date') + days * isAdding); 3604 } 3605 if (milliseconds) { 3606 mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding); 3607 } 3608 if (updateOffset) { 3609 hooks.updateOffset(mom, days || months); 3610 } 3611 } 3612 3613 var add = createAdder(1, 'add'), 3614 subtract = createAdder(-1, 'subtract'); 3615 3616 function isString(input) { 3617 return typeof input === 'string' || input instanceof String; 3618 } 3619 3620 // type MomentInput = Moment | Date | string | number | (number | string)[] | MomentInputObject | void; // null | undefined 3621 function isMomentInput(input) { 3622 return ( 3623 isMoment(input) || 3624 isDate(input) || 3625 isString(input) || 3626 isNumber(input) || 3627 isNumberOrStringArray(input) || 3628 isMomentInputObject(input) || 3629 input === null || 3630 input === undefined 3631 ); 3632 } 3633 3634 function isMomentInputObject(input) { 3635 var objectTest = isObject(input) && !isObjectEmpty(input), 3636 propertyTest = false, 3637 properties = [ 3638 'years', 3639 'year', 3640 'y', 3641 'months', 3642 'month', 3643 'M', 3644 'days', 3645 'day', 3646 'd', 3647 'dates', 3648 'date', 3649 'D', 3650 'hours', 3651 'hour', 3652 'h', 3653 'minutes', 3654 'minute', 3655 'm', 3656 'seconds', 3657 'second', 3658 's', 3659 'milliseconds', 3660 'millisecond', 3661 'ms', 3662 ], 3663 i, 3664 property; 3665 3666 for (i = 0; i < properties.length; i += 1) { 3667 property = properties[i]; 3668 propertyTest = propertyTest || hasOwnProp(input, property); 3669 } 3670 3671 return objectTest && propertyTest; 3672 } 3673 3674 function isNumberOrStringArray(input) { 3675 var arrayTest = isArray(input), 3676 dataTypeTest = false; 3677 if (arrayTest) { 3678 dataTypeTest = 3679 input.filter(function (item) { 3680 return !isNumber(item) && isString(input); 3681 }).length === 0; 3682 } 3683 return arrayTest && dataTypeTest; 3684 } 3685 3686 function isCalendarSpec(input) { 3687 var objectTest = isObject(input) && !isObjectEmpty(input), 3688 propertyTest = false, 3689 properties = [ 3690 'sameDay', 3691 'nextDay', 3692 'lastDay', 3693 'nextWeek', 3694 'lastWeek', 3695 'sameElse', 3696 ], 3697 i, 3698 property; 3699 3700 for (i = 0; i < properties.length; i += 1) { 3701 property = properties[i]; 3702 propertyTest = propertyTest || hasOwnProp(input, property); 3703 } 3704 3705 return objectTest && propertyTest; 3706 } 3707 3708 function getCalendarFormat(myMoment, now) { 3709 var diff = myMoment.diff(now, 'days', true); 3710 return diff < -6 3711 ? 'sameElse' 3712 : diff < -1 3713 ? 'lastWeek' 3714 : diff < 0 3715 ? 'lastDay' 3716 : diff < 1 3717 ? 'sameDay' 3718 : diff < 2 3719 ? 'nextDay' 3720 : diff < 7 3721 ? 'nextWeek' 3722 : 'sameElse'; 3723 } 3724 3725 function calendar$1(time, formats) { 3726 // Support for single parameter, formats only overload to the calendar function 3727 if (arguments.length === 1) { 3728 if (!arguments[0]) { 3729 time = undefined; 3730 formats = undefined; 3731 } else if (isMomentInput(arguments[0])) { 3732 time = arguments[0]; 3733 formats = undefined; 3734 } else if (isCalendarSpec(arguments[0])) { 3735 formats = arguments[0]; 3736 time = undefined; 3737 } 3738 } 3739 // We want to compare the start of today, vs this. 3740 // Getting start-of-today depends on whether we're local/utc/offset or not. 3741 var now = time || createLocal(), 3742 sod = cloneWithOffset(now, this).startOf('day'), 3743 format = hooks.calendarFormat(this, sod) || 'sameElse', 3744 output = 3745 formats && 3746 (isFunction(formats[format]) 3747 ? formats[format].call(this, now) 3748 : formats[format]); 3749 3750 return this.format( 3751 output || this.localeData().calendar(format, this, createLocal(now)) 3752 ); 3753 } 3754 3755 function clone() { 3756 return new Moment(this); 3757 } 3758 3759 function isAfter(input, units) { 3760 var localInput = isMoment(input) ? input : createLocal(input); 3761 if (!(this.isValid() && localInput.isValid())) { 3762 return false; 3763 } 3764 units = normalizeUnits(units) || 'millisecond'; 3765 if (units === 'millisecond') { 3766 return this.valueOf() > localInput.valueOf(); 3767 } else { 3768 return localInput.valueOf() < this.clone().startOf(units).valueOf(); 3769 } 3770 } 3771 3772 function isBefore(input, units) { 3773 var localInput = isMoment(input) ? input : createLocal(input); 3774 if (!(this.isValid() && localInput.isValid())) { 3775 return false; 3776 } 3777 units = normalizeUnits(units) || 'millisecond'; 3778 if (units === 'millisecond') { 3779 return this.valueOf() < localInput.valueOf(); 3780 } else { 3781 return this.clone().endOf(units).valueOf() < localInput.valueOf(); 3782 } 3783 } 3784 3785 function isBetween(from, to, units, inclusivity) { 3786 var localFrom = isMoment(from) ? from : createLocal(from), 3787 localTo = isMoment(to) ? to : createLocal(to); 3788 if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) { 3789 return false; 3790 } 3791 inclusivity = inclusivity || '()'; 3792 return ( 3793 (inclusivity[0] === '(' 3794 ? this.isAfter(localFrom, units) 3795 : !this.isBefore(localFrom, units)) && 3796 (inclusivity[1] === ')' 3797 ? this.isBefore(localTo, units) 3798 : !this.isAfter(localTo, units)) 3799 ); 3800 } 3801 3802 function isSame(input, units) { 3803 var localInput = isMoment(input) ? input : createLocal(input), 3804 inputMs; 3805 if (!(this.isValid() && localInput.isValid())) { 3806 return false; 3807 } 3808 units = normalizeUnits(units) || 'millisecond'; 3809 if (units === 'millisecond') { 3810 return this.valueOf() === localInput.valueOf(); 3811 } else { 3812 inputMs = localInput.valueOf(); 3813 return ( 3814 this.clone().startOf(units).valueOf() <= inputMs && 3815 inputMs <= this.clone().endOf(units).valueOf() 3816 ); 3817 } 3818 } 3819 3820 function isSameOrAfter(input, units) { 3821 return this.isSame(input, units) || this.isAfter(input, units); 3822 } 3823 3824 function isSameOrBefore(input, units) { 3825 return this.isSame(input, units) || this.isBefore(input, units); 3826 } 3827 3828 function diff(input, units, asFloat) { 3829 var that, zoneDelta, output; 3830 3831 if (!this.isValid()) { 3832 return NaN; 3833 } 3834 3835 that = cloneWithOffset(input, this); 3836 3837 if (!that.isValid()) { 3838 return NaN; 3839 } 3840 3841 zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4; 3842 3843 units = normalizeUnits(units); 3844 3845 switch (units) { 3846 case 'year': 3847 output = monthDiff(this, that) / 12; 3848 break; 3849 case 'month': 3850 output = monthDiff(this, that); 3851 break; 3852 case 'quarter': 3853 output = monthDiff(this, that) / 3; 3854 break; 3855 case 'second': 3856 output = (this - that) / 1e3; 3857 break; // 1000 3858 case 'minute': 3859 output = (this - that) / 6e4; 3860 break; // 1000 * 60 3861 case 'hour': 3862 output = (this - that) / 36e5; 3863 break; // 1000 * 60 * 60 3864 case 'day': 3865 output = (this - that - zoneDelta) / 864e5; 3866 break; // 1000 * 60 * 60 * 24, negate dst 3867 case 'week': 3868 output = (this - that - zoneDelta) / 6048e5; 3869 break; // 1000 * 60 * 60 * 24 * 7, negate dst 3870 default: 3871 output = this - that; 3872 } 3873 3874 return asFloat ? output : absFloor(output); 3875 } 3876 3877 function monthDiff(a, b) { 3878 if (a.date() < b.date()) { 3879 // end-of-month calculations work correct when the start month has more 3880 // days than the end month. 3881 return -monthDiff(b, a); 3882 } 3883 // difference in months 3884 var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month()), 3885 // b is in (anchor - 1 month, anchor + 1 month) 3886 anchor = a.clone().add(wholeMonthDiff, 'months'), 3887 anchor2, 3888 adjust; 3889 3890 if (b - anchor < 0) { 3891 anchor2 = a.clone().add(wholeMonthDiff - 1, 'months'); 3892 // linear across the month 3893 adjust = (b - anchor) / (anchor - anchor2); 3894 } else { 3895 anchor2 = a.clone().add(wholeMonthDiff + 1, 'months'); 3896 // linear across the month 3897 adjust = (b - anchor) / (anchor2 - anchor); 3898 } 3899 3900 //check for negative zero, return zero if negative zero 3901 return -(wholeMonthDiff + adjust) || 0; 3902 } 3903 3904 hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ'; 3905 hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]'; 3906 3907 function toString() { 3908 return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ'); 3909 } 3910 3911 function toISOString(keepOffset) { 3912 if (!this.isValid()) { 3913 return null; 3914 } 3915 var utc = keepOffset !== true, 3916 m = utc ? this.clone().utc() : this; 3917 if (m.year() < 0 || m.year() > 9999) { 3918 return formatMoment( 3919 m, 3920 utc 3921 ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]' 3922 : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ' 3923 ); 3924 } 3925 if (isFunction(Date.prototype.toISOString)) { 3926 // native implementation is ~50x faster, use it when we can 3927 if (utc) { 3928 return this.toDate().toISOString(); 3929 } else { 3930 return new Date(this.valueOf() + this.utcOffset() * 60 * 1000) 3931 .toISOString() 3932 .replace('Z', formatMoment(m, 'Z')); 3933 } 3934 } 3935 return formatMoment( 3936 m, 3937 utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ' 3938 ); 3939 } 3940 3941 /** 3942 * Return a human readable representation of a moment that can 3943 * also be evaluated to get a new moment which is the same 3944 * 3945 * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects 3946 */ 3947 function inspect() { 3948 if (!this.isValid()) { 3949 return 'moment.invalid(/* ' + this._i + ' */)'; 3950 } 3951 var func = 'moment', 3952 zone = '', 3953 prefix, 3954 year, 3955 datetime, 3956 suffix; 3957 if (!this.isLocal()) { 3958 func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone'; 3959 zone = 'Z'; 3960 } 3961 prefix = '[' + func + '("]'; 3962 year = 0 <= this.year() && this.year() <= 9999 ? 'YYYY' : 'YYYYYY'; 3963 datetime = '-MM-DD[T]HH:mm:ss.SSS'; 3964 suffix = zone + '[")]'; 3965 3966 return this.format(prefix + year + datetime + suffix); 3967 } 3968 3969 function format(inputString) { 3970 if (!inputString) { 3971 inputString = this.isUtc() 3972 ? hooks.defaultFormatUtc 3973 : hooks.defaultFormat; 3974 } 3975 var output = formatMoment(this, inputString); 3976 return this.localeData().postformat(output); 3977 } 3978 3979 function from(time, withoutSuffix) { 3980 if ( 3981 this.isValid() && 3982 ((isMoment(time) && time.isValid()) || createLocal(time).isValid()) 3983 ) { 3984 return createDuration({ to: this, from: time }) 3985 .locale(this.locale()) 3986 .humanize(!withoutSuffix); 3987 } else { 3988 return this.localeData().invalidDate(); 3989 } 3990 } 3991 3992 function fromNow(withoutSuffix) { 3993 return this.from(createLocal(), withoutSuffix); 3994 } 3995 3996 function to(time, withoutSuffix) { 3997 if ( 3998 this.isValid() && 3999 ((isMoment(time) && time.isValid()) || createLocal(time).isValid()) 4000 ) { 4001 return createDuration({ from: this, to: time }) 4002 .locale(this.locale()) 4003 .humanize(!withoutSuffix); 4004 } else { 4005 return this.localeData().invalidDate(); 4006 } 4007 } 4008 4009 function toNow(withoutSuffix) { 4010 return this.to(createLocal(), withoutSuffix); 4011 } 4012 4013 // If passed a locale key, it will set the locale for this 4014 // instance. Otherwise, it will return the locale configuration 4015 // variables for this instance. 4016 function locale(key) { 4017 var newLocaleData; 4018 4019 if (key === undefined) { 4020 return this._locale._abbr; 4021 } else { 4022 newLocaleData = getLocale(key); 4023 if (newLocaleData != null) { 4024 this._locale = newLocaleData; 4025 } 4026 return this; 4027 } 4028 } 4029 4030 var lang = deprecate( 4031 'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.', 4032 function (key) { 4033 if (key === undefined) { 4034 return this.localeData(); 4035 } else { 4036 return this.locale(key); 4037 } 4038 } 4039 ); 4040 4041 function localeData() { 4042 return this._locale; 4043 } 4044 4045 var MS_PER_SECOND = 1000, 4046 MS_PER_MINUTE = 60 * MS_PER_SECOND, 4047 MS_PER_HOUR = 60 * MS_PER_MINUTE, 4048 MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR; 4049 4050 // actual modulo - handles negative numbers (for dates before 1970): 4051 function mod$1(dividend, divisor) { 4052 return ((dividend % divisor) + divisor) % divisor; 4053 } 4054 4055 function localStartOfDate(y, m, d) { 4056 // the date constructor remaps years 0-99 to 1900-1999 4057 if (y < 100 && y >= 0) { 4058 // preserve leap years using a full 400 year cycle, then reset 4059 return new Date(y + 400, m, d) - MS_PER_400_YEARS; 4060 } else { 4061 return new Date(y, m, d).valueOf(); 4062 } 4063 } 4064 4065 function utcStartOfDate(y, m, d) { 4066 // Date.UTC remaps years 0-99 to 1900-1999 4067 if (y < 100 && y >= 0) { 4068 // preserve leap years using a full 400 year cycle, then reset 4069 return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS; 4070 } else { 4071 return Date.UTC(y, m, d); 4072 } 4073 } 4074 4075 function startOf(units) { 4076 var time, startOfDate; 4077 units = normalizeUnits(units); 4078 if (units === undefined || units === 'millisecond' || !this.isValid()) { 4079 return this; 4080 } 4081 4082 startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate; 4083 4084 switch (units) { 4085 case 'year': 4086 time = startOfDate(this.year(), 0, 1); 4087 break; 4088 case 'quarter': 4089 time = startOfDate( 4090 this.year(), 4091 this.month() - (this.month() % 3), 4092 1 4093 ); 4094 break; 4095 case 'month': 4096 time = startOfDate(this.year(), this.month(), 1); 4097 break; 4098 case 'week': 4099 time = startOfDate( 4100 this.year(), 4101 this.month(), 4102 this.date() - this.weekday() 4103 ); 4104 break; 4105 case 'isoWeek': 4106 time = startOfDate( 4107 this.year(), 4108 this.month(), 4109 this.date() - (this.isoWeekday() - 1) 4110 ); 4111 break; 4112 case 'day': 4113 case 'date': 4114 time = startOfDate(this.year(), this.month(), this.date()); 4115 break; 4116 case 'hour': 4117 time = this._d.valueOf(); 4118 time -= mod$1( 4119 time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), 4120 MS_PER_HOUR 4121 ); 4122 break; 4123 case 'minute': 4124 time = this._d.valueOf(); 4125 time -= mod$1(time, MS_PER_MINUTE); 4126 break; 4127 case 'second': 4128 time = this._d.valueOf(); 4129 time -= mod$1(time, MS_PER_SECOND); 4130 break; 4131 } 4132 4133 this._d.setTime(time); 4134 hooks.updateOffset(this, true); 4135 return this; 4136 } 4137 4138 function endOf(units) { 4139 var time, startOfDate; 4140 units = normalizeUnits(units); 4141 if (units === undefined || units === 'millisecond' || !this.isValid()) { 4142 return this; 4143 } 4144 4145 startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate; 4146 4147 switch (units) { 4148 case 'year': 4149 time = startOfDate(this.year() + 1, 0, 1) - 1; 4150 break; 4151 case 'quarter': 4152 time = 4153 startOfDate( 4154 this.year(), 4155 this.month() - (this.month() % 3) + 3, 4156 1 4157 ) - 1; 4158 break; 4159 case 'month': 4160 time = startOfDate(this.year(), this.month() + 1, 1) - 1; 4161 break; 4162 case 'week': 4163 time = 4164 startOfDate( 4165 this.year(), 4166 this.month(), 4167 this.date() - this.weekday() + 7 4168 ) - 1; 4169 break; 4170 case 'isoWeek': 4171 time = 4172 startOfDate( 4173 this.year(), 4174 this.month(), 4175 this.date() - (this.isoWeekday() - 1) + 7 4176 ) - 1; 4177 break; 4178 case 'day': 4179 case 'date': 4180 time = startOfDate(this.year(), this.month(), this.date() + 1) - 1; 4181 break; 4182 case 'hour': 4183 time = this._d.valueOf(); 4184 time += 4185 MS_PER_HOUR - 4186 mod$1( 4187 time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), 4188 MS_PER_HOUR 4189 ) - 4190 1; 4191 break; 4192 case 'minute': 4193 time = this._d.valueOf(); 4194 time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1; 4195 break; 4196 case 'second': 4197 time = this._d.valueOf(); 4198 time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1; 4199 break; 4200 } 4201 4202 this._d.setTime(time); 4203 hooks.updateOffset(this, true); 4204 return this; 4205 } 4206 4207 function valueOf() { 4208 return this._d.valueOf() - (this._offset || 0) * 60000; 4209 } 4210 4211 function unix() { 4212 return Math.floor(this.valueOf() / 1000); 4213 } 4214 4215 function toDate() { 4216 return new Date(this.valueOf()); 4217 } 4218 4219 function toArray() { 4220 var m = this; 4221 return [ 4222 m.year(), 4223 m.month(), 4224 m.date(), 4225 m.hour(), 4226 m.minute(), 4227 m.second(), 4228 m.millisecond(), 4229 ]; 4230 } 4231 4232 function toObject() { 4233 var m = this; 4234 return { 4235 years: m.year(), 4236 months: m.month(), 4237 date: m.date(), 4238 hours: m.hours(), 4239 minutes: m.minutes(), 4240 seconds: m.seconds(), 4241 milliseconds: m.milliseconds(), 4242 }; 4243 } 4244 4245 function toJSON() { 4246 // new Date(NaN).toJSON() === null 4247 return this.isValid() ? this.toISOString() : null; 4248 } 4249 4250 function isValid$2() { 4251 return isValid(this); 4252 } 4253 4254 function parsingFlags() { 4255 return extend({}, getParsingFlags(this)); 4256 } 4257 4258 function invalidAt() { 4259 return getParsingFlags(this).overflow; 4260 } 4261 4262 function creationData() { 4263 return { 4264 input: this._i, 4265 format: this._f, 4266 locale: this._locale, 4267 isUTC: this._isUTC, 4268 strict: this._strict, 4269 }; 4270 } 4271 4272 addFormatToken('N', 0, 0, 'eraAbbr'); 4273 addFormatToken('NN', 0, 0, 'eraAbbr'); 4274 addFormatToken('NNN', 0, 0, 'eraAbbr'); 4275 addFormatToken('NNNN', 0, 0, 'eraName'); 4276 addFormatToken('NNNNN', 0, 0, 'eraNarrow'); 4277 4278 addFormatToken('y', ['y', 1], 'yo', 'eraYear'); 4279 addFormatToken('y', ['yy', 2], 0, 'eraYear'); 4280 addFormatToken('y', ['yyy', 3], 0, 'eraYear'); 4281 addFormatToken('y', ['yyyy', 4], 0, 'eraYear'); 4282 4283 addRegexToken('N', matchEraAbbr); 4284 addRegexToken('NN', matchEraAbbr); 4285 addRegexToken('NNN', matchEraAbbr); 4286 addRegexToken('NNNN', matchEraName); 4287 addRegexToken('NNNNN', matchEraNarrow); 4288 4289 addParseToken(['N', 'NN', 'NNN', 'NNNN', 'NNNNN'], function ( 4290 input, 4291 array, 4292 config, 4293 token 4294 ) { 4295 var era = config._locale.erasParse(input, token, config._strict); 4296 if (era) { 4297 getParsingFlags(config).era = era; 4298 } else { 4299 getParsingFlags(config).invalidEra = input; 4300 } 4301 }); 4302 4303 addRegexToken('y', matchUnsigned); 4304 addRegexToken('yy', matchUnsigned); 4305 addRegexToken('yyy', matchUnsigned); 4306 addRegexToken('yyyy', matchUnsigned); 4307 addRegexToken('yo', matchEraYearOrdinal); 4308 4309 addParseToken(['y', 'yy', 'yyy', 'yyyy'], YEAR); 4310 addParseToken(['yo'], function (input, array, config, token) { 4311 var match; 4312 if (config._locale._eraYearOrdinalRegex) { 4313 match = input.match(config._locale._eraYearOrdinalRegex); 4314 } 4315 4316 if (config._locale.eraYearOrdinalParse) { 4317 array[YEAR] = config._locale.eraYearOrdinalParse(input, match); 4318 } else { 4319 array[YEAR] = parseInt(input, 10); 4320 } 4321 }); 4322 4323 function localeEras(m, format) { 4324 var i, 4325 l, 4326 date, 4327 eras = this._eras || getLocale('en')._eras; 4328 for (i = 0, l = eras.length; i < l; ++i) { 4329 switch (typeof eras[i].since) { 4330 case 'string': 4331 // truncate time 4332 date = hooks(eras[i].since).startOf('day'); 4333 eras[i].since = date.valueOf(); 4334 break; 4335 } 4336 4337 switch (typeof eras[i].until) { 4338 case 'undefined': 4339 eras[i].until = +Infinity; 4340 break; 4341 case 'string': 4342 // truncate time 4343 date = hooks(eras[i].until).startOf('day').valueOf(); 4344 eras[i].until = date.valueOf(); 4345 break; 4346 } 4347 } 4348 return eras; 4349 } 4350 4351 function localeErasParse(eraName, format, strict) { 4352 var i, 4353 l, 4354 eras = this.eras(), 4355 name, 4356 abbr, 4357 narrow; 4358 eraName = eraName.toUpperCase(); 4359 4360 for (i = 0, l = eras.length; i < l; ++i) { 4361 name = eras[i].name.toUpperCase(); 4362 abbr = eras[i].abbr.toUpperCase(); 4363 narrow = eras[i].narrow.toUpperCase(); 4364 4365 if (strict) { 4366 switch (format) { 4367 case 'N': 4368 case 'NN': 4369 case 'NNN': 4370 if (abbr === eraName) { 4371 return eras[i]; 4372 } 4373 break; 4374 4375 case 'NNNN': 4376 if (name === eraName) { 4377 return eras[i]; 4378 } 4379 break; 4380 4381 case 'NNNNN': 4382 if (narrow === eraName) { 4383 return eras[i]; 4384 } 4385 break; 4386 } 4387 } else if ([name, abbr, narrow].indexOf(eraName) >= 0) { 4388 return eras[i]; 4389 } 4390 } 4391 } 4392 4393 function localeErasConvertYear(era, year) { 4394 var dir = era.since <= era.until ? +1 : -1; 4395 if (year === undefined) { 4396 return hooks(era.since).year(); 4397 } else { 4398 return hooks(era.since).year() + (year - era.offset) * dir; 4399 } 4400 } 4401 4402 function getEraName() { 4403 var i, 4404 l, 4405 val, 4406 eras = this.localeData().eras(); 4407 for (i = 0, l = eras.length; i < l; ++i) { 4408 // truncate time 4409 val = this.clone().startOf('day').valueOf(); 4410 4411 if (eras[i].since <= val && val <= eras[i].until) { 4412 return eras[i].name; 4413 } 4414 if (eras[i].until <= val && val <= eras[i].since) { 4415 return eras[i].name; 4416 } 4417 } 4418 4419 return ''; 4420 } 4421 4422 function getEraNarrow() { 4423 var i, 4424 l, 4425 val, 4426 eras = this.localeData().eras(); 4427 for (i = 0, l = eras.length; i < l; ++i) { 4428 // truncate time 4429 val = this.clone().startOf('day').valueOf(); 4430 4431 if (eras[i].since <= val && val <= eras[i].until) { 4432 return eras[i].narrow; 4433 } 4434 if (eras[i].until <= val && val <= eras[i].since) { 4435 return eras[i].narrow; 4436 } 4437 } 4438 4439 return ''; 4440 } 4441 4442 function getEraAbbr() { 4443 var i, 4444 l, 4445 val, 4446 eras = this.localeData().eras(); 4447 for (i = 0, l = eras.length; i < l; ++i) { 4448 // truncate time 4449 val = this.clone().startOf('day').valueOf(); 4450 4451 if (eras[i].since <= val && val <= eras[i].until) { 4452 return eras[i].abbr; 4453 } 4454 if (eras[i].until <= val && val <= eras[i].since) { 4455 return eras[i].abbr; 4456 } 4457 } 4458 4459 return ''; 4460 } 4461 4462 function getEraYear() { 4463 var i, 4464 l, 4465 dir, 4466 val, 4467 eras = this.localeData().eras(); 4468 for (i = 0, l = eras.length; i < l; ++i) { 4469 dir = eras[i].since <= eras[i].until ? +1 : -1; 4470 4471 // truncate time 4472 val = this.clone().startOf('day').valueOf(); 4473 4474 if ( 4475 (eras[i].since <= val && val <= eras[i].until) || 4476 (eras[i].until <= val && val <= eras[i].since) 4477 ) { 4478 return ( 4479 (this.year() - hooks(eras[i].since).year()) * dir + 4480 eras[i].offset 4481 ); 4482 } 4483 } 4484 4485 return this.year(); 4486 } 4487 4488 function erasNameRegex(isStrict) { 4489 if (!hasOwnProp(this, '_erasNameRegex')) { 4490 computeErasParse.call(this); 4491 } 4492 return isStrict ? this._erasNameRegex : this._erasRegex; 4493 } 4494 4495 function erasAbbrRegex(isStrict) { 4496 if (!hasOwnProp(this, '_erasAbbrRegex')) { 4497 computeErasParse.call(this); 4498 } 4499 return isStrict ? this._erasAbbrRegex : this._erasRegex; 4500 } 4501 4502 function erasNarrowRegex(isStrict) { 4503 if (!hasOwnProp(this, '_erasNarrowRegex')) { 4504 computeErasParse.call(this); 4505 } 4506 return isStrict ? this._erasNarrowRegex : this._erasRegex; 4507 } 4508 4509 function matchEraAbbr(isStrict, locale) { 4510 return locale.erasAbbrRegex(isStrict); 4511 } 4512 4513 function matchEraName(isStrict, locale) { 4514 return locale.erasNameRegex(isStrict); 4515 } 4516 4517 function matchEraNarrow(isStrict, locale) { 4518 return locale.erasNarrowRegex(isStrict); 4519 } 4520 4521 function matchEraYearOrdinal(isStrict, locale) { 4522 return locale._eraYearOrdinalRegex || matchUnsigned; 4523 } 4524 4525 function computeErasParse() { 4526 var abbrPieces = [], 4527 namePieces = [], 4528 narrowPieces = [], 4529 mixedPieces = [], 4530 i, 4531 l, 4532 eras = this.eras(); 4533 4534 for (i = 0, l = eras.length; i < l; ++i) { 4535 namePieces.push(regexEscape(eras[i].name)); 4536 abbrPieces.push(regexEscape(eras[i].abbr)); 4537 narrowPieces.push(regexEscape(eras[i].narrow)); 4538 4539 mixedPieces.push(regexEscape(eras[i].name)); 4540 mixedPieces.push(regexEscape(eras[i].abbr)); 4541 mixedPieces.push(regexEscape(eras[i].narrow)); 4542 } 4543 4544 this._erasRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i'); 4545 this._erasNameRegex = new RegExp('^(' + namePieces.join('|') + ')', 'i'); 4546 this._erasAbbrRegex = new RegExp('^(' + abbrPieces.join('|') + ')', 'i'); 4547 this._erasNarrowRegex = new RegExp( 4548 '^(' + narrowPieces.join('|') + ')', 4549 'i' 4550 ); 4551 } 4552 4553 // FORMATTING 4554 4555 addFormatToken(0, ['gg', 2], 0, function () { 4556 return this.weekYear() % 100; 4557 }); 4558 4559 addFormatToken(0, ['GG', 2], 0, function () { 4560 return this.isoWeekYear() % 100; 4561 }); 4562 4563 function addWeekYearFormatToken(token, getter) { 4564 addFormatToken(0, [token, token.length], 0, getter); 4565 } 4566 4567 addWeekYearFormatToken('gggg', 'weekYear'); 4568 addWeekYearFormatToken('ggggg', 'weekYear'); 4569 addWeekYearFormatToken('GGGG', 'isoWeekYear'); 4570 addWeekYearFormatToken('GGGGG', 'isoWeekYear'); 4571 4572 // ALIASES 4573 4574 addUnitAlias('weekYear', 'gg'); 4575 addUnitAlias('isoWeekYear', 'GG'); 4576 4577 // PRIORITY 4578 4579 addUnitPriority('weekYear', 1); 4580 addUnitPriority('isoWeekYear', 1); 4581 4582 // PARSING 4583 4584 addRegexToken('G', matchSigned); 4585 addRegexToken('g', matchSigned); 4586 addRegexToken('GG', match1to2, match2); 4587 addRegexToken('gg', match1to2, match2); 4588 addRegexToken('GGGG', match1to4, match4); 4589 addRegexToken('gggg', match1to4, match4); 4590 addRegexToken('GGGGG', match1to6, match6); 4591 addRegexToken('ggggg', match1to6, match6); 4592 4593 addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function ( 4594 input, 4595 week, 4596 config, 4597 token 4598 ) { 4599 week[token.substr(0, 2)] = toInt(input); 4600 }); 4601 4602 addWeekParseToken(['gg', 'GG'], function (input, week, config, token) { 4603 week[token] = hooks.parseTwoDigitYear(input); 4604 }); 4605 4606 // MOMENTS 4607 4608 function getSetWeekYear(input) { 4609 return getSetWeekYearHelper.call( 4610 this, 4611 input, 4612 this.week(), 4613 this.weekday(), 4614 this.localeData()._week.dow, 4615 this.localeData()._week.doy 4616 ); 4617 } 4618 4619 function getSetISOWeekYear(input) { 4620 return getSetWeekYearHelper.call( 4621 this, 4622 input, 4623 this.isoWeek(), 4624 this.isoWeekday(), 4625 1, 4626 4 4627 ); 4628 } 4629 4630 function getISOWeeksInYear() { 4631 return weeksInYear(this.year(), 1, 4); 4632 } 4633 4634 function getISOWeeksInISOWeekYear() { 4635 return weeksInYear(this.isoWeekYear(), 1, 4); 4636 } 4637 4638 function getWeeksInYear() { 4639 var weekInfo = this.localeData()._week; 4640 return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy); 4641 } 4642 4643 function getWeeksInWeekYear() { 4644 var weekInfo = this.localeData()._week; 4645 return weeksInYear(this.weekYear(), weekInfo.dow, weekInfo.doy); 4646 } 4647 4648 function getSetWeekYearHelper(input, week, weekday, dow, doy) { 4649 var weeksTarget; 4650 if (input == null) { 4651 return weekOfYear(this, dow, doy).year; 4652 } else { 4653 weeksTarget = weeksInYear(input, dow, doy); 4654 if (week > weeksTarget) { 4655 week = weeksTarget; 4656 } 4657 return setWeekAll.call(this, input, week, weekday, dow, doy); 4658 } 4659 } 4660 4661 function setWeekAll(weekYear, week, weekday, dow, doy) { 4662 var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy), 4663 date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear); 4664 4665 this.year(date.getUTCFullYear()); 4666 this.month(date.getUTCMonth()); 4667 this.date(date.getUTCDate()); 4668 return this; 4669 } 4670 4671 // FORMATTING 4672 4673 addFormatToken('Q', 0, 'Qo', 'quarter'); 4674 4675 // ALIASES 4676 4677 addUnitAlias('quarter', 'Q'); 4678 4679 // PRIORITY 4680 4681 addUnitPriority('quarter', 7); 4682 4683 // PARSING 4684 4685 addRegexToken('Q', match1); 4686 addParseToken('Q', function (input, array) { 4687 array[MONTH] = (toInt(input) - 1) * 3; 4688 }); 4689 4690 // MOMENTS 4691 4692 function getSetQuarter(input) { 4693 return input == null 4694 ? Math.ceil((this.month() + 1) / 3) 4695 : this.month((input - 1) * 3 + (this.month() % 3)); 4696 } 4697 4698 // FORMATTING 4699 4700 addFormatToken('D', ['DD', 2], 'Do', 'date'); 4701 4702 // ALIASES 4703 4704 addUnitAlias('date', 'D'); 4705 4706 // PRIORITY 4707 addUnitPriority('date', 9); 4708 4709 // PARSING 4710 4711 addRegexToken('D', match1to2); 4712 addRegexToken('DD', match1to2, match2); 4713 addRegexToken('Do', function (isStrict, locale) { 4714 // TODO: Remove "ordinalParse" fallback in next major release. 4715 return isStrict 4716 ? locale._dayOfMonthOrdinalParse || locale._ordinalParse 4717 : locale._dayOfMonthOrdinalParseLenient; 4718 }); 4719 4720 addParseToken(['D', 'DD'], DATE); 4721 addParseToken('Do', function (input, array) { 4722 array[DATE] = toInt(input.match(match1to2)[0]); 4723 }); 4724 4725 // MOMENTS 4726 4727 var getSetDayOfMonth = makeGetSet('Date', true); 4728 4729 // FORMATTING 4730 4731 addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear'); 4732 4733 // ALIASES 4734 4735 addUnitAlias('dayOfYear', 'DDD'); 4736 4737 // PRIORITY 4738 addUnitPriority('dayOfYear', 4); 4739 4740 // PARSING 4741 4742 addRegexToken('DDD', match1to3); 4743 addRegexToken('DDDD', match3); 4744 addParseToken(['DDD', 'DDDD'], function (input, array, config) { 4745 config._dayOfYear = toInt(input); 4746 }); 4747 4748 // HELPERS 4749 4750 // MOMENTS 4751 4752 function getSetDayOfYear(input) { 4753 var dayOfYear = 4754 Math.round( 4755 (this.clone().startOf('day') - this.clone().startOf('year')) / 864e5 4756 ) + 1; 4757 return input == null ? dayOfYear : this.add(input - dayOfYear, 'd'); 4758 } 4759 4760 // FORMATTING 4761 4762 addFormatToken('m', ['mm', 2], 0, 'minute'); 4763 4764 // ALIASES 4765 4766 addUnitAlias('minute', 'm'); 4767 4768 // PRIORITY 4769 4770 addUnitPriority('minute', 14); 4771 4772 // PARSING 4773 4774 addRegexToken('m', match1to2); 4775 addRegexToken('mm', match1to2, match2); 4776 addParseToken(['m', 'mm'], MINUTE); 4777 4778 // MOMENTS 4779 4780 var getSetMinute = makeGetSet('Minutes', false); 4781 4782 // FORMATTING 4783 4784 addFormatToken('s', ['ss', 2], 0, 'second'); 4785 4786 // ALIASES 4787 4788 addUnitAlias('second', 's'); 4789 4790 // PRIORITY 4791 4792 addUnitPriority('second', 15); 4793 4794 // PARSING 4795 4796 addRegexToken('s', match1to2); 4797 addRegexToken('ss', match1to2, match2); 4798 addParseToken(['s', 'ss'], SECOND); 4799 4800 // MOMENTS 4801 4802 var getSetSecond = makeGetSet('Seconds', false); 4803 4804 // FORMATTING 4805 4806 addFormatToken('S', 0, 0, function () { 4807 return ~~(this.millisecond() / 100); 4808 }); 4809 4810 addFormatToken(0, ['SS', 2], 0, function () { 4811 return ~~(this.millisecond() / 10); 4812 }); 4813 4814 addFormatToken(0, ['SSS', 3], 0, 'millisecond'); 4815 addFormatToken(0, ['SSSS', 4], 0, function () { 4816 return this.millisecond() * 10; 4817 }); 4818 addFormatToken(0, ['SSSSS', 5], 0, function () { 4819 return this.millisecond() * 100; 4820 }); 4821 addFormatToken(0, ['SSSSSS', 6], 0, function () { 4822 return this.millisecond() * 1000; 4823 }); 4824 addFormatToken(0, ['SSSSSSS', 7], 0, function () { 4825 return this.millisecond() * 10000; 4826 }); 4827 addFormatToken(0, ['SSSSSSSS', 8], 0, function () { 4828 return this.millisecond() * 100000; 4829 }); 4830 addFormatToken(0, ['SSSSSSSSS', 9], 0, function () { 4831 return this.millisecond() * 1000000; 4832 }); 4833 4834 // ALIASES 4835 4836 addUnitAlias('millisecond', 'ms'); 4837 4838 // PRIORITY 4839 4840 addUnitPriority('millisecond', 16); 4841 4842 // PARSING 4843 4844 addRegexToken('S', match1to3, match1); 4845 addRegexToken('SS', match1to3, match2); 4846 addRegexToken('SSS', match1to3, match3); 4847 4848 var token, getSetMillisecond; 4849 for (token = 'SSSS'; token.length <= 9; token += 'S') { 4850 addRegexToken(token, matchUnsigned); 4851 } 4852 4853 function parseMs(input, array) { 4854 array[MILLISECOND] = toInt(('0.' + input) * 1000); 4855 } 4856 4857 for (token = 'S'; token.length <= 9; token += 'S') { 4858 addParseToken(token, parseMs); 4859 } 4860 4861 getSetMillisecond = makeGetSet('Milliseconds', false); 4862 4863 // FORMATTING 4864 4865 addFormatToken('z', 0, 0, 'zoneAbbr'); 4866 addFormatToken('zz', 0, 0, 'zoneName'); 4867 4868 // MOMENTS 4869 4870 function getZoneAbbr() { 4871 return this._isUTC ? 'UTC' : ''; 4872 } 4873 4874 function getZoneName() { 4875 return this._isUTC ? 'Coordinated Universal Time' : ''; 4876 } 4877 4878 var proto = Moment.prototype; 4879 4880 proto.add = add; 4881 proto.calendar = calendar$1; 4882 proto.clone = clone; 4883 proto.diff = diff; 4884 proto.endOf = endOf; 4885 proto.format = format; 4886 proto.from = from; 4887 proto.fromNow = fromNow; 4888 proto.to = to; 4889 proto.toNow = toNow; 4890 proto.get = stringGet; 4891 proto.invalidAt = invalidAt; 4892 proto.isAfter = isAfter; 4893 proto.isBefore = isBefore; 4894 proto.isBetween = isBetween; 4895 proto.isSame = isSame; 4896 proto.isSameOrAfter = isSameOrAfter; 4897 proto.isSameOrBefore = isSameOrBefore; 4898 proto.isValid = isValid$2; 4899 proto.lang = lang; 4900 proto.locale = locale; 4901 proto.localeData = localeData; 4902 proto.max = prototypeMax; 4903 proto.min = prototypeMin; 4904 proto.parsingFlags = parsingFlags; 4905 proto.set = stringSet; 4906 proto.startOf = startOf; 4907 proto.subtract = subtract; 4908 proto.toArray = toArray; 4909 proto.toObject = toObject; 4910 proto.toDate = toDate; 4911 proto.toISOString = toISOString; 4912 proto.inspect = inspect; 4913 if (typeof Symbol !== 'undefined' && Symbol.for != null) { 4914 proto[Symbol.for('nodejs.util.inspect.custom')] = function () { 4915 return 'Moment<' + this.format() + '>'; 4916 }; 4917 } 4918 proto.toJSON = toJSON; 4919 proto.toString = toString; 4920 proto.unix = unix; 4921 proto.valueOf = valueOf; 4922 proto.creationData = creationData; 4923 proto.eraName = getEraName; 4924 proto.eraNarrow = getEraNarrow; 4925 proto.eraAbbr = getEraAbbr; 4926 proto.eraYear = getEraYear; 4927 proto.year = getSetYear; 4928 proto.isLeapYear = getIsLeapYear; 4929 proto.weekYear = getSetWeekYear; 4930 proto.isoWeekYear = getSetISOWeekYear; 4931 proto.quarter = proto.quarters = getSetQuarter; 4932 proto.month = getSetMonth; 4933 proto.daysInMonth = getDaysInMonth; 4934 proto.week = proto.weeks = getSetWeek; 4935 proto.isoWeek = proto.isoWeeks = getSetISOWeek; 4936 proto.weeksInYear = getWeeksInYear; 4937 proto.weeksInWeekYear = getWeeksInWeekYear; 4938 proto.isoWeeksInYear = getISOWeeksInYear; 4939 proto.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear; 4940 proto.date = getSetDayOfMonth; 4941 proto.day = proto.days = getSetDayOfWeek; 4942 proto.weekday = getSetLocaleDayOfWeek; 4943 proto.isoWeekday = getSetISODayOfWeek; 4944 proto.dayOfYear = getSetDayOfYear; 4945 proto.hour = proto.hours = getSetHour; 4946 proto.minute = proto.minutes = getSetMinute; 4947 proto.second = proto.seconds = getSetSecond; 4948 proto.millisecond = proto.milliseconds = getSetMillisecond; 4949 proto.utcOffset = getSetOffset; 4950 proto.utc = setOffsetToUTC; 4951 proto.local = setOffsetToLocal; 4952 proto.parseZone = setOffsetToParsedOffset; 4953 proto.hasAlignedHourOffset = hasAlignedHourOffset; 4954 proto.isDST = isDaylightSavingTime; 4955 proto.isLocal = isLocal; 4956 proto.isUtcOffset = isUtcOffset; 4957 proto.isUtc = isUtc; 4958 proto.isUTC = isUtc; 4959 proto.zoneAbbr = getZoneAbbr; 4960 proto.zoneName = getZoneName; 4961 proto.dates = deprecate( 4962 'dates accessor is deprecated. Use date instead.', 4963 getSetDayOfMonth 4964 ); 4965 proto.months = deprecate( 4966 'months accessor is deprecated. Use month instead', 4967 getSetMonth 4968 ); 4969 proto.years = deprecate( 4970 'years accessor is deprecated. Use year instead', 4971 getSetYear 4972 ); 4973 proto.zone = deprecate( 4974 'moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', 4975 getSetZone 4976 ); 4977 proto.isDSTShifted = deprecate( 4978 'isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', 4979 isDaylightSavingTimeShifted 4980 ); 4981 4982 function createUnix(input) { 4983 return createLocal(input * 1000); 4984 } 4985 4986 function createInZone() { 4987 return createLocal.apply(null, arguments).parseZone(); 4988 } 4989 4990 function preParsePostFormat(string) { 4991 return string; 4992 } 4993 4994 var proto$1 = Locale.prototype; 4995 4996 proto$1.calendar = calendar; 4997 proto$1.longDateFormat = longDateFormat; 4998 proto$1.invalidDate = invalidDate; 4999 proto$1.ordinal = ordinal; 5000 proto$1.preparse = preParsePostFormat; 5001 proto$1.postformat = preParsePostFormat; 5002 proto$1.relativeTime = relativeTime; 5003 proto$1.pastFuture = pastFuture; 5004 proto$1.set = set; 5005 proto$1.eras = localeEras; 5006 proto$1.erasParse = localeErasParse; 5007 proto$1.erasConvertYear = localeErasConvertYear; 5008 proto$1.erasAbbrRegex = erasAbbrRegex; 5009 proto$1.erasNameRegex = erasNameRegex; 5010 proto$1.erasNarrowRegex = erasNarrowRegex; 5011 5012 proto$1.months = localeMonths; 5013 proto$1.monthsShort = localeMonthsShort; 5014 proto$1.monthsParse = localeMonthsParse; 5015 proto$1.monthsRegex = monthsRegex; 5016 proto$1.monthsShortRegex = monthsShortRegex; 5017 proto$1.week = localeWeek; 5018 proto$1.firstDayOfYear = localeFirstDayOfYear; 5019 proto$1.firstDayOfWeek = localeFirstDayOfWeek; 5020 5021 proto$1.weekdays = localeWeekdays; 5022 proto$1.weekdaysMin = localeWeekdaysMin; 5023 proto$1.weekdaysShort = localeWeekdaysShort; 5024 proto$1.weekdaysParse = localeWeekdaysParse; 5025 5026 proto$1.weekdaysRegex = weekdaysRegex; 5027 proto$1.weekdaysShortRegex = weekdaysShortRegex; 5028 proto$1.weekdaysMinRegex = weekdaysMinRegex; 5029 5030 proto$1.isPM = localeIsPM; 5031 proto$1.meridiem = localeMeridiem; 5032 5033 function get$1(format, index, field, setter) { 5034 var locale = getLocale(), 5035 utc = createUTC().set(setter, index); 5036 return locale[field](utc, format); 5037 } 5038 5039 function listMonthsImpl(format, index, field) { 5040 if (isNumber(format)) { 5041 index = format; 5042 format = undefined; 5043 } 5044 5045 format = format || ''; 5046 5047 if (index != null) { 5048 return get$1(format, index, field, 'month'); 5049 } 5050 5051 var i, 5052 out = []; 5053 for (i = 0; i < 12; i++) { 5054 out[i] = get$1(format, i, field, 'month'); 5055 } 5056 return out; 5057 } 5058 5059 // () 5060 // (5) 5061 // (fmt, 5) 5062 // (fmt) 5063 // (true) 5064 // (true, 5) 5065 // (true, fmt, 5) 5066 // (true, fmt) 5067 function listWeekdaysImpl(localeSorted, format, index, field) { 5068 if (typeof localeSorted === 'boolean') { 5069 if (isNumber(format)) { 5070 index = format; 5071 format = undefined; 5072 } 5073 5074 format = format || ''; 5075 } else { 5076 format = localeSorted; 5077 index = format; 5078 localeSorted = false; 5079 5080 if (isNumber(format)) { 5081 index = format; 5082 format = undefined; 5083 } 5084 5085 format = format || ''; 5086 } 5087 5088 var locale = getLocale(), 5089 shift = localeSorted ? locale._week.dow : 0, 5090 i, 5091 out = []; 5092 5093 if (index != null) { 5094 return get$1(format, (index + shift) % 7, field, 'day'); 5095 } 5096 5097 for (i = 0; i < 7; i++) { 5098 out[i] = get$1(format, (i + shift) % 7, field, 'day'); 5099 } 5100 return out; 5101 } 5102 5103 function listMonths(format, index) { 5104 return listMonthsImpl(format, index, 'months'); 5105 } 5106 5107 function listMonthsShort(format, index) { 5108 return listMonthsImpl(format, index, 'monthsShort'); 5109 } 5110 5111 function listWeekdays(localeSorted, format, index) { 5112 return listWeekdaysImpl(localeSorted, format, index, 'weekdays'); 5113 } 5114 5115 function listWeekdaysShort(localeSorted, format, index) { 5116 return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort'); 5117 } 5118 5119 function listWeekdaysMin(localeSorted, format, index) { 5120 return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin'); 5121 } 5122 5123 getSetGlobalLocale('en', { 5124 eras: [ 5125 { 5126 since: '0001-01-01', 5127 until: +Infinity, 5128 offset: 1, 5129 name: 'Anno Domini', 5130 narrow: 'AD', 5131 abbr: 'AD', 5132 }, 5133 { 5134 since: '0000-12-31', 5135 until: -Infinity, 5136 offset: 1, 5137 name: 'Before Christ', 5138 narrow: 'BC', 5139 abbr: 'BC', 5140 }, 5141 ], 5142 dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/, 5143 ordinal: function (number) { 5144 var b = number % 10, 5145 output = 5146 toInt((number % 100) / 10) === 1 5147 ? 'th' 5148 : b === 1 5149 ? 'st' 5150 : b === 2 5151 ? 'nd' 5152 : b === 3 5153 ? 'rd' 5154 : 'th'; 5155 return number + output; 5156 }, 5157 }); 5158 5159 // Side effect imports 5160 5161 hooks.lang = deprecate( 5162 'moment.lang is deprecated. Use moment.locale instead.', 5163 getSetGlobalLocale 5164 ); 5165 hooks.langData = deprecate( 5166 'moment.langData is deprecated. Use moment.localeData instead.', 5167 getLocale 5168 ); 5169 5170 var mathAbs = Math.abs; 5171 5172 function abs() { 5173 var data = this._data; 5174 5175 this._milliseconds = mathAbs(this._milliseconds); 5176 this._days = mathAbs(this._days); 5177 this._months = mathAbs(this._months); 5178 5179 data.milliseconds = mathAbs(data.milliseconds); 5180 data.seconds = mathAbs(data.seconds); 5181 data.minutes = mathAbs(data.minutes); 5182 data.hours = mathAbs(data.hours); 5183 data.months = mathAbs(data.months); 5184 data.years = mathAbs(data.years); 5185 5186 return this; 5187 } 5188 5189 function addSubtract$1(duration, input, value, direction) { 5190 var other = createDuration(input, value); 5191 5192 duration._milliseconds += direction * other._milliseconds; 5193 duration._days += direction * other._days; 5194 duration._months += direction * other._months; 5195 5196 return duration._bubble(); 5197 } 5198 5199 // supports only 2.0-style add(1, 's') or add(duration) 5200 function add$1(input, value) { 5201 return addSubtract$1(this, input, value, 1); 5202 } 5203 5204 // supports only 2.0-style subtract(1, 's') or subtract(duration) 5205 function subtract$1(input, value) { 5206 return addSubtract$1(this, input, value, -1); 5207 } 5208 5209 function absCeil(number) { 5210 if (number < 0) { 5211 return Math.floor(number); 5212 } else { 5213 return Math.ceil(number); 5214 } 5215 } 5216 5217 function bubble() { 5218 var milliseconds = this._milliseconds, 5219 days = this._days, 5220 months = this._months, 5221 data = this._data, 5222 seconds, 5223 minutes, 5224 hours, 5225 years, 5226 monthsFromDays; 5227 5228 // if we have a mix of positive and negative values, bubble down first 5229 // check: https://github.com/moment/moment/issues/2166 5230 if ( 5231 !( 5232 (milliseconds >= 0 && days >= 0 && months >= 0) || 5233 (milliseconds <= 0 && days <= 0 && months <= 0) 5234 ) 5235 ) { 5236 milliseconds += absCeil(monthsToDays(months) + days) * 864e5; 5237 days = 0; 5238 months = 0; 5239 } 5240 5241 // The following code bubbles up values, see the tests for 5242 // examples of what that means. 5243 data.milliseconds = milliseconds % 1000; 5244 5245 seconds = absFloor(milliseconds / 1000); 5246 data.seconds = seconds % 60; 5247 5248 minutes = absFloor(seconds / 60); 5249 data.minutes = minutes % 60; 5250 5251 hours = absFloor(minutes / 60); 5252 data.hours = hours % 24; 5253 5254 days += absFloor(hours / 24); 5255 5256 // convert days to months 5257 monthsFromDays = absFloor(daysToMonths(days)); 5258 months += monthsFromDays; 5259 days -= absCeil(monthsToDays(monthsFromDays)); 5260 5261 // 12 months -> 1 year 5262 years = absFloor(months / 12); 5263 months %= 12; 5264 5265 data.days = days; 5266 data.months = months; 5267 data.years = years; 5268 5269 return this; 5270 } 5271 5272 function daysToMonths(days) { 5273 // 400 years have 146097 days (taking into account leap year rules) 5274 // 400 years have 12 months === 4800 5275 return (days * 4800) / 146097; 5276 } 5277 5278 function monthsToDays(months) { 5279 // the reverse of daysToMonths 5280 return (months * 146097) / 4800; 5281 } 5282 5283 function as(units) { 5284 if (!this.isValid()) { 5285 return NaN; 5286 } 5287 var days, 5288 months, 5289 milliseconds = this._milliseconds; 5290 5291 units = normalizeUnits(units); 5292 5293 if (units === 'month' || units === 'quarter' || units === 'year') { 5294 days = this._days + milliseconds / 864e5; 5295 months = this._months + daysToMonths(days); 5296 switch (units) { 5297 case 'month': 5298 return months; 5299 case 'quarter': 5300 return months / 3; 5301 case 'year': 5302 return months / 12; 5303 } 5304 } else { 5305 // handle milliseconds separately because of floating point math errors (issue #1867) 5306 days = this._days + Math.round(monthsToDays(this._months)); 5307 switch (units) { 5308 case 'week': 5309 return days / 7 + milliseconds / 6048e5; 5310 case 'day': 5311 return days + milliseconds / 864e5; 5312 case 'hour': 5313 return days * 24 + milliseconds / 36e5; 5314 case 'minute': 5315 return days * 1440 + milliseconds / 6e4; 5316 case 'second': 5317 return days * 86400 + milliseconds / 1000; 5318 // Math.floor prevents floating point math errors here 5319 case 'millisecond': 5320 return Math.floor(days * 864e5) + milliseconds; 5321 default: 5322 throw new Error('Unknown unit ' + units); 5323 } 5324 } 5325 } 5326 5327 // TODO: Use this.as('ms')? 5328 function valueOf$1() { 5329 if (!this.isValid()) { 5330 return NaN; 5331 } 5332 return ( 5333 this._milliseconds + 5334 this._days * 864e5 + 5335 (this._months % 12) * 2592e6 + 5336 toInt(this._months / 12) * 31536e6 5337 ); 5338 } 5339 5340 function makeAs(alias) { 5341 return function () { 5342 return this.as(alias); 5343 }; 5344 } 5345 5346 var asMilliseconds = makeAs('ms'), 5347 asSeconds = makeAs('s'), 5348 asMinutes = makeAs('m'), 5349 asHours = makeAs('h'), 5350 asDays = makeAs('d'), 5351 asWeeks = makeAs('w'), 5352 asMonths = makeAs('M'), 5353 asQuarters = makeAs('Q'), 5354 asYears = makeAs('y'); 5355 5356 function clone$1() { 5357 return createDuration(this); 5358 } 5359 5360 function get$2(units) { 5361 units = normalizeUnits(units); 5362 return this.isValid() ? this[units + 's']() : NaN; 5363 } 5364 5365 function makeGetter(name) { 5366 return function () { 5367 return this.isValid() ? this._data[name] : NaN; 5368 }; 5369 } 5370 5371 var milliseconds = makeGetter('milliseconds'), 5372 seconds = makeGetter('seconds'), 5373 minutes = makeGetter('minutes'), 5374 hours = makeGetter('hours'), 5375 days = makeGetter('days'), 5376 months = makeGetter('months'), 5377 years = makeGetter('years'); 5378 5379 function weeks() { 5380 return absFloor(this.days() / 7); 5381 } 5382 5383 var round = Math.round, 5384 thresholds = { 5385 ss: 44, // a few seconds to seconds 5386 s: 45, // seconds to minute 5387 m: 45, // minutes to hour 5388 h: 22, // hours to day 5389 d: 26, // days to month/week 5390 w: null, // weeks to month 5391 M: 11, // months to year 5392 }; 5393 5394 // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize 5395 function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) { 5396 return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture); 5397 } 5398 5399 function relativeTime$1(posNegDuration, withoutSuffix, thresholds, locale) { 5400 var duration = createDuration(posNegDuration).abs(), 5401 seconds = round(duration.as('s')), 5402 minutes = round(duration.as('m')), 5403 hours = round(duration.as('h')), 5404 days = round(duration.as('d')), 5405 months = round(duration.as('M')), 5406 weeks = round(duration.as('w')), 5407 years = round(duration.as('y')), 5408 a = 5409 (seconds <= thresholds.ss && ['s', seconds]) || 5410 (seconds < thresholds.s && ['ss', seconds]) || 5411 (minutes <= 1 && ['m']) || 5412 (minutes < thresholds.m && ['mm', minutes]) || 5413 (hours <= 1 && ['h']) || 5414 (hours < thresholds.h && ['hh', hours]) || 5415 (days <= 1 && ['d']) || 5416 (days < thresholds.d && ['dd', days]); 5417 5418 if (thresholds.w != null) { 5419 a = 5420 a || 5421 (weeks <= 1 && ['w']) || 5422 (weeks < thresholds.w && ['ww', weeks]); 5423 } 5424 a = a || 5425 (months <= 1 && ['M']) || 5426 (months < thresholds.M && ['MM', months]) || 5427 (years <= 1 && ['y']) || ['yy', years]; 5428 5429 a[2] = withoutSuffix; 5430 a[3] = +posNegDuration > 0; 5431 a[4] = locale; 5432 return substituteTimeAgo.apply(null, a); 5433 } 5434 5435 // This function allows you to set the rounding function for relative time strings 5436 function getSetRelativeTimeRounding(roundingFunction) { 5437 if (roundingFunction === undefined) { 5438 return round; 5439 } 5440 if (typeof roundingFunction === 'function') { 5441 round = roundingFunction; 5442 return true; 5443 } 5444 return false; 5445 } 5446 5447 // This function allows you to set a threshold for relative time strings 5448 function getSetRelativeTimeThreshold(threshold, limit) { 5449 if (thresholds[threshold] === undefined) { 5450 return false; 5451 } 5452 if (limit === undefined) { 5453 return thresholds[threshold]; 5454 } 5455 thresholds[threshold] = limit; 5456 if (threshold === 's') { 5457 thresholds.ss = limit - 1; 5458 } 5459 return true; 5460 } 5461 5462 function humanize(argWithSuffix, argThresholds) { 5463 if (!this.isValid()) { 5464 return this.localeData().invalidDate(); 5465 } 5466 5467 var withSuffix = false, 5468 th = thresholds, 5469 locale, 5470 output; 5471 5472 if (typeof argWithSuffix === 'object') { 5473 argThresholds = argWithSuffix; 5474 argWithSuffix = false; 5475 } 5476 if (typeof argWithSuffix === 'boolean') { 5477 withSuffix = argWithSuffix; 5478 } 5479 if (typeof argThresholds === 'object') { 5480 th = Object.assign({}, thresholds, argThresholds); 5481 if (argThresholds.s != null && argThresholds.ss == null) { 5482 th.ss = argThresholds.s - 1; 5483 } 5484 } 5485 5486 locale = this.localeData(); 5487 output = relativeTime$1(this, !withSuffix, th, locale); 5488 5489 if (withSuffix) { 5490 output = locale.pastFuture(+this, output); 5491 } 5492 5493 return locale.postformat(output); 5494 } 5495 5496 var abs$1 = Math.abs; 5497 5498 function sign(x) { 5499 return (x > 0) - (x < 0) || +x; 5500 } 5501 5502 function toISOString$1() { 5503 // for ISO strings we do not use the normal bubbling rules: 5504 // * milliseconds bubble up until they become hours 5505 // * days do not bubble at all 5506 // * months bubble up until they become years 5507 // This is because there is no context-free conversion between hours and days 5508 // (think of clock changes) 5509 // and also not between days and months (28-31 days per month) 5510 if (!this.isValid()) { 5511 return this.localeData().invalidDate(); 5512 } 5513 5514 var seconds = abs$1(this._milliseconds) / 1000, 5515 days = abs$1(this._days), 5516 months = abs$1(this._months), 5517 minutes, 5518 hours, 5519 years, 5520 s, 5521 total = this.asSeconds(), 5522 totalSign, 5523 ymSign, 5524 daysSign, 5525 hmsSign; 5526 5527 if (!total) { 5528 // this is the same as C#'s (Noda) and python (isodate)... 5529 // but not other JS (goog.date) 5530 return 'P0D'; 5531 } 5532 5533 // 3600 seconds -> 60 minutes -> 1 hour 5534 minutes = absFloor(seconds / 60); 5535 hours = absFloor(minutes / 60); 5536 seconds %= 60; 5537 minutes %= 60; 5538 5539 // 12 months -> 1 year 5540 years = absFloor(months / 12); 5541 months %= 12; 5542 5543 // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js 5544 s = seconds ? seconds.toFixed(3).replace(/\.?0+$/, '') : ''; 5545 5546 totalSign = total < 0 ? '-' : ''; 5547 ymSign = sign(this._months) !== sign(total) ? '-' : ''; 5548 daysSign = sign(this._days) !== sign(total) ? '-' : ''; 5549 hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : ''; 5550 5551 return ( 5552 totalSign + 5553 'P' + 5554 (years ? ymSign + years + 'Y' : '') + 5555 (months ? ymSign + months + 'M' : '') + 5556 (days ? daysSign + days + 'D' : '') + 5557 (hours || minutes || seconds ? 'T' : '') + 5558 (hours ? hmsSign + hours + 'H' : '') + 5559 (minutes ? hmsSign + minutes + 'M' : '') + 5560 (seconds ? hmsSign + s + 'S' : '') 5561 ); 5562 } 5563 5564 var proto$2 = Duration.prototype; 5565 5566 proto$2.isValid = isValid$1; 5567 proto$2.abs = abs; 5568 proto$2.add = add$1; 5569 proto$2.subtract = subtract$1; 5570 proto$2.as = as; 5571 proto$2.asMilliseconds = asMilliseconds; 5572 proto$2.asSeconds = asSeconds; 5573 proto$2.asMinutes = asMinutes; 5574 proto$2.asHours = asHours; 5575 proto$2.asDays = asDays; 5576 proto$2.asWeeks = asWeeks; 5577 proto$2.asMonths = asMonths; 5578 proto$2.asQuarters = asQuarters; 5579 proto$2.asYears = asYears; 5580 proto$2.valueOf = valueOf$1; 5581 proto$2._bubble = bubble; 5582 proto$2.clone = clone$1; 5583 proto$2.get = get$2; 5584 proto$2.milliseconds = milliseconds; 5585 proto$2.seconds = seconds; 5586 proto$2.minutes = minutes; 5587 proto$2.hours = hours; 5588 proto$2.days = days; 5589 proto$2.weeks = weeks; 5590 proto$2.months = months; 5591 proto$2.years = years; 5592 proto$2.humanize = humanize; 5593 proto$2.toISOString = toISOString$1; 5594 proto$2.toString = toISOString$1; 5595 proto$2.toJSON = toISOString$1; 5596 proto$2.locale = locale; 5597 proto$2.localeData = localeData; 5598 5599 proto$2.toIsoString = deprecate( 5600 'toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', 5601 toISOString$1 5602 ); 5603 proto$2.lang = lang; 5604 5605 // FORMATTING 5606 5607 addFormatToken('X', 0, 0, 'unix'); 5608 addFormatToken('x', 0, 0, 'valueOf'); 5609 5610 // PARSING 5611 5612 addRegexToken('x', matchSigned); 5613 addRegexToken('X', matchTimestamp); 5614 addParseToken('X', function (input, array, config) { 5615 config._d = new Date(parseFloat(input) * 1000); 5616 }); 5617 addParseToken('x', function (input, array, config) { 5618 config._d = new Date(toInt(input)); 5619 }); 5620 5621 //! moment.js 5622 5623 hooks.version = '2.29.1'; 5624 5625 setHookCallback(createLocal); 5626 5627 hooks.fn = proto; 5628 hooks.min = min; 5629 hooks.max = max; 5630 hooks.now = now; 5631 hooks.utc = createUTC; 5632 hooks.unix = createUnix; 5633 hooks.months = listMonths; 5634 hooks.isDate = isDate; 5635 hooks.locale = getSetGlobalLocale; 5636 hooks.invalid = createInvalid; 5637 hooks.duration = createDuration; 5638 hooks.isMoment = isMoment; 5639 hooks.weekdays = listWeekdays; 5640 hooks.parseZone = createInZone; 5641 hooks.localeData = getLocale; 5642 hooks.isDuration = isDuration; 5643 hooks.monthsShort = listMonthsShort; 5644 hooks.weekdaysMin = listWeekdaysMin; 5645 hooks.defineLocale = defineLocale; 5646 hooks.updateLocale = updateLocale; 5647 hooks.locales = listLocales; 5648 hooks.weekdaysShort = listWeekdaysShort; 5649 hooks.normalizeUnits = normalizeUnits; 5650 hooks.relativeTimeRounding = getSetRelativeTimeRounding; 5651 hooks.relativeTimeThreshold = getSetRelativeTimeThreshold; 5652 hooks.calendarFormat = getCalendarFormat; 5653 hooks.prototype = proto; 5654 5655 // currently HTML5 input type only supports 24-hour formats 5656 hooks.HTML5_FMT = { 5657 DATETIME_LOCAL: 'YYYY-MM-DDTHH:mm', // <input type="datetime-local" /> 5658 DATETIME_LOCAL_SECONDS: 'YYYY-MM-DDTHH:mm:ss', // <input type="datetime-local" step="1" /> 5659 DATETIME_LOCAL_MS: 'YYYY-MM-DDTHH:mm:ss.SSS', // <input type="datetime-local" step="0.001" /> 5660 DATE: 'YYYY-MM-DD', // <input type="date" /> 5661 TIME: 'HH:mm', // <input type="time" /> 5662 TIME_SECONDS: 'HH:mm:ss', // <input type="time" step="1" /> 5663 TIME_MS: 'HH:mm:ss.SSS', // <input type="time" step="0.001" /> 5664 WEEK: 'GGGG-[W]WW', // <input type="week" /> 5665 MONTH: 'YYYY-MM', // <input type="month" /> 5666 }; 5667 5668 return hooks; 5669 5670 })));
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
| Generated: Sun Oct 17 01:00:03 2021 | Cross-referenced by PHPXref 0.7.1 |