1
|
{"version":3,"file":"workbox-precaching.dev.js","sources":["../_version.mjs","../utils/precachePlugins.mjs","../addPlugins.mjs","../utils/cleanRedirect.mjs","../utils/createCacheKey.mjs","../utils/printCleanupDetails.mjs","../utils/printInstallDetails.mjs","../PrecacheController.mjs","../utils/getOrCreatePrecacheController.mjs","../utils/removeIgnoredSearchParams.mjs","../utils/generateURLVariations.mjs","../utils/getCacheKeyForURL.mjs","../utils/addFetchListener.mjs","../addRoute.mjs","../utils/deleteOutdatedCaches.mjs","../cleanupOutdatedCaches.mjs","../getCacheKeyForURL.mjs","../precache.mjs","../precacheAndRoute.mjs","../index.mjs"],"sourcesContent":["try{self['workbox:precaching:4.3.1']&&_()}catch(e){}// eslint-disable-line","/*\n Copyright 2019 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport '../_version.mjs';\n\n\nconst plugins = [];\n\nexport const precachePlugins = {\n /*\n * @return {Array}\n * @private\n */\n get() {\n return plugins;\n },\n\n /*\n * @param {Array} newPlugins\n * @private\n */\n add(newPlugins) {\n plugins.push(...newPlugins);\n },\n};\n","/*\n Copyright 2019 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {precachePlugins} from './utils/precachePlugins.mjs';\nimport './_version.mjs';\n\n\n/**\n * Adds plugins to precaching.\n *\n * @param {Array<Object>} newPlugins\n *\n * @alias workbox.precaching.addPlugins\n */\nconst addPlugins = (newPlugins) => {\n precachePlugins.add(newPlugins);\n};\n\nexport {addPlugins};\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport '../_version.mjs';\n\n/**\n * @param {Response} response\n * @return {Response}\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport async function cleanRedirect(response) {\n const clonedResponse = response.clone();\n\n // Not all browsers support the Response.body stream, so fall back\n // to reading the entire body into memory as a blob.\n const bodyPromise = 'body' in clonedResponse ?\n Promise.resolve(clonedResponse.body) :\n clonedResponse.blob();\n\n const body = await bodyPromise;\n\n // new Response() is happy when passed either a stream or a Blob.\n return new Response(body, {\n headers: clonedResponse.headers,\n status: clonedResponse.status,\n statusText: clonedResponse.statusText,\n });\n}\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';\n\nimport '../_version.mjs';\n\n// Name of the search parameter used to store revision info.\nconst REVISION_SEARCH_PARAM = '__WB_REVISION__';\n\n/**\n * Converts a manifest entry into a versioned URL suitable for precaching.\n *\n * @param {Object} entry\n * @return {string} A URL with versioning info.\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function createCacheKey(entry) {\n if (!entry) {\n throw new WorkboxError('add-to-cache-list-unexpected-type', {entry});\n }\n\n // If a precache manifest entry is a string, it's assumed to be a versioned\n // URL, like '/app.abcd1234.js'. Return as-is.\n if (typeof entry === 'string') {\n const urlObject = new URL(entry, location);\n return {\n cacheKey: urlObject.href,\n url: urlObject.href,\n };\n }\n\n const {revision, url} = entry;\n if (!url) {\n throw new WorkboxError('add-to-cache-list-unexpected-type', {entry});\n }\n\n // If there's just a URL and no revision, then it's also assumed to be a\n // versioned URL.\n if (!revision) {\n const urlObject = new URL(url, location);\n return {\n cacheKey: urlObject.href,\n url: urlObject.href,\n };\n }\n\n // Otherwise, construct a properly versioned URL using the custom Workbox\n // search parameter along with the revision info.\n const originalURL = new URL(url, location);\n const cacheKeyURL = new URL(url, location);\n cacheKeyURL.searchParams.set(REVISION_SEARCH_PARAM, revision);\n return {\n cacheKey: cacheKeyURL.href,\n url: originalURL.href,\n };\n}\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {logger} from 'workbox-core/_private/logger.mjs';\n\nimport '../_version.mjs';\n\nconst logGroup = (groupTitle, deletedURLs) => {\n logger.groupCollapsed(groupTitle);\n\n for (const url of deletedURLs) {\n logger.log(url);\n }\n\n logger.groupEnd();\n};\n\n/**\n * @param {Array<string>} deletedURLs\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function printCleanupDetails(deletedURLs) {\n const deletionCount = deletedURLs.length;\n if (deletionCount > 0) {\n logger.groupCollapsed(`During precaching cleanup, ` +\n `${deletionCount} cached ` +\n `request${deletionCount === 1 ? ' was' : 's were'} deleted.`);\n logGroup('Deleted Cache Requests', deletedURLs);\n logger.groupEnd();\n }\n}\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {logger} from 'workbox-core/_private/logger.mjs';\n\nimport '../_version.mjs';\n\n/**\n * @param {string} groupTitle\n * @param {Array<string>} urls\n *\n * @private\n */\nfunction _nestedGroup(groupTitle, urls) {\n if (urls.length === 0) {\n return;\n }\n\n logger.groupCollapsed(groupTitle);\n\n for (const url of urls) {\n logger.log(url);\n }\n\n logger.groupEnd();\n}\n\n/**\n * @param {Array<string>} urlsToPrecache\n * @param {Array<string>} urlsAlreadyPrecached\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function printInstallDetails(urlsToPrecache, urlsAlreadyPrecached) {\n const precachedCount = urlsToPrecache.length;\n const alreadyPrecachedCount = urlsAlreadyPrecached.length;\n\n if (precachedCount || alreadyPrecachedCount) {\n let message =\n `Precaching ${precachedCount} file${precachedCount === 1 ? '' : 's'}.`;\n\n if (alreadyPrecachedCount > 0) {\n message += ` ${alreadyPrecachedCount} ` +\n `file${alreadyPrecachedCount === 1 ? ' is' : 's are'} already cached.`;\n }\n\n logger.groupCollapsed(message);\n\n _nestedGroup(`View newly precached URLs.`, urlsToPrecache);\n _nestedGroup(`View previously precached URLs.`, urlsAlreadyPrecached);\n logger.groupEnd();\n }\n}\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {assert} from 'workbox-core/_private/assert.mjs';\nimport {cacheNames} from 'workbox-core/_private/cacheNames.mjs';\nimport {cacheWrapper} from 'workbox-core/_private/cacheWrapper.mjs';\nimport {fetchWrapper} from 'workbox-core/_private/fetchWrapper.mjs';\nimport {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';\n\nimport {cleanRedirect} from './utils/cleanRedirect.mjs';\nimport {createCacheKey} from './utils/createCacheKey.mjs';\nimport {printCleanupDetails} from './utils/printCleanupDetails.mjs';\nimport {printInstallDetails} from './utils/printInstallDetails.mjs';\n\nimport './_version.mjs';\n\n\n/**\n * Performs efficient precaching of assets.\n *\n * @memberof module:workbox-precaching\n */\nclass PrecacheController {\n /**\n * Create a new PrecacheController.\n *\n * @param {string} [cacheName] An optional name for the cache, to override\n * the default precache name.\n */\n constructor(cacheName) {\n this._cacheName = cacheNames.getPrecacheName(cacheName);\n this._urlsToCacheKeys = new Map();\n }\n\n /**\n * This method will add items to the precache list, removing duplicates\n * and ensuring the information is valid.\n *\n * @param {\n * Array<module:workbox-precaching.PrecacheController.PrecacheEntry|string>\n * } entries Array of entries to precache.\n */\n addToCacheList(entries) {\n if (process.env.NODE_ENV !== 'production') {\n assert.isArray(entries, {\n moduleName: 'workbox-precaching',\n className: 'PrecacheController',\n funcName: 'addToCacheList',\n paramName: 'entries',\n });\n }\n\n for (const entry of entries) {\n const {cacheKey, url} = createCacheKey(entry);\n if (this._urlsToCacheKeys.has(url) &&\n this._urlsToCacheKeys.get(url) !== cacheKey) {\n throw new WorkboxError('add-to-cache-list-conflicting-entries', {\n firstEntry: this._urlsToCacheKeys.get(url),\n secondEntry: cacheKey,\n });\n }\n this._urlsToCacheKeys.set(url, cacheKey);\n }\n }\n\n /**\n * Precaches new and updated assets. Call this method from the service worker\n * install event.\n *\n * @param {Object} options\n * @param {Event} [options.event] The install event (if needed).\n * @param {Array<Object>} [options.plugins] Plugins to be used for fetching\n * and caching during install.\n * @return {Promise<workbox.precaching.InstallResult>}\n */\n async install({event, plugins} = {}) {\n if (process.env.NODE_ENV !== 'production') {\n if (plugins) {\n assert.isArray(plugins, {\n moduleName: 'workbox-precaching',\n className: 'PrecacheController',\n funcName: 'install',\n paramName: 'plugins',\n });\n }\n }\n\n const urlsToPrecache = [];\n const urlsAlreadyPrecached = [];\n\n const cache = await caches.open(this._cacheName);\n const alreadyCachedRequests = await cache.keys();\n const alreadyCachedURLs = new Set(alreadyCachedRequests.map(\n (request) => request.url));\n\n for (const cacheKey of this._urlsToCacheKeys.values()) {\n if (alreadyCachedURLs.has(cacheKey)) {\n urlsAlreadyPrecached.push(cacheKey);\n } else {\n urlsToPrecache.push(cacheKey);\n }\n }\n\n const precacheRequests = urlsToPrecache.map((url) => {\n return this._addURLToCache({event, plugins, url});\n });\n await Promise.all(precacheRequests);\n\n if (process.env.NODE_ENV !== 'production') {\n printInstallDetails(urlsToPrecache, urlsAlreadyPrecached);\n }\n\n return {\n updatedURLs: urlsToPrecache,\n notUpdatedURLs: urlsAlreadyPrecached,\n };\n }\n\n /**\n * Deletes assets that are no longer present in the current precache manifest.\n * Call this method from the service worker activate event.\n *\n * @return {Promise<workbox.precaching.CleanupResult>}\n */\n async activate() {\n const cache = await caches.open(this._cacheName);\n const currentlyCachedRequests = await cache.keys();\n const expectedCacheKeys = new Set(this._urlsToCacheKeys.values());\n\n const deletedURLs = [];\n for (const request of currentlyCachedRequests) {\n if (!expectedCacheKeys.has(request.url)) {\n await cache.delete(request);\n deletedURLs.push(request.url);\n }\n }\n\n if (process.env.NODE_ENV !== 'production') {\n printCleanupDetails(deletedURLs);\n }\n\n return {deletedURLs};\n }\n\n /**\n * Requests the entry and saves it to the cache if the response is valid.\n * By default, any response with a status code of less than 400 (including\n * opaque responses) is considered valid.\n *\n * If you need to use custom criteria to determine what's valid and what\n * isn't, then pass in an item in `options.plugins` that implements the\n * `cacheWillUpdate()` lifecycle event.\n *\n * @private\n * @param {Object} options\n * @param {string} options.url The URL to fetch and cache.\n * @param {Event} [options.event] The install event (if passed).\n * @param {Array<Object>} [options.plugins] An array of plugins to apply to\n * fetch and caching.\n */\n async _addURLToCache({url, event, plugins}) {\n const request = new Request(url, {credentials: 'same-origin'});\n let response = await fetchWrapper.fetch({\n event,\n plugins,\n request,\n });\n\n // Allow developers to override the default logic about what is and isn't\n // valid by passing in a plugin implementing cacheWillUpdate(), e.g.\n // a workbox.cacheableResponse.Plugin instance.\n let cacheWillUpdateCallback;\n for (const plugin of (plugins || [])) {\n if ('cacheWillUpdate' in plugin) {\n cacheWillUpdateCallback = plugin.cacheWillUpdate.bind(plugin);\n }\n }\n\n const isValidResponse = cacheWillUpdateCallback ?\n // Use a callback if provided. It returns a truthy value if valid.\n cacheWillUpdateCallback({event, request, response}) :\n // Otherwise, default to considering any response status under 400 valid.\n // This includes, by default, considering opaque responses valid.\n response.status < 400;\n\n // Consider this a failure, leading to the `install` handler failing, if\n // we get back an invalid response.\n if (!isValidResponse) {\n throw new WorkboxError('bad-precaching-response', {\n url,\n status: response.status,\n });\n }\n\n if (response.redirected) {\n response = await cleanRedirect(response);\n }\n\n await cacheWrapper.put({\n event,\n plugins,\n request,\n response,\n cacheName: this._cacheName,\n matchOptions: {\n ignoreSearch: true,\n },\n });\n }\n\n /**\n * Returns a mapping of a precached URL to the corresponding cache key, taking\n * into account the revision information for the URL.\n *\n * @return {Map<string, string>} A URL to cache key mapping.\n */\n getURLsToCacheKeys() {\n return this._urlsToCacheKeys;\n }\n\n /**\n * Returns a list of all the URLs that have been precached by the current\n * service worker.\n *\n * @return {Array<string>} The precached URLs.\n */\n getCachedURLs() {\n return [...this._urlsToCacheKeys.keys()];\n }\n\n /**\n * Returns the cache key used for storing a given URL. If that URL is\n * unversioned, like `/index.html', then the cache key will be the original\n * URL with a search parameter appended to it.\n *\n * @param {string} url A URL whose cache key you want to look up.\n * @return {string} The versioned URL that corresponds to a cache key\n * for the original URL, or undefined if that URL isn't precached.\n */\n getCacheKeyForURL(url) {\n const urlObject = new URL(url, location);\n return this._urlsToCacheKeys.get(urlObject.href);\n }\n}\n\nexport {PrecacheController};\n","/*\n Copyright 2019 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {PrecacheController} from '../PrecacheController.mjs';\nimport '../_version.mjs';\n\n\nlet precacheController;\n\n/**\n * @return {PrecacheController}\n * @private\n */\nexport const getOrCreatePrecacheController = () => {\n if (!precacheController) {\n precacheController = new PrecacheController();\n }\n return precacheController;\n};\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport '../_version.mjs';\n\n/**\n * Removes any URL search parameters that should be ignored.\n *\n * @param {URL} urlObject The original URL.\n * @param {Array<RegExp>} ignoreURLParametersMatching RegExps to test against\n * each search parameter name. Matches mean that the search parameter should be\n * ignored.\n * @return {URL} The URL with any ignored search parameters removed.\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function removeIgnoredSearchParams(urlObject,\n ignoreURLParametersMatching) {\n // Convert the iterable into an array at the start of the loop to make sure\n // deletion doesn't mess up iteration.\n for (const paramName of [...urlObject.searchParams.keys()]) {\n if (ignoreURLParametersMatching.some((regExp) => regExp.test(paramName))) {\n urlObject.searchParams.delete(paramName);\n }\n }\n\n return urlObject;\n}\n","/*\n Copyright 2019 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {removeIgnoredSearchParams} from './removeIgnoredSearchParams.mjs';\n\nimport '../_version.mjs';\n\n/**\n * Generator function that yields possible variations on the original URL to\n * check, one at a time.\n *\n * @param {string} url\n * @param {Object} options\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function* generateURLVariations(url, {\n ignoreURLParametersMatching,\n directoryIndex,\n cleanURLs,\n urlManipulation,\n} = {}) {\n const urlObject = new URL(url, location);\n urlObject.hash = '';\n yield urlObject.href;\n\n const urlWithoutIgnoredParams = removeIgnoredSearchParams(\n urlObject, ignoreURLParametersMatching);\n yield urlWithoutIgnoredParams.href;\n\n if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith('/')) {\n const directoryURL = new URL(urlWithoutIgnoredParams);\n directoryURL.pathname += directoryIndex;\n yield directoryURL.href;\n }\n\n if (cleanURLs) {\n const cleanURL = new URL(urlWithoutIgnoredParams);\n cleanURL.pathname += '.html';\n yield cleanURL.href;\n }\n\n if (urlManipulation) {\n const additionalURLs = urlManipulation({url: urlObject});\n for (const urlToAttempt of additionalURLs) {\n yield urlToAttempt.href;\n }\n }\n}\n","/*\n Copyright 2019 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {getOrCreatePrecacheController}\n from './getOrCreatePrecacheController.mjs';\nimport {generateURLVariations} from './generateURLVariations.mjs';\nimport '../_version.mjs';\n\n/**\n * This function will take the request URL and manipulate it based on the\n * configuration options.\n *\n * @param {string} url\n * @param {Object} options\n * @return {string} Returns the URL in the cache that matches the request,\n * if possible.\n *\n * @private\n */\nexport const getCacheKeyForURL = (url, options) => {\n const precacheController = getOrCreatePrecacheController();\n\n const urlsToCacheKeys = precacheController.getURLsToCacheKeys();\n for (const possibleURL of generateURLVariations(url, options)) {\n const possibleCacheKey = urlsToCacheKeys.get(possibleURL);\n if (possibleCacheKey) {\n return possibleCacheKey;\n }\n }\n};\n","/*\n Copyright 2019 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {cacheNames} from 'workbox-core/_private/cacheNames.mjs';\nimport {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.mjs';\nimport {logger} from 'workbox-core/_private/logger.mjs';\nimport {getCacheKeyForURL} from './getCacheKeyForURL.mjs';\nimport '../_version.mjs';\n\n\n/**\n * Adds a `fetch` listener to the service worker that will\n * respond to\n * [network requests]{@link https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests}\n * with precached assets.\n *\n * Requests for assets that aren't precached, the `FetchEvent` will not be\n * responded to, allowing the event to fall through to other `fetch` event\n * listeners.\n *\n * NOTE: when called more than once this method will replace the previously set\n * configuration options. Calling it more than once is not recommended outside\n * of tests.\n *\n * @private\n * @param {Object} options\n * @param {string} [options.directoryIndex=index.html] The `directoryIndex` will\n * check cache entries for a URLs ending with '/' to see if there is a hit when\n * appending the `directoryIndex` value.\n * @param {Array<RegExp>} [options.ignoreURLParametersMatching=[/^utm_/]] An\n * array of regex's to remove search params when looking for a cache match.\n * @param {boolean} [options.cleanURLs=true] The `cleanURLs` option will\n * check the cache for the URL with a `.html` added to the end of the end.\n * @param {workbox.precaching~urlManipulation} [options.urlManipulation]\n * This is a function that should take a URL and return an array of\n * alternative URL's that should be checked for precache matches.\n */\nexport const addFetchListener = ({\n ignoreURLParametersMatching = [/^utm_/],\n directoryIndex = 'index.html',\n cleanURLs = true,\n urlManipulation = null,\n} = {}) => {\n const cacheName = cacheNames.getPrecacheName();\n\n addEventListener('fetch', (event) => {\n const precachedURL = getCacheKeyForURL(event.request.url, {\n cleanURLs,\n directoryIndex,\n ignoreURLParametersMatching,\n urlManipulation,\n });\n if (!precachedURL) {\n if (process.env.NODE_ENV !== 'production') {\n logger.debug(`Precaching did not find a match for ` +\n getFriendlyURL(event.request.url));\n }\n return;\n }\n\n let responsePromise = caches.open(cacheName).then((cache) => {\n return cache.match(precachedURL);\n }).then((cachedResponse) => {\n if (cachedResponse) {\n return cachedResponse;\n }\n\n // Fall back to the network if we don't have a cached response\n // (perhaps due to manual cache cleanup).\n if (process.env.NODE_ENV !== 'production') {\n logger.warn(`The precached response for ` +\n `${getFriendlyURL(precachedURL)} in ${cacheName} was not found. ` +\n `Falling back to the network instead.`);\n }\n\n return fetch(precachedURL);\n });\n\n if (process.env.NODE_ENV !== 'production') {\n responsePromise = responsePromise.then((response) => {\n // Workbox is going to handle the route.\n // print the routing details to the console.\n logger.groupCollapsed(`Precaching is responding to: ` +\n getFriendlyURL(event.request.url));\n logger.log(`Serving the precached url: ${precachedURL}`);\n\n logger.groupCollapsed(`View request details here.`);\n logger.log(event.request);\n logger.groupEnd();\n\n logger.groupCollapsed(`View response details here.`);\n logger.log(response);\n logger.groupEnd();\n\n logger.groupEnd();\n return response;\n });\n }\n\n event.respondWith(responsePromise);\n });\n};\n","\n/*\n Copyright 2019 Google LLC\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {addFetchListener} from './utils/addFetchListener.mjs';\nimport './_version.mjs';\n\n\nlet listenerAdded = false;\n\n/**\n * Add a `fetch` listener to the service worker that will\n * respond to\n * [network requests]{@link https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests}\n * with precached assets.\n *\n * Requests for assets that aren't precached, the `FetchEvent` will not be\n * responded to, allowing the event to fall through to other `fetch` event\n * listeners.\n *\n * @param {Object} options\n * @param {string} [options.directoryIndex=index.html] The `directoryIndex` will\n * check cache entries for a URLs ending with '/' to see if there is a hit when\n * appending the `directoryIndex` value.\n * @param {Array<RegExp>} [options.ignoreURLParametersMatching=[/^utm_/]] An\n * array of regex's to remove search params when looking for a cache match.\n * @param {boolean} [options.cleanURLs=true] The `cleanURLs` option will\n * check the cache for the URL with a `.html` added to the end of the end.\n * @param {workbox.precaching~urlManipulation} [options.urlManipulation]\n * This is a function that should take a URL and return an array of\n * alternative URL's that should be checked for precache matches.\n *\n * @alias workbox.precaching.addRoute\n */\nexport const addRoute = (options) => {\n if (!listenerAdded) {\n addFetchListener(options);\n listenerAdded = true;\n }\n};\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport '../_version.mjs';\n\nconst SUBSTRING_TO_FIND = '-precache-';\n\n/**\n * Cleans up incompatible precaches that were created by older versions of\n * Workbox, by a service worker registered under the current scope.\n *\n * This is meant to be called as part of the `activate` event.\n *\n * This should be safe to use as long as you don't include `substringToFind`\n * (defaulting to `-precache-`) in your non-precache cache names.\n *\n * @param {string} currentPrecacheName The cache name currently in use for\n * precaching. This cache won't be deleted.\n * @param {string} [substringToFind='-precache-'] Cache names which include this\n * substring will be deleted (excluding `currentPrecacheName`).\n * @return {Array<string>} A list of all the cache names that were deleted.\n *\n * @private\n * @memberof module:workbox-precaching\n */\nconst deleteOutdatedCaches = async (\n currentPrecacheName,\n substringToFind = SUBSTRING_TO_FIND) => {\n const cacheNames = await caches.keys();\n\n const cacheNamesToDelete = cacheNames.filter((cacheName) => {\n return cacheName.includes(substringToFind) &&\n cacheName.includes(self.registration.scope) &&\n cacheName !== currentPrecacheName;\n });\n\n await Promise.all(\n cacheNamesToDelete.map((cacheName) => caches.delete(cacheName)));\n\n return cacheNamesToDelete;\n};\n\nexport {deleteOutdatedCaches};\n\n","/*\n Copyright 2019 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {cacheNames} from 'workbox-core/_private/cacheNames.mjs';\nimport {logger} from 'workbox-core/_private/logger.mjs';\nimport {deleteOutdatedCaches} from './utils/deleteOutdatedCaches.mjs';\nimport './_version.mjs';\n\n\n/**\n * Adds an `activate` event listener which will clean up incompatible\n * precaches that were created by older versions of Workbox.\n *\n * @alias workbox.precaching.cleanupOutdatedCaches\n */\nexport const cleanupOutdatedCaches = () => {\n addEventListener('activate', (event) => {\n const cacheName = cacheNames.getPrecacheName();\n\n event.waitUntil(deleteOutdatedCaches(cacheName).then((cachesDeleted) => {\n if (process.env.NODE_ENV !== 'production') {\n if (cachesDeleted.length > 0) {\n logger.log(`The following out-of-date precaches were cleaned up ` +\n `automatically:`, cachesDeleted);\n }\n }\n }));\n });\n};\n","/*\n Copyright 2019 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {getOrCreatePrecacheController}\n from './utils/getOrCreatePrecacheController.mjs';\nimport './_version.mjs';\n\n\n/**\n * Takes in a URL, and returns the corresponding URL that could be used to\n * lookup the entry in the precache.\n *\n * If a relative URL is provided, the location of the service worker file will\n * be used as the base.\n *\n * For precached entries without revision information, the cache key will be the\n * same as the original URL.\n *\n * For precached entries with revision information, the cache key will be the\n * original URL with the addition of a query parameter used for keeping track of\n * the revision info.\n *\n * @param {string} url The URL whose cache key to look up.\n * @return {string} The cache key that corresponds to that URL.\n *\n * @alias workbox.precaching.getCacheKeyForURL\n */\nexport const getCacheKeyForURL = (url) => {\n const precacheController = getOrCreatePrecacheController();\n return precacheController.getCacheKeyForURL(url);\n};\n","/*\n Copyright 2019 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {logger} from 'workbox-core/_private/logger.mjs';\nimport {getOrCreatePrecacheController} from './utils/getOrCreatePrecacheController.mjs';\nimport {precachePlugins} from './utils/precachePlugins.mjs';\nimport './_version.mjs';\n\n\nconst installListener = (event) => {\n const precacheController = getOrCreatePrecacheController();\n const plugins = precachePlugins.get();\n\n event.waitUntil(\n precacheController.install({event, plugins})\n .catch((error) => {\n if (process.env.NODE_ENV !== 'production') {\n logger.error(`Service worker installation failed. It will ` +\n `be retried automatically during the next navigation.`);\n }\n // Re-throw the error to ensure installation fails.\n throw error;\n })\n );\n};\n\nconst activateListener = (event) => {\n const precacheController = getOrCreatePrecacheController();\n const plugins = precachePlugins.get();\n\n event.waitUntil(precacheController.activate({event, plugins}));\n};\n\n/**\n * Adds items to the precache list, removing any duplicates and\n * stores the files in the\n * [\"precache cache\"]{@link module:workbox-core.cacheNames} when the service\n * worker installs.\n *\n * This method can be called multiple times.\n *\n * Please note: This method **will not** serve any of the cached files for you.\n * It only precaches files. To respond to a network request you call\n * [addRoute()]{@link module:workbox-precaching.addRoute}.\n *\n * If you have a single array of files to precache, you can just call\n * [precacheAndRoute()]{@link module:workbox-precaching.precacheAndRoute}.\n *\n * @param {Array<Object|string>} entries Array of entries to precache.\n *\n * @alias workbox.precaching.precache\n */\nexport const precache = (entries) => {\n const precacheController = getOrCreatePrecacheController();\n precacheController.addToCacheList(entries);\n\n if (entries.length > 0) {\n // NOTE: these listeners will only be added once (even if the `precache()`\n // method is called multiple times) because event listeners are implemented\n // as a set, where each listener must be unique.\n addEventListener('install', installListener);\n addEventListener('activate', activateListener);\n }\n};\n","/*\n Copyright 2019 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {addRoute} from './addRoute.mjs';\nimport {precache} from './precache.mjs';\nimport './_version.mjs';\n\n\n/**\n * This method will add entries to the precache list and add a route to\n * respond to fetch events.\n *\n * This is a convenience method that will call\n * [precache()]{@link module:workbox-precaching.precache} and\n * [addRoute()]{@link module:workbox-precaching.addRoute} in a single call.\n *\n * @param {Array<Object|string>} entries Array of entries to precache.\n * @param {Object} options See\n * [addRoute() options]{@link module:workbox-precaching.addRoute}.\n *\n * @alias workbox.precaching.precacheAndRoute\n */\nexport const precacheAndRoute = (entries, options) => {\n precache(entries);\n addRoute(options);\n};\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {assert} from 'workbox-core/_private/assert.mjs';\nimport {addPlugins} from './addPlugins.mjs';\nimport {addRoute} from './addRoute.mjs';\nimport {cleanupOutdatedCaches} from './cleanupOutdatedCaches.mjs';\nimport {getCacheKeyForURL} from './getCacheKeyForURL.mjs';\nimport {precache} from './precache.mjs';\nimport {precacheAndRoute} from './precacheAndRoute.mjs';\nimport {PrecacheController} from './PrecacheController.mjs';\nimport './_version.mjs';\n\n\nif (process.env.NODE_ENV !== 'production') {\n assert.isSWEnv('workbox-precaching');\n}\n\n/**\n * Most consumers of this module will want to use the\n * [precacheAndRoute()]{@link workbox.precaching.precacheAndRoute}\n * method to add assets to the Cache and respond to network requests with these\n * cached assets.\n *\n * If you require finer grained control, you can use the\n * [PrecacheController]{@link workbox.precaching.PrecacheController}\n * to determine when performed.\n *\n * @namespace workbox.precaching\n */\n\nexport {\n addPlugins,\n addRoute,\n cleanupOutdatedCaches,\n getCacheKeyForURL,\n precache,\n precacheAndRoute,\n PrecacheController,\n};\n"],"names":["self","_","e","plugins","precachePlugins","get","add","newPlugins","push","addPlugins","cleanRedirect","response","clonedResponse","clone","bodyPromise","Promise","resolve","body","blob","Response","headers","status","statusText","REVISION_SEARCH_PARAM","createCacheKey","entry","WorkboxError","urlObject","URL","location","cacheKey","href","url","revision","originalURL","cacheKeyURL","searchParams","set","logGroup","groupTitle","deletedURLs","logger","groupCollapsed","log","groupEnd","printCleanupDetails","deletionCount","length","_nestedGroup","urls","printInstallDetails","urlsToPrecache","urlsAlreadyPrecached","precachedCount","alreadyPrecachedCount","message","PrecacheController","constructor","cacheName","_cacheName","cacheNames","getPrecacheName","_urlsToCacheKeys","Map","addToCacheList","entries","assert","isArray","moduleName","className","funcName","paramName","has","firstEntry","secondEntry","install","event","cache","caches","open","alreadyCachedRequests","keys","alreadyCachedURLs","Set","map","request","values","precacheRequests","_addURLToCache","all","updatedURLs","notUpdatedURLs","activate","currentlyCachedRequests","expectedCacheKeys","delete","Request","credentials","fetchWrapper","fetch","cacheWillUpdateCallback","plugin","cacheWillUpdate","bind","isValidResponse","redirected","cacheWrapper","put","matchOptions","ignoreSearch","getURLsToCacheKeys","getCachedURLs","getCacheKeyForURL","precacheController","getOrCreatePrecacheController","removeIgnoredSearchParams","ignoreURLParametersMatching","some","regExp","test","generateURLVariations","directoryIndex","cleanURLs","urlManipulation","hash","urlWithoutIgnoredParams","pathname","endsWith","directoryURL","cleanURL","additionalURLs","urlToAttempt","options","urlsToCacheKeys","possibleURL","possibleCacheKey","addFetchListener","addEventListener","precachedURL","debug","getFriendlyURL","responsePromise","then","match","cachedResponse","warn","respondWith","listenerAdded","addRoute","SUBSTRING_TO_FIND","deleteOutdatedCaches","currentPrecacheName","substringToFind","cacheNamesToDelete","filter","includes","registration","scope","cleanupOutdatedCaches","waitUntil","cachesDeleted","installListener","catch","error","activateListener","precache","precacheAndRoute","isSWEnv"],"mappings":"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"}
|
