{“version”:3,“file”:“workbox-core.dev.js”,“sources”:,“sourcesContent”:[“"use strict";n// @ts-ignorentry {n self && _();n}ncatch (e) { }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 '../_version.js';nconst logger = (process.env.NODE_ENV === 'production' ? null : (() => {n // Don't overwrite this value if it's already set.n // See github.com/GoogleChrome/workbox/pull/2284#issuecomment-560470923n if (!('__WB_DISABLE_DEV_LOGS' in self)) {n self.__WB_DISABLE_DEV_LOGS = false;n }n let inGroup = false;n const methodToColorMap = {n debug: `#7f8c8d`,n log: `#2ecc71`,n warn: `#f39c12`,n error: `#c0392b`,n groupCollapsed: `#3498db`,n groupEnd: null,n };n const print = function (method, args) {n if (self.__WB_DISABLE_DEV_LOGS) {n return;n }n if (method === 'groupCollapsed') {n // Safari doesn't print all console.groupCollapsed() arguments:n // bugs.webkit.org/show_bug.cgi?id=182754n if (/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {n console(…args);n return;n }n }n const styles = [n `background: ${methodToColorMap}`,n `border-radius: 0.5em`,n `color: white`,n `font-weight: bold`,n `padding: 2px 0.5em`,n ];n // When in a group, the workbox prefix is not displayed.n const logPrefix = inGroup ? [] : ['%cworkbox', styles.join(';')];n console(…logPrefix, …args);n if (method === 'groupCollapsed') {n inGroup = true;n }n if (method === 'groupEnd') {n inGroup = false;n }n };n const api = {};n const loggerMethods = Object.keys(methodToColorMap);n for (const key of loggerMethods) {n const method = key;n api = (…args) => {n print(method, args);n };n }n return api;n})());nexport { logger };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 messages = {n 'invalid-value': ({ paramName, validValueDescription, value }) => {n if (!paramName || !validValueDescription) {n throw new Error(`Unexpected input to 'invalid-value' error.`);n }n return `The '${paramName}' parameter was given a value with an ` +n `unexpected value. ${validValueDescription} Received a value of ` +n `${JSON.stringify(value)}.`;n },n 'not-an-array': ({ moduleName, className, funcName, paramName }) => {n if (!moduleName || !className || !funcName || !paramName) {n throw new Error(`Unexpected input to 'not-an-array' error.`);n }n return `The parameter '${paramName}' passed into ` +n `'${moduleName}.${className}.${funcName}()' must be an array.`;n },n 'incorrect-type': ({ expectedType, paramName, moduleName, className, funcName }) => {n if (!expectedType || !paramName || !moduleName || !funcName) {n throw new Error(`Unexpected input to 'incorrect-type' error.`);n }n return `The parameter '${paramName}' passed into ` +n `'${moduleName}.${className ? (className + '.') : ''}` +n `${funcName}()' must be of type ${expectedType}.`;n },n 'incorrect-class': ({ expectedClass, paramName, moduleName, className, funcName, isReturnValueProblem }) => {n if (!expectedClass || !moduleName || !funcName) {n throw new Error(`Unexpected input to 'incorrect-class' error.`);n }n if (isReturnValueProblem) {n return `The return value from ` +n `'${moduleName}.${className ? (className + '.') : ''}${funcName}()' ` +n `must be an instance of class ${expectedClass.name}.`;n }n return `The parameter '${paramName}' passed into ` +n `'${moduleName}.${className ? (className + '.') : ''}${funcName}()' ` +n `must be an instance of class ${expectedClass.name}.`;n },n 'missing-a-method': ({ expectedMethod, paramName, moduleName, className, funcName }) => {n if (!expectedMethod || !paramName || !moduleName || !classNamen || !funcName) {n throw new Error(`Unexpected input to 'missing-a-method' error.`);n }n return `${moduleName}.${className}.${funcName}() expected the ` +n `'${paramName}' parameter to expose a '${expectedMethod}' method.`;n },n 'add-to-cache-list-unexpected-type': ({ entry }) => {n return `An unexpected entry was passed to ` +n `'workbox-precaching.PrecacheController.addToCacheList()' The entry ` +n `'${JSON.stringify(entry)}' isn't supported. You must supply an array of ` +n `strings with one or more characters, objects with a url property or ` +n `Request objects.`;n },n 'add-to-cache-list-conflicting-entries': ({ firstEntry, secondEntry }) => {n if (!firstEntry || !secondEntry) {n throw new Error(`Unexpected input to ` +n `'add-to-cache-list-duplicate-entries' error.`);n }n return `Two of the entries passed to ` +n `'workbox-precaching.PrecacheController.addToCacheList()' had the URL ` +n `${firstEntry._entryId} but different revision details. Workbox is ` +n `unable to cache and version the asset correctly. Please remove one ` +n `of the entries.`;n },n 'plugin-error-request-will-fetch': ({ thrownError }) => {n if (!thrownError) {n throw new Error(`Unexpected input to ` +n `'plugin-error-request-will-fetch', error.`);n }n return `An error was thrown by a plugins 'requestWillFetch()' method. ` +n `The thrown error message was: '${thrownError.message}'.`;n },n 'invalid-cache-name': ({ cacheNameId, value }) => {n if (!cacheNameId) {n throw new Error(`Expected a 'cacheNameId' for error 'invalid-cache-name'`);n }n return `You must provide a name containing at least one character for ` +n `setCacheDetails({${cacheNameId}: '…'}). Received a value of ` +n `'${JSON.stringify(value)}'`;n },n 'unregister-route-but-not-found-with-method': ({ method }) => {n if (!method) {n throw new Error(`Unexpected input to ` +n `'unregister-route-but-not-found-with-method' error.`);n }n return `The route you're trying to unregister was not previously ` +n `registered for the method type '${method}'.`;n },n 'unregister-route-route-not-registered': () => {n return `The route you're trying to unregister was not previously ` +n `registered.`;n },n 'queue-replay-failed': ({ name }) => {n return `Replaying the background sync queue '${name}' failed.`;n },n 'duplicate-queue-name': ({ name }) => {n return `The Queue name '${name}' is already being used. ` +n `All instances of backgroundSync.Queue must be given unique names.`;n },n 'expired-test-without-max-age': ({ methodName, paramName }) => {n return `The '${methodName}()' method can only be used when the ` +n `'${paramName}' is used in the constructor.`;n },n 'unsupported-route-type': ({ moduleName, className, funcName, paramName }) => {n return `The supplied '${paramName}' parameter was an unsupported type. ` +n `Please check the docs for ${moduleName}.${className}.${funcName} for ` +n `valid input types.`;n },n 'not-array-of-class': ({ value, expectedClass, moduleName, className, funcName, paramName }) => {n return `The supplied '${paramName}' parameter must be an array of ` +n `'${expectedClass}' objects. Received '${JSON.stringify(value)},'. ` +n `Please check the call to ${moduleName}.${className}.${funcName}() ` +n `to fix the issue.`;n },n 'max-entries-or-age-required': ({ moduleName, className, funcName }) => {n return `You must define either config.maxEntries or config.maxAgeSeconds` +n `in ${moduleName}.${className}.${funcName}`;n },n 'statuses-or-headers-required': ({ moduleName, className, funcName }) => {n return `You must define either config.statuses or config.headers` +n `in ${moduleName}.${className}.${funcName}`;n },n 'invalid-string': ({ moduleName, funcName, paramName }) => {n if (!paramName || !moduleName || !funcName) {n throw new Error(`Unexpected input to 'invalid-string' error.`);n }n return `When using strings, the '${paramName}' parameter must start with ` +n `'http' (for cross-origin matches) or '/' (for same-origin matches). ` +n `Please see the docs for ${moduleName}.${funcName}() for ` +n `more info.`;n },n 'channel-name-required': () => {n return `You must provide a channelName to construct a ` +n `BroadcastCacheUpdate instance.`;n },n 'invalid-responses-are-same-args': () => {n return `The arguments passed into responsesAreSame() appear to be ` +n `invalid. Please ensure valid Responses are used.`;n },n 'expire-custom-caches-only': () => {n return `You must provide a 'cacheName' property when using the ` +n `expiration plugin with a runtime caching strategy.`;n },n 'unit-must-be-bytes': ({ normalizedRangeHeader }) => {n if (!normalizedRangeHeader) {n throw new Error(`Unexpected input to 'unit-must-be-bytes' error.`);n }n return `The 'unit' portion of the Range header must be set to 'bytes'. ` +n `The Range header provided was "${normalizedRangeHeader}"`;n },n 'single-range-only': ({ normalizedRangeHeader }) => {n if (!normalizedRangeHeader) {n throw new Error(`Unexpected input to 'single-range-only' error.`);n }n return `Multiple ranges are not supported. Please use a single start ` +n `value, and optional end value. The Range header provided was ` +n `"${normalizedRangeHeader}"`;n },n 'invalid-range-values': ({ normalizedRangeHeader }) => {n if (!normalizedRangeHeader) {n throw new Error(`Unexpected input to 'invalid-range-values' error.`);n }n return `The Range header is missing both start and end values. At least ` +n `one of those values is needed. The Range header provided was ` +n `"${normalizedRangeHeader}"`;n },n 'no-range-header': () => {n return `No Range header was found in the Request provided.`;n },n 'range-not-satisfiable': ({ size, start, end }) => {n return `The start (${start}) and end (${end}) values in the Range are ` +n `not satisfiable by the cached response, which is ${size} bytes.`;n },n 'attempt-to-cache-non-get-request': ({ url, method }) => {n return `Unable to cache '${url}' because it is a '${method}' request and ` +n `only 'GET' requests can be cached.`;n },n 'cache-put-with-no-response': ({ url }) => {n return `There was an attempt to cache '${url}' but the response was not ` +n `defined.`;n },n 'no-response': ({ url, error }) => {n let message = `The strategy could not generate a response for '${url}'.`;n if (error) {n message += ` The underlying error is ${error}.`;n }n return message;n },n 'bad-precaching-response': ({ url, status }) => {n return `The precaching request for '${url}' failed with an HTTP ` +n `status of ${status}.`;n },n 'non-precached-url': ({ url }) => {n return `createHandlerBoundToURL('${url}') was called, but that URL is ` +n `not precached. Please pass in a URL that is precached instead.`;n },n 'add-to-cache-list-conflicting-integrities': ({ url }) => {n return `Two of the entries passed to ` +n `'workbox-precaching.PrecacheController.addToCacheList()' had the URL ` +n `${url} with different integrity values. Please remove one of them.`;n },n 'missing-precache-entry': ({ cacheName, url }) => {n return `Unable to find a precached response in ${cacheName} for ${url}.`;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 { messages } from './messages.js';nimport '../../_version.js';nconst fallback = (code, …args) => {n let msg = code;n if (args.length > 0) {n msg += `

${JSON.stringify(args)}`;n }n return msg;n};nconst generatorFunction = (code, details = {}) => {n const message = messages;n if (!message) {n throw new Error(`Unable to find message for code '${code}'.`);n }n return message(details);n};nexport const messageGenerator = (process.env.NODE_ENV === 'production') ?n fallback : generatorFunction;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 { messageGenerator } from '../models/messages/messageGenerator.js';nimport '../_version.js';n/**n * Workbox errors should be thrown with this class.n * This allows use to ensure the type easily in tests,n * helps developers identify errors from workboxn * easily and allows use to optimise errorn * messages correctly.n *n * @privaten */nclass WorkboxError extends Error {n /**n *n * @param {string} errorCode The error code thatn * identifies this particular error.n * @param {Object=} details Any relevant argumentsn * that will help developers identify issues shouldn * be added as a key on the context object.n */n constructor(errorCode, details) {n const message = messageGenerator(errorCode, details);n super(message);n this.name = errorCode;n this.details = details;n }n}nexport { WorkboxError };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 '../_private/WorkboxError.js';nimport '../_version.js';n/*n * This method throws if the supplied value is not an array.n * The destructed values are required to produce a meaningful error for users.n * The destructed and restructured object is so it's clear what isn * needed.n */nconst isArray = (value, details) => {n if (!Array.isArray(value)) {n throw new WorkboxError('not-an-array', details);n }n};nconst hasMethod = (object, expectedMethod, details) => {n const type = typeof object;n if (type !== 'function') {n details = expectedMethod;n throw new WorkboxError('missing-a-method', details);n }n};nconst isType = (object, expectedType, details) => {n if (typeof object !== expectedType) {n details = expectedType;n throw new WorkboxError('incorrect-type', details);n }n};nconst isInstance = (object, expectedClass, details) => {n if (!(object instanceof expectedClass)) {n details = expectedClass;n throw new WorkboxError('incorrect-class', details);n }n};nconst isOneOf = (value, validValues, details) => {n if (!validValues.includes(value)) {n details =n `Valid values are ${JSON.stringify(validValues)}.`;n throw new WorkboxError('invalid-value', details);n }n};nconst isArrayOfClass = (value, expectedClass, details) => {n const error = new WorkboxError('not-array-of-class', details);n if (!Array.isArray(value)) {n throw error;n }n for (const item of value) {n if (!(item instanceof expectedClass)) {n throw error;n }n }n};nconst finalAssertExports = process.env.NODE_ENV === 'production' ? null : {n hasMethod,n isArray,n isInstance,n isOneOf,n isType,n isArrayOfClass,n};nexport { finalAssertExports as assert };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// Callbacks to be executed whenever there's a quota error.nconst quotaErrorCallbacks = new Set();nexport { quotaErrorCallbacks };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 './_private/logger.js';nimport { assert } from './_private/assert.js';nimport { quotaErrorCallbacks } from './models/quotaErrorCallbacks.js';nimport './_version.js';n/**n * Adds a function to the set of quotaErrorCallbacks that will be executed ifn * there's a quota error.n *n * @param {Function} callbackn * @memberof module:workbox-coren */nfunction registerQuotaErrorCallback(callback) {n if (process.env.NODE_ENV !== 'production') {n assert.isType(callback, 'function', {n moduleName: 'workbox-core',n funcName: 'register',n paramName: 'callback',n });n }n quotaErrorCallbacks.add(callback);n if (process.env.NODE_ENV !== 'production') {n logger.log('Registered a callback to respond to quota errors.', callback);n }n}nexport { registerQuotaErrorCallback };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 _cacheNameDetails = {n googleAnalytics: 'googleAnalytics',n precache: 'precache-v2',n prefix: 'workbox',n runtime: 'runtime',n suffix: typeof registration !== 'undefined' ? registration.scope : '',n};nconst _createCacheName = (cacheName) => {n return [_cacheNameDetails.prefix, cacheName, _cacheNameDetails.suffix]n .filter((value) => value && value.length > 0)n .join('-');n};nconst eachCacheNameDetail = (fn) => {n for (const key of Object.keys(_cacheNameDetails)) {n fn(key);n }n};nexport const cacheNames = {n updateDetails: (details) => {n eachCacheNameDetail((key) => {n if (typeof details === 'string') {n _cacheNameDetails = details;n }n });n },n getGoogleAnalyticsName: (userCacheName) => {n return userCacheName || _createCacheName(_cacheNameDetails.googleAnalytics);n },n getPrecacheName: (userCacheName) => {n return userCacheName || _createCacheName(_cacheNameDetails.precache);n },n getPrefix: () => {n return _cacheNameDetails.prefix;n },n getRuntimeName: (userCacheName) => {n return userCacheName || _createCacheName(_cacheNameDetails.runtime);n },n getSuffix: () => {n return _cacheNameDetails.suffix;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 { logger } from '../_private/logger.js';nimport { quotaErrorCallbacks } from '../models/quotaErrorCallbacks.js';nimport '../_version.js';n/**n * Runs all of the callback functions, one at a time sequentially, in the ordern * in which they were registered.n *n * @memberof module:workbox-coren * @privaten */nasync function executeQuotaErrorCallbacks() {n if (process.env.NODE_ENV !== 'production') {n logger.log(`About to run ${quotaErrorCallbacks.size} ` +n `callbacks to clean up caches.`);n }n for (const callback of quotaErrorCallbacks) {n await callback();n if (process.env.NODE_ENV !== 'production') {n logger.log(callback, 'is complete.');n }n }n if (process.env.NODE_ENV !== 'production') {n logger.log('Finished running callbacks.');n }n}nexport { executeQuotaErrorCallbacks };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 getFriendlyURL = (url) => {n const urlObj = new URL(String(url), location.href);n // See github.com/GoogleChrome/workbox/issues/2323n // We want to include everything, except for the origin if it's same-origin.n return urlObj.href.replace(new RegExp(`^${location.origin}`), '');n};nexport { getFriendlyURL };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 pluginUtils = {n filter: (plugins, callbackName) => {n return plugins.filter((plugin) => callbackName in plugin);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 './assert.js';nimport { executeQuotaErrorCallbacks } from './executeQuotaErrorCallbacks.js';nimport { getFriendlyURL } from './getFriendlyURL.js';nimport { logger } from './logger.js';nimport { pluginUtils } from '../utils/pluginUtils.js';nimport { WorkboxError } from './WorkboxError.js';nimport '../_version.js';n/**n * Checks the list of plugins for the cacheKeyWillBeUsed callback, andn * executes any of those callbacks found in sequence. The final `Request` objectn * returned by the last plugin is treated as the cache key for cache readsn * and/or writes.n *n * @param {Object} optionsn * @param {Request} options.requestn * @param {string} options.moden * @param {Array<Object>} [options.plugins=n * @return {Promise<Request>}n *n * @privaten * @memberof module:workbox-coren */nconst _getEffectiveRequest = async ({ request, mode, plugins = [], }) => {n const cacheKeyWillBeUsedPlugins = pluginUtils.filter(plugins, "cacheKeyWillBeUsed" /* CACHE_KEY_WILL_BE_USED */);n let effectiveRequest = request;n for (const plugin of cacheKeyWillBeUsedPlugins) {n effectiveRequest = await plugin["cacheKeyWillBeUsed" /* CACHE_KEY_WILL_BE_USED */].call(plugin, { mode, request: effectiveRequest });n if (typeof effectiveRequest === 'string') {n effectiveRequest = new Request(effectiveRequest);n }n if (process.env.NODE_ENV !== 'production') {n assert.isInstance(effectiveRequest, Request, {n moduleName: 'Plugin',n funcName: "cacheKeyWillBeUsed" /* CACHE_KEY_WILL_BE_USED */,n isReturnValueProblem: true,n });n }n }n return effectiveRequest;n};n/**n * This method will call cacheWillUpdate on the available plugins (or usen * status === 200) to determine if the Response is safe and valid to cache.n *n * @param {Object} optionsn * @param {Request} options.requestn * @param {Response} options.responsen * @param {Event} [options.event]n * @param {Array<Object>} [options.plugins=n * @return {Promise<Response>}n *n * @privaten * @memberof module:workbox-coren */nconst _isResponseSafeToCache = async ({ request, response, event, plugins = [], }) => {n let responseToCache = response;n let pluginsUsed = false;n for (const plugin of plugins) {n if ("cacheWillUpdate" /* CACHE_WILL_UPDATE */ in plugin) {n pluginsUsed = true;n const pluginMethod = plugin["cacheWillUpdate" /* CACHE_WILL_UPDATE */];n responseToCache = await pluginMethod.call(plugin, {n request,n response: responseToCache,n event,n });n if (process.env.NODE_ENV !== 'production') {n if (responseToCache) {n assert.isInstance(responseToCache, Response, {n moduleName: 'Plugin',n funcName: "cacheWillUpdate" /* CACHE_WILL_UPDATE */,n isReturnValueProblem: true,n });n }n }n if (!responseToCache) {n break;n }n }n }n if (!pluginsUsed) {n if (process.env.NODE_ENV !== 'production') {n if (responseToCache) {n if (responseToCache.status !== 200) {n if (responseToCache.status === 0) {n logger.warn(`The response for '${request.url}' is an opaque ` +n `response. The caching strategy that you're using will not ` +n `cache opaque responses by default.`);n }n else {n logger.debug(`The response for '${request.url}' returned ` +n `a status code of '${response.status}' and won't be cached as a ` +n `result.`);n }n }n }n }n responseToCache = responseToCache && responseToCache.status === 200 ?n responseToCache : undefined;n }n return responseToCache ? responseToCache : null;n};n/**n * This is a wrapper around cache.match().n *n * @param {Object} optionsn * @param {string} options.cacheName Name of the cache to match against.n * @param {Request} options.request The Request that will be used to look upn * cache entries.n * @param {Event} [options.event] The event that prompted the action.n * @param {Object} [options.matchOptions] Options passed to cache.match().n * @param {Array<Object>} [options.plugins= Array of plugins.n * @return {Response} A cached response if available.n *n * @privaten * @memberof module:workbox-coren */nconst matchWrapper = async ({ cacheName, request, event, matchOptions, plugins = [], }) => {n const cache = await self.caches.open(cacheName);n const effectiveRequest = await _getEffectiveRequest({n plugins, request, mode: 'read'n });n let cachedResponse = await cache.match(effectiveRequest, matchOptions);n if (process.env.NODE_ENV !== 'production') {n if (cachedResponse) {n logger.debug(`Found a cached response in '${cacheName}'.`);n }n else {n logger.debug(`No cached response found in '${cacheName}'.`);n }n }n for (const plugin of plugins) {n if ("cachedResponseWillBeUsed" /* CACHED_RESPONSE_WILL_BE_USED */ in plugin) {n const pluginMethod = plugin["cachedResponseWillBeUsed" /* CACHED_RESPONSE_WILL_BE_USED */];n cachedResponse = await pluginMethod.call(plugin, {n cacheName,n event,n matchOptions,n cachedResponse,n request: effectiveRequest,n });n if (process.env.NODE_ENV !== 'production') {n if (cachedResponse) {n assert.isInstance(cachedResponse, Response, {n moduleName: 'Plugin',n funcName: "cachedResponseWillBeUsed" /* CACHED_RESPONSE_WILL_BE_USED */,n isReturnValueProblem: true,n });n }n }n }n }n return cachedResponse;n};n/**n * Wrapper around cache.put().n *n * Will call `cacheDidUpdate` on plugins if the cache was updated, usingn * `matchOptions` when determining what the old entry is.n *n * @param {Object} optionsn * @param {string} options.cacheNamen * @param {Request} options.requestn * @param {Response} options.responsen * @param {Event} [options.event]n * @param {Array<Object>} [options.plugins=n * @param {Object} [options.matchOptions]n *n * @privaten * @memberof module:workbox-coren */nconst putWrapper = async ({ cacheName, request, response, event, plugins = [], matchOptions, }) => {n if (process.env.NODE_ENV !== 'production') {n if (request.method && request.method !== 'GET') {n throw new WorkboxError('attempt-to-cache-non-get-request', {n url: getFriendlyURL(request.url),n method: request.method,n });n }n }n const effectiveRequest = await _getEffectiveRequest({n plugins, request, mode: 'write'n });n if (!response) {n if (process.env.NODE_ENV !== 'production') {n logger.error(`Cannot cache non-existent response for ` +n `'${getFriendlyURL(effectiveRequest.url)}'.`);n }n throw new WorkboxError('cache-put-with-no-response', {n url: getFriendlyURL(effectiveRequest.url),n });n }n const responseToCache = await _isResponseSafeToCache({n event,n plugins,n response,n request: effectiveRequest,n });n if (!responseToCache) {n if (process.env.NODE_ENV !== 'production') {n logger.debug(`Response '${getFriendlyURL(effectiveRequest.url)}' will ` +n `not be cached.`, responseToCache);n }n return;n }n const cache = await self.caches.open(cacheName);n const updatePlugins = pluginUtils.filter(plugins, "cacheDidUpdate" /* CACHE_DID_UPDATE */);n const oldResponse = updatePlugins.length > 0 ?n await matchWrapper({ cacheName, matchOptions, request: effectiveRequest }) :n null;n if (process.env.NODE_ENV !== 'production') {n logger.debug(`Updating the '${cacheName}' cache with a new Response for ` +n `${getFriendlyURL(effectiveRequest.url)}.`);n }n try {n await cache.put(effectiveRequest, responseToCache);n }n catch (error) {n // See developer.mozilla.org/en-US/docs/Web/API/DOMException#exception-QuotaExceededErrorn if (error.name === 'QuotaExceededError') {n await executeQuotaErrorCallbacks();n }n throw error;n }n for (const plugin of updatePlugins) {n await plugin["cacheDidUpdate" /* CACHE_DID_UPDATE */].call(plugin, {n cacheName,n event,n oldResponse,n newResponse: responseToCache,n request: effectiveRequest,n });n }n};nexport const cacheWrapper = {n put: putWrapper,n match: matchWrapper,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 '../_version.js';nlet supportStatus;n/**n * A utility function that determines whether the current browser supportsn * constructing a [`ReadableStream`](developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)n * object.n *n * @return {boolean} `true`, if the current browser can successfullyn * construct a `ReadableStream`, `false` otherwise.n *n * @privaten */nfunction canConstructReadableStream() {n if (supportStatus === undefined) {n // See github.com/GoogleChrome/workbox/issues/1473n try {n new ReadableStream({ start() { } });n supportStatus = true;n }n catch (error) {n supportStatus = false;n }n }n return supportStatus;n}nexport { canConstructReadableStream };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';nlet supportStatus;n/**n * A utility function that determines whether the current browser supportsn * constructing a new `Response` from a `response.body` stream.n *n * @return {boolean} `true`, if the current browser can successfullyn * construct a `Response` from a `response.body` stream, `false` otherwise.n *n * @privaten */nfunction canConstructResponseFromBodyStream() {n if (supportStatus === undefined) {n const testResponse = new Response('');n if ('body' in testResponse) {n try {n new Response(testResponse.body);n supportStatus = true;n }n catch (error) {n supportStatus = false;n }n }n supportStatus = false;n }n return supportStatus;n}nexport { canConstructResponseFromBodyStream };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 '../_version.js';n/**n * A helper function that prevents a promise from being flagged as unused.n *n * @privaten **/nexport function dontWaitFor(promise) {n // Effective no-op.n promise.then(() => { });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 * A class that wraps common IndexedDB functionality in a promise-based API.n * It exposes all the underlying power and functionality of IndexedDB, butn * wraps the most commonly used features in a way that's much simpler to use.n *n * @privaten */nexport class DBWrapper {n /**n * @param {string} namen * @param {number} versionn * @param {Object=} [callback]n * @param {!Function} [callbacks.onupgradeneeded]n * @param {!Function} [callbacks.onversionchange] Defaults ton * DBWrapper.prototype._onversionchange when not specified.n * @privaten */n constructor(name, version, { onupgradeneeded, onversionchange, } = {}) {n this._db = null;n this._name = name;n this._version = version;n this._onupgradeneeded = onupgradeneeded;n this._onversionchange = onversionchange || (() => this.close());n }n /**n * Returns the IDBDatabase instance (not normally needed).n * @return {IDBDatabase|undefined}n *n * @privaten */n get db() {n return this._db;n }n /**n * Opens a connected to an IDBDatabase, invokes any onupgradedneededn * callback, and added an onversionchange callback to the database.n *n * @return {IDBDatabase}n * @privaten */n async open() {n if (this._db)n return;n this._db = await new Promise((resolve, reject) => {n // This flag is flipped to true if the timeout callback runs priorn // to the request failing or succeeding. Note: we use a timeout insteadn // of an onblocked handler since there are cases where onblocked willn // never never run. A timeout better handles all possible scenarios:n // github.com/w3c/IndexedDB/issues/223n let openRequestTimedOut = false;n setTimeout(() => {n openRequestTimedOut = true;n reject(new Error('The open request was blocked and timed out'));n }, this.OPEN_TIMEOUT);n const openRequest = indexedDB.open(this._name, this._version);n openRequest.onerror = () => reject(openRequest.error);n openRequest.onupgradeneeded = (evt) => {n if (openRequestTimedOut) {n openRequest.transaction.abort();n openRequest.result.close();n }n else if (typeof this._onupgradeneeded === 'function') {n this._onupgradeneeded(evt);n }n };n openRequest.onsuccess = () => {n const db = openRequest.result;n if (openRequestTimedOut) {n db.close();n }n else {n db.onversionchange = this._onversionchange.bind(this);n resolve(db);n }n };n });n return this;n }n /**n * Polyfills the native `getKey()` method. Note, this is overridden atn * runtime if the browser supports the native method.n *n * @param {string} storeNamen * @param {*} queryn * @return {Array}n * @privaten */n async getKey(storeName, query) {n return (await this.getAllKeys(storeName, query, 1));n }n /**n * Polyfills the native `getAll()` method. Note, this is overridden atn * runtime if the browser supports the native method.n *n * @param {string} storeNamen * @param {*} queryn * @param {number} countn * @return {Array}n * @privaten */n async getAll(storeName, query, count) {n return await this.getAllMatching(storeName, { query, count });n }n /**n * Polyfills the native `getAllKeys()` method. Note, this is overridden atn * runtime if the browser supports the native method.n *n * @param {string} storeNamen * @param {*} queryn * @param {number} countn * @return {Array}n * @privaten */n async getAllKeys(storeName, query, count) {n const entries = await this.getAllMatching(storeName, { query, count, includeKeys: true });n return entries.map((entry) => entry.key);n }n /**n * Supports flexible lookup in an object store by specifying an index,n * query, direction, and count. This method returns an array of objectsn * with the signature .n *n * @param {string} storeNamen * @param {Object} [opts]n * @param {string} [opts.index] The index to use (if specified).n * @param {*} [opts.query]n * @param {IDBCursorDirection} [opts.direction]n * @param {number} [opts.count] The max number of results to return.n * @param {boolean} [opts.includeKeys] When true, the structure of then * returned objects is changed from an array of values to an array ofn * objects in the form {key, primaryKey, value}.n * @return {Array}n * @privaten */n async getAllMatching(storeName, { index, query = null, // IE/Edge errors if query === `undefined`.n direction = 'next', count, includeKeys = false, } = {}) {n return await this.transaction(, 'readonly', (txn, done) => {n const store = txn.objectStore(storeName);n const target = index ? store.index(index) : store;n const results = [];n const request = target.openCursor(query, direction);n request.onsuccess = () => {n const cursor = request.result;n if (cursor) {n results.push(includeKeys ? cursor : cursor.value);n if (count && results.length >= count) {n done(results);n }n else {n cursor.continue();n }n }n else {n done(results);n }n };n });n }n /**n * Accepts a list of stores, a transaction type, and a callback andn * performs a transaction. A promise is returned that resolves to whatevern * value the callback chooses. The callback holds all the transaction logicn * and is invoked with two arguments:n * 1. The IDBTransaction objectn * 2. A `done` function, that's used to resolve the promise whenn * when the transaction is done, if passed a value, the promise isn * resolved to that value.n *n * @param {Array<string>} storeNames An array of object store namesn * involved in the transaction.n * @param {string} type Can be `readonly` or `readwrite`.n * @param {!Function} callbackn * @return {*} The result of the transaction ran by the callback.n * @privaten */n async transaction(storeNames, type, callback) {n await this.open();n return await new Promise((resolve, reject) => {n const txn = this._db.transaction(storeNames, type);n txn.onabort = () => reject(txn.error);n txn.oncomplete = () => resolve();n callback(txn, (value) => resolve(value));n });n }n /**n * Delegates async to a native IDBObjectStore method.n *n * @param {string} method The method name.n * @param {string} storeName The object store name.n * @param {string} type Can be `readonly` or `readwrite`.n * @param {…*} args The list of args to pass to the native method.n * @return {*} The result of the transaction.n * @privaten */n async _call(method, storeName, type, …args) {n const callback = (txn, done) => {n const objStore = txn.objectStore(storeName);n // TODO(philipwalton): Fix this underlying TS2684 error.n // @ts-ignoren const request = objStore.apply(objStore, args);n request.onsuccess = () => done(request.result);n };n return await this.transaction(, type, callback);n }n /**n * Closes the connection opened by `DBWrapper.open()`. Generally this methodn * doesn't need to be called since:n * 1. It's usually better to keep a connection open since openingn * a new connection is somewhat slow.n * 2. Connections are automatically closed when the reference isn * garbage collected.n * The primary use case for needing to close a connection is when anothern * reference (typically in another tab) needs to upgrade it and would ben * blocked by the current, open connection.n *n * @privaten */n close() {n if (this._db) {n this._db.close();n this._db = null;n }n }n}n// Exposed on the prototype to let users modify the default timeout on an// per-instance or global basis.nDBWrapper.prototype.OPEN_TIMEOUT = 2000;n// Wrap native IDBObjectStore methods according to their mode.nconst methodsToWrap = {n readonly: ['get', 'count', 'getKey', 'getAll', 'getAllKeys'],n readwrite: ['add', 'put', 'clear', 'delete'],n};nfor (const [mode, methods] of Object.entries(methodsToWrap)) {n for (const method of methods) {n if (method in IDBObjectStore.prototype) {n // Don't use arrow functions here since we're outside of the class.n DBWrapper.prototype =n async function (storeName, …args) {n return await this._call(method, storeName, mode, …args);n };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 * The Deferred class composes Promises in a way that allows for them to ben * resolved or rejected from outside the constructor. In most cases promisesn * should be used directly, but Deferreds can be necessary when the logic ton * resolve a promise must be separate.n *n * @privaten */nclass Deferred {n /**n * Creates a promise and exposes its resolve and reject functions as methods.n */n constructor() {n this.promise = new Promise((resolve, reject) => {n this.resolve = resolve;n this.reject = reject;n });n }n}nexport { Deferred };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 * Deletes the database.n * Note: this is exported separately from the DBWrapper module because mostn * usages of IndexedDB in workbox dont need deleting, and this way it can ben * reused in tests to delete databases without creating DBWrapper instances.n *n * @param {string} name The database name.n * @privaten */nexport const deleteDatabase = async (name) => {n await new Promise((resolve, reject) => {n const request = indexedDB.deleteDatabase(name);n request.onerror = () => {n reject(request.error);n };n request.onblocked = () => {n reject(new Error('Delete blocked'));n };n request.onsuccess = () => {n resolve();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 { WorkboxError } from './WorkboxError.js';nimport { logger } from './logger.js';nimport { assert } from './assert.js';nimport { getFriendlyURL } from '../_private/getFriendlyURL.js';nimport { pluginUtils } from '../utils/pluginUtils.js';nimport '../_version.js';n/**n * Wrapper around the fetch API.n *n * Will call requestWillFetch on available plugins.n *n * @param {Object} optionsn * @param {Request|string} options.requestn * @param {Object} [options.fetchOptions]n * @param {ExtendableEvent} [options.event]n * @param {Array<Object>} [options.plugins=n * @return {Promise<Response>}n *n * @privaten * @memberof module:workbox-coren */nconst wrappedFetch = async ({ request, fetchOptions, event, plugins = [], }) => {n if (typeof request === 'string') {n request = new Request(request);n }n // We should be able to call `await event.preloadResponse` even if it'sn // undefined, but for some reason, doing so leads to errors in our Node unitn // tests. To work around that, explicitly check preloadResponse's value first.n if (event instanceof FetchEvent && event.preloadResponse) {n const possiblePreloadResponse = await event.preloadResponse;n if (possiblePreloadResponse) {n if (process.env.NODE_ENV !== 'production') {n logger.log(`Using a preloaded navigation response for ` +n `'${getFriendlyURL(request.url)}'`);n }n return possiblePreloadResponse;n }n }n if (process.env.NODE_ENV !== 'production') {n assert.isInstance(request, Request, {n paramName: 'request',n expectedClass: Request,n moduleName: 'workbox-core',n className: 'fetchWrapper',n funcName: 'wrappedFetch',n });n }n const failedFetchPlugins = pluginUtils.filter(plugins, "fetchDidFail" /* FETCH_DID_FAIL */);n // If there is a fetchDidFail plugin, we need to save a clone of then // original request before it's either modified by a requestWillFetchn // plugin or before the original request's body is consumed via fetch().n const originalRequest = failedFetchPlugins.length > 0 ?n request.clone() : null;n try {n for (const plugin of plugins) {n if ("requestWillFetch" /* REQUEST_WILL_FETCH */ in plugin) {n const pluginMethod = plugin["requestWillFetch" /* REQUEST_WILL_FETCH */];n const requestClone = request.clone();n request = await pluginMethod.call(plugin, {n request: requestClone,n event,n });n if (process.env.NODE_ENV !== 'production') {n if (request) {n assert.isInstance(request, Request, {n moduleName: 'Plugin',n funcName: "cachedResponseWillBeUsed" /* CACHED_RESPONSE_WILL_BE_USED */,n isReturnValueProblem: true,n });n }n }n }n }n }n catch (err) {n throw new WorkboxError('plugin-error-request-will-fetch', {n thrownError: err,n });n }n // The request can be altered by plugins with `requestWillFetch` makingn // the original request (Most likely from a `fetch` event) to be differentn // to the Request we make. Pass both to `fetchDidFail` to aid debugging.n const pluginFilteredRequest = request.clone();n try {n let fetchResponse;n // See github.com/GoogleChrome/workbox/issues/1796n if (request.mode === 'navigate') {n fetchResponse = await fetch(request);n }n else {n fetchResponse = await fetch(request, fetchOptions);n }n if (process.env.NODE_ENV !== 'production') {n logger.debug(`Network request for ` +n `'${getFriendlyURL(request.url)}' returned a response with ` +n `status '${fetchResponse.status}'.`);n }n for (const plugin of plugins) {n if ("fetchDidSucceed" /* FETCH_DID_SUCCEED */ in plugin) {n fetchResponse = await plugin["fetchDidSucceed" /* FETCH_DID_SUCCEED */]n .call(plugin, {n event,n request: pluginFilteredRequest,n response: fetchResponse,n });n if (process.env.NODE_ENV !== 'production') {n if (fetchResponse) {n assert.isInstance(fetchResponse, Response, {n moduleName: 'Plugin',n funcName: "fetchDidSucceed" /* FETCH_DID_SUCCEED */,n isReturnValueProblem: true,n });n }n }n }n }n return fetchResponse;n }n catch (error) {n if (process.env.NODE_ENV !== 'production') {n logger.error(`Network request for ` +n `'${getFriendlyURL(request.url)}' threw an error.`, error);n }n for (const plugin of failedFetchPlugins) {n await plugin["fetchDidFail" /* FETCH_DID_FAIL */].call(plugin, {n error,n event,n originalRequest: originalRequest.clone(),n request: pluginFilteredRequest.clone(),n });n }n throw error;n }n};nconst fetchWrapper = {n fetch: wrappedFetch,n};nexport { fetchWrapper };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 '../_version.js';n/**n * Returns a promise that resolves and the passed number of milliseconds.n * This utility is an async/await-friendly version of `setTimeout`.n *n * @param {number} msn * @return {Promise}n * @privaten */nexport function timeout(ms) {n return new Promise((resolve) => setTimeout(resolve, ms));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 { timeout } from './timeout.js';nimport '../_version.js';nconst MAX_RETRY_TIME = 2000;n/**n * Returns a promise that resolves to a window client matching the passedn * `resultingClientId`. For browsers that don't support `resultingClientId`n * or if waiting for the resulting client to apper takes too long, resolve ton * `undefined`.n *n * @param {string} [resultingClientId]n * @return {Promise<Client|undefined>}n * @privaten */nexport async function resultingClientExists(resultingClientId) {n if (!resultingClientId) {n return;n }n let existingWindows = await self.clients.matchAll({ type: 'window' });n const existingWindowIds = new Set(existingWindows.map((w) => w.id));n let resultingWindow;n const startTime = performance.now();n // Only wait up to `MAX_RETRY_TIME` to find a matching client.n while (performance.now() - startTime < MAX_RETRY_TIME) {n existingWindows = await self.clients.matchAll({ type: 'window' });n resultingWindow = existingWindows.find((w) => {n if (resultingClientId) {n // If we have a `resultingClientId`, we can match on that.n return w.id === resultingClientId;n }n else {n // Otherwise match on finding a window not in `existingWindowIds`.n return !existingWindowIds.has(w.id);n }n });n if (resultingWindow) {n break;n }n // Sleep for 100ms and retry.n await timeout(100);n }n return resultingWindow;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*/n// We either expose defaults or we expose every named export.nimport { assert } from './_private/assert.js';nimport { cacheNames } from './_private/cacheNames.js';nimport { cacheWrapper } from './_private/cacheWrapper.js';nimport { canConstructReadableStream } from './_private/canConstructReadableStream.js';nimport { canConstructResponseFromBodyStream } from './_private/canConstructResponseFromBodyStream.js';nimport { dontWaitFor } from './_private/dontWaitFor.js';nimport { DBWrapper } from './_private/DBWrapper.js';nimport { Deferred } from './_private/Deferred.js';nimport { deleteDatabase } from './_private/deleteDatabase.js';nimport { executeQuotaErrorCallbacks } from './_private/executeQuotaErrorCallbacks.js';nimport { fetchWrapper } from './_private/fetchWrapper.js';nimport { getFriendlyURL } from './_private/getFriendlyURL.js';nimport { logger } from './_private/logger.js';nimport { resultingClientExists } from './_private/resultingClientExists.js';nimport { timeout } from './_private/timeout.js';nimport { WorkboxError } from './_private/WorkboxError.js';nimport './_version.js';nexport { assert, cacheNames, cacheWrapper, canConstructReadableStream, canConstructResponseFromBodyStream, dontWaitFor, DBWrapper, Deferred, deleteDatabase, executeQuotaErrorCallbacks, fetchWrapper, getFriendlyURL, logger, resultingClientExists, timeout, WorkboxError, };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 as _cacheNames } from './_private/cacheNames.js';nimport './_version.js';n/**n * Get the current cache names and prefix/suffix used by Workbox.n *n * `cacheNames.precache` is used for precached assets,n * `cacheNames.googleAnalytics` is used by `workbox-google-analytics` ton * store `analytics.js`, and `cacheNames.runtime` is used for everything else.n *n * `cacheNames.prefix` can be used to retrieve just the current prefix value.n * `cacheNames.suffix` can be used to retrieve just the current suffix value.n *n * @return {Object} An object with `precache`, `runtime`, `prefix`, andn * `googleAnalytics` properties.n *n * @memberof module:workbox-coren */nconst cacheNames = {n get googleAnalytics() {n return _cacheNames.getGoogleAnalyticsName();n },n get precache() {n return _cacheNames.getPrecacheName();n },n get prefix() {n return _cacheNames.getPrefix();n },n get runtime() {n return _cacheNames.getRuntimeName();n },n get suffix() {n return _cacheNames.getSuffix();n },n};nexport { cacheNames };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 { canConstructResponseFromBodyStream } from './_private/canConstructResponseFromBodyStream.js';nimport './_version.js';n/**n * Allows developers to copy a response and modify its `headers`, `status`,n * or `statusText` values (the values settable via an * [`ResponseInit`]{@link developer.mozilla.org/en-US/docs/Web/API/Response/Response#Syntax}n * object in the constructor).n * To modify these values, pass a function as the second argument. Thatn * function will be invoked with a single object with the response propertiesn * `{headers, status, statusText}`. The return value of this function willn * be used as the `ResponseInit` for the new `Response`. To change the valuesn * either modify the passed parameter(s) and return it, or return a totallyn * new object.n *n * @param {Response} responsen * @param {Function} modifiern * @memberof module:workbox-coren */nasync function copyResponse(response, modifier) {n const clonedResponse = response.clone();n // Create a fresh `ResponseInit` object by cloning the headers.n const responseInit = {n headers: new Headers(clonedResponse.headers),n status: clonedResponse.status,n statusText: clonedResponse.statusText,n };n // Apply any user modifications.n const modifiedResponseInit = modifier ? modifier(responseInit) : responseInit;n // Create the new response from the body stream and `ResponseInit`n // modifications. Note: not all browsers support the Response.body stream,n // so fall back to reading the entire body into memory as a blob.n const body = canConstructResponseFromBodyStream() ?n clonedResponse.body : await clonedResponse.blob();n return new Response(body, modifiedResponseInit);n}nexport { copyResponse };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';n/**n * Claim any currently available clients once the service workern * becomes active. This is normally used in conjunction with `skipWaiting()`.n *n * @memberof module:workbox-coren */nfunction clientsClaim() {n self.addEventListener('activate', () => self.clients.claim());n}nexport { clientsClaim };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 './_private/assert.js';nimport { cacheNames } from './_private/cacheNames.js';nimport { WorkboxError } from './_private/WorkboxError.js';nimport './_version.js';n/**n * Modifies the default cache names used by the Workbox packages.n * Cache names are generated as `<prefix>-<Cache Name>-<suffix>`.n *n * @param {Object} detailsn * @param {Object} [details.prefix] The string to add to the beginning ofn * the precache and runtime cache names.n * @param {Object} [details.suffix] The string to add to the end ofn * the precache and runtime cache names.n * @param {Object} [details.precache] The cache name to use for precachen * caching.n * @param {Object} [details.runtime] The cache name to use for runtime caching.n * @param {Object} [details.googleAnalytics] The cache name to use forn * `workbox-google-analytics` caching.n *n * @memberof module:workbox-coren */nfunction setCacheNameDetails(details) {n if (process.env.NODE_ENV !== 'production') {n Object.keys(details).forEach((key) => {n assert.isType(details, 'string', {n moduleName: 'workbox-core',n funcName: 'setCacheNameDetails',n paramName: `details.${key}`,n });n });n if ('precache' in details && details.length === 0) {n throw new WorkboxError('invalid-cache-name', {n cacheNameId: 'precache',n value: details,n });n }n if ('runtime' in details && details.length === 0) {n throw new WorkboxError('invalid-cache-name', {n cacheNameId: 'runtime',n value: details,n });n }n if ('googleAnalytics' in details && details.length === 0) {n throw new WorkboxError('invalid-cache-name', {n cacheNameId: 'googleAnalytics',n value: details,n });n }n }n cacheNames.updateDetails(details);n}nexport { setCacheNameDetails };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';n/**n * Force a service worker to activate immediately, instead ofn * [waiting](developers.google.com/web/fundamentals/primers/service-workers/lifecycle#waiting)n * for existing clients to close.n *n * @memberof module:workbox-coren */nfunction skipWaiting() {n // We need to explicitly call `self.skipWaiting()` here because we'ren // shadowing `skipWaiting` with this local function.n self.addEventListener('install', () => self.skipWaiting());n}nexport { skipWaiting };n“],”names“:,”mappings“:”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“}