jekyll-pwa-workbox 0.0.7.alpha → 5.1.4

data/lib/vendor/workbox-v5.1.4/workbox-broadcast-update.dev.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workbox-broadcast-update.dev.js","sources":["../_version.js","../responsesAreSame.js","../utils/constants.js","../BroadcastCacheUpdate.js","../BroadcastUpdatePlugin.js"],"sourcesContent":["\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:broadcast-update:5.1.4'] && _();\n}\ncatch (e) { }\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport './_version.js';\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 module:workbox-broadcast-update\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    const atLeastOneHeaderAvailable = headersToCheck.some((header) => {\n        return firstResponse.headers.has(header) &&\n            secondResponse.headers.has(header);\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: `, firstResponse, secondResponse, headersToCheck);\n        }\n        // Just return true, indicating the that responses are the same, since we\n        // can't determine otherwise.\n        return true;\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        return headerStateComparison && headerValueComparison;\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*/\nimport '../_version.js';\nexport const CACHE_UPDATED_MESSAGE_TYPE = 'CACHE_UPDATED';\nexport const CACHE_UPDATED_MESSAGE_META = 'workbox-broadcast-update';\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*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { timeout } from 'workbox-core/_private/timeout.js';\nimport { resultingClientExists } from 'workbox-core/_private/resultingClientExists.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { responsesAreSame } from './responsesAreSame.js';\nimport { CACHE_UPDATED_MESSAGE_TYPE, CACHE_UPDATED_MESSAGE_META, DEFAULT_HEADERS_TO_CHECK } from './utils/constants.js';\nimport './_version.js';\n// UA-sniff Safari: https://stackoverflow.com/questions/7944460/detect-safari-browser\n// TODO(philipwalton): remove once this Safari bug fix has been released.\n// https://bugs.webkit.org/show_bug.cgi?id=201169\nconst isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);\n/**\n * Generates the default payload used in update messages. By default the\n * payload includes the `cacheName` and `updatedURL` fields.\n *\n * @return Object\n * @private\n */\nfunction defaultPayloadGenerator(data) {\n    return {\n        cacheName: data.cacheName,\n        updatedURL: data.request.url,\n    };\n}\n/**\n * Uses the `postMessage()` API to inform any open windows/tabs when a cached\n * response has been updated.\n *\n * For efficiency's sake, the underlying response bodies are not compared;\n * only specific response headers are checked.\n *\n * @memberof module:workbox-broadcast-update\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>} [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.generatePayload] A function whose return value\n     *     will be used as the `payload` field in any cache update messages sent\n     *     to the window clients.\n     */\n    constructor({ headersToCheck, generatePayload, } = {}) {\n        this._headersToCheck = headersToCheck || DEFAULT_HEADERS_TO_CHECK;\n        this._generatePayload = generatePayload || defaultPayloadGenerator;\n    }\n    /**\n     * Compares two [Responses](https://developer.mozilla.org/en-US/docs/Web/API/Response)\n     * and sends a message (via `postMessage()`) to all window clients if the\n     * responses differ (note: neither of the Responses can be\n     * {@link http://stackoverflow.com/questions/39109789|opaque}).\n     *\n     * The message that's posted has the following format (where `payload` can\n     * be customized via the `generatePayload` option the instance is created\n     * with):\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     * @param {Object} options\n     * @param {Response} [options.oldResponse] Cached response to compare.\n     * @param {Response} options.newResponse Possibly updated response to compare.\n     * @param {Request} options.request 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    async notifyIfUpdated(options) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isType(options.cacheName, 'string', {\n                moduleName: 'workbox-broadcast-update',\n                className: 'BroadcastCacheUpdate',\n                funcName: 'notifyIfUpdated',\n                paramName: 'cacheName',\n            });\n            assert.isInstance(options.newResponse, Response, {\n                moduleName: 'workbox-broadcast-update',\n                className: 'BroadcastCacheUpdate',\n                funcName: 'notifyIfUpdated',\n                paramName: 'newResponse',\n            });\n            assert.isInstance(options.request, Request, {\n                moduleName: 'workbox-broadcast-update',\n                className: 'BroadcastCacheUpdate',\n                funcName: 'notifyIfUpdated',\n                paramName: 'request',\n            });\n        }\n        // Without two responses there is nothing to compare.\n        if (!options.oldResponse) {\n            return;\n        }\n        if (!responsesAreSame(options.oldResponse, options.newResponse, this._headersToCheck)) {\n            if (process.env.NODE_ENV !== 'production') {\n                logger.log(`Newer response found (and cached) for:`, options.request.url);\n            }\n            const messageData = {\n                type: CACHE_UPDATED_MESSAGE_TYPE,\n                meta: CACHE_UPDATED_MESSAGE_META,\n                payload: this._generatePayload(options),\n            };\n            // For navigation requests, wait until the new window client exists\n            // before sending the message\n            if (options.request.mode === 'navigate') {\n                let resultingClientId;\n                if (options.event instanceof FetchEvent) {\n                    resultingClientId = options.event.resultingClientId;\n                }\n                const resultingWin = await resultingClientExists(resultingClientId);\n                // Safari does not currently implement postMessage buffering and\n                // there's no good way to feature detect that, so to increase the\n                // chances of the message being delivered in Safari, we add a timeout.\n                // We also do this if `resultingClientExists()` didn't return a client,\n                // which means it timed out, so it's worth waiting a bit longer.\n                if (!resultingWin || isSafari) {\n                    // 3500 is chosen because (according to CrUX data) 80% of mobile\n                    // websites hit the DOMContentLoaded event in less than 3.5 seconds.\n                    // And presumably sites implementing service worker are on the\n                    // higher end of the performance spectrum.\n                    await timeout(3500);\n                }\n            }\n            const windows = await self.clients.matchAll({ type: 'window' });\n            for (const win of windows) {\n                win.postMessage(messageData);\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*/\nimport { dontWaitFor } from 'workbox-core/_private/dontWaitFor.js';\nimport { BroadcastCacheUpdate } from './BroadcastCacheUpdate.js';\nimport './_version.js';\n/**\n * This plugin will automatically broadcast a message whenever a cached response\n * is updated.\n *\n * @memberof module:workbox-broadcast-update\n */\nclass BroadcastUpdatePlugin {\n    /**\n     * Construct a BroadcastCacheUpdate instance with the passed options and\n     * calls its [`notifyIfUpdated()`]{@link module:workbox-broadcast-update.BroadcastCacheUpdate~notifyIfUpdated}\n     * method whenever the plugin's `cacheDidUpdate` callback is invoked.\n     *\n     * @param {Object} options\n     * @param {Array<string>} [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.generatePayload] A function whose return value\n     *     will be used as the `payload` field in any cache update messages sent\n     *     to the window clients.\n     */\n    constructor(options) {\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 update.\n         * @param {Request} [options.event] The event that triggered the update.\n         */\n        this.cacheDidUpdate = async (options) => {\n            dontWaitFor(this._broadcastUpdate.notifyIfUpdated(options));\n        };\n        this._broadcastUpdate = new BroadcastCacheUpdate(options);\n    }\n}\nexport { BroadcastUpdatePlugin };\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_HEADERS_TO_CHECK","isSafari","test","navigator","userAgent","defaultPayloadGenerator","data","cacheName","updatedURL","request","url","BroadcastCacheUpdate","constructor","generatePayload","_headersToCheck","_generatePayload","notifyIfUpdated","options","assert","isType","moduleName","className","funcName","paramName","isInstance","newResponse","Request","oldResponse","log","messageData","type","meta","payload","mode","resultingClientId","event","FetchEvent","resultingWin","resultingClientExists","timeout","windows","clients","matchAll","win","postMessage","BroadcastUpdatePlugin","cacheDidUpdate","dontWaitFor","_broadcastUpdate"],"mappings":"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"}

data/lib/vendor/workbox-v5.1.4/workbox-broadcast-update.prod.js

@@ -0,0 +1,2 @@
+this.workbox=this.workbox||{},this.workbox.broadcastUpdate=function(t,a,o,s){"use strict";try{self["workbox:broadcast-update:5.1.4"]&&_()}catch(t){}const e=(t,a,o)=>!o.some(o=>t.headers.has(o)&&a.headers.has(o))||o.every(o=>{const s=t.headers.has(o)===a.headers.has(o),e=t.headers.get(o)===a.headers.get(o);return s&&e}),n=["content-length","etag","last-modified"],i=/^((?!chrome|android).)*safari/i.test(navigator.userAgent);function c(t){return{cacheName:t.cacheName,updatedURL:t.request.url}}class r{constructor({headersToCheck:t,generatePayload:a}={}){this.t=t||n,this.o=a||c}async notifyIfUpdated(t){if(t.oldResponse&&!e(t.oldResponse,t.newResponse,this.t)){const s={type:"CACHE_UPDATED",meta:"workbox-broadcast-update",payload:this.o(t)};if("navigate"===t.request.mode){let s;t.event instanceof FetchEvent&&(s=t.event.resultingClientId);await o.resultingClientExists(s)&&!i||await a.timeout(3500)}const e=await self.clients.matchAll({type:"window"});for(const t of e)t.postMessage(s)}}}return t.BroadcastCacheUpdate=r,t.BroadcastUpdatePlugin=class{constructor(t){this.cacheDidUpdate=async t=>{s.dontWaitFor(this.s.notifyIfUpdated(t))},this.s=new r(t)}},t.responsesAreSame=e,t}({},workbox.core._private,workbox.core._private,workbox.core._private);
+//# sourceMappingURL=workbox-broadcast-update.prod.js.map

data/lib/vendor/workbox-v5.1.4/workbox-broadcast-update.prod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workbox-broadcast-update.prod.js","sources":["../_version.js","../responsesAreSame.js","../utils/constants.js","../BroadcastCacheUpdate.js","../BroadcastUpdatePlugin.js"],"sourcesContent":["\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:broadcast-update:5.1.4'] && _();\n}\ncatch (e) { }\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport './_version.js';\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 module:workbox-broadcast-update\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    const atLeastOneHeaderAvailable = headersToCheck.some((header) => {\n        return firstResponse.headers.has(header) &&\n            secondResponse.headers.has(header);\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: `, firstResponse, secondResponse, headersToCheck);\n        }\n        // Just return true, indicating the that responses are the same, since we\n        // can't determine otherwise.\n        return true;\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        return headerStateComparison && headerValueComparison;\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*/\nimport '../_version.js';\nexport const CACHE_UPDATED_MESSAGE_TYPE = 'CACHE_UPDATED';\nexport const CACHE_UPDATED_MESSAGE_META = 'workbox-broadcast-update';\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*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { timeout } from 'workbox-core/_private/timeout.js';\nimport { resultingClientExists } from 'workbox-core/_private/resultingClientExists.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { responsesAreSame } from './responsesAreSame.js';\nimport { CACHE_UPDATED_MESSAGE_TYPE, CACHE_UPDATED_MESSAGE_META, DEFAULT_HEADERS_TO_CHECK } from './utils/constants.js';\nimport './_version.js';\n// UA-sniff Safari: https://stackoverflow.com/questions/7944460/detect-safari-browser\n// TODO(philipwalton): remove once this Safari bug fix has been released.\n// https://bugs.webkit.org/show_bug.cgi?id=201169\nconst isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);\n/**\n * Generates the default payload used in update messages. By default the\n * payload includes the `cacheName` and `updatedURL` fields.\n *\n * @return Object\n * @private\n */\nfunction defaultPayloadGenerator(data) {\n    return {\n        cacheName: data.cacheName,\n        updatedURL: data.request.url,\n    };\n}\n/**\n * Uses the `postMessage()` API to inform any open windows/tabs when a cached\n * response has been updated.\n *\n * For efficiency's sake, the underlying response bodies are not compared;\n * only specific response headers are checked.\n *\n * @memberof module:workbox-broadcast-update\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>} [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.generatePayload] A function whose return value\n     *     will be used as the `payload` field in any cache update messages sent\n     *     to the window clients.\n     */\n    constructor({ headersToCheck, generatePayload, } = {}) {\n        this._headersToCheck = headersToCheck || DEFAULT_HEADERS_TO_CHECK;\n        this._generatePayload = generatePayload || defaultPayloadGenerator;\n    }\n    /**\n     * Compares two [Responses](https://developer.mozilla.org/en-US/docs/Web/API/Response)\n     * and sends a message (via `postMessage()`) to all window clients if the\n     * responses differ (note: neither of the Responses can be\n     * {@link http://stackoverflow.com/questions/39109789|opaque}).\n     *\n     * The message that's posted has the following format (where `payload` can\n     * be customized via the `generatePayload` option the instance is created\n     * with):\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     * @param {Object} options\n     * @param {Response} [options.oldResponse] Cached response to compare.\n     * @param {Response} options.newResponse Possibly updated response to compare.\n     * @param {Request} options.request 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    async notifyIfUpdated(options) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isType(options.cacheName, 'string', {\n                moduleName: 'workbox-broadcast-update',\n                className: 'BroadcastCacheUpdate',\n                funcName: 'notifyIfUpdated',\n                paramName: 'cacheName',\n            });\n            assert.isInstance(options.newResponse, Response, {\n                moduleName: 'workbox-broadcast-update',\n                className: 'BroadcastCacheUpdate',\n                funcName: 'notifyIfUpdated',\n                paramName: 'newResponse',\n            });\n            assert.isInstance(options.request, Request, {\n                moduleName: 'workbox-broadcast-update',\n                className: 'BroadcastCacheUpdate',\n                funcName: 'notifyIfUpdated',\n                paramName: 'request',\n            });\n        }\n        // Without two responses there is nothing to compare.\n        if (!options.oldResponse) {\n            return;\n        }\n        if (!responsesAreSame(options.oldResponse, options.newResponse, this._headersToCheck)) {\n            if (process.env.NODE_ENV !== 'production') {\n                logger.log(`Newer response found (and cached) for:`, options.request.url);\n            }\n            const messageData = {\n                type: CACHE_UPDATED_MESSAGE_TYPE,\n                meta: CACHE_UPDATED_MESSAGE_META,\n                payload: this._generatePayload(options),\n            };\n            // For navigation requests, wait until the new window client exists\n            // before sending the message\n            if (options.request.mode === 'navigate') {\n                let resultingClientId;\n                if (options.event instanceof FetchEvent) {\n                    resultingClientId = options.event.resultingClientId;\n                }\n                const resultingWin = await resultingClientExists(resultingClientId);\n                // Safari does not currently implement postMessage buffering and\n                // there's no good way to feature detect that, so to increase the\n                // chances of the message being delivered in Safari, we add a timeout.\n                // We also do this if `resultingClientExists()` didn't return a client,\n                // which means it timed out, so it's worth waiting a bit longer.\n                if (!resultingWin || isSafari) {\n                    // 3500 is chosen because (according to CrUX data) 80% of mobile\n                    // websites hit the DOMContentLoaded event in less than 3.5 seconds.\n                    // And presumably sites implementing service worker are on the\n                    // higher end of the performance spectrum.\n                    await timeout(3500);\n                }\n            }\n            const windows = await self.clients.matchAll({ type: 'window' });\n            for (const win of windows) {\n                win.postMessage(messageData);\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*/\nimport { dontWaitFor } from 'workbox-core/_private/dontWaitFor.js';\nimport { BroadcastCacheUpdate } from './BroadcastCacheUpdate.js';\nimport './_version.js';\n/**\n * This plugin will automatically broadcast a message whenever a cached response\n * is updated.\n *\n * @memberof module:workbox-broadcast-update\n */\nclass BroadcastUpdatePlugin {\n    /**\n     * Construct a BroadcastCacheUpdate instance with the passed options and\n     * calls its [`notifyIfUpdated()`]{@link module:workbox-broadcast-update.BroadcastCacheUpdate~notifyIfUpdated}\n     * method whenever the plugin's `cacheDidUpdate` callback is invoked.\n     *\n     * @param {Object} options\n     * @param {Array<string>} [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.generatePayload] A function whose return value\n     *     will be used as the `payload` field in any cache update messages sent\n     *     to the window clients.\n     */\n    constructor(options) {\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 update.\n         * @param {Request} [options.event] The event that triggered the update.\n         */\n        this.cacheDidUpdate = async (options) => {\n            dontWaitFor(this._broadcastUpdate.notifyIfUpdated(options));\n        };\n        this._broadcastUpdate = new BroadcastCacheUpdate(options);\n    }\n}\nexport { BroadcastUpdatePlugin };\n"],"names":["self","_","e","responsesAreSame","firstResponse","secondResponse","headersToCheck","some","header","headers","has","every","headerStateComparison","headerValueComparison","get","DEFAULT_HEADERS_TO_CHECK","isSafari","test","navigator","userAgent","defaultPayloadGenerator","data","cacheName","updatedURL","request","url","BroadcastCacheUpdate","constructor","generatePayload","_headersToCheck","_generatePayload","options","oldResponse","newResponse","this","messageData","type","meta","payload","mode","resultingClientId","event","FetchEvent","resultingClientExists","timeout","windows","clients","matchAll","win","postMessage","cacheDidUpdate","async","dontWaitFor","_broadcastUpdate","notifyIfUpdated"],"mappings":"0FAEA,IACIA,KAAK,mCAAqCC,IAE9C,MAAOC,UCgBDC,EAAmB,CAACC,EAAeC,EAAgBC,KAOnBA,EAAeC,KAAMC,GAC5CJ,EAAcK,QAAQC,IAAIF,IAC7BH,EAAeI,QAAQC,IAAIF,KAY5BF,EAAeK,MAAOH,UACnBI,EAAwBR,EAAcK,QAAQC,IAAIF,KACpDH,EAAeI,QAAQC,IAAIF,GACzBK,EAAwBT,EAAcK,QAAQK,IAAIN,KACpDH,EAAeI,QAAQK,IAAIN,UACxBI,GAAyBC,ICrC3BE,EAA2B,CACpC,iBACA,OACA,iBCIEC,EAAW,iCAAiCC,KAAKC,UAAUC,WAQjE,SAASC,EAAwBC,SACtB,CACHC,UAAWD,EAAKC,UAChBC,WAAYF,EAAKG,QAAQC,KAYjC,MAAMC,EAaFC,aAAYrB,eAAEA,EAAFsB,gBAAkBA,GAAqB,SAC1CC,EAAkBvB,GAAkBS,OACpCe,EAAmBF,GAAmBR,wBAiCzBW,MAsBbA,EAAQC,cAGR7B,EAAiB4B,EAAQC,YAAaD,EAAQE,YAAaC,KAAKL,GAAkB,OAI7EM,EAAc,CAChBC,KD9G0B,gBC+G1BC,KD9G0B,2BC+G1BC,QAASJ,KAAKJ,EAAiBC,OAIN,aAAzBA,EAAQP,QAAQe,KAAqB,KACjCC,EACAT,EAAQU,iBAAiBC,aACzBF,EAAoBT,EAAQU,MAAMD,yBAEXG,wBAAsBH,KAM5BxB,SAKX4B,UAAQ,YAGhBC,QAAgB7C,KAAK8C,QAAQC,SAAS,CAAEX,KAAM,eAC/C,MAAMY,KAAOH,EACdG,EAAIC,YAAYd,6DCjIhC,MAcIR,YAAYI,QAcHmB,eAAiBC,MAAAA,IAClBC,cAAYlB,KAAKmB,EAAiBC,gBAAgBvB,UAEjDsB,EAAmB,IAAI3B,EAAqBK"}

data/lib/vendor/{workbox-v5.0.0.alpha1 → workbox-v5.1.4}/workbox-cacheable-response.dev.js

@@ -2,9 +2,8 @@ this.workbox = this.workbox || {};
 this.workbox.cacheableResponse = (function (exports, assert_js, WorkboxError_js, getFriendlyURL_js, logger_js) {
     'use strict';
 
-    // @ts-ignore
     try {
-      self['workbox:cacheable-response:5.0.0-alpha.0'] && _();
+      self['workbox:cacheable-response:5.1.4'] && _();
     } catch (e) {}
 
     /*
@@ -20,7 +19,7 @@ this.workbox.cacheableResponse = (function (exports, assert_js, WorkboxError_js,
      * [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
      * to be considered cacheable.
      *
-     * @memberof workbox.cacheableResponse
+     * @memberof module:workbox-cacheable-response
      */
 
     class CacheableResponse {
@@ -143,12 +142,12 @@ this.workbox.cacheableResponse = (function (exports, assert_js, WorkboxError_js,
      * easier to add in cacheability checks to requests made via Workbox's built-in
      * strategies.
      *
-     * @memberof workbox.cacheableResponse
+     * @memberof module:workbox-cacheable-response
      */
 
-    class Plugin {
+    class CacheableResponsePlugin {
       /**
-       * To construct a new cacheable response Plugin instance you must provide at
+       * To construct a new CacheableResponsePlugin instance you must provide at
        * least one of the `config` properties.
        *
        * If both `statuses` and `headers` are specified, then both conditions must
@@ -184,7 +183,7 @@ this.workbox.cacheableResponse = (function (exports, assert_js, WorkboxError_js,
     }
 
     exports.CacheableResponse = CacheableResponse;
-    exports.Plugin = Plugin;
+    exports.CacheableResponsePlugin = CacheableResponsePlugin;
 
     return exports;
 

data/lib/vendor/workbox-v5.1.4/workbox-cacheable-response.dev.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workbox-cacheable-response.dev.js","sources":["../_version.js","../CacheableResponse.js","../CacheableResponsePlugin.js"],"sourcesContent":["\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:cacheable-response:5.1.4'] && _();\n}\ncatch (e) { }\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport './_version.js';\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 module:workbox-cacheable-response\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            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            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        this._statuses = config.statuses;\n        this._headers = config.headers;\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        let cacheable = true;\n        if (this._statuses) {\n            cacheable = this._statuses.includes(response.status);\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        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                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                const logFriendlyHeaders = {};\n                response.headers.forEach((value, key) => {\n                    logFriendlyHeaders[key] = value;\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                logger.groupCollapsed(`View full response details here.`);\n                logger.log(response.headers);\n                logger.log(response);\n                logger.groupEnd();\n                logger.groupEnd();\n            }\n        }\n        return cacheable;\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*/\nimport { CacheableResponse } from './CacheableResponse.js';\nimport './_version.js';\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 module:workbox-cacheable-response\n */\nclass CacheableResponsePlugin {\n    /**\n     * To construct a new CacheableResponsePlugin 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        /**\n         * @param {Object} options\n         * @param {Response} options.response\n         * @return {Response|null}\n         * @private\n         */\n        this.cacheWillUpdate = async ({ response }) => {\n            if (this._cacheableResponse.isResponseCacheable(response)) {\n                return response;\n            }\n            return null;\n        };\n        this._cacheableResponse = new CacheableResponse(config);\n    }\n}\nexport { CacheableResponsePlugin };\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","CacheableResponsePlugin","cacheWillUpdate","_cacheableResponse"],"mappings":"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"}

data/lib/vendor/workbox-v5.1.4/workbox-cacheable-response.prod.js

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

data/lib/vendor/workbox-v5.1.4/workbox-cacheable-response.prod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workbox-cacheable-response.prod.js","sources":["../_version.js","../CacheableResponse.js","../CacheableResponsePlugin.js"],"sourcesContent":["\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:cacheable-response:5.1.4'] && _();\n}\ncatch (e) { }\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport './_version.js';\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 module:workbox-cacheable-response\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            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            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        this._statuses = config.statuses;\n        this._headers = config.headers;\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        let cacheable = true;\n        if (this._statuses) {\n            cacheable = this._statuses.includes(response.status);\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        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                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                const logFriendlyHeaders = {};\n                response.headers.forEach((value, key) => {\n                    logFriendlyHeaders[key] = value;\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                logger.groupCollapsed(`View full response details here.`);\n                logger.log(response.headers);\n                logger.log(response);\n                logger.groupEnd();\n                logger.groupEnd();\n            }\n        }\n        return cacheable;\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*/\nimport { CacheableResponse } from './CacheableResponse.js';\nimport './_version.js';\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 module:workbox-cacheable-response\n */\nclass CacheableResponsePlugin {\n    /**\n     * To construct a new CacheableResponsePlugin 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        /**\n         * @param {Object} options\n         * @param {Response} options.response\n         * @return {Response|null}\n         * @private\n         */\n        this.cacheWillUpdate = async ({ response }) => {\n            if (this._cacheableResponse.isResponseCacheable(response)) {\n                return response;\n            }\n            return null;\n        };\n        this._cacheableResponse = new CacheableResponse(config);\n    }\n}\nexport { CacheableResponsePlugin };\n"],"names":["self","_","e","CacheableResponse","constructor","config","_statuses","statuses","_headers","headers","isResponseCacheable","response","cacheable","this","includes","status","Object","keys","some","headerName","get","cacheWillUpdate","async","_cacheableResponse"],"mappings":"sFAEA,IACIA,KAAK,qCAAuCC,IAEhD,MAAOC,ICeP,MAAMC,EAeFC,YAAYC,EAAS,SA0BZC,EAAYD,EAAOE,cACnBC,EAAWH,EAAOI,QAW3BC,oBAAoBC,OASZC,GAAY,SACZC,KAAKP,IACLM,EAAYC,KAAKP,EAAUQ,SAASH,EAASI,SAE7CF,KAAKL,GAAYI,IACjBA,EAAYI,OAAOC,KAAKJ,KAAKL,GAAUU,KAAMC,GAClCR,EAASF,QAAQW,IAAID,KAAgBN,KAAKL,EAASW,KA8B3DP,0DCtGf,MAeIR,YAAYC,QAOHgB,gBAAkBC,OAASX,SAAAA,KACxBE,KAAKU,EAAmBb,oBAAoBC,GACrCA,EAEJ,UAENY,EAAqB,IAAIpB,EAAkBE"}

data/lib/vendor/{workbox-v5.0.0.alpha1 → workbox-v5.1.4}/workbox-core.dev.js

@@ -2,9 +2,8 @@ this.workbox = this.workbox || {};
 this.workbox.core = (function (exports) {
     'use strict';
 
-    // @ts-ignore
     try {
-      self['workbox:core:5.0.0-alpha.0'] && _();
+      self['workbox:core:5.1.4'] && _();
     } catch (e) {}
 
     /*
@@ -14,6 +13,12 @@ this.workbox.core = (function (exports) {
       https://opensource.org/licenses/MIT.
     */
     const logger =  (() => {
+      // Don't overwrite this value if it's already set.
+      // See https://github.com/GoogleChrome/workbox/pull/2284#issuecomment-560470923
+      if (!('__WB_DISABLE_DEV_LOGS' in self)) {
+        self.__WB_DISABLE_DEV_LOGS = false;
+      }
+
       let inGroup = false;
       const methodToColorMap = {
         debug: `#7f8c8d`,
@@ -25,6 +30,10 @@ this.workbox.core = (function (exports) {
       };
 
       const print = function (method, args) {
+        if (self.__WB_DISABLE_DEV_LOGS) {
+          return;
+        }
+
         if (method === 'groupCollapsed') {
           // Safari doesn't print all console.groupCollapsed() arguments:
           // https://bugs.webkit.org/show_bug.cgi?id=182754
@@ -81,15 +90,6 @@ this.workbox.core = (function (exports) {
 
         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,
@@ -159,7 +159,7 @@ this.workbox.core = (function (exports) {
           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.`;
+        return `Two of the entries passed to ` + `'workbox-precaching.PrecacheController.addToCacheList()' had the URL ` + `${firstEntry._entryId} but different revision details. Workbox is ` + `unable to cache and version the asset correctly. Please remove one ` + `of the entries.`;
       },
       'plugin-error-request-will-fetch': ({
         thrownError
@@ -178,7 +178,7 @@ this.workbox.core = (function (exports) {
           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)}'`;
+        return `You must provide a name containing at least one character for ` + `setCacheDetails({${cacheNameId}: '...'}). Received a value of ` + `'${JSON.stringify(value)}'`;
       },
       'unregister-route-but-not-found-with-method': ({
         method
@@ -325,6 +325,22 @@ this.workbox.core = (function (exports) {
         status
       }) => {
         return `The precaching request for '${url}' failed with an HTTP ` + `status of ${status}.`;
+      },
+      'non-precached-url': ({
+        url
+      }) => {
+        return `createHandlerBoundToURL('${url}') was called, but that URL is ` + `not precached. Please pass in a URL that is precached instead.`;
+      },
+      'add-to-cache-list-conflicting-integrities': ({
+        url
+      }) => {
+        return `Two of the entries passed to ` + `'workbox-precaching.PrecacheController.addToCacheList()' had the URL ` + `${url} with different integrity values. Please remove one of them.`;
+      },
+      'missing-precache-entry': ({
+        cacheName,
+        url
+      }) => {
+        return `Unable to find a precached response in ${cacheName} for ${url}.`;
       }
     };
 
@@ -375,7 +391,7 @@ this.workbox.core = (function (exports) {
        * be added as a key on the context object.
        */
       constructor(errorCode, details) {
-        let message = messageGenerator(errorCode, details);
+        const message = messageGenerator(errorCode, details);
         super(message);
         this.name = errorCode;
         this.details = details;
@@ -390,17 +406,6 @@ this.workbox.core = (function (exports) {
       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.
@@ -408,7 +413,6 @@ this.workbox.core = (function (exports) {
      * needed.
      */
 
-
     const isArray = (value, details) => {
       if (!Array.isArray(value)) {
         throw new WorkboxError('not-an-array', details);
@@ -419,28 +423,28 @@ this.workbox.core = (function (exports) {
       const type = typeof object[expectedMethod];
 
       if (type !== 'function') {
-        details.expectedMethod = expectedMethod;
+        details['expectedMethod'] = expectedMethod;
         throw new WorkboxError('missing-a-method', details);
       }
     };
 
     const isType = (object, expectedType, details) => {
       if (typeof object !== expectedType) {
-        details.expectedType = expectedType;
+        details['expectedType'] = expectedType;
         throw new WorkboxError('incorrect-type', details);
       }
     };
 
     const isInstance = (object, expectedClass, details) => {
       if (!(object instanceof expectedClass)) {
-        details.expectedClass = expectedClass;
+        details['expectedClass'] = expectedClass;
         throw new WorkboxError('incorrect-class', details);
       }
     };
 
     const isOneOf = (value, validValues, details) => {
       if (!validValues.includes(value)) {
-        details.validValueDescription = `Valid values are ${JSON.stringify(validValues)}.`;
+        details['validValueDescription'] = `Valid values are ${JSON.stringify(validValues)}.`;
         throw new WorkboxError('invalid-value', details);
       }
     };
@@ -452,7 +456,7 @@ this.workbox.core = (function (exports) {
         throw error;
       }
 
-      for (let item of value) {
+      for (const item of value) {
         if (!(item instanceof expectedClass)) {
           throw error;
         }
@@ -464,7 +468,6 @@ this.workbox.core = (function (exports) {
       isArray,
       isInstance,
       isOneOf,
-      isSWEnv,
       isType,
       isArrayOfClass
     };
@@ -491,7 +494,7 @@ this.workbox.core = (function (exports) {
      * there's a quota error.
      *
      * @param {Function} callback
-     * @memberof workbox.core
+     * @memberof module:workbox-core
      */
 
     function registerQuotaErrorCallback(callback) {
@@ -522,7 +525,7 @@ this.workbox.core = (function (exports) {
       precache: 'precache-v2',
       prefix: 'workbox',
       runtime: 'runtime',
-      suffix: registration.scope
+      suffix: typeof registration !== 'undefined' ? registration.scope : ''
     };
 
     const _createCacheName = cacheName => {
@@ -560,24 +563,6 @@ this.workbox.core = (function (exports) {
       }
     };
 
-    /*
-      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(String(url), location.href);
-
-      if (urlObj.origin === location.origin) {
-        return urlObj.pathname;
-      }
-
-      return urlObj.href;
-    };
-
     /*
       Copyright 2018 Google LLC
 
@@ -589,7 +574,7 @@ this.workbox.core = (function (exports) {
      * Runs all of the callback functions, one at a time sequentially, in the order
      * in which they were registered.
      *
-     * @memberof workbox.core
+     * @memberof module:workbox-core
      * @private
      */
 
@@ -611,6 +596,21 @@ this.workbox.core = (function (exports) {
       }
     }
 
+    /*
+      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(String(url), location.href); // See https://github.com/GoogleChrome/workbox/issues/2323
+      // We want to include everything, except for the origin if it's same-origin.
+
+      return urlObj.href.replace(new RegExp(`^${location.origin}`), '');
+    };
+
     /*
       Copyright 2018 Google LLC
 
@@ -632,107 +632,130 @@ this.workbox.core = (function (exports) {
       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.
+     * Checks the list of plugins for the cacheKeyWillBeUsed callback, and
+     * executes any of those callbacks found in sequence. The final `Request` object
+     * returned by the last plugin is treated as the cache key for cache reads
+     * and/or writes.
      *
      * @param {Object} options
-     * @param {string} options.cacheName
      * @param {Request} options.request
-     * @param {Response} options.response
-     * @param {Event} [options.event]
+     * @param {string} options.mode
      * @param {Array<Object>} [options.plugins=[]]
-     * @param {Object} [options.matchOptions]
+     * @return {Promise<Request>}
      *
      * @private
      * @memberof module:workbox-core
      */
 
-    const putWrapper = async ({
-      cacheName,
+    const _getEffectiveRequest = async ({
       request,
-      response,
-      event,
-      plugins = [],
-      matchOptions
+      mode,
+      plugins = []
     }) => {
-      {
-        if (request.method && request.method !== 'GET') {
-          throw new WorkboxError('attempt-to-cache-non-get-request', {
-            url: getFriendlyURL(request.url),
-            method: request.method
-          });
-        }
-      }
+      const cacheKeyWillBeUsedPlugins = pluginUtils.filter(plugins, "cacheKeyWillBeUsed"
+      /* CACHE_KEY_WILL_BE_USED */
+      );
+      let effectiveRequest = request;
 
-      const effectiveRequest = await _getEffectiveRequest({
-        plugins,
-        request,
-        mode: 'write'
-      });
+      for (const plugin of cacheKeyWillBeUsedPlugins) {
+        effectiveRequest = await plugin["cacheKeyWillBeUsed"
+        /* CACHE_KEY_WILL_BE_USED */
+        ].call(plugin, {
+          mode,
+          request: effectiveRequest
+        });
 
-      if (!response) {
-        {
-          logger.error(`Cannot cache non-existent response for ` + `'${getFriendlyURL(effectiveRequest.url)}'.`);
+        if (typeof effectiveRequest === 'string') {
+          effectiveRequest = new Request(effectiveRequest);
         }
 
-        throw new WorkboxError('cache-put-with-no-response', {
-          url: getFriendlyURL(effectiveRequest.url)
-        });
+        {
+          finalAssertExports.isInstance(effectiveRequest, Request, {
+            moduleName: 'Plugin',
+            funcName: "cacheKeyWillBeUsed"
+            /* CACHE_KEY_WILL_BE_USED */
+            ,
+            isReturnValueProblem: true
+          });
+        }
       }
 
-      let responseToCache = await _isResponseSafeToCache({
-        event,
-        plugins,
-        response,
-        request: effectiveRequest
-      });
+      return effectiveRequest;
+    };
+    /**
+     * 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
+     */
 
-      if (!responseToCache) {
-        {
-          logger.debug(`Response '${getFriendlyURL(effectiveRequest.url)}' will ` + `not be cached.`, responseToCache);
-        }
 
-        return;
-      }
+    const _isResponseSafeToCache = async ({
+      request,
+      response,
+      event,
+      plugins = []
+    }) => {
+      let responseToCache = response;
+      let pluginsUsed = false;
 
-      const cache = await caches.open(cacheName);
-      const updatePlugins = pluginUtils.filter(plugins, "cacheDidUpdate"
-      /* CACHE_DID_UPDATE */
-      );
-      let oldResponse = updatePlugins.length > 0 ? await matchWrapper({
-        cacheName,
-        matchOptions,
-        request: effectiveRequest
-      }) : null;
+      for (const plugin of plugins) {
+        if ("cacheWillUpdate"
+        /* CACHE_WILL_UPDATE */
+        in plugin) {
+          pluginsUsed = true;
+          const pluginMethod = plugin["cacheWillUpdate"
+          /* CACHE_WILL_UPDATE */
+          ];
+          responseToCache = await pluginMethod.call(plugin, {
+            request,
+            response: responseToCache,
+            event
+          });
 
-      {
-        logger.debug(`Updating the '${cacheName}' cache with a new Response for ` + `${getFriendlyURL(effectiveRequest.url)}.`);
+          {
+            if (responseToCache) {
+              finalAssertExports.isInstance(responseToCache, Response, {
+                moduleName: 'Plugin',
+                funcName: "cacheWillUpdate"
+                /* CACHE_WILL_UPDATE */
+                ,
+                isReturnValueProblem: true
+              });
+            }
+          }
+
+          if (!responseToCache) {
+            break;
+          }
+        }
       }
 
-      try {
-        await cache.put(effectiveRequest, responseToCache);
-      } catch (error) {
-        // See https://developer.mozilla.org/en-US/docs/Web/API/DOMException#exception-QuotaExceededError
-        if (error.name === 'QuotaExceededError') {
-          await executeQuotaErrorCallbacks();
+      if (!pluginsUsed) {
+        {
+          if (responseToCache) {
+            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.`);
+              }
+            }
+          }
         }
 
-        throw error;
+        responseToCache = responseToCache && responseToCache.status === 200 ? responseToCache : undefined;
       }
 
-      for (let plugin of updatePlugins) {
-        await plugin["cacheDidUpdate"
-        /* CACHE_DID_UPDATE */
-        ].call(plugin, {
-          cacheName,
-          event,
-          oldResponse,
-          newResponse: responseToCache,
-          request: effectiveRequest
-        });
-      }
+      return responseToCache ? responseToCache : null;
     };
     /**
      * This is a wrapper around cache.match().
@@ -741,7 +764,7 @@ this.workbox.core = (function (exports) {
      * @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 {Event} [options.event] The event that prompted 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.
@@ -758,7 +781,7 @@ this.workbox.core = (function (exports) {
       matchOptions,
       plugins = []
     }) => {
-      const cache = await caches.open(cacheName);
+      const cache = await self.caches.open(cacheName);
       const effectiveRequest = await _getEffectiveRequest({
         plugins,
         request,
@@ -803,140 +826,207 @@ this.workbox.core = (function (exports) {
         }
       }
 
-      return cachedResponse;
+      return cachedResponse;
+    };
+    /**
+     * 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 (request.method && request.method !== 'GET') {
+          throw new WorkboxError('attempt-to-cache-non-get-request', {
+            url: getFriendlyURL(request.url),
+            method: request.method
+          });
+        }
+      }
+
+      const effectiveRequest = await _getEffectiveRequest({
+        plugins,
+        request,
+        mode: 'write'
+      });
+
+      if (!response) {
+        {
+          logger.error(`Cannot cache non-existent response for ` + `'${getFriendlyURL(effectiveRequest.url)}'.`);
+        }
+
+        throw new WorkboxError('cache-put-with-no-response', {
+          url: getFriendlyURL(effectiveRequest.url)
+        });
+      }
+
+      const responseToCache = await _isResponseSafeToCache({
+        event,
+        plugins,
+        response,
+        request: effectiveRequest
+      });
+
+      if (!responseToCache) {
+        {
+          logger.debug(`Response '${getFriendlyURL(effectiveRequest.url)}' will ` + `not be cached.`, responseToCache);
+        }
+
+        return;
+      }
+
+      const cache = await self.caches.open(cacheName);
+      const updatePlugins = pluginUtils.filter(plugins, "cacheDidUpdate"
+      /* CACHE_DID_UPDATE */
+      );
+      const oldResponse = updatePlugins.length > 0 ? await matchWrapper({
+        cacheName,
+        matchOptions,
+        request: effectiveRequest
+      }) : null;
+
+      {
+        logger.debug(`Updating the '${cacheName}' cache with a new Response for ` + `${getFriendlyURL(effectiveRequest.url)}.`);
+      }
+
+      try {
+        await cache.put(effectiveRequest, 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 (const plugin of updatePlugins) {
+        await plugin["cacheDidUpdate"
+        /* CACHE_DID_UPDATE */
+        ].call(plugin, {
+          cacheName,
+          event,
+          oldResponse,
+          newResponse: responseToCache,
+          request: effectiveRequest
+        });
+      }
+    };
+
+    const cacheWrapper = {
+      put: putWrapper,
+      match: matchWrapper
     };
+
+    /*
+      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.
+    */
+    let supportStatus;
     /**
-     * This method will call cacheWillUpdate on the available plugins (or use
-     * status === 200) to determine if the Response is safe and valid to cache.
+     * A utility function that determines whether the current browser supports
+     * constructing a [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)
+     * object.
      *
-     * @param {Object} options
-     * @param {Request} options.request
-     * @param {Response} options.response
-     * @param {Event} [options.event]
-     * @param {Array<Object>} [options.plugins=[]]
-     * @return {Promise<Response>}
+     * @return {boolean} `true`, if the current browser can successfully
+     *     construct a `ReadableStream`, `false` otherwise.
      *
      * @private
-     * @memberof module:workbox-core
      */
 
+    function canConstructReadableStream() {
+      if (supportStatus === undefined) {
+        // See https://github.com/GoogleChrome/workbox/issues/1473
+        try {
+          new ReadableStream({
+            start() {}
 
-    const _isResponseSafeToCache = async ({
-      request,
-      response,
-      event,
-      plugins = []
-    }) => {
-      let responseToCache = response;
-      let pluginsUsed = false;
-
-      for (let plugin of plugins) {
-        if ("cacheWillUpdate"
-        /* CACHE_WILL_UPDATE */
-        in plugin) {
-          pluginsUsed = true;
-          const pluginMethod = plugin["cacheWillUpdate"
-          /* CACHE_WILL_UPDATE */
-          ];
-          responseToCache = await pluginMethod.call(plugin, {
-            request,
-            response: responseToCache,
-            event
           });
-
-          {
-            if (responseToCache) {
-              finalAssertExports.isInstance(responseToCache, Response, {
-                moduleName: 'Plugin',
-                funcName: "cacheWillUpdate"
-                /* CACHE_WILL_UPDATE */
-                ,
-                isReturnValueProblem: true
-              });
-            }
-          }
-
-          if (!responseToCache) {
-            break;
-          }
+          supportStatus = true;
+        } catch (error) {
+          supportStatus = false;
         }
       }
 
-      if (!pluginsUsed) {
-        {
-          if (responseToCache) {
-            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.`);
-              }
-            }
-          }
-        }
+      return supportStatus;
+    }
 
-        responseToCache = responseToCache && responseToCache.status === 200 ? responseToCache : undefined;
-      }
+    /*
+      Copyright 2019 Google LLC
 
-      return responseToCache ? responseToCache : null;
-    };
+      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.
+    */
+    let supportStatus$1;
     /**
-     * Checks the list of plugins for the cacheKeyWillBeUsed callback, and
-     * executes any of those callbacks found in sequence. The final `Request` object
-     * returned by the last plugin is treated as the cache key for cache reads
-     * and/or writes.
+     * A utility function that determines whether the current browser supports
+     * constructing a new `Response` from a `response.body` stream.
      *
-     * @param {Object} options
-     * @param {Request} options.request
-     * @param {string} options.mode
-     * @param {Array<Object>} [options.plugins=[]]
-     * @return {Promise<Request>}
+     * @return {boolean} `true`, if the current browser can successfully
+     *     construct a `Response` from a `response.body` stream, `false` otherwise.
      *
      * @private
-     * @memberof module:workbox-core
      */
 
+    function canConstructResponseFromBodyStream() {
+      if (supportStatus$1 === undefined) {
+        const testResponse = new Response('');
 
-    const _getEffectiveRequest = async ({
-      request,
-      mode,
-      plugins = []
-    }) => {
-      const cacheKeyWillBeUsedPlugins = pluginUtils.filter(plugins, "cacheKeyWillBeUsed"
-      /* CACHE_KEY_WILL_BE_USED */
-      );
-      let effectiveRequest = request;
-
-      for (const plugin of cacheKeyWillBeUsedPlugins) {
-        effectiveRequest = await plugin["cacheKeyWillBeUsed"
-        /* CACHE_KEY_WILL_BE_USED */
-        ].call(plugin, {
-          mode,
-          request: effectiveRequest
-        });
-
-        if (typeof effectiveRequest === 'string') {
-          effectiveRequest = new Request(effectiveRequest);
+        if ('body' in testResponse) {
+          try {
+            new Response(testResponse.body);
+            supportStatus$1 = true;
+          } catch (error) {
+            supportStatus$1 = false;
+          }
         }
 
-        {
-          finalAssertExports.isInstance(effectiveRequest, Request, {
-            moduleName: 'Plugin',
-            funcName: "cacheKeyWillBeUsed"
-            /* CACHE_KEY_WILL_BE_USED */
-            ,
-            isReturnValueProblem: true
-          });
-        }
+        supportStatus$1 = false;
       }
 
-      return effectiveRequest;
-    };
+      return supportStatus$1;
+    }
 
-    const cacheWrapper = {
-      put: putWrapper,
-      match: matchWrapper
-    };
+    /*
+      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.
+    */
+    /**
+     * A helper function that prevents a promise from being flagged as unused.
+     *
+     * @private
+     **/
+
+    function dontWaitFor(promise) {
+      // Effective no-op.
+      promise.then(() => {});
+    }
 
     /*
       Copyright 2018 Google LLC
@@ -1180,7 +1270,9 @@ this.workbox.core = (function (exports) {
 
       async _call(method, storeName, type, ...args) {
         const callback = (txn, done) => {
-          const objStore = txn.objectStore(storeName);
+          const objStore = txn.objectStore(storeName); // TODO(philipwalton): Fix this underlying TS2684 error.
+          // @ts-ignore
+
           const request = objStore[method].apply(objStore, args);
 
           request.onsuccess = () => done(request.result);
@@ -1311,7 +1403,7 @@ this.workbox.core = (function (exports) {
      * @param {Object} options
      * @param {Request|string} options.request
      * @param {Object} [options.fetchOptions]
-     * @param {Event} [options.event]
+     * @param {ExtendableEvent} [options.event]
      * @param {Array<Object>} [options.plugins=[]]
      * @return {Promise<Response>}
      *
@@ -1363,7 +1455,7 @@ this.workbox.core = (function (exports) {
       const originalRequest = failedFetchPlugins.length > 0 ? request.clone() : null;
 
       try {
-        for (let plugin of plugins) {
+        for (const plugin of plugins) {
           if ("requestWillFetch"
           /* REQUEST_WILL_FETCH */
           in plugin) {
@@ -1398,7 +1490,7 @@ this.workbox.core = (function (exports) {
       // to the Request we make. Pass both to `fetchDidFail` to aid debugging.
 
 
-      let pluginFilteredRequest = request.clone();
+      const pluginFilteredRequest = request.clone();
 
       try {
         let fetchResponse; // See https://github.com/GoogleChrome/workbox/issues/1796
@@ -1464,6 +1556,80 @@ this.workbox.core = (function (exports) {
       fetch: wrappedFetch
     };
 
+    /*
+      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.
+    */
+    /**
+     * Returns a promise that resolves and the passed number of milliseconds.
+     * This utility is an async/await-friendly version of `setTimeout`.
+     *
+     * @param {number} ms
+     * @return {Promise}
+     * @private
+     */
+
+    function timeout(ms) {
+      return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    /*
+      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 MAX_RETRY_TIME = 2000;
+    /**
+     * Returns a promise that resolves to a window client matching the passed
+     * `resultingClientId`. For browsers that don't support `resultingClientId`
+     * or if waiting for the resulting client to apper takes too long, resolve to
+     * `undefined`.
+     *
+     * @param {string} [resultingClientId]
+     * @return {Promise<Client|undefined>}
+     * @private
+     */
+
+    async function resultingClientExists(resultingClientId) {
+      if (!resultingClientId) {
+        return;
+      }
+
+      let existingWindows = await self.clients.matchAll({
+        type: 'window'
+      });
+      const existingWindowIds = new Set(existingWindows.map(w => w.id));
+      let resultingWindow;
+      const startTime = performance.now(); // Only wait up to `MAX_RETRY_TIME` to find a matching client.
+
+      while (performance.now() - startTime < MAX_RETRY_TIME) {
+        existingWindows = await self.clients.matchAll({
+          type: 'window'
+        });
+        resultingWindow = existingWindows.find(w => {
+          if (resultingClientId) {
+            // If we have a `resultingClientId`, we can match on that.
+            return w.id === resultingClientId;
+          } else {
+            // Otherwise match on finding a window not in `existingWindowIds`.
+            return !existingWindowIds.has(w.id);
+          }
+        });
+
+        if (resultingWindow) {
+          break;
+        } // Sleep for 100ms and retry.
+
+
+        await timeout(100);
+      }
+
+      return resultingWindow;
+    }
+
     /*
       Copyright 2018 Google LLC
 
@@ -1473,9 +1639,13 @@ this.workbox.core = (function (exports) {
     */
 
     var _private = /*#__PURE__*/Object.freeze({
+        __proto__: null,
         assert: finalAssertExports,
         cacheNames: cacheNames,
         cacheWrapper: cacheWrapper,
+        canConstructReadableStream: canConstructReadableStream,
+        canConstructResponseFromBodyStream: canConstructResponseFromBodyStream,
+        dontWaitFor: dontWaitFor,
         DBWrapper: DBWrapper,
         Deferred: Deferred,
         deleteDatabase: deleteDatabase,
@@ -1483,27 +1653,11 @@ this.workbox.core = (function (exports) {
         fetchWrapper: fetchWrapper,
         getFriendlyURL: getFriendlyURL,
         logger: logger,
+        resultingClientExists: resultingClientExists,
+        timeout: timeout,
         WorkboxError: WorkboxError
     });
 
-    /*
-      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', () => self.clients.claim());
-    };
-
     /*
       Copyright 2019 Google LLC
 
@@ -1524,7 +1678,7 @@ this.workbox.core = (function (exports) {
      * @return {Object} An object with `precache`, `runtime`, `prefix`, and
      *     `googleAnalytics` properties.
      *
-     * @alias workbox.core.cacheNames
+     * @memberof module:workbox-core
      */
 
     const cacheNames$1 = {
@@ -1550,6 +1704,65 @@ this.workbox.core = (function (exports) {
 
     };
 
+    /*
+      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.
+    */
+    /**
+     * Allows developers to copy a response and modify its `headers`, `status`,
+     * or `statusText` values (the values settable via a
+     * [`ResponseInit`]{@link https://developer.mozilla.org/en-US/docs/Web/API/Response/Response#Syntax}
+     * object in the constructor).
+     * To modify these values, pass a function as the second argument. That
+     * function will be invoked with a single object with the response properties
+     * `{headers, status, statusText}`. The return value of this function will
+     * be used as the `ResponseInit` for the new `Response`. To change the values
+     * either modify the passed parameter(s) and return it, or return a totally
+     * new object.
+     *
+     * @param {Response} response
+     * @param {Function} modifier
+     * @memberof module:workbox-core
+     */
+
+    async function copyResponse(response, modifier) {
+      const clonedResponse = response.clone(); // Create a fresh `ResponseInit` object by cloning the headers.
+
+      const responseInit = {
+        headers: new Headers(clonedResponse.headers),
+        status: clonedResponse.status,
+        statusText: clonedResponse.statusText
+      }; // Apply any user modifications.
+
+      const modifiedResponseInit = modifier ? modifier(responseInit) : responseInit; // Create the new response from the body stream and `ResponseInit`
+      // modifications. Note: not all browsers support the Response.body stream,
+      // so fall back to reading the entire body into memory as a blob.
+
+      const body = canConstructResponseFromBodyStream() ? clonedResponse.body : await clonedResponse.blob();
+      return new Response(body, modifiedResponseInit);
+    }
+
+    /*
+      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()`.
+     *
+     * @memberof module:workbox-core
+     */
+
+    function clientsClaim() {
+      self.addEventListener('activate', () => self.clients.claim());
+    }
+
     /*
       Copyright 2019 Google LLC
 
@@ -1572,10 +1785,10 @@ this.workbox.core = (function (exports) {
      * @param {Object} [details.googleAnalytics] The cache name to use for
      *     `workbox-google-analytics` caching.
      *
-     * @alias workbox.core.setCacheNameDetails
+     * @memberof module:workbox-core
      */
 
-    const setCacheNameDetails = details => {
+    function setCacheNameDetails(details) {
       {
         Object.keys(details).forEach(key => {
           finalAssertExports.isType(details[key], 'string', {
@@ -1585,30 +1798,30 @@ this.workbox.core = (function (exports) {
           });
         });
 
-        if ('precache' in details && details.precache.length === 0) {
+        if ('precache' in details && details['precache'].length === 0) {
           throw new WorkboxError('invalid-cache-name', {
             cacheNameId: 'precache',
-            value: details.precache
+            value: details['precache']
           });
         }
 
-        if ('runtime' in details && details.runtime.length === 0) {
+        if ('runtime' in details && details['runtime'].length === 0) {
           throw new WorkboxError('invalid-cache-name', {
             cacheNameId: 'runtime',
-            value: details.runtime
+            value: details['runtime']
           });
         }
 
-        if ('googleAnalytics' in details && details.googleAnalytics.length === 0) {
+        if ('googleAnalytics' in details && details['googleAnalytics'].length === 0) {
           throw new WorkboxError('invalid-cache-name', {
             cacheNameId: 'googleAnalytics',
-            value: details.googleAnalytics
+            value: details['googleAnalytics']
           });
         }
       }
 
       cacheNames.updateDetails(details);
-    };
+    }
 
     /*
       Copyright 2019 Google LLC
@@ -1618,21 +1831,23 @@ this.workbox.core = (function (exports) {
       https://opensource.org/licenses/MIT.
     */
     /**
-     * Force a service worker to become active, instead of waiting. This is
-     * normally used in conjunction with `clientsClaim()`.
+     * Force a service worker to activate immediately, instead of
+     * [waiting](https://developers.google.com/web/fundamentals/primers/service-workers/lifecycle#waiting)
+     * for existing clients to close.
      *
-     * @alias workbox.core.skipWaiting
+     * @memberof module:workbox-core
      */
 
-    const skipWaiting = () => {
+    function skipWaiting() {
       // We need to explicitly call `self.skipWaiting()` here because we're
       // shadowing `skipWaiting` with this local function.
-      addEventListener('install', () => self.skipWaiting());
-    };
+      self.addEventListener('install', () => self.skipWaiting());
+    }
 
     exports._private = _private;
     exports.cacheNames = cacheNames$1;
     exports.clientsClaim = clientsClaim;
+    exports.copyResponse = copyResponse;
     exports.registerQuotaErrorCallback = registerQuotaErrorCallback;
     exports.setCacheNameDetails = setCacheNameDetails;
     exports.skipWaiting = skipWaiting;