@tonyclaw/llm-inspector 1.7.8 → 1.8.0

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

@@ -0,0 +1,938 @@
+import { r as reactExports, a 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 () => subs.splice(subs.indexOf(callback), 1);
+    };
+    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);
+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,
+  useSWR as u
+};