{"version":3,"file":"umd/es6.min.js","mappings":"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","sources":["webpack://AxiosCacheInterceptor/webpack/universalModuleDefinition","webpack://AxiosCacheInterceptor/./node_modules/cache-parser/index.min.js","webpack://AxiosCacheInterceptor/./node_modules/fast-defer/index.min.js","webpack://AxiosCacheInterceptor/webpack/bootstrap","webpack://AxiosCacheInterceptor/webpack/runtime/define property getters","webpack://AxiosCacheInterceptor/webpack/runtime/hasOwnProperty shorthand","webpack://AxiosCacheInterceptor/webpack/runtime/make namespace object","webpack://AxiosCacheInterceptor/./src/util/headers.ts","webpack://AxiosCacheInterceptor/./src/header/interpreter.ts","webpack://AxiosCacheInterceptor/./src/interceptors/util.ts","webpack://AxiosCacheInterceptor/./src/interceptors/request.ts","webpack://AxiosCacheInterceptor/./src/util/cache-predicate.ts","webpack://AxiosCacheInterceptor/./src/util/update-cache.ts","webpack://AxiosCacheInterceptor/./src/interceptors/response.ts","webpack://AxiosCacheInterceptor/./src/storage/build.ts","webpack://AxiosCacheInterceptor/./src/storage/memory.ts","webpack://AxiosCacheInterceptor/./src/util/key-generator.ts","webpack://AxiosCacheInterceptor/./src/cache/create.ts","webpack://AxiosCacheInterceptor/./src/storage/web-api.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"AxiosCacheInterceptor\"] = factory();\n\telse\n\t\troot[\"AxiosCacheInterceptor\"] = factory();\n})(typeof self === 'undefined' ? this : self, function() {\nreturn ","!function(e){var a=Symbol(\"cache-parser\"),r=Number;function t(e){return(\"string\"==typeof e||\"number\"==typeof e)&&(e=r(e))>=0&&e<1/0}function s(e){return\"number\"==typeof e||!0===e||\"string\"==typeof e&&\"false\"!==e}e.__internal={isDuration:t,toBoolean:s},e.isCacheControl=function(e){return!!e&&!!e[a]},e.tokenize=function(e){if(!e||\"object\"!=typeof e)return[];var a=[];return s(e.immutable)&&a.push(\"immutable\"),t(e.maxAge)&&a.push(\"max-age=\"+r(e.maxAge)),t(e.maxStale)&&a.push(\"max-stale=\"+r(e.maxStale)),t(e.minFresh)&&a.push(\"min-fresh=\"+r(e.minFresh)),s(e.mustRevalidate)&&a.push(\"must-revalidate\"),s(e.mustUnderstand)&&a.push(\"must-understand\"),s(e.noCache)&&a.push(\"no-cache\"),s(e.noStore)&&a.push(\"no-store\"),s(e.noTransform)&&a.push(\"no-transform\"),s(e.onlyIfCached)&&a.push(\"only-if-cached\"),s(e.private)&&a.push(\"private\"),s(e.proxyRevalidate)&&a.push(\"proxy-revalidate\"),s(e.public)&&a.push(\"public\"),t(e.sMaxAge)&&a.push(\"s-maxage=\"+r(e.sMaxAge)),t(e.staleIfError)&&a.push(\"stale-if-error=\"+r(e.staleIfError)),t(e.staleWhileRevalidate)&&a.push(\"stale-while-revalidate=\"+r(e.staleWhileRevalidate)),a},e.parse=function(e){var n=Object.defineProperty({},a,{enumerable:!1,value:1});if(!e||\"string\"!=typeof e)return n;var i={},o=e.toLowerCase().replace(/\\s+/g,\"\").split(\",\");for(var l in o){var u=o[l].split(\"=\",2);i[u[0]]=1===u.length||u[1]}return s(i.immutable)&&(n.immutable=!0),t(i[\"max-age\"])&&(n.maxAge=r(i[\"max-age\"])),t(i[\"max-stale\"])&&(n.maxStale=r(i[\"max-stale\"])),t(i[\"min-fresh\"])&&(n.minFresh=r(i[\"min-fresh\"])),s(i[\"must-revalidate\"])&&(n.mustRevalidate=!0),s(i[\"must-understand\"])&&(n.mustUnderstand=!0),s(i[\"no-cache\"])&&(n.noCache=!0),s(i[\"no-store\"])&&(n.noStore=!0),s(i[\"no-transform\"])&&(n.noTransform=!0),s(i[\"only-if-cached\"])&&(n.onlyIfCached=!0),s(i.private)&&(n.private=!0),s(i[\"proxy-revalidate\"])&&(n.proxyRevalidate=!0),s(i.public)&&(n.public=!0),t(i[\"s-maxage\"])&&(n.sMaxAge=r(i[\"s-maxage\"])),t(i[\"stale-if-error\"])&&(n.staleIfError=r(i[\"stale-if-error\"])),t(i[\"stale-while-revalidate\"])&&(n.staleWhileRevalidate=r(i[\"stale-while-revalidate\"])),n}}(\"undefined\"!=typeof exports?exports:window.CacheParser||(window.CacheParser={}));","!function(e){var r=Symbol(\"fast-defer\");e.deferred=function(){var e,n,t=new Promise((function(r,t){e=r,n=t}));return t.resolve=e,t.reject=n,t[r]=1,t},e.isDeferred=function(e){return!!e&&!!e[r]}}(\"undefined\"!=typeof exports?exports:window.FastDefer||(window.FastDefer={}));","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","export var Header;\n(function (Header) {\n    /**\n     * ```txt\n     * If-Modified-Since: <day-name>, <day> <month> <year> <hour>:<minute>:<second> GMT\n     * ```\n     *\n     * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-Modified-Since\n     */\n    Header[\"IfModifiedSince\"] = \"if-modified-since\";\n    /**\n     * ```txt\n     * Last-Modified: <day-name>, <day> <month> <year> <hour>:<minute>:<second> GMT\n     * ```\n     *\n     * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Last-Modified\n     */\n    Header[\"LastModified\"] = \"last-modified\";\n    /**\n     * ```txt\n     * If-None-Match: \"<etag_value>\"\n     * If-None-Match: \"<etag_value>\", \"<etag_value>\", …\n     * If-None-Match: *\n     * ```\n     *\n     * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-None-Match\n     */\n    Header[\"IfNoneMatch\"] = \"if-none-match\";\n    /** @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control */\n    Header[\"CacheControl\"] = \"cache-control\";\n    /**\n     * ```txt\n     * ETag: W / '<etag_value>';\n     * ETag: '<etag_value>';\n     * ```\n     *\n     * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag\n     */\n    Header[\"ETag\"] = \"etag\";\n    /**\n     * ```txt\n     * Expires: <http-date>\n     * ```\n     *\n     * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Expires\n     */\n    Header[\"Expires\"] = \"expires\";\n    /**\n     * ```txt\n     * Age: <delta-seconds>\n     * ```\n     *\n     * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Age\n     */\n    Header[\"Age\"] = \"age\";\n    /**\n     * ```txt\n     * Content-Type: text/html; charset=UTF-8\n     * Content-Type: multipart/form-data; boundary=something\n     * ```\n     *\n     * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Type\n     */\n    Header[\"ContentType\"] = \"content-type\";\n    /**\n     * Used internally to mark the cache item as being revalidatable and enabling stale\n     * cache state Contains a string of ASCII characters that can be used as ETag for\n     * `If-Match` header Provided by user using `cache.etag` value.\n     *\n     * ```txt\n     * X-Axios-Cache-Etag: \"<etag_value>\"\n     * ```\n     */\n    Header[\"XAxiosCacheEtag\"] = \"x-axios-cache-etag\";\n    /**\n     * Used internally to mark the cache item as being revalidatable and enabling stale\n     * cache state may contain `'use-cache-timestamp'` if `cache.modifiedSince` is `true`,\n     * otherwise will contain a date from `cache.modifiedSince`. If a date is provided, it\n     * can be used for `If-Modified-Since` header, otherwise the cache timestamp can be used\n     * for `If-Modified-Since` header.\n     *\n     * ```txt\n     * X-Axios-Cache-Last-Modified: <day-name>, <day> <month> <year> <hour>:<minute>:<second> GMT\n     * X-Axios-Cache-Last-Modified: use-cache-timestamp\n     * ```\n     */\n    Header[\"XAxiosCacheLastModified\"] = \"x-axios-cache-last-modified\";\n})(Header || (Header = {}));\n","import { parse } from 'cache-parser';\nimport { Header } from '../util/headers';\nexport const defaultHeaderInterpreter = (headers) => {\n    if (!headers)\n        return 'not enough headers';\n    const cacheControl = headers[Header.CacheControl];\n    if (cacheControl) {\n        const { noCache, noStore, mustRevalidate, maxAge, immutable } = parse(cacheControl);\n        // Header told that this response should not be cached.\n        if (noCache || noStore) {\n            return 'dont cache';\n        }\n        if (immutable) {\n            // 1 year is sufficient, as Infinity may cause more problems.\n            // It might not be the best way, but a year is better than none.\n            return 1000 * 60 * 60 * 24 * 365;\n        }\n        // Already out of date, for cache can be saved, but must be requested again\n        if (mustRevalidate) {\n            return 0;\n        }\n        if (maxAge) {\n            const age = headers[Header.Age];\n            if (!age) {\n                return maxAge * 1000;\n            }\n            return (maxAge - Number(age)) * 1000;\n        }\n    }\n    const expires = headers[Header.Expires];\n    if (expires) {\n        const milliseconds = Date.parse(expires) - Date.now();\n        return milliseconds >= 0 ? milliseconds : 'dont cache';\n    }\n    return 'not enough headers';\n};\n","import { Header } from '../util/headers';\n/**\n * Creates a new validateStatus function that will use the one already used and also\n * accept status code 304.\n */\nexport function createValidateStatus(oldValidate) {\n    return oldValidate\n        ? (status) => oldValidate(status) || status === 304\n        : (status) => (status >= 200 && status < 300) || status === 304;\n}\n/** Checks if the given method is in the methods array */\nexport function isMethodIn(requestMethod = 'get', methodList = []) {\n    requestMethod = requestMethod.toLowerCase();\n    for (const method of methodList) {\n        if (method.toLowerCase() === requestMethod) {\n            return true;\n        }\n    }\n    return false;\n}\nexport function setRevalidationHeaders(cache, config) {\n    var _a;\n    config.headers || (config.headers = {});\n    const { etag, modifiedSince } = config.cache;\n    if (etag) {\n        const etagValue = etag === true ? (_a = cache.data) === null || _a === void 0 ? void 0 : _a.headers[Header.ETag] : etag;\n        if (etagValue) {\n            config.headers[Header.IfNoneMatch] = etagValue;\n        }\n    }\n    if (modifiedSince) {\n        config.headers[Header.IfModifiedSince] =\n            modifiedSince === true\n                ? // If last-modified is not present, use the createdAt timestamp\n                    cache.data.headers[Header.LastModified] ||\n                        new Date(cache.createdAt).toUTCString()\n                : modifiedSince.toUTCString();\n    }\n}\n/**\n * Creates the new date to the cache by the provided response. Also handles possible 304\n * Not Modified by updating response properties.\n */\nexport function setupCacheData(response, cache) {\n    if (response.status === 304 && cache) {\n        // Set the cache information into the response object\n        response.cached = true;\n        response.data = cache.data;\n        response.status = cache.status;\n        response.statusText = cache.statusText;\n        // Update possible new headers\n        response.headers = Object.assign(Object.assign({}, cache.headers), response.headers);\n        // return the old cache\n        return cache;\n    }\n    // New Response\n    return {\n        data: response.data,\n        status: response.status,\n        statusText: response.statusText,\n        headers: response.headers\n    };\n}\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};\nimport { deferred } from 'fast-defer';\nimport { createValidateStatus, isMethodIn, setRevalidationHeaders } from './util';\nexport function defaultRequestInterceptor(axios) {\n    const onFulfilled = (config) => __awaiter(this, void 0, void 0, function* () {\n        var _a;\n        if (config.cache === false) {\n            return config;\n        }\n        // merge defaults with per request configuration\n        config.cache = Object.assign(Object.assign({}, axios.defaults.cache), config.cache);\n        if (!isMethodIn(config.method, config.cache.methods)) {\n            return config;\n        }\n        const key = axios.generateKey(config);\n        // Assumes that the storage handled staled responses\n        let cache = yield axios.storage.get(key);\n        // Not cached, continue the request, and mark it as fetching\n        emptyOrStale: if (cache.state === 'empty' || cache.state === 'stale') {\n            /**\n             * This checks for simultaneous access to a new key. The js event loop jumps on the\n             * first await statement, so the second (asynchronous call) request may have already\n             * started executing.\n             */\n            if (axios.waiting[key]) {\n                cache = (yield axios.storage.get(key));\n                break emptyOrStale;\n            }\n            // Create a deferred to resolve other requests for the same key when it's completed\n            axios.waiting[key] = deferred();\n            /**\n             * Add a default reject handler to catch when the request is aborted without others\n             * waiting for it.\n             */\n            (_a = axios.waiting[key]) === null || _a === void 0 ? void 0 : _a.catch(() => undefined);\n            yield axios.storage.set(key, {\n                state: 'loading',\n                data: cache.data\n            });\n            if (cache.state === 'stale') {\n                setRevalidationHeaders(cache, config);\n            }\n            config.validateStatus = createValidateStatus(config.validateStatus);\n            return config;\n        }\n        let cachedResponse;\n        if (cache.state === 'loading') {\n            const deferred = axios.waiting[key];\n            // Just in case, the deferred doesn't exists.\n            /* istanbul ignore if 'really hard to test' */\n            if (!deferred) {\n                yield axios.storage.remove(key);\n                return config;\n            }\n            try {\n                cachedResponse = yield deferred;\n            }\n            catch (_b) {\n                // The deferred is rejected when the request that we are waiting rejected cache.\n                return config;\n            }\n        }\n        else {\n            cachedResponse = cache.data;\n        }\n        //Even though the response interceptor receives this one from here,\n        // it has been configured to ignore cached responses = true\n        // eslint-disable-next-line @typescript-eslint/require-await\n        config.adapter = () => Promise.resolve({\n            config,\n            data: cachedResponse.data,\n            headers: cachedResponse.headers,\n            status: cachedResponse.status,\n            statusText: cachedResponse.statusText,\n            cached: true,\n            id: key\n        });\n        return config;\n    });\n    return {\n        onFulfilled,\n        apply: () => axios.interceptors.request.use(onFulfilled)\n    };\n}\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};\n/** Tests an response against a {@link CachePredicateObject}. */\nexport function testCachePredicate(response, predicate) {\n    var _a;\n    return __awaiter(this, void 0, void 0, function* () {\n        if (typeof predicate === 'function') {\n            return predicate(response);\n        }\n        const { statusCheck, responseMatch, containsHeaders } = predicate;\n        if ((statusCheck && !(yield statusCheck(response.status))) ||\n            (responseMatch && !(yield responseMatch(response)))) {\n            return false;\n        }\n        if (containsHeaders) {\n            for (const header in containsHeaders) {\n                const predicate = containsHeaders[header];\n                if (predicate &&\n                    !(yield predicate(\n                    // Axios uses lowercase headers, but if for some reason it doesn't, we should\n                    // still be able to match.\n                    (_a = response.headers[header.toLowerCase()]) !== null && _a !== void 0 ? _a : response.headers[header]))) {\n                    return false;\n                }\n            }\n        }\n        return true;\n    });\n}\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};\n/** Function to update all caches, from CacheProperties.update, with the new data. */\nexport function updateCache(storage, data, entries) {\n    return __awaiter(this, void 0, void 0, function* () {\n        for (const cacheKey in entries) {\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            const value = entries[cacheKey];\n            if (value === 'delete') {\n                yield storage.remove(cacheKey);\n                continue;\n            }\n            const oldValue = yield storage.get(cacheKey);\n            if (oldValue.state === 'loading') {\n                continue;\n            }\n            const newValue = yield value(oldValue, data);\n            if (newValue === 'delete') {\n                yield storage.remove(cacheKey);\n                continue;\n            }\n            if (newValue === 'ignore') {\n                continue;\n            }\n            yield storage.set(cacheKey, newValue);\n        }\n    });\n}\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};\nimport { testCachePredicate } from '../util/cache-predicate';\nimport { Header } from '../util/headers';\nimport { updateCache } from '../util/update-cache';\nimport { setupCacheData } from './util';\nexport function defaultResponseInterceptor(axios) {\n    /**\n     * Rejects cache for an response response.\n     *\n     * Also update the waiting list for this key by rejecting it.\n     */\n    const rejectResponse = ({ storage, waiting }, responseId) => __awaiter(this, void 0, void 0, function* () {\n        var _a;\n        // Update the cache to empty to prevent infinite loading state\n        yield storage.remove(responseId);\n        // Reject the deferred if present\n        (_a = waiting[responseId]) === null || _a === void 0 ? void 0 : _a.reject(null);\n        delete waiting[responseId];\n    });\n    const onFulfilled = (response) => __awaiter(this, void 0, void 0, function* () {\n        var _b, _c;\n        (_b = response.id) !== null && _b !== void 0 ? _b : (response.id = axios.generateKey(response.config));\n        (_c = response.cached) !== null && _c !== void 0 ? _c : (response.cached = false);\n        // Response is already cached\n        if (response.cached) {\n            return response;\n        }\n        // Skip cache: either false or weird behavior\n        // config.cache should always exists, at least from global config merge.\n        if (!response.config.cache) {\n            return Object.assign(Object.assign({}, response), { cached: false });\n        }\n        const cacheConfig = response.config.cache;\n        const cache = yield axios.storage.get(response.id);\n        if (\n        // If the request interceptor had a problem\n        cache.state === 'stale' ||\n            cache.state === 'empty' ||\n            // Should not hit here because of previous response.cached check\n            cache.state === 'cached') {\n            return response;\n        }\n        // Config told that this response should be cached.\n        if (\n        // For 'loading' values (post stale), this check was already run in the past.\n        !cache.data &&\n            !(yield testCachePredicate(response, cacheConfig.cachePredicate))) {\n            yield rejectResponse(axios, response.id);\n            return response;\n        }\n        // avoid remnant headers from remote server to break implementation\n        delete response.headers[Header.XAxiosCacheEtag];\n        delete response.headers[Header.XAxiosCacheLastModified];\n        if (cacheConfig.etag && cacheConfig.etag !== true) {\n            response.headers[Header.XAxiosCacheEtag] = cacheConfig.etag;\n        }\n        if (cacheConfig.modifiedSince) {\n            response.headers[Header.XAxiosCacheLastModified] =\n                cacheConfig.modifiedSince === true\n                    ? 'use-cache-timestamp'\n                    : cacheConfig.modifiedSince.toUTCString();\n        }\n        let ttl = cacheConfig.ttl || -1; // always set from global config\n        if (cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.interpretHeader) {\n            const expirationTime = axios.headerInterpreter(response.headers);\n            // Cache should not be used\n            if (expirationTime === 'dont cache') {\n                yield rejectResponse(axios, response.id);\n                return response;\n            }\n            ttl = expirationTime === 'not enough headers' ? ttl : expirationTime;\n        }\n        const data = setupCacheData(response, cache.data);\n        if (typeof ttl === 'function') {\n            ttl = yield ttl(response);\n        }\n        const newCache = {\n            state: 'cached',\n            ttl,\n            createdAt: Date.now(),\n            data\n        };\n        // Update other entries before updating himself\n        if (cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.update) {\n            yield updateCache(axios.storage, response, cacheConfig.update);\n        }\n        const deferred = axios.waiting[response.id];\n        // Resolve all other requests waiting for this response\n        deferred === null || deferred === void 0 ? void 0 : deferred.resolve(newCache.data);\n        delete axios.waiting[response.id];\n        // Define this key as cache on the storage\n        yield axios.storage.set(response.id, newCache);\n        // Return the response with cached as false, because it was not cached at all\n        return response;\n    });\n    return {\n        onFulfilled,\n        apply: () => axios.interceptors.response.use(onFulfilled)\n    };\n}\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};\nimport { Header } from '../util/headers';\nconst storage = Symbol();\n/** Returns true if the provided object was created from {@link buildStorage} function. */\nexport const isStorage = (obj) => !!obj && !!obj[storage];\n/**\n * Builds a custom storage.\n *\n * **Note**: You can only create an custom storage with this function.\n *\n * @example\n *\n * ```js\n * const myStorage = buildStorage({\n *   find: () => {...},\n *   set: () => {...},\n *   remove: () => {...}\n * });\n *\n * const axios = setupCache(axios, { storage: myStorage });\n * ```\n */\nexport function buildStorage({ set, find, remove }) {\n    return {\n        //@ts-expect-error - we don't want to expose this\n        [storage]: 1,\n        set,\n        remove,\n        get: (key) => __awaiter(this, void 0, void 0, function* () {\n            const value = yield find(key);\n            if (!value) {\n                return { state: 'empty' };\n            }\n            if (\n            // Not cached or fresh value\n            value.state !== 'cached' ||\n                value.createdAt + value.ttl > Date.now()) {\n                return value;\n            }\n            if (value.data.headers &&\n                (Header.ETag in value.data.headers ||\n                    Header.LastModified in value.data.headers ||\n                    Header.XAxiosCacheEtag in value.data.headers ||\n                    Header.XAxiosCacheLastModified in value.data.headers)) {\n                const stale = {\n                    data: value.data,\n                    state: 'stale',\n                    createdAt: value.createdAt\n                };\n                yield set(key, stale);\n                return stale;\n            }\n            yield remove(key);\n            return { state: 'empty' };\n        })\n    };\n}\n","import { buildStorage } from './build';\n/**\n * Creates a simple in-memory storage. This means that if you need to persist data between\n * page or server reloads, this will not help.\n *\n * This is the storage used by default.\n *\n * If you need to modify it's data, you can do by the `data` property.\n *\n * @example\n *\n * ```js\n * const memoryStorage = buildMemoryStorage();\n *\n * setupCache(axios, { storage: memoryStorage });\n *\n * // Simple example to force delete the request cache\n *\n * const { id } = axios.get('url');\n *\n * delete memoryStorage.data[id];\n * ```\n */\nexport function buildMemoryStorage() {\n    const data = {};\n    const storage = buildStorage({\n        find: (key) => data[key],\n        set: (key, value) => {\n            data[key] = value;\n        },\n        remove: (key) => {\n            delete data[key];\n        }\n    });\n    return Object.assign(Object.assign({}, storage), { data });\n}\n","// Remove first and last '/' char, if present\nconst SLASHES_REGEX = /^\\/|\\/$/g;\nexport const defaultKeyGenerator = ({ baseURL = '', url = '', method = 'get', params, id }) => {\n    if (id) {\n        return id;\n    }\n    // Remove trailing slashes\n    baseURL = baseURL.replace(SLASHES_REGEX, '');\n    url = url.replace(SLASHES_REGEX, '');\n    return `${\n    // method\n    method.toLowerCase()}::${\n    // complete url\n    baseURL + (baseURL && url ? '/' : '') + url}::${\n    // params\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n    params ? JSON.stringify(params, Object.keys(params).sort()) : '{}'}`;\n};\n","var __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 { defaultHeaderInterpreter } from '../header/interpreter';\nimport { defaultRequestInterceptor } from '../interceptors/request';\nimport { defaultResponseInterceptor } from '../interceptors/response';\nimport { isStorage } from '../storage/build';\nimport { buildMemoryStorage } from '../storage/memory';\nimport { defaultKeyGenerator } from '../util/key-generator';\n/**\n * Apply the caching interceptors for a already created axios instance.\n *\n * @example\n *\n * ```ts\n * import Axios from 'axios';\n * import { setupCache, AxiosCacheInstance } from 'axios-cache-interceptor';\n *\n * // instance will have our custom typings from the return of this function\n * const instance = setupCache(\n *   Axios.create({\n *     // Axios options\n *   }),\n *   {\n *     // Axios-cache-interceptor options\n *   }\n * );\n *\n * // OR\n *\n * const instance = axios.create({\n *   // Axios options\n * }) as AxiosCacheInstance;\n *\n * // As this functions returns the same axios instance but only with\n * // different typings, you can ignore the function return.\n * setupCache(instance, {\n *   // Axios-cache-interceptor options\n * });\n * ```\n *\n * @param axios The already created axios instance\n * @param config The config for the caching interceptors\n * @returns The same instance with extended typescript types.\n */\nexport function setupCache(axios, _a = {}) {\n    var { storage, generateKey, waiting, headerInterpreter, requestInterceptor, responseInterceptor } = _a, cacheOptions = __rest(_a, [\"storage\", \"generateKey\", \"waiting\", \"headerInterpreter\", \"requestInterceptor\", \"responseInterceptor\"]);\n    const axiosCache = axios;\n    axiosCache.storage = storage || buildMemoryStorage();\n    if (!isStorage(axiosCache.storage)) {\n        throw new Error('Use buildStorage() function');\n    }\n    axiosCache.generateKey = generateKey || defaultKeyGenerator;\n    axiosCache.waiting = waiting || {};\n    axiosCache.headerInterpreter = headerInterpreter || defaultHeaderInterpreter;\n    axiosCache.requestInterceptor =\n        requestInterceptor || defaultRequestInterceptor(axiosCache);\n    axiosCache.responseInterceptor =\n        responseInterceptor || defaultResponseInterceptor(axiosCache);\n    // CacheRequestConfig values\n    axiosCache.defaults = Object.assign(Object.assign({}, axios.defaults), { cache: Object.assign({ ttl: 1000 * 60 * 5, interpretHeader: false, methods: ['get'], cachePredicate: { statusCheck: (status) => status >= 200 && status < 400 }, etag: false, modifiedSince: false, update: {} }, cacheOptions) });\n    // Apply interceptors\n    axiosCache.requestInterceptor.apply();\n    axiosCache.responseInterceptor.apply();\n    return axiosCache;\n}\n","import { buildStorage } from './build';\n/**\n * Creates a simple storage. You can persist his data by using `sessionStorage` or\n * `localStorage` with it.\n *\n * **ImplNote**: Without polyfill, this storage only works on browser environments.\n *\n * @example\n *\n * ```js\n * const fromLocalStorage = buildWebStorage(localStorage);\n * const fromSessionStorage = buildWebStorage(sessionStorage);\n *\n * const myStorage = new Storage();\n * const fromMyStorage = buildWebStorage(myStorage);\n * ```\n *\n * @param prefix The prefix to index the storage. Useful to prevent collision between\n *   multiple places using the same storage.\n */\nexport function buildWebStorage(storage, prefix = '') {\n    return buildStorage({\n        find: (key) => {\n            const json = storage.getItem(prefix + key);\n            return json ? JSON.parse(json) : undefined;\n        },\n        set: (key, value) => {\n            storage.setItem(prefix + key, JSON.stringify(value));\n        },\n        remove: (key) => {\n            storage.removeItem(prefix + key);\n        }\n    });\n}\n"],"names":["root","factory","exports","module","define","amd","self","this","e","a","Symbol","r","Number","t","s","__internal","isDuration","toBoolean","isCacheControl","tokenize","immutable","push","maxAge","maxStale","minFresh","mustRevalidate","mustUnderstand","noCache","noStore","noTransform","onlyIfCached","private","proxyRevalidate","public","sMaxAge","staleIfError","staleWhileRevalidate","parse","n","Object","defineProperty","enumerable","value","i","o","toLowerCase","replace","split","l","u","length","deferred","Promise","resolve","reject","isDeferred","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","__webpack_modules__","d","definition","key","get","obj","prop","prototype","hasOwnProperty","call","toStringTag","Header","defaultHeaderInterpreter","headers","cacheControl","CacheControl","age","Age","expires","Expires","milliseconds","Date","now","createValidateStatus","oldValidate","status","isMethodIn","requestMethod","methodList","method","setRevalidationHeaders","cache","config","_a","etag","modifiedSince","etagValue","data","ETag","IfNoneMatch","IfModifiedSince","LastModified","createdAt","toUTCString","setupCacheData","response","cached","statusText","assign","__awaiter","thisArg","_arguments","P","generator","fulfilled","step","next","rejected","result","done","then","apply","defaultRequestInterceptor","axios","onFulfilled","defaults","methods","generateKey","cachedResponse","storage","emptyOrStale","state","waiting","catch","set","validateStatus","remove","_b","adapter","id","interceptors","request","use","testCachePredicate","predicate","statusCheck","responseMatch","containsHeaders","header","updateCache","entries","cacheKey","oldValue","newValue","defaultResponseInterceptor","rejectResponse","responseId","_c","cacheConfig","cachePredicate","XAxiosCacheEtag","XAxiosCacheLastModified","ttl","interpretHeader","expirationTime","headerInterpreter","newCache","update","isStorage","buildStorage","find","stale","buildMemoryStorage","SLASHES_REGEX","defaultKeyGenerator","baseURL","url","params","JSON","stringify","keys","sort","__rest","p","indexOf","getOwnPropertySymbols","propertyIsEnumerable","setupCache","requestInterceptor","responseInterceptor","cacheOptions","axiosCache","Error","buildWebStorage","prefix","json","getItem","setItem","removeItem"],"sourceRoot":""}