RubyGems - jekyll-pwa-workbox - Versions diffs - 0.0.1 → 0.0.3 - Mend

jekyll-pwa-workbox 0.0.1 → 0.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (113) hide show

data/lib/vendor/workbox-v4.1.1/workbox-broadcast-update.dev.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"workbox-broadcast-update.dev.js","sources":["../_version.mjs","../responsesAreSame.mjs","../utils/constants.mjs","../broadcastUpdate.mjs","../BroadcastCacheUpdate.mjs","../Plugin.mjs","../index.mjs"],"sourcesContent":["try{self['workbox:broadcast-update:4.1.1']&&_()}catch(e){}// eslint-disable-line","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';\nimport {logger} from 'workbox-core/_private/logger.mjs';\nimport './_version.mjs';\n\n/**\n * Given two `Response's`, compares several header values to see if they are\n * the same or not.\n *\n * @param {Response} firstResponse\n * @param {Response} secondResponse\n * @param {Array<string>} headersToCheck\n * @return {boolean}\n *\n * @memberof workbox.broadcastUpdate\n * @private\n */\nconst responsesAreSame = (firstResponse, secondResponse, headersToCheck) => {\n if (process.env.NODE_ENV !== 'production') {\n if (!(firstResponse instanceof Response &&\n secondResponse instanceof Response)) {\n throw new WorkboxError('invalid-responses-are-same-args');\n }\n }\n\n const atLeastOneHeaderAvailable = headersToCheck.some((header) => {\n return firstResponse.headers.has(header) &&\n secondResponse.headers.has(header);\n });\n\n if (!atLeastOneHeaderAvailable) {\n if (process.env.NODE_ENV !== 'production') {\n logger.warn(`Unable to determine where the response has been updated ` +\n `because none of the headers that would be checked are present.`);\n logger.debug(`Attempting to compare the following: `,\n firstResponse, secondResponse, headersToCheck);\n }\n\n // Just return true, indicating the that responses are the same, since we\n // can't determine otherwise.\n return true;\n }\n\n return headersToCheck.every((header) => {\n const headerStateComparison = firstResponse.headers.has(header) ===\n secondResponse.headers.has(header);\n const headerValueComparison = firstResponse.headers.get(header) ===\n secondResponse.headers.get(header);\n\n return headerStateComparison && headerValueComparison;\n });\n};\n\nexport {responsesAreSame};\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport '../_version.mjs';\n\nexport const CACHE_UPDATED_MESSAGE_TYPE = 'CACHE_UPDATED';\nexport const CACHE_UPDATED_MESSAGE_META = 'workbox-broadcast-update';\nexport const DEFAULT_BROADCAST_CHANNEL_NAME = 'workbox';\nexport const DEFAULT_DEFER_NOTIFICATION_TIMEOUT = 10000;\nexport const DEFAULT_HEADERS_TO_CHECK = [\n 'content-length',\n 'etag',\n 'last-modified',\n];\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {assert} from 'workbox-core/_private/assert.mjs';\nimport {CACHE_UPDATED_MESSAGE_TYPE, CACHE_UPDATED_MESSAGE_META}\n from './utils/constants.mjs';\n\nimport './_version.mjs';\n\n/**\n * You would not normally call this method directly; it's called automatically\n * by an instance of the {@link BroadcastCacheUpdate} class. It's exposed here\n * for the benefit of developers who would rather not use the full\n * `BroadcastCacheUpdate` implementation.\n *\n * Calling this will dispatch a message on the provided\n * {@link https://developers.google.com/web/updates/2016/09/broadcastchannel|Broadcast Channel}\n * to notify interested subscribers about a change to a cached resource.\n *\n * The message that's posted has a formation inspired by the\n * [Flux standard action](https://github.com/acdlite/flux-standard-action#introduction)\n * format like so:\n *\n * ```\n * {\n * type: 'CACHE_UPDATED',\n * meta: 'workbox-broadcast-update',\n * payload: {\n * cacheName: 'the-cache-name',\n * updatedURL: 'https://example.com/'\n * }\n * }\n * ```\n *\n * (Usage of [Flux](https://facebook.github.io/flux/) itself is not at\n * all required.)\n *\n * @param {Object} options\n * @param {string} options.cacheName The name of the cache in which the updated\n * `Response` was stored.\n * @param {string} options.url The URL associated with the updated `Response`.\n * @param {BroadcastChannel} [options.channel] The `BroadcastChannel` to use.\n * If no channel is set or the browser doesn't support the BroadcastChannel\n * api, then an attempt will be made to `postMessage` each window client.\n *\n * @memberof workbox.broadcastUpdate\n */\nconst broadcastUpdate = async ({channel, cacheName, url}) => {\n if (process.env.NODE_ENV !== 'production') {\n assert.isType(cacheName, 'string', {\n moduleName: 'workbox-broadcast-update',\n className: '~',\n funcName: 'broadcastUpdate',\n paramName: 'cacheName',\n });\n assert.isType(url, 'string', {\n moduleName: 'workbox-broadcast-update',\n className: '~',\n funcName: 'broadcastUpdate',\n paramName: 'url',\n });\n }\n\n const data = {\n type: CACHE_UPDATED_MESSAGE_TYPE,\n meta: CACHE_UPDATED_MESSAGE_META,\n payload: {\n cacheName: cacheName,\n updatedURL: url,\n },\n };\n\n if (channel) {\n channel.postMessage(data);\n } else {\n const windows = await clients.matchAll({type: 'window'});\n for (const win of windows) {\n win.postMessage(data);\n }\n }\n};\n\nexport {broadcastUpdate};\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {assert} from 'workbox-core/_private/assert.mjs';\nimport {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.mjs';\nimport {logger} from 'workbox-core/_private/logger.mjs';\nimport {Deferred} from 'workbox-core/_private/Deferred.mjs';\nimport {responsesAreSame} from './responsesAreSame.mjs';\nimport {broadcastUpdate} from './broadcastUpdate.mjs';\n\nimport {DEFAULT_HEADERS_TO_CHECK, DEFAULT_BROADCAST_CHANNEL_NAME,\n DEFAULT_DEFER_NOTIFICATION_TIMEOUT} from './utils/constants.mjs';\n\nimport './_version.mjs';\n\n/**\n * Uses the [Broadcast Channel API]{@link https://developers.google.com/web/updates/2016/09/broadcastchannel}\n * to notify interested parties when a cached response has been updated.\n * In browsers that do not support the Broadcast Channel API, the instance\n * falls back to sending the update via `postMessage()` to all window clients.\n *\n * For efficiency's sake, the underlying response bodies are not compared;\n * only specific response headers are checked.\n *\n * @memberof workbox.broadcastUpdate\n */\nclass BroadcastCacheUpdate {\n /**\n * Construct a BroadcastCacheUpdate instance with a specific `channelName` to\n * broadcast messages on\n *\n * @param {Object} options\n * @param {Array<string>}\n * [options.headersToCheck=['content-length', 'etag', 'last-modified']]\n * A list of headers that will be used to determine whether the responses\n * differ.\n * @param {string} [options.channelName='workbox'] The name that will be used\n *. when creating the `BroadcastChannel`, which defaults to 'workbox' (the\n * channel name used by the `workbox-window` package).\n * @param {string} [options.deferNoticationTimeout=10000] The amount of time\n * to wait for a ready message from the window on navigation requests\n * before sending the update.\n */\n constructor({headersToCheck, channelName, deferNoticationTimeout} = {}) {\n this._headersToCheck = headersToCheck || DEFAULT_HEADERS_TO_CHECK;\n this._channelName = channelName || DEFAULT_BROADCAST_CHANNEL_NAME;\n this._deferNoticationTimeout =\n deferNoticationTimeout || DEFAULT_DEFER_NOTIFICATION_TIMEOUT;\n\n if (process.env.NODE_ENV !== 'production') {\n assert.isType(this._channelName, 'string', {\n moduleName: 'workbox-broadcast-update',\n className: 'BroadcastCacheUpdate',\n funcName: 'constructor',\n paramName: 'channelName',\n });\n assert.isArray(this._headersToCheck, {\n moduleName: 'workbox-broadcast-update',\n className: 'BroadcastCacheUpdate',\n funcName: 'constructor',\n paramName: 'headersToCheck',\n });\n }\n\n this._initWindowReadyDeferreds();\n }\n\n /**\n * Compare two [Responses](https://developer.mozilla.org/en-US/docs/Web/API/Response)\n * and send a message via the\n * {@link https://developers.google.com/web/updates/2016/09/broadcastchannel|Broadcast Channel API}\n * if they differ.\n *\n * Neither of the Responses can be {@link http://stackoverflow.com/questions/39109789|opaque}.\n *\n * @param {Object} options\n * @param {Response} options.oldResponse Cached response to compare.\n * @param {Response} options.newResponse Possibly updated response to compare.\n * @param {string} options.url The URL of the request.\n * @param {string} options.cacheName Name of the cache the responses belong\n * to. This is included in the broadcast message.\n * @param {Event} [options.event] event An optional event that triggered\n * this possible cache update.\n * @return {Promise} Resolves once the update is sent.\n */\n notifyIfUpdated({oldResponse, newResponse, url, cacheName, event}) {\n if (!responsesAreSame(oldResponse, newResponse, this._headersToCheck)) {\n if (process.env.NODE_ENV !== 'production') {\n logger.log(`Newer response found (and cached) for:`, url);\n }\n\n const sendUpdate = async () => {\n // In the case of a navigation request, the requesting page will likely\n // not have loaded its JavaScript in time to recevied the update\n // notification, so we defer it until ready (or we timeout waiting).\n if (event && event.request && event.request.mode === 'navigate') {\n if (process.env.NODE_ENV !== 'production') {\n logger.debug(`Original request was a navigation request, ` +\n `waiting for a ready message from the window`, event.request);\n }\n await this._windowReadyOrTimeout(event);\n }\n await broadcastUpdate({channel: this._getChannel(), cacheName, url});\n };\n\n // Send the update and ensure the SW stays alive until it's sent.\n const done = sendUpdate();\n\n if (event) {\n try {\n event.waitUntil(done);\n } catch (error) {\n if (process.env.NODE_ENV !== 'production') {\n logger.warn(`Unable to ensure service worker stays alive ` +\n `when broadcasting cache update for ` +\n `${getFriendlyURL(event.request.url)}'.`);\n }\n }\n }\n return done;\n }\n }\n\n /**\n * @return {BroadcastChannel|undefined} The BroadcastChannel instance used for\n * broadcasting updates, or undefined if the browser doesn't support the\n * Broadcast Channel API.\n *\n * @private\n */\n _getChannel() {\n if (('BroadcastChannel' in self) && !this._channel) {\n this._channel = new BroadcastChannel(this._channelName);\n }\n return this._channel;\n }\n\n /**\n * Waits for a message from the window indicating that it's capable of\n * receiving broadcasts. By default, this will only wait for the amount of\n * time specified via the `deferNoticationTimeout` option.\n *\n * @param {Event} event The navigation fetch event.\n * @return {Promise}\n * @private\n */\n _windowReadyOrTimeout(event) {\n if (!this._navigationEventsDeferreds.has(event)) {\n const deferred = new Deferred();\n\n // Set the deferred on the `_navigationEventsDeferreds` map so it will\n // be resolved when the next ready message event comes.\n this._navigationEventsDeferreds.set(event, deferred);\n\n // But don't wait too long for the message since it may never come.\n const timeout = setTimeout(() => {\n if (process.env.NODE_ENV !== 'production') {\n logger.debug(`Timed out after ${this._deferNoticationTimeout}` +\n `ms waiting for message from window`);\n }\n deferred.resolve();\n }, this._deferNoticationTimeout);\n\n // Ensure the timeout is cleared if the deferred promise is resolved.\n deferred.promise.then(() => clearTimeout(timeout));\n }\n return this._navigationEventsDeferreds.get(event).promise;\n }\n\n /**\n * Creates a mapping between navigation fetch events and deferreds, and adds\n * a listener for message events from the window. When message events arrive,\n * all deferreds in the mapping are resolved.\n *\n * Note: it would be easier if we could only resolve the deferred of\n * navigation fetch event whose client ID matched the source ID of the\n * message event, but currently client IDs are not exposed on navigation\n * fetch events: https://www.chromestatus.com/feature/4846038800138240\n */\n _initWindowReadyDeferreds() {\n // A mapping between navigation events and their deferreds.\n this._navigationEventsDeferreds = new Map();\n\n // The message listener needs to be added in the initial run of the\n // service worker, but since we don't actually need to be listening for\n // messages until the cache updates, we only invoke the callback if set.\n self.addEventListener('message', (event) => {\n if (event.data.type === 'WINDOW_READY' &&\n event.data.meta === 'workbox-window' &&\n this._navigationEventsDeferreds.size > 0) {\n if (process.env.NODE_ENV !== 'production') {\n logger.debug(`Received WINDOW_READY event: `, event);\n }\n // Resolve any pending deferreds.\n for (const deferred of this._navigationEventsDeferreds.values()) {\n deferred.resolve();\n }\n this._navigationEventsDeferreds.clear();\n }\n });\n }\n}\n\nexport {BroadcastCacheUpdate};\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {assert} from 'workbox-core/_private/assert.mjs';\nimport {BroadcastCacheUpdate} from './BroadcastCacheUpdate.mjs';\nimport './_version.mjs';\n\n/**\n * This plugin will automatically broadcast a message whenever a cached response\n * is updated.\n *\n * @memberof workbox.broadcastUpdate\n */\nclass Plugin {\n /**\n * Construct a BroadcastCacheUpdate instance with the passed options and\n * calls its `notifyIfUpdated()` method whenever the plugin's\n * `cacheDidUpdate` callback is invoked.\n *\n * @param {Object} options\n * @param {Array<string>}\n * [options.headersToCheck=['content-length', 'etag', 'last-modified']]\n * A list of headers that will be used to determine whether the responses\n * differ.\n * @param {string} [options.channelName='workbox'] The name that will be used\n *. when creating the `BroadcastChannel`, which defaults to 'workbox' (the\n * channel name used by the `workbox-window` package).\n * @param {string} [options.deferNoticationTimeout=10000] The amount of time\n * to wait for a ready message from the window on navigation requests\n * before sending the update.\n */\n constructor(options) {\n this._broadcastUpdate = new BroadcastCacheUpdate(options);\n }\n\n /**\n * A \"lifecycle\" callback that will be triggered automatically by the\n * `workbox-sw` and `workbox-runtime-caching` handlers when an entry is\n * added to a cache.\n *\n * @private\n * @param {Object} options The input object to this function.\n * @param {string} options.cacheName Name of the cache being updated.\n * @param {Response} [options.oldResponse] The previous cached value, if any.\n * @param {Response} options.newResponse The new value in the cache.\n * @param {Request} options.request The request that triggered the udpate.\n * @param {Request} [options.event] The event that triggered the update.\n */\n cacheDidUpdate({cacheName, oldResponse, newResponse, request, event}) {\n if (process.env.NODE_ENV !== 'production') {\n assert.isType(cacheName, 'string', {\n moduleName: 'workbox-broadcast-update',\n className: 'Plugin',\n funcName: 'cacheDidUpdate',\n paramName: 'cacheName',\n });\n assert.isInstance(newResponse, Response, {\n moduleName: 'workbox-broadcast-update',\n className: 'Plugin',\n funcName: 'cacheDidUpdate',\n paramName: 'newResponse',\n });\n assert.isInstance(request, Request, {\n moduleName: 'workbox-broadcast-update',\n className: 'Plugin',\n funcName: 'cacheDidUpdate',\n paramName: 'request',\n });\n }\n\n if (!oldResponse) {\n // Without a two responses there is nothing to compare.\n return;\n }\n this._broadcastUpdate.notifyIfUpdated({\n cacheName,\n oldResponse,\n newResponse,\n event,\n url: request.url,\n });\n }\n}\n\nexport {Plugin};\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {BroadcastCacheUpdate} from './BroadcastCacheUpdate.mjs';\nimport {Plugin} from './Plugin.mjs';\nimport {broadcastUpdate} from './broadcastUpdate.mjs';\nimport {responsesAreSame} from './responsesAreSame.mjs';\nimport './_version.mjs';\n\n\n/**\n * @namespace workbox.broadcastUpdate\n */\n\nexport {\n BroadcastCacheUpdate,\n Plugin,\n broadcastUpdate,\n responsesAreSame,\n};\n"],"names":["self","_","e","responsesAreSame","firstResponse","secondResponse","headersToCheck","Response","WorkboxError","atLeastOneHeaderAvailable","some","header","headers","has","logger","warn","debug","every","headerStateComparison","headerValueComparison","get","CACHE_UPDATED_MESSAGE_TYPE","CACHE_UPDATED_MESSAGE_META","DEFAULT_BROADCAST_CHANNEL_NAME","DEFAULT_DEFER_NOTIFICATION_TIMEOUT","DEFAULT_HEADERS_TO_CHECK","broadcastUpdate","channel","cacheName","url","assert","isType","moduleName","className","funcName","paramName","data","type","meta","payload","updatedURL","postMessage","windows","clients","matchAll","win","BroadcastCacheUpdate","constructor","channelName","deferNoticationTimeout","_headersToCheck","_channelName","_deferNoticationTimeout","isArray","_initWindowReadyDeferreds","notifyIfUpdated","oldResponse","newResponse","event","log","sendUpdate","request","mode","_windowReadyOrTimeout","_getChannel","done","waitUntil","error","getFriendlyURL","_channel","BroadcastChannel","_navigationEventsDeferreds","deferred","Deferred","set","timeout","setTimeout","resolve","promise","then","clearTimeout","Map","addEventListener","size","values","clear","Plugin","options","_broadcastUpdate","cacheDidUpdate","isInstance","Request"],"mappings":"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"}

data/lib/vendor/workbox-v4.1.1/workbox-broadcast-update.prod.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ this.workbox=this.workbox\|\|{},this.workbox.broadcastUpdate=function(e,t){"use strict";try{self["workbox:broadcast-update:4.1.1"]&&_()}catch(e){}const s=(e,t,s)=>{return!s.some(s=>e.headers.has(s)&&t.headers.has(s))\|\|s.every(s=>{const n=e.headers.has(s)===t.headers.has(s),a=e.headers.get(s)===t.headers.get(s);return n&&a})},n="workbox",a=1e4,i=["content-length","etag","last-modified"],o=async({channel:e,cacheName:t,url:s})=>{const n={type:"CACHE_UPDATED",meta:"workbox-broadcast-update",payload:{cacheName:t,updatedURL:s}};if(e)e.postMessage(n);else{const e=await clients.matchAll({type:"window"});for(const t of e)t.postMessage(n)}};class c{constructor({headersToCheck:e,channelName:t,deferNoticationTimeout:s}={}){this.t=e\|\|i,this.s=t\|\|n,this.i=s\|\|a,this.o()}notifyIfUpdated({oldResponse:e,newResponse:t,url:n,cacheName:a,event:i}){if(!s(e,t,this.t)){const e=(async()=>{i&&i.request&&"navigate"===i.request.mode&&await this.h(i),await o({channel:this.l(),cacheName:a,url:n})})();if(i)try{i.waitUntil(e)}catch(e){}return e}}l(){return"BroadcastChannel"in self&&!this.u&&(this.u=new BroadcastChannel(this.s)),this.u}h(e){if(!this.m.has(e)){const s=new t.Deferred;this.m.set(e,s);const n=setTimeout(()=>{s.resolve()},this.i);s.promise.then(()=>clearTimeout(n))}return this.m.get(e).promise}o(){this.m=new Map,self.addEventListener("message",e=>{if("WINDOW_READY"===e.data.type&&"workbox-window"===e.data.meta&&this.m.size>0){for(const e of this.m.values())e.resolve();this.m.clear()}})}}return e.BroadcastCacheUpdate=c,e.Plugin=class{constructor(e){this.p=new c(e)}cacheDidUpdate({cacheName:e,oldResponse:t,newResponse:s,request:n,event:a}){t&&this.p.notifyIfUpdated({cacheName:e,oldResponse:t,newResponse:s,event:a,url:n.url})}},e.broadcastUpdate=o,e.responsesAreSame=s,e}({},workbox.core._private);
2	+ //# sourceMappingURL=workbox-broadcast-update.prod.js.map

data/lib/vendor/workbox-v4.1.1/workbox-broadcast-update.prod.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"workbox-broadcast-update.prod.js","sources":["../_version.mjs","../responsesAreSame.mjs","../utils/constants.mjs","../broadcastUpdate.mjs","../BroadcastCacheUpdate.mjs","../Plugin.mjs"],"sourcesContent":["try{self['workbox:broadcast-update:4.1.1']&&_()}catch(e){}// eslint-disable-line","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';\nimport {logger} from 'workbox-core/_private/logger.mjs';\nimport './_version.mjs';\n\n/**\n * Given two `Response's`, compares several header values to see if they are\n * the same or not.\n *\n * @param {Response} firstResponse\n * @param {Response} secondResponse\n * @param {Array<string>} headersToCheck\n * @return {boolean}\n *\n * @memberof workbox.broadcastUpdate\n * @private\n */\nconst responsesAreSame = (firstResponse, secondResponse, headersToCheck) => {\n if (process.env.NODE_ENV !== 'production') {\n if (!(firstResponse instanceof Response &&\n secondResponse instanceof Response)) {\n throw new WorkboxError('invalid-responses-are-same-args');\n }\n }\n\n const atLeastOneHeaderAvailable = headersToCheck.some((header) => {\n return firstResponse.headers.has(header) &&\n secondResponse.headers.has(header);\n });\n\n if (!atLeastOneHeaderAvailable) {\n if (process.env.NODE_ENV !== 'production') {\n logger.warn(`Unable to determine where the response has been updated ` +\n `because none of the headers that would be checked are present.`);\n logger.debug(`Attempting to compare the following: `,\n firstResponse, secondResponse, headersToCheck);\n }\n\n // Just return true, indicating the that responses are the same, since we\n // can't determine otherwise.\n return true;\n }\n\n return headersToCheck.every((header) => {\n const headerStateComparison = firstResponse.headers.has(header) ===\n secondResponse.headers.has(header);\n const headerValueComparison = firstResponse.headers.get(header) ===\n secondResponse.headers.get(header);\n\n return headerStateComparison && headerValueComparison;\n });\n};\n\nexport {responsesAreSame};\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport '../_version.mjs';\n\nexport const CACHE_UPDATED_MESSAGE_TYPE = 'CACHE_UPDATED';\nexport const CACHE_UPDATED_MESSAGE_META = 'workbox-broadcast-update';\nexport const DEFAULT_BROADCAST_CHANNEL_NAME = 'workbox';\nexport const DEFAULT_DEFER_NOTIFICATION_TIMEOUT = 10000;\nexport const DEFAULT_HEADERS_TO_CHECK = [\n 'content-length',\n 'etag',\n 'last-modified',\n];\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {assert} from 'workbox-core/_private/assert.mjs';\nimport {CACHE_UPDATED_MESSAGE_TYPE, CACHE_UPDATED_MESSAGE_META}\n from './utils/constants.mjs';\n\nimport './_version.mjs';\n\n/**\n * You would not normally call this method directly; it's called automatically\n * by an instance of the {@link BroadcastCacheUpdate} class. It's exposed here\n * for the benefit of developers who would rather not use the full\n * `BroadcastCacheUpdate` implementation.\n *\n * Calling this will dispatch a message on the provided\n * {@link https://developers.google.com/web/updates/2016/09/broadcastchannel|Broadcast Channel}\n * to notify interested subscribers about a change to a cached resource.\n *\n * The message that's posted has a formation inspired by the\n * [Flux standard action](https://github.com/acdlite/flux-standard-action#introduction)\n * format like so:\n *\n * ```\n * {\n * type: 'CACHE_UPDATED',\n * meta: 'workbox-broadcast-update',\n * payload: {\n * cacheName: 'the-cache-name',\n * updatedURL: 'https://example.com/'\n * }\n * }\n * ```\n *\n * (Usage of [Flux](https://facebook.github.io/flux/) itself is not at\n * all required.)\n *\n * @param {Object} options\n * @param {string} options.cacheName The name of the cache in which the updated\n * `Response` was stored.\n * @param {string} options.url The URL associated with the updated `Response`.\n * @param {BroadcastChannel} [options.channel] The `BroadcastChannel` to use.\n * If no channel is set or the browser doesn't support the BroadcastChannel\n * api, then an attempt will be made to `postMessage` each window client.\n *\n * @memberof workbox.broadcastUpdate\n */\nconst broadcastUpdate = async ({channel, cacheName, url}) => {\n if (process.env.NODE_ENV !== 'production') {\n assert.isType(cacheName, 'string', {\n moduleName: 'workbox-broadcast-update',\n className: '~',\n funcName: 'broadcastUpdate',\n paramName: 'cacheName',\n });\n assert.isType(url, 'string', {\n moduleName: 'workbox-broadcast-update',\n className: '~',\n funcName: 'broadcastUpdate',\n paramName: 'url',\n });\n }\n\n const data = {\n type: CACHE_UPDATED_MESSAGE_TYPE,\n meta: CACHE_UPDATED_MESSAGE_META,\n payload: {\n cacheName: cacheName,\n updatedURL: url,\n },\n };\n\n if (channel) {\n channel.postMessage(data);\n } else {\n const windows = await clients.matchAll({type: 'window'});\n for (const win of windows) {\n win.postMessage(data);\n }\n }\n};\n\nexport {broadcastUpdate};\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {assert} from 'workbox-core/_private/assert.mjs';\nimport {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.mjs';\nimport {logger} from 'workbox-core/_private/logger.mjs';\nimport {Deferred} from 'workbox-core/_private/Deferred.mjs';\nimport {responsesAreSame} from './responsesAreSame.mjs';\nimport {broadcastUpdate} from './broadcastUpdate.mjs';\n\nimport {DEFAULT_HEADERS_TO_CHECK, DEFAULT_BROADCAST_CHANNEL_NAME,\n DEFAULT_DEFER_NOTIFICATION_TIMEOUT} from './utils/constants.mjs';\n\nimport './_version.mjs';\n\n/**\n * Uses the [Broadcast Channel API]{@link https://developers.google.com/web/updates/2016/09/broadcastchannel}\n * to notify interested parties when a cached response has been updated.\n * In browsers that do not support the Broadcast Channel API, the instance\n * falls back to sending the update via `postMessage()` to all window clients.\n *\n * For efficiency's sake, the underlying response bodies are not compared;\n * only specific response headers are checked.\n *\n * @memberof workbox.broadcastUpdate\n */\nclass BroadcastCacheUpdate {\n /**\n * Construct a BroadcastCacheUpdate instance with a specific `channelName` to\n * broadcast messages on\n *\n * @param {Object} options\n * @param {Array<string>}\n * [options.headersToCheck=['content-length', 'etag', 'last-modified']]\n * A list of headers that will be used to determine whether the responses\n * differ.\n * @param {string} [options.channelName='workbox'] The name that will be used\n *. when creating the `BroadcastChannel`, which defaults to 'workbox' (the\n * channel name used by the `workbox-window` package).\n * @param {string} [options.deferNoticationTimeout=10000] The amount of time\n * to wait for a ready message from the window on navigation requests\n * before sending the update.\n */\n constructor({headersToCheck, channelName, deferNoticationTimeout} = {}) {\n this._headersToCheck = headersToCheck || DEFAULT_HEADERS_TO_CHECK;\n this._channelName = channelName || DEFAULT_BROADCAST_CHANNEL_NAME;\n this._deferNoticationTimeout =\n deferNoticationTimeout || DEFAULT_DEFER_NOTIFICATION_TIMEOUT;\n\n if (process.env.NODE_ENV !== 'production') {\n assert.isType(this._channelName, 'string', {\n moduleName: 'workbox-broadcast-update',\n className: 'BroadcastCacheUpdate',\n funcName: 'constructor',\n paramName: 'channelName',\n });\n assert.isArray(this._headersToCheck, {\n moduleName: 'workbox-broadcast-update',\n className: 'BroadcastCacheUpdate',\n funcName: 'constructor',\n paramName: 'headersToCheck',\n });\n }\n\n this._initWindowReadyDeferreds();\n }\n\n /**\n * Compare two [Responses](https://developer.mozilla.org/en-US/docs/Web/API/Response)\n * and send a message via the\n * {@link https://developers.google.com/web/updates/2016/09/broadcastchannel|Broadcast Channel API}\n * if they differ.\n *\n * Neither of the Responses can be {@link http://stackoverflow.com/questions/39109789|opaque}.\n *\n * @param {Object} options\n * @param {Response} options.oldResponse Cached response to compare.\n * @param {Response} options.newResponse Possibly updated response to compare.\n * @param {string} options.url The URL of the request.\n * @param {string} options.cacheName Name of the cache the responses belong\n * to. This is included in the broadcast message.\n * @param {Event} [options.event] event An optional event that triggered\n * this possible cache update.\n * @return {Promise} Resolves once the update is sent.\n */\n notifyIfUpdated({oldResponse, newResponse, url, cacheName, event}) {\n if (!responsesAreSame(oldResponse, newResponse, this._headersToCheck)) {\n if (process.env.NODE_ENV !== 'production') {\n logger.log(`Newer response found (and cached) for:`, url);\n }\n\n const sendUpdate = async () => {\n // In the case of a navigation request, the requesting page will likely\n // not have loaded its JavaScript in time to recevied the update\n // notification, so we defer it until ready (or we timeout waiting).\n if (event && event.request && event.request.mode === 'navigate') {\n if (process.env.NODE_ENV !== 'production') {\n logger.debug(`Original request was a navigation request, ` +\n `waiting for a ready message from the window`, event.request);\n }\n await this._windowReadyOrTimeout(event);\n }\n await broadcastUpdate({channel: this._getChannel(), cacheName, url});\n };\n\n // Send the update and ensure the SW stays alive until it's sent.\n const done = sendUpdate();\n\n if (event) {\n try {\n event.waitUntil(done);\n } catch (error) {\n if (process.env.NODE_ENV !== 'production') {\n logger.warn(`Unable to ensure service worker stays alive ` +\n `when broadcasting cache update for ` +\n `${getFriendlyURL(event.request.url)}'.`);\n }\n }\n }\n return done;\n }\n }\n\n /**\n * @return {BroadcastChannel|undefined} The BroadcastChannel instance used for\n * broadcasting updates, or undefined if the browser doesn't support the\n * Broadcast Channel API.\n *\n * @private\n */\n _getChannel() {\n if (('BroadcastChannel' in self) && !this._channel) {\n this._channel = new BroadcastChannel(this._channelName);\n }\n return this._channel;\n }\n\n /**\n * Waits for a message from the window indicating that it's capable of\n * receiving broadcasts. By default, this will only wait for the amount of\n * time specified via the `deferNoticationTimeout` option.\n *\n * @param {Event} event The navigation fetch event.\n * @return {Promise}\n * @private\n */\n _windowReadyOrTimeout(event) {\n if (!this._navigationEventsDeferreds.has(event)) {\n const deferred = new Deferred();\n\n // Set the deferred on the `_navigationEventsDeferreds` map so it will\n // be resolved when the next ready message event comes.\n this._navigationEventsDeferreds.set(event, deferred);\n\n // But don't wait too long for the message since it may never come.\n const timeout = setTimeout(() => {\n if (process.env.NODE_ENV !== 'production') {\n logger.debug(`Timed out after ${this._deferNoticationTimeout}` +\n `ms waiting for message from window`);\n }\n deferred.resolve();\n }, this._deferNoticationTimeout);\n\n // Ensure the timeout is cleared if the deferred promise is resolved.\n deferred.promise.then(() => clearTimeout(timeout));\n }\n return this._navigationEventsDeferreds.get(event).promise;\n }\n\n /**\n * Creates a mapping between navigation fetch events and deferreds, and adds\n * a listener for message events from the window. When message events arrive,\n * all deferreds in the mapping are resolved.\n *\n * Note: it would be easier if we could only resolve the deferred of\n * navigation fetch event whose client ID matched the source ID of the\n * message event, but currently client IDs are not exposed on navigation\n * fetch events: https://www.chromestatus.com/feature/4846038800138240\n */\n _initWindowReadyDeferreds() {\n // A mapping between navigation events and their deferreds.\n this._navigationEventsDeferreds = new Map();\n\n // The message listener needs to be added in the initial run of the\n // service worker, but since we don't actually need to be listening for\n // messages until the cache updates, we only invoke the callback if set.\n self.addEventListener('message', (event) => {\n if (event.data.type === 'WINDOW_READY' &&\n event.data.meta === 'workbox-window' &&\n this._navigationEventsDeferreds.size > 0) {\n if (process.env.NODE_ENV !== 'production') {\n logger.debug(`Received WINDOW_READY event: `, event);\n }\n // Resolve any pending deferreds.\n for (const deferred of this._navigationEventsDeferreds.values()) {\n deferred.resolve();\n }\n this._navigationEventsDeferreds.clear();\n }\n });\n }\n}\n\nexport {BroadcastCacheUpdate};\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {assert} from 'workbox-core/_private/assert.mjs';\nimport {BroadcastCacheUpdate} from './BroadcastCacheUpdate.mjs';\nimport './_version.mjs';\n\n/**\n * This plugin will automatically broadcast a message whenever a cached response\n * is updated.\n *\n * @memberof workbox.broadcastUpdate\n */\nclass Plugin {\n /**\n * Construct a BroadcastCacheUpdate instance with the passed options and\n * calls its `notifyIfUpdated()` method whenever the plugin's\n * `cacheDidUpdate` callback is invoked.\n *\n * @param {Object} options\n * @param {Array<string>}\n * [options.headersToCheck=['content-length', 'etag', 'last-modified']]\n * A list of headers that will be used to determine whether the responses\n * differ.\n * @param {string} [options.channelName='workbox'] The name that will be used\n *. when creating the `BroadcastChannel`, which defaults to 'workbox' (the\n * channel name used by the `workbox-window` package).\n * @param {string} [options.deferNoticationTimeout=10000] The amount of time\n * to wait for a ready message from the window on navigation requests\n * before sending the update.\n */\n constructor(options) {\n this._broadcastUpdate = new BroadcastCacheUpdate(options);\n }\n\n /**\n * A \"lifecycle\" callback that will be triggered automatically by the\n * `workbox-sw` and `workbox-runtime-caching` handlers when an entry is\n * added to a cache.\n *\n * @private\n * @param {Object} options The input object to this function.\n * @param {string} options.cacheName Name of the cache being updated.\n * @param {Response} [options.oldResponse] The previous cached value, if any.\n * @param {Response} options.newResponse The new value in the cache.\n * @param {Request} options.request The request that triggered the udpate.\n * @param {Request} [options.event] The event that triggered the update.\n */\n cacheDidUpdate({cacheName, oldResponse, newResponse, request, event}) {\n if (process.env.NODE_ENV !== 'production') {\n assert.isType(cacheName, 'string', {\n moduleName: 'workbox-broadcast-update',\n className: 'Plugin',\n funcName: 'cacheDidUpdate',\n paramName: 'cacheName',\n });\n assert.isInstance(newResponse, Response, {\n moduleName: 'workbox-broadcast-update',\n className: 'Plugin',\n funcName: 'cacheDidUpdate',\n paramName: 'newResponse',\n });\n assert.isInstance(request, Request, {\n moduleName: 'workbox-broadcast-update',\n className: 'Plugin',\n funcName: 'cacheDidUpdate',\n paramName: 'request',\n });\n }\n\n if (!oldResponse) {\n // Without a two responses there is nothing to compare.\n return;\n }\n this._broadcastUpdate.notifyIfUpdated({\n cacheName,\n oldResponse,\n newResponse,\n event,\n url: request.url,\n });\n }\n}\n\nexport {Plugin};\n"],"names":["self","_","e","responsesAreSame","firstResponse","secondResponse","headersToCheck","some","header","headers","has","every","headerStateComparison","headerValueComparison","get","DEFAULT_BROADCAST_CHANNEL_NAME","DEFAULT_DEFER_NOTIFICATION_TIMEOUT","DEFAULT_HEADERS_TO_CHECK","broadcastUpdate","async","channel","cacheName","url","data","type","meta","payload","updatedURL","postMessage","windows","clients","matchAll","win","BroadcastCacheUpdate","constructor","channelName","deferNoticationTimeout","_headersToCheck","_channelName","_deferNoticationTimeout","_initWindowReadyDeferreds","notifyIfUpdated","oldResponse","newResponse","event","this","done","request","mode","_windowReadyOrTimeout","_getChannel","sendUpdate","waitUntil","error","_channel","BroadcastChannel","_navigationEventsDeferreds","deferred","Deferred","set","timeout","setTimeout","resolve","promise","then","clearTimeout","Map","addEventListener","size","values","clear","options","_broadcastUpdate","cacheDidUpdate"],"mappings":"sFAAA,IAAIA,KAAK,mCAAmCC,IAAI,MAAMC,UCwBhDC,EAAmB,CAACC,EAAeC,EAAgBC,YAQrBA,EAAeC,KAAMC,GAC9CJ,EAAcK,QAAQC,IAAIF,IAC/BH,EAAeI,QAAQC,IAAIF,KAgBxBF,EAAeK,MAAOH,UACrBI,EAAwBR,EAAcK,QAAQC,IAAIF,KACtDH,EAAeI,QAAQC,IAAIF,GACvBK,EAAwBT,EAAcK,QAAQK,IAAIN,KACtDH,EAAeI,QAAQK,IAAIN,UAEtBI,GAAyBC,KC5CvBE,EAAiC,UACjCC,EAAqC,IACrCC,EAA2B,CACtC,iBACA,OACA,iBCmCIC,EAAkBC,OAAQC,QAAAA,EAASC,UAAAA,EAAWC,IAAAA,YAgB5CC,EAAO,CACXC,KD3DsC,gBC4DtCC,KD3DsC,2BC4DtCC,QAAS,CACPL,UAAWA,EACXM,WAAYL,OAIZF,EACFA,EAAQQ,YAAYL,OACf,OACCM,QAAgBC,QAAQC,SAAS,CAACP,KAAM,eACzC,MAAMQ,KAAOH,EAChBG,EAAIJ,YAAYL,KCnDtB,MAAMU,EAiBJC,aAAY5B,eAACA,EAAD6B,YAAiBA,EAAjBC,uBAA8BA,GAA0B,SAC7DC,EAAkB/B,GAAkBW,OACpCqB,EAAeH,GAAepB,OAC9BwB,EACDH,GAA0BpB,OAiBzBwB,IAqBPC,iBAAgBC,YAACA,EAADC,YAAcA,EAAdrB,IAA2BA,EAA3BD,UAAgCA,EAAhCuB,MAA2CA,QACpDzC,EAAiBuC,EAAaC,EAAaE,KAAKR,GAAkB,OAoB/DS,EAfa3B,WAIbyB,GAASA,EAAMG,SAAkC,aAAvBH,EAAMG,QAAQC,YAKpCH,KAAKI,EAAsBL,SAE7B1B,EAAgB,CAACE,QAASyB,KAAKK,IAAe7B,UAAAA,EAAWC,IAAAA,KAIpD6B,MAETP,MAEAA,EAAMQ,UAAUN,GAChB,MAAOO,WAQJP,GAWXI,UACO,qBAAsBlD,OAAU6C,KAAKS,SACnCA,EAAW,IAAIC,iBAAiBV,KAAKP,IAErCO,KAAKS,EAYdL,EAAsBL,OACfC,KAAKW,EAA2B9C,IAAIkC,GAAQ,OACzCa,EAAW,IAAIC,gBAIhBF,EAA2BG,IAAIf,EAAOa,SAGrCG,EAAUC,WAAW,KAKzBJ,EAASK,WACRjB,KAAKN,GAGRkB,EAASM,QAAQC,KAAK,IAAMC,aAAaL,WAEpCf,KAAKW,EAA2B1C,IAAI8B,GAAOmB,QAapDvB,SAEOgB,EAA6B,IAAIU,IAKtClE,KAAKmE,iBAAiB,UAAYvB,OACR,iBAApBA,EAAMrB,KAAKC,MACS,mBAApBoB,EAAMrB,KAAKE,MACXoB,KAAKW,EAA2BY,KAAO,EAAG,KAKvC,MAAMX,KAAYZ,KAAKW,EAA2Ba,SACrDZ,EAASK,eAENN,EAA2Bc,qDCxLxC,MAkBEpC,YAAYqC,QACLC,EAAmB,IAAIvC,EAAqBsC,GAgBnDE,gBAAepD,UAACA,EAADqB,YAAYA,EAAZC,YAAyBA,EAAzBI,QAAsCA,EAAtCH,MAA+CA,IAsBvDF,QAIA8B,EAAiB/B,gBAAgB,CACpCpB,UAAAA,EACAqB,YAAAA,EACAC,YAAAA,EACAC,MAAAA,EACAtB,IAAKyB,EAAQzB"}

data/lib/vendor/{workbox-v3.6.3 → workbox-v4.1.1}/workbox-cacheable-response.dev.js RENAMED Viewed

@@ -1,27 +1,18 @@
 this.workbox = this.workbox || {};
-this.workbox.cacheableResponse = (function (exports,WorkboxError_mjs,assert_mjs,getFriendlyURL_mjs,logger_mjs) {
+this.workbox.cacheableResponse = (function (exports, WorkboxError_mjs, assert_mjs, getFriendlyURL_mjs, logger_mjs) {
   'use strict';
   try {
-    self.workbox.v['workbox:cacheable-response:3.6.3'] = 1;
+    self['workbox:cacheable-response:4.1.1'] && _();
   } catch (e) {} // eslint-disable-line
   /*
-    Copyright 2017 Google Inc.
+    Copyright 2018 Google LLC
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-        https://www.apache.org/licenses/LICENSE-2.0
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
   */
   /**
    * This class allows you to set up rules determining what
    * status codes and/or headers need to be present in order for a
@@ -30,6 +21,7 @@ this.workbox.cacheableResponse = (function (exports,WorkboxError_mjs,assert_mjs,
    *
    * @memberof workbox.cacheableResponse
    */
   class CacheableResponse {
     /**
      * To construct a new CacheableResponse instance you must provide at least
@@ -77,7 +69,6 @@ this.workbox.cacheableResponse = (function (exports,WorkboxError_mjs,assert_mjs,
       this._statuses = config.statuses;
       this._headers = config.headers;
     }
     /**
      * Checks a response to see whether it's cacheable or not, based on this
      * object's configuration.
@@ -87,6 +78,8 @@ this.workbox.cacheableResponse = (function (exports,WorkboxError_mjs,assert_mjs,
      * @return {boolean} `true` if the `Response` is cacheable, and `false`
      * otherwise.
      */
     isResponseCacheable(response) {
       {
         assert_mjs.assert.isInstance(response, Response, {
@@ -112,48 +105,38 @@ this.workbox.cacheableResponse = (function (exports,WorkboxError_mjs,assert_mjs,
       {
         if (!cacheable) {
           logger_mjs.logger.groupCollapsed(`The request for ` + `'${getFriendlyURL_mjs.getFriendlyURL(response.url)}' returned a response that does ` + `not meet the criteria for being cached.`);
           logger_mjs.logger.groupCollapsed(`View cacheability criteria here.`);
-          logger_mjs.logger.unprefixed.log(`Cacheable statuses: ` + JSON.stringify(this._statuses));
-          logger_mjs.logger.unprefixed.log(`Cacheable headers: ` + JSON.stringify(this._headers, null, 2));
+          logger_mjs.logger.log(`Cacheable statuses: ` + JSON.stringify(this._statuses));
+          logger_mjs.logger.log(`Cacheable headers: ` + JSON.stringify(this._headers, null, 2));
           logger_mjs.logger.groupEnd();
           const logFriendlyHeaders = {};
           response.headers.forEach((value, key) => {
             logFriendlyHeaders[key] = value;
           });
           logger_mjs.logger.groupCollapsed(`View response status and headers here.`);
-          logger_mjs.logger.unprefixed.log(`Response status: ` + response.status);
-          logger_mjs.logger.unprefixed.log(`Response headers: ` + JSON.stringify(logFriendlyHeaders, null, 2));
+          logger_mjs.logger.log(`Response status: ` + response.status);
+          logger_mjs.logger.log(`Response headers: ` + JSON.stringify(logFriendlyHeaders, null, 2));
           logger_mjs.logger.groupEnd();
           logger_mjs.logger.groupCollapsed(`View full response details here.`);
-          logger_mjs.logger.unprefixed.log(response.headers);
-          logger_mjs.logger.unprefixed.log(response);
+          logger_mjs.logger.log(response.headers);
+          logger_mjs.logger.log(response);
           logger_mjs.logger.groupEnd();
           logger_mjs.logger.groupEnd();
         }
       }
       return cacheable;
     }
   }
   /*
-   Copyright 2016 Google Inc. All Rights Reserved.
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-       http://www.apache.org/licenses/LICENSE-2.0
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-  */
+    Copyright 2018 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
   /**
    * A class implementing the `cacheWillUpdate` lifecycle callback. This makes it
    * easier to add in cacheability checks to requests made via Workbox's built-in
@@ -161,6 +144,7 @@ this.workbox.cacheableResponse = (function (exports,WorkboxError_mjs,assert_mjs,
    *
    * @memberof workbox.cacheableResponse
    */
   class Plugin {
     /**
      * To construct a new cacheable response Plugin instance you must provide at
@@ -179,51 +163,32 @@ this.workbox.cacheableResponse = (function (exports,WorkboxError_mjs,assert_mjs,
     constructor(config) {
       this._cacheableResponse = new CacheableResponse(config);
     }
     /**
      * @param {Object} options
      * @param {Response} options.response
      * @return {boolean}
      * @private
      */
-    cacheWillUpdate({ response }) {
+    cacheWillUpdate({
+      response
+    }) {
       if (this._cacheableResponse.isResponseCacheable(response)) {
         return response;
       }
       return null;
     }
-  }
-  /*
-    Copyright 2017 Google Inc.
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-        https://www.apache.org/licenses/LICENSE-2.0
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-  */
+  }
   /*
-    Copyright 2017 Google Inc.
+    Copyright 2018 Google LLC
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-        https://www.apache.org/licenses/LICENSE-2.0
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
   */
   exports.CacheableResponse = CacheableResponse;
@@ -231,6 +196,5 @@ this.workbox.cacheableResponse = (function (exports,WorkboxError_mjs,assert_mjs,
   return exports;
-}({},workbox.core._private,workbox.core._private,workbox.core._private,workbox.core._private));
+}({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private));
 //# sourceMappingURL=workbox-cacheable-response.dev.js.map

data/lib/vendor/workbox-v4.1.1/workbox-cacheable-response.dev.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"workbox-cacheable-response.dev.js","sources":["../_version.mjs","../CacheableResponse.mjs","../Plugin.mjs","../index.mjs"],"sourcesContent":["try{self['workbox:cacheable-response:4.1.1']&&_()}catch(e){}// eslint-disable-line","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';\nimport {assert} from 'workbox-core/_private/assert.mjs';\nimport {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.mjs';\nimport {logger} from 'workbox-core/_private/logger.mjs';\nimport './_version.mjs';\n\n/**\n * This class allows you to set up rules determining what\n * status codes and/or headers need to be present in order for a\n * [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)\n * to be considered cacheable.\n *\n * @memberof workbox.cacheableResponse\n */\nclass CacheableResponse {\n /**\n * To construct a new CacheableResponse instance you must provide at least\n * one of the `config` properties.\n *\n * If both `statuses` and `headers` are specified, then both conditions must\n * be met for the `Response` to be considered cacheable.\n *\n * @param {Object} config\n * @param {Array<number>} [config.statuses] One or more status codes that a\n * `Response` can have and be considered cacheable.\n * @param {Object<string,string>} [config.headers] A mapping of header names\n * and expected values that a `Response` can have and be considered cacheable.\n * If multiple headers are provided, only one needs to be present.\n */\n constructor(config = {}) {\n if (process.env.NODE_ENV !== 'production') {\n if (!(config.statuses || config.headers)) {\n throw new WorkboxError('statuses-or-headers-required', {\n moduleName: 'workbox-cacheable-response',\n className: 'CacheableResponse',\n funcName: 'constructor',\n });\n }\n\n if (config.statuses) {\n assert.isArray(config.statuses, {\n moduleName: 'workbox-cacheable-response',\n className: 'CacheableResponse',\n funcName: 'constructor',\n paramName: 'config.statuses',\n });\n }\n\n if (config.headers) {\n assert.isType(config.headers, 'object', {\n moduleName: 'workbox-cacheable-response',\n className: 'CacheableResponse',\n funcName: 'constructor',\n paramName: 'config.headers',\n });\n }\n }\n\n this._statuses = config.statuses;\n this._headers = config.headers;\n }\n\n /**\n * Checks a response to see whether it's cacheable or not, based on this\n * object's configuration.\n *\n * @param {Response} response The response whose cacheability is being\n * checked.\n * @return {boolean} `true` if the `Response` is cacheable, and `false`\n * otherwise.\n */\n isResponseCacheable(response) {\n if (process.env.NODE_ENV !== 'production') {\n assert.isInstance(response, Response, {\n moduleName: 'workbox-cacheable-response',\n className: 'CacheableResponse',\n funcName: 'isResponseCacheable',\n paramName: 'response',\n });\n }\n\n let cacheable = true;\n\n if (this._statuses) {\n cacheable = this._statuses.includes(response.status);\n }\n\n if (this._headers && cacheable) {\n cacheable = Object.keys(this._headers).some((headerName) => {\n return response.headers.get(headerName) === this._headers[headerName];\n });\n }\n\n if (process.env.NODE_ENV !== 'production') {\n if (!cacheable) {\n logger.groupCollapsed(`The request for ` +\n `'${getFriendlyURL(response.url)}' returned a response that does ` +\n `not meet the criteria for being cached.`);\n\n logger.groupCollapsed(`View cacheability criteria here.`);\n logger.log(`Cacheable statuses: ` +\n JSON.stringify(this._statuses));\n logger.log(`Cacheable headers: ` +\n JSON.stringify(this._headers, null, 2));\n logger.groupEnd();\n\n const logFriendlyHeaders = {};\n response.headers.forEach((value, key) => {\n logFriendlyHeaders[key] = value;\n });\n\n logger.groupCollapsed(`View response status and headers here.`);\n logger.log(`Response status: ` + response.status);\n logger.log(`Response headers: ` +\n JSON.stringify(logFriendlyHeaders, null, 2));\n logger.groupEnd();\n\n logger.groupCollapsed(`View full response details here.`);\n logger.log(response.headers);\n logger.log(response);\n logger.groupEnd();\n\n logger.groupEnd();\n }\n }\n\n return cacheable;\n }\n}\n\nexport {CacheableResponse};\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {CacheableResponse} from './CacheableResponse.mjs';\nimport './_version.mjs';\n\n/**\n * A class implementing the `cacheWillUpdate` lifecycle callback. This makes it\n * easier to add in cacheability checks to requests made via Workbox's built-in\n * strategies.\n *\n * @memberof workbox.cacheableResponse\n */\nclass Plugin {\n /**\n * To construct a new cacheable response Plugin instance you must provide at\n * least one of the `config` properties.\n *\n * If both `statuses` and `headers` are specified, then both conditions must\n * be met for the `Response` to be considered cacheable.\n *\n * @param {Object} config\n * @param {Array<number>} [config.statuses] One or more status codes that a\n * `Response` can have and be considered cacheable.\n * @param {Object<string,string>} [config.headers] A mapping of header names\n * and expected values that a `Response` can have and be considered cacheable.\n * If multiple headers are provided, only one needs to be present.\n */\n constructor(config) {\n this._cacheableResponse = new CacheableResponse(config);\n }\n\n /**\n * @param {Object} options\n * @param {Response} options.response\n * @return {boolean}\n * @private\n */\n cacheWillUpdate({response}) {\n if (this._cacheableResponse.isResponseCacheable(response)) {\n return response;\n }\n return null;\n }\n}\n\nexport {Plugin};\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {CacheableResponse} from './CacheableResponse.mjs';\nimport {Plugin} from './Plugin.mjs';\nimport './_version.mjs';\n\n\n/**\n * @namespace workbox.cacheableResponse\n */\n\nexport {\n CacheableResponse,\n Plugin,\n};\n"],"names":["self","_","e","CacheableResponse","constructor","config","statuses","headers","WorkboxError","moduleName","className","funcName","assert","isArray","paramName","isType","_statuses","_headers","isResponseCacheable","response","isInstance","Response","cacheable","includes","status","Object","keys","some","headerName","get","logger","groupCollapsed","getFriendlyURL","url","log","JSON","stringify","groupEnd","logFriendlyHeaders","forEach","value","key","Plugin","_cacheableResponse","cacheWillUpdate"],"mappings":"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"}

data/lib/vendor/workbox-v4.1.1/workbox-cacheable-response.prod.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ this.workbox=this.workbox\|\|{},this.workbox.cacheableResponse=function(t){"use strict";try{self["workbox:cacheable-response:4.1.1"]&&_()}catch(t){}class s{constructor(t={}){this.t=t.statuses,this.s=t.headers}isResponseCacheable(t){let s=!0;return this.t&&(s=this.t.includes(t.status)),this.s&&s&&(s=Object.keys(this.s).some(s=>t.headers.get(s)===this.s[s])),s}}return t.CacheableResponse=s,t.Plugin=class{constructor(t){this.i=new s(t)}cacheWillUpdate({response:t}){return this.i.isResponseCacheable(t)?t:null}},t}({});
2	+ //# sourceMappingURL=workbox-cacheable-response.prod.js.map

data/lib/vendor/workbox-v4.1.1/workbox-cacheable-response.prod.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"workbox-cacheable-response.prod.js","sources":["../_version.mjs","../CacheableResponse.mjs","../Plugin.mjs"],"sourcesContent":["try{self['workbox:cacheable-response:4.1.1']&&_()}catch(e){}// eslint-disable-line","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';\nimport {assert} from 'workbox-core/_private/assert.mjs';\nimport {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.mjs';\nimport {logger} from 'workbox-core/_private/logger.mjs';\nimport './_version.mjs';\n\n/**\n * This class allows you to set up rules determining what\n * status codes and/or headers need to be present in order for a\n * [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)\n * to be considered cacheable.\n *\n * @memberof workbox.cacheableResponse\n */\nclass CacheableResponse {\n /**\n * To construct a new CacheableResponse instance you must provide at least\n * one of the `config` properties.\n *\n * If both `statuses` and `headers` are specified, then both conditions must\n * be met for the `Response` to be considered cacheable.\n *\n * @param {Object} config\n * @param {Array<number>} [config.statuses] One or more status codes that a\n * `Response` can have and be considered cacheable.\n * @param {Object<string,string>} [config.headers] A mapping of header names\n * and expected values that a `Response` can have and be considered cacheable.\n * If multiple headers are provided, only one needs to be present.\n */\n constructor(config = {}) {\n if (process.env.NODE_ENV !== 'production') {\n if (!(config.statuses || config.headers)) {\n throw new WorkboxError('statuses-or-headers-required', {\n moduleName: 'workbox-cacheable-response',\n className: 'CacheableResponse',\n funcName: 'constructor',\n });\n }\n\n if (config.statuses) {\n assert.isArray(config.statuses, {\n moduleName: 'workbox-cacheable-response',\n className: 'CacheableResponse',\n funcName: 'constructor',\n paramName: 'config.statuses',\n });\n }\n\n if (config.headers) {\n assert.isType(config.headers, 'object', {\n moduleName: 'workbox-cacheable-response',\n className: 'CacheableResponse',\n funcName: 'constructor',\n paramName: 'config.headers',\n });\n }\n }\n\n this._statuses = config.statuses;\n this._headers = config.headers;\n }\n\n /**\n * Checks a response to see whether it's cacheable or not, based on this\n * object's configuration.\n *\n * @param {Response} response The response whose cacheability is being\n * checked.\n * @return {boolean} `true` if the `Response` is cacheable, and `false`\n * otherwise.\n */\n isResponseCacheable(response) {\n if (process.env.NODE_ENV !== 'production') {\n assert.isInstance(response, Response, {\n moduleName: 'workbox-cacheable-response',\n className: 'CacheableResponse',\n funcName: 'isResponseCacheable',\n paramName: 'response',\n });\n }\n\n let cacheable = true;\n\n if (this._statuses) {\n cacheable = this._statuses.includes(response.status);\n }\n\n if (this._headers && cacheable) {\n cacheable = Object.keys(this._headers).some((headerName) => {\n return response.headers.get(headerName) === this._headers[headerName];\n });\n }\n\n if (process.env.NODE_ENV !== 'production') {\n if (!cacheable) {\n logger.groupCollapsed(`The request for ` +\n `'${getFriendlyURL(response.url)}' returned a response that does ` +\n `not meet the criteria for being cached.`);\n\n logger.groupCollapsed(`View cacheability criteria here.`);\n logger.log(`Cacheable statuses: ` +\n JSON.stringify(this._statuses));\n logger.log(`Cacheable headers: ` +\n JSON.stringify(this._headers, null, 2));\n logger.groupEnd();\n\n const logFriendlyHeaders = {};\n response.headers.forEach((value, key) => {\n logFriendlyHeaders[key] = value;\n });\n\n logger.groupCollapsed(`View response status and headers here.`);\n logger.log(`Response status: ` + response.status);\n logger.log(`Response headers: ` +\n JSON.stringify(logFriendlyHeaders, null, 2));\n logger.groupEnd();\n\n logger.groupCollapsed(`View full response details here.`);\n logger.log(response.headers);\n logger.log(response);\n logger.groupEnd();\n\n logger.groupEnd();\n }\n }\n\n return cacheable;\n }\n}\n\nexport {CacheableResponse};\n","/*\n Copyright 2018 Google LLC\n\n Use of this source code is governed by an MIT-style\n license that can be found in the LICENSE file or at\n https://opensource.org/licenses/MIT.\n*/\n\nimport {CacheableResponse} from './CacheableResponse.mjs';\nimport './_version.mjs';\n\n/**\n * A class implementing the `cacheWillUpdate` lifecycle callback. This makes it\n * easier to add in cacheability checks to requests made via Workbox's built-in\n * strategies.\n *\n * @memberof workbox.cacheableResponse\n */\nclass Plugin {\n /**\n * To construct a new cacheable response Plugin instance you must provide at\n * least one of the `config` properties.\n *\n * If both `statuses` and `headers` are specified, then both conditions must\n * be met for the `Response` to be considered cacheable.\n *\n * @param {Object} config\n * @param {Array<number>} [config.statuses] One or more status codes that a\n * `Response` can have and be considered cacheable.\n * @param {Object<string,string>} [config.headers] A mapping of header names\n * and expected values that a `Response` can have and be considered cacheable.\n * If multiple headers are provided, only one needs to be present.\n */\n constructor(config) {\n this._cacheableResponse = new CacheableResponse(config);\n }\n\n /**\n * @param {Object} options\n * @param {Response} options.response\n * @return {boolean}\n * @private\n */\n cacheWillUpdate({response}) {\n if (this._cacheableResponse.isResponseCacheable(response)) {\n return response;\n }\n return null;\n }\n}\n\nexport {Plugin};\n"],"names":["self","_","e","CacheableResponse","constructor","config","_statuses","statuses","_headers","headers","isResponseCacheable","response","cacheable","this","includes","status","Object","keys","some","headerName","get","_cacheableResponse","cacheWillUpdate"],"mappings":"sFAAA,IAAIA,KAAK,qCAAqCC,IAAI,MAAMC,ICsBxD,MAAMC,EAeJC,YAAYC,EAAS,SA6BdC,EAAYD,EAAOE,cACnBC,EAAWH,EAAOI,QAYzBC,oBAAoBC,OAUdC,GAAY,SAEZC,KAAKP,IACPM,EAAYC,KAAKP,EAAUQ,SAASH,EAASI,SAG3CF,KAAKL,GAAYI,IACnBA,EAAYI,OAAOC,KAAKJ,KAAKL,GAAUU,KAAMC,GACpCR,EAASF,QAAQW,IAAID,KAAgBN,KAAKL,EAASW,KAqCvDP,yCCpHX,MAeER,YAAYC,QACLgB,EAAqB,IAAIlB,EAAkBE,GASlDiB,iBAAgBX,SAACA,WACXE,KAAKQ,EAAmBX,oBAAoBC,GACvCA,EAEF"}

data/lib/vendor/workbox-v4.1.1/workbox-core.dev.js ADDED Viewed

@@ -0,0 +1,1584 @@
+this.workbox = this.workbox || {};
+this.workbox.core = (function (exports) {
+  'use strict';
+  try {
+    self['workbox:core:4.1.1'] && _();
+  } catch (e) {} // eslint-disable-line
+  /*
+    Copyright 2019 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  const logger = (() => {
+    let inGroup = false;
+    const methodToColorMap = {
+      debug: `#7f8c8d`,
+      // Gray
+      log: `#2ecc71`,
+      // Green
+      warn: `#f39c12`,
+      // Yellow
+      error: `#c0392b`,
+      // Red
+      groupCollapsed: `#3498db`,
+      // Blue
+      groupEnd: null // No colored prefix on groupEnd
+    };
+    const print = function (method, args) {
+      if (method === 'groupCollapsed') {
+        // Safari doesn't print all console.groupCollapsed() arguments:
+        // https://bugs.webkit.org/show_bug.cgi?id=182754
+        if (/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
+          console[method](...args);
+          return;
+        }
+      }
+      const styles = [`background: ${methodToColorMap[method]}`, `border-radius: 0.5em`, `color: white`, `font-weight: bold`, `padding: 2px 0.5em`]; // When in a group, the workbox prefix is not displayed.
+      const logPrefix = inGroup ? [] : ['%cworkbox', styles.join(';')];
+      console[method](...logPrefix, ...args);
+      if (method === 'groupCollapsed') {
+        inGroup = true;
+      }
+      if (method === 'groupEnd') {
+        inGroup = false;
+      }
+    };
+    const api = {};
+    for (const method of Object.keys(methodToColorMap)) {
+      api[method] = (...args) => {
+        print(method, args);
+      };
+    }
+    return api;
+  })();
+  /*
+    Copyright 2018 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  const messages = {
+    'invalid-value': ({
+      paramName,
+      validValueDescription,
+      value
+    }) => {
+      if (!paramName || !validValueDescription) {
+        throw new Error(`Unexpected input to 'invalid-value' error.`);
+      }
+      return `The '${paramName}' parameter was given a value with an ` + `unexpected value. ${validValueDescription} Received a value of ` + `${JSON.stringify(value)}.`;
+    },
+    'not-in-sw': ({
+      moduleName
+    }) => {
+      if (!moduleName) {
+        throw new Error(`Unexpected input to 'not-in-sw' error.`);
+      }
+      return `The '${moduleName}' must be used in a service worker.`;
+    },
+    'not-an-array': ({
+      moduleName,
+      className,
+      funcName,
+      paramName
+    }) => {
+      if (!moduleName || !className || !funcName || !paramName) {
+        throw new Error(`Unexpected input to 'not-an-array' error.`);
+      }
+      return `The parameter '${paramName}' passed into ` + `'${moduleName}.${className}.${funcName}()' must be an array.`;
+    },
+    'incorrect-type': ({
+      expectedType,
+      paramName,
+      moduleName,
+      className,
+      funcName
+    }) => {
+      if (!expectedType || !paramName || !moduleName || !funcName) {
+        throw new Error(`Unexpected input to 'incorrect-type' error.`);
+      }
+      return `The parameter '${paramName}' passed into ` + `'${moduleName}.${className ? className + '.' : ''}` + `${funcName}()' must be of type ${expectedType}.`;
+    },
+    'incorrect-class': ({
+      expectedClass,
+      paramName,
+      moduleName,
+      className,
+      funcName,
+      isReturnValueProblem
+    }) => {
+      if (!expectedClass || !moduleName || !funcName) {
+        throw new Error(`Unexpected input to 'incorrect-class' error.`);
+      }
+      if (isReturnValueProblem) {
+        return `The return value from ` + `'${moduleName}.${className ? className + '.' : ''}${funcName}()' ` + `must be an instance of class ${expectedClass.name}.`;
+      }
+      return `The parameter '${paramName}' passed into ` + `'${moduleName}.${className ? className + '.' : ''}${funcName}()' ` + `must be an instance of class ${expectedClass.name}.`;
+    },
+    'missing-a-method': ({
+      expectedMethod,
+      paramName,
+      moduleName,
+      className,
+      funcName
+    }) => {
+      if (!expectedMethod || !paramName || !moduleName || !className || !funcName) {
+        throw new Error(`Unexpected input to 'missing-a-method' error.`);
+      }
+      return `${moduleName}.${className}.${funcName}() expected the ` + `'${paramName}' parameter to expose a '${expectedMethod}' method.`;
+    },
+    'add-to-cache-list-unexpected-type': ({
+      entry
+    }) => {
+      return `An unexpected entry was passed to ` + `'workbox-precaching.PrecacheController.addToCacheList()' The entry ` + `'${JSON.stringify(entry)}' isn't supported. You must supply an array of ` + `strings with one or more characters, objects with a url property or ` + `Request objects.`;
+    },
+    'add-to-cache-list-conflicting-entries': ({
+      firstEntry,
+      secondEntry
+    }) => {
+      if (!firstEntry || !secondEntry) {
+        throw new Error(`Unexpected input to ` + `'add-to-cache-list-duplicate-entries' error.`);
+      }
+      return `Two of the entries passed to ` + `'workbox-precaching.PrecacheController.addToCacheList()' had the URL ` + `${firstEntry._entryId} but different revision details. Workbox is ` + `is unable to cache and version the asset correctly. Please remove one ` + `of the entries.`;
+    },
+    'plugin-error-request-will-fetch': ({
+      thrownError
+    }) => {
+      if (!thrownError) {
+        throw new Error(`Unexpected input to ` + `'plugin-error-request-will-fetch', error.`);
+      }
+      return `An error was thrown by a plugins 'requestWillFetch()' method. ` + `The thrown error message was: '${thrownError.message}'.`;
+    },
+    'invalid-cache-name': ({
+      cacheNameId,
+      value
+    }) => {
+      if (!cacheNameId) {
+        throw new Error(`Expected a 'cacheNameId' for error 'invalid-cache-name'`);
+      }
+      return `You must provide a name containing at least one character for ` + `setCacheDeatils({${cacheNameId}: '...'}). Received a value of ` + `'${JSON.stringify(value)}'`;
+    },
+    'unregister-route-but-not-found-with-method': ({
+      method
+    }) => {
+      if (!method) {
+        throw new Error(`Unexpected input to ` + `'unregister-route-but-not-found-with-method' error.`);
+      }
+      return `The route you're trying to unregister was not  previously ` + `registered for the method type '${method}'.`;
+    },
+    'unregister-route-route-not-registered': () => {
+      return `The route you're trying to unregister was not previously ` + `registered.`;
+    },
+    'queue-replay-failed': ({
+      name
+    }) => {
+      return `Replaying the background sync queue '${name}' failed.`;
+    },
+    'duplicate-queue-name': ({
+      name
+    }) => {
+      return `The Queue name '${name}' is already being used. ` + `All instances of backgroundSync.Queue must be given unique names.`;
+    },
+    'expired-test-without-max-age': ({
+      methodName,
+      paramName
+    }) => {
+      return `The '${methodName}()' method can only be used when the ` + `'${paramName}' is used in the constructor.`;
+    },
+    'unsupported-route-type': ({
+      moduleName,
+      className,
+      funcName,
+      paramName
+    }) => {
+      return `The supplied '${paramName}' parameter was an unsupported type. ` + `Please check the docs for ${moduleName}.${className}.${funcName} for ` + `valid input types.`;
+    },
+    'not-array-of-class': ({
+      value,
+      expectedClass,
+      moduleName,
+      className,
+      funcName,
+      paramName
+    }) => {
+      return `The supplied '${paramName}' parameter must be an array of ` + `'${expectedClass}' objects. Received '${JSON.stringify(value)},'. ` + `Please check the call to ${moduleName}.${className}.${funcName}() ` + `to fix the issue.`;
+    },
+    'max-entries-or-age-required': ({
+      moduleName,
+      className,
+      funcName
+    }) => {
+      return `You must define either config.maxEntries or config.maxAgeSeconds` + `in ${moduleName}.${className}.${funcName}`;
+    },
+    'statuses-or-headers-required': ({
+      moduleName,
+      className,
+      funcName
+    }) => {
+      return `You must define either config.statuses or config.headers` + `in ${moduleName}.${className}.${funcName}`;
+    },
+    'invalid-string': ({
+      moduleName,
+      className,
+      funcName,
+      paramName
+    }) => {
+      if (!paramName || !moduleName || !funcName) {
+        throw new Error(`Unexpected input to 'invalid-string' error.`);
+      }
+      return `When using strings, the '${paramName}' parameter must start with ` + `'http' (for cross-origin matches) or '/' (for same-origin matches). ` + `Please see the docs for ${moduleName}.${funcName}() for ` + `more info.`;
+    },
+    'channel-name-required': () => {
+      return `You must provide a channelName to construct a ` + `BroadcastCacheUpdate instance.`;
+    },
+    'invalid-responses-are-same-args': () => {
+      return `The arguments passed into responsesAreSame() appear to be ` + `invalid. Please ensure valid Responses are used.`;
+    },
+    'expire-custom-caches-only': () => {
+      return `You must provide a 'cacheName' property when using the ` + `expiration plugin with a runtime caching strategy.`;
+    },
+    'unit-must-be-bytes': ({
+      normalizedRangeHeader
+    }) => {
+      if (!normalizedRangeHeader) {
+        throw new Error(`Unexpected input to 'unit-must-be-bytes' error.`);
+      }
+      return `The 'unit' portion of the Range header must be set to 'bytes'. ` + `The Range header provided was "${normalizedRangeHeader}"`;
+    },
+    'single-range-only': ({
+      normalizedRangeHeader
+    }) => {
+      if (!normalizedRangeHeader) {
+        throw new Error(`Unexpected input to 'single-range-only' error.`);
+      }
+      return `Multiple ranges are not supported. Please use a  single start ` + `value, and optional end value. The Range header provided was ` + `"${normalizedRangeHeader}"`;
+    },
+    'invalid-range-values': ({
+      normalizedRangeHeader
+    }) => {
+      if (!normalizedRangeHeader) {
+        throw new Error(`Unexpected input to 'invalid-range-values' error.`);
+      }
+      return `The Range header is missing both start and end values. At least ` + `one of those values is needed. The Range header provided was ` + `"${normalizedRangeHeader}"`;
+    },
+    'no-range-header': () => {
+      return `No Range header was found in the Request provided.`;
+    },
+    'range-not-satisfiable': ({
+      size,
+      start,
+      end
+    }) => {
+      return `The start (${start}) and end (${end}) values in the Range are ` + `not satisfiable by the cached response, which is ${size} bytes.`;
+    },
+    'attempt-to-cache-non-get-request': ({
+      url,
+      method
+    }) => {
+      return `Unable to cache '${url}' because it is a '${method}' request and ` + `only 'GET' requests can be cached.`;
+    },
+    'cache-put-with-no-response': ({
+      url
+    }) => {
+      return `There was an attempt to cache '${url}' but the response was not ` + `defined.`;
+    },
+    'no-response': ({
+      url,
+      error
+    }) => {
+      let message = `The strategy could not generate a response for '${url}'.`;
+      if (error) {
+        message += ` The underlying error is ${error}.`;
+      }
+      return message;
+    },
+    'bad-precaching-response': ({
+      url,
+      status
+    }) => {
+      return `The precaching request for '${url}' failed with an HTTP ` + `status of ${status}.`;
+    }
+  };
+  /*
+    Copyright 2018 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  const generatorFunction = (code, ...args) => {
+    const message = messages[code];
+    if (!message) {
+      throw new Error(`Unable to find message for code '${code}'.`);
+    }
+    return message(...args);
+  };
+  const messageGenerator = generatorFunction;
+  /*
+    Copyright 2018 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  /**
+   * Workbox errors should be thrown with this class.
+   * This allows use to ensure the type easily in tests,
+   * helps developers identify errors from workbox
+   * easily and allows use to optimise error
+   * messages correctly.
+   *
+   * @private
+   */
+  class WorkboxError extends Error {
+    /**
+     *
+     * @param {string} errorCode The error code that
+     * identifies this particular error.
+     * @param {Object=} details Any relevant arguments
+     * that will help developers identify issues should
+     * be added as a key on the context object.
+     */
+    constructor(errorCode, details) {
+      let message = messageGenerator(errorCode, details);
+      super(message);
+      this.name = errorCode;
+      this.details = details;
+    }
+  }
+  /*
+    Copyright 2018 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  /*
+   * This method returns true if the current context is a service worker.
+   */
+  const isSWEnv = moduleName => {
+    if (!('ServiceWorkerGlobalScope' in self)) {
+      throw new WorkboxError('not-in-sw', {
+        moduleName
+      });
+    }
+  };
+  /*
+   * This method throws if the supplied value is not an array.
+   * The destructed values are required to produce a meaningful error for users.
+   * The destructed and restructured object is so it's clear what is
+   * needed.
+   */
+  const isArray = (value, {
+    moduleName,
+    className,
+    funcName,
+    paramName
+  }) => {
+    if (!Array.isArray(value)) {
+      throw new WorkboxError('not-an-array', {
+        moduleName,
+        className,
+        funcName,
+        paramName
+      });
+    }
+  };
+  const hasMethod = (object, expectedMethod, {
+    moduleName,
+    className,
+    funcName,
+    paramName
+  }) => {
+    const type = typeof object[expectedMethod];
+    if (type !== 'function') {
+      throw new WorkboxError('missing-a-method', {
+        paramName,
+        expectedMethod,
+        moduleName,
+        className,
+        funcName
+      });
+    }
+  };
+  const isType = (object, expectedType, {
+    moduleName,
+    className,
+    funcName,
+    paramName
+  }) => {
+    if (typeof object !== expectedType) {
+      throw new WorkboxError('incorrect-type', {
+        paramName,
+        expectedType,
+        moduleName,
+        className,
+        funcName
+      });
+    }
+  };
+  const isInstance = (object, expectedClass, {
+    moduleName,
+    className,
+    funcName,
+    paramName,
+    isReturnValueProblem
+  }) => {
+    if (!(object instanceof expectedClass)) {
+      throw new WorkboxError('incorrect-class', {
+        paramName,
+        expectedClass,
+        moduleName,
+        className,
+        funcName,
+        isReturnValueProblem
+      });
+    }
+  };
+  const isOneOf = (value, validValues, {
+    paramName
+  }) => {
+    if (!validValues.includes(value)) {
+      throw new WorkboxError('invalid-value', {
+        paramName,
+        value,
+        validValueDescription: `Valid values are ${JSON.stringify(validValues)}.`
+      });
+    }
+  };
+  const isArrayOfClass = (value, expectedClass, {
+    moduleName,
+    className,
+    funcName,
+    paramName
+  }) => {
+    const error = new WorkboxError('not-array-of-class', {
+      value,
+      expectedClass,
+      moduleName,
+      className,
+      funcName,
+      paramName
+    });
+    if (!Array.isArray(value)) {
+      throw error;
+    }
+    for (let item of value) {
+      if (!(item instanceof expectedClass)) {
+        throw error;
+      }
+    }
+  };
+  const finalAssertExports = {
+    hasMethod,
+    isArray,
+    isInstance,
+    isOneOf,
+    isSWEnv,
+    isType,
+    isArrayOfClass
+  };
+  /*
+    Copyright 2018 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  const callbacks = new Set();
+  /**
+   * Adds a function to the set of callbacks that will be executed when there's
+   * a quota error.
+   *
+   * @param {Function} callback
+   * @memberof workbox.core
+   */
+  function registerQuotaErrorCallback(callback) {
+    {
+      finalAssertExports.isType(callback, 'function', {
+        moduleName: 'workbox-core',
+        funcName: 'register',
+        paramName: 'callback'
+      });
+    }
+    callbacks.add(callback);
+    {
+      logger.log('Registered a callback to respond to quota errors.', callback);
+    }
+  }
+  /**
+   * Runs all of the callback functions, one at a time sequentially, in the order
+   * in which they were registered.
+   *
+   * @memberof workbox.core
+   * @private
+   */
+  async function executeQuotaErrorCallbacks() {
+    {
+      logger.log(`About to run ${callbacks.size} callbacks to clean up caches.`);
+    }
+    for (const callback of callbacks) {
+      await callback();
+      {
+        logger.log(callback, 'is complete.');
+      }
+    }
+    {
+      logger.log('Finished running callbacks.');
+    }
+  }
+  /*
+    Copyright 2019 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  /*
+    Copyright 2018 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  /**
+   * A class that wraps common IndexedDB functionality in a promise-based API.
+   * It exposes all the underlying power and functionality of IndexedDB, but
+   * wraps the most commonly used features in a way that's much simpler to use.
+   *
+   * @private
+   */
+  class DBWrapper {
+    /**
+     * @param {string} name
+     * @param {number} version
+     * @param {Object=} [callback]
+     * @param {!Function} [callbacks.onupgradeneeded]
+     * @param {!Function} [callbacks.onversionchange] Defaults to
+     *     DBWrapper.prototype._onversionchange when not specified.
+     */
+    constructor(name, version, {
+      onupgradeneeded,
+      onversionchange = this._onversionchange
+    } = {}) {
+      this._name = name;
+      this._version = version;
+      this._onupgradeneeded = onupgradeneeded;
+      this._onversionchange = onversionchange; // If this is null, it means the database isn't open.
+      this._db = null;
+    }
+    /**
+     * Returns the IDBDatabase instance (not normally needed).
+     */
+    get db() {
+      return this._db;
+    }
+    /**
+     * Opens a connected to an IDBDatabase, invokes any onupgradedneeded
+     * callback, and added an onversionchange callback to the database.
+     *
+     * @return {IDBDatabase}
+     */
+    async open() {
+      if (this._db) return;
+      this._db = await new Promise((resolve, reject) => {
+        // This flag is flipped to true if the timeout callback runs prior
+        // to the request failing or succeeding. Note: we use a timeout instead
+        // of an onblocked handler since there are cases where onblocked will
+        // never never run. A timeout better handles all possible scenarios:
+        // https://github.com/w3c/IndexedDB/issues/223
+        let openRequestTimedOut = false;
+        setTimeout(() => {
+          openRequestTimedOut = true;
+          reject(new Error('The open request was blocked and timed out'));
+        }, this.OPEN_TIMEOUT);
+        const openRequest = indexedDB.open(this._name, this._version);
+        openRequest.onerror = () => reject(openRequest.error);
+        openRequest.onupgradeneeded = evt => {
+          if (openRequestTimedOut) {
+            openRequest.transaction.abort();
+            evt.target.result.close();
+          } else if (this._onupgradeneeded) {
+            this._onupgradeneeded(evt);
+          }
+        };
+        openRequest.onsuccess = ({
+          target
+        }) => {
+          const db = target.result;
+          if (openRequestTimedOut) {
+            db.close();
+          } else {
+            db.onversionchange = this._onversionchange.bind(this);
+            resolve(db);
+          }
+        };
+      });
+      return this;
+    }
+    /**
+     * Polyfills the native `getKey()` method. Note, this is overridden at
+     * runtime if the browser supports the native method.
+     *
+     * @param {string} storeName
+     * @param {*} query
+     * @return {Array}
+     */
+    async getKey(storeName, query) {
+      return (await this.getAllKeys(storeName, query, 1))[0];
+    }
+    /**
+     * Polyfills the native `getAll()` method. Note, this is overridden at
+     * runtime if the browser supports the native method.
+     *
+     * @param {string} storeName
+     * @param {*} query
+     * @param {number} count
+     * @return {Array}
+     */
+    async getAll(storeName, query, count) {
+      return await this.getAllMatching(storeName, {
+        query,
+        count
+      });
+    }
+    /**
+     * Polyfills the native `getAllKeys()` method. Note, this is overridden at
+     * runtime if the browser supports the native method.
+     *
+     * @param {string} storeName
+     * @param {*} query
+     * @param {number} count
+     * @return {Array}
+     */
+    async getAllKeys(storeName, query, count) {
+      return (await this.getAllMatching(storeName, {
+        query,
+        count,
+        includeKeys: true
+      })).map(({
+        key
+      }) => key);
+    }
+    /**
+     * Supports flexible lookup in an object store by specifying an index,
+     * query, direction, and count. This method returns an array of objects
+     * with the signature .
+     *
+     * @param {string} storeName
+     * @param {Object} [opts]
+     * @param {string} [opts.index] The index to use (if specified).
+     * @param {*} [opts.query]
+     * @param {IDBCursorDirection} [opts.direction]
+     * @param {number} [opts.count] The max number of results to return.
+     * @param {boolean} [opts.includeKeys] When true, the structure of the
+     *     returned objects is changed from an array of values to an array of
+     *     objects in the form {key, primaryKey, value}.
+     * @return {Array}
+     */
+    async getAllMatching(storeName, {
+      index,
+      query = null,
+      // IE errors if query === `undefined`.
+      direction = 'next',
+      count,
+      includeKeys
+    } = {}) {
+      return await this.transaction([storeName], 'readonly', (txn, done) => {
+        const store = txn.objectStore(storeName);
+        const target = index ? store.index(index) : store;
+        const results = [];
+        target.openCursor(query, direction).onsuccess = ({
+          target
+        }) => {
+          const cursor = target.result;
+          if (cursor) {
+            const {
+              primaryKey,
+              key,
+              value
+            } = cursor;
+            results.push(includeKeys ? {
+              primaryKey,
+              key,
+              value
+            } : value);
+            if (count && results.length >= count) {
+              done(results);
+            } else {
+              cursor.continue();
+            }
+          } else {
+            done(results);
+          }
+        };
+      });
+    }
+    /**
+     * Accepts a list of stores, a transaction type, and a callback and
+     * performs a transaction. A promise is returned that resolves to whatever
+     * value the callback chooses. The callback holds all the transaction logic
+     * and is invoked with two arguments:
+     *   1. The IDBTransaction object
+     *   2. A `done` function, that's used to resolve the promise when
+     *      when the transaction is done, if passed a value, the promise is
+     *      resolved to that value.
+     *
+     * @param {Array<string>} storeNames An array of object store names
+     *     involved in the transaction.
+     * @param {string} type Can be `readonly` or `readwrite`.
+     * @param {!Function} callback
+     * @return {*} The result of the transaction ran by the callback.
+     */
+    async transaction(storeNames, type, callback) {
+      await this.open();
+      return await new Promise((resolve, reject) => {
+        const txn = this._db.transaction(storeNames, type);
+        txn.onabort = ({
+          target
+        }) => reject(target.error);
+        txn.oncomplete = () => resolve();
+        callback(txn, value => resolve(value));
+      });
+    }
+    /**
+     * Delegates async to a native IDBObjectStore method.
+     *
+     * @param {string} method The method name.
+     * @param {string} storeName The object store name.
+     * @param {string} type Can be `readonly` or `readwrite`.
+     * @param {...*} args The list of args to pass to the native method.
+     * @return {*} The result of the transaction.
+     */
+    async _call(method, storeName, type, ...args) {
+      const callback = (txn, done) => {
+        txn.objectStore(storeName)[method](...args).onsuccess = ({
+          target
+        }) => {
+          done(target.result);
+        };
+      };
+      return await this.transaction([storeName], type, callback);
+    }
+    /**
+     * The default onversionchange handler, which closes the database so other
+     * connections can open without being blocked.
+     */
+    _onversionchange() {
+      this.close();
+    }
+    /**
+     * Closes the connection opened by `DBWrapper.open()`. Generally this method
+     * doesn't need to be called since:
+     *   1. It's usually better to keep a connection open since opening
+     *      a new connection is somewhat slow.
+     *   2. Connections are automatically closed when the reference is
+     *      garbage collected.
+     * The primary use case for needing to close a connection is when another
+     * reference (typically in another tab) needs to upgrade it and would be
+     * blocked by the current, open connection.
+     */
+    close() {
+      if (this._db) {
+        this._db.close();
+        this._db = null;
+      }
+    }
+  } // Exposed to let users modify the default timeout on a per-instance
+  // or global basis.
+  DBWrapper.prototype.OPEN_TIMEOUT = 2000; // Wrap native IDBObjectStore methods according to their mode.
+  const methodsToWrap = {
+    'readonly': ['get', 'count', 'getKey', 'getAll', 'getAllKeys'],
+    'readwrite': ['add', 'put', 'clear', 'delete']
+  };
+  for (const [mode, methods] of Object.entries(methodsToWrap)) {
+    for (const method of methods) {
+      if (method in IDBObjectStore.prototype) {
+        // Don't use arrow functions here since we're outside of the class.
+        DBWrapper.prototype[method] = async function (storeName, ...args) {
+          return await this._call(method, storeName, mode, ...args);
+        };
+      }
+    }
+  }
+  /*
+    Copyright 2018 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  /**
+   * Deletes the database.
+   * Note: this is exported separately from the DBWrapper module because most
+   * usages of IndexedDB in workbox dont need deleting, and this way it can be
+   * reused in tests to delete databases without creating DBWrapper instances.
+   *
+   * @param {string} name The database name.
+   * @private
+   */
+  const deleteDatabase = async name => {
+    await new Promise((resolve, reject) => {
+      const request = indexedDB.deleteDatabase(name);
+      request.onerror = ({
+        target
+      }) => {
+        reject(target.error);
+      };
+      request.onblocked = () => {
+        reject(new Error('Delete blocked'));
+      };
+      request.onsuccess = () => {
+        resolve();
+      };
+    });
+  };
+  /*
+    Copyright 2018 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  const _cacheNameDetails = {
+    googleAnalytics: 'googleAnalytics',
+    precache: 'precache-v2',
+    prefix: 'workbox',
+    runtime: 'runtime',
+    suffix: self.registration.scope
+  };
+  const _createCacheName = cacheName => {
+    return [_cacheNameDetails.prefix, cacheName, _cacheNameDetails.suffix].filter(value => value.length > 0).join('-');
+  };
+  const cacheNames = {
+    updateDetails: details => {
+      Object.keys(_cacheNameDetails).forEach(key => {
+        if (typeof details[key] !== 'undefined') {
+          _cacheNameDetails[key] = details[key];
+        }
+      });
+    },
+    getGoogleAnalyticsName: userCacheName => {
+      return userCacheName || _createCacheName(_cacheNameDetails.googleAnalytics);
+    },
+    getPrecacheName: userCacheName => {
+      return userCacheName || _createCacheName(_cacheNameDetails.precache);
+    },
+    getRuntimeName: userCacheName => {
+      return userCacheName || _createCacheName(_cacheNameDetails.runtime);
+    }
+  };
+  /*
+    Copyright 2018 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  const pluginEvents = {
+    CACHE_DID_UPDATE: 'cacheDidUpdate',
+    CACHE_WILL_UPDATE: 'cacheWillUpdate',
+    CACHED_RESPONSE_WILL_BE_USED: 'cachedResponseWillBeUsed',
+    FETCH_DID_FAIL: 'fetchDidFail',
+    FETCH_DID_SUCCEED: 'fetchDidSucceed',
+    REQUEST_WILL_FETCH: 'requestWillFetch'
+  };
+  /*
+    Copyright 2018 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  const pluginUtils = {
+    filter: (plugins, callbackName) => {
+      return plugins.filter(plugin => callbackName in plugin);
+    }
+  };
+  /*
+    Copyright 2018 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  const getFriendlyURL = url => {
+    const urlObj = new URL(url, location);
+    if (urlObj.origin === location.origin) {
+      return urlObj.pathname;
+    }
+    return urlObj.href;
+  };
+  /*
+    Copyright 2018 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  /**
+   * Wrapper around cache.put().
+   *
+   * Will call `cacheDidUpdate` on plugins if the cache was updated, using
+   * `matchOptions` when determining what the old entry is.
+   *
+   * @param {Object} options
+   * @param {string} options.cacheName
+   * @param {Request} options.request
+   * @param {Response} options.response
+   * @param {Event} [options.event]
+   * @param {Array<Object>} [options.plugins=[]]
+   * @param {Object} [options.matchOptions]
+   *
+   * @private
+   * @memberof module:workbox-core
+   */
+  const putWrapper = async ({
+    cacheName,
+    request,
+    response,
+    event,
+    plugins = [],
+    matchOptions
+  } = {}) => {
+    if (!response) {
+      {
+        logger.error(`Cannot cache non-existent response for ` + `'${getFriendlyURL(request.url)}'.`);
+      }
+      throw new WorkboxError('cache-put-with-no-response', {
+        url: getFriendlyURL(request.url)
+      });
+    }
+    let responseToCache = await _isResponseSafeToCache({
+      request,
+      response,
+      event,
+      plugins
+    });
+    if (!responseToCache) {
+      {
+        logger.debug(`Response '${getFriendlyURL(request.url)}' will not be ` + `cached.`, responseToCache);
+      }
+      return;
+    }
+    {
+      if (responseToCache.method && responseToCache.method !== 'GET') {
+        throw new WorkboxError('attempt-to-cache-non-get-request', {
+          url: getFriendlyURL(request.url),
+          method: responseToCache.method
+        });
+      }
+    }
+    const cache = await caches.open(cacheName);
+    const updatePlugins = pluginUtils.filter(plugins, pluginEvents.CACHE_DID_UPDATE);
+    let oldResponse = updatePlugins.length > 0 ? await matchWrapper({
+      cacheName,
+      request,
+      matchOptions
+    }) : null;
+    {
+      logger.debug(`Updating the '${cacheName}' cache with a new Response for ` + `${getFriendlyURL(request.url)}.`);
+    }
+    try {
+      await cache.put(request, responseToCache);
+    } catch (error) {
+      // See https://developer.mozilla.org/en-US/docs/Web/API/DOMException#exception-QuotaExceededError
+      if (error.name === 'QuotaExceededError') {
+        await executeQuotaErrorCallbacks();
+      }
+      throw error;
+    }
+    for (let plugin of updatePlugins) {
+      await plugin[pluginEvents.CACHE_DID_UPDATE].call(plugin, {
+        cacheName,
+        request,
+        event,
+        oldResponse,
+        newResponse: responseToCache
+      });
+    }
+  };
+  /**
+   * This is a wrapper around cache.match().
+   *
+   * @param {Object} options
+   * @param {string} options.cacheName Name of the cache to match against.
+   * @param {Request} options.request The Request that will be used to look up
+   *     cache entries.
+   * @param {Event} [options.event] The event that propted the action.
+   * @param {Object} [options.matchOptions] Options passed to cache.match().
+   * @param {Array<Object>} [options.plugins=[]] Array of plugins.
+   * @return {Response} A cached response if available.
+   *
+   * @private
+   * @memberof module:workbox-core
+   */
+  const matchWrapper = async ({
+    cacheName,
+    request,
+    event,
+    matchOptions,
+    plugins = []
+  }) => {
+    const cache = await caches.open(cacheName);
+    let cachedResponse = await cache.match(request, matchOptions);
+    {
+      if (cachedResponse) {
+        logger.debug(`Found a cached response in '${cacheName}'.`);
+      } else {
+        logger.debug(`No cached response found in '${cacheName}'.`);
+      }
+    }
+    for (const plugin of plugins) {
+      if (pluginEvents.CACHED_RESPONSE_WILL_BE_USED in plugin) {
+        cachedResponse = await plugin[pluginEvents.CACHED_RESPONSE_WILL_BE_USED].call(plugin, {
+          cacheName,
+          request,
+          event,
+          matchOptions,
+          cachedResponse
+        });
+        {
+          if (cachedResponse) {
+            finalAssertExports.isInstance(cachedResponse, Response, {
+              moduleName: 'Plugin',
+              funcName: pluginEvents.CACHED_RESPONSE_WILL_BE_USED,
+              isReturnValueProblem: true
+            });
+          }
+        }
+      }
+    }
+    return cachedResponse;
+  };
+  /**
+   * This method will call cacheWillUpdate on the available plugins (or use
+   * status === 200) to determine if the Response is safe and valid to cache.
+   *
+   * @param {Object} options
+   * @param {Request} options.request
+   * @param {Response} options.response
+   * @param {Event} [options.event]
+   * @param {Array<Object>} [options.plugins=[]]
+   * @return {Promise<Response>}
+   *
+   * @private
+   * @memberof module:workbox-core
+   */
+  const _isResponseSafeToCache = async ({
+    request,
+    response,
+    event,
+    plugins
+  }) => {
+    let responseToCache = response;
+    let pluginsUsed = false;
+    for (let plugin of plugins) {
+      if (pluginEvents.CACHE_WILL_UPDATE in plugin) {
+        pluginsUsed = true;
+        responseToCache = await plugin[pluginEvents.CACHE_WILL_UPDATE].call(plugin, {
+          request,
+          response: responseToCache,
+          event
+        });
+        {
+          if (responseToCache) {
+            finalAssertExports.isInstance(responseToCache, Response, {
+              moduleName: 'Plugin',
+              funcName: pluginEvents.CACHE_WILL_UPDATE,
+              isReturnValueProblem: true
+            });
+          }
+        }
+        if (!responseToCache) {
+          break;
+        }
+      }
+    }
+    if (!pluginsUsed) {
+      {
+        if (!responseToCache.status === 200) {
+          if (responseToCache.status === 0) {
+            logger.warn(`The response for '${request.url}' is an opaque ` + `response. The caching strategy that you're using will not ` + `cache opaque responses by default.`);
+          } else {
+            logger.debug(`The response for '${request.url}' returned ` + `a status code of '${response.status}' and won't be cached as a ` + `result.`);
+          }
+        }
+      }
+      responseToCache = responseToCache.status === 200 ? responseToCache : null;
+    }
+    return responseToCache ? responseToCache : null;
+  };
+  const cacheWrapper = {
+    put: putWrapper,
+    match: matchWrapper
+  };
+  /*
+    Copyright 2018 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  /**
+   * Wrapper around the fetch API.
+   *
+   * Will call requestWillFetch on available plugins.
+   *
+   * @param {Object} options
+   * @param {Request|string} options.request
+   * @param {Object} [options.fetchOptions]
+   * @param {Event} [options.event]
+   * @param {Array<Object>} [options.plugins=[]]
+   * @return {Promise<Response>}
+   *
+   * @private
+   * @memberof module:workbox-core
+   */
+  const wrappedFetch = async ({
+    request,
+    fetchOptions,
+    event,
+    plugins = []
+  }) => {
+    // We *should* be able to call `await event.preloadResponse` even if it's
+    // undefined, but for some reason, doing so leads to errors in our Node unit
+    // tests. To work around that, explicitly check preloadResponse's value first.
+    if (event && event.preloadResponse) {
+      const possiblePreloadResponse = await event.preloadResponse;
+      if (possiblePreloadResponse) {
+        {
+          logger.log(`Using a preloaded navigation response for ` + `'${getFriendlyURL(request.url)}'`);
+        }
+        return possiblePreloadResponse;
+      }
+    }
+    if (typeof request === 'string') {
+      request = new Request(request);
+    }
+    {
+      finalAssertExports.isInstance(request, Request, {
+        paramName: request,
+        expectedClass: 'Request',
+        moduleName: 'workbox-core',
+        className: 'fetchWrapper',
+        funcName: 'wrappedFetch'
+      });
+    }
+    const failedFetchPlugins = pluginUtils.filter(plugins, pluginEvents.FETCH_DID_FAIL); // If there is a fetchDidFail plugin, we need to save a clone of the
+    // original request before it's either modified by a requestWillFetch
+    // plugin or before the original request's body is consumed via fetch().
+    const originalRequest = failedFetchPlugins.length > 0 ? request.clone() : null;
+    try {
+      for (let plugin of plugins) {
+        if (pluginEvents.REQUEST_WILL_FETCH in plugin) {
+          request = await plugin[pluginEvents.REQUEST_WILL_FETCH].call(plugin, {
+            request: request.clone(),
+            event
+          });
+          {
+            if (request) {
+              finalAssertExports.isInstance(request, Request, {
+                moduleName: 'Plugin',
+                funcName: pluginEvents.CACHED_RESPONSE_WILL_BE_USED,
+                isReturnValueProblem: true
+              });
+            }
+          }
+        }
+      }
+    } catch (err) {
+      throw new WorkboxError('plugin-error-request-will-fetch', {
+        thrownError: err
+      });
+    } // The request can be altered by plugins with `requestWillFetch` making
+    // the original request (Most likely from a `fetch` event) to be different
+    // to the Request we make. Pass both to `fetchDidFail` to aid debugging.
+    let pluginFilteredRequest = request.clone();
+    try {
+      let fetchResponse; // See https://github.com/GoogleChrome/workbox/issues/1796
+      if (request.mode === 'navigate') {
+        fetchResponse = await fetch(request);
+      } else {
+        fetchResponse = await fetch(request, fetchOptions);
+      }
+      {
+        logger.debug(`Network request for ` + `'${getFriendlyURL(request.url)}' returned a response with ` + `status '${fetchResponse.status}'.`);
+      }
+      for (const plugin of plugins) {
+        if (pluginEvents.FETCH_DID_SUCCEED in plugin) {
+          fetchResponse = await plugin[pluginEvents.FETCH_DID_SUCCEED].call(plugin, {
+            event,
+            request: pluginFilteredRequest,
+            response: fetchResponse
+          });
+          {
+            if (fetchResponse) {
+              finalAssertExports.isInstance(fetchResponse, Response, {
+                moduleName: 'Plugin',
+                funcName: pluginEvents.FETCH_DID_SUCCEED,
+                isReturnValueProblem: true
+              });
+            }
+          }
+        }
+      }
+      return fetchResponse;
+    } catch (error) {
+      {
+        logger.error(`Network request for ` + `'${getFriendlyURL(request.url)}' threw an error.`, error);
+      }
+      for (const plugin of failedFetchPlugins) {
+        await plugin[pluginEvents.FETCH_DID_FAIL].call(plugin, {
+          error,
+          event,
+          originalRequest: originalRequest.clone(),
+          request: pluginFilteredRequest.clone()
+        });
+      }
+      throw error;
+    }
+  };
+  const fetchWrapper = {
+    fetch: wrappedFetch
+  };
+  /*
+    Copyright 2018 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  var _private = /*#__PURE__*/Object.freeze({
+    DBWrapper: DBWrapper,
+    deleteDatabase: deleteDatabase,
+    WorkboxError: WorkboxError,
+    assert: finalAssertExports,
+    cacheNames: cacheNames,
+    cacheWrapper: cacheWrapper,
+    fetchWrapper: fetchWrapper,
+    getFriendlyURL: getFriendlyURL,
+    logger: logger
+  });
+  /*
+    Copyright 2019 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  /**
+   * Claim any currently available clients once the service worker
+   * becomes active. This is normally used in conjunction with `skipWaiting()`.
+   *
+   * @alias workbox.core.clientsClaim
+   */
+  const clientsClaim = () => {
+    addEventListener('activate', () => clients.claim());
+  };
+  /*
+    Copyright 2019 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  /**
+   * Get the current cache names used by Workbox.
+   *
+   * `cacheNames.precache` is used for precached assets,
+   * `cacheNames.googleAnalytics` is used by `workbox-google-analytics` to
+   * store `analytics.js`, and `cacheNames.runtime` is used for everything else.
+   *
+   * @return {Object} An object with `precache`, `runtime`, and
+   *     `googleAnalytics` cache names.
+   *
+   * @alias workbox.core.cacheNames
+   */
+  const cacheNames$1 = {
+    get googleAnalytics() {
+      return cacheNames.getGoogleAnalyticsName();
+    },
+    get precache() {
+      return cacheNames.getPrecacheName();
+    },
+    get runtime() {
+      return cacheNames.getRuntimeName();
+    }
+  };
+  /*
+    Copyright 2019 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  /**
+   * Modifies the default cache names used by the Workbox packages.
+   * Cache names are generated as `<prefix>-<Cache Name>-<suffix>`.
+   *
+   * @param {Object} details
+   * @param {Object} [details.prefix] The string to add to the beginning of
+   *     the precache and runtime cache names.
+   * @param {Object} [details.suffix] The string to add to the end of
+   *     the precache and runtime cache names.
+   * @param {Object} [details.precache] The cache name to use for precache
+   *     caching.
+   * @param {Object} [details.runtime] The cache name to use for runtime caching.
+   * @param {Object} [details.googleAnalytics] The cache name to use for
+   *     `workbox-google-analytics` caching.
+   *
+   * @alias workbox.core.setCacheNameDetails
+   */
+  const setCacheNameDetails = details => {
+    {
+      Object.keys(details).forEach(key => {
+        finalAssertExports.isType(details[key], 'string', {
+          moduleName: 'workbox-core',
+          funcName: 'setCacheNameDetails',
+          paramName: `details.${key}`
+        });
+      });
+      if ('precache' in details && details.precache.length === 0) {
+        throw new WorkboxError('invalid-cache-name', {
+          cacheNameId: 'precache',
+          value: details.precache
+        });
+      }
+      if ('runtime' in details && details.runtime.length === 0) {
+        throw new WorkboxError('invalid-cache-name', {
+          cacheNameId: 'runtime',
+          value: details.runtime
+        });
+      }
+      if ('googleAnalytics' in details && details.googleAnalytics.length === 0) {
+        throw new WorkboxError('invalid-cache-name', {
+          cacheNameId: 'googleAnalytics',
+          value: details.googleAnalytics
+        });
+      }
+    }
+    cacheNames.updateDetails(details);
+  };
+  /*
+    Copyright 2019 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  /**
+   * Force a service worker to become active, instead of waiting. This is
+   * normally used in conjunction with `clientsClaim()`.
+   *
+   * @alias workbox.core.skipWaiting
+   */
+  const skipWaiting = () => {
+    // We need to explicitly call `self.skipWaiting()` here because we're
+    // shadowing `skipWaiting` with this local function.
+    addEventListener('install', () => self.skipWaiting());
+  };
+  /*
+    Copyright 2018 Google LLC
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+  */
+  try {
+    self.workbox.v = self.workbox.v || {};
+  } catch (errer) {} // NOOP
+  exports._private = _private;
+  exports.clientsClaim = clientsClaim;
+  exports.cacheNames = cacheNames$1;
+  exports.registerQuotaErrorCallback = registerQuotaErrorCallback;
+  exports.setCacheNameDetails = setCacheNameDetails;
+  exports.skipWaiting = skipWaiting;
+  return exports;
+}({}));
+//# sourceMappingURL=workbox-core.dev.js.map