{“version”:3,“file”:“workbox-precaching.prod.js”,“sources”:,“sourcesContent”:[“"use strict";n// @ts-ignorentry {n self && _();n}ncatch (e) { }n”,“/*n Copyright 2019 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport '../_version.js';nconst plugins = [];nexport const precachePlugins = {n /*n * @return {Array}n * @privaten */n get() {n return plugins;n },n /*n * @param {Array} newPluginsn * @privaten */n add(newPlugins) {n plugins.push(…newPlugins);n },n};n”,“/*n Copyright 2018 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn 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} entryn * @return {string} A URL with versioning info.n *n * @privaten * @memberof module:workbox-precachingn */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 versionedn // 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 an // 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 Workboxn // 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 2019 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn 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-precachingn */nclass PrecacheController {n /**n * Create a new PrecacheController.n *n * @param {string} [cacheName] An optional name for the cache, to overriden * 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 duplicatesn * 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 github.com/GoogleChrome/workbox/issues/2259n 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 bit.ly/wb-precache`;n if (process.env.NODE_ENV === 'production') {n // Use console directly to display this warning without bloatingn // 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 workern * install event.n *n * @param {Object} optionsn * @param {Event} [options.event] The install event (if needed).n * @param {Array<Object>} [options.plugins] Plugins to be used for fetchingn * 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 (includingn * opaque responses) is considered valid.n *n * If you need to use custom criteria to determine what's valid and whatn * isn't, then pass in an item in `options.plugins` that implements then * `cacheWillUpdate()` lifecycle event.n *n * @privaten * @param {Object} optionsn * @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 ton * 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'tn // 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` contextn // 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, ifn // 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, son // any redirected response must be "copied" rather than cloned, so the newn // response doesn't contain the `redirected` flag. See:n // bugs.chromium.org/p/chromium/issues/detail?id=669363&desc=2#c1n 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, takingn * 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 currentn * 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 isn * unversioned, like `/index.html', then the cache key will be the originaln * 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 keyn * 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()`](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 currentlyn * active revision of that URL.n *n * E.g., `matchPrecache('index.html')` will find the correct precachedn * response for the currently active service worker, even if the actual cachen * 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 an * {@link module:workbox-routing.Route} that will find a response for then * 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()` whenn * `fallbackToNetwork` is `true`.n *n * @param {boolean} [fallbackToNetwork=true] Whether to attempt to get then * 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 // github.com/GoogleChrome/workbox/issues/1441n 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 inton * 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()` whenn * `fallbackToNetwork` is `true`.n *n * @param {string} url The precached URL which will be used to lookup then * `Response`.n * @param {boolean} [fallbackToNetwork=true] Whether to attempt to get then * 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 LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport { PrecacheController } from '../PrecacheController.js';nimport '../_version.js';nlet precacheController;n/**n * @return {PrecacheController}n * @privaten */nexport const getOrCreatePrecacheController = () => {n if (!precacheController) {n precacheController = new PrecacheController();n }n return precacheController;n};n”,“/*n Copyright 2019 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn 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 then * configuration options.n *n * @param {string} urln * @param {Object} optionsn * @return {string} Returns the URL in the cache that matches the request,n * if possible.n *n * @privaten */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 LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn 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 ton * check, one at a time.n *n * @param {string} urln * @param {Object} optionsn *n * @privaten * @memberof module:workbox-precachingn */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 2018 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn 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 againstn * each search parameter name. Matches mean that the search parameter should ben * ignored.n * @return {URL} The URL with any ignored search parameters removed.n *n * @privaten * @memberof module:workbox-precachingn */nexport function removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching = []) {n // Convert the iterable into an array at the start of the loop to make suren // 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 LLCn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn 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 willn * respond ton * [network requests]{@link 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 ben * responded to, allowing the event to fall through to other `fetch` eventn * listeners.n *n * @param {Object} [options]n * @param {string} [options.directoryIndex=index.html] The `directoryIndex` willn * check cache entries for a URLs ending with '/' to see if there is a hit whenn * appending the `directoryIndex` value.n * @param {Array<RegExp>} [options.ignoreURLParametersMatching=] Ann * array of regex's to remove search params when looking for a cache match.n * @param {boolean} [options.cleanURLs=true] The `cleanURLs` option willn * 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 ofn * alternative URLs that should be checked for precache matches.n *n * @memberof module:workbox-precachingn */nfunction addRoute(options) {n if (!listenerAdded) {n addFetchListener(options);n listenerAdded = true;n }n}nexport { addRoute };n”,“/*n Copyright 2019 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn 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 willn * respond ton * [network requests]{@link 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 ben * responded to, allowing the event to fall through to other `fetch` eventn * listeners.n *n * NOTE: when called more than once this method will replace the previously setn * configuration options. Calling it more than once is not recommended outsiden * of tests.n *n * @privaten * @param {Object} [options]n * @param {string} [options.directoryIndex=index.html] The `directoryIndex` willn * check cache entries for a URLs ending with '/' to see if there is a hit whenn * appending the `directoryIndex` value.n * @param {Array<RegExp>} [options.ignoreURLParametersMatching=] Ann * array of regex's to remove search params when looking for a cache match.n * @param {boolean} [options.cleanURLs=true] The `cleanURLs` option willn * 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 ofn * 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 github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705n 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 responsen // (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 LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn 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 andn * stores the files in then * ["precache cache"]{@link module:workbox-core.cacheNames} when the servicen * 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 calln * [addRoute()]{@link module:workbox-precaching.addRoute}.n *n * If you have a single array of files to precache, you can just calln * [precacheAndRoute()]{@link module:workbox-precaching.precacheAndRoute}.n *n * @param {Array<Object|string>} [entries= Array of entries to precache.n *n * @memberof module:workbox-precachingn */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 implementedn // as a set, where each listener must be unique.n // See github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705n self.addEventListener('install', installListener);n self.addEventListener('activate', activateListener);n }n}nexport { precache };n”,“/*n Copyright 2019 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn 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>} newPluginsn *n * @memberof module:workbox-precachingn */nfunction addPlugins(newPlugins) {n precachePlugins.add(newPlugins);n}nexport { addPlugins };n”,“/*n Copyright 2019 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn 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 incompatiblen * precaches that were created by older versions of Workbox.n *n * @memberof module:workbox-precachingn */nfunction cleanupOutdatedCaches() {n // See github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705n 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 2018 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn 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 ofn * 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 forn * precaching. This cache won't be deleted.n * @param {string} [substringToFind='-precache-'] Cache names which include thisn * substring will be deleted (excluding `currentPrecacheName`).n * @return {Array<string>} A list of all the cache names that were deleted.n *n * @privaten * @memberof module:workbox-precachingn */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 LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';nimport './_version.js';n/**n * Helper function that callsn * {@link PrecacheController#createHandler} on the defaultn * {@link PrecacheController} instance.n *n * If you are creating your own {@link PrecacheController}, then call then * {@link PrecacheController#createHandler} on that instance,n * instead of using this function.n *n * @param {boolean} [fallbackToNetwork=true] Whether to attempt to get then * response from the network if there's a precache miss.n * @return {module:workbox-routing~handlerCallback}n *n * @memberof module:workbox-precachingn */nfunction createHandler(fallbackToNetwork = true) {n const precacheController = getOrCreatePrecacheController();n return precacheController.createHandler(fallbackToNetwork);n}nexport { createHandler };n”,“/*n Copyright 2019 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';nimport './_version.js';n/**n * Helper function that callsn * {@link PrecacheController#createHandlerBoundToURL} on the defaultn * {@link PrecacheController} instance.n *n * If you are creating your own {@link PrecacheController}, then call then * {@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 then * `Response`.n * @param {boolean} [fallbackToNetwork=true] Whether to attempt to get then * response from the network if there's a precache miss.n * @return {module:workbox-routing~handlerCallback}n *n * @memberof module:workbox-precachingn */nfunction createHandlerBoundToURL(url) {n const precacheController = getOrCreatePrecacheController();n return precacheController.createHandlerBoundToURL(url);n}nexport { createHandlerBoundToURL };n”,“/*n Copyright 2019 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn 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 ton * lookup the entry in the precache.n *n * If a relative URL is provided, the location of the service worker file willn * be used as the base.n *n * For precached entries without revision information, the cache key will be then * same as the original URL.n *n * For precached entries with revision information, the cache key will be then * original URL with the addition of a query parameter used for keeping track ofn * 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-precachingn */nfunction getCacheKeyForURL(url) {n const precacheController = getOrCreatePrecacheController();n return precacheController.getCacheKeyForURL(url);n}nexport { getCacheKeyForURL };n”,“/*n Copyright 2019 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn opensource.org/licenses/MIT.n*/nimport { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';nimport './_version.js';n/**n * Helper function that callsn * {@link PrecacheController#matchPrecache} on the defaultn * {@link PrecacheController} instance.n *n * If you are creating your own {@link PrecacheController}, then calln * {@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-precachingn */nfunction matchPrecache(request) {n const precacheController = getOrCreatePrecacheController();n return precacheController.matchPrecache(request);n}nexport { matchPrecache };n”,“/*n Copyright 2019 Google LLCnn Use of this source code is governed by an MIT-stylen license that can be found in the LICENSE file or atn 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 ton * respond to fetch events.n *n * This is a convenience method that will calln * [precache()]{@link module:workbox-precaching.precache} andn * [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] Seen * [addRoute() options]{@link module:workbox-precaching.addRoute}.n *n * @memberof module:workbox-precachingn */nfunction precacheAndRoute(entries, options) {n precache(entries);n addRoute(options);n}nexport { precacheAndRoute };n”],“names”:,“mappings”:“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”}