@tonyclaw/agent-inspector 3.0.45 → 3.0.47

package/.output/server/_libs/swr.mjs

@@ -1,947 +0,0 @@
-import { r as reactExports, R as React } from "./react.mjs";
-import { s as shimExports } from "./use-sync-external-store.mjs";
-import { d as dequal } from "./dequal.mjs";
-const FOCUS_EVENT = 0;
-const RECONNECT_EVENT = 1;
-const MUTATE_EVENT = 2;
-const ERROR_REVALIDATE_EVENT = 3;
-const SWRGlobalState = /* @__PURE__ */ new WeakMap();
-const noop = () => {
-};
-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 isPromiseLike = (x) => isFunction(x.then);
-const EMPTY_CACHE = {};
-const INITIAL_CACHE = {};
-const STR_UNDEFINED = "undefined";
-const isWindowDefined = typeof window != STR_UNDEFINED;
-const isDocumentDefined = typeof document != STR_UNDEFINED;
-const isLegacyDeno = isWindowDefined && "Deno" in window;
-const hasRequestAnimationFrame = () => isWindowDefined && typeof window["requestAnimationFrame"] != STR_UNDEFINED;
-const createCacheHelper = (cache2, key) => {
-  const state = SWRGlobalState.get(cache2);
-  return [
-    // Getter
-    () => !isUndefined(key) && cache2.get(key) || EMPTY_CACHE,
-    // Setter
-    (info) => {
-      if (!isUndefined(key)) {
-        const prev = cache2.get(key);
-        if (!(key in INITIAL_CACHE)) {
-          INITIAL_CACHE[key] = prev;
-        }
-        state[5](key, mergeObjects(prev, info), prev || EMPTY_CACHE);
-      }
-    },
-    // Subscriber
-    state[6],
-    // Get server cache snapshot
-    () => {
-      if (!isUndefined(key)) {
-        if (key in INITIAL_CACHE) return INITIAL_CACHE[key];
-      }
-      return !isUndefined(key) && cache2.get(key) || EMPTY_CACHE;
-    }
-  ];
-};
-let online = true;
-const isOnline = () => online;
-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";
-};
-const initFocus = (callback) => {
-  if (isDocumentDefined) {
-    document.addEventListener("visibilitychange", callback);
-  }
-  onWindowEvent("focus", callback);
-  return () => {
-    if (isDocumentDefined) {
-      document.removeEventListener("visibilitychange", callback);
-    }
-    offWindowEvent("focus", callback);
-  };
-};
-const initReconnect = (callback) => {
-  const onOnline = () => {
-    online = true;
-    callback();
-  };
-  const onOffline = () => {
-    online = false;
-  };
-  onWindowEvent("online", onOnline);
-  onWindowEvent("offline", onOffline);
-  return () => {
-    offWindowEvent("online", onOnline);
-    offWindowEvent("offline", onOffline);
-  };
-};
-const preset = {
-  isOnline,
-  isVisible
-};
-const defaultConfigOptions = {
-  initFocus,
-  initReconnect
-};
-const IS_REACT_LEGACY = !React.useId;
-const IS_SERVER = !isWindowDefined || isLegacyDeno;
-const rAF = (f) => hasRequestAnimationFrame() ? window["requestAnimationFrame"](f) : setTimeout(f, 1);
-const useIsomorphicLayoutEffect = IS_SERVER ? reactExports.useEffect : reactExports.useLayoutEffect;
-const navigatorConnection = typeof navigator !== "undefined" && navigator.connection;
-const slowConnection = !IS_SERVER && navigatorConnection && ([
-  "slow-2g",
-  "2g"
-].includes(navigatorConnection.effectiveType) || navigatorConnection.saveData);
-const table = /* @__PURE__ */ new WeakMap();
-const getTypeName = (value) => OBJECT.prototype.toString.call(value);
-const isObjectTypeName = (typeName, type) => typeName === `[object ${type}]`;
-let counter = 0;
-const stableHash = (arg) => {
-  const type = typeof arg;
-  const typeName = getTypeName(arg);
-  const isDate = isObjectTypeName(typeName, "Date");
-  const isRegex = isObjectTypeName(typeName, "RegExp");
-  const isPlainObject = isObjectTypeName(typeName, "Object");
-  let result;
-  let index;
-  if (OBJECT(arg) === arg && !isDate && !isRegex) {
-    result = table.get(arg);
-    if (result) return result;
-    result = ++counter + "~";
-    table.set(arg, result);
-    if (Array.isArray(arg)) {
-      result = "@";
-      for (index = 0; index < arg.length; index++) {
-        result += stableHash(arg[index]) + ",";
-      }
-      table.set(arg, result);
-    }
-    if (isPlainObject) {
-      result = "#";
-      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;
-  }
-  return result;
-};
-const serialize = (key) => {
-  if (isFunction(key)) {
-    try {
-      key = key();
-    } catch (err) {
-      key = "";
-    }
-  }
-  const args = key;
-  key = typeof key == "string" ? key : (Array.isArray(key) ? key.length : key) ? stableHash(key) : "";
-  return [
-    key,
-    args
-  ];
-};
-let __timestamp = 0;
-const getTimestamp = () => ++__timestamp;
-async function internalMutate(...args) {
-  const [cache2, _key, _data, _opts] = args;
-  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 rollbackOnError = (error) => {
-    return typeof rollbackOnErrorOption === "function" ? rollbackOnErrorOption(error) : rollbackOnErrorOption !== false;
-  };
-  const throwOnError = options.throwOnError;
-  if (isFunction(_key)) {
-    const keyFilter = _key;
-    const matchedKeys = [];
-    const it = cache2.keys();
-    for (const key of it) {
-      if (
-        // Skip the special useSWRInfinite and useSWRSubscription keys.
-        !/^\$(inf|sub)\$/.test(key) && keyFilter(cache2.get(key)._k)
-      ) {
-        matchedKeys.push(key);
-      }
-    }
-    return Promise.all(matchedKeys.map(mutateByKey));
-  }
-  return mutateByKey(_key);
-  async function mutateByKey(_k) {
-    const [key] = serialize(_k);
-    if (!key) return;
-    const [get, set] = createCacheHelper(cache2, key);
-    const [EVENT_REVALIDATORS, MUTATION, FETCH, PRELOAD] = SWRGlobalState.get(cache2);
-    const startRevalidate = () => {
-      const revalidators = EVENT_REVALIDATORS[key];
-      const revalidate = isFunction(options.revalidate) ? options.revalidate(get().data, _k) : options.revalidate !== false;
-      if (revalidate) {
-        delete FETCH[key];
-        delete PRELOAD[key];
-        if (revalidators && revalidators[0]) {
-          return revalidators[0](MUTATE_EVENT).then(() => get().data);
-        }
-      }
-      return get().data;
-    };
-    if (args.length < 3) {
-      return startRevalidate();
-    }
-    let data = _data;
-    let error;
-    let isError = false;
-    const beforeMutationTs = getTimestamp();
-    MUTATION[key] = [
-      beforeMutationTs,
-      0
-    ];
-    const hasOptimisticData = !isUndefined(optimisticData);
-    const state = get();
-    const displayedData = state.data;
-    const currentData = state._c;
-    const committedData = isUndefined(currentData) ? displayedData : currentData;
-    if (hasOptimisticData) {
-      optimisticData = isFunction(optimisticData) ? optimisticData(committedData, displayedData) : optimisticData;
-      set({
-        data: optimisticData,
-        _c: committedData
-      });
-    }
-    if (isFunction(data)) {
-      try {
-        data = data(committedData);
-      } catch (err) {
-        error = err;
-        isError = true;
-      }
-    }
-    if (data && isPromiseLike(data)) {
-      data = await data.catch((err) => {
-        error = err;
-        isError = true;
-      });
-      if (beforeMutationTs !== MUTATION[key][0]) {
-        if (isError) throw error;
-        return data;
-      } else if (isError && hasOptimisticData && rollbackOnError(error)) {
-        populateCache = true;
-        set({
-          data: committedData,
-          _c: UNDEFINED
-        });
-      }
-    }
-    if (populateCache) {
-      if (!isError) {
-        if (isFunction(populateCache)) {
-          const populateCachedData = populateCache(data, committedData);
-          set({
-            data: populateCachedData,
-            error: UNDEFINED,
-            _c: UNDEFINED
-          });
-        } else {
-          set({
-            data,
-            error: UNDEFINED,
-            _c: UNDEFINED
-          });
-        }
-      }
-    }
-    MUTATION[key][1] = getTimestamp();
-    Promise.resolve(startRevalidate()).then(() => {
-      set({
-        _c: UNDEFINED
-      });
-    });
-    if (isError) {
-      if (throwOnError) throw error;
-      return;
-    }
-    return data;
-  }
-}
-const revalidateAllKeys = (revalidators, type) => {
-  for (const key in revalidators) {
-    if (revalidators[key][0]) revalidators[key][0](type);
-  }
-};
-const initCache = (provider, options) => {
-  if (!SWRGlobalState.has(provider)) {
-    const opts = mergeObjects(defaultConfigOptions, options);
-    const EVENT_REVALIDATORS = /* @__PURE__ */ Object.create(null);
-    const mutate2 = internalMutate.bind(UNDEFINED, provider);
-    let unmount = noop;
-    const subscriptions = /* @__PURE__ */ Object.create(null);
-    const subscribe = (key, callback) => {
-      const subs = subscriptions[key] || [];
-      subscriptions[key] = subs;
-      subs.push(callback);
-      return () => {
-        const index = subs.indexOf(callback);
-        if (index >= 0) {
-          subs[index] = subs[subs.length - 1];
-          subs.pop();
-        }
-      };
-    };
-    const setter = (key, value, prev) => {
-      provider.set(key, value);
-      const subs = subscriptions[key];
-      if (subs) {
-        for (const fn of subs) {
-          fn(value, prev);
-        }
-      }
-    };
-    const initProvider = () => {
-      if (!SWRGlobalState.has(provider)) {
-        SWRGlobalState.set(provider, [
-          EVENT_REVALIDATORS,
-          /* @__PURE__ */ Object.create(null),
-          /* @__PURE__ */ Object.create(null),
-          /* @__PURE__ */ Object.create(null),
-          mutate2,
-          setter,
-          subscribe
-        ]);
-        if (!IS_SERVER) {
-          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();
-            SWRGlobalState.delete(provider);
-          };
-        }
-      }
-    };
-    initProvider();
-    return [
-      provider,
-      mutate2,
-      initProvider,
-      unmount
-    ];
-  }
-  return [
-    provider,
-    SWRGlobalState.get(provider)[4]
-  ];
-};
-const onErrorRetry = (_, __, config, revalidate, opts) => {
-  const maxRetryCount = config.errorRetryCount;
-  const currentRetryCount = opts.retryCount;
-  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 = dequal;
-const [cache, mutate] = initCache(/* @__PURE__ */ new Map());
-const defaultConfig = mergeObjects(
-  {
-    // events
-    onLoadingSlow: noop,
-    onSuccess: noop,
-    onError: noop,
-    onErrorRetry,
-    onDiscarded: noop,
-    // switches
-    revalidateOnFocus: true,
-    revalidateOnReconnect: true,
-    revalidateIfStale: true,
-    shouldRetryOnError: true,
-    // timeouts
-    errorRetryInterval: slowConnection ? 1e4 : 5e3,
-    focusThrottleInterval: 5 * 1e3,
-    dedupingInterval: 2 * 1e3,
-    loadingTimeout: slowConnection ? 5e3 : 3e3,
-    // providers
-    compare,
-    isPaused: () => false,
-    cache,
-    mutate,
-    fallback: {}
-  },
-  // use web preset by default
-  preset
-);
-const mergeConfigs = (a, b) => {
-  const v = mergeObjects(a, b);
-  if (b) {
-    const { use: u1, fallback: f1 } = a;
-    const { use: u2, fallback: f2 } = b;
-    if (u1 && u2) {
-      v.use = u1.concat(u2);
-    }
-    if (f1 && f2) {
-      v.fallback = mergeObjects(f1, f2);
-    }
-  }
-  return v;
-};
-const SWRConfigContext = reactExports.createContext({});
-const SWRConfig$1 = (props) => {
-  const { value } = props;
-  const parentConfig = reactExports.useContext(SWRConfigContext);
-  const isFunctionalConfig = isFunction(value);
-  const config = reactExports.useMemo(() => isFunctionalConfig ? value(parentConfig) : value, [
-    isFunctionalConfig,
-    parentConfig,
-    value
-  ]);
-  const extendedConfig = reactExports.useMemo(() => isFunctionalConfig ? config : mergeConfigs(parentConfig, config), [
-    isFunctionalConfig,
-    parentConfig,
-    config
-  ]);
-  const provider = config && config.provider;
-  const cacheContextRef = reactExports.useRef(UNDEFINED);
-  if (provider && !cacheContextRef.current) {
-    cacheContextRef.current = initCache(provider(extendedConfig.cache || cache), config);
-  }
-  const cacheContext = cacheContextRef.current;
-  if (cacheContext) {
-    extendedConfig.cache = cacheContext[0];
-    extendedConfig.mutate = cacheContext[1];
-  }
-  useIsomorphicLayoutEffect(() => {
-    if (cacheContext) {
-      cacheContext[2] && cacheContext[2]();
-      return cacheContext[3];
-    }
-  }, []);
-  return reactExports.createElement(SWRConfigContext.Provider, mergeObjects(props, {
-    value: extendedConfig
-  }));
-};
-const INFINITE_PREFIX = "$inf$";
-const enableDevtools = isWindowDefined && window.__SWR_DEVTOOLS_USE__;
-const use$1 = enableDevtools ? window.__SWR_DEVTOOLS_USE__ : [];
-const setupDevTools = () => {
-  if (enableDevtools) {
-    window.__SWR_DEVTOOLS_REACT__ = 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 = () => {
-  const parentConfig = reactExports.useContext(SWRConfigContext);
-  const mergedConfig = reactExports.useMemo(() => mergeObjects(defaultConfig, parentConfig), [
-    parentConfig
-  ]);
-  return mergedConfig;
-};
-const middleware = (useSWRNext) => (key_, fetcher_, config) => {
-  const fetcher = fetcher_ && ((...args) => {
-    const [key] = serialize(key_);
-    const [, , , PRELOAD] = SWRGlobalState.get(cache);
-    if (key.startsWith(INFINITE_PREFIX)) {
-      return fetcher_(...args);
-    }
-    const req = PRELOAD[key];
-    if (isUndefined(req)) return fetcher_(...args);
-    delete PRELOAD[key];
-    return req;
-  });
-  return useSWRNext(key_, fetcher, config);
-};
-const BUILT_IN_MIDDLEWARE = use$1.concat(middleware);
-const withArgs = (hook) => {
-  return function useSWRArgs(...args) {
-    const fallbackConfig = useSWRConfig();
-    const [key, fn, _config] = normalize(args);
-    const config = mergeConfigs(fallbackConfig, _config);
-    let next = hook;
-    const { use: use2 } = config;
-    const middleware2 = (use2 || []).concat(BUILT_IN_MIDDLEWARE);
-    for (let i = middleware2.length; i--; ) {
-      next = middleware2[i](next);
-    }
-    return next(key, fn || config.fetcher || null, config);
-  };
-};
-const subscribeCallback = (key, callbacks, callback) => {
-  const keyedRevalidators = callbacks[key] || (callbacks[key] = []);
-  keyedRevalidators.push(callback);
-  return () => {
-    const index = keyedRevalidators.indexOf(callback);
-    if (index >= 0) {
-      keyedRevalidators[index] = keyedRevalidators[keyedRevalidators.length - 1];
-      keyedRevalidators.pop();
-    }
-  };
-};
-setupDevTools();
-const use = React.use || // This extra generic is to avoid TypeScript mixing up the generic and JSX sytax
-// and emitting an error.
-// We assume that this is only for the `use(thenable)` case, not `use(context)`.
-// https://github.com/facebook/react/blob/aed00dacfb79d17c53218404c52b1c7aa59c4a89/packages/react-server/src/ReactFizzThenable.js#L45
-((thenable) => {
-  switch (thenable.status) {
-    case "pending":
-      throw thenable;
-    case "fulfilled":
-      return thenable.value;
-    case "rejected":
-      throw thenable.reason;
-    default:
-      thenable.status = "pending";
-      thenable.then((v) => {
-        thenable.status = "fulfilled";
-        thenable.value = v;
-      }, (e) => {
-        thenable.status = "rejected";
-        thenable.reason = e;
-      });
-      throw thenable;
-  }
-});
-const WITH_DEDUPE = {
-  dedupe: true
-};
-const resolvedUndef = Promise.resolve(UNDEFINED);
-resolvedUndef.status = "fulfilled";
-resolvedUndef.value = UNDEFINED;
-const sub = () => noop;
-const useSWRHandler = (_key, fetcher, config) => {
-  const { cache: cache2, compare: compare2, suspense, fallbackData, revalidateOnMount, revalidateIfStale, refreshInterval, refreshWhenHidden, refreshWhenOffline, keepPreviousData, strictServerPrefetchWarning } = config;
-  const [EVENT_REVALIDATORS, MUTATION, FETCH, PRELOAD] = SWRGlobalState.get(cache2);
-  const [key, fnArg] = serialize(_key);
-  const initialMountedRef = reactExports.useRef(false);
-  const unmountedRef = reactExports.useRef(false);
-  const keyRef = reactExports.useRef(key);
-  const fetcherRef = reactExports.useRef(fetcher);
-  const configRef = reactExports.useRef(config);
-  const getConfig = () => configRef.current;
-  const isActive = () => getConfig().isVisible() && getConfig().isOnline();
-  const [getCache, setCache, subscribeCache, getInitialCache] = createCacheHelper(cache2, key);
-  const stateDependencies = reactExports.useRef({}).current;
-  const fallback = isUndefined(fallbackData) ? isUndefined(config.fallback) ? UNDEFINED : config.fallback[key] : fallbackData;
-  const isEqual = (prev, current) => {
-    for (const _ in stateDependencies) {
-      const t = _;
-      if (t === "data") {
-        if (!compare2(prev[t], current[t])) {
-          if (!isUndefined(prev[t])) {
-            return false;
-          }
-          if (!compare2(returnedData, current[t])) {
-            return false;
-          }
-        }
-      } else {
-        if (current[t] !== prev[t]) {
-          return false;
-        }
-      }
-    }
-    return true;
-  };
-  const isInitialMount = !initialMountedRef.current;
-  const getSnapshot = reactExports.useMemo(() => {
-    const cachedData2 = getCache();
-    const initialData = getInitialCache();
-    const getSelectedCache = (state) => {
-      const snapshot = mergeObjects(state);
-      delete snapshot._k;
-      const shouldStartRequest = (() => {
-        if (!key) return false;
-        if (!fetcher) return false;
-        if (getConfig().isPaused()) return false;
-        if (isInitialMount && !isUndefined(revalidateOnMount)) return revalidateOnMount;
-        const data2 = !isUndefined(fallback) ? fallback : snapshot.data;
-        if (suspense) return isUndefined(data2) || revalidateIfStale;
-        return isUndefined(data2) || revalidateIfStale;
-      })();
-      if (!shouldStartRequest) {
-        return snapshot;
-      }
-      return {
-        isValidating: true,
-        isLoading: true,
-        ...snapshot
-      };
-    };
-    const clientSnapshot = getSelectedCache(cachedData2);
-    const serverSnapshot = cachedData2 === initialData ? clientSnapshot : getSelectedCache(initialData);
-    let memorizedSnapshot = clientSnapshot;
-    return [
-      () => {
-        const newSnapshot = getSelectedCache(getCache());
-        const compareResult = isEqual(newSnapshot, memorizedSnapshot);
-        if (compareResult) {
-          memorizedSnapshot.data = newSnapshot.data;
-          memorizedSnapshot.isLoading = newSnapshot.isLoading;
-          memorizedSnapshot.isValidating = newSnapshot.isValidating;
-          memorizedSnapshot.error = newSnapshot.error;
-          return memorizedSnapshot;
-        } else {
-          memorizedSnapshot = newSnapshot;
-          return newSnapshot;
-        }
-      },
-      () => serverSnapshot
-    ];
-  }, [
-    cache2,
-    key
-  ]);
-  const cached = shimExports.useSyncExternalStore(reactExports.useCallback(
-    (callback) => subscribeCache(key, (current, prev) => {
-      if (!isEqual(prev, current)) callback();
-    }),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [
-      cache2,
-      key
-    ]
-  ), getSnapshot[0], getSnapshot[1]);
-  const hasRevalidator = EVENT_REVALIDATORS[key] && EVENT_REVALIDATORS[key].length > 0;
-  const cachedData = cached.data;
-  const data = isUndefined(cachedData) ? fallback && isPromiseLike(fallback) ? use(fallback) : fallback : cachedData;
-  const error = cached.error;
-  const laggyDataRef = reactExports.useRef(data);
-  const returnedData = keepPreviousData ? isUndefined(cachedData) ? isUndefined(laggyDataRef.current) ? data : laggyDataRef.current : cachedData : data;
-  const hasKeyButNoData = key && isUndefined(data);
-  const hydrationRef = reactExports.useRef(null);
-  !IS_SERVER && // getServerSnapshot is only called during hydration
-  // eslint-disable-next-line react-hooks/rules-of-hooks
-  shimExports.useSyncExternalStore(sub, () => {
-    hydrationRef.current = false;
-    return hydrationRef;
-  }, () => {
-    hydrationRef.current = true;
-    return hydrationRef;
-  });
-  const isHydration = hydrationRef.current;
-  if (strictServerPrefetchWarning && isHydration && !suspense && hasKeyButNoData) {
-    console.warn(`Missing pre-initiated data for serialized key "${key}" during server-side rendering. Data fetching should be initiated on the server and provided to SWR via fallback data. You can set "strictServerPrefetchWarning: false" to disable this warning.`);
-  }
-  const shouldDoInitialRevalidation = (() => {
-    if (!key || !fetcher) return false;
-    if (getConfig().isPaused()) return false;
-    if (hasRevalidator && !isUndefined(error)) return false;
-    if (isInitialMount && !isUndefined(revalidateOnMount)) return revalidateOnMount;
-    if (suspense) return isUndefined(data) ? false : revalidateIfStale;
-    return isUndefined(data) || revalidateIfStale;
-  })();
-  const defaultValidatingState = isInitialMount && shouldDoInitialRevalidation;
-  const isValidating = isUndefined(cached.isValidating) ? defaultValidatingState : cached.isValidating;
-  const isLoading = isUndefined(cached.isLoading) ? defaultValidatingState : cached.isLoading;
-  const revalidate = reactExports.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 || {};
-      const shouldStartNewRequest = !FETCH[key] || !opts.dedupe;
-      const callbackSafeguard = () => {
-        if (IS_REACT_LEGACY) {
-          return !unmountedRef.current && key === keyRef.current && initialMountedRef.current;
-        }
-        return key === keyRef.current;
-      };
-      const finalState = {
-        isValidating: false,
-        isLoading: false
-      };
-      const finishRequestAndUpdateState = () => {
-        setCache(finalState);
-      };
-      const cleanupState = () => {
-        const requestInfo = FETCH[key];
-        if (requestInfo && requestInfo[1] === startAt) {
-          delete FETCH[key];
-        }
-      };
-      const initialState = {
-        isValidating: true
-      };
-      if (isUndefined(getCache().data)) {
-        initialState.isLoading = true;
-      }
-      try {
-        if (shouldStartNewRequest) {
-          setCache(initialState);
-          if (config.loadingTimeout && isUndefined(getCache().data)) {
-            setTimeout(() => {
-              if (loading && callbackSafeguard()) {
-                getConfig().onLoadingSlow(key, config);
-              }
-            }, config.loadingTimeout);
-          }
-          FETCH[key] = [
-            currentFetcher(fnArg),
-            getTimestamp()
-          ];
-        }
-        ;
-        [newData, startAt] = FETCH[key];
-        newData = await newData;
-        if (shouldStartNewRequest) {
-          setTimeout(cleanupState, config.dedupingInterval);
-        }
-        if (!FETCH[key] || FETCH[key][1] !== startAt) {
-          if (shouldStartNewRequest) {
-            if (callbackSafeguard()) {
-              getConfig().onDiscarded(key);
-            }
-          }
-          return false;
-        }
-        finalState.error = UNDEFINED;
-        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 false;
-        }
-        const cacheData = getCache().data;
-        finalState.data = compare2(cacheData, newData) ? cacheData : newData;
-        if (shouldStartNewRequest) {
-          if (callbackSafeguard()) {
-            getConfig().onSuccess(newData, key, config);
-          }
-        }
-      } catch (err) {
-        cleanupState();
-        const currentConfig = getConfig();
-        const { shouldRetryOnError } = currentConfig;
-        if (!currentConfig.isPaused()) {
-          finalState.error = err;
-          if (shouldStartNewRequest && callbackSafeguard()) {
-            currentConfig.onError(err, key, currentConfig);
-            if (shouldRetryOnError === true || isFunction(shouldRetryOnError) && shouldRetryOnError(err)) {
-              if (!getConfig().revalidateOnFocus || !getConfig().revalidateOnReconnect || isActive()) {
-                currentConfig.onErrorRetry(err, key, currentConfig, (_opts) => {
-                  const revalidators = EVENT_REVALIDATORS[key];
-                  if (revalidators && revalidators[0]) {
-                    revalidators[0](ERROR_REVALIDATE_EVENT, _opts);
-                  }
-                }, {
-                  retryCount: (opts.retryCount || 0) + 1,
-                  dedupe: true
-                });
-              }
-            }
-          }
-        }
-      }
-      loading = false;
-      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:
-    // `fn` and `config` might be changed during the lifecycle,
-    // but they might be changed every render like this.
-    // `useSWR('key', () => fetch('/api/'), { suspense: true })`
-    // 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,
-      cache2
-    ]
-  );
-  const boundMutate = reactExports.useCallback(
-    // Use callback to make sure `keyRef.current` returns latest result every time
-    (...args) => {
-      return internalMutate(cache2, keyRef.current, ...args);
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    []
-  );
-  useIsomorphicLayoutEffect(() => {
-    fetcherRef.current = fetcher;
-    configRef.current = config;
-    if (!isUndefined(cachedData)) {
-      laggyDataRef.current = cachedData;
-    }
-  });
-  useIsomorphicLayoutEffect(() => {
-    if (!key) return;
-    const softRevalidate = revalidate.bind(UNDEFINED, WITH_DEDUPE);
-    let nextFocusRevalidatedAt = 0;
-    if (getConfig().revalidateOnFocus) {
-      const initNow = Date.now();
-      nextFocusRevalidatedAt = initNow + getConfig().focusThrottleInterval;
-    }
-    const onRevalidate = (type, opts = {}) => {
-      if (type == FOCUS_EVENT) {
-        const now = Date.now();
-        if (getConfig().revalidateOnFocus && now > nextFocusRevalidatedAt && isActive()) {
-          nextFocusRevalidatedAt = now + getConfig().focusThrottleInterval;
-          softRevalidate();
-        }
-      } else if (type == RECONNECT_EVENT) {
-        if (getConfig().revalidateOnReconnect && isActive()) {
-          softRevalidate();
-        }
-      } else if (type == MUTATE_EVENT) {
-        return revalidate();
-      } else if (type == ERROR_REVALIDATE_EVENT) {
-        return revalidate(opts);
-      }
-      return;
-    };
-    const unsubEvents = subscribeCallback(key, EVENT_REVALIDATORS, onRevalidate);
-    unmountedRef.current = false;
-    keyRef.current = key;
-    initialMountedRef.current = true;
-    setCache({
-      _k: fnArg
-    });
-    if (shouldDoInitialRevalidation) {
-      if (!FETCH[key]) {
-        if (isUndefined(data) || IS_SERVER) {
-          softRevalidate();
-        } else {
-          rAF(softRevalidate);
-        }
-      }
-    }
-    return () => {
-      unmountedRef.current = true;
-      unsubEvents();
-    };
-  }, [
-    key
-  ]);
-  useIsomorphicLayoutEffect(() => {
-    let timer;
-    function next() {
-      const interval = isFunction(refreshInterval) ? refreshInterval(getCache().data) : refreshInterval;
-      if (interval && timer !== -1) {
-        timer = setTimeout(execute, interval);
-      }
-    }
-    function execute() {
-      if (!getCache().error && (refreshWhenHidden || getConfig().isVisible()) && (refreshWhenOffline || getConfig().isOnline())) {
-        revalidate(WITH_DEDUPE).then(next);
-      } else {
-        next();
-      }
-    }
-    next();
-    return () => {
-      if (timer) {
-        clearTimeout(timer);
-        timer = -1;
-      }
-    };
-  }, [
-    refreshInterval,
-    refreshWhenHidden,
-    refreshWhenOffline,
-    key
-  ]);
-  reactExports.useDebugValue(returnedData);
-  if (suspense) {
-    if (!IS_REACT_LEGACY && IS_SERVER && hasKeyButNoData) {
-      throw new Error("Fallback data is required when using Suspense in SSR.");
-    }
-    if (hasKeyButNoData) {
-      fetcherRef.current = fetcher;
-      configRef.current = config;
-      unmountedRef.current = false;
-    }
-    const req = PRELOAD[key];
-    const mutateReq = !isUndefined(req) && hasKeyButNoData ? boundMutate(req) : resolvedUndef;
-    use(mutateReq);
-    if (!isUndefined(error) && hasKeyButNoData) {
-      throw error;
-    }
-    const revalidation = hasKeyButNoData ? revalidate(WITH_DEDUPE) : resolvedUndef;
-    if (!isUndefined(returnedData) && hasKeyButNoData) {
-      revalidation.status = "fulfilled";
-      revalidation.value = true;
-    }
-    use(revalidation);
-  }
-  const swrResponse = {
-    mutate: boundMutate,
-    get data() {
-      stateDependencies.data = true;
-      return returnedData;
-    },
-    get error() {
-      stateDependencies.error = true;
-      return error;
-    },
-    get isValidating() {
-      stateDependencies.isValidating = true;
-      return isValidating;
-    },
-    get isLoading() {
-      stateDependencies.isLoading = true;
-      return isLoading;
-    }
-  };
-  return swrResponse;
-};
-const SWRConfig = OBJECT.defineProperty(SWRConfig$1, "defaultValue", {
-  value: defaultConfig
-});
-const useSWR = withArgs(useSWRHandler);
-export {
-  SWRConfig as S,
-  useSWRConfig as a,
-  useSWR as u
-};