https://aimcompanies.com/wp-content/plugins/canto/public/assets/app.vendor.bundle.js?ver=1.0.0

123
124}(this, (function () { 'use strict';
125
126    var hookCallback;
127
128    function hooks () {
129        return hookCallback.apply(null, arguments);
130    }
131
132    // This is done to register the method called with moment()
133    // without creating circular dependencies.
134    function setHookCallback (callback) {
135        hookCallback = callback;
136    }
137
138    function isArray(input) {
139        return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';
140    }
141
142    function isObject(input) {
143        // IE8 will treat undefined and null as object if it wasn't for
144        // input != null
145        return input != null && Object.prototype.toString.call(input) === '[object Object]';
146    }
147
148    function isObjectEmpty(obj) {
149        if (Object.getOwnPropertyNames) {
150            return (Object.getOwnPropertyNames(obj).length === 0);
151        } else {
152            var k;
153            for (k in obj) {
154                if (obj.hasOwnProperty(k)) {
155                    return false;
156                }
157            }
158            return true;
159        }
160    }
161
162    function isUndefined(input) {
163        return input === void 0;
164    }
165
166    function isNumber(input) {
167        return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]';
168    }
169
170    function isDate(input) {
171        return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
172    }
173
174    function map(arr, fn) {
175        var res = [], i;
176        for (i = 0; i < arr.length; ++i) {
177            res.push(fn(arr[i], i));
178        }
179        return res;
180    }
181
182    function hasOwnProp(a, b) {
183        return Object.prototype.hasOwnProperty.call(a, b);
184    }
185
186    function extend(a, b) {
187        for (var i in b) {
188            if (hasOwnProp(b, i)) {
189                a[i] = b[i];
190            }
191        }
192
193        if (hasOwnProp(b, 'toString')) {
194            a.toString = b.toString;
195        }
196
197        if (hasOwnProp(b, 'valueOf')) {
198            a.valueOf = b.valueOf;
199        }
200
201        return a;
202    }
203
204    function createUTC (input, format, locale, strict) {
205        return createLocalOrUTC(input, format, locale, strict, true).utc();
206    }
207
208    function defaultParsingFlags() {
209        // We need to deep clone this object.
210        return {
211            empty           : false,
212            unusedTokens    : [],
213            unusedInput     : [],
214            overflow        : -2,
215            charsLeftOver   : 0,
216            nullInput       : false,
217            invalidMonth    : null,
218            invalidFormat   : false,
219            userInvalidated : false,
220            iso             : false,
221            parsedDateParts : [],
222            meridiem        : null,
223            rfc2822         : false,
224            weekdayMismatch : false
225        };
226    }
227
228    function getParsingFlags(m) {
229        if (m._pf == null) {
230            m._pf = defaultParsingFlags();
231        }
232        return m._pf;
233    }
234
235    var some;
236    if (Array.prototype.some) {
237        some = Array.prototype.some;
238    } else {
239        some = function (fun) {
240            var t = Object(this);
241            var len = t.length >>> 0;
242
243            for (var i = 0; i < len; i++) {
244                if (i in t && fun.call(this, t[i], i, t)) {
245                    return true;
246                }
247            }
248
249            return false;
250        };
251    }
252
253    function isValid(m) {
254        if (m._isValid == null) {
255            var flags = getParsingFlags(m);
256            var parsedParts = some.call(flags.parsedDateParts, function (i) {
257                return i != null;
258            });
259            var isNowValid = !isNaN(m._d.getTime()) &&
260                flags.overflow < 0 &&
261                !flags.empty &&
262                !flags.invalidMonth &&
263                !flags.invalidWeekday &&
264                !flags.weekdayMismatch &&
265                !flags.nullInput &&
266                !flags.invalidFormat &&
267                !flags.userInvalidated &&
268                (!flags.meridiem || (flags.meridiem && parsedParts));
269
270            if (m._strict) {
271                isNowValid = isNowValid &&
272                    flags.charsLeftOver === 0 &&
273                    flags.unusedTokens.length === 0 &&
274                    flags.bigHour === undefined;
275            }
276
277            if (Object.isFrozen == null || !Object.isFrozen(m)) {
278                m._isValid = isNowValid;
279            }
280            else {
281                return isNowValid;
282            }
283        }
284        return m._isValid;
285    }
286
287    function createInvalid (flags) {
288        var m = createUTC(NaN);
289        if (flags != null) {
290            extend(getParsingFlags(m), flags);
291        }
292        else {
293            getParsingFlags(m).userInvalidated = true;
294        }
295
296        return m;
297    }
298
299    // Plugins that add properties should also add the key here (null value),
300    // so we can properly clone ourselves.
301    var momentProperties = hooks.momentProperties = [];
302
303    function copyConfig(to, from) {
304        var i, prop, val;
305
306        if (!isUndefined(from._isAMomentObject)) {
307            to._isAMomentObject = from._isAMomentObject;
308        }
309        if (!isUndefined(from._i)) {
310            to._i = from._i;
311        }
312        if (!isUndefined(from._f)) {
313            to._f = from._f;
314        }
315        if (!isUndefined(from._l)) {
316            to._l = from._l;
317        }
318        if (!isUndefined(from._strict)) {
319            to._strict = from._strict;
320        }
321        if (!isUndefined(from._tzm)) {
322            to._tzm = from._tzm;
323        }
324        if (!isUndefined(from._isUTC)) {
325            to._isUTC = from._isUTC;
326        }
327        if (!isUndefined(from._offset)) {
328            to._offset = from._offset;
329        }
330        if (!isUndefined(from._pf)) {
331            to._pf = getParsingFlags(from);
332        }
333        if (!isUndefined(from._locale)) {
334            to._locale = from._locale;
335        }
336
337        if (momentProperties.length > 0) {
338            for (i = 0; i < momentProperties.length; i++) {
339                prop = momentProperties[i];
340                val = from[prop];
341                if (!isUndefined(val)) {
342                    to[prop] = val;
343                }
344            }
345        }
346
347        return to;
348    }
349
350    var updateInProgress = false;
351
352    // Moment prototype object
353    function Moment(config) {
354        copyConfig(this, config);
355        this._d = new Date(config._d != null ? config._d.getTime() : NaN);
356        if (!this.isValid()) {
357            this._d = new Date(NaN);
358        }
359        // Prevent infinite loop in case updateOffset creates new moment
360        // objects.
361        if (updateInProgress === false) {
362            updateInProgress = true;
363            hooks.updateOffset(this);
364            updateInProgress = false;
365        }
366    }
367
368    function isMoment (obj) {
369        return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
370    }
371
372    function absFloor (number) {
373        if (number < 0) {
374            // -0 -> 0
375            return Math.ceil(number) || 0;
376        } else {
377            return Math.floor(number);
378        }
379    }
380
381    function toInt(argumentForCoercion) {
382        var coercedNumber = +argumentForCoercion,
383            value = 0;
384
385        if (coercedNumber !== 0 && isFinite(coercedNumber)) {
386            value = absFloor(coercedNumber);
387        }
388
389        return value;
390    }
391
392    // compare two arrays, return the number of differences
393    function compareArrays(array1, array2, dontConvert) {
394        var len = Math.min(array1.length, array2.length),
395            lengthDiff = Math.abs(array1.length - array2.length),
396            diffs = 0,
397            i;
398        for (i = 0; i < len; i++) {
399            if ((dontConvert && array1[i] !== array2[i]) ||
400                (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
401                diffs++;
402            }
403        }
404        return diffs + lengthDiff;
405    }
406
407    function warn(msg) {
408        if (hooks.suppressDeprecationWarnings === false &&
409                (typeof console !==  'undefined') && console.warn) {
410            console.warn('Deprecation warning: ' + msg);
411        }
412    }
413
414    function deprecate(msg, fn) {
415        var firstTime = true;
416
417        return extend(function () {
418            if (hooks.deprecationHandler != null) {
419                hooks.deprecationHandler(null, msg);
420            }
421            if (firstTime) {
422                var args = [];
423                var arg;
424                for (var i = 0; i < arguments.length; i++) {
425                    arg = '';
426                    if (typeof arguments[i] === 'object') {
427                        arg += '\n[' + i + '] ';
428                        for (var key in arguments[0]) {
429                            arg += key + ': ' + arguments[0][key] + ', ';
430                        }
431                        arg = arg.slice(0, -2); // Remove trailing comma and space
432                    } else {
433                        arg = arguments[i];
434                    }
435                    args.push(arg);
436                }
437                warn(msg + '\nArguments: ' + Array.prototype.slice.call(args).join('') + '\n' + (new Error()).stack);
438                firstTime = false;
439            }
440            return fn.apply(this, arguments);
441        }, fn);
442    }
443
444    var deprecations = {};
445
446    function deprecateSimple(name, msg) {
447        if (hooks.deprecationHandler != null) {
448            hooks.deprecationHandler(name, msg);
449        }
450        if (!deprecations[name]) {
451            warn(msg);
452            deprecations[name] = true;
453        }
454    }
455
456    hooks.suppressDeprecationWarnings = false;
457    hooks.deprecationHandler = null;
458
459    function isFunction(input) {
460        return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';
461    }
462
463    function set (config) {
464        var prop, i;
465        for (i in config) {
466            prop = config[i];
467            if (isFunction(prop)) {
468                this[i] = prop;
469            } else {
470                this['_' + i] = prop;
471            }
472        }
473        this._config = config;
474        // Lenient ordinal parsing accepts just a number in addition to
475        // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
476        // TODO: Remove "ordinalParse" fallback in next major release.
477        this._dayOfMonthOrdinalParseLenient = new RegExp(
478            (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +
479                '|' + (/\d{1,2}/).source);
480    }
481
482    function mergeConfigs(parentConfig, childConfig) {
483        var res = extend({}, parentConfig), prop;
484        for (prop in childConfig) {
485            if (hasOwnProp(childConfig, prop)) {
486                if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
487                    res[prop] = {};
488                    extend(res[prop], parentConfig[prop]);
489                    extend(res[prop], childConfig[prop]);
490                } else if (childConfig[prop] != null) {
491                    res[prop] = childConfig[prop];
492                } else {
493                    delete res[prop];
494                }
495            }
496        }
497        for (prop in parentConfig) {
498            if (hasOwnProp(parentConfig, prop) &&
499                    !hasOwnProp(childConfig, prop) &&
500                    isObject(parentConfig[prop])) {
501                // make sure changes to properties don't modify parent config
502                res[prop] = extend({}, res[prop]);
503            }
504        }
505        return res;
506    }
507
508    function Locale(config) {
509        if (config != null) {
510            this.set(config);
511        }
512    }
513
514    var keys;
515
516    if (Object.keys) {
517        keys = Object.keys;
518    } else {
519        keys = function (obj) {
520            var i, res = [];
521            for (i in obj) {
522                if (hasOwnProp(obj, i)) {
523                    res.push(i);
524                }
525            }
526            return res;
527        };
528    }
529
530    var defaultCalendar = {
531        sameDay : '[Today at] LT',
532        nextDay : '[Tomorrow at] LT',
533        nextWeek : 'dddd [at] LT',
534        lastDay : '[Yesterday at] LT',
535        lastWeek : '[Last] dddd [at] LT',
536        sameElse : 'L'
537    };
538
539    function calendar (key, mom, now) {
540        var output = this._calendar[key] || this._calendar['sameElse'];
541        return isFunction(output) ? output.call(mom, now) : output;
542    }
543
544    var defaultLongDateFormat = {
545        LTS  : 'h:mm:ss A',
546        LT   : 'h:mm A',
547        L    : 'MM/DD/YYYY',
548        LL   : 'MMMM D, YYYY',
549        LLL  : 'MMMM D, YYYY h:mm A',
550        LLLL : 'dddd, MMMM D, YYYY h:mm A'
551    };
552
553    function longDateFormat (key) {
554        var format = this._longDateFormat[key],
555            formatUpper = this._longDateFormat[key.toUpperCase()];
556
557        if (format || !formatUpper) {
558            return format;
559        }
560
561        this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
562            return val.slice(1);
563        });
564
565        return this._longDateFormat[key];
566    }
567
568    var defaultInvalidDate = 'Invalid date';
569
570    function invalidDate () {
571        return this._invalidDate;
572    }
573
574    var defaultOrdinal = '%d';
575    var defaultDayOfMonthOrdinalParse = /\d{1,2}/;
576
577    function ordinal (number) {
578        return this._ordinal.replace('%d', number);
579    }
580
581    var defaultRelativeTime = {
582        future : 'in %s',
583        past   : '%s ago',
584        s  : 'a few seconds',
585        ss : '%d seconds',
586        m  : 'a minute',
587        mm : '%d minutes',
588        h  : 'an hour',
589        hh : '%d hours',
590        d  : 'a day',
591        dd : '%d days',
592        M  : 'a month',
593        MM : '%d months',
594        y  : 'a year',
595        yy : '%d years'
596    };
597
598    function relativeTime (number, withoutSuffix, string, isFuture) {
599        var output = this._relativeTime[string];
600        return (isFunction(output)) ?
601            output(number, withoutSuffix, string, isFuture) :
602            output.replace(/%d/i, number);
603    }
604
605    function pastFuture (diff, output) {
606        var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
607        return isFunction(format) ? format(output) : format.replace(/%s/i, output);
608    }
609
610    var aliases = {};
611
612    function addUnitAlias (unit, shorthand) {
613        var lowerCase = unit.toLowerCase();
614        aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
615    }
616
617    function normalizeUnits(units) {
618        return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
619    }
620
621    function normalizeObjectUnits(inputObject) {
622        var normalizedInput = {},
623            normalizedProp,
624            prop;
625
626        for (prop in inputObject) {
627            if (hasOwnProp(inputObject, prop)) {
628                normalizedProp = normalizeUnits(prop);
629                if (normalizedProp) {
630                    normalizedInput[normalizedProp] = inputObject[prop];
631                }
632            }
633        }
634
635        return normalizedInput;
636    }
637
638    var priorities = {};
639
640    function addUnitPriority(unit, priority) {
641        priorities[unit] = priority;
642    }
643
644    function getPrioritizedUnits(unitsObj) {
645        var units = [];
646        for (var u in unitsObj) {
647            units.push({unit: u, priority: priorities[u]});
648        }
649        units.sort(function (a, b) {
650            return a.priority - b.priority;
651        });
652        return units;
653    }
654
655    function zeroFill(number, targetLength, forceSign) {
656        var absNumber = '' + Math.abs(number),
657            zerosToFill = targetLength - absNumber.length,
658            sign = number >= 0;
659        return (sign ? (forceSign ? '+' : '') : '-') +
660            Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
661    }
662
663    var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;
664
665    var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
666
667    var formatFunctions = {};
668
669    var formatTokenFunctions = {};
670
671    // token:    'M'
672    // padded:   ['MM', 2]
673    // ordinal:  'Mo'
674    // callback: function () { this.month() + 1 }
675    function addFormatToken (token, padded, ordinal, callback) {
676        var func = callback;
677        if (typeof callback === 'string') {
678            func = function () {
679                return this[callback]();
680            };
681        }
682        if (token) {
683            formatTokenFunctions[token] = func;
684        }
685        if (padded) {
686            formatTokenFunctions[padded[0]] = function () {
687                return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
688            };
689        }
690        if (ordinal) {
691            formatTokenFunctions[ordinal] = function () {
692                return this.localeData().ordinal(func.apply(this, arguments), token);
693            };
694        }
695    }
696
697    function removeFormattingTokens(input) {
698        if (input.match(/\[[\s\S]/)) {
699            return input.replace(/^\[|\]$/g, '');
700        }
701        return input.replace(/\\/g, '');
702    }
703
704    function makeFormatFunction(format) {
705        var array = format.match(formattingTokens), i, length;
706
707        for (i = 0, length = array.length; i < length; i++) {
708            if (formatTokenFunctions[array[i]]) {
709                array[i] = formatTokenFunctions[array[i]];
710            } else {
711                array[i] = removeFormattingTokens(array[i]);
712            }
713        }
714
715        return function (mom) {
716            var output = '', i;
717            for (i = 0; i < length; i++) {
718                output += isFunction(array[i]) ? array[i].call(mom, format) : array[i];
719            }
720            return output;
721        };
722    }
723
724    // format date using native date object
725    function formatMoment(m, format) {
726        if (!m.isValid()) {
727            return m.localeData().invalidDate();
728        }
729
730        format = expandFormat(format, m.localeData());
731        formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);
732
733        return formatFunctions[format](m);
734    }
735
736    function expandFormat(format, locale) {
737        var i = 5;
738
739        function replaceLongDateFormatTokens(input) {
740            return locale.longDateFormat(input) || input;
741        }
742
743        localFormattingTokens.lastIndex = 0;
744        while (i >= 0 && localFormattingTokens.test(format)) {
745            format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
746            localFormattingTokens.lastIndex = 0;
747            i -= 1;
748        }
749
750        return format;
751    }
752
753    var match1         = /\d/;            //       0 - 9
754    var match2         = /\d\d/;          //      00 - 99
755    var match3         = /\d{3}/;         //     000 - 999
756    var match4         = /\d{4}/;         //    0000 - 9999
757    var match6         = /[+-]?\d{6}/;    // -999999 - 999999
758    var match1to2      = /\d\d?/;         //       0 - 99
759    var match3to4      = /\d\d\d\d?/;     //     999 - 9999
760    var match5to6      = /\d\d\d\d\d\d?/; //   99999 - 999999
761    var match1to3      = /\d{1,3}/;       //       0 - 999
762    var match1to4      = /\d{1,4}/;       //       0 - 9999
763    var match1to6      = /[+-]?\d{1,6}/;  // -999999 - 999999
764
765    var matchUnsigned  = /\d+/;           //       0 - inf
766    var matchSigned    = /[+-]?\d+/;      //    -inf - inf
767
768    var matchOffset    = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
769    var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z
770
771    var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
772
773    // any word (or two) characters or numbers including two/three word month in arabic.
774    // includes scottish gaelic two word and hyphenated months
775    var 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;
776
777    var regexes = {};
778
779    function addRegexToken (token, regex, strictRegex) {
780        regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
781            return (isStrict && strictRegex) ? strictRegex : regex;
782        };
783    }
784
785    function getParseRegexForToken (token, config) {
786        if (!hasOwnProp(regexes, token)) {
787            return new RegExp(unescapeFormat(token));
788        }
789
790        return regexes[token](config._strict, config._locale);
791    }
792
793    // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
794    function unescapeFormat(s) {
795        return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
796            return p1 || p2 || p3 || p4;
797        }));
798    }
799
800    function regexEscape(s) {
801        return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
802    }
803
804    var tokens = {};
805
806    function addParseToken (token, callback) {
807        var i, func = callback;
808        if (typeof token === 'string') {
809            token = [token];
810        }
811        if (isNumber(callback)) {
812            func = function (input, array) {
813                array[callback] = toInt(input);
814            };
815        }
816        for (i = 0; i < token.length; i++) {
817            tokens[token[i]] = func;
818        }
819    }
820
821    function addWeekParseToken (token, callback) {
822        addParseToken(token, function (input, array, config, token) {
823            config._w = config._w || {};
824            callback(input, config._w, config, token);
825        });
826    }
827
828    function addTimeToArrayFromToken(token, input, config) {
829        if (input != null && hasOwnProp(tokens, token)) {
830            tokens[token](input, config._a, config, token);
831        }
832    }
833
834    var YEAR = 0;
835    var MONTH = 1;
836    var DATE = 2;
837    var HOUR = 3;
838    var MINUTE = 4;
839    var SECOND = 5;
840    var MILLISECOND = 6;
841    var WEEK = 7;
842    var WEEKDAY = 8;
843
844    // FORMATTING
845
846    addFormatToken('Y', 0, 0, function () {
847        var y = this.year();
848        return y <= 9999 ? '' + y : '+' + y;
849    });
850
851    addFormatToken(0, ['YY', 2], 0, function () {
852        return this.year() % 100;
853    });
854
855    addFormatToken(0, ['YYYY',   4],       0, 'year');
856    addFormatToken(0, ['YYYYY',  5],       0, 'year');
857    addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
858
859    // ALIASES
860
861    addUnitAlias('year', 'y');
862
863    // PRIORITIES
864
865    addUnitPriority('year', 1);
866
867    // PARSING
868
869    addRegexToken('Y',      matchSigned);
870    addRegexToken('YY',     match1to2, match2);
871    addRegexToken('YYYY',   match1to4, match4);
872    addRegexToken('YYYYY',  match1to6, match6);
873    addRegexToken('YYYYYY', match1to6, match6);
874
875    addParseToken(['YYYYY', 'YYYYYY'], YEAR);
876    addParseToken('YYYY', function (input, array) {
877        array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
878    });
879    addParseToken('YY', function (input, array) {
880        array[YEAR] = hooks.parseTwoDigitYear(input);
881    });
882    addParseToken('Y', function (input, array) {
883        array[YEAR] = parseInt(input, 10);
884    });
885
886    // HELPERS
887
888    function daysInYear(year) {
889        return isLeapYear(year) ? 366 : 365;
890    }
891
892    function isLeapYear(year) {
893        return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
894    }
895
896    // HOOKS
897
898    hooks.parseTwoDigitYear = function (input) {
899        return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
900    };
901
902    // MOMENTS
903
904    var getSetYear = makeGetSet('FullYear', true);
905
906    function getIsLeapYear () {
907        return isLeapYear(this.year());
908    }
909
910    function makeGetSet (unit, keepTime) {
911        return function (value) {
912            if (value != null) {
913                set$1(this, unit, value);
914                hooks.updateOffset(this, keepTime);
915                return this;
916            } else {
917                return get(this, unit);
918            }
919        };
920    }
921
922    function get (mom, unit) {
923        return mom.isValid() ?
924            mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;
925    }
926
927    function set$1 (mom, unit, value) {
928        if (mom.isValid() && !isNaN(value)) {
929            if (unit === 'FullYear' && isLeapYear(mom.year()) && mom.month() === 1 && mom.date() === 29) {
930                mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value, mom.month(), daysInMonth(value, mom.month()));
931            }
932            else {
933                mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
934            }
935        }
936    }
937
938    // MOMENTS
939
940    function stringGet (units) {
941        units = normalizeUnits(units);
942        if (isFunction(this[units])) {
943            return this[units]();
944        }
945        return this;
946    }
947
948
949    function stringSet (units, value) {
950        if (typeof units === 'object') {
951            units = normalizeObjectUnits(units);
952            var prioritized = getPrioritizedUnits(units);
953            for (var i = 0; i < prioritized.length; i++) {
954                this[prioritized[i].unit](units[prioritized[i].unit]);
955            }
956        } else {
957            units = normalizeUnits(units);
958            if (isFunction(this[units])) {
959                return this[units](value);
960            }
961        }
962        return this;
963    }
964
965    function mod(n, x) {
966        return ((n % x) + x) % x;
967    }
968
969    var indexOf;
970
971    if (Array.prototype.indexOf) {
972        indexOf = Array.prototype.indexOf;
973    } else {
974        indexOf = function (o) {
975            // I know
976            var i;
977            for (i = 0; i < this.length; ++i) {
978                if (this[i] === o) {
979                    return i;
980                }
981            }
982            return -1;
983        };
984    }
985
986    function daysInMonth(year, month) {
987        if (isNaN(year) || isNaN(month)) {
988            return NaN;
989        }
990        var modMonth = mod(month, 12);
991        year += (month - modMonth) / 12;
992        return modMonth === 1 ? (isLeapYear(year) ? 29 : 28) : (31 - modMonth % 7 % 2);
993    }
994
995    // FORMATTING
996
997    addFormatToken('M', ['MM', 2], 'Mo', function () {
998        return this.month() + 1;
999    });
1000
1001    addFormatToken('MMM', 0, 0, function (format) {
1002        return this.localeData().monthsShort(this, format);
1003    });
1004
1005    addFormatToken('MMMM', 0, 0, function (format) {
1006        return this.localeData().months(this, format);
1007    });
1008
1009    // ALIASES
1010
1011    addUnitAlias('month', 'M');
1012
1013    // PRIORITY
1014
1015    addUnitPriority('month', 8);
1016
1017    // PARSING
1018
1019    addRegexToken('M',    match1to2);
1020    addRegexToken('MM',   match1to2, match2);
1021    addRegexToken('MMM',  function (isStrict, locale) {
1022        return locale.monthsShortRegex(isStrict);
1023    });
1024    addRegexToken('MMMM', function (isStrict, locale) {
1025        return locale.monthsRegex(isStrict);
1026    });
1027
1028    addParseToken(['M', 'MM'], function (input, array) {
1029        array[MONTH] = toInt(input) - 1;
1030    });
1031
1032    addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
1033        var month = config._locale.monthsParse(input, token, config._strict);
1034        // if we didn't find a month name, mark the date as invalid.
1035        if (month != null) {
1036            array[MONTH] = month;
1037        } else {
1038            getParsingFlags(config).invalidMonth = input;
1039        }
1040    });
1041
1042    // LOCALES
1043
1044    var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/;
1045    var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
1046    function localeMonths (m, format) {
1047        if (!m) {
1048            return isArray(this._months) ? this._months :
1049                this._months['standalone'];
1050        }
1051        return isArray(this._months) ? this._months[m.month()] :
1052            this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];
1053    }
1054
1055    var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
1056    function localeMonthsShort (m, format) {
1057        if (!m) {
1058            return isArray(this._monthsShort) ? this._monthsShort :
1059                this._monthsShort['standalone'];
1060        }
1061        return isArray(this._monthsShort) ? this._monthsShort[m.month()] :
1062            this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
1063    }
1064
1065    function handleStrictParse(monthName, format, strict) {
1066        var i, ii, mom, llc = monthName.toLocaleLowerCase();
1067        if (!this._monthsParse) {
1068            // this is not used
1069            this._monthsParse = [];
1070            this._longMonthsParse = [];
1071            this._shortMonthsParse = [];
1072            for (i = 0; i < 12; ++i) {
1073                mom = createUTC([2000, i]);
1074                this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();
1075                this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
1076            }
1077        }
1078
1079        if (strict) {
1080            if (format === 'MMM') {
1081                ii = indexOf.call(this._shortMonthsParse, llc);
1082                return ii !== -1 ? ii : null;
1083            } else {
1084                ii = indexOf.call(this._longMonthsParse, llc);
1085                return ii !== -1 ? ii : null;
1086            }
1087        } else {
1088            if (format === 'MMM') {
1089                ii = indexOf.call(this._shortMonthsParse, llc);
1090                if (ii !== -1) {
1091                    return ii;
1092                }
1093                ii = indexOf.call(this._longMonthsParse, llc);
1094                return ii !== -1 ? ii : null;
1095            } else {
1096                ii = indexOf.call(this._longMonthsParse, llc);
1097                if (ii !== -1) {
1098                    return ii;
1099                }
1100                ii = indexOf.call(this._shortMonthsParse, llc);
1101                return ii !== -1 ? ii : null;
1102            }
1103        }
1104    }
1105
1106    function localeMonthsParse (monthName, format, strict) {
1107        var i, mom, regex;
1108
1109        if (this._monthsParseExact) {
1110            return handleStrictParse.call(this, monthName, format, strict);
1111        }
1112
1113        if (!this._monthsParse) {
1114            this._monthsParse = [];
1115            this._longMonthsParse = [];
1116            this._shortMonthsParse = [];
1117        }
1118
1119        // TODO: add sorting
1120        // Sorting makes sure if one month (or abbr) is a prefix of another
1121        // see sorting in computeMonthsParse
1122        for (i = 0; i < 12; i++) {
1123            // make the regex if we don't have it already
1124            mom = createUTC([2000, i]);
1125            if (strict && !this._longMonthsParse[i]) {
1126                this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
1127                this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
1128            }
1129            if (!strict && !this._monthsParse[i]) {
1130                regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
1131                this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
1132            }
1133            // test the regex
1134            if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
1135                return i;
1136            } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
1137                return i;
1138            } else if (!strict && this._monthsParse[i].test(monthName)) {
1139                return i;
1140            }
1141        }
1142    }
1143
1144    // MOMENTS
1145
1146    function setMonth (mom, value) {
1147        var dayOfMonth;
1148
1149        if (!mom.isValid()) {
1150            // No op
1151            return mom;
1152        }
1153
1154        if (typeof value === 'string') {
1155            if (/^\d+$/.test(value)) {
1156                value = toInt(value);
1157            } else {
1158                value = mom.localeData().monthsParse(value);
1159                // TODO: Another silent failure?
1160                if (!isNumber(value)) {
1161                    return mom;
1162                }
1163            }
1164        }
1165
1166        dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
1167        mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
1168        return mom;
1169    }
1170
1171    function getSetMonth (value) {
1172        if (value != null) {
1173            setMonth(this, value);
1174            hooks.updateOffset(this, true);
1175            return this;
1176        } else {
1177            return get(this, 'Month');
1178        }
1179    }
1180
1181    function getDaysInMonth () {
1182        return daysInMonth(this.year(), this.month());
1183    }
1184
1185    var defaultMonthsShortRegex = matchWord;
1186    function monthsShortRegex (isStrict) {
1187        if (this._monthsParseExact) {
1188            if (!hasOwnProp(this, '_monthsRegex')) {
1189                computeMonthsParse.call(this);
1190            }
1191            if (isStrict) {
1192                return this._monthsShortStrictRegex;
1193            } else {
1194                return this._monthsShortRegex;
1195            }
1196        } else {
1197            if (!hasOwnProp(this, '_monthsShortRegex')) {
1198                this._monthsShortRegex = defaultMonthsShortRegex;
1199            }
1200            return this._monthsShortStrictRegex && isStrict ?
1201                this._monthsShortStrictRegex : this._monthsShortRegex;
1202        }
1203    }
1204
1205    var defaultMonthsRegex = matchWord;
1206    function monthsRegex (isStrict) {
1207        if (this._monthsParseExact) {
1208            if (!hasOwnProp(this, '_monthsRegex')) {
1209                computeMonthsParse.call(this);
1210            }
1211            if (isStrict) {
1212                return this._monthsStrictRegex;
1213            } else {
1214                return this._monthsRegex;
1215            }
1216        } else {
1217            if (!hasOwnProp(this, '_monthsRegex')) {
1218                this._monthsRegex = defaultMonthsRegex;
1219            }
1220            return this._monthsStrictRegex && isStrict ?
1221                this._monthsStrictRegex : this._monthsRegex;
1222        }
1223    }
1224
1225    function computeMonthsParse () {
1226        function cmpLenRev(a, b) {
1227            return b.length - a.length;
1228        }
1229
1230        var shortPieces = [], longPieces = [], mixedPieces = [],
1231            i, mom;
1232        for (i = 0; i < 12; i++) {
1233            // make the regex if we don't have it already
1234            mom = createUTC([2000, i]);
1235            shortPieces.push(this.monthsShort(mom, ''));
1236            longPieces.push(this.months(mom, ''));
1237            mixedPieces.push(this.months(mom, ''));
1238            mixedPieces.push(this.monthsShort(mom, ''));
1239        }
1240        // Sorting makes sure if one month (or abbr) is a prefix of another it
1241        // will match the longer piece.
1242        shortPieces.sort(cmpLenRev);
1243        longPieces.sort(cmpLenRev);
1244        mixedPieces.sort(cmpLenRev);
1245        for (i = 0; i < 12; i++) {
1246            shortPieces[i] = regexEscape(shortPieces[i]);
1247            longPieces[i] = regexEscape(longPieces[i]);
1248        }
1249        for (i = 0; i < 24; i++) {
1250            mixedPieces[i] = regexEscape(mixedPieces[i]);
1251        }
1252
1253        this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
1254        this._monthsShortRegex = this._monthsRegex;
1255        this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
1256        this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
1257    }
1258
1259    function createDate (y, m, d, h, M, s, ms) {
1260        // can't just apply() to create a date:
1261        // https://stackoverflow.com/q/181348
1262        var date

1262 = new Date(y, m, d, h, M, s, ms);
1263
1264        // the date constructor remaps years 0-99 to 1900-1999
1265        if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {
1266            date.setFullYear(y);
1267        }
1268        return date;
1269    }
1270
1271    function createUTCDate (y) {
1272        var date = new Date(Date.UTC.apply(null, arguments));
1273
1274        // the Date.UTC function remaps years 0-99 to 1900-1999
1275        if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {
1276            date.setUTCFullYear(y);
1277        }
1278        return date;
1279    }
1280
1281    // start-of-first-week - start-of-year
1282    function firstWeekOffset(year, dow, doy) {
1283        var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
1284            fwd = 7 + dow - doy,
1285            // first-week day local weekday -- which local weekday is fwd
1286            fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
1287
1288        return -fwdlw + fwd - 1;
1289    }
1290
1291    // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
1292    function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
1293        var localWeekday = (7 + weekday - dow) % 7,
1294            weekOffset = firstWeekOffset(year, dow, doy),
1295            dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
1296            resYear, resDayOfYear;
1297
1298        if (dayOfYear <= 0) {
1299            resYear = year - 1;
1300            resDayOfYear = daysInYear(resYear) + dayOfYear;
1301        } else if (dayOfYear > daysInYear(year)) {
1302            resYear = year + 1;
1303            resDayOfYear = dayOfYear - daysInYear(year);
1304        } else {
1305            resYear = year;
1306            resDayOfYear = dayOfYear;
1307        }
1308
1309        return {
1310            year: resYear,
1311            dayOfYear: resDayOfYear
1312        };
1313    }
1314
1315    function weekOfYear(mom, dow, doy) {
1316        var weekOffset = firstWeekOffset(mom.year(), dow, doy),
1317            week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
1318            resWeek, resYear;
1319
1320        if (week < 1) {
1321            resYear = mom.year() - 1;
1322            resWeek = week + weeksInYear(resYear, dow, doy);
1323        } else if (week > weeksInYear(mom.year(), dow, doy)) {
1324            resWeek = week - weeksInYear(mom.year(), dow, doy);
1325            resYear = mom.year() + 1;
1326        } else {
1327            resYear = mom.year();
1328            resWeek = week;
1329        }
1330
1331        return {
1332            week: resWeek,
1333            year: resYear
1334        };
1335    }
1336
1337    function weeksInYear(year, dow, doy) {
1338        var weekOffset = firstWeekOffset(year, dow, doy),
1339            weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
1340        return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
1341    }
1342
1343    // FORMATTING
1344
1345    addFormatToken('w', ['ww', 2], 'wo', 'week');
1346    addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
1347
1348    // ALIASES
1349
1350    addUnitAlias('week', 'w');
1351    addUnitAlias('isoWeek', 'W');
1352
1353    // PRIORITIES
1354
1355    addUnitPriority('week', 5);
1356    addUnitPriority('isoWeek', 5);
1357
1358    // PARSING
1359
1360    addRegexToken('w',  match1to2);
1361    addRegexToken('ww', match1to2, match2);
1362    addRegexToken('W',  match1to2);
1363    addRegexToken('WW', match1to2, match2);
1364

1365    addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
1366        week[token.substr(0, 1)] = toInt(input);
1367    });
1368
1369    // HELPERS
1370
1371    // LOCALES
1372
1373    function localeWeek (mom) {
1374        return weekOfYear(mom, this._week.dow, this._week.doy).week;
1375    }
1376
1377    var defaultLocaleWeek = {
1378        dow : 0, // Sunday is the first day of the week.
1379        doy : 6  // The week that contains Jan 1st is the first week of the year.
1380    };
1381
1382    function localeFirstDayOfWeek () {
1383        return this._week.dow;
1384    }
1385
1386    function localeFirstDayOfYear () {
1387        return this._week.doy;
1388    }
1389
1390    // MOMENTS
1391
1392    function getSetWeek (input) {
1393        var week = this.localeData().week(this);
1394        return input == null ? week : this.add((input - week) * 7, 'd');
1395    }
1396
1397    function getSetISOWeek (input) {
1398        var week = weekOfYear(this, 1, 4).week;
1399        return input == null ? week : this.add((input - week) * 7, 'd');
1400    }
1401
1402    // FORMATTING
1403
1404    addFormatToken('d', 0, 'do', 'day');
1405
1406    addFormatToken('dd', 0, 0, function (format) {
1407        return this.localeData().weekdaysMin(this, format);
1408    });
1409
1410    addFormatToken('ddd', 0, 0, function (format) {
1411        return this.localeData().weekdaysShort(this, format);
1412    });
1413
1414    addFormatToken('dddd', 0, 0, function (format) {
1415        return this.localeData().weekdays(this, format);
1416    });
1417
1418    addFormatToken('e', 0, 0, 'weekday');
1419    addFormatToken('E', 0, 0, 'isoWeekday');
1420
1421    // ALIASES
1422
1423    addUnitAlias('day', 'd');
1424    addUnitAlias('weekday', 'e');
1425    addUnitAlias('isoWeekday', 'E');
1426
1427    // PRIORITY
1428    addUnitPriority('day', 11);
1429    addUnitPriority('weekday', 11);
1430    addUnitPriority('isoWeekday', 11);
1431
1432    // PARSING
1433
1434    addRegexToken('d',    match1to2);
1435    addRegexToken('e',    match1to2);
1436    addRegexToken('E',    match1to2);
1437    addRegexToken('dd',   function (isStrict, locale) {
1438        return locale.weekdaysMinRegex(isStrict);
1439    });
1440    addRegexToken('ddd',   function (isStrict, locale) {
1441        return locale.weekdaysShortRegex(isStrict);
1442    });
1443    addRegexToken('dddd',   function (isStrict, locale) {
1444        return locale.weekdaysRegex(isStrict);
1445    });
1446
1447    addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
1448        var weekday = config._locale.weekdaysParse(input, token, config._strict);
1449        // if we didn't get a weekday name, mark the date as invalid
1450        if (weekday != null) {
1451            week.d = weekday;
1452        } else {
1453            getParsingFlags(config).invalidWeekday = input;
1454        }
1455    });
1456
1457    addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
1458        week[token] = toInt(input);
1459    });
1460
1461    // HELPERS
1462
1463    function parseWeekday(input, locale) {
1464        if (typeof input !== 'string') {
1465            return input;
1466        }
1467
1468        if (!isNaN(input)) {
1469            return parseInt(input, 10);
1470        }
1471
1472        input = locale.weekdaysParse(input);
1473        if (typeof input === 'number') {
1474            return input;
1475        }
1476
1477        return null;
1478    }
1479
1480    function parseIsoWeekday(input, locale) {
1481        if (typeof input === 'string') {
1482            return locale.weekdaysParse(input) % 7 || 7;
1483        }
1484        return isNaN(input) ? null : input;
1485    }
1486
1487    // LOCALES
1488
1489    var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
1490    function localeWeekdays (m, format) {
1491        if (!m) {
1492            return isArray(this._weekdays) ? this._weekdays :
1493                this._weekdays['standalone'];
1494        }
1495        return isArray(this._weekdays) ? this._weekdays[m.day()] :
1496            this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()];
1497    }
1498
1499    var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
1500    function localeWeekdaysShort (m) {
1501        return (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;
1502    }
1503
1504    var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
1505    function localeWeekdaysMin (m) {
1506        return (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;
1507    }
1508
1509    function handleStrictParse$1(weekdayName, format, strict) {
1510        var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
1511        if (!this._weekdaysParse) {
1512            this._weekdaysParse = [];
1513            this._shortWeekdaysParse = [];
1514            this._minWeekdaysParse = [];
1515
1516            for (i = 0; i < 7; ++i) {
1517                mom = createUTC([2000, 1]).day(i);
1518                this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();
1519                this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();
1520                this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
1521            }
1522        }
1523
1524        if (strict) {
1525            if (format === 'dddd') {
1526                ii = indexOf.call(this._weekdaysParse, llc);
1527                return ii !== -1 ? ii : null;
1528            } else if (format === 'ddd') {
1529                ii = indexOf.call(this._shortWeekdaysParse, llc);
1530                return ii !== -1 ? ii : null;
1531            } else {
1532                ii = indexOf.call(this._minWeekdaysParse, llc);
1533                return ii !== -1 ? ii : null;
1534            }
1535        } else {
1536            if (format === 'dddd') {
1537                ii = indexOf.call(this._weekdaysParse, llc);
1538                if (ii !== -1) {
1539                    return ii;
1540                }
1541                ii = indexOf.call(this._shortWeekdaysParse, llc);
1542                if (ii !== -1) {
1543                    return ii;
1544                }
1545                ii = indexOf.call(this._minWeekdaysParse, llc);
1546                return ii !== -1 ? ii : null;
1547            } else if (format === 'ddd') {
1548                ii = indexOf.call(this._shortWeekdaysParse, llc);
1549                if (ii !== -1) {
1550                    return ii;
1551                }
1552                ii = indexOf.call(this._weekdaysParse, llc);
1553                if (ii !== -1) {
1554                    return ii;
1555                }
1556                ii = indexOf.call(this._minWeekdaysParse, llc);
1557                return ii !== -1 ? ii : null;
1558            } else {
1559                ii = indexOf.call(this._minWeekdaysParse, llc);
1560                if (ii !== -1) {
1561                    return ii;
1562                }
1563                ii = indexOf.call(this._weekdaysParse, llc);
1564                if (ii !== -1) {
1565                    return ii;
1566                }
1567                ii = indexOf.call(this._shortWeekdaysParse, llc);
1568                return ii !== -1 ? ii : null;
1569            }
1570        }
1571    }
1572
1573    function localeWeekdaysParse (weekdayName, format, strict) {
1574        var i, mom, regex;
1575
1576        if (this._weekdaysParseExact) {
1577            return handleStrictParse$1.call(this, weekdayName, format, strict);
1578        }
1579
1580        if (!this._weekdaysParse) {
1581            this._weekdaysParse = [];
1582            this._minWeekdaysParse = [];
1583            this._shortWeekdaysParse = [];
1584            this._fullWeekdaysParse = [];
1585        }
1586
1587        for (i = 0; i < 7; i++) {
1588            // make the regex if we don't have it already
1589
1590            mom = createUTC([2000, 1]).day(i);
1591            if (strict && !this._fullWeekdaysParse[i]) {
1592                this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\\.?') + '$', 'i');
1593                this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\\.?') + '$', 'i');
1594                this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\\.?') + '$', 'i');
1595            }
1596            if (!this._weekdaysParse[i]) {
1597                regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
1598                this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
1599            }
1600            // test the regex
1601            if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {
1602                return i;
1603            } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {
1604                return i;
1605            } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {
1606                return i;
1607            } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
1608                return i;
1609            }
1610        }
1611    }
1612
1613    // MOMENTS
1614
1615    function getSetDayOfWeek (input) {
1616        if (!this.isValid()) {
1617            return input != null ? this : NaN;
1618        }
1619        var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
1620        if (input != null) {
1621            input = parseWeekday(input, this.localeData());
1622            return this.add(input - day, 'd');
1623        } else {
1624            return day;
1625        }
1626    }
1627
1628    function getSetLocaleDayOfWeek (input) {
1629        if (!this.isValid()) {
1630            return input != null ? this : NaN;
1631        }
1632        var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
1633        return input == null ? weekday : this.add(input - weekday, 'd');
1634    }
1635
1636    function getSetISODayOfWeek (input) {
1637        if (!this.isValid()) {
1638            return input != null ? this : NaN;
1639        }
1640
1641        // behaves the same as moment#day except
1642        // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
1643        // as a setter, sunday should belong to the previous week.
1644
1645        if (input != null) {
1646            var weekday = parseIsoWeekday(input, this.localeData());
1647            return this.day(this.day() % 7 ? weekday : weekday - 7);
1648        } else {
1649            return this.day() || 7;
1650        }
1651    }
1652
1653    var defaultWeekdaysRegex = matchWord;
1654    function weekdaysRegex (isStrict) {
1655        if (this._weekdaysParseExact) {
1656            if (!hasOwnProp(this, '_weekdaysRegex')) {
1657                computeWeekdaysParse.call(this);
1658            }
1659            if (isStrict) {
1660                return this._weekdaysStrictRegex;
1661            } else {
1662                return this._weekdaysRegex;
1663            }
1664        } else {
1665            if (!hasOwnProp(this, '_weekdaysRegex')) {
1666                this._weekdaysRegex = defaultWeekdaysRegex;
1667            }
1668            return this._weekdaysStrictRegex && isStrict ?
1669                this._weekdaysStrictRegex : this._weekdaysRegex;
1670        }
1671    }
1672
1673    var defaultWeekdaysShortRegex = matchWord;
1674    function weekdaysShortRegex (isStrict) {
1675        if (this._weekdaysParseExact) {
1676            if (!hasOwnProp(this, '_weekdaysRegex')) {
1677                computeWeekdaysParse.call(this);
1678            }
1679            if (isStrict) {
1680                return this._weekdaysShortStrictRegex;
1681            } else {
1682                return this._weekdaysShortRegex;
1683            }
1684        } else {
1685            if (!hasOwnProp(this, '_weekdaysShortRegex')) {
1686                this._weekdaysShortRegex = defaultWeekdaysShortRegex;
1687            }
1688            return this._weekdaysShortStrictRegex && isStrict ?
1689                this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
1690        }
1691    }
1692
1693    var defaultWeekdaysMinRegex = matchWord;
1694    function weekdaysMinRegex (isStrict) {
1695        if (this._weekdaysParseExact) {
1696            if (!hasOwnProp(this, '_weekdaysRegex')) {
1697                computeWeekdaysParse.call(this);
1698            }
1699            if (isStrict) {
1700                return this._weekdaysMinStrictRegex;
1701            } else {
1702                return this._weekdaysMinRegex;
1703            }
1704        } else {
1705            if (!hasOwnProp(this, '_weekdaysMinRegex')) {
1706                this._weekdaysMinRegex = defaultWeekdaysMinRegex;
1707            }
1708            return this._weekdaysMinStrictRegex && isStrict ?
1709                this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
1710        }
1711    }
1712
1713
1714    function computeWeekdaysParse () {
1715        function cmpLenRev(a, b) {
1716            return b.length - a.length;
1717        }
1718
1719        var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [],
1720            i, mom, minp, shortp, longp;
1721        for (i = 0; i < 7; i++) {
1722            // make the regex if we don't have it already
1723            mom = createUTC([2000, 1]).day(i);
1724            minp = this.weekdaysMin(mom, '');
1725            shortp = this.weekdaysShort(mom, '');
1726            longp = this.weekdays(mom, '');
1727            minPieces.push(minp);
1728            shortPieces.push(shortp);
1729            longPieces.push(longp);
1730            mixedPieces.push(minp);
1731            mixedPieces.push(shortp);
1732            mixedPieces.push(longp);
1733        }
1734        // Sorting makes sure if one weekday (or abbr) is a prefix of another it
1735        // will match the longer piece.
1736        minPieces.sort(cmpLenRev);
1737        shortPieces.sort(cmpLenRev);
1738        longPieces.sort(cmpLenRev);
1739        mixedPieces.sort(cmpLenRev);
1740        for (i = 0; i < 7; i++) {
1741            shortPieces[i] = regexEscape(shortPieces[i]);
1742            longPieces[i] = regexEscape(longPieces[i]);
1743            mixedPieces[i] = regexEscape(mixedPieces[i]);
1744        }
1745
1746        this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
1747        this._weekdaysShortRegex = this._weekdaysRegex;
1748        this._weekdaysMinRegex = this._weekdaysRegex;
1749
1750        this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
1751        this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
1752        this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');
1753    }
1754
1755    // FORMATTING
1756
1757    function hFormat() {
1758        return this.hours() % 12 || 12;
1759    }
1760
1761    function kFormat() {
1762        return this.hours() || 24;
1763    }
1764
1765    addFormatToken('H', ['HH', 2], 0, 'hour');
1766    addFormatToken('h', ['hh', 2], 0, hFormat);
1767    addFormatToken('k', ['kk', 2], 0, kFormat);
1768
1769    addFormatToken('hmm', 0, 0, function () {
1770        return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
1771    });
1772
1773    addFormatToken('hmmss', 0, 0, function () {
1774        return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +
1775            zeroFill(this.seconds(), 2);
1776    });
1777
1778    addFormatToken('Hmm', 0, 0, function () {
1779        return '' + this.hours() + zeroFill(this.minutes(), 2);
1780    });
1781
1782    addFormatToken('Hmmss', 0, 0, function () {
1783        return '' + this.hours() + zeroFill(this.minutes(), 2) +
1784            zeroFill(this.seconds(), 2);
1785    });
1786
1787    function meridiem (token, lowercase) {
1788        addFormatToken(token, 0, 0, function () {
1789            return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
1790        });
1791    }
1792
1793    meridiem('a', true);
1794    meridiem('A', false);
1795
1796    // ALIASES
1797
1798    addUnitAlias('hour', 'h');
1799
1800    // PRIORITY
1801    addUnitPriority('hour', 13);
1802
1803    // PARSING
1804
1805    function matchMeridiem (isStrict, locale) {
1806        return locale._meridiemParse;
1807    }
1808
1809    addRegexToken('a',  matchMeridiem);
1810    addRegexToken('A',  matchMeridiem);
1811    addRegexToken('H',  match1to2);
1812    addRegexToken('h',  match1to2);
1813    addRegexToken('k',  match1to2);
1814    addRegexToken('HH', match1to2, match2);
1815    addRegexToken('hh', match1to2, match2);
1816    addRegexToken('kk', match1to2, match2);
1817
1818    addRegexToken('hmm', match3to4);
1819    addRegexToken('hmmss', match5to6);
1820    addRegexToken('Hmm', match3to4);
1821    addRegexToken('Hmmss', match5to6);
1822
1823    addParseToken(['H', 'HH'], HOUR);
1824    addParseToken(['k', 'kk'], function (input, array, config) {
1825        var kInput = toInt(input);
1826        array[HOUR] = kInput === 24 ? 0 : kInput;
1827    });
1828    addParseToken(['a', 'A'], function (input, array, config) {
1829        config._isPm = config._locale.isPM(input);
1830        config._meridiem = input;
1831    });
1832    addParseToken(['h', 'hh'], function (input, array, config) {
1833        array[HOUR] = toInt(input);
1834        getParsingFlags(config).bigHour = true;
1835    });
1836    addParseToken('hmm', function (input, array, config) {
1837        var pos = input.length - 2;
1838        array[HOUR] = toInt(input.substr(0, pos));
1839        array[MINUTE] = toInt(input.substr(pos));
1840        getParsingFlags(config).bigHour = true;
1841    });
1842    addParseToken('hmmss', function (input, array, config) {
1843        var pos1 = input.length - 4;
1844        var pos2 = input.length - 2;
1845        array[HOUR] = toInt(input.substr(0, pos1));
1846        array[MINUTE] = toInt(input.substr(pos1, 2));
1847        array[SECOND] = toInt(input

1847.substr(pos2));
1848        getParsingFlags(config).bigHour = true;
1849    });
1850    addParseToken('Hmm', function (input, array, config) {
1851        var pos = input.length - 2;
1852        array[HOUR] = toInt(input.substr(0, pos));
1853        array[MINUTE] = toInt(input.substr(pos));
1854    });
1855    addParseToken('Hmmss', function (input, array, config) {
1856        var pos1 = input.length - 4;
1857        var pos2 = input.length - 2;
1858        array[HOUR] = toInt(input.substr(0, pos1));
1859        array[MINUTE] = toInt(input.substr(pos1, 2));
1860        array[SECOND] = toInt(input.substr(pos2));
1861    });
1862
1863    // LOCALES
1864
1865    function localeIsPM (input) {
1866        // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
1867        // Using charAt should be more compatible.
1868        return ((input + '').toLowerCase().charAt(0) === 'p');
1869    }
1870
1871    var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
1872    function localeMeridiem (hours, minutes, isLower) {
1873        if (hours > 11) {
1874            return isLower ? 'pm' : 'PM';
1875        } else {
1876            return isLower ? 'am' : 'AM';
1877        }
1878    }
1879
1880
1881    // MOMENTS
1882
1883    // Setting the hour should keep the time, because the user explicitly
1884    // specified which hour they want. So trying to maintain the same hour (in
1885    // a new timezone) makes sense. Adding/subtracting hours does not follow
1886    // this rule.
1887    var getSetHour = makeGetSet('Hours', true);
1888
1889    var baseConfig = {
1890        calendar: defaultCalendar,
1891        longDateFormat: defaultLongDateFormat,
1892        invalidDate: defaultInvalidDate,
1893        ordinal: defaultOrdinal,
1894        dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
1895        relativeTime: defaultRelativeTime,
1896
1897        months: defaultLocaleMonths,
1898        monthsShort: defaultLocaleMonthsShort,
1899
1900        week: defaultLocaleWeek,
1901
1902        weekdays: defaultLocaleWeekdays,
1903        weekdaysMin: defaultLocaleWeekdaysMin,
1904        weekdaysShort: defaultLocaleWeekdaysShort,
1905
1906        meridiemParse: defaultLocaleMeridiemParse
1907    };
1908
1909    // internal storage for locale config files
1910    var locales = {};
1911    var localeFamilies = {};
1912    var globalLocale;
1913
1914    function normalizeLocale(key) {
1915        return key ? key.toLowerCase().replace('_', '-') : key;
1916    }
1917
1918    // pick the locale from the array
1919    // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
1920    // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
1921    function chooseLocale(names) {
1922        var i = 0, j, next, locale, split;
1923
1924        while (i < names.length) {
1925            split = normalizeLocale(names[i]).split('-');
1926            j = split.length;
1927            next = normalizeLocale(names[i + 1]);
1928            next = next ? next.split('-') : null;
1929            while (j > 0) {
1930                locale = loadLocale(split.slice(0, j).join('-'));
1931                if (locale) {
1932                    return locale;
1933                }
1934                if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
1935                    //the next array item is better than a shallower substring of this one
1936                    break;
1937                }
1938                j--;
1939            }
1940            i++;
1941        }
1942        return globalLocale;
1943    }
1944
1945    function loadLocale(name) {
1946        var oldLocale = null;
1947        // TODO: Find a better way to register and load all the locales in Node
1948        if (!locales[name] && (typeof module !== 'undefined') &&
1949                module && module.exports) {
1950            try {
1951                oldLocale = globalLocale._abbr;
1952                var aliasedRequire = require;
1953                __webpack_require__(566)("./" + name);
1954                getSetGlobalLocale(oldLocale);
1955            } catch (e) {}
1956        }
1957        return locales[name];
1958    }
1959
1960    // This function will load locale and then set the global locale.  If
1961    // no arguments are passed in, it will simply return the current global
1962    // locale key.
1963    function getSetGlobalLocale (key, values) {
1964        var data;
1965        if (key) {
1966            if (isUndefined(values)) {
1967                data = getLocale(key);
1968            }
1969            else {
1970                data = defineLocale(key, values);
1971            }
1972
1973            if (data) {
1974                // moment.duration._locale = moment._locale = data;
1975                globalLocale = data;
1976            }
1977            else {
1978                if ((typeof console !==  'undefined') && console.warn) {
1979                    //warn user if arguments are passed but the locale could not be set
1980                    console.warn('Locale ' + key +  ' not found. Did you forget to load it?');
1981                }
1982            }
1983        }
1984
1985        return globalLocale._abbr;
1986    }
1987
1988    function defineLocale (name, config) {
1989        if (config !== null) {
1990            var locale, parentConfig = baseConfig;
1991            config.abbr = name;
1992            if (locales[name] != null) {
1993                deprecateSimple('defineLocaleOverride',
1994                        'use moment.updateLocale(localeName, config) to change ' +
1995                        'an existing locale. moment.defineLocale(localeName, ' +
1996                        'config) should only be used for creating a new locale ' +
1997                        'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');
1998                parentConfig = locales[name]._config;
1999            } else if (config.parentLocale != null) {
2000                if (locales[config.parentLocale] != null) {
2001                    parentConfig = locales[config.parentLocale]._config;
2002                } else {
2003                    locale = loadLocale(config.parentLocale);
2004                    if (locale != null) {
2005                        parentConfig = locale._config;
2006                    } else {
2007                        if (!localeFamilies[config.parentLocale]) {
2008                            localeFamilies[config.parentLocale] = [];
2009                        }
2010                        localeFamilies[config.parentLocale].push({
2011                            name: name,
2012                            config: config
2013                        });
2014                        return null;
2015                    }
2016                }
2017            }
2018            locales[name] = new Locale(mergeConfigs(parentConfig, config));
2019
2020            if (localeFamilies[name]) {
2021                localeFamilies[name].forEach(function (x) {
2022                    defineLocale(x.name, x.config);
2023                });
2024            }
2025
2026            // backwards compat for now: also set the locale
2027            // make sure we set the locale AFTER all child locales have been
2028            // created, so we won't end up with the child locale set.
2029            getSetGlobalLocale(name);
2030
2031
2032            return locales[name];
2033        } else {
2034            // useful for testing
2035            delete locales[name];
2036            return null;
2037        }
2038    }
2039
2040    function updateLocale(name, config) {
2041        if (config != null) {
2042            var locale, tmpLocale, parentConfig = baseConfig;
2043            // MERGE
2044            tmpLocale = loadLocale(name);
2045            if (tmpLocale != null) {
2046                parentConfig = tmpLocale._config;
2047            }
2048            config = mergeConfigs(parentConfig, config);
2049            locale = new Locale(config);
2050            locale.parentLocale = locales[name];
2051            locales[name] = locale;
2052
2053            // backwards compat for now: also set the locale
2054            getSetGlobalLocale(name);
2055        } else {
2056            // pass null for config to unupdate, useful for tests
2057            if (locales[name] != null) {
2058                if (locales[name].parentLocale != null) {
2059                    locales[name] = locales[name].parentLocale;
2060                } else if (locales[name] != null) {
2061                    delete locales[name];
2062                }
2063            }
2064        }
2065        return locales[name];
2066    }
2067
2068    // returns locale data
2069    function getLocale (key) {
2070        var locale;
2071
2072        if (key && key._locale && key._locale._abbr) {
2073            key = key._locale._abbr;
2074        }
2075
2076        if (!key) {
2077            return globalLocale;
2078        }
2079
2080        if (!isArray(key)) {
2081            //short-circuit everything else
2082            locale = loadLocale(key);
2083            if (locale) {
2084                return locale;
2085            }
2086            key = [key];
2087        }
2088
2089        return chooseLocale(key);
2090    }
2091
2092    function listLocales() {
2093        return keys(locales);
2094    }
2095
2096    function checkOverflow (m) {
2097        var overflow;
2098        var a = m._a;
2099
2100        if (a && getParsingFlags(m).overflow === -2) {
2101            overflow =
2102                a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :
2103                a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
2104                a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
2105                a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :
2106                a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :
2107                a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
2108                -1;
2109
2110            if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
2111                overflow = DATE;
2112            }
2113            if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
2114                overflow = WEEK;
2115            }
2116            if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
2117                overflow = WEEKDAY;
2118            }
2119
2120            getParsingFlags(m).overflow = overflow;
2121        }
2122
2123        return m;
2124    }
2125
2126    // Pick the first defined of two or three arguments.
2127    function defaults(a, b, c) {
2128        if (a != null) {
2129            return a;
2130        }
2131        if (b != null) {
2132            return b;
2133        }
2134        return c;
2135    }
2136
2137    function currentDateArray(config) {
2138        // hooks is actually the exported moment object
2139        var nowValue = new Date(hooks.now());
2140        if (config._useUTC) {
2141            return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
2142        }
2143        return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
2144    }
2145
2146    // convert an array to a date.
2147    // the array should mirror the parameters below
2148    // note: all values past the year are optional and will default to the lowest possible value.
2149    // [year, month, day , hour, minute, second, millisecond]
2150    function configFromArray (config) {
2151        var i, date, input = [], currentDate, expectedWeekday, yearToUse;
2152
2153        if (config._d) {
2154            return;
2155        }
2156
2157        currentDate = currentDateArray(config);
2158
2159        //compute day of the year from weeks and weekdays
2160        if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
2161            dayOfYearFromWeekInfo(config);
2162        }
2163
2164        //if the day of the year is set, figure out what it is
2165        if (config._dayOfYear != null) {
2166            yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
2167
2168            if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {
2169                getParsingFlags(config)._overflowDayOfYear = true;
2170            }
2171
2172            date = createUTCDate(yearToUse, 0, config._dayOfYear);
2173            config._a[MONTH] = date.getUTCMonth();
2174            config._a[DATE] = date.getUTCDate();
2175        }
2176
2177        // Default to current date.
2178        // * if no year, month, day of month are given, default to today
2179        // * if day of month is given, default month and year
2180        // * if month is given, default only year
2181        // * if year is given, don't default anything
2182        for (i = 0; i < 3 && config._a[i] == null; ++i) {

2183            config._a[i] = input[i] = currentDate[i];
2184        }
2185
2186        // Zero out whatever was not defaulted, including time
2187        for (; i < 7; i++) {
2188            config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
2189        }
2190
2191        // Check for 24:00:00.000
2192        if (config._a[HOUR] === 24 &&
2193                config._a[MINUTE] === 0 &&
2194                config._a[SECOND] === 0 &&
2195                config._a[MILLISECOND] === 0) {
2196            config._nextDay = true;
2197            config._a[HOUR] = 0;
2198        }
2199
2200        config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
2201        expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay();
2202
2203        // Apply timezone offset from input. The actual utcOffset can be changed
2204        // with parseZone.
2205        if (config._tzm != null) {
2206            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
2207        }
2208
2209        if (config._nextDay) {
2210            config._a[HOUR] = 24;
2211        }
2212
2213        // check for mismatching day of week
2214        if (config._w && typeof config._w.d !== 'undefined' && config._w.d !== expectedWeekday) {
2215            getParsingFlags(config).weekdayMismatch = true;
2216        }
2217    }
2218
2219    function dayOfYearFromWeekInfo(config) {
2220        var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;
2221
2222        w = config._w;
2223        if (w.GG != null || w.W != null || w.E != null) {
2224            dow = 1;
2225            doy = 4;
2226
2227            // TODO: We need to take the current isoWeekYear, but that depends on
2228            // how we interpret now (local, utc, fixed offset). So create
2229            // a now version of current config (take local/utc/offset flags, and
2230            // create now).
2231            weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);
2232            week = defaults(w.W, 1);
2233            weekday = defaults(w.E, 1);
2234            if (weekday < 1 || weekday > 7) {
2235                weekdayOverflow = true;
2236            }
2237        } else {
2238            dow = config._locale._week.dow;
2239            doy = config._locale._week.doy;
2240
2241            var curWeek = weekOfYear(createLocal(), dow, doy);
2242
2243            weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
2244
2245            // Default to current week.
2246            week = defaults(w.w, curWeek.week);
2247
2248            if (w.d != null) {
2249                // weekday -- low day numbers are considered next week
2250                weekday = w.d;
2251                if (weekday < 0 || weekday > 6) {
2252                    weekdayOverflow = true;
2253                }
2254            } else if (w.e != null) {
2255                // local weekday -- counting starts from begining of week
2256                weekday = w.e + dow;
2257                if (w.e < 0 || w.e > 6) {
2258                    weekdayOverflow = true;
2259                }
2260            } else {
2261                // default to begi

2261ning of week
2262                weekday = dow;
2263            }
2264        }
2265        if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
2266            getParsingFlags(config)._overflowWeeks = true;
2267        } else if (weekdayOverflow != null) {
2268            getParsingFlags(config)._overflowWeekday = true;
2269        } else {
2270            temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
2271            config._a[YEAR] = temp.year;
2272            config._dayOfYear = temp.dayOfYear;
2273        }
2274    }
2275
2276    // iso 8601 regex
2277    // 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)
2278    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)?)?$/;
2279    var 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)?)?$/;
2280
2281    var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/;
2282
2283    var isoDates = [
2284        ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
2285        ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
2286        ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
2287        ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
2288        ['YYYY-DDD', /\d{4}-\d{3}/],
2289        ['YYYY-MM', /\d{4}-\d\d/, false],
2290        ['YYYYYYMMDD', /[+-]\d{10}/],
2291        ['YYYYMMDD', /\d{8}/],
2292        // YYYYMM is NOT allowed by the standard
2293        ['GGGG[W]WWE', /\d{4}W\d{3}/],
2294        ['GGGG[W]WW', /\d{4}W\d{2}/, false],
2295        ['YYYYDDD', /\d{7}/]
2296    ];
2297
2298    // iso time formats and regexes
2299    var isoTimes = [
2300        ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
2301        ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
2302        ['HH:mm:ss', /\d\d:\d\d:\d\d/],
2303        ['HH:mm', /\d\d:\d\d/],
2304        ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
2305        ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
2306        ['HHmmss', /\d\d\d\d\d\d/],
2307        ['HHmm', /\d\d\d\d/],
2308        ['HH', /\d\d/]
2309    ];
2310
2311    var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
2312
2313    // date from iso format
2314    function configFromISO(config) {
2315        var i, l,
2316            string = config._i,
2317            match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
2318            allowTime, dateFormat, timeFormat, tzFormat;
2319
2320        if (match) {
2321            getParsingFlags(config).iso = true;
2322
2323            for (i = 0, l = isoDates.length; i < l; i++) {
2324                if (isoDates[i][1].exec(match[1])) {
2325                    dateFormat = isoDates[i][0];
2326                    allowTime = isoDates[i][2] !== false;
2327                    break;
2328                }
2329            }
2330            if (dateFormat == null) {
2331                config._isValid = false;
2332                return;
2333            }
2334            if (match[3]) {
2335                for (i = 0, l = isoTimes.length; i < l; i++) {
2336                    if (isoTimes[i][1].exec(match[3])) {
2337                        // match[2] should be 'T' or space
2338                        timeFormat = (match[2] || ' ') + isoTimes[i][0];
2339                        break;
2340                    }
2341                }
2342                if (timeFormat == null) {
2343                    config._isValid = false;
2344                    return;
2345                }
2346            }
2347            if (!allowTime && timeFormat != null) {
2348                config._isValid = false;
2349                return;
2350            }
2351            if (match[4]) {
2352                if (tzRegex.exec(match[4])) {
2353                    tzFormat = 'Z';
2354                } else {
2355                    config._isValid = false;
2356                    return;
2357                }
2358            }
2359            config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
2360            configFromStringAndFormat(config);
2361        } else {
2362            config._isValid = false;
2363        }
2364    }
2365
2366    // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
2367    var 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}))$/;
2368
2369    function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {
2370        var result = [
2371            untruncateYear(yearStr),
2372            defaultLocaleMonthsShort.indexOf(monthStr),
2373            parseInt(dayStr, 10),
2374            parseInt(hourStr, 10),
2375            parseInt(minuteStr, 10)
2376        ];
2377
2378        if (secondStr) {
2379            result.push(parseInt(secondStr, 10));
2380        }
2381
2382        return result;
2383    }
2384
2385    function untruncateYear(yearStr) {
2386        var year = parseInt(yearStr, 10);
2387        if (year <= 49) {
2388            return 2000 + year;
2389        } else if (year <= 999) {
2390            return 1900 + year;
2391        }
2392        return year;
2393    }
2394
2395    function preprocessRFC2822(s) {
2396        // Remove comments and folding whitespace and replace multiple-spaces with a single space
2397        return s.replace(/\([^)]*\)|[\n\t]/g, ' ').replace(/(\s\s+)/g, ' ').replace(/^\s\s*/, '').replace(/\s\s*$/, '');
2398    }
2399
2400    function checkWeekday(weekdayStr, parsedInput, config) {
2401        if (weekdayStr) {
2402            // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.
2403            var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr),
2404                weekdayActual = new Date(parsedInput[0], parsedInput[1], parsedInput[2]).getDay();
2405            if (weekdayProvided !== weekdayActual) {
2406                getParsingFlags(config).weekdayMismatch = true;
2407                config._isValid = false;
2408                return false;
2409            }
2410        }
2411        return true;
2412    }
2413
2414    var obsOffsets = {
2415        UT: 0,
2416        GMT: 0,
2417        EDT: -4 * 60,
2418        EST: -5 * 60,
2419        CDT: -5 * 60,
2420        CST: -6 * 60,
2421        MDT: -6 * 60,
2422        MST: -7 * 60,
2423        PDT: -7 * 60,
2424        PST: -8 * 60
2425    };
2426
2427    function calculateOffset(obsOffset, militaryOffset, numOffset) {
2428        if (obsOffset) {
2429            return obsOffsets[obsOffset];
2430        } else if (militaryOffset) {
2431            // the only allowed military tz is Z
2432            return 0;
2433        } else {
2434            var hm = parseInt(numOffset, 10);
2435            var m = hm % 100, h = (hm - m) / 100;
2436            return h * 60 + m;
2437        }
2438    }
2439
2440    // date and time from ref 2822 format
2441    function configFromRFC2822(config) {
2442        var match = rfc2822.exec(preprocessRFC2822(config._i));
2443        if (match) {
2444            var parsedArray = extractFromRFC2822Strings(match[4], match[3], match[2], match[5], match[6], match[7]);
2445            if (!checkWeekday(match[1], parsedArray, config)) {
2446                return;
2447            }
2448
2449            config._a = parsedArray;
2450            config._tzm = calculateOffset(match[8], match[9], match[10]);
2451
2452            config._d = createUTCDate.apply(null, config._a);
2453            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
2454
2455            getParsingFlags(config).rfc2822 = true;
2456        } else {
2457            config._isValid = false;
2458        }
2459    }
2460
2461    // date from iso format or fallback
2462    function configFromString(config) {
2463        var matched = aspNetJsonRegex.exec(config._i);
2464
2465        if (matched !== null) {
2466            config._d = new Date(+matched[1]);
2467            return;
2468        }
2469
2470        configFromISO(config);
2471        if (config._isValid === false) {
2472            delete config._isValid;
2473        } else {
2474            return;
2475        }
2476
2477        configFromRFC2822(config);
2478        if (config._isValid === false) {
2479            delete config._isValid;
2480        } else {
2481            return;
2482        }
2483
2484        // Final attempt, use Input Fallback
2485        hooks.createFromInputFallback(config);
2486    }
2487
2488    hooks.createFromInputFallback = deprecate(
2489        'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
2490        'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +
2491        'discouraged and will be removed in an upcoming major release. Please refer to ' +
2492        'http://momentjs.com/guides/#/warnings/js-date/ for more info.',
2493        function (config) {
2494            config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
2495        }
2496    );
2497
2498    // constant that refers to the ISO standard
2499    hooks.ISO_8601 = function () {};
2500
2501    // constant that refers to the RFC 2822 form
2502    hooks.RFC_2822 = function () {};
2503
2504    // date from string and format string
2505    function configFromStringAndFormat(config) {
2506        // TODO: Move this to another part of the creation flow to prevent circular deps
2507        if (config._f === hooks.ISO_8601) {
2508            configFromISO(config);
2509            return;
2510        }
2511        if (config._f === hooks.RFC_2822) {
2512            configFromRFC2822(config);
2513            return;
2514        }
2515        config._a = [];
2516        getParsingFlags(config).empty = true;
2517
2518        // This array is used to make a Date, either with `new Date` or `Date.UTC`
2519        var string = '' + config._i,
2520            i, parsedInput, tokens, token, skipped,
2521            stringLength = string.length,
2522            totalParsedInputLength = 0;
2523
2524        tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
2525
2526        for (i = 0; i < tokens.length; i++) {
2527            token = tokens[i];
2528            parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
2529            // console.log('token', token, 'parsedInput', parsedInput,
2530            //         'regex', getParseRegexForToken(token, config));
2531            if (parsedInput) {
2532                skipped = string.substr(0, string.indexOf(parsedInput));
2533                if (skipped.length > 0) {
2534                    getParsingFlags(config).unusedInput.push(skipped);
2535                }
2536                string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
2537                totalParsedInputLength += parsedInput.length;
2538            }
2539            // don't parse if it's not a known token
2540            if (formatTokenFunctions[token]) {
2541                if (parsedInput) {
2542                    getParsingFlags(config).empty = false;
2543                }
2544                else {
2545                    getParsingFlags(config).unusedTokens.push(token);
2546                }
2547                addTimeToArrayFromToken(token, parsedInput, config);
2548            }
2549            else if (config._strict && !parsedInput) {
2550                getParsingFlags(config).unusedTokens.push(token);
2551            }
2552        }
2553
2554        // add remaining unparsed input length to the string
2555        getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
2556        if (string.length > 0) {
2557            getParsingFlags(config).unusedInput.push(string);
2558        }
2559
2560        // clear _12h flag if hour is <= 12
2561        if (config._a[HOUR] <= 12 &&
2562            getParsingFlags(config).bigHour === true &&
2563            config._a[HOUR] > 0) {
2564            getParsingFlags(config).bigHour = undefined;
2565        }
2566
2567        getParsingFlags(config).parsedDateParts = config._a.slice(0);
2568        getParsingFlags(config).meridiem = config._meridiem;
2569        // handle meridiem
2570        config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
2571
2572        configFromArray(config);
2573        checkOverflow(config);
2574    }
2575
2576
2577    function meridiemFixWrap (locale, hour, meridiem) {
2578        var isPm;
2579
2580        if (meridiem == null) {
2581            // nothing to do
2582            return hour;
2583        }
2584        if (locale.meridiemHour != null) {
2585            return locale.meridiemHour(hour, meridiem);
2586        } else if (locale.isPM != null) {
2587            // Fallback
2588            isPm = locale.isPM(meridiem);
2589            if (isPm && hour < 12) {
2590                hour += 12;
2591            }
2592            if (!isPm && hour === 12) {
2593                hour = 0;
2594            }
2595            return hour;
2596        } else {
2597            // this is not supposed to happen
2598            return hour;
2599        }
2600    }
2601
2602    // date from string and array of format strings
2603    function configFromStringAndArray(config) {
2604        var tempConfig,
2605            bestMoment,
2606
2607            scoreToBeat,
2608            i,
2609            currentScore;
2610
2611        if (config._f.length === 0) {
2612            getParsingFlags(config).invalidFormat = true;
2613            config._d = new Date(NaN);
2614            return;
2615        }
2616
2617        for (i = 0; i < config._f.length; i++) {
2618            currentScore = 0;
2619            tempConfig = copyConfig({}, config);
2620            if (config._useUTC != null) {
2621                tempConfig._useUTC = config._useUTC;
2622            }
2623            tempConfig._f = config._f[i];
2624            configFromStringAndFormat(tempConfig);
2625
2626            if (!isValid(tempConfig)) {
2627                continue;
2628            }
2629
2630            // if there is any input that was not parsed add a penalty for that format
2631            currentScore += getParsingFlags(tempConfig).charsLeftOver;
2632
2633            //or tokens
2634            currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
2635
2636            getParsingFlags(tempConfig).score = currentScore;
2637
2638            if (scoreToBeat == null || currentScore < scoreToBeat) {
2639                scoreToBeat = currentScore;
2640                bestMoment = tempConfig;
2641            }
2642        }
2643
2644        extend(config, bestMoment || tempConfig);
2645    }
2646
2647    function configFromObject(config) {
2648        if (config._d) {
2649            return;
2650        }
2651
2652        var i = normalizeObjectUnits(config._i);
2653        config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {
2654            return obj && parseInt(obj, 10);
2655        });
2656
2657        configFromArray(config);
2658    }
2659
2660    function createFromConfig (config) {
2661        var res = new Moment(checkOverflow(prepareConfig(config)));
2662        if (res._nextDay) {
2663            // Adding is smart enough around DST
2664            res.add(1, 'd');
2665            res._nextDay = undefined;
2666        }
2667
2668        return res;
2669    }
2670
2671    function prepareConfig (config) {
2672        var input = config._i,
2673            format = config._f;
2674
2675        config._locale = config._locale || getLocale(config._l);
2676
2677        if (input === null || (format === undefined && input === '')) {
2678            return createInvalid({nullInput: true});
2679        }
2680
2681        if (typeof input === 'string') {
2682            config._i = input = config._locale.preparse(input);
2683        }
2684
2685        if (isMoment(input)) {
2686            return new Moment(checkOverflow(input));
2687        } else if (isDate(input)) {
2688            config._d = input;
2689        } else if (isArray(format)) {
2690            configFromStringAndArray(config);
2691        } else if (format) {
2692            configFromStringAndFormat(config);
2693        }  else {
2694            configFromInput(config);
2695        }
2696
2697        if (!isValid(config)) {
2698            config._d = null;
2699        }
2700
2701        return config;
2702    }
2703
2704    function configFromInput(config) {
2705        var input = config._i;
2706        if (isUndefined(input)) {
2707            config._d = new Date(hooks.now());
2708        } else if (isDate(input)) {
2709            config._d = new Date(input.valueOf());
2710        } else if (typeof input === 'string') {
2711            configFromString(config);
2712        } else if (isArray(input)) {
2713            config._a = map(input.slice(0), function (obj) {
2714                return parseInt(obj, 10);
2715            });
2716            configFromArray(config);
2717        } else if (isObject(input)) {
2718            configFromObject(config);
2719        } else if (isNumber(input)) {
2720            // from milliseconds
2721            config._d = new Date(input);
2722        } else {
2723            hooks.createFromInputFallback(config);
2724        }
2725    }
2726
2727    function createLocalOrUTC (input, format, locale, strict, isUTC) {
2728        var c = {};
2729
2730        if (locale === true || locale === false) {
2731            strict = locale;
2732            locale = undefined;
2733        }
2734
2735        if ((isObject(input) && isObjectEmpty(input)) ||
2736                (isArray(input) && input.length === 0)) {
2737            input = undefined;
2738        }
2739        // object construction must be done this way.
2740        // https://github.com/moment/moment/issues/1423
2741        c._isAMomentObject = true;
2742        c._useUTC = c._isUTC = isUTC;
2743        c._l = locale;
2744        c._i = input;
2745        c._f = format;
2746        c._strict = strict;
2747
2748        return createFromConfig(c);
2749    }
2750
2751    function createLocal (input, format, locale, strict) {
2752        return createLocalOrUTC(input, format, locale, strict, false);
2753    }
2754
2755    var prototypeMin = deprecate(
2756        'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
2757        function () {
2758            var other = createLocal.apply(null, arguments);
2759            if (this.isValid() && other.isValid()) {
2760                return other < this ? this : other;
2761            } else {
2762                return createInvalid();
2763            }
2764        }
2765    );
2766
2767    var prototypeMax = deprecate(
2768        'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
2769        function () {
2770            var other = createLocal.apply(null, arguments);
2771            if (this.isValid() && other.isValid()) {
2772                return other > this ? this : other;
2773            } else {
2774                return createInvalid();
2775            }
2776        }
2777    );
2778
2779    // Pick a moment m from moments so that m[fn](other) is true for all
2780    // other. This relies on the function fn to be transitive.
2781    //
2782    // moments should either be an array of moment objects or an array, whose
2783    // first element is an array of moment objects.
2784    function pickBy(fn, moments) {
2785        var res, i;
2786        if (moments.length === 1 && isArray(moments[0])) {
2787            moments = moments[0];
2788        }
2789        if (!moments.length) {
2790            return createLocal();
2791        }
2792        res = moments[0];
2793        for (i = 1; i < moments.length; ++i) {
2794            if (!moments[i].isValid() || moments[i][fn](res)) {
2795                res = moments[i];
2796            }
2797        }
2798        return res;
2799    }
2800
2801    // TODO: Use [].sort instead?
2802    function min () {
2803        var args = [].slice.call(arguments, 0);
2804
2805        return pickBy('isBefore', args);
2806    }
2807
2808    function max () {
2809        var args = [].slice.call(arguments, 0);
2810
2811        return pickBy('isAfter', args);
2812    }
2813
2814    var now = function () {
2815        return Date.now ? Date.now() : +(new Date());
2816    };
2817
2818    var ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];
2819
2820    function isDurationValid(m) {
2821        for (var key in m) {
2822            if (!(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) {
2823                return false;
2824            }
2825        }
2826
2827        var unitHasDecimal = false;
2828        for (var i = 0; i < ordering.length; ++i) {
2829            if (m[ordering[i]]) {
2830                if (unitHasDecimal) {
2831                    return false; // only allow non-integers for smallest unit
2832                }
2833                if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
2834                    unitHasDecimal = true;
2835                }
2836            }
2837        }
2838
2839        return true;
2840    }
2841
2842    function isValid$1() {
2843        return this._isValid;
2844    }
2845
2846    function createInvalid$1() {
2847        return createDuration(NaN);
2848    }
2849
2850    function Duration (duration) {
2851        var normalizedInput = normalizeObjectUnits(duration),
2852            years = normalizedInput.year || 0,
2853            quarters = normalizedInput.quarter || 0,
2854            months = normalizedInput.month || 0,
2855            weeks = normalizedInput.week ||