https://www.domaineforget.com/dist/app-js?v=5mBlUSr0ozTx0bnyie6tWzz7tffjZh_41zxjjzjlOjk1

281	                }
282	            }
283	            return true;
284	        }
285	    }
286	
287	    function isUndefined(input) {
288	        return input === void 0;
289	    }
290	
291	    function isNumber(input) {
292	        return (
293	            typeof input === 'number' ||
294	            Object.prototype.toString.call(input) === '[object Number]'
295	        );
296	    }
297	
298	    function isDate(input) {
299	        return (
300	            input instanceof Date ||
301	            Object.prototype.toString.call(input) === '[object Date]'
302	        );
303	    }
304	
305	    function map(arr, fn) {
306	        var res = [],
307	            i;
308	        for (i = 0; i < arr.length; ++i) {
309	            res.push(fn(arr[i], i));
310	        }
311	        return res;
312	    }
313	
314	    function extend(a, b) {
315	        for (var i in b) {
316	            if (hasOwnProp(b, i)) {
317	                a[i] = b[i];
318	            }
319	        }
320	
321	        if (hasOwnProp(b, 'toString')) {
322	            a.toString = b.toString;
323	        }
324	
325	        if (hasOwnProp(b, 'valueOf')) {
326	            a.valueOf = b.valueOf;
327	        }
328	
329	        return a;
330	    }
331	
332	    function createUTC(input, format, locale, strict) {
333	        return createLocalOrUTC(input, format, locale, strict, true).utc();
334	    }
335	
336	    function defaultParsingFlags() {
337	        // We need to deep clone this object.
338	        return {
339	            empty: false,
340	            unusedTokens: [],
341	            unusedInput: [],
342	            overflow: -2,
343	            charsLeftOver: 0,
344	            nullInput: false,
345	            invalidEra: null,
346	            invalidMonth: null,
347	            invalidFormat: false,
348	            userInvalidated: false,
349	            iso: false,
350	            parsedDateParts: [],
351	            era: null,
352	            meridiem: null,
353	            rfc2822: false,
354	            weekdayMismatch: false,
355	        };
356	    }
357	
358	    function getParsingFlags(m) {
359	        if (m._pf == null) {
360	            m._pf = defaultParsingFlags();
361	        }
362	        return m._pf;
363	    }
364	
365	    var some;
366	    if (Array.prototype.some) {
367	        some = Array.prototype.some;
368	    } else {
369	        some = function (fun) {
370	            var t = Object(this),
371	                len = t.length >>> 0,
372	                i;
373	
374	            for (i = 0; i < len; i++) {
375	                if (i in t && fun.call(this, t[i], i, t)) {
376	                    return true;
377	                }
378	            }
379	
380	            return false;
381	        };
382	    }
383	
384	    function isValid(m) {
385	        if (m._isValid == null) {
386	            var flags = getParsingFlags(m),
387	                parsedParts = some.call(flags.parsedDateParts, function (i) {
388	                    return i != null;
389	                }),
390	                isNowValid =
391	                    !isNaN(m._d.getTime()) &&
392	                    flags.overflow < 0 &&
393	                    !flags.empty &&
394	                    !flags.invalidEra &&
395	                    !flags.invalidMonth &&
396	                    !flags.invalidWeekday &&
397	                    !flags.weekdayMismatch &&
398	                    !flags.nullInput &&
399	                    !flags.invalidFormat &&
400	                    !flags.userInvalidated &&
401	                    (!flags.meridiem || (flags.meridiem && parsedParts));
402	
403	            if (m._strict) {
404	                isNowValid =
405	                    isNowValid &&
406	                    flags.charsLeftOver === 0 &&
407	                    flags.unusedTokens.length === 0 &&
408	                    flags.bigHour === undefined;
409	            }
410	
411	            if (Object.isFrozen == null || !Object.isFrozen(m)) {
412	                m._isValid = isNowValid;
413	            } else {
414	                return isNowValid;
415	            }
416	        }
417	        return m._isValid;
418	    }
419	
420	    function createInvalid(flags) {
421	        var m = createUTC(NaN);
422	        if (flags != null) {
423	            extend(getParsingFlags(m), flags);
424	        } else {
425	            getParsingFlags(m).userInvalidated = true;
426	        }
427	
428	        return m;
429	    }
430	
431	    // Plugins that add properties should also add the key here (null value),
432	    // so we can properly clone ourselves.
433	    var momentProperties = (hooks.momentProperties = []),
434	        updateInProgress = false;
435	
436	    function copyConfig(to, from) {
437	        var i, prop, val;
438	
439	        if (!isUndefined(from._isAMomentObject)) {
440	            to._isAMomentObject = from._isAMomentObject;
441	        }
442	        if (!isUndefined(from._i)) {
443	            to._i = from._i;
444	        }
445	        if (!isUndefined(from._f)) {
446	            to._f = from._f;
447	        }
448	        if (!isUndefined(from._l)) {
449	            to._l = from._l;
450	        }
451	        if (!isUndefined(from._strict)) {
452	            to._strict = from._strict;
453	        }
454	        if (!isUndefined(from._tzm)) {
455	            to._tzm = from._tzm;
456	        }
457	        if (!isUndefined(from._isUTC)) {
458	            to._isUTC = from._isUTC;
459	        }
460	        if (!isUndefined(from._offset)) {
461	            to._offset = from._offset;
462	        }
463	        if (!isUndefined(from._pf)) {
464	            to._pf = getParsingFlags(from);
465	        }
466	        if (!isUndefined(from._locale)) {
467	            to._locale = from._locale;
468	        }
469	
470	        if (momentProperties.length > 0) {
471	            for (i = 0; i < momentProperties.length; i++) {
472	                prop = momentProperties[i];
473	                val = from[prop];
474	                if (!isUndefined(val)) {
475	                    to[prop] = val;
476	                }
477	            }
478	        }
479	
480	        return to;
481	    }
482	
483	    // Moment prototype object
484	    function Moment(config) {
485	        copyConfig(this, config);
486	        this._d = new Date(config._d != null ? config._d.getTime() : NaN);
487	        if (!this.isValid()) {
488	            this._d = new Date(NaN);
489	        }
490	        // Prevent infinite loop in case updateOffset creates new moment
491	        // objects.
492	        if (updateInProgress === false) {
493	            updateInProgress = true;
494	            hooks.updateOffset(this);
495	            updateInProgress = false;
496	        }
497	    }
498	
499	    function isMoment(obj) {
500	        return (
501	            obj instanceof Moment || (obj != null && obj._isAMomentObject != null)
502	        );
503	    }
504	
505	    function warn(msg) {
506	        if (
507	            hooks.suppressDeprecationWarnings === false &&
508	            typeof console !== 'undefined' &&
509	            console.warn
510	        ) {
511	            console.warn('Deprecation warning: ' + msg);
512	        }
513	    }
514	
515	    function deprecate(msg, fn) {
516	        var firstTime = true;
517	
518	        return extend(function () {
519	            if (hooks.deprecationHandler != null) {
520	                hooks.deprecationHandler(null, msg);
521	            }
522	            if (firstTime) {
523	                var args = [],
524	                    arg,
525	                    i,
526	                    key;
527	                for (i = 0; i < arguments.length; i++) {
528	                    arg = '';
529	                    if (typeof arguments[i] === 'object') {
530	                        arg += '\n[' + i + '] ';
531	                        for (key in arguments[0]) {
532	                            if (hasOwnProp(arguments[0], key)) {
533	                                arg += key + ': ' + arguments[0][key] + ', ';
534	                            }
535	                        }
536	                        arg = arg.slice(0, -2); // Remove trailing comma and space
537	                    } else {
538	                        arg = arguments[i];
539	                    }
540	                    args.push(arg);
541	                }
542	                warn(
543	                    msg +
544	                        '\nArguments: ' +
545	                        Array.prototype.slice.call(args).join('') +
546	                        '\n' +
547	                        new Error().stack
548	                );
549	                firstTime = false;
550	            }
551	            return fn.apply(this, arguments);
552	        }, fn);
553	    }
554	
555	    var deprecations = {};
556	
557	    function deprecateSimple(name, msg) {
558	        if (hooks.deprecationHandler != null) {
559	            hooks.deprecationHandler(name, msg);
560	        }
561	        if (!deprecations[name]) {
562	            warn(msg);
563	            deprecations[name] = true;
564	        }
565	    }
566	
567	    hooks.suppressDeprecationWarnings = false;
568	    hooks.deprecationHandler = null;
569	
570	    function isFunction(input) {
571	        return (
572	            (typeof Function !== 'undefined' && input instanceof Function) ||
573	            Object.prototype.toString.call(input) === '[object Function]'
574	        );
575	    }
576	
577	    function set(config) {
578	        var prop, i;
579	        for (i in config) {
580	            if (hasOwnProp(config, i)) {
581	                prop = config[i];
582	                if (isFunction(prop)) {
583	                    this[i] = prop;
584	                } else {
585	                    this['_' + i] = prop;
586	                }
587	            }
588	        }
589	        this._config = config;
590	        // Lenient ordinal parsing accepts just a number in addition to
591	        // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
592	        // TODO: Remove "ordinalParse" fallback in next major release.
593	        this._dayOfMonthOrdinalParseLenient = new RegExp(
594	            (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +
595	                '|' +
596	                /\d{1,2}/.source
597	        );
598	    }
599	
600	    function mergeConfigs(parentConfig, childConfig) {
601	        var res = extend({}, parentConfig),
602	            prop;
603	        for (prop in childConfig) {
604	            if (hasOwnProp(childConfig, prop)) {
605	                if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
606	                    res[prop] = {};
607	                    extend(res[prop], parentConfig[prop]);
608	                    extend(res[prop], childConfig[prop]);
609	                } else if (childConfig[prop] != null) {
610	                    res[prop] = childConfig[prop];
611	                } else {
612	                    delete res[prop];
613	                }
614	            }
615	        }
616	        for (prop in parentConfig) {
617	            if (
618	                hasOwnProp(parentConfig, prop) &&
619	                !hasOwnProp(childConfig, prop) &&
620	                isObject(parentConfig[prop])
621	            ) {
622	                // make sure changes to properties don't modify parent config
623	                res[prop] = extend({}, res[prop]);
624	            }
625	        }
626	        return res;
627	    }
628	
629	    function Locale(config) {
630	        if (config != null) {
631	            this.set(config);
632	        }
633	    }
634	
635	    var keys;
636	
637	    if (Object.keys) {
638	        keys = Object.keys;
639	    } else {
640	        keys = function (obj) {
641	            var i,
642	                res = [];
643	            for (i in obj) {
644	                if (hasOwnProp(obj, i)) {
645	                    res.push(i);
646	                }
647	            }
648	            return res;
649	        };
650	    }
651	
652	    var defaultCalendar = {
653	        sameDay: '[Today at] LT',
654	        nextDay: '[Tomorrow at] LT',
655	        nextWeek: 'dddd [at] LT',
656	        lastDay: '[Yesterday at] LT',
657	        lastWeek: '[Last] dddd [at] LT',
658	        sameElse: 'L',
659	    };
660	
661	    function calendar(key, mom, now) {
662	        var output = this._calendar[key] || this._calendar['sameElse'];
663	        return isFunction(output) ? output.call(mom, now) : output;
664	    }
665	
666	    function zeroFill(number, targetLength, forceSign) {
667	        var absNumber = '' + Math.abs(number),
668	            zerosToFill = targetLength - absNumber.length,
669	            sign = number >= 0;
670	        return (
671	            (sign ? (forceSign ? '+' : '') : '-') +
672	            Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) +
673	            absNumber
674	        );
675	    }
676	
677	    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}

677|x|X|zz?|ZZ?|.)/g,
678	        localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,
679	        formatFunctions = {},
680	        formatTokenFunctions = {};
681	
682	    // token:    'M'
683	    // padded:   ['MM', 2]
684	    // ordinal:  'Mo'
685	    // callback: function () { this.month() + 1 }
686	    function addFormatToken(token, padded, ordinal, callback) {
687	        var func = callback;
688	        if (typeof callback === 'string') {
689	            func = function () {
690	                return this[callback]();
691	            };
692	        }
693	        if (token) {
694	            formatTokenFunctions[token] = func;
695	        }
696	        if (padded) {
697	            formatTokenFunctions[padded[0]] = function () {
698	                return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
699	            };
700	        }
701	        if (ordinal) {
702	            formatTokenFunctions[ordinal] = function () {
703	                return this.localeData().ordinal(
704	                    func.apply(this, arguments),
705	                    token
706	                );
707	            };
708	        }
709	    }
710	
711	    function removeFormattingTokens(input) {
712	        if (input.match(/\[[\s\S]/)) {
713	            return input.replace(/^\[|\]$/g, '');
714	        }
715	        return input.replace(/\\/g, '');
716	    }
717	
718	    function makeFormatFunction(format) {
719	        var array = format.match(formattingTokens),
720	            i,
721	            length;
722	
723	        for (i = 0, length = array.length; i < length; i++) {
724	            if (formatTokenFunctions[array[i]]) {
725	                array[i] = formatTokenFunctions[array[i]];
726	            } else {
727	                array[i] = removeFormattingTokens(array[i]);
728	            }
729	        }
730	
731	        return function (mom) {
732	            var output = '',
733	                i;
734	            for (i = 0; i < length; i++) {
735	                output += isFunction(array[i])
736	                    ? array[i].call(mom, format)
737	                    : array[i];
738	            }
739	            return output;
740	        };
741	    }
742	
743	    // format date using native date object
744	    function formatMoment(m, format) {
745	        if (!m.isValid()) {
746	            return m.localeData().invalidDate();
747	        }
748	
749	        format = expandFormat(format, m.localeData());
750	        formatFunctions[format] =
751	            formatFunctions[format] || makeFormatFunction(format);
752	
753	        return formatFunctions[format](m);
754	    }
755	
756	    function expandFormat(format, locale) {
757	        var i = 5;
758	
759	        function replaceLongDateFormatTokens(input) {
760	            return locale.longDateFormat(input) || input;
761	        }
762	
763	        localFormattingTokens.lastIndex = 0;
764	        while (i >= 0 && localFormattingTokens.test(format)) {
765	            format = format.replace(
766	                localFormattingTokens,
767	                replaceLongDateFormatTokens
768	            );
769	            localFormattingTokens.lastIndex = 0;
770	            i -= 1;
771	        }
772	
773	        return format;
774	    }
775	
776	    var defaultLongDateFormat = {
777	        LTS: 'h:mm:ss A',
778	        LT: 'h:mm A',
779	        L: 'MM/DD/YYYY',
780	        LL: 'MMMM D, YYYY',
781	        LLL: 'MMMM D, YYYY h:mm A',
782	        LLLL: 'dddd, MMMM D, YYYY h:mm A',
783	    };
784	
785	    function longDateFormat(key) {
786	        var format = this._longDateFormat[key],
787	            formatUpper = this._longDateFormat[key.toUpperCase()];
788	
789	        if (format || !formatUpper) {
790	            return format;
791	        }
792	
793	        this._longDateFormat[key] = formatUpper
794	            .match(formattingTokens)
795	            .map(function (tok) {
796	                if (
797	                    tok === 'MMMM' ||
798	                    tok === 'MM' ||
799	                    tok === 'DD' ||
800	                    tok === 'dddd'
801	                ) {
802	                    return tok.slice(1);
803	                }
804	                return tok;
805	            })
806	            .join('');
807	
808	        return this._longDateFormat[key];
809	    }
810	
811	    var defaultInvalidDate = 'Invalid date';
812	

813	    function invalidDate() {
814	        return this._invalidDate;
815	    }
816	
817	    var defaultOrdinal = '%d',
818	        defaultDayOfMonthOrdinalParse = /\d{1,2}/;
819	
820	    function ordinal(number) {
821	        return this._ordinal.replace('%d', number);
822	    }
823	
824	    var defaultRelativeTime = {
825	        future: 'in %s',
826	        past: '%s ago',
827	        s: 'a few seconds',
828	        ss: '%d seconds',
829	        m: 'a minute',
830	        mm: '%d minutes',
831	        h: 'an hour',
832	        hh: '%d hours',
833	        d: 'a day',
834	        dd: '%d days',
835	        w: 'a week',
836	        ww: '%d weeks',
837	        M: 'a month',
838	        MM: '%d months',
839	        y: 'a year',
840	        yy: '%d years',
841	    };
842	
843	    function relativeTime(number, withoutSuffix, string, isFuture) {
844	        var output = this._relativeTime[string];
845	        return isFunction(output)
846	            ? output(number, withoutSuffix, string, isFuture)
847	            : output.replace(/%d/i, number);
848	    }
849	
850	    function pastFuture(diff, output) {
851	        var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
852	        return isFunction(format) ? format(output) : format.replace(/%s/i, output);
853	    }
854	
855	    var aliases = {};
856	
857	    function addUnitAlias(unit, shorthand) {
858	        var lowerCase = unit.toLowerCase();
859	        aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
860	    }
861	
862	    function normalizeUnits(units) {
863	        return typeof units === 'string'
864	            ? aliases[units] || aliases[units.toLowerCase()]
865	            : undefined;
866	    }
867	
868	    function normalizeObjectUnits(inputObject) {
869	        var normalizedInput = {},
870	            normalizedProp,
871	            prop;
872	
873	        for (prop in inputObject) {
874	            if (hasOwnProp(inputObject, prop)) {
875	                normalizedProp = normalizeUnits(prop);
876	                if (normalizedProp) {
877	                    normalizedInput[normalizedProp] = inputObject[prop];
878	                }
879	            }
880	        }
881	
882	        return normalizedInput;
883	    }
884	
885	    var priorities = {};
886	
887	    function addUnitPriority(unit, priority) {
888	        priorities[unit] = priority;
889	    }
890	
891	    function getPrioritizedUnits(unitsObj) {
892	        var units = [],
893	            u;
894	        for (u in unitsObj) {
895	            if (hasOwnProp(unitsObj, u)) {
896	                units.push({ unit: u, priority: priorities[u] });
897	            }
898	        }
899	        units.sort(function (a, b) {
900	            return a.priority - b.priority;
901	        });
902	        return units;
903	    }
904	
905	    function isLeapYear(year) {
906	        return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
907	    }
908	
909	    function absFloor(number) {
910	        if (number < 0) {
911	            // -0 -> 0
912	            return Math.ceil(number) || 0;
913	        } else {
914	            return Math.floor(number);
915	        }
916	    }
917	
918	    function toInt(argumentForCoercion) {
919	        var coercedNumber = +argumentForCoercion,
920	            value = 0;
921	
922	        if (coercedNumber !== 0 && isFinite(coercedNumber)) {
923	            value = absFloor(coercedNumber);
924	        }
925	
926	        return value;
927	    }
928	
929	    function makeGetSet(unit, keepTime) {
930	        return function (value) {
931	            if (value != null) {
932	                set$1(this, unit, value);
933	                hooks.updateOffset(this, keepTime);
934	                return this;
935	            } else {
936	                return get(this, unit);
937	            }
938	        };
939	    }
940	
941	    function get(mom, unit) {
942	        return mom.isValid()
943	            ? mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]()
944	            : NaN;
945	    }
946	
947	    function set$1(mom, unit, value) {
948	        if (mom.isValid() && !isNaN(value)) {
949	            if (
950	                unit === 'FullYear' &&
951	                isLeapYear(mom.year()) &&
952	                mom.month() === 1 &&
953	                mom.date() === 29
954	            ) {
955	                value = toInt(value);
956	                mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](
957	                    value,
958	                    mom.month(),
959	                    daysInMonth(value, mom.month())
960	                );
961	            } else {
962	                mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
963	            }
964	        }
965	    }
966	
967	    // MOMENTS
968	
969	    function stringGet(units) {
970	        units = normalizeUnits(units);
971	        if (isFunction(this[units])) {
972	            return this[units]();
973	        }
974	        return this;
975	    }
976	
977	    function stringSet(units, value) {
978	        if (typeof units === 'object') {
979	            units = normalizeObjectUnits(units);
980	            var prioritized = getPrioritizedUnits(units),
981	                i;
982	            for (i = 0; i < prioritized.length; i++) {
983	                this[prioritized[i].unit](units[prioritized[i].unit]);
984	            }
985	        } else {
986	            units = normalizeUnits(units);
987	            if (isFunction(this[units])) {
988	                return this[units](value);
989	            }
990	        }
991	        return this;
992	    }
993	
994	    var match1 = /\d/, //       0 - 9
995	        match2 = /\d\d/, //      00 - 99
996	        match3 = /\d{3}/, //     000 - 999
997	        match4 = /\d{4}/, //    0000 - 9999
998	        match6 = /[+-]?\d{6}/, // -999999 - 999999
999	        match1to2 = /\d\d?/, //       0 - 99
1000	        match3to4 = /\d\d\d\d?/, //     999 - 9999
1001	        match5to6 = /\d\d\d\d\d\d?/, //   99999 - 999999
1002	        match1to3 = /\d{1,3}/, //       0 - 999
1003	        match1to4 = /\d{1,4}/, //       0 - 9999
1004	        match1to6 = /[+-]?\d{1,6}/, // -999999 - 999999
1005	        matchUnsigned = /\d+/, //       0 - inf
1006	        matchSigned = /[+-]?\d+/, //    -inf - inf
1007	        matchOffset = /Z|[+-]\d\d:?\d\d/gi, // +00:00 -00:00 +0000 -0000 or Z
1008	        matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi, // +00 -00 +00:00 -00:00 +0000 -0000 or Z
1009	        matchTimestamp = /[+-]?\d+(\.\d{1,3})?/, // 123456789 123456789.123
1010	        // any word (or two) characters or numbers including two/three word month in arabic.
1011	        // includes scottish gaelic two word and hyphenated months
1012	        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,
1013	        regexes;
1014	
1015	    regexes = {};
1016	
1017	    function addRegexToken(token, regex, strictRegex) {
1018	        regexes[token] = isFunction(regex)
1019	            ? regex
1020	            : function (isStrict, localeData) {
1021	                  return isStrict && strictRegex ? strictRegex : regex;
1022	              };
1023	    }
1024	
1025	    function getParseRegexForToken(token, config) {
1026	        if (!hasOwnProp(regexes, token)) {
1027	            return new RegExp(unescapeFormat(token));
1028	        }
1029	
1030	        return regexes[token](config._strict, config._locale);
1031	    }
1032	
1033	    // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
1034	    function unescapeFormat(s) {
1035	        return regexEscape(
1036	            s
1037	                .replace('\\', '')
1038	                .replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (
1039	                    matched,
1040	                    p1,
1041	                    p2,
1042	                    p3,
1043	                    p4
1044	                ) {
1045	                    return p1 || p2 || p3 || p4;
1046	                })
1047	        );
1048	    }
1049	
1050	    function regexEscape(s) {
1051	        return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
1052	    }
1053	
1054	    var tokens = {};
1055	
1056	    function addParseToken(token, callback) {
1057	        var i,
1058	            func = callback;
1059	        if (typeof token === 'string') {
1060	            token = [token];
1061	        }
1062	        if (isNumber(callback)) {
1063	            func = function (input, array) {
1064	                array[callback] = toInt(input);
1065	            };
1066	        }
1067	        for (i = 0; i < token.length; i++) {
1068	            tokens[token[i]] = func;
1069	        }
1070	    }
1071	
1072	    function addWeekParseToken(token, callback) {
1073	        addParseToken(token, function (input, array, config, token) {
1074	            config._w = config._w || {};
1075	            callback(input, config._w, config, token);
1076	        });
1077	    }
1078	
1079	    function addTimeToArrayFromToken(token, input, config) {
1080	        if (input != null && hasOwnProp(tokens, token)) {
1081	            tokens[token](input, config._a, config, token);
1082	        }
1083	    }
1084	
1085	    var YEAR = 0,
1086	        MONTH = 1,
1087	        DATE = 2,
1088	        HOUR = 3,
1089	        MINUTE = 4,
1090	        SECOND = 5,
1091	        MILLISECOND = 6,
1092	        WEEK = 7,
1093	        WEEKDAY = 8;
1094	
1095	    function mod(n, x) {
1096	        return ((n % x) + x) % x;
1097	    }
1098	
1099	    var indexOf;
1100	
1101	    if (Array.prototype.indexOf) {
1102	        indexOf = Array.prototype.indexOf;
1103	    } else {
1104	        indexOf = function (o) {
1105	            // I know
1106	            var i;
1107	            for (i = 0; i < this.length; ++i) {
1108	                if (this[i] === o) {
1109	                    return i;
1110	                }
1111	            }
1112	            return -1;
1113	        };
1114	    }
1115	
1116	    function daysInMonth(year, month) {
1117	        if (isNaN(year) || isNaN(month)) {
1118	            return NaN;
1119	        }
1120	        var modMonth = mod(month, 12);
1121	        year += (month - modMonth) / 12;
1122	        return modMonth === 1
1123	            ? isLeapYear(year)
1124	                ? 29
1125	                : 28
1126	            : 31 - ((modMonth % 7) % 2);
1127	    }
1128	
1129	    // FORMATTING
1130	
1131	    addFormatToken('M', ['MM', 2], 'Mo', function () {
1132	        return this.month() + 1;
1133	    });
1134	
1135	    addFormatToken('MMM', 0, 0, function (format) {
1136	        return this.localeData().monthsShort(this, format);
1137	    });
1138	
1139	    addFormatToken('MMMM', 0, 0, function (format) {
1140	        return this.localeData().months(this, format);
1141	    });
1142	
1143	    // ALIASES
1144	
1145	    addUnitAlias('month', 'M');
1146	
1147	    // PRIORITY
1148	
1149	    addUnitPriority('month', 8);
1150	
1151	    // PARSING
1152	
1153	    addRegexToken('M', match1to2);
1154	    addRegexToken('MM', match1to2, match2);
1155	    addRegexToken('MMM', function (isStrict, locale) {
1156	        return locale.monthsShortRegex(isStrict);
1157	    });
1158	    addRegexToken('MMMM', function (isStrict, locale) {
1159	        return locale.monthsRegex(isStrict);
1160	    });
1161	
1162	    addParseToken(['M', 'MM'], function (input, array) {
1163	        array[MONTH] = toInt(input) - 1;
1164	    });
1165	
1166	    addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
1167	        var month = config._locale.monthsParse(input, token, config._strict);
1168	        // if we didn't find a month name, mark the date as invalid.
1169	        if (month != null) {
1170	            array[MONTH] = month;
1171	        } else {
1172	            getParsingFlags(config).invalidMonth = input;
1173	        }
1174	    });
1175	
1176	    // LOCALES
1177	
1178	    var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
1179	            '_'
1180	        ),
1181	        defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split(
1182	            '_'
1183	        ),
1184	        MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/,
1185	        defaultMonthsShortRegex = matchWord,
1186	        defaultMonthsRegex = matchWord;
1187	
1188	    function localeMonths(m, format) {
1189	        if (!m) {
1190	            return isArray(this._months)
1191	                ? this._months
1192	                : this._months['standalone'];
1193	        }
1194	        return isArray(this._months)
1195	            ? this._months[m.month()]
1196	            : this._months[
1197	                  (this._months.isFormat || MONTHS_IN_FORMAT).test(format)
1198	                      ? 'format'
1199	                      : 'standalone'
1200	              ][m.month()];
1201	    }
1202	
1203	    function localeMonthsShort(m, format) {
1204	        if (!m) {
1205	            return isArray(this._monthsShort)
1206	                ? this._monthsShort
1207	                : this._monthsShort['standalone'];
1208	        }
1209	        return isArray(this._monthsShort)
1210	            ? this._monthsShort[m.month()]
1211	            : this._monthsShort[
1212	                  MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'
1213	              ][m.month()];
1214	    }
1215	
1216	    function handleStrictParse(monthName, format, strict) {
1217	        var i,
1218	            ii,
1219	            mom,
1220	            llc = monthName.toLocaleLowerCase();
1221	        if (!this._monthsParse) {
1222	            // this is not used
1223	            this._monthsParse = [];
1224	            this._longMonthsParse = [];
1225	            this._shortMonthsParse = [];
1226	            for (i = 0; i < 12; ++i) {
1227	                mom = createUTC([2000, i]);
1228	                this._shortMonthsParse[i] = this.monthsShort(
1229	                    mom,
1230	                    ''
1231	                ).toLocaleLowerCase();
1232	                this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
1233	            }
1234	        }
1235	
1236	        if (strict) {
1237	            if (format === 'MMM') {
1238	                ii = indexOf.call(this._shortMonthsParse, llc);
1239	                return ii !== -1 ? ii : null;
1240	            } else {
1241	                ii = indexOf.call(this._longMonthsParse, llc);
1242	                return ii !== -1 ? ii : null;
1243	            }
1244	        } else {
1245	            if (format === 'MMM') {
1246	                ii = indexOf.call(this._shortMonthsParse, llc);
1247	                if (ii !== -1) {
1248	                    return ii;
1249	                }
1250	                ii = indexOf.call(this._longMonthsParse, llc);
1251	                return ii !== -1 ? ii : null;
1252	            } else {
1253	                ii = indexOf.call(this._longMonthsParse, llc);
1254	                if (ii !== -1) {
1255	                    return ii;
1256	                }
1257	                ii = indexOf.call(this._shortMonthsParse, llc);
1258	                return ii !== -1 ? ii : null;
1259	            }
1260	        }
1261	    }
1262	
1263	    function localeMonthsParse(monthName, format, strict) {
1264	        var i, mom, regex;
1265	
1266	        if (this._monthsParseExact) {
1267	            return handleStrictParse.call(this, monthName, format, strict);
1268	        }
1269	
1270	        if (!this._monthsParse) {
1271	            this._monthsParse = [];
1272	            this._longMonthsParse = [];
1273	            this._shortMonthsParse = [];
1274	        }
1275	
1276	        // TODO: add sorting
1277	        // Sorting makes sure if one month (or abbr) is a prefix of another
1278	        // see sorting in computeMonthsParse
1279	        for (i = 0; i < 12; i++) {
1280	            // make the regex if we don't have it already
1281	            mom = createUTC([2000, i]);
1282	            if (strict && !this._longMonthsParse[i]) {
1283	                this._longMonthsParse[i] = new RegExp(
1284	                    '^' + this.months(mom, '').replace('.', '') + '$',
1285	                    'i'
1286	                );
1287	                this._shortMonthsParse[i] = new RegExp(
1288	                    '^' + this.monthsShort(mom, '').replace('.', '') + '$',
1289	                    'i'
1290	                );
1291	            }
1292	            if (!strict && !this._monthsParse[i]) {
1293	                regex =
1294	                    '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
1295	                this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
1296	            }
1297	            // test the regex
1298	            if (

1299	                strict &&
1300	                format === 'MMMM' &&
1301	                this._longMonthsParse[i].test(monthName)
1302	            ) {
1303	                return i;
1304	            } else if (
1305	                strict &&
1306	                format === 'MMM' &&
1307	                this._shortMonthsParse[i].test(monthName)
1308	            ) {
1309	                return i;
1310	            } else if (!strict && this._monthsParse[i].test(monthName)) {
1311	                return i;
1312	            }
1313	        }
1314	    }
1315	
1316	    // MOMENTS
1317	
1318	    function setMonth(mom, value) {
1319	        var dayOfMonth;
1320	
1321	        if (!mom.isValid()) {
1322	            // No op
1323	            return mom;
1324	        }
1325	
1326	        if (typeof value === 'string') {
1327	            if (/^\d+$/.test(value)) {
1328	                value = toInt(value);
1329	            } else {
1330	                value = mom.localeData().monthsParse(value);
1331	                // TODO: Another silent failure?
1332	                if (!isNumber(value)) {
1333	                    return mom;
1334	                }
1335	            }
1336	        }
1337	
1338	        dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
1339	        mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
1340	        return mom;
1341	    }
1342	
1343	    function getSetMonth(value) {
1344	        if (value != null) {
1345	            setMonth(this, value);
1346	            hooks.updateOffset(this, true);
1347	            return this;
1348	        } else {
1349	            return get(this, 'Month');
1350	        }
1351	    }
1352	
1353	    function getDaysInMonth() {
1354	        return daysInMonth(this.year(), this.month());
1355	    }
1356	
1357	    function monthsShortRegex(isStrict) {
1358	        if (this._monthsParseExact) {
1359	            if (!hasOwnProp(this, '_monthsRegex')) {
1360	                computeMonthsParse.call(this);
1361	            }
1362	            if (isStrict) {
1363	                return this._monthsShortStrictRegex;
1364	            } else {
1365	                return this._monthsShortRegex;
1366	            }
1367	        } else {
1368	            if (!hasOwnProp(this, '_monthsShortRegex')) {
1369	                this._monthsShortRegex = defaultMonthsShortRegex;
1370	            }
1371	            return this._monthsShortStrictRegex && isStrict
1372	                ? this._monthsShortStrictRegex
1373	                : this._monthsShortRegex;
1374	        }
1375	    }
1376	
1377	    function monthsRegex(isStrict) {
1378	        if (this._monthsParseExact) {
1379	            if (!hasOwnProp(this, '_monthsRegex')) {
1380	                computeMonthsParse.call(this);
1381	            }
1382	            if (isStrict) {
1383	                return this._monthsStrictRegex;
1384	            } else {
1385	                return this._monthsRegex;
1386	            }
1387	        } else {
1388	            if (!hasOwnProp(this, '_monthsRegex')) {
1389	                this._monthsRegex = defaultMonthsRegex;
1390	            }
1391	            return this._monthsStrictRegex && isStrict
1392	                ? this._monthsStrictRegex
1393	                : this._monthsRegex;
1394	        }
1395	    }
1396	
1397	    function computeMonthsParse() {
1398	        function cmpLenRev(a, b) {
1399	            return b.length - a.length;
1400	        }
1401	
1402	        var shortPieces = [],
1403	            longPieces = [],
1404	            mixedPieces = [],
1405	            i,
1406	            mom;
1407	        for (i = 0; i < 12; i++) {
1408	            // make the regex if we don't have it already
1409	            mom = createUTC([2000, i]);
1410	            shortPieces.push(this.monthsShort(mom, ''));
1411	            longPieces.push(this.months(mom, ''));
1412	            mixedPieces.push(this.months(mom, ''));
1413	            mixedPieces.push(this.monthsShort(mom, ''));
1414	        }
1415	        // Sorting makes sure if one month (or abbr) is a prefix of another it
1416	        // will match the longer piece.
1417	        shortPieces.sort(cmpLenRev);
1418	        longPieces.sort(cmpLenRev);
1419	        mixedPieces.sort(cmpLenRev);
1420	        for (i = 0; i < 12; i++) {
1421	            shortPieces[i] = regexEscape(shortPieces[i]);
1422	            longPieces[i] = regexEscape(longPieces[i]);
1423	        }
1424	        for (i = 0; i < 24; i++) {
1425	            mixedPieces[i] = regexEscape(mixedPieces[i]);
1426	        }
1427	
1428	        this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
1429	        this._monthsShortRegex = this._monthsRegex;
1430	        this._monthsStrictRegex = new RegExp(
1431	            '^(' + longPieces.join('|') + ')',
1432	            'i'
1433	        );
1434	        this._monthsShortStrictRegex = new RegExp(
1435	            '^(' + shortPieces.join('|') + ')',
1436	            'i'
1437	        );
1438	    }
1439	
1440	    // FORMATTING
1441	
1442	    addFormatToken('Y', 0, 0, function () {
1443	        var y = this.year();
1444	        return y <= 9999 ? zeroFill(y, 4) : '+' + y;
1445	    });
1446	
1447	    addFormatToken(0, ['YY', 2], 0, function () {
1448	        return this.year() % 100;
1449	    });
1450	
1451	    addFormatToken(0, ['YYYY', 4], 0, 'year');
1452	    addFormatToken(0, ['YYYYY', 5], 0, 'year');
1453	    addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
1454	
1455	    // ALIASES
1456	
1457	    addUnitAlias('year', 'y');
1458	
1459	    // PRIORITIES
1460	
1461	    addUnitPriority('year', 1);
1462	
1463	    // PARSING
1464	
1465	    addRegexToken('Y', matchSigned);
1466	    addRegexToken('YY', match1to2, match2);
1467	    addRegexToken('YYYY', match1to4, match4);
1468	    addRegexToken('YYYYY', match1to6, match6);
1469	    addRegexToken('YYYYYY', match1to6, match6);
1470	
1471	    addParseToken(['YYYYY', 'YYYYYY'], YEAR);
1472	    addParseToken('YYYY', function (input, array) {
1473	        array[YEAR] =
1474	            input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
1475	    });
1476	    addParseToken('YY', function (input, array) {
1477	        array[YEAR] = hooks.parseTwoDigitYear(input);
1478	    });
1479	    addParseToken('Y', function (input, array) {
1480	        array[YEAR] = parseInt(input, 10);
1481	    });
1482	
1483	    // HELPERS
1484	
1485	    function daysInYear(year) {
1486	        return isLeapYear(year) ? 366 : 365;
1487	    }
1488	
1489	    // HOOKS
1490	
1491	    hooks.parseTwoDigitYear = function (input) {
1492	        return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
1493	    };
1494	
1495	    // MOMENTS
1496	
1497	    var getSetYear = makeGetSet('FullYear', true);
1498	
1499	    function getIsLeapYear() {
1500	        return isLeapYear(this.year());
1501	    }
1502	
1503	    function createDate(y, m, d, h, M, s, ms) {
1504	        // can't just apply() to create a date:
1505	        // https://stackoverflow.com/q/181348
1506	        var date;
1507	        // the date constructor remaps years 0-99 to 1900-1999
1508	        if (y < 100 && y >= 0) {
1509	            // preserve leap years using a full 400 year cycle, then reset
1510	            date = new Date(y + 400, m, d, h, M, s, ms);
1511	            if (isFinite(date.getFullYear())) {
1512	                date.setFullYear(y);
1513	            }
1514	        } else {
1515	            date = new Date(y, m, d, h, M, s, ms);
1516	        }
1517	
1518	        return date;
1519	    }
1520	
1521	    function createUTCDate(y) {
1522	        var date, args;
1523	        // the Date.UTC function remaps years 0-99 to 1900-1999
1524	        if (y < 100 && y >= 0) {
1525	            args = Array.prototype.slice.call(arguments);
1526	            // preserve leap years using a full 400 year cycle, then reset
1527	            args[0] = y + 400;
1528	            date = new Date(Date.UTC.apply(null, args));
1529	            if (isFinite(date.getUTCFullYear())) {
1530	                date.setUTCFullYear(y);
1531	            }
1532	        } else {
1533	            date = new Date(Date.UTC.apply(null, arguments));
1534	        }
1535	
1536	        return date;
1537	    }
1538	
1539	    // start-of-first-week - start-of-year
1540	    function firstWeekOffset(year, dow, doy) {
1541	        var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
1542	            fwd = 7 + dow - doy,
1543	            // first-week day local weekday -- which local weekday is fwd
1544	            fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
1545	
1546	        return -fwdlw + fwd - 1;
1547	    }
1548	
1549	    // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
1550	    function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
1551	        var localWeekday = (7 + weekday - dow) % 7,
1552	            weekOffset = firstWeekOffset(year, dow, doy),
1553	            dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
1554	            resYear,
1555	            resDayOfYear;
1556	
1557	        if (dayOfYear <= 0) {
1558	            resYear = year - 1;
1559	            resDayOfYear = daysInYear(resYear) + dayOfYear;
1560	        } else if (dayOfYear > daysInYear(year)) {
1561	            resYear = year + 1;
1562	            resDayOfYear = dayOfYear - daysInYear(year);
1563	        } else {
1564	            resYear = year;
1565	            resDayOfYear = dayOfYear;
1566	        }
1567	
1568	        return {
1569	            year: resYear,
1570	            dayOfYear: resDayOfYear,
1571	        };
1572	    }
1573	
1574	    function weekOfYear(mom, dow, doy) {
1575	        var weekOffset = firstWeekOffset(mom.year(), dow, doy),
1576	            week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
1577	            resWeek,
1578	            resYear;
1579	
1580	        if (week < 1) {
1581	            resYear = mom.year() - 1;
1582	            resWeek = week + weeksInYear(resYear, dow, doy);
1583	        } else if (week > weeksInYear(mom.year(), dow, doy)) {
1584	            resWeek = week - weeksInYear(mom.year(), dow, doy);
1585	            resYear = mom.year() + 1;
1586	        } else {
1587	            resYear = mom.year();
1588	            resWeek = week;
1589	        }
1590	
1591	        return {
1592	            week: resWeek,
1593	            year: resYear,
1594	        };
1595	    }
1596	
1597	    function weeksInYear(year, dow, doy) {
1598	        var weekOffset = firstWeekOffset(year, dow, doy),
1599	            weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
1600	        return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
1601	    }
1602	
1603	    // FORMATTING
1604	
1605	    addFormatToken('w', ['ww', 2], 'wo', 'week');
1606	    addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
1607	
1608	    // ALIASES
1609	
1610	    addUnitAlias('week', 'w');
1611	    addUnitAlias('isoWeek', 'W');
1612	
1613	    // PRIORITIES
1614	
1615	    addUnitPriority('week', 5);
1616	    addUnitPriority('isoWeek', 5);
1617	
1618	    // PARSING
1619	
1620	    addRegexToken('w', match1to2);
1621	    addRegexToken('ww', match1to2, match2);
1622	    addRegexToken('W', match1to2);
1623	    addRegexToken('WW', match1to2, match2);
1624	
1625	    addWeekParseToken(['w', 'ww', 'W', 'WW'], function (
1626	        input,
1627	        week,
1628	        config,
1629	        token
1630	    ) {
1631	        week[token.substr(0, 1)] = toInt(input);
1632	    });
1633	
1634	    // HELPERS
1635	
1636	    // LOCALES
1637	
1638	    function localeWeek(mom) {
1639	        return weekOfYear(mom, this._week.dow, this._week.doy).week;
1640	    }
1641	
1642	    var defaultLocaleWeek = {
1643	        dow: 0, // Sunday is the first day of the week.
1644	        doy: 6, // The week that contains Jan 6th is the first week of the year.
1645	    };
1646	
1647	    function localeFirstDayOfWeek() {
1648	        return this._week.dow;
1649	    }
1650	
1651	    function localeFirstDayOfYear() {
1652	        return this._week.doy;
1653	    }
1654	
1655	    // MOMENTS
1656	
1657	    function getSetWeek(input) {
1658	        var week = this.localeData().week(this);
1659	        return input == null ? week : this.add((input - week) * 7, 'd');
1660	    }
1661	
1662	    function getSetISOWeek(input) {
1663	        var week = weekOfYear(this, 1, 4).week;
1664	        return input == null ? week : this.add((input - week) * 7, 'd');
1665	    }
1666	
1667	    // FORMATTING
1668	
1669	    addFormatToken('d', 0, 'do', 'day');
1670	
1671	    addFormatToken('dd', 0, 0, function (format) {
1672	        return this.localeData().weekdaysMin(this, format);
1673	    });
1674	
1675	    addFormatToken('ddd', 0, 0, function (format) {
1676	        return this.localeData().weekdaysShort(this, format);
1677	    });
1678	
1679	    addFormatToken('dddd', 0, 0, function (format) {
1680	        return this.localeData().weekdays(this, format);
1681	    });
1682	
1683	    addFormatToken('e', 0, 0, 'weekday');
1684	    addFormatToken('E', 0, 0, 'isoWeekday');
1685	
1686	    // ALIASES
1687	
1688	    addUnitAlias('day', 'd');
1689	    addUnitAlias('weekday', 'e');
1690	    addUnitAlias('isoWeekday', 'E');
1691	
1692	    // PRIORITY
1693	    addUnitPriority('day', 11);
1694	    addUnitPriority('weekday', 11);
1695	    addUnitPriority('isoWeekday', 11);
1696	
1697	    // PARSING
1698	
1699	    addRegexToken('d', match1to2);
1700	    addRegexToken('e', match1to2);
1701	    addRegexToken('E', match1to2);
1702	    addRegexToken('dd', function (isStrict, locale) {
1703	        return locale.weekdaysMinRegex(isStrict);
1704	    });
1705	    addRegexToken('ddd', function (isStrict, locale) {
1706	        return locale.weekdaysShortRegex(isStrict);
1707	    });
1708	    addRegexToken('dddd', function (isStrict, locale) {
1709	        return locale.weekdaysRegex(isStrict);
1710	    });
1711	
1712	    addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
1713	        var weekday = config._locale.weekdaysParse(input, token, config._strict);
1714	        // if we didn't get a weekday name, mark the date as invalid
1715	        if (weekday != null) {
1716	            week.d = weekday;
1717	        } else {
1718	            getParsingFlags(config).invalidWeekday = input;
1719	        }
1720	    });
1721	
1722	    addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
1723	        week[token] = toInt(input);
1724	    });
1725	
1726	    // HELPERS
1727	
1728	    function parseWeekday(input, locale) {
1729	        if (typeof input !== 'string') {
1730	            return input;
1731	        }
1732	
1733	        if (!isNaN(input)) {
1734	            return parseInt(input, 10);
1735	        }
1736	
1737	        input = locale.weekdaysParse(input);
1738	        if (typeof input === 'number') {
1739	            return input;
1740	        }
1741	
1742	        return null;
1743	    }
1744	
1745	    function parseIsoWeekday(input, locale) {
1746	        if (typeof input === 'string') {
1747	            return locale.weekdaysParse(input) % 7 || 7;
1748	        }
1749	        return isNaN(input) ? null : input;
1750	    }
1751	
1752	    // LOCALES
1753	    function shiftWeekdays(ws, n) {
1754	        return ws.slice(n, 7).concat(ws.slice(0, n));
1755	    }
1756	
1757	    var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
1758	            '_'
1759	        ),
1760	        defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
1761	        defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
1762	        defaultWeekdaysRegex = matchWord,
1763	        defaultWeekdaysShortRegex = matchWord,
1764	        defaultWeekdaysMinRegex = matchWord;
1765	
1766	    function localeWeekdays(m, format) {
1767	        var weekdays = isArray(this._weekdays)
1768	            ? this._weekdays
1769	            : this._weekdays[
1770	                  m && m !== true && this._weekdays.isFormat.test(format)
1771	                      ? 'format'
1772	                      : 'standalone'
1773	              ];
1774	        return m === true
1775	            ? shiftWeekdays(weekdays, this._week.dow)
1776	            : m
1777	            ? weekdays[m.day()]
1778	            : weekdays;
1779	    }
1780	
1781	    function localeWeekdaysShort(m) {
1782	        return m === true
1783	            ? shiftWeekdays(this._weekdaysShort, this._week.dow)
1784	            : m
1785	            ? this._weekdaysShort[m.day()]
1786	            : this._weekdaysShort;
1787	    }
1788	
1789	    function localeWeekdaysMin(m) {
1790	        return m === true
1791	            ? shiftWeekdays(this._weekdaysMin, this._week.dow)
1792	            : m
1793	            ? this._weekdaysMin[m.day()]
1794	            : this._weekdaysMin;
1795	    }
1796	
1797	    function handleStrictParse$1(weekdayName, format, strict) {
1798	        var i,
1799	            ii,
1800	            mom,
1801	            llc = weekdayName.toLocaleLowerCase();
1802	        if (!this._weekdaysParse) {
1803	            this._weekdaysParse = [];
1804	            this._shortWeekdaysParse = [];
1805	            this._minWeekdaysParse = [];
1806	
1807	            for (i = 0; i < 7; ++i) {
1808	                mom = createUTC([2000, 1]).day(i);
1809	                this._minWeekdaysParse[i] = this.weekdaysMin(
1810	                    mom,
1811	                    ''
1812	                ).toLocaleLowerCase();
1813	                this._shortWeekdaysParse[i] = this.weekdaysShort(
1814	                    mom,
1815	                    ''
1816	                ).toLocaleLowerCase();
1817	                this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
1818	            }
1819	        }
1820	
1821	        if (strict) {
1822	            if (format === 'dddd') {
1823	                ii = indexOf.call(this._weekdaysParse, llc);
1824	                return ii !== -1 ? ii : null;
1825	            } else if (format === 'ddd') {
1826	                ii = indexOf.call(this._shortWeekdaysParse, llc);
1827	                return ii !== -1 ? ii : null;
1828	            } else {
1829	                ii = indexOf.call(this._minWeekdaysParse, llc);
1830	                return ii !== -1 ? ii : null;
1831	            }
1832	        } else {
1833	            if (format === 'dddd') {
1834	                ii = indexOf.call(this._weekdaysParse, llc);
1835	                if (ii !== -1) {
1836	                    return ii;
1837	                }
1838	                ii = indexOf.call(this._shortWeekdaysParse, llc);
1839	                if (ii !== -1) {
1840	                    return ii;
1841	                }
1842	                ii = indexOf.call(this._minWeekdaysParse, llc);
1843	                return ii !== -1 ? ii : null;
1844	            } else if (format === 'ddd') {
1845	                ii = indexOf.call(this._shortWeekdaysParse, llc);
1846	                if (ii !== -1) {
1847	                    return ii;
1848	                }
1849	                ii = indexOf.call(this._weekdaysParse, llc);
1850	                if (ii !== -1) {
1851	                    return ii;
1852	                }
1853	                ii = indexOf.call(this._minWeekdaysParse, llc);
1854	                return ii !== -1 ? ii : null;
1855	            } else {
1856	                ii = indexOf.call(this._minWeekdaysParse, llc);
1857	                if (ii !== -1) {
1858	                    return ii;
1859	                }
1860	                ii = indexOf.call(this._weekdaysParse, llc);
1861	                if (ii !== -1) {
1862	                    return ii;
1863	                }
1864	                ii = indexOf.call(this._shortWeekdaysParse, llc);
1865	                return ii !== -1 ? ii : null;
1866	            }
1867	        }
1868	    }
1869	
1870	    function localeWeekdaysParse(weekdayName, format, strict) {
1871	        var i, mom, regex;
1872	
1873	        if (this._weekdaysParseExact) {
1874	            return handleStrictParse$1.call(this, weekdayName, format, strict);
1875	        }
1876	
1877	        if (!this._weekdaysParse) {
1878	            this._weekdaysParse = [];
1879	            this._minWeekdaysParse = [];
1880	            this._shortWeekdaysParse = [];
1881	            this._fullWeekdaysParse = [];
1882	        }
1883	
1884	        for (i = 0; i < 7; i++) {
1885	            // make the regex if we don't have it already
1886	
1887	            mom = createUTC([2000, 1]).day(i);
1888	            if (strict && !this._fullWeekdaysParse[i]) {
1889	                this._fullWeekdaysParse[i] = new RegExp(
1890	                    '^' + this.weekdays(mom, '').replace('.', '\\.?') + '$',
1891	                    'i'
1892	                );
1893	                this._shortWeekdaysParse[i] = new RegExp(
1894	                    '^' + this.weekdaysShort(mom, '').replace('.', '\\.?') + '$',
1895	                    'i'
1896	                );
1897	                this._minWeekdaysParse[i] = new RegExp(
1898	                    '^' + this.weekdaysMin(mom, '').replace('.', '\\.?') + '$',
1899	                    'i'
1900	                );
1901	            }
1902	            if (!this._weekdaysParse[i]) {
1903	                regex =
1904	                    '^' +
1905	                    this.weekdays(mom, '') +
1906	                    '|^' +
1907	                    this.weekdaysShort(mom, '') +
1908	                    '|^' +
1909	                    this.weekdaysMin(mom, '');
1910	                this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
1911	            }
1912	            // test the regex
1913	            if (
1914	                strict &&
1915	                format === 'dddd' &&
1916	                this._fullWeekdaysParse[i].test(weekdayName)
1917	            ) {
1918	                return i;
1919	            } else if (
1920	                strict &&
1921	                format === 'ddd' &&
1922	                this._shortWeekdaysParse[i].test(weekdayName)
1923	            ) {
1924	                return i;
1925	            } else if (
1926	                strict &&
1927	                format === 'dd' &&
1928	                this._minWeekdaysParse[i].test(weekdayName)
1929	            ) {
1930	                return i;
1931	            } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
1932	                return i;
1933	            }
1934	        }
1935	    }
1936	
1937	    // MOMENTS
1938	
1939	    function getSetDayOfWeek(input) {
1940	        if (!this.isValid()) {
1941	            return input != null ? this : NaN;
1942	        }
1943	        var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
1944	        if (input != null) {
1945	            input = parseWeekday(input, this.localeData());
1946	            return this.add(input - day, 'd');
1947	        } else {
1948	            return day;
1949	        }
1950	    }
1951	
1952	    function getSetLocaleDayOfWeek(input) {
1953	        if (!this.isValid()) {
1954	            return input != null ? this : NaN;
1955	        }
1956	        var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
1957	        return input == null ? weekday : this.add(input - weekday, 'd');
1958	    }
1959	
1960	    function getSetISODayOfWeek(input) {
1961	        if (!this.isValid()) {
1962	            return input != null ? this : NaN;
1963	        }
1964	
1965	        // behaves the same as moment#day except
1966	        // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
1967	        // as a setter, sunday should belong to the previous week.
1968	
1969	        if (input != null) {
1970	            var weekday = parseIsoWeekday(input, this.localeData());
1971	            return this.day(this.day() % 7 ? weekday : weekday - 7);
1972	        } else {
1973	            return this.day() || 7;
1974	        }
1975	    }
1976	
1977	    function weekdaysRegex(isStrict) {
1978	        if (this._weekdaysParseExact) {
1979	            if (!hasOwnProp(this, '_weekdaysRegex')) {
1980	                computeWeekdaysParse.call(this);
1981	            }
1982	            if (isStrict) {
1983	                return this._weekdaysStrictRegex;
1984	            } else {
1985	                return this._weekdaysRegex;
1986	            }
1987	        } else {
1988	            if (!hasOwnProp(this, '_weekdaysRegex')) {
1989	                this._weekdaysRegex = defaultWeekdaysRegex;
1990	            }
1991	            return this._weekdaysStrictRegex && isStrict
1992	                ? this._weekdaysStrictRegex
1993	                : this._weekdaysRegex;
1994	        }
1995	    }
1996	
1997	    function weekdaysShortRegex(isStrict) {
1998	        if (this._weekdaysParseExact) {
1999	            if (!hasOwnProp(this, '_weekdaysRegex')) {
2000	                computeWeekdaysParse.call(this);
2001	            }
2002	            if (isStrict) {
2003	                return this._weekdaysShortStrictRegex;
2004	            } else {
2005	                return this._weekdaysShortRegex;
2006	            }
2007	        } else {
2008	            if (!hasOwnProp(this, '_weekdaysShortRegex')) {
2009	                this._weekdaysShortRegex = defaultWeekdaysShortRegex;
2010	            }
2011	            return this._weekdaysShortStrictRegex && isStrict
2012	                ? this._weekdaysShortStrictRegex
2013	                : this._weekdaysShortRegex;
2014	        }
2015	    }
2016	
2017	    function weekdaysMinRegex(isStrict) {
2018	        if (this._weekdaysParseExact) {
2019	            if (!hasOwnProp(this, '_weekdaysRegex')) {
2020	                computeWeekdaysParse.call(this);
2021	            }
2022	            if (isStrict) {
2023	                return this._weekdaysMinStrictRegex;
2024	            } else {
2025	                return this._weekdaysMinRegex;
2026	            }
2027	        } else {
2028	            if (!hasOwnProp(this, '_weekdaysMinRegex')) {
2029	                this._weekdaysMinRegex = defaultWeekdaysMinRegex;
2030	            }
2031	            return this._weekdaysMinStrictRegex && isStrict
2032	                ? this._weekdaysMinStrictRegex
2033	                : this._weekdaysMinRegex;
2034	        }
2035	    }
2036	
2037	    function computeWeekdaysParse() {
2038	        function cmpLenRev(a, b) {
2039	            return b.length - a.length;
2040	        }
2041	
2042	        var minPieces = [],
2043	            shortPieces = [],
2044	            longPieces = [],
2045	            mixedPieces = [],
2046	            i,
2047	            mom,
2048	            minp,
2049	            shortp,
2050	            longp;
2051	        for (i = 0; i < 7; i++) {
2052	            // make the regex if we don't have it already
2053	            mom = createUTC([2000, 1]).day(i);
2054	            minp = regexEscape(this.weekdaysMin(mom, ''));
2055	            shortp = regexEscape(this.weekdaysShort(mom, ''));
2056	            longp = regexEscape(this.weekdays(mom, ''));
2057	            minPieces.push(minp);
2058	            shortPieces.push(shortp);
2059	            longPieces.push(longp);
2060	            mixedPieces.push(minp);
2061	            mixedPieces.push(shortp);
2062	            mixedPieces.push(longp);
2063	        }
2064	        // Sorting makes sure if one weekday (or abbr) is a prefix of another it
2065	        // will match the longer piece.
2066	        minPieces.sort(cmpLenRev);
2067	        shortPieces.sort(cmpLenRev);
2068	        longPieces.sort(cmpLenRev);
2069	        mixedPieces.sort(cmpLenRev);
2070	
2071	        this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
2072	        this._weekdaysShortRegex = this._weekdaysRegex;
2073	        this._weekdaysMinRegex = this._weekdaysRegex;
2074	
2075	        this._weekdaysStrictRegex = new RegExp(
2076	            '^(' + longPieces.join('|') + ')',
2077	            'i'
2078	        );
2079	        this._weekdaysShortStrictRegex = new RegExp(
2080	            '^(' + shortPieces.join('|') + ')',
2081	            'i'
2082	        );
2083	        this._weekdaysMinStrictRegex = new RegExp(
2084	            '^(' + minPieces.join('|') + ')',
2085	            'i'
2086	        );
2087	    }
2088	
2089	    // FORMATTING
2090	
2091	    function hFormat() {
2092	        return this.hours() % 12 || 12;
2093	    }
2094	
2095	    function kFormat() {
2096	        return this.hours() || 24;
2097	    }
2098	
2099	    addFormatToken('H', ['HH', 2], 0, 'hour');
2100	    addFormatToken('h', ['hh', 2], 0, hFormat);
2101	    addFormatToken('k', ['kk', 2], 0, kFormat);
2102	
2103	    addFormatToken('hmm', 0, 0, function () {
2104	        return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
2105	    });
2106	
2107	    addFormatToken('hmmss', 0, 0, function () {
2108	        return (
2109	            '' +
2110	            hFormat.apply(this) +
2111	            zeroFill(this.minutes(), 2) +
2112	            zeroFill(this.seconds(), 2)
2113	        );
2114	    });
2115	
2116	    addFormatToken('Hmm', 0, 0, function () {
2117	        return '' + this.hours() + zeroFill(this.minutes(), 2);
2118	    });
2119	
2120	    addFormatToken('Hmmss', 0, 0, function () {
2121	        return (
2122	            '' +
2123	            this.hours() +
2124	            zeroFill(this.minutes(), 2) +
2125	            zeroFill(this.seconds(), 2)
2126	        );
2127	    });
2128	
2129	    function meridiem(token, lowercase) {
2130	        addFormatToken(token, 0, 0, function () {
2131	            return this.localeData().meridiem(
2132	                this.hours(),
2133	                this.minutes(),
2134	                lowercase
2135	            );
2136	        });
2137	    }
2138	
2139	    meridiem('a', true);
2140	    meridiem('A', false);
2141	
2142	    // ALIASES
2143	
2144	    addUnitAlias('hour', 'h');
2145	
2146	    // PRIORITY
2147	    addUnitPriority('hour', 13);
2148	
2149	    // PARSING
2150	
2151	    function matchMeridiem(isStrict, locale) {
2152	        return locale._meridiemParse;
2153	    }
2154	
2155	    addRegexToken('a', matchMeridiem);
2156	    addRegexToken('A', matchMeridiem);
2157	    addRegexToken('H', match1to2);
2158	    addRegexToken('h', match1to2);
2159	    addRegexToken('k', match1to2);
2160	    addRegexToken('HH', match1to2, match2);
2161	    addRegexToken('hh', match1to2, match2);
2162	    addRegexToken('kk', match1to2, match2);
2163	
2164	    addRegexToken('hmm', match3to4);
2165	    addRegexToken('hmmss', match5to6);
2166	    addRegexToken('Hmm', match3to4);
2167	    addRegexToken('Hmmss', match5to6);
2168	
2169	    addParseToken(['H', 'HH'], HOUR);
2170	    addParseToken(['k', 'kk'], function (input, array, config) {
2171	        var kInput = toInt(input);
2172	        array[HOUR] = kInput === 24 ? 0 : kInput;
2173	    });
2174	    addParseToken(['a', 'A'], function (input, array, config) {
2175	        config._isPm = config._locale.isPM(input);
2176	        config._meridiem = input;
2177	    });
2178	    addParseToken(['h', 'hh'], function (input, array, config) {
2179	        array[HOUR] = toInt(input);
2180	        getParsingFlags(config).bigHour = true;
2181	    });
2182	    addParseToken('hmm', function (input, array, config) {
2183	        var pos = input.length - 2;
2184	        array[HOUR] = toInt(input.substr(0, pos));
2185	        array[MINUTE] = toInt(input.substr(pos));
2186	        getParsingFlags(config).bigHour = true;
2187	    });
2188	    addParseToken('hmmss', function (input, array, config) {
2189	        var pos1 = input.length - 4,
2190	            pos2 = input.length - 2;
2191	        array[HOUR] = toInt(input.substr(0, pos1));
2192	        array[MINUTE] = toInt(input.substr(pos1, 2));
2193	        array[SECOND] = toInt(input.substr(pos2));
2194	        getParsingFlags(config).bigHour = true;
2195	    });
2196	    addParseToken('Hmm', function (input, array, config) {
2197	        var pos = input.length - 2;
2198	        array[HOUR] = toInt(input.substr(0, pos));
2199	        array[MINUTE] = toInt(input.substr(pos));
2200	    });
2201	    addParseToken('Hmmss', function (input, array, config) {
2202	        var pos1 = input.length - 4,
2203	            pos2 = input.length - 2;
2204	        array[HOUR] = toInt(input.substr(0, pos1));
2205	        array[MINUTE] = toInt(input.substr(pos1, 2));
2206	        array[SECOND] = toInt(input.substr(pos2));
2207	    });
2208	
2209	    // LOCALES
2210	
2211	    function localeIsPM(input) {
2212	        // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing str

2212ings like arrays
2213	        // Using charAt should be more compatible.
2214	        return (input + '').toLowerCase().charAt(0) === 'p';
2215	    }
2216	
2217	    var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i,
2218	        // Setting the hour should keep the time, because the user explicitly
2219	        // specified which hour they want. So trying to maintain the same hour (in
2220	        // a new timezone) makes sense. Adding/subtracting hours does not follow
2221	        // this rule.
2222	        getSetHour = makeGetSet('Hours', true);
2223	
2224	    function localeMeridiem(hours, minutes, isLower) {
2225	        if (hours > 11) {
2226	            return isLower ? 'pm' : 'PM';
2227	        } else {
2228	            return isLower ? 'am' : 'AM';
2229	        }
2230	    }
2231	
2232	    var baseConfig = {
2233	        calendar: defaultCalendar,
2234	        longDateFormat: defaultLongDateFormat,
2235	        invalidDate: defaultInvalidDate,
2236	        ordinal: defaultOrdinal,
2237	        dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
2238	        relativeTime: defaultRelativeTime,
2239	
2240	        months: defaultLocaleMonths,
2241	        monthsShort: defaultLocaleMonthsShort,
2242	
2243	        week: defaultLocaleWeek,
2244	
2245	        weekdays: defaultLocaleWeekdays,
2246	        weekdaysMin: defaultLocaleWeekdaysMin,
2247	        weekdaysShort: defaultLocaleWeekdaysShort,
2248	
2249	        meridiemParse: defaultLocaleMeridiemParse,
2250	    };
2251	
2252	    // internal storage for locale config files
2253	    var locales = {},
2254	        localeFamilies = {},
2255	        globalLocale;
2256	
2257	    function commonPrefix(arr1, arr2) {
2258	        var i,
2259	            minl = Math.min(arr1.length, arr2.length);
2260	        for (i = 0; i < minl; i += 1) {
2261	            if (arr1[i] !== arr2[i]) {
2262	                return i;
2263	            }
2264	        }
2265	        return minl;
2266	    }
2267	
2268	    function normalizeLocale(key) {
2269	        return key ? key.toLowerCase().replace('_', '-') : key;
2270	    }
2271	
2272	    // pick the locale from the array
2273	    // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
2274	    // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
2275	    function chooseLocale(names) {
2276	        var i = 0,
2277	            j,
2278	            next,
2279	            locale,
2280	            split;
2281	
2282	        while (i < names.length) {
2283	            split = normalizeLocale(names[i]).split('-');
2284	            j = split.length;
2285	            next = normalizeLocale(names[i + 1]);
2286	            next = next ? next.split('-') : null;
2287	            while (j > 0) {
2288	                locale = loadLocale(split.slice(0, j).join('-'));
2289	                if (locale) {
2290	                    return locale;
2291	                }
2292	                if (
2293	                    next &&
2294	                    next.length >= j &&
2295	                    commonPrefix(split, next) >= j - 1
2296	                ) {
2297	                    //the next array item is better than a shallower substring of this one
2298	                    break;
2299	                }
2300	                j--;
2301	            }
2302	            i++;
2303	        }
2304	        return globalLocale;
2305	    }
2306	
2307	    function loadLocale(name) {
2308	        var oldLocale = null,
2309	            aliasedRequire;
2310	        // TODO: Find a better way to register and load all the locales in Node
2311	        if (
2312	            locales[name] === undefined &&
2313	            typeof module !== 'undefined' &&
2314	            module &&
2315	            module.exports
2316	        ) {
2317	            try {
2318	                oldLocale = globalLocale._abbr;
2319	                aliasedRequire = require;

2320	                __webpack_require__(388)("./" + name);
2321	                getSetGlobalLocale(oldLocale);
2322	            } catch (e) {
2323	                // mark as not found to avoid repeating expensive file require call causing high CPU
2324	                // when trying to find en-US, en_US, en-us for every format call
2325	                locales[name] = null; // null means not found
2326	            }
2327	        }
2328	        return locales[name];
2329	    }
2330	
2331	    // This function will load locale and then set the global locale.  If
2332	    // no arguments are passed in, it will simply return the current global
2333	    // locale key.
2334	    function getSetGlobalLocale(key, values) {
2335	        var data;
2336	        if (key) {
2337	            if (isUndefined(values)) {
2338	                data = getLocale(key);
2339	            } else {
2340	                data = defineLocale(key, values);
2341	            }
2342	
2343	            if (data) {
2344	                // moment.duration._locale = moment._locale = data;
2345	                globalLocale = data;
2346	            } else {
2347	                if (typeof console !== 'undefined' && console.warn) {
2348	                    //warn user if arguments are passed but the locale could not be set
2349	                    console.warn(
2350	                        'Locale ' + key + ' not found. Did you forget to load it?'
2351	                    );
2352	                }
2353	            }
2354	        }
2355	
2356	        return globalLocale._abbr;
2357	    }
2358	
2359	    function defineLocale(name, config) {
2360	        if (config !== null) {
2361	            var locale,
2362	                parentConfig = baseConfig;
2363	            config.abbr = name;
2364	            if (locales[name] != null) {
2365	                deprecateSimple(
2366	                    'defineLocaleOverride',
2367	                    'use moment.updateLocale(localeName, config) to change ' +
2368	                        'an existing locale. moment.defineLocale(localeName, ' +
2369	                        'config) should only be used for creating a new locale ' +
2370	                        'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.'
2371	                );
2372	                parentConfig = locales[name]._config;
2373	            } else if (config.parentLocale != null) {
2374	                if (locales[config.parentLocale] != null) {
2375	                    parentConfig = locales[config.parentLocale]._config;
2376	                } else {
2377	                    locale = loadLocale(config.parentLocale);
2378	                    if (locale != null) {
2379	                        parentConfig = locale._config;
2380	                    } else {
2381	                        if (!localeFamilies[config.parentLocale]) {
2382	                            localeFamilies[config.parentLocale] = [];
2383	                        }
2384	                        localeFamilies[config.parentLocale].push({
2385	                            name: name,
2386	                            config: config,
2387	                        });
2388	                        return null;
2389	                    }
2390	                }
2391	            }
2392	            locales[name] = new Locale(mergeConfigs(parentConfig, config));
2393	
2394	            if (localeFamilies[name]) {
2395	                localeFamilies[name].forEach(function (x) {
2396	                    defineLocale(x.name, x.config);
2397	                });
2398	            }
2399	
2400	            // backwards compat for now: also set the locale
2401	            // make sure we set the locale AFTER all child locales have been
2402	            // created, so we won't end up with the child locale set.
2403	            getSetGlobalLocale(name);
2404	
2405	            return locales[name];
2406	        } else {
2407	            // useful for testing
2408	            delete locales[name];
2409	            return null;
2410	        }
2411	    }
2412	
2413	    function updateLocale(name, config) {
2414	        if (config != null) {
2415	            var locale,
2416	                tmpLocale,
2417	                parentConfig = baseConfig;
2418	
2419	            if (locales[name] != null && locales[name].parentLocale != null) {
2420	                // Update existing child locale in-place to avoid memory-leaks
2421	                locales[name].set(mergeConfigs(locales[name]._config, config));
2422	            } else {
2423	                // MERGE
2424	                tmpLocale = loadLocale(name);
2425	                if (tmpLocale != null) {
2426	                    parentConfig = tmpLocale._config;
2427	                }
2428	                config = mergeConfigs(parentConfig, config);
2429	                if (tmpLocale == null) {
2430	                    // updateLocale is called for creating a new locale
2431	                    // Set abbr so it will have a name (getters return
2432	                    // undefined otherwise).
2433	                    config.abbr = name;
2434	                }
2435	                locale = new Locale(config);
2436	                locale.parentLocale = locales[name];
2437	                locales[name] = locale;
2438	            }
2439	
2440	            // backwards compat for now: also set the locale
2441	            getSetGlobalLocale(name);
2442	        } else {
2443	            // pass null for config to unupdate, useful for tests
2444	            if (locales[name] != null) {
2445	                if (locales[name].parentLocale != null) {
2446	                    locales[name] = locales[name].parentLocale;
2447	                    if (name === getSetGlobalLocale()) {
2448	                        getSetGlobalLocale(name);
2449	                    }
2450	                } else if (locales[name] != null) {
2451	                    delete locales[name];
2452	                }
2453	            }
2454	        }
2455	        return locales[name];
2456	    }
2457	
2458	    // returns locale data
2459	    function getLocale(key) {
2460	        var locale;
2461	
2462	        if (key && key._locale && key._locale._abbr) {
2463	            key = key._locale._abbr;
2464	        }
2465	
2466	        if (!key) {
2467	            return globalLocale;
2468	        }
2469	
2470	        if (!isArray(key)) {
2471	            //short-circuit everything else
2472	            locale = loadLocale(key);
2473	            if (locale) {
2474	                return locale;
2475	            }
2476	            key = [key];
2477	        }
2478	
2479	        return chooseLocale(key);
2480	    }
2481	
2482	    function listLocales() {
2483	        return keys(locales);
2484	    }
2485	
2486	    function checkOverflow(m) {
2487	        var overflow,
2488	            a = m._a;
2489	
2490	        if (a && getParsingFlags(m).overflow === -2) {
2491	            overflow =
2492	                a[MONTH] < 0 || a[MONTH] > 11
2493	                    ? MONTH
2494	                    : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH])
2495	                    ? DATE
2496	                    : a[HOUR] < 0 ||
2497	                      a[HOUR] > 24 ||
2498	                      (a[HOUR] === 24 &&
2499	                          (a[MINUTE] !== 0 ||
2500	                              a[SECOND] !== 0 ||
2501	                              a[MILLISECOND] !== 0))
2502	                    ? HOUR
2503	                    : a[MINUTE] < 0 || a[MINUTE] > 59
2504	                    ? MINUTE
2505	                    : a[SECOND] < 0 || a[SECOND] > 59
2506	                    ? SECOND
2507	                    : a[MILLISECOND] < 0 || a[MILLISECOND] > 999
2508	                    ? MILLISECOND
2509	                    : -1;
2510	
2511	            if (
2512	                getParsingFlags(m)._overflowDayOfYear &&
2513	                (overflow < YEAR || overflow > DATE)
2514	            ) {
2515	                overflow = DATE;
2516	            }
2517	            if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
2518	                overflow = WEEK;
2519	            }
2520	            if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
2521	                overflow = WEEKDAY;
2522	            }
2523	
2524	            getParsingFlags(m).overflow = overflow;
2525	        }
2526	
2527	        return m;
2528	    }
2529	
2530	    // iso 8601 regex
2531	    // 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)
2532	    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)?)?$/,
2533	        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)?)?$/,
2534	        tzRegex = /Z|[+-]\d\d(?::?\d\d)?/,
2535	        isoDates = [
2536	            ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
2537	            ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
2538	            ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
2539	            ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
2540	            ['YYYY-DDD', /\d{4}-\d{3}/],
2541	            ['YYYY-MM', /\d{4}-\d\d/, false],
2542	            ['YYYYYYMMDD', /[+-]\d{10}/],
2543	            ['YYYYMMDD', /\d{8}/],
2544	            ['GGGG[W]WWE', /\d{4}W\d{3}/],
2545	            ['GGGG[W]WW', /\d{4}W\d{2}/, false],
2546	            ['YYYYDDD', /\d{7}/],
2547	            ['YYYYMM', /\d{6}/, false],
2548	            ['YYYY', /\d{4}/, false],
2549	        ],
2550	        // iso time formats and regexes
2551	        isoTimes = [
2552	            ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
2553	            ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
2554	            ['HH:mm:ss', /\d\d:\d\d:\d\d/],
2555	            ['HH:mm', /\d\d:\d\d/],
2556	            ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
2557	            ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
2558	            ['HHmmss', /\d\d\d\d\d\d/],
2559	            ['HHmm', /\d\d\d\d/],
2560	            ['HH', /\d\d/],
2561	        ],
2562	        aspNetJsonRegex = /^\/?Date\((-?\d+)/i,
2563	        // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
2564	        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}))$/,
2565	        obsOffsets = {
2566	            UT: 0,
2567	            GMT: 0,
2568	            EDT: -4 * 60,
2569	            EST: -5 * 60,

2570	            CDT: -5 * 60,
2571	            CST: -6 * 60,
2572	            MDT: -6 * 60,
2573	            MST: -7 * 60,
2574	            PDT: -7 * 60,
2575	            PST: -8 * 60,
2576	        };
2577	
2578	    // date from iso format
2579	    function configFromISO(config) {
2580	        var i,
2581	            l,
2582	            string = config._i,
2583	            match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
2584	            allowTime,
2585	            dateFormat,
2586	            timeFormat,
2587	            tzFormat;
2588	
2589	        if (match) {
2590	            getParsingFlags(config).iso = true;
2591	
2592	            for (i = 0, l = isoDates.length; i < l; i++) {
2593	                if (isoDates[i][1].exec(match[1])) {
2594	                    dateFormat = isoDates[i][0];
2595	                    allowTime = isoDates[i][2] !== false;
2596	                    break;
2597	                }
2598	            }
2599	            if (dateFormat == null) {
2600	                config._isValid = false;
2601	                return;
2602	            }
2603	            if (match[3]) {
2604	                for (i = 0, l = isoTimes.length; i < l; i++) {
2605	                    if (isoTimes[i][1].exec(match[3])) {
2606	                        // match[2] should be 'T' or space
2607	                        timeFormat = (match[2] || ' ') + isoTimes[i][0];
2608	                        break;
2609	                    }
2610	                }
2611	                if (timeFormat == null) {
2612	                    config._isValid = false;
2613	                    return;
2614	                }
2615	            }
2616	            if (!allowTime && timeFormat != null) {
2617	                config._isValid = false;
2618	                return;
2619	            }
2620	            if (match[4]) {
2621	                if (tzRegex.exec(match[4])) {
2622	                    tzFormat = 'Z';
2623	                } else {
2624	                    config._isValid = false;
2625	                    return;
2626	                }
2627	            }
2628	            config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
2629	            configFromStringAndFormat(config);
2630	        } else {
2631	            config._isValid = false;
2632	        }
2633	    }
2634	
2635	    function extractFromRFC2822Strings(
2636	        yearStr,
2637	        monthStr,
2638	        dayStr,
2639	        hourStr,
2640	        minuteStr,
2641	        secondStr
2642	    ) {
2643	        var result = [
2644	            untruncateYear(yearStr),
2645	            defaultLocaleMonthsShort.indexOf(monthStr),
2646	            parseInt(dayStr, 10),
2647	            parseInt(hourStr, 10),
2648	            parseInt(minuteStr, 10),
2649	        ];
2650	
2651	        if (secondStr) {
2652	            result.push(parseInt(secondStr, 10));
2653	        }
2654	
2655	        return result;
2656	    }
2657	
2658	    function untruncateYear(yearStr) {
2659	        var year = parseInt(yearStr, 10);
2660	        if (year <= 49) {
2661	            return 2000 + year;
2662	        } else if (year <= 999) {
2663	            return 1900 + year;
2664	        }
2665	        return year;
2666	    }
2667	
2668	    function preprocessRFC2822(s) {
2669	        // Remove comments and folding whitespace and replace multiple-spaces with a single space
2670	        return s
2671	            .replace(/\([^)]*\)|[\n\t]/g, ' ')
2672	            .replace(/(\s\s+)/g, ' ')
2673	            .replace(/^\s\s*/, '')
2674	            .replace(/\s\s*$/, '');
2675	    }
2676	
2677	    function checkWeekday(weekdayStr, parsedInput, config) {
2678	        if (weekdayStr) {
2679	            // TODO: Replace the vanilla JS Date object with an independent day-of-week check.
2680	            var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr),
2681	                weekdayActual = new Date(
2682	                    parsedInput[0],
2683	                    parsedInput[1],
2684	                    parsedInput[2]
2685	                ).getDay();
2686	            if (weekdayProvided !== weekdayActual) {
2687	                getParsingFlags(config).weekdayMismatch = true;
2688	                config._isValid = false;
2689	                return false;
2690	            }
2691	        }
2692	        return true;
2693	    }
2694	
2695	    function calculateOffset(obsOffset, militaryOffset, numOffset) {
2696	        if (obsOffset) {
2697	            return obsOffsets[obsOffset];
2698	        } else if (militaryOffset) {
2699	            // the only allowed military tz is Z
2700	            return 0;
2701	        } else {
2702	            var hm = parseInt(numOffset, 10),
2703	                m = hm % 100,
2704	                h = (hm - m) / 100;
2705	            return h * 60 + m;
2706	        }
2707	    }
2708	
2709	    // date and time from ref 2822 format
2710	    function configFromRFC2822(config) {
2711	        var match = rfc2822.exec(preprocessRFC2822(config._i)),
2712	            parsedArray;
2713	        if (match) {
2714	            parsedArray = extractFromRFC2822Strings(
2715	                match[4],
2716	                match[3],
2717	                match[2],
2718	                match[5],
2719	                match[6],
2720	                match[7]
2721	            );
2722	            if (!checkWeekday(match[1], parsedArray, config)) {
2723	                return;
2724	            }
2725	
2726	            config._a = parsedArray;
2727	            config._tzm = calculateOffset(match[8], match[9], match[10]);
2728	
2729	            config._d = createUTCDate.apply(null, config._a);
2730	            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
2731	
2732	            getParsingFlags(config).rfc2822 = true;
2733	        } else {
2734	            config._isValid = false;
2735	        }
2736	    }
2737	
2738	    // date from 1) ASP.NET, 2) ISO, 3) RFC 2822 formats, or 4) optional fallback if parsing isn't strict
2739	    function configFromString(config) {
2740	        var matched = aspNetJsonRegex.exec(config._i);
2741	        if (matched !== null) {
2742	            config._d = new Date(+matched[1]);
2743	            return;
2744	        }
2745	
2746	        configFromISO(config);
2747	        if (config._isValid === false) {
2748	            delete config._isValid;
2749	        } else {
2750	            return;
2751	        }
2752	
2753	        configFromRFC2822(config);
2754	        if (config._isValid === false) {
2755	            delete config._isValid;
2756	        } else {
2757	            return;
2758	        }
2759	
2760	        if (config._strict) {
2761	            config._isValid = false;
2762	        } else {
2763	            // Final attempt, use Input Fallback
2764	            hooks.createFromInputFallback(config);
2765	        }
2766	    }
2767	
2768	    hooks.createFromInputFallback = deprecate(
2769	        'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
2770	            'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +
2771	            'discouraged and will be removed in an upcoming major release. Please refer to ' +
2772	            'http://momentjs.com/guides/#/warnings/js-date/ for more info.',
2773	        function (config) {
2774	            config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
2775	        }
2776	    );
2777	
2778	    // Pick the first defined of two or three arguments.
2779	    function defaults(a, b, c) {
2780	        if (a != null) {
2781	            return a;
2782	        }
2783	        if (b != null) {
2784	            return b;
2785	        }
2786	        return c;
2787	    }
2788	
2789	    function currentDateArray(config) {
2790	        // hooks is actually the exported moment object
2791	        var nowValue = new Date(hooks.now());
2792	        if (config._useUTC) {
2793	            return [
2794	                nowValue.getUTCFullYear(),
2795	                nowValue.getUTCMonth(),
2796	                nowValue.getUTCDate(),
2797	            ];
2798	        }
2799	        return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
2800	    }
2801	
2802	    // convert an array to a date.
2803	    // the array should mirror the parameters below
2804	    // note: all values past the year are optional and will default to the lowest possible value.
2805	    // [year, month, day , hour, minute, second, millisecond]
2806	    function configFromArray(config) {
2807	        var i,
2808	            date,
2809	            input = [],
2810	            currentDate,
2811	            expectedWeekday,
2812	            yearToUse;
2813	
2814	        if (config._d) {
2815	            return;
2816	        }
2817	
2818	        currentDate = currentDateArray(config);
2819	
2820	        //compute day of the year from weeks and weekdays
2821	        if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
2822	            dayOfYearFromWeekInfo(config);
2823	        }
2824	
2825	        //if the day of the year is set, figure out what it is
2826	        if (config._dayOfYear != null) {
2827	            yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
2828	
2829	            if (
2830	                config._dayOfYear > daysInYear(yearToUse) ||
2831	                config._dayOfYear === 0
2832	            ) {
2833	                getParsingFlags(config)._overflowDayOfYear = true;
2834	            }
2835	
2836	            date = createUTCDate(yearToUse, 0, config._dayOfYear);
2837	            config._a[MONTH] = date.getUTCMonth();
2838	            config._a[DATE] = date.getUTCDate();
2839	        }
2840	
2841	        // Default to current date.
2842	        // * if no year, month, day of month are given, default to today
2843	        // * if day of month is given, default month and year
2844	        // * if month is given, default only year
2845	        // * if year is given, don't default anything
2846	        for (i = 0; i < 3 && config._a[i] == null; ++i) {
2847	            config._a[i] = input[i] = currentDate[i];
2848	        }
2849	
2850	        // Zero out whatever was not defaulted, including time
2851	        for (; i < 7; i++) {
2852	            config._a[i] = input[i] =
2853	                config._a[i] == null ? (i === 2 ? 1 : 0) : config._a[i];
2854	        }
2855	
2856	        // Check for 24:00:00.000
2857	        if (
2858	            config._a[HOUR] === 24 &&
2859	            config._a[MINUTE] === 0 &&
2860	            config._a[SECOND] === 0 &&
2861	            config._a[MILLISECOND] === 0
2862	        ) {
2863	            config._nextDay = true;
2864	            config._a[HOUR] = 0;
2865	        }
2866	
2867	        config._d = (config._useUTC ? createUTCDate : createDate).apply(
2868	            null,
2869	            input
2870	        );
2871	        expectedWeekday = config._useUTC
2872	            ? config._d.getUTCDay()
2873	            : config._d.getDay();
2874	
2875	        // Apply timezone offset from input. The actual utcOffset can be changed
2876	        // with parseZone.
2877	        if (config._tzm != null) {
2878	            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
2879	        }
2880	
2881	        if (config._nextDay) {
2882	            config._a[HOUR] = 24;
2883	        }
2884	
2885	        // check for mismatching day of week
2886	        if (
2887	            config._w &&
2888	            typeof config._w.d !== 'undefined' &&
2889	            config._w.d !== expectedWeekday
2890	        ) {
2891	            getParsingFlags(config).weekdayMismatch = true;
2892	        }
2893	    }
2894	
2895	    function dayOfYearFromWeekInfo(config) {
2896	        var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow, curWeek;
2897	
2898	        w = config._w;
2899	        if (w.GG != null || w.W != null || w.E != null) {
2900	            dow = 1;
2901	            doy = 4;
2902	
2903	            // TODO: We need to take the current isoWeekYear, but that depends on
2904	            // how we interpret now (local, utc, fixed offset). So create
2905	            // a now version of current config (take local/utc/offset flags, and
2906	            // create now).
2907	            weekYear = defaults(
2908	                w.GG,
2909	                config._a[YEAR],
2910	                weekOfYear(createLocal(), 1, 4).year
2911	            );
2912	            week = defaults(w.W, 1);
2913	            weekday = defaults(w.E, 1);
2914	            if (weekday < 1 || weekday > 7) {
2915	                weekdayOverflow = true;
2916	            }
2917	        } else {
2918	            dow = config._locale._week.dow;
2919	            doy = config._locale._week.doy;
2920	
2921	            curWeek = weekOfYear(createLocal(), dow, doy);
2922	
2923	            weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
2924	
2925	            // Default to current week.
2926	            week = defaults(w.w, curWeek.week);
2927	
2928	            if (w.d != null) {
2929	                // weekday -- low day numbers are considered next week
2930	                weekday = w.d;
2931	                if (weekday < 0 || weekday > 6) {
2932	                    weekdayOverflow = true;
2933	                }
2934	            } else if (w.e != null) {
2935	                // local weekday -- counting starts from beginning of week
2936	                weekday = w.e + dow;
2937	                if (w.e < 0 || w.e > 6) {
2938	                    weekdayOverflow = true;
2939	                }
2940	            } else {
2941	                // default to beginning of week
2942	                weekday = dow;
2943	            }
2944	        }
2945	        if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
2946	            getParsingFlags(config)._overflowWeeks = true;
2947	        } else if (weekdayOverflow != null) {
2948	            getParsingFlags(config)._overflowWeekday = true;
2949	        } else {
2950	            temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
2951	            config._a[YEAR] = temp.year;
2952	            config._dayOfYear = temp.dayOfYear;
2953	        }
2954	    }
2955	
2956	    // constant that refers to the ISO standard
2957	    hooks.ISO_8601 = function () {};
2958	
2959	    // constant that refers to the RFC 2822 form
2960	    hooks.RFC_2822 = function () {};
2961	
2962	    // date from string and format string
2963	    function configFromStringAndFormat(config) {
2964	        // TODO: Move this to another part of the creation flow to prevent circular deps
2965	        if (config._f === hooks.ISO_8601) {
2966	            configFromISO(config);
2967	            return;
2968	        }
2969	        if (config._f === hooks.RFC_2822) {
2970	            configFromRFC2822(config);
2971	            return;
2972	        }
2973	        config._a = [];
2974	        getParsingFlags(config).empty = true;
2975	
2976	        // This array is used to make a Date, either with `new Date` or `Date.UTC`
2977	        var string = '' + config._i,
2978	            i,
2979	            parsedInput,
2980	            tokens,
2981	            token,
2982	            skipped,
2983	            stringLength = string.length,
2984	            totalParsedInputLength = 0,
2985	            era;
2986	
2987	        tokens =
2988	            expandFormat(config._f, config._locale).match(formattingTokens) || [];
2989	
2990	        for (i = 0; i < tokens.length; i++) {
2991	            token = tokens[i];
2992	            parsedInput = (string.match(getParseRegexForToken(token, config)) ||
2993	                [])[0];
2994	            if (parsedInput) {
2995	                skipped = string.substr(0, string.indexOf(parsedInput));
2996	                if (skipped.length > 0) {
2997	                    getParsingFlags(config).unusedInput.push(skipped);
2998	                }
2999	                string = string.slice(
3000	                    string.indexOf(parsedInput) + parsedInput.length
3001	                );
3002	                totalParsedInputLength += parsedInput.length;
3003	            }
3004	            // don't parse if it's not a known token
3005	            if (formatTokenFunctions[token]) {
3006	                if (parsedInput) {
3007	                    getParsingFlags(config).empty = false;
3008	                } else {
3009	                    getParsingFlags(config).unusedTokens.push(token);
3010	                }
3011	                addTimeToArrayFromToken(token, parsedInput, config);
3012	            } else if (config._strict && !parsedInput) {
3013	                getParsingFlags(config).unusedTokens.push(token);
3014	            }
3015	        }
3016	
3017	        // add remaining unparsed input length to the string
3018	        getParsingFlags(config).charsLeftOver =
3019	            stringLength - totalParsedInputLength;
3020	        if (string.length > 0) {
3021	            getParsingFlags(config).unusedInput.push(string);
3022	        }
3023	
3024	        // clear _12h flag if hour is <= 12
3025	        if (
3026	            config._a[HOUR] <= 12 &&
3027	            getParsingFlags(config).bigHour === true &&
3028	            config._a[HOUR] > 0
3029	        ) {
3030	            getParsingFlags(config).bigHour = undefined;
3031	        }
3032	
3033	        getParsingFlags(config).parsedDateParts = config._a.slice(0);
3034	        getParsingFlags(config).meridiem = config._meridiem;
3035	        // handle meridiem
3036	        config._a[HOUR] = meridiemFixWrap(
3037	            config._locale,
3038	            config._a[HOUR],
3039	            config._meridiem
3040	        );
3041	
3042	        // handle era
3043	        era = getParsingFlags(config).era;
3044	        if (era !== null) {
3045	            config._a[YEAR] = config._locale.erasConvertYear(era, config._a[YEAR]);
3046	        }
3047	
3048	        configFromArray(config);
3049	        checkOverflow(config);
3050	    }
3051	
3052	    function meridiemFixWrap(locale, hour, meridiem) {
3053	        var isPm;
3054	
3055	        if (meridiem == null) {
3056	            // nothing to do
3057	            return hour;
3058	        }
3059	        if (locale.meridiemHour != null) {
3060	            return locale.meridiemHour(hour, meridiem);
3061	        } else if (locale.isPM != null) {
3062	            // Fallback
3063	            isPm = locale.isPM(meridiem);
3064	            if (isPm && hour < 12) {
3065	                hour += 12;
3066	            }
3067	            if (!isPm && hour === 12) {
3068	                hour = 0;
3069	            }
3070	            return hour;
3071	        } else {
3072	            // this is not supposed to happen
3073	            return hour;
3074	        }
3075	    }
3076	
3077	    // date from string and array of format strings
3078	    function configFromStringAndArray(config) {
3079	        var tempConfig,
3080	            bestMoment,
3081	            scoreToBeat,
3082	            i,
3083	            currentScore,
3084	            validFormatFound,
3085	            bestFormatIsValid = false;
3086	
3087	        if (config._f.length === 0) {
3088	            getParsingFlags(config).invalidFormat = true;
3089	            config._d = new Date(NaN);
3090	            return;
3091	        }
3092	
3093	        for (i = 0; i < config._f.length; i++) {
3094	            currentScore = 0;
3095	            validFormatFound = false;
3096	            tempConfig = copyConfig({}, config);
3097	            if (config._useUTC != null) {
3098	                tempConfig._useUTC = config._useUTC;
3099	            }
3100	            tempConfig._f = config._f[i];
3101	            configFromStringAndFormat(tempConfig);
3102	
3103	            if (isValid(tempConfig)) {
3104	                validFormatFound = true;
3105	            }
3106	
3107	            // if there is any input that was not parsed add a penalty for that format
3108	            currentScore += getParsingFlags(tempConfig).charsLeftOver;
3109	
3110	            //or tokens
3111	            currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
3112	
3113	            getParsingFlags(tempConfig).score = currentScore;
3114	
3115	            if (!bestFormatIsValid) {
3116	                if (
3117	                    scoreToBeat == null ||
3118	                    currentScore < scoreToBeat ||
3119	                    validFormatFound
3120	                ) {
3121	                    scoreToBeat = currentScore;
3122	                    bestMoment = tempConfig;
3123	                    if (validFormatFound) {
3124	                        bestFormatIsValid = true;
3125	                    }
3126	                }
3127	            } else {
3128	                if (currentScore < scoreToBeat) {
3129	                    scoreToBeat = currentScore;
3130	                    bestMoment = tempConfig;
3131	                }
3132	            }
3133	        }
3134	
3135	        extend(config, bestMoment || tempConfig);
3136	    }
3137	
3138	    function configFromObject(config) {
3139	        if (config._d) {
3140	            return;
3141	        }
3142	
3143	        var i = normalizeObjectUnits(config._i),
3144	            dayOrDate = i.day === undefined ? i.date : i.day;
3145	        config._a = map(
3146	            [i.year, i.month, dayOrDate, i.hour, i.minute, i.second, i.millisecond],
3147	            function (obj) {
3148	                return obj && parseInt(obj, 10);
3149	            }
3150	        );
3151	
3152	        configFromArray(config);
3153	    }
3154	
3155	    function createFromConfig(config) {
3156	        var res = new Moment(checkOverflow(prepareConfig(config)));
3157	        if (res._nextDay) {
3158	            // Adding is smart enough around DST
3159	            res.add(1, 'd');
3160	            res._nextDay = undefined;
3161	        }
3162	
3163	        return res;
3164	    }
3165	
3166	    function prepareConfig(config) {
3167	        var input = config._i,
3168	            format = config._f;
3169	
3170	        config._locale = config._locale || getLocale(config._l);
3171	
3172	        if (input === null || (format === undefined && input === '')) {
3173	            return createInvalid({ nullInput: true });
3174	        }
3175	
3176	        if (typeof input === 'string') {
3177	            config._i = input = config._locale.preparse(input);
3178	        }
3179	
3180	        if (isMoment(input)) {
3181	            return new Moment(checkOverflow(input));
3182	        } else if (isDate(input)) {
3183	            config._d = input;
3184	        } else if (isArray(format)) {
3185	            configFromStringAndArray(config);
3186	        } else if (format) {
3187	            configFromStringAndFormat(config);
3188	        } else {
3189	            configFromInput(config);
3190	        }
3191	
3192	        if (!isValid(config)) {
3193	            config._d = null;
3194	        }
3195	
3196	        return config;
3197	    }
3198	
3199	    function configFromInput(config) {
3200	        var input = config._i;
3201	        if (isUndefined(input)) {
3202	            config._d = new Date(hooks.now());
3203	        } else if (isDate(input)) {
3204	            config._d = new Date(input.valueOf());
3205	        } else if (typeof input === 'string') {
3206	            configFromString(config);
3207	        } else if (isArray(input)) {
3208	            config._a = map(input.slice(0), function (obj) {
3209	                return parseInt(obj, 10);
3210	            });
3211	            configFromArray(config);
3212	        } else if (isObject(input)) {
3213	            configFromObject(config);
3214	        } else if (isNumber(input)) {
3215	            // from milliseconds
3216	            config._d = new Date(input);
3217	        } else {
3218	            hooks.createFromInputFallback(config);
3219	        }
3220	    }
3221	
3222	    function createLocalOrUTC(input, format, locale, strict, isUTC) {
3223	        var c = {};
3224	
3225	        if (format === true || format === false) {
3226	            strict = format;
3227	            format = undefined;
3228	        }
3229	
3230	        if (locale === true || locale === false) {
3231	            strict = locale;
3232	            locale = undefined;
3233	        }
3234	
3235	        if (
3236	            (isObject(input) && isObjectEmpty(input)) ||
3237	            (isArray(input) && input.length === 0)
3238	        ) {
3239	            input = undefined;
3240	        }
3241	        // object construction must be done this way.
3242	        // https://github.com/moment/moment/issues/1423
3243	        c._isAMomentObject = true;
3244	        c._useUTC = c._isUTC = isUTC;
3245	        c._l = locale;
3246	        c._i = input;
3247	        c._f = format;
3248	        c._strict = strict;
3249	
3250	        return createFromConfig(c);
3251	    }
3252	
3253	    function createLocal(input, format, locale, strict) {
3254	        return createLocalOrUTC(input, format, locale, strict, false);
3255	    }
3256	
3257	    var prototypeMin = deprecate(
3258	            'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
3259	            function () {
3260	                var other = createLocal.apply(null, arguments);
3261	                if (this.isValid() && other.isValid()) {
3262	                    return other < this ? this : other;
3263	                } else {
3264	                    return createInvalid();
3265	                }
3266	            }
3267	        ),
3268	        prototypeMax = deprecate(
3269	            'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
3270	            function () {
3271	                var other = createLocal.apply(null, arguments);
3272	                if (this.isValid() && other.isValid()) {
3273	                    return other > this ? this : other;
3274	                } else {
3275	                    return createInvalid();
3276	                }
3277	            }
3278	        );
3279	
3280	    // Pick a moment m from moments so that m[fn](other) is true for all
3281	    // other. This relies on the function fn to be transitive.
3282	    //
3283	    // moments should either be an array of moment objects or an array, whose
3284	    // first element is an array of moment objects.
3285	    function pickBy(fn, moments) {
3286	        var res, i;
3287	        if (moments.length === 1 && isArray(moments[0])) {
3288	            moments = moments[0];
3289	        }
3290	        if (!moments.length) {
3291	            return createLocal();
3292	        }
3293	        res = moments[0];
3294	        for (i = 1; i < moments.length; ++i) {
3295	            if (!moments[i].isValid() || moments[i][fn](res)) {
3296	                res = moments[i];
3297	            }
3298	        }
3299	        return res;
3300	    }
3301	
3302	    // TODO: Use [].sort instead?
3303	    function min() {
3304	        var args = [].slice.call(arguments, 0);
3305	
3306	        return pickBy('isBefore', args);
3307	    }
3308	
3309	    function max() {
3310	        var args = [].slice.call(arguments, 0);
3311	
3312	        return pickBy('isAfter', args);
3313	    }
3314	
3315	    var now = function () {
3316	        return Date.now ? Date.now() : +new Date();
3317	    };
3318	
3319	    var ordering = [
3320	        'year',
3321	        'quarter',
3322	        'month',
3323	        'week',
3324	        'day',
3325	        'hour',
3326	        'minute',
3327	        'second',
3328	        'millisecond',
3329	    ];
3330	
3331	    function isDurationValid(m) {
3332	        var key,
3333	            unitHasDecimal = false,
3334	            i;
3335	        for (key in m) {
3336	            if (
3337	                hasOwnProp(m, key) &&
3338	                !(
3339	                    indexOf.call(ordering, key) !== -1 &&
3340	                    (m[key] == null || !isNaN(m[key]))
3341	                )
3342	            ) {
3343	                return false;
3344	            }
3345	        }
3346	
3347	        for (i = 0; i < ordering.length; ++i) {
3348	            if (m[ordering[i]]) {
3349	                if (unitHasDecimal) {
3350	                    return false; // only allow non-integers for smallest unit
3351	                }
3352	                if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
3353	                    unitHasDecimal = true;
3354	                }
3355	            }
3356	        }
3357	
3358	        return true;
3359	    }
3360	
3361	    function isValid$1() {
3362	        return this._isValid;
3363	    }
3364	
3365	    function createInvalid$1() {
3366	        return createDuration(NaN);
3367	    }
3368	
3369	    function Duration(duration) {
3370	        var normalizedInput = normalizeObjectUnits(duration),
3371	            years = normalizedInput.year || 0,
3372	            quarters = normalizedInput.quarter || 0,
3373	            months = normalizedInput.month || 0,
3374	            weeks = normalizedInput.week || normalizedInput.isoWeek || 0,
3375	            days = normalizedInput.day || 0,
3376	            hours = normalizedInput.hour || 0,
3377	            minutes = normalizedInput.minute || 0,
3378	            seconds = normalizedInput.second || 0,
3379	            milliseconds = normalizedInput.millisecond || 0;
3380	
3381	        this._isValid = isDurationValid(normalizedInput);
3382	
3383	        // representation for dateAddRemove
3384	        this._milliseconds =
3385	            +milliseconds +
3386	            seconds * 1e3 + // 1000
3387	            minutes * 6e4 + // 1000 * 60
3388	            hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
3389	        // Because of dateAddRemove treats 24 hours as different from a
3390	        // day when working around DST, we need to store them separately
3391	        this._days = +days + weeks * 7;
3392	        // It is impossible to translate months into days without knowing
3393	        // which months you are are talking about, so we have to store
3394	        // it separately.
3395	        this._months = +months + quarters * 3 + years * 12;
3396	
3397	        this._data = {};
3398	
3399	        this._locale = getLocale();
3400	
3401	        this._bubble();
3402	    }
3403	
3404	    function isDuration(obj) {
3405	        return obj instanceof Duration;
3406	    }
3407	
3408	    function absRound(number) {
3409	        if (number < 0) {
3410	            return Math.round(-1 * number) * -1;
3411	        } else {
3412	            return Math.round(number);
3413	        }
3414	    }
3415	
3416	    // compare two arrays, return the number of differences
3417	    function compareArrays(array1, array2, dontConvert) {
3418	        var len = Math.min(array1.length, array2.length),
3419	            lengthDiff = Math.abs(array1.length - array2.length),
3420	            diffs = 0,
3421	            i;
3422	        for (i = 0; i < len; i++) {
3423	            if (
3424	                (dontConvert && array1[i] !== array2[i]) ||
3425	                (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))
3426	            ) {
3427	                diffs++;
3428	            }
3429	        }
3430	        return diffs + lengthDiff;
3431	    }
3432	
3433	    // FORMATTING
3434	
3435	    function offset(token, separator) {
3436	        addFormatToken(token, 0, 0, function () {
3437	            var offset = this.utcOffset(),
3438	                sign = '+';
3439	            if (offset < 0) {
3440	                offset = -offset;
3441	                sign = '-';
3442	            }
3443	            return (
3444	                sign +
3445	                zeroFill(~~(offset / 60), 2) +
3446	                separator +
3447	                zeroFill(~~offset % 60, 2)
3448	            );
3449	        });
3450	    }
3451	
3452	    offset('Z', ':');
3453	    offset('ZZ', '');
3454	
3455	    // PARSING
3456	
3457	    addRegexToken('Z', matchShortOffset);
3458	    addRegexToken('ZZ', matchShortOffset);
3459	    addParseToken(['Z', 'ZZ'], function (input, array, config) {
3460	        config._useUTC = true;
3461	        config._tzm = offsetFromString(matchShortOffset, input);
3462	    });
3463	
3464	    // HELPERS
3465	
3466	    // timezone chunker
3467	    // '+10:00' > ['10',  '00']
3468	    // '-1530'  > ['-15', '30']
3469	    var chunkOffset = /([\+\-]|\d\d)/gi;
3470	
3471	    function offsetFromString(matcher, string) {
3472	        var matches = (string || '').match(matcher),
3473	            chunk,
3474	            parts,
3475	            minutes;
3476	
3477	        if (matches === null) {
3478	            return null;
3479	        }
3480	
3481	        chunk = matches[matches.length - 1] || [];
3482	        parts = (chunk + '').match(chunkOffset) || ['-', 0, 0];
3483	        minutes = +(parts[1] * 60) + toInt(parts[2]);
3484	
3485	        return minutes === 0 ? 0 : parts[0] === '+' ? minutes : -minutes;
3486	    }
3487	
3488	    // Return a moment from input, that is local/utc/zone equivalent to model.
3489	    function cloneWithOffset(input, model) {
3490	        var res, diff;
3491	        if (model._isUTC) {
3492	            res = model.clone();
3493	            diff =
3494	                (isMoment(input) || isDate(input)
3495	                    ? input.valueOf()
3496	                    : createLocal(input).valueOf()) - res.valueOf();
3497	            // Use low-level api, because this fn is low-level api.
3498	            res._d.setTime(res._d.valueOf() + diff);
3499	            hooks.updateOffset(res, false);
3500	            return res;
3501	        } else {
3502	            return createLocal(input).local();
3503	        }
3504	    }
3505	
3506	    function getDateOffset(m) {
3507	        // On Firefox.24 Date#getTimezoneOffset returns a floating point.
3508	        // https://github.com/moment/moment/pull/1871
3509	        return -Math.round(m._d.getTimezoneOffset());
3510	    }
3511	
3512	    // HOOKS
3513	
3514	    // This function will be called whenever a moment is mutated.
3515	    // It is intended to keep the offset in sync with the timezone.
3516	    hooks.updateOffset = function () {};
3517	
3518	    // MOMENTS
3519	
3520	    // keepLocalTime = true means only change the timezone, without
3521	    // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
3522	    // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
3523	    // +0200, so we adjust the time as needed, to be valid.
3524	    //
3525	    // Keeping the time actually adds/subtracts (one hour)