@nocobase/plugin-backup-restore 2.2.20 → 2.2.21

package/dist/node_modules/moment/src/lib/moment/get-set.js

@@ -2,9 +2,7 @@ import { normalizeUnits, normalizeObjectUnits } from '../units/aliases';
 import { getPrioritizedUnits } from '../units/priorities';
 import { hooks } from '../utils/hooks';
 import isFunction from '../utils/is-function';
-import { daysInMonth } from '../units/month';
-import { isLeapYear } from '../utils/is-leap-year';
-import toInt from '../utils/to-int';
+import { isLeapYear } from '../units/year';
 
 export function makeGetSet(unit, keepTime) {
     return function (value) {
@@ -19,29 +17,75 @@ export function makeGetSet(unit, keepTime) {
 }
 
 export function get(mom, unit) {
-    return mom.isValid()
-        ? mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]()
-        : NaN;
+    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
+    }
 }
 
 export function set(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

package/dist/node_modules/moment/src/lib/moment/min-max.js

@@ -2,6 +2,7 @@ import { deprecate } from '../utils/deprecate';
 import isArray from '../utils/is-array';
 import { createLocal } from '../create/local';
 import { createInvalid } from '../create/valid';
+import { isMoment } from './constructor';
 
 export var prototypeMin = deprecate(
         'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
@@ -39,9 +40,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();
+    }
+    for (++i; i < moments.length; ++i) {
+        if (
+            isMoment(moments[i]) &&
+            (!moments[i].isValid() || moments[i][fn](res))
+        ) {
             res = moments[i];
         }
     }

package/dist/node_modules/moment/src/lib/parse/regex.js

@@ -18,6 +18,8 @@ var match1 = /\d/, //       0 - 9
     // 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;
 
 export {
@@ -38,6 +40,8 @@ export {
     matchShortOffset,
     matchTimestamp,
     matchWord,
+    match1to2NoLeadingZero,
+    match1to2HasZero,
 };
 
 import hasOwnProp from '../utils/has-own-prop';

package/dist/node_modules/moment/src/lib/units/aliases.js

@@ -1,11 +1,55 @@
 import hasOwnProp from '../utils/has-own-prop';
 
-var aliases = {};
-
-export function addUnitAlias(unit, shorthand) {
-    var lowerCase = unit.toLowerCase();
-    aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
-}
+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',
+};
 
 export function normalizeUnits(units) {
     return typeof units === 'string'

package/dist/node_modules/moment/src/lib/units/day-of-month.js

@@ -1,8 +1,11 @@
 import { makeGetSet } from '../moment/get-set';
 import { addFormatToken } from '../format/format';
-import { addUnitAlias } from './aliases';
-import { addUnitPriority } from './priorities';
-import { addRegexToken, match1to2, match2 } from '../parse/regex';
+import {
+    addRegexToken,
+    match1to2,
+    match2,
+    match1to2NoLeadingZero,
+} from '../parse/regex';
 import { addParseToken } from '../parse/token';
 import { DATE } from './constants';
 import toInt from '../utils/to-int';
@@ -11,16 +14,9 @@ import toInt from '../utils/to-int';
 
 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.

package/dist/node_modules/moment/src/lib/units/day-of-week.js

@@ -1,14 +1,16 @@
+import { get } from '../moment/get-set';
 import { addFormatToken } from '../format/format';
-import { addUnitAlias } from './aliases';
-import { addUnitPriority } from './priorities';
 import {
     addRegexToken,
     match1to2,
+    match5to6,
     matchWord,
     regexEscape,
 } from '../parse/regex';
 import { addWeekParseToken } from '../parse/token';
+import { HOUR, MINUTE } from './constants';
 import toInt from '../utils/to-int';
+import zeroFill from '../utils/zero-fill';
 import isArray from '../utils/is-array';
 import indexOf from '../utils/index-of';
 import hasOwnProp from '../utils/has-own-prop';
@@ -33,23 +35,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);
 });
@@ -74,6 +74,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) {
@@ -111,7 +119,19 @@ 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',
+    ];
 
 export {
     defaultLocaleWeekdays,
@@ -119,6 +139,16 @@ export {
     defaultLocaleWeekdaysMin,
 };
 
+export function clearWeekdaysParseCache(locale, config) {
+    var i, prop;
+    for (i = 0; i < weekdaysParseProperties.length; i++) {
+        prop = weekdaysParseProperties[i];
+        if (!hasOwnProp(config, prop)) {
+            delete locale['_' + prop];
+        }
+    }
+}
+
 export function localeWeekdays(m, format) {
     var weekdays = isArray(this._weekdays)
         ? this._weekdays
@@ -130,24 +160,24 @@ export function localeWeekdays(m, format) {
     return m === true
         ? shiftWeekdays(weekdays, this._week.dow)
         : m
-        ? weekdays[m.day()]
-        : weekdays;
+          ? weekdays[m.day()]
+          : weekdays;
 }
 
 export 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;
 }
 
 export 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(weekdayName, format, strict) {
@@ -296,7 +326,8 @@ export function getSetDayOfWeek(input) {
     if (!this.isValid()) {
         return input != null ? this : NaN;
     }
-    var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
+
+    var day = get(this, 'Day');
     if (input != null) {
         input = parseWeekday(input, this.localeData());
         return this.add(input - day, 'd');

package/dist/node_modules/moment/src/lib/units/day-of-year.js

@@ -1,6 +1,4 @@
 import { addFormatToken } from '../format/format';
-import { addUnitAlias } from './aliases';
-import { addUnitPriority } from './priorities';
 import { addRegexToken, match3, match1to3 } from '../parse/regex';
 import { addParseToken } from '../parse/token';
 import toInt from '../utils/to-int';
@@ -9,13 +7,6 @@ import toInt from '../utils/to-int';
 
 addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
 
-// ALIASES
-
-addUnitAlias('dayOfYear', 'DDD');
-
-// PRIORITY
-addUnitPriority('dayOfYear', 4);
-
 // PARSING
 
 addRegexToken('DDD', match1to3);

package/dist/node_modules/moment/src/lib/units/era.js

@@ -265,16 +265,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));
-
-        mixedPieces.push(regexEscape(eras[i].name));
-        mixedPieces.push(regexEscape(eras[i].abbr));
-        mixedPieces.push(regexEscape(eras[i].narrow));
+        erasName = regexEscape(eras[i].name);
+        erasAbbr = regexEscape(eras[i].abbr);
+        erasNarrow = 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');

package/dist/node_modules/moment/src/lib/units/hour.js

@@ -1,13 +1,13 @@
 import { makeGetSet } from '../moment/get-set';
 import { addFormatToken } from '../format/format';
-import { addUnitAlias } from './aliases';
-import { addUnitPriority } from './priorities';
 import {
     addRegexToken,
     match1to2,
     match2,
     match3to4,
     match5to6,
+    match1to2NoLeadingZero,
+    match1to2HasZero,
 } from '../parse/regex';
 import { addParseToken } from '../parse/token';
 import { HOUR, MINUTE, SECOND } from './constants';
@@ -68,13 +68,6 @@ function meridiem(token, lowercase) {
 meridiem('a', true);
 meridiem('A', false);
 
-// ALIASES
-
-addUnitAlias('hour', 'h');
-
-// PRIORITY
-addUnitPriority('hour', 13);
-
 // PARSING
 
 function matchMeridiem(isStrict, locale) {
@@ -83,9 +76,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);

package/dist/node_modules/moment/src/lib/units/millisecond.js

@@ -1,7 +1,5 @@
 import { makeGetSet } from '../moment/get-set';
 import { addFormatToken } from '../format/format';
-import { addUnitAlias } from './aliases';
-import { addUnitPriority } from './priorities';
 import {
     addRegexToken,
     match1,
@@ -44,14 +42,6 @@ addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
     return this.millisecond() * 1000000;
 });
 
-// ALIASES
-
-addUnitAlias('millisecond', 'ms');
-
-// PRIORITY
-
-addUnitPriority('millisecond', 16);
-
 // PARSING
 
 addRegexToken('S', match1to3, match1);

package/dist/node_modules/moment/src/lib/units/minute.js

@@ -1,8 +1,11 @@
 import { makeGetSet } from '../moment/get-set';
 import { addFormatToken } from '../format/format';
-import { addUnitAlias } from './aliases';
-import { addUnitPriority } from './priorities';
-import { addRegexToken, match1to2, match2 } from '../parse/regex';
+import {
+    addRegexToken,
+    match1to2,
+    match2,
+    match1to2HasZero,
+} from '../parse/regex';
 import { addParseToken } from '../parse/token';
 import { MINUTE } from './constants';
 
@@ -10,17 +13,9 @@ import { MINUTE } from './constants';
 
 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);
 

package/dist/node_modules/moment/src/lib/units/month.js

@@ -1,14 +1,13 @@
 import { get } from '../moment/get-set';
 import hasOwnProp from '../utils/has-own-prop';
 import { addFormatToken } from '../format/format';
-import { addUnitAlias } from './aliases';
-import { addUnitPriority } from './priorities';
 import {
     addRegexToken,
     match1to2,
     match2,
     matchWord,
     regexEscape,
+    match1to2NoLeadingZero,
 } from '../parse/regex';
 import { addParseToken } from '../parse/token';
 import { hooks } from '../utils/hooks';
@@ -49,17 +48,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);
@@ -92,10 +83,29 @@ 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',
+    ];
 
 export { defaultLocaleMonths, defaultLocaleMonthsShort };
 
+export function clearMonthsParseCache(locale, config) {
+    var i, prop;
+    for (i = 0; i < monthsParseProperties.length; i++) {
+        prop = monthsParseProperties[i];
+        if (!hasOwnProp(config, prop)) {
+            delete locale['_' + prop];
+        }
+    }
+}
+
 export function localeMonths(m, format) {
     if (!m) {
         return isArray(this._months)
@@ -227,8 +237,6 @@ export function localeMonthsParse(monthName, format, strict) {
 // MOMENTS
 
 export function setMonth(mom, value) {
-    var dayOfMonth;
-
     if (!mom.isValid()) {
         // No op
         return mom;
@@ -246,8 +254,13 @@ export 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;
 }
 
@@ -314,27 +327,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;