https://gminaoswiecim.pl/live/js/scripts-plugins.js

266
267    // Moment prototype object
268    function Moment(config) {
269        copyConfig(this, config);
270        this._d = new Date(config._d != null ? config._d.getTime() : NaN);
271        // Prevent infinite loop in case updateOffset creates new moment
272        // objects.
273        if (updateInProgress === false) {
274            updateInProgress = true;
275            utils_hooks__hooks.updateOffset(this);
276            updateInProgress = false;
277        }
278    }
279
280    function isMoment(obj) {
281        return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
282    }
283
284    function absFloor(number) {
285        if (number < 0) {
286            return Math.ceil(number);
287        } else {
288            return Math.floor(number);
289        }
290    }
291
292    function toInt(argumentForCoercion) {
293        var coercedNumber = +argumentForCoercion,
294            value = 0;
295
296        if (coercedNumber !== 0 && isFinite(coercedNumber)) {
297            value = absFloor(coercedNumber);
298        }
299
300        return value;
301    }
302
303    function compareArrays(array1, array2, dontConvert) {
304        var len = Math.min(array1.length, array2.length),
305            lengthDiff = Math.abs(array1.length - array2.length),
306            diffs = 0,
307            i;
308        for (i = 0; i < len; i++) {
309            if ((dontConvert && array1[i] !== array2[i]) || (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
310                diffs++;
311            }
312        }
313        return diffs + lengthDiff;
314    }
315
316    function Locale() {}
317
318    var locales = {};
319    var globalLocale;
320
321    function normalizeLocale(key) {
322        return key ? key.toLowerCase().replace('_', '-') : key;
323    }
324
325    // pick the locale from the array
326    // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
327    // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
328    function chooseLocale(names) {
329        var i = 0,
330            j, next, locale, split;
331
332        while (i < names.length) {
333            split = normalizeLocale(names[i]).split('-');
334            j = split.length;
335            next = normalizeLocale(names[i + 1]);
336            next = next ? next.split('-') : null;
337            while (j > 0) {
338                locale = loadLocale(split.slice(0, j).join('-'));
339                if (locale) {
340                    return locale;
341                }
342                if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
343                    //the next array item is better than a shallower substring of this one
344                    break;
345                }
346                j--;
347            }
348            i++;
349        }
350        return null;
351    }
352
353    function loadLocale(name) {
354        var oldLocale = null;
355        // TODO: Find a better way to register and load all the locales in Node
356        if (!locales[name] && typeof module !== 'undefined' && module && module.exports) {
357            try {
358                oldLocale = globalLocale._abbr;
359                require('./locale/' + name);
360                // because defineLocale currently also sets the global locale, we
361                // want to undo that for lazy loaded locales
362                locale_locales__getSetGlobalLocale(oldLocale);
363            } catch (e) {}
364        }
365        return locales[name];
366    }
367
368    // This function will load locale and then set the global locale.  If
369    // no arguments are passed in, it will simply return the current global
370    // locale key.
371    function locale_locales__getSetGlobalLocale(key, values) {
372        var data;
373        if (key) {
374            if (typeof values === 'undefined') {
375                data = locale_locales__getLocale(key);
376            } else {
377                data = defineLocale(key, values);
378            }
379
380            if (data) {
381                // moment.duration._locale = moment._locale = data;
382                globalLocale = data;
383            }
384        }
385
386        return globalLocale._abbr;
387    }
388
389    function defineLocale(name, values) {
390        if (values !== null) {
391            values.abbr = name;
392            locales[name] = locales[name] || new Locale();
393            locales[name].set(values);
394
395            // backwards compat for now: also set the locale
396            locale_locales__getSetGlobalLocale(name);
397
398            return locales[name];
399        } else {
400            // useful for testing
401            delete locales[name];
402            return null;
403        }
404    }
405
406    // returns locale data
407    function locale_locales__getLocale(key) {
408        var locale;
409
410        if (key && key._locale && key._locale._abbr) {
411            key = key._locale._abbr;
412        }
413
414        if (!key) {
415            return globalLocale;
416        }
417
418        if (!isArray(key)) {
419            //short-circuit everything else
420            locale = loadLocale(key);
421            if (locale) {
422                return locale;
423            }
424            key = [key];
425        }
426
427        return chooseLocale(key);
428    }
429
430    var aliases = {};
431
432    function addUnitAlias(unit, shorthand) {
433        var lowerCase = unit.toLowerCase();
434        aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
435    }
436
437    function normalizeUnits(units) {
438        return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
439    }
440
441    function normalizeObjectUnits(inputObject) {
442        var normalizedInput = {},
443        normalizedProp,
444        prop;
445
446        for (prop in inputObject) {
447            if (hasOwnProp(inputObject, prop)) {
448                normalizedProp = normalizeUnits(prop);
449                if (normalizedProp) {
450                    normalizedInput[normalizedProp] = inputObject[prop];
451                }
452            }
453        }
454
455        return normalizedInput;
456    }
457
458    function makeGetSet(unit, keepTime) {
459        return function(value) {
460            if (value != null) {
461                get_set__set(this, unit, value);
462                utils_hooks__hooks.updateOffset(this, keepTime);
463                return this;
464            } else {
465                return get_set__get(this, unit);
466            }
467        };
468    }
469
470    function get_set__get(mom, unit) {
471        return mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]();
472    }
473
474    function get_set__set(mom, unit, value) {
475        return mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
476    }
477
478    // MOMENTS
479
480    function getSet(units, value) {
481        var unit;
482        if (typeof units === 'object') {
483            for (unit in units) {
484                this.set(unit, units[unit]);
485            }
486        } else {
487            units = normalizeUnits(units);
488            if (typeof this[units] === 'function') {
489                return this[units](value);
490            }
491        }
492        return this;
493    }
494
495    function zeroFill(number, targetLength, forceSign) {
496        var absNumber = '' + Math.abs(number),
497            zerosToFill = targetLength - absNumber.length,
498            sign = number >= 0;
499        return (sign ? (forceSign ? '+' : '') : '-') + Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
500    }
501
502    var formattingTokens = /(\[[^\[]*\])|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Q|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;
503
504    var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
505
506    var formatFunctions = {};
507
508    var formatTokenFunctions = {};
509
510    // token:    'M'
511    // padded:   ['MM', 2]
512    // ordinal:  'Mo'
513    // callback: function () { this.month() + 1 }
514    function addFormatToken(token, padded, ordinal, callback) {
515        var func = callback;
516        if (typeof callback === 'string') {
517            func = function() {
518                return this[callback]();
519            };
520        }
521        if (token) {
522            formatTokenFunctions[token] = func;
523        }
524        if (padded) {
525            formatTokenFunctions[padded[0]] = function() {
526                return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
527            };
528        }
529        if (ordinal) {
530            formatTokenFunctions[ordinal] = function() {
531                return this.localeData().ordinal(func.apply(this, arguments), token);
532            };
533        }
534    }
535
536    function removeFormattingTokens(input) {
537        if (input.match(/\[[\s\S]/)) {
538            return input.replace(/^\[|\]$/g, '');
539        }
540        return input.replace(/\\/g, '');
541    }
542
543    function makeFormatFunction(format) {
544        var array = format.match(formattingTokens),
545            i, length;
546
547        for (i = 0, length = array.length; i < length; i++) {
548            if (formatTokenFunctions[array[i]]) {
549                array[i] = formatTokenFunctions[array[i]];
550            } else {
551                array[i] = removeFormattingTokens(array[i]);
552            }
553        }
554
555        return function(mom) {
556            var output = '';
557            for (i = 0; i < length; i++) {
558                output += array[i] instanceof Function ? array[i].call(mom, format) : array[i];
559            }
560            return output;
561        };
562    }
563
564    // format date using native date object
565    function formatMoment(m, format) {
566        if (!m.isValid()) {
567            return m.localeData().invalidDate();
568        }
569
570        format = expandFormat(format, m.localeData());
571        formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);
572
573        return formatFunctions[format](m);
574    }
575
576    function expandFormat(format, locale) {
577        var i = 5;
578
579        function replaceLongDateFormatTokens(input) {
580            return locale.longDateFormat(input) || input;
581        }
582
583        localFormattingTokens.lastIndex = 0;
584        while (i >= 0 && localFormattingTokens.test(format)) {
585            format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
586            localFormattingTokens.lastIndex = 0;
587            i -= 1;
588        }
589
590        return format;
591    }
592
593    var match1 = /\d/; //       0 - 9
594    var match2 = /\d\d/; //      00 - 99
595    var match3 = /\d{3}/; //     000 - 999
596    var match4 = /\d{4}/; //    0000 - 9999
597    var match6 = /[+-]?\d{6}/; // -999999 - 999999
598    var match1to2 = /\d\d?/; //       0 - 99
599    var match1to3 = /\d{1,3}/; //       0 - 999
600    var match1to4 = /\d{1,4}/; //       0 - 9999
601    var match1to6 = /[+-]?\d{1,6}/; // -999999 - 999999
602
603    var matchUnsigned = /\d+/; //       0 - inf
604    var matchSigned = /[+-]?\d+/; //    -inf - inf
605
606    var matchOffset = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
607
608    var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
609
610    // any word (or two) characters or numbers including two/three word month in arabic.
611    var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
612
613    var regexes = {};
614
615    function isFunction(sth) {
616        // https://github.com/moment/moment/issues/2325
617        return typeof sth === 'function' && Object.prototype.toString.call(sth) === '[object Function]';
618    }
619
620
621    function addRegexToken(token, regex, strictRegex) {
622        regexes[token] = isFunction(regex) ? regex : function(isStrict) {
623            return (isStrict && strictRegex) ? strictRegex : regex;
624        };
625    }
626
627    function getParseRegexForToken(token, config) {
628        if (!hasOwnProp(regexes, token)) {
629            return new RegExp(unescapeFormat(token));
630        }
631
632        return regexes[token](config._strict, config._locale);
633    }
634
635    // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
636    function unescapeFormat(s) {
637        return s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function(matched, p1, p2, p3, p4) {
638            return p1 || p2 || p3 || p4;
639        }).replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
640    }
641
642    var tokens = {};
643
644    function addParseToken(token, callback) {
645        var i, func = callback;
646        if (typeof token === 'string') {
647            token = [token];
648        }
649        if (typeof callback === 'number') {
650            func = function(input, array) {
651                array[callback] = toInt(input);
652            };
653        }
654        for (i = 0; i < token.length; i++) {
655            tokens[token[i]] = func;
656        }
657    }
658
659    function addWeekParseToken(token, callback) {
660        addParseToken(token, function(input, array, config, token) {
661            config._w = config._w || {};
662            callback(input, config._w, config, token);
663        });
664    }
665
666    function addTimeToArrayFromToken(token, input, config) {
667        if (input != null && hasOwnProp(tokens, token)) {
668            tokens[token](input, config._a, config, token);
669        }
670    }
671
672    var YEAR = 0;
673    var MONTH = 1;
674    var DATE = 2;
675    var HOUR = 3;
676    var MINUTE = 4;
677    var SECOND = 5;
678    var MILLISECOND = 6;
679
680    function daysInMonth(year, month) {
681        return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
682    }
683
684    // FORMATTING
685
686    addFormatToken('M', ['MM', 2], 'Mo', function() {
687        return this.month() + 1;
688    });
689
690    addFormatToken('MMM', 0, 0, function(format) {
691        return this.localeData().monthsShort(this, format);
692    });
693
694    addFormatToken('MMMM', 0, 0, function(format) {
695        return this.localeData().months(this, format);
696    });
697
698    // ALIASES
699
700    addUnitAlias('month', 'M');
701
702    // PARSING
703
704    addRegexToken('M', match1to2);
705    addRegexToken('MM', match1to2, match2);
706    addRegexToken('MMM', matchWord);
707    addRegexToken('MMMM', matchWord);
708
709    addParseToken(['M', 'MM'], function(input, array) {
710        array[MONTH] = toInt(input) - 1;
711    });
712
713    addParseToken(['MMM', 'MMMM'], function(input, array, config, token) {
714        var month = config._locale.monthsParse(input, token, config._strict);
715        // if we didn't find a month name, mark the date as invalid.
716        if (month != null) {
717            array[MONTH] = month;
718        } else {
719            getParsingFlags(config).invalidMonth = input;
720        }
721    });
722
723    // LOCALES
724
725    var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
726
727    function localeMonths(m) {
728        return this._months[m.month()];
729    }
730
731    var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
732
733    function localeMonthsShort(m) {
734        return this._monthsShort[m.month()];
735    }
736
737    function localeMonthsParse(monthName, format, strict) {
738        var i, mom, regex;
739
740        if (!this._monthsParse) {
741            this._monthsParse = [];
742            this._longMonthsParse = [];
743            this._shortMonthsParse = [];
744        }
745
746        for (i = 0; i < 12; i++) {
747            // make the regex if we don't have it already
748            mom = create_utc__createUTC([2000, i]);
749            if (strict && !this._longMonthsParse[i]) {
750                this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
751                this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
752            }
753            if (!strict && !this._monthsParse[i]) {
754                regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
755                this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
756            }
757            // test the regex
758            if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
759                return i;
760            } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
761                return i;
762            } else if (!strict && this._monthsParse[i].test(monthName)) {
763                return i;
764            }
765        }
766    }
767
768    // MOMENTS
769
770    function setMonth(mom, value) {
771        var dayOfMonth;
772
773        // TODO: Move this out of here!
774        if (typeof value === 'string') {
775            value = mom.localeData().monthsParse(value);
776            // TODO: Another silent failure?
777            if (typeof value !== 'number') {
778                return mom;
779            }
780        }
781
782        dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
783        mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
784        return mom;
785    }
786
787    function getSetMonth(value) {
788        if (value != null) {
789            setMonth(this, value);
790            utils_hooks__hooks.updateOffset(this, true);
791            return this;
792        } else {
793            return get_set__get(this, 'Month');
794        }
795    }
796
797    function getDaysInMonth() {
798        return daysInMonth(this.year(), this.month());
799    }
800
801    function checkOverflow(m) {
802        var overflow;
803        var a = m._a;
804
805        if (a && getParsingFlags(m).overflow === -2) {
806            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;
807
808            if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
809                overflow = DATE;
810            }
811
812            getParsingFlags(m).overflow = overflow;
813        }
814
815        return m;
816    }
817
818    function warn(msg) {
819        if (utils_hooks__hooks.suppressDeprecationWarnings === false && typeof console !== 'undefined' && console.warn) {
820            console.warn('Deprecation warning: ' + msg);
821        }
822    }
823
824    function deprecate(msg, fn) {
825        var firstTime = true;
826
827        return extend(function() {
828            if (firstTime) {
829                warn(msg + '\n' + (new Error()).stack);
830                firstTime = false;

1171            config._a[i] = input[i] = currentDate[i];
1172        }
1173
1174        // Zero out whatever was not defaulted, including time
1175        for (; i < 7; i++) {
1176            config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
1177        }
1178
1179        // Check for 24:00:00.000
1180        if (config._a[HOUR] === 24 && config._a[MINUTE] === 0 && config._a[SECOND] === 0 && config._a[MILLISECOND] === 0) {
1181            config._nextDay = true;
1182            config._a[HOUR] = 0;
1183        }
1184
1185        config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
1186        // Apply timezone offset from input. The actual utcOffset can be changed
1187        // with parseZone.
1188        if (config._tzm != null) {
1189            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
1190        }
1191
1192        if (config._nextDay) {
1193            config._a[HOUR] = 24;
1194        }
1195    }
1196
1197    function dayOfYearFromWeekInfo(config) {
1198        var w, weekYear, week, weekday, dow, doy, temp;
1199
1200        w = config._w;
1201        if (w.GG != null || w.W != null || w.E != null) {
1202            dow = 1;
1203            doy = 4;
1204
1205            // TODO: We need to take the current isoWeekYear, but that depends on
1206            // how we interpret now (local, utc, fixed offset). So create
1207            // a now version of current config (take local/utc/offset flags, and
1208            // create now).
1209            weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(local__createLocal(), 1, 4).year);
1210            week = defaults(w.W, 1);
1211            weekday = defaults(w.E, 1);
1212        } else {
1213            dow = config._locale._week.dow;
1214            doy = config._locale._week.doy;
1215
1216            weekYear = defaults(w.gg, config._a[YEAR], weekOfYear(local__createLocal(), dow, doy).year);
1217            week = defaults(w.w, 1);
1218
1219            if (w.d != null) {
1220                // weekday -- low day numbers are considered next week
1221                weekday = w.d;
1222                if (weekday < dow) {
1223                    ++week;
1224                }
1225            } else if (w.e != null) {
1226                // local weekday -- counting starts from begining of week
1227                weekday = w.e + dow;
1228            } else {
1229                // default to begining of week
1230                weekday = dow;
1231            }
1232        }
1233        temp = dayOfYearFromWeeks(weekYear, week, weekday, doy, dow);
1234
1235        config._a[YEAR] = temp.year;
1236        config._dayOfYear = temp.dayOfYear;
1237    }
1238
1239    utils_hooks__hooks.ISO_8601 = function() {};
1240
1241    // date from string and format string
1242    function configFromStringAndFormat(config) {
1243        // TODO: Move this to another part of the creation flow to prevent circular deps
1244        if (config._f === utils_hooks__hooks.ISO_8601) {
1245            configFromISO(config);
1246            return;
1247        }
1248
1249        config._a = [];
1250        getParsingFlags(config).empty = true;
1251
1252        // This array is used to make a Date, either with `new Date` or `Date.UTC`
1253        var string = '' + config._i,
1254            i, parsedInput, tokens, token, skipped,
1255            stringLength = string.length,
1256            totalParsedInputLength = 0;
1257
1258        tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
1259
1260        for (i = 0; i < tokens.length; i++) {
1261            token = tokens[i];
1262            parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
1263            if (parsedInput) {
1264                skipped = string.substr(0, string.indexOf(parsedInput));
1265                if (skipped.length > 0) {
1266                    getParsingFlags(config).unusedInput.push(skipped);
1267                }
1268                string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
1269                totalParsedInputLength += parsedInput.length;
1270            }
1271            // don't parse if it's not a known token
1272            if (formatTokenFunctions[token]) {
1273                if (parsedInput) {
1274                    getParsingFlags(config).empty = false;
1275                } else {
1276                    getParsingFlags(config).unusedTokens.push(token);
1277                }
1278                addTimeToArrayFromToken(token, parsedInput, config);
1279            } else if (config._strict && !parsedInput) {
1280                getParsingFlags(config).unusedTokens.push(token);
1281            }
1282        }
1283
1284        // add remaining unparsed input length to the string
1285        getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
1286        if (string.length > 0) {
1287            getParsingFlags(config).unusedInput.push(string);
1288        }
1289
1290        // clear _12h flag if hour is <= 12
1291        if (getParsingFlags(config).bigHour === true && config._a[HOUR] <= 12 && config._a[HOUR] > 0) {
1292            getParsingFlags(config).bigHour = undefined;
1293        }
1294        // handle meridiem
1295        config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
1296
1297        configFromArray(config);
1298        checkOverflow(config);
1299    }
1300
1301
1302    function meridiemFixWrap(locale, hour, meridiem) {
1303        var isPm;
1304
1305        if (meridiem == null) {
1306            // nothing to do
1307            return hour;
1308        }
1309        if (locale.meridiemHour != null) {
1310            return locale.meridiemHour(hour, meridiem);
1311        } else if (locale.isPM != null) {
1312            // Fallback
1313            isPm = locale.isPM(meridiem);
1314            if (isPm && hour < 12) {
1315                hour += 12;
1316            }
1317            if (!isPm && hour === 12) {
1318                hour = 0;
1319            }
1320            return hour;
1321        } else {
1322            // this is not supposed to happen
1323            return hour;
1324        }
1325    }
1326
1327    function configFromStringAndArray(config) {
1328        var tempConfig,
1329        bestMoment,
1330
1331        scoreToBeat,
1332        i,
1333        currentScore;
1334
1335        if (config._f.length === 0) {
1336            getParsingFlags(config).invalidFormat = true;
1337            config._d = new Date(NaN);
1338            return;
1339        }
1340
1341        for (i = 0; i < config._f.length; i++) {
1342            currentScore = 0;
1343            tempConfig = copyConfig({}, config);
1344            if (config._useUTC != null) {
1345                tempConfig._useUTC = config._useUTC;
1346            }
1347            tempConfig._f = config._f[i];
1348            configFromStringAndFormat(tempConfig);
1349
1350            if (!valid__isValid(tempConfig)) {
1351                continue;
1352            }
1353
1354            // if there is any input that was not parsed add a penalty for that format
1355            currentScore += getParsingFlags(tempConfig).charsLeftOver;
1356
1357            //or tokens
1358            currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
1359
1360            getParsingFlags(tempConfig).score = currentScore;
1361
1362            if (scoreToBeat == null || currentScore < scoreToBeat) {
1363                scoreToBeat = currentScore;
1364                bestMoment = tempConfig;
1365            }
1366        }
1367
1368        extend(config, bestMoment || tempConfig);
1369    }
1370
1371    function configFromObject(config) {
1372        if (config._d) {
1373            return;
1374        }
1375
1376        var i = normalizeObjectUnits(config._i);
1377        config._a = [i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond];
1378
1379        configFromArray(config);
1380    }
1381
1382    function createFromConfig(config) {
1383        var res = new Moment(checkOverflow(prepareConfig(config)));
1384        if (res._nextDay) {
1385            // Adding is smart enough around DST
1386            res.add(1, 'd');
1387            res._nextDay = undefined;
1388        }
1389
1390        return res;
1391    }
1392
1393    function prepareConfig(config) {
1394        var input = config._i,
1395            format = config._f;
1396
1397        config._locale = config._locale || locale_locales__getLocale(config._l);
1398
1399        if (input === null || (format === undefined && input === '')) {
1400            return valid__createInvalid({
1401                nullInput: true
1402            });
1403        }
1404
1405        if (typeof input === 'string') {
1406            config._i = input = config._locale.preparse(input);
1407        }
1408
1409        if (isMoment(input)) {
1410            return new Moment(checkOverflow(input));
1411        } else if (isArray(format)) {
1412            configFromStringAndArray(config);
1413        } else if (format) {
1414            configFromStringAndFormat(config);
1415        } else if (isDate(input)) {
1416            config._d = input;
1417        } else {
1418            configFromInput(config);
1419        }
1420
1421        return config;
1422    }
1423
1424    function configFromInput(config) {
1425        var input = config._i;
1426        if (input === undefined) {
1427            config._d = new Date();
1428        } else if (isDate(input)) {
1429            config._d = new Date(+input);
1430        } else if (typeof input === 'string') {
1431            configFromString(config);
1432        } else if (isArray(input)) {
1433            config._a = map(input.slice(0), function(obj) {
1434                return parseInt(obj, 10);
1435            });
1436            configFromArray(config);
1437        } else if (typeof(input) === 'object') {
1438            configFromObject(config);
1439        } else if (typeof(input) === 'number') {
1440            // from milliseconds
1441            config._d = new Date(input);
1442        } else {
1443            utils_hooks__hooks.createFromInputFallback(config);
1444        }
1445    }
1446
1447    function createLocalOrUTC(input, format, locale, strict, isUTC) {
1448        var c = {};
1449
1450        if (typeof(locale) === 'boolean') {
1451            strict = locale;
1452            locale = undefined;
1453        }
1454        // object construction must be done this way.
1455        // https://github.com/moment/moment/issues/1423
1456        c._isAMomentObject = true;
1457        c._useUTC = c._isUTC = isUTC;
1458        c._l = locale;
1459        c._i = input;
1460        c._f = format;
1461        c._strict = strict;
1462
1463        return createFromConfig(c);
1464    }
1465
1466    function local__createLocal(input, format, locale, strict) {
1467        return createLocalOrUTC(input, format, locale, strict, false);
1468    }
1469
1470    var prototypeMin = deprecate('moment().min is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548',
1471
1472    function() {
1473        var other = local__createLocal.apply(null, arguments);
1474        return other < this ? this : other;
1475    });
1476
1477    var prototypeMax = deprecate('moment().max is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548',
1478
1479    function() {
1480        var other = local__createLocal.apply(null, arguments);
1481        return other > this ? this : other;
1482    });
1483
1484    // Pick a moment m from moments so that m[fn](other) is true for all
1485    // other. This relies on the function fn to be transitive.
1486    //
1487    // moments should either be an array of moment objects or an array, whose
1488    // first element is an array of moment objects.
1489    function pickBy(fn, moments) {
1490        var res, i;
1491        if (moments.length === 1 && isArray(moments[0])) {
1492            moments = moments[0];
1493        }
1494        if (!moments.length) {
1495            return local__createLocal();
1496        }
1497        res = moments[0];
1498        for (i = 1; i < moments.length; ++i) {
1499            if (!moments[i].isValid() || moments[i][fn](res)) {
1500                res = moments[i];
1501            }
1502        }
1503        return res;
1504    }
1505
1506    // TODO: Use [].sort instead?
1507    function min() {
1508        var args = [].slice.call(arguments, 0);
1509
1510        return pickBy('isBefore', args);
1511    }
1512
1513    function max() {
1514        var args = [].slice.call(arguments, 0);
1515
1516        return pickBy('isAfter', args);
1517    }
1518
1519    function Duration(duration) {
1520        var normalizedInput = normalizeObjectUnits(duration),
1521            years = normalizedInput.year || 0,
1522            quarters = normalizedInput.quarter || 0,
1523            months = normalizedInput.month || 0,
1524            weeks = normalizedInput.week || 0,
1525            days = normalizedInput.day || 0,
1526            hours = normalizedInput.hour || 0,
1527            minutes = normalizedInput.minute || 0,
1528            seconds = normalizedInput.second || 0,
1529            milliseconds = normalizedInput.millisecond || 0;
1530
1531        // representation for dateAddRemove
1532        this._milliseconds = +milliseconds + seconds * 1e3 + // 1000
1533        minutes * 6e4 + // 1000 * 60
1534        hours * 36e5; // 1000 * 60 * 60
1535        // Because of dateAddRemove treats 24 hours as different from a
1536        // day when working around DST, we need to store them separately
1537        this._days = +days + weeks * 7;
1538        // It is impossible translate months into days without knowing
1539        // which months you are are talking about, so we have to store
1540        // it separately.
1541        this._months = +months + quarters * 3 + years * 12;
1542
1543        this._data = {};
1544
1545        this._locale = locale_locales__getLocale();
1546
1547        this._bubble();
1548    }
1549
1550    function isDuration(obj) {
1551        return obj instanceof Duration;
1552    }
1553
1554    function offset(token, separator) {
1555        addFormatToken(token, 0, 0, function() {
1556            var offset = this.utcOffset();
1557            var sign = '+';
1558            if (offset < 0) {
1559                offset = -offset;
1560                sign = '-';
1561            }
1562            return sign + zeroFill(~~ (offset / 60), 2) + separator + zeroFill(~~ (offset) % 60, 2);
1563        });
1564    }
1565
1566    offset('Z', ':');
1567    offset('ZZ', '');
1568
1569    // PARSING
1570
1571    addRegexToken('Z', matchOffset);
1572    addRegexToken('ZZ', matchOffset);
1573    addParseToken(['Z', 'ZZ'], function(input, array, config) {
1574        config._useUTC = true;
1575        config._tzm = offsetFromString(input);
1576    });
1577
1578    // HELPERS
1579
1580    // timezone chunker
1581    // '+10:00' > ['10',  '00']
1582    // '-1530'  > ['-15', '30']
1583    var chunkOffset = /([\+\-]|\d\d)/gi;
1584
1585    function offsetFromString(string) {
1586        var matches = ((string || '').match(matchOffset) || []);
1587        var chunk = matches[matches.length - 1] || [];
1588        var parts = (chunk + '').match(chunkOffset) || ['-', 0, 0];
1589        var minutes = +(parts[1] * 60) + toInt(parts[2]);
1590
1591        return parts[0] === '+' ? minutes : -minutes;
1592    }
1593
1594    // Return a moment from input, that is local/utc/zone equivalent to model.
1595    function cloneWithOffset(input, model) {
1596        var res, diff;
1597        if (model._isUTC) {
1598            res = model.clone();
1599            diff = (isMoment(input) || isDate(input) ? +input : +local__createLocal(input)) - (+res);
1600            // Use low-level api, because this fn is low-level api.
1601            res._d.setTime(+res._d + diff);
1602            utils_hooks__hooks.updateOffset(res, false);
1603            return res;
1604        } else {
1605            return local__createLocal(input).local();
1606        }
1607    }
1608
1609    function getDateOffset(m) {
1610        // On Firefox.24 Date#getTimezoneOffset returns a floating point.
1611        // https://github.com/moment/moment/pull/1871
1612        return -Math.round(m._d.getTimezoneOffset() / 15) * 15;
1613    }
1614
1615    // HOOKS
1616
1617    // This function will be called whenever a moment is mutated.
1618    // It is intended to keep the offset in sync with the timezone.
1619    utils_hooks__hooks.updateOffset = function() {};
1620
1621    // MOMENTS
1622
1623    // keepLocalTime = true means only change the timezone, without
1624    // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
1625    // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
1626    // +0200, so we adjust the time as needed, to be valid.
1627    //
1628    // Keeping the time actually adds/subtracts (one hour)
1629    // from the actual represented time. That is why we call updateOffset
1630    // a second time. In case it wants us to change the offset again
1631    // _changeInProgress == true case, then we have to adjust, because
1632    // there is no such time in the given timezone.
1633    function getSetOffset(input, keepLocalTime) {
1634        var offset = this._offset || 0,
1635            localAdjust;
1636        if (input != null) {
1637            if (typeof input === 'string') {
1638                input = offsetFromString(input);
1639            }
1640            if (Math.abs(input) < 16) {
1641                input = input * 60;
1642            }
1643            if (!this._isUTC && keepLocalTime) {
1644                localAdjust = getDateOffset(this);
1645            }
1646            this._offset = input;
1647            this._isUTC = true;
1648            if (localAdjust != null) {
1649                this.add(localAdjust, 'm');
1650            }
1651            if (offset !== input) {
1652                if (!keepLocalTime || this._changeInProgress) {
1653                    add_subtract__addSubtract(this, create__createDuration(input - offset, 'm'), 1, false);
1654                } else if (!this._changeInProgress) {
1655                    this._changeInProgress = true;
1656                    utils_hooks__hooks.updateOffset(this, true);
1657                    this._changeInProgress = null;
1658                }
1659            }
1660            return this;
1661        } else {
1662            return this._isUTC ? offset : getDateOffset(this);
1663        }
1664    }
1665
1666    function getSetZone(input, keepLocalTime) {
1667        if (input != null) {
1668            if (typeof input !== 'string') {
1669                input = -input;
1670            }
1671
1672            this.utcOffset(input, keepLocalTime);
1673
1674            return this;
1675        } else {
1676            return -this.utcOffset();
1677        }
1678    }
1679
1680    function setOffsetToUTC(keepLocalTime) {
1681        return this.utcOffset(0, keepLocalTime);
1682    }
1683
1684    function setOffsetToLocal(keepLocalTime) {
1685        if (this._isUTC) {
1686            this.utcOffset(0, keepLocalTime);
1687            this._isUTC = false;
1688
1689            if (keepLocalTime) {
1690                this.subtract(getDateOffset(this), 'm');
1691            }
1692        }
1693        return this;
1694    }
1695
1696    function setOffsetToParsedOffset() {
1697        if (this._tzm) {
1698            this.utcOffset(this._tzm);
1699        } else if (typeof this._i === 'string') {
1700            this.utcOffset(offsetFromString(this._i));
1701        }
1702        return this;
1703    }
1704
1705    function hasAlignedHourOffset(input) {
1706        input = input ? local__createLocal(input).utcOffset() : 0;
1707
1708        return (this.utcOffset() - input) % 60 === 0;
1709    }
1710
1711    function isDaylightSavingTime() {
1712        return (
1713        this.utcOffset() > this.clone().month(0).utcOffset() || this.utcOffset() > this.clone().month(5).utcOffset());
1714    }
1715
1716    function isDaylightSavingTimeShifted() {
1717        if (typeof this._isDSTShifted !== 'undefined') {
1718            return this._isDSTShifted;
1719        }
1720
1721        var c = {};
1722
1723        copyConfig(c, this);
1724        c = prepareConfig(c);
1725
1726        if (c._a) {
1727            var other = c._isUTC ? create_utc__createUTC(c._a) : local__createLocal(c._a);
1728            this._isDSTShifted = this.isValid() && compareArrays(c._a, other.toArray()) > 0;
1729        } else {
1730            this._isDSTShifted = false;
1731        }
1732
1733        return this._isDSTShifted;
1734    }
1735
1736    function isLocal() {
1737        return !this._isUTC;
1738    }
1739
1740    function isUtcOffset() {
1741        return this._isUTC;
1742    }
1743
1744    function isUtc() {
1745        return this._isUTC && this._offset === 0;
1746    }
1747
1748    var aspNetRegex = /(\-)?(?:(\d*)\.)?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?)?/;
1749
1750    // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
1751    // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
1752    var create__isoRegex = /^(-)?P(?:(?:([0-9,.]*)Y)?(?:([0-9,.]*)M)?(?:([0-9,.]*)D)?(?:T(?:([0-9,.]*)H)?(?:([0-9,.]*)M)?(?:([0-9,.]*)S)?)?|([0-9,.]*)W)$/;
1753
1754    function create__createDuration(input, key) {
1755        var duration = input,
1756            // matching against regexp is expensive, do it on demand
1757            match = null,
1758            sign,
1759            ret,
1760            diffRes;
1761
1762        if (isDuration(input)) {
1763            duration = {
1764                ms: input._milliseconds,
1765                d: input._days,
1766                M: input._months
1767            };
1768        } else if (typeof input === 'number') {
1769            duration = {};
1770            if (key) {
1771                duration[key] = input;
1772            } else {
1773                duration.milliseconds = input;
1774            }
1775        } else if ( !! (match = aspNetRegex.exec(input))) {
1776            sign = (match[1] === '-') ? -1 : 1;
1777            duration = {
1778                y: 0,
1779                d: toInt(match[DATE]) * sign,
1780                h: toInt(match[HOUR]) * sign,
1781                m: toInt(match[MINUTE]) * sign,
1782                s: toInt(match[SECOND]) * sign,
1783                ms: toInt(match[MILLISECOND]) * sign
1784            };
1785        } else if ( !! (match = create__isoRegex.exec(input))) {
1786            sign = (match[1] === '-') ? -1 : 1;
1787            duration = {
1788                y: parseIso(match[2], sign),
1789                M: parseIso(match[3], sign),
1790                d: parseIso(match[4], sign),
1791                h: parseIso(match[5], sign),
1792                m: parseIso(match[6], sign),
1793                s: parseIso(match[7], sign),
1794                w: parseIso(match[8], sign)
1795            };
1796        } else if (duration == null) { // checks for null or undefined
1797            duration = {};
1798        } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
1799            diffRes = momentsDifference(local__createLocal(duration.from), local__createLocal(duration.to));
1800
1801            duration = {};
1802            duration.ms = diffRes.milliseconds;
1803            duration.M = diffRes.months;
1804        }
1805
1806        ret = new Duration(duration);
1807
1808        if (isDuration(input) && hasOwnProp(input, '_locale')) {
1809            ret._locale = input._locale;
1810        }
1811
1812        return ret;
1813    }
1814
1815    create__createDuration.fn = Duration.prototype;
1816
1817    function parseIso(inp, sign) {
1818        // We'd normally use ~~inp for this, but unfortunately it also
1819        // converts floats to ints.
1820        // inp may be undefined, so careful calling replace on it.
1821        var res = inp && parseFloat(inp.replace(',', '.'));
1822        // apply sign while we're at it
1823        return (isNaN(res) ? 0 : res) * sign;
1824    }
1825
1826    function positiveMomentsDifference(base, other) {
1827        var res = {
1828            milliseconds: 0,
1829            months: 0
1830        };
1831
1832        res.months = other.month() - base.month() + (other.year() - base.year()) * 12;
1833        if (base.clone().add(res.months, 'M').isAfter(other)) {
1834            --res.months;
1835        }
1836
1837        res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
1838
1839        return res;
1840    }
1841
1842    function momentsDifference(base, other) {
1843        var res;
1844        other = cloneWithOffset(other, base);
1845        if (base.isBefore(other)) {
1846            res = positiveMomentsDifference(base, other);
1847        } else {
1848            res = positiveMomentsDifference(other, base);
1849            res.milliseconds = -res.milliseconds;
1850            res.months = -res.months;
1851        }
1852
1853        return res;
1854    }
1855
1856    function createAdder(direction, name) {
1857        return function(val, period) {
1858            var dur, tmp;
1859            //invert the arguments, but complain about it
1860            if (period !== null && !isNaN(+period)) {
1861                deprecateSimple(name, 'moment().' + name + '(period, number) is deprecated. Please use moment().' + name + '(number, period).');
1862                tmp = val;
1863                val = period;
1864                period = tmp;
1865            }
1866
1867            val = typeof val === 'string' ? +val : val;
1868            dur = create__createDuration(val, period);
1869            add_subtract__addSubtract(this, dur, direction);
1870            return this;
1871        };
1872    }
1873
1874    function add_subtract__addSubtract(mom, duration, isAdding, updateOffset) {
1875        var milliseconds = duration._milliseconds,
1876            days = duration._days,
1877            months = duration._months;
1878        updateOffset = updateOffset == null ? true : updateOffset;
1879
1880        if (milliseconds) {
1881            mom._d.setTime(+mom._d + milliseconds * isAdding);
1882        }
1883        if (days) {
1884            get_set__set(mom, 'Date', get_set__get(mom, 'Date') + days * isAdding);
1885        }
1886        if (months) {
1887            setMonth(mom, get_set__get(mom, 'Month') + months * isAdding);
1888        }
1889        if (updateOffset) {
1890            utils_hooks__hooks.updateOffset(mom, days || months);
1891        }
1892    }
1893
1894    var add_subtract__add = createAdder(1, 'add');
1895    var add_subtract__subtract = createAdder(-1, 'subtract');
1896
1897    function moment_calendar__calendar(time, formats) {
1898        // We want to compare the start of today, vs this.
1899        // Getting start-of-today depends on whether we're local/utc/offset or not.
1900        var now = time || local__createLocal(),
1901            sod = cloneWithOffset(now, this).startOf('day'),
1902            diff = this.diff(sod, 'days', true),
1903            format = diff < -6 ? 'sameElse' : diff < -1 ? 'lastWeek' : diff < 0 ? 'lastDay' : diff < 1 ? 'sameDay' : diff < 2 ? 'nextDay' : diff < 7 ? 'nextWeek' : 'sameElse';
1904        return this.format(formats && formats[format] || this.localeData().calendar(format, this, local__createLocal(now)));
1905    }
1906
1907    function clone() {
1908        return new Moment(this);
1909    }
1910
1911    function isAfter(input, units) {
1912        var inputMs;
1913        units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond');
1914        if (units === 'millisecond') {
1915            input = isMoment(input) ? input : local__createLocal(input);
1916            return +this > +input;
1917        } else {
1918            inputMs = isMoment(input) ? +input : +local__createLocal(input);
1919            return inputMs < +this.clone().startOf(units);
1920        }
1921    }
1922
1923    function isBefore(input, units) {
1924        var inputMs;
1925        units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond');
1926        if (units === 'millisecond') {
1927            input = isMoment(input) ? input : local__createLocal(input);
1928            return +this < +input;
1929        } else {
1930            inputMs = isMoment(input) ? +input : +local__createLocal(input);
1931            return +this.clone().endOf(units) < inputMs;
1932        }
1933    }
1934
1935    function isBetween(from, to, units) {
1936        return this.isAfter(from, units) && this.isBefore(to, units);
1937    }
1938
1939    function isSame(input, units) {
1940        var inputMs;
1941        units = normalizeUnits(units || 'millisecond');
1942        if (units === 'millisecond') {
1943            input = isMoment(input) ? input : local__createLocal(input);
1944            return +this === +input;
1945        } else {
1946            inputMs = +local__createLocal(input);
1947            return +(this.clone().startOf(units)) <= inputMs && inputMs <= +(this.clone().endOf(units));
1948        }
1949    }
1950
1951    function diff(input, units, asFloat) {
1952        var that = cloneWithOffset(input, this),
1953            zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4,
1954            delta, output;
1955
1956        units = normalizeUnits(units);
1957
1958        if (units === 'year' || units === 'month' || units === 'quarter') {
1959            output = monthDiff(this, that);
1960            if (units === 'quarter') {
1961                output = output / 3;
1962            } else if (units === 'year') {
1963                output = output / 12;
1964            }
1965        } else {
1966            delta = this - that;
1967            output = units === 'second' ? delta / 1e3 : // 1000
1968            units === 'minute' ? delta / 6e4 : // 1000 * 60
1969            units === 'hour' ? delta / 36e5 : // 1000 * 60 * 60
1970            units === 'day' ? (delta - zoneDelta) / 864e5 : // 1000 * 60 * 60 * 24, negate dst
1971            units === 'week' ? (delta - zoneDelta) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst
1972            delta;
1973        }
1974        return asFloat ? output : absFloor(output);
1975    }
1976
1977    function monthDiff(a, b) {
1978        // difference in months
1979        var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
1980            // b is in (anchor - 1 month, anchor + 1 month)
1981            anchor = a.clone().add(wholeMonthDiff, 'months'),
1982            anchor2, adjust;
1983
1984        if (b - anchor < 0) {
1985            anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
1986            // linear across the month
1987            adjust = (b - anchor) / (anchor - anchor2);
1988        } else {
1989            anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
1990            // linear across the month
1991            adjust = (b - anchor) / (anchor2 - anchor);
1992        }
1993
1994        return -(wholeMonthDiff + adjust);
1995    }
1996
1997    utils_hooks__hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
1998
1999    function toString() {
2000        return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
2001    }
2002
2003    function moment_format__toISOString() {
2004        var m = this.clone().utc();
2005        if (0 < m.year() && m.year() <= 9999) {
2006            if ('function' === typeof Date.prototype.toISOString) {
2007                // native implementation is ~50x faster, use it when we can
2008                return this.toDate().toISOString();
2009            } else {
2010                return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
2011            }
2012        } else {
2013            return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
2014        }
2015    }
2016
2017    function format(inputString) {
2018        var output = formatMoment(this, inputString || utils_hooks__hooks.defaultFormat);

2167    function invalidAt() {
2168        return getParsingFlags(this).overflow;
2169    }
2170
2171    addFormatToken(0, ['gg', 2], 0, function() {
2172        return this.weekYear() % 100;
2173    });
2174
2175    addFormatToken(0, ['GG', 2], 0, function() {
2176        return this.isoWeekYear() % 100;
2177    });
2178
2179    function addWeekYearFormatToken(token, getter) {
2180        addFormatToken(0, [token, token.length], 0, getter);
2181    }
2182
2183    addWeekYearFormatToken('gggg', 'weekYear');
2184    addWeekYearFormatToken('ggggg', 'weekYear');
2185    addWeekYearFormatToken('GGGG', 'isoWeekYear');
2186    addWeekYearFormatToken('GGGGG', 'isoWeekYear');
2187
2188    // ALIASES
2189
2190    addUnitAlias('weekYear', 'gg');
2191    addUnitAlias('isoWeekYear', 'GG');
2192
2193    // PARSING
2194
2195    addRegexToken('G', matchSigned);
2196    addRegexToken('g', matchSigned);
2197    addRegexToken('GG', match1to2, match2);
2198    addRegexToken('gg', match1to2, match2);
2199    addRegexToken('GGGG', match1to4, match4);
2200    addRegexToken('gggg', match1to4, match4);
2201    addRegexToken('GGGGG', match1to6, match6);
2202    addRegexToken('ggggg', match1to6, match6);
2203
2204    addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function(input, week, config, token) {
2205        week[token.substr(0, 2)] = toInt(input);
2206    });
2207
2208    addWeekParseToken(['gg', 'GG'], function(input, week, config, token) {
2209        week[token] = utils_hooks__hooks.parseTwoDigitYear(input);
2210    });
2211
2212    // HELPERS
2213
2214    function weeksInYear(year, dow, doy) {
2215        return weekOfYear(local__createLocal([year, 11, 31 + dow - doy]), dow, doy).week;
2216    }
2217
2218    // MOMENTS
2219
2220    function getSetWeekYear(input) {
2221        var year = weekOfYear(this, this.localeData()._week.dow, this.localeData()._week.doy).year;
2222        return input == null ? year : this.add((input - year), 'y');
2223    }
2224
2225    function getSetISOWeekYear(input) {
2226        var year = weekOfYear(this, 1, 4).year;
2227        return input == null ? year : this.add((input - year), 'y');
2228    }
2229
2230    function getISOWeeksInYear() {
2231        return weeksInYear(this.year(), 1, 4);
2232    }
2233
2234    function getWeeksInYear() {
2235        var weekInfo = this.localeData()._week;
2236        return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
2237    }
2238
2239    addFormatToken('Q', 0, 0, 'quarter');
2240
2241    // ALIASES
2242
2243    addUnitAlias('quarter', 'Q');
2244
2245    // PARSING
2246
2247    addRegexToken('Q', match1);
2248    addParseToken('Q', function(input, array) {
2249        array[MONTH] = (toInt(input) - 1) * 3;
2250    });
2251
2252    // MOMENTS
2253
2254    function getSetQuarter(input) {
2255        return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
2256    }
2257
2258    addFormatToken('D', ['DD', 2], 'Do', 'date');
2259
2260    // ALIASES
2261
2262    addUnitAlias('date', 'D');
2263
2264    // PARSING
2265
2266    addRegexToken('D', match1to2);
2267    addRegexToken('DD', match1to2, match2);
2268    addRegexToken('Do', function(isStrict, locale) {
2269        return isStrict ? locale._ordinalParse : locale._ordinalParseLenient;
2270    });
2271
2272    addParseToken(['D', 'DD'], DATE);
2273    addParseToken('Do', function(input, array) {
2274        array[DATE] = toInt(input.match(match1to2)[0], 10);
2275    });
2276
2277    // MOMENTS
2278
2279    var getSetDayOfMonth = makeGetSet('Date', true);
2280
2281    addFormatToken('d', 0, 'do', 'day');
2282
2283    addFormatToken('dd', 0, 0, function(format) {
2284        return this.localeData().weekdaysMin(this, format);
2285    });
2286
2287    addFormatToken('ddd', 0, 0, function(format) {
2288        return this.localeData().weekdaysShort(this, format);
2289    });
2290
2291    addFormatToken('dddd', 0, 0, function(format) {
2292        return this.localeData().weekdays(this, format);
2293    });
2294
2295    addFormatToken('e', 0, 0, 'weekday');
2296    addFormatToken('E', 0, 0, 'isoWeekday');
2297
2298    // ALIASES
2299
2300    addUnitAlias('day', 'd');
2301    addUnitAlias('weekday', 'e');
2302    addUnitAlias('isoWeekday', 'E');
2303
2304    // PARSING
2305
2306    addRegexToken('d', match1to2);
2307    addRegexToken('e', match1to2);
2308    addRegexToken('E', match1to2);
2309    addRegexToken('dd', matchWord);
2310    addRegexToken('ddd', matchWord);
2311    addRegexToken('dddd', matchWord);
2312
2313    addWeekParseToken(['dd', 'ddd', 'dddd'], function(input, week, config) {
2314        var weekday = config._locale.weekdaysParse(input);
2315        // if we didn't get a weekday name, mark the date as invalid
2316        if (weekday != null) {
2317            week.d = weekday;
2318        } else {
2319            getParsingFlags(config).invalidWeekday = input;
2320        }
2321    });
2322
2323    addWeekParseToken(['d', 'e', 'E'], function(input, week, config, token) {
2324        week[token] = toInt(input);
2325    });
2326
2327    // HELPERS
2328
2329    function parseWeekday(input, locale) {
2330        if (typeof input !== 'string') {
2331            return input;
2332        }
2333
2334        if (!isNaN(input)) {
2335            return parseInt(input, 10);
2336        }
2337
2338        input = locale.weekdaysParse(input);
2339        if (typeof input === 'number') {
2340            return input;
2341        }
2342
2343        return null;
2344    }
2345
2346    // LOCALES
2347
2348    var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
2349
2350    function localeWeekdays(m) {
2351        return this._weekdays[m.day()];
2352    }
2353
2354    var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
2355
2356    function localeWeekdaysShort(m) {
2357        return this._weekdaysShort[m.day()];
2358    }
2359
2360    var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
2361
2362    function localeWeekdaysMin(m) {
2363        return this._weekdaysMin[m.day()];
2364    }
2365
2366    function localeWeekdaysParse(weekdayName) {
2367        var i, mom, regex;
2368
2369        this._weekdaysParse = this._weekdaysParse || [];
2370
2371        for (i = 0; i < 7; i++) {
2372            // make the regex if we don't have it already
2373            if (!this._weekdaysParse[i]) {
2374                mom = local__createLocal([2000, 1]).day(i);
2375                regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
2376                this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
2377            }
2378            // test the regex
2379            if (this._weekdaysParse[i].test(weekdayName)) {
2380                return i;
2381            }
2382        }
2383    }
2384
2385    // MOMENTS
2386
2387    function getSetDayOfWeek(input) {
2388        var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
2389        if (input != null) {
2390            input = parseWeekday(input, this.localeData());
2391            return this.add(input - day, 'd');
2392        } else {
2393            return day;
2394        }
2395    }
2396
2397    function getSetLocaleDayOfWeek(input) {
2398        var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
2399        return input == null ? weekday : this.add(input - weekday, 'd');
2400    }
2401
2402    function getSetISODayOfWeek(input) {
2403        // behaves the same as moment#day except
2404        // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
2405        // as a setter, sunday should belong to the previous week.
2406        return input == null ? this.day() || 7 : this.day(this.day() % 7 ? input : input - 7);
2407    }
2408
2409    addFormatToken('H', ['HH', 2], 0, 'hour');
2410    addFormatToken('h', ['hh', 2], 0, function() {
2411        return this.hours() % 12 || 12;
2412    });
2413
2414    function meridiem(token, lowercase) {
2415        addFormatToken(token, 0, 0, function() {
2416            return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
2417        });
2418    }
2419
2420    meridiem('a', true);
2421    meridiem('A', false);
2422
2423    // ALIASES
2424
2425    addUnitAlias('hour', 'h');
2426
2427    // PARSING
2428
2429    function matchMeridiem(isStrict, locale) {
2430        return locale._meridiemParse;
2431    }
2432
2433    addRegexToken('a', matchMeridiem);
2434    addRegexToken('A', matchMeridiem);
2435    addRegexToken('H', match1to2);
2436    addRegexToken('h', match1to2);
2437    addRegexToken('HH', match1to2, match2);
2438    addRegexToken('hh', match1to2, match2);
2439
2440    addParseToken(['H', 'HH'], HOUR);
2441    addParseToken(['a', 'A'], function(input, array, config) {
2442        config._isPm = config._locale.isPM(input);
2443        config._meridiem = input;
2444    });
2445    addParseToken(['h', 'hh'], function(input, array, config) {
2446        array[HOUR] = toInt(input);
2447        getParsingFlags(config).bigHour = true;
2448    });
2449
2450    // LOCALES
2451
2452    function localeIsPM(input) {
2453        // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
2454        // Using charAt should be more compatible.
2455        return ((input + '').toLowerCase().charAt(0) === 'p');
2456    }
2457
2458    var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
2459
2460    function localeMeridiem(hours, minutes, isLower) {
2461        if (hours > 11) {
2462            return isLower ? 'pm' : 'PM';
2463        } else {
2464            return isLower ? 'am' : 'AM';
2465        }
2466    }
2467
2468
2469    // MOMENTS
2470
2471    // Setting the hour should keep the time, because the user explicitly
2472    // specified which hour he wants. So trying to maintain the same hour (in
2473    // a new timezone) makes sense. Adding/subtracting hours does not follow
2474    // this rule.
2475    var getSetHour = makeGetSet('Hours', true);
2476
2477    addFormatToken('m', ['mm', 2], 0, 'minute');
2478
2479    // ALIASES
2480
2481    addUnitAlias('minute', 'm');
2482
2483    // PARSING
2484
2485    addRegexToken('m', match1to2);
2486    addRegexToken('mm', match1to2, match2);
2487    addParseToken(['m', 'mm'], MINUTE);
2488
2489    // MOMENTS
2490
2491    var getSetMinute = makeGetSet('Minutes', false);
2492
2493    addFormatToken('s', ['ss', 2], 0, 'second');
2494
2495    // ALIASES
2496
2497    addUnitAlias('second', 's');
2498
2499    // PARSING
2500
2501    addRegexToken('s', match1to2);
2502    addRegexToken('ss', match1to2, match2);
2503    addParseToken(['s', 'ss'], SECOND);
2504
2505    // MOMENTS
2506
2507    var getSetSecond = makeGetSet('Seconds', false);
2508
2509    addFormatToken('S', 0, 0, function() {
2510        return~~ (this.millisecond() / 100);
2511    });
2512
2513    addFormatToken(0, ['SS', 2], 0, function() {
2514        return~~ (this.millisecond() / 10);
2515    });
2516
2517    addFormatToken(0, ['SSS', 3], 0, 'millisecond');
2518    addFormatToken(0, ['SSSS', 4], 0, function() {
2519        return this.millisecond() * 10;
2520    });
2521    addFormatToken(0, ['SSSSS', 5], 0, function() {
2522        return this.millisecond() * 100;
2523    });
2524    addFormatToken(0, ['SSSSSS', 6], 0, function() {
2525        return this.millisecond() * 1000;
2526    });
2527    addFormatToken(0, ['SSSSSSS', 7], 0, function() {
2528        return this.millisecond() * 10000;
2529    });
2530    addFormatToken(0, ['SSSSSSSS', 8], 0, function() {
2531        return this.millisecond() * 100000;
2532    });
2533    addFormatToken(0, ['SSSSSSSSS', 9], 0, function() {
2534        return this.millisecond() * 1000000;
2535    });
2536
2537
2538    // ALIASES
2539
2540    addUnitAlias('millisecond', 'ms');
2541
2542    // PARSING
2543
2544    addRegexToken('S', match1to3, match1);
2545    addRegexToken('SS', match1to3, match2);
2546    addRegexToken('SSS', match1to3, match3);
2547
2548    var token;
2549    for (token = 'SSSS'; token.length <= 9; token += 'S') {
2550        addRegexToken(token, matchUnsigned);
2551    }
2552
2553    function parseMs(input, array) {
2554        array[MILLISECOND] = toInt(('0.' + input) * 1000);
2555    }
2556
2557    for (token = 'S'; token.length <= 9; token += 'S') {
2558        addParseToken(token, parseMs);
2559    }
2560    // MOMENTS
2561
2562    var getSetMillisecond = makeGetSet('Milliseconds', false);
2563
2564    addFormatToken('z', 0, 0, 'zoneAbbr');
2565    addFormatToken('zz', 0, 0, 'zoneName');
2566
2567    // MOMENTS
2568
2569    function getZoneAbbr() {
2570        return this._isUTC ? 'UTC' : '';
2571    }
2572
2573    function getZoneName() {
2574        return this._isUTC ? 'Coordinated Universal Time' : '';
2575    }
2576
2577    var momentPrototype__proto = Moment.prototype;
2578
2579    momentPrototype__proto.add = add_subtract__add;
2580    momentPrototype__proto.calendar = moment_calendar__calendar;
2581    momentPrototype__proto.clone = clone;
2582    momentPrototype__proto.diff = diff;
2583    momentPrototype__proto.endOf = endOf;
2584    momentPrototype__proto.format = format;
2585    momentPrototype__proto.from = from;
2586    momentPrototype__proto.fromNow = fromNow;
2587    momentPrototype__proto.to = to;
2588    momentPrototype__proto.toNow = toNow;
2589    momentPrototype__proto.get = getSet;
2590    momentPrototype__proto.invalidAt = invalidAt;
2591    momentPrototype__proto.isAfter = isAfter;
2592    momentPrototype__proto.isBefore = isBefore;
2593    momentPrototype__proto.isBetween = isBetween;
2594    momentPrototype__proto.isSame = isSame;
2595    momentPrototype__proto.isValid = moment_valid__isValid;
2596    momentPrototype__proto.lang = lang;
2597    momentPrototype__proto.locale = locale;
2598    momentPrototype__proto.localeData = localeData;
2599    momentPrototype__proto.max = prototypeMax;
2600    momentPrototype__proto.min = prototypeMin;
2601    momentPrototype__proto.parsingFlags = parsingFlags;
2602    momentPrototype__proto.set = getSet;
2603    momentPrototype__proto.startOf = startOf;
2604    momentPrototype__proto.subtract = add_subtract__subtract;
2605    momentPrototype__proto.toArray = toArray;
2606    momentPrototype__proto.toObject = toObject;
2607    momentPrototype__proto.toDate = toDate;
2608    momentPrototype__proto.toISOString = moment_format__toISOString;
2609    momentPrototype__proto.toJSON = moment_format__toISOString;
2610    momentPrototype__proto.toString = toString;
2611    momentPrototype__proto.unix = unix;
2612    momentPrototype__proto.valueOf = to_type__valueOf;
2613
2614    // Year
2615    momentPrototype__proto.year = getSetYear;
2616    momentPrototype__proto.isLeapYear = getIsLeapYear;
2617
2618    // Week Year
2619    momentPrototype__proto.weekYear = getSetWeekYear;
2620    momentPrototype__proto.isoWeekYear = getSetISOWeekYear;
2621
2622    // Quarter
2623    momentPrototype__proto.quarter = momentPrototype__proto.quarters = getSetQuarter;
2624
2625    // Month
2626    momentPrototype__proto.month = getSetMonth;
2627    momentPrototype__proto.daysInMonth = getDaysInMonth;
2628
2629    // Week
2630    momentPrototype__proto.week = momentPrototype__proto.weeks = getSetWeek;
2631    momentPrototype__proto.isoWeek = momentPrototype__proto.isoWeeks = getSetISOWeek;
2632    momentPrototype__proto.weeksInYear = getWeeksInYear;
2633    momentPrototype__proto.isoWeeksInYear = getISOWeeksInYear;
2634
2635    // Day
2636    momentPrototype__proto.date = getSetDayOfMonth;
2637    momentPrototype__proto.day = momentPrototype__proto.days = getSetDayOfWeek;
2638    momentPrototype__proto.weekday = getSetLocaleDayOfWeek;
2639    momentPrototype__proto.isoWeekday = getSetISODayOfWeek;
2640    momentPrototype__proto.dayOfYear = getSetDayOfYear;
2641
2642    // Hour
2643    momentPrototype__proto.hour = momentPrototype__proto.hours = getSetHour;
2644
2645    // Minute
2646    momentPrototype__proto.minute = momentPrototype__proto.minutes = getSetMinute;
2647
2648    // Second
2649    momentPrototype__proto.second = momentPrototype__proto.seconds = getSetSecond;
2650
2651    // Millisecond
2652    momentPrototype__proto.millisecond = momentPrototype__proto.milliseconds = getSetMillisecond;
2653
2654    // Offset
2655    momentPrototype__proto.utcOffset = getSetOffset;
2656    momentPrototype__proto.utc = setOffsetToUTC;
2657    momentPrototype__proto.local = setOffsetToLocal;
2658    momentPrototype__proto.parseZone = setOffsetToParsedOffset;
2659    momentPrototype__proto.hasAlignedHourOffset = hasAlignedHourOffset;
2660    momentPrototype__proto.isDST = isDaylightSavingTime;
2661    momentPrototype__proto.isDSTShifted = isDaylightSavingTimeShifted;
2662    momentPrototype__proto.isLocal = isLocal;
2663    momentPrototype__proto.isUtcOffset = isUtcOffset;
2664    momentPrototype__proto.isUtc = isUtc;
2665    momentPrototype__proto.isUTC = isUtc;
2666
2667    // Timezone
2668    momentPrototype__proto.zoneAbbr = getZoneAbbr;
2669    momentPrototype__proto.zoneName = getZoneName;
2670
2671    // Deprecations
2672    momentPrototype__proto.dates = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
2673    momentPrototype__proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
2674    momentPrototype__proto.years = deprecate('years accessor is deprecated. Use year instead', getSetYear);
2675    momentPrototype__proto.zone = deprecate('moment().zone is deprecated, use moment().utcOffset instead. https://github.com/moment/moment/issues/1779', getSetZone);
2676
2677    var momentPrototype = momentPrototype__proto;
2678
2679    function moment__createUnix(input) {
2680        return local__createLocal(input * 1000);
2681    }
2682
2683    function moment__createInZone() {
2684        return local__createLocal.apply(null, arguments).parseZone();
2685    }
2686
2687    var defaultCalendar = {
2688        sameDay: '[Today at] LT',
2689        nextDay: '[Tomorrow at] LT',
2690        nextWeek: 'dddd [at] LT',
2691        lastDay: '[Yesterday at] LT',
2692        lastWeek: '[Last] dddd [at] LT',
2693        sameElse: 'L'
2694    };
2695
2696    function locale_calendar__calendar(key, mom, now) {
2697        var output = this._calendar[key];
2698        return typeof output === 'function' ? output.call(mom, now) : output;
2699    }
2700
2701    var defaultLongDateFormat = {
2702        LTS: 'h:mm:ss A',
2703        LT: 'h:mm A',
2704        L: 'MM/DD/YYYY',
2705        LL: 'MMMM D, YYYY',
2706        LLL: 'MMMM D, YYYY h:mm A',
2707        LLLL: 'dddd, MMMM D, YYYY h:mm A'
2708    };
2709
2710    function longDateFormat(key) {
2711        var format = this._longDateFormat[key],
2712            formatUpper = this._longDateFormat[key.toUpperCase()];
2713
2714        if (format || !formatUpper) {
2715            return format;
2716        }
2717
2718        this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function(val) {
2719            return val.slice(1);
2720        });
2721
2722        return this._longDateFormat[key];
2723    }
2724
2725    var defaultInvalidDate = 'Invalid date';
2726
2727    function invalidDate() {
2728        return this._invalidDate;
2729    }
2730
2731    var defaultOrdinal = '%d';
2732    var defaultOrdinalParse = /\d{1,2}/;
2733
2734    function ordinal(number) {
2735        return this._ordinal.replace('%d', number);
2736    }
2737
2738    function preParsePostFormat(string) {
2739        return string;
2740    }
2741
2742    var defaultRelativeTime = {
2743        future: 'in %s',
2744        past: '%s ago',
2745        s: 'a few seconds',
2746        m: 'a minute',
2747        mm: '%d minutes',
2748        h: 'an hour',
2749        hh: '%d hours',
2750        d: 'a day',
2751        dd: '%d days',
2752        M: 'a month',
2753        MM: '%d months',
2754        y: 'a year',
2755        yy: '%d years'
2756    };
2757
2758    function relative__relativeTime(number, withoutSuffix, string, isFuture) {
2759        var output = this._relativeTime[string];
2760        return (typeof output === 'function') ? output(number, withoutSuffix, string, isFuture) : output.replace(/%d/i, number);
2761    }
2762
2763    function pastFuture(diff, output) {
2764        var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
2765        return typeof format === 'function' ? format(output) : format.replace(/%s/i, output);
2766    }
2767
2768    function locale_set__set(config) {
2769        var prop, i;
2770        for (i in config) {
2771            prop = config[i];
2772            if (typeof prop === 'function') {
2773                this[i] = prop;
2774            } else {
2775                this['_' + i] = prop;
2776            }
2777        }
2778        // Lenient ordinal parsing accepts just a number in addition to
2779        // number + (possibly) stuff coming from _ordinalParseLenient.
2780        this._ordinalParseLenient = new RegExp(this._ordinalParse.source + '|' + (/\d{1,2}/).source);
2781    }
2782
2783    var prototype__proto = Locale.prototype;
2784
2785    prototype__proto._calendar = defaultCalendar;
2786    prototype__proto.calendar = locale_calendar__calendar;
2787    prototype__proto._longDateFormat = defaultLongDateFormat;
2788    prototype__proto.longDateFormat = longDateFormat;
2789    prototype__proto._invalidDate = defaultInvalidDate;
2790    prototype__proto.invalidDate = invalidDate;
2791    prototype__proto._ordinal = defaultOrdinal;
2792    prototype__proto.ordinal = ordinal;
2793    prototype__proto._ordinalParse = defaultOrdinalParse;
2794    prototype__proto.preparse = preParsePostFormat;
2795    prototype__proto.postformat = preParsePostFormat;
2796    prototype__proto._relativeTime = defaultRelativeTime;
2797    prototype__proto.relativeTime = relative__relativeTime;
2798    prototype__proto.pastFuture = pastFuture;
2799    prototype__proto.set = locale_set__set;
2800
2801    // Month
2802    prototype__proto.months = localeMonths;
2803    prototype__proto._months = defaultLocaleMonths;
2804    prototype__proto.monthsShort = localeMonthsShort;
2805    prototype__proto._monthsShort = defaultLocaleMonthsShort;
2806    prototype__proto.monthsParse = localeMonthsParse;
2807
2808    // Week
2809    prototype__proto.week = localeWeek;
2810    prototype__proto._week = defaultLocaleWeek;
2811    prototype__proto.firstDayOfYear = localeFirstDayOfYear;
2812    prototype__proto.firstDayOfWeek = localeFirstDayOfWeek;
2813
2814    // Day of Week
2815    prototype__proto.weekdays = localeWeekdays;
2816    prototype__proto._weekdays = defaultLocaleWeekdays;
2817    prototype__proto.weekdaysMin = localeWeekdaysMin;
2818    prototype__proto._weekdaysMin = defaultLocaleWeekdaysMin;
2819    prototype__proto.weekdaysShort = localeWeekdaysShort;
2820    prototype__proto._weekdaysShort = defaultLocaleWeekdaysShort;
2821    prototype__proto.weekdaysParse = localeWeekdaysParse;
2822
2823    // Hours
2824    prototype__proto.isPM = localeIsPM;
2825    prototype__proto._meridiemParse = defaultLocaleMeridiemParse;
2826    prototype__proto.meridiem = localeMeridiem;
2827
2828    function lists__get(format, index, field, setter) {
2829        var locale = locale_locales__getLocale();
2830        var utc = create_utc__createUTC().set(setter, index);
2831        return locale[field](utc, format);
2832    }
2833
2834    function list(format, index, field, count, setter) {
2835        if (typeof format === 'number') {
2836            index = format;
2837            format = undefined;
2838        }
2839
2840        format = format || '';
2841
2842        if (index != null) {
2843            return lists__get(format, index, field, setter);
2844        }
2845
2846        var i;
2847        var out = [];
2848        for (i = 0; i < count; i++) {
2849            out[i] = lists__get(format, i, field, setter);
2850        }
2851        return out;
2852    }
2853
2854    function lists__listMonths(format, index) {
2855        return list(format, index, 'months', 12, 'month');
2856    }
2857
2858    function lists__listMonthsShort(format, index) {
2859        return list(format, index, 'monthsShort', 12, 'month');
2860    }
2861
2862    function lists__listWeekdays(format, index) {
2863        return list(format, index, 'weekdays', 7, 'day');
2864    }
2865
2866    function lists__listWeekdaysShort(format, index) {
2867        return list(format, index, 'weekdaysShort', 7, 'day');
2868    }
2869
2870    function lists__listWeekdaysMin(format, index) {
2871        return list(format, index, 'weekdaysMin', 7, 'day');
2872    }
2873
2874    locale_locales__getSetGlobalLocale('en', {
2875        ordinalParse: /\d{1,2}(th|st|nd|rd)/,
2876        ordinal: function(number) {
2877            var b = number % 10,
2878                output = (toInt(number % 100 / 10) === 1) ? 'th' : (b === 1) ? 'st' : (b === 2) ? 'nd' : (b === 3) ? 'rd' : 'th';
2879            return number + output;
2880        }
2881    });
2882
2883    // Side effect imports
2884    utils_hooks__hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', locale_locales__getSetGlobalLocale);
2885    utils_hooks__hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', locale_locales__getLocale);
2886
2887    var mathAbs = Math.abs;
2888
2889    function duration_abs__abs() {
2890        var data = this._data;
2891
2892        this._milliseconds = mathAbs(this._milliseconds);
2893        this._days = mathAbs(this._days);
2894        this._months = mathAbs(this._months);
2895
2896        data.milliseconds = mathAbs(data.milliseconds);
2897        data.seconds = mathAbs(data.seconds);
2898        data.minutes = mathAbs(data.minutes);
2899        data.hours = mathAbs(data.hours);
2900        data.months = mathAbs(data.months);
2901        data.years = mathAbs(data.years);
2902
2903        return this;
2904    }
2905
2906    function duration_add_subtract__addSubtract(duration, input, value, direction) {
2907        var other = create__createDuration(input, value);
2908
2909        duration._milliseconds += direction * other._milliseconds;
2910        duration._days += direction * other._days;
2911        duration._months += direction * other._months;
2912
2913        return duration._bubble();
2914    }
2915
2916    // supports only 2.0-style add(1, 's') or add(duration)
2917    function duration_add_subtract__add(input, value) {
2918        return duration_add_subtract__addSubtract(this, input, value, 1);
2919    }
2920
2921    // supports only 2.0-style subtract(1, 's') or subtract(duration)
2922    function duration_add_subtract__subtract(input, value) {
2923        return duration_add_subtract__addSubtract(this, input, value, - 1);
2924    }
2925
2926    function absCeil(number) {
2927        if (number < 0) {
2928            return Math.floor(number);
2929        } else {
2930            return Math.ceil(number);
2931        }
2932    }
2933
2934    function bubble() {
2935        var milliseconds = this._milliseconds;
2936        var days = this._days;
2937        var months = this._months;
2938        var data = this._data;
2939        var seconds, minutes, hours, years, monthsFromDays;
2940
2941        // if we have a mix of positive and negative values, bubble down first
2942        // check: https://github.com/moment/moment/issues/2166
2943        if (!((milliseconds >= 0 && days >= 0 && months >= 0) || (milliseconds <= 0 && days <= 0 && months <= 0))) {
2944            milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
2945            days = 0;
2946            months = 0;
2947        }
2948
2949        // The following code bubbles up values, see the tests for
2950        // examples of what that means.
2951        data.milliseconds = milliseconds % 1000;
2952
2953        seconds = absFloor(milliseconds / 1000);
2954        data.seconds = seconds % 60;
2955
2956        minutes = absFloor(seconds / 60);
2957        data.minutes = minutes % 60;
2958
2959        hours = absFloor(minutes / 60);
2960        data.hours = hours % 24;
2961
2962        days += absFloor(hours / 24);
2963
2964        // convert days to months
2965        monthsFromDays = absFloor(daysToMonths(days));
2966        months += monthsFromDays;
2967        days -= absCeil(monthsToDays(monthsFromDays));
2968
2969        // 12 months -> 1 year
2970        years = absFloor(months / 12);
2971        months %= 12;
2972
2973        data.days = days;
2974        data.months = months;
2975        data.years = years;
2976
2977        return this;
2978    }
2979
2980    function daysToMonths(days) {
2981        // 400 years have 146097 days (taking into account leap year rules)
2982        // 400 years have 12 months === 4800
2983        return days * 4800 / 146097;
2984    }
2985
2986    function monthsToDays(months) {
2987        // the reverse of daysToMonths
2988        return months * 146097 / 4800;
2989    }
2990
2991    function as(units) {
2992        var days;
2993        var months;
2994        var milliseconds = this._milliseconds;
2995
2996        units = normalizeUnits(units);
2997
2998        if (units === 'month' || units === 'year') {
2999            days = this._days + milliseconds / 864e5;
3000            months = this._months + daysToMonths(days);
3001            return units === 'month' ? months : months / 12;
3002        } else {
3003            // handle milliseconds separately because of floating point math errors (issue #1867)
3004            days = this._days + Math.round(monthsToDays(this._months));
3005            switch (units) {
3006                case 'week':
3007                    return days / 7 + milliseconds / 6048e5;
3008                case 'day':
3009                    return days + milliseconds / 864e5;
3010                case 'hour':
3011                    return days * 24 + milliseconds / 36e5;
3012                case 'minute':
3013                    return days * 1440 + milliseconds / 6e4;
3014                case 'second':
3015                    return days * 86400 + milliseconds / 1000;
3016                    // Math.floor prevents floating point math errors here
3017                case 'millisecond':
3018                    return Math.floor(days * 864e5) + milliseconds;
3019                default:
3020                    throw new Error('Unknown unit ' + units);
3021            }
3022        }
3023    }
3024
3025    // TODO: Use this.as('ms')?
3026    function duration_as__valueOf() {
3027        return (
3028        this._milliseconds + this._days * 864e5 + (this._months % 12) * 2592e6 + toInt(this._months / 12) * 31536e6);
3029    }
3030
3031    function makeAs(alias) {
3032        return function() {
3033            return this.as(alias);
3034        };
3035    }
3036
3037    var asMilliseconds = makeAs('ms');
3038    var asSeconds = makeAs('s');
3039    var asMinutes = makeAs('m');
3040    var asHours = makeAs('h');
3041    var asDays = makeAs('d');
3042    var asWeeks = makeAs('w');
3043    var asMonths = makeAs('M');
3044    var asYears = makeAs('y');
3045
3046    function duration_get__get(units) {
3047        units = normalizeUnits(units);
3048        return this[units + 's']();
3049    }
3050
3051    function makeGetter(name) {
3052        return function() {
3053            return this._data[name];
3054        };
3055    }
3056
3057    var milliseconds = makeGetter('milliseconds');
3058    var seconds = makeGetter('seconds');
3059    var minutes = makeGetter('minutes');
3060    var hours = makeGetter('hours');
3061    var days = makeGetter('days');
3062    var months = makeGetter('months');
3063    var years = makeGetter('years');
3064
3065    function weeks() {
3066        return absFloor(this.days() / 7);
3067    }
3068
3069    var round = Math.round;
3070    var thresholds = {
3071        s: 45, // seconds to minute
3072        m: 45, // minutes to hour
3073        h: 22, // hours to day
3074        d: 26, // days to month
3075        M: 11 // months to year
3076    };
3077
3078    // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
3079    function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
3080        return locale.relativeTime(number || 1, !! withoutSuffix, string, isFuture);
3081    }
3082
3083    function duration_humanize__relativeTime(posNegDuration, withoutSuffix, locale) {
3084        var duration = create__createDuration(posNegDuration).abs();
3085        var seconds = round(duration.as('s'));
3086        var minutes = round(duration.as('m'));
3087        var hours = round(duration.as('h'));
3088        var days = round(duration.as('d'));
3089        var months = round(duration.as('M'));
3090        var years = round(duration.as('y'));
3091
3092        var a = seconds < thresholds.s && ['s', seconds] || minutes === 1 && ['m'] || minutes < thresholds.m && ['mm', minutes] || hours === 1 && ['h'] || hours < thresholds.h && ['hh', hours] || days === 1 && ['d'] || days < thresholds.d && ['dd', days] || months === 1 && ['M'] || months < thresholds.M && ['MM', months] || years === 1 && ['y'] || ['yy', years];
3093
3094        a[2] = withoutSuffix;
3095        a[3] = +posNegDuration > 0;
3096        a[4] = locale;
3097        return substituteTimeAgo.apply(null, a);
3098    }
3099
3100    // This function allows you to set a threshold for relative time strings
3101    function duration_humanize__getSetRelativeTimeThreshold(threshold, limit) {
3102        if (thresholds[threshold] === undefined) {
3103            return false;