https://www.icuregswe.org/Static/dist/js/app.min.js

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

1206 = new Date(y, m, d, h, M, s, ms);
1207
1208        // the date constructor remaps years 0-99 to 1900-1999
1209        if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {
1210            date.setFullYear(y);
1211        }
1212        return date;
1213    }
1214
1215    function createUTCDate(y) {
1216        var date = new Date(Date.UTC.apply(null, arguments));
1217
1218        // the Date.UTC function remaps years 0-99 to 1900-1999
1219        if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {
1220            date.setUTCFullYear(y);
1221        }
1222        return date;
1223    }
1224
1225    // start-of-first-week - start-of-year
1226    function firstWeekOffset(year, dow, doy) {
1227        var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
1228        fwd = 7 + dow - doy,
1229
1230        // first-week day local weekday -- which local weekday is fwd
1231        fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
1232
1233        return -fwdlw + fwd - 1;
1234    }
1235
1236    // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
1237    function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
1238        var localWeekday = (7 + weekday - dow) % 7,
1239            weekOffset = firstWeekOffset(year, dow, doy),
1240            dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
1241            resYear,
1242            resDayOfYear;
1243
1244        if (dayOfYear <= 0) {
1245            resYear = year - 1;
1246            resDayOfYear = daysInYear(resYear) + dayOfYear;
1247        } else if (dayOfYear > daysInYear(year)) {
1248            resYear = year + 1;
1249            resDayOfYear = dayOfYear - daysInYear(year);
1250        } else {
1251            resYear = year;
1252            resDayOfYear = dayOfYear;
1253        }
1254
1255        return {
1256            year: resYear,
1257            dayOfYear: resDayOfYear
1258        };
1259    }
1260
1261    function weekOfYear(mom, dow, doy) {
1262        var weekOffset = firstWeekOffset(mom.year(), dow, doy),
1263            week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
1264            resWeek,
1265            resYear;
1266
1267        if (week < 1) {
1268            resYear = mom.year() - 1;
1269            resWeek = week + weeksInYear(resYear, dow, doy);
1270        } else if (week > weeksInYear(mom.year(), dow, doy)) {
1271            resWeek = week - weeksInYear(mom.year(), dow, doy);
1272            resYear = mom.year() + 1;
1273        } else {
1274            resYear = mom.year();
1275            resWeek = week;
1276        }
1277
1278        return {
1279            week: resWeek,
1280            year: resYear
1281        };
1282    }
1283
1284    function weeksInYear(year, dow, doy) {
1285        var weekOffset = firstWeekOffset(year, dow, doy),
1286            weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
1287        return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
1288    }
1289
1290    // FORMATTING
1291
1292    addFormatToken('w', ['ww', 2], 'wo', 'week');
1293    addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
1294
1295    // ALIASES
1296
1297    addUnitAlias('week', 'w');
1298    addUnitAlias('isoWeek', 'W');
1299
1300    // PRIORITIES
1301
1302    addUnitPriority('week', 5);
1303    addUnitPriority('isoWeek', 5);
1304
1305    // PARSING
1306
1307    addRegexToken('w', match1to2);
1308    addRegexToken('ww', match1to2, match2);
1309    addRegexToken('W', match1to2);
1310    addRegexToken('WW', match1to2, match2);
1311

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

1797rsingFlags(config).bigHour = true;
1798    });
1799    addParseToken('Hmm', function (input, array, config) {
1800        var pos = input.length - 2;
1801        array[HOUR] = toInt(input.substr(0, pos));
1802        array[MINUTE] = toInt(input.substr(pos));
1803    });
1804    addParseToken('Hmmss', function (input, array, config) {
1805        var pos1 = input.length - 4;
1806        var pos2 = input.length - 2;
1807        array[HOUR] = toInt(input.substr(0, pos1));
1808        array[MINUTE] = toInt(input.substr(pos1, 2));
1809        array[SECOND] = toInt(input.substr(pos2));
1810    });
1811
1812    // LOCALES
1813
1814    function localeIsPM(input) {
1815        // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
1816        // Using charAt should be more compatible.
1817        return (input + '').toLowerCase().charAt(0) === 'p';
1818    }
1819
1820    var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
1821    function localeMeridiem(hours, minutes, isLower) {
1822        if (hours > 11) {
1823            return isLower ? 'pm' : 'PM';
1824        } else {
1825            return isLower ? 'am' : 'AM';
1826        }
1827    }
1828
1829    // MOMENTS
1830
1831    // Setting the hour should keep the time, because the user explicitly
1832    // specified which hour they want. So trying to maintain the same hour (in
1833    // a new timezone) makes sense. Adding/subtracting hours does not follow
1834    // this rule.
1835    var getSetHour = makeGetSet('Hours', true);
1836
1837    var baseConfig = {
1838        calendar: defaultCalendar,
1839        longDateFormat: defaultLongDateFormat,
1840        invalidDate: defaultInvalidDate,
1841        ordinal: defaultOrdinal,
1842        dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
1843        relativeTime: defaultRelativeTime,
1844
1845        months: defaultLocaleMonths,
1846        monthsShort: defaultLocaleMonthsShort,
1847
1848        week: defaultLocaleWeek,
1849
1850        weekdays: defaultLocaleWeekdays,
1851        weekdaysMin: defaultLocaleWeekdaysMin,
1852        weekdaysShort: defaultLocaleWeekdaysShort,
1853
1854        meridiemParse: defaultLocaleMeridiemParse
1855    };
1856
1857    // internal storage for locale config files
1858    var locales = {};
1859    var localeFamilies = {};
1860    var globalLocale;
1861
1862    function normalizeLocale(key) {
1863        return key ? key.toLowerCase().replace('_', '-') : key;
1864    }
1865
1866    // pick the locale from the array
1867    // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
1868    // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
1869    function chooseLocale(names) {
1870        var i = 0,
1871            j,
1872            next,
1873            locale,
1874            split;
1875
1876        while (i < names.length) {
1877            split = normalizeLocale(names[i]).split('-');
1878            j = split.length;
1879            next = normalizeLocale(names[i + 1]);
1880            next = next ? next.split('-') : null;
1881            while (j > 0) {
1882                locale = loadLocale(split.slice(0, j).join('-'));
1883                if (locale) {
1884                    return locale;
1885                }
1886                if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
1887                    //the next array item is better than a shallower substring of this one
1888                    break;
1889                }
1890                j--;
1891            }
1892            i++;
1893        }
1894        return globalLocale;
1895    }
1896
1897    function loadLocale(name) {
1898        var oldLocale = null;
1899        // TODO: Find a better way to register and load all the locales in Node
1900        if (!locales[name] && typeof module !== 'undefined' && module && module.exports) {
1901            try {
1902                oldLocale = globalLocale._abbr;
1903                var aliasedRequire = require;
1904                __webpack_require__(299)("./" + name);
1905                getSetGlobalLocale(oldLocale);
1906            } catch (e) {}
1907        }
1908        return locales[name];
1909    }
1910
1911    // This function will load locale and then set the global locale.  If
1912    // no arguments are passed in, it will simply return the current global
1913    // locale key.
1914    function getSetGlobalLocale(key, values) {
1915        var data;
1916        if (key) {
1917            if (isUndefined(values)) {
1918                data = getLocale(key);
1919            } else {
1920                data = defineLocale(key, values);
1921            }
1922
1923            if (data) {
1924                // moment.duration._locale = moment._locale = data;
1925                globalLocale = data;
1926            } else {
1927                if (typeof console !== 'undefined' && console.warn) {
1928                    //warn user if arguments are passed but the locale could not be set
1929                    console.warn('Locale ' + key + ' not found. Did you forget to load it?');
1930                }
1931            }
1932        }
1933
1934        return globalLocale._abbr;
1935    }
1936
1937    function defineLocale(name, config) {
1938        if (config !== null) {
1939            var locale,
1940                parentConfig = baseConfig;
1941            config.abbr = name;
1942            if (locales[name] != null) {
1943                deprecateSimple('defineLocaleOverride', 'use moment.updateLocale(localeName, config) to change ' + 'an existing locale. moment.defineLocale(localeName, ' + 'config) should only be used for creating a new locale ' + 'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');
1944                parentConfig = locales[name]._config;
1945            } else if (config.parentLocale != null) {
1946                if (locales[config.parentLocale] != null) {
1947                    parentConfig = locales[config.parentLocale]._config;
1948                } else {
1949                    locale = loadLocale(config.parentLocale);
1950                    if (locale != null) {
1951                        parentConfig = locale._config;
1952                    } else {
1953                        if (!localeFamilies[config.parentLocale]) {
1954                            localeFamilies[config.parentLocale] = [];
1955                        }
1956                        localeFamilies[config.parentLocale].push({
1957                            name: name,
1958                            config: config
1959                        });
1960                        return null;
1961                    }
1962                }
1963            }
1964            locales[name] = new Locale(mergeConfigs(parentConfig, config));
1965
1966            if (localeFamilies[name]) {
1967                localeFamilies[name].forEach(function (x) {
1968                    defineLocale(x.name, x.config);
1969                });
1970            }
1971
1972            // backwards compat for now: also set the locale
1973            // make sure we set the locale AFTER all child locales have been
1974            // created, so we won't end up with the child locale set.
1975            getSetGlobalLocale(name);
1976
1977            return locales[name];
1978        } else {
1979            // useful for testing
1980            delete locales[name];
1981            return null;
1982        }
1983    }
1984
1985    function updateLocale(name, config) {
1986        if (config != null) {
1987            var locale,
1988                tmpLocale,
1989                parentConfig = baseConfig;
1990            // MERGE
1991            tmpLocale = loadLocale(name);
1992            if (tmpLocale != null) {
1993                parentConfig = tmpLocale._config;
1994            }
1995            config = mergeConfigs(parentConfig, config);
1996            locale = new Locale(config);
1997            locale.parentLocale = locales[name];
1998            locales[name] = locale;
1999
2000            // backwards compat for now: also set the locale
2001            getSetGlobalLocale(name);
2002        } else {
2003            // pass null for config to unupdate, useful for tests
2004            if (locales[name] != null) {
2005                if (locales[name].parentLocale != null) {
2006                    locales[name] = locales[name].parentLocale;
2007                } else if (locales[name] != null) {
2008                    delete locales[name];
2009                }
2010            }
2011        }
2012        return locales[name];
2013    }
2014
2015    // returns locale data
2016    function getLocale(key) {
2017        var locale;
2018
2019        if (key && key._locale && key._locale._abbr) {
2020            key = key._locale._abbr;
2021        }
2022
2023        if (!key) {
2024            return globalLocale;
2025        }
2026
2027        if (!isArray(key)) {
2028            //short-circuit everything else
2029            locale = loadLocale(key);
2030            if (locale) {
2031                return locale;
2032            }
2033            key = [key];
2034        }
2035
2036        return chooseLocale(key);
2037    }
2038
2039    function listLocales() {
2040        return keys(locales);
2041    }
2042
2043    function checkOverflow(m) {
2044        var overflow;
2045        var a = m._a;
2046
2047        if (a && getParsingFlags(m).overflow === -2) {
2048            overflow = a[MONTH] < 0 || a[MONTH] > 11 ? MONTH : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) ? DATE : a[HOUR] < 0 || a[HOUR] > 24 || a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0) ? HOUR : a[MINUTE] < 0 || a[MINUTE] > 59 ? MINUTE : a[SECOND] < 0 || a[SECOND] > 59 ? SECOND : a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND : -1;
2049
2050            if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
2051                overflow = DATE;
2052            }
2053            if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
2054                overflow = WEEK;
2055            }
2056            if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
2057                overflow = WEEKDAY;
2058            }
2059
2060            getParsingFlags(m).overflow = overflow;
2061        }
2062
2063        return m;
2064    }
2065
2066    // Pick the first defined of two or three arguments.
2067    function defaults(a, b, c) {
2068        if (a != null) {
2069            return a;
2070        }
2071        if (b != null) {
2072            return b;
2073        }
2074        return c;
2075    }
2076
2077    function currentDateArray(config) {
2078        // hooks is actually the exported moment object
2079        var nowValue = new Date(hooks.now());
2080        if (config._useUTC) {
2081            return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
2082        }
2083        return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
2084    }
2085
2086    // convert an array to a date.
2087    // the array should mirror the parameters below
2088    // note: all values past the year are optional and will default to the lowest possible value.
2089    // [year, month, day , hour, minute, second, millisecond]
2090    function configFromArray(config) {
2091        var i,
2092            date,
2093            input = [],
2094            currentDate,
2095            expectedWeekday,
2096            yearToUse;
2097
2098        if (config._d) {
2099            return;
2100        }
2101
2102        currentDate = currentDateArray(config);
2103
2104        //compute day of the year from weeks and weekdays
2105        if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
2106            dayOfYearFromWeekInfo(config);
2107        }
2108
2109        //if the day of the year is set, figure out what it is
2110        if (config._dayOfYear != null) {
2111            yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
2112
2113            if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {
2114                getParsingFlags(config)._overflowDayOfYear = true;
2115            }
2116
2117            date = createUTCDate(yearToUse, 0, config._dayOfYear);
2118            config._a[MONTH] = date.getUTCMonth();
2119            config._a[DATE] = date.getUTCDate();
2120        }
2121
2122        // Default to current date.
2123        // * if no year, month, day of month are given, default to today
2124        // * if day of month is given, default month and year
2125        // * if month is given, default only year
2126        // * if year is given, don't default anything
2127        for (i = 0; i < 3 && config._a[i] == null; ++i) {
2128            config._a[i] = input[i] = currentDate[i];
2129        }
2130
2131        // Zero out whatever was not defaulted, including time
2132        for (; i < 7; i++) {
2133            config._a[i] = input[i] = config._a[i] == null ? i === 2 ? 1 : 0 : config._a[i];
2134        }
2135
2136        // Check for 24:00:00.000
2137        if (config._a[HOUR] === 24 && config._a[MINUTE] === 0 && config._a[SECOND] === 0 && config._a[MILLISECOND] === 0) {
2138            config._nextDay = true;
2139            config._a[HOUR] = 0;
2140        }
2141
2142        config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
2143        expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay();
2144
2145        // Apply timezone offset from input. The actual utcOffset can be changed
2146        // with parseZone.
2147        if (config._tzm != null) {
2148            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
2149        }
2150
2151        if (config._nextDay) {
2152            config._a[HOUR] = 24;
2153        }
2154
2155        // check for mismatching day of week
2156        if (config._w && typeof config._w.d !== 'undefined' && config._w.d !== expectedWeekday) {
2157            getParsingFlags(config).weekdayMismatch = true;
2158        }
2159    }
2160
2161    function dayOfYearFromWeekInfo(config) {
2162        var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;
2163
2164        w = config._w;
2165        if (w.GG != null || w.W != null || w.E != null) {
2166            dow = 1;
2167            doy = 4;
2168
2169            // TODO: We need to take the current isoWeekYear, but that depends on
2170            // how we interpret now (local, utc, fixed offset). So create
2171            // a now version of current config (take local/utc/offset flags, and
2172            // create now).
2173            weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);
2174            week = defaults(w.W, 1);
2175            weekday = defaults(w.E, 1);
2176            if (weekday < 1 || weekday > 7) {
2177                weekdayOverflow = true;
2178            }
2179        } else {
2180            dow = config._locale._week.dow;
2181            doy = config._locale._week.doy;
2182
2183            var curWeek = weekOfYear(createLocal(), dow, doy);
2184
2185            weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
2186
2187            // Default to current week.
2188            week = defaults(w.w, curWeek.week);
2189
2190            if (w.d != null) {
2191                // weekday -- low day numbers are considered next week
2192                weekday = w.d;
2193                if (weekday < 0 || weekday > 6) {
2194                    weekdayOverflow = true;
2195                }
2196            } else if (w.e != null) {
2197                // local weekday -- counting starts from begining of week
2198                weekday = w.e + dow;
2199                if (w.e < 0 || w.e > 6) {
2200                    weekdayOverflow = true;
2201                }
2202            } else {
2203                // default to begining of week
2204                weekday = dow;
2205            }
2206        }
2207        if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
2208            getParsingFlags(config)._overflowWeeks = true;
2209        } else if (weekdayOverflow != null) {
2210            getParsingFlags(config)._overflowWeekday = true;
2211        } else {
2212            temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
2213            config._a[YEAR] = temp.year;
2214            config._dayOfYear = temp.dayOfYear;
2215        }
2216    }
2217
2218    // iso 8601 regex
2219    // 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)
2220    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)?)?$/;
2221    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)?)?$/;
2222
2223    var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/;
2224
2225    var isoDates = [['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/], ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/], ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/], ['GGGG-[W]WW', /\d{4}-W\d\d/, false], ['YYYY-DDD', /\d{4}-\d{3}/], ['YYYY-MM', /\d{4}-\d\d/, false], ['YYYYYYMMDD', /[+-]\d{10}/], ['YYYYMMDD', /\d{8}/],
2226    // YYYYMM is NOT allowed by the standard
2227    ['GGGG[W]WWE', /\d{4}W\d{3}/], ['GGGG[W]WW', /\d{4}W\d{2}/, false], ['YYYYDDD', /\d{7}/]];
2228
2229    // iso time formats and regexes
2230    var isoTimes = [['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/], ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/], ['HH:mm:ss', /\d\d:\d\d:\d\d/], ['HH:mm', /\d\d:\d\d/], ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/], ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/], ['HHmmss', /\d\d\d\d\d\d/], ['HHmm', /\d\d\d\d/], ['HH', /\d\d/]];
2231
2232    var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
2233
2234    // date from iso format
2235    function configFromISO(config) {
2236        var i,
2237            l,

2238            string = config._i,
2239            match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
2240            allowTime,
2241            dateFormat,
2242            timeFormat,
2243            tzFormat;
2244
2245        if (match) {
2246            getParsingFlags(config).iso = true;
2247
2248            for (i = 0, l = isoDates.length; i < l; i++) {
2249                if (isoDates[i][1].exec(match[1])) {
2250                    dateFormat = isoDates[i][0];
2251                    allowTime = isoDates[i][2] !== false;
2252                    break;
2253                }
2254            }
2255            if (dateFormat == null) {
2256                config._isValid = false;
2257                return;
2258            }
2259            if (match[3]) {
2260                for (i = 0, l = isoTimes.length; i < l; i++) {
2261                    if (isoTimes[i][1].exec(match[3])) {
2262                        // match[2] should be 'T' or space
2263                        timeFormat = (match[2] || ' ') + isoTimes[i][0];
2264                        break;
2265                    }
2266                }
2267                if (timeFormat == null) {
2268                    config._isValid = false;
2269                    return;
2270                }
2271            }
2272            if (!allowTime && timeFormat != null) {
2273                config._isValid = false;
2274                return;
2275            }
2276            if (match[4]) {
2277                if (tzRegex.exec(match[4])) {
2278                    tzFormat = 'Z';
2279                } else {
2280                    config._isValid = false;
2281                    return;
2282                }
2283            }
2284            config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
2285            configFromStringAndFormat(config);
2286        } else {
2287            config._isValid = false;
2288        }
2289    }
2290
2291    // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
2292    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}))$/;
2293
2294    function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {
2295        var result = [untruncateYear(yearStr), defaultLocaleMonthsShort.indexOf(monthStr), parseInt(dayStr, 10), parseInt(hourStr, 10), parseInt(minuteStr, 10)];
2296
2297        if (secondStr) {
2298            result.push(parseInt(secondStr, 10));
2299        }
2300
2301        return result;
2302    }
2303
2304    function untruncateYear(yearStr) {
2305        var year = parseInt(yearStr, 10);
2306        if (year <= 49) {
2307            return 2000 + year;
2308        } else if (year <= 999) {
2309            return 1900 + year;
2310        }
2311        return year;
2312    }
2313
2314    function preprocessRFC2822(s) {
2315        // Remove comments and folding whitespace and replace multiple-spaces with a single space
2316        return s.replace(/\([^)]*\)|[\n\t]/g, ' ').replace(/(\s\s+)/g, ' ').trim(

2316);
2317    }
2318
2319    function checkWeekday(weekdayStr, parsedInput, config) {
2320        if (weekdayStr) {
2321            // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.
2322            var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr),
2323                weekdayActual = new Date(parsedInput[0], parsedInput[1], parsedInput[2]).getDay();
2324            if (weekdayProvided !== weekdayActual) {
2325                getParsingFlags(config).weekdayMismatch = true;
2326                config._isValid = false;
2327                return false;
2328            }
2329        }
2330        return true;
2331    }
2332
2333    var obsOffsets = {
2334        UT: 0,
2335        GMT: 0,
2336        EDT: -4 * 60,
2337        EST: -5 * 60,
2338        CDT: -5 * 60,
2339        CST: -6 * 60,
2340        MDT: -6 * 60,
2341        MST: -7 * 60,
2342        PDT: -7 * 60,
2343        PST: -8 * 60
2344    };
2345
2346    function calculateOffset(obsOffset, militaryOffset, numOffset) {
2347        if (obsOffset) {
2348            return obsOffsets[obsOffset];
2349        } else if (militaryOffset) {
2350            // the only allowed military tz is Z
2351            return 0;
2352        } else {
2353            var hm = parseInt(numOffset, 10);
2354            var m = hm % 100,
2355                h = (hm - m) / 100;
2356            return h * 60 + m;
2357        }
2358    }
2359
2360    // date and time from ref 2822 format
2361    function configFromRFC2822(config) {
2362        var match = rfc2822.exec(preprocessRFC2822(config._i));
2363        if (match) {
2364            var parsedArray = extractFromRFC2822Strings(match[4], match[3], match[2], match[5], match[6], match[7]);
2365            if (!checkWeekday(match[1], parsedArray, config)) {
2366                return;
2367            }
2368
2369            config._a = parsedArray;
2370            config._tzm = calculateOffset(match[8], match[9], match[10]);
2371
2372            config._d = createUTCDate.apply(null, config._a);
2373            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
2374
2375            getParsingFlags(config).rfc2822 = true;
2376        } else {
2377            config._isValid = false;
2378        }
2379    }
2380
2381    // date from iso format or fallback
2382    function configFromString(config) {
2383        var matched = aspNetJsonRegex.exec(config._i);
2384
2385        if (matched !== null) {
2386            config._d = new Date(+matched[1]);
2387            return;
2388        }
2389
2390        configFromISO(config);
2391        if (config._isValid === false) {
2392            delete config._isValid;
2393        } else {
2394            return;
2395        }
2396
2397        configFromRFC2822(config);
2398        if (config._isValid === false) {
2399            delete config._isValid;
2400        } else {
2401            return;
2402        }
2403
2404        // Final attempt, use Input Fallback
2405        hooks.createFromInputFallback(config);
2406    }
2407
2408    hooks.createFromInputFallback = deprecate('value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' + 'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' + 'discouraged and will be removed in an upcoming major release. Please refer to ' + 'http://momentjs.com/guides/#/warnings/js-date/ for more info.', function (config) {
2409        config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
2410    });
2411
2412    // constant that refers to the ISO standard
2413    hooks.ISO_8601 = function () {};
2414
2415    // constant that refers to the RFC 2822 form
2416    hooks.RFC_2822 = function () {};
2417
2418    // date from string and format string
2419    function configFromStringAndFormat(config) {
2420        // TODO: Move this to another part of the creation flow to prevent circular deps
2421        if (config._f === hooks.ISO_8601) {
2422            configFromISO(config);
2423            return;
2424        }
2425        if (config._f === hooks.RFC_2822) {
2426            configFromRFC2822(config);
2427            return;
2428        }
2429        config._a = [];
2430        getParsingFlags(config).empty = true;
2431
2432        // This array is used to make a Date, either with `new Date` or `Date.UTC`
2433        var string = '' + config._i,
2434            i,
2435            parsedInput,
2436            tokens,
2437            token,
2438            skipped,
2439            stringLength = string.length,
2440            totalParsedInputLength = 0;
2441
2442        tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
2443
2444        for (i = 0; i < tokens.length; i++) {
2445            token = tokens[i];
2446            parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
2447            // console.log('token', token, 'parsedInput', parsedInput,
2448            //         'regex', getParseRegexForToken(token, config));
2449            if (parsedInput) {
2450                skipped = string.substr(0, string.indexOf(parsedInput));
2451                if (skipped.length > 0) {
2452                    getParsingFlags(config).unusedInput.push(skipped);
2453                }
2454                string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
2455                totalParsedInputLength += parsedInput.length;
2456            }
2457            // don't parse if it's not a known token
2458            if (formatTokenFunctions[token]) {
2459                if (parsedInput) {
2460                    getParsingFlags(config).empty = false;
2461                } else {
2462                    getParsingFlags(config).unusedTokens.push(token);
2463                }
2464                addTimeToArrayFromToken(token, parsedInput, config);
2465            } else if (config._strict && !parsedInput) {
2466                getParsingFlags(config).unusedTokens.push(token);
2467            }
2468        }
2469
2470        // add remaining unparsed input length to the string
2471        getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
2472        if (string.length > 0) {
2473            getParsingFlags(config).unusedInput.push(string);
2474        }
2475
2476        // clear _12h flag if hour is <= 12
2477        if (config._a[HOUR] <= 12 && getParsingFlags(config).bigHour === true && config._a[HOUR] > 0) {
2478            getParsingFlags(config).bigHour = undefined;
2479        }
2480
2481        getParsingFlags(config).parsedDateParts = config._a.slice(0);
2482        getParsingFlags(config).meridiem = config._meridiem;
2483        // handle meridiem
2484        config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
2485
2486        configFromArray(config);
2487        checkOverflow(config);
2488    }
2489
2490    function meridiemFixWrap(locale, hour, meridiem) {
2491        var isPm;
2492
2493        if (meridiem == null) {
2494            // nothing to do
2495            return hour;
2496        }
2497        if (locale.meridiemHour != null) {
2498            return locale.meridiemHour(hour, meridiem);
2499        } else if (locale.isPM != null) {
2500            // Fallback
2501            isPm = locale.isPM(meridiem);
2502            if (isPm && hour < 12) {
2503                hour += 12;
2504            }
2505            if (!isPm && hour === 12) {
2506                hour = 0;
2507            }
2508            return hour;
2509        } else {
2510            // this is not supposed to happen
2511            return hour;
2512        }
2513    }
2514
2515    // date from string and array of format strings
2516    function configFromStringAndArray(config) {
2517        var tempConfig, bestMoment, scoreToBeat, i, currentScore;
2518
2519        if (config._f.length === 0) {
2520            getParsingFlags(config).invalidFormat = true;
2521            config._d = new Date(NaN);
2522            return;
2523        }
2524
2525        for (i = 0; i < config._f.length; i++) {
2526            currentScore = 0;
2527            tempConfig = copyConfig({}, config);
2528            if (config._useUTC != null) {
2529                tempConfig._useUTC = config._useUTC;
2530            }
2531            tempConfig._f = config._f[i];
2532            configFromStringAndFormat(tempConfig);
2533
2534            if (!isValid(tempConfig)) {
2535                continue;
2536            }
2537
2538            // if there is any input that was not parsed add a penalty for that format
2539            currentScore += getParsingFlags(tempConfig).charsLeftOver;
2540
2541            //or tokens
2542            currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
2543
2544            getParsingFlags(tempConfig).score = currentScore;
2545
2546            if (scoreToBeat == null || currentScore < scoreToBeat) {
2547                scoreToBeat = currentScore;
2548                bestMoment = tempConfig;
2549            }
2550        }
2551
2552        extend(config, bestMoment || tempConfig);
2553    }
2554
2555    function configFromObject(config) {
2556        if (config._d) {
2557            return;
2558        }
2559
2560        var i = normalizeObjectUnits(config._i);
2561        config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {
2562            return obj && parseInt(obj, 10);
2563        });
2564
2565        configFromArray(config);
2566    }
2567
2568    function createFromConfig(config) {
2569        var res = new Moment(checkOverflow(prepareConfig(config)));
2570        if (res._nextDay) {
2571            // Adding is smart enough around DST
2572            res.add(1, 'd');
2573            res._nextDay = undefined;
2574        }
2575
2576        return res;
2577    }
2578
2579    function prepareConfig(config) {
2580        var input = config._i,
2581            format = config._f;
2582
2583        config._locale = config._locale || getLocale(config._l);
2584
2585        if (input === null || format === undefined && input === '') {
2586            return createInvalid({ nullInput: true });
2587        }
2588
2589        if (typeof input === 'string') {
2590            config._i = input = config._locale.preparse(input);
2591        }
2592
2593        if (isMoment(input)) {
2594            return new Moment(checkOverflow(input));
2595        } else if (isDate(input)) {
2596            config._d = input;
2597        } else if (isArray(format)) {
2598            configFromStringAndArray(config);
2599        } else if (format) {
2600            configFromStringAndFormat(config);
2601        } else {
2602            configFromInput(config);
2603        }
2604
2605        if (!isValid(config)) {
2606            config._d = null;
2607        }
2608
2609        return config;
2610    }
2611
2612    function configFromInput(config) {
2613        var input = config._i;
2614        if (isUndefined(input)) {
2615            config._d = new Date(hooks.now());
2616        } else if (isDate(input)) {
2617            config._d = new Date(input.valueOf());
2618        } else if (typeof input === 'string') {
2619            configFromString(config);
2620        } else if (isArray(input)) {
2621            config._a = map(input.slice(0), function (obj) {
2622                return parseInt(obj, 10);
2623            });
2624            configFromArray(config);
2625        } else if (isObject(input)) {
2626            configFromObject(config);
2627        } else if (isNumber(input)) {
2628            // from milliseconds
2629            config._d = new Date(input);
2630        } else {
2631            hooks.createFromInputFallback(config);
2632        }
2633    }
2634
2635    function createLocalOrUTC(input, format, locale, strict, isUTC) {
2636        var c = {};
2637
2638        if (locale === true || locale === false) {
2639            strict = locale;
2640            locale = undefined;
2641        }
2642
2643        if (isObject(input) && isObjectEmpty(input) || isArray(input) && input.length === 0) {
2644            input = undefined;
2645        }
2646        // object construction must be done this way.
2647        // https://github.com/moment/moment/issues/1423
2648        c._isAMomentObject = true;
2649        c._useUTC = c._isUTC = isUTC;
2650        c._l = locale;
2651        c._i = input;
2652        c._f = format;
2653        c._strict = strict;
2654
2655        return createFromConfig(c);
2656    }
2657
2658    function createLocal(input, format, locale, strict) {
2659        return createLocalOrUTC(input, format, locale, strict, false);
2660    }
2661
2662    var prototypeMin = deprecate('moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/', function () {
2663        var other = createLocal.apply(null, arguments);
2664        if (this.isValid() && other.isValid()) {
2665            return other < this ? this : other;
2666        } else {
2667            return createInvalid();
2668        }
2669    });
2670
2671    var prototypeMax = deprecate('moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/', function () {
2672        var other = createLocal.apply(null, arguments);
2673        if (this.isValid() && other.isValid()) {
2674            return other > this ? this : other;
2675        } else {
2676            return createInvalid();
2677        }
2678    });
2679
2680    // Pick a moment m from moments so that m[fn](other) is true for all
2681    // other. This relies on the function fn to be transitive.
2682    //
2683    // moments should either be an array of moment objects or an array, whose
2684    // first element is an array of moment objects.
2685    function pickBy(fn, moments) {
2686        var res, i;
2687        if (moments.length === 1 && isArray(moments[0])) {
2688            moments = moments[0];
2689        }
2690        if (!moments.length) {
2691            return createLocal();
2692        }
2693        res = moments[0];
2694        for (i = 1; i < moments.length; ++i) {
2695            if (!moments[i].isValid() || moments[i][fn](res)) {
2696                res = moments[i];
2697            }
2698        }
2699        return res;
2700    }
2701
2702    // TODO: Use [].sort instead?
2703    function min() {
2704        var args = [].slice.call(arguments, 0);
2705
2706        return pickBy('isBefore', args);
2707    }
2708
2709    function max() {
2710        var args = [].slice.call(arguments, 0);
2711
2712        return pickBy('isAfter', args);
2713    }
2714
2715    var now = function now() {
2716        return Date.now ? Date.now() : +new Date();
2717    };
2718
2719    var ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];
2720
2721    function isDurationValid(m) {
2722        for (var key in m) {
2723            if (!(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) {
2724                return false;
2725            }
2726        }
2727
2728        var unitHasDecimal = false;
2729        for (var i = 0; i < ordering.length; ++i) {
2730            if (m[ordering[i]]) {
2731                if (unitHasDecimal) {
2732                    return false; // only allow non-integers for smallest unit
2733                }
2734                if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
2735                    unitHasDecimal = true;
2736                }
2737            }
2738        }
2739
2740        return true;
2741    }
2742
2743    function isValid$1() {
2744        return this._isValid;
2745    }
2746
2747    function createInvalid$1() {
2748        return createDuration(NaN);
2749    }
2750
2751    function Duration(duration) {
2752        var normalizedInput = normalizeObjectUnits(duration),
2753            years = normalizedInput.year || 0,
2754            quarters = normalizedInput.quarter || 0,
2755            months = normalizedInput.month || 0,
2756            weeks = normalizedInput.week ||