@pucp-gidis-hiisc/esm-fua-app 1.0.0

package/dist/vendors-node_modules_swr_dist_infinite_index_mjs.js

@@ -0,0 +1,815 @@
+"use strict";
+(globalThis["webpackChunk_pucp_gidis_hiisc_esm_dyaku_app"] = globalThis["webpackChunk_pucp_gidis_hiisc_esm_dyaku_app"] || []).push([["vendors-node_modules_swr_dist_infinite_index_mjs"],{
+
+/***/ "../../node_modules/swr/dist/infinite/index.mjs":
+/*!******************************************************!*\
+  !*** ../../node_modules/swr/dist/infinite/index.mjs ***!
+  \******************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (/* binding */ useSWRInfinite),
+/* harmony export */   infinite: () => (/* binding */ infinite),
+/* harmony export */   unstable_serialize: () => (/* binding */ unstable_serialize)
+/* harmony export */ });
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "webpack/sharing/consume/default/react/react");
+/* harmony import */ var client_only__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! client-only */ "../../node_modules/client-only/index.js");
+/* harmony import */ var use_sync_external_store_shim_index_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! use-sync-external-store/shim/index.js */ "../../node_modules/use-sync-external-store/shim/index.js");
+/* harmony import */ var swr_internal__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! swr/_internal */ "webpack/sharing/consume/default/swr/_internal/swr/_internal");
+
+
+
+
+
+/// <reference types="react/experimental" />
+const use = react__WEBPACK_IMPORTED_MODULE_0__.use || ((promise)=>{
+    if (promise.status === 'pending') {
+        throw promise;
+    } else if (promise.status === 'fulfilled') {
+        return promise.value;
+    } else if (promise.status === 'rejected') {
+        throw promise.reason;
+    } else {
+        promise.status = 'pending';
+        promise.then((v)=>{
+            promise.status = 'fulfilled';
+            promise.value = v;
+        }, (e)=>{
+            promise.status = 'rejected';
+            promise.reason = e;
+        });
+        throw promise;
+    }
+});
+const WITH_DEDUPE = {
+    dedupe: true
+};
+const useSWRHandler = (_key, fetcher, config)=>{
+    const { cache, compare, suspense, fallbackData, revalidateOnMount, revalidateIfStale, refreshInterval, refreshWhenHidden, refreshWhenOffline, keepPreviousData } = config;
+    const [EVENT_REVALIDATORS, MUTATION, FETCH, PRELOAD] = swr_internal__WEBPACK_IMPORTED_MODULE_3__.SWRGlobalState.get(cache);
+    // `key` is the identifier of the SWR internal state,
+    // `fnArg` is the argument/arguments parsed from the key, which will be passed
+    // to the fetcher.
+    // All of them are derived from `_key`.
+    const [key, fnArg] = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.serialize)(_key);
+    // If it's the initial render of this hook.
+    const initialMountedRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(false);
+    // If the hook is unmounted already. This will be used to prevent some effects
+    // to be called after unmounting.
+    const unmountedRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(false);
+    // Refs to keep the key and config.
+    const keyRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(key);
+    const fetcherRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(fetcher);
+    const configRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(config);
+    const getConfig = ()=>configRef.current;
+    const isActive = ()=>getConfig().isVisible() && getConfig().isOnline();
+    const [getCache, setCache, subscribeCache, getInitialCache] = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.createCacheHelper)(cache, key);
+    const stateDependencies = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)({}).current;
+    const fallback = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(fallbackData) ? config.fallback[key] : fallbackData;
+    const isEqual = (prev, current)=>{
+        for(const _ in stateDependencies){
+            const t = _;
+            if (t === 'data') {
+                if (!compare(prev[t], current[t])) {
+                    if (!(0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(prev[t])) {
+                        return false;
+                    }
+                    if (!compare(returnedData, current[t])) {
+                        return false;
+                    }
+                }
+            } else {
+                if (current[t] !== prev[t]) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    };
+    const getSnapshot = (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(()=>{
+        const shouldStartRequest = (()=>{
+            if (!key) return false;
+            if (!fetcher) return false;
+            // If `revalidateOnMount` is set, we take the value directly.
+            if (!(0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(revalidateOnMount)) return revalidateOnMount;
+            // If it's paused, we skip revalidation.
+            if (getConfig().isPaused()) return false;
+            if (suspense) return false;
+            if (!(0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(revalidateIfStale)) return revalidateIfStale;
+            return true;
+        })();
+        // Get the cache and merge it with expected states.
+        const getSelectedCache = (state)=>{
+            // We only select the needed fields from the state.
+            const snapshot = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.mergeObjects)(state);
+            delete snapshot._k;
+            if (!shouldStartRequest) {
+                return snapshot;
+            }
+            return {
+                isValidating: true,
+                isLoading: true,
+                ...snapshot
+            };
+        };
+        const cachedData = getCache();
+        const initialData = getInitialCache();
+        const clientSnapshot = getSelectedCache(cachedData);
+        const serverSnapshot = cachedData === initialData ? clientSnapshot : getSelectedCache(initialData);
+        // To make sure that we are returning the same object reference to avoid
+        // unnecessary re-renders, we keep the previous snapshot and use deep
+        // comparison to check if we need to return a new one.
+        let memorizedSnapshot = clientSnapshot;
+        return [
+            ()=>{
+                const newSnapshot = getSelectedCache(getCache());
+                const compareResult = isEqual(newSnapshot, memorizedSnapshot);
+                if (compareResult) {
+                    // Mentally, we should always return the `memorizedSnapshot` here
+                    // as there's no change between the new and old snapshots.
+                    // However, since the `isEqual` function only compares selected fields,
+                    // the values of the unselected fields might be changed. That's
+                    // simply because we didn't track them.
+                    // To support the case in https://github.com/vercel/swr/pull/2576,
+                    // we need to update these fields in the `memorizedSnapshot` too
+                    // with direct mutations to ensure the snapshot is always up-to-date
+                    // even for the unselected fields, but only trigger re-renders when
+                    // the selected fields are changed.
+                    memorizedSnapshot.data = newSnapshot.data;
+                    memorizedSnapshot.isLoading = newSnapshot.isLoading;
+                    memorizedSnapshot.isValidating = newSnapshot.isValidating;
+                    memorizedSnapshot.error = newSnapshot.error;
+                    return memorizedSnapshot;
+                } else {
+                    memorizedSnapshot = newSnapshot;
+                    return newSnapshot;
+                }
+            },
+            ()=>serverSnapshot
+        ];
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [
+        cache,
+        key
+    ]);
+    // Get the current state that SWR should return.
+    const cached = (0,use_sync_external_store_shim_index_js__WEBPACK_IMPORTED_MODULE_2__.useSyncExternalStore)((0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)((callback)=>subscribeCache(key, (current, prev)=>{
+            if (!isEqual(prev, current)) callback();
+        }), // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+        cache,
+        key
+    ]), getSnapshot[0], getSnapshot[1]);
+    const isInitialMount = !initialMountedRef.current;
+    const hasRevalidator = EVENT_REVALIDATORS[key] && EVENT_REVALIDATORS[key].length > 0;
+    const cachedData = cached.data;
+    const data = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.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,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(data);
+    const returnedData = keepPreviousData ? (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.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.
+    const shouldDoInitialRevalidation = (()=>{
+        // if a key already has revalidators and also has error, we should not trigger revalidation
+        if (hasRevalidator && !(0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(error)) return false;
+        // If `revalidateOnMount` is set, we take the value directly.
+        if (isInitialMount && !(0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(revalidateOnMount)) return revalidateOnMount;
+        // If it's paused, we skip revalidation.
+        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 mount it again.
+        // If data exists, only revalidate if `revalidateIfStale` is true.
+        if (suspense) return (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(data) ? false : revalidateIfStale;
+        // If there is no stale data, we need to revalidate when mount;
+        // If `revalidateIfStale` is set to true, we will always revalidate.
+        return (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(data) || revalidateIfStale;
+    })();
+    // 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 = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(cached.isValidating) ? defaultValidatingState : cached.isValidating;
+    const isLoading = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.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.
+    const revalidate = (0,react__WEBPACK_IMPORTED_MODULE_0__.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 (swr_internal__WEBPACK_IMPORTED_MODULE_3__.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 ((0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.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 && (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(getCache().data)) {
+                    setTimeout(()=>{
+                        if (loading && callbackSafeguard()) {
+                            getConfig().onLoadingSlow(key, config);
+                        }
+                    }, config.loadingTimeout);
+                }
+                // Start the request and save the timestamp.
+                // Key must be truthy if entering here.
+                FETCH[key] = [
+                    currentFetcher(fnArg),
+                    (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.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);
+                    }
+                }
+                return false;
+            }
+            // Clear error.
+            finalState.error = swr_internal__WEBPACK_IMPORTED_MODULE_3__.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 (!(0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.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;
+            }
+            // 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 || (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isFunction)(shouldRetryOnError) && shouldRetryOnError(err)) {
+                        if (!getConfig().revalidateOnFocus || !getConfig().revalidateOnReconnect || 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, (_opts)=>{
+                                const revalidators = EVENT_REVALIDATORS[key];
+                                if (revalidators && revalidators[0]) {
+                                    revalidators[0](swr_internal__WEBPACK_IMPORTED_MODULE_3__.revalidateEvents.ERROR_REVALIDATE_EVENT, _opts);
+                                }
+                            }, {
+                                retryCount: (opts.retryCount || 0) + 1,
+                                dedupe: true
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        // 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:
+    // `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,
+        cache
+    ]);
+    // Similar to the global mutate but bound to the current cache and key.
+    // `cache` isn't allowed to change during the lifecycle.
+    const boundMutate = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)(// Use callback to make sure `keyRef.current` returns latest result every time
+    (...args)=>{
+        return (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.internalMutate)(cache, keyRef.current, ...args);
+    }, // eslint-disable-next-line react-hooks/exhaustive-deps
+    []);
+    // The logic for updating refs.
+    (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.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 (!(0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(cachedData)) {
+            laggyDataRef.current = cachedData;
+        }
+    });
+    // After mounted or key changed.
+    (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.useIsomorphicLayoutEffect)(()=>{
+        if (!key) return;
+        const softRevalidate = revalidate.bind(swr_internal__WEBPACK_IMPORTED_MODULE_3__.UNDEFINED, WITH_DEDUPE);
+        // Expose revalidators to global event listeners. So we can trigger
+        // revalidation from the outside.
+        let nextFocusRevalidatedAt = 0;
+        const onRevalidate = (type, opts = {})=>{
+            if (type == swr_internal__WEBPACK_IMPORTED_MODULE_3__.revalidateEvents.FOCUS_EVENT) {
+                const now = Date.now();
+                if (getConfig().revalidateOnFocus && now > nextFocusRevalidatedAt && isActive()) {
+                    nextFocusRevalidatedAt = now + getConfig().focusThrottleInterval;
+                    softRevalidate();
+                }
+            } else if (type == swr_internal__WEBPACK_IMPORTED_MODULE_3__.revalidateEvents.RECONNECT_EVENT) {
+                if (getConfig().revalidateOnReconnect && isActive()) {
+                    softRevalidate();
+                }
+            } else if (type == swr_internal__WEBPACK_IMPORTED_MODULE_3__.revalidateEvents.MUTATE_EVENT) {
+                return revalidate();
+            } else if (type == swr_internal__WEBPACK_IMPORTED_MODULE_3__.revalidateEvents.ERROR_REVALIDATE_EVENT) {
+                return revalidate(opts);
+            }
+            return;
+        };
+        const unsubEvents = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.subscribeCallback)(key, EVENT_REVALIDATORS, onRevalidate);
+        // Mark the component as mounted and update corresponding refs.
+        unmountedRef.current = false;
+        keyRef.current = key;
+        initialMountedRef.current = true;
+        // Keep the original key in the cache.
+        setCache({
+            _k: fnArg
+        });
+        // Trigger a revalidation
+        if (shouldDoInitialRevalidation) {
+            if ((0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(data) || swr_internal__WEBPACK_IMPORTED_MODULE_3__.IS_SERVER) {
+                // Revalidate immediately.
+                softRevalidate();
+            } else {
+                // Delay the revalidate if we have data to return so we won't block
+                // rendering.
+                (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.rAF)(softRevalidate);
+            }
+        }
+        return ()=>{
+            // Mark it as unmounted.
+            unmountedRef.current = true;
+            unsubEvents();
+        };
+    }, [
+        key
+    ]);
+    // Polling
+    (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.useIsomorphicLayoutEffect)(()=>{
+        let timer;
+        function next() {
+            // Use the passed interval
+            // ...or invoke the function with the updated data to get the interval
+            const interval = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isFunction)(refreshInterval) ? refreshInterval(getCache().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) {
+                timer = setTimeout(execute, interval);
+            }
+        }
+        function execute() {
+            // Check if it's OK to execute:
+            // 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 the next interval to check again.
+                next();
+            }
+        }
+        next();
+        return ()=>{
+            if (timer) {
+                clearTimeout(timer);
+                timer = -1;
+            }
+        };
+    }, [
+        refreshInterval,
+        refreshWhenHidden,
+        refreshWhenOffline,
+        key
+    ]);
+    // Display debug info in React DevTools.
+    (0,react__WEBPACK_IMPORTED_MODULE_0__.useDebugValue)(returnedData);
+    // In Suspense mode, we can't return the empty `data` state.
+    // 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 && (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.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 (!swr_internal__WEBPACK_IMPORTED_MODULE_3__.IS_REACT_LEGACY && swr_internal__WEBPACK_IMPORTED_MODULE_3__.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;
+        unmountedRef.current = false;
+        const req = PRELOAD[key];
+        if (!(0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(req)) {
+            const promise = boundMutate(req);
+            use(promise);
+        }
+        if ((0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(error)) {
+            const promise = revalidate(WITH_DEDUPE);
+            if (!(0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(returnedData)) {
+                promise.status = 'fulfilled';
+                promise.value = true;
+            }
+            use(promise);
+        } else {
+            throw error;
+        }
+    }
+    return {
+        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;
+        }
+    };
+};
+swr_internal__WEBPACK_IMPORTED_MODULE_3__.OBJECT.defineProperty(swr_internal__WEBPACK_IMPORTED_MODULE_3__.SWRConfig, 'defaultValue', {
+    value: swr_internal__WEBPACK_IMPORTED_MODULE_3__.defaultConfig
+});
+/**
+ * A hook to fetch data.
+ *
+ * @link https://swr.vercel.app
+ * @example
+ * ```jsx
+ * import useSWR from 'swr'
+ * function Profile() {
+ *   const { data, error, isLoading } = useSWR('/api/user', fetcher)
+ *   if (error) return <div>failed to load</div>
+ *   if (isLoading) return <div>loading...</div>
+ *   return <div>hello {data.name}!</div>
+ * }
+ * ```
+ */ const useSWR = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.withArgs)(useSWRHandler);
+
+const getFirstPageKey = (getKey)=>{
+    return (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.serialize)(getKey ? getKey(0, null) : null)[0];
+};
+const unstable_serialize = (getKey)=>{
+    return swr_internal__WEBPACK_IMPORTED_MODULE_3__.INFINITE_PREFIX + getFirstPageKey(getKey);
+};
+
+// We have to several type castings here because `useSWRInfinite` is a special
+// hook where `key` and return type are not like the normal `useSWR` types.
+// const INFINITE_PREFIX = '$inf$'
+const EMPTY_PROMISE = Promise.resolve();
+// export const unstable_serialize = (getKey: SWRInfiniteKeyLoader) => {
+//   return INFINITE_PREFIX + getFirstPageKey(getKey)
+// }
+const infinite = (useSWRNext)=>(getKey, fn, config)=>{
+        const didMountRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(false);
+        const { cache: cache$1, initialSize = 1, revalidateAll = false, persistSize = false, revalidateFirstPage = true, revalidateOnMount = false, parallel = false } = config;
+        const [, , , PRELOAD] = swr_internal__WEBPACK_IMPORTED_MODULE_3__.SWRGlobalState.get(swr_internal__WEBPACK_IMPORTED_MODULE_3__.cache);
+        // The serialized key of the first page. This key will be used to store
+        // metadata of this SWR infinite hook.
+        let infiniteKey;
+        try {
+            infiniteKey = getFirstPageKey(getKey);
+            if (infiniteKey) infiniteKey = swr_internal__WEBPACK_IMPORTED_MODULE_3__.INFINITE_PREFIX + infiniteKey;
+        } catch (err) {
+        // Not ready yet.
+        }
+        const [get, set, subscribeCache] = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.createCacheHelper)(cache$1, infiniteKey);
+        const getSnapshot = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)(()=>{
+            const size = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(get()._l) ? initialSize : get()._l;
+            return size;
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        }, [
+            cache$1,
+            infiniteKey,
+            initialSize
+        ]);
+        (0,use_sync_external_store_shim_index_js__WEBPACK_IMPORTED_MODULE_2__.useSyncExternalStore)((0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)((callback)=>{
+            if (infiniteKey) return subscribeCache(infiniteKey, ()=>{
+                callback();
+            });
+            return ()=>{};
+        }, // eslint-disable-next-line react-hooks/exhaustive-deps
+        [
+            cache$1,
+            infiniteKey
+        ]), getSnapshot, getSnapshot);
+        const resolvePageSize = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)(()=>{
+            const cachedPageSize = get()._l;
+            return (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(cachedPageSize) ? initialSize : cachedPageSize;
+        // `cache` isn't allowed to change during the lifecycle
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        }, [
+            infiniteKey,
+            initialSize
+        ]);
+        // keep the last page size to restore it with the persistSize option
+        const lastPageSizeRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(resolvePageSize());
+        // When the page key changes, we reset the page size if it's not persisted
+        (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.useIsomorphicLayoutEffect)(()=>{
+            if (!didMountRef.current) {
+                didMountRef.current = true;
+                return;
+            }
+            if (infiniteKey) {
+                // If the key has been changed, we keep the current page size if persistSize is enabled
+                // Otherwise, we reset the page size to cached pageSize
+                set({
+                    _l: persistSize ? lastPageSizeRef.current : resolvePageSize()
+                });
+            }
+        // `initialSize` isn't allowed to change during the lifecycle
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        }, [
+            infiniteKey,
+            cache$1
+        ]);
+        // Needs to check didMountRef during mounting, not in the fetcher
+        const shouldRevalidateOnMount = revalidateOnMount && !didMountRef.current;
+        // Actual SWR hook to load all pages in one fetcher.
+        const swr = useSWRNext(infiniteKey, async (key)=>{
+            // get the revalidate context
+            const forceRevalidateAll = get()._i;
+            const shouldRevalidatePage = get()._r;
+            set({
+                _r: swr_internal__WEBPACK_IMPORTED_MODULE_3__.UNDEFINED
+            });
+            // return an array of page data
+            const data = [];
+            const pageSize = resolvePageSize();
+            const [getCache] = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.createCacheHelper)(cache$1, key);
+            const cacheData = getCache().data;
+            const revalidators = [];
+            let previousPageData = null;
+            for(let i = 0; i < pageSize; ++i){
+                const [pageKey, pageArg] = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.serialize)(getKey(i, parallel ? null : previousPageData));
+                if (!pageKey) {
+                    break;
+                }
+                const [getSWRCache, setSWRCache] = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.createCacheHelper)(cache$1, pageKey);
+                // Get the cached page data.
+                let pageData = getSWRCache().data;
+                // should fetch (or revalidate) if:
+                // - `revalidateAll` is enabled
+                // - `mutate()` called
+                // - the cache is missing
+                // - it's the first page and it's not the initial render
+                // - `revalidateOnMount` is enabled and it's on mount
+                // - cache for that page has changed
+                const shouldFetchPage = revalidateAll || forceRevalidateAll || (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(pageData) || revalidateFirstPage && !i && !(0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(cacheData) || shouldRevalidateOnMount || cacheData && !(0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(cacheData[i]) && !config.compare(cacheData[i], pageData);
+                if (fn && (typeof shouldRevalidatePage === 'function' ? shouldRevalidatePage(pageData, pageArg) : shouldFetchPage)) {
+                    const revalidate = async ()=>{
+                        const hasPreloadedRequest = pageKey in PRELOAD;
+                        if (!hasPreloadedRequest) {
+                            pageData = await fn(pageArg);
+                        } else {
+                            const req = PRELOAD[pageKey];
+                            // delete the preload cache key before resolving it
+                            // in case there's an error
+                            delete PRELOAD[pageKey];
+                            // get the page data from the preload cache
+                            pageData = await req;
+                        }
+                        setSWRCache({
+                            data: pageData,
+                            _k: pageArg
+                        });
+                        data[i] = pageData;
+                    };
+                    if (parallel) {
+                        revalidators.push(revalidate);
+                    } else {
+                        await revalidate();
+                    }
+                } else {
+                    data[i] = pageData;
+                }
+                if (!parallel) {
+                    previousPageData = pageData;
+                }
+            }
+            // flush all revalidateions in parallel
+            if (parallel) {
+                await Promise.all(revalidators.map((r)=>r()));
+            }
+            // once we executed the data fetching based on the context, clear the context
+            set({
+                _i: swr_internal__WEBPACK_IMPORTED_MODULE_3__.UNDEFINED
+            });
+            // return the data
+            return data;
+        }, config);
+        const mutate = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)(// eslint-disable-next-line func-names
+        function(data, opts) {
+            // When passing as a boolean, it's explicitly used to disable/enable
+            // revalidation.
+            const options = typeof opts === 'boolean' ? {
+                revalidate: opts
+            } : opts || {};
+            // Default to true.
+            const shouldRevalidate = options.revalidate !== false;
+            // It is possible that the key is still falsy.
+            if (!infiniteKey) return EMPTY_PROMISE;
+            if (shouldRevalidate) {
+                if (!(0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(data)) {
+                    // We only revalidate the pages that are changed
+                    set({
+                        _i: false,
+                        _r: options.revalidate
+                    });
+                } else {
+                    // Calling `mutate()`, we revalidate all pages
+                    set({
+                        _i: true,
+                        _r: options.revalidate
+                    });
+                }
+            }
+            return arguments.length ? swr.mutate(data, {
+                ...options,
+                revalidate: shouldRevalidate
+            }) : swr.mutate();
+        }, // swr.mutate is always the same reference
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        [
+            infiniteKey,
+            cache$1
+        ]);
+        // Extend the SWR API
+        const setSize = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)((arg)=>{
+            // It is possible that the key is still falsy.
+            if (!infiniteKey) return EMPTY_PROMISE;
+            const [, changeSize] = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.createCacheHelper)(cache$1, infiniteKey);
+            let size;
+            if ((0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isFunction)(arg)) {
+                size = arg(resolvePageSize());
+            } else if (typeof arg == 'number') {
+                size = arg;
+            }
+            if (typeof size != 'number') return EMPTY_PROMISE;
+            changeSize({
+                _l: size
+            });
+            lastPageSizeRef.current = size;
+            // Calculate the page data after the size change.
+            const data = [];
+            const [getInfiniteCache] = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.createCacheHelper)(cache$1, infiniteKey);
+            let previousPageData = null;
+            for(let i = 0; i < size; ++i){
+                const [pageKey] = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.serialize)(getKey(i, previousPageData));
+                const [getCache] = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.createCacheHelper)(cache$1, pageKey);
+                // Get the cached page data.
+                const pageData = pageKey ? getCache().data : swr_internal__WEBPACK_IMPORTED_MODULE_3__.UNDEFINED;
+                // Call `mutate` with infinte cache data if we can't get it from the page cache.
+                if ((0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.isUndefined)(pageData)) {
+                    return mutate(getInfiniteCache().data);
+                }
+                data.push(pageData);
+                previousPageData = pageData;
+            }
+            return mutate(data);
+        }, // exclude getKey from the dependencies, which isn't allowed to change during the lifecycle
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        [
+            infiniteKey,
+            cache$1,
+            mutate,
+            resolvePageSize
+        ]);
+        // Use getter functions to avoid unnecessary re-renders caused by triggering
+        // all the getters of the returned swr object.
+        return {
+            size: resolvePageSize(),
+            setSize,
+            mutate,
+            get data () {
+                return swr.data;
+            },
+            get error () {
+                return swr.error;
+            },
+            get isValidating () {
+                return swr.isValidating;
+            },
+            get isLoading () {
+                return swr.isLoading;
+            }
+        };
+    };
+const useSWRInfinite = (0,swr_internal__WEBPACK_IMPORTED_MODULE_3__.withMiddleware)(useSWR, infinite);
+
+
+
+
+/***/ })
+
+}]);
+//# sourceMappingURL=vendors-node_modules_swr_dist_infinite_index_mjs.js.map