@ant-design/pro-components 2.3.45 → 2.3.47

package/dist/components.js

@@ -13397,6 +13397,90 @@ var __WEBPACK_AMD_DEFINE_RESULT__;// TinyColor v1.4.2
 
 /***/ }),
 
+/***/ 2618:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+/**
+ * @license React
+ * use-sync-external-store-shim.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+var e = __webpack_require__(1024);
+function h(a, b) {
+  return a === b && (0 !== a || 1 / a === 1 / b) || a !== a && b !== b;
+}
+var k = "function" === typeof Object.is ? Object.is : h,
+  l = e.useState,
+  m = e.useEffect,
+  n = e.useLayoutEffect,
+  p = e.useDebugValue;
+function q(a, b) {
+  var d = b(),
+    f = l({
+      inst: {
+        value: d,
+        getSnapshot: b
+      }
+    }),
+    c = f[0].inst,
+    g = f[1];
+  n(function () {
+    c.value = d;
+    c.getSnapshot = b;
+    r(c) && g({
+      inst: c
+    });
+  }, [a, d, b]);
+  m(function () {
+    r(c) && g({
+      inst: c
+    });
+    return a(function () {
+      r(c) && g({
+        inst: c
+      });
+    });
+  }, [a]);
+  p(d);
+  return d;
+}
+function r(a) {
+  var b = a.getSnapshot;
+  a = a.value;
+  try {
+    var d = b();
+    return !k(a, d);
+  } catch (f) {
+    return !0;
+  }
+}
+function t(a, b) {
+  return b();
+}
+var u = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? t : q;
+exports.useSyncExternalStore = void 0 !== e.useSyncExternalStore ? e.useSyncExternalStore : u;
+
+/***/ }),
+
+/***/ 3740:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+
+if (true) {
+  module.exports = __webpack_require__(2618);
+} else {}
+
+/***/ }),
+
 /***/ 1242:
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
@@ -15092,7 +15176,7 @@ function combine(array, callback) {
  * @param {function} callback
  * @return {string}
  */
-function serialize(children, callback) {
+function Serializer_serialize(children, callback) {
   var output = '';
   var length = sizeof(children);
   for (var i = 0; i < length; i++) {
@@ -15116,11 +15200,11 @@ function stringify(element, index, children, callback) {
     case COMMENT:
       return '';
     case KEYFRAMES:
-      return element.return = element.value + '{' + serialize(element.children, callback) + '}';
+      return element.return = element.value + '{' + Serializer_serialize(element.children, callback) + '}';
     case RULESET:
       element.value = element.props.join(',');
   }
-  return strlen(children = serialize(element.children, callback)) ? element.return = element.value + '{' + children + '}' : '';
+  return strlen(children = Serializer_serialize(element.children, callback)) ? element.return = element.value + '{' + children + '}' : '';
 }
 ;// CONCATENATED MODULE: ./node_modules/stylis/src/Tokenizer.js
 
@@ -15954,7 +16038,7 @@ var SKIP_CHECK = '_skip_check_';
 // ============================================================================
 // Preprocessor style content to browser support one
 function normalizeStyle(styleStr) {
-  var serialized = serialize(compile(styleStr), stringify);
+  var serialized = Serializer_serialize(compile(styleStr), stringify);
   return serialized.replace(/\{%%%\:[^;];}/g, ';');
 }
 function isCompoundCSSProperty(value) {
@@ -17390,87 +17474,55 @@ var localeValues = {
   }
 };
 /* harmony default export */ var es_locale_zh_CN = (localeValues);
-;// CONCATENATED MODULE: ./node_modules/swr/dist/index.mjs
-
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-}
-
-var noop = function () { };
-// Using noop() as the undefined value as undefined can possibly be replaced
-// by something else.  Prettier ignore and extra parentheses are necessary here
+// EXTERNAL MODULE: ./node_modules/use-sync-external-store/shim/index.js
+var shim = __webpack_require__(3740);
+;// CONCATENATED MODULE: ./node_modules/swr/_internal/dist/index.mjs
+
+
+// Global state used to deduplicate requests and store listeners
+const SWRGlobalState = new WeakMap();
+
+const EMPTY_CACHE = {};
+const noop = ()=>{};
+// Using noop() as the undefined value as undefined can be replaced
+// by something else. Prettier ignore and extra parentheses are necessary here
 // to ensure that tsc doesn't remove the __NOINLINE__ comment.
 // prettier-ignore
-var UNDEFINED = ( /*#__NOINLINE__*/noop());
-var OBJECT = Object;
-var isUndefined = function (v) { return v === UNDEFINED; };
-var isFunction = function (v) { return typeof v == 'function'; };
-var mergeObjects = function (a, b) { return OBJECT.assign({}, a, b); };
-var STR_UNDEFINED = 'undefined';
-// NOTE: Use function to guarantee it's re-evaluated between jsdom and node runtime for tests.
-var hasWindow = function () { return typeof window != STR_UNDEFINED; };
-var hasDocument = function () { return typeof document != STR_UNDEFINED; };
-var hasRequestAnimationFrame = function () {
-    return hasWindow() && typeof window['requestAnimationFrame'] != STR_UNDEFINED;
+const UNDEFINED = /*#__NOINLINE__*/ noop();
+const OBJECT = Object;
+const isUndefined = (v)=>v === UNDEFINED;
+const isFunction = (v)=>typeof v == 'function';
+const mergeObjects = (a, b)=>({
+        ...a,
+        ...b
+    });
+const STR_UNDEFINED = 'undefined';
+// NOTE: Use the function to guarantee it's re-evaluated between jsdom and node runtime for tests.
+const isWindowDefined = typeof window != STR_UNDEFINED;
+const isDocumentDefined = typeof document != STR_UNDEFINED;
+const hasRequestAnimationFrame = ()=>isWindowDefined && typeof window['requestAnimationFrame'] != STR_UNDEFINED;
+const createCacheHelper = (cache, key)=>{
+    const state = SWRGlobalState.get(cache);
+    return [
+        // Getter
+        ()=>cache.get(key) || EMPTY_CACHE,
+        // Setter
+        (info)=>{
+            const prev = cache.get(key);
+            state[5](key, mergeObjects(prev, info), prev || EMPTY_CACHE);
+        },
+        // Subscriber
+        state[6]
+    ];
 };
 
 // use WeakMap to store the object->key mapping
 // so the objects can be garbage collected.
 // WeakMap uses a hashtable under the hood, so the lookup
 // complexity is almost O(1).
-var table = new WeakMap();
+const table = new WeakMap();
 // counter of the key
-var counter = 0;
+let counter = 0;
 // A stable hash implementation that supports:
 // - Fast and ensures unique hash properties
 // - Handles unserializable values
@@ -17478,19 +17530,18 @@ var counter = 0;
 // - Generates short results
 //
 // This is not a serialization function, and the result is not guaranteed to be
-// parsible.
-var stableHash = function (arg) {
-    var type = typeof arg;
-    var constructor = arg && arg.constructor;
-    var isDate = constructor == Date;
-    var result;
-    var index;
+// parsable.
+const stableHash = (arg)=>{
+    const type = typeof arg;
+    const constructor = arg && arg.constructor;
+    const isDate = constructor == Date;
+    let result;
+    let index;
     if (OBJECT(arg) === arg && !isDate && constructor != RegExp) {
         // Object/function, not null/date/regexp. Use WeakMap to store the id first.
         // If it's already hashed, directly return the result.
         result = table.get(arg);
-        if (result)
-            return result;
+        if (result) return result;
         // Store the hash first for circular reference detection before entering the
         // recursive `stableHash` calls.
         // For other objects like set and map, we use this id directly as the hash.
@@ -17499,7 +17550,7 @@ var stableHash = function (arg) {
         if (constructor == Array) {
             // Array.
             result = '@';
-            for (index = 0; index < arg.length; index++) {
+            for(index = 0; index < arg.length; index++){
                 result += stableHash(arg[index]) + ',';
             }
             table.set(arg, result);
@@ -17507,342 +17558,384 @@ var stableHash = function (arg) {
         if (constructor == OBJECT) {
             // Object, sort keys.
             result = '#';
-            var keys = OBJECT.keys(arg).sort();
-            while (!isUndefined((index = keys.pop()))) {
+            const keys = OBJECT.keys(arg).sort();
+            while(!isUndefined(index = keys.pop())){
                 if (!isUndefined(arg[index])) {
                     result += index + ':' + stableHash(arg[index]) + ',';
                 }
             }
             table.set(arg, result);
         }
-    }
-    else {
-        result = isDate
-            ? arg.toJSON()
-            : type == 'symbol'
-                ? arg.toString()
-                : type == 'string'
-                    ? JSON.stringify(arg)
-                    : '' + arg;
+    } else {
+        result = isDate ? arg.toJSON() : type == 'symbol' ? arg.toString() : type == 'string' ? JSON.stringify(arg) : '' + arg;
     }
     return result;
 };
 
 /**
- * Due to bug https://bugs.chromium.org/p/chromium/issues/detail?id=678075,
+ * Due to the bug https://bugs.chromium.org/p/chromium/issues/detail?id=678075,
  * it's not reliable to detect if the browser is currently online or offline
  * based on `navigator.onLine`.
- * As a work around, we always assume it's online on first load, and change
+ * As a workaround, we always assume it's online on the first load, and change
  * the status upon `online` or `offline` events.
- */
-var online = true;
-var isOnline = function () { return online; };
-var hasWin = hasWindow();
-var hasDoc = hasDocument();
+ */ let online = true;
+const isOnline = ()=>online;
 // For node and React Native, `add/removeEventListener` doesn't exist on window.
-var onWindowEvent = hasWin && window.addEventListener
-    ? window.addEventListener.bind(window)
-    : noop;
-var onDocumentEvent = hasDoc ? document.addEventListener.bind(document) : noop;
-var offWindowEvent = hasWin && window.removeEventListener
-    ? window.removeEventListener.bind(window)
-    : noop;
-var offDocumentEvent = hasDoc
-    ? document.removeEventListener.bind(document)
-    : noop;
-var isVisible = function () {
-    var visibilityState = hasDoc && document.visibilityState;
+const [onWindowEvent, offWindowEvent] = isWindowDefined && window.addEventListener ? [
+    window.addEventListener.bind(window),
+    window.removeEventListener.bind(window)
+] : [
+    noop,
+    noop
+];
+const isVisible = ()=>{
+    const visibilityState = isDocumentDefined && document.visibilityState;
     return isUndefined(visibilityState) || visibilityState !== 'hidden';
 };
-var initFocus = function (callback) {
+const initFocus = (callback)=>{
     // focus revalidate
-    onDocumentEvent('visibilitychange', callback);
+    if (isDocumentDefined) {
+        document.addEventListener('visibilitychange', callback);
+    }
     onWindowEvent('focus', callback);
-    return function () {
-        offDocumentEvent('visibilitychange', callback);
+    return ()=>{
+        if (isDocumentDefined) {
+            document.removeEventListener('visibilitychange', callback);
+        }
         offWindowEvent('focus', callback);
     };
 };
-var initReconnect = function (callback) {
+const initReconnect = (callback)=>{
     // revalidate on reconnected
-    var onOnline = function () {
+    const onOnline = ()=>{
         online = true;
         callback();
     };
     // nothing to revalidate, just update the status
-    var onOffline = function () {
+    const onOffline = ()=>{
         online = false;
     };
     onWindowEvent('online', onOnline);
     onWindowEvent('offline', onOffline);
-    return function () {
+    return ()=>{
         offWindowEvent('online', onOnline);
         offWindowEvent('offline', onOffline);
     };
 };
-var preset = {
-    isOnline: isOnline,
-    isVisible: isVisible
+const preset = {
+    isOnline,
+    isVisible
 };
-var defaultConfigOptions = {
-    initFocus: initFocus,
-    initReconnect: initReconnect
+const defaultConfigOptions = {
+    initFocus,
+    initReconnect
 };
 
-var IS_SERVER = !hasWindow() || 'Deno' in window;
+const IS_REACT_LEGACY = !external_React_.useId;
+const IS_SERVER = !isWindowDefined || 'Deno' in window;
 // Polyfill requestAnimationFrame
-var rAF = function (f) {
-    return hasRequestAnimationFrame() ? window['requestAnimationFrame'](f) : setTimeout(f, 1);
-};
+const rAF = (f)=>hasRequestAnimationFrame() ? window['requestAnimationFrame'](f) : setTimeout(f, 1);
 // React currently throws a warning when using useLayoutEffect on the server.
 // To get around it, we can conditionally useEffect on the server (no-op) and
 // useLayoutEffect in the browser.
-var useIsomorphicLayoutEffect = IS_SERVER ? external_React_.useEffect : external_React_.useLayoutEffect;
+const useIsomorphicLayoutEffect = IS_SERVER ? external_React_.useEffect : external_React_.useLayoutEffect;
 // This assignment is to extend the Navigator type to use effectiveType.
-var navigatorConnection = typeof navigator !== 'undefined' &&
-    navigator.connection;
+const navigatorConnection = typeof navigator !== 'undefined' && navigator.connection;
 // Adjust the config based on slow connection status (<= 70Kbps).
-var slowConnection = !IS_SERVER &&
-    navigatorConnection &&
-    (['slow-2g', '2g'].includes(navigatorConnection.effectiveType) ||
-        navigatorConnection.saveData);
+const slowConnection = !IS_SERVER && navigatorConnection && ([
+    'slow-2g',
+    '2g'
+].includes(navigatorConnection.effectiveType) || navigatorConnection.saveData);
 
-var dist_serialize = function (key) {
+const dist_serialize = (key)=>{
     if (isFunction(key)) {
         try {
             key = key();
-        }
-        catch (err) {
+        } catch (err) {
             // dependencies not ready
             key = '';
         }
     }
-    var args = [].concat(key);
+    // Use the original key as the argument of fetcher. This can be a string or an
+    // array of values.
+    const args = key;
     // If key is not falsy, or not an empty array, hash it.
-    key =
-        typeof key == 'string'
-            ? key
-            : (Array.isArray(key) ? key.length : key)
-                ? stableHash(key)
-                : '';
-    var infoKey = key ? '$swr$' + key : '';
-    return [key, args, infoKey];
+    key = typeof key == 'string' ? key : (Array.isArray(key) ? key.length : key) ? stableHash(key) : '';
+    return [
+        key,
+        args
+    ];
 };
 
-// Global state used to deduplicate requests and store listeners
-var SWRGlobalState = new WeakMap();
-
-var FOCUS_EVENT = 0;
-var RECONNECT_EVENT = 1;
-var MUTATE_EVENT = 2;
-
-var broadcastState = function (cache, key, data, error, isValidating, revalidate, broadcast) {
-    if (broadcast === void 0) { broadcast = true; }
-    var _a = SWRGlobalState.get(cache), EVENT_REVALIDATORS = _a[0], STATE_UPDATERS = _a[1], FETCH = _a[3];
-    var revalidators = EVENT_REVALIDATORS[key];
-    var updaters = STATE_UPDATERS[key];
-    // Cache was populated, update states of all hooks.
-    if (broadcast && updaters) {
-        for (var i = 0; i < updaters.length; ++i) {
-            updaters[i](data, error, isValidating);
+// Global timestamp.
+let __timestamp = 0;
+const getTimestamp = ()=>++__timestamp;
+
+const FOCUS_EVENT = 0;
+const RECONNECT_EVENT = 1;
+const MUTATE_EVENT = 2;
+
+var constants = {
+  __proto__: null,
+  FOCUS_EVENT: FOCUS_EVENT,
+  RECONNECT_EVENT: RECONNECT_EVENT,
+  MUTATE_EVENT: MUTATE_EVENT
+};
+
+async function internalMutate(...args) {
+    const [cache, _key, _data, _opts] = args;
+    // When passing as a boolean, it's explicitly used to disable/enable
+    // revalidation.
+    const options = mergeObjects({
+        populateCache: true,
+        throwOnError: true
+    }, typeof _opts === 'boolean' ? {
+        revalidate: _opts
+    } : _opts || {});
+    let populateCache = options.populateCache;
+    const rollbackOnErrorOption = options.rollbackOnError;
+    let optimisticData = options.optimisticData;
+    const revalidate = options.revalidate !== false;
+    const rollbackOnError = (error)=>{
+        return typeof rollbackOnErrorOption === 'function' ? rollbackOnErrorOption(error) : rollbackOnErrorOption !== false;
+    };
+    const throwOnError = options.throwOnError;
+    // If the second argument is a key filter, return the mutation results for all
+    // filtered keys.
+    if (isFunction(_key)) {
+        const keyFilter = _key;
+        const matchedKeys = [];
+        const it = cache.keys();
+        for(let keyIt = it.next(); !keyIt.done; keyIt = it.next()){
+            const key = keyIt.value;
+            if (// Skip the special useSWRInfinite keys.
+            !key.startsWith('$inf$') && keyFilter(cache.get(key)._k)) {
+                matchedKeys.push(key);
+            }
         }
-    }
-    // If we also need to revalidate, only do it for the first hook.
-    if (revalidate) {
-        // Invalidate the key by deleting the concurrent request markers so new
-        // requests will not be deduped.
-        delete FETCH[key];
-        if (revalidators && revalidators[0]) {
-            return revalidators[0](MUTATE_EVENT).then(function () {
-                return cache.get(key);
+        return Promise.all(matchedKeys.map(mutateByKey));
+    }
+    return mutateByKey(_key);
+    async function mutateByKey(_k) {
+        // Serialize key
+        const [key] = dist_serialize(_k);
+        if (!key) return;
+        const [get, set] = createCacheHelper(cache, key);
+        const [EVENT_REVALIDATORS, MUTATION, FETCH] = SWRGlobalState.get(cache);
+        const revalidators = EVENT_REVALIDATORS[key];
+        const startRevalidate = ()=>{
+            if (revalidate) {
+                // Invalidate the key by deleting the concurrent request markers so new
+                // requests will not be deduped.
+                delete FETCH[key];
+                if (revalidators && revalidators[0]) {
+                    return revalidators[0](MUTATE_EVENT).then(()=>get().data);
+                }
+            }
+            return get().data;
+        };
+        // If there is no new data provided, revalidate the key with current state.
+        if (args.length < 3) {
+            // Revalidate and broadcast state.
+            return startRevalidate();
+        }
+        let data = _data;
+        let error;
+        // Update global timestamps.
+        const beforeMutationTs = getTimestamp();
+        MUTATION[key] = [
+            beforeMutationTs,
+            0
+        ];
+        const hasOptimisticData = !isUndefined(optimisticData);
+        const state = get();
+        // `displayedData` is the current value on screen. It could be the optimistic value
+        // that is going to be overridden by a `committedData`, or get reverted back.
+        // `committedData` is the validated value that comes from a fetch or mutation.
+        const displayedData = state.data;
+        const currentData = state._c;
+        const committedData = isUndefined(currentData) ? displayedData : currentData;
+        // Do optimistic data update.
+        if (hasOptimisticData) {
+            optimisticData = isFunction(optimisticData) ? optimisticData(committedData) : optimisticData;
+            // When we set optimistic data, backup the current committedData data in `_c`.
+            set({
+                data: optimisticData,
+                _c: committedData
             });
         }
-    }
-    return cache.get(key);
-};
-
-// Global timestamp.
-var __timestamp = 0;
-var getTimestamp = function () { return ++__timestamp; };
-
-var internalMutate = function () {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    return __awaiter(void 0, void 0, void 0, function () {
-        var cache, _key, _data, _opts, options, populateCache, revalidate, rollbackOnError, customOptimisticData, _a, key, keyInfo, _b, MUTATION, data, error, beforeMutationTs, hasCustomOptimisticData, rollbackData, optimisticData, res;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    cache = args[0], _key = args[1], _data = args[2], _opts = args[3];
-                    options = typeof _opts === 'boolean' ? { revalidate: _opts } : _opts || {};
-                    populateCache = isUndefined(options.populateCache)
-                        ? true
-                        : options.populateCache;
-                    revalidate = options.revalidate !== false;
-                    rollbackOnError = options.rollbackOnError !== false;
-                    customOptimisticData = options.optimisticData;
-                    _a = dist_serialize(_key), key = _a[0], keyInfo = _a[2];
-                    if (!key)
-                        return [2 /*return*/];
-                    _b = SWRGlobalState.get(cache), MUTATION = _b[2];
-                    // If there is no new data provided, revalidate the key with current state.
-                    if (args.length < 3) {
-                        // Revalidate and broadcast state.
-                        return [2 /*return*/, broadcastState(cache, key, cache.get(key), UNDEFINED, UNDEFINED, revalidate, true)];
-                    }
-                    data = _data;
-                    beforeMutationTs = getTimestamp();
-                    MUTATION[key] = [beforeMutationTs, 0];
-                    hasCustomOptimisticData = !isUndefined(customOptimisticData);
-                    rollbackData = cache.get(key);
-                    // Do optimistic data update.
-                    if (hasCustomOptimisticData) {
-                        optimisticData = isFunction(customOptimisticData)
-                            ? customOptimisticData(rollbackData)
-                            : customOptimisticData;
-                        cache.set(key, optimisticData);
-                        broadcastState(cache, key, optimisticData);
-                    }
-                    if (isFunction(data)) {
-                        // `data` is a function, call it passing current cache value.
-                        try {
-                            data = data(cache.get(key));
-                        }
-                        catch (err) {
-                            // If it throws an error synchronously, we shouldn't update the cache.
-                            error = err;
-                        }
-                    }
-                    if (!(data && isFunction(data.then))) return [3 /*break*/, 2];
-                    return [4 /*yield*/, data.catch(function (err) {
-                            error = err;
-                        })
-                        // Check if other mutations have occurred since we've started this mutation.
-                        // If there's a race we don't update cache or broadcast the change,
-                        // just return the data.
-                    ];
-                case 1:
-                    // This means that the mutation is async, we need to check timestamps to
-                    // avoid race conditions.
-                    data = _c.sent();
-                    // Check if other mutations have occurred since we've started this mutation.
-                    // If there's a race we don't update cache or broadcast the change,
-                    // just return the data.
-                    if (beforeMutationTs !== MUTATION[key][0]) {
-                        if (error)
-                            throw error;
-                        return [2 /*return*/, data];
-                    }
-                    else if (error && hasCustomOptimisticData && rollbackOnError) {
-                        // Rollback. Always populate the cache in this case but without
-                        // transforming the data.
-                        populateCache = true;
-                        data = rollbackData;
-                        cache.set(key, rollbackData);
-                    }
-                    _c.label = 2;
-                case 2:
-                    // If we should write back the cache after request.
-                    if (populateCache) {
-                        if (!error) {
-                            // Transform the result into data.
-                            if (isFunction(populateCache)) {
-                                data = populateCache(data, rollbackData);
-                            }
-                            // Only update cached data if there's no error. Data can be `undefined` here.
-                            cache.set(key, data);
-                        }
-                        // Always update or reset the error.
-                        cache.set(keyInfo, mergeObjects(cache.get(keyInfo), { error: error }));
-                    }
-                    // Reset the timestamp to mark the mutation has ended.
-                    MUTATION[key][1] = getTimestamp();
-                    return [4 /*yield*/, broadcastState(cache, key, data, error, UNDEFINED, revalidate, !!populateCache)
-                        // Throw error or return data
-                    ];
-                case 3:
-                    res = _c.sent();
-                    // Throw error or return data
-                    if (error)
-                        throw error;
-                    return [2 /*return*/, populateCache ? res : data];
+        if (isFunction(data)) {
+            // `data` is a function, call it passing current cache value.
+            try {
+                data = data(committedData);
+            } catch (err) {
+                // If it throws an error synchronously, we shouldn't update the cache.
+                error = err;
+            }
+        }
+        // `data` is a promise/thenable, resolve the final data first.
+        if (data && isFunction(data.then)) {
+            // This means that the mutation is async, we need to check timestamps to
+            // avoid race conditions.
+            data = await data.catch((err)=>{
+                error = err;
+            });
+            // Check if other mutations have occurred since we've started this mutation.
+            // If there's a race we don't update cache or broadcast the change,
+            // just return the data.
+            if (beforeMutationTs !== MUTATION[key][0]) {
+                if (error) throw error;
+                return data;
+            } else if (error && hasOptimisticData && rollbackOnError(error)) {
+                // Rollback. Always populate the cache in this case but without
+                // transforming the data.
+                populateCache = true;
+                data = committedData;
+                // Reset data to be the latest committed data, and clear the `_c` value.
+                set({
+                    data,
+                    _c: UNDEFINED
+                });
+            }
+        }
+        // If we should write back the cache after request.
+        if (populateCache) {
+            if (!error) {
+                // Transform the result into data.
+                if (isFunction(populateCache)) {
+                    data = populateCache(data, committedData);
+                }
+                // Only update cached data if there's no error. Data can be `undefined` here.
+                set({
+                    data,
+                    _c: UNDEFINED
+                });
             }
+        }
+        // Reset the timestamp to mark the mutation has ended.
+        MUTATION[key][1] = getTimestamp();
+        // Update existing SWR Hooks' internal states:
+        const res = await startRevalidate();
+        // The mutation and revalidation are ended, we can clear it since the data is
+        // not an optimistic value anymore.
+        set({
+            _c: UNDEFINED
         });
-    });
-};
+        // Throw error or return data
+        if (error) {
+            if (throwOnError) throw error;
+            return;
+        }
+        return populateCache ? res : data;
+    }
+}
 
-var revalidateAllKeys = function (revalidators, type) {
-    for (var key in revalidators) {
-        if (revalidators[key][0])
-            revalidators[key][0](type);
+const revalidateAllKeys = (revalidators, type)=>{
+    for(const key in revalidators){
+        if (revalidators[key][0]) revalidators[key][0](type);
     }
 };
-var initCache = function (provider, options) {
+const initCache = (provider, options)=>{
     // The global state for a specific provider will be used to deduplicate
-    // requests and store listeners. As well as a mutate function that bound to
+    // requests and store listeners. As well as a mutate function that is bound to
     // the cache.
-    // Provider's global state might be already initialized. Let's try to get the
+    // The provider's global state might be already initialized. Let's try to get the
     // global state associated with the provider first.
     if (!SWRGlobalState.has(provider)) {
-        var opts = mergeObjects(defaultConfigOptions, options);
+        const opts = mergeObjects(defaultConfigOptions, options);
         // If there's no global state bound to the provider, create a new one with the
         // new mutate function.
-        var EVENT_REVALIDATORS = {};
-        var mutate = internalMutate.bind(UNDEFINED, provider);
-        var unmount = noop;
-        // Update the state if it's new, or the provider has been extended.
-        SWRGlobalState.set(provider, [EVENT_REVALIDATORS, {}, {}, {}, mutate]);
+        const EVENT_REVALIDATORS = {};
+        const mutate = internalMutate.bind(UNDEFINED, provider);
+        let unmount = noop;
+        const subscriptions = {};
+        const subscribe = (key, callback)=>{
+            const subs = subscriptions[key] || [];
+            subscriptions[key] = subs;
+            subs.push(callback);
+            return ()=>subs.splice(subs.indexOf(callback), 1);
+        };
+        const setter = (key, value, prev)=>{
+            provider.set(key, value);
+            const subs = subscriptions[key];
+            if (subs) {
+                for(let i = subs.length; i--;){
+                    subs[i](prev, value);
+                }
+            }
+        };
+        const initProvider = ()=>{
+            if (!SWRGlobalState.has(provider)) {
+                // Update the state if it's new, or if the provider has been extended.
+                SWRGlobalState.set(provider, [
+                    EVENT_REVALIDATORS,
+                    {},
+                    {},
+                    {},
+                    mutate,
+                    setter,
+                    subscribe
+                ]);
+                if (!IS_SERVER) {
+                    // When listening to the native events for auto revalidations,
+                    // we intentionally put a delay (setTimeout) here to make sure they are
+                    // fired after immediate JavaScript executions, which can be
+                    // React's state updates.
+                    // This avoids some unnecessary revalidations such as
+                    // https://github.com/vercel/swr/issues/1680.
+                    const releaseFocus = opts.initFocus(setTimeout.bind(UNDEFINED, revalidateAllKeys.bind(UNDEFINED, EVENT_REVALIDATORS, FOCUS_EVENT)));
+                    const releaseReconnect = opts.initReconnect(setTimeout.bind(UNDEFINED, revalidateAllKeys.bind(UNDEFINED, EVENT_REVALIDATORS, RECONNECT_EVENT)));
+                    unmount = ()=>{
+                        releaseFocus && releaseFocus();
+                        releaseReconnect && releaseReconnect();
+                        // When un-mounting, we need to remove the cache provider from the state
+                        // storage too because it's a side-effect. Otherwise, when re-mounting we
+                        // will not re-register those event listeners.
+                        SWRGlobalState.delete(provider);
+                    };
+                }
+            }
+        };
+        initProvider();
         // This is a new provider, we need to initialize it and setup DOM events
         // listeners for `focus` and `reconnect` actions.
-        if (!IS_SERVER) {
-            // When listening to the native events for auto revalidations,
-            // we intentionally put a delay (setTimeout) here to make sure they are
-            // fired after immediate JavaScript executions, which can possibly be
-            // React's state updates.
-            // This avoids some unnecessary revalidations such as
-            // https://github.com/vercel/swr/issues/1680.
-            var releaseFocus_1 = opts.initFocus(setTimeout.bind(UNDEFINED, revalidateAllKeys.bind(UNDEFINED, EVENT_REVALIDATORS, FOCUS_EVENT)));
-            var releaseReconnect_1 = opts.initReconnect(setTimeout.bind(UNDEFINED, revalidateAllKeys.bind(UNDEFINED, EVENT_REVALIDATORS, RECONNECT_EVENT)));
-            unmount = function () {
-                releaseFocus_1 && releaseFocus_1();
-                releaseReconnect_1 && releaseReconnect_1();
-                // When un-mounting, we need to remove the cache provider from the state
-                // storage too because it's a side-effect. Otherwise when re-mounting we
-                // will not re-register those event listeners.
-                SWRGlobalState.delete(provider);
-            };
-        }
         // We might want to inject an extra layer on top of `provider` in the future,
         // such as key serialization, auto GC, etc.
         // For now, it's just a `Map` interface without any modifications.
-        return [provider, mutate, unmount];
+        return [
+            provider,
+            mutate,
+            initProvider,
+            unmount
+        ];
     }
-    return [provider, SWRGlobalState.get(provider)[4]];
+    return [
+        provider,
+        SWRGlobalState.get(provider)[4]
+    ];
 };
 
 // error retry
-var onErrorRetry = function (_, __, config, revalidate, opts) {
-    var maxRetryCount = config.errorRetryCount;
-    var currentRetryCount = opts.retryCount;
+const onErrorRetry = (_, __, config, revalidate, opts)=>{
+    const maxRetryCount = config.errorRetryCount;
+    const currentRetryCount = opts.retryCount;
     // Exponential backoff
-    var timeout = ~~((Math.random() + 0.5) *
-        (1 << (currentRetryCount < 8 ? currentRetryCount : 8))) * config.errorRetryInterval;
+    const timeout = ~~((Math.random() + 0.5) * (1 << (currentRetryCount < 8 ? currentRetryCount : 8))) * config.errorRetryInterval;
     if (!isUndefined(maxRetryCount) && currentRetryCount > maxRetryCount) {
         return;
     }
     setTimeout(revalidate, timeout, opts);
 };
+const compare = (currentData, newData)=>stableHash(currentData) == stableHash(newData);
 // Default cache provider
-var _a = initCache(new Map()), cache = _a[0], mutate = _a[1];
+const [cache, mutate] = initCache(new Map());
 // Default config
-var defaultConfig = mergeObjects({
+const defaultConfig = mergeObjects({
     // events
     onLoadingSlow: noop,
     onSuccess: noop,
     onError: noop,
-    onErrorRetry: onErrorRetry,
+    onErrorRetry,
     onDiscarded: noop,
     // switches
     revalidateOnFocus: true,
@@ -17855,24 +17948,21 @@ var defaultConfig = mergeObjects({
     dedupingInterval: 2 * 1000,
     loadingTimeout: slowConnection ? 5000 : 3000,
     // providers
-    compare: function (currentData, newData) {
-        return stableHash(currentData) == stableHash(newData);
-    },
-    isPaused: function () { return false; },
-    cache: cache,
-    mutate: mutate,
+    compare,
+    isPaused: ()=>false,
+    cache,
+    mutate,
     fallback: {}
-}, 
-// use web preset by default
+}, // use web preset by default
 preset);
 
-var mergeConfigs = function (a, b) {
+const mergeConfigs = (a, b)=>{
     // Need to create a new object to avoid mutating the original here.
-    var v = mergeObjects(a, b);
+    const v = mergeObjects(a, b);
     // If two configs are provided, merge their `use` and `fallback` options.
     if (b) {
-        var u1 = a.use, f1 = a.fallback;
-        var u2 = b.use, f2 = b.fallback;
+        const { use: u1 , fallback: f1  } = a;
+        const { use: u2 , fallback: f2  } = b;
         if (u1 && u2) {
             v.use = u1.concat(u2);
         }
@@ -17883,68 +17973,152 @@ var mergeConfigs = function (a, b) {
     return v;
 };
 
-var SWRConfigContext = (0,external_React_.createContext)({});
-var SWRConfig$1 = function (props) {
-    var value = props.value;
+const SWRConfigContext = (0,external_React_.createContext)({});
+const SWRConfig = (props)=>{
+    const { value  } = props;
+    const parentConfig = (0,external_React_.useContext)(SWRConfigContext);
+    const isFunctionalConfig = isFunction(value);
+    const config = (0,external_React_.useMemo)(()=>isFunctionalConfig ? value(parentConfig) : value, [
+        isFunctionalConfig,
+        parentConfig,
+        value
+    ]);
     // Extend parent context values and middleware.
-    var extendedConfig = mergeConfigs((0,external_React_.useContext)(SWRConfigContext), value);
+    const extendedConfig = (0,external_React_.useMemo)(()=>isFunctionalConfig ? config : mergeConfigs(parentConfig, config), [
+        isFunctionalConfig,
+        parentConfig,
+        config
+    ]);
     // Should not use the inherited provider.
-    var provider = value && value.provider;
+    const provider = config && config.provider;
     // Use a lazy initialized state to create the cache on first access.
-    var cacheContext = (0,external_React_.useState)(function () {
-        return provider
-            ? initCache(provider(extendedConfig.cache || cache), value)
-            : UNDEFINED;
-    })[0];
+    const [cacheContext] = (0,external_React_.useState)(()=>provider ? initCache(provider(extendedConfig.cache || cache), config) : UNDEFINED);
     // Override the cache if a new provider is given.
     if (cacheContext) {
         extendedConfig.cache = cacheContext[0];
         extendedConfig.mutate = cacheContext[1];
     }
     // Unsubscribe events.
-    useIsomorphicLayoutEffect(function () { return (cacheContext ? cacheContext[2] : UNDEFINED); }, []);
+    useIsomorphicLayoutEffect(()=>{
+        if (cacheContext) {
+            cacheContext[2] && cacheContext[2]();
+            return cacheContext[3];
+        }
+    }, []);
     return (0,external_React_.createElement)(SWRConfigContext.Provider, mergeObjects(props, {
         value: extendedConfig
     }));
 };
 
+// @ts-expect-error
+const enableDevtools = isWindowDefined && window.__SWR_DEVTOOLS_USE__;
+const use = enableDevtools ? window.__SWR_DEVTOOLS_USE__ : [];
+const setupDevTools = ()=>{
+    if (enableDevtools) {
+        // @ts-expect-error
+        window.__SWR_DEVTOOLS_REACT__ = external_React_;
+    }
+};
+
+const normalize = (args)=>{
+    return isFunction(args[1]) ? [
+        args[0],
+        args[1],
+        args[2] || {}
+    ] : [
+        args[0],
+        null,
+        (args[1] === null ? args[2] : args[1]) || {}
+    ];
+};
+
+const useSWRConfig = ()=>{
+    return mergeObjects(defaultConfig, (0,external_React_.useContext)(SWRConfigContext));
+};
+
+const preload = (key_, fetcher)=>{
+    const key = dist_serialize(key_)[0];
+    const [, , , PRELOAD] = SWRGlobalState.get(cache);
+    // Prevent preload to be called multiple times before used.
+    if (PRELOAD[key]) return PRELOAD[key];
+    const req = fetcher(key_);
+    PRELOAD[key] = req;
+    return req;
+};
+const middleware = (useSWRNext)=>(key_, fetcher_, config)=>{
+        // fetcher might be a sync function, so this should not be an async function
+        const fetcher = fetcher_ && ((...args)=>{
+            const key = dist_serialize(key_)[0];
+            const [, , , PRELOAD] = SWRGlobalState.get(cache);
+            const req = PRELOAD[key];
+            if (req) {
+                delete PRELOAD[key];
+                return req;
+            }
+            return fetcher_(...args);
+        });
+        return useSWRNext(key_, fetcher, config);
+    };
+
+const BUILT_IN_MIDDLEWARE = use.concat(middleware);
+
+// It's tricky to pass generic types as parameters, so we just directly override
+// the types here.
+const withArgs = (hook)=>{
+    return function useSWRArgs(...args) {
+        // Get the default and inherited configuration.
+        const fallbackConfig = useSWRConfig();
+        // Normalize arguments.
+        const [key, fn, _config] = normalize(args);
+        // Merge configurations.
+        const config = mergeConfigs(fallbackConfig, _config);
+        // Apply middleware
+        let next = hook;
+        const { use  } = config;
+        const middleware = (use || []).concat(BUILT_IN_MIDDLEWARE);
+        for(let i = middleware.length; i--;){
+            next = middleware[i](next);
+        }
+        return next(key, fn || config.fetcher || null, config);
+    };
+};
+
 /**
  * An implementation of state with dependency-tracking.
- */
-var useStateWithDeps = function (state, unmountedRef) {
-    var rerender = (0,external_React_.useState)({})[1];
-    var stateRef = (0,external_React_.useRef)(state);
-    // If a state property (data, error or isValidating) is accessed by the render
+ */ const useStateWithDeps = (state)=>{
+    const rerender = useState({})[1];
+    const unmountedRef = useRef(false);
+    const stateRef = useRef(state);
+    // If a state property (data, error, or isValidating) is accessed by the render
     // function, we mark the property as a dependency so if it is updated again
     // in the future, we trigger a rerender.
     // This is also known as dependency-tracking.
-    var stateDependenciesRef = (0,external_React_.useRef)({
+    const stateDependenciesRef = useRef({
         data: false,
         error: false,
         isValidating: false
     });
     /**
-     * @param payload To change stateRef, pass the values explicitly to setState:
-     * @example
-     * ```js
-     * setState({
-     *   isValidating: false
-     *   data: newData // set data to newData
-     *   error: undefined // set error to undefined
-     * })
-     *
-     * setState({
-     *   isValidating: false
-     *   data: undefined // set data to undefined
-     *   error: err // set error to err
-     * })
-     * ```
-     */
-    var setState = (0,external_React_.useCallback)(function (payload) {
-        var shouldRerender = false;
-        var currentState = stateRef.current;
-        for (var _ in payload) {
-            var k = _;
+   * @param payload To change stateRef, pass the values explicitly to setState:
+   * @example
+   * ```js
+   * setState({
+   *   isValidating: false
+   *   data: newData // set data to newData
+   *   error: undefined // set error to undefined
+   * })
+   *
+   * setState({
+   *   isValidating: false
+   *   data: undefined // set data to undefined
+   *   error: err // set error to err
+   * })
+   * ```
+   */ const setState = useCallback((payload)=>{
+        let shouldRerender = false;
+        const currentState = stateRef.current;
+        for(const _ in payload){
+            const k = _;
             // If the property has changed, update the state and mark rerender as
             // needed.
             if (currentState[k] !== payload[k]) {
@@ -17957,62 +18131,35 @@ var useStateWithDeps = function (state, unmountedRef) {
             }
         }
         if (shouldRerender && !unmountedRef.current) {
-            rerender({});
+            if (IS_REACT_LEGACY) {
+                rerender({});
+            } else {
+                React.startTransition(()=>rerender({}));
+            }
         }
-    }, 
-    // config.suspense isn't allowed to change during the lifecycle
+    }, // config.suspense isn't allowed to change during the lifecycle
     // eslint-disable-next-line react-hooks/exhaustive-deps
     []);
-    // Always update the state reference.
-    useIsomorphicLayoutEffect(function () {
-        stateRef.current = state;
+    useIsomorphicLayoutEffect(()=>{
+        unmountedRef.current = false;
+        return ()=>{
+            unmountedRef.current = true;
+        };
     });
-    return [stateRef, stateDependenciesRef.current, setState];
-};
-
-var normalize = function (args) {
-    return isFunction(args[1])
-        ? [args[0], args[1], args[2] || {}]
-        : [args[0], null, (args[1] === null ? args[2] : args[1]) || {}];
-};
-
-var useSWRConfig = function () {
-    return mergeObjects(defaultConfig, (0,external_React_.useContext)(SWRConfigContext));
-};
-
-// It's tricky to pass generic types as parameters, so we just directly override
-// the types here.
-var withArgs = function (hook) {
-    return function useSWRArgs() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        // Get the default and inherited configuration.
-        var fallbackConfig = useSWRConfig();
-        // Normalize arguments.
-        var _a = normalize(args), key = _a[0], fn = _a[1], _config = _a[2];
-        // Merge configurations.
-        var config = mergeConfigs(fallbackConfig, _config);
-        // Apply middleware
-        var next = hook;
-        var use = config.use;
-        if (use) {
-            for (var i = use.length; i-- > 0;) {
-                next = use[i](next);
-            }
-        }
-        return next(key, fn || config.fetcher, config);
-    };
+    return [
+        stateRef,
+        stateDependenciesRef.current,
+        setState
+    ];
 };
 
 // Add a callback function to a list of keyed callback functions and return
 // the unsubscribe function.
-var subscribeCallback = function (key, callbacks, callback) {
-    var keyedRevalidators = callbacks[key] || (callbacks[key] = []);
+const subscribeCallback = (key, callbacks, callback)=>{
+    const keyedRevalidators = callbacks[key] || (callbacks[key] = []);
     keyedRevalidators.push(callback);
-    return function () {
-        var index = keyedRevalidators.indexOf(callback);
+    return ()=>{
+        const index = keyedRevalidators.indexOf(callback);
         if (index >= 0) {
             // O(1): faster than splice
             keyedRevalidators[index] = keyedRevalidators[keyedRevalidators.length - 1];
@@ -18021,247 +18168,308 @@ var subscribeCallback = function (key, callbacks, callback) {
     };
 };
 
-var WITH_DEDUPE = { dedupe: true };
-var useSWRHandler = function (_key, fetcher, config) {
-    var cache = config.cache, compare = config.compare, fallbackData = config.fallbackData, suspense = config.suspense, revalidateOnMount = config.revalidateOnMount, refreshInterval = config.refreshInterval, refreshWhenHidden = config.refreshWhenHidden, refreshWhenOffline = config.refreshWhenOffline;
-    var _a = SWRGlobalState.get(cache), EVENT_REVALIDATORS = _a[0], STATE_UPDATERS = _a[1], MUTATION = _a[2], FETCH = _a[3];
+// Create a custom hook with a middleware
+const withMiddleware = (useSWR, middleware)=>{
+    return (...args)=>{
+        const [key, fn, config] = normalize(args);
+        const uses = (config.use || []).concat(middleware);
+        return useSWR(key, fn, {
+            ...config,
+            use: uses
+        });
+    };
+};
+
+setupDevTools();
+
+
+
+;// CONCATENATED MODULE: ./node_modules/swr/core/dist/index.mjs
+
+
+
+
+
+const WITH_DEDUPE = {
+    dedupe: true
+};
+const useSWRHandler = (_key, fetcher, config)=>{
+    const { cache , compare , suspense , fallbackData , revalidateOnMount , refreshInterval , refreshWhenHidden , refreshWhenOffline , keepPreviousData  } = config;
+    const [EVENT_REVALIDATORS, MUTATION, FETCH] = SWRGlobalState.get(cache);
     // `key` is the identifier of the SWR `data` state, `keyInfo` holds extra
     // states such as `error` and `isValidating` inside,
     // all of them are derived from `_key`.
-    // `fnArgs` is an array of arguments parsed from the key, which will be passed
+    // `fnArg` is the argument/arguments parsed from the key, which will be passed
     // to the fetcher.
-    var _b = dist_serialize(_key), key = _b[0], fnArgs = _b[1], keyInfo = _b[2];
+    const [key, fnArg] = dist_serialize(_key);
     // If it's the initial render of this hook.
-    var initialMountedRef = (0,external_React_.useRef)(false);
+    const initialMountedRef = (0,external_React_.useRef)(false);
     // If the hook is unmounted already. This will be used to prevent some effects
     // to be called after unmounting.
-    var unmountedRef = (0,external_React_.useRef)(false);
+    const unmountedRef = (0,external_React_.useRef)(false);
     // Refs to keep the key and config.
-    var keyRef = (0,external_React_.useRef)(key);
-    var fetcherRef = (0,external_React_.useRef)(fetcher);
-    var configRef = (0,external_React_.useRef)(config);
-    var getConfig = function () { return configRef.current; };
-    var isActive = function () { return getConfig().isVisible() && getConfig().isOnline(); };
-    var patchFetchInfo = function (info) {
-        return cache.set(keyInfo, mergeObjects(cache.get(keyInfo), info));
+    const keyRef = (0,external_React_.useRef)(key);
+    const fetcherRef = (0,external_React_.useRef)(fetcher);
+    const configRef = (0,external_React_.useRef)(config);
+    const getConfig = ()=>configRef.current;
+    const isActive = ()=>getConfig().isVisible() && getConfig().isOnline();
+    const [getCache, setCache, subscribeCache] = createCacheHelper(cache, key);
+    const stateDependencies = (0,external_React_.useRef)({}).current;
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    const fallback = isUndefined(fallbackData) ? config.fallback[key] : fallbackData;
+    const isEqual = (prev, current)=>{
+        let equal = true;
+        for(const _ in stateDependencies){
+            const t = _;
+            if (!compare(current[t], prev[t])) {
+                if (t === 'data' && isUndefined(prev[t])) {
+                    if (!compare(current[t], returnedData)) {
+                        equal = false;
+                    }
+                } else {
+                    equal = false;
+                }
+            }
+        }
+        return equal;
     };
+    const getSnapshot = (0,external_React_.useMemo)(()=>{
+        const shouldStartRequest = (()=>{
+            if (!key) return false;
+            if (!fetcher) return false;
+            // If `revalidateOnMount` is set, we take the value directly.
+            if (!isUndefined(revalidateOnMount)) return revalidateOnMount;
+            // If it's paused, we skip revalidation.
+            if (getConfig().isPaused()) return false;
+            if (suspense) return false;
+            return true;
+        })();
+        const getSelectedCache = ()=>{
+            const state = getCache();
+            // We only select the needed fields from the state.
+            const snapshot = mergeObjects(state);
+            delete snapshot._k;
+            if (!shouldStartRequest) {
+                return snapshot;
+            }
+            return {
+                isValidating: true,
+                isLoading: true,
+                ...snapshot
+            };
+        };
+        let memorizedSnapshot = getSelectedCache();
+        return ()=>{
+            const snapshot = getSelectedCache();
+            return isEqual(snapshot, memorizedSnapshot) ? memorizedSnapshot : memorizedSnapshot = snapshot;
+        };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [
+        cache,
+        key
+    ]);
     // Get the current state that SWR should return.
-    var cached = cache.get(key);
-    var fallback = isUndefined(fallbackData)
-        ? config.fallback[key]
-        : fallbackData;
-    var data = isUndefined(cached) ? fallback : cached;
-    var info = cache.get(keyInfo) || {};
-    var error = info.error;
-    var isInitialMount = !initialMountedRef.current;
+    const cached = (0,shim.useSyncExternalStore)((0,external_React_.useCallback)((callback)=>subscribeCache(key, (prev, current)=>{
+            if (!isEqual(prev, current)) callback();
+        }), // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+        cache,
+        key
+    ]), getSnapshot, getSnapshot);
+    const isInitialMount = !initialMountedRef.current;
+    const cachedData = cached.data;
+    const data = isUndefined(cachedData) ? fallback : cachedData;
+    const error = cached.error;
+    // Use a ref to store previously returned data. Use the initial data as its initial value.
+    const laggyDataRef = (0,external_React_.useRef)(data);
+    const returnedData = keepPreviousData ? isUndefined(cachedData) ? laggyDataRef.current : cachedData : data;
     // - Suspense mode and there's stale data for the initial render.
     // - Not suspense mode and there is no fallback data and `revalidateIfStale` is enabled.
     // - `revalidateIfStale` is enabled but `data` is not defined.
-    var shouldRevalidate = function () {
+    const shouldDoInitialRevalidation = (()=>{
         // If `revalidateOnMount` is set, we take the value directly.
-        if (isInitialMount && !isUndefined(revalidateOnMount))
-            return revalidateOnMount;
+        if (isInitialMount && !isUndefined(revalidateOnMount)) return revalidateOnMount;
         // If it's paused, we skip revalidation.
-        if (getConfig().isPaused())
-            return false;
+        if (getConfig().isPaused()) return false;
         // Under suspense mode, it will always fetch on render if there is no
-        // stale data so no need to revalidate immediately on mount again.
+        // stale data so no need to revalidate immediately mount it again.
         // If data exists, only revalidate if `revalidateIfStale` is true.
-        if (suspense)
-            return isUndefined(data) ? false : config.revalidateIfStale;
-        // If there is no stale data, we need to revalidate on mount;
+        if (suspense) return isUndefined(data) ? false : config.revalidateIfStale;
+        // If there is no stale data, we need to revalidate when mount;
         // If `revalidateIfStale` is set to true, we will always revalidate.
         return isUndefined(data) || config.revalidateIfStale;
-    };
-    // Resolve the current validating state.
-    var resolveValidating = function () {
-        if (!key || !fetcher)
-            return false;
-        if (info.isValidating)
-            return true;
-        // If it's not mounted yet and it should revalidate on mount, revalidate.
-        return isInitialMount && shouldRevalidate();
-    };
-    var isValidating = resolveValidating();
-    var _c = useStateWithDeps({
-        data: data,
-        error: error,
-        isValidating: isValidating
-    }, unmountedRef), stateRef = _c[0], stateDependencies = _c[1], setState = _c[2];
+    })();
+    // Resolve the default validating state:
+    // If it's able to validate, and it should revalidate when mount, this will be true.
+    const defaultValidatingState = !!(key && fetcher && isInitialMount && shouldDoInitialRevalidation);
+    const isValidating = isUndefined(cached.isValidating) ? defaultValidatingState : cached.isValidating;
+    const isLoading = isUndefined(cached.isLoading) ? defaultValidatingState : cached.isLoading;
     // The revalidation function is a carefully crafted wrapper of the original
     // `fetcher`, to correctly handle the many edge cases.
-    var revalidate = (0,external_React_.useCallback)(function (revalidateOpts) { return __awaiter(void 0, void 0, void 0, function () {
-        var currentFetcher, newData, startAt, loading, opts, shouldStartNewRequest, isCurrentKeyMounted, cleanupState, newState, finishRequestAndUpdateState, mutationInfo, err_1;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    currentFetcher = fetcherRef.current;
-                    if (!key ||
-                        !currentFetcher ||
-                        unmountedRef.current ||
-                        getConfig().isPaused()) {
-                        return [2 /*return*/, false];
-                    }
-                    loading = true;
-                    opts = revalidateOpts || {};
-                    shouldStartNewRequest = !FETCH[key] || !opts.dedupe;
-                    isCurrentKeyMounted = function () {
-                        return !unmountedRef.current &&
-                            key === keyRef.current &&
-                            initialMountedRef.current;
-                    };
-                    cleanupState = function () {
-                        // Check if it's still the same request before deleting.
-                        var requestInfo = FETCH[key];
-                        if (requestInfo && requestInfo[1] === startAt) {
-                            delete FETCH[key];
-                        }
-                    };
-                    newState = { isValidating: false };
-                    finishRequestAndUpdateState = function () {
-                        patchFetchInfo({ isValidating: false });
-                        // We can only set state if it's safe (still mounted with the same key).
-                        if (isCurrentKeyMounted()) {
-                            setState(newState);
-                        }
-                    };
-                    // Start fetching. Change the `isValidating` state, update the cache.
-                    patchFetchInfo({
-                        isValidating: true
-                    });
-                    setState({ isValidating: true });
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 3, , 4]);
-                    if (shouldStartNewRequest) {
-                        // Tell all other hooks to change the `isValidating` state.
-                        broadcastState(cache, key, stateRef.current.data, stateRef.current.error, true);
-                        // If no cache being rendered currently (it shows a blank page),
-                        // we trigger the loading slow event.
-                        if (config.loadingTimeout && !cache.get(key)) {
-                            setTimeout(function () {
-                                if (loading && isCurrentKeyMounted()) {
-                                    getConfig().onLoadingSlow(key, config);
-                                }
-                            }, config.loadingTimeout);
-                        }
-                        // Start the request and save the timestamp.
-                        FETCH[key] = [currentFetcher.apply(void 0, fnArgs), getTimestamp()];
-                    }
-                    _a = FETCH[key], newData = _a[0], startAt = _a[1];
-                    return [4 /*yield*/, newData];
-                case 2:
-                    newData = _b.sent();
-                    if (shouldStartNewRequest) {
-                        // If the request isn't interrupted, clean it up after the
-                        // deduplication interval.
-                        setTimeout(cleanupState, config.dedupingInterval);
-                    }
-                    // If there're other ongoing request(s), started after the current one,
-                    // we need to ignore the current one to avoid possible race conditions:
-                    //   req1------------------>res1        (current one)
-                    //        req2---------------->res2
-                    // the request that fired later will always be kept.
-                    // The timestamp maybe be `undefined` or a number
-                    if (!FETCH[key] || FETCH[key][1] !== startAt) {
-                        if (shouldStartNewRequest) {
-                            if (isCurrentKeyMounted()) {
-                                getConfig().onDiscarded(key);
-                            }
-                        }
-                        return [2 /*return*/, false];
-                    }
-                    // Clear error.
-                    patchFetchInfo({
-                        error: UNDEFINED
-                    });
-                    newState.error = UNDEFINED;
-                    mutationInfo = MUTATION[key];
-                    if (!isUndefined(mutationInfo) &&
-                        // case 1
-                        (startAt <= mutationInfo[0] ||
-                            // case 2
-                            startAt <= mutationInfo[1] ||
-                            // case 3
-                            mutationInfo[1] === 0)) {
-                        finishRequestAndUpdateState();
-                        if (shouldStartNewRequest) {
-                            if (isCurrentKeyMounted()) {
-                                getConfig().onDiscarded(key);
-                            }
+    const revalidate = (0,external_React_.useCallback)(async (revalidateOpts)=>{
+        const currentFetcher = fetcherRef.current;
+        if (!key || !currentFetcher || unmountedRef.current || getConfig().isPaused()) {
+            return false;
+        }
+        let newData;
+        let startAt;
+        let loading = true;
+        const opts = revalidateOpts || {};
+        // If there is no ongoing concurrent request, or `dedupe` is not set, a
+        // new request should be initiated.
+        const shouldStartNewRequest = !FETCH[key] || !opts.dedupe;
+        /*
+         For React 17
+         Do unmount check for calls:
+         If key has changed during the revalidation, or the component has been
+         unmounted, old dispatch and old event callbacks should not take any
+         effect
+
+        For React 18
+        only check if key has changed
+        https://github.com/reactwg/react-18/discussions/82
+      */ const callbackSafeguard = ()=>{
+            if (IS_REACT_LEGACY) {
+                return !unmountedRef.current && key === keyRef.current && initialMountedRef.current;
+            }
+            return key === keyRef.current;
+        };
+        // The final state object when the request finishes.
+        const finalState = {
+            isValidating: false,
+            isLoading: false
+        };
+        const finishRequestAndUpdateState = ()=>{
+            setCache(finalState);
+        };
+        const cleanupState = ()=>{
+            // Check if it's still the same request before deleting it.
+            const requestInfo = FETCH[key];
+            if (requestInfo && requestInfo[1] === startAt) {
+                delete FETCH[key];
+            }
+        };
+        // Start fetching. Change the `isValidating` state, update the cache.
+        const initialState = {
+            isValidating: true
+        };
+        // It is in the `isLoading` state, if and only if there is no cached data.
+        // This bypasses fallback data and laggy data.
+        if (isUndefined(getCache().data)) {
+            initialState.isLoading = true;
+        }
+        try {
+            if (shouldStartNewRequest) {
+                setCache(initialState);
+                // If no cache is being rendered currently (it shows a blank page),
+                // we trigger the loading slow event.
+                if (config.loadingTimeout && isUndefined(getCache().data)) {
+                    setTimeout(()=>{
+                        if (loading && callbackSafeguard()) {
+                            getConfig().onLoadingSlow(key, config);
                         }
-                        return [2 /*return*/, false];
-                    }
-                    // Deep compare with latest state to avoid extra re-renders.
-                    // For local state, compare and assign.
-                    if (!compare(stateRef.current.data, newData)) {
-                        newState.data = newData;
-                    }
-                    else {
-                        // data and newData are deeply equal
-                        // it should be safe to broadcast the stale data
-                        newState.data = stateRef.current.data;
-                        // At the end of this function, `brocastState` invokes the `onStateUpdate` function,
-                        // which takes care of avoiding the re-render
-                    }
-                    // For global state, it's possible that the key has changed.
-                    // https://github.com/vercel/swr/pull/1058
-                    if (!compare(cache.get(key), newData)) {
-                        cache.set(key, newData);
+                    }, config.loadingTimeout);
+                }
+                // Start the request and save the timestamp.
+                // Key must be truthy if entering here.
+                FETCH[key] = [
+                    currentFetcher(fnArg),
+                    getTimestamp()
+                ];
+            }
+            [newData, startAt] = FETCH[key];
+            newData = await newData;
+            if (shouldStartNewRequest) {
+                // If the request isn't interrupted, clean it up after the
+                // deduplication interval.
+                setTimeout(cleanupState, config.dedupingInterval);
+            }
+            // If there're other ongoing request(s), started after the current one,
+            // we need to ignore the current one to avoid possible race conditions:
+            //   req1------------------>res1        (current one)
+            //        req2---------------->res2
+            // the request that fired later will always be kept.
+            // The timestamp maybe be `undefined` or a number
+            if (!FETCH[key] || FETCH[key][1] !== startAt) {
+                if (shouldStartNewRequest) {
+                    if (callbackSafeguard()) {
+                        getConfig().onDiscarded(key);
                     }
-                    // Trigger the successful callback if it's the original request.
-                    if (shouldStartNewRequest) {
-                        if (isCurrentKeyMounted()) {
-                            getConfig().onSuccess(newData, key, config);
-                        }
+                }
+                return false;
+            }
+            // Clear error.
+            finalState.error = UNDEFINED;
+            // If there're other mutations(s), that overlapped with the current revalidation:
+            // case 1:
+            //   req------------------>res
+            //       mutate------>end
+            // case 2:
+            //         req------------>res
+            //   mutate------>end
+            // case 3:
+            //   req------------------>res
+            //       mutate-------...---------->
+            // we have to ignore the revalidation result (res) because it's no longer fresh.
+            // meanwhile, a new revalidation should be triggered when the mutation ends.
+            const mutationInfo = MUTATION[key];
+            if (!isUndefined(mutationInfo) && // case 1
+            (startAt <= mutationInfo[0] || // case 2
+            startAt <= mutationInfo[1] || // case 3
+            mutationInfo[1] === 0)) {
+                finishRequestAndUpdateState();
+                if (shouldStartNewRequest) {
+                    if (callbackSafeguard()) {
+                        getConfig().onDiscarded(key);
                     }
-                    return [3 /*break*/, 4];
-                case 3:
-                    err_1 = _b.sent();
-                    cleanupState();
-                    // Not paused, we continue handling the error. Otherwise discard it.
-                    if (!getConfig().isPaused()) {
-                        // Get a new error, don't use deep comparison for errors.
-                        patchFetchInfo({ error: err_1 });
-                        newState.error = err_1;
-                        // Error event and retry logic. Only for the actual request, not
-                        // deduped ones.
-                        if (shouldStartNewRequest && isCurrentKeyMounted()) {
-                            getConfig().onError(err_1, key, config);
-                            if ((typeof config.shouldRetryOnError === 'boolean' &&
-                                config.shouldRetryOnError) ||
-                                (isFunction(config.shouldRetryOnError) &&
-                                    config.shouldRetryOnError(err_1))) {
-                                // When retrying, dedupe is always enabled
-                                if (isActive()) {
-                                    // If it's active, stop. It will auto revalidate when refocusing
-                                    // or reconnecting.
-                                    getConfig().onErrorRetry(err_1, key, config, revalidate, {
-                                        retryCount: (opts.retryCount || 0) + 1,
-                                        dedupe: true
-                                    });
-                                }
-                            }
+                }
+                return false;
+            }
+            // Deep compare with the latest state to avoid extra re-renders.
+            // For local state, compare and assign.
+            const cacheData = getCache().data;
+            // Since the compare fn could be custom fn
+            // cacheData might be different from newData even when compare fn returns True
+            finalState.data = compare(cacheData, newData) ? cacheData : newData;
+            // Trigger the successful callback if it's the original request.
+            if (shouldStartNewRequest) {
+                if (callbackSafeguard()) {
+                    getConfig().onSuccess(newData, key, config);
+                }
+            }
+        } catch (err) {
+            cleanupState();
+            const currentConfig = getConfig();
+            const { shouldRetryOnError  } = currentConfig;
+            // Not paused, we continue handling the error. Otherwise, discard it.
+            if (!currentConfig.isPaused()) {
+                // Get a new error, don't use deep comparison for errors.
+                finalState.error = err;
+                // Error event and retry logic. Only for the actual request, not
+                // deduped ones.
+                if (shouldStartNewRequest && callbackSafeguard()) {
+                    currentConfig.onError(err, key, currentConfig);
+                    if (shouldRetryOnError === true || isFunction(shouldRetryOnError) && shouldRetryOnError(err)) {
+                        if (isActive()) {
+                            // If it's inactive, stop. It will auto-revalidate when
+                            // refocusing or reconnecting.
+                            // When retrying, deduplication is always enabled.
+                            currentConfig.onErrorRetry(err, key, currentConfig, revalidate, {
+                                retryCount: (opts.retryCount || 0) + 1,
+                                dedupe: true
+                            });
                         }
                     }
-                    return [3 /*break*/, 4];
-                case 4:
-                    // Mark loading as stopped.
-                    loading = false;
-                    // Update the current hook's state.
-                    finishRequestAndUpdateState();
-                    // Here is the source of the request, need to tell all other hooks to
-                    // update their states.
-                    if (isCurrentKeyMounted() && shouldStartNewRequest) {
-                        broadcastState(cache, key, newState.data, newState.error, false);
-                    }
-                    return [2 /*return*/, true];
+                }
             }
-        });
-    }); }, 
-    // `setState` is immutable, and `eventsCallback`, `fnArgs`, `keyInfo`,
-    // and `keyValidating` are depending on `key`, so we can exclude them from
+        }
+        // Mark loading as stopped.
+        loading = false;
+        // Update the current hook's state.
+        finishRequestAndUpdateState();
+        return true;
+    }, // `setState` is immutable, and `eventsCallback`, `fnArg`, and
+    // `keyValidating` are depending on `key`, so we can exclude them from
     // the deps array.
     //
     // FIXME:
@@ -18271,110 +18479,87 @@ var useSWRHandler = function (_key, fetcher, config) {
     // So we omit the values from the deps array
     // even though it might cause unexpected behaviors.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [key]);
-    // Similar to the global mutate, but bound to the current cache and key.
+    [
+        key,
+        cache
+    ]);
+    // Similar to the global mutate but bound to the current cache and key.
     // `cache` isn't allowed to change during the lifecycle.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    var boundMutate = (0,external_React_.useCallback)(
-    // By using `bind` we don't need to modify the size of the rest arguments.
-    // Due to https://github.com/microsoft/TypeScript/issues/37181, we have to
-    // cast it to any for now.
-    internalMutate.bind(UNDEFINED, cache, function () { return keyRef.current; }), 
-    // eslint-disable-next-line react-hooks/exhaustive-deps
+    const boundMutate = (0,external_React_.useCallback)(// Use callback to make sure `keyRef.current` returns latest result every time
+    (...args)=>{
+        return internalMutate(cache, keyRef.current, ...args);
+    }, // eslint-disable-next-line react-hooks/exhaustive-deps
     []);
-    // Always update fetcher and config refs.
-    useIsomorphicLayoutEffect(function () {
+    // The logic for updating refs.
+    useIsomorphicLayoutEffect(()=>{
         fetcherRef.current = fetcher;
         configRef.current = config;
+        // Handle laggy data updates. If there's cached data of the current key,
+        // it'll be the correct reference.
+        if (!isUndefined(cachedData)) {
+            laggyDataRef.current = cachedData;
+        }
     });
     // After mounted or key changed.
-    useIsomorphicLayoutEffect(function () {
-        if (!key)
-            return;
-        var keyChanged = key !== keyRef.current;
-        var softRevalidate = revalidate.bind(UNDEFINED, WITH_DEDUPE);
-        // Expose state updater to global event listeners. So we can update hook's
-        // internal state from the outside.
-        var onStateUpdate = function (updatedData, updatedError, updatedIsValidating) {
-            setState(mergeObjects({
-                error: updatedError,
-                isValidating: updatedIsValidating
-            }, 
-            // Since `setState` only shallowly compares states, we do a deep
-            // comparison here.
-            compare(stateRef.current.data, updatedData)
-                ? UNDEFINED
-                : {
-                    data: updatedData
-                }));
-        };
+    useIsomorphicLayoutEffect(()=>{
+        if (!key) return;
+        const softRevalidate = revalidate.bind(UNDEFINED, WITH_DEDUPE);
         // Expose revalidators to global event listeners. So we can trigger
         // revalidation from the outside.
-        var nextFocusRevalidatedAt = 0;
-        var onRevalidate = function (type) {
-            if (type == FOCUS_EVENT) {
-                var now = Date.now();
-                if (getConfig().revalidateOnFocus &&
-                    now > nextFocusRevalidatedAt &&
-                    isActive()) {
+        let nextFocusRevalidatedAt = 0;
+        const onRevalidate = (type)=>{
+            if (type == constants.FOCUS_EVENT) {
+                const now = Date.now();
+                if (getConfig().revalidateOnFocus && now > nextFocusRevalidatedAt && isActive()) {
                     nextFocusRevalidatedAt = now + getConfig().focusThrottleInterval;
                     softRevalidate();
                 }
-            }
-            else if (type == RECONNECT_EVENT) {
+            } else if (type == constants.RECONNECT_EVENT) {
                 if (getConfig().revalidateOnReconnect && isActive()) {
                     softRevalidate();
                 }
-            }
-            else if (type == MUTATE_EVENT) {
+            } else if (type == constants.MUTATE_EVENT) {
                 return revalidate();
             }
             return;
         };
-        var unsubUpdate = subscribeCallback(key, STATE_UPDATERS, onStateUpdate);
-        var unsubEvents = subscribeCallback(key, EVENT_REVALIDATORS, onRevalidate);
+        const unsubEvents = subscribeCallback(key, EVENT_REVALIDATORS, onRevalidate);
         // Mark the component as mounted and update corresponding refs.
         unmountedRef.current = false;
         keyRef.current = key;
         initialMountedRef.current = true;
-        // When `key` updates, reset the state to the initial value
-        // and trigger a rerender if necessary.
-        if (keyChanged) {
-            setState({
-                data: data,
-                error: error,
-                isValidating: isValidating
-            });
-        }
+        // Keep the original key in the cache.
+        setCache({
+            _k: fnArg
+        });
         // Trigger a revalidation.
-        if (shouldRevalidate()) {
+        if (shouldDoInitialRevalidation) {
             if (isUndefined(data) || IS_SERVER) {
                 // Revalidate immediately.
                 softRevalidate();
-            }
-            else {
+            } else {
                 // Delay the revalidate if we have data to return so we won't block
                 // rendering.
                 rAF(softRevalidate);
             }
         }
-        return function () {
+        return ()=>{
             // Mark it as unmounted.
             unmountedRef.current = true;
-            unsubUpdate();
             unsubEvents();
         };
-    }, [key, revalidate]);
+    }, [
+        key
+    ]);
     // Polling
-    useIsomorphicLayoutEffect(function () {
-        var timer;
+    useIsomorphicLayoutEffect(()=>{
+        let timer;
         function next() {
             // Use the passed interval
             // ...or invoke the function with the updated data to get the interval
-            var interval = isFunction(refreshInterval)
-                ? refreshInterval(data)
-                : refreshInterval;
-            // We only start next interval if `refreshInterval` is not 0, and:
+            const interval = isFunction(refreshInterval) ? refreshInterval(data) : refreshInterval;
+            // We only start the next interval if `refreshInterval` is not 0, and:
             // - `force` is true, which is the start of polling
             // - or `timer` is not 0, which means the effect wasn't canceled
             if (interval && timer !== -1) {
@@ -18383,32 +18568,40 @@ var useSWRHandler = function (_key, fetcher, config) {
         }
         function execute() {
             // Check if it's OK to execute:
-            // Only revalidate when the page is visible, online and not errored.
-            if (!stateRef.current.error &&
-                (refreshWhenHidden || getConfig().isVisible()) &&
-                (refreshWhenOffline || getConfig().isOnline())) {
+            // Only revalidate when the page is visible, online, and not errored.
+            if (!getCache().error && (refreshWhenHidden || getConfig().isVisible()) && (refreshWhenOffline || getConfig().isOnline())) {
                 revalidate(WITH_DEDUPE).then(next);
-            }
-            else {
-                // Schedule next interval to check again.
+            } else {
+                // Schedule the next interval to check again.
                 next();
             }
         }
         next();
-        return function () {
+        return ()=>{
             if (timer) {
                 clearTimeout(timer);
                 timer = -1;
             }
         };
-    }, [refreshInterval, refreshWhenHidden, refreshWhenOffline, revalidate]);
+    }, [
+        refreshInterval,
+        refreshWhenHidden,
+        refreshWhenOffline,
+        key
+    ]);
     // Display debug info in React DevTools.
-    (0,external_React_.useDebugValue)(data);
+    (0,external_React_.useDebugValue)(returnedData);
     // In Suspense mode, we can't return the empty `data` state.
-    // If there is `error`, the `error` needs to be thrown to the error boundary.
+    // If there is an `error`, the `error` needs to be thrown to the error boundary.
     // If there is no `error`, the `revalidation` promise needs to be thrown to
     // the suspense boundary.
     if (suspense && isUndefined(data) && key) {
+        // SWR should throw when trying to use Suspense on the server with React 18,
+        // without providing any initial data. See:
+        // https://github.com/vercel/swr/issues/1832
+        if (!IS_REACT_LEGACY && IS_SERVER) {
+            throw new Error('Fallback data is required when using suspense in SSR.');
+        }
         // Always update fetcher and config refs even with the Suspense mode.
         fetcherRef.current = fetcher;
         configRef.current = config;
@@ -18417,25 +18610,43 @@ var useSWRHandler = function (_key, fetcher, config) {
     }
     return {
         mutate: boundMutate,
-        get data() {
+        get data () {
             stateDependencies.data = true;
-            return data;
+            return returnedData;
         },
-        get error() {
+        get error () {
             stateDependencies.error = true;
             return error;
         },
-        get isValidating() {
+        get isValidating () {
             stateDependencies.isValidating = true;
             return isValidating;
+        },
+        get isLoading () {
+            stateDependencies.isLoading = true;
+            return isLoading;
         }
     };
 };
-var SWRConfig = OBJECT.defineProperty(SWRConfig$1, 'default', {
+const dist_SWRConfig = OBJECT.defineProperty(SWRConfig, 'defaultValue', {
     value: defaultConfig
 });
-var unstable_serialize = function (key) { return dist_serialize(key)[0]; };
-var useSWR = withArgs(useSWRHandler);
+const unstable_serialize = (key)=>serialize(key)[0];
+/**
+ * A hook to fetch data.
+ *
+ * @link https://swr.vercel.app
+ * @example
+ * ```jsx
+ * import useSWR from 'swr'
+ * function Profile() {
+ *   const { data, error } = useSWR('/api/user', fetcher)
+ *   if (error) return <div>failed to load</div>
+ *   if (!data) return <div>loading...</div>
+ *   return <div>hello {data.name}!</div>
+ * }
+ * ```
+ */ var useSWR = withArgs(useSWRHandler);
 
 // useSWR
 
@@ -20034,6 +20245,8 @@ var useSWR = withArgs(useSWRHandler);
 ;// CONCATENATED MODULE: ./packages/provider/es/locale/zh_TW.js
 /* harmony default export */ var zh_TW = ({
   moneySymbol: 'NT$',
+  deleteThisLine: '刪除此行',
+  copyThisLine: '複製此行',
   form: {
     lightFilter: {
       more: '更多篩選',
@@ -20083,19 +20296,20 @@ var useSWR = withArgs(useSWRHandler);
     densitySmall: '緊湊'
   },
   stepsForm: {
-    next: '下一個',
-    prev: '以前的',
+    next: '下一步',
+    prev: '上一步',
     submit: '完成'
   },
   loginForm: {
     submitText: '登入'
   },
   editableTable: {
+    onlyOneLineEditor: '只能同時編輯一行',
     action: {
       save: '保存',
       cancel: '取消',
       delete: '刪除',
-      add: '添加一行數據'
+      add: '新增一行資料'
     }
   },
   switch: {
@@ -20863,7 +21077,7 @@ var ConfigProVidContainer = function ConfigProVidContainer(props) {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [autoClearCache, children, getPrefixCls, hashId, locale, proProvideValue, token]);
   if (!autoClearCache) return configProviderDom;
-  return (0,jsx_runtime.jsx)(SWRConfig, {
+  return (0,jsx_runtime.jsx)(dist_SWRConfig, {
     value: {
       provider: function provider() {
         return new Map();
@@ -32009,7 +32223,10 @@ var useFieldFetchData = function useFieldFetchData(props) {
         return null;
       }
       return swrKey;
-    }, function (_, params, kw) {
+    }, function (_ref6) {
+      var _ref7 = slicedToArray_slicedToArray(_ref6, 3),
+        params = _ref7[1],
+        kw = _ref7[2];
       return props.request(objectSpread2_objectSpread2(objectSpread2_objectSpread2({}, params), {}, {
         keyWords: kw
       }), props);
@@ -32107,13 +32324,13 @@ var FieldSelect = function FieldSelect(props, ref) {
   });
   var optionsValueEnum = (0,external_React_.useMemo)(function () {
     if (mode !== 'read') return;
-    var _ref6 = fieldNames || {},
-      _ref6$label = _ref6.label,
-      labelPropsName = _ref6$label === void 0 ? 'label' : _ref6$label,
-      _ref6$value = _ref6.value,
-      valuePropsName = _ref6$value === void 0 ? 'value' : _ref6$value,
-      _ref6$options = _ref6.options,
-      optionsPropsName = _ref6$options === void 0 ? 'options' : _ref6$options;
+    var _ref8 = fieldNames || {},
+      _ref8$label = _ref8.label,
+      labelPropsName = _ref8$label === void 0 ? 'label' : _ref8$label,
+      _ref8$value = _ref8.value,
+      valuePropsName = _ref8$value === void 0 ? 'value' : _ref8$value,
+      _ref8$options = _ref8.options,
+      optionsPropsName = _ref8$options === void 0 ? 'options' : _ref8$options;
     var valuesMap = new Map();
     var traverseOptions = function traverseOptions(_options) {
       if (!(_options === null || _options === void 0 ? void 0 : _options.length)) {
@@ -48780,7 +48997,7 @@ var TopNavHeader = function TopNavHeader(props) {
 
 
 var genGlobalHeaderStyle = function genGlobalHeaderStyle(token) {
-  var _token$layout, _token$layout$header, _token$layout2, _token$layout2$header, _token$componentCls;
+  var _token$layout, _token$layout$header, _token$layout2, _token$layout2$header, _token$layout3, _token$layout3$header, _token$componentCls;
   return defineProperty_defineProperty({}, token.componentCls, (_token$componentCls = {
     position: 'relative',
     background: 'transparent',
@@ -48819,7 +49036,7 @@ var genGlobalHeaderStyle = function genGlobalHeaderStyle(token) {
       marginInline: 0,
       marginInlineStart: 8,
       fontWeight: '600',
-      color: token.colorTextHeading,
+      color: ((_token$layout3 = token.layout) === null || _token$layout3 === void 0 ? void 0 : (_token$layout3$header = _token$layout3.header) === null || _token$layout3$header === void 0 ? void 0 : _token$layout3$header.colorHeaderTitle) || token.colorTextHeading,
       fontSize: '18px',
       lineHeight: '32px'
     },
@@ -53087,7 +53304,6 @@ var ProLayout_excluded = ["id", "defaultMessage"],
 
 
 
-
 
 
 var layoutIndex = 0;
@@ -53256,33 +53472,31 @@ var BaseProLayout = function BaseProLayout(props) {
     var locales = gLocaleObject();
     return locales[id] ? locales[id] : defaultMessage;
   }, [propsFormatMessage]);
-  var _useSWR = useSWR(function () {
-      if (!(menu === null || menu === void 0 ? void 0 : menu.params)) return [defaultId, {}];
-      return [defaultId, menu === null || menu === void 0 ? void 0 : menu.params];
-    }, /*#__PURE__*/function () {
-      var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_, params) {
+  var _useSWR = useSWR([defaultId, menu === null || menu === void 0 ? void 0 : menu.params], /*#__PURE__*/function () {
+      var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref5) {
         var _menu$request;
-        var msg;
+        var _ref7, params, menuDataItems;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) {
             switch (_context.prev = _context.next) {
               case 0:
+                _ref7 = slicedToArray_slicedToArray(_ref5, 2), params = _ref7[1];
                 setMenuLoading(true);
-                _context.next = 3;
-                return menu === null || menu === void 0 ? void 0 : (_menu$request = menu.request) === null || _menu$request === void 0 ? void 0 : _menu$request.call(menu, params, (route === null || route === void 0 ? void 0 : route.children) || (route === null || route === void 0 ? void 0 : route.routes) || []);
-              case 3:
-                msg = _context.sent;
+                _context.next = 4;
+                return menu === null || menu === void 0 ? void 0 : (_menu$request = menu.request) === null || _menu$request === void 0 ? void 0 : _menu$request.call(menu, params || {}, (route === null || route === void 0 ? void 0 : route.children) || (route === null || route === void 0 ? void 0 : route.routes) || []);
+              case 4:
+                menuDataItems = _context.sent;
                 setMenuLoading(false);
-                return _context.abrupt("return", msg);
-              case 6:
+                return _context.abrupt("return", menuDataItems);
+              case 7:
               case "end":
                 return _context.stop();
             }
           }
         }, _callee);
       }));
-      return function (_x, _x2) {
-        return _ref5.apply(this, arguments);
+      return function (_x) {
+        return _ref6.apply(this, arguments);
       };
     }(), {
       revalidateOnFocus: false,
@@ -53302,12 +53516,12 @@ var BaseProLayout = function BaseProLayout(props) {
   var menuInfoData = (0,external_React_.useMemo)(function () {
     return getMenuData(data || (route === null || route === void 0 ? void 0 : route.children) || (route === null || route === void 0 ? void 0 : route.routes) || [], menu, formatMessage, menuDataRender);
   }, [formatMessage, menu, menuDataRender, data, route === null || route === void 0 ? void 0 : route.children, route === null || route === void 0 ? void 0 : route.routes]);
-  var _ref6 = menuInfoData || {},
-    _ref6$breadcrumb = _ref6.breadcrumb,
-    breadcrumb = _ref6$breadcrumb === void 0 ? {} : _ref6$breadcrumb,
-    breadcrumbMap = _ref6.breadcrumbMap,
-    _ref6$menuData = _ref6.menuData,
-    menuData = _ref6$menuData === void 0 ? [] : _ref6$menuData;
+  var _ref8 = menuInfoData || {},
+    _ref8$breadcrumb = _ref8.breadcrumb,
+    breadcrumb = _ref8$breadcrumb === void 0 ? {} : _ref8$breadcrumb,
+    breadcrumbMap = _ref8.breadcrumbMap,
+    _ref8$menuData = _ref8.menuData,
+    menuData = _ref8$menuData === void 0 ? [] : _ref8$menuData;
   if (actionRef && (menu === null || menu === void 0 ? void 0 : menu.request)) {
     actionRef.current = {
       reload: function reload() {
@@ -64674,7 +64888,7 @@ var genFocusStyle = function genFocusStyle(token) {
   };
 };
 ;// CONCATENATED MODULE: ./node_modules/antd/es/version/version.js
-/* harmony default export */ var version = ('5.0.4');
+/* harmony default export */ var version = ('5.0.5');
 ;// CONCATENATED MODULE: ./node_modules/antd/es/version/index.js
 /* eslint import/no-unresolved: 0 */
 // @ts-ignore
@@ -65660,7 +65874,6 @@ var Checkbox_rest = undefined && undefined.__rest || function (s, e) {
 
 
 
-
 var InternalCheckbox = function InternalCheckbox(_a, ref) {
   var _classNames;
   var _b;
@@ -65680,9 +65893,9 @@ var InternalCheckbox = function InternalCheckbox(_a, ref) {
     getPrefixCls = _React$useContext.getPrefixCls,
     direction = _React$useContext.direction;
   var checkboxGroup = external_React_.useContext(GroupContext);
-  var _useContext = (0,external_React_.useContext)(FormItemInputContext),
-    isFormItemInput = _useContext.isFormItemInput;
-  var contextDisabled = (0,external_React_.useContext)(config_provider_DisabledContext);
+  var _React$useContext2 = external_React_.useContext(FormItemInputContext),
+    isFormItemInput = _React$useContext2.isFormItemInput;
+  var contextDisabled = external_React_.useContext(config_provider_DisabledContext);
   var mergedDisabled = (_b = (checkboxGroup === null || checkboxGroup === void 0 ? void 0 : checkboxGroup.disabled) || disabled) !== null && _b !== void 0 ? _b : contextDisabled;
   var prevValue = external_React_.useRef(restProps.value);
   external_React_.useEffect(function () {
@@ -76501,15 +76714,18 @@ var genGroupStyle = function genGroupStyle(token) {
 
 
 // handle border collapse
-function compactItemBorder(token, borderedItemCls, popoverFocusedCls) {
-  var childCombinator = borderedItemCls ? '> *' : '';
+function compactItemBorder(token, options) {
+  var childCombinator = options.borderElCls ? '> *' : '';
+  var hoverEffects = ['hover', options.focus ? 'focus' : null, 'active'].filter(Boolean).map(function (n) {
+    return "&:" + n + " " + childCombinator;
+  }).join(',');
   return {
     '&-item:not(&-last-item)': {
       marginInlineEnd: -token.lineWidth
     },
-    '&-item': extends_extends(extends_extends(defineProperty_defineProperty({}, "&:hover " + childCombinator + ", &:focus " + childCombinator + ", &:active " + childCombinator, {
+    '&-item': extends_extends(extends_extends(defineProperty_defineProperty({}, hoverEffects, {
       zIndex: 2
-    }), popoverFocusedCls ? defineProperty_defineProperty({}, "&" + popoverFocusedCls, {
+    }), options.focusElCls ? defineProperty_defineProperty({}, "&" + options.focusElCls, {
       zIndex: 2
     }) : {}), defineProperty_defineProperty({}, "&[disabled] " + childCombinator, {
       zIndex: 0
@@ -76517,9 +76733,9 @@ function compactItemBorder(token, borderedItemCls, popoverFocusedCls) {
   };
 }
 // handle border-radius
-function compactItemBorderRadius(prefixCls, borderedElementCls) {
+function compactItemBorderRadius(prefixCls, options) {
   var _ref2;
-  var childCombinator = borderedElementCls ? "> " + borderedElementCls : '';
+  var childCombinator = options.borderElCls ? "> " + options.borderElCls : '';
   return _ref2 = {}, defineProperty_defineProperty(_ref2, "&-item:not(&-first-item):not(&-last-item) " + childCombinator, {
     borderRadius: 0
   }), defineProperty_defineProperty(_ref2, '&-item:not(&-last-item)&-first-item', defineProperty_defineProperty({}, "& " + childCombinator + ", &" + prefixCls + "-sm " + childCombinator + ", &" + prefixCls + "-lg " + childCombinator, {
@@ -76530,15 +76746,12 @@ function compactItemBorderRadius(prefixCls, borderedElementCls) {
     borderEndStartRadius: 0
   })), _ref2;
 }
-function genCompactItemStyle(token, prefixCls, /** Some component borders are implemented on child elements like `Select` */
-borderedElementCls,
-/**
- * Some components have special `focus` className especially with popovers like `Select` and
- * `DatePicker`
- */
-popoverFocusedCls) {
+function genCompactItemStyle(token, prefixCls) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+    focus: true
+  };
   return {
-    '&-compact': extends_extends(extends_extends({}, compactItemBorder(token, borderedElementCls, popoverFocusedCls)), compactItemBorderRadius(prefixCls, borderedElementCls))
+    '&-compact': extends_extends(extends_extends({}, compactItemBorder(token, options)), compactItemBorderRadius(prefixCls, options))
   };
 }
 ;// CONCATENATED MODULE: ./node_modules/antd/es/style/compact-item-vertical.js
@@ -76614,7 +76827,9 @@ var genSharedButtonStyle = function genSharedButtonStyle(token) {
     }
   }, defineProperty_defineProperty(_extends2, "> " + iconCls + " + span, > span + " + iconCls, {
     marginInlineStart: token.marginXS
-  }), defineProperty_defineProperty(_extends2, '&:not(:disabled)', extends_extends({}, genFocusStyle(token))), _extends2), genCompactItemStyle(token, componentCls)), genCompactItemVerticalStyle(token, componentCls)), (_extends3 = {
+  }), defineProperty_defineProperty(_extends2, '&:not(:disabled)', extends_extends({}, genFocusStyle(token))), _extends2), genCompactItemStyle(token, componentCls, {
+    focus: false
+  })), genCompactItemVerticalStyle(token, componentCls)), (_extends3 = {
     // make `btn-icon-only` not too narrow
     '&-icon-only&-compact-item': {
       flex: 'none'
@@ -76622,28 +76837,28 @@ var genSharedButtonStyle = function genSharedButtonStyle(token) {
   }, defineProperty_defineProperty(_extends3, "&-compact-item" + componentCls + "-primary", {
     '&:not([disabled]) + &:not([disabled])': {
       position: 'relative',
-      '&:after': {
+      '&:before': {
         position: 'absolute',
         top: -token.lineWidth,
         insetInlineStart: -token.lineWidth,
         display: 'inline-block',
         width: token.lineWidth,
         height: "calc(100% + " + token.lineWidth * 2 + "px)",
-        backgroundColor: token.colorPrimaryBorder,
+        backgroundColor: token.colorPrimaryHover,
         content: '""'
       }
     }
   }), defineProperty_defineProperty(_extends3, '&-compact-vertical-item', defineProperty_defineProperty({}, "&" + componentCls + "-primary", {
     '&:not([disabled]) + &:not([disabled])': {
       position: 'relative',
-      '&:after': {
+      '&:before': {
         position: 'absolute',
         top: -token.lineWidth,
         insetInlineStart: -token.lineWidth,
         display: 'inline-block',
         width: "calc(100% + " + token.lineWidth * 2 + "px)",
         height: token.lineWidth,
-        backgroundColor: token.colorPrimaryBorder,
+        backgroundColor: token.colorPrimaryHover,
         content: '""'
       }
     }
@@ -78528,7 +78743,6 @@ var radio_rest = undefined && undefined.__rest || function (s, e) {
 
 
 
-
 var InternalRadio = function InternalRadio(props, ref) {
   var _classNames;
   var groupContext = external_React_.useContext(radio_context);
@@ -78538,8 +78752,8 @@ var InternalRadio = function InternalRadio(props, ref) {
     direction = _React$useContext.direction;
   var innerRef = external_React_.useRef();
   var mergedRef = composeRef(ref, innerRef);
-  var _useContext = (0,external_React_.useContext)(FormItemInputContext),
-    isFormItemInput = _useContext.isFormItemInput;
+  var _React$useContext2 = external_React_.useContext(FormItemInputContext),
+    isFormItemInput = _React$useContext2.isFormItemInput;
    false ? 0 : void 0;
   var onChange = function onChange(e) {
     var _a, _b;
@@ -80139,17 +80353,17 @@ function BaseProList(props) {
 
 ;// CONCATENATED MODULE: ./packages/components/src/version.ts
 var version_version = {
-  "@ant-design/pro-card": "2.1.4",
-  "@ant-design/pro-components": "2.3.44",
-  "@ant-design/pro-descriptions": "2.0.37",
-  "@ant-design/pro-field": "2.1.28",
-  "@ant-design/pro-form": "2.4.5",
-  "@ant-design/pro-layout": "7.3.7",
-  "@ant-design/pro-list": "2.0.38",
-  "@ant-design/pro-provider": "2.1.4",
+  "@ant-design/pro-card": "2.1.5",
+  "@ant-design/pro-components": "2.3.46",
+  "@ant-design/pro-descriptions": "2.0.38",
+  "@ant-design/pro-field": "2.1.29",
+  "@ant-design/pro-form": "2.4.6",
+  "@ant-design/pro-layout": "7.3.9",
+  "@ant-design/pro-list": "2.0.39",
+  "@ant-design/pro-provider": "2.1.5",
   "@ant-design/pro-skeleton": "2.0.7",
-  "@ant-design/pro-table": "3.2.5",
-  "@ant-design/pro-utils": "2.4.4"
+  "@ant-design/pro-table": "3.2.6",
+  "@ant-design/pro-utils": "2.4.5"
 };
 ;// CONCATENATED MODULE: ./packages/components/src/index.tsx