{“version”:3,“file”:“workbox-strategies.prod.js”,“sources”:,“sourcesContent”:[“"use strict";n// @ts-ignorentry {n self && _();n}ncatch (e) { }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';nexport const cacheOkAndOpaquePlugin = {n /**n * Returns a valid response (to allow caching) if the status is 200 (OK) orn * 0 (opaque).n *n * @param {Object} optionsn * @param {Response} options.responsen * @return {Response|null}n *n * @privaten */n cacheWillUpdate: async ({ response }) => {n if (response.status === 200 || response.status === 0) {n return response;n }n return null;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 { 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 { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';nimport { logger } from 'workbox-core/_private/logger.js';nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';nimport { messages } from './utils/messages.js';nimport './_version.js';n/**n * An implementation of a [cache-first]{@link developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#cache-falling-back-to-network}n * request strategy.n *n * A cache first strategy is useful for assets that have been revisioned,n * such as URLs like `/styles/example.a8f5f1.css`, since theyn * can be cached for long periods of time.n *n * If the network request fails, and there is no cache match, this will thrown * a `WorkboxError` exception.n *n * @memberof module:workbox-strategiesn */nclass CacheFirst {n /**n * @param {Object} optionsn * @param {string} options.cacheName Cache name to store and retrieven * requests. Defaults to cache names provided byn * [workbox-core]{@link module:workbox-core.cacheNames}.n * @param {Array<Object>} options.plugins [Plugins]{@link developers.google.com/web/tools/workbox/guides/using-plugins}n * to use in conjunction with this caching strategy.n * @param {Object} options.fetchOptions Values passed along to then * [`init`](developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)n * of all fetch() requests made by this strategy.n * @param {Object} options.matchOptions [`CacheQueryOptions`](w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)n */n constructor(options = {}) {n this._cacheName = cacheNames.getRuntimeName(options.cacheName);n this._plugins = options.plugins || [];n this._fetchOptions = options.fetchOptions;n this._matchOptions = options.matchOptions;n }n /**n * This method will perform a request strategy and follows an API thatn * will work with then * [Workbox Router]{@link module:workbox-routing.Router}.n *n * @param {Object} optionsn * @param {Request|string} options.request A request to run this strategy for.n * @param {Event} [options.event] The event that triggered the request.n * @return {Promise<Response>}n */n async handle({ event, request }) {n const logs = [];n if (typeof request === 'string') {n request = new Request(request);n }n if (process.env.NODE_ENV !== 'production') {n assert.isInstance(request, Request, {n moduleName: 'workbox-strategies',n className: 'CacheFirst',n funcName: 'makeRequest',n paramName: 'request',n });n }n let response = await cacheWrapper.match({n cacheName: this._cacheName,n request,n event,n matchOptions: this._matchOptions,n plugins: this._plugins,n });n let error;n if (!response) {n if (process.env.NODE_ENV !== 'production') {n logs.push(`No response found in the '${this._cacheName}' cache. ` +n `Will respond with a network request.`);n }n try {n response = await this._getFromNetwork(request, event);n }n catch (err) {n error = err;n }n if (process.env.NODE_ENV !== 'production') {n if (response) {n logs.push(`Got response from network.`);n }n else {n logs.push(`Unable to get a response from the network.`);n }n }n }n else {n if (process.env.NODE_ENV !== 'production') {n logs.push(`Found a cached response in the '${this._cacheName}' cache.`);n }n }n if (process.env.NODE_ENV !== 'production') {n logger.groupCollapsed(messages.strategyStart('CacheFirst', request));n for (const log of logs) {n logger.log(log);n }n messages.printFinalResponse(response);n logger.groupEnd();n }n if (!response) {n throw new WorkboxError('no-response', { url: request.url, error });n }n return response;n }n /**n * Handles the network and cache part of CacheFirst.n *n * @param {Request} requestn * @param {Event} [event]n * @return {Promise<Response>}n *n * @privaten */n async _getFromNetwork(request, event) {n const response = await fetchWrapper.fetch({n request,n event,n fetchOptions: this._fetchOptions,n plugins: this._plugins,n });n // Keep the service worker while we put the request to the cachen const responseClone = response.clone();n const cachePutPromise = cacheWrapper.put({n cacheName: this._cacheName,n request,n response: responseClone,n event,n plugins: this._plugins,n });n if (event) {n try {n event.waitUntil(cachePutPromise);n }n catch (error) {n if (process.env.NODE_ENV !== 'production') {n logger.warn(`Unable to ensure service worker stays alive when ` +n `updating cache for '${getFriendlyURL(request.url)}'.`);n }n }n }n return response;n }n}nexport { CacheFirst };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 { assert } from 'workbox-core/_private/assert.js';nimport { cacheNames } from 'workbox-core/_private/cacheNames.js';nimport { cacheWrapper } from 'workbox-core/_private/cacheWrapper.js';nimport { logger } from 'workbox-core/_private/logger.js';nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';nimport { messages } from './utils/messages.js';nimport './_version.js';n/**n * An implementation of an * [cache-only]{@link developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#cache-only}n * request strategy.n *n * This class is useful if you want to take advantage of anyn * [Workbox plugins]{@link developers.google.com/web/tools/workbox/guides/using-plugins}.n *n * If there is no cache match, this will throw a `WorkboxError` exception.n *n * @memberof module:workbox-strategiesn */nclass CacheOnly {n /**n * @param {Object} optionsn * @param {string} options.cacheName Cache name to store and retrieven * requests. Defaults to cache names provided byn * [workbox-core]{@link module:workbox-core.cacheNames}.n * @param {Array<Object>} options.plugins [Plugins]{@link developers.google.com/web/tools/workbox/guides/using-plugins}n * to use in conjunction with this caching strategy.n * @param {Object} options.matchOptions [`CacheQueryOptions`](w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)n */n constructor(options = {}) {n this._cacheName = cacheNames.getRuntimeName(options.cacheName);n this._plugins = options.plugins || [];n this._matchOptions = options.matchOptions;n }n /**n * This method will perform a request strategy and follows an API thatn * will work with then * [Workbox Router]{@link module:workbox-routing.Router}.n *n * @param {Object} optionsn * @param {Request|string} options.request A request to run this strategy for.n * @param {Event} [options.event] The event that triggered the request.n * @return {Promise<Response>}n */n async handle({ event, request }) {n if (typeof request === 'string') {n request = new Request(request);n }n if (process.env.NODE_ENV !== 'production') {n assert.isInstance(request, Request, {n moduleName: 'workbox-strategies',n className: 'CacheOnly',n funcName: 'makeRequest',n paramName: 'request',n });n }n const response = await cacheWrapper.match({n cacheName: this._cacheName,n request,n event,n matchOptions: this._matchOptions,n plugins: this._plugins,n });n if (process.env.NODE_ENV !== 'production') {n logger.groupCollapsed(messages.strategyStart('CacheOnly', request));n if (response) {n logger.log(`Found a cached response in the '${this._cacheName}'` +n ` cache.`);n messages.printFinalResponse(response);n }n else {n logger.log(`No response found in the '${this._cacheName}' cache.`);n }n logger.groupEnd();n }n if (!response) {n throw new WorkboxError('no-response', { url: request.url });n }n return response;n }n}nexport { CacheOnly };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 { 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 { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';nimport { logger } from 'workbox-core/_private/logger.js';nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';nimport { messages } from './utils/messages.js';nimport { cacheOkAndOpaquePlugin } from './plugins/cacheOkAndOpaquePlugin.js';nimport './_version.js';n/**n * An implementation of an * [network first]{@link developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#network-falling-back-to-cache}n * request strategy.n *n * By default, this strategy will cache responses with a 200 status code asn * well as [opaque responses]{@link developers.google.com/web/tools/workbox/guides/handle-third-party-requests}.n * Opaque responses are are cross-origin requests where the response doesn'tn * support [CORS]{@link enable-cors.org/}.n *n * If the network request fails, and there is no cache match, this will thrown * a `WorkboxError` exception.n *n * @memberof module:workbox-strategiesn */nclass NetworkFirst {n /**n * @param {Object} optionsn * @param {string} options.cacheName Cache name to store and retrieven * requests. Defaults to cache names provided byn * [workbox-core]{@link module:workbox-core.cacheNames}.n * @param {Array<Object>} options.plugins [Plugins]{@link developers.google.com/web/tools/workbox/guides/using-plugins}n * to use in conjunction with this caching strategy.n * @param {Object} options.fetchOptions Values passed along to then * [`init`](developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)n * of all fetch() requests made by this strategy.n * @param {Object} options.matchOptions [`CacheQueryOptions`](w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)n * @param {number} options.networkTimeoutSeconds If set, any network requestsn * that fail to respond within the timeout will fallback to the cache.n *n * This option can be used to combatn * "[lie-fi]{@link developers.google.com/web/fundamentals/performance/poor-connectivity/#lie-fi}"n * scenarios.n */n constructor(options = {}) {n this._cacheName = cacheNames.getRuntimeName(options.cacheName);n if (options.plugins) {n const isUsingCacheWillUpdate = options.plugins.some((plugin) => !!plugin.cacheWillUpdate);n this._plugins = isUsingCacheWillUpdate ?n options.plugins : [cacheOkAndOpaquePlugin, …options.plugins];n }n else {n // No plugins passed in, use the default plugin.n this._plugins = [cacheOkAndOpaquePlugin];n }n this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;n if (process.env.NODE_ENV !== 'production') {n if (this._networkTimeoutSeconds) {n assert.isType(this._networkTimeoutSeconds, 'number', {n moduleName: 'workbox-strategies',n className: 'NetworkFirst',n funcName: 'constructor',n paramName: 'networkTimeoutSeconds',n });n }n }n this._fetchOptions = options.fetchOptions;n this._matchOptions = options.matchOptions;n }n /**n * This method will perform a request strategy and follows an API thatn * will work with then * [Workbox Router]{@link module:workbox-routing.Router}.n *n * @param {Object} optionsn * @param {Request|string} options.request A request to run this strategy for.n * @param {Event} [options.event] The event that triggered the request.n * @return {Promise<Response>}n */n async handle({ event, request }) {n const logs = [];n if (typeof request === 'string') {n request = new Request(request);n }n if (process.env.NODE_ENV !== 'production') {n assert.isInstance(request, Request, {n moduleName: 'workbox-strategies',n className: 'NetworkFirst',n funcName: 'handle',n paramName: 'makeRequest',n });n }n const promises = [];n let timeoutId;n if (this._networkTimeoutSeconds) {n const { id, promise } = this._getTimeoutPromise({ request, event, logs });n timeoutId = id;n promises.push(promise);n }n const networkPromise = this._getNetworkPromise({ timeoutId, request, event, logs });n promises.push(networkPromise);n // Promise.race() will resolve as soon as the first promise resolves.n let response = await Promise.race(promises);n // If Promise.race() resolved with null, it might be due to a networkn // timeout + a cache miss. If that were to happen, we'd rather wait untiln // the networkPromise resolves instead of returning null.n // Note that it's fine to await an already-resolved promise, so we don'tn // have to check to see if it's still "in flight".n if (!response) {n response = await networkPromise;n }n if (process.env.NODE_ENV !== 'production') {n logger.groupCollapsed(messages.strategyStart('NetworkFirst', request));n for (const log of logs) {n logger.log(log);n }n messages.printFinalResponse(response);n logger.groupEnd();n }n if (!response) {n throw new WorkboxError('no-response', { url: request.url });n }n return response;n }n /**n * @param {Object} optionsn * @param {Request} options.requestn * @param {Array} options.logs A reference to the logs arrayn * @param {Event} [options.event]n * @return {Promise<Response>}n *n * @privaten */n _getTimeoutPromise({ request, logs, event }) {n let timeoutId;n const timeoutPromise = new Promise((resolve) => {n const onNetworkTimeout = async () => {n if (process.env.NODE_ENV !== 'production') {n logs.push(`Timing out the network response at ` +n `${this._networkTimeoutSeconds} seconds.`);n }n resolve(await this._respondFromCache({ request, event }));n };n timeoutId = setTimeout(onNetworkTimeout, this._networkTimeoutSeconds * 1000);n });n return {n promise: timeoutPromise,n id: timeoutId,n };n }n /**n * @param {Object} optionsn * @param {number|undefined} options.timeoutIdn * @param {Request} options.requestn * @param {Array} options.logs A reference to the logs Array.n * @param {Event} [options.event]n * @return {Promise<Response>}n *n * @privaten */n async _getNetworkPromise({ timeoutId, request, logs, event }) {n let error;n let response;n try {n response = await fetchWrapper.fetch({n request,n event,n fetchOptions: this._fetchOptions,n plugins: this._plugins,n });n }n catch (err) {n error = err;n }n if (timeoutId) {n clearTimeout(timeoutId);n }n if (process.env.NODE_ENV !== 'production') {n if (response) {n logs.push(`Got response from network.`);n }n else {n logs.push(`Unable to get a response from the network. Will respond ` +n `with a cached response.`);n }n }n if (error || !response) {n response = await this._respondFromCache({ request, event });n if (process.env.NODE_ENV !== 'production') {n if (response) {n logs.push(`Found a cached response in the '${this._cacheName}'` +n ` cache.`);n }n else {n logs.push(`No response found in the '${this._cacheName}' cache.`);n }n }n }n else {n // Keep the service worker alive while we put the request in the cachen const responseClone = response.clone();n const cachePut = cacheWrapper.put({n cacheName: this._cacheName,n request,n response: responseClone,n event,n plugins: this._plugins,n });n if (event) {n try {n // The event has been responded to so we can keep the SW alive ton // respond to the requestn event.waitUntil(cachePut);n }n catch (err) {n if (process.env.NODE_ENV !== 'production') {n logger.warn(`Unable to ensure service worker stays alive when ` +n `updating cache for '${getFriendlyURL(request.url)}'.`);n }n }n }n }n return response;n }n /**n * Used if the network timeouts or fails to make the request.n *n * @param {Object} optionsn * @param {Request} request The request to match in the cachen * @param {Event} [options.event]n * @return {Promise<Object>}n *n * @privaten */n _respondFromCache({ event, request }) {n return cacheWrapper.match({n cacheName: this._cacheName,n request,n event,n matchOptions: this._matchOptions,n plugins: this._plugins,n });n }n}nexport { NetworkFirst };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 { assert } from 'workbox-core/_private/assert.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 { messages } from './utils/messages.js';nimport './_version.js';n/**n * An implementation of an * [network-only]{@link developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#network-only}n * request strategy.n *n * This class is useful if you want to take advantage of anyn * [Workbox plugins]{@link developers.google.com/web/tools/workbox/guides/using-plugins}.n *n * If the network request fails, this will throw a `WorkboxError` exception.n *n * @memberof module:workbox-strategiesn */nclass NetworkOnly {n /**n * @param {Object} optionsn * @param {string} options.cacheName Cache name to store and retrieven * requests. Defaults to cache names provided byn * [workbox-core]{@link module:workbox-core.cacheNames}.n * @param {Array<Object>} options.plugins [Plugins]{@link developers.google.com/web/tools/workbox/guides/using-plugins}n * to use in conjunction with this caching strategy.n * @param {Object} options.fetchOptions Values passed along to then * [`init`](developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)n * of all fetch() requests made by this strategy.n */n constructor(options = {}) {n this._plugins = options.plugins || [];n this._fetchOptions = options.fetchOptions;n }n /**n * This method will perform a request strategy and follows an API thatn * will work with then * [Workbox Router]{@link module:workbox-routing.Router}.n *n * @param {Object} optionsn * @param {Request|string} options.request The request to run this strategy for.n * @param {Event} [options.event] The event that triggered the request.n * @return {Promise<Response>}n */n async handle({ event, request }) {n if (typeof request === 'string') {n request = new Request(request);n }n if (process.env.NODE_ENV !== 'production') {n assert.isInstance(request, Request, {n moduleName: 'workbox-strategies',n className: 'NetworkOnly',n funcName: 'handle',n paramName: 'request',n });n }n let error;n let response;n try {n response = await fetchWrapper.fetch({n request,n event,n fetchOptions: this._fetchOptions,n plugins: this._plugins,n });n }n catch (err) {n error = err;n }n if (process.env.NODE_ENV !== 'production') {n logger.groupCollapsed(messages.strategyStart('NetworkOnly', request));n if (response) {n logger.log(`Got response from network.`);n }n else {n logger.log(`Unable to get a response from the network.`);n }n messages.printFinalResponse(response);n logger.groupEnd();n }n if (!response) {n throw new WorkboxError('no-response', { url: request.url, error });n }n return response;n }n}nexport { NetworkOnly };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 { 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 { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';nimport { logger } from 'workbox-core/_private/logger.js';nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';nimport { messages } from './utils/messages.js';nimport { cacheOkAndOpaquePlugin } from './plugins/cacheOkAndOpaquePlugin.js';nimport './_version.js';n/**n * An implementation of an * [stale-while-revalidate]{@link developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#stale-while-revalidate}n * request strategy.n *n * Resources are requested from both the cache and the network in parallel.n * The strategy will respond with the cached version if available, otherwisen * wait for the network response. The cache is updated with the network responsen * with each successful request.n *n * By default, this strategy will cache responses with a 200 status code asn * well as [opaque responses]{@link developers.google.com/web/tools/workbox/guides/handle-third-party-requests}.n * Opaque responses are cross-origin requests where the response doesn'tn * support [CORS]{@link enable-cors.org/}.n *n * If the network request fails, and there is no cache match, this will thrown * a `WorkboxError` exception.n *n * @memberof module:workbox-strategiesn */nclass StaleWhileRevalidate {n /**n * @param {Object} optionsn * @param {string} options.cacheName Cache name to store and retrieven * requests. Defaults to cache names provided byn * [workbox-core]{@link module:workbox-core.cacheNames}.n * @param {Array<Object>} options.plugins [Plugins]{@link developers.google.com/web/tools/workbox/guides/using-plugins}n * to use in conjunction with this caching strategy.n * @param {Object} options.fetchOptions Values passed along to then * [`init`](developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)n * of all fetch() requests made by this strategy.n * @param {Object} options.matchOptions [`CacheQueryOptions`](w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)n */n constructor(options = {}) {n this._cacheName = cacheNames.getRuntimeName(options.cacheName);n this._plugins = options.plugins || [];n if (options.plugins) {n const isUsingCacheWillUpdate = options.plugins.some((plugin) => !!plugin.cacheWillUpdate);n this._plugins = isUsingCacheWillUpdate ?n options.plugins : [cacheOkAndOpaquePlugin, …options.plugins];n }n else {n // No plugins passed in, use the default plugin.n this._plugins = [cacheOkAndOpaquePlugin];n }n this._fetchOptions = options.fetchOptions;n this._matchOptions = options.matchOptions;n }n /**n * This method will perform a request strategy and follows an API thatn * will work with then * [Workbox Router]{@link module:workbox-routing.Router}.n *n * @param {Object} optionsn * @param {Request|string} options.request A request to run this strategy for.n * @param {Event} [options.event] The event that triggered the request.n * @return {Promise<Response>}n */n async handle({ event, request }) {n const logs = [];n if (typeof request === 'string') {n request = new Request(request);n }n if (process.env.NODE_ENV !== 'production') {n assert.isInstance(request, Request, {n moduleName: 'workbox-strategies',n className: 'StaleWhileRevalidate',n funcName: 'handle',n paramName: 'request',n });n }n const fetchAndCachePromise = this._getFromNetwork({ request, event });n let response = await cacheWrapper.match({n cacheName: this._cacheName,n request,n event,n matchOptions: this._matchOptions,n plugins: this._plugins,n });n let error;n if (response) {n if (process.env.NODE_ENV !== 'production') {n logs.push(`Found a cached response in the '${this._cacheName}'` +n ` cache. Will update with the network response in the background.`);n }n if (event) {n try {n event.waitUntil(fetchAndCachePromise);n }n catch (error) {n if (process.env.NODE_ENV !== 'production') {n logger.warn(`Unable to ensure service worker stays alive when ` +n `updating cache for '${getFriendlyURL(request.url)}'.`);n }n }n }n }n else {n if (process.env.NODE_ENV !== 'production') {n logs.push(`No response found in the '${this._cacheName}' cache. ` +n `Will wait for the network response.`);n }n try {n response = await fetchAndCachePromise;n }n catch (err) {n error = err;n }n }n if (process.env.NODE_ENV !== 'production') {n logger.groupCollapsed(messages.strategyStart('StaleWhileRevalidate', request));n for (const log of logs) {n logger.log(log);n }n messages.printFinalResponse(response);n logger.groupEnd();n }n if (!response) {n throw new WorkboxError('no-response', { url: request.url, error });n }n return response;n }n /**n * @param {Object} optionsn * @param {Request} options.requestn * @param {Event} [options.event]n * @return {Promise<Response>}n *n * @privaten */n async _getFromNetwork({ request, event }) {n const response = await fetchWrapper.fetch({n request,n event,n fetchOptions: this._fetchOptions,n plugins: this._plugins,n });n const cachePutPromise = cacheWrapper.put({n cacheName: this._cacheName,n request,n response: response.clone(),n event,n plugins: this._plugins,n });n if (event) {n try {n event.waitUntil(cachePutPromise);n }n catch (error) {n if (process.env.NODE_ENV !== 'production') {n logger.warn(`Unable to ensure service worker stays alive when ` +n `updating cache for '${getFriendlyURL(request.url)}'.`);n }n }n }n return response;n }n}nexport { StaleWhileRevalidate };n”],“names”:,“mappings”:“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”}