jekyll-pwa-workbox 0.0.6 → 0.0.91

data/lib/vendor/workbox-v5.1.3/workbox-strategies.dev.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workbox-strategies.dev.js","sources":["../_version.js","../utils/messages.js","../CacheFirst.js","../CacheOnly.js","../plugins/cacheOkAndOpaquePlugin.js","../NetworkFirst.js","../NetworkOnly.js","../StaleWhileRevalidate.js"],"sourcesContent":["\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:strategies:5.1.3'] && _();\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 { logger } from 'workbox-core/_private/logger.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport '../_version.js';\nexport const messages = {\n    strategyStart: (strategyName, request) => `Using ${strategyName} to respond to '${getFriendlyURL(request.url)}'`,\n    printFinalResponse: (response) => {\n        if (response) {\n            logger.groupCollapsed(`View the final response here.`);\n            logger.log(response || '[No response returned]');\n            logger.groupEnd();\n        }\n    },\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 { cacheNames } from 'workbox-core/_private/cacheNames.js';\nimport { cacheWrapper } from 'workbox-core/_private/cacheWrapper.js';\nimport { fetchWrapper } from 'workbox-core/_private/fetchWrapper.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { messages } from './utils/messages.js';\nimport './_version.js';\n/**\n * An implementation of a [cache-first]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#cache-falling-back-to-network}\n * request strategy.\n *\n * A cache first strategy is useful for assets that have been revisioned,\n * such as URLs like `/styles/example.a8f5f1.css`, since they\n * can be cached for long periods of time.\n *\n * If the network request fails, and there is no cache match, this will throw\n * a `WorkboxError` exception.\n *\n * @memberof module:workbox-strategies\n */\nclass CacheFirst {\n    /**\n     * @param {Object} options\n     * @param {string} options.cacheName Cache name to store and retrieve\n     * requests. Defaults to cache names provided by\n     * [workbox-core]{@link module:workbox-core.cacheNames}.\n     * @param {Array<Object>} options.plugins [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}\n     * to use in conjunction with this caching strategy.\n     * @param {Object} options.fetchOptions Values passed along to the\n     * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)\n     * of all fetch() requests made by this strategy.\n     * @param {Object} options.matchOptions [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)\n     */\n    constructor(options = {}) {\n        this._cacheName = cacheNames.getRuntimeName(options.cacheName);\n        this._plugins = options.plugins || [];\n        this._fetchOptions = options.fetchOptions;\n        this._matchOptions = options.matchOptions;\n    }\n    /**\n     * This method will perform a request strategy and follows an API that\n     * will work with the\n     * [Workbox Router]{@link module:workbox-routing.Router}.\n     *\n     * @param {Object} options\n     * @param {Request|string} options.request A request to run this strategy for.\n     * @param {Event} [options.event] The event that triggered the request.\n     * @return {Promise<Response>}\n     */\n    async handle({ event, request }) {\n        const logs = [];\n        if (typeof request === 'string') {\n            request = new Request(request);\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isInstance(request, Request, {\n                moduleName: 'workbox-strategies',\n                className: 'CacheFirst',\n                funcName: 'makeRequest',\n                paramName: 'request',\n            });\n        }\n        let response = await cacheWrapper.match({\n            cacheName: this._cacheName,\n            request,\n            event,\n            matchOptions: this._matchOptions,\n            plugins: this._plugins,\n        });\n        let error;\n        if (!response) {\n            if (process.env.NODE_ENV !== 'production') {\n                logs.push(`No response found in the '${this._cacheName}' cache. ` +\n                    `Will respond with a network request.`);\n            }\n            try {\n                response = await this._getFromNetwork(request, event);\n            }\n            catch (err) {\n                error = err;\n            }\n            if (process.env.NODE_ENV !== 'production') {\n                if (response) {\n                    logs.push(`Got response from network.`);\n                }\n                else {\n                    logs.push(`Unable to get a response from the network.`);\n                }\n            }\n        }\n        else {\n            if (process.env.NODE_ENV !== 'production') {\n                logs.push(`Found a cached response in the '${this._cacheName}' cache.`);\n            }\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            logger.groupCollapsed(messages.strategyStart('CacheFirst', request));\n            for (const log of logs) {\n                logger.log(log);\n            }\n            messages.printFinalResponse(response);\n            logger.groupEnd();\n        }\n        if (!response) {\n            throw new WorkboxError('no-response', { url: request.url, error });\n        }\n        return response;\n    }\n    /**\n     * Handles the network and cache part of CacheFirst.\n     *\n     * @param {Request} request\n     * @param {Event} [event]\n     * @return {Promise<Response>}\n     *\n     * @private\n     */\n    async _getFromNetwork(request, event) {\n        const response = await fetchWrapper.fetch({\n            request,\n            event,\n            fetchOptions: this._fetchOptions,\n            plugins: this._plugins,\n        });\n        // Keep the service worker while we put the request to the cache\n        const responseClone = response.clone();\n        const cachePutPromise = cacheWrapper.put({\n            cacheName: this._cacheName,\n            request,\n            response: responseClone,\n            event,\n            plugins: this._plugins,\n        });\n        if (event) {\n            try {\n                event.waitUntil(cachePutPromise);\n            }\n            catch (error) {\n                if (process.env.NODE_ENV !== 'production') {\n                    logger.warn(`Unable to ensure service worker stays alive when ` +\n                        `updating cache for '${getFriendlyURL(request.url)}'.`);\n                }\n            }\n        }\n        return response;\n    }\n}\nexport { CacheFirst };\n","/*\n  Copyright 2018 Google 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 { cacheNames } from 'workbox-core/_private/cacheNames.js';\nimport { cacheWrapper } from 'workbox-core/_private/cacheWrapper.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { messages } from './utils/messages.js';\nimport './_version.js';\n/**\n * An implementation of a\n * [cache-only]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#cache-only}\n * request strategy.\n *\n * This class is useful if you want to take advantage of any\n * [Workbox plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}.\n *\n * If there is no cache match, this will throw a `WorkboxError` exception.\n *\n * @memberof module:workbox-strategies\n */\nclass CacheOnly {\n    /**\n     * @param {Object} options\n     * @param {string} options.cacheName Cache name to store and retrieve\n     * requests. Defaults to cache names provided by\n     * [workbox-core]{@link module:workbox-core.cacheNames}.\n     * @param {Array<Object>} options.plugins [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}\n     * to use in conjunction with this caching strategy.\n     * @param {Object} options.matchOptions [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)\n     */\n    constructor(options = {}) {\n        this._cacheName = cacheNames.getRuntimeName(options.cacheName);\n        this._plugins = options.plugins || [];\n        this._matchOptions = options.matchOptions;\n    }\n    /**\n     * This method will perform a request strategy and follows an API that\n     * will work with the\n     * [Workbox Router]{@link module:workbox-routing.Router}.\n     *\n     * @param {Object} options\n     * @param {Request|string} options.request A request to run this strategy for.\n     * @param {Event} [options.event] The event that triggered the request.\n     * @return {Promise<Response>}\n     */\n    async handle({ event, request }) {\n        if (typeof request === 'string') {\n            request = new Request(request);\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isInstance(request, Request, {\n                moduleName: 'workbox-strategies',\n                className: 'CacheOnly',\n                funcName: 'makeRequest',\n                paramName: 'request',\n            });\n        }\n        const response = await cacheWrapper.match({\n            cacheName: this._cacheName,\n            request,\n            event,\n            matchOptions: this._matchOptions,\n            plugins: this._plugins,\n        });\n        if (process.env.NODE_ENV !== 'production') {\n            logger.groupCollapsed(messages.strategyStart('CacheOnly', request));\n            if (response) {\n                logger.log(`Found a cached response in the '${this._cacheName}'` +\n                    ` cache.`);\n                messages.printFinalResponse(response);\n            }\n            else {\n                logger.log(`No response found in the '${this._cacheName}' cache.`);\n            }\n            logger.groupEnd();\n        }\n        if (!response) {\n            throw new WorkboxError('no-response', { url: request.url });\n        }\n        return response;\n    }\n}\nexport { CacheOnly };\n","/*\n  Copyright 2018 Google 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 cacheOkAndOpaquePlugin = {\n    /**\n     * Returns a valid response (to allow caching) if the status is 200 (OK) or\n     * 0 (opaque).\n     *\n     * @param {Object} options\n     * @param {Response} options.response\n     * @return {Response|null}\n     *\n     * @private\n     */\n    cacheWillUpdate: async ({ response }) => {\n        if (response.status === 200 || response.status === 0) {\n            return response;\n        }\n        return null;\n    },\n};\n","/*\n  Copyright 2018 Google 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 { cacheNames } from 'workbox-core/_private/cacheNames.js';\nimport { cacheWrapper } from 'workbox-core/_private/cacheWrapper.js';\nimport { fetchWrapper } from 'workbox-core/_private/fetchWrapper.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { messages } from './utils/messages.js';\nimport { cacheOkAndOpaquePlugin } from './plugins/cacheOkAndOpaquePlugin.js';\nimport './_version.js';\n/**\n * An implementation of a\n * [network first]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#network-falling-back-to-cache}\n * request strategy.\n *\n * By default, this strategy will cache responses with a 200 status code as\n * well as [opaque responses]{@link https://developers.google.com/web/tools/workbox/guides/handle-third-party-requests}.\n * Opaque responses are are cross-origin requests where the response doesn't\n * support [CORS]{@link https://enable-cors.org/}.\n *\n * If the network request fails, and there is no cache match, this will throw\n * a `WorkboxError` exception.\n *\n * @memberof module:workbox-strategies\n */\nclass NetworkFirst {\n    /**\n     * @param {Object} options\n     * @param {string} options.cacheName Cache name to store and retrieve\n     * requests. Defaults to cache names provided by\n     * [workbox-core]{@link module:workbox-core.cacheNames}.\n     * @param {Array<Object>} options.plugins [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}\n     * to use in conjunction with this caching strategy.\n     * @param {Object} options.fetchOptions Values passed along to the\n     * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)\n     * of all fetch() requests made by this strategy.\n     * @param {Object} options.matchOptions [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)\n     * @param {number} options.networkTimeoutSeconds If set, any network requests\n     * that fail to respond within the timeout will fallback to the cache.\n     *\n     * This option can be used to combat\n     * \"[lie-fi]{@link https://developers.google.com/web/fundamentals/performance/poor-connectivity/#lie-fi}\"\n     * scenarios.\n     */\n    constructor(options = {}) {\n        this._cacheName = cacheNames.getRuntimeName(options.cacheName);\n        if (options.plugins) {\n            const isUsingCacheWillUpdate = options.plugins.some((plugin) => !!plugin.cacheWillUpdate);\n            this._plugins = isUsingCacheWillUpdate ?\n                options.plugins : [cacheOkAndOpaquePlugin, ...options.plugins];\n        }\n        else {\n            // No plugins passed in, use the default plugin.\n            this._plugins = [cacheOkAndOpaquePlugin];\n        }\n        this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;\n        if (process.env.NODE_ENV !== 'production') {\n            if (this._networkTimeoutSeconds) {\n                assert.isType(this._networkTimeoutSeconds, 'number', {\n                    moduleName: 'workbox-strategies',\n                    className: 'NetworkFirst',\n                    funcName: 'constructor',\n                    paramName: 'networkTimeoutSeconds',\n                });\n            }\n        }\n        this._fetchOptions = options.fetchOptions;\n        this._matchOptions = options.matchOptions;\n    }\n    /**\n     * This method will perform a request strategy and follows an API that\n     * will work with the\n     * [Workbox Router]{@link module:workbox-routing.Router}.\n     *\n     * @param {Object} options\n     * @param {Request|string} options.request A request to run this strategy for.\n     * @param {Event} [options.event] The event that triggered the request.\n     * @return {Promise<Response>}\n     */\n    async handle({ event, request }) {\n        const logs = [];\n        if (typeof request === 'string') {\n            request = new Request(request);\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isInstance(request, Request, {\n                moduleName: 'workbox-strategies',\n                className: 'NetworkFirst',\n                funcName: 'handle',\n                paramName: 'makeRequest',\n            });\n        }\n        const promises = [];\n        let timeoutId;\n        if (this._networkTimeoutSeconds) {\n            const { id, promise } = this._getTimeoutPromise({ request, event, logs });\n            timeoutId = id;\n            promises.push(promise);\n        }\n        const networkPromise = this._getNetworkPromise({ timeoutId, request, event, logs });\n        promises.push(networkPromise);\n        // Promise.race() will resolve as soon as the first promise resolves.\n        let response = await Promise.race(promises);\n        // If Promise.race() resolved with null, it might be due to a network\n        // timeout + a cache miss. If that were to happen, we'd rather wait until\n        // the networkPromise resolves instead of returning null.\n        // Note that it's fine to await an already-resolved promise, so we don't\n        // have to check to see if it's still \"in flight\".\n        if (!response) {\n            response = await networkPromise;\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            logger.groupCollapsed(messages.strategyStart('NetworkFirst', request));\n            for (const log of logs) {\n                logger.log(log);\n            }\n            messages.printFinalResponse(response);\n            logger.groupEnd();\n        }\n        if (!response) {\n            throw new WorkboxError('no-response', { url: request.url });\n        }\n        return response;\n    }\n    /**\n     * @param {Object} options\n     * @param {Request} options.request\n     * @param {Array} options.logs A reference to the logs array\n     * @param {Event} [options.event]\n     * @return {Promise<Response>}\n     *\n     * @private\n     */\n    _getTimeoutPromise({ request, logs, event }) {\n        let timeoutId;\n        const timeoutPromise = new Promise((resolve) => {\n            const onNetworkTimeout = async () => {\n                if (process.env.NODE_ENV !== 'production') {\n                    logs.push(`Timing out the network response at ` +\n                        `${this._networkTimeoutSeconds} seconds.`);\n                }\n                resolve(await this._respondFromCache({ request, event }));\n            };\n            timeoutId = setTimeout(onNetworkTimeout, this._networkTimeoutSeconds * 1000);\n        });\n        return {\n            promise: timeoutPromise,\n            id: timeoutId,\n        };\n    }\n    /**\n     * @param {Object} options\n     * @param {number|undefined} options.timeoutId\n     * @param {Request} options.request\n     * @param {Array} options.logs A reference to the logs Array.\n     * @param {Event} [options.event]\n     * @return {Promise<Response>}\n     *\n     * @private\n     */\n    async _getNetworkPromise({ timeoutId, request, logs, event }) {\n        let error;\n        let response;\n        try {\n            response = await fetchWrapper.fetch({\n                request,\n                event,\n                fetchOptions: this._fetchOptions,\n                plugins: this._plugins,\n            });\n        }\n        catch (err) {\n            error = err;\n        }\n        if (timeoutId) {\n            clearTimeout(timeoutId);\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            if (response) {\n                logs.push(`Got response from network.`);\n            }\n            else {\n                logs.push(`Unable to get a response from the network. Will respond ` +\n                    `with a cached response.`);\n            }\n        }\n        if (error || !response) {\n            response = await this._respondFromCache({ request, event });\n            if (process.env.NODE_ENV !== 'production') {\n                if (response) {\n                    logs.push(`Found a cached response in the '${this._cacheName}'` +\n                        ` cache.`);\n                }\n                else {\n                    logs.push(`No response found in the '${this._cacheName}' cache.`);\n                }\n            }\n        }\n        else {\n            // Keep the service worker alive while we put the request in the cache\n            const responseClone = response.clone();\n            const cachePut = cacheWrapper.put({\n                cacheName: this._cacheName,\n                request,\n                response: responseClone,\n                event,\n                plugins: this._plugins,\n            });\n            if (event) {\n                try {\n                    // The event has been responded to so we can keep the SW alive to\n                    // respond to the request\n                    event.waitUntil(cachePut);\n                }\n                catch (err) {\n                    if (process.env.NODE_ENV !== 'production') {\n                        logger.warn(`Unable to ensure service worker stays alive when ` +\n                            `updating cache for '${getFriendlyURL(request.url)}'.`);\n                    }\n                }\n            }\n        }\n        return response;\n    }\n    /**\n     * Used if the network timeouts or fails to make the request.\n     *\n     * @param {Object} options\n     * @param {Request} request The request to match in the cache\n     * @param {Event} [options.event]\n     * @return {Promise<Object>}\n     *\n     * @private\n     */\n    _respondFromCache({ event, request }) {\n        return cacheWrapper.match({\n            cacheName: this._cacheName,\n            request,\n            event,\n            matchOptions: this._matchOptions,\n            plugins: this._plugins,\n        });\n    }\n}\nexport { NetworkFirst };\n","/*\n  Copyright 2018 Google 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 { fetchWrapper } from 'workbox-core/_private/fetchWrapper.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { messages } from './utils/messages.js';\nimport './_version.js';\n/**\n * An implementation of a\n * [network-only]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#network-only}\n * request strategy.\n *\n * This class is useful if you want to take advantage of any\n * [Workbox plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}.\n *\n * If the network request fails, this will throw a `WorkboxError` exception.\n *\n * @memberof module:workbox-strategies\n */\nclass NetworkOnly {\n    /**\n     * @param {Object} options\n     * @param {string} options.cacheName Cache name to store and retrieve\n     * requests. Defaults to cache names provided by\n     * [workbox-core]{@link module:workbox-core.cacheNames}.\n     * @param {Array<Object>} options.plugins [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}\n     * to use in conjunction with this caching strategy.\n     * @param {Object} options.fetchOptions Values passed along to the\n     * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)\n     * of all fetch() requests made by this strategy.\n     */\n    constructor(options = {}) {\n        this._plugins = options.plugins || [];\n        this._fetchOptions = options.fetchOptions;\n    }\n    /**\n     * This method will perform a request strategy and follows an API that\n     * will work with the\n     * [Workbox Router]{@link module:workbox-routing.Router}.\n     *\n     * @param {Object} options\n     * @param {Request|string} options.request The request to run this strategy for.\n     * @param {Event} [options.event] The event that triggered the request.\n     * @return {Promise<Response>}\n     */\n    async handle({ event, request }) {\n        if (typeof request === 'string') {\n            request = new Request(request);\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isInstance(request, Request, {\n                moduleName: 'workbox-strategies',\n                className: 'NetworkOnly',\n                funcName: 'handle',\n                paramName: 'request',\n            });\n        }\n        let error;\n        let response;\n        try {\n            response = await fetchWrapper.fetch({\n                request,\n                event,\n                fetchOptions: this._fetchOptions,\n                plugins: this._plugins,\n            });\n        }\n        catch (err) {\n            error = err;\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            logger.groupCollapsed(messages.strategyStart('NetworkOnly', request));\n            if (response) {\n                logger.log(`Got response from network.`);\n            }\n            else {\n                logger.log(`Unable to get a response from the network.`);\n            }\n            messages.printFinalResponse(response);\n            logger.groupEnd();\n        }\n        if (!response) {\n            throw new WorkboxError('no-response', { url: request.url, error });\n        }\n        return response;\n    }\n}\nexport { NetworkOnly };\n","/*\n  Copyright 2018 Google 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 { cacheNames } from 'workbox-core/_private/cacheNames.js';\nimport { cacheWrapper } from 'workbox-core/_private/cacheWrapper.js';\nimport { fetchWrapper } from 'workbox-core/_private/fetchWrapper.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { messages } from './utils/messages.js';\nimport { cacheOkAndOpaquePlugin } from './plugins/cacheOkAndOpaquePlugin.js';\nimport './_version.js';\n/**\n * An implementation of a\n * [stale-while-revalidate]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#stale-while-revalidate}\n * request strategy.\n *\n * Resources are requested from both the cache and the network in parallel.\n * The strategy will respond with the cached version if available, otherwise\n * wait for the network response. The cache is updated with the network response\n * with each successful request.\n *\n * By default, this strategy will cache responses with a 200 status code as\n * well as [opaque responses]{@link https://developers.google.com/web/tools/workbox/guides/handle-third-party-requests}.\n * Opaque responses are cross-origin requests where the response doesn't\n * support [CORS]{@link https://enable-cors.org/}.\n *\n * If the network request fails, and there is no cache match, this will throw\n * a `WorkboxError` exception.\n *\n * @memberof module:workbox-strategies\n */\nclass StaleWhileRevalidate {\n    /**\n     * @param {Object} options\n     * @param {string} options.cacheName Cache name to store and retrieve\n     * requests. Defaults to cache names provided by\n     * [workbox-core]{@link module:workbox-core.cacheNames}.\n     * @param {Array<Object>} options.plugins [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}\n     * to use in conjunction with this caching strategy.\n     * @param {Object} options.fetchOptions Values passed along to the\n     * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)\n     * of all fetch() requests made by this strategy.\n     * @param {Object} options.matchOptions [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)\n     */\n    constructor(options = {}) {\n        this._cacheName = cacheNames.getRuntimeName(options.cacheName);\n        this._plugins = options.plugins || [];\n        if (options.plugins) {\n            const isUsingCacheWillUpdate = options.plugins.some((plugin) => !!plugin.cacheWillUpdate);\n            this._plugins = isUsingCacheWillUpdate ?\n                options.plugins : [cacheOkAndOpaquePlugin, ...options.plugins];\n        }\n        else {\n            // No plugins passed in, use the default plugin.\n            this._plugins = [cacheOkAndOpaquePlugin];\n        }\n        this._fetchOptions = options.fetchOptions;\n        this._matchOptions = options.matchOptions;\n    }\n    /**\n     * This method will perform a request strategy and follows an API that\n     * will work with the\n     * [Workbox Router]{@link module:workbox-routing.Router}.\n     *\n     * @param {Object} options\n     * @param {Request|string} options.request A request to run this strategy for.\n     * @param {Event} [options.event] The event that triggered the request.\n     * @return {Promise<Response>}\n     */\n    async handle({ event, request }) {\n        const logs = [];\n        if (typeof request === 'string') {\n            request = new Request(request);\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isInstance(request, Request, {\n                moduleName: 'workbox-strategies',\n                className: 'StaleWhileRevalidate',\n                funcName: 'handle',\n                paramName: 'request',\n            });\n        }\n        const fetchAndCachePromise = this._getFromNetwork({ request, event });\n        let response = await cacheWrapper.match({\n            cacheName: this._cacheName,\n            request,\n            event,\n            matchOptions: this._matchOptions,\n            plugins: this._plugins,\n        });\n        let error;\n        if (response) {\n            if (process.env.NODE_ENV !== 'production') {\n                logs.push(`Found a cached response in the '${this._cacheName}'` +\n                    ` cache. Will update with the network response in the background.`);\n            }\n            if (event) {\n                try {\n                    event.waitUntil(fetchAndCachePromise);\n                }\n                catch (error) {\n                    if (process.env.NODE_ENV !== 'production') {\n                        logger.warn(`Unable to ensure service worker stays alive when ` +\n                            `updating cache for '${getFriendlyURL(request.url)}'.`);\n                    }\n                }\n            }\n        }\n        else {\n            if (process.env.NODE_ENV !== 'production') {\n                logs.push(`No response found in the '${this._cacheName}' cache. ` +\n                    `Will wait for the network response.`);\n            }\n            try {\n                response = await fetchAndCachePromise;\n            }\n            catch (err) {\n                error = err;\n            }\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            logger.groupCollapsed(messages.strategyStart('StaleWhileRevalidate', request));\n            for (const log of logs) {\n                logger.log(log);\n            }\n            messages.printFinalResponse(response);\n            logger.groupEnd();\n        }\n        if (!response) {\n            throw new WorkboxError('no-response', { url: request.url, error });\n        }\n        return response;\n    }\n    /**\n     * @param {Object} options\n     * @param {Request} options.request\n     * @param {Event} [options.event]\n     * @return {Promise<Response>}\n     *\n     * @private\n     */\n    async _getFromNetwork({ request, event }) {\n        const response = await fetchWrapper.fetch({\n            request,\n            event,\n            fetchOptions: this._fetchOptions,\n            plugins: this._plugins,\n        });\n        const cachePutPromise = cacheWrapper.put({\n            cacheName: this._cacheName,\n            request,\n            response: response.clone(),\n            event,\n            plugins: this._plugins,\n        });\n        if (event) {\n            try {\n                event.waitUntil(cachePutPromise);\n            }\n            catch (error) {\n                if (process.env.NODE_ENV !== 'production') {\n                    logger.warn(`Unable to ensure service worker stays alive when ` +\n                        `updating cache for '${getFriendlyURL(request.url)}'.`);\n                }\n            }\n        }\n        return response;\n    }\n}\nexport { StaleWhileRevalidate };\n"],"names":["self","_","e","messages","strategyStart","strategyName","request","getFriendlyURL","url","printFinalResponse","response","logger","groupCollapsed","log","groupEnd","CacheFirst","constructor","options","_cacheName","cacheNames","getRuntimeName","cacheName","_plugins","plugins","_fetchOptions","fetchOptions","_matchOptions","matchOptions","handle","event","logs","Request","assert","isInstance","moduleName","className","funcName","paramName","cacheWrapper","match","error","push","_getFromNetwork","err","WorkboxError","fetchWrapper","fetch","responseClone","clone","cachePutPromise","put","waitUntil","warn","CacheOnly","cacheOkAndOpaquePlugin","cacheWillUpdate","status","NetworkFirst","isUsingCacheWillUpdate","some","plugin","_networkTimeoutSeconds","networkTimeoutSeconds","isType","promises","timeoutId","id","promise","_getTimeoutPromise","networkPromise","_getNetworkPromise","Promise","race","timeoutPromise","resolve","onNetworkTimeout","_respondFromCache","setTimeout","clearTimeout","cachePut","NetworkOnly","StaleWhileRevalidate","fetchAndCachePromise"],"mappings":";;;;IAEA,IAAI;IACAA,EAAAA,IAAI,CAAC,0BAAD,CAAJ,IAAoCC,CAAC,EAArC;IACH,CAFD,CAGA,OAAOC,CAAP,EAAU;;ICLV;;;;;;;AAOA,IAGO,MAAMC,QAAQ,GAAG;IACpBC,EAAAA,aAAa,EAAE,CAACC,YAAD,EAAeC,OAAf,KAA4B,SAAQD,YAAa,mBAAkBE,gCAAc,CAACD,OAAO,CAACE,GAAT,CAAc,GAD1F;IAEpBC,EAAAA,kBAAkB,EAAGC,QAAD,IAAc;IAC9B,QAAIA,QAAJ,EAAc;IACVC,MAAAA,gBAAM,CAACC,cAAP,CAAuB,+BAAvB;IACAD,MAAAA,gBAAM,CAACE,GAAP,CAAWH,QAAQ,IAAI,wBAAvB;IACAC,MAAAA,gBAAM,CAACG,QAAP;IACH;IACJ;IARmB,CAAjB;;ICVP;;;;;;;AAOA,IASA;;;;;;;;;;;;;;IAaA,MAAMC,UAAN,CAAiB;IACb;;;;;;;;;;;;IAYAC,EAAAA,WAAW,CAACC,OAAO,GAAG,EAAX,EAAe;IACtB,SAAKC,UAAL,GAAkBC,wBAAU,CAACC,cAAX,CAA0BH,OAAO,CAACI,SAAlC,CAAlB;IACA,SAAKC,QAAL,GAAgBL,OAAO,CAACM,OAAR,IAAmB,EAAnC;IACA,SAAKC,aAAL,GAAqBP,OAAO,CAACQ,YAA7B;IACA,SAAKC,aAAL,GAAqBT,OAAO,CAACU,YAA7B;IACH;IACD;;;;;;;;;;;;IAUA,QAAMC,MAAN,CAAa;IAAEC,IAAAA,KAAF;IAASvB,IAAAA;IAAT,GAAb,EAAiC;IAC7B,UAAMwB,IAAI,GAAG,EAAb;;IACA,QAAI,OAAOxB,OAAP,KAAmB,QAAvB,EAAiC;IAC7BA,MAAAA,OAAO,GAAG,IAAIyB,OAAJ,CAAYzB,OAAZ,CAAV;IACH;;IACD,IAA2C;IACvC0B,MAAAA,gBAAM,CAACC,UAAP,CAAkB3B,OAAlB,EAA2ByB,OAA3B,EAAoC;IAChCG,QAAAA,UAAU,EAAE,oBADoB;IAEhCC,QAAAA,SAAS,EAAE,YAFqB;IAGhCC,QAAAA,QAAQ,EAAE,aAHsB;IAIhCC,QAAAA,SAAS,EAAE;IAJqB,OAApC;IAMH;;IACD,QAAI3B,QAAQ,GAAG,MAAM4B,4BAAY,CAACC,KAAb,CAAmB;IACpClB,MAAAA,SAAS,EAAE,KAAKH,UADoB;IAEpCZ,MAAAA,OAFoC;IAGpCuB,MAAAA,KAHoC;IAIpCF,MAAAA,YAAY,EAAE,KAAKD,aAJiB;IAKpCH,MAAAA,OAAO,EAAE,KAAKD;IALsB,KAAnB,CAArB;IAOA,QAAIkB,KAAJ;;IACA,QAAI,CAAC9B,QAAL,EAAe;IACX,MAA2C;IACvCoB,QAAAA,IAAI,CAACW,IAAL,CAAW,6BAA4B,KAAKvB,UAAW,WAA7C,GACL,sCADL;IAEH;;IACD,UAAI;IACAR,QAAAA,QAAQ,GAAG,MAAM,KAAKgC,eAAL,CAAqBpC,OAArB,EAA8BuB,KAA9B,CAAjB;IACH,OAFD,CAGA,OAAOc,GAAP,EAAY;IACRH,QAAAA,KAAK,GAAGG,GAAR;IACH;;IACD,MAA2C;IACvC,YAAIjC,QAAJ,EAAc;IACVoB,UAAAA,IAAI,CAACW,IAAL,CAAW,4BAAX;IACH,SAFD,MAGK;IACDX,UAAAA,IAAI,CAACW,IAAL,CAAW,4CAAX;IACH;IACJ;IACJ,KAnBD,MAoBK;IACD,MAA2C;IACvCX,QAAAA,IAAI,CAACW,IAAL,CAAW,mCAAkC,KAAKvB,UAAW,UAA7D;IACH;IACJ;;IACD,IAA2C;IACvCP,MAAAA,gBAAM,CAACC,cAAP,CAAsBT,QAAQ,CAACC,aAAT,CAAuB,YAAvB,EAAqCE,OAArC,CAAtB;;IACA,WAAK,MAAMO,GAAX,IAAkBiB,IAAlB,EAAwB;IACpBnB,QAAAA,gBAAM,CAACE,GAAP,CAAWA,GAAX;IACH;;IACDV,MAAAA,QAAQ,CAACM,kBAAT,CAA4BC,QAA5B;IACAC,MAAAA,gBAAM,CAACG,QAAP;IACH;;IACD,QAAI,CAACJ,QAAL,EAAe;IACX,YAAM,IAAIkC,4BAAJ,CAAiB,aAAjB,EAAgC;IAAEpC,QAAAA,GAAG,EAAEF,OAAO,CAACE,GAAf;IAAoBgC,QAAAA;IAApB,OAAhC,CAAN;IACH;;IACD,WAAO9B,QAAP;IACH;IACD;;;;;;;;;;;IASA,QAAMgC,eAAN,CAAsBpC,OAAtB,EAA+BuB,KAA/B,EAAsC;IAClC,UAAMnB,QAAQ,GAAG,MAAMmC,4BAAY,CAACC,KAAb,CAAmB;IACtCxC,MAAAA,OADsC;IAEtCuB,MAAAA,KAFsC;IAGtCJ,MAAAA,YAAY,EAAE,KAAKD,aAHmB;IAItCD,MAAAA,OAAO,EAAE,KAAKD;IAJwB,KAAnB,CAAvB,CADkC;;IAQlC,UAAMyB,aAAa,GAAGrC,QAAQ,CAACsC,KAAT,EAAtB;IACA,UAAMC,eAAe,GAAGX,4BAAY,CAACY,GAAb,CAAiB;IACrC7B,MAAAA,SAAS,EAAE,KAAKH,UADqB;IAErCZ,MAAAA,OAFqC;IAGrCI,MAAAA,QAAQ,EAAEqC,aAH2B;IAIrClB,MAAAA,KAJqC;IAKrCN,MAAAA,OAAO,EAAE,KAAKD;IALuB,KAAjB,CAAxB;;IAOA,QAAIO,KAAJ,EAAW;IACP,UAAI;IACAA,QAAAA,KAAK,CAACsB,SAAN,CAAgBF,eAAhB;IACH,OAFD,CAGA,OAAOT,KAAP,EAAc;IACV,QAA2C;IACvC7B,UAAAA,gBAAM,CAACyC,IAAP,CAAa,mDAAD,GACP,uBAAsB7C,gCAAc,CAACD,OAAO,CAACE,GAAT,CAAc,IADvD;IAEH;IACJ;IACJ;;IACD,WAAOE,QAAP;IACH;;IA7HY;;IC7BjB;;;;;;;AAOA,IAOA;;;;;;;;;;;;;IAYA,MAAM2C,SAAN,CAAgB;IACZ;;;;;;;;;IASArC,EAAAA,WAAW,CAACC,OAAO,GAAG,EAAX,EAAe;IACtB,SAAKC,UAAL,GAAkBC,wBAAU,CAACC,cAAX,CAA0BH,OAAO,CAACI,SAAlC,CAAlB;IACA,SAAKC,QAAL,GAAgBL,OAAO,CAACM,OAAR,IAAmB,EAAnC;IACA,SAAKG,aAAL,GAAqBT,OAAO,CAACU,YAA7B;IACH;IACD;;;;;;;;;;;;IAUA,QAAMC,MAAN,CAAa;IAAEC,IAAAA,KAAF;IAASvB,IAAAA;IAAT,GAAb,EAAiC;IAC7B,QAAI,OAAOA,OAAP,KAAmB,QAAvB,EAAiC;IAC7BA,MAAAA,OAAO,GAAG,IAAIyB,OAAJ,CAAYzB,OAAZ,CAAV;IACH;;IACD,IAA2C;IACvC0B,MAAAA,gBAAM,CAACC,UAAP,CAAkB3B,OAAlB,EAA2ByB,OAA3B,EAAoC;IAChCG,QAAAA,UAAU,EAAE,oBADoB;IAEhCC,QAAAA,SAAS,EAAE,WAFqB;IAGhCC,QAAAA,QAAQ,EAAE,aAHsB;IAIhCC,QAAAA,SAAS,EAAE;IAJqB,OAApC;IAMH;;IACD,UAAM3B,QAAQ,GAAG,MAAM4B,4BAAY,CAACC,KAAb,CAAmB;IACtClB,MAAAA,SAAS,EAAE,KAAKH,UADsB;IAEtCZ,MAAAA,OAFsC;IAGtCuB,MAAAA,KAHsC;IAItCF,MAAAA,YAAY,EAAE,KAAKD,aAJmB;IAKtCH,MAAAA,OAAO,EAAE,KAAKD;IALwB,KAAnB,CAAvB;;IAOA,IAA2C;IACvCX,MAAAA,gBAAM,CAACC,cAAP,CAAsBT,QAAQ,CAACC,aAAT,CAAuB,WAAvB,EAAoCE,OAApC,CAAtB;;IACA,UAAII,QAAJ,EAAc;IACVC,QAAAA,gBAAM,CAACE,GAAP,CAAY,mCAAkC,KAAKK,UAAW,GAAnD,GACN,SADL;IAEAf,QAAAA,QAAQ,CAACM,kBAAT,CAA4BC,QAA5B;IACH,OAJD,MAKK;IACDC,QAAAA,gBAAM,CAACE,GAAP,CAAY,6BAA4B,KAAKK,UAAW,UAAxD;IACH;;IACDP,MAAAA,gBAAM,CAACG,QAAP;IACH;;IACD,QAAI,CAACJ,QAAL,EAAe;IACX,YAAM,IAAIkC,4BAAJ,CAAiB,aAAjB,EAAgC;IAAEpC,QAAAA,GAAG,EAAEF,OAAO,CAACE;IAAf,OAAhC,CAAN;IACH;;IACD,WAAOE,QAAP;IACH;;IA5DW;;IC1BhB;;;;;;;AAOA,IACO,MAAM4C,sBAAsB,GAAG;IAClC;;;;;;;;;;IAUAC,EAAAA,eAAe,EAAE,OAAO;IAAE7C,IAAAA;IAAF,GAAP,KAAwB;IACrC,QAAIA,QAAQ,CAAC8C,MAAT,KAAoB,GAApB,IAA2B9C,QAAQ,CAAC8C,MAAT,KAAoB,CAAnD,EAAsD;IAClD,aAAO9C,QAAP;IACH;;IACD,WAAO,IAAP;IACH;IAhBiC,CAA/B;;ICRP;;;;;;;AAOA,IAUA;;;;;;;;;;;;;;;;IAeA,MAAM+C,YAAN,CAAmB;IACf;;;;;;;;;;;;;;;;;;IAkBAzC,EAAAA,WAAW,CAACC,OAAO,GAAG,EAAX,EAAe;IACtB,SAAKC,UAAL,GAAkBC,wBAAU,CAACC,cAAX,CAA0BH,OAAO,CAACI,SAAlC,CAAlB;;IACA,QAAIJ,OAAO,CAACM,OAAZ,EAAqB;IACjB,YAAMmC,sBAAsB,GAAGzC,OAAO,CAACM,OAAR,CAAgBoC,IAAhB,CAAsBC,MAAD,IAAY,CAAC,CAACA,MAAM,CAACL,eAA1C,CAA/B;IACA,WAAKjC,QAAL,GAAgBoC,sBAAsB,GAClCzC,OAAO,CAACM,OAD0B,GAChB,CAAC+B,sBAAD,EAAyB,GAAGrC,OAAO,CAACM,OAApC,CADtB;IAEH,KAJD,MAKK;IACD;IACA,WAAKD,QAAL,GAAgB,CAACgC,sBAAD,CAAhB;IACH;;IACD,SAAKO,sBAAL,GAA8B5C,OAAO,CAAC6C,qBAAR,IAAiC,CAA/D;;IACA,IAA2C;IACvC,UAAI,KAAKD,sBAAT,EAAiC;IAC7B7B,QAAAA,gBAAM,CAAC+B,MAAP,CAAc,KAAKF,sBAAnB,EAA2C,QAA3C,EAAqD;IACjD3B,UAAAA,UAAU,EAAE,oBADqC;IAEjDC,UAAAA,SAAS,EAAE,cAFsC;IAGjDC,UAAAA,QAAQ,EAAE,aAHuC;IAIjDC,UAAAA,SAAS,EAAE;IAJsC,SAArD;IAMH;IACJ;;IACD,SAAKb,aAAL,GAAqBP,OAAO,CAACQ,YAA7B;IACA,SAAKC,aAAL,GAAqBT,OAAO,CAACU,YAA7B;IACH;IACD;;;;;;;;;;;;IAUA,QAAMC,MAAN,CAAa;IAAEC,IAAAA,KAAF;IAASvB,IAAAA;IAAT,GAAb,EAAiC;IAC7B,UAAMwB,IAAI,GAAG,EAAb;;IACA,QAAI,OAAOxB,OAAP,KAAmB,QAAvB,EAAiC;IAC7BA,MAAAA,OAAO,GAAG,IAAIyB,OAAJ,CAAYzB,OAAZ,CAAV;IACH;;IACD,IAA2C;IACvC0B,MAAAA,gBAAM,CAACC,UAAP,CAAkB3B,OAAlB,EAA2ByB,OAA3B,EAAoC;IAChCG,QAAAA,UAAU,EAAE,oBADoB;IAEhCC,QAAAA,SAAS,EAAE,cAFqB;IAGhCC,QAAAA,QAAQ,EAAE,QAHsB;IAIhCC,QAAAA,SAAS,EAAE;IAJqB,OAApC;IAMH;;IACD,UAAM2B,QAAQ,GAAG,EAAjB;IACA,QAAIC,SAAJ;;IACA,QAAI,KAAKJ,sBAAT,EAAiC;IAC7B,YAAM;IAAEK,QAAAA,EAAF;IAAMC,QAAAA;IAAN,UAAkB,KAAKC,kBAAL,CAAwB;IAAE9D,QAAAA,OAAF;IAAWuB,QAAAA,KAAX;IAAkBC,QAAAA;IAAlB,OAAxB,CAAxB;;IACAmC,MAAAA,SAAS,GAAGC,EAAZ;IACAF,MAAAA,QAAQ,CAACvB,IAAT,CAAc0B,OAAd;IACH;;IACD,UAAME,cAAc,GAAG,KAAKC,kBAAL,CAAwB;IAAEL,MAAAA,SAAF;IAAa3D,MAAAA,OAAb;IAAsBuB,MAAAA,KAAtB;IAA6BC,MAAAA;IAA7B,KAAxB,CAAvB;;IACAkC,IAAAA,QAAQ,CAACvB,IAAT,CAAc4B,cAAd,EArB6B;;IAuB7B,QAAI3D,QAAQ,GAAG,MAAM6D,OAAO,CAACC,IAAR,CAAaR,QAAb,CAArB,CAvB6B;IAyB7B;IACA;IACA;IACA;;IACA,QAAI,CAACtD,QAAL,EAAe;IACXA,MAAAA,QAAQ,GAAG,MAAM2D,cAAjB;IACH;;IACD,IAA2C;IACvC1D,MAAAA,gBAAM,CAACC,cAAP,CAAsBT,QAAQ,CAACC,aAAT,CAAuB,cAAvB,EAAuCE,OAAvC,CAAtB;;IACA,WAAK,MAAMO,GAAX,IAAkBiB,IAAlB,EAAwB;IACpBnB,QAAAA,gBAAM,CAACE,GAAP,CAAWA,GAAX;IACH;;IACDV,MAAAA,QAAQ,CAACM,kBAAT,CAA4BC,QAA5B;IACAC,MAAAA,gBAAM,CAACG,QAAP;IACH;;IACD,QAAI,CAACJ,QAAL,EAAe;IACX,YAAM,IAAIkC,4BAAJ,CAAiB,aAAjB,EAAgC;IAAEpC,QAAAA,GAAG,EAAEF,OAAO,CAACE;IAAf,OAAhC,CAAN;IACH;;IACD,WAAOE,QAAP;IACH;IACD;;;;;;;;;;;IASA0D,EAAAA,kBAAkB,CAAC;IAAE9D,IAAAA,OAAF;IAAWwB,IAAAA,IAAX;IAAiBD,IAAAA;IAAjB,GAAD,EAA2B;IACzC,QAAIoC,SAAJ;IACA,UAAMQ,cAAc,GAAG,IAAIF,OAAJ,CAAaG,OAAD,IAAa;IAC5C,YAAMC,gBAAgB,GAAG,YAAY;IACjC,QAA2C;IACvC7C,UAAAA,IAAI,CAACW,IAAL,CAAW,qCAAD,GACL,GAAE,KAAKoB,sBAAuB,WADnC;IAEH;;IACDa,QAAAA,OAAO,EAAC,MAAM,KAAKE,iBAAL,CAAuB;IAAEtE,UAAAA,OAAF;IAAWuB,UAAAA;IAAX,SAAvB,CAAP,EAAP;IACH,OAND;;IAOAoC,MAAAA,SAAS,GAAGY,UAAU,CAACF,gBAAD,EAAmB,KAAKd,sBAAL,GAA8B,IAAjD,CAAtB;IACH,KATsB,CAAvB;IAUA,WAAO;IACHM,MAAAA,OAAO,EAAEM,cADN;IAEHP,MAAAA,EAAE,EAAED;IAFD,KAAP;IAIH;IACD;;;;;;;;;;;;IAUA,QAAMK,kBAAN,CAAyB;IAAEL,IAAAA,SAAF;IAAa3D,IAAAA,OAAb;IAAsBwB,IAAAA,IAAtB;IAA4BD,IAAAA;IAA5B,GAAzB,EAA8D;IAC1D,QAAIW,KAAJ;IACA,QAAI9B,QAAJ;;IACA,QAAI;IACAA,MAAAA,QAAQ,GAAG,MAAMmC,4BAAY,CAACC,KAAb,CAAmB;IAChCxC,QAAAA,OADgC;IAEhCuB,QAAAA,KAFgC;IAGhCJ,QAAAA,YAAY,EAAE,KAAKD,aAHa;IAIhCD,QAAAA,OAAO,EAAE,KAAKD;IAJkB,OAAnB,CAAjB;IAMH,KAPD,CAQA,OAAOqB,GAAP,EAAY;IACRH,MAAAA,KAAK,GAAGG,GAAR;IACH;;IACD,QAAIsB,SAAJ,EAAe;IACXa,MAAAA,YAAY,CAACb,SAAD,CAAZ;IACH;;IACD,IAA2C;IACvC,UAAIvD,QAAJ,EAAc;IACVoB,QAAAA,IAAI,CAACW,IAAL,CAAW,4BAAX;IACH,OAFD,MAGK;IACDX,QAAAA,IAAI,CAACW,IAAL,CAAW,0DAAD,GACL,yBADL;IAEH;IACJ;;IACD,QAAID,KAAK,IAAI,CAAC9B,QAAd,EAAwB;IACpBA,MAAAA,QAAQ,GAAG,MAAM,KAAKkE,iBAAL,CAAuB;IAAEtE,QAAAA,OAAF;IAAWuB,QAAAA;IAAX,OAAvB,CAAjB;;IACA,MAA2C;IACvC,YAAInB,QAAJ,EAAc;IACVoB,UAAAA,IAAI,CAACW,IAAL,CAAW,mCAAkC,KAAKvB,UAAW,GAAnD,GACL,SADL;IAEH,SAHD,MAIK;IACDY,UAAAA,IAAI,CAACW,IAAL,CAAW,6BAA4B,KAAKvB,UAAW,UAAvD;IACH;IACJ;IACJ,KAXD,MAYK;IACD;IACA,YAAM6B,aAAa,GAAGrC,QAAQ,CAACsC,KAAT,EAAtB;IACA,YAAM+B,QAAQ,GAAGzC,4BAAY,CAACY,GAAb,CAAiB;IAC9B7B,QAAAA,SAAS,EAAE,KAAKH,UADc;IAE9BZ,QAAAA,OAF8B;IAG9BI,QAAAA,QAAQ,EAAEqC,aAHoB;IAI9BlB,QAAAA,KAJ8B;IAK9BN,QAAAA,OAAO,EAAE,KAAKD;IALgB,OAAjB,CAAjB;;IAOA,UAAIO,KAAJ,EAAW;IACP,YAAI;IACA;IACA;IACAA,UAAAA,KAAK,CAACsB,SAAN,CAAgB4B,QAAhB;IACH,SAJD,CAKA,OAAOpC,GAAP,EAAY;IACR,UAA2C;IACvChC,YAAAA,gBAAM,CAACyC,IAAP,CAAa,mDAAD,GACP,uBAAsB7C,gCAAc,CAACD,OAAO,CAACE,GAAT,CAAc,IADvD;IAEH;IACJ;IACJ;IACJ;;IACD,WAAOE,QAAP;IACH;IACD;;;;;;;;;;;;IAUAkE,EAAAA,iBAAiB,CAAC;IAAE/C,IAAAA,KAAF;IAASvB,IAAAA;IAAT,GAAD,EAAqB;IAClC,WAAOgC,4BAAY,CAACC,KAAb,CAAmB;IACtBlB,MAAAA,SAAS,EAAE,KAAKH,UADM;IAEtBZ,MAAAA,OAFsB;IAGtBuB,MAAAA,KAHsB;IAItBF,MAAAA,YAAY,EAAE,KAAKD,aAJG;IAKtBH,MAAAA,OAAO,EAAE,KAAKD;IALQ,KAAnB,CAAP;IAOH;;IAzNc;;IChCnB;;;;;;;AAOA,IAMA;;;;;;;;;;;;;IAYA,MAAM0D,WAAN,CAAkB;IACd;;;;;;;;;;;IAWAhE,EAAAA,WAAW,CAACC,OAAO,GAAG,EAAX,EAAe;IACtB,SAAKK,QAAL,GAAgBL,OAAO,CAACM,OAAR,IAAmB,EAAnC;IACA,SAAKC,aAAL,GAAqBP,OAAO,CAACQ,YAA7B;IACH;IACD;;;;;;;;;;;;IAUA,QAAMG,MAAN,CAAa;IAAEC,IAAAA,KAAF;IAASvB,IAAAA;IAAT,GAAb,EAAiC;IAC7B,QAAI,OAAOA,OAAP,KAAmB,QAAvB,EAAiC;IAC7BA,MAAAA,OAAO,GAAG,IAAIyB,OAAJ,CAAYzB,OAAZ,CAAV;IACH;;IACD,IAA2C;IACvC0B,MAAAA,gBAAM,CAACC,UAAP,CAAkB3B,OAAlB,EAA2ByB,OAA3B,EAAoC;IAChCG,QAAAA,UAAU,EAAE,oBADoB;IAEhCC,QAAAA,SAAS,EAAE,aAFqB;IAGhCC,QAAAA,QAAQ,EAAE,QAHsB;IAIhCC,QAAAA,SAAS,EAAE;IAJqB,OAApC;IAMH;;IACD,QAAIG,KAAJ;IACA,QAAI9B,QAAJ;;IACA,QAAI;IACAA,MAAAA,QAAQ,GAAG,MAAMmC,4BAAY,CAACC,KAAb,CAAmB;IAChCxC,QAAAA,OADgC;IAEhCuB,QAAAA,KAFgC;IAGhCJ,QAAAA,YAAY,EAAE,KAAKD,aAHa;IAIhCD,QAAAA,OAAO,EAAE,KAAKD;IAJkB,OAAnB,CAAjB;IAMH,KAPD,CAQA,OAAOqB,GAAP,EAAY;IACRH,MAAAA,KAAK,GAAGG,GAAR;IACH;;IACD,IAA2C;IACvChC,MAAAA,gBAAM,CAACC,cAAP,CAAsBT,QAAQ,CAACC,aAAT,CAAuB,aAAvB,EAAsCE,OAAtC,CAAtB;;IACA,UAAII,QAAJ,EAAc;IACVC,QAAAA,gBAAM,CAACE,GAAP,CAAY,4BAAZ;IACH,OAFD,MAGK;IACDF,QAAAA,gBAAM,CAACE,GAAP,CAAY,4CAAZ;IACH;;IACDV,MAAAA,QAAQ,CAACM,kBAAT,CAA4BC,QAA5B;IACAC,MAAAA,gBAAM,CAACG,QAAP;IACH;;IACD,QAAI,CAACJ,QAAL,EAAe;IACX,YAAM,IAAIkC,4BAAJ,CAAiB,aAAjB,EAAgC;IAAEpC,QAAAA,GAAG,EAAEF,OAAO,CAACE,GAAf;IAAoBgC,QAAAA;IAApB,OAAhC,CAAN;IACH;;IACD,WAAO9B,QAAP;IACH;;IAlEa;;ICzBlB;;;;;;;AAOA,IAUA;;;;;;;;;;;;;;;;;;;;;IAoBA,MAAMuE,oBAAN,CAA2B;IACvB;;;;;;;;;;;;IAYAjE,EAAAA,WAAW,CAACC,OAAO,GAAG,EAAX,EAAe;IACtB,SAAKC,UAAL,GAAkBC,wBAAU,CAACC,cAAX,CAA0BH,OAAO,CAACI,SAAlC,CAAlB;IACA,SAAKC,QAAL,GAAgBL,OAAO,CAACM,OAAR,IAAmB,EAAnC;;IACA,QAAIN,OAAO,CAACM,OAAZ,EAAqB;IACjB,YAAMmC,sBAAsB,GAAGzC,OAAO,CAACM,OAAR,CAAgBoC,IAAhB,CAAsBC,MAAD,IAAY,CAAC,CAACA,MAAM,CAACL,eAA1C,CAA/B;IACA,WAAKjC,QAAL,GAAgBoC,sBAAsB,GAClCzC,OAAO,CAACM,OAD0B,GAChB,CAAC+B,sBAAD,EAAyB,GAAGrC,OAAO,CAACM,OAApC,CADtB;IAEH,KAJD,MAKK;IACD;IACA,WAAKD,QAAL,GAAgB,CAACgC,sBAAD,CAAhB;IACH;;IACD,SAAK9B,aAAL,GAAqBP,OAAO,CAACQ,YAA7B;IACA,SAAKC,aAAL,GAAqBT,OAAO,CAACU,YAA7B;IACH;IACD;;;;;;;;;;;;IAUA,QAAMC,MAAN,CAAa;IAAEC,IAAAA,KAAF;IAASvB,IAAAA;IAAT,GAAb,EAAiC;IAC7B,UAAMwB,IAAI,GAAG,EAAb;;IACA,QAAI,OAAOxB,OAAP,KAAmB,QAAvB,EAAiC;IAC7BA,MAAAA,OAAO,GAAG,IAAIyB,OAAJ,CAAYzB,OAAZ,CAAV;IACH;;IACD,IAA2C;IACvC0B,MAAAA,gBAAM,CAACC,UAAP,CAAkB3B,OAAlB,EAA2ByB,OAA3B,EAAoC;IAChCG,QAAAA,UAAU,EAAE,oBADoB;IAEhCC,QAAAA,SAAS,EAAE,sBAFqB;IAGhCC,QAAAA,QAAQ,EAAE,QAHsB;IAIhCC,QAAAA,SAAS,EAAE;IAJqB,OAApC;IAMH;;IACD,UAAM6C,oBAAoB,GAAG,KAAKxC,eAAL,CAAqB;IAAEpC,MAAAA,OAAF;IAAWuB,MAAAA;IAAX,KAArB,CAA7B;;IACA,QAAInB,QAAQ,GAAG,MAAM4B,4BAAY,CAACC,KAAb,CAAmB;IACpClB,MAAAA,SAAS,EAAE,KAAKH,UADoB;IAEpCZ,MAAAA,OAFoC;IAGpCuB,MAAAA,KAHoC;IAIpCF,MAAAA,YAAY,EAAE,KAAKD,aAJiB;IAKpCH,MAAAA,OAAO,EAAE,KAAKD;IALsB,KAAnB,CAArB;IAOA,QAAIkB,KAAJ;;IACA,QAAI9B,QAAJ,EAAc;IACV,MAA2C;IACvCoB,QAAAA,IAAI,CAACW,IAAL,CAAW,mCAAkC,KAAKvB,UAAW,GAAnD,GACL,kEADL;IAEH;;IACD,UAAIW,KAAJ,EAAW;IACP,YAAI;IACAA,UAAAA,KAAK,CAACsB,SAAN,CAAgB+B,oBAAhB;IACH,SAFD,CAGA,OAAO1C,KAAP,EAAc;IACV,UAA2C;IACvC7B,YAAAA,gBAAM,CAACyC,IAAP,CAAa,mDAAD,GACP,uBAAsB7C,gCAAc,CAACD,OAAO,CAACE,GAAT,CAAc,IADvD;IAEH;IACJ;IACJ;IACJ,KAhBD,MAiBK;IACD,MAA2C;IACvCsB,QAAAA,IAAI,CAACW,IAAL,CAAW,6BAA4B,KAAKvB,UAAW,WAA7C,GACL,qCADL;IAEH;;IACD,UAAI;IACAR,QAAAA,QAAQ,GAAG,MAAMwE,oBAAjB;IACH,OAFD,CAGA,OAAOvC,GAAP,EAAY;IACRH,QAAAA,KAAK,GAAGG,GAAR;IACH;IACJ;;IACD,IAA2C;IACvChC,MAAAA,gBAAM,CAACC,cAAP,CAAsBT,QAAQ,CAACC,aAAT,CAAuB,sBAAvB,EAA+CE,OAA/C,CAAtB;;IACA,WAAK,MAAMO,GAAX,IAAkBiB,IAAlB,EAAwB;IACpBnB,QAAAA,gBAAM,CAACE,GAAP,CAAWA,GAAX;IACH;;IACDV,MAAAA,QAAQ,CAACM,kBAAT,CAA4BC,QAA5B;IACAC,MAAAA,gBAAM,CAACG,QAAP;IACH;;IACD,QAAI,CAACJ,QAAL,EAAe;IACX,YAAM,IAAIkC,4BAAJ,CAAiB,aAAjB,EAAgC;IAAEpC,QAAAA,GAAG,EAAEF,OAAO,CAACE,GAAf;IAAoBgC,QAAAA;IAApB,OAAhC,CAAN;IACH;;IACD,WAAO9B,QAAP;IACH;IACD;;;;;;;;;;IAQA,QAAMgC,eAAN,CAAsB;IAAEpC,IAAAA,OAAF;IAAWuB,IAAAA;IAAX,GAAtB,EAA0C;IACtC,UAAMnB,QAAQ,GAAG,MAAMmC,4BAAY,CAACC,KAAb,CAAmB;IACtCxC,MAAAA,OADsC;IAEtCuB,MAAAA,KAFsC;IAGtCJ,MAAAA,YAAY,EAAE,KAAKD,aAHmB;IAItCD,MAAAA,OAAO,EAAE,KAAKD;IAJwB,KAAnB,CAAvB;IAMA,UAAM2B,eAAe,GAAGX,4BAAY,CAACY,GAAb,CAAiB;IACrC7B,MAAAA,SAAS,EAAE,KAAKH,UADqB;IAErCZ,MAAAA,OAFqC;IAGrCI,MAAAA,QAAQ,EAAEA,QAAQ,CAACsC,KAAT,EAH2B;IAIrCnB,MAAAA,KAJqC;IAKrCN,MAAAA,OAAO,EAAE,KAAKD;IALuB,KAAjB,CAAxB;;IAOA,QAAIO,KAAJ,EAAW;IACP,UAAI;IACAA,QAAAA,KAAK,CAACsB,SAAN,CAAgBF,eAAhB;IACH,OAFD,CAGA,OAAOT,KAAP,EAAc;IACV,QAA2C;IACvC7B,UAAAA,gBAAM,CAACyC,IAAP,CAAa,mDAAD,GACP,uBAAsB7C,gCAAc,CAACD,OAAO,CAACE,GAAT,CAAc,IADvD;IAEH;IACJ;IACJ;;IACD,WAAOE,QAAP;IACH;;IAxIsB;;;;;;;;;;;;;;"}

data/lib/vendor/workbox-v5.1.3/workbox-strategies.prod.js

@@ -0,0 +1,2 @@
+this.workbox=this.workbox||{},this.workbox.strategies=function(t,e,s,i,n){"use strict";try{self["workbox:strategies:5.1.3"]&&_()}catch(t){}const r={cacheWillUpdate:async({response:t})=>200===t.status||0===t.status?t:null};return t.CacheFirst=class{constructor(t={}){this.t=e.cacheNames.getRuntimeName(t.cacheName),this.s=t.plugins||[],this.i=t.fetchOptions,this.h=t.matchOptions}async handle({event:t,request:e}){"string"==typeof e&&(e=new Request(e));let i,r=await s.cacheWrapper.match({cacheName:this.t,request:e,event:t,matchOptions:this.h,plugins:this.s});if(!r)try{r=await this.o(e,t)}catch(t){i=t}if(!r)throw new n.WorkboxError("no-response",{url:e.url,error:i});return r}async o(t,e){const n=await i.fetchWrapper.fetch({request:t,event:e,fetchOptions:this.i,plugins:this.s}),r=n.clone(),h=s.cacheWrapper.put({cacheName:this.t,request:t,response:r,event:e,plugins:this.s});if(e)try{e.waitUntil(h)}catch(t){}return n}},t.CacheOnly=class{constructor(t={}){this.t=e.cacheNames.getRuntimeName(t.cacheName),this.s=t.plugins||[],this.h=t.matchOptions}async handle({event:t,request:e}){"string"==typeof e&&(e=new Request(e));const i=await s.cacheWrapper.match({cacheName:this.t,request:e,event:t,matchOptions:this.h,plugins:this.s});if(!i)throw new n.WorkboxError("no-response",{url:e.url});return i}},t.NetworkFirst=class{constructor(t={}){if(this.t=e.cacheNames.getRuntimeName(t.cacheName),t.plugins){const e=t.plugins.some(t=>!!t.cacheWillUpdate);this.s=e?t.plugins:[r,...t.plugins]}else this.s=[r];this.u=t.networkTimeoutSeconds||0,this.i=t.fetchOptions,this.h=t.matchOptions}async handle({event:t,request:e}){const s=[];"string"==typeof e&&(e=new Request(e));const i=[];let r;if(this.u){const{id:n,promise:h}=this.l({request:e,event:t,logs:s});r=n,i.push(h)}const h=this.p({timeoutId:r,request:e,event:t,logs:s});i.push(h);let o=await Promise.race(i);if(o||(o=await h),!o)throw new n.WorkboxError("no-response",{url:e.url});return o}l({request:t,logs:e,event:s}){let i;return{promise:new Promise(e=>{i=setTimeout(async()=>{e(await this.q({request:t,event:s}))},1e3*this.u)}),id:i}}async p({timeoutId:t,request:e,logs:n,event:r}){let h,o;try{o=await i.fetchWrapper.fetch({request:e,event:r,fetchOptions:this.i,plugins:this.s})}catch(t){h=t}if(t&&clearTimeout(t),h||!o)o=await this.q({request:e,event:r});else{const t=o.clone(),i=s.cacheWrapper.put({cacheName:this.t,request:e,response:t,event:r,plugins:this.s});if(r)try{r.waitUntil(i)}catch(t){}}return o}q({event:t,request:e}){return s.cacheWrapper.match({cacheName:this.t,request:e,event:t,matchOptions:this.h,plugins:this.s})}},t.NetworkOnly=class{constructor(t={}){this.s=t.plugins||[],this.i=t.fetchOptions}async handle({event:t,request:e}){let s,r;"string"==typeof e&&(e=new Request(e));try{r=await i.fetchWrapper.fetch({request:e,event:t,fetchOptions:this.i,plugins:this.s})}catch(t){s=t}if(!r)throw new n.WorkboxError("no-response",{url:e.url,error:s});return r}},t.StaleWhileRevalidate=class{constructor(t={}){if(this.t=e.cacheNames.getRuntimeName(t.cacheName),this.s=t.plugins||[],t.plugins){const e=t.plugins.some(t=>!!t.cacheWillUpdate);this.s=e?t.plugins:[r,...t.plugins]}else this.s=[r];this.i=t.fetchOptions,this.h=t.matchOptions}async handle({event:t,request:e}){"string"==typeof e&&(e=new Request(e));const i=this.o({request:e,event:t});let r,h=await s.cacheWrapper.match({cacheName:this.t,request:e,event:t,matchOptions:this.h,plugins:this.s});if(h){if(t)try{t.waitUntil(i)}catch(r){}}else try{h=await i}catch(t){r=t}if(!h)throw new n.WorkboxError("no-response",{url:e.url,error:r});return h}async o({request:t,event:e}){const n=await i.fetchWrapper.fetch({request:t,event:e,fetchOptions:this.i,plugins:this.s}),r=s.cacheWrapper.put({cacheName:this.t,request:t,response:n.clone(),event:e,plugins:this.s});if(e)try{e.waitUntil(r)}catch(t){}return n}},t}({},workbox.core._private,workbox.core._private,workbox.core._private,workbox.core._private);
+//# sourceMappingURL=workbox-strategies.prod.js.map

data/lib/vendor/workbox-v5.1.3/workbox-strategies.prod.js.map

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

data/lib/vendor/workbox-v5.1.3/workbox-streams.dev.js

@@ -0,0 +1,318 @@
+this.workbox = this.workbox || {};
+this.workbox.streams = (function (exports, logger_js, assert_js, Deferred_js, canConstructReadableStream_js) {
+    'use strict';
+
+    try {
+      self['workbox:streams:5.1.3'] && _();
+    } catch (e) {}
+
+    /*
+      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.
+    */
+    /**
+     * Takes either a Response, a ReadableStream, or a
+     * [BodyInit](https://fetch.spec.whatwg.org/#bodyinit) and returns the
+     * ReadableStreamReader object associated with it.
+     *
+     * @param {module:workbox-streams.StreamSource} source
+     * @return {ReadableStreamReader}
+     * @private
+     */
+
+    function _getReaderFromSource(source) {
+      if (source instanceof Response) {
+        return source.body.getReader();
+      }
+
+      if (source instanceof ReadableStream) {
+        return source.getReader();
+      }
+
+      return new Response(source).body.getReader();
+    }
+    /**
+     * Takes multiple source Promises, each of which could resolve to a Response, a
+     * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit).
+     *
+     * Returns an object exposing a ReadableStream with each individual stream's
+     * data returned in sequence, along with a Promise which signals when the
+     * stream is finished (useful for passing to a FetchEvent's waitUntil()).
+     *
+     * @param {Array<Promise<module:workbox-streams.StreamSource>>} sourcePromises
+     * @return {Object<{done: Promise, stream: ReadableStream}>}
+     *
+     * @memberof module:workbox-streams
+     */
+
+
+    function concatenate(sourcePromises) {
+      {
+        assert_js.assert.isArray(sourcePromises, {
+          moduleName: 'workbox-streams',
+          funcName: 'concatenate',
+          paramName: 'sourcePromises'
+        });
+      }
+
+      const readerPromises = sourcePromises.map(sourcePromise => {
+        return Promise.resolve(sourcePromise).then(source => {
+          return _getReaderFromSource(source);
+        });
+      });
+      const streamDeferred = new Deferred_js.Deferred();
+      let i = 0;
+      const logMessages = [];
+      const stream = new ReadableStream({
+        pull(controller) {
+          return readerPromises[i].then(reader => reader.read()).then(result => {
+            if (result.done) {
+              {
+                logMessages.push(['Reached the end of source:', sourcePromises[i]]);
+              }
+
+              i++;
+
+              if (i >= readerPromises.length) {
+                // Log all the messages in the group at once in a single group.
+                {
+                  logger_js.logger.groupCollapsed(`Concatenating ${readerPromises.length} sources.`);
+
+                  for (const message of logMessages) {
+                    if (Array.isArray(message)) {
+                      logger_js.logger.log(...message);
+                    } else {
+                      logger_js.logger.log(message);
+                    }
+                  }
+
+                  logger_js.logger.log('Finished reading all sources.');
+                  logger_js.logger.groupEnd();
+                }
+
+                controller.close();
+                streamDeferred.resolve();
+                return;
+              } // The `pull` method is defined because we're inside it.
+
+
+              return this.pull(controller);
+            } else {
+              controller.enqueue(result.value);
+            }
+          }).catch(error => {
+            {
+              logger_js.logger.error('An error occurred:', error);
+            }
+
+            streamDeferred.reject(error);
+            throw error;
+          });
+        },
+
+        cancel() {
+          {
+            logger_js.logger.warn('The ReadableStream was cancelled.');
+          }
+
+          streamDeferred.resolve();
+        }
+
+      });
+      return {
+        done: streamDeferred.promise,
+        stream
+      };
+    }
+
+    /*
+      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 is a utility method that determines whether the current browser supports
+     * the features required to create streamed responses. Currently, it checks if
+     * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)
+     * is available.
+     *
+     * @private
+     * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,
+     * `'text/html'` will be used by default.
+     * @return {boolean} `true`, if the current browser meets the requirements for
+     * streaming responses, and `false` otherwise.
+     *
+     * @memberof module:workbox-streams
+     */
+
+    function createHeaders(headersInit = {}) {
+      // See https://github.com/GoogleChrome/workbox/issues/1461
+      const headers = new Headers(headersInit);
+
+      if (!headers.has('content-type')) {
+        headers.set('content-type', 'text/html');
+      }
+
+      return headers;
+    }
+
+    /*
+      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.
+    */
+    /**
+     * Takes multiple source Promises, each of which could resolve to a Response, a
+     * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit),
+     * along with a
+     * [HeadersInit](https://fetch.spec.whatwg.org/#typedefdef-headersinit).
+     *
+     * Returns an object exposing a Response whose body consists of each individual
+     * stream's data returned in sequence, along with a Promise which signals when
+     * the stream is finished (useful for passing to a FetchEvent's waitUntil()).
+     *
+     * @param {Array<Promise<module:workbox-streams.StreamSource>>} sourcePromises
+     * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,
+     * `'text/html'` will be used by default.
+     * @return {Object<{done: Promise, response: Response}>}
+     *
+     * @memberof module:workbox-streams
+     */
+
+    function concatenateToResponse(sourcePromises, headersInit) {
+      const {
+        done,
+        stream
+      } = concatenate(sourcePromises);
+      const headers = createHeaders(headersInit);
+      const response = new Response(stream, {
+        headers
+      });
+      return {
+        done,
+        response
+      };
+    }
+
+    /*
+      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 is a utility method that determines whether the current browser supports
+     * the features required to create streamed responses. Currently, it checks if
+     * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)
+     * can be created.
+     *
+     * @return {boolean} `true`, if the current browser meets the requirements for
+     * streaming responses, and `false` otherwise.
+     *
+     * @memberof module:workbox-streams
+     */
+
+    function isSupported() {
+      return canConstructReadableStream_js.canConstructReadableStream();
+    }
+
+    /*
+      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 shortcut to create a strategy that could be dropped-in to Workbox's router.
+     *
+     * On browsers that do not support constructing new `ReadableStream`s, this
+     * strategy will automatically wait for all the `sourceFunctions` to complete,
+     * and create a final response that concatenates their values together.
+     *
+     * @param {Array<function({event, request, url, params})>} sourceFunctions
+     * An array of functions similar to {@link module:workbox-routing~handlerCallback}
+     * but that instead return a {@link module:workbox-streams.StreamSource} (or a
+     * Promise which resolves to one).
+     * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,
+     * `'text/html'` will be used by default.
+     * @return {module:workbox-routing~handlerCallback}
+     * @memberof module:workbox-streams
+     */
+
+    function strategy(sourceFunctions, headersInit) {
+      return async ({
+        event,
+        request,
+        url,
+        params
+      }) => {
+        const sourcePromises = sourceFunctions.map(fn => {
+          // Ensure the return value of the function is always a promise.
+          return Promise.resolve(fn({
+            event,
+            request,
+            url,
+            params
+          }));
+        });
+
+        if (isSupported()) {
+          const {
+            done,
+            response
+          } = concatenateToResponse(sourcePromises, headersInit);
+
+          if (event) {
+            event.waitUntil(done);
+          }
+
+          return response;
+        }
+
+        {
+          logger_js.logger.log(`The current browser doesn't support creating response ` + `streams. Falling back to non-streaming response instead.`);
+        } // Fallback to waiting for everything to finish, and concatenating the
+        // responses.
+
+
+        const blobPartsPromises = sourcePromises.map(async sourcePromise => {
+          const source = await sourcePromise;
+
+          if (source instanceof Response) {
+            return source.blob();
+          } else {
+            // Technically, a `StreamSource` object can include any valid
+            // `BodyInit` type, including `FormData` and `URLSearchParams`, which
+            // cannot be passed to the Blob constructor directly, so we have to
+            // convert them to actual Blobs first.
+            return new Response(source).blob();
+          }
+        });
+        const blobParts = await Promise.all(blobPartsPromises);
+        const headers = createHeaders(headersInit); // Constructing a new Response from a Blob source is well-supported.
+        // So is constructing a new Blob from multiple source Blobs or strings.
+
+        return new Response(new Blob(blobParts), {
+          headers
+        });
+      };
+    }
+
+    exports.concatenate = concatenate;
+    exports.concatenateToResponse = concatenateToResponse;
+    exports.isSupported = isSupported;
+    exports.strategy = strategy;
+
+    return exports;
+
+}({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private));
+//# sourceMappingURL=workbox-streams.dev.js.map

data/lib/vendor/workbox-v5.1.3/workbox-streams.dev.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workbox-streams.dev.js","sources":["../_version.js","../concatenate.js","../utils/createHeaders.js","../concatenateToResponse.js","../isSupported.js","../strategy.js"],"sourcesContent":["\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:streams:5.1.3'] && _();\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 { logger } from 'workbox-core/_private/logger.js';\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { Deferred } from 'workbox-core/_private/Deferred.js';\nimport './_version.js';\n/**\n * Takes either a Response, a ReadableStream, or a\n * [BodyInit](https://fetch.spec.whatwg.org/#bodyinit) and returns the\n * ReadableStreamReader object associated with it.\n *\n * @param {module:workbox-streams.StreamSource} source\n * @return {ReadableStreamReader}\n * @private\n */\nfunction _getReaderFromSource(source) {\n    if (source instanceof Response) {\n        return source.body.getReader();\n    }\n    if (source instanceof ReadableStream) {\n        return source.getReader();\n    }\n    return new Response(source).body.getReader();\n}\n/**\n * Takes multiple source Promises, each of which could resolve to a Response, a\n * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit).\n *\n * Returns an object exposing a ReadableStream with each individual stream's\n * data returned in sequence, along with a Promise which signals when the\n * stream is finished (useful for passing to a FetchEvent's waitUntil()).\n *\n * @param {Array<Promise<module:workbox-streams.StreamSource>>} sourcePromises\n * @return {Object<{done: Promise, stream: ReadableStream}>}\n *\n * @memberof module:workbox-streams\n */\nfunction concatenate(sourcePromises) {\n    if (process.env.NODE_ENV !== 'production') {\n        assert.isArray(sourcePromises, {\n            moduleName: 'workbox-streams',\n            funcName: 'concatenate',\n            paramName: 'sourcePromises',\n        });\n    }\n    const readerPromises = sourcePromises.map((sourcePromise) => {\n        return Promise.resolve(sourcePromise).then((source) => {\n            return _getReaderFromSource(source);\n        });\n    });\n    const streamDeferred = new Deferred();\n    let i = 0;\n    const logMessages = [];\n    const stream = new ReadableStream({\n        pull(controller) {\n            return readerPromises[i]\n                .then((reader) => reader.read())\n                .then((result) => {\n                if (result.done) {\n                    if (process.env.NODE_ENV !== 'production') {\n                        logMessages.push(['Reached the end of source:',\n                            sourcePromises[i]]);\n                    }\n                    i++;\n                    if (i >= readerPromises.length) {\n                        // Log all the messages in the group at once in a single group.\n                        if (process.env.NODE_ENV !== 'production') {\n                            logger.groupCollapsed(`Concatenating ${readerPromises.length} sources.`);\n                            for (const message of logMessages) {\n                                if (Array.isArray(message)) {\n                                    logger.log(...message);\n                                }\n                                else {\n                                    logger.log(message);\n                                }\n                            }\n                            logger.log('Finished reading all sources.');\n                            logger.groupEnd();\n                        }\n                        controller.close();\n                        streamDeferred.resolve();\n                        return;\n                    }\n                    // The `pull` method is defined because we're inside it.\n                    return this.pull(controller);\n                }\n                else {\n                    controller.enqueue(result.value);\n                }\n            }).catch((error) => {\n                if (process.env.NODE_ENV !== 'production') {\n                    logger.error('An error occurred:', error);\n                }\n                streamDeferred.reject(error);\n                throw error;\n            });\n        },\n        cancel() {\n            if (process.env.NODE_ENV !== 'production') {\n                logger.warn('The ReadableStream was cancelled.');\n            }\n            streamDeferred.resolve();\n        },\n    });\n    return { done: streamDeferred.promise, stream };\n}\nexport { concatenate };\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';\n/**\n * This is a utility method that determines whether the current browser supports\n * the features required to create streamed responses. Currently, it checks if\n * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)\n * is available.\n *\n * @private\n * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,\n * `'text/html'` will be used by default.\n * @return {boolean} `true`, if the current browser meets the requirements for\n * streaming responses, and `false` otherwise.\n *\n * @memberof module:workbox-streams\n */\nfunction createHeaders(headersInit = {}) {\n    // See https://github.com/GoogleChrome/workbox/issues/1461\n    const headers = new Headers(headersInit);\n    if (!headers.has('content-type')) {\n        headers.set('content-type', 'text/html');\n    }\n    return headers;\n}\nexport { createHeaders };\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 { createHeaders } from './utils/createHeaders.js';\nimport { concatenate } from './concatenate.js';\nimport './_version.js';\n/**\n * Takes multiple source Promises, each of which could resolve to a Response, a\n * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit),\n * along with a\n * [HeadersInit](https://fetch.spec.whatwg.org/#typedefdef-headersinit).\n *\n * Returns an object exposing a Response whose body consists of each individual\n * stream's data returned in sequence, along with a Promise which signals when\n * the stream is finished (useful for passing to a FetchEvent's waitUntil()).\n *\n * @param {Array<Promise<module:workbox-streams.StreamSource>>} sourcePromises\n * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,\n * `'text/html'` will be used by default.\n * @return {Object<{done: Promise, response: Response}>}\n *\n * @memberof module:workbox-streams\n */\nfunction concatenateToResponse(sourcePromises, headersInit) {\n    const { done, stream } = concatenate(sourcePromises);\n    const headers = createHeaders(headersInit);\n    const response = new Response(stream, { headers });\n    return { done, response };\n}\nexport { concatenateToResponse };\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 { canConstructReadableStream } from 'workbox-core/_private/canConstructReadableStream.js';\nimport './_version.js';\n/**\n * This is a utility method that determines whether the current browser supports\n * the features required to create streamed responses. Currently, it checks if\n * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)\n * can be created.\n *\n * @return {boolean} `true`, if the current browser meets the requirements for\n * streaming responses, and `false` otherwise.\n *\n * @memberof module:workbox-streams\n */\nfunction isSupported() {\n    return canConstructReadableStream();\n}\nexport { isSupported };\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 { logger } from 'workbox-core/_private/logger.js';\nimport { createHeaders } from './utils/createHeaders.js';\nimport { concatenateToResponse } from './concatenateToResponse.js';\nimport { isSupported } from './isSupported.js';\nimport './_version.js';\n/**\n * A shortcut to create a strategy that could be dropped-in to Workbox's router.\n *\n * On browsers that do not support constructing new `ReadableStream`s, this\n * strategy will automatically wait for all the `sourceFunctions` to complete,\n * and create a final response that concatenates their values together.\n *\n * @param {Array<function({event, request, url, params})>} sourceFunctions\n * An array of functions similar to {@link module:workbox-routing~handlerCallback}\n * but that instead return a {@link module:workbox-streams.StreamSource} (or a\n * Promise which resolves to one).\n * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,\n * `'text/html'` will be used by default.\n * @return {module:workbox-routing~handlerCallback}\n * @memberof module:workbox-streams\n */\nfunction strategy(sourceFunctions, headersInit) {\n    return async ({ event, request, url, params }) => {\n        const sourcePromises = sourceFunctions.map((fn) => {\n            // Ensure the return value of the function is always a promise.\n            return Promise.resolve(fn({ event, request, url, params }));\n        });\n        if (isSupported()) {\n            const { done, response } = concatenateToResponse(sourcePromises, headersInit);\n            if (event) {\n                event.waitUntil(done);\n            }\n            return response;\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            logger.log(`The current browser doesn't support creating response ` +\n                `streams. Falling back to non-streaming response instead.`);\n        }\n        // Fallback to waiting for everything to finish, and concatenating the\n        // responses.\n        const blobPartsPromises = sourcePromises.map(async (sourcePromise) => {\n            const source = await sourcePromise;\n            if (source instanceof Response) {\n                return source.blob();\n            }\n            else {\n                // Technically, a `StreamSource` object can include any valid\n                // `BodyInit` type, including `FormData` and `URLSearchParams`, which\n                // cannot be passed to the Blob constructor directly, so we have to\n                // convert them to actual Blobs first.\n                return new Response(source).blob();\n            }\n        });\n        const blobParts = await Promise.all(blobPartsPromises);\n        const headers = createHeaders(headersInit);\n        // Constructing a new Response from a Blob source is well-supported.\n        // So is constructing a new Blob from multiple source Blobs or strings.\n        return new Response(new Blob(blobParts), { headers });\n    };\n}\nexport { strategy };\n"],"names":["self","_","e","_getReaderFromSource","source","Response","body","getReader","ReadableStream","concatenate","sourcePromises","assert","isArray","moduleName","funcName","paramName","readerPromises","map","sourcePromise","Promise","resolve","then","streamDeferred","Deferred","i","logMessages","stream","pull","controller","reader","read","result","done","push","length","logger","groupCollapsed","message","Array","log","groupEnd","close","enqueue","value","catch","error","reject","cancel","warn","promise","createHeaders","headersInit","headers","Headers","has","set","concatenateToResponse","response","isSupported","canConstructReadableStream","strategy","sourceFunctions","event","request","url","params","fn","waitUntil","blobPartsPromises","blob","blobParts","all","Blob"],"mappings":"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"}

data/lib/vendor/workbox-v5.1.3/workbox-streams.prod.js

@@ -0,0 +1,2 @@
+this.workbox=this.workbox||{},this.workbox.streams=function(e,n,t){"use strict";try{self["workbox:streams:5.1.3"]&&_()}catch(e){}function s(e){const t=e.map(e=>Promise.resolve(e).then(e=>function(e){return e instanceof Response?e.body.getReader():e instanceof ReadableStream?e.getReader():new Response(e).body.getReader()}(e))),s=new n.Deferred;let r=0;const o=new ReadableStream({pull(e){return t[r].then(e=>e.read()).then(n=>{if(n.done)return r++,r>=t.length?(e.close(),void s.resolve()):this.pull(e);e.enqueue(n.value)}).catch(e=>{throw s.reject(e),e})},cancel(){s.resolve()}});return{done:s.promise,stream:o}}function r(e={}){const n=new Headers(e);return n.has("content-type")||n.set("content-type","text/html"),n}function o(e,n){const{done:t,stream:o}=s(e),c=r(n);return{done:t,response:new Response(o,{headers:c})}}function c(){return t.canConstructReadableStream()}return e.concatenate=s,e.concatenateToResponse=o,e.isSupported=c,e.strategy=function(e,n){return async({event:t,request:s,url:a,params:u})=>{const i=e.map(e=>Promise.resolve(e({event:t,request:s,url:a,params:u})));if(c()){const{done:e,response:s}=o(i,n);return t&&t.waitUntil(e),s}const f=i.map(async e=>{const n=await e;return n instanceof Response?n.blob():new Response(n).blob()}),p=await Promise.all(f),w=r(n);return new Response(new Blob(p),{headers:w})}},e}({},workbox.core._private,workbox.core._private);
+//# sourceMappingURL=workbox-streams.prod.js.map

data/lib/vendor/workbox-v5.1.3/workbox-streams.prod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workbox-streams.prod.js","sources":["../_version.js","../concatenate.js","../utils/createHeaders.js","../concatenateToResponse.js","../isSupported.js","../strategy.js"],"sourcesContent":["\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:streams:5.1.3'] && _();\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 { logger } from 'workbox-core/_private/logger.js';\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { Deferred } from 'workbox-core/_private/Deferred.js';\nimport './_version.js';\n/**\n * Takes either a Response, a ReadableStream, or a\n * [BodyInit](https://fetch.spec.whatwg.org/#bodyinit) and returns the\n * ReadableStreamReader object associated with it.\n *\n * @param {module:workbox-streams.StreamSource} source\n * @return {ReadableStreamReader}\n * @private\n */\nfunction _getReaderFromSource(source) {\n    if (source instanceof Response) {\n        return source.body.getReader();\n    }\n    if (source instanceof ReadableStream) {\n        return source.getReader();\n    }\n    return new Response(source).body.getReader();\n}\n/**\n * Takes multiple source Promises, each of which could resolve to a Response, a\n * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit).\n *\n * Returns an object exposing a ReadableStream with each individual stream's\n * data returned in sequence, along with a Promise which signals when the\n * stream is finished (useful for passing to a FetchEvent's waitUntil()).\n *\n * @param {Array<Promise<module:workbox-streams.StreamSource>>} sourcePromises\n * @return {Object<{done: Promise, stream: ReadableStream}>}\n *\n * @memberof module:workbox-streams\n */\nfunction concatenate(sourcePromises) {\n    if (process.env.NODE_ENV !== 'production') {\n        assert.isArray(sourcePromises, {\n            moduleName: 'workbox-streams',\n            funcName: 'concatenate',\n            paramName: 'sourcePromises',\n        });\n    }\n    const readerPromises = sourcePromises.map((sourcePromise) => {\n        return Promise.resolve(sourcePromise).then((source) => {\n            return _getReaderFromSource(source);\n        });\n    });\n    const streamDeferred = new Deferred();\n    let i = 0;\n    const logMessages = [];\n    const stream = new ReadableStream({\n        pull(controller) {\n            return readerPromises[i]\n                .then((reader) => reader.read())\n                .then((result) => {\n                if (result.done) {\n                    if (process.env.NODE_ENV !== 'production') {\n                        logMessages.push(['Reached the end of source:',\n                            sourcePromises[i]]);\n                    }\n                    i++;\n                    if (i >= readerPromises.length) {\n                        // Log all the messages in the group at once in a single group.\n                        if (process.env.NODE_ENV !== 'production') {\n                            logger.groupCollapsed(`Concatenating ${readerPromises.length} sources.`);\n                            for (const message of logMessages) {\n                                if (Array.isArray(message)) {\n                                    logger.log(...message);\n                                }\n                                else {\n                                    logger.log(message);\n                                }\n                            }\n                            logger.log('Finished reading all sources.');\n                            logger.groupEnd();\n                        }\n                        controller.close();\n                        streamDeferred.resolve();\n                        return;\n                    }\n                    // The `pull` method is defined because we're inside it.\n                    return this.pull(controller);\n                }\n                else {\n                    controller.enqueue(result.value);\n                }\n            }).catch((error) => {\n                if (process.env.NODE_ENV !== 'production') {\n                    logger.error('An error occurred:', error);\n                }\n                streamDeferred.reject(error);\n                throw error;\n            });\n        },\n        cancel() {\n            if (process.env.NODE_ENV !== 'production') {\n                logger.warn('The ReadableStream was cancelled.');\n            }\n            streamDeferred.resolve();\n        },\n    });\n    return { done: streamDeferred.promise, stream };\n}\nexport { concatenate };\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';\n/**\n * This is a utility method that determines whether the current browser supports\n * the features required to create streamed responses. Currently, it checks if\n * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)\n * is available.\n *\n * @private\n * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,\n * `'text/html'` will be used by default.\n * @return {boolean} `true`, if the current browser meets the requirements for\n * streaming responses, and `false` otherwise.\n *\n * @memberof module:workbox-streams\n */\nfunction createHeaders(headersInit = {}) {\n    // See https://github.com/GoogleChrome/workbox/issues/1461\n    const headers = new Headers(headersInit);\n    if (!headers.has('content-type')) {\n        headers.set('content-type', 'text/html');\n    }\n    return headers;\n}\nexport { createHeaders };\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 { createHeaders } from './utils/createHeaders.js';\nimport { concatenate } from './concatenate.js';\nimport './_version.js';\n/**\n * Takes multiple source Promises, each of which could resolve to a Response, a\n * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit),\n * along with a\n * [HeadersInit](https://fetch.spec.whatwg.org/#typedefdef-headersinit).\n *\n * Returns an object exposing a Response whose body consists of each individual\n * stream's data returned in sequence, along with a Promise which signals when\n * the stream is finished (useful for passing to a FetchEvent's waitUntil()).\n *\n * @param {Array<Promise<module:workbox-streams.StreamSource>>} sourcePromises\n * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,\n * `'text/html'` will be used by default.\n * @return {Object<{done: Promise, response: Response}>}\n *\n * @memberof module:workbox-streams\n */\nfunction concatenateToResponse(sourcePromises, headersInit) {\n    const { done, stream } = concatenate(sourcePromises);\n    const headers = createHeaders(headersInit);\n    const response = new Response(stream, { headers });\n    return { done, response };\n}\nexport { concatenateToResponse };\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 { canConstructReadableStream } from 'workbox-core/_private/canConstructReadableStream.js';\nimport './_version.js';\n/**\n * This is a utility method that determines whether the current browser supports\n * the features required to create streamed responses. Currently, it checks if\n * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)\n * can be created.\n *\n * @return {boolean} `true`, if the current browser meets the requirements for\n * streaming responses, and `false` otherwise.\n *\n * @memberof module:workbox-streams\n */\nfunction isSupported() {\n    return canConstructReadableStream();\n}\nexport { isSupported };\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 { logger } from 'workbox-core/_private/logger.js';\nimport { createHeaders } from './utils/createHeaders.js';\nimport { concatenateToResponse } from './concatenateToResponse.js';\nimport { isSupported } from './isSupported.js';\nimport './_version.js';\n/**\n * A shortcut to create a strategy that could be dropped-in to Workbox's router.\n *\n * On browsers that do not support constructing new `ReadableStream`s, this\n * strategy will automatically wait for all the `sourceFunctions` to complete,\n * and create a final response that concatenates their values together.\n *\n * @param {Array<function({event, request, url, params})>} sourceFunctions\n * An array of functions similar to {@link module:workbox-routing~handlerCallback}\n * but that instead return a {@link module:workbox-streams.StreamSource} (or a\n * Promise which resolves to one).\n * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,\n * `'text/html'` will be used by default.\n * @return {module:workbox-routing~handlerCallback}\n * @memberof module:workbox-streams\n */\nfunction strategy(sourceFunctions, headersInit) {\n    return async ({ event, request, url, params }) => {\n        const sourcePromises = sourceFunctions.map((fn) => {\n            // Ensure the return value of the function is always a promise.\n            return Promise.resolve(fn({ event, request, url, params }));\n        });\n        if (isSupported()) {\n            const { done, response } = concatenateToResponse(sourcePromises, headersInit);\n            if (event) {\n                event.waitUntil(done);\n            }\n            return response;\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            logger.log(`The current browser doesn't support creating response ` +\n                `streams. Falling back to non-streaming response instead.`);\n        }\n        // Fallback to waiting for everything to finish, and concatenating the\n        // responses.\n        const blobPartsPromises = sourcePromises.map(async (sourcePromise) => {\n            const source = await sourcePromise;\n            if (source instanceof Response) {\n                return source.blob();\n            }\n            else {\n                // Technically, a `StreamSource` object can include any valid\n                // `BodyInit` type, including `FormData` and `URLSearchParams`, which\n                // cannot be passed to the Blob constructor directly, so we have to\n                // convert them to actual Blobs first.\n                return new Response(source).blob();\n            }\n        });\n        const blobParts = await Promise.all(blobPartsPromises);\n        const headers = createHeaders(headersInit);\n        // Constructing a new Response from a Blob source is well-supported.\n        // So is constructing a new Blob from multiple source Blobs or strings.\n        return new Response(new Blob(blobParts), { headers });\n    };\n}\nexport { strategy };\n"],"names":["self","_","e","concatenate","sourcePromises","readerPromises","map","sourcePromise","Promise","resolve","then","source","Response","body","getReader","ReadableStream","_getReaderFromSource","streamDeferred","Deferred","i","stream","pull","controller","reader","read","result","done","length","close","this","enqueue","value","catch","error","reject","cancel","promise","createHeaders","headersInit","headers","Headers","has","set","concatenateToResponse","response","isSupported","canConstructReadableStream","sourceFunctions","async","event","request","url","params","fn","waitUntil","blobPartsPromises","blob","blobParts","all","Blob"],"mappings":"gFAEA,IACIA,KAAK,0BAA4BC,IAErC,MAAOC,ICqCP,SAASC,EAAYC,SAQXC,EAAiBD,EAAeE,IAAKC,GAChCC,QAAQC,QAAQF,GAAeG,KAAMC,GA/BpD,SAA8BA,UACtBA,aAAkBC,SACXD,EAAOE,KAAKC,YAEnBH,aAAkBI,eACXJ,EAAOG,YAEX,IAAIF,SAASD,GAAQE,KAAKC,YAyBlBE,CAAqBL,KAG9BM,EAAiB,IAAIC,eACvBC,EAAI,QAEFC,EAAS,IAAIL,eAAe,CAC9BM,KAAKC,UACMjB,EAAec,GACjBT,KAAMa,GAAWA,EAAOC,QACxBd,KAAMe,OACHA,EAAOC,YAKPP,IACIA,GAAKd,EAAesB,QAepBL,EAAWM,aACXX,EAAeR,WAIZoB,KAAKR,KAAKC,GAGjBA,EAAWQ,QAAQL,EAAOM,SAE/BC,MAAOC,UAINhB,EAAeiB,OAAOD,GAChBA,KAGdE,SAIIlB,EAAeR,mBAGhB,CAAEiB,KAAMT,EAAemB,QAAShB,OAAAA,GCvF3C,SAASiB,EAAcC,EAAc,UAE3BC,EAAU,IAAIC,QAAQF,UACvBC,EAAQE,IAAI,iBACbF,EAAQG,IAAI,eAAgB,aAEzBH,ECDX,SAASI,EAAsBvC,EAAgBkC,SACrCZ,KAAEA,EAAFN,OAAQA,GAAWjB,EAAYC,GAC/BmC,EAAUF,EAAcC,SAEvB,CAAEZ,KAAAA,EAAMkB,SADE,IAAIhC,SAASQ,EAAQ,CAAEmB,QAAAA,KCV5C,SAASM,WACEC,2GCOX,SAAkBC,EAAiBT,UACxBU,OAASC,MAAAA,EAAOC,QAAAA,EAASC,IAAAA,EAAKC,OAAAA,YAC3BhD,EAAiB2C,EAAgBzC,IAAK+C,GAEjC7C,QAAQC,QAAQ4C,EAAG,CAAEJ,MAAAA,EAAOC,QAAAA,EAASC,IAAAA,EAAKC,OAAAA,SAEjDP,IAAe,OACTnB,KAAEA,EAAFkB,SAAQA,GAAaD,EAAsBvC,EAAgBkC,UAC7DW,GACAA,EAAMK,UAAU5B,GAEbkB,QAQLW,EAAoBnD,EAAeE,IAAI0C,MAAAA,UACnCrC,QAAeJ,SACjBI,aAAkBC,SACXD,EAAO6C,OAOP,IAAI5C,SAASD,GAAQ6C,SAG9BC,QAAkBjD,QAAQkD,IAAIH,GAC9BhB,EAAUF,EAAcC,UAGvB,IAAI1B,SAAS,IAAI+C,KAAKF,GAAY,CAAElB,QAAAA"}

data/lib/vendor/workbox-v5.1.3/workbox-sw.js

@@ -0,0 +1,2 @@
+!function(){"use strict";try{self["workbox:sw:5.1.3"]&&_()}catch(t){}const t={backgroundSync:"background-sync",broadcastUpdate:"broadcast-update",cacheableResponse:"cacheable-response",core:"core",expiration:"expiration",googleAnalytics:"offline-ga",navigationPreload:"navigation-preload",precaching:"precaching",rangeRequests:"range-requests",routing:"routing",strategies:"strategies",streams:"streams"};self.workbox=new class{constructor(){return this.v={},this.t={debug:"localhost"===self.location.hostname,modulePathPrefix:null,modulePathCb:null},this.s=this.t.debug?"dev":"prod",this.o=!1,new Proxy(this,{get(e,s){if(e[s])return e[s];const o=t[s];return o&&e.loadModule(`workbox-${o}`),e[s]}})}setConfig(t={}){if(this.o)throw new Error("Config must be set before accessing workbox.* modules");Object.assign(this.t,t),this.s=this.t.debug?"dev":"prod"}loadModule(t){const e=this.i(t);try{importScripts(e),this.o=!0}catch(s){throw console.error(`Unable to import module '${t}' from '${e}'.`),s}}i(t){if(this.t.modulePathCb)return this.t.modulePathCb(t,this.t.debug);let e=["https://storage.googleapis.com/workbox-cdn/releases/5.1.3"];const s=`${t}.${this.s}.js`,o=this.t.modulePathPrefix;return o&&(e=o.split("/"),""===e[e.length-1]&&e.splice(e.length-1,1)),e.push(s),e.join("/")}}}();
+//# sourceMappingURL=workbox-sw.js.map

data/lib/vendor/workbox-v5.1.3/workbox-sw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workbox-sw.js","sources":["../_version.mjs","../controllers/WorkboxSW.mjs","../index.mjs"],"sourcesContent":["try{self['workbox:sw:5.1.3']&&_()}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 '../_version.mjs';\n\nconst CDN_PATH = `WORKBOX_CDN_ROOT_URL`;\n\nconst MODULE_KEY_TO_NAME_MAPPING = {\n  /**\n   * @name backgroundSync\n   * @memberof workbox\n   * @see module:workbox-background-sync\n   */\n  backgroundSync: 'background-sync',\n  /**\n   * @name broadcastUpdate\n   * @memberof workbox\n   * @see module:workbox-broadcast-update\n   */\n  broadcastUpdate: 'broadcast-update',\n  /**\n   * @name cacheableResponse\n   * @memberof workbox\n   * @see module:workbox-cacheable-response\n   */\n  cacheableResponse: 'cacheable-response',\n  /**\n   * @name core\n   * @memberof workbox\n   * @see module:workbox-core\n   */\n  core: 'core',\n  /**\n   * @name expiration\n   * @memberof workbox\n   * @see module:workbox-expiration\n   */\n  expiration: 'expiration',\n  /**\n   * @name googleAnalytics\n   * @memberof workbox\n   * @see module:workbox-google-analytics\n   */\n  googleAnalytics: 'offline-ga',\n  /**\n   * @name navigationPreload\n   * @memberof workbox\n   * @see module:workbox-navigation-preload\n   */\n  navigationPreload: 'navigation-preload',\n  /**\n   * @name precaching\n   * @memberof workbox\n   * @see module:workbox-precaching\n   */\n  precaching: 'precaching',\n  /**\n   * @name rangeRequests\n   * @memberof workbox\n   * @see module:workbox-range-requests\n   */\n  rangeRequests: 'range-requests',\n  /**\n   * @name routing\n   * @memberof workbox\n   * @see module:workbox-routing\n   */\n  routing: 'routing',\n  /**\n   * @name strategies\n   * @memberof workbox\n   * @see module:workbox-strategies\n   */\n  strategies: 'strategies',\n  /**\n   * @name streams\n   * @memberof workbox\n   * @see module:workbox-streams\n   */\n  streams: 'streams',\n};\n\n/**\n * This class can be used to make it easy to use the various parts of\n * Workbox.\n *\n * @private\n */\nexport class WorkboxSW {\n  /**\n   * Creates a proxy that automatically loads workbox namespaces on demand.\n   *\n   * @private\n   */\n  constructor() {\n    this.v = {};\n    this._options = {\n      debug: self.location.hostname === 'localhost',\n      modulePathPrefix: null,\n      modulePathCb: null,\n    };\n\n    this._env = this._options.debug ? 'dev' : 'prod';\n    this._modulesLoaded = false;\n\n    return new Proxy(this, {\n      get(target, key) {\n        if (target[key]) {\n          return target[key];\n        }\n\n        const moduleName = MODULE_KEY_TO_NAME_MAPPING[key];\n        if (moduleName) {\n          target.loadModule(`workbox-${moduleName}`);\n        }\n\n        return target[key];\n      },\n    });\n  }\n\n  /**\n   * Updates the configuration options. You can specify whether to treat as a\n   * debug build and whether to use a CDN or a specific path when importing\n   * other workbox-modules\n   *\n   * @param {Object} [options]\n   * @param {boolean} [options.debug] If true, `dev` builds are using, otherwise\n   * `prod` builds are used. By default, `prod` is used unless on localhost.\n   * @param {Function} [options.modulePathPrefix] To avoid using the CDN with\n   * `workbox-sw` set the path prefix of where modules should be loaded from.\n   * For example `modulePathPrefix: '/third_party/workbox/v3.0.0/'`.\n   * @param {workbox~ModulePathCallback} [options.modulePathCb] If defined,\n   * this callback will be responsible for determining the path of each\n   * workbox module.\n   *\n   * @alias workbox.setConfig\n   */\n  setConfig(options = {}) {\n    if (!this._modulesLoaded) {\n      Object.assign(this._options, options);\n      this._env = this._options.debug ? 'dev' : 'prod';\n    } else {\n      throw new Error('Config must be set before accessing workbox.* modules');\n    }\n  }\n\n  /**\n   * Load a Workbox module by passing in the appropriate module name.\n   *\n   * This is not generally needed unless you know there are modules that are\n   * dynamically used and you want to safe guard use of the module while the\n   * user may be offline.\n   *\n   * @param {string} moduleName\n   *\n   * @alias workbox.loadModule\n   */\n  loadModule(moduleName) {\n    const modulePath = this._getImportPath(moduleName);\n    try {\n      importScripts(modulePath);\n      this._modulesLoaded = true;\n    } catch (err) {\n      // TODO Add context of this error if using the CDN vs the local file.\n\n      // We can't rely on workbox-core being loaded so using console\n      // eslint-disable-next-line\n      console.error(\n          `Unable to import module '${moduleName}' from '${modulePath}'.`);\n      throw err;\n    }\n  }\n\n  /**\n   * This method will get the path / CDN URL to be used for importScript calls.\n   *\n   * @param {string} moduleName\n   * @return {string} URL to the desired module.\n   *\n   * @private\n   */\n  _getImportPath(moduleName) {\n    if (this._options.modulePathCb) {\n      return this._options.modulePathCb(moduleName, this._options.debug);\n    }\n\n    // TODO: This needs to be dynamic some how.\n    let pathParts = [CDN_PATH];\n\n    const fileName = `${moduleName}.${this._env}.js`;\n\n    const pathPrefix = this._options.modulePathPrefix;\n    if (pathPrefix) {\n      // Split to avoid issues with developers ending / not ending with slash\n      pathParts = pathPrefix.split('/');\n\n      // We don't need a slash at the end as we will be adding\n      // a filename regardless\n      if (pathParts[pathParts.length - 1] === '') {\n        pathParts.splice(pathParts.length - 1, 1);\n      }\n    }\n\n    pathParts.push(fileName);\n\n    return pathParts.join('/');\n  }\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 {WorkboxSW} from './controllers/WorkboxSW.mjs';\nimport './_version.mjs';\n\n/**\n * @namespace workbox\n */\n\n// Don't export anything, just expose a global.\nself.workbox = new WorkboxSW();\n"],"names":["self","_","e","MODULE_KEY_TO_NAME_MAPPING","backgroundSync","broadcastUpdate","cacheableResponse","core","expiration","googleAnalytics","navigationPreload","precaching","rangeRequests","routing","strategies","streams","workbox","constructor","v","_options","debug","location","hostname","modulePathPrefix","modulePathCb","_env","this","_modulesLoaded","Proxy","get","target","key","moduleName","loadModule","setConfig","options","Error","Object","assign","modulePath","_getImportPath","importScripts","err","console","error","pathParts","fileName","pathPrefix","split","length","splice","push","join"],"mappings":"yBAAA,IAAIA,KAAK,qBAAqBC,IAAI,MAAMC,ICUxC,MAEMC,EAA6B,CAMjCC,eAAgB,kBAMhBC,gBAAiB,mBAMjBC,kBAAmB,qBAMnBC,KAAM,OAMNC,WAAY,aAMZC,gBAAiB,aAMjBC,kBAAmB,qBAMnBC,WAAY,aAMZC,cAAe,iBAMfC,QAAS,UAMTC,WAAY,aAMZC,QAAS,WCpEXf,KAAKgB,QAAU,ID6ER,MAMLC,0BACOC,EAAI,QACJC,EAAW,CACdC,MAAkC,cAA3BpB,KAAKqB,SAASC,SACrBC,iBAAkB,KAClBC,aAAc,WAGXC,EAAOC,KAAKP,EAASC,MAAQ,MAAQ,YACrCO,GAAiB,EAEf,IAAIC,MAAMF,KAAM,CACrBG,IAAIC,EAAQC,MACND,EAAOC,UACFD,EAAOC,SAGVC,EAAa7B,EAA2B4B,UAC1CC,GACFF,EAAOG,WAAY,WAAUD,KAGxBF,EAAOC,MAsBpBG,UAAUC,EAAU,OACbT,KAAKC,QAIF,IAAIS,MAAM,yDAHhBC,OAAOC,OAAOZ,KAAKP,EAAUgB,QACxBV,EAAOC,KAAKP,EAASC,MAAQ,MAAQ,OAiB9Ca,WAAWD,SACHO,EAAab,KAAKc,EAAeR,OAErCS,cAAcF,QACTZ,GAAiB,EACtB,MAAOe,SAKPC,QAAQC,MACH,4BAA2BZ,YAAqBO,OAC/CG,GAYVF,EAAeR,MACTN,KAAKP,EAASK,oBACTE,KAAKP,EAASK,aAAaQ,EAAYN,KAAKP,EAASC,WAI1DyB,EAAY,CAvLF,mEAyLRC,EAAY,GAAEd,KAAcN,KAAKD,OAEjCsB,EAAarB,KAAKP,EAASI,wBAC7BwB,IAEFF,EAAYE,EAAWC,MAAM,KAIW,KAApCH,EAAUA,EAAUI,OAAS,IAC/BJ,EAAUK,OAAOL,EAAUI,OAAS,EAAG,IAI3CJ,EAAUM,KAAKL,GAERD,EAAUO,KAAK"}

data/lib/vendor/workbox-v5.1.3/workbox-window.dev.es5.mjs

@@ -0,0 +1,1094 @@
+try {
+  self['workbox:window:5.1.3'] && _();
+} catch (e) {}
+
+/*
+  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.
+*/
+/**
+ * Sends a data object to a service worker via `postMessage` and resolves with
+ * a response (if any).
+ *
+ * A response can be set in a message handler in the service worker by
+ * calling `event.ports[0].postMessage(...)`, which will resolve the promise
+ * returned by `messageSW()`. If no response is set, the promise will not
+ * resolve.
+ *
+ * @param {ServiceWorker} sw The service worker to send the message to.
+ * @param {Object} data An object to send to the service worker.
+ * @return {Promise<Object|undefined>}
+ * @memberof module:workbox-window
+ */
+
+function messageSW(sw, data) {
+  return new Promise(function (resolve) {
+    var messageChannel = new MessageChannel();
+
+    messageChannel.port1.onmessage = function (event) {
+      resolve(event.data);
+    };
+
+    sw.postMessage(data, [messageChannel.port2]);
+  });
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  subClass.__proto__ = superClass;
+}
+
+try {
+  self['workbox:core:5.1.3'] && _();
+} catch (e) {}
+
+/*
+  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.
+*/
+/**
+ * The Deferred class composes Promises in a way that allows for them to be
+ * resolved or rejected from outside the constructor. In most cases promises
+ * should be used directly, but Deferreds can be necessary when the logic to
+ * resolve a promise must be separate.
+ *
+ * @private
+ */
+
+var Deferred =
+/**
+ * Creates a promise and exposes its resolve and reject functions as methods.
+ */
+function Deferred() {
+  var _this = this;
+
+  this.promise = new Promise(function (resolve, reject) {
+    _this.resolve = resolve;
+    _this.reject = reject;
+  });
+};
+
+/*
+  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(function () {});
+}
+
+/*
+  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.
+*/
+var logger =  function () {
+  // 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;
+  }
+
+  var inGroup = false;
+  var methodToColorMap = {
+    debug: "#7f8c8d",
+    log: "#2ecc71",
+    warn: "#f39c12",
+    error: "#c0392b",
+    groupCollapsed: "#3498db",
+    groupEnd: null
+  };
+
+  var print = function print(method, args) {
+    var _console2;
+
+    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
+      if (/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
+        var _console;
+
+        (_console = console)[method].apply(_console, args);
+
+        return;
+      }
+    }
+
+    var 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.
+
+    var logPrefix = inGroup ? [] : ['%cworkbox', styles.join(';')];
+
+    (_console2 = console)[method].apply(_console2, logPrefix.concat(args));
+
+    if (method === 'groupCollapsed') {
+      inGroup = true;
+    }
+
+    if (method === 'groupEnd') {
+      inGroup = false;
+    }
+  };
+
+  var api = {};
+  var loggerMethods = Object.keys(methodToColorMap);
+
+  var _loop = function _loop() {
+    var key = _loggerMethods[_i];
+    var method = key;
+
+    api[method] = function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      print(method, args);
+    };
+  };
+
+  for (var _i = 0, _loggerMethods = loggerMethods; _i < _loggerMethods.length; _i++) {
+    _loop();
+  }
+
+  return api;
+}();
+
+/*
+  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 minimal `EventTarget` shim.
+ * This is necessary because not all browsers support constructable
+ * `EventTarget`, so using a real `EventTarget` will error.
+ * @private
+ */
+var WorkboxEventTarget = /*#__PURE__*/function () {
+  function WorkboxEventTarget() {
+    this._eventListenerRegistry = new Map();
+  }
+  /**
+   * @param {string} type
+   * @param {Function} listener
+   * @private
+   */
+
+
+  var _proto = WorkboxEventTarget.prototype;
+
+  _proto.addEventListener = function addEventListener(type, listener) {
+    var foo = this._getEventListenersByType(type);
+
+    foo.add(listener);
+  }
+  /**
+   * @param {string} type
+   * @param {Function} listener
+   * @private
+   */
+  ;
+
+  _proto.removeEventListener = function removeEventListener(type, listener) {
+    this._getEventListenersByType(type).delete(listener);
+  }
+  /**
+   * @param {Object} event
+   * @private
+   */
+  ;
+
+  _proto.dispatchEvent = function dispatchEvent(event) {
+    event.target = this;
+
+    var listeners = this._getEventListenersByType(event.type);
+
+    for (var _iterator = listeners, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      var listener = _ref;
+      listener(event);
+    }
+  }
+  /**
+   * Returns a Set of listeners associated with the passed event type.
+   * If no handlers have been registered, an empty Set is returned.
+   *
+   * @param {string} type The event type.
+   * @return {Set<ListenerCallback>} An array of handler functions.
+   * @private
+   */
+  ;
+
+  _proto._getEventListenersByType = function _getEventListenersByType(type) {
+    if (!this._eventListenerRegistry.has(type)) {
+      this._eventListenerRegistry.set(type, new Set());
+    }
+
+    return this._eventListenerRegistry.get(type);
+  };
+
+  return WorkboxEventTarget;
+}();
+
+/*
+  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 true if two URLs have the same `.href` property. The URLS can be
+ * relative, and if they are the current location href is used to resolve URLs.
+ *
+ * @private
+ * @param {string} url1
+ * @param {string} url2
+ * @return {boolean}
+ */
+
+function urlsMatch(url1, url2) {
+  var _location = location,
+      href = _location.href;
+  return new URL(url1, href).href === new URL(url2, href).href;
+}
+
+/*
+  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 minimal `Event` subclass shim.
+ * This doesn't *actually* subclass `Event` because not all browsers support
+ * constructable `EventTarget`, and using a real `Event` will error.
+ * @private
+ */
+
+var WorkboxEvent = function WorkboxEvent(type, props) {
+  this.type = type;
+  Object.assign(this, props);
+};
+
+// `skipWaiting()` wasn't called. This 200 amount wasn't scientifically
+// chosen, but it seems to avoid false positives in my testing.
+
+function _await(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+
+  return then ? value.then(then) : value;
+}
+
+var WAITING_TIMEOUT_DURATION = 200; // The amount of time after a registration that we can reasonably conclude
+// that the registration didn't trigger an update.
+
+function _async(f) {
+  return function () {
+    for (var args = [], i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+
+    try {
+      return Promise.resolve(f.apply(this, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+}
+
+var REGISTRATION_TIMEOUT_DURATION = 60000;
+/**
+ * A class to aid in handling service worker registration, updates, and
+ * reacting to service worker lifecycle events.
+ *
+ * @fires [message]{@link module:workbox-window.Workbox#message}
+ * @fires [installed]{@link module:workbox-window.Workbox#installed}
+ * @fires [waiting]{@link module:workbox-window.Workbox#waiting}
+ * @fires [controlling]{@link module:workbox-window.Workbox#controlling}
+ * @fires [activated]{@link module:workbox-window.Workbox#activated}
+ * @fires [redundant]{@link module:workbox-window.Workbox#redundant}
+ * @fires [externalinstalled]{@link module:workbox-window.Workbox#externalinstalled}
+ * @fires [externalwaiting]{@link module:workbox-window.Workbox#externalwaiting}
+ * @fires [externalactivated]{@link module:workbox-window.Workbox#externalactivated}
+ * @memberof module:workbox-window
+ */
+
+function _empty() {}
+
+var Workbox = /*#__PURE__*/function (_WorkboxEventTarget) {
+  _inheritsLoose(Workbox, _WorkboxEventTarget);
+
+  /**
+   * Creates a new Workbox instance with a script URL and service worker
+   * options. The script URL and options are the same as those used when
+   * calling `navigator.serviceWorker.register(scriptURL, options)`. See:
+   * https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/register
+   *
+   * @param {string} scriptURL The service worker script associated with this
+   *     instance.
+   * @param {Object} [registerOptions] The service worker options associated
+   *     with this instance.
+   */
+  function Workbox(scriptURL, registerOptions) {
+    var _this;
+
+    if (registerOptions === void 0) {
+      registerOptions = {};
+    }
+
+    _this = _WorkboxEventTarget.call(this) || this;
+    _this._registerOptions = {};
+    _this._updateFoundCount = 0; // Deferreds we can resolve later.
+
+    _this._swDeferred = new Deferred();
+    _this._activeDeferred = new Deferred();
+    _this._controllingDeferred = new Deferred();
+    _this._registrationTime = 0;
+    _this._ownSWs = new Set();
+    /**
+     * @private
+     */
+
+    _this._onUpdateFound = function () {
+      // `this._registration` will never be `undefined` after an update is found.
+      var registration = _this._registration;
+      var installingSW = registration.installing; // If the script URL passed to `navigator.serviceWorker.register()` is
+      // different from the current controlling SW's script URL, we know any
+      // successful registration calls will trigger an `updatefound` event.
+      // But if the registered script URL is the same as the current controlling
+      // SW's script URL, we'll only get an `updatefound` event if the file
+      // changed since it was last registered. This can be a problem if the user
+      // opens up the same page in a different tab, and that page registers
+      // a SW that triggers an update. It's a problem because this page has no
+      // good way of knowing whether the `updatefound` event came from the SW
+      // script it registered or from a registration attempt made by a newer
+      // version of the page running in another tab.
+      // To minimize the possibility of a false positive, we use the logic here:
+
+      var updateLikelyTriggeredExternally = // Since we enforce only calling `register()` once, and since we don't
+      // add the `updatefound` event listener until the `register()` call, if
+      // `_updateFoundCount` is > 0 then it means this method has already
+      // been called, thus this SW must be external
+      _this._updateFoundCount > 0 || // If the script URL of the installing SW is different from this
+      // instance's script URL, we know it's definitely not from our
+      // registration.
+      !urlsMatch(installingSW.scriptURL, _this._scriptURL) || // If all of the above are false, then we use a time-based heuristic:
+      // Any `updatefound` event that occurs long after our registration is
+      // assumed to be external.
+      performance.now() > _this._registrationTime + REGISTRATION_TIMEOUT_DURATION ? // If any of the above are not true, we assume the update was
+      // triggered by this instance.
+      true : false;
+
+      if (updateLikelyTriggeredExternally) {
+        _this._externalSW = installingSW;
+        registration.removeEventListener('updatefound', _this._onUpdateFound);
+      } else {
+        // If the update was not triggered externally we know the installing
+        // SW is the one we registered, so we set it.
+        _this._sw = installingSW;
+
+        _this._ownSWs.add(installingSW);
+
+        _this._swDeferred.resolve(installingSW); // The `installing` state isn't something we have a dedicated
+        // callback for, but we do log messages for it in development.
+
+
+        {
+          if (navigator.serviceWorker.controller) {
+            logger.log('Updated service worker found. Installing now...');
+          } else {
+            logger.log('Service worker is installing...');
+          }
+        }
+      } // Increment the `updatefound` count, so future invocations of this
+      // method can be sure they were triggered externally.
+
+
+      ++_this._updateFoundCount; // Add a `statechange` listener regardless of whether this update was
+      // triggered externally, since we have callbacks for both.
+
+      installingSW.addEventListener('statechange', _this._onStateChange);
+    };
+    /**
+     * @private
+     * @param {Event} originalEvent
+     */
+
+
+    _this._onStateChange = function (originalEvent) {
+      // `this._registration` will never be `undefined` after an update is found.
+      var registration = _this._registration;
+      var sw = originalEvent.target;
+      var state = sw.state;
+      var isExternal = sw === _this._externalSW;
+      var eventPrefix = isExternal ? 'external' : '';
+      var eventProps = {
+        sw: sw,
+        originalEvent: originalEvent
+      };
+
+      if (!isExternal && _this._isUpdate) {
+        eventProps.isUpdate = true;
+      }
+
+      _this.dispatchEvent(new WorkboxEvent(eventPrefix + state, eventProps));
+
+      if (state === 'installed') {
+        // This timeout is used to ignore cases where the service worker calls
+        // `skipWaiting()` in the install event, thus moving it directly in the
+        // activating state. (Since all service workers *must* go through the
+        // waiting phase, the only way to detect `skipWaiting()` called in the
+        // install event is to observe that the time spent in the waiting phase
+        // is very short.)
+        // NOTE: we don't need separate timeouts for the own and external SWs
+        // since they can't go through these phases at the same time.
+        _this._waitingTimeout = self.setTimeout(function () {
+          // Ensure the SW is still waiting (it may now be redundant).
+          if (state === 'installed' && registration.waiting === sw) {
+            _this.dispatchEvent(new WorkboxEvent(eventPrefix + 'waiting', eventProps));
+
+            {
+              if (isExternal) {
+                logger.warn('An external service worker has installed but is ' + 'waiting for this client to close before activating...');
+              } else {
+                logger.warn('The service worker has installed but is waiting ' + 'for existing clients to close before activating...');
+              }
+            }
+          }
+        }, WAITING_TIMEOUT_DURATION);
+      } else if (state === 'activating') {
+        clearTimeout(_this._waitingTimeout);
+
+        if (!isExternal) {
+          _this._activeDeferred.resolve(sw);
+        }
+      }
+
+      {
+        switch (state) {
+          case 'installed':
+            if (isExternal) {
+              logger.warn('An external service worker has installed. ' + 'You may want to suggest users reload this page.');
+            } else {
+              logger.log('Registered service worker installed.');
+            }
+
+            break;
+
+          case 'activated':
+            if (isExternal) {
+              logger.warn('An external service worker has activated.');
+            } else {
+              logger.log('Registered service worker activated.');
+
+              if (sw !== navigator.serviceWorker.controller) {
+                logger.warn('The registered service worker is active but ' + 'not yet controlling the page. Reload or run ' + '`clients.claim()` in the service worker.');
+              }
+            }
+
+            break;
+
+          case 'redundant':
+            if (sw === _this._compatibleControllingSW) {
+              logger.log('Previously controlling service worker now redundant!');
+            } else if (!isExternal) {
+              logger.log('Registered service worker now redundant!');
+            }
+
+            break;
+        }
+      }
+    };
+    /**
+     * @private
+     * @param {Event} originalEvent
+     */
+
+
+    _this._onControllerChange = function (originalEvent) {
+      var sw = _this._sw;
+
+      if (sw === navigator.serviceWorker.controller) {
+        _this.dispatchEvent(new WorkboxEvent('controlling', {
+          sw: sw,
+          originalEvent: originalEvent,
+          isUpdate: _this._isUpdate
+        }));
+
+        {
+          logger.log('Registered service worker now controlling this page.');
+        }
+
+        _this._controllingDeferred.resolve(sw);
+      }
+    };
+    /**
+     * @private
+     * @param {Event} originalEvent
+     */
+
+
+    _this._onMessage = _async(function (originalEvent) {
+      var data = originalEvent.data,
+          source = originalEvent.source; // Wait until there's an "own" service worker. This is used to buffer
+      // `message` events that may be received prior to calling `register()`.
+
+      return _await(_this.getSW(), function () {
+        if (_this._ownSWs.has(source)) {
+          _this.dispatchEvent(new WorkboxEvent('message', {
+            data: data,
+            sw: source,
+            originalEvent: originalEvent
+          }));
+        }
+      }); // If the service worker that sent the message is in the list of own
+      // service workers for this instance, dispatch a `message` event.
+      // NOTE: we check for all previously owned service workers rather than
+      // just the current one because some messages (e.g. cache updates) use
+      // a timeout when sent and may be delayed long enough for a service worker
+      // update to be found.
+    });
+    _this._scriptURL = scriptURL;
+    _this._registerOptions = registerOptions; // Add a message listener immediately since messages received during
+    // page load are buffered only until the DOMContentLoaded event:
+    // https://github.com/GoogleChrome/workbox/issues/2202
+
+    navigator.serviceWorker.addEventListener('message', _this._onMessage);
+    return _this;
+  }
+  /**
+   * Registers a service worker for this instances script URL and service
+   * worker options. By default this method delays registration until after
+   * the window has loaded.
+   *
+   * @param {Object} [options]
+   * @param {Function} [options.immediate=false] Setting this to true will
+   *     register the service worker immediately, even if the window has
+   *     not loaded (not recommended).
+   */
+
+
+  var _proto = Workbox.prototype;
+
+  _proto.register = function register(_temp) {
+    var _ref = _temp === void 0 ? {} : _temp,
+        _ref$immediate = _ref.immediate,
+        immediate = _ref$immediate === void 0 ? false : _ref$immediate;
+
+    try {
+      var _this3 = this;
+
+      if ("dev" !== 'production') {
+        if (_this3._registrationTime) {
+          logger.error('Cannot re-register a Workbox instance after it has ' + 'been registered. Create a new instance instead.');
+          return;
+        }
+      }
+
+      return _invoke(function () {
+        if (!immediate && document.readyState !== 'complete') {
+          return _awaitIgnored(new Promise(function (res) {
+            return window.addEventListener('load', res);
+          }));
+        }
+      }, function () {
+        // Set this flag to true if any service worker was controlling the page
+        // at registration time.
+        _this3._isUpdate = Boolean(navigator.serviceWorker.controller); // Before registering, attempt to determine if a SW is already controlling
+        // the page, and if that SW script (and version, if specified) matches this
+        // instance's script.
+
+        _this3._compatibleControllingSW = _this3._getControllingSWIfCompatible();
+        return _await(_this3._registerScript(), function (_this2$_registerScrip) {
+          _this3._registration = _this2$_registerScrip;
+
+          // If we have a compatible controller, store the controller as the "own"
+          // SW, resolve active/controlling deferreds and add necessary listeners.
+          if (_this3._compatibleControllingSW) {
+            _this3._sw = _this3._compatibleControllingSW;
+
+            _this3._activeDeferred.resolve(_this3._compatibleControllingSW);
+
+            _this3._controllingDeferred.resolve(_this3._compatibleControllingSW);
+
+            _this3._compatibleControllingSW.addEventListener('statechange', _this3._onStateChange, {
+              once: true
+            });
+          } // If there's a waiting service worker with a matching URL before the
+          // `updatefound` event fires, it likely means that this site is open
+          // in another tab, or the user refreshed the page (and thus the previous
+          // page wasn't fully unloaded before this page started loading).
+          // https://developers.google.com/web/fundamentals/primers/service-workers/lifecycle#waiting
+
+
+          var waitingSW = _this3._registration.waiting;
+
+          if (waitingSW && urlsMatch(waitingSW.scriptURL, _this3._scriptURL)) {
+            // Store the waiting SW as the "own" Sw, even if it means overwriting
+            // a compatible controller.
+            _this3._sw = waitingSW; // Run this in the next microtask, so any code that adds an event
+            // listener after awaiting `register()` will get this event.
+
+            dontWaitFor(Promise.resolve().then(function () {
+              _this3.dispatchEvent(new WorkboxEvent('waiting', {
+                sw: waitingSW,
+                wasWaitingBeforeRegister: true
+              }));
+
+              if ("dev" !== 'production') {
+                logger.warn('A service worker was already waiting to activate ' + 'before this script was registered...');
+              }
+            }));
+          } // If an "own" SW is already set, resolve the deferred.
+
+
+          if (_this3._sw) {
+            _this3._swDeferred.resolve(_this3._sw);
+
+            _this3._ownSWs.add(_this3._sw);
+          }
+
+          if ("dev" !== 'production') {
+            logger.log('Successfully registered service worker.', _this3._scriptURL);
+
+            if (navigator.serviceWorker.controller) {
+              if (_this3._compatibleControllingSW) {
+                logger.debug('A service worker with the same script URL ' + 'is already controlling this page.');
+              } else {
+                logger.debug('A service worker with a different script URL is ' + 'currently controlling the page. The browser is now fetching ' + 'the new script now...');
+              }
+            }
+
+            var currentPageIsOutOfScope = function currentPageIsOutOfScope() {
+              var scopeURL = new URL(_this3._registerOptions.scope || _this3._scriptURL, document.baseURI);
+              var scopeURLBasePath = new URL('./', scopeURL.href).pathname;
+              return !location.pathname.startsWith(scopeURLBasePath);
+            };
+
+            if (currentPageIsOutOfScope()) {
+              logger.warn('The current page is not in scope for the registered ' + 'service worker. Was this a mistake?');
+            }
+          }
+
+          _this3._registration.addEventListener('updatefound', _this3._onUpdateFound);
+
+          navigator.serviceWorker.addEventListener('controllerchange', _this3._onControllerChange, {
+            once: true
+          });
+          return _this3._registration;
+        });
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * Checks for updates of the registered service worker.
+   */
+  ;
+
+  _proto.update = function update() {
+    try {
+      var _this5 = this;
+
+      if (!_this5._registration) {
+        if ("dev" !== 'production') {
+          logger.error('Cannot update a Workbox instance without ' + 'being registered. Register the Workbox instance first.');
+        }
+
+        return;
+      } // Try to update registration
+
+
+      return _awaitIgnored(_this5._registration.update());
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * Resolves to the service worker registered by this instance as soon as it
+   * is active. If a service worker was already controlling at registration
+   * time then it will resolve to that if the script URLs (and optionally
+   * script versions) match, otherwise it will wait until an update is found
+   * and activates.
+   *
+   * @return {Promise<ServiceWorker>}
+   */
+  ;
+
+  /**
+   * Resolves with a reference to a service worker that matches the script URL
+   * of this instance, as soon as it's available.
+   *
+   * If, at registration time, there's already an active or waiting service
+   * worker with a matching script URL, it will be used (with the waiting
+   * service worker taking precedence over the active service worker if both
+   * match, since the waiting service worker would have been registered more
+   * recently).
+   * If there's no matching active or waiting service worker at registration
+   * time then the promise will not resolve until an update is found and starts
+   * installing, at which point the installing service worker is used.
+   *
+   * @return {Promise<ServiceWorker>}
+   */
+  _proto.getSW = function getSW() {
+    try {
+      var _this7 = this;
+
+      // If `this._sw` is set, resolve with that as we want `getSW()` to
+      // return the correct (new) service worker if an update is found.
+      return _this7._sw !== undefined ? _this7._sw : _this7._swDeferred.promise;
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * Sends the passed data object to the service worker registered by this
+   * instance (via [`getSW()`]{@link module:workbox-window.Workbox#getSW}) and resolves
+   * with a response (if any).
+   *
+   * A response can be set in a message handler in the service worker by
+   * calling `event.ports[0].postMessage(...)`, which will resolve the promise
+   * returned by `messageSW()`. If no response is set, the promise will never
+   * resolve.
+   *
+   * @param {Object} data An object to send to the service worker
+   * @return {Promise<Object>}
+   */
+  ;
+
+  _proto.messageSW = function messageSW$1(data) {
+    try {
+      var _this9 = this;
+
+      return _await(_this9.getSW(), function (sw) {
+        return messageSW(sw, data);
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * Checks for a service worker already controlling the page and returns
+   * it if its script URL matches.
+   *
+   * @private
+   * @return {ServiceWorker|undefined}
+   */
+  ;
+
+  _proto._getControllingSWIfCompatible = function _getControllingSWIfCompatible() {
+    var controller = navigator.serviceWorker.controller;
+
+    if (controller && urlsMatch(controller.scriptURL, this._scriptURL)) {
+      return controller;
+    } else {
+      return undefined;
+    }
+  }
+  /**
+   * Registers a service worker for this instances script URL and register
+   * options and tracks the time registration was complete.
+   *
+   * @private
+   */
+  ;
+
+  _proto._registerScript = function _registerScript() {
+    try {
+      var _this11 = this;
+
+      return _catch(function () {
+        return _await(navigator.serviceWorker.register(_this11._scriptURL, _this11._registerOptions), function (reg) {
+          // Keep track of when registration happened, so it can be used in the
+          // `this._onUpdateFound` heuristic. Also use the presence of this
+          // property as a way to see if `.register()` has been called.
+          _this11._registrationTime = performance.now();
+          return reg;
+        });
+      }, function (error) {
+        if ("dev" !== 'production') {
+          logger.error(error);
+        } // Re-throw the error.
+
+
+        throw error;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+
+  _createClass(Workbox, [{
+    key: "active",
+    get: function get() {
+      return this._activeDeferred.promise;
+    }
+    /**
+     * Resolves to the service worker registered by this instance as soon as it
+     * is controlling the page. If a service worker was already controlling at
+     * registration time then it will resolve to that if the script URLs (and
+     * optionally script versions) match, otherwise it will wait until an update
+     * is found and starts controlling the page.
+     * Note: the first time a service worker is installed it will active but
+     * not start controlling the page unless `clients.claim()` is called in the
+     * service worker.
+     *
+     * @return {Promise<ServiceWorker>}
+     */
+
+  }, {
+    key: "controlling",
+    get: function get() {
+      return this._controllingDeferred.promise;
+    }
+  }]);
+
+  return Workbox;
+}(WorkboxEventTarget);
+
+function _awaitIgnored(value, direct) {
+  if (!direct) {
+    return value && value.then ? value.then(_empty) : Promise.resolve();
+  }
+} // The jsdoc comments below outline the events this instance may dispatch:
+// -----------------------------------------------------------------------
+
+/**
+ * The `message` event is dispatched any time a `postMessage` is received.
+ *
+ * @event module:workbox-window.Workbox#message
+ * @type {WorkboxEvent}
+ * @property {*} data The `data` property from the original `message` event.
+ * @property {Event} originalEvent The original [`message`]{@link https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent}
+ *     event.
+ * @property {string} type `message`.
+ * @property {Workbox} target The `Workbox` instance.
+ */
+
+/**
+ * The `installed` event is dispatched if the state of a
+ * [`Workbox`]{@link module:workbox-window.Workbox} instance's
+ * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}
+ * changes to `installed`.
+ *
+ * Then can happen either the very first time a service worker is installed,
+ * or after an update to the current service worker is found. In the case
+ * of an update being found, the event's `isUpdate` property will be `true`.
+ *
+ * @event module:workbox-window.Workbox#installed
+ * @type {WorkboxEvent}
+ * @property {ServiceWorker} sw The service worker instance.
+ * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
+ *     event.
+ * @property {boolean|undefined} isUpdate True if a service worker was already
+ *     controlling when this `Workbox` instance called `register()`.
+ * @property {string} type `installed`.
+ * @property {Workbox} target The `Workbox` instance.
+ */
+
+/**
+ * The `waiting` event is dispatched if the state of a
+ * [`Workbox`]{@link module:workbox-window.Workbox} instance's
+ * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}
+ * changes to `installed` and then doesn't immediately change to `activating`.
+ * It may also be dispatched if a service worker with the same
+ * [`scriptURL`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/scriptURL}
+ * was already waiting when the [`register()`]{@link module:workbox-window.Workbox#register}
+ * method was called.
+ *
+ * @event module:workbox-window.Workbox#waiting
+ * @type {WorkboxEvent}
+ * @property {ServiceWorker} sw The service worker instance.
+ * @property {Event|undefined} originalEvent The original
+ *    [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
+ *     event, or `undefined` in the case where the service worker was waiting
+ *     to before `.register()` was called.
+ * @property {boolean|undefined} isUpdate True if a service worker was already
+ *     controlling when this `Workbox` instance called `register()`.
+ * @property {boolean|undefined} wasWaitingBeforeRegister True if a service worker with
+ *     a matching `scriptURL` was already waiting when this `Workbox`
+ *     instance called `register()`.
+ * @property {string} type `waiting`.
+ * @property {Workbox} target The `Workbox` instance.
+ */
+
+/**
+ * The `controlling` event is dispatched if a
+ * [`controllerchange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/oncontrollerchange}
+ * fires on the service worker [container]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer}
+ * and the [`scriptURL`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/scriptURL}
+ * of the new [controller]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/controller}
+ * matches the `scriptURL` of the `Workbox` instance's
+ * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}.
+ *
+ * @event module:workbox-window.Workbox#controlling
+ * @type {WorkboxEvent}
+ * @property {ServiceWorker} sw The service worker instance.
+ * @property {Event} originalEvent The original [`controllerchange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/oncontrollerchange}
+ *     event.
+ * @property {boolean|undefined} isUpdate True if a service worker was already
+ *     controlling when this service worker was registered.
+ * @property {string} type `controlling`.
+ * @property {Workbox} target The `Workbox` instance.
+ */
+
+/**
+ * The `activated` event is dispatched if the state of a
+ * [`Workbox`]{@link module:workbox-window.Workbox} instance's
+ * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}
+ * changes to `activated`.
+ *
+ * @event module:workbox-window.Workbox#activated
+ * @type {WorkboxEvent}
+ * @property {ServiceWorker} sw The service worker instance.
+ * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
+ *     event.
+ * @property {boolean|undefined} isUpdate True if a service worker was already
+ *     controlling when this `Workbox` instance called `register()`.
+ * @property {string} type `activated`.
+ * @property {Workbox} target The `Workbox` instance.
+ */
+
+/**
+ * The `redundant` event is dispatched if the state of a
+ * [`Workbox`]{@link module:workbox-window.Workbox} instance's
+ * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}
+ * changes to `redundant`.
+ *
+ * @event module:workbox-window.Workbox#redundant
+ * @type {WorkboxEvent}
+ * @property {ServiceWorker} sw The service worker instance.
+ * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
+ *     event.
+ * @property {boolean|undefined} isUpdate True if a service worker was already
+ *     controlling when this `Workbox` instance called `register()`.
+ * @property {string} type `redundant`.
+ * @property {Workbox} target The `Workbox` instance.
+ */
+
+/**
+ * The `externalinstalled` event is dispatched if the state of an
+ * [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}
+ * changes to `installed`.
+ *
+ * @event module:workbox-window.Workbox#externalinstalled
+ * @type {WorkboxEvent}
+ * @property {ServiceWorker} sw The service worker instance.
+ * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
+ *     event.
+ * @property {string} type `externalinstalled`.
+ * @property {Workbox} target The `Workbox` instance.
+ */
+
+/**
+ * The `externalwaiting` event is dispatched if the state of an
+ * [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}
+ * changes to `waiting`.
+ *
+ * @event module:workbox-window.Workbox#externalwaiting
+ * @type {WorkboxEvent}
+ * @property {ServiceWorker} sw The service worker instance.
+ * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
+ *     event.
+ * @property {string} type `externalwaiting`.
+ * @property {Workbox} target The `Workbox` instance.
+ */
+
+/**
+ * The `externalactivated` event is dispatched if the state of an
+ * [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}
+ * changes to `activated`.
+ *
+ * @event module:workbox-window.Workbox#externalactivated
+ * @type {WorkboxEvent}
+ * @property {ServiceWorker} sw The service worker instance.
+ * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
+ *     event.
+ * @property {string} type `externalactivated`.
+ * @property {Workbox} target The `Workbox` instance.
+ */
+
+
+function _invoke(body, then) {
+  var result = body();
+
+  if (result && result.then) {
+    return result.then(then);
+  }
+
+  return then(result);
+}
+
+function _catch(body, recover) {
+  try {
+    var result = body();
+  } catch (e) {
+    return recover(e);
+  }
+
+  if (result && result.then) {
+    return result.then(void 0, recover);
+  }
+
+  return result;
+}
+
+export { Workbox, messageSW };
+//# sourceMappingURL=workbox-window.dev.es5.mjs.map