{"version":3,"sources":["webpack://_N_E/./node_modules/dequal/lite/index.mjs","webpack://_N_E/./node_modules/swr/esm/libs/hash.js","webpack://_N_E/./node_modules/swr/esm/cache.js","webpack://_N_E/./node_modules/swr/esm/libs/web-preset.js","webpack://_N_E/./node_modules/swr/esm/config.js","webpack://_N_E/./node_modules/swr/esm/env.js","webpack://_N_E/./node_modules/swr/esm/swr-config-context.js","webpack://_N_E/./node_modules/swr/esm/use-swr.js","webpack://_N_E/./node_modules/swr/esm/use-swr-infinite.js","webpack://_N_E/./node_modules/swr/esm/index.js"],"names":["has","Object","prototype","hasOwnProperty","table","WeakMap","counter","Cache","initialData","this","cache","Map","entries","subs","get","key","_key","serializeKey","set","value","notify","keys","Array","from","clear","delete","args","err","isArray","length","i","_hash","String","hash","subscribe","listener","_this","Error","isSubscribed","push","index","indexOf","_i","_a","online","isOnline","isDocumentVisible","document","undefined","visibilityState","fetcher","url","fetch","then","res","json","registerOnFocus","cb","window","addEventListener","registerOnReconnect","__assign","assign","t","s","n","arguments","p","call","apply","slowConnection","navigator","effectiveType","onLoadingSlow","onSuccess","onError","onErrorRetry","_","__","config","revalidate","opts","errorRetryCount","retryCount","count","Math","min","timeout","random","errorRetryInterval","setTimeout","focusThrottleInterval","dedupingInterval","loadingTimeout","refreshInterval","revalidateOnFocus","revalidateOnReconnect","refreshWhenHidden","refreshWhenOffline","shouldRetryOnError","suspense","compare","dequal","foo","bar","ctor","len","constructor","Date","getTime","RegExp","toString","isPaused","IS_SERVER","Deno","version","deno","rAF","f","useIsomorphicLayoutEffect","SWRConfigContext","displayName","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","step","next","e","rejected","result","done","__generator","body","y","g","label","sent","trys","ops","verb","Symbol","iterator","v","op","TypeError","pop","CONCURRENT_PROMISES","CONCURRENT_PROMISES_TS","FOCUS_REVALIDATORS","RECONNECT_REVALIDATORS","CACHE_REVALIDATORS","MUTATION_TS","MUTATION_END_TS","now","ts","revalidate_1","revalidators","trigger","shouldRevalidate","keyErr","keyValidating","updaters","currentData","currentError","currentIsValidating","promises","all","broadcastState","data","error","isValidating","_data","beforeMutationTs","beforeConcurrentPromisesTs","isAsyncMutation","err_1","shouldAbort","_b","defineProperty","Provider","SWRConfig","fn","fnArgs","configRef","current","willRevalidateOnMount","revalidateOnMount","resolveData","cachedData","resolveIsValidating","initialError","initialIsValidating","stateDependencies","stateRef","latestData","latestError","rerender","dispatch","payload","shouldUpdateState","k","unmountedRef","initialMountedRef","keyRef","eventsCallback","event","params","boundMutate","addRevalidator","callback","keyedRevalidators","revalidateOpts","dedupe","loading","shouldDeduping","newData","startAt","newState","err_2","_c","isUpdating","currentHookData","latestKeyedData","softRevalidate","pending","unsubFocus","unsubReconnect","unsubUpdate","updatedData","updatedError","updatedIsValidating","needUpdate","timer","tick","clearTimeout","memoizedState","state","mutate","defineProperties","enumerable","__rest","getOwnPropertySymbols","propertyIsEnumerable","useSWRInfinite","getKey","initialSize","revalidateAll","persistSize","extraConfig","firstPageKey","contextCacheKey","pageSizeCacheKey","didMountRef","resolvePageSize","cachedPageSize","lastPageSizeRef","dataRef","swr","originalData","force","pageSize","previousPageData","pageKey","pageArgs","pageData","setSize","arg","size","swrInfinite"],"mappings":"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","file":"static/chunks/5792b1a04faaacc33bd8c74428f3a3f88db42d51.cf7f0b3318f18accf5b7.js","sourcesContent":["var has = Object.prototype.hasOwnProperty;\n\nexport function dequal(foo, bar) {\n\tvar ctor, len;\n\tif (foo === bar) return true;\n\n\tif (foo && bar && (ctor=foo.constructor) === bar.constructor) {\n\t\tif (ctor === Date) return foo.getTime() === bar.getTime();\n\t\tif (ctor === RegExp) return foo.toString() === bar.toString();\n\n\t\tif (ctor === Array) {\n\t\t\tif ((len=foo.length) === bar.length) {\n\t\t\t\twhile (len-- && dequal(foo[len], bar[len]));\n\t\t\t}\n\t\t\treturn len === -1;\n\t\t}\n\n\t\tif (!ctor || typeof foo === 'object') {\n\t\t\tlen = 0;\n\t\t\tfor (ctor in foo) {\n\t\t\t\tif (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;\n\t\t\t\tif (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;\n\t\t\t}\n\t\t\treturn Object.keys(bar).length === len;\n\t\t}\n\t}\n\n\treturn foo !== foo && bar !== bar;\n}\n","// use WeakMap to store the object->key mapping\n// so the objects can be garbage collected.\n// WeakMap uses a hashtable under the hood, so the lookup\n// complexity is almost O(1).\nvar table = new WeakMap();\n// counter of the key\nvar counter = 0;\n// hashes an array of objects and returns a string\nexport default function hash(args) {\n    if (!args.length)\n        return '';\n    var key = 'arg';\n    for (var i = 0; i < args.length; ++i) {\n        if (args[i] === null) {\n            key += '@null';\n            continue;\n        }\n        var _hash = void 0;\n        if (typeof args[i] !== 'object' && typeof args[i] !== 'function') {\n            // need to consider the case that args[i] is a string:\n            // args[i]        _hash\n            // \"undefined\" -> '\"undefined\"'\n            // undefined   -> 'undefined'\n            // 123         -> '123'\n            // \"null\"      -> '\"null\"'\n            if (typeof args[i] === 'string') {\n                _hash = '\"' + args[i] + '\"';\n            }\n            else {\n                _hash = String(args[i]);\n            }\n        }\n        else {\n            if (!table.has(args[i])) {\n                _hash = counter;\n                table.set(args[i], counter++);\n            }\n            else {\n                _hash = table.get(args[i]);\n            }\n        }\n        key += '@' + _hash;\n    }\n    return key;\n}\n","import hash from './libs/hash';\nvar Cache = /** @class */ (function () {\n    function Cache(initialData) {\n        if (initialData === void 0) { initialData = {}; }\n        this.cache = new Map(Object.entries(initialData));\n        this.subs = [];\n    }\n    Cache.prototype.get = function (key) {\n        var _key = this.serializeKey(key)[0];\n        return this.cache.get(_key);\n    };\n    Cache.prototype.set = function (key, value) {\n        var _key = this.serializeKey(key)[0];\n        this.cache.set(_key, value);\n        this.notify();\n    };\n    Cache.prototype.keys = function () {\n        return Array.from(this.cache.keys());\n    };\n    Cache.prototype.has = function (key) {\n        var _key = this.serializeKey(key)[0];\n        return this.cache.has(_key);\n    };\n    Cache.prototype.clear = function () {\n        this.cache.clear();\n        this.notify();\n    };\n    Cache.prototype.delete = function (key) {\n        var _key = this.serializeKey(key)[0];\n        this.cache.delete(_key);\n        this.notify();\n    };\n    // TODO: introduce namespace for the cache\n    Cache.prototype.serializeKey = function (key) {\n        var args = null;\n        if (typeof key === 'function') {\n            try {\n                key = key();\n            }\n            catch (err) {\n                // dependencies not ready\n                key = '';\n            }\n        }\n        if (Array.isArray(key)) {\n            // args array\n            args = key;\n            key = hash(key);\n        }\n        else {\n            // convert null to ''\n            key = String(key || '');\n        }\n        var errorKey = key ? 'err@' + key : '';\n        var isValidatingKey = key ? 'validating@' + key : '';\n        return [key, args, errorKey, isValidatingKey];\n    };\n    Cache.prototype.subscribe = function (listener) {\n        var _this = this;\n        if (typeof listener !== 'function') {\n            throw new Error('Expected the listener to be a function.');\n        }\n        var isSubscribed = true;\n        this.subs.push(listener);\n        return function () {\n            if (!isSubscribed)\n                return;\n            isSubscribed = false;\n            var index = _this.subs.indexOf(listener);\n            if (index > -1) {\n                _this.subs[index] = _this.subs[_this.subs.length - 1];\n                _this.subs.length--;\n            }\n        };\n    };\n    // Notify Cache subscribers about a change in the cache\n    Cache.prototype.notify = function () {\n        for (var _i = 0, _a = this.subs; _i < _a.length; _i++) {\n            var listener = _a[_i];\n            listener();\n        }\n    };\n    return Cache;\n}());\nexport default Cache;\n","/**\n * Due to bug https://bugs.chromium.org/p/chromium/issues/detail?id=678075,\n * it's not reliable to detect if the browser is currently online or offline\n * based on `navigator.onLine`.\n * As a work around, we always assume it's online on first load, and change\n * the status upon `online` or `offline` events.\n */\nvar online = true;\nvar isOnline = function () { return online; };\nvar isDocumentVisible = function () {\n    if (typeof document !== 'undefined' &&\n        document.visibilityState !== undefined) {\n        return document.visibilityState !== 'hidden';\n    }\n    // always assume it's visible\n    return true;\n};\nvar fetcher = function (url) { return fetch(url).then(function (res) { return res.json(); }); };\nvar registerOnFocus = function (cb) {\n    if (typeof window !== 'undefined' &&\n        window.addEventListener !== undefined &&\n        typeof document !== 'undefined' &&\n        document.addEventListener !== undefined) {\n        // focus revalidate\n        document.addEventListener('visibilitychange', function () { return cb(); }, false);\n        window.addEventListener('focus', function () { return cb(); }, false);\n    }\n};\nvar registerOnReconnect = function (cb) {\n    if (typeof window !== 'undefined' && window.addEventListener !== undefined) {\n        // reconnect revalidate\n        window.addEventListener('online', function () {\n            online = true;\n            cb();\n        }, false);\n        // nothing to revalidate, just update the status\n        window.addEventListener('offline', function () { return (online = false); }, false);\n    }\n};\nexport default {\n    isOnline: isOnline,\n    isDocumentVisible: isDocumentVisible,\n    fetcher: fetcher,\n    registerOnFocus: registerOnFocus,\n    registerOnReconnect: registerOnReconnect\n};\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport { dequal } from 'dequal/lite';\nimport Cache from './cache';\nimport webPreset from './libs/web-preset';\n// cache\nvar cache = new Cache();\n// error retry\nfunction onErrorRetry(_, __, config, revalidate, opts) {\n    if (!config.isDocumentVisible()) {\n        // if it's hidden, stop\n        // it will auto revalidate when focus\n        return;\n    }\n    if (typeof config.errorRetryCount === 'number' &&\n        opts.retryCount > config.errorRetryCount) {\n        return;\n    }\n    // exponential backoff\n    var count = Math.min(opts.retryCount, 8);\n    var timeout = ~~((Math.random() + 0.5) * (1 << count)) * config.errorRetryInterval;\n    setTimeout(revalidate, timeout, opts);\n}\n// client side: need to adjust the config\n// based on the browser status\n// slow connection (<= 70Kbps)\nvar slowConnection = typeof window !== 'undefined' &&\n    // @ts-ignore\n    navigator['connection'] &&\n    // @ts-ignore\n    ['slow-2g', '2g'].indexOf(navigator['connection'].effectiveType) !== -1;\n// config\nvar defaultConfig = __assign({ \n    // events\n    onLoadingSlow: function () { }, onSuccess: function () { }, onError: function () { }, onErrorRetry: onErrorRetry, errorRetryInterval: (slowConnection ? 10 : 5) * 1000, focusThrottleInterval: 5 * 1000, dedupingInterval: 2 * 1000, loadingTimeout: (slowConnection ? 5 : 3) * 1000, refreshInterval: 0, revalidateOnFocus: true, revalidateOnReconnect: true, refreshWhenHidden: false, refreshWhenOffline: false, shouldRetryOnError: true, suspense: false, compare: dequal, isPaused: function () { return false; } }, webPreset);\nexport { cache };\nexport default defaultConfig;\n","import { useEffect, useLayoutEffect } from 'react';\nexport var IS_SERVER = typeof window === 'undefined' ||\n    // @ts-ignore\n    !!(typeof Deno !== 'undefined' && Deno && Deno.version && Deno.version.deno);\n// polyfill for requestAnimationFrame\nexport var rAF = IS_SERVER\n    ? null\n    : window['requestAnimationFrame']\n        ? function (f) { return window['requestAnimationFrame'](f); }\n        : function (f) { return setTimeout(f, 1); };\n// React currently throws a warning when using useLayoutEffect on the server.\n// To get around it, we can conditionally useEffect on the server (no-op) and\n// useLayoutEffect in the browser.\nexport var useIsomorphicLayoutEffect = IS_SERVER ? useEffect : useLayoutEffect;\n","import { createContext } from 'react';\nvar SWRConfigContext = createContext({});\nSWRConfigContext.displayName = 'SWRConfigContext';\nexport default SWRConfigContext;\n","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\n// TODO: use @ts-expect-error\nimport { useCallback, useContext, useState, useRef, useMemo, useDebugValue } from 'react';\nimport defaultConfig, { cache } from './config';\nimport { IS_SERVER, rAF, useIsomorphicLayoutEffect } from './env';\nimport SWRConfigContext from './swr-config-context';\n// global state managers\nvar CONCURRENT_PROMISES = {};\nvar CONCURRENT_PROMISES_TS = {};\nvar FOCUS_REVALIDATORS = {};\nvar RECONNECT_REVALIDATORS = {};\nvar CACHE_REVALIDATORS = {};\nvar MUTATION_TS = {};\nvar MUTATION_END_TS = {};\n// generate strictly increasing timestamps\nvar now = (function () {\n    var ts = 0;\n    return function () { return ++ts; };\n})();\n// setup DOM events listeners for `focus` and `reconnect` actions\nif (!IS_SERVER) {\n    var revalidate_1 = function (revalidators) {\n        if (!defaultConfig.isDocumentVisible() || !defaultConfig.isOnline())\n            return;\n        for (var key in revalidators) {\n            if (revalidators[key][0])\n                revalidators[key][0]();\n        }\n    };\n    if (typeof defaultConfig.registerOnFocus === 'function') {\n        defaultConfig.registerOnFocus(function () { return revalidate_1(FOCUS_REVALIDATORS); });\n    }\n    if (typeof defaultConfig.registerOnReconnect === 'function') {\n        defaultConfig.registerOnReconnect(function () { return revalidate_1(RECONNECT_REVALIDATORS); });\n    }\n}\nvar trigger = function (_key, shouldRevalidate) {\n    if (shouldRevalidate === void 0) { shouldRevalidate = true; }\n    // we are ignoring the second argument which correspond to the arguments\n    // the fetcher will receive when key is an array\n    var _a = cache.serializeKey(_key), key = _a[0], keyErr = _a[2], keyValidating = _a[3];\n    if (!key)\n        return Promise.resolve();\n    var updaters = CACHE_REVALIDATORS[key];\n    if (key && updaters) {\n        var currentData = cache.get(key);\n        var currentError = cache.get(keyErr);\n        var currentIsValidating = cache.get(keyValidating);\n        var promises = [];\n        for (var i = 0; i < updaters.length; ++i) {\n            promises.push(updaters[i](shouldRevalidate, currentData, currentError, currentIsValidating, i > 0));\n        }\n        // return new updated value\n        return Promise.all(promises).then(function () { return cache.get(key); });\n    }\n    return Promise.resolve(cache.get(key));\n};\nvar broadcastState = function (key, data, error, isValidating) {\n    var updaters = CACHE_REVALIDATORS[key];\n    if (key && updaters) {\n        for (var i = 0; i < updaters.length; ++i) {\n            updaters[i](false, data, error, isValidating);\n        }\n    }\n};\nvar mutate = function (_key, _data, shouldRevalidate) {\n    if (shouldRevalidate === void 0) { shouldRevalidate = true; }\n    return __awaiter(void 0, void 0, void 0, function () {\n        var _a, key, keyErr, beforeMutationTs, beforeConcurrentPromisesTs, data, error, isAsyncMutation, err_1, shouldAbort, updaters, promises, i;\n        return __generator(this, function (_b) {\n            switch (_b.label) {\n                case 0:\n                    _a = cache.serializeKey(_key), key = _a[0], keyErr = _a[2];\n                    if (!key)\n                        return [2 /*return*/];\n                    // if there is no new data to update, let's just revalidate the key\n                    if (typeof _data === 'undefined')\n                        return [2 /*return*/, trigger(_key, shouldRevalidate)\n                            // update global timestamps\n                        ];\n                    // update global timestamps\n                    MUTATION_TS[key] = now() - 1;\n                    MUTATION_END_TS[key] = 0;\n                    beforeMutationTs = MUTATION_TS[key];\n                    beforeConcurrentPromisesTs = CONCURRENT_PROMISES_TS[key];\n                    isAsyncMutation = false;\n                    if (_data && typeof _data === 'function') {\n                        // `_data` is a function, call it passing current cache value\n                        try {\n                            _data = _data(cache.get(key));\n                        }\n                        catch (err) {\n                            // if `_data` function throws an error synchronously, it shouldn't be cached\n                            _data = undefined;\n                            error = err;\n                        }\n                    }\n                    if (!(_data && typeof _data.then === 'function')) return [3 /*break*/, 5];\n                    // `_data` is a promise\n                    isAsyncMutation = true;\n                    _b.label = 1;\n                case 1:\n                    _b.trys.push([1, 3, , 4]);\n                    return [4 /*yield*/, _data];\n                case 2:\n                    data = _b.sent();\n                    return [3 /*break*/, 4];\n                case 3:\n                    err_1 = _b.sent();\n                    error = err_1;\n                    return [3 /*break*/, 4];\n                case 4: return [3 /*break*/, 6];\n                case 5:\n                    data = _data;\n                    _b.label = 6;\n                case 6:\n                    shouldAbort = function () {\n                        // check if other mutations have occurred since we've started this mutation\n                        if (beforeMutationTs !== MUTATION_TS[key] ||\n                            beforeConcurrentPromisesTs !== CONCURRENT_PROMISES_TS[key]) {\n                            if (error)\n                                throw error;\n                            return true;\n                        }\n                    };\n                    // if there's a race we don't update cache or broadcast change, just return the data\n                    if (shouldAbort())\n                        return [2 /*return*/, data];\n                    if (typeof data !== 'undefined') {\n                        // update cached data\n                        cache.set(key, data);\n                    }\n                    // always update or reset the error\n                    cache.set(keyErr, error);\n                    // reset the timestamp to mark the mutation has ended\n                    MUTATION_END_TS[key] = now() - 1;\n                    if (!isAsyncMutation) {\n                        // we skip broadcasting if there's another mutation happened synchronously\n                        if (shouldAbort())\n                            return [2 /*return*/, data];\n                    }\n                    updaters = CACHE_REVALIDATORS[key];\n                    if (updaters) {\n                        promises = [];\n                        for (i = 0; i < updaters.length; ++i) {\n                            promises.push(updaters[i](!!shouldRevalidate, data, error, undefined, i > 0));\n                        }\n                        // return new updated value\n                        return [2 /*return*/, Promise.all(promises).then(function () {\n                                if (error)\n                                    throw error;\n                                return cache.get(key);\n                            })];\n                    }\n                    // throw error or return data to be used by caller of mutate\n                    if (error)\n                        throw error;\n                    return [2 /*return*/, data];\n            }\n        });\n    });\n};\nfunction useSWR() {\n    var _this = this;\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    var _key = args[0];\n    var config = Object.assign({}, defaultConfig, useContext(SWRConfigContext), args.length > 2\n        ? args[2]\n        : args.length === 2 && typeof args[1] === 'object'\n            ? args[1]\n            : {});\n    // in typescript args.length > 2 is not same as args.lenth === 3\n    // we do a safe type assertion here\n    // args.length === 3\n    var fn = (args.length > 2\n        ? args[1]\n        : args.length === 2 && typeof args[1] === 'function'\n            ? args[1]\n            : /**\n                  pass fn as null will disable revalidate\n                  https://paco.sh/blog/shared-hook-state-with-swr\n                */\n                args[1] === null\n                    ? args[1]\n                    : config.fetcher);\n    // we assume `key` as the identifier of the request\n    // `key` can change but `fn` shouldn't\n    // (because `revalidate` only depends on `key`)\n    // `keyErr` is the cache key for error objects\n    var _a = cache.serializeKey(_key), key = _a[0], fnArgs = _a[1], keyErr = _a[2], keyValidating = _a[3];\n    var configRef = useRef(config);\n    useIsomorphicLayoutEffect(function () {\n        configRef.current = config;\n    });\n    var willRevalidateOnMount = function () {\n        return (config.revalidateOnMount ||\n            (!config.initialData && config.revalidateOnMount === undefined));\n    };\n    var resolveData = function () {\n        var cachedData = cache.get(key);\n        return typeof cachedData === 'undefined' ? config.initialData : cachedData;\n    };\n    var resolveIsValidating = function () {\n        return !!cache.get(keyValidating) || (key && willRevalidateOnMount());\n    };\n    var initialData = resolveData();\n    var initialError = cache.get(keyErr);\n    var initialIsValidating = resolveIsValidating();\n    // if a state is accessed (data, error or isValidating),\n    // we add the state to dependencies so if the state is\n    // updated in the future, we can trigger a rerender\n    var stateDependencies = useRef({\n        data: false,\n        error: false,\n        isValidating: false\n    });\n    var stateRef = useRef({\n        data: initialData,\n        error: initialError,\n        isValidating: initialIsValidating\n    });\n    // display the data label in the React DevTools next to SWR hooks\n    useDebugValue(stateRef.current.data);\n    var rerender = useState({})[1];\n    var dispatch = useCallback(function (payload) {\n        var shouldUpdateState = false;\n        for (var k in payload) {\n            // @ts-ignore\n            if (stateRef.current[k] === payload[k]) {\n                continue;\n            }\n            // @ts-ignore\n            stateRef.current[k] = payload[k];\n            // @ts-ignore\n            if (stateDependencies.current[k]) {\n                shouldUpdateState = true;\n            }\n        }\n        if (shouldUpdateState) {\n            // if component is unmounted, should skip rerender\n            // if component is not mounted, should skip rerender\n            if (unmountedRef.current || !initialMountedRef.current)\n                return;\n            rerender({});\n        }\n    }, \n    // config.suspense isn't allowed to change during the lifecycle\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    []);\n    // error ref inside revalidate (is last request errored?)\n    var unmountedRef = useRef(false);\n    var keyRef = useRef(key);\n    // check if component is mounted in suspense mode\n    var initialMountedRef = useRef(false);\n    // do unmount check for callbacks\n    var eventsCallback = useCallback(function (event) {\n        var _a;\n        var params = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            params[_i - 1] = arguments[_i];\n        }\n        if (unmountedRef.current)\n            return;\n        if (!initialMountedRef.current)\n            return;\n        if (key !== keyRef.current)\n            return;\n        // @ts-ignore\n        (_a = configRef.current)[event].apply(_a, params);\n    }, [key]);\n    var boundMutate = useCallback(function (data, shouldRevalidate) {\n        return mutate(keyRef.current, data, shouldRevalidate);\n    }, []);\n    var addRevalidator = function (revalidators, callback) {\n        if (!revalidators[key]) {\n            revalidators[key] = [callback];\n        }\n        else {\n            revalidators[key].push(callback);\n        }\n        return function () {\n            var keyedRevalidators = revalidators[key];\n            var index = keyedRevalidators.indexOf(callback);\n            if (index >= 0) {\n                // O(1): faster than splice\n                keyedRevalidators[index] =\n                    keyedRevalidators[keyedRevalidators.length - 1];\n                keyedRevalidators.pop();\n            }\n        };\n    };\n    // start a revalidation\n    var revalidate = useCallback(function (revalidateOpts) {\n        if (revalidateOpts === void 0) { revalidateOpts = {}; }\n        return __awaiter(_this, void 0, void 0, function () {\n            var _a, retryCount, _b, dedupe, loading, shouldDeduping, newData, startAt, newState, err_2;\n            return __generator(this, function (_c) {\n                switch (_c.label) {\n                    case 0:\n                        if (!key || !fn)\n                            return [2 /*return*/, false];\n                        if (unmountedRef.current)\n                            return [2 /*return*/, false];\n                        if (configRef.current.isPaused())\n                            return [2 /*return*/, false];\n                        _a = revalidateOpts.retryCount, retryCount = _a === void 0 ? 0 : _a, _b = revalidateOpts.dedupe, dedupe = _b === void 0 ? false : _b;\n                        loading = true;\n                        shouldDeduping = typeof CONCURRENT_PROMISES[key] !== 'undefined' && dedupe;\n                        _c.label = 1;\n                    case 1:\n                        _c.trys.push([1, 6, , 7]);\n                        dispatch({\n                            isValidating: true\n                        });\n                        cache.set(keyValidating, true);\n                        if (!shouldDeduping) {\n                            // also update other hooks\n                            broadcastState(key, stateRef.current.data, stateRef.current.error, true);\n                        }\n                        newData = void 0;\n                        startAt = void 0;\n                        if (!shouldDeduping) return [3 /*break*/, 3];\n                        // there's already an ongoing request,\n                        // this one needs to be deduplicated.\n                        startAt = CONCURRENT_PROMISES_TS[key];\n                        return [4 /*yield*/, CONCURRENT_PROMISES[key]];\n                    case 2:\n                        newData = _c.sent();\n                        return [3 /*break*/, 5];\n                    case 3:\n                        // if no cache being rendered currently (it shows a blank page),\n                        // we trigger the loading slow event.\n                        if (config.loadingTimeout && !cache.get(key)) {\n                            setTimeout(function () {\n                                if (loading)\n                                    eventsCallback('onLoadingSlow', key, config);\n                            }, config.loadingTimeout);\n                        }\n                        if (fnArgs !== null) {\n                            CONCURRENT_PROMISES[key] = fn.apply(void 0, fnArgs);\n                        }\n                        else {\n                            CONCURRENT_PROMISES[key] = fn(key);\n                        }\n                        CONCURRENT_PROMISES_TS[key] = startAt = now();\n                        return [4 /*yield*/, CONCURRENT_PROMISES[key]];\n                    case 4:\n                        newData = _c.sent();\n                        setTimeout(function () {\n                            delete CONCURRENT_PROMISES[key];\n                            delete CONCURRENT_PROMISES_TS[key];\n                        }, config.dedupingInterval);\n                        // trigger the success event,\n                        // only do this for the original request.\n                        eventsCallback('onSuccess', newData, key, config);\n                        _c.label = 5;\n                    case 5:\n                        // if there're other ongoing request(s), started after the current one,\n                        // we need to ignore the current one to avoid possible race conditions:\n                        //   req1------------------>res1        (current one)\n                        //        req2---------------->res2\n                        // the request that fired later will always be kept.\n                        if (CONCURRENT_PROMISES_TS[key] > startAt) {\n                            return [2 /*return*/, false];\n                        }\n                        // if there're other mutations(s), overlapped with the current revalidation:\n                        // case 1:\n                        //   req------------------>res\n                        //       mutate------>end\n                        // case 2:\n                        //         req------------>res\n                        //   mutate------>end\n                        // case 3:\n                        //   req------------------>res\n                        //       mutate-------...---------->\n                        // we have to ignore the revalidation result (res) because it's no longer fresh.\n                        // meanwhile, a new revalidation should be triggered when the mutation ends.\n                        if (MUTATION_TS[key] &&\n                            // case 1\n                            (startAt <= MUTATION_TS[key] ||\n                                // case 2\n                                startAt <= MUTATION_END_TS[key] ||\n                                // case 3\n                                MUTATION_END_TS[key] === 0)) {\n                            dispatch({ isValidating: false });\n                            return [2 /*return*/, false];\n                        }\n                        cache.set(keyErr, undefined);\n                        cache.set(keyValidating, false);\n                        newState = {\n                            isValidating: false\n                        };\n                        if (typeof stateRef.current.error !== 'undefined') {\n                            // we don't have an error\n                            newState.error = undefined;\n                        }\n                        if (!config.compare(stateRef.current.data, newData)) {\n                            // deep compare to avoid extra re-render\n                            // data changed\n                            newState.data = newData;\n                        }\n                        if (!config.compare(cache.get(key), newData)) {\n                            cache.set(key, newData);\n                        }\n                        // merge the new state\n                        dispatch(newState);\n                        if (!shouldDeduping) {\n                            // also update other hooks\n                            broadcastState(key, newData, newState.error, false);\n                        }\n                        return [3 /*break*/, 7];\n                    case 6:\n                        err_2 = _c.sent();\n                        delete CONCURRENT_PROMISES[key];\n                        delete CONCURRENT_PROMISES_TS[key];\n                        if (configRef.current.isPaused()) {\n                            dispatch({\n                                isValidating: false\n                            });\n                            return [2 /*return*/, false];\n                        }\n                        cache.set(keyErr, err_2);\n                        // get a new error\n                        // don't use deep equal for errors\n                        if (stateRef.current.error !== err_2) {\n                            // we keep the stale data\n                            dispatch({\n                                isValidating: false,\n                                error: err_2\n                            });\n                            if (!shouldDeduping) {\n                                // also broadcast to update other hooks\n                                broadcastState(key, undefined, err_2, false);\n                            }\n                        }\n                        // events and retry\n                        eventsCallback('onError', err_2, key, config);\n                        if (config.shouldRetryOnError) {\n                            // when retrying, we always enable deduping\n                            eventsCallback('onErrorRetry', err_2, key, config, revalidate, {\n                                retryCount: retryCount + 1,\n                                dedupe: true\n                            });\n                        }\n                        return [3 /*break*/, 7];\n                    case 7:\n                        loading = false;\n                        return [2 /*return*/, true];\n                }\n            });\n        });\n    }, \n    // dispatch is immutable, and `eventsCallback`, `fnArgs`, `keyErr`, and `keyValidating` are based on `key`,\n    // so we can them from the deps array.\n    //\n    // FIXME:\n    // `fn` and `config` might be changed during the lifecycle,\n    // but they might be changed every render like this.\n    // useSWR('key', () => fetch('/api/'), { suspense: true })\n    // So we omit the values from the deps array\n    // even though it might cause unexpected behaviors.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [key]);\n    // mounted (client side rendering)\n    useIsomorphicLayoutEffect(function () {\n        if (!key)\n            return undefined;\n        // after `key` updates, we need to mark it as mounted\n        unmountedRef.current = false;\n        var isUpdating = initialMountedRef.current;\n        initialMountedRef.current = true;\n        // after the component is mounted (hydrated),\n        // we need to update the data from the cache\n        // and trigger a revalidation\n        var currentHookData = stateRef.current.data;\n        var latestKeyedData = resolveData();\n        // update the state if the key changed (not the inital render) or cache updated\n        keyRef.current = key;\n        if (!config.compare(currentHookData, latestKeyedData)) {\n            dispatch({ data: latestKeyedData });\n        }\n        // revalidate with deduping\n        var softRevalidate = function () { return revalidate({ dedupe: true }); };\n        // trigger a revalidation\n        if (isUpdating || willRevalidateOnMount()) {\n            if (typeof latestKeyedData !== 'undefined' && !IS_SERVER) {\n                // delay revalidate if there's cache\n                // to not block the rendering\n                // @ts-ignore it's safe to use requestAnimationFrame in browser\n                rAF(softRevalidate);\n            }\n            else {\n                softRevalidate();\n            }\n        }\n        var pending = false;\n        var onFocus = function () {\n            if (pending || !configRef.current.revalidateOnFocus)\n                return;\n            pending = true;\n            softRevalidate();\n            setTimeout(function () { return (pending = false); }, configRef.current.focusThrottleInterval);\n        };\n        var onReconnect = function () {\n            if (configRef.current.revalidateOnReconnect) {\n                softRevalidate();\n            }\n        };\n        // register global cache update listener\n        var onUpdate = function (shouldRevalidate, updatedData, updatedError, updatedIsValidating, dedupe) {\n            if (shouldRevalidate === void 0) { shouldRevalidate = true; }\n            if (dedupe === void 0) { dedupe = true; }\n            // update hook state\n            var newState = {};\n            var needUpdate = false;\n            if (typeof updatedData !== 'undefined' &&\n                !config.compare(stateRef.current.data, updatedData)) {\n                newState.data = updatedData;\n                needUpdate = true;\n            }\n            // always update error\n            // because it can be `undefined`\n            if (stateRef.current.error !== updatedError) {\n                newState.error = updatedError;\n                needUpdate = true;\n            }\n            if (typeof updatedIsValidating !== 'undefined' &&\n                stateRef.current.isValidating !== updatedIsValidating) {\n                newState.isValidating = updatedIsValidating;\n                needUpdate = true;\n            }\n            if (needUpdate) {\n                dispatch(newState);\n            }\n            if (shouldRevalidate) {\n                if (dedupe) {\n                    return softRevalidate();\n                }\n                else {\n                    return revalidate();\n                }\n            }\n            return false;\n        };\n        var unsubFocus = addRevalidator(FOCUS_REVALIDATORS, onFocus);\n        var unsubReconnect = addRevalidator(RECONNECT_REVALIDATORS, onReconnect);\n        var unsubUpdate = addRevalidator(CACHE_REVALIDATORS, onUpdate);\n        return function () {\n            // cleanup\n            dispatch = function () { return null; };\n            // mark it as unmounted\n            unmountedRef.current = true;\n            unsubFocus();\n            unsubReconnect();\n            unsubUpdate();\n        };\n    }, [key, revalidate]);\n    useIsomorphicLayoutEffect(function () {\n        var timer = null;\n        var tick = function () { return __awaiter(_this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        if (!(!stateRef.current.error &&\n                            (configRef.current.refreshWhenHidden ||\n                                configRef.current.isDocumentVisible()) &&\n                            (configRef.current.refreshWhenOffline || configRef.current.isOnline()))) return [3 /*break*/, 2];\n                        // only revalidate when the page is visible\n                        // if API request errored, we stop polling in this round\n                        // and let the error retry function handle it\n                        return [4 /*yield*/, revalidate({ dedupe: true })];\n                    case 1:\n                        // only revalidate when the page is visible\n                        // if API request errored, we stop polling in this round\n                        // and let the error retry function handle it\n                        _a.sent();\n                        _a.label = 2;\n                    case 2:\n                        // Read the latest refreshInterval\n                        if (configRef.current.refreshInterval && timer) {\n                            timer = setTimeout(tick, configRef.current.refreshInterval);\n                        }\n                        return [2 /*return*/];\n                }\n            });\n        }); };\n        if (configRef.current.refreshInterval) {\n            timer = setTimeout(tick, configRef.current.refreshInterval);\n        }\n        return function () {\n            if (timer) {\n                clearTimeout(timer);\n                timer = null;\n            }\n        };\n    }, [\n        config.refreshInterval,\n        config.refreshWhenHidden,\n        config.refreshWhenOffline,\n        revalidate\n    ]);\n    // suspense\n    var latestData;\n    var latestError;\n    if (config.suspense) {\n        // in suspense mode, we can't return empty state\n        // (it should be suspended)\n        // try to get data and error from cache\n        latestData = cache.get(key);\n        latestError = cache.get(keyErr);\n        if (typeof latestData === 'undefined') {\n            latestData = initialData;\n        }\n        if (typeof latestError === 'undefined') {\n            latestError = initialError;\n        }\n        if (typeof latestData === 'undefined' &&\n            typeof latestError === 'undefined') {\n            // need to start the request if it hasn't\n            if (!CONCURRENT_PROMISES[key]) {\n                // trigger revalidate immediately\n                // to get the promise\n                // in this revalidate, should not rerender\n                revalidate();\n            }\n            if (CONCURRENT_PROMISES[key] &&\n                typeof CONCURRENT_PROMISES[key].then === 'function') {\n                // if it is a promise\n                throw CONCURRENT_PROMISES[key];\n            }\n            // it's a value, return it directly (override)\n            latestData = CONCURRENT_PROMISES[key];\n        }\n        if (typeof latestData === 'undefined' && latestError) {\n            // in suspense mode, throw error if there's no content\n            throw latestError;\n        }\n    }\n    // define returned state\n    // can be memorized since the state is a ref\n    var memoizedState = useMemo(function () {\n        // revalidate will be deprecated in the 1.x release\n        // because mutate() covers the same use case of revalidate().\n        // This remains only for backward compatibility\n        var state = { revalidate: revalidate, mutate: boundMutate };\n        Object.defineProperties(state, {\n            error: {\n                // `key` might be changed in the upcoming hook re-render,\n                // but the previous state will stay\n                // so we need to match the latest key and data (fallback to `initialData`)\n                get: function () {\n                    stateDependencies.current.error = true;\n                    if (config.suspense) {\n                        return latestError;\n                    }\n                    return keyRef.current === key ? stateRef.current.error : initialError;\n                },\n                enumerable: true\n            },\n            data: {\n                get: function () {\n                    stateDependencies.current.data = true;\n                    if (config.suspense) {\n                        return latestData;\n                    }\n                    return keyRef.current === key ? stateRef.current.data : initialData;\n                },\n                enumerable: true\n            },\n            isValidating: {\n                get: function () {\n                    stateDependencies.current.isValidating = true;\n                    return key ? stateRef.current.isValidating : false;\n                },\n                enumerable: true\n            }\n        });\n        return state;\n        // `config.suspense` isn't allowed to change during the lifecycle.\n        // `boundMutate` is immutable, and the immutability of `revalidate` depends on `key`\n        // so we can omit them from the deps array,\n        // but we put it to enable react-hooks/exhaustive-deps rule.\n        // `initialData` and `initialError` are not initial values\n        // because they are changed during the lifecycle\n        // so we should add them in the deps array.\n    }, [\n        revalidate,\n        initialData,\n        initialError,\n        boundMutate,\n        key,\n        config.suspense,\n        latestError,\n        latestData\n    ]);\n    return memoizedState;\n}\nObject.defineProperty(SWRConfigContext.Provider, 'default', {\n    value: defaultConfig\n});\nvar SWRConfig = SWRConfigContext.Provider;\nexport { trigger, mutate, SWRConfig };\nexport default useSWR;\n","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nvar __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\n// TODO: use @ts-expect-error\nimport { useContext, useRef, useState, useCallback } from 'react';\nimport defaultConfig, { cache } from './config';\nimport { useIsomorphicLayoutEffect } from './env';\nimport SWRConfigContext from './swr-config-context';\nimport useSWR from './use-swr';\nfunction useSWRInfinite() {\n    var _this = this;\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    var getKey = args[0];\n    var config = Object.assign({}, defaultConfig, useContext(SWRConfigContext), args.length > 2\n        ? args[2]\n        : args.length === 2 && typeof args[1] === 'object'\n            ? args[1]\n            : {});\n    // in typescript args.length > 2 is not same as args.lenth === 3\n    // we do a safe type assertion here\n    // args.length === 3\n    var fn = (args.length > 2\n        ? args[1]\n        : args.length === 2 && typeof args[1] === 'function'\n            ? args[1]\n            : config.fetcher);\n    var _a = config.initialSize, initialSize = _a === void 0 ? 1 : _a, _b = config.revalidateAll, revalidateAll = _b === void 0 ? false : _b, _c = config.persistSize, persistSize = _c === void 0 ? false : _c, extraConfig = __rest(config\n    // get the serialized key of the first page\n    , [\"initialSize\", \"revalidateAll\", \"persistSize\"]);\n    // get the serialized key of the first page\n    var firstPageKey = null;\n    try {\n        ;\n        firstPageKey = cache.serializeKey(getKey(0, null))[0];\n    }\n    catch (err) {\n        // not ready\n    }\n    var rerender = useState({})[1];\n    // we use cache to pass extra info (context) to fetcher so it can be globally shared\n    // here we get the key of the fetcher context cache\n    var contextCacheKey = null;\n    if (firstPageKey) {\n        contextCacheKey = 'ctx@' + firstPageKey;\n    }\n    // page size is also cached to share the page data between hooks having the same key\n    var pageSizeCacheKey = null;\n    if (firstPageKey) {\n        pageSizeCacheKey = 'len@' + firstPageKey;\n    }\n    var didMountRef = useRef(false);\n    var resolvePageSize = useCallback(function () {\n        var cachedPageSize = cache.get(pageSizeCacheKey);\n        return typeof cachedPageSize !== 'undefined' ? cachedPageSize : initialSize;\n    }, [pageSizeCacheKey, initialSize]);\n    // keep the last page size to restore it with the persistSize option\n    var lastPageSizeRef = useRef(resolvePageSize());\n    // every time the key changes, we reset the page size if it's not persisted\n    useIsomorphicLayoutEffect(function () {\n        if (!didMountRef.current) {\n            didMountRef.current = true;\n            return;\n        }\n        // If the key has been changed, we keep the current page size if persistSize is enabled\n        cache.set(pageSizeCacheKey, persistSize ? lastPageSizeRef.current : initialSize);\n        // initialSize isn't allowed to change during the lifecycle\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [firstPageKey]);\n    // keep the data inside a ref\n    var dataRef = useRef();\n    // actual swr of all pages\n    var swr = useSWR(firstPageKey ? ['inf', firstPageKey] : null, function () { return __awaiter(_this, void 0, void 0, function () {\n        var _a, originalData, force, data, pageSize, previousPageData, i, _b, pageKey, pageArgs, pageData, shouldFetchPage;\n        return __generator(this, function (_c) {\n            switch (_c.label) {\n                case 0:\n                    _a = cache.get(contextCacheKey) || {}, originalData = _a.data, force = _a.force;\n                    data = [];\n                    pageSize = resolvePageSize();\n                    previousPageData = null;\n                    i = 0;\n                    _c.label = 1;\n                case 1:\n                    if (!(i < pageSize)) return [3 /*break*/, 8];\n                    _b = cache.serializeKey(getKey(i, previousPageData)), pageKey = _b[0], pageArgs = _b[1];\n                    if (!pageKey) {\n                        // pageKey is falsy, stop fetching next pages\n                        return [3 /*break*/, 8];\n                    }\n                    pageData = cache.get(pageKey);\n                    shouldFetchPage = revalidateAll ||\n                        force ||\n                        typeof pageData === 'undefined' ||\n                        (typeof force === 'undefined' &&\n                            i === 0 &&\n                            typeof dataRef.current !== 'undefined') ||\n                        (originalData && !config.compare(originalData[i], pageData));\n                    if (!shouldFetchPage) return [3 /*break*/, 6];\n                    if (!(pageArgs !== null)) return [3 /*break*/, 3];\n                    return [4 /*yield*/, fn.apply(void 0, pageArgs)];\n                case 2:\n                    pageData = _c.sent();\n                    return [3 /*break*/, 5];\n                case 3: return [4 /*yield*/, fn(pageKey)];\n                case 4:\n                    pageData = _c.sent();\n                    _c.label = 5;\n                case 5:\n                    cache.set(pageKey, pageData);\n                    _c.label = 6;\n                case 6:\n                    data.push(pageData);\n                    previousPageData = pageData;\n                    _c.label = 7;\n                case 7:\n                    ++i;\n                    return [3 /*break*/, 1];\n                case 8:\n                    // once we executed the data fetching based on the context, clear the context\n                    cache.delete(contextCacheKey);\n                    // return the data\n                    return [2 /*return*/, data];\n            }\n        });\n    }); }, extraConfig);\n    // update dataRef\n    useIsomorphicLayoutEffect(function () {\n        dataRef.current = swr.data;\n    }, [swr.data]);\n    var mutate = useCallback(function (data, shouldRevalidate) {\n        if (shouldRevalidate === void 0) { shouldRevalidate = true; }\n        if (shouldRevalidate && typeof data !== 'undefined') {\n            // we only revalidate the pages that are changed\n            var originalData = dataRef.current;\n            cache.set(contextCacheKey, { data: originalData, force: false });\n        }\n        else if (shouldRevalidate) {\n            // calling `mutate()`, we revalidate all pages\n            cache.set(contextCacheKey, { force: true });\n        }\n        return swr.mutate(data, shouldRevalidate);\n    }, \n    // swr.mutate is always the same reference\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [contextCacheKey]);\n    // extend the SWR API\n    var setSize = useCallback(function (arg) {\n        var size;\n        if (typeof arg === 'function') {\n            size = arg(resolvePageSize());\n        }\n        else if (typeof arg === 'number') {\n            size = arg;\n        }\n        if (typeof size === 'number') {\n            cache.set(pageSizeCacheKey, size);\n            lastPageSizeRef.current = size;\n        }\n        rerender({});\n        return mutate(function (v) { return v; });\n    }, \n    // immutability of rerender is guaranteed by React, but react-hooks/exhaustive-deps doesn't recognize it\n    // from `rerender = useState({})[1], so we put rerender here\n    [pageSizeCacheKey, resolvePageSize, mutate, rerender]);\n    // Use getter functions to avoid unnecessary re-renders caused by triggering all the getters of the returned swr object\n    var swrInfinite = { size: resolvePageSize(), setSize: setSize, mutate: mutate };\n    Object.defineProperties(swrInfinite, {\n        error: {\n            get: function () { return swr.error; },\n            enumerable: true\n        },\n        data: {\n            get: function () { return swr.data; },\n            enumerable: true\n        },\n        // revalidate will be deprecated in the 1.x release\n        // because mutate() covers the same use case of revalidate().\n        // This remains only for backward compatibility\n        revalidate: {\n            get: function () { return swr.revalidate; },\n            enumerable: true\n        },\n        isValidating: {\n            get: function () { return swr.isValidating; },\n            enumerable: true\n        }\n    });\n    return swrInfinite;\n}\nexport { useSWRInfinite };\n","// `useSWR` and related APIs\nimport { default as useSWR } from './use-swr';\nexport default useSWR;\nexport * from './use-swr';\n// `useSWRInfinite`\nexport { useSWRInfinite } from './use-swr-infinite';\n// Cache related, to be replaced by the new APIs\nexport { cache } from './config';\n"],"sourceRoot":""}