https://www.provincial.rugby/_resources/themes/provincial-rugby-bu…/javascript/bundles/common.js?m=1790310943

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