@nocobase/plugin-backup-restore 2.2.20 → 2.2.21

package/dist/node_modules/moment/dist/moment.js

@@ -1,5 +1,5 @@
 //! moment.js
-//! version : 2.29.4
+//! version : 2.31.0
 //! authors : Tim Wood, Iskren Chernev, Moment.js contributors
 //! license : MIT
 //! momentjs.com
@@ -111,6 +111,7 @@ function defaultParsingFlags() {
         nullInput: false,
         invalidEra: null,
         invalidMonth: null,
+        invalidOffset: null,
         invalidFormat: false,
         userInvalidated: false,
         iso: false,
@@ -148,25 +149,27 @@ if (Array.prototype.some) {
     };
 }
 
-function isValid(m) {
-    if (m._isValid == null) {
-        var flags = getParsingFlags(m),
-            parsedParts = some.call(flags.parsedDateParts, function (i) {
-                return i != null;
-            }),
-            isNowValid =
-                !isNaN(m._d.getTime()) &&
-                flags.overflow < 0 &&
-                !flags.empty &&
-                !flags.invalidEra &&
-                !flags.invalidMonth &&
-                !flags.invalidWeekday &&
-                !flags.weekdayMismatch &&
-                !flags.nullInput &&
-                !flags.invalidFormat &&
-                !flags.userInvalidated &&
-                (!flags.meridiem || (flags.meridiem && parsedParts));
-
+function isValid$2(m) {
+    var flags = null,
+        parsedParts = false,
+        isNowValid = m._d && !isNaN(m._d.getTime());
+    if (isNowValid) {
+        flags = getParsingFlags(m);
+        parsedParts = some.call(flags.parsedDateParts, function (i) {
+            return i != null;
+        });
+        isNowValid =
+            flags.overflow < 0 &&
+            !flags.empty &&
+            !flags.invalidEra &&
+            !flags.invalidMonth &&
+            !flags.invalidOffset &&
+            !flags.invalidWeekday &&
+            !flags.weekdayMismatch &&
+            !flags.nullInput &&
+            !flags.invalidFormat &&
+            !flags.userInvalidated &&
+            (!flags.meridiem || (flags.meridiem && parsedParts));
         if (m._strict) {
             isNowValid =
                 isNowValid &&
@@ -174,17 +177,16 @@ function isValid(m) {
                 flags.unusedTokens.length === 0 &&
                 flags.bigHour === undefined;
         }
-
-        if (Object.isFrozen == null || !Object.isFrozen(m)) {
-            m._isValid = isNowValid;
-        } else {
-            return isNowValid;
-        }
+    }
+    if (Object.isFrozen == null || !Object.isFrozen(m)) {
+        m._isValid = isNowValid;
+    } else {
+        return isNowValid;
     }
     return m._isValid;
 }
 
-function createInvalid(flags) {
+function createInvalid$1(flags) {
     var m = createUTC(NaN);
     if (flags != null) {
         extend(getParsingFlags(m), flags);
@@ -330,7 +332,7 @@ function deprecateSimple(name, msg) {
         hooks.deprecationHandler(name, msg);
     }
     if (!deprecations[name]) {
-        warn(msg);
+        warn(msg + '\n' + new Error().stack);
         deprecations[name] = true;
     }
 }
@@ -345,93 +347,111 @@ function isFunction(input) {
     );
 }
 
-function set(config) {
-    var prop, i;
-    for (i in config) {
-        if (hasOwnProp(config, i)) {
-            prop = config[i];
-            if (isFunction(prop)) {
-                this[i] = prop;
-            } else {
-                this['_' + i] = prop;
-            }
-        }
-    }
-    this._config = config;
-    // Lenient ordinal parsing accepts just a number in addition to
-    // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
-    // TODO: Remove "ordinalParse" fallback in next major release.
-    this._dayOfMonthOrdinalParseLenient = new RegExp(
-        (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +
-            '|' +
-            /\d{1,2}/.source
-    );
+var aliases = {
+    D: 'date',
+    dates: 'date',
+    date: 'date',
+    d: 'day',
+    days: 'day',
+    day: 'day',
+    e: 'weekday',
+    weekdays: 'weekday',
+    weekday: 'weekday',
+    E: 'isoWeekday',
+    isoweekdays: 'isoWeekday',
+    isoweekday: 'isoWeekday',
+    DDD: 'dayOfYear',
+    dayofyears: 'dayOfYear',
+    dayofyear: 'dayOfYear',
+    h: 'hour',
+    hours: 'hour',
+    hour: 'hour',
+    ms: 'millisecond',
+    milliseconds: 'millisecond',
+    millisecond: 'millisecond',
+    m: 'minute',
+    minutes: 'minute',
+    minute: 'minute',
+    M: 'month',
+    months: 'month',
+    month: 'month',
+    Q: 'quarter',
+    quarters: 'quarter',
+    quarter: 'quarter',
+    s: 'second',
+    seconds: 'second',
+    second: 'second',
+    gg: 'weekYear',
+    weekyears: 'weekYear',
+    weekyear: 'weekYear',
+    GG: 'isoWeekYear',
+    isoweekyears: 'isoWeekYear',
+    isoweekyear: 'isoWeekYear',
+    w: 'week',
+    weeks: 'week',
+    week: 'week',
+    W: 'isoWeek',
+    isoweeks: 'isoWeek',
+    isoweek: 'isoWeek',
+    y: 'year',
+    years: 'year',
+    year: 'year',
+};
+
+function normalizeUnits(units) {
+    return typeof units === 'string'
+        ? aliases[units] || aliases[units.toLowerCase()]
+        : undefined;
 }
 
-function mergeConfigs(parentConfig, childConfig) {
-    var res = extend({}, parentConfig),
+function normalizeObjectUnits(inputObject) {
+    var normalizedInput = {},
+        normalizedProp,
         prop;
-    for (prop in childConfig) {
-        if (hasOwnProp(childConfig, prop)) {
-            if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
-                res[prop] = {};
-                extend(res[prop], parentConfig[prop]);
-                extend(res[prop], childConfig[prop]);
-            } else if (childConfig[prop] != null) {
-                res[prop] = childConfig[prop];
-            } else {
-                delete res[prop];
+
+    for (prop in inputObject) {
+        if (hasOwnProp(inputObject, prop)) {
+            normalizedProp = normalizeUnits(prop);
+            if (normalizedProp) {
+                normalizedInput[normalizedProp] = inputObject[prop];
             }
         }
     }
-    for (prop in parentConfig) {
-        if (
-            hasOwnProp(parentConfig, prop) &&
-            !hasOwnProp(childConfig, prop) &&
-            isObject(parentConfig[prop])
-        ) {
-            // make sure changes to properties don't modify parent config
-            res[prop] = extend({}, res[prop]);
-        }
-    }
-    return res;
-}
-
-function Locale(config) {
-    if (config != null) {
-        this.set(config);
-    }
-}
-
-var keys;
 
-if (Object.keys) {
-    keys = Object.keys;
-} else {
-    keys = function (obj) {
-        var i,
-            res = [];
-        for (i in obj) {
-            if (hasOwnProp(obj, i)) {
-                res.push(i);
-            }
-        }
-        return res;
-    };
+    return normalizedInput;
 }
 
-var defaultCalendar = {
-    sameDay: '[Today at] LT',
-    nextDay: '[Tomorrow at] LT',
-    nextWeek: 'dddd [at] LT',
-    lastDay: '[Yesterday at] LT',
-    lastWeek: '[Last] dddd [at] LT',
-    sameElse: 'L',
+var priorities = {
+    date: 9,
+    day: 11,
+    weekday: 11,
+    isoWeekday: 11,
+    dayOfYear: 4,
+    hour: 13,
+    millisecond: 16,
+    minute: 14,
+    month: 8,
+    quarter: 7,
+    second: 15,
+    weekYear: 1,
+    isoWeekYear: 1,
+    week: 5,
+    isoWeek: 5,
+    year: 1,
 };
 
-function calendar(key, mom, now) {
-    var output = this._calendar[key] || this._calendar['sameElse'];
-    return isFunction(output) ? output.call(mom, now) : output;
+function getPrioritizedUnits(unitsObj) {
+    var units = [],
+        u;
+    for (u in unitsObj) {
+        if (hasOwnProp(unitsObj, u)) {
+            units.push({ unit: u, priority: priorities[u] });
+        }
+    }
+    units.sort(function (a, b) {
+        return a.priority - b.priority;
+    });
+    return units;
 }
 
 function zeroFill(number, targetLength, forceSign) {
@@ -446,7 +466,7 @@ function zeroFill(number, targetLength, forceSign) {
 }
 
 var formattingTokens =
-        /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,
+        /(\[[^\[]*\])|(\\e)|(\\)?(eHHmm|[Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,
     localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,
     formatFunctions = {},
     formatTokenFunctions = {};
@@ -519,10 +539,12 @@ function formatMoment(m, format) {
     }
 
     format = expandFormat(format, m.localeData());
-    formatFunctions[format] =
-        formatFunctions[format] || makeFormatFunction(format);
+    var cacheKey = '$' + format;
+    if (!hasOwnProp(formatFunctions, cacheKey)) {
+        formatFunctions[cacheKey] = makeFormatFunction(format);
+    }
 
-    return formatFunctions[format](m);
+    return formatFunctions[cacheKey](m);
 }
 
 function expandFormat(format, locale) {
@@ -545,157 +567,186 @@ function expandFormat(format, locale) {
     return format;
 }
 
-var defaultLongDateFormat = {
-    LTS: 'h:mm:ss A',
-    LT: 'h:mm A',
-    L: 'MM/DD/YYYY',
-    LL: 'MMMM D, YYYY',
-    LLL: 'MMMM D, YYYY h:mm A',
-    LLLL: 'dddd, MMMM D, YYYY h:mm A',
-};
-
-function longDateFormat(key) {
-    var format = this._longDateFormat[key],
-        formatUpper = this._longDateFormat[key.toUpperCase()];
-
-    if (format || !formatUpper) {
-        return format;
-    }
-
-    this._longDateFormat[key] = formatUpper
-        .match(formattingTokens)
-        .map(function (tok) {
-            if (
-                tok === 'MMMM' ||
-                tok === 'MM' ||
-                tok === 'DD' ||
-                tok === 'dddd'
-            ) {
-                return tok.slice(1);
-            }
-            return tok;
-        })
-        .join('');
-
-    return this._longDateFormat[key];
-}
-
-var defaultInvalidDate = 'Invalid date';
-
-function invalidDate() {
-    return this._invalidDate;
-}
+var match1 = /\d/, //       0 - 9
+    match2 = /\d\d/, //      00 - 99
+    match3 = /\d{3}/, //     000 - 999
+    match4 = /\d{4}/, //    0000 - 9999
+    match6 = /[+-]?\d{6}/, // -999999 - 999999
+    match1to2 = /\d\d?/, //       0 - 99
+    match3to4 = /\d\d\d\d?/, //     999 - 9999
+    match5to6 = /\d\d\d\d\d\d?/, //   99999 - 999999
+    match1to3 = /\d{1,3}/, //       0 - 999
+    match1to4 = /\d{1,4}/, //       0 - 9999
+    match1to6 = /[+-]?\d{1,6}/, // -999999 - 999999
+    matchUnsigned = /\d+/, //       0 - inf
+    matchSigned = /[+-]?\d+/, //    -inf - inf
+    matchOffset = /Z|[+-]\d\d:?\d\d/gi, // +00:00 -00:00 +0000 -0000 or Z
+    matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi, // +00 -00 +00:00 -00:00 +0000 -0000 or Z
+    matchTimestamp = /[+-]?\d+(\.\d{1,3})?/, // 123456789 123456789.123
+    // any word (or two) characters or numbers including two/three word month in arabic.
+    // includes scottish gaelic two word and hyphenated months
+    matchWord =
+        /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i,
+    match1to2NoLeadingZero = /^[1-9]\d?/, //         1-99
+    match1to2HasZero = /^([1-9]\d|\d)/, //           0-99
+    regexes;
 
-var defaultOrdinal = '%d',
-    defaultDayOfMonthOrdinalParse = /\d{1,2}/;
+regexes = {};
 
-function ordinal(number) {
-    return this._ordinal.replace('%d', number);
+function addRegexToken(token, regex, strictRegex) {
+    regexes[token] = isFunction(regex)
+        ? regex
+        : function (isStrict, localeData) {
+              return isStrict && strictRegex ? strictRegex : regex;
+          };
 }
 
-var defaultRelativeTime = {
-    future: 'in %s',
-    past: '%s ago',
-    s: 'a few seconds',
-    ss: '%d seconds',
-    m: 'a minute',
-    mm: '%d minutes',
-    h: 'an hour',
-    hh: '%d hours',
-    d: 'a day',
-    dd: '%d days',
-    w: 'a week',
-    ww: '%d weeks',
-    M: 'a month',
-    MM: '%d months',
-    y: 'a year',
-    yy: '%d years',
-};
+function getParseRegexForToken(token, config) {
+    if (!hasOwnProp(regexes, token)) {
+        return new RegExp(unescapeFormat(token));
+    }
 
-function relativeTime(number, withoutSuffix, string, isFuture) {
-    var output = this._relativeTime[string];
-    return isFunction(output)
-        ? output(number, withoutSuffix, string, isFuture)
-        : output.replace(/%d/i, number);
+    return regexes[token](config._strict, config._locale);
 }
 
-function pastFuture(diff, output) {
-    var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
-    return isFunction(format) ? format(output) : format.replace(/%s/i, output);
+// Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
+function unescapeFormat(s) {
+    return regexEscape(
+        s
+            .replace('\\', '')
+            .replace(
+                /\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,
+                function (matched, p1, p2, p3, p4) {
+                    return p1 || p2 || p3 || p4;
+                }
+            )
+    );
 }
 
-var aliases = {};
-
-function addUnitAlias(unit, shorthand) {
-    var lowerCase = unit.toLowerCase();
-    aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
+function regexEscape(s) {
+    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
 }
 
-function normalizeUnits(units) {
-    return typeof units === 'string'
-        ? aliases[units] || aliases[units.toLowerCase()]
-        : undefined;
+function absFloor(number) {
+    if (number < 0) {
+        // -0 -> 0
+        return Math.ceil(number) || 0;
+    } else {
+        return Math.floor(number);
+    }
 }
 
-function normalizeObjectUnits(inputObject) {
-    var normalizedInput = {},
-        normalizedProp,
-        prop;
+function toInt(argumentForCoercion) {
+    var coercedNumber = +argumentForCoercion,
+        value = 0;
 
-    for (prop in inputObject) {
-        if (hasOwnProp(inputObject, prop)) {
-            normalizedProp = normalizeUnits(prop);
-            if (normalizedProp) {
-                normalizedInput[normalizedProp] = inputObject[prop];
-            }
-        }
+    if (coercedNumber !== 0 && isFinite(coercedNumber)) {
+        value = absFloor(coercedNumber);
     }
 
-    return normalizedInput;
+    return value;
 }
 
-var priorities = {};
+var tokens = {};
 
-function addUnitPriority(unit, priority) {
-    priorities[unit] = priority;
+function addParseToken(token, callback) {
+    var i,
+        func = callback,
+        tokenLen;
+    if (typeof token === 'string') {
+        token = [token];
+    }
+    if (isNumber(callback)) {
+        func = function (input, array) {
+            array[callback] = toInt(input);
+        };
+    }
+    tokenLen = token.length;
+    for (i = 0; i < tokenLen; i++) {
+        tokens[token[i]] = func;
+    }
 }
 
-function getPrioritizedUnits(unitsObj) {
-    var units = [],
-        u;
-    for (u in unitsObj) {
-        if (hasOwnProp(unitsObj, u)) {
-            units.push({ unit: u, priority: priorities[u] });
-        }
-    }
-    units.sort(function (a, b) {
-        return a.priority - b.priority;
+function addWeekParseToken(token, callback) {
+    addParseToken(token, function (input, array, config, token) {
+        config._w = config._w || {};
+        callback(input, config._w, config, token);
     });
-    return units;
+}
+
+function addTimeToArrayFromToken(token, input, config) {
+    if (input != null && hasOwnProp(tokens, token)) {
+        tokens[token](input, config._a, config, token);
+    }
 }
 
 function isLeapYear(year) {
     return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
 }
 
-function absFloor(number) {
-    if (number < 0) {
-        // -0 -> 0
-        return Math.ceil(number) || 0;
-    } else {
-        return Math.floor(number);
-    }
+var YEAR = 0,
+    MONTH = 1,
+    DATE = 2,
+    HOUR = 3,
+    MINUTE = 4,
+    SECOND = 5,
+    MILLISECOND = 6,
+    WEEK = 7,
+    WEEKDAY = 8;
+
+// FORMATTING
+
+addFormatToken('Y', 0, 0, function () {
+    var y = this.year();
+    return y <= 9999 ? zeroFill(y, 4) : '+' + y;
+});
+
+addFormatToken(0, ['YY', 2], 0, function () {
+    return this.year() % 100;
+});
+
+addFormatToken(0, ['YYYY', 4], 0, 'year');
+addFormatToken(0, ['YYYYY', 5], 0, 'year');
+addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
+
+// PARSING
+
+addRegexToken('Y', matchSigned);
+addRegexToken('YY', match1to2, match2);
+addRegexToken('YYYY', match1to4, match4);
+addRegexToken('YYYYY', match1to6, match6);
+addRegexToken('YYYYYY', match1to6, match6);
+
+addParseToken(['YYYYY', 'YYYYYY'], YEAR);
+addParseToken('YYYY', function (input, array) {
+    array[YEAR] =
+        input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
+});
+addParseToken('YY', function (input, array) {
+    array[YEAR] = hooks.parseTwoDigitYear(input);
+});
+addParseToken('Y', function (input, array) {
+    array[YEAR] = parseInt(input, 10);
+});
+
+// HELPERS
+
+function daysInYear(year) {
+    return isLeapYear(year) ? 366 : 365;
 }
 
-function toInt(argumentForCoercion) {
-    var coercedNumber = +argumentForCoercion,
-        value = 0;
+// HOOKS
 
-    if (coercedNumber !== 0 && isFinite(coercedNumber)) {
-        value = absFloor(coercedNumber);
-    }
+hooks.parseTwoDigitYear = function (input) {
+    return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
+};
 
-    return value;
+// MOMENTS
+
+var getSetYear = makeGetSet('FullYear', true);
+
+function getIsLeapYear() {
+    return isLeapYear(this.year());
 }
 
 function makeGetSet(unit, keepTime) {
@@ -705,35 +756,81 @@ function makeGetSet(unit, keepTime) {
             hooks.updateOffset(this, keepTime);
             return this;
         } else {
-            return get(this, unit);
+            return get$2(this, unit);
         }
     };
 }
 
-function get(mom, unit) {
-    return mom.isValid()
-        ? mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]()
-        : NaN;
+function get$2(mom, unit) {
+    if (!mom.isValid()) {
+        return NaN;
+    }
+
+    var d = mom._d,
+        isUTC = mom._isUTC;
+
+    switch (unit) {
+        case 'Milliseconds':
+            return isUTC ? d.getUTCMilliseconds() : d.getMilliseconds();
+        case 'Seconds':
+            return isUTC ? d.getUTCSeconds() : d.getSeconds();
+        case 'Minutes':
+            return isUTC ? d.getUTCMinutes() : d.getMinutes();
+        case 'Hours':
+            return isUTC ? d.getUTCHours() : d.getHours();
+        case 'Date':
+            return isUTC ? d.getUTCDate() : d.getDate();
+        case 'Day':
+            return isUTC ? d.getUTCDay() : d.getDay();
+        case 'Month':
+            return isUTC ? d.getUTCMonth() : d.getMonth();
+        case 'FullYear':
+            return isUTC ? d.getUTCFullYear() : d.getFullYear();
+        default:
+            return NaN; // Just in case
+    }
 }
 
 function set$1(mom, unit, value) {
-    if (mom.isValid() && !isNaN(value)) {
-        if (
-            unit === 'FullYear' &&
-            isLeapYear(mom.year()) &&
-            mom.month() === 1 &&
-            mom.date() === 29
-        ) {
-            value = toInt(value);
-            mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](
-                value,
-                mom.month(),
-                daysInMonth(value, mom.month())
-            );
-        } else {
-            mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
-        }
+    var d, isUTC, year, month, date;
+
+    if (!mom.isValid() || isNaN(value)) {
+        return;
     }
+
+    d = mom._d;
+    isUTC = mom._isUTC;
+
+    switch (unit) {
+        case 'Milliseconds':
+            return void (isUTC
+                ? d.setUTCMilliseconds(value)
+                : d.setMilliseconds(value));
+        case 'Seconds':
+            return void (isUTC ? d.setUTCSeconds(value) : d.setSeconds(value));
+        case 'Minutes':
+            return void (isUTC ? d.setUTCMinutes(value) : d.setMinutes(value));
+        case 'Hours':
+            return void (isUTC ? d.setUTCHours(value) : d.setHours(value));
+        case 'Date':
+            return void (isUTC ? d.setUTCDate(value) : d.setDate(value));
+        // case 'Day': // Not real
+        //    return void (isUTC ? d.setUTCDay(value) : d.setDay(value));
+        // case 'Month': // Not used because we need to pass two variables
+        //     return void (isUTC ? d.setUTCMonth(value) : d.setMonth(value));
+        case 'FullYear':
+            break; // See below ...
+        default:
+            return; // Just in case
+    }
+
+    year = value;
+    month = mom.month();
+    date = mom.date();
+    date = date === 29 && month === 1 && !isLeapYear(year) ? 28 : date;
+    void (isUTC
+        ? d.setUTCFullYear(year, month, date)
+        : d.setFullYear(year, month, date));
 }
 
 // MOMENTS
@@ -764,108 +861,7 @@ function stringSet(units, value) {
     return this;
 }
 
-var match1 = /\d/, //       0 - 9
-    match2 = /\d\d/, //      00 - 99
-    match3 = /\d{3}/, //     000 - 999
-    match4 = /\d{4}/, //    0000 - 9999
-    match6 = /[+-]?\d{6}/, // -999999 - 999999
-    match1to2 = /\d\d?/, //       0 - 99
-    match3to4 = /\d\d\d\d?/, //     999 - 9999
-    match5to6 = /\d\d\d\d\d\d?/, //   99999 - 999999
-    match1to3 = /\d{1,3}/, //       0 - 999
-    match1to4 = /\d{1,4}/, //       0 - 9999
-    match1to6 = /[+-]?\d{1,6}/, // -999999 - 999999
-    matchUnsigned = /\d+/, //       0 - inf
-    matchSigned = /[+-]?\d+/, //    -inf - inf
-    matchOffset = /Z|[+-]\d\d:?\d\d/gi, // +00:00 -00:00 +0000 -0000 or Z
-    matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi, // +00 -00 +00:00 -00:00 +0000 -0000 or Z
-    matchTimestamp = /[+-]?\d+(\.\d{1,3})?/, // 123456789 123456789.123
-    // any word (or two) characters or numbers including two/three word month in arabic.
-    // includes scottish gaelic two word and hyphenated months
-    matchWord =
-        /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i,
-    regexes;
-
-regexes = {};
-
-function addRegexToken(token, regex, strictRegex) {
-    regexes[token] = isFunction(regex)
-        ? regex
-        : function (isStrict, localeData) {
-              return isStrict && strictRegex ? strictRegex : regex;
-          };
-}
-
-function getParseRegexForToken(token, config) {
-    if (!hasOwnProp(regexes, token)) {
-        return new RegExp(unescapeFormat(token));
-    }
-
-    return regexes[token](config._strict, config._locale);
-}
-
-// Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
-function unescapeFormat(s) {
-    return regexEscape(
-        s
-            .replace('\\', '')
-            .replace(
-                /\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,
-                function (matched, p1, p2, p3, p4) {
-                    return p1 || p2 || p3 || p4;
-                }
-            )
-    );
-}
-
-function regexEscape(s) {
-    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
-}
-
-var tokens = {};
-
-function addParseToken(token, callback) {
-    var i,
-        func = callback,
-        tokenLen;
-    if (typeof token === 'string') {
-        token = [token];
-    }
-    if (isNumber(callback)) {
-        func = function (input, array) {
-            array[callback] = toInt(input);
-        };
-    }
-    tokenLen = token.length;
-    for (i = 0; i < tokenLen; i++) {
-        tokens[token[i]] = func;
-    }
-}
-
-function addWeekParseToken(token, callback) {
-    addParseToken(token, function (input, array, config, token) {
-        config._w = config._w || {};
-        callback(input, config._w, config, token);
-    });
-}
-
-function addTimeToArrayFromToken(token, input, config) {
-    if (input != null && hasOwnProp(tokens, token)) {
-        tokens[token](input, config._a, config, token);
-    }
-}
-
-var YEAR = 0,
-    MONTH = 1,
-    DATE = 2,
-    HOUR = 3,
-    MINUTE = 4,
-    SECOND = 5,
-    MILLISECOND = 6,
-    WEEK = 7,
-    WEEKDAY = 8;
-
-function mod(n, x) {
+function mod$1(n, x) {
     return ((n % x) + x) % x;
 }
 
@@ -890,7 +886,7 @@ function daysInMonth(year, month) {
     if (isNaN(year) || isNaN(month)) {
         return NaN;
     }
-    var modMonth = mod(month, 12);
+    var modMonth = mod$1(month, 12);
     year += (month - modMonth) / 12;
     return modMonth === 1
         ? isLeapYear(year)
@@ -913,17 +909,9 @@ addFormatToken('MMMM', 0, 0, function (format) {
     return this.localeData().months(this, format);
 });
 
-// ALIASES
-
-addUnitAlias('month', 'M');
-
-// PRIORITY
-
-addUnitPriority('month', 8);
-
 // PARSING
 
-addRegexToken('M', match1to2);
+addRegexToken('M', match1to2, match1to2NoLeadingZero);
 addRegexToken('MM', match1to2, match2);
 addRegexToken('MMM', function (isStrict, locale) {
     return locale.monthsShortRegex(isStrict);
@@ -956,7 +944,26 @@ var defaultLocaleMonths =
         'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
     MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/,
     defaultMonthsShortRegex = matchWord,
-    defaultMonthsRegex = matchWord;
+    defaultMonthsRegex = matchWord,
+    monthsParseProperties = [
+        'monthsParse',
+        'longMonthsParse',
+        'shortMonthsParse',
+        'monthsRegex',
+        'monthsShortRegex',
+        'monthsStrictRegex',
+        'monthsShortStrictRegex',
+    ];
+
+function clearMonthsParseCache(locale, config) {
+    var i, prop;
+    for (i = 0; i < monthsParseProperties.length; i++) {
+        prop = monthsParseProperties[i];
+        if (!hasOwnProp(config, prop)) {
+            delete locale['_' + prop];
+        }
+    }
+}
 
 function localeMonths(m, format) {
     if (!m) {
@@ -986,7 +993,7 @@ function localeMonthsShort(m, format) {
           ][m.month()];
 }
 
-function handleStrictParse(monthName, format, strict) {
+function handleStrictParse$1(monthName, format, strict) {
     var i,
         ii,
         mom,
@@ -1037,7 +1044,7 @@ function localeMonthsParse(monthName, format, strict) {
     var i, mom, regex;
 
     if (this._monthsParseExact) {
-        return handleStrictParse.call(this, monthName, format, strict);
+        return handleStrictParse$1.call(this, monthName, format, strict);
     }
 
     if (!this._monthsParse) {
@@ -1089,8 +1096,6 @@ function localeMonthsParse(monthName, format, strict) {
 // MOMENTS
 
 function setMonth(mom, value) {
-    var dayOfMonth;
-
     if (!mom.isValid()) {
         // No op
         return mom;
@@ -1108,8 +1113,13 @@ function setMonth(mom, value) {
         }
     }
 
-    dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
-    mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
+    var month = value,
+        date = mom.date();
+
+    date = date < 29 ? date : Math.min(date, daysInMonth(mom.year(), month));
+    void (mom._isUTC
+        ? mom._d.setUTCMonth(month, date)
+        : mom._d.setMonth(month, date));
     return mom;
 }
 
@@ -1119,7 +1129,7 @@ function getSetMonth(value) {
         hooks.updateOffset(this, true);
         return this;
     } else {
-        return get(this, 'Month');
+        return get$2(this, 'Month');
     }
 }
 
@@ -1176,27 +1186,24 @@ function computeMonthsParse() {
         longPieces = [],
         mixedPieces = [],
         i,
-        mom;
+        mom,
+        shortP,
+        longP;
     for (i = 0; i < 12; i++) {
         // make the regex if we don't have it already
         mom = createUTC([2000, i]);
-        shortPieces.push(this.monthsShort(mom, ''));
-        longPieces.push(this.months(mom, ''));
-        mixedPieces.push(this.months(mom, ''));
-        mixedPieces.push(this.monthsShort(mom, ''));
+        shortP = regexEscape(this.monthsShort(mom, ''));
+        longP = regexEscape(this.months(mom, ''));
+        shortPieces.push(shortP);
+        longPieces.push(longP);
+        mixedPieces.push(longP);
+        mixedPieces.push(shortP);
     }
     // Sorting makes sure if one month (or abbr) is a prefix of another it
     // will match the longer piece.
     shortPieces.sort(cmpLenRev);
     longPieces.sort(cmpLenRev);
     mixedPieces.sort(cmpLenRev);
-    for (i = 0; i < 12; i++) {
-        shortPieces[i] = regexEscape(shortPieces[i]);
-        longPieces[i] = regexEscape(longPieces[i]);
-    }
-    for (i = 0; i < 24; i++) {
-        mixedPieces[i] = regexEscape(mixedPieces[i]);
-    }
 
     this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
     this._monthsShortRegex = this._monthsRegex;
@@ -1212,239 +1219,14 @@ function computeMonthsParse() {
 
 // FORMATTING
 
-addFormatToken('Y', 0, 0, function () {
-    var y = this.year();
-    return y <= 9999 ? zeroFill(y, 4) : '+' + y;
+addFormatToken('d', 0, 'do', 'day');
+
+addFormatToken('dd', 0, 0, function (format) {
+    return this.localeData().weekdaysMin(this, format);
 });
 
-addFormatToken(0, ['YY', 2], 0, function () {
-    return this.year() % 100;
-});
-
-addFormatToken(0, ['YYYY', 4], 0, 'year');
-addFormatToken(0, ['YYYYY', 5], 0, 'year');
-addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
-
-// ALIASES
-
-addUnitAlias('year', 'y');
-
-// PRIORITIES
-
-addUnitPriority('year', 1);
-
-// PARSING
-
-addRegexToken('Y', matchSigned);
-addRegexToken('YY', match1to2, match2);
-addRegexToken('YYYY', match1to4, match4);
-addRegexToken('YYYYY', match1to6, match6);
-addRegexToken('YYYYYY', match1to6, match6);
-
-addParseToken(['YYYYY', 'YYYYYY'], YEAR);
-addParseToken('YYYY', function (input, array) {
-    array[YEAR] =
-        input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
-});
-addParseToken('YY', function (input, array) {
-    array[YEAR] = hooks.parseTwoDigitYear(input);
-});
-addParseToken('Y', function (input, array) {
-    array[YEAR] = parseInt(input, 10);
-});
-
-// HELPERS
-
-function daysInYear(year) {
-    return isLeapYear(year) ? 366 : 365;
-}
-
-// HOOKS
-
-hooks.parseTwoDigitYear = function (input) {
-    return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
-};
-
-// MOMENTS
-
-var getSetYear = makeGetSet('FullYear', true);
-
-function getIsLeapYear() {
-    return isLeapYear(this.year());
-}
-
-function createDate(y, m, d, h, M, s, ms) {
-    // can't just apply() to create a date:
-    // https://stackoverflow.com/q/181348
-    var date;
-    // the date constructor remaps years 0-99 to 1900-1999
-    if (y < 100 && y >= 0) {
-        // preserve leap years using a full 400 year cycle, then reset
-        date = new Date(y + 400, m, d, h, M, s, ms);
-        if (isFinite(date.getFullYear())) {
-            date.setFullYear(y);
-        }
-    } else {
-        date = new Date(y, m, d, h, M, s, ms);
-    }
-
-    return date;
-}
-
-function createUTCDate(y) {
-    var date, args;
-    // the Date.UTC function remaps years 0-99 to 1900-1999
-    if (y < 100 && y >= 0) {
-        args = Array.prototype.slice.call(arguments);
-        // preserve leap years using a full 400 year cycle, then reset
-        args[0] = y + 400;
-        date = new Date(Date.UTC.apply(null, args));
-        if (isFinite(date.getUTCFullYear())) {
-            date.setUTCFullYear(y);
-        }
-    } else {
-        date = new Date(Date.UTC.apply(null, arguments));
-    }
-
-    return date;
-}
-
-// start-of-first-week - start-of-year
-function firstWeekOffset(year, dow, doy) {
-    var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
-        fwd = 7 + dow - doy,
-        // first-week day local weekday -- which local weekday is fwd
-        fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
-
-    return -fwdlw + fwd - 1;
-}
-
-// https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
-function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
-    var localWeekday = (7 + weekday - dow) % 7,
-        weekOffset = firstWeekOffset(year, dow, doy),
-        dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
-        resYear,
-        resDayOfYear;
-
-    if (dayOfYear <= 0) {
-        resYear = year - 1;
-        resDayOfYear = daysInYear(resYear) + dayOfYear;
-    } else if (dayOfYear > daysInYear(year)) {
-        resYear = year + 1;
-        resDayOfYear = dayOfYear - daysInYear(year);
-    } else {
-        resYear = year;
-        resDayOfYear = dayOfYear;
-    }
-
-    return {
-        year: resYear,
-        dayOfYear: resDayOfYear,
-    };
-}
-
-function weekOfYear(mom, dow, doy) {
-    var weekOffset = firstWeekOffset(mom.year(), dow, doy),
-        week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
-        resWeek,
-        resYear;
-
-    if (week < 1) {
-        resYear = mom.year() - 1;
-        resWeek = week + weeksInYear(resYear, dow, doy);
-    } else if (week > weeksInYear(mom.year(), dow, doy)) {
-        resWeek = week - weeksInYear(mom.year(), dow, doy);
-        resYear = mom.year() + 1;
-    } else {
-        resYear = mom.year();
-        resWeek = week;
-    }
-
-    return {
-        week: resWeek,
-        year: resYear,
-    };
-}
-
-function weeksInYear(year, dow, doy) {
-    var weekOffset = firstWeekOffset(year, dow, doy),
-        weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
-    return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
-}
-
-// FORMATTING
-
-addFormatToken('w', ['ww', 2], 'wo', 'week');
-addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
-
-// ALIASES
-
-addUnitAlias('week', 'w');
-addUnitAlias('isoWeek', 'W');
-
-// PRIORITIES
-
-addUnitPriority('week', 5);
-addUnitPriority('isoWeek', 5);
-
-// PARSING
-
-addRegexToken('w', match1to2);
-addRegexToken('ww', match1to2, match2);
-addRegexToken('W', match1to2);
-addRegexToken('WW', match1to2, match2);
-
-addWeekParseToken(
-    ['w', 'ww', 'W', 'WW'],
-    function (input, week, config, token) {
-        week[token.substr(0, 1)] = toInt(input);
-    }
-);
-
-// HELPERS
-
-// LOCALES
-
-function localeWeek(mom) {
-    return weekOfYear(mom, this._week.dow, this._week.doy).week;
-}
-
-var defaultLocaleWeek = {
-    dow: 0, // Sunday is the first day of the week.
-    doy: 6, // The week that contains Jan 6th is the first week of the year.
-};
-
-function localeFirstDayOfWeek() {
-    return this._week.dow;
-}
-
-function localeFirstDayOfYear() {
-    return this._week.doy;
-}
-
-// MOMENTS
-
-function getSetWeek(input) {
-    var week = this.localeData().week(this);
-    return input == null ? week : this.add((input - week) * 7, 'd');
-}
-
-function getSetISOWeek(input) {
-    var week = weekOfYear(this, 1, 4).week;
-    return input == null ? week : this.add((input - week) * 7, 'd');
-}
-
-// FORMATTING
-
-addFormatToken('d', 0, 'do', 'day');
-
-addFormatToken('dd', 0, 0, function (format) {
-    return this.localeData().weekdaysMin(this, format);
-});
-
-addFormatToken('ddd', 0, 0, function (format) {
-    return this.localeData().weekdaysShort(this, format);
+addFormatToken('ddd', 0, 0, function (format) {
+    return this.localeData().weekdaysShort(this, format);
 });
 
 addFormatToken('dddd', 0, 0, function (format) {
@@ -1453,23 +1235,21 @@ addFormatToken('dddd', 0, 0, function (format) {
 
 addFormatToken('e', 0, 0, 'weekday');
 addFormatToken('E', 0, 0, 'isoWeekday');
-
-// ALIASES
-
-addUnitAlias('day', 'd');
-addUnitAlias('weekday', 'e');
-addUnitAlias('isoWeekday', 'E');
-
-// PRIORITY
-addUnitPriority('day', 11);
-addUnitPriority('weekday', 11);
-addUnitPriority('isoWeekday', 11);
+addFormatToken('eHHmm', 0, 0, function () {
+    return (
+        '' +
+        this.weekday() +
+        zeroFill(this.hours(), 2) +
+        zeroFill(this.minutes(), 2)
+    );
+});
 
 // PARSING
 
 addRegexToken('d', match1to2);
 addRegexToken('e', match1to2);
 addRegexToken('E', match1to2);
+addRegexToken('eHHmm', match5to6);
 addRegexToken('dd', function (isStrict, locale) {
     return locale.weekdaysMinRegex(isStrict);
 });
@@ -1494,6 +1274,14 @@ addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
     week[token] = toInt(input);
 });
 
+addWeekParseToken('eHHmm', function (input, week, config) {
+    var weekdayEnd = input.length - 4;
+
+    week.e = toInt(input.substr(0, weekdayEnd));
+    config._a[HOUR] = toInt(input.substr(weekdayEnd, 2));
+    config._a[MINUTE] = toInt(input.substr(weekdayEnd + 2));
+});
+
 // HELPERS
 
 function parseWeekday(input, locale) {
@@ -1531,7 +1319,29 @@ var defaultLocaleWeekdays =
     defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
     defaultWeekdaysRegex = matchWord,
     defaultWeekdaysShortRegex = matchWord,
-    defaultWeekdaysMinRegex = matchWord;
+    defaultWeekdaysMinRegex = matchWord,
+    weekdaysParseProperties = [
+        'weekdaysParse',
+        'fullWeekdaysParse',
+        'shortWeekdaysParse',
+        'minWeekdaysParse',
+        'weekdaysRegex',
+        'weekdaysShortRegex',
+        'weekdaysMinRegex',
+        'weekdaysStrictRegex',
+        'weekdaysShortStrictRegex',
+        'weekdaysMinStrictRegex',
+    ];
+
+function clearWeekdaysParseCache(locale, config) {
+    var i, prop;
+    for (i = 0; i < weekdaysParseProperties.length; i++) {
+        prop = weekdaysParseProperties[i];
+        if (!hasOwnProp(config, prop)) {
+            delete locale['_' + prop];
+        }
+    }
+}
 
 function localeWeekdays(m, format) {
     var weekdays = isArray(this._weekdays)
@@ -1544,27 +1354,27 @@ function localeWeekdays(m, format) {
     return m === true
         ? shiftWeekdays(weekdays, this._week.dow)
         : m
-        ? weekdays[m.day()]
-        : weekdays;
+          ? weekdays[m.day()]
+          : weekdays;
 }
 
 function localeWeekdaysShort(m) {
     return m === true
         ? shiftWeekdays(this._weekdaysShort, this._week.dow)
         : m
-        ? this._weekdaysShort[m.day()]
-        : this._weekdaysShort;
+          ? this._weekdaysShort[m.day()]
+          : this._weekdaysShort;
 }
 
 function localeWeekdaysMin(m) {
     return m === true
         ? shiftWeekdays(this._weekdaysMin, this._week.dow)
         : m
-        ? this._weekdaysMin[m.day()]
-        : this._weekdaysMin;
+          ? this._weekdaysMin[m.day()]
+          : this._weekdaysMin;
 }
 
-function handleStrictParse$1(weekdayName, format, strict) {
+function handleStrictParse(weekdayName, format, strict) {
     var i,
         ii,
         mom,
@@ -1641,7 +1451,7 @@ function localeWeekdaysParse(weekdayName, format, strict) {
     var i, mom, regex;
 
     if (this._weekdaysParseExact) {
-        return handleStrictParse$1.call(this, weekdayName, format, strict);
+        return handleStrictParse.call(this, weekdayName, format, strict);
     }
 
     if (!this._weekdaysParse) {
@@ -1710,7 +1520,8 @@ function getSetDayOfWeek(input) {
     if (!this.isValid()) {
         return input != null ? this : NaN;
     }
-    var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
+
+    var day = get$2(this, 'Day');
     if (input != null) {
         input = parseWeekday(input, this.localeData());
         return this.add(input - day, 'd');
@@ -1764,96 +1575,471 @@ function weekdaysRegex(isStrict) {
     }
 }
 
-function weekdaysShortRegex(isStrict) {
-    if (this._weekdaysParseExact) {
-        if (!hasOwnProp(this, '_weekdaysRegex')) {
-            computeWeekdaysParse.call(this);
-        }
-        if (isStrict) {
-            return this._weekdaysShortStrictRegex;
-        } else {
-            return this._weekdaysShortRegex;
-        }
-    } else {
-        if (!hasOwnProp(this, '_weekdaysShortRegex')) {
-            this._weekdaysShortRegex = defaultWeekdaysShortRegex;
-        }
-        return this._weekdaysShortStrictRegex && isStrict
-            ? this._weekdaysShortStrictRegex
-            : this._weekdaysShortRegex;
+function weekdaysShortRegex(isStrict) {
+    if (this._weekdaysParseExact) {
+        if (!hasOwnProp(this, '_weekdaysRegex')) {
+            computeWeekdaysParse.call(this);
+        }
+        if (isStrict) {
+            return this._weekdaysShortStrictRegex;
+        } else {
+            return this._weekdaysShortRegex;
+        }
+    } else {
+        if (!hasOwnProp(this, '_weekdaysShortRegex')) {
+            this._weekdaysShortRegex = defaultWeekdaysShortRegex;
+        }
+        return this._weekdaysShortStrictRegex && isStrict
+            ? this._weekdaysShortStrictRegex
+            : this._weekdaysShortRegex;
+    }
+}
+
+function weekdaysMinRegex(isStrict) {
+    if (this._weekdaysParseExact) {
+        if (!hasOwnProp(this, '_weekdaysRegex')) {
+            computeWeekdaysParse.call(this);
+        }
+        if (isStrict) {
+            return this._weekdaysMinStrictRegex;
+        } else {
+            return this._weekdaysMinRegex;
+        }
+    } else {
+        if (!hasOwnProp(this, '_weekdaysMinRegex')) {
+            this._weekdaysMinRegex = defaultWeekdaysMinRegex;
+        }
+        return this._weekdaysMinStrictRegex && isStrict
+            ? this._weekdaysMinStrictRegex
+            : this._weekdaysMinRegex;
+    }
+}
+
+function computeWeekdaysParse() {
+    function cmpLenRev(a, b) {
+        return b.length - a.length;
+    }
+
+    var minPieces = [],
+        shortPieces = [],
+        longPieces = [],
+        mixedPieces = [],
+        i,
+        mom,
+        minp,
+        shortp,
+        longp;
+    for (i = 0; i < 7; i++) {
+        // make the regex if we don't have it already
+        mom = createUTC([2000, 1]).day(i);
+        minp = regexEscape(this.weekdaysMin(mom, ''));
+        shortp = regexEscape(this.weekdaysShort(mom, ''));
+        longp = regexEscape(this.weekdays(mom, ''));
+        minPieces.push(minp);
+        shortPieces.push(shortp);
+        longPieces.push(longp);
+        mixedPieces.push(minp);
+        mixedPieces.push(shortp);
+        mixedPieces.push(longp);
+    }
+    // Sorting makes sure if one weekday (or abbr) is a prefix of another it
+    // will match the longer piece.
+    minPieces.sort(cmpLenRev);
+    shortPieces.sort(cmpLenRev);
+    longPieces.sort(cmpLenRev);
+    mixedPieces.sort(cmpLenRev);
+
+    this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
+    this._weekdaysShortRegex = this._weekdaysRegex;
+    this._weekdaysMinRegex = this._weekdaysRegex;
+
+    this._weekdaysStrictRegex = new RegExp(
+        '^(' + longPieces.join('|') + ')',
+        'i'
+    );
+    this._weekdaysShortStrictRegex = new RegExp(
+        '^(' + shortPieces.join('|') + ')',
+        'i'
+    );
+    this._weekdaysMinStrictRegex = new RegExp(
+        '^(' + minPieces.join('|') + ')',
+        'i'
+    );
+}
+
+function set(config) {
+    var prop, i;
+    clearMonthsParseCache(this, config);
+    clearWeekdaysParseCache(this, config);
+    for (i in config) {
+        if (hasOwnProp(config, i)) {
+            prop = config[i];
+            if (isFunction(prop)) {
+                this[i] = prop;
+            } else {
+                this['_' + i] = prop;
+            }
+        }
+    }
+    this._config = config;
+    // Lenient ordinal parsing accepts just a number in addition to
+    // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
+    // TODO: Remove "ordinalParse" fallback in next major release.
+    this._dayOfMonthOrdinalParseLenient = new RegExp(
+        (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +
+            '|' +
+            /\d{1,2}/.source
+    );
+}
+
+function mergeConfigs(parentConfig, childConfig) {
+    var res = extend({}, parentConfig),
+        prop;
+    for (prop in childConfig) {
+        if (hasOwnProp(childConfig, prop)) {
+            if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
+                res[prop] = {};
+                extend(res[prop], parentConfig[prop]);
+                extend(res[prop], childConfig[prop]);
+            } else if (childConfig[prop] != null) {
+                res[prop] = childConfig[prop];
+            } else {
+                delete res[prop];
+            }
+        }
+    }
+    for (prop in parentConfig) {
+        if (
+            hasOwnProp(parentConfig, prop) &&
+            !hasOwnProp(childConfig, prop) &&
+            isObject(parentConfig[prop])
+        ) {
+            // make sure changes to properties don't modify parent config
+            res[prop] = extend({}, res[prop]);
+        }
+    }
+    return res;
+}
+
+function Locale(config) {
+    if (config != null) {
+        this.set(config);
+    }
+}
+
+var keys;
+
+if (Object.keys) {
+    keys = Object.keys;
+} else {
+    keys = function (obj) {
+        var i,
+            res = [];
+        for (i in obj) {
+            if (hasOwnProp(obj, i)) {
+                res.push(i);
+            }
+        }
+        return res;
+    };
+}
+
+var defaultCalendar = {
+    sameDay: '[Today at] LT',
+    nextDay: '[Tomorrow at] LT',
+    nextWeek: 'dddd [at] LT',
+    lastDay: '[Yesterday at] LT',
+    lastWeek: '[Last] dddd [at] LT',
+    sameElse: 'L',
+};
+
+function calendar$1(key, mom, now) {
+    var output = this._calendar[key] || this._calendar['sameElse'];
+    return isFunction(output) ? output.call(mom, now) : output;
+}
+
+var defaultLongDateFormat = {
+    LTS: 'h:mm:ss A',
+    LT: 'h:mm A',
+    L: 'MM/DD/YYYY',
+    LL: 'MMMM D, YYYY',
+    LLL: 'MMMM D, YYYY h:mm A',
+    LLLL: 'dddd, MMMM D, YYYY h:mm A',
+};
+
+function longDateFormat(key) {
+    var format = this._longDateFormat[key],
+        formatUpper = this._longDateFormat[key.toUpperCase()],
+        formatCache = this._longDateFormatCache;
+
+    if (format || !formatUpper) {
+        return format;
+    }
+
+    if (
+        formatCache &&
+        formatCache[key] &&
+        formatCache[key].formatUpper === formatUpper
+    ) {
+        return formatCache[key].format;
+    }
+
+    format = formatUpper
+        .match(formattingTokens)
+        .map(function (tok) {
+            if (
+                tok === 'MMMM' ||
+                tok === 'MM' ||
+                tok === 'DD' ||
+                tok === 'dddd'
+            ) {
+                return tok.slice(1);
+            }
+            return tok;
+        })
+        .join('');
+
+    if (!formatCache) {
+        formatCache = this._longDateFormatCache = {};
+    }
+    formatCache[key] = {
+        formatUpper: formatUpper,
+        format: format,
+    };
+    return format;
+}
+
+var defaultInvalidDate = 'Invalid date';
+
+function invalidDate() {
+    return this._invalidDate;
+}
+
+var defaultOrdinal = '%d',
+    defaultDayOfMonthOrdinalParse = /\d{1,2}/;
+
+function ordinal(number) {
+    return this._ordinal.replace('%d', number);
+}
+
+var defaultRelativeTime = {
+    future: 'in %s',
+    past: '%s ago',
+    s: 'a few seconds',
+    ss: '%d seconds',
+    m: 'a minute',
+    mm: '%d minutes',
+    h: 'an hour',
+    hh: '%d hours',
+    d: 'a day',
+    dd: '%d days',
+    w: 'a week',
+    ww: '%d weeks',
+    M: 'a month',
+    MM: '%d months',
+    y: 'a year',
+    yy: '%d years',
+};
+
+function relativeTimeWithoutPostformat(
+    number,
+    withoutSuffix,
+    string,
+    isFuture
+) {
+    var output = this._relativeTime[string];
+    return isFunction(output)
+        ? output(number, withoutSuffix, string, isFuture)
+        : output.replace(/%d/i, number);
+}
+
+function relativeTime$1(number, withoutSuffix, string, isFuture) {
+    return this.postformat(
+        relativeTimeWithoutPostformat.call(
+            this,
+            number,
+            withoutSuffix,
+            string,
+            isFuture
+        )
+    );
+}
+
+function pastFutureWithoutPostformat(diff, output) {
+    var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
+    return isFunction(format) ? format(output) : format.replace(/%s/i, output);
+}
+
+function pastFuture(diff, output) {
+    return this.postformat(
+        pastFutureWithoutPostformat.call(this, diff, output)
+    );
+}
+
+function createDate(y, m, d, h, M, s, ms) {
+    // can't just apply() to create a date:
+    // https://stackoverflow.com/q/181348
+    var date;
+    // the date constructor remaps years 0-99 to 1900-1999
+    if (y < 100 && y >= 0) {
+        // preserve leap years using a full 400 year cycle, then reset
+        date = new Date(y + 400, m, d, h, M, s, ms);
+        if (isFinite(date.getFullYear())) {
+            date.setFullYear(y);
+        }
+    } else {
+        date = new Date(y, m, d, h, M, s, ms);
+    }
+
+    return date;
+}
+
+function createUTCDate(y) {
+    var date, args;
+    // the Date.UTC function remaps years 0-99 to 1900-1999
+    if (y < 100 && y >= 0) {
+        args = Array.prototype.slice.call(arguments);
+        // preserve leap years using a full 400 year cycle, then reset
+        args[0] = y + 400;
+        date = new Date(Date.UTC.apply(null, args));
+        if (isFinite(date.getUTCFullYear())) {
+            date.setUTCFullYear(y);
+        }
+    } else {
+        date = new Date(Date.UTC.apply(null, arguments));
+    }
+
+    return date;
+}
+
+// start-of-first-week - start-of-year
+function firstWeekOffset(year, dow, doy) {
+    var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
+        fwd = 7 + dow - doy,
+        // first-week day local weekday -- which local weekday is fwd
+        fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
+
+    return -fwdlw + fwd - 1;
+}
+
+// https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
+function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
+    var localWeekday = (7 + weekday - dow) % 7,
+        weekOffset = firstWeekOffset(year, dow, doy),
+        dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
+        resYear,
+        resDayOfYear;
+
+    if (dayOfYear <= 0) {
+        resYear = year - 1;
+        resDayOfYear = daysInYear(resYear) + dayOfYear;
+    } else if (dayOfYear > daysInYear(year)) {
+        resYear = year + 1;
+        resDayOfYear = dayOfYear - daysInYear(year);
+    } else {
+        resYear = year;
+        resDayOfYear = dayOfYear;
+    }
+
+    return {
+        year: resYear,
+        dayOfYear: resDayOfYear,
+    };
+}
+
+function weekOfYearFromDayOfYear(year, dayOfYear, dow, doy) {
+    var weekOffset = firstWeekOffset(year, dow, doy),
+        week = Math.floor((dayOfYear - weekOffset - 1) / 7) + 1,
+        resWeek,
+        resYear;
+
+    if (week < 1) {
+        resYear = year - 1;
+        resWeek = week + weeksInYear(resYear, dow, doy);
+    } else if (week > weeksInYear(year, dow, doy)) {
+        resWeek = week - weeksInYear(year, dow, doy);
+        resYear = year + 1;
+    } else {
+        resYear = year;
+        resWeek = week;
+    }
+
+    return {
+        week: resWeek,
+        year: resYear,
+    };
+}
+
+function weekOfYear(mom, dow, doy) {
+    return weekOfYearFromDayOfYear(mom.year(), mom.dayOfYear(), dow, doy);
+}
+
+function weekOfYearFromDate(year, month, date, dow, doy) {
+    var dayOfYear =
+        Math.round(
+            (createUTCDate(year, month, date) - createUTCDate(year, 0, 1)) /
+                864e5
+        ) + 1;
+
+    return weekOfYearFromDayOfYear(year, dayOfYear, dow, doy);
+}
+
+function weeksInYear(year, dow, doy) {
+    var weekOffset = firstWeekOffset(year, dow, doy),
+        weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
+    return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
+}
+
+// FORMATTING
+
+addFormatToken('w', ['ww', 2], 'wo', 'week');
+addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
+
+// PARSING
+
+addRegexToken('w', match1to2, match1to2NoLeadingZero);
+addRegexToken('ww', match1to2, match2);
+addRegexToken('W', match1to2, match1to2NoLeadingZero);
+addRegexToken('WW', match1to2, match2);
+
+addWeekParseToken(
+    ['w', 'ww', 'W', 'WW'],
+    function (input, week, config, token) {
+        week[token.substr(0, 1)] = toInt(input);
     }
+);
+
+// HELPERS
+
+// LOCALES
+
+function localeWeek(mom) {
+    return weekOfYear(mom, this._week.dow, this._week.doy).week;
 }
 
-function weekdaysMinRegex(isStrict) {
-    if (this._weekdaysParseExact) {
-        if (!hasOwnProp(this, '_weekdaysRegex')) {
-            computeWeekdaysParse.call(this);
-        }
-        if (isStrict) {
-            return this._weekdaysMinStrictRegex;
-        } else {
-            return this._weekdaysMinRegex;
-        }
-    } else {
-        if (!hasOwnProp(this, '_weekdaysMinRegex')) {
-            this._weekdaysMinRegex = defaultWeekdaysMinRegex;
-        }
-        return this._weekdaysMinStrictRegex && isStrict
-            ? this._weekdaysMinStrictRegex
-            : this._weekdaysMinRegex;
-    }
+var defaultLocaleWeek = {
+    dow: 0, // Sunday is the first day of the week.
+    doy: 6, // The week that contains Jan 6th is the first week of the year.
+};
+
+function localeFirstDayOfWeek() {
+    return this._week.dow;
 }
 
-function computeWeekdaysParse() {
-    function cmpLenRev(a, b) {
-        return b.length - a.length;
-    }
+function localeFirstDayOfYear() {
+    return this._week.doy;
+}
 
-    var minPieces = [],
-        shortPieces = [],
-        longPieces = [],
-        mixedPieces = [],
-        i,
-        mom,
-        minp,
-        shortp,
-        longp;
-    for (i = 0; i < 7; i++) {
-        // make the regex if we don't have it already
-        mom = createUTC([2000, 1]).day(i);
-        minp = regexEscape(this.weekdaysMin(mom, ''));
-        shortp = regexEscape(this.weekdaysShort(mom, ''));
-        longp = regexEscape(this.weekdays(mom, ''));
-        minPieces.push(minp);
-        shortPieces.push(shortp);
-        longPieces.push(longp);
-        mixedPieces.push(minp);
-        mixedPieces.push(shortp);
-        mixedPieces.push(longp);
-    }
-    // Sorting makes sure if one weekday (or abbr) is a prefix of another it
-    // will match the longer piece.
-    minPieces.sort(cmpLenRev);
-    shortPieces.sort(cmpLenRev);
-    longPieces.sort(cmpLenRev);
-    mixedPieces.sort(cmpLenRev);
+// MOMENTS
 
-    this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
-    this._weekdaysShortRegex = this._weekdaysRegex;
-    this._weekdaysMinRegex = this._weekdaysRegex;
+function getSetWeek(input) {
+    var week = this.localeData().week(this);
+    return input == null ? week : this.add((input - week) * 7, 'd');
+}
 
-    this._weekdaysStrictRegex = new RegExp(
-        '^(' + longPieces.join('|') + ')',
-        'i'
-    );
-    this._weekdaysShortStrictRegex = new RegExp(
-        '^(' + shortPieces.join('|') + ')',
-        'i'
-    );
-    this._weekdaysMinStrictRegex = new RegExp(
-        '^(' + minPieces.join('|') + ')',
-        'i'
-    );
+function getSetISOWeek(input) {
+    var week = weekOfYear(this, 1, 4).week;
+    return input == null ? week : this.add((input - week) * 7, 'd');
 }
 
 // FORMATTING
@@ -1909,13 +2095,6 @@ function meridiem(token, lowercase) {
 meridiem('a', true);
 meridiem('A', false);
 
-// ALIASES
-
-addUnitAlias('hour', 'h');
-
-// PRIORITY
-addUnitPriority('hour', 13);
-
 // PARSING
 
 function matchMeridiem(isStrict, locale) {
@@ -1924,9 +2103,9 @@ function matchMeridiem(isStrict, locale) {
 
 addRegexToken('a', matchMeridiem);
 addRegexToken('A', matchMeridiem);
-addRegexToken('H', match1to2);
-addRegexToken('h', match1to2);
-addRegexToken('k', match1to2);
+addRegexToken('H', match1to2, match1to2HasZero);
+addRegexToken('h', match1to2, match1to2NoLeadingZero);
+addRegexToken('k', match1to2, match1to2NoLeadingZero);
 addRegexToken('HH', match1to2, match2);
 addRegexToken('hh', match1to2, match2);
 addRegexToken('kk', match1to2, match2);
@@ -2075,33 +2254,49 @@ function chooseLocale(names) {
 }
 
 function isLocaleNameSane(name) {
-    // Prevent names that look like filesystem paths, i.e contain '/' or '\'
-    return name.match('^[^/\\\\]*$') != null;
+    // Only canonical locale module names are safe to append to the require path.
+    return typeof name === 'string' && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name);
 }
 
 function loadLocale(name) {
     var oldLocale = null,
-        aliasedRequire;
+        aliasedRequire,
+        normalizedName;
+
+    // Preserve exact custom locale names before trying the canonical built-in name.
+    // Use hasOwnProp rather than a plain lookup so that names like "__proto__",
+    // "constructor", or "prototype" can't resolve to an inherited Object.prototype
+    // property instead of a real (or missing) locale entry.
+    if (hasOwnProp(locales, name)) {
+        return locales[name];
+    }
+
+    normalizedName = normalizeLocale(name);
+    if (hasOwnProp(locales, normalizedName)) {
+        return locales[normalizedName];
+    }
+
     // TODO: Find a better way to register and load all the locales in Node
     if (
-        locales[name] === undefined &&
         typeof module !== 'undefined' &&
         module &&
         module.exports &&
-        isLocaleNameSane(name)
+        isLocaleNameSane(normalizedName)
     ) {
         try {
             oldLocale = globalLocale._abbr;
             aliasedRequire = require;
-            aliasedRequire('./locale/' + name);
+            aliasedRequire('./locale/' + normalizedName);
             getSetGlobalLocale(oldLocale);
         } catch (e) {
             // mark as not found to avoid repeating expensive file require call causing high CPU
             // when trying to find en-US, en_US, en-us for every format call
-            locales[name] = null; // null means not found
+            locales[normalizedName] = null; // null means not found
         }
     }
-    return locales[name];
+    if (hasOwnProp(locales, normalizedName)) {
+        return locales[normalizedName];
+    }
 }
 
 // This function will load locale and then set the global locale.  If
@@ -2187,17 +2382,20 @@ function defineLocale(name, config) {
 }
 
 function updateLocale(name, config) {
-    if (config != null) {
-        var locale,
-            tmpLocale,
-            parentConfig = baseConfig;
+    var locale,
+        tmpLocale = loadLocale(name),
+        parentConfig = baseConfig;
 
+    if (tmpLocale != null) {
+        name = tmpLocale._abbr;
+    }
+
+    if (config != null) {
         if (locales[name] != null && locales[name].parentLocale != null) {
             // Update existing child locale in-place to avoid memory-leaks
             locales[name].set(mergeConfigs(locales[name]._config, config));
         } else {
             // MERGE
-            tmpLocale = loadLocale(name);
             if (tmpLocale != null) {
                 parentConfig = tmpLocale._config;
             }
@@ -2268,21 +2466,21 @@ function checkOverflow(m) {
             a[MONTH] < 0 || a[MONTH] > 11
                 ? MONTH
                 : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH])
-                ? DATE
-                : a[HOUR] < 0 ||
-                  a[HOUR] > 24 ||
-                  (a[HOUR] === 24 &&
-                      (a[MINUTE] !== 0 ||
-                          a[SECOND] !== 0 ||
-                          a[MILLISECOND] !== 0))
-                ? HOUR
-                : a[MINUTE] < 0 || a[MINUTE] > 59
-                ? MINUTE
-                : a[SECOND] < 0 || a[SECOND] > 59
-                ? SECOND
-                : a[MILLISECOND] < 0 || a[MILLISECOND] > 999
-                ? MILLISECOND
-                : -1;
+                  ? DATE
+                  : a[HOUR] < 0 ||
+                      a[HOUR] > 24 ||
+                      (a[HOUR] === 24 &&
+                          (a[MINUTE] !== 0 ||
+                              a[SECOND] !== 0 ||
+                              a[MILLISECOND] !== 0))
+                    ? HOUR
+                    : a[MINUTE] < 0 || a[MINUTE] > 59
+                      ? MINUTE
+                      : a[SECOND] < 0 || a[SECOND] > 59
+                        ? SECOND
+                        : a[MILLISECOND] < 0 || a[MILLISECOND] > 999
+                          ? MILLISECOND
+                          : -1;
 
         if (
             getParsingFlags(m)._overflowDayOfYear &&
@@ -2565,9 +2763,46 @@ function defaults(a, b, c) {
     return c;
 }
 
-function currentDateArray(config) {
+function currentDateArray(config, now, forWeek) {
+    var hadWeekContext = Object.prototype.hasOwnProperty.call(
+            config,
+            '_isDefaultDatePartsForWeek'
+        ),
+        weekContext = config._isDefaultDatePartsForWeek;
+
     // hooks is actually the exported moment object
-    var nowValue = new Date(hooks.now());
+    config._isDefaultDatePartsForWeek = !!forWeek;
+    try {
+        return hooks._getDefaultDateParts(config, now, forWeek);
+    } finally {
+        if (hadWeekContext) {
+            config._isDefaultDatePartsForWeek = weekContext;
+        } else {
+            delete config._isDefaultDatePartsForWeek;
+        }
+    }
+}
+
+function currentDateNow(config) {
+    var now = config._defaultDatePartsNow;
+
+    if (!now) {
+        return hooks.now();
+    }
+    if (!now.hasValue) {
+        now.value = hooks.now();
+        now.hasValue = true;
+    }
+    return now.value;
+}
+
+// Internal hook for extensions that supply omitted calendar fields.
+function getDefaultDateParts(config, now, forWeek) {
+    var useWeekDefaults = forWeek || config._isDefaultDatePartsForWeek,
+        nowValue = useWeekDefaults ? createLocal(now) : new Date(now);
+    if (useWeekDefaults) {
+        return [nowValue.year(), nowValue.month(), nowValue.date()];
+    }
     if (config._useUTC) {
         return [
             nowValue.getUTCFullYear(),
@@ -2578,6 +2813,8 @@ function currentDateArray(config) {
     return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
 }
 
+hooks._getDefaultDateParts = getDefaultDateParts;
+
 // convert an array to a date.
 // the array should mirror the parameters below
 // note: all values past the year are optional and will default to the lowest possible value.
@@ -2586,24 +2823,34 @@ function configFromArray(config) {
     var i,
         date,
         input = [],
+        now,
         currentDate,
         expectedWeekday,
-        yearToUse;
+        yearToUse,
+        dateIsDefaulted;
 
     if (config._d) {
         return;
     }
 
-    currentDate = currentDateArray(config);
+    if (
+        config._a[YEAR] == null ||
+        config._a[MONTH] == null ||
+        config._a[DATE] == null
+    ) {
+        now = currentDateNow(config);
+        currentDate = currentDateArray(config, now);
+    }
 
     //compute day of the year from weeks and weekdays
     if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
-        dayOfYearFromWeekInfo(config);
+        dayOfYearFromWeekInfo(config, currentDateArray(config, now, true));
     }
 
     //if the day of the year is set, figure out what it is
     if (config._dayOfYear != null) {
-        yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
+        yearToUse =
+            config._a[YEAR] != null ? config._a[YEAR] : currentDate[YEAR];
 
         if (
             config._dayOfYear > daysInYear(yearToUse) ||
@@ -2617,6 +2864,11 @@ function configFromArray(config) {
         config._a[DATE] = date.getUTCDate();
     }
 
+    dateIsDefaulted =
+        config._a[YEAR] == null ||
+        config._a[MONTH] == null ||
+        config._a[DATE] == null;
+
     // Default to current date.
     // * if no year, month, day of month are given, default to today
     // * if day of month is given, default month and year
@@ -2665,13 +2917,14 @@ function configFromArray(config) {
     if (
         config._w &&
         typeof config._w.d !== 'undefined' &&
+        !dateIsDefaulted &&
         config._w.d !== expectedWeekday
     ) {
         getParsingFlags(config).weekdayMismatch = true;
     }
 }
 
-function dayOfYearFromWeekInfo(config) {
+function dayOfYearFromWeekInfo(config, currentDate) {
     var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow, curWeek;
 
     w = config._w;
@@ -2686,7 +2939,13 @@ function dayOfYearFromWeekInfo(config) {
         weekYear = defaults(
             w.GG,
             config._a[YEAR],
-            weekOfYear(createLocal(), 1, 4).year
+            weekOfYearFromDate(
+                currentDate[YEAR],
+                currentDate[MONTH],
+                currentDate[DATE],
+                1,
+                4
+            ).year
         );
         week = defaults(w.W, 1);
         weekday = defaults(w.E, 1);
@@ -2697,7 +2956,13 @@ function dayOfYearFromWeekInfo(config) {
         dow = config._locale._week.dow;
         doy = config._locale._week.doy;
 
-        curWeek = weekOfYear(createLocal(), dow, doy);
+        curWeek = weekOfYearFromDate(
+            currentDate[YEAR],
+            currentDate[MONTH],
+            currentDate[DATE],
+            dow,
+            doy
+        );
 
         weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
 
@@ -2863,6 +3128,7 @@ function configFromStringAndArray(config) {
         currentScore,
         validFormatFound,
         bestFormatIsValid = false,
+        defaultDatePartsNow = {},
         configfLen = config._f.length;
 
     if (configfLen === 0) {
@@ -2878,10 +3144,11 @@ function configFromStringAndArray(config) {
         if (config._useUTC != null) {
             tempConfig._useUTC = config._useUTC;
         }
+        tempConfig._defaultDatePartsNow = defaultDatePartsNow;
         tempConfig._f = config._f[i];
         configFromStringAndFormat(tempConfig);
 
-        if (isValid(tempConfig)) {
+        if (isValid$2(tempConfig)) {
             validFormatFound = true;
         }
 
@@ -2951,7 +3218,7 @@ function prepareConfig(config) {
     config._locale = config._locale || getLocale(config._l);
 
     if (input === null || (format === undefined && input === '')) {
-        return createInvalid({ nullInput: true });
+        return createInvalid$1({ nullInput: true });
     }
 
     if (typeof input === 'string') {
@@ -2970,7 +3237,7 @@ function prepareConfig(config) {
         configFromInput(config);
     }
 
-    if (!isValid(config)) {
+    if (!isValid$2(config)) {
         config._d = null;
     }
 
@@ -3042,7 +3309,7 @@ var prototypeMin = deprecate(
             if (this.isValid() && other.isValid()) {
                 return other < this ? this : other;
             } else {
-                return createInvalid();
+                return createInvalid$1();
             }
         }
     ),
@@ -3053,7 +3320,7 @@ var prototypeMin = deprecate(
             if (this.isValid() && other.isValid()) {
                 return other > this ? this : other;
             } else {
-                return createInvalid();
+                return createInvalid$1();
             }
         }
     );
@@ -3071,9 +3338,20 @@ function pickBy(fn, moments) {
     if (!moments.length) {
         return createLocal();
     }
-    res = moments[0];
-    for (i = 1; i < moments.length; ++i) {
-        if (!moments[i].isValid() || moments[i][fn](res)) {
+    for (i = 0; i < moments.length; ++i) {
+        if (isMoment(moments[i])) {
+            res = moments[i];
+            break;
+        }
+    }
+    if (!res) {
+        return createInvalid$1();
+    }
+    for (++i; i < moments.length; ++i) {
+        if (
+            isMoment(moments[i]) &&
+            (!moments[i].isValid() || moments[i][fn](res))
+        ) {
             res = moments[i];
         }
     }
@@ -3144,7 +3422,7 @@ function isValid$1() {
     return this._isValid;
 }
 
-function createInvalid$1() {
+function createInvalid() {
     return createDuration(NaN);
 }
 
@@ -3203,8 +3481,7 @@ function compareArrays(array1, array2, dontConvert) {
         i;
     for (i = 0; i < len; i++) {
         if (
-            (dontConvert && array1[i] !== array2[i]) ||
-            (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))
+            (toInt(array1[i]) !== toInt(array2[i]))
         ) {
             diffs++;
         }
@@ -3239,8 +3516,12 @@ offset('ZZ', '');
 addRegexToken('Z', matchShortOffset);
 addRegexToken('ZZ', matchShortOffset);
 addParseToken(['Z', 'ZZ'], function (input, array, config) {
+    var offset = offsetFromString(matchShortOffset, input);
     config._useUTC = true;
-    config._tzm = offsetFromString(matchShortOffset, input);
+    config._tzm = offset;
+    if (offset === null) {
+        getParsingFlags(config).invalidOffset = input;
+    }
 });
 
 // HELPERS
@@ -3264,6 +3545,13 @@ function offsetFromString(matcher, string) {
     parts = (chunk + '').match(chunkOffset) || ['-', 0, 0];
     minutes = +(parts[1] * 60) + toInt(parts[2]);
 
+    if (
+        toInt(parts[2]) > 59 ||
+        (parts[0] === '+' ? minutes > 14 * 60 : minutes > 12 * 60)
+    ) {
+        return null;
+    }
+
     return minutes === 0 ? 0 : parts[0] === '+' ? minutes : -minutes;
 }
 
@@ -3334,7 +3622,7 @@ function getSetOffset(input, keepLocalTime, keepMinutes) {
         }
         if (offset !== input) {
             if (!keepLocalTime || this._changeInProgress) {
-                addSubtract(
+                addSubtract$1(
                     this,
                     createDuration(input - offset, 'm'),
                     1,
@@ -3527,7 +3815,7 @@ function createDuration(input, key) {
 }
 
 createDuration.fn = Duration.prototype;
-createDuration.invalid = createInvalid$1;
+createDuration.invalid = createInvalid;
 
 function parseIso(inp, sign) {
     // We'd normally use ~~inp for this, but unfortunately it also
@@ -3591,12 +3879,12 @@ function createAdder(direction, name) {
         }
 
         dur = createDuration(val, period);
-        addSubtract(this, dur, direction);
+        addSubtract$1(this, dur, direction);
         return this;
     };
 }
 
-function addSubtract(mom, duration, isAdding, updateOffset) {
+function addSubtract$1(mom, duration, isAdding, updateOffset) {
     var milliseconds = duration._milliseconds,
         days = absRound(duration._days),
         months = absRound(duration._months);
@@ -3609,10 +3897,10 @@ function addSubtract(mom, duration, isAdding, updateOffset) {
     updateOffset = updateOffset == null ? true : updateOffset;
 
     if (months) {
-        setMonth(mom, get(mom, 'Month') + months * isAdding);
+        setMonth(mom, get$2(mom, 'Month') + months * isAdding);
     }
     if (days) {
-        set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);
+        set$1(mom, 'Date', get$2(mom, 'Date') + days * isAdding);
     }
     if (milliseconds) {
         mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
@@ -3622,8 +3910,8 @@ function addSubtract(mom, duration, isAdding, updateOffset) {
     }
 }
 
-var add = createAdder(1, 'add'),
-    subtract = createAdder(-1, 'subtract');
+var add$1 = createAdder(1, 'add'),
+    subtract$1 = createAdder(-1, 'subtract');
 
 function isString(input) {
     return typeof input === 'string' || input instanceof String;
@@ -3723,19 +4011,19 @@ function getCalendarFormat(myMoment, now) {
     return diff < -6
         ? 'sameElse'
         : diff < -1
-        ? 'lastWeek'
-        : diff < 0
-        ? 'lastDay'
-        : diff < 1
-        ? 'sameDay'
-        : diff < 2
-        ? 'nextDay'
-        : diff < 7
-        ? 'nextWeek'
-        : 'sameElse';
-}
-
-function calendar$1(time, formats) {
+          ? 'lastWeek'
+          : diff < 0
+            ? 'lastDay'
+            : diff < 1
+              ? 'sameDay'
+              : diff < 2
+                ? 'nextDay'
+                : diff < 7
+                  ? 'nextWeek'
+                  : 'sameElse';
+}
+
+function calendar(time, formats) {
     // Support for single parameter, formats only overload to the calendar function
     if (arguments.length === 1) {
         if (!arguments[0]) {
@@ -3765,7 +4053,7 @@ function calendar$1(time, formats) {
     );
 }
 
-function clone() {
+function clone$1() {
     return new Moment(this);
 }
 
@@ -3921,7 +4209,7 @@ function toString() {
     return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
 }
 
-function toISOString(keepOffset) {
+function toISOString$1(keepOffset) {
     if (!this.isValid()) {
         return null;
     }
@@ -4061,7 +4349,7 @@ var MS_PER_SECOND = 1000,
     MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR;
 
 // actual modulo - handles negative numbers (for dates before 1970):
-function mod$1(dividend, divisor) {
+function mod(dividend, divisor) {
     return ((dividend % divisor) + divisor) % divisor;
 }
 
@@ -4128,18 +4416,18 @@ function startOf(units) {
             break;
         case 'hour':
             time = this._d.valueOf();
-            time -= mod$1(
+            time -= mod(
                 time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
                 MS_PER_HOUR
             );
             break;
         case 'minute':
             time = this._d.valueOf();
-            time -= mod$1(time, MS_PER_MINUTE);
+            time -= mod(time, MS_PER_MINUTE);
             break;
         case 'second':
             time = this._d.valueOf();
-            time -= mod$1(time, MS_PER_SECOND);
+            time -= mod(time, MS_PER_SECOND);
             break;
     }
 
@@ -4196,7 +4484,7 @@ function endOf(units) {
             time = this._d.valueOf();
             time +=
                 MS_PER_HOUR -
-                mod$1(
+                mod(
                     time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
                     MS_PER_HOUR
                 ) -
@@ -4204,11 +4492,11 @@ function endOf(units) {
             break;
         case 'minute':
             time = this._d.valueOf();
-            time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1;
+            time += MS_PER_MINUTE - mod(time, MS_PER_MINUTE) - 1;
             break;
         case 'second':
             time = this._d.valueOf();
-            time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1;
+            time += MS_PER_SECOND - mod(time, MS_PER_SECOND) - 1;
             break;
     }
 
@@ -4217,7 +4505,7 @@ function endOf(units) {
     return this;
 }
 
-function valueOf() {
+function valueOf$1() {
     return this._d.valueOf() - (this._offset || 0) * 60000;
 }
 
@@ -4260,8 +4548,8 @@ function toJSON() {
     return this.isValid() ? this.toISOString() : null;
 }
 
-function isValid$2() {
-    return isValid(this);
+function isValid() {
+    return isValid$2(this);
 }
 
 function parsingFlags() {
@@ -4402,7 +4690,7 @@ function localeErasParse(eraName, format, strict) {
 }
 
 function localeErasConvertYear(era, year) {
-    var dir = era.since <= era.until ? +1 : -1;
+    var dir = era.since <= era.until ? 1 : -1;
     if (year === undefined) {
         return hooks(era.since).year();
     } else {
@@ -4477,7 +4765,7 @@ function getEraYear() {
         val,
         eras = this.localeData().eras();
     for (i = 0, l = eras.length; i < l; ++i) {
-        dir = eras[i].since <= eras[i].until ? +1 : -1;
+        dir = eras[i].since <= eras[i].until ? 1 : -1;
 
         // truncate time
         val = this.clone().startOf('day').valueOf();
@@ -4540,16 +4828,22 @@ function computeErasParse() {
         mixedPieces = [],
         i,
         l,
+        erasName,
+        erasAbbr,
+        erasNarrow,
         eras = this.eras();
 
     for (i = 0, l = eras.length; i < l; ++i) {
-        namePieces.push(regexEscape(eras[i].name));
-        abbrPieces.push(regexEscape(eras[i].abbr));
-        narrowPieces.push(regexEscape(eras[i].narrow));
+        erasName = regexEscape(eras[i].name);
+        erasAbbr = regexEscape(eras[i].abbr);
+        erasNarrow = regexEscape(eras[i].narrow);
 
-        mixedPieces.push(regexEscape(eras[i].name));
-        mixedPieces.push(regexEscape(eras[i].abbr));
-        mixedPieces.push(regexEscape(eras[i].narrow));
+        namePieces.push(erasName);
+        abbrPieces.push(erasAbbr);
+        narrowPieces.push(erasNarrow);
+        mixedPieces.push(erasName);
+        mixedPieces.push(erasAbbr);
+        mixedPieces.push(erasNarrow);
     }
 
     this._erasRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
@@ -4582,14 +4876,6 @@ addWeekYearFormatToken('GGGGG', 'isoWeekYear');
 
 // ALIASES
 
-addUnitAlias('weekYear', 'gg');
-addUnitAlias('isoWeekYear', 'GG');
-
-// PRIORITY
-
-addUnitPriority('weekYear', 1);
-addUnitPriority('isoWeekYear', 1);
-
 // PARSING
 
 addRegexToken('G', matchSigned);
@@ -4619,7 +4905,7 @@ function getSetWeekYear(input) {
         this,
         input,
         this.week(),
-        this.weekday(),
+        this.weekday() + this.localeData()._week.dow,
         this.localeData()._week.dow,
         this.localeData()._week.doy
     );
@@ -4681,14 +4967,6 @@ function setWeekAll(weekYear, week, weekday, dow, doy) {
 
 addFormatToken('Q', 0, 'Qo', 'quarter');
 
-// ALIASES
-
-addUnitAlias('quarter', 'Q');
-
-// PRIORITY
-
-addUnitPriority('quarter', 7);
-
 // PARSING
 
 addRegexToken('Q', match1);
@@ -4708,16 +4986,9 @@ function getSetQuarter(input) {
 
 addFormatToken('D', ['DD', 2], 'Do', 'date');
 
-// ALIASES
-
-addUnitAlias('date', 'D');
-
-// PRIORITY
-addUnitPriority('date', 9);
-
 // PARSING
 
-addRegexToken('D', match1to2);
+addRegexToken('D', match1to2, match1to2NoLeadingZero);
 addRegexToken('DD', match1to2, match2);
 addRegexToken('Do', function (isStrict, locale) {
     // TODO: Remove "ordinalParse" fallback in next major release.
@@ -4739,13 +5010,6 @@ var getSetDayOfMonth = makeGetSet('Date', true);
 
 addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
 
-// ALIASES
-
-addUnitAlias('dayOfYear', 'DDD');
-
-// PRIORITY
-addUnitPriority('dayOfYear', 4);
-
 // PARSING
 
 addRegexToken('DDD', match1to3);
@@ -4770,17 +5034,9 @@ function getSetDayOfYear(input) {
 
 addFormatToken('m', ['mm', 2], 0, 'minute');
 
-// ALIASES
-
-addUnitAlias('minute', 'm');
-
-// PRIORITY
-
-addUnitPriority('minute', 14);
-
 // PARSING
 
-addRegexToken('m', match1to2);
+addRegexToken('m', match1to2, match1to2HasZero);
 addRegexToken('mm', match1to2, match2);
 addParseToken(['m', 'mm'], MINUTE);
 
@@ -4792,17 +5048,9 @@ var getSetMinute = makeGetSet('Minutes', false);
 
 addFormatToken('s', ['ss', 2], 0, 'second');
 
-// ALIASES
-
-addUnitAlias('second', 's');
-
-// PRIORITY
-
-addUnitPriority('second', 15);
-
 // PARSING
 
-addRegexToken('s', match1to2);
+addRegexToken('s', match1to2, match1to2HasZero);
 addRegexToken('ss', match1to2, match2);
 addParseToken(['s', 'ss'], SECOND);
 
@@ -4840,14 +5088,6 @@ addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
     return this.millisecond() * 1000000;
 });
 
-// ALIASES
-
-addUnitAlias('millisecond', 'ms');
-
-// PRIORITY
-
-addUnitPriority('millisecond', 16);
-
 // PARSING
 
 addRegexToken('S', match1to3, match1);
@@ -4884,106 +5124,106 @@ function getZoneName() {
     return this._isUTC ? 'Coordinated Universal Time' : '';
 }
 
-var proto = Moment.prototype;
+var proto$2 = Moment.prototype;
 
-proto.add = add;
-proto.calendar = calendar$1;
-proto.clone = clone;
-proto.diff = diff;
-proto.endOf = endOf;
-proto.format = format;
-proto.from = from;
-proto.fromNow = fromNow;
-proto.to = to;
-proto.toNow = toNow;
-proto.get = stringGet;
-proto.invalidAt = invalidAt;
-proto.isAfter = isAfter;
-proto.isBefore = isBefore;
-proto.isBetween = isBetween;
-proto.isSame = isSame;
-proto.isSameOrAfter = isSameOrAfter;
-proto.isSameOrBefore = isSameOrBefore;
-proto.isValid = isValid$2;
-proto.lang = lang;
-proto.locale = locale;
-proto.localeData = localeData;
-proto.max = prototypeMax;
-proto.min = prototypeMin;
-proto.parsingFlags = parsingFlags;
-proto.set = stringSet;
-proto.startOf = startOf;
-proto.subtract = subtract;
-proto.toArray = toArray;
-proto.toObject = toObject;
-proto.toDate = toDate;
-proto.toISOString = toISOString;
-proto.inspect = inspect;
+proto$2.add = add$1;
+proto$2.calendar = calendar;
+proto$2.clone = clone$1;
+proto$2.diff = diff;
+proto$2.endOf = endOf;
+proto$2.format = format;
+proto$2.from = from;
+proto$2.fromNow = fromNow;
+proto$2.to = to;
+proto$2.toNow = toNow;
+proto$2.get = stringGet;
+proto$2.invalidAt = invalidAt;
+proto$2.isAfter = isAfter;
+proto$2.isBefore = isBefore;
+proto$2.isBetween = isBetween;
+proto$2.isSame = isSame;
+proto$2.isSameOrAfter = isSameOrAfter;
+proto$2.isSameOrBefore = isSameOrBefore;
+proto$2.isValid = isValid;
+proto$2.lang = lang;
+proto$2.locale = locale;
+proto$2.localeData = localeData;
+proto$2.max = prototypeMax;
+proto$2.min = prototypeMin;
+proto$2.parsingFlags = parsingFlags;
+proto$2.set = stringSet;
+proto$2.startOf = startOf;
+proto$2.subtract = subtract$1;
+proto$2.toArray = toArray;
+proto$2.toObject = toObject;
+proto$2.toDate = toDate;
+proto$2.toISOString = toISOString$1;
+proto$2.inspect = inspect;
 if (typeof Symbol !== 'undefined' && Symbol.for != null) {
-    proto[Symbol.for('nodejs.util.inspect.custom')] = function () {
+    proto$2[Symbol.for('nodejs.util.inspect.custom')] = function () {
         return 'Moment<' + this.format() + '>';
     };
 }
-proto.toJSON = toJSON;
-proto.toString = toString;
-proto.unix = unix;
-proto.valueOf = valueOf;
-proto.creationData = creationData;
-proto.eraName = getEraName;
-proto.eraNarrow = getEraNarrow;
-proto.eraAbbr = getEraAbbr;
-proto.eraYear = getEraYear;
-proto.year = getSetYear;
-proto.isLeapYear = getIsLeapYear;
-proto.weekYear = getSetWeekYear;
-proto.isoWeekYear = getSetISOWeekYear;
-proto.quarter = proto.quarters = getSetQuarter;
-proto.month = getSetMonth;
-proto.daysInMonth = getDaysInMonth;
-proto.week = proto.weeks = getSetWeek;
-proto.isoWeek = proto.isoWeeks = getSetISOWeek;
-proto.weeksInYear = getWeeksInYear;
-proto.weeksInWeekYear = getWeeksInWeekYear;
-proto.isoWeeksInYear = getISOWeeksInYear;
-proto.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear;
-proto.date = getSetDayOfMonth;
-proto.day = proto.days = getSetDayOfWeek;
-proto.weekday = getSetLocaleDayOfWeek;
-proto.isoWeekday = getSetISODayOfWeek;
-proto.dayOfYear = getSetDayOfYear;
-proto.hour = proto.hours = getSetHour;
-proto.minute = proto.minutes = getSetMinute;
-proto.second = proto.seconds = getSetSecond;
-proto.millisecond = proto.milliseconds = getSetMillisecond;
-proto.utcOffset = getSetOffset;
-proto.utc = setOffsetToUTC;
-proto.local = setOffsetToLocal;
-proto.parseZone = setOffsetToParsedOffset;
-proto.hasAlignedHourOffset = hasAlignedHourOffset;
-proto.isDST = isDaylightSavingTime;
-proto.isLocal = isLocal;
-proto.isUtcOffset = isUtcOffset;
-proto.isUtc = isUtc;
-proto.isUTC = isUtc;
-proto.zoneAbbr = getZoneAbbr;
-proto.zoneName = getZoneName;
-proto.dates = deprecate(
+proto$2.toJSON = toJSON;
+proto$2.toString = toString;
+proto$2.unix = unix;
+proto$2.valueOf = valueOf$1;
+proto$2.creationData = creationData;
+proto$2.eraName = getEraName;
+proto$2.eraNarrow = getEraNarrow;
+proto$2.eraAbbr = getEraAbbr;
+proto$2.eraYear = getEraYear;
+proto$2.year = getSetYear;
+proto$2.isLeapYear = getIsLeapYear;
+proto$2.weekYear = getSetWeekYear;
+proto$2.isoWeekYear = getSetISOWeekYear;
+proto$2.quarter = proto$2.quarters = getSetQuarter;
+proto$2.month = getSetMonth;
+proto$2.daysInMonth = getDaysInMonth;
+proto$2.week = proto$2.weeks = getSetWeek;
+proto$2.isoWeek = proto$2.isoWeeks = getSetISOWeek;
+proto$2.weeksInYear = getWeeksInYear;
+proto$2.weeksInWeekYear = getWeeksInWeekYear;
+proto$2.isoWeeksInYear = getISOWeeksInYear;
+proto$2.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear;
+proto$2.date = getSetDayOfMonth;
+proto$2.day = proto$2.days = getSetDayOfWeek;
+proto$2.weekday = getSetLocaleDayOfWeek;
+proto$2.isoWeekday = getSetISODayOfWeek;
+proto$2.dayOfYear = getSetDayOfYear;
+proto$2.hour = proto$2.hours = getSetHour;
+proto$2.minute = proto$2.minutes = getSetMinute;
+proto$2.second = proto$2.seconds = getSetSecond;
+proto$2.millisecond = proto$2.milliseconds = getSetMillisecond;
+proto$2.utcOffset = getSetOffset;
+proto$2.utc = setOffsetToUTC;
+proto$2.local = setOffsetToLocal;
+proto$2.parseZone = setOffsetToParsedOffset;
+proto$2.hasAlignedHourOffset = hasAlignedHourOffset;
+proto$2.isDST = isDaylightSavingTime;
+proto$2.isLocal = isLocal;
+proto$2.isUtcOffset = isUtcOffset;
+proto$2.isUtc = isUtc;
+proto$2.isUTC = isUtc;
+proto$2.zoneAbbr = getZoneAbbr;
+proto$2.zoneName = getZoneName;
+proto$2.dates = deprecate(
     'dates accessor is deprecated. Use date instead.',
     getSetDayOfMonth
 );
-proto.months = deprecate(
+proto$2.months = deprecate(
     'months accessor is deprecated. Use month instead',
     getSetMonth
 );
-proto.years = deprecate(
+proto$2.years = deprecate(
     'years accessor is deprecated. Use year instead',
     getSetYear
 );
-proto.zone = deprecate(
+proto$2.zone = deprecate(
     'moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/',
     getSetZone
 );
-proto.isDSTShifted = deprecate(
+proto$2.isDSTShifted = deprecate(
     'isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information',
     isDaylightSavingTimeShifted
 );
@@ -5002,13 +5242,13 @@ function preParsePostFormat(string) {
 
 var proto$1 = Locale.prototype;
 
-proto$1.calendar = calendar;
+proto$1.calendar = calendar$1;
 proto$1.longDateFormat = longDateFormat;
 proto$1.invalidDate = invalidDate;
 proto$1.ordinal = ordinal;
 proto$1.preparse = preParsePostFormat;
 proto$1.postformat = preParsePostFormat;
-proto$1.relativeTime = relativeTime;
+proto$1.relativeTime = relativeTime$1;
 proto$1.pastFuture = pastFuture;
 proto$1.set = set;
 proto$1.eras = localeEras;
@@ -5155,12 +5395,12 @@ getSetGlobalLocale('en', {
                 toInt((number % 100) / 10) === 1
                     ? 'th'
                     : b === 1
-                    ? 'st'
-                    : b === 2
-                    ? 'nd'
-                    : b === 3
-                    ? 'rd'
-                    : 'th';
+                      ? 'st'
+                      : b === 2
+                        ? 'nd'
+                        : b === 3
+                          ? 'rd'
+                          : 'th';
         return number + output;
     },
 });
@@ -5178,7 +5418,7 @@ hooks.langData = deprecate(
 
 var mathAbs = Math.abs;
 
-function abs() {
+function abs$1() {
     var data = this._data;
 
     this._milliseconds = mathAbs(this._milliseconds);
@@ -5195,7 +5435,7 @@ function abs() {
     return this;
 }
 
-function addSubtract$1(duration, input, value, direction) {
+function addSubtract(duration, input, value, direction) {
     var other = createDuration(input, value);
 
     duration._milliseconds += direction * other._milliseconds;
@@ -5206,13 +5446,13 @@ function addSubtract$1(duration, input, value, direction) {
 }
 
 // supports only 2.0-style add(1, 's') or add(duration)
-function add$1(input, value) {
-    return addSubtract$1(this, input, value, 1);
+function add(input, value) {
+    return addSubtract(this, input, value, 1);
 }
 
 // supports only 2.0-style subtract(1, 's') or subtract(duration)
-function subtract$1(input, value) {
-    return addSubtract$1(this, input, value, -1);
+function subtract(input, value) {
+    return addSubtract(this, input, value, -1);
 }
 
 function absCeil(number) {
@@ -5236,12 +5476,10 @@ function bubble() {
 
     // if we have a mix of positive and negative values, bubble down first
     // check: https://github.com/moment/moment/issues/2166
-    if (
-        !(
-            (milliseconds >= 0 && days >= 0 && months >= 0) ||
-            (milliseconds <= 0 && days <= 0 && months <= 0)
-        )
-    ) {
+    if (!(
+        (milliseconds >= 0 && days >= 0 && months >= 0) ||
+        (milliseconds <= 0 && days <= 0 && months <= 0)
+    )) {
         milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
         days = 0;
         months = 0;
@@ -5333,19 +5571,6 @@ function as(units) {
     }
 }
 
-// TODO: Use this.as('ms')?
-function valueOf$1() {
-    if (!this.isValid()) {
-        return NaN;
-    }
-    return (
-        this._milliseconds +
-        this._days * 864e5 +
-        (this._months % 12) * 2592e6 +
-        toInt(this._months / 12) * 31536e6
-    );
-}
-
 function makeAs(alias) {
     return function () {
         return this.as(alias);
@@ -5360,13 +5585,14 @@ var asMilliseconds = makeAs('ms'),
     asWeeks = makeAs('w'),
     asMonths = makeAs('M'),
     asQuarters = makeAs('Q'),
-    asYears = makeAs('y');
+    asYears = makeAs('y'),
+    valueOf = asMilliseconds;
 
-function clone$1() {
+function clone() {
     return createDuration(this);
 }
 
-function get$2(units) {
+function get(units) {
     units = normalizeUnits(units);
     return this.isValid() ? this[units + 's']() : NaN;
 }
@@ -5402,10 +5628,16 @@ var round = Math.round,
 
 // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
 function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
-    return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
+    return relativeTimeWithoutPostformat.call(
+        locale,
+        number || 1,
+        !!withoutSuffix,
+        string,
+        isFuture
+    );
 }
 
-function relativeTime$1(posNegDuration, withoutSuffix, thresholds, locale) {
+function relativeTime(posNegDuration, withoutSuffix, thresholds, locale) {
     var duration = createDuration(posNegDuration).abs(),
         seconds = round(duration.as('s')),
         minutes = round(duration.as('m')),
@@ -5486,29 +5718,29 @@ function humanize(argWithSuffix, argThresholds) {
         withSuffix = argWithSuffix;
     }
     if (typeof argThresholds === 'object') {
-        th = Object.assign({}, thresholds, argThresholds);
+        th = extend(extend({}, thresholds), argThresholds || {});
         if (argThresholds.s != null && argThresholds.ss == null) {
             th.ss = argThresholds.s - 1;
         }
     }
 
     locale = this.localeData();
-    output = relativeTime$1(this, !withSuffix, th, locale);
+    output = relativeTime(this, !withSuffix, th, locale);
 
     if (withSuffix) {
-        output = locale.pastFuture(+this, output);
+        output = pastFutureWithoutPostformat.call(locale, +this, output);
     }
 
     return locale.postformat(output);
 }
 
-var abs$1 = Math.abs;
+var abs = Math.abs;
 
 function sign(x) {
     return (x > 0) - (x < 0) || +x;
 }
 
-function toISOString$1() {
+function toISOString() {
     // for ISO strings we do not use the normal bubbling rules:
     //  * milliseconds bubble up until they become hours
     //  * days do not bubble at all
@@ -5520,9 +5752,9 @@ function toISOString$1() {
         return this.localeData().invalidDate();
     }
 
-    var seconds = abs$1(this._milliseconds) / 1000,
-        days = abs$1(this._days),
-        months = abs$1(this._months),
+    var seconds = abs(this._milliseconds) / 1000,
+        days = abs(this._days),
+        months = abs(this._months),
         minutes,
         hours,
         years,
@@ -5570,46 +5802,46 @@ function toISOString$1() {
     );
 }
 
-var proto$2 = Duration.prototype;
+var proto = Duration.prototype;
 
-proto$2.isValid = isValid$1;
-proto$2.abs = abs;
-proto$2.add = add$1;
-proto$2.subtract = subtract$1;
-proto$2.as = as;
-proto$2.asMilliseconds = asMilliseconds;
-proto$2.asSeconds = asSeconds;
-proto$2.asMinutes = asMinutes;
-proto$2.asHours = asHours;
-proto$2.asDays = asDays;
-proto$2.asWeeks = asWeeks;
-proto$2.asMonths = asMonths;
-proto$2.asQuarters = asQuarters;
-proto$2.asYears = asYears;
-proto$2.valueOf = valueOf$1;
-proto$2._bubble = bubble;
-proto$2.clone = clone$1;
-proto$2.get = get$2;
-proto$2.milliseconds = milliseconds;
-proto$2.seconds = seconds;
-proto$2.minutes = minutes;
-proto$2.hours = hours;
-proto$2.days = days;
-proto$2.weeks = weeks;
-proto$2.months = months;
-proto$2.years = years;
-proto$2.humanize = humanize;
-proto$2.toISOString = toISOString$1;
-proto$2.toString = toISOString$1;
-proto$2.toJSON = toISOString$1;
-proto$2.locale = locale;
-proto$2.localeData = localeData;
+proto.isValid = isValid$1;
+proto.abs = abs$1;
+proto.add = add;
+proto.subtract = subtract;
+proto.as = as;
+proto.asMilliseconds = asMilliseconds;
+proto.asSeconds = asSeconds;
+proto.asMinutes = asMinutes;
+proto.asHours = asHours;
+proto.asDays = asDays;
+proto.asWeeks = asWeeks;
+proto.asMonths = asMonths;
+proto.asQuarters = asQuarters;
+proto.asYears = asYears;
+proto.valueOf = valueOf;
+proto._bubble = bubble;
+proto.clone = clone;
+proto.get = get;
+proto.milliseconds = milliseconds;
+proto.seconds = seconds;
+proto.minutes = minutes;
+proto.hours = hours;
+proto.days = days;
+proto.weeks = weeks;
+proto.months = months;
+proto.years = years;
+proto.humanize = humanize;
+proto.toISOString = toISOString;
+proto.toString = toISOString;
+proto.toJSON = toISOString;
+proto.locale = locale;
+proto.localeData = localeData;
 
-proto$2.toIsoString = deprecate(
+proto.toIsoString = deprecate(
     'toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)',
-    toISOString$1
+    toISOString
 );
-proto$2.lang = lang;
+proto.lang = lang;
 
 // FORMATTING
 
@@ -5629,11 +5861,11 @@ addParseToken('x', function (input, array, config) {
 
 //! moment.js
 
-hooks.version = '2.29.4';
+hooks.version = '2.31.0';
 
 setHookCallback(createLocal);
 
-hooks.fn = proto;
+hooks.fn = proto$2;
 hooks.min = min;
 hooks.max = max;
 hooks.now = now;
@@ -5642,7 +5874,7 @@ hooks.unix = createUnix;
 hooks.months = listMonths;
 hooks.isDate = isDate;
 hooks.locale = getSetGlobalLocale;
-hooks.invalid = createInvalid;
+hooks.invalid = createInvalid$1;
 hooks.duration = createDuration;
 hooks.isMoment = isMoment;
 hooks.weekdays = listWeekdays;
@@ -5659,7 +5891,7 @@ hooks.normalizeUnits = normalizeUnits;
 hooks.relativeTimeRounding = getSetRelativeTimeRounding;
 hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
 hooks.calendarFormat = getCalendarFormat;
-hooks.prototype = proto;
+hooks.prototype = proto$2;
 
 // currently HTML5 input type only supports 24-hour formats
 hooks.HTML5_FMT = {
@@ -5674,4 +5906,4 @@ hooks.HTML5_FMT = {
     MONTH: 'YYYY-MM', // <input type="month" />
 };
 
-export default hooks;
+export { hooks as default };