{"version":3,"file":"static/chunks/4355.10a666b084bfd44d.js","mappings":"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","sources":["webpack://_N_E/./node_modules/react-spinners/SyncLoader.js","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/libs/web-preset.js","webpack://_N_E/./node_modules/swr/esm/config.js","webpack://_N_E/./node_modules/swr/esm/cache.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/index.js"],"sourcesContent":["\"use strict\";\nvar __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\n    return cooked;\n};\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\n    result[\"default\"] = mod;\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/** @jsx jsx */\nvar React = __importStar(require(\"react\"));\nvar core_1 = require(\"@emotion/core\");\nvar proptypes_1 = require(\"./helpers/proptypes\");\nvar helpers_1 = require(\"./helpers\");\nvar sync = core_1.keyframes(templateObject_1 || (templateObject_1 = __makeTemplateObject([\"\\n  33% {transform: translateY(10px)}\\n  66% {transform: translateY(-10px)}\\n  100% {transform: translateY(0)}\\n\"], [\"\\n  33% {transform: translateY(10px)}\\n  66% {transform: translateY(-10px)}\\n  100% {transform: translateY(0)}\\n\"])));\nvar Loader = /** @class */ (function (_super) {\n    __extends(Loader, _super);\n    function Loader() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.style = function (i) {\n            var _a = _this.props, color = _a.color, size = _a.size, margin = _a.margin;\n            return core_1.css(templateObject_2 || (templateObject_2 = __makeTemplateObject([\"\\n      background-color: \", \";\\n      width: \", \";\\n      height: \", \";\\n      margin: \", \";\\n      border-radius: 100%;\\n      display: inline-block;\\n      animation: \", \" 0.6s \", \"s infinite ease-in-out;\\n      animation-fill-mode: both;\\n    \"], [\"\\n      background-color: \", \";\\n      width: \", \";\\n      height: \", \";\\n      margin: \", \";\\n      border-radius: 100%;\\n      display: inline-block;\\n      animation: \", \" 0.6s \", \"s infinite ease-in-out;\\n      animation-fill-mode: both;\\n    \"])), color, helpers_1.cssValue(size), helpers_1.cssValue(size), helpers_1.cssValue(margin), sync, i * 0.07);\n        };\n        return _this;\n    }\n    Loader.prototype.render = function () {\n        var _a = this.props, loading = _a.loading, css = _a.css;\n        return loading ? (core_1.jsx(\"div\", { css: [css] },\n            core_1.jsx(\"div\", { css: this.style(1) }),\n            core_1.jsx(\"div\", { css: this.style(2) }),\n            core_1.jsx(\"div\", { css: this.style(3) }))) : null;\n    };\n    Loader.defaultProps = proptypes_1.sizeMarginDefaults(15);\n    return Loader;\n}(React.PureComponent));\nexports.default = Loader;\nvar templateObject_1, templateObject_2;\n","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","function isOnline() {\n    if (typeof navigator.onLine !== 'undefined') {\n        return navigator.onLine;\n    }\n    // always assume it's online\n    return true;\n}\nfunction isDocumentVisible() {\n    if (typeof document !== 'undefined' &&\n        typeof 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(); }); };\nexport default {\n    isOnline: isOnline,\n    isDocumentVisible: isDocumentVisible,\n    fetcher: fetcher\n};\n","import { 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 || 0, 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    navigator['connection'] &&\n    ['slow-2g', '2g'].indexOf(navigator['connection'].effectiveType) !== -1;\n// config\nvar defaultConfig = {\n    // events\n    onLoadingSlow: function () { },\n    onSuccess: function () { },\n    onError: function () { },\n    onErrorRetry: onErrorRetry,\n    errorRetryInterval: (slowConnection ? 10 : 5) * 1000,\n    focusThrottleInterval: 5 * 1000,\n    dedupingInterval: 2 * 1000,\n    loadingTimeout: (slowConnection ? 5 : 3) * 1000,\n    refreshInterval: 0,\n    revalidateOnFocus: true,\n    revalidateOnReconnect: true,\n    refreshWhenHidden: false,\n    refreshWhenOffline: false,\n    shouldRetryOnError: true,\n    suspense: false,\n    compare: dequal,\n    fetcher: webPreset.fetcher,\n    isOnline: webPreset.isOnline,\n    isDocumentVisible: webPreset.isDocumentVisible\n};\nexport { cache };\nexport default defaultConfig;\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.__listeners = [];\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.__listeners.push(listener);\n        return function () {\n            if (!isSubscribed)\n                return;\n            isSubscribed = false;\n            var index = _this.__listeners.indexOf(listener);\n            if (index > -1) {\n                _this.__listeners[index] = _this.__listeners[_this.__listeners.length - 1];\n                _this.__listeners.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.__listeners; _i < _a.length; _i++) {\n            var listener = _a[_i];\n            listener();\n        }\n    };\n    return Cache;\n}());\nexport default Cache;\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};\nimport { useCallback, useContext, useEffect, useLayoutEffect, useState, useRef, useMemo, useDebugValue } from 'react';\nimport defaultConfig, { cache } from './config';\nimport SWRConfigContext from './swr-config-context';\nvar IS_SERVER = typeof window === 'undefined' ||\n    // @ts-ignore\n    !!(typeof Deno !== 'undefined' && Deno && Deno.version && Deno.version.deno);\n// polyfill for requestAnimationFrame\nvar rAF = IS_SERVER\n    ? null\n    : window['requestAnimationFrame'] || (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.\nvar useIsomorphicLayoutEffect = IS_SERVER ? useEffect : useLayoutEffect;\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 && window.addEventListener) {\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    // focus revalidate\n    window.addEventListener('visibilitychange', function () { return revalidate_1(FOCUS_REVALIDATORS); }, false);\n    window.addEventListener('focus', function () { return revalidate_1(FOCUS_REVALIDATORS); }, false);\n    // reconnect revalidate\n    window.addEventListener('online', function () { return revalidate_1(RECONNECT_REVALIDATORS); }, false);\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                            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) return [3 /*break*/, 8];\n                    // let's always broadcast in the next tick\n                    // to dedupe synchronous mutation calls\n                    // check out https://github.com/vercel/swr/pull/735 for more details\n                    return [4 /*yield*/, 0\n                        // we skip broadcasting if there's another mutation happened synchronously\n                    ];\n                case 7:\n                    // let's always broadcast in the next tick\n                    // to dedupe synchronous mutation calls\n                    // check out https://github.com/vercel/swr/pull/735 for more details\n                    _b.sent();\n                    // we skip broadcasting if there's another mutation happened synchronously\n                    if (shouldAbort())\n                        return [2 /*return*/, data];\n                    _b.label = 8;\n                case 8:\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, fn, config = {};\n    if (args.length >= 1) {\n        _key = args[0];\n    }\n    if (args.length > 2) {\n        fn = args[1];\n        config = args[2];\n    }\n    else {\n        if (typeof args[1] === 'function') {\n            fn = args[1];\n        }\n        else if (typeof args[1] === 'object') {\n            config = args[1];\n        }\n    }\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    config = Object.assign({}, defaultConfig, useContext(SWRConfigContext), config);\n    var configRef = useRef(config);\n    useIsomorphicLayoutEffect(function () {\n        configRef.current = config;\n    });\n    if (typeof fn === 'undefined') {\n        // use the global fetcher\n        fn = config.fetcher;\n    }\n    var resolveData = function () {\n        var cachedData = cache.get(key);\n        return typeof cachedData === 'undefined' ? config.initialData : cachedData;\n    };\n    var initialData = resolveData();\n    var initialError = cache.get(keyErr);\n    var initialIsValidating = !!cache.get(keyValidating);\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(null)[1];\n    var dispatch = useCallback(function (payload) {\n        var shouldUpdateState = false;\n        for (var k in payload) {\n            if (stateRef.current[k] === payload[k]) {\n                continue;\n            }\n            stateRef.current[k] = payload[k];\n            if (stateDependencies.current[k]) {\n                shouldUpdateState = true;\n            }\n        }\n        if (shouldUpdateState || config.suspense) {\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    // 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 eventsRef = useRef({\n        emit: 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            (_a = configRef.current)[event].apply(_a, params);\n        }\n    });\n    var boundMutate = useCallback(function (data, shouldRevalidate) {\n        return mutate(keyRef.current, data, shouldRevalidate);\n    }, []);\n    var addRevalidator = function (revalidators, callback) {\n        if (!callback)\n            return;\n        if (!revalidators[key]) {\n            revalidators[key] = [callback];\n        }\n        else {\n            revalidators[key].push(callback);\n        }\n    };\n    var removeRevalidator = function (revlidators, callback) {\n        if (revlidators[key]) {\n            var revalidators = revlidators[key];\n            var index = revalidators.indexOf(callback);\n            if (index >= 0) {\n                // 10x faster than splice\n                // https://jsperf.com/array-remove-by-index\n                revalidators[index] = revalidators[revalidators.length - 1];\n                revalidators.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 loading, shouldDeduping, newData, startAt, shouldIgnoreRequest, newState, err_2, retryCount;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        if (!key || !fn)\n                            return [2 /*return*/, false];\n                        if (unmountedRef.current)\n                            return [2 /*return*/, false];\n                        revalidateOpts = Object.assign({ dedupe: false }, revalidateOpts);\n                        loading = true;\n                        shouldDeduping = typeof CONCURRENT_PROMISES[key] !== 'undefined' && revalidateOpts.dedupe;\n                        _a.label = 1;\n                    case 1:\n                        _a.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 = _a.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                                    eventsRef.current.emit('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 = _a.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                        eventsRef.current.emit('onSuccess', newData, key, config);\n                        _a.label = 5;\n                    case 5:\n                        shouldIgnoreRequest = \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                        CONCURRENT_PROMISES_TS[key] > startAt ||\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                            (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                        if (shouldIgnoreRequest) {\n                            dispatch({ isValidating: false });\n                            return [2 /*return*/, false];\n                        }\n                        cache.set(key, newData);\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                        // 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 = _a.sent();\n                        delete CONCURRENT_PROMISES[key];\n                        delete CONCURRENT_PROMISES_TS[key];\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                        eventsRef.current.emit('onError', err_2, key, config);\n                        if (config.shouldRetryOnError) {\n                            retryCount = (revalidateOpts.retryCount || 0) + 1;\n                            eventsRef.current.emit('onErrorRetry', err_2, key, config, revalidate, Object.assign({ dedupe: true }, revalidateOpts, { retryCount: retryCount }));\n                        }\n                        return [3 /*break*/, 7];\n                    case 7:\n                        loading = false;\n                        return [2 /*return*/, true];\n                }\n            });\n        });\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        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        if (keyRef.current !== key) {\n            keyRef.current = key;\n        }\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 (config.revalidateOnMount ||\n            (!config.initialData && config.revalidateOnMount === undefined)) {\n            if (typeof latestKeyedData !== 'undefined') {\n                // delay revalidate if there's cache\n                // to not block the rendering\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        addRevalidator(FOCUS_REVALIDATORS, onFocus);\n        addRevalidator(RECONNECT_REVALIDATORS, onReconnect);\n        addRevalidator(CACHE_REVALIDATORS, onUpdate);\n        return function () {\n            // cleanup\n            dispatch = function () { return null; };\n            // mark it as unmounted\n            unmountedRef.current = true;\n            removeRevalidator(FOCUS_REVALIDATORS, onFocus);\n            removeRevalidator(RECONNECT_REVALIDATORS, onReconnect);\n            removeRevalidator(CACHE_REVALIDATORS, onUpdate);\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) {\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        };\n    }, [\n        config.refreshInterval,\n        config.refreshWhenHidden,\n        config.refreshWhenOffline,\n        revalidate\n    ]);\n    // define returned state\n    // can be memorized since the state is a ref\n    var memoizedState = useMemo(function () {\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                    return keyRef.current === key ? stateRef.current.error : initialError;\n                },\n                enumerable: true\n            },\n            data: {\n                get: function () {\n                    stateDependencies.current.data = true;\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    }, [revalidate]);\n    // suspense\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        var latestData = cache.get(key);\n        var 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        // return the latest data / error from cache\n        // in case `key` has changed\n        return {\n            error: latestError,\n            data: latestData,\n            revalidate: revalidate,\n            mutate: boundMutate,\n            isValidating: stateRef.current.isValidating\n        };\n    }\n    return memoizedState;\n}\nvar SWRConfig = SWRConfigContext.Provider;\nexport { trigger, mutate, SWRConfig };\nexport default useSWR;\n","export * from './use-swr';\nimport { default as useSWR } from './use-swr';\nexport { useSWRInfinite } from './use-swr-infinite';\nexport { cache } from './config';\nexport default useSWR;\n"],"names":["__makeTemplateObject","this","cooked","raw","Object","defineProperty","value","__extends","extendStatics","d","b","setPrototypeOf","__proto__","Array","p","hasOwnProperty","__","constructor","prototype","create","__importStar","mod","__esModule","result","k","call","exports","templateObject_1","templateObject_2","React","core_1","proptypes_1","helpers_1","sync","keyframes","Loader","_super","_this","apply","arguments","style","i","_a","props","color","size","margin","css","cssValue","render","loading","jsx","defaultProps","sizeMarginDefaults","PureComponent","has","table","WeakMap","counter","isOnline","navigator","onLine","isDocumentVisible","document","visibilityState","fetcher","url","fetch","then","res","json","Cache","initialData","__cache","Map","entries","__listeners","get","key","_key","serializeKey","set","notify","keys","from","clear","delete","args","err","isArray","length","_hash","String","hash","subscribe","listener","Error","isSubscribed","push","index","indexOf","_i","slowConnection","window","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","Date","getTime","RegExp","toString","createContext","displayName","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","step","next","e","rejected","done","__generator","body","f","y","t","g","label","sent","trys","ops","verb","Symbol","iterator","n","v","op","TypeError","pop","IS_SERVER","Deno","version","deno","rAF","useIsomorphicLayoutEffect","useEffect","useLayoutEffect","CONCURRENT_PROMISES","CONCURRENT_PROMISES_TS","FOCUS_REVALIDATORS","RECONNECT_REVALIDATORS","CACHE_REVALIDATORS","MUTATION_TS","MUTATION_END_TS","now","ts","addEventListener","revalidate_1","revalidators","trigger","shouldRevalidate","keyErr","keyValidating","updaters","currentData","currentError","currentIsValidating","promises","all","broadcastState","data","error","isValidating","mutate","_data","beforeMutationTs","beforeConcurrentPromisesTs","isAsyncMutation","err_1","shouldAbort","_b","undefined","fn","fnArgs","assign","useContext","configRef","useRef","current","resolveData","cachedData","initialError","initialIsValidating","stateDependencies","stateRef","useDebugValue","rerender","useState","dispatch","useCallback","payload","shouldUpdateState","unmountedRef","initialMountedRef","keyRef","eventsRef","emit","event","params","boundMutate","addRevalidator","callback","removeRevalidator","revlidators","revalidateOpts","shouldDeduping","newData","startAt","newState","err_2","dedupe","currentHookData","latestKeyedData","softRevalidate","revalidateOnMount","pending","onFocus","onReconnect","onUpdate","updatedData","updatedError","updatedIsValidating","needUpdate","timer","tick","clearTimeout","memoizedState","useMemo","state","defineProperties","enumerable","latestData","latestError"],"sourceRoot":""}