{"version":3,"sources":["webpack://_N_E/./client/public/styledComponent/global.ts","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/use-swr-infinite.js","webpack://_N_E/./node_modules/swr/esm/index.js","webpack://_N_E/./static/layout/loading.tsx"],"names":["rem","px","vw","androidTheme","background","inputBackground","iosTheme","has","Object","prototype","hasOwnProperty","table","WeakMap","counter","isOnline","navigator","onLine","isDocumentVisible","document","visibilityState","fetcher","url","fetch","then","res","json","Cache","initialData","this","__cache","Map","entries","__listeners","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","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","constructor","Date","getTime","RegExp","toString","call","isPaused","SWRConfigContext","displayName","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","step","next","e","rejected","result","done","apply","__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","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","_data","beforeMutationTs","beforeConcurrentPromisesTs","isAsyncMutation","err_1","shouldAbort","_b","undefined","Provider","arguments","fn","fnArgs","assign","configRef","current","resolveData","cachedData","initialError","initialIsValidating","stateDependencies","stateRef","rerender","dispatch","payload","shouldUpdateState","k","unmountedRef","initialMountedRef","keyRef","eventsCallback","event","params","boundMutate","addRevalidator","callback","removeRevalidator","revlidators","revalidateOpts","loading","shouldDeduping","newData","startAt","newState","err_2","dedupe","currentHookData","latestKeyedData","softRevalidate","revalidateOnMount","pending","onFocus","onReconnect","onUpdate","updatedData","updatedError","updatedIsValidating","needUpdate","timer","tick","clearTimeout","memoizedState","state","mutate","defineProperties","enumerable","latestData","latestError","__rest","s","p","getOwnPropertySymbols","propertyIsEnumerable","useSWRInfinite","getKey","initialSize","revalidateAll","_c","persistSize","defaultFetcher","extraConfig","firstPageKey","_d","contextCacheKey","cachedPageSize","pageCountCacheKey","pageCountRef","didMountRef","dataRef","swr","originalData","force","previousPageData","pageKey","pageArgs","pageData","size","setSize","arg","swrInfinite","Container","styled","div","Loading","color","style","xmlns","viewBox","width","height","transform","animation","opacity","fill","d","stroke","strokeLinecap","strokeLinejoin","strokeWidth"],"mappings":"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","file":"static/chunks/7e5291efc5b828558a9251e4f0dcd824fbb5d463.23abbf1f1c815627ae36.js","sourcesContent":["/**\n * @fileoverview styled components 常用函数及变量, 不想写less的同学可以尝试使用\n * @author 杨文宇\n */\n\nexport const rem = (px: number) => {\n return px / 72 + 'rem';\n};\n\nexport const vw = (px: number) => {\n return px / 7.2 + 'vw';\n};\n\nexport const androidTheme: Theme = {\n background: '#19191e',\n inputBackground: 'rgba(255, 255, 255, 0.05)',\n};\n\nexport const iosTheme: Theme = {\n background: '#000',\n inputBackground: 'rgba(255, 255, 255, 0.08)',\n};\n\nexport interface Theme {\n background: string;\n inputBackground: string;\n}\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 !== 'undefined' &&\n 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 isPaused: function () { return false; }\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 &&\n window.addEventListener &&\n typeof document !== 'undefined' &&\n typeof document.addEventListener !== 'undefined') {\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 document.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 _b = useState(null), rerender = _b[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 // 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 (_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 (!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, 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 if (configRef.current.isPaused())\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 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 = _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 eventsCallback('onSuccess', newData, key, config);\n _a.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(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 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 retryCount = (revalidateOpts.retryCount || 0) + 1;\n eventsCallback('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 }, \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 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' && !IS_SERVER) {\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 && 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 // 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 // `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 }, [revalidate, initialData, initialError, boundMutate, key]);\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 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: 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","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};\nimport { useContext, useRef, useState, useEffect, useCallback } from 'react';\nimport defaultConfig, { cache } from './config';\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, fn, config = {};\n if (args.length >= 1) {\n getKey = 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 config = Object.assign({}, defaultConfig, useContext(SWRConfigContext), config);\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, defaultFetcher = config.fetcher, extraConfig = __rest(config, [\"initialSize\", \"revalidateAll\", \"persistSize\", \"fetcher\"]);\n if (typeof fn === 'undefined') {\n // use the global fetcher\n // we have to convert the type here\n fn = defaultFetcher;\n }\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 _d = useState(false), rerender = _d[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 = 'context@' + firstPageKey;\n }\n // page count is cached as well, so when navigating the list can be restored\n var pageCountCacheKey = null;\n var cachedPageSize;\n if (firstPageKey) {\n pageCountCacheKey = 'size@' + firstPageKey;\n cachedPageSize = cache.get(pageCountCacheKey);\n }\n var pageCountRef = useRef(cachedPageSize || initialSize);\n var didMountRef = useRef(false);\n // every time the key changes, we reset the page size if it's not persisted\n useEffect(function () {\n if (didMountRef.current) {\n if (!persistSize) {\n pageCountRef.current = initialSize;\n }\n }\n else {\n didMountRef.current = true;\n }\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 ? ['many', firstPageKey] : null, function () { return __awaiter(_this, void 0, void 0, function () {\n var _a, originalData, force, data, 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.originalData, force = _a.force;\n data = [];\n previousPageData = null;\n i = 0;\n _c.label = 1;\n case 1:\n if (!(i < pageCountRef.current)) 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 useEffect(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, { originalData: 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 size = pageCountRef.current;\n var setSize = useCallback(function (arg) {\n if (typeof arg === 'function') {\n pageCountRef.current = arg(pageCountRef.current);\n }\n else if (typeof arg === 'number') {\n pageCountRef.current = arg;\n }\n cache.set(pageCountCacheKey, pageCountRef.current);\n rerender(function (v) { return !v; });\n return mutate(function (v) { return v; });\n }, [mutate, pageCountCacheKey]);\n // Use getter functions to avoid unnecessary re-renders caused by triggering all the getters of the returned swr object\n var swrInfinite = { size: size, 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","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","import React, { FC } from 'react';\nimport styled from 'styled-components';\n\nconst Container = styled.div`\n position: fixed;\n top: 0;\n bottom: 0;\n left: 0;\n right: 0;\n display: flex;\n justify-content: center;\n align-items: center;\n z-index: 999;\n`;\n\nexport interface LoadingConfig {\n background?: string;\n color?: string;\n size?: string;\n}\n\nconst Loading: FC = ({ background = '#19191e', color = '#ffffff', size = '80px' }) => {\n return (\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n );\n};\n\nexport default Loading;\n"],"sourceRoot":""}