@nocobase/plugin-backup-restore 2.2.20 → 2.2.21

package/dist/node_modules/moment/src/lib/create/from-array.js

@@ -2,7 +2,7 @@ import { hooks } from '../utils/hooks';
 import { createDate, createUTCDate } from './date-from-array';
 import { daysInYear } from '../units/year';
 import {
-    weekOfYear,
+    weekOfYearFromDate,
     weeksInYear,
     dayOfYearFromWeeks,
 } from '../units/week-calendar-utils';
@@ -19,9 +19,46 @@ import { createLocal } from './local';
 import defaults from '../utils/defaults';
 import getParsingFlags from './parsing-flags';
 
-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(),
@@ -32,6 +69,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.
@@ -40,24 +79,34 @@ export 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) ||
@@ -71,6 +120,11 @@ export 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
@@ -119,13 +173,14 @@ export 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;
@@ -140,7 +195,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);
@@ -151,7 +212,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);
 

package/dist/node_modules/moment/src/lib/create/from-string-and-array.js

@@ -13,6 +13,7 @@ export function configFromStringAndArray(config) {
         currentScore,
         validFormatFound,
         bestFormatIsValid = false,
+        defaultDatePartsNow = {},
         configfLen = config._f.length;
 
     if (configfLen === 0) {
@@ -28,6 +29,7 @@ export function configFromStringAndArray(config) {
         if (config._useUTC != null) {
             tempConfig._useUTC = config._useUTC;
         }
+        tempConfig._defaultDatePartsNow = defaultDatePartsNow;
         tempConfig._f = config._f[i];
         configFromStringAndFormat(tempConfig);
 

package/dist/node_modules/moment/src/lib/create/parsing-flags.js

@@ -9,6 +9,7 @@ function defaultParsingFlags() {
         nullInput: false,
         invalidEra: null,
         invalidMonth: null,
+        invalidOffset: null,
         invalidFormat: false,
         userInvalidated: false,
         iso: false,

package/dist/node_modules/moment/src/lib/create/valid.js

@@ -4,24 +4,26 @@ import getParsingFlags from '../create/parsing-flags';
 import some from '../utils/some';
 
 export 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));
-
+    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 &&
@@ -29,12 +31,11 @@ export 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;
 }

package/dist/node_modules/moment/src/lib/duration/as.js

@@ -1,6 +1,5 @@
 import { daysToMonths, monthsToDays } from './bubble';
 import { normalizeUnits } from '../units/aliases';
-import toInt from '../utils/to-int';
 
 export function as(units) {
     if (!this.isValid()) {
@@ -46,19 +45,6 @@ export function as(units) {
     }
 }
 
-// TODO: Use this.as('ms')?
-export function valueOf() {
-    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);
@@ -73,7 +59,8 @@ var asMilliseconds = makeAs('ms'),
     asWeeks = makeAs('w'),
     asMonths = makeAs('M'),
     asQuarters = makeAs('Q'),
-    asYears = makeAs('y');
+    asYears = makeAs('y'),
+    valueOf = asMilliseconds;
 
 export {
     asMilliseconds,
@@ -85,4 +72,5 @@ export {
     asMonths,
     asQuarters,
     asYears,
+    valueOf,
 };

package/dist/node_modules/moment/src/lib/duration/bubble.js

@@ -14,12 +14,10 @@ export 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;

package/dist/node_modules/moment/src/lib/duration/humanize.js

@@ -1,4 +1,9 @@
 import { createDuration } from './create';
+import extend from '../utils/extend';
+import {
+    relativeTimeWithoutPostformat,
+    pastFutureWithoutPostformat,
+} from '../locale/relative';
 
 var round = Math.round,
     thresholds = {
@@ -13,7 +18,13 @@ 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(posNegDuration, withoutSuffix, thresholds, locale) {
@@ -97,7 +108,7 @@ export 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;
         }
@@ -107,7 +118,7 @@ export function humanize(argWithSuffix, argThresholds) {
     output = relativeTime(this, !withSuffix, th, locale);
 
     if (withSuffix) {
-        output = locale.pastFuture(+this, output);
+        output = pastFutureWithoutPostformat.call(locale, +this, output);
     }
 
     return locale.postformat(output);

package/dist/node_modules/moment/src/lib/format/format.js

@@ -1,8 +1,9 @@
 import zeroFill from '../utils/zero-fill';
 import isFunction from '../utils/is-function';
+import hasOwnProp from '../utils/has-own-prop';
 
 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 = {};
@@ -77,10 +78,12 @@ export 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);
 }
 
 export function expandFormat(format, locale) {

package/dist/node_modules/moment/src/lib/locale/en.js

@@ -28,12 +28,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;
     },
 });

package/dist/node_modules/moment/src/lib/locale/formats.js

@@ -11,13 +11,22 @@ export var defaultLongDateFormat = {
 
 export function longDateFormat(key) {
     var format = this._longDateFormat[key],
-        formatUpper = this._longDateFormat[key.toUpperCase()];
+        formatUpper = this._longDateFormat[key.toUpperCase()],
+        formatCache = this._longDateFormatCache;
 
     if (format || !formatUpper) {
         return format;
     }
 
-    this._longDateFormat[key] = formatUpper
+    if (
+        formatCache &&
+        formatCache[key] &&
+        formatCache[key].formatUpper === formatUpper
+    ) {
+        return formatCache[key].format;
+    }
+
+    format = formatUpper
         .match(formattingTokens)
         .map(function (tok) {
             if (
@@ -32,5 +41,12 @@ export function longDateFormat(key) {
         })
         .join('');
 
-    return this._longDateFormat[key];
+    if (!formatCache) {
+        formatCache = this._longDateFormatCache = {};
+    }
+    formatCache[key] = {
+        formatUpper: formatUpper,
+        format: format,
+    };
+    return format;
 }

package/dist/node_modules/moment/src/lib/locale/locales.js

@@ -1,5 +1,6 @@
 import isArray from '../utils/is-array';
 import isUndefined from '../utils/is-undefined';
+import hasOwnProp from '../utils/has-own-prop';
 import { deprecateSimple } from '../utils/deprecate';
 import { mergeConfigs } from './set';
 import { Locale } from './constructor';
@@ -63,33 +64,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
@@ -175,17 +192,20 @@ export function defineLocale(name, config) {
 }
 
 export 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;
             }

package/dist/node_modules/moment/src/lib/locale/relative.js

@@ -19,14 +19,37 @@ export var defaultRelativeTime = {
 
 import isFunction from '../utils/is-function';
 
-export function relativeTime(number, withoutSuffix, string, isFuture) {
+export function relativeTimeWithoutPostformat(
+    number,
+    withoutSuffix,
+    string,
+    isFuture
+) {
     var output = this._relativeTime[string];
     return isFunction(output)
         ? output(number, withoutSuffix, string, isFuture)
         : output.replace(/%d/i, number);
 }
 
-export function pastFuture(diff, output) {
+export function relativeTime(number, withoutSuffix, string, isFuture) {
+    return this.postformat(
+        relativeTimeWithoutPostformat.call(
+            this,
+            number,
+            withoutSuffix,
+            string,
+            isFuture
+        )
+    );
+}
+
+export function pastFutureWithoutPostformat(diff, output) {
     var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
     return isFunction(format) ? format(output) : format.replace(/%s/i, output);
 }
+
+export function pastFuture(diff, output) {
+    return this.postformat(
+        pastFutureWithoutPostformat.call(this, diff, output)
+    );
+}

package/dist/node_modules/moment/src/lib/locale/set.js

@@ -2,9 +2,13 @@ import isFunction from '../utils/is-function';
 import extend from '../utils/extend';
 import isObject from '../utils/is-object';
 import hasOwnProp from '../utils/has-own-prop';
+import { clearMonthsParseCache } from '../units/month';
+import { clearWeekdaysParseCache } from '../units/day-of-week';
 
 export function set(config) {
     var prop, i;
+    clearMonthsParseCache(this, config);
+    clearWeekdaysParseCache(this, config);
     for (i in config) {
         if (hasOwnProp(config, i)) {
             prop = config[i];

package/dist/node_modules/moment/src/lib/moment/calendar.js

@@ -10,16 +10,16 @@ export function getCalendarFormat(myMoment, now) {
     return diff < -6
         ? 'sameElse'
         : diff < -1
-        ? 'lastWeek'
-        : diff < 0
-        ? 'lastDay'
-        : diff < 1
-        ? 'sameDay'
-        : diff < 2
-        ? 'nextDay'
-        : diff < 7
-        ? 'nextWeek'
-        : 'sameElse';
+          ? 'lastWeek'
+          : diff < 0
+            ? 'lastDay'
+            : diff < 1
+              ? 'sameDay'
+              : diff < 2
+                ? 'nextDay'
+                : diff < 7
+                  ? 'nextWeek'
+                  : 'sameElse';
 }
 
 export function calendar(time, formats) {