tempestas

A REST API for processing sensor.community data
git clone https://git.bracken.jp/tempestas.git
Log | Files | Refs | README | LICENSE

moment.js (173902B)


      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 })));