serviceWorker.js.map

{
  "version": 3,
  "sources": ["node_modules/workbox-core/_version.js", "node_modules/workbox-core/models/messages/messageGenerator.js", "node_modules/workbox-core/_private/WorkboxError.js", "node_modules/workbox-routing/_version.js", "node_modules/workbox-routing/utils/constants.js", "node_modules/workbox-routing/utils/normalizeHandler.js", "node_modules/workbox-routing/Route.js", "node_modules/workbox-routing/RegExpRoute.js", "node_modules/workbox-core/_private/getFriendlyURL.js", "node_modules/workbox-routing/Router.js", "node_modules/workbox-routing/utils/getOrCreateDefaultRouter.js", "node_modules/workbox-routing/registerRoute.js", "node_modules/workbox-core/_private/cacheNames.js", "node_modules/workbox-core/_private/cacheMatchIgnoreParams.js", "node_modules/workbox-core/_private/Deferred.js", "node_modules/workbox-core/models/quotaErrorCallbacks.js", "node_modules/workbox-core/_private/executeQuotaErrorCallbacks.js", "node_modules/workbox-core/_private/timeout.js", "node_modules/workbox-strategies/_version.js", "node_modules/workbox-strategies/StrategyHandler.js", "node_modules/workbox-strategies/Strategy.js", "node_modules/workbox-strategies/plugins/cacheOkAndOpaquePlugin.js", "node_modules/workbox-strategies/StaleWhileRevalidate.js", "node_modules/workbox-navigation-preload/_version.js", "node_modules/workbox-navigation-preload/isSupported.js", "node_modules/workbox-navigation-preload/enable.js", "src/ts/serviceWorker.ts"],
  "sourcesContent": ["\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:core:7.0.0'] && _();\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 { messages } from './messages.js';\nimport '../../_version.js';\nconst fallback = (code, ...args) => {\n    let msg = code;\n    if (args.length > 0) {\n        msg += ` :: ${JSON.stringify(args)}`;\n    }\n    return msg;\n};\nconst generatorFunction = (code, details = {}) => {\n    const message = messages[code];\n    if (!message) {\n        throw new Error(`Unable to find message for code '${code}'.`);\n    }\n    return message(details);\n};\nexport const messageGenerator = process.env.NODE_ENV === 'production' ? fallback : generatorFunction;\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 { messageGenerator } from '../models/messages/messageGenerator.js';\nimport '../_version.js';\n/**\n * Workbox errors should be thrown with this class.\n * This allows use to ensure the type easily in tests,\n * helps developers identify errors from workbox\n * easily and allows use to optimise error\n * messages correctly.\n *\n * @private\n */\nclass WorkboxError extends Error {\n    /**\n     *\n     * @param {string} errorCode The error code that\n     * identifies this particular error.\n     * @param {Object=} details Any relevant arguments\n     * that will help developers identify issues should\n     * be added as a key on the context object.\n     */\n    constructor(errorCode, details) {\n        const message = messageGenerator(errorCode, details);\n        super(message);\n        this.name = errorCode;\n        this.details = details;\n    }\n}\nexport { WorkboxError };\n", "\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:routing:7.0.0'] && _();\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';\n/**\n * The default HTTP method, 'GET', used when there's no specific method\n * configured for a route.\n *\n * @type {string}\n *\n * @private\n */\nexport const defaultMethod = 'GET';\n/**\n * The list of valid HTTP methods associated with requests that could be routed.\n *\n * @type {Array<string>}\n *\n * @private\n */\nexport const validMethods = [\n    'DELETE',\n    'GET',\n    'HEAD',\n    'PATCH',\n    'POST',\n    'PUT',\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 '../_version.js';\n/**\n * @param {function()|Object} handler Either a function, or an object with a\n * 'handle' method.\n * @return {Object} An object with a handle method.\n *\n * @private\n */\nexport const normalizeHandler = (handler) => {\n    if (handler && typeof handler === 'object') {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.hasMethod(handler, 'handle', {\n                moduleName: 'workbox-routing',\n                className: 'Route',\n                funcName: 'constructor',\n                paramName: 'handler',\n            });\n        }\n        return handler;\n    }\n    else {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isType(handler, 'function', {\n                moduleName: 'workbox-routing',\n                className: 'Route',\n                funcName: 'constructor',\n                paramName: 'handler',\n            });\n        }\n        return { handle: handler };\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 { defaultMethod, validMethods } from './utils/constants.js';\nimport { normalizeHandler } from './utils/normalizeHandler.js';\nimport './_version.js';\n/**\n * A `Route` consists of a pair of callback functions, \"match\" and \"handler\".\n * The \"match\" callback determine if a route should be used to \"handle\" a\n * request by returning a non-falsy value if it can. The \"handler\" callback\n * is called when there is a match and should return a Promise that resolves\n * to a `Response`.\n *\n * @memberof workbox-routing\n */\nclass Route {\n    /**\n     * Constructor for Route class.\n     *\n     * @param {workbox-routing~matchCallback} match\n     * A callback function that determines whether the route matches a given\n     * `fetch` event by returning a non-falsy value.\n     * @param {workbox-routing~handlerCallback} handler A callback\n     * function that returns a Promise resolving to a Response.\n     * @param {string} [method='GET'] The HTTP method to match the Route\n     * against.\n     */\n    constructor(match, handler, method = defaultMethod) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isType(match, 'function', {\n                moduleName: 'workbox-routing',\n                className: 'Route',\n                funcName: 'constructor',\n                paramName: 'match',\n            });\n            if (method) {\n                assert.isOneOf(method, validMethods, { paramName: 'method' });\n            }\n        }\n        // These values are referenced directly by Router so cannot be\n        // altered by minificaton.\n        this.handler = normalizeHandler(handler);\n        this.match = match;\n        this.method = method;\n    }\n    /**\n     *\n     * @param {workbox-routing-handlerCallback} handler A callback\n     * function that returns a Promise resolving to a Response\n     */\n    setCatchHandler(handler) {\n        this.catchHandler = normalizeHandler(handler);\n    }\n}\nexport { Route };\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 { logger } from 'workbox-core/_private/logger.js';\nimport { Route } from './Route.js';\nimport './_version.js';\n/**\n * RegExpRoute makes it easy to create a regular expression based\n * {@link workbox-routing.Route}.\n *\n * For same-origin requests the RegExp only needs to match part of the URL. For\n * requests against third-party servers, you must define a RegExp that matches\n * the start of the URL.\n *\n * @memberof workbox-routing\n * @extends workbox-routing.Route\n */\nclass RegExpRoute extends Route {\n    /**\n     * If the regular expression contains\n     * [capture groups]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#grouping-back-references},\n     * the captured values will be passed to the\n     * {@link workbox-routing~handlerCallback} `params`\n     * argument.\n     *\n     * @param {RegExp} regExp The regular expression to match against URLs.\n     * @param {workbox-routing~handlerCallback} handler A callback\n     * function that returns a Promise resulting in a Response.\n     * @param {string} [method='GET'] The HTTP method to match the Route\n     * against.\n     */\n    constructor(regExp, handler, method) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isInstance(regExp, RegExp, {\n                moduleName: 'workbox-routing',\n                className: 'RegExpRoute',\n                funcName: 'constructor',\n                paramName: 'pattern',\n            });\n        }\n        const match = ({ url }) => {\n            const result = regExp.exec(url.href);\n            // Return immediately if there's no match.\n            if (!result) {\n                return;\n            }\n            // Require that the match start at the first character in the URL string\n            // if it's a cross-origin request.\n            // See https://github.com/GoogleChrome/workbox/issues/281 for the context\n            // behind this behavior.\n            if (url.origin !== location.origin && result.index !== 0) {\n                if (process.env.NODE_ENV !== 'production') {\n                    logger.debug(`The regular expression '${regExp.toString()}' only partially matched ` +\n                        `against the cross-origin URL '${url.toString()}'. RegExpRoute's will only ` +\n                        `handle cross-origin requests if they match the entire URL.`);\n                }\n                return;\n            }\n            // If the route matches, but there aren't any capture groups defined, then\n            // this will return [], which is truthy and therefore sufficient to\n            // indicate a match.\n            // If there are capture groups, then it will return their values.\n            return result.slice(1);\n        };\n        super(match, handler, method);\n    }\n}\nexport { RegExpRoute };\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';\nconst getFriendlyURL = (url) => {\n    const urlObj = new URL(String(url), location.href);\n    // See https://github.com/GoogleChrome/workbox/issues/2323\n    // We want to include everything, except for the origin if it's same-origin.\n    return urlObj.href.replace(new RegExp(`^${location.origin}`), '');\n};\nexport { getFriendlyURL };\n", "/*\n  Copyright 2018 Google 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 { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { defaultMethod } from './utils/constants.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { normalizeHandler } from './utils/normalizeHandler.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport './_version.js';\n/**\n * The Router can be used to process a `FetchEvent` using one or more\n * {@link workbox-routing.Route}, responding with a `Response` if\n * a matching route exists.\n *\n * If no route matches a given a request, the Router will use a \"default\"\n * handler if one is defined.\n *\n * Should the matching Route throw an error, the Router will use a \"catch\"\n * handler if one is defined to gracefully deal with issues and respond with a\n * Request.\n *\n * If a request matches multiple routes, the **earliest** registered route will\n * be used to respond to the request.\n *\n * @memberof workbox-routing\n */\nclass Router {\n    /**\n     * Initializes a new Router.\n     */\n    constructor() {\n        this._routes = new Map();\n        this._defaultHandlerMap = new Map();\n    }\n    /**\n     * @return {Map<string, Array<workbox-routing.Route>>} routes A `Map` of HTTP\n     * method name ('GET', etc.) to an array of all the corresponding `Route`\n     * instances that are registered.\n     */\n    get routes() {\n        return this._routes;\n    }\n    /**\n     * Adds a fetch event listener to respond to events when a route matches\n     * the event's request.\n     */\n    addFetchListener() {\n        // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705\n        self.addEventListener('fetch', ((event) => {\n            const { request } = event;\n            const responsePromise = this.handleRequest({ request, event });\n            if (responsePromise) {\n                event.respondWith(responsePromise);\n            }\n        }));\n    }\n    /**\n     * Adds a message event listener for URLs to cache from the window.\n     * This is useful to cache resources loaded on the page prior to when the\n     * service worker started controlling it.\n     *\n     * The format of the message data sent from the window should be as follows.\n     * Where the `urlsToCache` array may consist of URL strings or an array of\n     * URL string + `requestInit` object (the same as you'd pass to `fetch()`).\n     *\n     * ```\n     * {\n     *   type: 'CACHE_URLS',\n     *   payload: {\n     *     urlsToCache: [\n     *       './script1.js',\n     *       './script2.js',\n     *       ['./script3.js', {mode: 'no-cors'}],\n     *     ],\n     *   },\n     * }\n     * ```\n     */\n    addCacheListener() {\n        // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705\n        self.addEventListener('message', ((event) => {\n            // event.data is type 'any'\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            if (event.data && event.data.type === 'CACHE_URLS') {\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n                const { payload } = event.data;\n                if (process.env.NODE_ENV !== 'production') {\n                    logger.debug(`Caching URLs from the window`, payload.urlsToCache);\n                }\n                const requestPromises = Promise.all(payload.urlsToCache.map((entry) => {\n                    if (typeof entry === 'string') {\n                        entry = [entry];\n                    }\n                    const request = new Request(...entry);\n                    return this.handleRequest({ request, event });\n                    // TODO(philipwalton): TypeScript errors without this typecast for\n                    // some reason (probably a bug). The real type here should work but\n                    // doesn't: `Array<Promise<Response> | undefined>`.\n                })); // TypeScript\n                event.waitUntil(requestPromises);\n                // If a MessageChannel was used, reply to the message on success.\n                if (event.ports && event.ports[0]) {\n                    void requestPromises.then(() => event.ports[0].postMessage(true));\n                }\n            }\n        }));\n    }\n    /**\n     * Apply the routing rules to a FetchEvent object to get a Response from an\n     * appropriate Route's handler.\n     *\n     * @param {Object} options\n     * @param {Request} options.request The request to handle.\n     * @param {ExtendableEvent} options.event The event that triggered the\n     *     request.\n     * @return {Promise<Response>|undefined} A promise is returned if a\n     *     registered route can handle the request. If there is no matching\n     *     route and there's no `defaultHandler`, `undefined` is returned.\n     */\n    handleRequest({ request, event, }) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isInstance(request, Request, {\n                moduleName: 'workbox-routing',\n                className: 'Router',\n                funcName: 'handleRequest',\n                paramName: 'options.request',\n            });\n        }\n        const url = new URL(request.url, location.href);\n        if (!url.protocol.startsWith('http')) {\n            if (process.env.NODE_ENV !== 'production') {\n                logger.debug(`Workbox Router only supports URLs that start with 'http'.`);\n            }\n            return;\n        }\n        const sameOrigin = url.origin === location.origin;\n        const { params, route } = this.findMatchingRoute({\n            event,\n            request,\n            sameOrigin,\n            url,\n        });\n        let handler = route && route.handler;\n        const debugMessages = [];\n        if (process.env.NODE_ENV !== 'production') {\n            if (handler) {\n                debugMessages.push([`Found a route to handle this request:`, route]);\n                if (params) {\n                    debugMessages.push([\n                        `Passing the following params to the route's handler:`,\n                        params,\n                    ]);\n                }\n            }\n        }\n        // If we don't have a handler because there was no matching route, then\n        // fall back to defaultHandler if that's defined.\n        const method = request.method;\n        if (!handler && this._defaultHandlerMap.has(method)) {\n            if (process.env.NODE_ENV !== 'production') {\n                debugMessages.push(`Failed to find a matching route. Falling ` +\n                    `back to the default handler for ${method}.`);\n            }\n            handler = this._defaultHandlerMap.get(method);\n        }\n        if (!handler) {\n            if (process.env.NODE_ENV !== 'production') {\n                // No handler so Workbox will do nothing. If logs is set of debug\n                // i.e. verbose, we should print out this information.\n                logger.debug(`No route found for: ${getFriendlyURL(url)}`);\n            }\n            return;\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            // We have a handler, meaning Workbox is going to handle the route.\n            // print the routing details to the console.\n            logger.groupCollapsed(`Router is responding to: ${getFriendlyURL(url)}`);\n            debugMessages.forEach((msg) => {\n                if (Array.isArray(msg)) {\n                    logger.log(...msg);\n                }\n                else {\n                    logger.log(msg);\n                }\n            });\n            logger.groupEnd();\n        }\n        // Wrap in try and catch in case the handle method throws a synchronous\n        // error. It should still callback to the catch handler.\n        let responsePromise;\n        try {\n            responsePromise = handler.handle({ url, request, event, params });\n        }\n        catch (err) {\n            responsePromise = Promise.reject(err);\n        }\n        // Get route's catch handler, if it exists\n        const catchHandler = route && route.catchHandler;\n        if (responsePromise instanceof Promise &&\n            (this._catchHandler || catchHandler)) {\n            responsePromise = responsePromise.catch(async (err) => {\n                // If there's a route catch handler, process that first\n                if (catchHandler) {\n                    if (process.env.NODE_ENV !== 'production') {\n                        // Still include URL here as it will be async from the console group\n                        // and may not make sense without the URL\n                        logger.groupCollapsed(`Error thrown when responding to: ` +\n                            ` ${getFriendlyURL(url)}. Falling back to route's Catch Handler.`);\n                        logger.error(`Error thrown by:`, route);\n                        logger.error(err);\n                        logger.groupEnd();\n                    }\n                    try {\n                        return await catchHandler.handle({ url, request, event, params });\n                    }\n                    catch (catchErr) {\n                        if (catchErr instanceof Error) {\n                            err = catchErr;\n                        }\n                    }\n                }\n                if (this._catchHandler) {\n                    if (process.env.NODE_ENV !== 'production') {\n                        // Still include URL here as it will be async from the console group\n                        // and may not make sense without the URL\n                        logger.groupCollapsed(`Error thrown when responding to: ` +\n                            ` ${getFriendlyURL(url)}. Falling back to global Catch Handler.`);\n                        logger.error(`Error thrown by:`, route);\n                        logger.error(err);\n                        logger.groupEnd();\n                    }\n                    return this._catchHandler.handle({ url, request, event });\n                }\n                throw err;\n            });\n        }\n        return responsePromise;\n    }\n    /**\n     * Checks a request and URL (and optionally an event) against the list of\n     * registered routes, and if there's a match, returns the corresponding\n     * route along with any params generated by the match.\n     *\n     * @param {Object} options\n     * @param {URL} options.url\n     * @param {boolean} options.sameOrigin The result of comparing `url.origin`\n     *     against the current origin.\n     * @param {Request} options.request The request to match.\n     * @param {Event} options.event The corresponding event.\n     * @return {Object} An object with `route` and `params` properties.\n     *     They are populated if a matching route was found or `undefined`\n     *     otherwise.\n     */\n    findMatchingRoute({ url, sameOrigin, request, event, }) {\n        const routes = this._routes.get(request.method) || [];\n        for (const route of routes) {\n            let params;\n            // route.match returns type any, not possible to change right now.\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n            const matchResult = route.match({ url, sameOrigin, request, event });\n            if (matchResult) {\n                if (process.env.NODE_ENV !== 'production') {\n                    // Warn developers that using an async matchCallback is almost always\n                    // not the right thing to do.\n                    if (matchResult instanceof Promise) {\n                        logger.warn(`While routing ${getFriendlyURL(url)}, an async ` +\n                            `matchCallback function was used. Please convert the ` +\n                            `following route to use a synchronous matchCallback function:`, route);\n                    }\n                }\n                // See https://github.com/GoogleChrome/workbox/issues/2079\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n                params = matchResult;\n                if (Array.isArray(params) && params.length === 0) {\n                    // Instead of passing an empty array in as params, use undefined.\n                    params = undefined;\n                }\n                else if (matchResult.constructor === Object && // eslint-disable-line\n                    Object.keys(matchResult).length === 0) {\n                    // Instead of passing an empty object in as params, use undefined.\n                    params = undefined;\n                }\n                else if (typeof matchResult === 'boolean') {\n                    // For the boolean value true (rather than just something truth-y),\n                    // don't set params.\n                    // See https://github.com/GoogleChrome/workbox/pull/2134#issuecomment-513924353\n                    params = undefined;\n                }\n                // Return early if have a match.\n                return { route, params };\n            }\n        }\n        // If no match was found above, return and empty object.\n        return {};\n    }\n    /**\n     * Define a default `handler` that's called when no routes explicitly\n     * match the incoming request.\n     *\n     * Each HTTP method ('GET', 'POST', etc.) gets its own default handler.\n     *\n     * Without a default handler, unmatched requests will go against the\n     * network as if there were no service worker present.\n     *\n     * @param {workbox-routing~handlerCallback} handler A callback\n     * function that returns a Promise resulting in a Response.\n     * @param {string} [method='GET'] The HTTP method to associate with this\n     * default handler. Each method has its own default.\n     */\n    setDefaultHandler(handler, method = defaultMethod) {\n        this._defaultHandlerMap.set(method, normalizeHandler(handler));\n    }\n    /**\n     * If a Route throws an error while handling a request, this `handler`\n     * will be called and given a chance to provide a response.\n     *\n     * @param {workbox-routing~handlerCallback} handler A callback\n     * function that returns a Promise resulting in a Response.\n     */\n    setCatchHandler(handler) {\n        this._catchHandler = normalizeHandler(handler);\n    }\n    /**\n     * Registers a route with the router.\n     *\n     * @param {workbox-routing.Route} route The route to register.\n     */\n    registerRoute(route) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isType(route, 'object', {\n                moduleName: 'workbox-routing',\n                className: 'Router',\n                funcName: 'registerRoute',\n                paramName: 'route',\n            });\n            assert.hasMethod(route, 'match', {\n                moduleName: 'workbox-routing',\n                className: 'Router',\n                funcName: 'registerRoute',\n                paramName: 'route',\n            });\n            assert.isType(route.handler, 'object', {\n                moduleName: 'workbox-routing',\n                className: 'Router',\n                funcName: 'registerRoute',\n                paramName: 'route',\n            });\n            assert.hasMethod(route.handler, 'handle', {\n                moduleName: 'workbox-routing',\n                className: 'Router',\n                funcName: 'registerRoute',\n                paramName: 'route.handler',\n            });\n            assert.isType(route.method, 'string', {\n                moduleName: 'workbox-routing',\n                className: 'Router',\n                funcName: 'registerRoute',\n                paramName: 'route.method',\n            });\n        }\n        if (!this._routes.has(route.method)) {\n            this._routes.set(route.method, []);\n        }\n        // Give precedence to all of the earlier routes by adding this additional\n        // route to the end of the array.\n        this._routes.get(route.method).push(route);\n    }\n    /**\n     * Unregisters a route with the router.\n     *\n     * @param {workbox-routing.Route} route The route to unregister.\n     */\n    unregisterRoute(route) {\n        if (!this._routes.has(route.method)) {\n            throw new WorkboxError('unregister-route-but-not-found-with-method', {\n                method: route.method,\n            });\n        }\n        const routeIndex = this._routes.get(route.method).indexOf(route);\n        if (routeIndex > -1) {\n            this._routes.get(route.method).splice(routeIndex, 1);\n        }\n        else {\n            throw new WorkboxError('unregister-route-route-not-registered');\n        }\n    }\n}\nexport { Router };\n", "/*\n  Copyright 2019 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 { Router } from '../Router.js';\nimport '../_version.js';\nlet defaultRouter;\n/**\n * Creates a new, singleton Router instance if one does not exist. If one\n * does already exist, that instance is returned.\n *\n * @private\n * @return {Router}\n */\nexport const getOrCreateDefaultRouter = () => {\n    if (!defaultRouter) {\n        defaultRouter = new Router();\n        // The helpers that use the default Router assume these listeners exist.\n        defaultRouter.addFetchListener();\n        defaultRouter.addCacheListener();\n    }\n    return defaultRouter;\n};\n", "/*\n  Copyright 2019 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 { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { Route } from './Route.js';\nimport { RegExpRoute } from './RegExpRoute.js';\nimport { getOrCreateDefaultRouter } from './utils/getOrCreateDefaultRouter.js';\nimport './_version.js';\n/**\n * Easily register a RegExp, string, or function with a caching\n * strategy to a singleton Router instance.\n *\n * This method will generate a Route for you if needed and\n * call {@link workbox-routing.Router#registerRoute}.\n *\n * @param {RegExp|string|workbox-routing.Route~matchCallback|workbox-routing.Route} capture\n * If the capture param is a `Route`, all other arguments will be ignored.\n * @param {workbox-routing~handlerCallback} [handler] A callback\n * function that returns a Promise resulting in a Response. This parameter\n * is required if `capture` is not a `Route` object.\n * @param {string} [method='GET'] The HTTP method to match the Route\n * against.\n * @return {workbox-routing.Route} The generated `Route`.\n *\n * @memberof workbox-routing\n */\nfunction registerRoute(capture, handler, method) {\n    let route;\n    if (typeof capture === 'string') {\n        const captureUrl = new URL(capture, location.href);\n        if (process.env.NODE_ENV !== 'production') {\n            if (!(capture.startsWith('/') || capture.startsWith('http'))) {\n                throw new WorkboxError('invalid-string', {\n                    moduleName: 'workbox-routing',\n                    funcName: 'registerRoute',\n                    paramName: 'capture',\n                });\n            }\n            // We want to check if Express-style wildcards are in the pathname only.\n            // TODO: Remove this log message in v4.\n            const valueToCheck = capture.startsWith('http')\n                ? captureUrl.pathname\n                : capture;\n            // See https://github.com/pillarjs/path-to-regexp#parameters\n            const wildcards = '[*:?+]';\n            if (new RegExp(`${wildcards}`).exec(valueToCheck)) {\n                logger.debug(`The '$capture' parameter contains an Express-style wildcard ` +\n                    `character (${wildcards}). Strings are now always interpreted as ` +\n                    `exact matches; use a RegExp for partial or wildcard matches.`);\n            }\n        }\n        const matchCallback = ({ url }) => {\n            if (process.env.NODE_ENV !== 'production') {\n                if (url.pathname === captureUrl.pathname &&\n                    url.origin !== captureUrl.origin) {\n                    logger.debug(`${capture} only partially matches the cross-origin URL ` +\n                        `${url.toString()}. This route will only handle cross-origin requests ` +\n                        `if they match the entire URL.`);\n                }\n            }\n            return url.href === captureUrl.href;\n        };\n        // If `capture` is a string then `handler` and `method` must be present.\n        route = new Route(matchCallback, handler, method);\n    }\n    else if (capture instanceof RegExp) {\n        // If `capture` is a `RegExp` then `handler` and `method` must be present.\n        route = new RegExpRoute(capture, handler, method);\n    }\n    else if (typeof capture === 'function') {\n        // If `capture` is a function then `handler` and `method` must be present.\n        route = new Route(capture, handler, method);\n    }\n    else if (capture instanceof Route) {\n        route = capture;\n    }\n    else {\n        throw new WorkboxError('unsupported-route-type', {\n            moduleName: 'workbox-routing',\n            funcName: 'registerRoute',\n            paramName: 'capture',\n        });\n    }\n    const defaultRouter = getOrCreateDefaultRouter();\n    defaultRouter.registerRoute(route);\n    return route;\n}\nexport { registerRoute };\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';\nconst _cacheNameDetails = {\n    googleAnalytics: 'googleAnalytics',\n    precache: 'precache-v2',\n    prefix: 'workbox',\n    runtime: 'runtime',\n    suffix: typeof registration !== 'undefined' ? registration.scope : '',\n};\nconst _createCacheName = (cacheName) => {\n    return [_cacheNameDetails.prefix, cacheName, _cacheNameDetails.suffix]\n        .filter((value) => value && value.length > 0)\n        .join('-');\n};\nconst eachCacheNameDetail = (fn) => {\n    for (const key of Object.keys(_cacheNameDetails)) {\n        fn(key);\n    }\n};\nexport const cacheNames = {\n    updateDetails: (details) => {\n        eachCacheNameDetail((key) => {\n            if (typeof details[key] === 'string') {\n                _cacheNameDetails[key] = details[key];\n            }\n        });\n    },\n    getGoogleAnalyticsName: (userCacheName) => {\n        return userCacheName || _createCacheName(_cacheNameDetails.googleAnalytics);\n    },\n    getPrecacheName: (userCacheName) => {\n        return userCacheName || _createCacheName(_cacheNameDetails.precache);\n    },\n    getPrefix: () => {\n        return _cacheNameDetails.prefix;\n    },\n    getRuntimeName: (userCacheName) => {\n        return userCacheName || _createCacheName(_cacheNameDetails.runtime);\n    },\n    getSuffix: () => {\n        return _cacheNameDetails.suffix;\n    },\n};\n", "/*\n  Copyright 2020 Google LLC\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';\nfunction stripParams(fullURL, ignoreParams) {\n    const strippedURL = new URL(fullURL);\n    for (const param of ignoreParams) {\n        strippedURL.searchParams.delete(param);\n    }\n    return strippedURL.href;\n}\n/**\n * Matches an item in the cache, ignoring specific URL params. This is similar\n * to the `ignoreSearch` option, but it allows you to ignore just specific\n * params (while continuing to match on the others).\n *\n * @private\n * @param {Cache} cache\n * @param {Request} request\n * @param {Object} matchOptions\n * @param {Array<string>} ignoreParams\n * @return {Promise<Response|undefined>}\n */\nasync function cacheMatchIgnoreParams(cache, request, ignoreParams, matchOptions) {\n    const strippedRequestURL = stripParams(request.url, ignoreParams);\n    // If the request doesn't include any ignored params, match as normal.\n    if (request.url === strippedRequestURL) {\n        return cache.match(request, matchOptions);\n    }\n    // Otherwise, match by comparing keys\n    const keysOptions = Object.assign(Object.assign({}, matchOptions), { ignoreSearch: true });\n    const cacheKeys = await cache.keys(request, keysOptions);\n    for (const cacheKey of cacheKeys) {\n        const strippedCacheKeyURL = stripParams(cacheKey.url, ignoreParams);\n        if (strippedRequestURL === strippedCacheKeyURL) {\n            return cache.match(cacheKey, matchOptions);\n        }\n    }\n    return;\n}\nexport { cacheMatchIgnoreParams };\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 * The Deferred class composes Promises in a way that allows for them to be\n * resolved or rejected from outside the constructor. In most cases promises\n * should be used directly, but Deferreds can be necessary when the logic to\n * resolve a promise must be separate.\n *\n * @private\n */\nclass Deferred {\n    /**\n     * Creates a promise and exposes its resolve and reject functions as methods.\n     */\n    constructor() {\n        this.promise = new Promise((resolve, reject) => {\n            this.resolve = resolve;\n            this.reject = reject;\n        });\n    }\n}\nexport { Deferred };\n", "/*\n  Copyright 2018 Google 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// Callbacks to be executed whenever there's a quota error.\n// Can't change Function type right now.\n// eslint-disable-next-line @typescript-eslint/ban-types\nconst quotaErrorCallbacks = new Set();\nexport { quotaErrorCallbacks };\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 '../_private/logger.js';\nimport { quotaErrorCallbacks } from '../models/quotaErrorCallbacks.js';\nimport '../_version.js';\n/**\n * Runs all of the callback functions, one at a time sequentially, in the order\n * in which they were registered.\n *\n * @memberof workbox-core\n * @private\n */\nasync function executeQuotaErrorCallbacks() {\n    if (process.env.NODE_ENV !== 'production') {\n        logger.log(`About to run ${quotaErrorCallbacks.size} ` +\n            `callbacks to clean up caches.`);\n    }\n    for (const callback of quotaErrorCallbacks) {\n        await callback();\n        if (process.env.NODE_ENV !== 'production') {\n            logger.log(callback, 'is complete.');\n        }\n    }\n    if (process.env.NODE_ENV !== 'production') {\n        logger.log('Finished running callbacks.');\n    }\n}\nexport { executeQuotaErrorCallbacks };\n", "/*\n  Copyright 2019 Google LLC\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 * Returns a promise that resolves and the passed number of milliseconds.\n * This utility is an async/await-friendly version of `setTimeout`.\n *\n * @param {number} ms\n * @return {Promise}\n * @private\n */\nexport function timeout(ms) {\n    return new Promise((resolve) => setTimeout(resolve, ms));\n}\n", "\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:strategies:7.0.0'] && _();\n}\ncatch (e) { }\n", "/*\n  Copyright 2020 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 { cacheMatchIgnoreParams } from 'workbox-core/_private/cacheMatchIgnoreParams.js';\nimport { Deferred } from 'workbox-core/_private/Deferred.js';\nimport { executeQuotaErrorCallbacks } from 'workbox-core/_private/executeQuotaErrorCallbacks.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { timeout } from 'workbox-core/_private/timeout.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport './_version.js';\nfunction toRequest(input) {\n    return typeof input === 'string' ? new Request(input) : input;\n}\n/**\n * A class created every time a Strategy instance instance calls\n * {@link workbox-strategies.Strategy~handle} or\n * {@link workbox-strategies.Strategy~handleAll} that wraps all fetch and\n * cache actions around plugin callbacks and keeps track of when the strategy\n * is \"done\" (i.e. all added `event.waitUntil()` promises have resolved).\n *\n * @memberof workbox-strategies\n */\nclass StrategyHandler {\n    /**\n     * Creates a new instance associated with the passed strategy and event\n     * that's handling the request.\n     *\n     * The constructor also initializes the state that will be passed to each of\n     * the plugins handling this request.\n     *\n     * @param {workbox-strategies.Strategy} strategy\n     * @param {Object} options\n     * @param {Request|string} options.request A request to run this strategy for.\n     * @param {ExtendableEvent} options.event The event associated with the\n     *     request.\n     * @param {URL} [options.url]\n     * @param {*} [options.params] The return value from the\n     *     {@link workbox-routing~matchCallback} (if applicable).\n     */\n    constructor(strategy, options) {\n        this._cacheKeys = {};\n        /**\n         * The request the strategy is performing (passed to the strategy's\n         * `handle()` or `handleAll()` method).\n         * @name request\n         * @instance\n         * @type {Request}\n         * @memberof workbox-strategies.StrategyHandler\n         */\n        /**\n         * The event associated with this request.\n         * @name event\n         * @instance\n         * @type {ExtendableEvent}\n         * @memberof workbox-strategies.StrategyHandler\n         */\n        /**\n         * A `URL` instance of `request.url` (if passed to the strategy's\n         * `handle()` or `handleAll()` method).\n         * Note: the `url` param will be present if the strategy was invoked\n         * from a workbox `Route` object.\n         * @name url\n         * @instance\n         * @type {URL|undefined}\n         * @memberof workbox-strategies.StrategyHandler\n         */\n        /**\n         * A `param` value (if passed to the strategy's\n         * `handle()` or `handleAll()` method).\n         * Note: the `param` param will be present if the strategy was invoked\n         * from a workbox `Route` object and the\n         * {@link workbox-routing~matchCallback} returned\n         * a truthy value (it will be that value).\n         * @name params\n         * @instance\n         * @type {*|undefined}\n         * @memberof workbox-strategies.StrategyHandler\n         */\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isInstance(options.event, ExtendableEvent, {\n                moduleName: 'workbox-strategies',\n                className: 'StrategyHandler',\n                funcName: 'constructor',\n                paramName: 'options.event',\n            });\n        }\n        Object.assign(this, options);\n        this.event = options.event;\n        this._strategy = strategy;\n        this._handlerDeferred = new Deferred();\n        this._extendLifetimePromises = [];\n        // Copy the plugins list (since it's mutable on the strategy),\n        // so any mutations don't affect this handler instance.\n        this._plugins = [...strategy.plugins];\n        this._pluginStateMap = new Map();\n        for (const plugin of this._plugins) {\n            this._pluginStateMap.set(plugin, {});\n        }\n        this.event.waitUntil(this._handlerDeferred.promise);\n    }\n    /**\n     * Fetches a given request (and invokes any applicable plugin callback\n     * methods) using the `fetchOptions` (for non-navigation requests) and\n     * `plugins` defined on the `Strategy` object.\n     *\n     * The following plugin lifecycle methods are invoked when using this method:\n     * - `requestWillFetch()`\n     * - `fetchDidSucceed()`\n     * - `fetchDidFail()`\n     *\n     * @param {Request|string} input The URL or request to fetch.\n     * @return {Promise<Response>}\n     */\n    async fetch(input) {\n        const { event } = this;\n        let request = toRequest(input);\n        if (request.mode === 'navigate' &&\n            event instanceof FetchEvent &&\n            event.preloadResponse) {\n            const possiblePreloadResponse = (await event.preloadResponse);\n            if (possiblePreloadResponse) {\n                if (process.env.NODE_ENV !== 'production') {\n                    logger.log(`Using a preloaded navigation response for ` +\n                        `'${getFriendlyURL(request.url)}'`);\n                }\n                return possiblePreloadResponse;\n            }\n        }\n        // If there is a fetchDidFail plugin, we need to save a clone of the\n        // original request before it's either modified by a requestWillFetch\n        // plugin or before the original request's body is consumed via fetch().\n        const originalRequest = this.hasCallback('fetchDidFail')\n            ? request.clone()\n            : null;\n        try {\n            for (const cb of this.iterateCallbacks('requestWillFetch')) {\n                request = await cb({ request: request.clone(), event });\n            }\n        }\n        catch (err) {\n            if (err instanceof Error) {\n                throw new WorkboxError('plugin-error-request-will-fetch', {\n                    thrownErrorMessage: err.message,\n                });\n            }\n        }\n        // The request can be altered by plugins with `requestWillFetch` making\n        // the original request (most likely from a `fetch` event) different\n        // from the Request we make. Pass both to `fetchDidFail` to aid debugging.\n        const pluginFilteredRequest = request.clone();\n        try {\n            let fetchResponse;\n            // See https://github.com/GoogleChrome/workbox/issues/1796\n            fetchResponse = await fetch(request, request.mode === 'navigate' ? undefined : this._strategy.fetchOptions);\n            if (process.env.NODE_ENV !== 'production') {\n                logger.debug(`Network request for ` +\n                    `'${getFriendlyURL(request.url)}' returned a response with ` +\n                    `status '${fetchResponse.status}'.`);\n            }\n            for (const callback of this.iterateCallbacks('fetchDidSucceed')) {\n                fetchResponse = await callback({\n                    event,\n                    request: pluginFilteredRequest,\n                    response: fetchResponse,\n                });\n            }\n            return fetchResponse;\n        }\n        catch (error) {\n            if (process.env.NODE_ENV !== 'production') {\n                logger.log(`Network request for ` +\n                    `'${getFriendlyURL(request.url)}' threw an error.`, error);\n            }\n            // `originalRequest` will only exist if a `fetchDidFail` callback\n            // is being used (see above).\n            if (originalRequest) {\n                await this.runCallbacks('fetchDidFail', {\n                    error: error,\n                    event,\n                    originalRequest: originalRequest.clone(),\n                    request: pluginFilteredRequest.clone(),\n                });\n            }\n            throw error;\n        }\n    }\n    /**\n     * Calls `this.fetch()` and (in the background) runs `this.cachePut()` on\n     * the response generated by `this.fetch()`.\n     *\n     * The call to `this.cachePut()` automatically invokes `this.waitUntil()`,\n     * so you do not have to manually call `waitUntil()` on the event.\n     *\n     * @param {Request|string} input The request or URL to fetch and cache.\n     * @return {Promise<Response>}\n     */\n    async fetchAndCachePut(input) {\n        const response = await this.fetch(input);\n        const responseClone = response.clone();\n        void this.waitUntil(this.cachePut(input, responseClone));\n        return response;\n    }\n    /**\n     * Matches a request from the cache (and invokes any applicable plugin\n     * callback methods) using the `cacheName`, `matchOptions`, and `plugins`\n     * defined on the strategy object.\n     *\n     * The following plugin lifecycle methods are invoked when using this method:\n     * - cacheKeyWillByUsed()\n     * - cachedResponseWillByUsed()\n     *\n     * @param {Request|string} key The Request or URL to use as the cache key.\n     * @return {Promise<Response|undefined>} A matching response, if found.\n     */\n    async cacheMatch(key) {\n        const request = toRequest(key);\n        let cachedResponse;\n        const { cacheName, matchOptions } = this._strategy;\n        const effectiveRequest = await this.getCacheKey(request, 'read');\n        const multiMatchOptions = Object.assign(Object.assign({}, matchOptions), { cacheName });\n        cachedResponse = await caches.match(effectiveRequest, multiMatchOptions);\n        if (process.env.NODE_ENV !== 'production') {\n            if (cachedResponse) {\n                logger.debug(`Found a cached response in '${cacheName}'.`);\n            }\n            else {\n                logger.debug(`No cached response found in '${cacheName}'.`);\n            }\n        }\n        for (const callback of this.iterateCallbacks('cachedResponseWillBeUsed')) {\n            cachedResponse =\n                (await callback({\n                    cacheName,\n                    matchOptions,\n                    cachedResponse,\n                    request: effectiveRequest,\n                    event: this.event,\n                })) || undefined;\n        }\n        return cachedResponse;\n    }\n    /**\n     * Puts a request/response pair in the cache (and invokes any applicable\n     * plugin callback methods) using the `cacheName` and `plugins` defined on\n     * the strategy object.\n     *\n     * The following plugin lifecycle methods are invoked when using this method:\n     * - cacheKeyWillByUsed()\n     * - cacheWillUpdate()\n     * - cacheDidUpdate()\n     *\n     * @param {Request|string} key The request or URL to use as the cache key.\n     * @param {Response} response The response to cache.\n     * @return {Promise<boolean>} `false` if a cacheWillUpdate caused the response\n     * not be cached, and `true` otherwise.\n     */\n    async cachePut(key, response) {\n        const request = toRequest(key);\n        // Run in the next task to avoid blocking other cache reads.\n        // https://github.com/w3c/ServiceWorker/issues/1397\n        await timeout(0);\n        const effectiveRequest = await this.getCacheKey(request, 'write');\n        if (process.env.NODE_ENV !== 'production') {\n            if (effectiveRequest.method && effectiveRequest.method !== 'GET') {\n                throw new WorkboxError('attempt-to-cache-non-get-request', {\n                    url: getFriendlyURL(effectiveRequest.url),\n                    method: effectiveRequest.method,\n                });\n            }\n            // See https://github.com/GoogleChrome/workbox/issues/2818\n            const vary = response.headers.get('Vary');\n            if (vary) {\n                logger.debug(`The response for ${getFriendlyURL(effectiveRequest.url)} ` +\n                    `has a 'Vary: ${vary}' header. ` +\n                    `Consider setting the {ignoreVary: true} option on your strategy ` +\n                    `to ensure cache matching and deletion works as expected.`);\n            }\n        }\n        if (!response) {\n            if (process.env.NODE_ENV !== 'production') {\n                logger.error(`Cannot cache non-existent response for ` +\n                    `'${getFriendlyURL(effectiveRequest.url)}'.`);\n            }\n            throw new WorkboxError('cache-put-with-no-response', {\n                url: getFriendlyURL(effectiveRequest.url),\n            });\n        }\n        const responseToCache = await this._ensureResponseSafeToCache(response);\n        if (!responseToCache) {\n            if (process.env.NODE_ENV !== 'production') {\n                logger.debug(`Response '${getFriendlyURL(effectiveRequest.url)}' ` +\n                    `will not be cached.`, responseToCache);\n            }\n            return false;\n        }\n        const { cacheName, matchOptions } = this._strategy;\n        const cache = await self.caches.open(cacheName);\n        const hasCacheUpdateCallback = this.hasCallback('cacheDidUpdate');\n        const oldResponse = hasCacheUpdateCallback\n            ? await cacheMatchIgnoreParams(\n            // TODO(philipwalton): the `__WB_REVISION__` param is a precaching\n            // feature. Consider into ways to only add this behavior if using\n            // precaching.\n            cache, effectiveRequest.clone(), ['__WB_REVISION__'], matchOptions)\n            : null;\n        if (process.env.NODE_ENV !== 'production') {\n            logger.debug(`Updating the '${cacheName}' cache with a new Response ` +\n                `for ${getFriendlyURL(effectiveRequest.url)}.`);\n        }\n        try {\n            await cache.put(effectiveRequest, hasCacheUpdateCallback ? responseToCache.clone() : responseToCache);\n        }\n        catch (error) {\n            if (error instanceof Error) {\n                // See https://developer.mozilla.org/en-US/docs/Web/API/DOMException#exception-QuotaExceededError\n                if (error.name === 'QuotaExceededError') {\n                    await executeQuotaErrorCallbacks();\n                }\n                throw error;\n            }\n        }\n        for (const callback of this.iterateCallbacks('cacheDidUpdate')) {\n            await callback({\n                cacheName,\n                oldResponse,\n                newResponse: responseToCache.clone(),\n                request: effectiveRequest,\n                event: this.event,\n            });\n        }\n        return true;\n    }\n    /**\n     * Checks the list of plugins for the `cacheKeyWillBeUsed` callback, and\n     * executes any of those callbacks found in sequence. The final `Request`\n     * object returned by the last plugin is treated as the cache key for cache\n     * reads and/or writes. If no `cacheKeyWillBeUsed` plugin callbacks have\n     * been registered, the passed request is returned unmodified\n     *\n     * @param {Request} request\n     * @param {string} mode\n     * @return {Promise<Request>}\n     */\n    async getCacheKey(request, mode) {\n        const key = `${request.url} | ${mode}`;\n        if (!this._cacheKeys[key]) {\n            let effectiveRequest = request;\n            for (const callback of this.iterateCallbacks('cacheKeyWillBeUsed')) {\n                effectiveRequest = toRequest(await callback({\n                    mode,\n                    request: effectiveRequest,\n                    event: this.event,\n                    // params has a type any can't change right now.\n                    params: this.params, // eslint-disable-line\n                }));\n            }\n            this._cacheKeys[key] = effectiveRequest;\n        }\n        return this._cacheKeys[key];\n    }\n    /**\n     * Returns true if the strategy has at least one plugin with the given\n     * callback.\n     *\n     * @param {string} name The name of the callback to check for.\n     * @return {boolean}\n     */\n    hasCallback(name) {\n        for (const plugin of this._strategy.plugins) {\n            if (name in plugin) {\n                return true;\n            }\n        }\n        return false;\n    }\n    /**\n     * Runs all plugin callbacks matching the given name, in order, passing the\n     * given param object (merged ith the current plugin state) as the only\n     * argument.\n     *\n     * Note: since this method runs all plugins, it's not suitable for cases\n     * where the return value of a callback needs to be applied prior to calling\n     * the next callback. See\n     * {@link workbox-strategies.StrategyHandler#iterateCallbacks}\n     * below for how to handle that case.\n     *\n     * @param {string} name The name of the callback to run within each plugin.\n     * @param {Object} param The object to pass as the first (and only) param\n     *     when executing each callback. This object will be merged with the\n     *     current plugin state prior to callback execution.\n     */\n    async runCallbacks(name, param) {\n        for (const callback of this.iterateCallbacks(name)) {\n            // TODO(philipwalton): not sure why `any` is needed. It seems like\n            // this should work with `as WorkboxPluginCallbackParam[C]`.\n            await callback(param);\n        }\n    }\n    /**\n     * Accepts a callback and returns an iterable of matching plugin callbacks,\n     * where each callback is wrapped with the current handler state (i.e. when\n     * you call each callback, whatever object parameter you pass it will\n     * be merged with the plugin's current state).\n     *\n     * @param {string} name The name fo the callback to run\n     * @return {Array<Function>}\n     */\n    *iterateCallbacks(name) {\n        for (const plugin of this._strategy.plugins) {\n            if (typeof plugin[name] === 'function') {\n                const state = this._pluginStateMap.get(plugin);\n                const statefulCallback = (param) => {\n                    const statefulParam = Object.assign(Object.assign({}, param), { state });\n                    // TODO(philipwalton): not sure why `any` is needed. It seems like\n                    // this should work with `as WorkboxPluginCallbackParam[C]`.\n                    return plugin[name](statefulParam);\n                };\n                yield statefulCallback;\n            }\n        }\n    }\n    /**\n     * Adds a promise to the\n     * [extend lifetime promises]{@link https://w3c.github.io/ServiceWorker/#extendableevent-extend-lifetime-promises}\n     * of the event event associated with the request being handled (usually a\n     * `FetchEvent`).\n     *\n     * Note: you can await\n     * {@link workbox-strategies.StrategyHandler~doneWaiting}\n     * to know when all added promises have settled.\n     *\n     * @param {Promise} promise A promise to add to the extend lifetime promises\n     *     of the event that triggered the request.\n     */\n    waitUntil(promise) {\n        this._extendLifetimePromises.push(promise);\n        return promise;\n    }\n    /**\n     * Returns a promise that resolves once all promises passed to\n     * {@link workbox-strategies.StrategyHandler~waitUntil}\n     * have settled.\n     *\n     * Note: any work done after `doneWaiting()` settles should be manually\n     * passed to an event's `waitUntil()` method (not this handler's\n     * `waitUntil()` method), otherwise the service worker thread my be killed\n     * prior to your work completing.\n     */\n    async doneWaiting() {\n        let promise;\n        while ((promise = this._extendLifetimePromises.shift())) {\n            await promise;\n        }\n    }\n    /**\n     * Stops running the strategy and immediately resolves any pending\n     * `waitUntil()` promises.\n     */\n    destroy() {\n        this._handlerDeferred.resolve(null);\n    }\n    /**\n     * This method will call cacheWillUpdate on the available plugins (or use\n     * status === 200) to determine if the Response is safe and valid to cache.\n     *\n     * @param {Request} options.request\n     * @param {Response} options.response\n     * @return {Promise<Response|undefined>}\n     *\n     * @private\n     */\n    async _ensureResponseSafeToCache(response) {\n        let responseToCache = response;\n        let pluginsUsed = false;\n        for (const callback of this.iterateCallbacks('cacheWillUpdate')) {\n            responseToCache =\n                (await callback({\n                    request: this.request,\n                    response: responseToCache,\n                    event: this.event,\n                })) || undefined;\n            pluginsUsed = true;\n            if (!responseToCache) {\n                break;\n            }\n        }\n        if (!pluginsUsed) {\n            if (responseToCache && responseToCache.status !== 200) {\n                responseToCache = undefined;\n            }\n            if (process.env.NODE_ENV !== 'production') {\n                if (responseToCache) {\n                    if (responseToCache.status !== 200) {\n                        if (responseToCache.status === 0) {\n                            logger.warn(`The response for '${this.request.url}' ` +\n                                `is an opaque response. The caching strategy that you're ` +\n                                `using will not cache opaque responses by default.`);\n                        }\n                        else {\n                            logger.debug(`The response for '${this.request.url}' ` +\n                                `returned a status code of '${response.status}' and won't ` +\n                                `be cached as a result.`);\n                        }\n                    }\n                }\n            }\n        }\n        return responseToCache;\n    }\n}\nexport { StrategyHandler };\n", "/*\n  Copyright 2020 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 { cacheNames } from 'workbox-core/_private/cacheNames.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { StrategyHandler } from './StrategyHandler.js';\nimport './_version.js';\n/**\n * An abstract base class that all other strategy classes must extend from:\n *\n * @memberof workbox-strategies\n */\nclass Strategy {\n    /**\n     * Creates a new instance of the strategy and sets all documented option\n     * properties as public instance properties.\n     *\n     * Note: if a custom strategy class extends the base Strategy class and does\n     * not need more than these properties, it does not need to define its own\n     * constructor.\n     *\n     * @param {Object} [options]\n     * @param {string} [options.cacheName] Cache name to store and retrieve\n     * requests. Defaults to the cache names provided by\n     * {@link 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 [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796)\n     * `fetch()` requests made by this strategy.\n     * @param {Object} [options.matchOptions] The\n     * [`CacheQueryOptions`]{@link https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions}\n     * for any `cache.match()` or `cache.put()` calls made by this strategy.\n     */\n    constructor(options = {}) {\n        /**\n         * Cache name to store and retrieve\n         * requests. Defaults to the cache names provided by\n         * {@link workbox-core.cacheNames}.\n         *\n         * @type {string}\n         */\n        this.cacheName = cacheNames.getRuntimeName(options.cacheName);\n        /**\n         * The list\n         * [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}\n         * used by this strategy.\n         *\n         * @type {Array<Object>}\n         */\n        this.plugins = options.plugins || [];\n        /**\n         * Values passed along to the\n         * [`init`]{@link https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters}\n         * of all fetch() requests made by this strategy.\n         *\n         * @type {Object}\n         */\n        this.fetchOptions = options.fetchOptions;\n        /**\n         * The\n         * [`CacheQueryOptions`]{@link https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions}\n         * for any `cache.match()` or `cache.put()` calls made by this strategy.\n         *\n         * @type {Object}\n         */\n        this.matchOptions = options.matchOptions;\n    }\n    /**\n     * Perform a request strategy and returns a `Promise` that will resolve with\n     * a `Response`, invoking all relevant plugin callbacks.\n     *\n     * When a strategy instance is registered with a Workbox\n     * {@link workbox-routing.Route}, this method is automatically\n     * called when the route matches.\n     *\n     * Alternatively, this method can be used in a standalone `FetchEvent`\n     * listener by passing it to `event.respondWith()`.\n     *\n     * @param {FetchEvent|Object} options A `FetchEvent` or an object with the\n     *     properties listed below.\n     * @param {Request|string} options.request A request to run this strategy for.\n     * @param {ExtendableEvent} options.event The event associated with the\n     *     request.\n     * @param {URL} [options.url]\n     * @param {*} [options.params]\n     */\n    handle(options) {\n        const [responseDone] = this.handleAll(options);\n        return responseDone;\n    }\n    /**\n     * Similar to {@link workbox-strategies.Strategy~handle}, but\n     * instead of just returning a `Promise` that resolves to a `Response` it\n     * it will return an tuple of `[response, done]` promises, where the former\n     * (`response`) is equivalent to what `handle()` returns, and the latter is a\n     * Promise that will resolve once any promises that were added to\n     * `event.waitUntil()` as part of performing the strategy have completed.\n     *\n     * You can await the `done` promise to ensure any extra work performed by\n     * the strategy (usually caching responses) completes successfully.\n     *\n     * @param {FetchEvent|Object} options A `FetchEvent` or an object with the\n     *     properties listed below.\n     * @param {Request|string} options.request A request to run this strategy for.\n     * @param {ExtendableEvent} options.event The event associated with the\n     *     request.\n     * @param {URL} [options.url]\n     * @param {*} [options.params]\n     * @return {Array<Promise>} A tuple of [response, done]\n     *     promises that can be used to determine when the response resolves as\n     *     well as when the handler has completed all its work.\n     */\n    handleAll(options) {\n        // Allow for flexible options to be passed.\n        if (options instanceof FetchEvent) {\n            options = {\n                event: options,\n                request: options.request,\n            };\n        }\n        const event = options.event;\n        const request = typeof options.request === 'string'\n            ? new Request(options.request)\n            : options.request;\n        const params = 'params' in options ? options.params : undefined;\n        const handler = new StrategyHandler(this, { event, request, params });\n        const responseDone = this._getResponse(handler, request, event);\n        const handlerDone = this._awaitComplete(responseDone, handler, request, event);\n        // Return an array of promises, suitable for use with Promise.all().\n        return [responseDone, handlerDone];\n    }\n    async _getResponse(handler, request, event) {\n        await handler.runCallbacks('handlerWillStart', { event, request });\n        let response = undefined;\n        try {\n            response = await this._handle(request, handler);\n            // The \"official\" Strategy subclasses all throw this error automatically,\n            // but in case a third-party Strategy doesn't, ensure that we have a\n            // consistent failure when there's no response or an error response.\n            if (!response || response.type === 'error') {\n                throw new WorkboxError('no-response', { url: request.url });\n            }\n        }\n        catch (error) {\n            if (error instanceof Error) {\n                for (const callback of handler.iterateCallbacks('handlerDidError')) {\n                    response = await callback({ error, event, request });\n                    if (response) {\n                        break;\n                    }\n                }\n            }\n            if (!response) {\n                throw error;\n            }\n            else if (process.env.NODE_ENV !== 'production') {\n                logger.log(`While responding to '${getFriendlyURL(request.url)}', ` +\n                    `an ${error instanceof Error ? error.toString() : ''} error occurred. Using a fallback response provided by ` +\n                    `a handlerDidError plugin.`);\n            }\n        }\n        for (const callback of handler.iterateCallbacks('handlerWillRespond')) {\n            response = await callback({ event, request, response });\n        }\n        return response;\n    }\n    async _awaitComplete(responseDone, handler, request, event) {\n        let response;\n        let error;\n        try {\n            response = await responseDone;\n        }\n        catch (error) {\n            // Ignore errors, as response errors should be caught via the `response`\n            // promise above. The `done` promise will only throw for errors in\n            // promises passed to `handler.waitUntil()`.\n        }\n        try {\n            await handler.runCallbacks('handlerDidRespond', {\n                event,\n                request,\n                response,\n            });\n            await handler.doneWaiting();\n        }\n        catch (waitUntilError) {\n            if (waitUntilError instanceof Error) {\n                error = waitUntilError;\n            }\n        }\n        await handler.runCallbacks('handlerDidComplete', {\n            event,\n            request,\n            response,\n            error: error,\n        });\n        handler.destroy();\n        if (error) {\n            throw error;\n        }\n    }\n}\nexport { Strategy };\n/**\n * Classes extending the `Strategy` based class should implement this method,\n * and leverage the {@link workbox-strategies.StrategyHandler}\n * arg to perform all fetching and cache logic, which will ensure all relevant\n * cache, cache options, fetch options and plugins are used (per the current\n * strategy instance).\n *\n * @name _handle\n * @instance\n * @abstract\n * @function\n * @param {Request} request\n * @param {workbox-strategies.StrategyHandler} handler\n * @return {Promise<Response>}\n *\n * @memberof workbox-strategies.Strategy\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 '../_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 { logger } from 'workbox-core/_private/logger.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { cacheOkAndOpaquePlugin } from './plugins/cacheOkAndOpaquePlugin.js';\nimport { Strategy } from './Strategy.js';\nimport { messages } from './utils/messages.js';\nimport './_version.js';\n/**\n * An implementation of a\n * [stale-while-revalidate](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#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](https://developer.chrome.com/docs/workbox/caching-resources-during-runtime/#opaque-responses).\n * Opaque responses are cross-origin requests where the response doesn't\n * support [CORS](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 * @extends workbox-strategies.Strategy\n * @memberof workbox-strategies\n */\nclass StaleWhileRevalidate extends Strategy {\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     * {@link 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 [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796)\n     * `fetch()` requests made by this strategy.\n     * @param {Object} [options.matchOptions] [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)\n     */\n    constructor(options = {}) {\n        super(options);\n        // If this instance contains no plugins with a 'cacheWillUpdate' callback,\n        // prepend the `cacheOkAndOpaquePlugin` plugin to the plugins list.\n        if (!this.plugins.some((p) => 'cacheWillUpdate' in p)) {\n            this.plugins.unshift(cacheOkAndOpaquePlugin);\n        }\n    }\n    /**\n     * @private\n     * @param {Request|string} request A request to run this strategy for.\n     * @param {workbox-strategies.StrategyHandler} handler The event that\n     *     triggered the request.\n     * @return {Promise<Response>}\n     */\n    async _handle(request, handler) {\n        const logs = [];\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isInstance(request, Request, {\n                moduleName: 'workbox-strategies',\n                className: this.constructor.name,\n                funcName: 'handle',\n                paramName: 'request',\n            });\n        }\n        const fetchAndCachePromise = handler.fetchAndCachePut(request).catch(() => {\n            // Swallow this error because a 'no-response' error will be thrown in\n            // main handler return flow. This will be in the `waitUntil()` flow.\n        });\n        void handler.waitUntil(fetchAndCachePromise);\n        let response = await handler.cacheMatch(request);\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        }\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                // NOTE(philipwalton): Really annoying that we have to type cast here.\n                // https://github.com/microsoft/TypeScript/issues/20006\n                response = (await fetchAndCachePromise);\n            }\n            catch (err) {\n                if (err instanceof Error) {\n                    error = err;\n                }\n            }\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            logger.groupCollapsed(messages.strategyStart(this.constructor.name, 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}\nexport { StaleWhileRevalidate };\n", "\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:navigation-preload:7.0.0'] && _();\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';\n/**\n * @return {boolean} Whether or not the current browser supports enabling\n * navigation preload.\n *\n * @memberof workbox-navigation-preload\n */\nfunction isSupported() {\n    return Boolean(self.registration && self.registration.navigationPreload);\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 { isSupported } from './isSupported.js';\nimport './_version.js';\n/**\n * If the browser supports Navigation Preload, then this will enable it.\n *\n * @param {string} [headerValue] Optionally, allows developers to\n * [override](https://developers.google.com/web/updates/2017/02/navigation-preload#changing_the_header)\n * the value of the `Service-Worker-Navigation-Preload` header which will be\n * sent to the server when making the navigation request.\n *\n * @memberof workbox-navigation-preload\n */\nfunction enable(headerValue) {\n    if (isSupported()) {\n        self.addEventListener('activate', (event) => {\n            event.waitUntil(self.registration.navigationPreload.enable().then(() => {\n                // Defaults to Service-Worker-Navigation-Preload: true if not set.\n                if (headerValue) {\n                    void self.registration.navigationPreload.setHeaderValue(headerValue);\n                }\n                if (process.env.NODE_ENV !== 'production') {\n                    logger.log(`Navigation preload is enabled.`);\n                }\n            }));\n        });\n    }\n    else {\n        if (process.env.NODE_ENV !== 'production') {\n            logger.log(`Navigation preload is not supported in this browser.`);\n        }\n    }\n}\nexport { enable };\n", "import { registerRoute } from \"workbox-routing\";\nimport { StaleWhileRevalidate } from \"workbox-strategies\";\nimport { enable, isSupported } from \"workbox-navigation-preload\";\n// This is the service worker with the combined offline experience (Offline page + Offline copy of pages)\n\nconst CACHE = \"modo\";\n\n// TODO: replace the following with the correct offline fallback page i.e.: const offlineFallbackPage = \"offline.html\";\nconst offlineFallbackPage = \"index.html\";\n\nself.addEventListener(\"message\", (event) => {\n  if (event.data && event.data.type === \"SKIP_WAITING\") {\n    self.skipWaiting();\n  }\n});\n\nself.addEventListener('install', async (event: any) => {\n  event.waitUntil(\n    caches.open(CACHE)\n      .then((cache) => cache.add(offlineFallbackPage))\n  );\n});\n\nif (isSupported()) {\n  enable();\n}\n\nregisterRoute(\n  new RegExp('/*'),\n  new StaleWhileRevalidate({\n    cacheName: CACHE\n  })\n);\n\nself.addEventListener('fetch', (event: any) => {\n  if (event.request.mode === 'navigate') {\n    event.respondWith((async () => {\n      try {\n        const preloadResp = await event.preloadResponse;\n\n        if (preloadResp) {\n          return preloadResp;\n        }\n\n        const networkResp = await fetch(event.request);\n        return networkResp;\n      } catch (error) {\n\n        const cache = await caches.open(CACHE);\n        const cachedResp = await cache.match(offlineFallbackPage);\n        return cachedResp;\n      }\n    })());\n  }\n});\n"],
  "mappings": "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",
  "names": ["fallback", "code", "args", "msg", "messageGenerator", "fallback", "WorkboxError", "errorCode", "details", "message", "messageGenerator", "defaultMethod", "normalizeHandler", "handler", "Route", "match", "handler", "method", "defaultMethod", "normalizeHandler", "RegExpRoute", "Route", "regExp", "handler", "method", "match", "url", "result", "getFriendlyURL", "url", "Router", "event", "request", "responsePromise", "payload", "requestPromises", "entry", "url", "sameOrigin", "params", "route", "handler", "debugMessages", "method", "err", "catchHandler", "catchErr", "routes", "matchResult", "defaultMethod", "normalizeHandler", "WorkboxError", "routeIndex", "defaultRouter", "getOrCreateDefaultRouter", "Router", "registerRoute", "capture", "handler", "method", "route", "captureUrl", "matchCallback", "url", "Route", "RegExpRoute", "WorkboxError", "getOrCreateDefaultRouter", "_cacheNameDetails", "_createCacheName", "cacheName", "value", "eachCacheNameDetail", "fn", "key", "cacheNames", "details", "userCacheName", "stripParams", "fullURL", "ignoreParams", "strippedURL", "param", "cacheMatchIgnoreParams", "cache", "request", "matchOptions", "strippedRequestURL", "keysOptions", "cacheKeys", "cacheKey", "strippedCacheKeyURL", "Deferred", "resolve", "reject", "quotaErrorCallbacks", "executeQuotaErrorCallbacks", "callback", "quotaErrorCallbacks", "timeout", "ms", "resolve", "toRequest", "input", "StrategyHandler", "strategy", "options", "Deferred", "plugin", "event", "request", "possiblePreloadResponse", "originalRequest", "cb", "err", "WorkboxError", "pluginFilteredRequest", "fetchResponse", "callback", "error", "response", "responseClone", "key", "cachedResponse", "cacheName", "matchOptions", "effectiveRequest", "multiMatchOptions", "timeout", "getFriendlyURL", "responseToCache", "cache", "hasCacheUpdateCallback", "oldResponse", "cacheMatchIgnoreParams", "executeQuotaErrorCallbacks", "mode", "name", "param", "state", "statefulParam", "promise", "pluginsUsed", "Strategy", "options", "cacheNames", "responseDone", "event", "request", "params", "handler", "StrategyHandler", "handlerDone", "response", "WorkboxError", "error", "callback", "waitUntilError", "cacheOkAndOpaquePlugin", "response", "StaleWhileRevalidate", "Strategy", "options", "p", "cacheOkAndOpaquePlugin", "request", "handler", "logs", "fetchAndCachePromise", "response", "error", "err", "WorkboxError", "isSupported", "enable", "headerValue", "isSupported", "event", "CACHE", "offlineFallbackPage", "event", "cache", "isSupported", "enable", "registerRoute", "StaleWhileRevalidate", "preloadResp"]
}