| 1 |
- {"version":3,"file":"workbox-precaching.dev.js","sources":["../_version.js","../utils/precachePlugins.js","../addPlugins.js","../utils/createCacheKey.js","../utils/printCleanupDetails.js","../utils/printInstallDetails.js","../PrecacheController.js","../utils/getOrCreatePrecacheController.js","../utils/removeIgnoredSearchParams.js","../utils/generateURLVariations.js","../utils/getCacheKeyForURL.js","../utils/addFetchListener.js","../addRoute.js","../utils/deleteOutdatedCaches.js","../cleanupOutdatedCaches.js","../createHandler.js","../createHandlerBoundToURL.js","../getCacheKeyForURL.js","../matchPrecache.js","../precache.js","../precacheAndRoute.js"],"sourcesContent":["\"use strict\";\n// @ts-ignore\ntry {\n self['workbox:precaching:5.1.4'] && _();\n}\ncatch (e) { }\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*/\nimport '../_version.js';\nconst plugins = [];\nexport const precachePlugins = {\n /*\n * @return {Array}\n * @private\n */\n get() {\n return plugins;\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*/\nimport { precachePlugins } from './utils/precachePlugins.js';\nimport './_version.js';\n/**\n * Adds plugins to precaching.\n *\n * @param {Array<Object>} newPlugins\n *\n * @memberof module:workbox-precaching\n */\nfunction addPlugins(newPlugins) {\n precachePlugins.add(newPlugins);\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*/\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport '../_version.js';\n// Name of the search parameter used to store revision info.\nconst REVISION_SEARCH_PARAM = '__WB_REVISION__';\n/**\n * Converts a manifest entry into a versioned URL suitable for precaching.\n *\n * @param {Object|string} 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 // 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.href);\n return {\n cacheKey: urlObject.href,\n url: urlObject.href,\n };\n }\n const { revision, url } = entry;\n if (!url) {\n throw new WorkboxError('add-to-cache-list-unexpected-type', { entry });\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.href);\n return {\n cacheKey: urlObject.href,\n url: urlObject.href,\n };\n }\n // Otherwise, construct a properly versioned URL using the custom Workbox\n // search parameter along with the revision info.\n const cacheKeyURL = new URL(url, location.href);\n const originalURL = new URL(url, location.href);\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*/\nimport { logger } from 'workbox-core/_private/logger.js';\nimport '../_version.js';\n/**\n * @param {string} groupTitle\n * @param {Array<string>} deletedURLs\n *\n * @private\n */\nconst logGroup = (groupTitle, deletedURLs) => {\n logger.groupCollapsed(groupTitle);\n for (const url of deletedURLs) {\n logger.log(url);\n }\n logger.groupEnd();\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*/\nimport { logger } from 'workbox-core/_private/logger.js';\nimport '../_version.js';\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 logger.groupCollapsed(groupTitle);\n for (const url of urls) {\n logger.log(url);\n }\n logger.groupEnd();\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 if (precachedCount || alreadyPrecachedCount) {\n let message = `Precaching ${precachedCount} file${precachedCount === 1 ? '' : 's'}.`;\n if (alreadyPrecachedCount > 0) {\n message += ` ${alreadyPrecachedCount} ` +\n `file${alreadyPrecachedCount === 1 ? ' is' : 's are'} already cached.`;\n }\n logger.groupCollapsed(message);\n _nestedGroup(`View newly precached URLs.`, urlsToPrecache);\n _nestedGroup(`View previously precached URLs.`, urlsAlreadyPrecached);\n logger.groupEnd();\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*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { cacheNames } from 'workbox-core/_private/cacheNames.js';\nimport { cacheWrapper } from 'workbox-core/_private/cacheWrapper.js';\nimport { fetchWrapper } from 'workbox-core/_private/fetchWrapper.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { copyResponse } from 'workbox-core/copyResponse.js';\nimport { createCacheKey } from './utils/createCacheKey.js';\nimport { printCleanupDetails } from './utils/printCleanupDetails.js';\nimport { printInstallDetails } from './utils/printInstallDetails.js';\nimport './_version.js';\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 this._urlsToCacheModes = new Map();\n this._cacheKeysToIntegrities = new Map();\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 const urlsToWarnAbout = [];\n for (const entry of entries) {\n // See https://github.com/GoogleChrome/workbox/issues/2259\n if (typeof entry === 'string') {\n urlsToWarnAbout.push(entry);\n }\n else if (entry && entry.revision === undefined) {\n urlsToWarnAbout.push(entry.url);\n }\n const { cacheKey, url } = createCacheKey(entry);\n const cacheMode = (typeof entry !== 'string' && entry.revision) ?\n 'reload' : 'default';\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 if (typeof entry !== 'string' && entry.integrity) {\n if (this._cacheKeysToIntegrities.has(cacheKey) &&\n this._cacheKeysToIntegrities.get(cacheKey) !== entry.integrity) {\n throw new WorkboxError('add-to-cache-list-conflicting-integrities', {\n url,\n });\n }\n this._cacheKeysToIntegrities.set(cacheKey, entry.integrity);\n }\n this._urlsToCacheKeys.set(url, cacheKey);\n this._urlsToCacheModes.set(url, cacheMode);\n if (urlsToWarnAbout.length > 0) {\n const warningMessage = `Workbox is precaching URLs without revision ` +\n `info: ${urlsToWarnAbout.join(', ')}\\nThis is generally NOT safe. ` +\n `Learn more at https://bit.ly/wb-precache`;\n if (process.env.NODE_ENV === 'production') {\n // Use console directly to display this warning without bloating\n // bundle sizes by pulling in all of the logger codebase in prod.\n console.warn(warningMessage);\n }\n else {\n logger.warn(warningMessage);\n }\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<module: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 const toBePrecached = [];\n const alreadyPrecached = [];\n const cache = await self.caches.open(this._cacheName);\n const alreadyCachedRequests = await cache.keys();\n const existingCacheKeys = new Set(alreadyCachedRequests.map((request) => request.url));\n for (const [url, cacheKey] of this._urlsToCacheKeys) {\n if (existingCacheKeys.has(cacheKey)) {\n alreadyPrecached.push(url);\n }\n else {\n toBePrecached.push({ cacheKey, url });\n }\n }\n const precacheRequests = toBePrecached.map(({ cacheKey, url }) => {\n const integrity = this._cacheKeysToIntegrities.get(cacheKey);\n const cacheMode = this._urlsToCacheModes.get(url);\n return this._addURLToCache({\n cacheKey,\n cacheMode,\n event,\n integrity,\n plugins,\n url,\n });\n });\n await Promise.all(precacheRequests);\n const updatedURLs = toBePrecached.map((item) => item.url);\n if (process.env.NODE_ENV !== 'production') {\n printInstallDetails(updatedURLs, alreadyPrecached);\n }\n return {\n updatedURLs,\n notUpdatedURLs: alreadyPrecached,\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<module:workbox-precaching.CleanupResult>}\n */\n async activate() {\n const cache = await self.caches.open(this._cacheName);\n const currentlyCachedRequests = await cache.keys();\n const expectedCacheKeys = new Set(this._urlsToCacheKeys.values());\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 if (process.env.NODE_ENV !== 'production') {\n printCleanupDetails(deletedURLs);\n }\n return { deletedURLs };\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.cacheKey The string to use a cache key.\n * @param {string} options.url The URL to fetch and cache.\n * @param {string} [options.cacheMode] The cache mode for the network request.\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 * @param {string} [options.integrity] The value to use for the `integrity`\n * field when making the request.\n */\n async _addURLToCache({ cacheKey, url, cacheMode, event, plugins, integrity }) {\n const request = new Request(url, {\n integrity,\n cache: cacheMode,\n credentials: 'same-origin',\n });\n let response = await fetchWrapper.fetch({\n event,\n plugins,\n request,\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 `CacheableResponsePlugin` instance.\n let cacheWillUpdatePlugin;\n for (const plugin of (plugins || [])) {\n if ('cacheWillUpdate' in plugin) {\n cacheWillUpdatePlugin = plugin;\n }\n }\n const isValidResponse = cacheWillUpdatePlugin ?\n // Use a callback if provided. It returns a truthy value if valid.\n // NOTE: invoke the method on the plugin instance so the `this` context\n // is correct.\n await cacheWillUpdatePlugin.cacheWillUpdate({ 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 // 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 // Redirected responses cannot be used to satisfy a navigation request, so\n // any redirected response must be \"copied\" rather than cloned, so the new\n // response doesn't contain the `redirected` flag. See:\n // https://bugs.chromium.org/p/chromium/issues/detail?id=669363&desc=2#c1\n if (response.redirected) {\n response = await copyResponse(response);\n }\n await cacheWrapper.put({\n event,\n plugins,\n response,\n // `request` already uses `url`. We may be able to reuse it.\n request: cacheKey === url ? request : new Request(cacheKey),\n cacheName: this._cacheName,\n matchOptions: {\n ignoreSearch: true,\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 * 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 * 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.href);\n return this._urlsToCacheKeys.get(urlObject.href);\n }\n /**\n * This acts as a drop-in replacement for [`cache.match()`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/match)\n * with the following differences:\n *\n * - It knows what the name of the precache is, and only checks in that cache.\n * - It allows you to pass in an \"original\" URL without versioning parameters,\n * and it will automatically look up the correct cache key for the currently\n * active revision of that URL.\n *\n * E.g., `matchPrecache('index.html')` will find the correct precached\n * response for the currently active service worker, even if the actual cache\n * key is `'/index.html?__WB_REVISION__=1234abcd'`.\n *\n * @param {string|Request} request The key (without revisioning parameters)\n * to look up in the precache.\n * @return {Promise<Response|undefined>}\n */\n async matchPrecache(request) {\n const url = request instanceof Request ? request.url : request;\n const cacheKey = this.getCacheKeyForURL(url);\n if (cacheKey) {\n const cache = await self.caches.open(this._cacheName);\n return cache.match(cacheKey);\n }\n return undefined;\n }\n /**\n * Returns a function that can be used within a\n * {@link module:workbox-routing.Route} that will find a response for the\n * incoming request against the precache.\n *\n * If for an unexpected reason there is a cache miss for the request,\n * this will fall back to retrieving the `Response` via `fetch()` when\n * `fallbackToNetwork` is `true`.\n *\n * @param {boolean} [fallbackToNetwork=true] Whether to attempt to get the\n * response from the network if there's a precache miss.\n * @return {module:workbox-routing~handlerCallback}\n */\n createHandler(fallbackToNetwork = true) {\n return async ({ request }) => {\n try {\n const response = await this.matchPrecache(request);\n if (response) {\n return response;\n }\n // This shouldn't normally happen, but there are edge cases:\n // https://github.com/GoogleChrome/workbox/issues/1441\n throw new WorkboxError('missing-precache-entry', {\n cacheName: this._cacheName,\n url: request instanceof Request ? request.url : request,\n });\n }\n catch (error) {\n if (fallbackToNetwork) {\n if (process.env.NODE_ENV !== 'production') {\n logger.debug(`Unable to respond with precached response. ` +\n `Falling back to network.`, error);\n }\n return fetch(request);\n }\n throw error;\n }\n };\n }\n /**\n * Returns a function that looks up `url` in the precache (taking into\n * account revision information), and returns the corresponding `Response`.\n *\n * If for an unexpected reason there is a cache miss when looking up `url`,\n * this will fall back to retrieving the `Response` via `fetch()` when\n * `fallbackToNetwork` is `true`.\n *\n * @param {string} url The precached URL which will be used to lookup the\n * `Response`.\n * @param {boolean} [fallbackToNetwork=true] Whether to attempt to get the\n * response from the network if there's a precache miss.\n * @return {module:workbox-routing~handlerCallback}\n */\n createHandlerBoundToURL(url, fallbackToNetwork = true) {\n const cacheKey = this.getCacheKeyForURL(url);\n if (!cacheKey) {\n throw new WorkboxError('non-precached-url', { url });\n }\n const handler = this.createHandler(fallbackToNetwork);\n const request = new Request(url);\n return () => handler({ request });\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*/\nimport { PrecacheController } from '../PrecacheController.js';\nimport '../_version.js';\nlet precacheController;\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*/\nimport '../_version.js';\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, 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 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*/\nimport { removeIgnoredSearchParams } from './removeIgnoredSearchParams.js';\nimport '../_version.js';\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, { ignoreURLParametersMatching, directoryIndex, cleanURLs, urlManipulation, } = {}) {\n const urlObject = new URL(url, location.href);\n urlObject.hash = '';\n yield urlObject.href;\n const urlWithoutIgnoredParams = removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching);\n yield urlWithoutIgnoredParams.href;\n if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith('/')) {\n const directoryURL = new URL(urlWithoutIgnoredParams.href);\n directoryURL.pathname += directoryIndex;\n yield directoryURL.href;\n }\n if (cleanURLs) {\n const cleanURL = new URL(urlWithoutIgnoredParams.href);\n cleanURL.pathname += '.html';\n yield cleanURL.href;\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*/\nimport { getOrCreatePrecacheController } from './getOrCreatePrecacheController.js';\nimport { generateURLVariations } from './generateURLVariations.js';\nimport '../_version.js';\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 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*/\nimport { cacheNames } from 'workbox-core/_private/cacheNames.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { getCacheKeyForURL } from './getCacheKeyForURL.js';\nimport '../_version.js';\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 URLs that should be checked for precache matches.\n */\nexport const addFetchListener = ({ ignoreURLParametersMatching = [/^utm_/], directoryIndex = 'index.html', cleanURLs = true, urlManipulation, } = {}) => {\n const cacheName = cacheNames.getPrecacheName();\n // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705\n self.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 let responsePromise = self.caches.open(cacheName).then((cache) => {\n return cache.match(precachedURL);\n }).then((cachedResponse) => {\n if (cachedResponse) {\n return cachedResponse;\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 return fetch(precachedURL);\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 logger.groupCollapsed(`View request details here.`);\n logger.log(event.request);\n logger.groupEnd();\n logger.groupCollapsed(`View response details here.`);\n logger.log(response);\n logger.groupEnd();\n logger.groupEnd();\n return response;\n });\n }\n event.respondWith(responsePromise);\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*/\nimport { addFetchListener } from './utils/addFetchListener.js';\nimport './_version.js';\nlet listenerAdded = false;\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 {module:workbox-precaching~urlManipulation} [options.urlManipulation]\n * This is a function that should take a URL and return an array of\n * alternative URLs that should be checked for precache matches.\n *\n * @memberof module:workbox-precaching\n */\nfunction addRoute(options) {\n if (!listenerAdded) {\n addFetchListener(options);\n listenerAdded = true;\n }\n}\nexport { addRoute };\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*/\nimport '../_version.js';\nconst SUBSTRING_TO_FIND = '-precache-';\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 (currentPrecacheName, substringToFind = SUBSTRING_TO_FIND) => {\n const cacheNames = await self.caches.keys();\n const cacheNamesToDelete = cacheNames.filter((cacheName) => {\n return cacheName.includes(substringToFind) &&\n cacheName.includes(self.registration.scope) &&\n cacheName !== currentPrecacheName;\n });\n await Promise.all(cacheNamesToDelete.map((cacheName) => self.caches.delete(cacheName)));\n return cacheNamesToDelete;\n};\nexport { deleteOutdatedCaches };\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*/\nimport { cacheNames } from 'workbox-core/_private/cacheNames.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { deleteOutdatedCaches } from './utils/deleteOutdatedCaches.js';\nimport './_version.js';\n/**\n * Adds an `activate` event listener which will clean up incompatible\n * precaches that were created by older versions of Workbox.\n *\n * @memberof module:workbox-precaching\n */\nfunction cleanupOutdatedCaches() {\n // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705\n self.addEventListener('activate', ((event) => {\n const cacheName = cacheNames.getPrecacheName();\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}\nexport { cleanupOutdatedCaches };\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*/\nimport { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';\nimport './_version.js';\n/**\n * Helper function that calls\n * {@link PrecacheController#createHandler} on the default\n * {@link PrecacheController} instance.\n *\n * If you are creating your own {@link PrecacheController}, then call the\n * {@link PrecacheController#createHandler} on that instance,\n * instead of using this function.\n *\n * @param {boolean} [fallbackToNetwork=true] Whether to attempt to get the\n * response from the network if there's a precache miss.\n * @return {module:workbox-routing~handlerCallback}\n *\n * @memberof module:workbox-precaching\n */\nfunction createHandler(fallbackToNetwork = true) {\n const precacheController = getOrCreatePrecacheController();\n return precacheController.createHandler(fallbackToNetwork);\n}\nexport { createHandler };\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*/\nimport { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';\nimport './_version.js';\n/**\n * Helper function that calls\n * {@link PrecacheController#createHandlerBoundToURL} on the default\n * {@link PrecacheController} instance.\n *\n * If you are creating your own {@link PrecacheController}, then call the\n * {@link PrecacheController#createHandlerBoundToURL} on that instance,\n * instead of using this function.\n *\n * @param {string} url The precached URL which will be used to lookup the\n * `Response`.\n * @param {boolean} [fallbackToNetwork=true] Whether to attempt to get the\n * response from the network if there's a precache miss.\n * @return {module:workbox-routing~handlerCallback}\n *\n * @memberof module:workbox-precaching\n */\nfunction createHandlerBoundToURL(url) {\n const precacheController = getOrCreatePrecacheController();\n return precacheController.createHandlerBoundToURL(url);\n}\nexport { createHandlerBoundToURL };\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*/\nimport { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';\nimport './_version.js';\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 * @memberof module:workbox-precaching\n */\nfunction getCacheKeyForURL(url) {\n const precacheController = getOrCreatePrecacheController();\n return precacheController.getCacheKeyForURL(url);\n}\nexport { getCacheKeyForURL };\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*/\nimport { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';\nimport './_version.js';\n/**\n * Helper function that calls\n * {@link PrecacheController#matchPrecache} on the default\n * {@link PrecacheController} instance.\n *\n * If you are creating your own {@link PrecacheController}, then call\n * {@link PrecacheController#matchPrecache} on that instance,\n * instead of using this function.\n *\n * @param {string|Request} request The key (without revisioning parameters)\n * to look up in the precache.\n * @return {Promise<Response|undefined>}\n *\n * @memberof module:workbox-precaching\n */\nfunction matchPrecache(request) {\n const precacheController = getOrCreatePrecacheController();\n return precacheController.matchPrecache(request);\n}\nexport { matchPrecache };\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*/\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';\nimport { precachePlugins } from './utils/precachePlugins.js';\nimport './_version.js';\nconst installListener = (event) => {\n const precacheController = getOrCreatePrecacheController();\n const plugins = precachePlugins.get();\n event.waitUntil(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};\nconst activateListener = (event) => {\n const precacheController = getOrCreatePrecacheController();\n event.waitUntil(precacheController.activate());\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 * @memberof module:workbox-precaching\n */\nfunction precache(entries) {\n const precacheController = getOrCreatePrecacheController();\n precacheController.addToCacheList(entries);\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 // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705\n self.addEventListener('install', installListener);\n self.addEventListener('activate', activateListener);\n }\n}\nexport { precache };\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*/\nimport { addRoute } from './addRoute.js';\nimport { precache } from './precache.js';\nimport './_version.js';\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 * @memberof module:workbox-precaching\n */\nfunction precacheAndRoute(entries, options) {\n precache(entries);\n addRoute(options);\n}\nexport { precacheAndRoute };\n"],"names":["self","_","e","plugins","precachePlugins","get","add","newPlugins","push","addPlugins","REVISION_SEARCH_PARAM","createCacheKey","entry","WorkboxError","urlObject","URL","location","href","cacheKey","url","revision","cacheKeyURL","originalURL","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","_urlsToCacheModes","_cacheKeysToIntegrities","addToCacheList","entries","assert","isArray","moduleName","className","funcName","paramName","urlsToWarnAbout","undefined","cacheMode","has","firstEntry","secondEntry","integrity","warningMessage","join","warn","install","event","toBePrecached","alreadyPrecached","cache","caches","open","alreadyCachedRequests","keys","existingCacheKeys","Set","map","request","precacheRequests","_addURLToCache","Promise","all","updatedURLs","item","notUpdatedURLs","activate","currentlyCachedRequests","expectedCacheKeys","values","delete","Request","credentials","response","fetchWrapper","fetch","cacheWillUpdatePlugin","plugin","isValidResponse","cacheWillUpdate","status","redirected","copyResponse","cacheWrapper","put","matchOptions","ignoreSearch","getURLsToCacheKeys","getCachedURLs","getCacheKeyForURL","matchPrecache","match","createHandler","fallbackToNetwork","error","debug","createHandlerBoundToURL","handler","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","getFriendlyURL","responsePromise","then","cachedResponse","respondWith","listenerAdded","addRoute","SUBSTRING_TO_FIND","deleteOutdatedCaches","currentPrecacheName","substringToFind","cacheNamesToDelete","filter","includes","registration","scope","cleanupOutdatedCaches","waitUntil","cachesDeleted","installListener","catch","activateListener","precache","precacheAndRoute"],"mappings":"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"}
|
