{"version":3,"file":"umd/es5.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=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 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(String(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(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 { __assign } from \"tslib\";\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}\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 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 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 = __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","import { __assign, __awaiter, __generator } from \"tslib\";\nimport { deferred } from 'fast-defer';\nimport { createValidateStatus, isMethodIn, updateStaleRequest } 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 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 case 4:\n _c.sent();\n if (cache.state === 'stale') {\n updateStaleRequest(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 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","import { __awaiter, __generator } 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 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","import { __awaiter, __generator } 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 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","import { __assign, __awaiter, __generator } 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 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 (responseId) { return __awaiter(_this, void 0, void 0, function () {\n var _a;\n return __generator(this, function (_b) {\n switch (_b.label) {\n case 0: \n // Update the cache to empty to prevent infinite loading state\n return [4 /*yield*/, axios.storage.remove(responseId)];\n case 1:\n // Update the cache to empty to prevent infinite loading state\n _b.sent();\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 return [2 /*return*/];\n }\n });\n }); };\n var onFulfilled = function (response) { return __awaiter(_this, void 0, void 0, function () {\n var cacheConfig, cache, _a, header, ttl, expirationTime, data, newCache;\n var _b, _c, _d;\n var _e;\n return __generator(this, function (_f) {\n switch (_f.label) {\n case 0:\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 [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 = _f.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 = !(_f.sent());\n _f.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(response.id)];\n case 4:\n _f.sent();\n return [2 /*return*/, response];\n case 5:\n // avoid remnant headers from remote server to break implementation\n for (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 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(response.id)];\n case 6:\n _f.sent();\n return [2 /*return*/, response];\n case 7:\n ttl = expirationTime === 'not enough headers' ? ttl : expirationTime;\n _f.label = 8;\n case 8:\n data = createCacheResponse(response, cache.data);\n if (!(typeof ttl === 'function')) return [3 /*break*/, 10];\n return [4 /*yield*/, ttl(response)];\n case 9:\n ttl = _f.sent();\n _f.label = 10;\n case 10:\n if (cacheConfig.staleIfError) {\n response.headers[Header.XAxiosCacheStaleIfError] = String(ttl);\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 _f.sent();\n _f.label = 12;\n case 12:\n newCache = {\n state: 'cached',\n ttl: ttl,\n createdAt: Date.now(),\n data: 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 return [4 /*yield*/, axios.storage.set(response.id, newCache)];\n case 13:\n // Define this key as cache on the storage\n _f.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 var onRejected = function (error) { return __awaiter(_this, void 0, void 0, function () {\n var config, cache, cacheConfig, staleIfError, _a;\n var _b;\n return __generator(this, function (_c) {\n switch (_c.label) {\n case 0:\n config = error['config'];\n if (!config || config.cache === false || !config.id) {\n throw error;\n }\n return [4 /*yield*/, axios.storage.get(config.id)];\n case 1:\n cache = _c.sent();\n 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 // This will only not be loading if the interceptor broke\n return [3 /*break*/, 3];\n return [4 /*yield*/, rejectResponse(config.id)];\n case 2:\n _c.sent();\n throw error;\n case 3:\n if (!(cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.staleIfError)) return [3 /*break*/, 8];\n if (!(typeof cacheConfig.staleIfError === 'function')) return [3 /*break*/, 5];\n return [4 /*yield*/, cacheConfig.staleIfError(error.response, cache, error)];\n case 4:\n _a = _c.sent();\n return [3 /*break*/, 6];\n case 5:\n _a = cacheConfig.staleIfError;\n _c.label = 6;\n case 6:\n staleIfError = _a;\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()))) return [3 /*break*/, 8];\n // Resolve all other requests waiting for this response\n (_b = axios.waiting[config.id]) === null || _b === void 0 ? void 0 : _b.resolve(cache.data);\n delete axios.waiting[config.id];\n // re-mark the cache as stale\n return [4 /*yield*/, axios.storage.set(config.id, {\n state: 'stale',\n createdAt: Date.now(),\n data: cache.data\n })];\n case 7:\n // re-mark the cache as stale\n _c.sent();\n return [2 /*return*/, {\n cached: true,\n config: 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 case 8: throw error;\n }\n });\n }); };\n return {\n onFulfilled: onFulfilled,\n onRejected: onRejected,\n apply: function () { return axios.interceptors.response.use(onFulfilled, onRejected); }\n };\n}\n","import { __awaiter, __generator } from \"tslib\";\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 // 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))) return [3 /*break*/, 3];\n stale = {\n state: 'stale',\n createdAt: value.createdAt,\n data: value.data\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","import { __assign } from \"tslib\";\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","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 if (options === void 0) { options = {}; }\n var 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: function (status) { return 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 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","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","_a","a","i","toLowerCase","replace","split","s","immutable","maxAge","maxStale","minFresh","mustRevalidate","mustUnderstand","noCache","noStore","noTransform","onlyIfCached","private","proxyRevalidate","public","sMaxAge","staleIfError","staleWhileRevalidate","age","expires","milliseconds","parse","now","__assign","assign","arguments","p","apply","__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","push","create","createValidateStatus","oldValidate","status","isMethodIn","requestMethod","methodList","_i","methodList_1","updateStaleRequest","cache","config","_b","etag","modifiedSince","etagValue","data","createdAt","toUTCString","createCacheResponse","response","cached","statusText","defaultRequestInterceptor","axios","_this","onFulfilled","cachedResponse","deferred_1","_c","defaults","method","methods","id","generateKey","storage","state","waiting","catch","set","previous","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","startsWith","interpretHeader","headerInterpreter","update","onRejected","error","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":""}