{"version":3,"file":"umd/es5.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/./node_modules/object-code/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={}));","!function(r){r.transform=function(t){var n=typeof t;if(\"object\"===n&&t){if(t instanceof Date)return\"#\"+t.getTime();if(t instanceof RegExp)return\"#\"+t.toString();var o=Array.isArray(t)?[]:{};for(var e in t)o[e]=r.transform(t[e]);return\"#\"+String(t.constructor)+JSON.stringify(o,Object.keys(o).sort())}return n+String(t)+(\"symbol\"===n?Math.random():\"\")},r.code=function(t){t=r.transform(t);for(var n=7,o=0;o<t.length;)n=31*n+t.charCodeAt(o++)&9007199254740991;return n}}(\"undefined\"!=typeof exports?exports:window.FastHash||(window.FastHash={}));","// 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 = function(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 = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }","// define __esModule on exports\n__webpack_require__.r = function(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 var defaultHeaderInterpreter = function (headers) {\n    if (!headers)\n        return 'not enough headers';\n    var cacheControl = headers[Header.CacheControl];\n    if (cacheControl) {\n        var _a = parse(cacheControl), noCache = _a.noCache, noStore = _a.noStore, mustRevalidate = _a.mustRevalidate, maxAge = _a.maxAge, immutable = _a.immutable;\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            var age = headers[Header.Age];\n            if (!age) {\n                return maxAge * 1000;\n            }\n            return (maxAge - Number(age)) * 1000;\n        }\n    }\n    var expires = headers[Header.Expires];\n    if (expires) {\n        var milliseconds = Date.parse(expires) - Date.now();\n        return milliseconds >= 0 ? milliseconds : 'dont cache';\n    }\n    return 'not enough headers';\n};\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport { 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        ? function (status) { return oldValidate(status) || status === 304; }\n        : function (status) { return (status >= 200 && status < 300) || status === 304; };\n}\n/** Checks if the given method is in the methods array */\nexport function isMethodIn(requestMethod, methodList) {\n    if (requestMethod === void 0) { requestMethod = 'get'; }\n    if (methodList === void 0) { methodList = []; }\n    requestMethod = requestMethod.toLowerCase();\n    for (var _i = 0, methodList_1 = methodList; _i < methodList_1.length; _i++) {\n        var method = methodList_1[_i];\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    var _b = config.cache, etag = _b.etag, modifiedSince = _b.modifiedSince;\n    if (etag) {\n        var 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 = __assign(__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 __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __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 { deferred } from 'fast-defer';\nimport { createValidateStatus, isMethodIn, setRevalidationHeaders } from './util';\nexport function defaultRequestInterceptor(axios) {\n    var _this = this;\n    var onFulfilled = function (config) { return __awaiter(_this, void 0, void 0, function () {\n        var key, cache, cachedResponse, deferred_1, _a;\n        var _b;\n        return __generator(this, function (_c) {\n            switch (_c.label) {\n                case 0:\n                    if (config.cache === false) {\n                        return [2 /*return*/, config];\n                    }\n                    // merge defaults with per request configuration\n                    config.cache = __assign(__assign({}, axios.defaults.cache), config.cache);\n                    if (!isMethodIn(config.method, config.cache.methods)) {\n                        return [2 /*return*/, config];\n                    }\n                    key = (config.id = axios.generateKey(config));\n                    return [4 /*yield*/, axios.storage.get(key)];\n                case 1:\n                    cache = _c.sent();\n                    if (!(cache.state === 'empty' || cache.state === 'stale')) return [3 /*break*/, 5];\n                    if (!axios.waiting[key]) return [3 /*break*/, 3];\n                    return [4 /*yield*/, axios.storage.get(key)];\n                case 2:\n                    cache = (_c.sent());\n                    return [3 /*break*/, 5];\n                case 3:\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                    (_b = axios.waiting[key]) === null || _b === void 0 ? void 0 : _b.catch(function () { return undefined; });\n                    return [4 /*yield*/, axios.storage.set(key, {\n                            state: 'loading',\n                            data: cache.data\n                        })];\n                case 4:\n                    _c.sent();\n                    if (cache.state === 'stale') {\n                        setRevalidationHeaders(cache, config);\n                    }\n                    config.validateStatus = createValidateStatus(config.validateStatus);\n                    return [2 /*return*/, config];\n                case 5:\n                    if (!(cache.state === 'loading')) return [3 /*break*/, 11];\n                    deferred_1 = axios.waiting[key];\n                    if (!!deferred_1) return [3 /*break*/, 7];\n                    return [4 /*yield*/, axios.storage.remove(key)];\n                case 6:\n                    _c.sent();\n                    return [2 /*return*/, config];\n                case 7:\n                    _c.trys.push([7, 9, , 10]);\n                    return [4 /*yield*/, deferred_1];\n                case 8:\n                    cachedResponse = _c.sent();\n                    return [3 /*break*/, 10];\n                case 9:\n                    _a = _c.sent();\n                    // The deferred is rejected when the request that we are waiting rejected cache.\n                    return [2 /*return*/, config];\n                case 10: return [3 /*break*/, 12];\n                case 11:\n                    cachedResponse = cache.data;\n                    _c.label = 12;\n                case 12:\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 = function () {\n                        return Promise.resolve({\n                            config: 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                    };\n                    return [2 /*return*/, config];\n            }\n        });\n    }); };\n    return {\n        onFulfilled: onFulfilled,\n        apply: function () { return 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};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\n/** 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        var statusCheck, responseMatch, containsHeaders, _b, _c, _d, _e, _f, _i, header, predicate_1, _g;\n        return __generator(this, function (_h) {\n            switch (_h.label) {\n                case 0:\n                    if (typeof predicate === 'function') {\n                        return [2 /*return*/, predicate(response)];\n                    }\n                    statusCheck = predicate.statusCheck, responseMatch = predicate.responseMatch, containsHeaders = predicate.containsHeaders;\n                    _c = statusCheck;\n                    if (!_c) return [3 /*break*/, 2];\n                    return [4 /*yield*/, statusCheck(response.status)];\n                case 1:\n                    _c = !(_h.sent());\n                    _h.label = 2;\n                case 2:\n                    _b = (_c);\n                    if (_b) return [3 /*break*/, 5];\n                    _d = responseMatch;\n                    if (!_d) return [3 /*break*/, 4];\n                    return [4 /*yield*/, responseMatch(response)];\n                case 3:\n                    _d = !(_h.sent());\n                    _h.label = 4;\n                case 4:\n                    _b = (_d);\n                    _h.label = 5;\n                case 5:\n                    if (_b) {\n                        return [2 /*return*/, false];\n                    }\n                    if (!containsHeaders) return [3 /*break*/, 10];\n                    _e = [];\n                    for (_f in containsHeaders)\n                        _e.push(_f);\n                    _i = 0;\n                    _h.label = 6;\n                case 6:\n                    if (!(_i < _e.length)) return [3 /*break*/, 10];\n                    header = _e[_i];\n                    predicate_1 = containsHeaders[header];\n                    _g = predicate_1;\n                    if (!_g) return [3 /*break*/, 8];\n                    return [4 /*yield*/, predicate_1(\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                case 7:\n                    _g = !(_h.sent());\n                    _h.label = 8;\n                case 8:\n                    if (_g) {\n                        return [2 /*return*/, false];\n                    }\n                    _h.label = 9;\n                case 9:\n                    _i++;\n                    return [3 /*break*/, 6];\n                case 10: return [2 /*return*/, true];\n            }\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};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\n/** 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        var _a, _b, _i, cacheKey, value, oldValue, newValue;\n        return __generator(this, function (_c) {\n            switch (_c.label) {\n                case 0:\n                    _a = [];\n                    for (_b in entries)\n                        _a.push(_b);\n                    _i = 0;\n                    _c.label = 1;\n                case 1:\n                    if (!(_i < _a.length)) return [3 /*break*/, 10];\n                    cacheKey = _a[_i];\n                    value = entries[cacheKey];\n                    if (!(value === 'delete')) return [3 /*break*/, 3];\n                    return [4 /*yield*/, storage.remove(cacheKey)];\n                case 2:\n                    _c.sent();\n                    return [3 /*break*/, 9];\n                case 3: return [4 /*yield*/, storage.get(cacheKey)];\n                case 4:\n                    oldValue = _c.sent();\n                    if (oldValue.state === 'loading') {\n                        return [3 /*break*/, 9];\n                    }\n                    return [4 /*yield*/, value(oldValue, data)];\n                case 5:\n                    newValue = _c.sent();\n                    if (!(newValue === 'delete')) return [3 /*break*/, 7];\n                    return [4 /*yield*/, storage.remove(cacheKey)];\n                case 6:\n                    _c.sent();\n                    return [3 /*break*/, 9];\n                case 7:\n                    if (newValue === 'ignore') {\n                        return [3 /*break*/, 9];\n                    }\n                    return [4 /*yield*/, storage.set(cacheKey, newValue)];\n                case 8:\n                    _c.sent();\n                    _c.label = 9;\n                case 9:\n                    _i++;\n                    return [3 /*break*/, 1];\n                case 10: return [2 /*return*/];\n            }\n        });\n    });\n}\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __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 { 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    var _this = this;\n    /**\n     * Rejects cache for an response response.\n     *\n     * Also update the waiting list for this key by rejecting it.\n     */\n    var rejectResponse = function (_a, responseId) {\n        var storage = _a.storage, waiting = _a.waiting;\n        return __awaiter(_this, void 0, void 0, function () {\n            var _b;\n            return __generator(this, function (_c) {\n                switch (_c.label) {\n                    case 0: \n                    // Update the cache to empty to prevent infinite loading state\n                    return [4 /*yield*/, storage.remove(responseId)];\n                    case 1:\n                        // Update the cache to empty to prevent infinite loading state\n                        _c.sent();\n                        // Reject the deferred if present\n                        (_b = waiting[responseId]) === null || _b === void 0 ? void 0 : _b.reject(null);\n                        delete waiting[responseId];\n                        return [2 /*return*/];\n                }\n            });\n        });\n    };\n    var onFulfilled = function (response) { return __awaiter(_this, void 0, void 0, function () {\n        var cacheConfig, cache, _a, ttl, expirationTime, data, newCache, deferred;\n        var _b, _c;\n        var _d;\n        return __generator(this, function (_e) {\n            switch (_e.label) {\n                case 0:\n                    response.id = (_b = (_d = response.config).id) !== null && _b !== void 0 ? _b : (_d.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 [2 /*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 [2 /*return*/, __assign(__assign({}, response), { cached: false })];\n                    }\n                    cacheConfig = response.config.cache;\n                    return [4 /*yield*/, axios.storage.get(response.id)];\n                case 1:\n                    cache = _e.sent();\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 [2 /*return*/, response];\n                    }\n                    // For 'loading' values (post stale), this check was already run in the past.\n                    _a = !cache.data;\n                    if (!_a) \n                    // For 'loading' values (post stale), this check was already run in the past.\n                    return [3 /*break*/, 3];\n                    return [4 /*yield*/, testCachePredicate(response, cacheConfig.cachePredicate)];\n                case 2:\n                    _a = !(_e.sent());\n                    _e.label = 3;\n                case 3:\n                    if (!_a) \n                    // For 'loading' values (post stale), this check was already run in the past.\n                    return [3 /*break*/, 5];\n                    return [4 /*yield*/, rejectResponse(axios, response.id)];\n                case 4:\n                    _e.sent();\n                    return [2 /*return*/, response];\n                case 5:\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                    ttl = cacheConfig.ttl || -1;\n                    if (!(cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.interpretHeader)) return [3 /*break*/, 8];\n                    expirationTime = axios.headerInterpreter(response.headers);\n                    if (!(expirationTime === 'dont cache')) return [3 /*break*/, 7];\n                    return [4 /*yield*/, rejectResponse(axios, response.id)];\n                case 6:\n                    _e.sent();\n                    return [2 /*return*/, response];\n                case 7:\n                    ttl = expirationTime === 'not enough headers' ? ttl : expirationTime;\n                    _e.label = 8;\n                case 8:\n                    data = setupCacheData(response, cache.data);\n                    if (!(typeof ttl === 'function')) return [3 /*break*/, 10];\n                    return [4 /*yield*/, ttl(response)];\n                case 9:\n                    ttl = _e.sent();\n                    _e.label = 10;\n                case 10:\n                    newCache = {\n                        state: 'cached',\n                        ttl: ttl,\n                        createdAt: Date.now(),\n                        data: data\n                    };\n                    if (!(cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.update)) return [3 /*break*/, 12];\n                    return [4 /*yield*/, updateCache(axios.storage, response, cacheConfig.update)];\n                case 11:\n                    _e.sent();\n                    _e.label = 12;\n                case 12:\n                    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                    return [4 /*yield*/, axios.storage.set(response.id, newCache)];\n                case 13:\n                    // Define this key as cache on the storage\n                    _e.sent();\n                    // Return the response with cached as false, because it was not cached at all\n                    return [2 /*return*/, response];\n            }\n        });\n    }); };\n    return {\n        onFulfilled: onFulfilled,\n        apply: function () { return 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};\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 { Header } from '../util/headers';\nvar storage = Symbol();\n/** Returns true if the provided object was created from {@link buildStorage} function. */\nexport var isStorage = function (obj) {\n    return !!obj && !!obj[storage];\n};\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(_a) {\n    var _b;\n    var _this = this;\n    var set = _a.set, find = _a.find, remove = _a.remove;\n    return _b = {},\n        //@ts-expect-error - we don't want to expose this\n        _b[storage] = 1,\n        _b.set = set,\n        _b.remove = remove,\n        _b.get = function (key) { return __awaiter(_this, void 0, void 0, function () {\n            var value, stale;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0: return [4 /*yield*/, find(key)];\n                    case 1:\n                        value = _a.sent();\n                        if (!value) {\n                            return [2 /*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 [2 /*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))) return [3 /*break*/, 3];\n                        stale = {\n                            data: value.data,\n                            state: 'stale',\n                            createdAt: value.createdAt\n                        };\n                        return [4 /*yield*/, set(key, stale)];\n                    case 2:\n                        _a.sent();\n                        return [2 /*return*/, stale];\n                    case 3: return [4 /*yield*/, remove(key)];\n                    case 4:\n                        _a.sent();\n                        return [2 /*return*/, { state: 'empty' }];\n                }\n            });\n        }); },\n        _b;\n}\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport { 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    var data = {};\n    var storage = buildStorage({\n        find: function (key) { return data[key]; },\n        set: function (key, value) {\n            data[key] = value;\n        },\n        remove: function (key) {\n            delete data[key];\n        }\n    });\n    return __assign(__assign({}, storage), { data: data });\n}\n","import { code } from 'object-code';\n// Remove first and last '/' char, if present\nvar SLASHES_REGEX = /^\\/|\\/$/g;\nexport function buildKeyGenerator(hash, generator) {\n    return function (request) {\n        if (request.id) {\n            return request.id;\n        }\n        // Remove trailing slashes\n        request.baseURL && (request.baseURL = request.baseURL.replace(SLASHES_REGEX, ''));\n        request.url && (request.url = request.url.replace(SLASHES_REGEX, ''));\n        // lowercase method\n        request.method && (request.method = request.method.toLowerCase());\n        var result = generator(request);\n        return hash ? code(result).toString() : result;\n    };\n}\nexport var defaultKeyGenerator = buildKeyGenerator(true, function (_a) {\n    var _b = _a.baseURL, baseURL = _b === void 0 ? '' : _b, _c = _a.url, url = _c === void 0 ? '' : _c, _d = _a.method, method = _d === void 0 ? 'get' : _d, params = _a.params, data = _a.data;\n    return {\n        url: baseURL + (baseURL && url ? '/' : '') + url,\n        method: method,\n        params: params,\n        data: data\n    };\n});\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\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 { 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    if (_a === void 0) { _a = {}; }\n    var storage = _a.storage, generateKey = _a.generateKey, waiting = _a.waiting, headerInterpreter = _a.headerInterpreter, requestInterceptor = _a.requestInterceptor, responseInterceptor = _a.responseInterceptor, cacheOptions = __rest(_a, [\"storage\", \"generateKey\", \"waiting\", \"headerInterpreter\", \"requestInterceptor\", \"responseInterceptor\"]);\n    var 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 = __assign(__assign({}, axios.defaults), { cache: __assign({ ttl: 1000 * 60 * 5, interpretHeader: false, methods: ['get'], cachePredicate: { statusCheck: function (status) { return 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    if (prefix === void 0) { prefix = ''; }\n    return buildStorage({\n        find: function (key) {\n            var json = storage.getItem(prefix + key);\n            return json ? JSON.parse(json) : undefined;\n        },\n        set: function (key, value) {\n            storage.setItem(prefix + key, JSON.stringify(value));\n        },\n        remove: function (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","transform","Date","getTime","RegExp","toString","Array","isArray","String","constructor","JSON","stringify","keys","sort","Math","random","code","charCodeAt","__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","_a","age","Age","expires","Expires","milliseconds","now","__assign","assign","arguments","p","apply","createValidateStatus","oldValidate","status","isMethodIn","requestMethod","methodList","_i","methodList_1","setRevalidationHeaders","cache","config","_b","etag","modifiedSince","etagValue","data","ETag","IfNoneMatch","IfModifiedSince","LastModified","createdAt","toUTCString","setupCacheData","response","cached","statusText","__awaiter","thisArg","_arguments","P","generator","fulfilled","step","next","rejected","result","done","then","__generator","body","f","y","g","_","label","sent","trys","ops","verb","iterator","v","op","TypeError","pop","defaultRequestInterceptor","axios","_this","onFulfilled","cachedResponse","deferred_1","_c","defaults","method","methods","id","generateKey","storage","state","waiting","catch","set","validateStatus","remove","adapter","interceptors","request","use","testCachePredicate","predicate","statusCheck","responseMatch","containsHeaders","_d","_e","_f","header","predicate_1","_g","_h","updateCache","entries","cacheKey","oldValue","newValue","defaultResponseInterceptor","rejectResponse","responseId","cacheConfig","ttl","expirationTime","newCache","cachePredicate","XAxiosCacheEtag","XAxiosCacheLastModified","interpretHeader","headerInterpreter","update","isStorage","buildStorage","find","stale","buildMemoryStorage","SLASHES_REGEX","buildKeyGenerator","hash","baseURL","url","defaultKeyGenerator","params","__rest","indexOf","getOwnPropertySymbols","propertyIsEnumerable","setupCache","requestInterceptor","responseInterceptor","cacheOptions","axiosCache","Error","buildWebStorage","prefix","json","getItem","setItem","removeItem"],"sourceRoot":""}