{"version":3,"file":"umd/es6.js","mappings":"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","sources":["webpack://AxiosCacheInterceptor/webpack/universalModuleDefinition","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/./node_modules/cache-parser/dist/index.mjs","webpack://AxiosCacheInterceptor/./src/util/headers.ts","webpack://AxiosCacheInterceptor/./src/header/interpreter.ts","webpack://AxiosCacheInterceptor/./node_modules/tslib/tslib.es6.js","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' ? self : this, function() {\nreturn ","!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 {\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};","var e=Symbol(\"cache-parser\");function a(a){return!(!a||!a[e])}function r(e){return(\"string\"==typeof e||\"number\"==typeof e)&&(e=Number(e))>=0&&e, :: GMT\n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-Modified-Since\n */\n IfModifiedSince: 'if-modified-since',\n /**\n * ```txt\n * Last-Modified: , :: GMT\n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Last-Modified\n */\n LastModified: 'last-modified',\n /**\n * ```txt\n * If-None-Match: \"\"\n * If-None-Match: \"\", \"\", …\n * If-None-Match: *\n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-None-Match\n */\n IfNoneMatch: 'if-none-match',\n /**\n * ```txt\n * Cache-Control: max-age=604800\n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control\n */\n CacheControl: 'cache-control',\n /**\n * ```txt\n * ETag: W / '';\n * ETag: '';\n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag\n */\n ETag: 'etag',\n /**\n * ```txt\n * Expires: \n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Expires\n */\n Expires: 'expires',\n /**\n * ```txt\n * Age: \n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Age\n */\n 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 ContentType: 'content-type',\n /**\n * Used internally as metadata to mark the cache item as revalidatable and enabling\n * stale 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: \"\"\n * ```\n */\n XAxiosCacheEtag: 'x-axios-cache-etag',\n /**\n * Used internally as metadata to mark the cache item as revalidatable and enabling\n * stale cache state may contain `'use-cache-timestamp'` if `cache.modifiedSince` is\n * `true`, otherwise will contain a date from `cache.modifiedSince`. If a date is\n * provided, it can be used for `If-Modified-Since` header, otherwise the cache\n * timestamp can be used for `If-Modified-Since` header.\n *\n * ```txt\n * X-Axios-Cache-Last-Modified: , :: GMT\n * X-Axios-Cache-Last-Modified: use-cache-timestamp\n * ```\n */\n XAxiosCacheLastModified: 'x-axios-cache-last-modified',\n /**\n * Used internally as metadata to mark the cache item able to be used if the server\n * returns an error. The stale-if-error response directive indicates that the cache can\n * reuse a stale response when any error occurs.\n *\n * ```txt\n * XAxiosCacheStaleIfError: \n * ```\n */\n XAxiosCacheStaleIfError: 'x-axios-cache-stale-if-error'\n});\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(String(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(String(expires)) - Date.now();\n return milliseconds >= 0 ? milliseconds : 'dont cache';\n }\n return 'not enough headers';\n};\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n extendStatics = Object.setPrototypeOf ||\r\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n if (typeof b !== \"function\" && b !== null)\r\n throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n extendStatics(d, b);\r\n function __() { this.constructor = d; }\r\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n __assign = Object.assign || function __assign(t) {\r\n for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n s = arguments[i];\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n }\r\n return t;\r\n }\r\n return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n var t = {};\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n t[p] = s[p];\r\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n t[p[i]] = s[p[i]];\r\n }\r\n return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n return new (P || (P = Promise))(function (resolve, reject) {\r\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n function verb(n) { return function (v) { return step([n, v]); }; }\r\n function step(op) {\r\n if (f) throw new TypeError(\"Generator is already executing.\");\r\n while (_) try {\r\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;\r\n if (y = 0, t) op = [op[0] & 2, t.value];\r\n switch (op[0]) {\r\n case 0: case 1: t = op; break;\r\n case 4: _.label++; return { value: op[1], done: false };\r\n case 5: _.label++; y = op[1]; op = [0]; continue;\r\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n default:\r\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n if (t[2]) _.ops.pop();\r\n _.trys.pop(); continue;\r\n }\r\n op = body.call(thisArg, _);\r\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n if (m) return m.call(o);\r\n if (o && typeof o.length === \"number\") return {\r\n next: function () {\r\n if (o && i >= o.length) o = void 0;\r\n return { value: o && o[i++], done: !o };\r\n }\r\n };\r\n throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n for (var ar = [], i = 0; i < arguments.length; i++)\r\n ar = ar.concat(__read(arguments[i]));\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n r[k] = a[j];\r\n return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n if (ar || !(i in from)) {\r\n if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n ar[i] = from[i];\r\n }\r\n }\r\n return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n function fulfill(value) { resume(\"next\", value); }\r\n function reject(value) { resume(\"throw\", value); }\r\n function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n var i, p;\r\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var m = o[Symbol.asyncIterator], i;\r\n return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n if (mod && mod.__esModule) return mod;\r\n var result = {};\r\n if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n __setModuleDefault(result, mod);\r\n return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\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}\n/**\n * This function updates the cache when the request is stale. So, the next request to the\n * server will be made with proper header / settings.\n */\nexport function updateStaleRequest(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 createCacheResponse(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","import { __awaiter } from \"tslib\";\nimport { deferred } from 'fast-defer';\nimport { createValidateStatus, isMethodIn, updateStaleRequest } 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 = (config.id = 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 previous: cache.state,\n // Eslint complains a lot :)\n // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any\n data: cache.data,\n // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any\n createdAt: cache.createdAt\n });\n if (cache.state === 'stale') {\n updateStaleRequest(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 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","import { __awaiter } from \"tslib\";\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","import { __awaiter } from \"tslib\";\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","import { __awaiter } from \"tslib\";\nimport { testCachePredicate } from '../util/cache-predicate';\nimport { Header } from '../util/headers';\nimport { updateCache } from '../util/update-cache';\nimport { createCacheResponse } 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 = (responseId) => __awaiter(this, void 0, void 0, function* () {\n var _a;\n // Update the cache to empty to prevent infinite loading state\n yield axios.storage.remove(responseId);\n // Reject the deferred if present\n (_a = axios.waiting[responseId]) === null || _a === void 0 ? void 0 : _a.reject(null);\n delete axios.waiting[responseId];\n });\n const onFulfilled = (response) => __awaiter(this, void 0, void 0, function* () {\n var _b, _c, _d;\n var _e;\n response.id = (_b = (_e = response.config).id) !== null && _b !== void 0 ? _b : (_e.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 // Request interceptor merges defaults with per request configuration\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(response.id);\n return response;\n }\n // avoid remnant headers from remote server to break implementation\n for (const header in Header) {\n if (!header.startsWith('XAxiosCache')) {\n continue;\n }\n delete response.headers[header];\n }\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(response.id);\n return response;\n }\n ttl = expirationTime === 'not enough headers' ? ttl : expirationTime;\n }\n const data = createCacheResponse(response, cache.data);\n if (typeof ttl === 'function') {\n ttl = yield ttl(response);\n }\n if (cacheConfig.staleIfError) {\n response.headers[Header.XAxiosCacheStaleIfError] = String(ttl);\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 newCache = {\n state: 'cached',\n ttl,\n createdAt: Date.now(),\n data\n };\n // Resolve all other requests waiting for this response\n (_d = axios.waiting[response.id]) === null || _d === void 0 ? void 0 : _d.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 const onRejected = (error) => __awaiter(this, void 0, void 0, function* () {\n var _f;\n const config = error['config'];\n if (!config || config.cache === false || !config.id) {\n throw error;\n }\n const cache = yield axios.storage.get(config.id);\n const cacheConfig = config.cache;\n if (\n // This will only not be loading if the interceptor broke\n cache.state !== 'loading' ||\n cache.previous !== 'stale') {\n yield rejectResponse(config.id);\n throw error;\n }\n if (cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.staleIfError) {\n const staleIfError = typeof cacheConfig.staleIfError === 'function'\n ? yield cacheConfig.staleIfError(error.response, cache, error)\n : cacheConfig.staleIfError;\n if (staleIfError === true ||\n // staleIfError is the number of seconds that stale is allowed to be used\n (typeof staleIfError === 'number' && cache.createdAt + staleIfError > Date.now())) {\n // Resolve all other requests waiting for this response\n (_f = axios.waiting[config.id]) === null || _f === void 0 ? void 0 : _f.resolve(cache.data);\n delete axios.waiting[config.id];\n // re-mark the cache as stale\n yield axios.storage.set(config.id, {\n state: 'stale',\n createdAt: Date.now(),\n data: cache.data\n });\n return {\n cached: true,\n config,\n id: config.id,\n data: cache.data.data,\n headers: cache.data.headers,\n status: cache.data.status,\n statusText: cache.data.statusText\n };\n }\n }\n throw error;\n });\n return {\n onFulfilled,\n onRejected,\n apply: () => axios.interceptors.response.use(onFulfilled, onRejected)\n };\n}\n","import { __awaiter } from \"tslib\";\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 // Any header below allows the response to stale\n (Header.ETag in value.data.headers ||\n Header.LastModified in value.data.headers ||\n Header.XAxiosCacheEtag in value.data.headers ||\n Header.XAxiosCacheStaleIfError in value.data.headers ||\n Header.XAxiosCacheLastModified in value.data.headers)) {\n const stale = {\n state: 'stale',\n createdAt: value.createdAt,\n data: value.data\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","import { code } from 'object-code';\n// Remove first and last '/' char, if present\nconst SLASHES_REGEX = /^\\/|\\/$/g;\nexport function buildKeyGenerator(hash, generator) {\n return (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 const result = generator(request);\n return hash ? code(result).toString() : result;\n };\n}\nexport const defaultKeyGenerator = buildKeyGenerator(true, ({ baseURL = '', url = '', method = 'get', params, data }) => {\n return {\n url: baseURL + (baseURL && url ? '/' : '') + url,\n method,\n params: params,\n data\n };\n});\n","import { 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, options = {}) {\n var _a, _b, _c, _d, _e;\n const axiosCache = axios;\n axiosCache.storage = options.storage || buildMemoryStorage();\n if (!isStorage(axiosCache.storage)) {\n throw new Error('Use buildStorage() function');\n }\n axiosCache.generateKey = options.generateKey || defaultKeyGenerator;\n axiosCache.waiting = options.waiting || {};\n axiosCache.headerInterpreter = options.headerInterpreter || defaultHeaderInterpreter;\n axiosCache.requestInterceptor =\n options.requestInterceptor || defaultRequestInterceptor(axiosCache);\n axiosCache.responseInterceptor =\n options.responseInterceptor || defaultResponseInterceptor(axiosCache);\n // CacheRequestConfig values\n axiosCache.defaults.cache = {\n ttl: (_a = options.ttl) !== null && _a !== void 0 ? _a : 1000 * 60 * 5,\n interpretHeader: (_b = options.interpretHeader) !== null && _b !== void 0 ? _b : false,\n methods: options.methods || ['get'],\n cachePredicate: options.cachePredicate || {\n statusCheck: (status) => status >= 200 && status < 400\n },\n etag: (_c = options.etag) !== null && _c !== void 0 ? _c : false,\n modifiedSince: (_d = options.modifiedSince) !== null && _d !== void 0 ? _d : false,\n staleIfError: (_e = options.staleIfError) !== null && _e !== void 0 ? _e : false,\n update: options.update || {}\n };\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","r","Symbol","deferred","n","t","Promise","resolve","reject","isDeferred","transform","Date","getTime","RegExp","toString","o","Array","isArray","String","constructor","JSON","stringify","Object","keys","sort","Math","random","code","length","charCodeAt","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","__webpack_modules__","d","definition","key","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","toStringTag","value","Number","Infinity","Header","freeze","IfModifiedSince","LastModified","IfNoneMatch","CacheControl","ETag","Expires","Age","ContentType","XAxiosCacheEtag","XAxiosCacheLastModified","XAxiosCacheStaleIfError","defaultHeaderInterpreter","headers","cacheControl","noCache","noStore","mustRevalidate","maxAge","immutable","a","i","toLowerCase","replace","split","s","maxStale","minFresh","mustUnderstand","noTransform","onlyIfCached","private","proxyRevalidate","public","sMaxAge","staleIfError","staleWhileRevalidate","age","expires","milliseconds","parse","now","__awaiter","thisArg","_arguments","P","generator","fulfilled","step","next","rejected","result","done","then","apply","create","createValidateStatus","oldValidate","status","isMethodIn","requestMethod","methodList","method","updateStaleRequest","cache","config","_a","etag","modifiedSince","etagValue","data","createdAt","toUTCString","createCacheResponse","response","cached","statusText","assign","defaultRequestInterceptor","axios","onFulfilled","defaults","methods","id","generateKey","cachedResponse","storage","emptyOrStale","state","waiting","catch","set","previous","validateStatus","remove","_b","adapter","interceptors","request","use","testCachePredicate","predicate","statusCheck","responseMatch","containsHeaders","header","updateCache","entries","cacheKey","oldValue","newValue","defaultResponseInterceptor","rejectResponse","responseId","_c","_d","_e","cacheConfig","cachePredicate","startsWith","ttl","interpretHeader","expirationTime","headerInterpreter","update","newCache","onRejected","error","_f","isStorage","buildStorage","find","stale","buildMemoryStorage","SLASHES_REGEX","buildKeyGenerator","hash","baseURL","url","defaultKeyGenerator","params","setupCache","options","axiosCache","Error","requestInterceptor","responseInterceptor","buildWebStorage","prefix","json","getItem","setItem","removeItem"],"sourceRoot":""}