https://mportal.cau.ac.kr/common/js/angular-input-masks-standalone.js

729        return createLocalOrUTC(input, format, locale, strict, true).utc();
730    }
731
732    function defaultParsingFlags() {
733        // We need to deep clone this object.
734        return {
735            empty           : false,
736            unusedTokens    : [],
737            unusedInput     : [],
738            overflow        : -2,
739            charsLeftOver   : 0,
740            nullInput       : false,
741            invalidMonth    : null,
742            invalidFormat   : false,
743            userInvalidated : false,
744            iso             : false,
745            parsedDateParts : [],
746            meridiem        : null
747        };
748    }
749
750    function getParsingFlags(m) {
751        if (m._pf == null) {
752            m._pf = defaultParsingFlags();
753        }
754        return m._pf;
755    }
756
757    var some;
758    if (Array.prototype.some) {
759        some = Array.prototype.some;
760    } else {
761        some = function (fun) {
762            var t = Object(this);
763            var len = t.length >>> 0;
764
765            for (var i = 0; i < len; i++) {
766                if (i in t && fun.call(this, t[i], i, t)) {
767                    return true;
768                }
769            }
770
771            return false;
772        };
773    }
774
775    function valid__isValid(m) {
776        if (m._isValid == null) {
777            var flags = getParsingFlags(m);
778            var parsedParts = some.call(flags.parsedDateParts, function (i) {
779                return i != null;
780            });
781            m._isValid = !isNaN(m._d.getTime()) &&
782                flags.overflow < 0 &&
783                !flags.empty &&
784                !flags.invalidMonth &&
785                !flags.invalidWeekday &&
786                !flags.nullInput &&
787                !flags.invalidFormat &&
788                !flags.userInvalidated &&
789                (!flags.meridiem || (flags.meridiem && parsedParts));
790
791            if (m._strict) {
792                m._isValid = m._isValid &&
793                    flags.charsLeftOver === 0 &&
794                    flags.unusedTokens.length === 0 &&
795                    flags.bigHour === undefined;
796            }
797        }
798        return m._isValid;
799    }
800
801    function valid__createInvalid (flags) {
802        var m = create_utc__createUTC(NaN);
803        if (flags != null) {
804            extend(getParsingFlags(m), flags);
805        }
806        else {
807            getParsingFlags(m).userInvalidated = true;
808        }
809
810        return m;
811    }
812
813    function isUndefined(input) {
814        return input === void 0;
815    }
816
817    // Plugins that add properties should also add the key here (null value),
818    // so we can properly clone ourselves.
819    var momentProperties = utils_hooks__hooks.momentProperties = [];
820
821    function copyConfig(to, from) {
822        var i, prop, val;
823
824        if (!isUndefined(from._isAMomentObject)) {
825            to._isAMomentObject = from._isAMomentObject;
826        }
827        if (!isUndefined(from._i)) {
828            to._i = from._i;
829        }
830        if (!isUndefined(from._f)) {
831            to._f = from._f;
832        }
833        if (!isUndefined(from._l)) {
834            to._l = from._l;
835        }
836        if (!isUndefined(from._strict)) {
837            to._strict = from._strict;
838        }
839        if (!isUndefined(from._tzm)) {
840            to._tzm = from._tzm;
841        }
842        if (!isUndefined(from._isUTC)) {
843            to._isUTC = from._isUTC;
844        }
845        if (!isUndefined(from._offset)) {
846            to._offset = from._offset;
847        }
848        if (!isUndefined(from._pf)) {
849            to._pf = getParsingFlags(from);
850        }
851        if (!isUndefined(from._locale)) {
852            to._locale = from._locale;
853        }
854
855        if (momentProperties.length > 0) {
856            for (i in momentProperties) {
857                prop = momentProperties[i];
858                val = from[prop];
859                if (!isUndefined(val)) {
860                    to[prop] = val;
861                }
862            }
863        }
864
865        return to;
866    }
867
868    var updateInProgress = false;
869
870    // Moment prototype object
871    function Moment(config) {
872        copyConfig(this, config);
873        this._d = new Date(config._d != null ? config._d.getTime() : NaN);
874        // Prevent infinite loop in case updateOffset creates new moment
875        // objects.
876        if (updateInProgress === false) {
877            updateInProgress = true;
878            utils_hooks__hooks.updateOffset(this);
879            updateInProgress = false;
880        }
881    }
882
883    function isMoment (obj) {
884        return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
885    }
886
887    function absFloor (number) {
888        if (number < 0) {
889            // -0 -> 0
890            return Math.ceil(number) || 0;
891        } else {
892            return Math.floor(number);
893        }
894    }
895
896    function toInt(argumentForCoercion) {
897        var coercedNumber = +argumentForCoercion,
898            value = 0;
899
900        if (coercedNumber !== 0 && isFinite(coercedNumber)) {
901            value = absFloor(coercedNumber);
902        }
903
904        return value;
905    }
906
907    // compare two arrays, return the number of differences
908    function compareArrays(array1, array2, dontConvert) {
909        var len = Math.min(array1.length, array2.length),
910            lengthDiff = Math.abs(array1.length - array2.length),
911            diffs = 0,
912            i;
913        for (i = 0; i < len; i++) {
914            if ((dontConvert && array1[i] !== array2[i]) ||
915                (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
916                diffs++;
917            }
918        }
919        return diffs + lengthDiff;
920    }
921
922    function warn(msg) {
923        if (utils_hooks__hooks.suppressDeprecationWarnings === false &&
924                (typeof console !==  'undefined') && console.warn) {
925            console.warn('Deprecation warning: ' + msg);
926        }
927    }
928
929    function deprecate(msg, fn) {
930        var firstTime = true;
931
932        return extend(function () {
933            if (utils_hooks__hooks.deprecationHandler != null) {
934                utils_hooks__hooks.deprecationHandler(null, msg);
935            }
936            if (firstTime) {
937                warn(msg + '\nArguments: ' + Array.prototype.slice.call(arguments).join(', ') + '\n' + (new Error()).stack);
938                firstTime = false;
939            }
940            return fn.apply(this, arguments);
941        }, fn);
942    }
943
944    var deprecations = {};
945
946    function deprecateSimple(name, msg) {
947        if (utils_hooks__hooks.deprecationHandler != null) {
948            utils_hooks__hooks.deprecationHandler(name, msg);
949        }
950        if (!deprecations[name]) {
951            warn(msg);
952            deprecations[name] = true;
953        }
954    }
955
956    utils_hooks__hooks.suppressDeprecationWarnings = false;
957    utils_hooks__hooks.deprecationHandler = null;
958
959    function isFunction(input) {
960        return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';
961    }
962
963    function locale_set__set (config) {
964        var prop, i;
965        for (i in config) {
966            prop = config[i];
967            if (isFunction(prop)) {
968                this[i] = prop;
969            } else {
970                this['_' + i] = prop;
971            }
972        }
973        this._config = config;
974        // Lenient ordinal parsing accepts just a number in addition to
975        // number + (possibly) stuff coming from _ordinalParseLenient.
976        this._ordinalParseLenient = new RegExp(this._ordinalParse.source + '|' + (/\d{1,2}/).source);
977    }
978
979    function mergeConfigs(parentConfig, childConfig) {
980        var res = extend({}, parentConfig), prop;
981        for (prop in childConfig) {
982            if (hasOwnProp(childConfig, prop)) {
983                if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
984                    res[prop] = {};
985                    extend(res[prop], parentConfig[prop]);
986                    extend(res[prop], childConfig[prop]);
987                } else if (childConfig[prop] != null) {
988                    res[prop] = childConfig[prop];
989                } else {
990                    delete res[prop];
991                }
992            }
993        }
994        for (prop in parentConfig) {
995            if (hasOwnProp(parentConfig, prop) &&
996                    !hasOwnProp(childConfig, prop) &&
997                    isObject(parentConfig[prop])) {
998                // make sure changes to properties don't modify parent config
999                res[prop] = extend({}, res[prop]);
1000            }
1001        }
1002        return res;
1003    }
1004
1005    function Locale(config) {
1006        if (config != null) {
1007            this.set(config);
1008        }
1009    }
1010
1011    var keys;
1012
1013    if (Object.keys) {
1014        keys = Object.keys;
1015    } else {
1016        keys = function (obj) {
1017            var i, res = [];
1018            for (i in obj) {
1019                if (hasOwnProp(obj, i)) {
1020                    res.push(i);
1021                }
1022            }
1023            return res;
1024        };
1025    }
1026
1027    var defaultCalendar = {
1028        sameDay : '[Today at] LT',
1029        nextDay : '[Tomorrow at] LT',
1030        nextWeek : 'dddd [at] LT',
1031        lastDay : '[Yesterday at] LT',
1032        lastWeek : '[Last] dddd [at] LT',
1033        sameElse : 'L'
1034    };
1035
1036    function locale_calendar__calendar (key, mom, now) {
1037        var output = this._calendar[key] || this._calendar['sameElse'];
1038        return isFunction(output) ? output.call(mom, now) : output;
1039    }
1040
1041    var defaultLongDateFormat = {
1042        LTS  : 'h:mm:ss A',
1043        LT   : 'h:mm A',
1044        L    : 'MM/DD/YYYY',
1045        LL   : 'MMMM D, YYYY',
1046        LLL  : 'MMMM D, YYYY h:mm A',
1047        LLLL : 'dddd, MMMM D, YYYY h:mm A'
1048    };
1049
1050    function longDateFormat (key) {
1051        var format = this._longDateFormat[key],
1052            formatUpper = this._longDateFormat[key.toUpperCase()];
1053
1054        if (format || !formatUpper) {
1055            return format;
1056        }
1057
1058        this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
1059            return val.slice(1);
1060        });
1061
1062        return this._longDateFormat[key];
1063    }
1064
1065    var defaultInvalidDate = 'Invalid date';
1066

1209|x|X|zz?|ZZ?|.)/g;
1210
1211    var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
1212
1213    var formatFunctions = {};
1214
1215    var formatTokenFunctions = {};
1216
1217    // token:    'M'
1218    // padded:   ['MM', 2]
1219    // ordinal:  'Mo'
1220    // callback: function () { this.month() + 1 }
1221    function addFormatToken (token, padded, ordinal, callback) {
1222        var func = callback;
1223        if (typeof callback === 'string') {
1224            func = function () {
1225                return this[callback]();
1226            };
1227        }
1228        if (token) {
1229            formatTokenFunctions[token] = func;
1230        }
1231        if (padded) {
1232            formatTokenFunctions[padded[0]] = function () {
1233                return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
1234            };
1235        }
1236        if (ordinal) {
1237            formatTokenFunctions[ordinal] = function () {
1238                return this.localeData().ordinal(func.apply(this, arguments), token);
1239            };
1240        }
1241    }
1242
1243    function removeFormattingTokens(input) {
1244        if (input.match(/\[[\s\S]/)) {
1245            return input.replace(/^\[|\]$/g, '');
1246        }
1247        return input.replace(/\\/g, '');
1248    }
1249
1250    function makeFormatFunction(format) {
1251        var array = format.match(formattingTokens), i, length;
1252
1253        for (i = 0, length = array.length; i < length; i++) {
1254            if (formatTokenFunctions[array[i]]) {
1255                array[i] = formatTokenFunctions[array[i]];
1256            } else {
1257                array[i] = removeFormattingTokens(array[i]);
1258            }
1259        }
1260
1261        return function (mom) {
1262            var output = '', i;
1263            for (i = 0; i < length; i++) {
1264                output += array[i] instanceof Function ? array[i].call(mom, format) : array[i];
1265            }
1266            return output;
1267        };
1268    }
1269
1270    // format date using native date object
1271    function formatMoment(m, format) {
1272        if (!m.isValid()) {
1273            return m.localeData().invalidDate();
1274        }
1275
1276        format = expandFormat(format, m.localeData());
1277        formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);
1278
1279        return formatFunctions[format](m);
1280    }
1281
1282    function expandFormat(format, locale) {
1283        var i = 5;
1284
1285        function replaceLongDateFormatTokens(input) {
1286            return locale.longDateFormat(input) || input;
1287        }
1288
1289        localFormattingTokens.lastIndex = 0;
1290        while (i >= 0 && localFormattingTokens.test(format)) {
1291            format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
1292            localFormattingTokens.lastIndex = 0;
1293            i -= 1;
1294        }
1295
1296        return format;
1297    }
1298
1299    var match1         = /\d/;            //       0 - 9
1300    var match2         = /\d\d/;          //      00 - 99
1301    var match3         = /\d{3}/;         //     000 - 999
1302    var match4         = /\d{4}/;         //    0000 - 9999
1303    var match6         = /[+-]?\d{6}/;    // -999999 - 999999
1304    var match1to2      = /\d\d?/;         //       0 - 99
1305    var match3to4      = /\d\d\d\d?/;     //     999 - 9999
1306    var match5to6      = /\d\d\d\d\d\d?/; //   99999 - 999999
1307    var match1to3      = /\d{1,3}/;       //       0 - 999
1308    var match1to4      = /\d{1,4}/;       //       0 - 9999
1309    var match1to6      = /[+-]?\d{1,6}/;  // -999999 - 999999
1310
1311    var matchUnsigned  = /\d+/;           //       0 - inf
1312    var matchSigned    = /[+-]?\d+/;      //    -inf - inf
1313
1314    var matchOffset    = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
1315    var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z
1316
1317    var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
1318
1319    // any word (or two) characters or numbers including two/three word month in arabic.
1320    // includes scottish gaelic two word and hyphenated months
1321    var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
1322
1323
1324    var regexes = {};
1325
1326    function addRegexToken (token, regex, strictRegex) {
1327        regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
1328            return (isStrict && strictRegex) ? strictRegex : regex;
1329        };
1330    }
1331
1332    function getParseRegexForToken (token, config) {
1333        if (!hasOwnProp(regexes, token)) {
1334            return new RegExp(unescapeFormat(token));
1335        }
1336
1337        return regexes[token](config._strict, config._locale);
1338    }
1339
1340    // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
1341    function unescapeFormat(s) {
1342        return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
1343            return p1 || p2 || p3 || p4;
1344        }));
1345    }
1346
1347    function regexEscape(s) {
1348        return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
1349    }
1350
1351    var tokens = {};
1352
1353    function addParseToken (token, callback) {
1354        var i, func = callback;
1355        if (typeof token === 'string') {
1356            token = [token];
1357        }
1358        if (typeof callback === 'number') {
1359            func = function (input, array) {
1360                array[callback] = toInt(input);
1361            };
1362        }
1363        for (i = 0; i < token.length; i++) {
1364            tokens[token[i]] = func;
1365        }
1366    }
1367
1368    function addWeekParseToken (token, callback) {
1369        addParseToken(token, function (input, array, config, token) {
1370            config._w = config._w || {};
1371            callback(input, config._w, config, token);
1372        });
1373    }
1374
1375    function addTimeToArrayFromToken(token, input, config) {
1376        if (input != null && hasOwnProp(tokens, token)) {
1377            tokens[token](input, config._a, config, token);
1378        }
1379    }
1380
1381    var YEAR = 0;
1382    var MONTH = 1;
1383    var DATE = 2;
1384    var HOUR = 3;
1385    var MINUTE = 4;
1386    var SECOND = 5;
1387    var MILLISECOND = 6;
1388    var WEEK = 7;
1389    var WEEKDAY = 8;
1390
1391    var indexOf;
1392
1393    if (Array.prototype.indexOf) {
1394        indexOf = Array.prototype.indexOf;
1395    } else {
1396        indexOf = function (o) {
1397            // I know
1398            var i;
1399            for (i = 0; i < this.length; ++i) {
1400                if (this[i] === o) {
1401                    return i;
1402                }
1403            }
1404            return -1;
1405        };
1406    }
1407
1408    function daysInMonth(year, month) {
1409        return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
1410    }
1411
1412    // FORMATTING
1413
1414    addFormatToken('M', ['MM', 2], 'Mo', function () {
1415        return this.month() + 1;
1416    });
1417
1418    addFormatToken('MMM', 0, 0, function (format) {
1419        return this.localeData().monthsShort(this, format);
1420    });
1421
1422    addFormatToken('MMMM', 0, 0, function (format) {
1423        return this.localeData().months(this, format);
1424    });
1425
1426    // ALIASES
1427
1428    addUnitAlias('month', 'M');
1429
1430    // PRIORITY
1431
1432    addUnitPriority('month', 8);
1433
1434    // PARSING
1435
1436    addRegexToken('M',    match1to2);
1437    addRegexToken('MM',   match1to2, match2);
1438    addRegexToken('MMM',  function (isStrict, locale) {
1439        return locale.monthsShortRegex(isStrict);
1440    });
1441    addRegexToken('MMMM', function (isStrict, locale) {
1442        return locale.monthsRegex(isStrict);
1443    });
1444
1445    addParseToken(['M', 'MM'], function (input, array) {
1446        array[MONTH] = toInt(input) - 1;
1447    });
1448
1449    addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
1450        var month = config._locale.monthsParse(input, token, config._strict);
1451        // if we didn't find a month name, mark the date as invalid.
1452        if (month != null) {
1453            array[MONTH] = month;
1454        } else {
1455            getParsingFlags(config).invalidMonth = input;
1456        }
1457    });
1458
1459    // LOCALES
1460
1461    var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s+)+MMMM?/;
1462    var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
1463    function localeMonths (m, format) {
1464        return isArray(this._months) ? this._months[m.month()] :
1465            this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];
1466    }
1467
1468    var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
1469    function localeMonthsShort (m, format) {
1470        return isArray(this._monthsShort) ? this._monthsShort[m.month()] :
1471            this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
1472    }
1473
1474    function units_month__handleStrictParse(monthName, format, strict) {
1475        var i, ii, mom, llc = monthName.toLocaleLowerCase();
1476        if (!this._monthsParse) {
1477            // this is not used
1478            this._monthsParse = [];
1479            this._longMonthsParse = [];
1480            this._shortMonthsParse = [];
1481            for (i = 0; i < 12; ++i) {
1482                mom = create_utc__createUTC([2000, i]);
1483                this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();
1484                this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
1485            }
1486        }
1487
1488        if (strict) {
1489            if (format === 'MMM') {
1490                ii = indexOf.call(this._shortMonthsParse, llc);
1491                return ii !== -1 ? ii : null;
1492            } else {
1493                ii = indexOf.call(this._longMonthsParse, llc);
1494                return ii !== -1 ? ii : null;
1495            }
1496        } else {
1497            if (format === 'MMM') {
1498                ii = indexOf.call(this._shortMonthsParse, llc);
1499                if (ii !== -1) {
1500                    return ii;
1501                }
1502                ii = indexOf.call(this._longMonthsParse, llc);
1503                return ii !== -1 ? ii : null;
1504            } else {
1505                ii = indexOf.call(this._longMonthsParse, llc);
1506                if (ii !== -1) {
1507                    return ii;
1508                }
1509                ii = indexOf.call(this._shortMonthsParse, llc);
1510                return ii !== -1 ? ii : null;
1511            }
1512        }
1513    }
1514
1515    function localeMonthsParse (monthName, format, strict) {
1516        var i, mom, regex;
1517
1518        if (this._monthsParseExact) {
1519            return units_month__handleStrictParse.call(this, monthName, format, strict);
1520        }
1521
1522        if (!this._monthsParse) {
1523            this._monthsParse = [];
1524            this._longMonthsParse = [];
1525            this._shortMonthsParse = [];
1526        }
1527
1528        // TODO: add sorting
1529        // Sorting makes sure if one month (or abbr) is a prefix of another
1530        // see sorting in computeMonthsParse
1531        for (i = 0; i < 12; i++) {
1532            // make the regex if we don't have it already
1533            mom = create_utc__createUTC([2000, i]);
1534            if (strict && !this._longMonthsParse[i]) {
1535                this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
1536                this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
1537            }
1538            if (!strict && !this._monthsParse[i]) {
1539                regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
1540                this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
1541            }
1542            // test the regex
1543            if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
1544                return i;
1545            } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
1546                return i;
1547            } else if (!strict && this._monthsParse[i].test(monthName)) {
1548                return i;
1549            }
1550        }
1551    }
1552
1553    // MOMENTS
1554
1555    function setMonth (mom, value) {
1556        var dayOfMonth;
1557
1558        if (!mom.isValid()) {
1559            // No op
1560            return mom;
1561        }
1562
1563        if (typeof value === 'string') {
1564            if (/^\d+$/.test(value)) {
1565                value = toInt(value);
1566            } else {
1567                value = mom.localeData().monthsParse(value);
1568                // TODO: Another silent failure?
1569                if (typeof value !== 'number') {
1570                    return mom;
1571                }
1572            }
1573        }
1574
1575        dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
1576        mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
1577        return mom;
1578    }
1579
1580    function getSetMonth (value) {
1581        if (value != null) {
1582            setMonth(this, value);
1583            utils_hooks__hooks.updateOffset(this, true);
1584            return this;
1585        } else {
1586            return get_set__get(this, 'Month');
1587        }
1588    }
1589
1590    function getDaysInMonth () {
1591        return daysInMonth(this.year(), this.month());
1592    }
1593
1594    var defaultMonthsShortRegex = matchWord;
1595    function monthsShortRegex (isStrict) {
1596        if (this._monthsParseExact) {
1597            if (!hasOwnProp(this, '_monthsRegex')) {
1598                computeMonthsParse.call(this);
1599            }
1600            if (isStrict) {
1601                return this._monthsShortStrictRegex;
1602            } else {
1603                return this._monthsShortRegex;
1604            }
1605        } else {
1606            if (!hasOwnProp(this, '_monthsShortRegex')) {
1607                this._monthsShortRegex = defaultMonthsShortRegex;
1608            }
1609            return this._monthsShortStrictRegex && isStrict ?
1610                this._monthsShortStrictRegex : this._monthsShortRegex;
1611        }
1612    }
1613
1614    var defaultMonthsRegex = matchWord;
1615    function monthsRegex (isStrict) {
1616        if (this._monthsParseExact) {
1617            if (!hasOwnProp(this, '_monthsRegex')) {
1618                computeMonthsParse.call(this);
1619            }
1620            if (isStrict) {
1621                return this._monthsStrictRegex;
1622            } else {
1623                return this._monthsRegex;
1624            }
1625        } else {
1626            if (!hasOwnProp(this, '_monthsRegex')) {
1627                this._monthsRegex = defaultMonthsRegex;
1628            }
1629            return this._monthsStrictRegex && isStrict ?
1630                this._monthsStrictRegex : this._monthsRegex;
1631        }
1632    }
1633
1634    function computeMonthsParse () {
1635        function cmpLenRev(a, b) {
1636            return b.length - a.length;
1637        }
1638
1639        var shortPieces = [], longPieces = [], mixedPieces = [],
1640            i, mom;
1641        for (i = 0; i < 12; i++) {
1642            // make the regex if we don't have it already
1643            mom = create_utc__createUTC([2000, i]);
1644            shortPieces.push(this.monthsShort(mom, ''));
1645            longPieces.push(this.months(mom, ''));
1646            mixedPieces.push(this.months(mom, ''));
1647            mixedPieces.push(this.monthsShort(mom, ''));
1648        }
1649        // Sorting makes sure if one month (or abbr) is a prefix of another it
1650        // will match the longer piece.
1651        shortPieces.sort(cmpLenRev);
1652        longPieces.sort(cmpLenRev);
1653        mixedPieces.sort(cmpLenRev);
1654        for (i = 0; i < 12; i++) {
1655            shortPieces[i] = regexEscape(shortPieces[i]);
1656            longPieces[i] = regexEscape(longPieces[i]);
1657        }
1658        for (i = 0; i < 24; i++) {
1659            mixedPieces[i] = regexEscape(mixedPieces[i]);
1660        }
1661
1662        this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
1663        this._monthsShortRegex = this._monthsRegex;
1664        this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
1665        this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
1666    }
1667
1668    // FORMATTING
1669
1670    addFormatToken('Y', 0, 0, function () {
1671        var y = this.year();
1672        return y <= 9999 ? '' + y : '+' + y;
1673    });
1674
1675    addFormatToken(0, ['YY', 2], 0, function () {
1676        return this.year() % 100;
1677    });
1678
1679    addFormatToken(0, ['YYYY',   4],       0, 'year');
1680    addFormatToken(0, ['YYYYY',  5],       0, 'year');
1681    addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
1682
1683    // ALIASES
1684
1685    addUnitAlias('year', 'y');
1686
1687    // PRIORITIES
1688
1689    addUnitPriority('year', 1);
1690
1691    // PARSING
1692
1693    addRegexToken('Y',      matchSigned);
1694    addRegexToken('YY',     match1to2, match2);
1695    addRegexToken('YYYY',   match1to4, match4);
1696    addRegexToken('YYYYY',  match1to6, match6);
1697    addRegexToken('YYYYYY', match1to6, match6);
1698
1699    addParseToken(['YYYYY', 'YYYYYY'], YEAR);
1700    addParseToken('YYYY', function (input, array) {
1701        array[YEAR] = input.length === 2 ? utils_hooks__hooks.parseTwoDigitYear(input) : toInt(input);
1702    });
1703    addParseToken('YY', function (input, array) {
1704        array[YEAR] = utils_hooks__hooks.parseTwoDigitYear(input);
1705    });
1706    addParseToken('Y', function (input, array) {
1707        array[YEAR] = parseInt(input, 10);
1708    });
1709
1710    // HELPERS
1711
1712    function daysInYear(year) {
1713        return isLeapYear(year) ? 366 : 365;
1714    }
1715
1716    function isLeapYear(year) {
1717        return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
1718    }
1719
1720    // HOOKS
1721
1722    utils_hooks__hooks.parseTwoDigitYear = function (input) {
1723        return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
1724    };
1725
1726    // MOMENTS
1727
1728    var getSetYear = makeGetSet('FullYear', true);
1729
1730    function getIsLeapYear () {
1731        return isLeapYear(this.year());
1732    }
1733
1734    function createDate (y, m, d, h, M, s, ms) {
1735        //can't just apply() to create a date:
1736        //http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
1737        var date = new Date(y, m, d, h, M, s, ms);
1738
1739        //the date constructor remaps years 0-99 to 1900-1999
1740        if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {
1741            date.setFullYear(y);
1742        }
1743        return date;
1744    }
1745
1746    function createUTCDate (y) {
1747        var date = new Date(Date.UTC.apply(null, arguments));
1748
1749        //the Date.UTC function remaps years 0-99 to 1900-1999
1750        if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {
1751            date.setUTCFullYear(y);
1752        }
1753        return date;
1754    }
1755
1756    // start-of-first-week - start-of-year
1757    function firstWeekOffset(year, dow, doy) {
1758        var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
1759            fwd = 7 + dow - doy,
1760            // first-week day local weekday -- which local weekday is fwd
1761            fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
1762
1763        return -fwdlw + fwd - 1;
1764    }
1765
1766    //http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
1767    function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
1768        var localWeekday = (7 + weekday - dow) % 7,
1769            weekOffset = firstWeekOffset(year, dow, doy),
1770            dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
1771            resYear, resDayOfYear;
1772
1773        if (dayOfYear <= 0) {
1774            resYear = year - 1;
1775            resDayOfYear = daysInYear(resYear) + dayOfYear;
1776        } else if (dayOfYear > daysInYear(year)) {
1777            resYear = year + 1;
1778            resDayOfYear = dayOfYear - daysInYear(year);
1779        } else {
1780            resYear = year;
1781            resDayOfYear = dayOfYear;
1782        }
1783
1784        return {
1785            year: resYear,
1786            dayOfYear: resDayOfYear
1787        };
1788    }
1789
1790    function weekOfYear(mom, dow, doy) {
1791        var weekOffset = firstWeekOffset(mom.year(), dow, doy),
1792            week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
1793            resWeek, resYear;
1794
1795        if (week < 1) {
1796            resYear = mom.year() - 1;
1797            resWeek = week + weeksInYear(resYear, dow, doy);
1798        } else if (week > weeksInYear(mom.year(), dow, doy)) {
1799            resWeek = week - weeksInYear(mom.year(), dow, doy);
1800            resYear = mom.year() + 1;
1801        } else {
1802            resYear = mom.year();
1803            resWeek = week;
1804        }
1805
1806        return {
1807            week: resWeek,
1808            year: resYear
1809        };
1810    }
1811
1812    function weeksInYear(year, dow, doy) {
1813        var weekOffset = firstWeekOffset(year, dow, doy),
1814            weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
1815        return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
1816    }
1817
1818    // FORMATTING
1819
1820    addFormatToken('w', ['ww', 2], 'wo', 'week');
1821    addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
1822
1823    // ALIASES
1824
1825    addUnitAlias('week', 'w');
1826    addUnitAlias('isoWeek', 'W');
1827
1828    // PRIORITIES
1829
1830    addUnitPriority('week', 5);
1831    addUnitPriority('isoWeek', 5);
1832
1833    // PARSING
1834
1835    addRegexToken('w',  match1to2);
1836    addRegexToken('ww', match1to2, match2);
1837    addRegexToken('W',  match1to2);
1838    addRegexToken('WW', match1to2, match2);
1839
1840    addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
1841        week[token.substr(0, 1)] = toInt(input);
1842    });
1843
1844    // HELPERS
1845
1846    // LOCALES
1847
1848    function localeWeek (mom) {
1849        return weekOfYear(mom, this._week.dow, this._week.doy).week;
1850    }
1851
1852    var defaultLocaleWeek = {
1853        dow : 0, // Sunday is the first day of the week.
1854        doy : 6  // The week that contains Jan 1st is the first week of the year.
1855    };
1856
1857    function localeFirstDayOfWeek () {
1858        return this._week.dow;
1859    }
1860
1861    function localeFirstDayOfYear () {
1862        return this._week.doy;
1863    }
1864
1865    // MOMENTS
1866
1867    function getSetWeek (input) {
1868        var week = this.localeData().week(this);
1869        return input == null ? week : this.add((input - week) * 7, 'd');
1870    }
1871
1872    function getSetISOWeek (input) {
1873        var week = weekOfYear(this, 1, 4).week;
1874        return input == null ? week : this.add((input - week) * 7, 'd');
1875    }
1876
1877    // FORMATTING
1878
1879    addFormatToken('d', 0, 'do', 'day');
1880
1881    addFormatToken('dd', 0, 0, function (format) {
1882        return this.localeData().weekdaysMin(this, format);
1883    });
1884
1885    addFormatToken('ddd', 0, 0, function (format) {
1886        return this.localeData().weekdaysShort(this, format);
1887    });
1888
1889    addFormatToken('dddd', 0, 0, function (format) {
1890        return this.localeData().weekdays(this, format);
1891    });
1892
1893    addFormatToken('e', 0, 0, 'weekday');
1894    addFormatToken('E', 0, 0, 'isoWeekday');
1895
1896    // ALIASES
1897
1898    addUnitAlias('day', 'd');
1899    addUnitAlias('weekday', 'e');
1900    addUnitAlias('isoWeekday', 'E');
1901
1902    // PRIORITY
1903    addUnitPriority('day', 11);
1904    addUnitPriority('weekday', 11);
1905    addUnitPriority('isoWeekday', 11);
1906
1907    // PARSING
1908
1909    addRegexToken('d',    match1to2);
1910    addRegexToken('e',    match1to2);
1911    addRegexToken('E',    match1to2);
1912    addRegexToken('dd',   function (isStrict, locale) {
1913        return locale.weekdaysMinRegex(isStrict);
1914    });
1915    addRegexToken('ddd',   function (isStrict, locale) {
1916        return locale.weekdaysShortRegex(isStrict);
1917    });
1918    addRegexToken('dddd',   function (isStrict, locale) {
1919        return locale.weekdaysRegex(isStrict);
1920    });
1921
1922    addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
1923        var weekday = config._locale.weekdaysParse(input, token, config._strict);
1924        // if we didn't get a weekday name, mark the date as invalid
1925        if (weekday != null) {
1926            week.d = weekday;
1927        } else {
1928            getParsingFlags(config).invalidWeekday = input;
1929        }
1930    });
1931
1932    addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
1933        week[token] = toInt(input);
1934    });
1935
1936    // HELPERS
1937
1938    function parseWeekday(input, locale) {
1939        if (typeof input !== 'string') {
1940            return input;
1941        }
1942
1943        if (!isNaN(input)) {
1944            return parseInt(input, 10);
1945        }
1946
1947        input = locale.weekdaysParse(input);
1948        if (typeof input === 'number') {
1949            return input;
1950        }
1951
1952        return null;
1953    }
1954
1955    function parseIsoWeekday(input, locale) {
1956        if (typeof input === 'string') {
1957            return locale.weekdaysParse(input) % 7 || 7;
1958        }
1959        return isNaN(input) ? null : input;
1960    }
1961
1962    // LOCALES
1963
1964    var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
1965    function localeWeekdays (m, format) {
1966        return isArray(this._weekdays) ? this._weekdays[m.day()] :
1967            this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()];
1968    }
1969
1970    var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
1971    function localeWeekdaysShort (m) {
1972        return this._weekdaysShort[m.day()];
1973    }
1974
1975    var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
1976    function localeWeekdaysMin (m) {
1977        return this._weekdaysMin[m.day()];
1978    }
1979
1980    function day_of_week__handleStrictParse(weekdayName, format, strict) {
1981        var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
1982        if (!this._weekdaysParse) {
1983            this._weekdaysParse = [];
1984            this._shortWeekdaysParse = [];
1985            this._minWeekdaysParse = [];
1986
1987            for (i = 0; i < 7; ++i) {
1988                mom = create_utc__createUTC([2000, 1]).day(i);
1989                this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();
1990                this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();
1991                this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
1992            }
1993        }
1994
1995        if (strict) {
1996            if (format === 'dddd') {
1997                ii = indexOf.call(this._weekdaysParse, llc);
1998                return ii !== -1 ? ii : null;
1999            } else if (format === 'ddd') {
2000                ii = indexOf.call(this._shortWeekdaysParse, llc);
2001                return ii !== -1 ? ii : null;
2002            } else {
2003                ii = indexOf.call(this._minWeekdaysParse, llc);
2004                return ii !== -1 ? ii : null;
2005            }
2006        } else {
2007            if (format === 'dddd') {
2008                ii = indexOf.call(this._weekdaysParse, llc);
2009                if (ii !== -1) {
2010                    return ii;
2011                }
2012                ii = indexOf.call(this._shortWeekdaysParse, llc);
2013                if (ii !== -1) {
2014                    return ii;
2015                }
2016                ii = indexOf.call(this._minWeekdaysParse, llc);
2017                return ii !== -1 ? ii : null;
2018            } else if (format === 'ddd') {
2019                ii = indexOf.call(this._shortWeekdaysParse, llc);
2020                if (ii !== -1) {
2021                    return ii;
2022                }
2023                ii = indexOf.call(this._weekdaysParse, llc);
2024                if (ii !== -1) {
2025                    return ii;
2026                }
2027                ii = indexOf.call(this._minWeekdaysParse, llc);
2028                return ii !== -1 ? ii : null;
2029            } else {
2030                ii = indexOf.call(this._minWeekdaysParse, llc);
2031                if (ii !== -1) {
2032                    return ii;
2033                }
2034                ii = indexOf.call(this._weekdaysParse, llc);
2035                if (ii !== -1) {
2036                    return ii;
2037                }
2038                ii = indexOf.call(this._shortWeekdaysParse, llc);
2039                return ii !== -1 ? ii : null;
2040            }
2041        }
2042    }
2043
2044    function localeWeekdaysParse (weekdayName, format, strict) {
2045        var i, mom, regex;
2046
2047        if (this._weekdaysParseExact) {
2048            return day_of_week__handleStrictParse.call(this, weekdayName, format, strict);
2049        }
2050
2051        if (!this._weekdaysParse) {
2052            this._weekdaysParse = [];
2053            this._minWeekdaysParse = [];
2054            this._shortWeekdaysParse = [];
2055            this._fullWeekdaysParse = [];
2056        }
2057
2058        for (i = 0; i < 7; i++) {
2059            // make the regex if we don't have it already
2060
2061            mom = create_utc__createUTC([2000, 1]).day(i);
2062            if (strict && !this._fullWeekdaysParse[i]) {
2063                this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\.?') + '$', 'i');
2064                this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\.?') + '$', 'i');
2065                this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\.?') + '$', 'i');
2066            }
2067            if (!this._weekdaysParse[i]) {
2068                regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
2069                this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
2070            }
2071            // test the regex
2072            if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {
2073                return i;
2074            } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {
2075                return i;
2076            } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {
2077                return i;
2078            } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
2079                return i;
2080            }
2081        }
2082    }
2083
2084    // MOMENTS
2085
2086    function getSetDayOfWeek (input) {
2087        if (!this.isValid()) {
2088            return input != null ? this : NaN;
2089        }
2090        var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
2091        if (input != null) {
2092            input = parseWeekday(input, this.localeData());
2093            return this.add(input - day, 'd');
2094        } else {
2095            return day;
2096        }
2097    }
2098
2099    function getSetLocaleDayOfWeek (input) {
2100        if (!this.isValid()) {
2101            return input != null ? this : NaN;
2102        }
2103        var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
2104        return input == null ? weekday : this.add(input - weekday, 'd');
2105    }
2106
2107    function getSetISODayOfWeek (input) {
2108        if (!this.isValid()) {
2109            return input != null ? this : NaN;
2110        }
2111
2112        // behaves the same as moment#day except
2113        // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
2114        // as a setter, sunday should belong to the previous week.
2115
2116        if (input != null) {
2117            var weekday = parseIsoWeekday(input, this.localeData());
2118            return this.day(this.day() % 7 ? weekday : weekday - 7);
2119        } else {
2120            return this.day() || 7;
2121        }
2122    }
2123
2124    var defaultWeekdaysRegex = matchWord;
2125    function weekdaysRegex (isStrict) {
2126        if (this._weekdaysParseExact) {
2127            if (!hasOwnProp(this, '_weekdaysRegex')) {
2128                computeWeekdaysParse.call(this);
2129            }
2130            if (isStrict) {
2131                return this._weekdaysStrictRegex;
2132            } else {
2133                return this._weekdaysRegex;
2134            }
2135        } else {
2136            if (!hasOwnProp(this, '_weekdaysRegex')) {
2137                this._weekdaysRegex = defaultWeekdaysRegex;
2138            }
2139            return this._weekdaysStrictRegex && isStrict ?
2140                this._weekdaysStrictRegex : this._weekdaysRegex;
2141        }
2142    }
2143
2144    var defaultWeekdaysShortRegex = matchWord;
2145    function weekdaysShortRegex (isStrict) {
2146        if (this._weekdaysParseExact) {
2147            if (!hasOwnProp(this, '_weekdaysRegex')) {
2148                computeWeekdaysParse.call(this);
2149            }
2150            if (isStrict) {
2151                return this._weekdaysShortStrictRegex;
2152            } else {
2153                return this._weekdaysShortRegex;
2154            }
2155        } else {
2156            if (!hasOwnProp(this, '_weekdaysShortRegex')) {
2157                this._weekdaysShortRegex = defaultWeekdaysShortRegex;
2158            }
2159            return this._weekdaysShortStrictRegex && isStrict ?
2160                this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
2161        }
2162    }
2163
2164    var defaultWeekdaysMinRegex = matchWord;
2165    function weekdaysMinRegex (isStrict) {
2166        if (this._weekdaysParseExact) {
2167            if (!hasOwnProp(this, '_weekdaysRegex')) {
2168                computeWeekdaysParse.call(this);
2169            }
2170            if (isStrict) {
2171                return this._weekdaysMinStrictRegex;
2172            } else {
2173                return this._weekdaysMinRegex;
2174            }
2175        } else {
2176            if (!hasOwnProp(this, '_weekdaysMinRegex')) {
2177                this._weekdaysMinRegex = defaultWeekdaysMinRegex;
2178            }
2179            return this._weekdaysMinStrictRegex && isStrict ?
2180                this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
2181        }
2182    }
2183
2184
2185    function computeWeekdaysParse () {
2186        function cmpLenRev(a, b) {
2187            return b.length - a.length;
2188        }
2189
2190        var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [],
2191            i, mom, minp, shortp, longp;
2192        for (i = 0; i < 7; i++) {
2193            // make the regex if we don't have it already
2194            mom = create_utc__createUTC([2000, 1]).day(i);
2195            minp = this.weekdaysMin(mom, '');
2196            shortp = this.weekdaysShort(mom, '');
2197            longp = this.weekdays(mom, '');
2198            minPieces.push(minp);
2199            shortPieces.push(shortp);
2200            longPieces.push(longp);
2201            mixedPieces.push(minp);
2202            mixedPieces.push(shortp);
2203            mixedPieces.push(longp);
2204        }
2205        // Sorting makes sure if one weekday (or abbr) is a prefix of another it
2206        // will match the longer piece.
2207        minPieces.sort(cmpLenRev);
2208        shortPieces.sort(cmpLenRev);
2209        longPieces.sort(cmpLenRev);
2210        mixedPieces.sort(cmpLenRev);
2211        for (i = 0; i < 7; i++) {
2212            shortPieces[i] = regexEscape(shortPieces[i]);
2213            longPieces[i] = regexEscape(longPieces[i]);
2214            mixedPieces[i] = regexEscape(mixedPieces[i]);
2215        }
2216
2217        this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
2218        this._weekdaysShortRegex = this._weekdaysRegex;
2219        this._weekdaysMinRegex = this._weekdaysRegex;
2220
2221        this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
2222        this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
2223        this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');
2224    }
2225
2226    // FORMATTING
2227
2228    function hFormat() {
2229        return this.hours() % 12 || 12;
2230    }
2231
2232    function kFormat() {
2233        return this.hours() || 24;
2234    }
2235
2236    addFormatToken('H', ['HH', 2], 0, 'hour');
2237    addFormatToken('h', ['hh', 2], 0, hFormat);
2238    addFormatToken('k', ['kk', 2], 0, kFormat);
2239
2240    addFormatToken('hmm', 0, 0, function () {
2241        return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
2242    });
2243
2244    addFormatToken('hmmss', 0, 0, function () {
2245        return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +
2246            zeroFill(this.seconds(), 2);
2247    });
2248
2249    addFormatToken('Hmm', 0, 0, function () {
2250        return '' + this.hours() + zeroFill(this.minutes(), 2);
2251    });
2252
2253    addFormatToken('Hmmss', 0, 0, function () {
2254        return '' + this.hours() + zeroFill(this.minutes(), 2) +
2255            zeroFill(this.seconds(), 2);
2256    });
2257
2258    function meridiem (token, lowercase) {
2259        addFormatToken(token, 0, 0, function () {
2260            return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
2261        });
2262    }
2263
2264    meridiem('a', true);
2265    meridiem('A', false);
2266
2267    // ALIASES
2268
2269    addUnitAlias('hour', 'h');
2270
2271    // PRIORITY
2272    addUnitPriority('hour', 13);
2273
2274    // PARSING
2275
2276    function matchMeridiem (isStrict, locale) {
2277        return locale._meridiemParse;
2278    }
2279
2280    addRegexToken('a',  matchMeridiem);
2281    addRegexToken('A',  matchMeridiem);
2282    addRegexToken('H',  match1to2);
2283    addRegexToken('h',  match1to2);
2284    addRegexToken('HH', match1to2, match2);
2285    addRegexToken('hh', match1to2, match2);
2286
2287    addRegexToken('hmm', match3to4);
2288    addRegexToken('hmmss', match5to6);
2289    addRegexToken('Hmm', match3to4);
2290    addRegexToken('Hmmss', match5to6);
2291
2292    addParseToken(['H', 'HH'], HOUR);
2293    addParseToken(['a', 'A'], function (input, array, config) {
2294        config._isPm = config._locale.isPM(input);
2295        config._meridiem = input;
2296    });
2297    addParseToken(['h', 'hh'], function (input, array, config) {
2298        array[HOUR] = toInt(input);
2299        getParsingFlags(config).bigHour = true;
2300    });
2301    addParseToken('hmm', function (input, array, config) {
2302        var pos = input.length - 2;
2303        array[HOUR] = toInt(input.substr(0, pos));
2304        array[MINUTE] = toInt(input.substr(pos));
2305        getParsingFlags(config).bigHour = true;
2306    });
2307    addParseToken('hmmss', function (input, array, config) {
2308        var pos1 = input.length - 4;
2309        var pos2 = input.length - 2;
2310        array[HOUR] = toInt(input.substr(0, pos1));
2311        array[MINUTE] = toInt(input.substr(pos1, 2));
2312        array[SECOND] = toInt(input.substr(pos2));
2313        getParsingFlags(config).bigHour = true;
2314    });
2315    addParseToken('Hmm', function (input, array, config) {
2316        var pos = input.length - 2;
2317        array[HOUR] = toInt(input.substr(0, pos));
2318        array[MINUTE] = toInt(input.substr(pos));
2319    });
2320    addParseToken('Hmmss', function (input, array, config) {
2321        var pos1 = input.length - 4;
2322        var pos2 = input.length - 2;
2323        array[HOUR] = toInt(input.substr(0, pos1));
2324        array[MINUTE] = toInt(input.substr(pos1, 2));
2325        array[SECOND] = toInt(input.substr(pos2));
2326    });
2327
2328    // LOCALES
2329
2330    function localeIsPM (input) {
2331        // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
2332        // Using charAt should be more compatible.
2333        return ((input + '').toLowerCase().charAt(0) === 'p');
2334    }
2335
2336    var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
2337    function localeMeridiem (hours, minutes, isLower) {
2338        if (hours > 11) {
2339            return isLower ? 'pm' : 'PM';
2340        } else {
2341            return isLower ? 'am' : 'AM';
2342        }
2343    }
2344
2345
2346    // MOMENTS
2347
2348    // Setting the hour should keep the time, because the user explicitly
2349    // specified which hour he wants. So trying to maintain the same hour (in
2350    // a new timezone) makes sense. Adding/subtracting hours does not follow
2351    // this rule.
2352    var getSetHour = makeGetSet('Hours', true);
2353
2354    var baseConfig = {
2355        calendar: defaultCalendar,
2356        longDateFormat: defaultLongDateFormat,
2357        invalidDate: defaultInvalidDate,
2358        ordinal: defaultOrdinal,
2359        ordinalParse: defaultOrdinalParse,
2360        relativeTime: defaultRelativeTime,
2361
2362        months: defaultLocaleMonths,
2363        monthsShort: defaultLocaleMonthsShort,
2364
2365        week: defaultLocaleWeek,
2366
2367        weekdays: defaultLocaleWeekdays,
2368        weekdaysMin: defaultLocaleWeekdaysMin,
2369        weekdaysShort: defaultLocaleWeekdaysShort,
2370
2371        meridiemParse: defaultLocaleMeridiemParse
2372    };
2373
2374    // internal storage for locale config files
2375    var locales = {};
2376    var globalLocale;
2377
2378    function normalizeLocale(key) {
2379        return key ? key.toLowerCase().replace('_', '-') : key;
2380    }
2381
2382    // pick the locale from the array
2383    // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
2384    // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
2385    function chooseLocale(names) {
2386        var i = 0, j, next, locale, split;
2387
2388        while (i < names.length) {
2389            split = normalizeLocale(names[i]).split('-');
2390            j = split.length;
2391            next = normalizeLocale(names[i + 1]);
2392            next = next ? next.split('-') : null;
2393            while (j > 0) {
2394                locale = loadLocale(split.slice(0, j).join('-'));
2395                if (locale) {
2396                    return locale;
2397                }
2398                if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
2399                    //the next array item is better than a shallower substring of this one
2400                    break;
2401                }
2402                j--;
2403            }
2404            i++;
2405        }
2406        return null;
2407    }
2408
2409    function loadLocale(name) {
2410        var oldLocale = null;
2411        // TODO: Find a better way to register and load all the locales in Node
2412        if (!locales[name] && (typeof module !== 'undefined') &&
2413                module && module.exports) {
2414            try {
2415                oldLocale = globalLocale._abbr;
2416                require('./locale/' + name);
2417                // because defineLocale currently also sets the global locale, we
2418                // want to undo that for lazy loaded locales
2419                locale_locales__getSetGlobalLocale(oldLocale);
2420            } catch (e) { }
2421        }
2422        return locales[name];
2423    }
2424
2425    // This function will load locale and then set the global locale.  If
2426    // no arguments are passed in, it will simply return the current global
2427    // locale key.
2428    function locale_locales__getSetGlobalLocale (key, values) {
2429        var data;
2430        if (key) {
2431            if (isUndefined(values)) {
2432                data = locale_locales__getLocale(key);
2433            }
2434            else {
2435                data = defineLocale(key, values);
2436            }
2437
2438            if (data) {
2439                // moment.duration._locale = moment._locale = data;
2440                globalLocale = data;
2441            }
2442        }
2443
2444        return globalLocale._abbr;
2445    }
2446
2447    function defineLocale (name, config) {
2448        if (config !== null) {
2449            var parentConfig = baseConfig;
2450            config.abbr = name;
2451            if (locales[name] != null) {
2452                deprecateSimple('defineLocaleOverride',
2453                        'use moment.updateLocale(localeName, config) to change ' +
2454                        'an existing locale. moment.defineLocale(localeName, ' +
2455                        'config) should only be used for creating a new locale ' +
2456                        'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');
2457                parentConfig = locales[name]._config;
2458            } else if (config.parentLocale != null) {
2459                if (locales[config.parentLocale] != null) {
2460                    parentConfig = locales[config.parentLocale]._config;
2461                } else {
2462                    // treat as if there is no base config
2463                    deprecateSimple('parentLocaleUndefined',
2464                            'specified parentLocale is not defined yet. See http://momentjs.com/guides/#/warnings/parent-locale/');
2465                }
2466            }
2467            locales[name] = new Locale(mergeConfigs(parentConfig, config));
2468
2469            // backwards compat for now: also set the locale
2470            locale_locales__getSetGlobalLocale(name);
2471
2472            return locales[name];
2473        } else {
2474            // useful for testing
2475            delete locales[name];
2476            return null;
2477        }
2478    }
2479
2480    function updateLocale(name, config) {
2481        if (config != null) {
2482            var locale, parentConfig = baseConfig;
2483            // MERGE
2484            if (locales[name] != null) {
2485                parentConfig = locales[name]._config;
2486            }
2487            config = mergeConfigs(parentConfig, config);
2488            locale = new Locale(config);
2489            locale.parentLocale = locales[name];
2490            locales[name] = locale;
2491
2492            // backwards compat for now: also set the locale
2493            locale_locales__getSetGlobalLocale(name);
2494        } else {
2495            // pass null for config to unupdate, useful for tests
2496            if (locales[name] != null) {
2497                if (locales[name].parentLocale != null) {
2498                    locales[name] = locales[name].parentLocale;
2499                } else if (locales[name] != null) {
2500                    delete locales[name];
2501                }
2502            }
2503        }
2504        return locales[name];
2505    }
2506
2507    // returns locale data
2508    function locale_locales__getLocale (key) {
2509        var locale;
2510
2511        if (key && key._locale && key._locale._abbr) {
2512            key = key._locale._abbr;
2513        }
2514
2515        if (!key) {
2516            return globalLocale;
2517        }
2518
2519        if (!isArray(key)) {
2520            //short-circuit everything else
2521            locale = loadLocale(key);
2522            if (locale) {
2523                return locale;
2524            }
2525            key = [key];
2526        }
2527
2528        return chooseLocale(key);
2529    }
2530
2531    function locale_locales__listLocales() {
2532        return keys(locales);
2533    }
2534
2535    function checkOverflow (m) {
2536        var overflow;
2537        var a = m._a;
2538
2539        if (a && getParsingFlags(m).overflow === -2) {
2540            overflow =
2541                a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :
2542                a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
2543                a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
2544                a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :
2545                a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :
2546                a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
2547                -1;
2548
2549            if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
2550                overflow = DATE;
2551            }
2552            if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
2553                overflow = WEEK;
2554            }
2555            if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
2556                overflow = WEEKDAY;
2557            }
2558
2559            getParsingFlags(m).overflow = overflow;
2560        }
2561
2562        return m;
2563    }
2564
2565    // iso 8601 regex
2566    // 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)
2567    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)?)?/;
2568    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)?)?/;
2569
2570    var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/;
2571
2572    var isoDates = [
2573        ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
2574        ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
2575        ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
2576        ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
2577        ['YYYY-DDD', /\d{4}-\d{3}/],
2578        ['YYYY-MM', /\d{4}-\d\d/, false],
2579        ['YYYYYYMMDD', /[+-]\d{10}/],
2580        ['YYYYMMDD', /\d{8}/],
2581        // YYYYMM is NOT allowed by the standard
2582        ['GGGG[W]WWE', /\d{4}W\d{3}/],
2583        ['GGGG[W]WW', /\d{4}W\d{2}/, false],
2584        ['YYYYDDD', /\d{7}/]
2585    ];
2586
2587    // iso time formats and regexes
2588    var isoTimes = [
2589        ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
2590        ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
2591        ['HH:mm:ss', /\d\d:\d\d:\d\d/],
2592        ['HH:mm', /\d\d:\d\d/],
2593        ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
2594        ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
2595        ['HHmmss', /\d\d\d\d\d\d/],
2596        ['HHmm', /\d\d\d\d/],
2597        ['HH', /\d\d/]
2598    ];
2599
2600    var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
2601
2602    // date from iso format
2603    function configFromISO(config) {
2604        var i, l,
2605            string = config._i,
2606            match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
2607            allowTime, dateFormat, timeFormat, tzFormat;
2608
2609        if (match) {
2610            getParsingFlags(config).iso = true;
2611
2612            for (i = 0, l = isoDates.length; i < l; i++) {
2613                if (isoDates[i][1].exec(match[1])) {
2614                    dateFormat = isoDates[i][0];
2615                    allowTime = isoDates[i][2] !== false;
2616                    break;
2617                }
2618            }
2619            if (dateFormat == null) {
2620                config._isValid = false;
2621                return;
2622            }
2623            if (match[3]) {
2624                for (i = 0, l = isoTimes.length; i < l; i++) {
2625                    if (isoTimes[i][1].exec(match[3])) {
2626                        // match[2] should be 'T' or space
2627                        timeFormat = (match[2] || ' ') + isoTimes[i][0];
2628                        break;
2629                    }
2630                }
2631                if (timeFormat == null) {
2632                    config._isValid = false;
2633                    return;
2634                }
2635            }
2636            if (!allowTime && timeFormat != null) {
2637                config._isValid = false;
2638                return;
2639            }
2640            if (match[4]) {
2641                if (tzRegex.exec(match[4])) {
2642                    tzFormat = 'Z';
2643                } else {
2644                    config._isValid = false;
2645                    return;
2646                }
2647            }
2648            config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
2649            configFromStringAndFormat(config);
2650        } else {
2651            config._isValid = false;
2652        }
2653    }
2654
2655    // date from iso format or fallback
2656    function configFromString(config) {
2657        var matched = aspNetJsonRegex.exec(config._i);
2658
2659        if (matched !== null) {
2660            config._d = new Date(+matched[1]);
2661            return;
2662        }
2663
2664        configFromISO(config);
2665        if (config._isValid === false) {
2666            delete config._isValid;
2667            utils_hooks__hooks.createFromInputFallback(config);
2668        }
2669    }
2670
2671    utils_hooks__hooks.createFromInputFallback = deprecate(
2672        'moment construction falls back to js Date. This is ' +
2673        'discouraged and will be removed in upcoming major ' +
2674        'release. Please refer to ' +
2675        'http://momentjs.com/guides/#/warnings/js-date/ for more info.',
2676        function (config) {
2677            config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
2678        }
2679    );
2680
2681    // Pick the first defined of two or three arguments.
2682    function defaults(a, b, c) {
2683        if (a != null) {
2684            return a;
2685        }
2686        if (b != null) {
2687            return b;
2688        }
2689        return c;
2690    }
2691
2692    function currentDateArray(config) {
2693        // hooks is actually the exported moment object
2694        var nowValue = new Date(utils_hooks__hooks.now());
2695        if (config._useUTC) {
2696            return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
2697        }
2698        return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
2699    }
2700
2701    // convert an array to a date.
2702    // the array should mirror the parameters below
2703    // note: all values past the year are optional and will default to the lowest possible value.
2704    // [year, month, day , hour, minute, second, millisecond]
2705    function configFromArray (config) {
2706        var i, date, input = [], currentDate, yearToUse;
2707
2708        if (config._d) {
2709            return;
2710        }
2711
2712        currentDate = currentDateArray(config);
2713
2714        //compute day of the year from weeks and weekdays
2715        if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
2716            dayOfYearFromWeekInfo(config);
2717        }
2718
2719        //if the day of the year is set, figure out what it is
2720        if (config._dayOfYear) {
2721            yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
2722
2723            if (config._dayOfYear > daysInYear(yearToUse)) {
2724                getParsingFlags(config)._overflowDayOfYear = true;
2725            }
2726
2727            date = createUTCDate(yearToUse, 0, config._dayOfYear);
2728            config._a[MONTH] = date.getUTCMonth();
2729            config._a[DATE] = date.getUTCDate();
2730        }
2731
2732        // Default to current date.
2733        // * if no year, month, day of month are given, default to today
2734        // * if day of month is given, default month and year
2735        // * if month is given, default only year
2736        // * if year is given, don't default anything
2737        for (i = 0; i < 3 && config._a[i] == null; ++i) {
2738            config._a[i] = input[i] = currentDate[i];
2739        }
2740
2741        // Zero out whatever was not defaulted, including time
2742        for (; i < 7; i++) {
2743            config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
2744        }
2745
2746        // Check for 24:00:00.000
2747        if (config._a[HOUR] === 24 &&
2748                config._a[MINUTE] === 0 &&
2749                config._a[SECOND] === 0 &&
2750                config._a[MILLISECOND] === 0) {
2751            config._nextDay = true;
2752            config._a[HOUR] = 0;
2753        }
2754
2755        config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
2756        // Apply timezone offset from input. The actual utcOffset can be changed
2757        // with parseZone.
2758        if (config._tzm != null) {
2759            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
2760        }
2761
2762        if (config._nextDay) {
2763            config._a[HOUR] = 24;
2764        }
2765    }
2766
2767    function dayOfYearFromWeekInfo(config) {
2768        var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;
2769
2770        w = config._w;
2771        if (w.GG != null || w.W != null || w.E != null) {
2772            dow = 1;
2773            doy = 4;
2774
2775            // TODO: We need to take the current isoWeekYear, but that depends on
2776            // how we interpret now (local, utc, fixed offset). So create
2777            // a now version of current config (take local/utc/offset flags, and
2778            // create now).
2779            weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(local__createLocal(), 1, 4).year);
2780            week = defaults(w.W, 1);
2781            weekday = defaults(w.E, 1);
2782            if (weekday < 1 || weekday > 7) {
2783                weekdayOverflow = true;
2784            }
2785        } else {
2786            dow = config._locale._week.dow;
2787            doy = config._locale._week.doy;
2788
2789            weekYear = defaults(w.gg, config._a[YEAR], weekOfYear(local__createLocal(), dow, doy).year);
2790            week = defaults(w.w, 1);
2791
2792            if (w.d != null) {
2793                // weekday -- low day numbers are considered next week
2794                weekday = w.d;
2795                if (weekday < 0 || weekday > 6) {
2796                    weekdayOverflow = true;
2797                }
2798            } else if (w.e != null) {
2799                // local weekday -- counting starts from begining of week
2800                weekday = w.e + dow;
2801                if (w.e < 0 || w.e > 6) {
2802                    weekdayOverflow = true;
2803                }
2804            } else {
2805                // default to begining of week
2806                weekday = dow;
2807            }
2808        }
2809        if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
2810            getParsingFlags(config)._overflowWeeks = true;
2811        } else if (weekdayOverflow != null) {
2812            getParsingFlags(config)._overflowWeekday = true;
2813        } else {
2814            temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
2815            config._a[YEAR] = temp.year;
2816            config._dayOfYear = temp.dayOfYear;
2817        }
2818    }
2819
2820    // constant that refers to the ISO standard
2821    utils_hooks__hooks.ISO_8601 = function () {};
2822
2823    // date from string and format string
2824    function configFromStringAndFormat(config) {
2825        // TODO: Move this to another part of the creation flow to prevent circular deps
2826        if (config._f === utils_hooks__hooks.ISO_8601) {
2827            configFromISO(config);
2828            return;
2829        }
2830
2831        config._a = [];
2832        getParsingFlags(config).empty = true;
2833
2834        // This array is used to make a Date, either with `new Date` or `Date.UTC`
2835        var string = '' + config._i,
2836            i, parsedInput, tokens, token, skipped,
2837            stringLength = string.length,
2838            totalParsedInputLength = 0;
2839
2840        tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
2841
2842        for (i = 0; i < tokens.length; i++) {
2843            token = tokens[i];
2844            parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
2845            // console.log('token', token, 'parsedInput', parsedInput,
2846            //         'regex', getParseRegexForToken(token, config));
2847            if (parsedInput) {
2848                skipped = string.substr(0, string.indexOf(parsedInput));
2849                if (skipped.length > 0) {
2850                    getParsingFlags(config).unusedInput.push(skipped);
2851                }
2852                string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
2853                totalParsedInputLength += parsedInput.length;
2854            }
2855            // don't parse if it's not a known token
2856            if (formatTokenFunctions[token]) {
2857                if (parsedInput) {
2858                    getParsingFlags(config).empty = false;
2859                }
2860                else {
2861                    getParsingFlags(config).unusedTokens.push(token);
2862                }
2863                addTimeToArrayFromToken(token, parsedInput, config);
2864            }
2865            else if (config._strict && !parsedInput) {
2866                getParsingFlags(config).unusedTokens.push(token);
2867            }
2868        }
2869
2870        // add remaining unparsed input length to the string
2871        getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
2872        if (string.length > 0) {
2873            getParsingFlags(config).unusedInput.push(string);
2874        }
2875
2876        // clear _12h flag if hour is <= 12
2877        if (config._a[HOUR] <= 12 &&
2878            getParsingFlags(config).bigHour === true &&
2879            config._a[HOUR] > 0) {
2880            getParsingFlags(config).bigHour = undefined;
2881        }
2882
2883        getParsingFlags(config).parsedDateParts = config._a.slice(0);
2884        getParsingFlags(config).meridiem = config._meridiem;
2885        // handle meridiem
2886        config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
2887
2888        configFromArray(config);
2889        checkOverflow(config);
2890    }
2891
2892
2893    function meridiemFixWrap (locale, hour, meridiem) {
2894        var isPm;
2895
2896        if (meridiem == null) {
2897            // nothing to do
2898            return hour;
2899        }
2900        if (locale.meridiemHour != null) {
2901            return locale.meridiemHour(hour, meridiem);
2902        } else if (locale.isPM != null) {
2903            // Fallback
2904            isPm = locale.isPM(meridiem);
2905            if (isPm && hour < 12) {
2906                hour += 12;
2907            }
2908            if (!isPm && hour === 12) {
2909                hour = 0;
2910            }
2911            return hour;
2912        } else {
2913            // this is not supposed to happen
2914            return hour;
2915        }
2916    }
2917
2918    // date from string and array of format strings
2919    function configFromStringAndArray(config) {
2920        var tempConfig,
2921            bestMoment,
2922
2923            scoreToBeat,
2924            i,
2925            currentScore;
2926
2927        if (config._f.length === 0) {
2928            getParsingFlags(config).invalidFormat = true;
2929            config._d = new Date(NaN);
2930            return;
2931        }
2932
2933        for (i = 0; i < config._f.length; i++) {
2934            currentScore = 0;
2935            tempConfig = copyConfig({}, config);
2936            if (config._useUTC != null) {
2937                tempConfig._useUTC = config._useUTC;
2938            }
2939            tempConfig._f = config._f[i];
2940            configFromStringAndFormat(tempConfig);
2941
2942            if (!valid__isValid(tempConfig)) {
2943                continue;
2944            }
2945
2946            // if there is any input that was not parsed add a penalty for that format
2947            currentScore += getParsingFlags(tempConfig).charsLeftOver;
2948
2949            //or tokens
2950            currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
2951
2952            getParsingFlags(tempConfig).score = currentScore;
2953
2954            if (scoreToBeat == null || currentScore < scoreToBeat) {
2955                scoreToBeat = currentScore;
2956                bestMoment = tempConfig;
2957            }
2958        }
2959
2960        extend(config, bestMoment || tempConfig);
2961    }
2962
2963    function configFromObject(config) {
2964        if (config._d) {
2965            return;
2966        }
2967
2968        var i = normalizeObjectUnits(config._i);
2969        config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {
2970            return obj && parseInt(obj, 10);
2971        });
2972
2973        configFromArray(config);
2974    }
2975
2976    function createFromConfig (config) {
2977        var res = new Moment(checkOverflow(prepareConfig(config)));
2978        if (res._nextDay) {
2979            // Adding is smart enough around DST
2980            res.add(1, 'd');
2981            res._nextDay = undefined;
2982        }
2983
2984        return res;
2985    }
2986
2987    function prepareConfig (config) {
2988        var input = config._i,
2989            format = config._f;
2990
2991        config._locale = config._locale || locale_locales__getLocale(config._l);
2992
2993        if (input === null || (format === undefined && input === '')) {
2994            return valid__createInvalid({nullInput: true});
2995        }
2996
2997        if (typeof input === 'string') {
2998            config._i = input = config._locale.preparse(input);
2999        }
3000
3001        if (isMoment(input)) {
3002            return new Moment(checkOverflow(input));
3003        } else if (isArray(format)) {
3004            configFromStringAndArray(config);
3005        } else if (isDate(input)) {
3006            config._d = input;
3007        } else if (format) {
3008            configFromStringAndFormat(config);
3009        }  else {
3010            configFromInput(config);
3011        }
3012
3013        if (!valid__isValid(config)) {
3014            config._d = null;
3015        }
3016
3017        return config;
3018    }
3019
3020    function configFromInput(config) {
3021        var input = config._i;
3022        if (input === undefined) {
3023            config._d = new Date(utils_hooks__hooks.now());
3024        } else if (isDate(input)) {
3025            config._d = new Date(input.valueOf());
3026        } else if (typeof input === 'string') {
3027            configFromString(config);
3028        } else if (isArray(input)) {
3029            config._a = map(input.slice(0), function (obj) {
3030                return parseInt(obj, 10);
3031            });
3032            configFromArray(config);
3033        } else if (typeof(input) === 'object') {
3034            configFromObject(config);
3035        } else if (typeof(input) === 'number') {
3036            // from milliseconds
3037            config._d = new Date(input);
3038        } else {
3039            utils_hooks__hooks.createFromInputFallback(config);
3040        }
3041    }
3042
3043    function createLocalOrUTC (input, format, locale, strict, isUTC) {
3044        var c = {};
3045
3046        if (typeof(locale) === 'boolean') {
3047            strict = locale;
3048            locale = undefined;
3049        }
3050
3051        if ((isObject(input) && isObjectEmpty(input)) ||
3052                (isArray(input) && input.length === 0)) {
3053            input = undefined;
3054        }
3055        // object construction must be done this way.
3056        // https://github.com/moment/moment/issues/1423
3057        c._isAMomentObject = true;
3058        c._useUTC = c._isUTC = isUTC;
3059        c._l = locale;
3060        c._i = input;
3061        c._f = format;
3062        c._strict = strict;
3063
3064        return createFromConfig(c);
3065    }
3066
3067    function local__createLocal (input, format, locale, strict) {
3068        return createLocalOrUTC(input, format, locale, strict, false);
3069    }
3070
3071    var prototypeMin = deprecate(
3072        'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
3073        function () {
3074            var other = local__createLocal.apply(null, arguments);
3075            if (this.isValid() && other.isValid()) {
3076                return other < this ? this : other;
3077            } else {
3078                return valid__createInvalid();
3079            }
3080        }
3081    );
3082
3083    var prototypeMax = deprecate(
3084        'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
3085        function () {
3086            var other = local__createLocal.apply(null, arguments);
3087            if (this.isValid() && other.isValid()) {
3088                return other > this ? this : other;
3089            } else {
3090                return valid__createInvalid();
3091            }
3092        }
3093    );
3094
3095    // Pick a moment m from moments so that m[fn](other) is true for all
3096    // other. This relies on the function fn to be transitive.
3097    //
3098    // moments should either be an array of moment objects or an array, whose
3099    // first element is an array of moment objects.
3100    function pickBy(fn, moments) {
3101        var res, i;
3102        if (moments.length === 1 && isArray(moments[0])) {
3103            moments = moments[0];
3104        }
3105        if (!moments.length) {
3106            return local__createLocal();
3107        }
3108        res = moments[0];
3109        for (i = 1; i < moments.length; ++i) {
3110            if (!moments[i].isValid() || moments[i][fn](res)) {
3111                res = moments[i];
3112            }
3113        }
3114        return res;
3115    }
3116
3117    // TODO: Use [].sort instead?
3118    function min () {
3119        var args = [].slice.call(arguments, 0);
3120
3121        return pickBy('isBefore', args);
3122    }
3123
3124    function max () {
3125        var args = [].slice.call(arguments, 0);
3126
3127        return pickBy('isAfter', args);
3128    }
3129
3130    var now = function () {
3131        return Date.now ? Date.now() : +(new Date());
3132    };
3133
3134    function Duration (duration) {
3135        var normalizedInput = normalizeObjectUnits(duration),
3136            years = normalizedInput.year || 0,
3137            quarters = normalizedInput.quarter || 0,
3138            months = normalizedInput.month || 0,
3139            weeks = normalizedInput.week || 0,
3140            days = normalizedInput.day || 0,
3141            hours = normalizedInput.hour || 0,
3142            minutes = normalizedInput.minute || 0,
3143            seconds = normalizedInput.second || 0,
3144            milliseconds = normalizedInput.millisecond || 0;
3145
3146        // representation for dateAddRemove
3147        this._milliseconds = +milliseconds +
3148            seconds * 1e3 + // 1000
3149            minutes * 6e4 + // 1000 * 60
3150            hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
3151        // Because of dateAddRemove treats 24 hours as different from a
3152        // day when working around DST, we need to store them separately
3153        this._days = +days +
3154            weeks * 7;
3155        // It is impossible translate months into days without knowing
3156        // which months you are are talking about, so we have to store
3157        // it separately.
3158        this._months = +months +
3159            quarters * 3 +
3160            years * 12;
3161
3162        this._data = {};
3163
3164        this._locale = locale_locales__getLocale();
3165
3166        this._bubble();
3167    }
3168
3169    function isDuration (obj) {
3170        return obj instanceof Duration;
3171    }
3172
3173    // FORMATTING
3174
3175    function offset (token, separator) {
3176        addFormatToken(token, 0, 0, function () {
3177            var offset = this.utcOffset();
3178            var sign = '+';
3179            if (offset < 0) {
3180                offset = -offset;
3181                sign = '-';
3182            }
3183            return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
3184        });
3185    }
3186
3187    offset('Z', ':');
3188    offset('ZZ', '');
3189
3190    // PARSING
3191
3192    addRegexToken('Z',  matchShortOffset);
3193    addRegexToken('ZZ', matchShortOffset);
3194    addParseToken(['Z', 'ZZ'], function (input, array, config) {
3195        config._useUTC = true;
3196        config._tzm = offsetFromString(matchShortOffset, input);
3197    });
3198
3199    // HELPERS
3200
3201    // timezone chunker
3202    // '+10:00' > ['10',  '00']
3203    // '-1530'  > ['-15', '30']
3204    var chunkOffset = /([\+\-]|\d\d)/gi;
3205
3206    function offsetFromString(matcher, string) {
3207        var matches = ((string || '').match(matcher) || []);
3208        var chunk   = matches[matches.length - 1] || [];
3209        var parts   = (chunk + '').match(chunkOffset) || ['-', 0, 0];
3210        var minutes = +(parts[1] * 60) + toInt(parts[2]);
3211
3212        return parts[0] === '+' ? minutes : -minutes;
3213    }
3214
3215    // Return a moment from input, that is local/utc/zone equivalent to model.
3216    function cloneWithOffset(input, model) {
3217        var res, diff;
3218        if (model._isUTC) {
3219            res = model.clone();
3220            diff = (isMoment(input) || isDate(input) ? input.valueOf() : local__createLocal(input).valueOf()) - res.valueOf();
3221            // Use low-level api, because this fn is low-level api.
3222            res._d.setTime(res._d.valueOf() + diff);
3223            utils_hooks__hooks.updateOffset(res, false);
3224            return res;
3225        } else {
3226            return local__createLocal(input).local();
3227        }
3228    }
3229
3230    function getDateOffset (m) {
3231        // On Firefox.24 Date#getTimezoneOffset returns a floating point.
3232        // https://github.com/moment/moment/pull/1871
3233        return -Math.round(m._d.getTimezoneOffset() / 15) * 15;
3234    }
3235
3236    // HOOKS
3237
3238    // This function will be called whenever a moment is mutated.
3239    // It is intended to keep the offset in sync with the timezone.
3240    utils_hooks__hooks.updateOffset = function () {};
3241
3242    // MOMENTS
3243
3244    // keepLocalTime = true means only change the timezone, without
3245    // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
3246    // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
3247    // +0200, so we adjust the time as needed, to be valid.
3248    //
3249    // Keeping the time actually adds/subtracts (one hour)
3250    // from the actual represented time. That is why we call updateOffset
3251    // a second time. In case it wants us to change the offset again
3252    // _changeInProgress == true case, then we have to adjust, because
3253    // there is no such time in the given timezone.
3254    function getSetOffset (input, keepLocalTime) {
3255        var offset = this._offset || 0,
3256            localAdjust;
3257        if (!this.isValid()) {
3258            return input != null ? this : NaN;
3259        }
3260        if (input != null) {
3261            if (typeof input === 'string') {
3262                input = offsetFromString(matchShortOffset, input);
3263            } else if (Math.abs(input) < 16) {
3264                input = input * 60;
3265            }
3266            if (!this._isUTC && keepLocalTime) {
3267                localAdjust = getDateOffset(this);
3268            }
3269            this._offset = input;
3270            this._isUTC = true;
3271            if (localAdjust != null) {
3272                this.add(localAdjust, 'm');
3273            }
3274            if (offset !== input) {
3275                if (!keepLocalTime || this._changeInProgress) {
3276                    add_subtract__addSubtract(this, create__createDuration(input - offset, 'm'), 1, false);
3277                } else if (!this._changeInProgress) {
3278                    this._changeInProgress = true;
3279                    utils_hooks__hooks.updateOffset(this, true);
3280                    this._changeInProgress = null;
3281                }
3282            }
3283            return this;
3284        } else {
3285            return this._isUTC ? offset : getDateOffset(this);
3286        }
3287    }
3288
3289    function getSetZone (input, keepLocalTime) {
3290        if (input != null) {
3291            if (typeof input !== 'string') {
3292                input = -input;
3293            }
3294
3295            this.utcOffset(input, keepLocalTime);
3296
3297            return this;
3298        } else {
3299            return -this.utcOffset();
3300        }
3301    }
3302
3303    function setOffsetToUTC (keepLocalTime) {
3304        return this.utcOffset(0, keepLocalTime);
3305    }
3306
3307    function setOffsetToLocal (keepLocalTime) {
3308        if (this._isUTC) {
3309            this.utcOffset(0, keepLocalTime);
3310            this._isUTC = false;
3311
3312            if (keepLocalTime) {
3313                this.subtract(getDateOffset(this), 'm');
3314            }
3315        }
3316        return this;
3317    }
3318
3319    function setOffsetToParsedOffset () {
3320        if (this._tzm) {
3321            this.utcOffset(this._tzm);
3322        } else if (typeof this._i === 'string') {
3323            this.utcOffset(offsetFromString(matchOffset, this._i));
3324        }
3325        return this;
3326    }
3327
3328    function hasAlignedHourOffset (input) {
3329        if (!this.isValid()) {
3330            return false;
3331        }
3332        input = input ? local__createLocal(input).utcOffset() : 0;
3333
3334        return (this.utcOffset() - input) % 60 === 0;
3335    }
3336
3337    function isDaylightSavingTime () {
3338        return (
3339            this.utcOffset() > this.clone().month(0).utcOffset() ||
3340            this.utcOffset() > this.clone().month(5).utcOffset()
3341        );
3342    }
3343
3344    function isDaylightSavingTimeShifted () {
3345        if (!isUndefined(this._isDSTShifted)) {
3346            return this._isDSTShifted;
3347        }
3348
3349        var c = {};
3350
3351        copyConfig(c, this);
3352        c = prepareConfig(c);
3353
3354        if (c._a) {
3355            var other = c._isUTC ? create_utc__createUTC(c._a) : local__createLocal(c._a);
3356            this._isDSTShifted = this.isValid() &&
3357                compareArrays(c._a, other.toArray()) > 0;
3358        } else {
3359            this._isDSTShifted = false;
3360        }
3361
3362        return this._isDSTShifted;
3363    }
3364
3365    function isLocal () {
3366        return this.isValid() ? !this._isUTC : false;
3367    }
3368
3369    function isUtcOffset () {
3370        return this.isValid() ? this._isUTC : false;
3371    }
3372
3373    function isUtc () {
3374        return this.isValid() ? this._isUTC && this._offset === 0 : false;
3375    }
3376
3377    // ASP.NET json date format regex
3378    var aspNetRegex = /^(\-)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?\d*)?$/;
3379
3380    // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
3381    // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
3382    // and further modified to allow for strings containing both week and day
3383    var isoRegex = /^(-)?P(?:(-?[0-9,.]*)Y)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)W)?(?:(-?[0-9,.]*)D)?(?:T(?:(-?[0-9,.]*)H)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)S)?)?$/;
3384
3385    function create__createDuration (input, key) {
3386        var duration = input,
3387            // matching against regexp is expensive, do it on demand
3388            match = null,
3389            sign,
3390            ret,
3391            diffRes;
3392
3393        if (isDuration(input)) {
3394            duration = {
3395                ms : input._milliseconds,
3396                d  : input._days,
3397                M  : input._months
3398            };
3399        } else if (typeof input === 'number') {
3400            duration = {};
3401            if (key) {
3402                duration[key] = input;
3403            } else {
3404                duration.milliseconds = input;
3405            }
3406        } else if (!!(match = aspNetRegex.exec(input))) {
3407            sign = (match[1] === '-') ? -1 : 1;
3408            duration = {
3409                y  : 0,
3410                d  : toInt(match[DATE])        * sign,
3411                h  : toInt(match[HOUR])        * sign,
3412                m  : toInt(match[MINUTE])      * sign,
3413                s  : toInt(match[SECOND])      * sign,
3414                ms : toInt(match[MILLISECOND]) * sign
3415            };
3416        } else if (!!(match = isoRegex.exec(input))) {
3417            sign = (match[1] === '-') ? -1 : 1;
3418            duration = {
3419                y : parseIso(match[2], sign),
3420                M : parseIso(match[3], sign),
3421                w : parseIso(match[4], sign),
3422                d : parseIso(match[5], sign),
3423                h : parseIso(match[6], sign),
3424                m : parseIso(match[7], sign),
3425                s : parseIso(match[8], sign)
3426            };
3427        } else if (duration == null) {// checks for null or undefined
3428            duration = {};
3429        } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
3430            diffRes = momentsDifference(local__createLocal(duration.from), local__createLocal(duration.to));
3431
3432            duration = {};
3433            duration.ms = diffRes.milliseconds;
3434            duration.M = diffRes.months;
3435        }
3436
3437        ret = new Duration(duration);
3438
3439        if (isDuration(input) && hasOwnProp(input, '_locale')) {
3440            ret._locale = input._locale;
3441        }
3442
3443        return ret;
3444    }
3445
3446    create__createDuration.fn = Duration.prototype;
3447
3448    function parseIso (inp, sign) {
3449        // We'd normally use ~~inp for this, but unfortunately it also
3450        // converts floats to ints.
3451        // inp may be undefined, so careful calling replace on it.
3452        var res = inp && parseFloat(inp.replace(',', '.'));
3453        // apply sign while we're at it
3454        return (isNaN(res) ? 0 : res) * sign;
3455    }
3456
3457    function positiveMomentsDifference(base, other) {
3458        var res = {milliseconds: 0, months: 0};
3459
3460        res.months = other.month() - base.month() +
3461            (other.year() - base.year()) * 12;
3462        if (base.clone().add(res.months, 'M').isAfter(other)) {
3463            --res.months;
3464        }
3465
3466        res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
3467
3468        return res;
3469    }
3470
3471    function momentsDifference(base, other) {
3472        var res;
3473        if (!(base.isValid() && other.isValid())) {
3474            return {milliseconds: 0, months: 0};
3475        }
3476
3477        other = cloneWithOffset(other, base);
3478        if (base.isBefore(other)) {
3479            res = positiveMomentsDifference(base, other);
3480        } else {
3481            res = positiveMomentsDifference(other, base);
3482            res.milliseconds = -res.milliseconds;
3483            res.months = -res.months;
3484        }
3485
3486        return res;
3487    }
3488
3489    function absRound (number) {
3490        if (number < 0) {
3491            return Math.round(-1 * number) * -1;
3492        } else {
3493            return Math.round(number);
3494        }
3495    }
3496
3497    // TODO: remove 'name' arg after deprecation is removed
3498    function createAdder(direction, name) {
3499        return function (val, period) {
3500            var dur, tmp;
3501            //invert the arguments, but complain about it
3502            if (period !== null && !isNaN(+period)) {
3503                deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' +
3504                'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');
3505                tmp = val; val = period; period = tmp;
3506            }
3507
3508            val = typeof val === 'string' ? +val : val;
3509            dur = create__createDuration(val, period);
3510            add_subtract__addSubtract(this, dur, direction);
3511            return this;
3512        };
3513    }
3514
3515    function add_subtract__addSubtract (mom, duration, isAdding, updateOffset) {
3516        var milliseconds = duration._milliseconds,
3517            days = absRound(duration._days),
3518            months = absRound(duration._months);
3519
3520        if (!mom.isValid()) {
3521            // No op
3522            return;
3523        }
3524
3525        updateOffset = updateOffset == null ? true : updateOffset;
3526
3527        if (milliseconds) {
3528            mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
3529        }
3530        if (days) {
3531            get_set__set(mom, 'Date', get_set__get(mom, 'Date') + days * isAdding);
3532        }
3533        if (months) {
3534            setMonth(mom, get_set__get(mom, 'Month') + months * isAdding);
3535        }
3536        if (updateOffset) {
3537            utils_hooks__hooks.updateOffset(mom, days || months);
3538        }
3539    }
3540
3541    var add_subtract__add      = createAdder(1, 'add');
3542    var add_subtract__subtract = createAdder(-1, 'subtract');
3543
3544    function getCalendarFormat(myMoment, now) {
3545        var diff = myMoment.diff(now, 'days', true);
3546        return diff < -6 ? 'sameElse' :
3547                diff < -1 ? 'lastWeek' :
3548                diff < 0 ? 'lastDay' :
3549                diff < 1 ? 'sameDay' :
3550                diff < 2 ? 'nextDay' :
3551                diff < 7 ? 'nextWeek' : 'sameElse';
3552    }
3553
3554    function moment_calendar__calendar (time, formats) {
3555        // We want to compare the start of today, vs this.
3556        // Getting start-of-today depends on whether we're local/utc/offset or not.
3557        var now = time || local__createLocal(),
3558            sod = cloneWithOffset(now, this).startOf('day'),
3559            format = utils_hooks__hooks.calendarFormat(this, sod) || 'sameElse';
3560
3561        var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]);
3562