jekyll-pwa-workbox 0.0.7.alpha → 5.1.4

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

@@ -0,0 +1 @@
+{"version":3,"file":"workbox-precaching.dev.js","sources":["../_version.js","../utils/precachePlugins.js","../addPlugins.js","../utils/createCacheKey.js","../utils/printCleanupDetails.js","../utils/printInstallDetails.js","../PrecacheController.js","../utils/getOrCreatePrecacheController.js","../utils/removeIgnoredSearchParams.js","../utils/generateURLVariations.js","../utils/getCacheKeyForURL.js","../utils/addFetchListener.js","../addRoute.js","../utils/deleteOutdatedCaches.js","../cleanupOutdatedCaches.js","../createHandler.js","../createHandlerBoundToURL.js","../getCacheKeyForURL.js","../matchPrecache.js","../precache.js","../precacheAndRoute.js"],"sourcesContent":["\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:precaching:5.1.4'] && _();\n}\ncatch (e) { }\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 '../_version.js';\nconst plugins = [];\nexport const precachePlugins = {\n    /*\n     * @return {Array}\n     * @private\n     */\n    get() {\n        return plugins;\n    },\n    /*\n     * @param {Array} newPlugins\n     * @private\n     */\n    add(newPlugins) {\n        plugins.push(...newPlugins);\n    },\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 { precachePlugins } from './utils/precachePlugins.js';\nimport './_version.js';\n/**\n * Adds plugins to precaching.\n *\n * @param {Array<Object>} newPlugins\n *\n * @memberof module:workbox-precaching\n */\nfunction addPlugins(newPlugins) {\n    precachePlugins.add(newPlugins);\n}\nexport { addPlugins };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport '../_version.js';\n// Name of the search parameter used to store revision info.\nconst REVISION_SEARCH_PARAM = '__WB_REVISION__';\n/**\n * Converts a manifest entry into a versioned URL suitable for precaching.\n *\n * @param {Object|string} entry\n * @return {string} A URL with versioning info.\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function createCacheKey(entry) {\n    if (!entry) {\n        throw new WorkboxError('add-to-cache-list-unexpected-type', { entry });\n    }\n    // If a precache manifest entry is a string, it's assumed to be a versioned\n    // URL, like '/app.abcd1234.js'. Return as-is.\n    if (typeof entry === 'string') {\n        const urlObject = new URL(entry, location.href);\n        return {\n            cacheKey: urlObject.href,\n            url: urlObject.href,\n        };\n    }\n    const { revision, url } = entry;\n    if (!url) {\n        throw new WorkboxError('add-to-cache-list-unexpected-type', { entry });\n    }\n    // If there's just a URL and no revision, then it's also assumed to be a\n    // versioned URL.\n    if (!revision) {\n        const urlObject = new URL(url, location.href);\n        return {\n            cacheKey: urlObject.href,\n            url: urlObject.href,\n        };\n    }\n    // Otherwise, construct a properly versioned URL using the custom Workbox\n    // search parameter along with the revision info.\n    const cacheKeyURL = new URL(url, location.href);\n    const originalURL = new URL(url, location.href);\n    cacheKeyURL.searchParams.set(REVISION_SEARCH_PARAM, revision);\n    return {\n        cacheKey: cacheKeyURL.href,\n        url: originalURL.href,\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 { logger } from 'workbox-core/_private/logger.js';\nimport '../_version.js';\n/**\n * @param {string} groupTitle\n * @param {Array<string>} deletedURLs\n *\n * @private\n */\nconst logGroup = (groupTitle, deletedURLs) => {\n    logger.groupCollapsed(groupTitle);\n    for (const url of deletedURLs) {\n        logger.log(url);\n    }\n    logger.groupEnd();\n};\n/**\n * @param {Array<string>} deletedURLs\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function printCleanupDetails(deletedURLs) {\n    const deletionCount = deletedURLs.length;\n    if (deletionCount > 0) {\n        logger.groupCollapsed(`During precaching cleanup, ` +\n            `${deletionCount} cached ` +\n            `request${deletionCount === 1 ? ' was' : 's were'} deleted.`);\n        logGroup('Deleted Cache Requests', deletedURLs);\n        logger.groupEnd();\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 { logger } from 'workbox-core/_private/logger.js';\nimport '../_version.js';\n/**\n * @param {string} groupTitle\n * @param {Array<string>} urls\n *\n * @private\n */\nfunction _nestedGroup(groupTitle, urls) {\n    if (urls.length === 0) {\n        return;\n    }\n    logger.groupCollapsed(groupTitle);\n    for (const url of urls) {\n        logger.log(url);\n    }\n    logger.groupEnd();\n}\n/**\n * @param {Array<string>} urlsToPrecache\n * @param {Array<string>} urlsAlreadyPrecached\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function printInstallDetails(urlsToPrecache, urlsAlreadyPrecached) {\n    const precachedCount = urlsToPrecache.length;\n    const alreadyPrecachedCount = urlsAlreadyPrecached.length;\n    if (precachedCount || alreadyPrecachedCount) {\n        let message = `Precaching ${precachedCount} file${precachedCount === 1 ? '' : 's'}.`;\n        if (alreadyPrecachedCount > 0) {\n            message += ` ${alreadyPrecachedCount} ` +\n                `file${alreadyPrecachedCount === 1 ? ' is' : 's are'} already cached.`;\n        }\n        logger.groupCollapsed(message);\n        _nestedGroup(`View newly precached URLs.`, urlsToPrecache);\n        _nestedGroup(`View previously precached URLs.`, urlsAlreadyPrecached);\n        logger.groupEnd();\n    }\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 { 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 { logger } from 'workbox-core/_private/logger.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { copyResponse } from 'workbox-core/copyResponse.js';\nimport { createCacheKey } from './utils/createCacheKey.js';\nimport { printCleanupDetails } from './utils/printCleanupDetails.js';\nimport { printInstallDetails } from './utils/printInstallDetails.js';\nimport './_version.js';\n/**\n * Performs efficient precaching of assets.\n *\n * @memberof module:workbox-precaching\n */\nclass PrecacheController {\n    /**\n     * Create a new PrecacheController.\n     *\n     * @param {string} [cacheName] An optional name for the cache, to override\n     * the default precache name.\n     */\n    constructor(cacheName) {\n        this._cacheName = cacheNames.getPrecacheName(cacheName);\n        this._urlsToCacheKeys = new Map();\n        this._urlsToCacheModes = new Map();\n        this._cacheKeysToIntegrities = new Map();\n    }\n    /**\n     * This method will add items to the precache list, removing duplicates\n     * and ensuring the information is valid.\n     *\n     * @param {\n     * Array<module:workbox-precaching.PrecacheController.PrecacheEntry|string>\n     * } entries Array of entries to precache.\n     */\n    addToCacheList(entries) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isArray(entries, {\n                moduleName: 'workbox-precaching',\n                className: 'PrecacheController',\n                funcName: 'addToCacheList',\n                paramName: 'entries',\n            });\n        }\n        const urlsToWarnAbout = [];\n        for (const entry of entries) {\n            // See https://github.com/GoogleChrome/workbox/issues/2259\n            if (typeof entry === 'string') {\n                urlsToWarnAbout.push(entry);\n            }\n            else if (entry && entry.revision === undefined) {\n                urlsToWarnAbout.push(entry.url);\n            }\n            const { cacheKey, url } = createCacheKey(entry);\n            const cacheMode = (typeof entry !== 'string' && entry.revision) ?\n                'reload' : 'default';\n            if (this._urlsToCacheKeys.has(url) &&\n                this._urlsToCacheKeys.get(url) !== cacheKey) {\n                throw new WorkboxError('add-to-cache-list-conflicting-entries', {\n                    firstEntry: this._urlsToCacheKeys.get(url),\n                    secondEntry: cacheKey,\n                });\n            }\n            if (typeof entry !== 'string' && entry.integrity) {\n                if (this._cacheKeysToIntegrities.has(cacheKey) &&\n                    this._cacheKeysToIntegrities.get(cacheKey) !== entry.integrity) {\n                    throw new WorkboxError('add-to-cache-list-conflicting-integrities', {\n                        url,\n                    });\n                }\n                this._cacheKeysToIntegrities.set(cacheKey, entry.integrity);\n            }\n            this._urlsToCacheKeys.set(url, cacheKey);\n            this._urlsToCacheModes.set(url, cacheMode);\n            if (urlsToWarnAbout.length > 0) {\n                const warningMessage = `Workbox is precaching URLs without revision ` +\n                    `info: ${urlsToWarnAbout.join(', ')}\\nThis is generally NOT safe. ` +\n                    `Learn more at https://bit.ly/wb-precache`;\n                if (process.env.NODE_ENV === 'production') {\n                    // Use console directly to display this warning without bloating\n                    // bundle sizes by pulling in all of the logger codebase in prod.\n                    console.warn(warningMessage);\n                }\n                else {\n                    logger.warn(warningMessage);\n                }\n            }\n        }\n    }\n    /**\n     * Precaches new and updated assets. Call this method from the service worker\n     * install event.\n     *\n     * @param {Object} options\n     * @param {Event} [options.event] The install event (if needed).\n     * @param {Array<Object>} [options.plugins] Plugins to be used for fetching\n     * and caching during install.\n     * @return {Promise<module:workbox-precaching.InstallResult>}\n     */\n    async install({ event, plugins } = {}) {\n        if (process.env.NODE_ENV !== 'production') {\n            if (plugins) {\n                assert.isArray(plugins, {\n                    moduleName: 'workbox-precaching',\n                    className: 'PrecacheController',\n                    funcName: 'install',\n                    paramName: 'plugins',\n                });\n            }\n        }\n        const toBePrecached = [];\n        const alreadyPrecached = [];\n        const cache = await self.caches.open(this._cacheName);\n        const alreadyCachedRequests = await cache.keys();\n        const existingCacheKeys = new Set(alreadyCachedRequests.map((request) => request.url));\n        for (const [url, cacheKey] of this._urlsToCacheKeys) {\n            if (existingCacheKeys.has(cacheKey)) {\n                alreadyPrecached.push(url);\n            }\n            else {\n                toBePrecached.push({ cacheKey, url });\n            }\n        }\n        const precacheRequests = toBePrecached.map(({ cacheKey, url }) => {\n            const integrity = this._cacheKeysToIntegrities.get(cacheKey);\n            const cacheMode = this._urlsToCacheModes.get(url);\n            return this._addURLToCache({\n                cacheKey,\n                cacheMode,\n                event,\n                integrity,\n                plugins,\n                url,\n            });\n        });\n        await Promise.all(precacheRequests);\n        const updatedURLs = toBePrecached.map((item) => item.url);\n        if (process.env.NODE_ENV !== 'production') {\n            printInstallDetails(updatedURLs, alreadyPrecached);\n        }\n        return {\n            updatedURLs,\n            notUpdatedURLs: alreadyPrecached,\n        };\n    }\n    /**\n     * Deletes assets that are no longer present in the current precache manifest.\n     * Call this method from the service worker activate event.\n     *\n     * @return {Promise<module:workbox-precaching.CleanupResult>}\n     */\n    async activate() {\n        const cache = await self.caches.open(this._cacheName);\n        const currentlyCachedRequests = await cache.keys();\n        const expectedCacheKeys = new Set(this._urlsToCacheKeys.values());\n        const deletedURLs = [];\n        for (const request of currentlyCachedRequests) {\n            if (!expectedCacheKeys.has(request.url)) {\n                await cache.delete(request);\n                deletedURLs.push(request.url);\n            }\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            printCleanupDetails(deletedURLs);\n        }\n        return { deletedURLs };\n    }\n    /**\n     * Requests the entry and saves it to the cache if the response is valid.\n     * By default, any response with a status code of less than 400 (including\n     * opaque responses) is considered valid.\n     *\n     * If you need to use custom criteria to determine what's valid and what\n     * isn't, then pass in an item in `options.plugins` that implements the\n     * `cacheWillUpdate()` lifecycle event.\n     *\n     * @private\n     * @param {Object} options\n     * @param {string} options.cacheKey The string to use a cache key.\n     * @param {string} options.url The URL to fetch and cache.\n     * @param {string} [options.cacheMode] The cache mode for the network request.\n     * @param {Event} [options.event] The install event (if passed).\n     * @param {Array<Object>} [options.plugins] An array of plugins to apply to\n     * fetch and caching.\n     * @param {string} [options.integrity] The value to use for the `integrity`\n     * field when making the request.\n     */\n    async _addURLToCache({ cacheKey, url, cacheMode, event, plugins, integrity }) {\n        const request = new Request(url, {\n            integrity,\n            cache: cacheMode,\n            credentials: 'same-origin',\n        });\n        let response = await fetchWrapper.fetch({\n            event,\n            plugins,\n            request,\n        });\n        // Allow developers to override the default logic about what is and isn't\n        // valid by passing in a plugin implementing cacheWillUpdate(), e.g.\n        // a `CacheableResponsePlugin` instance.\n        let cacheWillUpdatePlugin;\n        for (const plugin of (plugins || [])) {\n            if ('cacheWillUpdate' in plugin) {\n                cacheWillUpdatePlugin = plugin;\n            }\n        }\n        const isValidResponse = cacheWillUpdatePlugin ?\n            // Use a callback if provided. It returns a truthy value if valid.\n            // NOTE: invoke the method on the plugin instance so the `this` context\n            // is correct.\n            await cacheWillUpdatePlugin.cacheWillUpdate({ event, request, response }) :\n            // Otherwise, default to considering any response status under 400 valid.\n            // This includes, by default, considering opaque responses valid.\n            response.status < 400;\n        // Consider this a failure, leading to the `install` handler failing, if\n        // we get back an invalid response.\n        if (!isValidResponse) {\n            throw new WorkboxError('bad-precaching-response', {\n                url,\n                status: response.status,\n            });\n        }\n        // Redirected responses cannot be used to satisfy a navigation request, so\n        // any redirected response must be \"copied\" rather than cloned, so the new\n        // response doesn't contain the `redirected` flag. See:\n        // https://bugs.chromium.org/p/chromium/issues/detail?id=669363&desc=2#c1\n        if (response.redirected) {\n            response = await copyResponse(response);\n        }\n        await cacheWrapper.put({\n            event,\n            plugins,\n            response,\n            // `request` already uses `url`. We may be able to reuse it.\n            request: cacheKey === url ? request : new Request(cacheKey),\n            cacheName: this._cacheName,\n            matchOptions: {\n                ignoreSearch: true,\n            },\n        });\n    }\n    /**\n     * Returns a mapping of a precached URL to the corresponding cache key, taking\n     * into account the revision information for the URL.\n     *\n     * @return {Map<string, string>} A URL to cache key mapping.\n     */\n    getURLsToCacheKeys() {\n        return this._urlsToCacheKeys;\n    }\n    /**\n     * Returns a list of all the URLs that have been precached by the current\n     * service worker.\n     *\n     * @return {Array<string>} The precached URLs.\n     */\n    getCachedURLs() {\n        return [...this._urlsToCacheKeys.keys()];\n    }\n    /**\n     * Returns the cache key used for storing a given URL. If that URL is\n     * unversioned, like `/index.html', then the cache key will be the original\n     * URL with a search parameter appended to it.\n     *\n     * @param {string} url A URL whose cache key you want to look up.\n     * @return {string} The versioned URL that corresponds to a cache key\n     * for the original URL, or undefined if that URL isn't precached.\n     */\n    getCacheKeyForURL(url) {\n        const urlObject = new URL(url, location.href);\n        return this._urlsToCacheKeys.get(urlObject.href);\n    }\n    /**\n     * This acts as a drop-in replacement for [`cache.match()`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/match)\n     * with the following differences:\n     *\n     * - It knows what the name of the precache is, and only checks in that cache.\n     * - It allows you to pass in an \"original\" URL without versioning parameters,\n     * and it will automatically look up the correct cache key for the currently\n     * active revision of that URL.\n     *\n     * E.g., `matchPrecache('index.html')` will find the correct precached\n     * response for the currently active service worker, even if the actual cache\n     * key is `'/index.html?__WB_REVISION__=1234abcd'`.\n     *\n     * @param {string|Request} request The key (without revisioning parameters)\n     * to look up in the precache.\n     * @return {Promise<Response|undefined>}\n     */\n    async matchPrecache(request) {\n        const url = request instanceof Request ? request.url : request;\n        const cacheKey = this.getCacheKeyForURL(url);\n        if (cacheKey) {\n            const cache = await self.caches.open(this._cacheName);\n            return cache.match(cacheKey);\n        }\n        return undefined;\n    }\n    /**\n     * Returns a function that can be used within a\n     * {@link module:workbox-routing.Route} that will find a response for the\n     * incoming request against the precache.\n     *\n     * If for an unexpected reason there is a cache miss for the request,\n     * this will fall back to retrieving the `Response` via `fetch()` when\n     * `fallbackToNetwork` is `true`.\n     *\n     * @param {boolean} [fallbackToNetwork=true] Whether to attempt to get the\n     * response from the network if there's a precache miss.\n     * @return {module:workbox-routing~handlerCallback}\n     */\n    createHandler(fallbackToNetwork = true) {\n        return async ({ request }) => {\n            try {\n                const response = await this.matchPrecache(request);\n                if (response) {\n                    return response;\n                }\n                // This shouldn't normally happen, but there are edge cases:\n                // https://github.com/GoogleChrome/workbox/issues/1441\n                throw new WorkboxError('missing-precache-entry', {\n                    cacheName: this._cacheName,\n                    url: request instanceof Request ? request.url : request,\n                });\n            }\n            catch (error) {\n                if (fallbackToNetwork) {\n                    if (process.env.NODE_ENV !== 'production') {\n                        logger.debug(`Unable to respond with precached response. ` +\n                            `Falling back to network.`, error);\n                    }\n                    return fetch(request);\n                }\n                throw error;\n            }\n        };\n    }\n    /**\n     * Returns a function that looks up `url` in the precache (taking into\n     * account revision information), and returns the corresponding `Response`.\n     *\n     * If for an unexpected reason there is a cache miss when looking up `url`,\n     * this will fall back to retrieving the `Response` via `fetch()` when\n     * `fallbackToNetwork` is `true`.\n     *\n     * @param {string} url The precached URL which will be used to lookup the\n     * `Response`.\n     * @param {boolean} [fallbackToNetwork=true] Whether to attempt to get the\n     * response from the network if there's a precache miss.\n     * @return {module:workbox-routing~handlerCallback}\n     */\n    createHandlerBoundToURL(url, fallbackToNetwork = true) {\n        const cacheKey = this.getCacheKeyForURL(url);\n        if (!cacheKey) {\n            throw new WorkboxError('non-precached-url', { url });\n        }\n        const handler = this.createHandler(fallbackToNetwork);\n        const request = new Request(url);\n        return () => handler({ request });\n    }\n}\nexport { PrecacheController };\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 { PrecacheController } from '../PrecacheController.js';\nimport '../_version.js';\nlet precacheController;\n/**\n * @return {PrecacheController}\n * @private\n */\nexport const getOrCreatePrecacheController = () => {\n    if (!precacheController) {\n        precacheController = new PrecacheController();\n    }\n    return precacheController;\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';\n/**\n * Removes any URL search parameters that should be ignored.\n *\n * @param {URL} urlObject The original URL.\n * @param {Array<RegExp>} ignoreURLParametersMatching RegExps to test against\n * each search parameter name. Matches mean that the search parameter should be\n * ignored.\n * @return {URL} The URL with any ignored search parameters removed.\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching = []) {\n    // Convert the iterable into an array at the start of the loop to make sure\n    // deletion doesn't mess up iteration.\n    for (const paramName of [...urlObject.searchParams.keys()]) {\n        if (ignoreURLParametersMatching.some((regExp) => regExp.test(paramName))) {\n            urlObject.searchParams.delete(paramName);\n        }\n    }\n    return urlObject;\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 { removeIgnoredSearchParams } from './removeIgnoredSearchParams.js';\nimport '../_version.js';\n/**\n * Generator function that yields possible variations on the original URL to\n * check, one at a time.\n *\n * @param {string} url\n * @param {Object} options\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function* generateURLVariations(url, { ignoreURLParametersMatching, directoryIndex, cleanURLs, urlManipulation, } = {}) {\n    const urlObject = new URL(url, location.href);\n    urlObject.hash = '';\n    yield urlObject.href;\n    const urlWithoutIgnoredParams = removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching);\n    yield urlWithoutIgnoredParams.href;\n    if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith('/')) {\n        const directoryURL = new URL(urlWithoutIgnoredParams.href);\n        directoryURL.pathname += directoryIndex;\n        yield directoryURL.href;\n    }\n    if (cleanURLs) {\n        const cleanURL = new URL(urlWithoutIgnoredParams.href);\n        cleanURL.pathname += '.html';\n        yield cleanURL.href;\n    }\n    if (urlManipulation) {\n        const additionalURLs = urlManipulation({ url: urlObject });\n        for (const urlToAttempt of additionalURLs) {\n            yield urlToAttempt.href;\n        }\n    }\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 { getOrCreatePrecacheController } from './getOrCreatePrecacheController.js';\nimport { generateURLVariations } from './generateURLVariations.js';\nimport '../_version.js';\n/**\n * This function will take the request URL and manipulate it based on the\n * configuration options.\n *\n * @param {string} url\n * @param {Object} options\n * @return {string} Returns the URL in the cache that matches the request,\n * if possible.\n *\n * @private\n */\nexport const getCacheKeyForURL = (url, options) => {\n    const precacheController = getOrCreatePrecacheController();\n    const urlsToCacheKeys = precacheController.getURLsToCacheKeys();\n    for (const possibleURL of generateURLVariations(url, options)) {\n        const possibleCacheKey = urlsToCacheKeys.get(possibleURL);\n        if (possibleCacheKey) {\n            return possibleCacheKey;\n        }\n    }\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 { cacheNames } from 'workbox-core/_private/cacheNames.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { getCacheKeyForURL } from './getCacheKeyForURL.js';\nimport '../_version.js';\n/**\n * Adds a `fetch` listener to the service worker that will\n * respond to\n * [network requests]{@link https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests}\n * with precached assets.\n *\n * Requests for assets that aren't precached, the `FetchEvent` will not be\n * responded to, allowing the event to fall through to other `fetch` event\n * listeners.\n *\n * NOTE: when called more than once this method will replace the previously set\n * configuration options. Calling it more than once is not recommended outside\n * of tests.\n *\n * @private\n * @param {Object} [options]\n * @param {string} [options.directoryIndex=index.html] The `directoryIndex` will\n * check cache entries for a URLs ending with '/' to see if there is a hit when\n * appending the `directoryIndex` value.\n * @param {Array<RegExp>} [options.ignoreURLParametersMatching=[/^utm_/]] An\n * array of regex's to remove search params when looking for a cache match.\n * @param {boolean} [options.cleanURLs=true] The `cleanURLs` option will\n * check the cache for the URL with a `.html` added to the end of the end.\n * @param {workbox.precaching~urlManipulation} [options.urlManipulation]\n * This is a function that should take a URL and return an array of\n * alternative URLs that should be checked for precache matches.\n */\nexport const addFetchListener = ({ ignoreURLParametersMatching = [/^utm_/], directoryIndex = 'index.html', cleanURLs = true, urlManipulation, } = {}) => {\n    const cacheName = cacheNames.getPrecacheName();\n    // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705\n    self.addEventListener('fetch', ((event) => {\n        const precachedURL = getCacheKeyForURL(event.request.url, {\n            cleanURLs,\n            directoryIndex,\n            ignoreURLParametersMatching,\n            urlManipulation,\n        });\n        if (!precachedURL) {\n            if (process.env.NODE_ENV !== 'production') {\n                logger.debug(`Precaching did not find a match for ` +\n                    getFriendlyURL(event.request.url));\n            }\n            return;\n        }\n        let responsePromise = self.caches.open(cacheName).then((cache) => {\n            return cache.match(precachedURL);\n        }).then((cachedResponse) => {\n            if (cachedResponse) {\n                return cachedResponse;\n            }\n            // Fall back to the network if we don't have a cached response\n            // (perhaps due to manual cache cleanup).\n            if (process.env.NODE_ENV !== 'production') {\n                logger.warn(`The precached response for ` +\n                    `${getFriendlyURL(precachedURL)} in ${cacheName} was not found. ` +\n                    `Falling back to the network instead.`);\n            }\n            return fetch(precachedURL);\n        });\n        if (process.env.NODE_ENV !== 'production') {\n            responsePromise = responsePromise.then((response) => {\n                // Workbox is going to handle the route.\n                // print the routing details to the console.\n                logger.groupCollapsed(`Precaching is responding to: ` +\n                    getFriendlyURL(event.request.url));\n                logger.log(`Serving the precached url: ${precachedURL}`);\n                logger.groupCollapsed(`View request details here.`);\n                logger.log(event.request);\n                logger.groupEnd();\n                logger.groupCollapsed(`View response details here.`);\n                logger.log(response);\n                logger.groupEnd();\n                logger.groupEnd();\n                return response;\n            });\n        }\n        event.respondWith(responsePromise);\n    }));\n};\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 { addFetchListener } from './utils/addFetchListener.js';\nimport './_version.js';\nlet listenerAdded = false;\n/**\n * Add a `fetch` listener to the service worker that will\n * respond to\n * [network requests]{@link https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests}\n * with precached assets.\n *\n * Requests for assets that aren't precached, the `FetchEvent` will not be\n * responded to, allowing the event to fall through to other `fetch` event\n * listeners.\n *\n * @param {Object} [options]\n * @param {string} [options.directoryIndex=index.html] The `directoryIndex` will\n * check cache entries for a URLs ending with '/' to see if there is a hit when\n * appending the `directoryIndex` value.\n * @param {Array<RegExp>} [options.ignoreURLParametersMatching=[/^utm_/]] An\n * array of regex's to remove search params when looking for a cache match.\n * @param {boolean} [options.cleanURLs=true] The `cleanURLs` option will\n * check the cache for the URL with a `.html` added to the end of the end.\n * @param {module:workbox-precaching~urlManipulation} [options.urlManipulation]\n * This is a function that should take a URL and return an array of\n * alternative URLs that should be checked for precache matches.\n *\n * @memberof module:workbox-precaching\n */\nfunction addRoute(options) {\n    if (!listenerAdded) {\n        addFetchListener(options);\n        listenerAdded = true;\n    }\n}\nexport { addRoute };\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 SUBSTRING_TO_FIND = '-precache-';\n/**\n * Cleans up incompatible precaches that were created by older versions of\n * Workbox, by a service worker registered under the current scope.\n *\n * This is meant to be called as part of the `activate` event.\n *\n * This should be safe to use as long as you don't include `substringToFind`\n * (defaulting to `-precache-`) in your non-precache cache names.\n *\n * @param {string} currentPrecacheName The cache name currently in use for\n * precaching. This cache won't be deleted.\n * @param {string} [substringToFind='-precache-'] Cache names which include this\n * substring will be deleted (excluding `currentPrecacheName`).\n * @return {Array<string>} A list of all the cache names that were deleted.\n *\n * @private\n * @memberof module:workbox-precaching\n */\nconst deleteOutdatedCaches = async (currentPrecacheName, substringToFind = SUBSTRING_TO_FIND) => {\n    const cacheNames = await self.caches.keys();\n    const cacheNamesToDelete = cacheNames.filter((cacheName) => {\n        return cacheName.includes(substringToFind) &&\n            cacheName.includes(self.registration.scope) &&\n            cacheName !== currentPrecacheName;\n    });\n    await Promise.all(cacheNamesToDelete.map((cacheName) => self.caches.delete(cacheName)));\n    return cacheNamesToDelete;\n};\nexport { deleteOutdatedCaches };\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 { cacheNames } from 'workbox-core/_private/cacheNames.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { deleteOutdatedCaches } from './utils/deleteOutdatedCaches.js';\nimport './_version.js';\n/**\n * Adds an `activate` event listener which will clean up incompatible\n * precaches that were created by older versions of Workbox.\n *\n * @memberof module:workbox-precaching\n */\nfunction cleanupOutdatedCaches() {\n    // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705\n    self.addEventListener('activate', ((event) => {\n        const cacheName = cacheNames.getPrecacheName();\n        event.waitUntil(deleteOutdatedCaches(cacheName).then((cachesDeleted) => {\n            if (process.env.NODE_ENV !== 'production') {\n                if (cachesDeleted.length > 0) {\n                    logger.log(`The following out-of-date precaches were cleaned up ` +\n                        `automatically:`, cachesDeleted);\n                }\n            }\n        }));\n    }));\n}\nexport { cleanupOutdatedCaches };\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 { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';\nimport './_version.js';\n/**\n * Helper function that calls\n * {@link PrecacheController#createHandler} on the default\n * {@link PrecacheController} instance.\n *\n * If you are creating your own {@link PrecacheController}, then call the\n * {@link PrecacheController#createHandler} on that instance,\n * instead of using this function.\n *\n * @param {boolean} [fallbackToNetwork=true] Whether to attempt to get the\n * response from the network if there's a precache miss.\n * @return {module:workbox-routing~handlerCallback}\n *\n * @memberof module:workbox-precaching\n */\nfunction createHandler(fallbackToNetwork = true) {\n    const precacheController = getOrCreatePrecacheController();\n    return precacheController.createHandler(fallbackToNetwork);\n}\nexport { createHandler };\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 { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';\nimport './_version.js';\n/**\n * Helper function that calls\n * {@link PrecacheController#createHandlerBoundToURL} on the default\n * {@link PrecacheController} instance.\n *\n * If you are creating your own {@link PrecacheController}, then call the\n * {@link PrecacheController#createHandlerBoundToURL} on that instance,\n * instead of using this function.\n *\n * @param {string} url The precached URL which will be used to lookup the\n * `Response`.\n * @param {boolean} [fallbackToNetwork=true] Whether to attempt to get the\n * response from the network if there's a precache miss.\n * @return {module:workbox-routing~handlerCallback}\n *\n * @memberof module:workbox-precaching\n */\nfunction createHandlerBoundToURL(url) {\n    const precacheController = getOrCreatePrecacheController();\n    return precacheController.createHandlerBoundToURL(url);\n}\nexport { createHandlerBoundToURL };\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 { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';\nimport './_version.js';\n/**\n * Takes in a URL, and returns the corresponding URL that could be used to\n * lookup the entry in the precache.\n *\n * If a relative URL is provided, the location of the service worker file will\n * be used as the base.\n *\n * For precached entries without revision information, the cache key will be the\n * same as the original URL.\n *\n * For precached entries with revision information, the cache key will be the\n * original URL with the addition of a query parameter used for keeping track of\n * the revision info.\n *\n * @param {string} url The URL whose cache key to look up.\n * @return {string} The cache key that corresponds to that URL.\n *\n * @memberof module:workbox-precaching\n */\nfunction getCacheKeyForURL(url) {\n    const precacheController = getOrCreatePrecacheController();\n    return precacheController.getCacheKeyForURL(url);\n}\nexport { getCacheKeyForURL };\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 { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';\nimport './_version.js';\n/**\n * Helper function that calls\n * {@link PrecacheController#matchPrecache} on the default\n * {@link PrecacheController} instance.\n *\n * If you are creating your own {@link PrecacheController}, then call\n * {@link PrecacheController#matchPrecache} on that instance,\n * instead of using this function.\n *\n * @param {string|Request} request The key (without revisioning parameters)\n * to look up in the precache.\n * @return {Promise<Response|undefined>}\n *\n * @memberof module:workbox-precaching\n */\nfunction matchPrecache(request) {\n    const precacheController = getOrCreatePrecacheController();\n    return precacheController.matchPrecache(request);\n}\nexport { matchPrecache };\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 { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';\nimport { precachePlugins } from './utils/precachePlugins.js';\nimport './_version.js';\nconst installListener = (event) => {\n    const precacheController = getOrCreatePrecacheController();\n    const plugins = precachePlugins.get();\n    event.waitUntil(precacheController.install({ event, plugins })\n        .catch((error) => {\n        if (process.env.NODE_ENV !== 'production') {\n            logger.error(`Service worker installation failed. It will ` +\n                `be retried automatically during the next navigation.`);\n        }\n        // Re-throw the error to ensure installation fails.\n        throw error;\n    }));\n};\nconst activateListener = (event) => {\n    const precacheController = getOrCreatePrecacheController();\n    event.waitUntil(precacheController.activate());\n};\n/**\n * Adds items to the precache list, removing any duplicates and\n * stores the files in the\n * [\"precache cache\"]{@link module:workbox-core.cacheNames} when the service\n * worker installs.\n *\n * This method can be called multiple times.\n *\n * Please note: This method **will not** serve any of the cached files for you.\n * It only precaches files. To respond to a network request you call\n * [addRoute()]{@link module:workbox-precaching.addRoute}.\n *\n * If you have a single array of files to precache, you can just call\n * [precacheAndRoute()]{@link module:workbox-precaching.precacheAndRoute}.\n *\n * @param {Array<Object|string>} [entries=[]] Array of entries to precache.\n *\n * @memberof module:workbox-precaching\n */\nfunction precache(entries) {\n    const precacheController = getOrCreatePrecacheController();\n    precacheController.addToCacheList(entries);\n    if (entries.length > 0) {\n        // NOTE: these listeners will only be added once (even if the `precache()`\n        // method is called multiple times) because event listeners are implemented\n        // as a set, where each listener must be unique.\n        // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705\n        self.addEventListener('install', installListener);\n        self.addEventListener('activate', activateListener);\n    }\n}\nexport { precache };\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 { addRoute } from './addRoute.js';\nimport { precache } from './precache.js';\nimport './_version.js';\n/**\n * This method will add entries to the precache list and add a route to\n * respond to fetch events.\n *\n * This is a convenience method that will call\n * [precache()]{@link module:workbox-precaching.precache} and\n * [addRoute()]{@link module:workbox-precaching.addRoute} in a single call.\n *\n * @param {Array<Object|string>} entries Array of entries to precache.\n * @param {Object} [options] See\n * [addRoute() options]{@link module:workbox-precaching.addRoute}.\n *\n * @memberof module:workbox-precaching\n */\nfunction precacheAndRoute(entries, options) {\n    precache(entries);\n    addRoute(options);\n}\nexport { precacheAndRoute };\n"],"names":["self","_","e","plugins","precachePlugins","get","add","newPlugins","push","addPlugins","REVISION_SEARCH_PARAM","createCacheKey","entry","WorkboxError","urlObject","URL","location","href","cacheKey","url","revision","cacheKeyURL","originalURL","searchParams","set","logGroup","groupTitle","deletedURLs","logger","groupCollapsed","log","groupEnd","printCleanupDetails","deletionCount","length","_nestedGroup","urls","printInstallDetails","urlsToPrecache","urlsAlreadyPrecached","precachedCount","alreadyPrecachedCount","message","PrecacheController","constructor","cacheName","_cacheName","cacheNames","getPrecacheName","_urlsToCacheKeys","Map","_urlsToCacheModes","_cacheKeysToIntegrities","addToCacheList","entries","assert","isArray","moduleName","className","funcName","paramName","urlsToWarnAbout","undefined","cacheMode","has","firstEntry","secondEntry","integrity","warningMessage","join","warn","install","event","toBePrecached","alreadyPrecached","cache","caches","open","alreadyCachedRequests","keys","existingCacheKeys","Set","map","request","precacheRequests","_addURLToCache","Promise","all","updatedURLs","item","notUpdatedURLs","activate","currentlyCachedRequests","expectedCacheKeys","values","delete","Request","credentials","response","fetchWrapper","fetch","cacheWillUpdatePlugin","plugin","isValidResponse","cacheWillUpdate","status","redirected","copyResponse","cacheWrapper","put","matchOptions","ignoreSearch","getURLsToCacheKeys","getCachedURLs","getCacheKeyForURL","matchPrecache","match","createHandler","fallbackToNetwork","error","debug","createHandlerBoundToURL","handler","precacheController","getOrCreatePrecacheController","removeIgnoredSearchParams","ignoreURLParametersMatching","some","regExp","test","generateURLVariations","directoryIndex","cleanURLs","urlManipulation","hash","urlWithoutIgnoredParams","pathname","endsWith","directoryURL","cleanURL","additionalURLs","urlToAttempt","options","urlsToCacheKeys","possibleURL","possibleCacheKey","addFetchListener","addEventListener","precachedURL","getFriendlyURL","responsePromise","then","cachedResponse","respondWith","listenerAdded","addRoute","SUBSTRING_TO_FIND","deleteOutdatedCaches","currentPrecacheName","substringToFind","cacheNamesToDelete","filter","includes","registration","scope","cleanupOutdatedCaches","waitUntil","cachesDeleted","installListener","catch","activateListener","precache","precacheAndRoute"],"mappings":";;;;IAEA,IAAI;IACAA,EAAAA,IAAI,CAAC,0BAAD,CAAJ,IAAoCC,CAAC,EAArC;IACH,CAFD,CAGA,OAAOC,CAAP,EAAU;;ICLV;;;;;;;AAOA,IACA,MAAMC,OAAO,GAAG,EAAhB;AACA,IAAO,MAAMC,eAAe,GAAG;IAC3B;;;;IAIAC,EAAAA,GAAG,GAAG;IACF,WAAOF,OAAP;IACH,GAP0B;;IAQ3B;;;;IAIAG,EAAAA,GAAG,CAACC,UAAD,EAAa;IACZJ,IAAAA,OAAO,CAACK,IAAR,CAAa,GAAGD,UAAhB;IACH;;IAd0B,CAAxB;;ICTP;;;;;;;AAOA,IAEA;;;;;;;;IAOA,SAASE,UAAT,CAAoBF,UAApB,EAAgC;IAC5BH,EAAAA,eAAe,CAACE,GAAhB,CAAoBC,UAApB;IACH;;IClBD;;;;;;;AAOA;IAGA,MAAMG,qBAAqB,GAAG,iBAA9B;IACA;;;;;;;;;;AASA,IAAO,SAASC,cAAT,CAAwBC,KAAxB,EAA+B;IAClC,MAAI,CAACA,KAAL,EAAY;IACR,UAAM,IAAIC,4BAAJ,CAAiB,mCAAjB,EAAsD;IAAED,MAAAA;IAAF,KAAtD,CAAN;IACH,GAHiC;IAKlC;;;IACA,MAAI,OAAOA,KAAP,KAAiB,QAArB,EAA+B;IAC3B,UAAME,SAAS,GAAG,IAAIC,GAAJ,CAAQH,KAAR,EAAeI,QAAQ,CAACC,IAAxB,CAAlB;IACA,WAAO;IACHC,MAAAA,QAAQ,EAAEJ,SAAS,CAACG,IADjB;IAEHE,MAAAA,GAAG,EAAEL,SAAS,CAACG;IAFZ,KAAP;IAIH;;IACD,QAAM;IAAEG,IAAAA,QAAF;IAAYD,IAAAA;IAAZ,MAAoBP,KAA1B;;IACA,MAAI,CAACO,GAAL,EAAU;IACN,UAAM,IAAIN,4BAAJ,CAAiB,mCAAjB,EAAsD;IAAED,MAAAA;IAAF,KAAtD,CAAN;IACH,GAhBiC;IAkBlC;;;IACA,MAAI,CAACQ,QAAL,EAAe;IACX,UAAMN,SAAS,GAAG,IAAIC,GAAJ,CAAQI,GAAR,EAAaH,QAAQ,CAACC,IAAtB,CAAlB;IACA,WAAO;IACHC,MAAAA,QAAQ,EAAEJ,SAAS,CAACG,IADjB;IAEHE,MAAAA,GAAG,EAAEL,SAAS,CAACG;IAFZ,KAAP;IAIH,GAzBiC;IA2BlC;;;IACA,QAAMI,WAAW,GAAG,IAAIN,GAAJ,CAAQI,GAAR,EAAaH,QAAQ,CAACC,IAAtB,CAApB;IACA,QAAMK,WAAW,GAAG,IAAIP,GAAJ,CAAQI,GAAR,EAAaH,QAAQ,CAACC,IAAtB,CAApB;IACAI,EAAAA,WAAW,CAACE,YAAZ,CAAyBC,GAAzB,CAA6Bd,qBAA7B,EAAoDU,QAApD;IACA,SAAO;IACHF,IAAAA,QAAQ,EAAEG,WAAW,CAACJ,IADnB;IAEHE,IAAAA,GAAG,EAAEG,WAAW,CAACL;IAFd,GAAP;IAIH;;ICvDD;;;;;;;AAOA,IAEA;;;;;;;IAMA,MAAMQ,QAAQ,GAAG,CAACC,UAAD,EAAaC,WAAb,KAA6B;IAC1CC,EAAAA,gBAAM,CAACC,cAAP,CAAsBH,UAAtB;;IACA,OAAK,MAAMP,GAAX,IAAkBQ,WAAlB,EAA+B;IAC3BC,IAAAA,gBAAM,CAACE,GAAP,CAAWX,GAAX;IACH;;IACDS,EAAAA,gBAAM,CAACG,QAAP;IACH,CAND;IAOA;;;;;;;;AAMA,IAAO,SAASC,mBAAT,CAA6BL,WAA7B,EAA0C;IAC7C,QAAMM,aAAa,GAAGN,WAAW,CAACO,MAAlC;;IACA,MAAID,aAAa,GAAG,CAApB,EAAuB;IACnBL,IAAAA,gBAAM,CAACC,cAAP,CAAuB,6BAAD,GACjB,GAAEI,aAAc,UADC,GAEjB,UAASA,aAAa,KAAK,CAAlB,GAAsB,MAAtB,GAA+B,QAAS,WAFtD;IAGAR,IAAAA,QAAQ,CAAC,wBAAD,EAA2BE,WAA3B,CAAR;IACAC,IAAAA,gBAAM,CAACG,QAAP;IACH;IACJ;;ICrCD;;;;;;;AAOA,IAEA;;;;;;;IAMA,SAASI,YAAT,CAAsBT,UAAtB,EAAkCU,IAAlC,EAAwC;IACpC,MAAIA,IAAI,CAACF,MAAL,KAAgB,CAApB,EAAuB;IACnB;IACH;;IACDN,EAAAA,gBAAM,CAACC,cAAP,CAAsBH,UAAtB;;IACA,OAAK,MAAMP,GAAX,IAAkBiB,IAAlB,EAAwB;IACpBR,IAAAA,gBAAM,CAACE,GAAP,CAAWX,GAAX;IACH;;IACDS,EAAAA,gBAAM,CAACG,QAAP;IACH;IACD;;;;;;;;;AAOA,IAAO,SAASM,mBAAT,CAA6BC,cAA7B,EAA6CC,oBAA7C,EAAmE;IACtE,QAAMC,cAAc,GAAGF,cAAc,CAACJ,MAAtC;IACA,QAAMO,qBAAqB,GAAGF,oBAAoB,CAACL,MAAnD;;IACA,MAAIM,cAAc,IAAIC,qBAAtB,EAA6C;IACzC,QAAIC,OAAO,GAAI,cAAaF,cAAe,QAAOA,cAAc,KAAK,CAAnB,GAAuB,EAAvB,GAA4B,GAAI,GAAlF;;IACA,QAAIC,qBAAqB,GAAG,CAA5B,EAA+B;IAC3BC,MAAAA,OAAO,IAAK,IAAGD,qBAAsB,GAA1B,GACN,OAAMA,qBAAqB,KAAK,CAA1B,GAA8B,KAA9B,GAAsC,OAAQ,kBADzD;IAEH;;IACDb,IAAAA,gBAAM,CAACC,cAAP,CAAsBa,OAAtB;;IACAP,IAAAA,YAAY,CAAE,4BAAF,EAA+BG,cAA/B,CAAZ;;IACAH,IAAAA,YAAY,CAAE,iCAAF,EAAoCI,oBAApC,CAAZ;;IACAX,IAAAA,gBAAM,CAACG,QAAP;IACH;IACJ;;IC9CD;;;;;;;AAOA,IAWA;;;;;;IAKA,MAAMY,kBAAN,CAAyB;IACrB;;;;;;IAMAC,EAAAA,WAAW,CAACC,SAAD,EAAY;IACnB,SAAKC,UAAL,GAAkBC,wBAAU,CAACC,eAAX,CAA2BH,SAA3B,CAAlB;IACA,SAAKI,gBAAL,GAAwB,IAAIC,GAAJ,EAAxB;IACA,SAAKC,iBAAL,GAAyB,IAAID,GAAJ,EAAzB;IACA,SAAKE,uBAAL,GAA+B,IAAIF,GAAJ,EAA/B;IACH;IACD;;;;;;;;;;IAQAG,EAAAA,cAAc,CAACC,OAAD,EAAU;IACpB,IAA2C;IACvCC,MAAAA,gBAAM,CAACC,OAAP,CAAeF,OAAf,EAAwB;IACpBG,QAAAA,UAAU,EAAE,oBADQ;IAEpBC,QAAAA,SAAS,EAAE,oBAFS;IAGpBC,QAAAA,QAAQ,EAAE,gBAHU;IAIpBC,QAAAA,SAAS,EAAE;IAJS,OAAxB;IAMH;;IACD,UAAMC,eAAe,GAAG,EAAxB;;IACA,SAAK,MAAMjD,KAAX,IAAoB0C,OAApB,EAA6B;IACzB;IACA,UAAI,OAAO1C,KAAP,KAAiB,QAArB,EAA+B;IAC3BiD,QAAAA,eAAe,CAACrD,IAAhB,CAAqBI,KAArB;IACH,OAFD,MAGK,IAAIA,KAAK,IAAIA,KAAK,CAACQ,QAAN,KAAmB0C,SAAhC,EAA2C;IAC5CD,QAAAA,eAAe,CAACrD,IAAhB,CAAqBI,KAAK,CAACO,GAA3B;IACH;;IACD,YAAM;IAAED,QAAAA,QAAF;IAAYC,QAAAA;IAAZ,UAAoBR,cAAc,CAACC,KAAD,CAAxC;IACA,YAAMmD,SAAS,GAAI,OAAOnD,KAAP,KAAiB,QAAjB,IAA6BA,KAAK,CAACQ,QAApC,GACd,QADc,GACH,SADf;;IAEA,UAAI,KAAK6B,gBAAL,CAAsBe,GAAtB,CAA0B7C,GAA1B,KACA,KAAK8B,gBAAL,CAAsB5C,GAAtB,CAA0Bc,GAA1B,MAAmCD,QADvC,EACiD;IAC7C,cAAM,IAAIL,4BAAJ,CAAiB,uCAAjB,EAA0D;IAC5DoD,UAAAA,UAAU,EAAE,KAAKhB,gBAAL,CAAsB5C,GAAtB,CAA0Bc,GAA1B,CADgD;IAE5D+C,UAAAA,WAAW,EAAEhD;IAF+C,SAA1D,CAAN;IAIH;;IACD,UAAI,OAAON,KAAP,KAAiB,QAAjB,IAA6BA,KAAK,CAACuD,SAAvC,EAAkD;IAC9C,YAAI,KAAKf,uBAAL,CAA6BY,GAA7B,CAAiC9C,QAAjC,KACA,KAAKkC,uBAAL,CAA6B/C,GAA7B,CAAiCa,QAAjC,MAA+CN,KAAK,CAACuD,SADzD,EACoE;IAChE,gBAAM,IAAItD,4BAAJ,CAAiB,2CAAjB,EAA8D;IAChEM,YAAAA;IADgE,WAA9D,CAAN;IAGH;;IACD,aAAKiC,uBAAL,CAA6B5B,GAA7B,CAAiCN,QAAjC,EAA2CN,KAAK,CAACuD,SAAjD;IACH;;IACD,WAAKlB,gBAAL,CAAsBzB,GAAtB,CAA0BL,GAA1B,EAA+BD,QAA/B;;IACA,WAAKiC,iBAAL,CAAuB3B,GAAvB,CAA2BL,GAA3B,EAAgC4C,SAAhC;;IACA,UAAIF,eAAe,CAAC3B,MAAhB,GAAyB,CAA7B,EAAgC;IAC5B,cAAMkC,cAAc,GAAI,8CAAD,GAClB,SAAQP,eAAe,CAACQ,IAAhB,CAAqB,IAArB,CAA2B,gCADjB,GAElB,0CAFL;;IAGA,QAKK;IACDzC,UAAAA,gBAAM,CAAC0C,IAAP,CAAYF,cAAZ;IACH;IACJ;IACJ;IACJ;IACD;;;;;;;;;;;;IAUA,QAAMG,OAAN,CAAc;IAAEC,IAAAA,KAAF;IAASrE,IAAAA;IAAT,MAAqB,EAAnC,EAAuC;IACnC,IAA2C;IACvC,UAAIA,OAAJ,EAAa;IACToD,QAAAA,gBAAM,CAACC,OAAP,CAAerD,OAAf,EAAwB;IACpBsD,UAAAA,UAAU,EAAE,oBADQ;IAEpBC,UAAAA,SAAS,EAAE,oBAFS;IAGpBC,UAAAA,QAAQ,EAAE,SAHU;IAIpBC,UAAAA,SAAS,EAAE;IAJS,SAAxB;IAMH;IACJ;;IACD,UAAMa,aAAa,GAAG,EAAtB;IACA,UAAMC,gBAAgB,GAAG,EAAzB;IACA,UAAMC,KAAK,GAAG,MAAM3E,IAAI,CAAC4E,MAAL,CAAYC,IAAZ,CAAiB,KAAK/B,UAAtB,CAApB;IACA,UAAMgC,qBAAqB,GAAG,MAAMH,KAAK,CAACI,IAAN,EAApC;IACA,UAAMC,iBAAiB,GAAG,IAAIC,GAAJ,CAAQH,qBAAqB,CAACI,GAAtB,CAA2BC,OAAD,IAAaA,OAAO,CAAChE,GAA/C,CAAR,CAA1B;;IACA,SAAK,MAAM,CAACA,GAAD,EAAMD,QAAN,CAAX,IAA8B,KAAK+B,gBAAnC,EAAqD;IACjD,UAAI+B,iBAAiB,CAAChB,GAAlB,CAAsB9C,QAAtB,CAAJ,EAAqC;IACjCwD,QAAAA,gBAAgB,CAAClE,IAAjB,CAAsBW,GAAtB;IACH,OAFD,MAGK;IACDsD,QAAAA,aAAa,CAACjE,IAAd,CAAmB;IAAEU,UAAAA,QAAF;IAAYC,UAAAA;IAAZ,SAAnB;IACH;IACJ;;IACD,UAAMiE,gBAAgB,GAAGX,aAAa,CAACS,GAAd,CAAkB,CAAC;IAAEhE,MAAAA,QAAF;IAAYC,MAAAA;IAAZ,KAAD,KAAuB;IAC9D,YAAMgD,SAAS,GAAG,KAAKf,uBAAL,CAA6B/C,GAA7B,CAAiCa,QAAjC,CAAlB;;IACA,YAAM6C,SAAS,GAAG,KAAKZ,iBAAL,CAAuB9C,GAAvB,CAA2Bc,GAA3B,CAAlB;;IACA,aAAO,KAAKkE,cAAL,CAAoB;IACvBnE,QAAAA,QADuB;IAEvB6C,QAAAA,SAFuB;IAGvBS,QAAAA,KAHuB;IAIvBL,QAAAA,SAJuB;IAKvBhE,QAAAA,OALuB;IAMvBgB,QAAAA;IANuB,OAApB,CAAP;IAQH,KAXwB,CAAzB;IAYA,UAAMmE,OAAO,CAACC,GAAR,CAAYH,gBAAZ,CAAN;IACA,UAAMI,WAAW,GAAGf,aAAa,CAACS,GAAd,CAAmBO,IAAD,IAAUA,IAAI,CAACtE,GAAjC,CAApB;;IACA,IAA2C;IACvCkB,MAAAA,mBAAmB,CAACmD,WAAD,EAAcd,gBAAd,CAAnB;IACH;;IACD,WAAO;IACHc,MAAAA,WADG;IAEHE,MAAAA,cAAc,EAAEhB;IAFb,KAAP;IAIH;IACD;;;;;;;;IAMA,QAAMiB,QAAN,GAAiB;IACb,UAAMhB,KAAK,GAAG,MAAM3E,IAAI,CAAC4E,MAAL,CAAYC,IAAZ,CAAiB,KAAK/B,UAAtB,CAApB;IACA,UAAM8C,uBAAuB,GAAG,MAAMjB,KAAK,CAACI,IAAN,EAAtC;IACA,UAAMc,iBAAiB,GAAG,IAAIZ,GAAJ,CAAQ,KAAKhC,gBAAL,CAAsB6C,MAAtB,EAAR,CAA1B;IACA,UAAMnE,WAAW,GAAG,EAApB;;IACA,SAAK,MAAMwD,OAAX,IAAsBS,uBAAtB,EAA+C;IAC3C,UAAI,CAACC,iBAAiB,CAAC7B,GAAlB,CAAsBmB,OAAO,CAAChE,GAA9B,CAAL,EAAyC;IACrC,cAAMwD,KAAK,CAACoB,MAAN,CAAaZ,OAAb,CAAN;IACAxD,QAAAA,WAAW,CAACnB,IAAZ,CAAiB2E,OAAO,CAAChE,GAAzB;IACH;IACJ;;IACD,IAA2C;IACvCa,MAAAA,mBAAmB,CAACL,WAAD,CAAnB;IACH;;IACD,WAAO;IAAEA,MAAAA;IAAF,KAAP;IACH;IACD;;;;;;;;;;;;;;;;;;;;;;IAoBA,QAAM0D,cAAN,CAAqB;IAAEnE,IAAAA,QAAF;IAAYC,IAAAA,GAAZ;IAAiB4C,IAAAA,SAAjB;IAA4BS,IAAAA,KAA5B;IAAmCrE,IAAAA,OAAnC;IAA4CgE,IAAAA;IAA5C,GAArB,EAA8E;IAC1E,UAAMgB,OAAO,GAAG,IAAIa,OAAJ,CAAY7E,GAAZ,EAAiB;IAC7BgD,MAAAA,SAD6B;IAE7BQ,MAAAA,KAAK,EAAEZ,SAFsB;IAG7BkC,MAAAA,WAAW,EAAE;IAHgB,KAAjB,CAAhB;IAKA,QAAIC,QAAQ,GAAG,MAAMC,4BAAY,CAACC,KAAb,CAAmB;IACpC5B,MAAAA,KADoC;IAEpCrE,MAAAA,OAFoC;IAGpCgF,MAAAA;IAHoC,KAAnB,CAArB,CAN0E;IAY1E;IACA;;IACA,QAAIkB,qBAAJ;;IACA,SAAK,MAAMC,MAAX,IAAsBnG,OAAO,IAAI,EAAjC,EAAsC;IAClC,UAAI,qBAAqBmG,MAAzB,EAAiC;IAC7BD,QAAAA,qBAAqB,GAAGC,MAAxB;IACH;IACJ;;IACD,UAAMC,eAAe,GAAGF,qBAAqB;IAEzC;IACA;IACA,UAAMA,qBAAqB,CAACG,eAAtB,CAAsC;IAAEhC,MAAAA,KAAF;IAASW,MAAAA,OAAT;IAAkBe,MAAAA;IAAlB,KAAtC,CAJmC;IAMzC;IACAA,IAAAA,QAAQ,CAACO,MAAT,GAAkB,GAPtB,CApB0E;IA6B1E;;IACA,QAAI,CAACF,eAAL,EAAsB;IAClB,YAAM,IAAI1F,4BAAJ,CAAiB,yBAAjB,EAA4C;IAC9CM,QAAAA,GAD8C;IAE9CsF,QAAAA,MAAM,EAAEP,QAAQ,CAACO;IAF6B,OAA5C,CAAN;IAIH,KAnCyE;IAqC1E;IACA;IACA;;;IACA,QAAIP,QAAQ,CAACQ,UAAb,EAAyB;IACrBR,MAAAA,QAAQ,GAAG,MAAMS,4BAAY,CAACT,QAAD,CAA7B;IACH;;IACD,UAAMU,4BAAY,CAACC,GAAb,CAAiB;IACnBrC,MAAAA,KADmB;IAEnBrE,MAAAA,OAFmB;IAGnB+F,MAAAA,QAHmB;IAInB;IACAf,MAAAA,OAAO,EAAEjE,QAAQ,KAAKC,GAAb,GAAmBgE,OAAnB,GAA6B,IAAIa,OAAJ,CAAY9E,QAAZ,CALnB;IAMnB2B,MAAAA,SAAS,EAAE,KAAKC,UANG;IAOnBgE,MAAAA,YAAY,EAAE;IACVC,QAAAA,YAAY,EAAE;IADJ;IAPK,KAAjB,CAAN;IAWH;IACD;;;;;;;;IAMAC,EAAAA,kBAAkB,GAAG;IACjB,WAAO,KAAK/D,gBAAZ;IACH;IACD;;;;;;;;IAMAgE,EAAAA,aAAa,GAAG;IACZ,WAAO,CAAC,GAAG,KAAKhE,gBAAL,CAAsB8B,IAAtB,EAAJ,CAAP;IACH;IACD;;;;;;;;;;;IASAmC,EAAAA,iBAAiB,CAAC/F,GAAD,EAAM;IACnB,UAAML,SAAS,GAAG,IAAIC,GAAJ,CAAQI,GAAR,EAAaH,QAAQ,CAACC,IAAtB,CAAlB;IACA,WAAO,KAAKgC,gBAAL,CAAsB5C,GAAtB,CAA0BS,SAAS,CAACG,IAApC,CAAP;IACH;IACD;;;;;;;;;;;;;;;;;;;IAiBA,QAAMkG,aAAN,CAAoBhC,OAApB,EAA6B;IACzB,UAAMhE,GAAG,GAAGgE,OAAO,YAAYa,OAAnB,GAA6Bb,OAAO,CAAChE,GAArC,GAA2CgE,OAAvD;IACA,UAAMjE,QAAQ,GAAG,KAAKgG,iBAAL,CAAuB/F,GAAvB,CAAjB;;IACA,QAAID,QAAJ,EAAc;IACV,YAAMyD,KAAK,GAAG,MAAM3E,IAAI,CAAC4E,MAAL,CAAYC,IAAZ,CAAiB,KAAK/B,UAAtB,CAApB;IACA,aAAO6B,KAAK,CAACyC,KAAN,CAAYlG,QAAZ,CAAP;IACH;;IACD,WAAO4C,SAAP;IACH;IACD;;;;;;;;;;;;;;;IAaAuD,EAAAA,aAAa,CAACC,iBAAiB,GAAG,IAArB,EAA2B;IACpC,WAAO,OAAO;IAAEnC,MAAAA;IAAF,KAAP,KAAuB;IAC1B,UAAI;IACA,cAAMe,QAAQ,GAAG,MAAM,KAAKiB,aAAL,CAAmBhC,OAAnB,CAAvB;;IACA,YAAIe,QAAJ,EAAc;IACV,iBAAOA,QAAP;IACH,SAJD;IAMA;;;IACA,cAAM,IAAIrF,4BAAJ,CAAiB,wBAAjB,EAA2C;IAC7CgC,UAAAA,SAAS,EAAE,KAAKC,UAD6B;IAE7C3B,UAAAA,GAAG,EAAEgE,OAAO,YAAYa,OAAnB,GAA6Bb,OAAO,CAAChE,GAArC,GAA2CgE;IAFH,SAA3C,CAAN;IAIH,OAXD,CAYA,OAAOoC,KAAP,EAAc;IACV,YAAID,iBAAJ,EAAuB;IACnB,UAA2C;IACvC1F,YAAAA,gBAAM,CAAC4F,KAAP,CAAc,6CAAD,GACR,0BADL,EACgCD,KADhC;IAEH;;IACD,iBAAOnB,KAAK,CAACjB,OAAD,CAAZ;IACH;;IACD,cAAMoC,KAAN;IACH;IACJ,KAvBD;IAwBH;IACD;;;;;;;;;;;;;;;;IAcAE,EAAAA,uBAAuB,CAACtG,GAAD,EAAMmG,iBAAiB,GAAG,IAA1B,EAAgC;IACnD,UAAMpG,QAAQ,GAAG,KAAKgG,iBAAL,CAAuB/F,GAAvB,CAAjB;;IACA,QAAI,CAACD,QAAL,EAAe;IACX,YAAM,IAAIL,4BAAJ,CAAiB,mBAAjB,EAAsC;IAAEM,QAAAA;IAAF,OAAtC,CAAN;IACH;;IACD,UAAMuG,OAAO,GAAG,KAAKL,aAAL,CAAmBC,iBAAnB,CAAhB;IACA,UAAMnC,OAAO,GAAG,IAAIa,OAAJ,CAAY7E,GAAZ,CAAhB;IACA,WAAO,MAAMuG,OAAO,CAAC;IAAEvC,MAAAA;IAAF,KAAD,CAApB;IACH;;IA1VoB;;ICvBzB;;;;;;;AAOA,IAEA,IAAIwC,kBAAJ;IACA;;;;;AAIA,IAAO,MAAMC,6BAA6B,GAAG,MAAM;IAC/C,MAAI,CAACD,kBAAL,EAAyB;IACrBA,IAAAA,kBAAkB,GAAG,IAAIhF,kBAAJ,EAArB;IACH;;IACD,SAAOgF,kBAAP;IACH,CALM;;ICdP;;;;;;;AAOA,IACA;;;;;;;;;;;;;AAYA,IAAO,SAASE,yBAAT,CAAmC/G,SAAnC,EAA8CgH,2BAA2B,GAAG,EAA5E,EAAgF;IACnF;IACA;IACA,OAAK,MAAMlE,SAAX,IAAwB,CAAC,GAAG9C,SAAS,CAACS,YAAV,CAAuBwD,IAAvB,EAAJ,CAAxB,EAA4D;IACxD,QAAI+C,2BAA2B,CAACC,IAA5B,CAAkCC,MAAD,IAAYA,MAAM,CAACC,IAAP,CAAYrE,SAAZ,CAA7C,CAAJ,EAA0E;IACtE9C,MAAAA,SAAS,CAACS,YAAV,CAAuBwE,MAAvB,CAA8BnC,SAA9B;IACH;IACJ;;IACD,SAAO9C,SAAP;IACH;;IC7BD;;;;;;;AAOA,IAEA;;;;;;;;;;;AAUA,IAAO,UAAUoH,qBAAV,CAAgC/G,GAAhC,EAAqC;IAAE2G,EAAAA,2BAAF;IAA+BK,EAAAA,cAA/B;IAA+CC,EAAAA,SAA/C;IAA0DC,EAAAA;IAA1D,IAA+E,EAApH,EAAwH;IAC3H,QAAMvH,SAAS,GAAG,IAAIC,GAAJ,CAAQI,GAAR,EAAaH,QAAQ,CAACC,IAAtB,CAAlB;IACAH,EAAAA,SAAS,CAACwH,IAAV,GAAiB,EAAjB;IACA,QAAMxH,SAAS,CAACG,IAAhB;IACA,QAAMsH,uBAAuB,GAAGV,yBAAyB,CAAC/G,SAAD,EAAYgH,2BAAZ,CAAzD;IACA,QAAMS,uBAAuB,CAACtH,IAA9B;;IACA,MAAIkH,cAAc,IAAII,uBAAuB,CAACC,QAAxB,CAAiCC,QAAjC,CAA0C,GAA1C,CAAtB,EAAsE;IAClE,UAAMC,YAAY,GAAG,IAAI3H,GAAJ,CAAQwH,uBAAuB,CAACtH,IAAhC,CAArB;IACAyH,IAAAA,YAAY,CAACF,QAAb,IAAyBL,cAAzB;IACA,UAAMO,YAAY,CAACzH,IAAnB;IACH;;IACD,MAAImH,SAAJ,EAAe;IACX,UAAMO,QAAQ,GAAG,IAAI5H,GAAJ,CAAQwH,uBAAuB,CAACtH,IAAhC,CAAjB;IACA0H,IAAAA,QAAQ,CAACH,QAAT,IAAqB,OAArB;IACA,UAAMG,QAAQ,CAAC1H,IAAf;IACH;;IACD,MAAIoH,eAAJ,EAAqB;IACjB,UAAMO,cAAc,GAAGP,eAAe,CAAC;IAAElH,MAAAA,GAAG,EAAEL;IAAP,KAAD,CAAtC;;IACA,SAAK,MAAM+H,YAAX,IAA2BD,cAA3B,EAA2C;IACvC,YAAMC,YAAY,CAAC5H,IAAnB;IACH;IACJ;IACJ;;ICzCD;;;;;;;AAOA,IAGA;;;;;;;;;;;;AAWA,IAAO,MAAMiG,iBAAiB,GAAG,CAAC/F,GAAD,EAAM2H,OAAN,KAAkB;IAC/C,QAAMnB,kBAAkB,GAAGC,6BAA6B,EAAxD;IACA,QAAMmB,eAAe,GAAGpB,kBAAkB,CAACX,kBAAnB,EAAxB;;IACA,OAAK,MAAMgC,WAAX,IAA0Bd,qBAAqB,CAAC/G,GAAD,EAAM2H,OAAN,CAA/C,EAA+D;IAC3D,UAAMG,gBAAgB,GAAGF,eAAe,CAAC1I,GAAhB,CAAoB2I,WAApB,CAAzB;;IACA,QAAIC,gBAAJ,EAAsB;IAClB,aAAOA,gBAAP;IACH;IACJ;IACJ,CATM;;ICrBP;;;;;;;AAOA,IAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,IAAO,MAAMC,gBAAgB,GAAG,CAAC;IAAEpB,EAAAA,2BAA2B,GAAG,CAAC,OAAD,CAAhC;IAA2CK,EAAAA,cAAc,GAAG,YAA5D;IAA0EC,EAAAA,SAAS,GAAG,IAAtF;IAA4FC,EAAAA;IAA5F,IAAiH,EAAlH,KAAyH;IACrJ,QAAMxF,SAAS,GAAGE,wBAAU,CAACC,eAAX,EAAlB,CADqJ;;IAGrJhD,EAAAA,IAAI,CAACmJ,gBAAL,CAAsB,OAAtB,EAAiC3E,KAAD,IAAW;IACvC,UAAM4E,YAAY,GAAGlC,iBAAiB,CAAC1C,KAAK,CAACW,OAAN,CAAchE,GAAf,EAAoB;IACtDiH,MAAAA,SADsD;IAEtDD,MAAAA,cAFsD;IAGtDL,MAAAA,2BAHsD;IAItDO,MAAAA;IAJsD,KAApB,CAAtC;;IAMA,QAAI,CAACe,YAAL,EAAmB;IACf,MAA2C;IACvCxH,QAAAA,gBAAM,CAAC4F,KAAP,CAAc,sCAAD,GACT6B,gCAAc,CAAC7E,KAAK,CAACW,OAAN,CAAchE,GAAf,CADlB;IAEH;;IACD;IACH;;IACD,QAAImI,eAAe,GAAGtJ,IAAI,CAAC4E,MAAL,CAAYC,IAAZ,CAAiBhC,SAAjB,EAA4B0G,IAA5B,CAAkC5E,KAAD,IAAW;IAC9D,aAAOA,KAAK,CAACyC,KAAN,CAAYgC,YAAZ,CAAP;IACH,KAFqB,EAEnBG,IAFmB,CAEbC,cAAD,IAAoB;IACxB,UAAIA,cAAJ,EAAoB;IAChB,eAAOA,cAAP;IACH,OAHuB;IAKxB;;;IACA,MAA2C;IACvC5H,QAAAA,gBAAM,CAAC0C,IAAP,CAAa,6BAAD,GACP,GAAE+E,gCAAc,CAACD,YAAD,CAAe,OAAMvG,SAAU,kBADxC,GAEP,sCAFL;IAGH;;IACD,aAAOuD,KAAK,CAACgD,YAAD,CAAZ;IACH,KAdqB,CAAtB;;IAeA,IAA2C;IACvCE,MAAAA,eAAe,GAAGA,eAAe,CAACC,IAAhB,CAAsBrD,QAAD,IAAc;IACjD;IACA;IACAtE,QAAAA,gBAAM,CAACC,cAAP,CAAuB,+BAAD,GAClBwH,gCAAc,CAAC7E,KAAK,CAACW,OAAN,CAAchE,GAAf,CADlB;IAEAS,QAAAA,gBAAM,CAACE,GAAP,CAAY,8BAA6BsH,YAAa,EAAtD;IACAxH,QAAAA,gBAAM,CAACC,cAAP,CAAuB,4BAAvB;IACAD,QAAAA,gBAAM,CAACE,GAAP,CAAW0C,KAAK,CAACW,OAAjB;IACAvD,QAAAA,gBAAM,CAACG,QAAP;IACAH,QAAAA,gBAAM,CAACC,cAAP,CAAuB,6BAAvB;IACAD,QAAAA,gBAAM,CAACE,GAAP,CAAWoE,QAAX;IACAtE,QAAAA,gBAAM,CAACG,QAAP;IACAH,QAAAA,gBAAM,CAACG,QAAP;IACA,eAAOmE,QAAP;IACH,OAdiB,CAAlB;IAeH;;IACD1B,IAAAA,KAAK,CAACiF,WAAN,CAAkBH,eAAlB;IACH,GA/CD;IAgDH,CAnDM;;ICvCP;;;;;;AAMA,IAEA,IAAII,aAAa,GAAG,KAApB;IACA;;;;;;;;;;;;;;;;;;;;;;;;;IAwBA,SAASC,QAAT,CAAkBb,OAAlB,EAA2B;IACvB,MAAI,CAACY,aAAL,EAAoB;IAChBR,IAAAA,gBAAgB,CAACJ,OAAD,CAAhB;IACAY,IAAAA,aAAa,GAAG,IAAhB;IACH;IACJ;;ICtCD;;;;;;;AAOA,IACA,MAAME,iBAAiB,GAAG,YAA1B;IACA;;;;;;;;;;;;;;;;;;;IAkBA,MAAMC,oBAAoB,GAAG,OAAOC,mBAAP,EAA4BC,eAAe,GAAGH,iBAA9C,KAAoE;IAC7F,QAAM7G,UAAU,GAAG,MAAM/C,IAAI,CAAC4E,MAAL,CAAYG,IAAZ,EAAzB;IACA,QAAMiF,kBAAkB,GAAGjH,UAAU,CAACkH,MAAX,CAAmBpH,SAAD,IAAe;IACxD,WAAOA,SAAS,CAACqH,QAAV,CAAmBH,eAAnB,KACHlH,SAAS,CAACqH,QAAV,CAAmBlK,IAAI,CAACmK,YAAL,CAAkBC,KAArC,CADG,IAEHvH,SAAS,KAAKiH,mBAFlB;IAGH,GAJ0B,CAA3B;IAKA,QAAMxE,OAAO,CAACC,GAAR,CAAYyE,kBAAkB,CAAC9E,GAAnB,CAAwBrC,SAAD,IAAe7C,IAAI,CAAC4E,MAAL,CAAYmB,MAAZ,CAAmBlD,SAAnB,CAAtC,CAAZ,CAAN;IACA,SAAOmH,kBAAP;IACH,CATD;;IC3BA;;;;;;;AAOA,IAIA;;;;;;;IAMA,SAASK,qBAAT,GAAiC;IAC7B;IACArK,EAAAA,IAAI,CAACmJ,gBAAL,CAAsB,UAAtB,EAAoC3E,KAAD,IAAW;IAC1C,UAAM3B,SAAS,GAAGE,wBAAU,CAACC,eAAX,EAAlB;IACAwB,IAAAA,KAAK,CAAC8F,SAAN,CAAgBT,oBAAoB,CAAChH,SAAD,CAApB,CAAgC0G,IAAhC,CAAsCgB,aAAD,IAAmB;IACpE,MAA2C;IACvC,YAAIA,aAAa,CAACrI,MAAd,GAAuB,CAA3B,EAA8B;IAC1BN,UAAAA,gBAAM,CAACE,GAAP,CAAY,sDAAD,GACN,gBADL,EACsByI,aADtB;IAEH;IACJ;IACJ,KAPe,CAAhB;IAQH,GAVD;IAWH;;IC9BD;;;;;;;AAOA,IAEA;;;;;;;;;;;;;;;;IAeA,SAASlD,aAAT,CAAuBC,iBAAiB,GAAG,IAA3C,EAAiD;IAC7C,QAAMK,kBAAkB,GAAGC,6BAA6B,EAAxD;IACA,SAAOD,kBAAkB,CAACN,aAAnB,CAAiCC,iBAAjC,CAAP;IACH;;IC3BD;;;;;;;AAOA,IAEA;;;;;;;;;;;;;;;;;;IAiBA,SAASG,uBAAT,CAAiCtG,GAAjC,EAAsC;IAClC,QAAMwG,kBAAkB,GAAGC,6BAA6B,EAAxD;IACA,SAAOD,kBAAkB,CAACF,uBAAnB,CAA2CtG,GAA3C,CAAP;IACH;;IC7BD;;;;;;;AAOA,IAEA;;;;;;;;;;;;;;;;;;;;IAmBA,SAAS+F,mBAAT,CAA2B/F,GAA3B,EAAgC;IAC5B,QAAMwG,kBAAkB,GAAGC,6BAA6B,EAAxD;IACA,SAAOD,kBAAkB,CAACT,iBAAnB,CAAqC/F,GAArC,CAAP;IACH;;IC/BD;;;;;;;AAOA,IAEA;;;;;;;;;;;;;;;;IAeA,SAASgG,aAAT,CAAuBhC,OAAvB,EAAgC;IAC5B,QAAMwC,kBAAkB,GAAGC,6BAA6B,EAAxD;IACA,SAAOD,kBAAkB,CAACR,aAAnB,CAAiChC,OAAjC,CAAP;IACH;;IC3BD;;;;;;;AAOA;IAIA,MAAMqF,eAAe,GAAIhG,KAAD,IAAW;IAC/B,QAAMmD,kBAAkB,GAAGC,6BAA6B,EAAxD;IACA,QAAMzH,OAAO,GAAGC,eAAe,CAACC,GAAhB,EAAhB;IACAmE,EAAAA,KAAK,CAAC8F,SAAN,CAAgB3C,kBAAkB,CAACpD,OAAnB,CAA2B;IAAEC,IAAAA,KAAF;IAASrE,IAAAA;IAAT,GAA3B,EACXsK,KADW,CACJlD,KAAD,IAAW;IAClB,IAA2C;IACvC3F,MAAAA,gBAAM,CAAC2F,KAAP,CAAc,8CAAD,GACR,sDADL;IAEH,KAJiB;;;IAMlB,UAAMA,KAAN;IACH,GARe,CAAhB;IASH,CAZD;;IAaA,MAAMmD,gBAAgB,GAAIlG,KAAD,IAAW;IAChC,QAAMmD,kBAAkB,GAAGC,6BAA6B,EAAxD;IACApD,EAAAA,KAAK,CAAC8F,SAAN,CAAgB3C,kBAAkB,CAAChC,QAAnB,EAAhB;IACH,CAHD;IAIA;;;;;;;;;;;;;;;;;;;;;IAmBA,SAASgF,QAAT,CAAkBrH,OAAlB,EAA2B;IACvB,QAAMqE,kBAAkB,GAAGC,6BAA6B,EAAxD;IACAD,EAAAA,kBAAkB,CAACtE,cAAnB,CAAkCC,OAAlC;;IACA,MAAIA,OAAO,CAACpB,MAAR,GAAiB,CAArB,EAAwB;IACpB;IACA;IACA;IACA;IACAlC,IAAAA,IAAI,CAACmJ,gBAAL,CAAsB,SAAtB,EAAiCqB,eAAjC;IACAxK,IAAAA,IAAI,CAACmJ,gBAAL,CAAsB,UAAtB,EAAkCuB,gBAAlC;IACH;IACJ;;IC1DD;;;;;;;AAOA,IAGA;;;;;;;;;;;;;;;IAcA,SAASE,gBAAT,CAA0BtH,OAA1B,EAAmCwF,OAAnC,EAA4C;IACxC6B,EAAAA,QAAQ,CAACrH,OAAD,CAAR;IACAqG,EAAAA,QAAQ,CAACb,OAAD,CAAR;IACH;;;;;;;;;;;;;;;;;;;"}

data/lib/vendor/workbox-v5.1.4/workbox-precaching.prod.js

@@ -0,0 +1,2 @@
+this.workbox=this.workbox||{},this.workbox.precaching=function(t,e,n,i,s,c){"use strict";try{self["workbox:precaching:5.1.4"]&&_()}catch(t){}const r=[],o={get:()=>r,add(t){r.push(...t)}};function a(t){if(!t)throw new s.WorkboxError("add-to-cache-list-unexpected-type",{entry:t});if("string"==typeof t){const e=new URL(t,location.href);return{cacheKey:e.href,url:e.href}}const{revision:e,url:n}=t;if(!n)throw new s.WorkboxError("add-to-cache-list-unexpected-type",{entry:t});if(!e){const t=new URL(n,location.href);return{cacheKey:t.href,url:t.href}}const i=new URL(n,location.href),c=new URL(n,location.href);return i.searchParams.set("__WB_REVISION__",e),{cacheKey:i.href,url:c.href}}class h{constructor(t){this.t=e.cacheNames.getPrecacheName(t),this.i=new Map,this.s=new Map,this.o=new Map}addToCacheList(t){const e=[];for(const n of t){"string"==typeof n?e.push(n):n&&void 0===n.revision&&e.push(n.url);const{cacheKey:t,url:i}=a(n),c="string"!=typeof n&&n.revision?"reload":"default";if(this.i.has(i)&&this.i.get(i)!==t)throw new s.WorkboxError("add-to-cache-list-conflicting-entries",{firstEntry:this.i.get(i),secondEntry:t});if("string"!=typeof n&&n.integrity){if(this.o.has(t)&&this.o.get(t)!==n.integrity)throw new s.WorkboxError("add-to-cache-list-conflicting-integrities",{url:i});this.o.set(t,n.integrity)}if(this.i.set(i,t),this.s.set(i,c),e.length>0){const t=`Workbox is precaching URLs without revision info: ${e.join(", ")}\nThis is generally NOT safe. Learn more at https://bit.ly/wb-precache`;console.warn(t)}}}async install({event:t,plugins:e}={}){const n=[],i=[],s=await self.caches.open(this.t),c=await s.keys(),r=new Set(c.map(t=>t.url));for(const[t,e]of this.i)r.has(e)?i.push(t):n.push({cacheKey:e,url:t});const o=n.map(({cacheKey:n,url:i})=>{const s=this.o.get(n),c=this.s.get(i);return this.h({cacheKey:n,cacheMode:c,event:t,integrity:s,plugins:e,url:i})});await Promise.all(o);return{updatedURLs:n.map(t=>t.url),notUpdatedURLs:i}}async activate(){const t=await self.caches.open(this.t),e=await t.keys(),n=new Set(this.i.values()),i=[];for(const s of e)n.has(s.url)||(await t.delete(s),i.push(s.url));return{deletedURLs:i}}async h({cacheKey:t,url:e,cacheMode:r,event:o,plugins:a,integrity:h}){const u=new Request(e,{integrity:h,cache:r,credentials:"same-origin"});let l,f=await i.fetchWrapper.fetch({event:o,plugins:a,request:u});for(const t of a||[])"cacheWillUpdate"in t&&(l=t);if(!(l?await l.cacheWillUpdate({event:o,request:u,response:f}):f.status<400))throw new s.WorkboxError("bad-precaching-response",{url:e,status:f.status});f.redirected&&(f=await c.copyResponse(f)),await n.cacheWrapper.put({event:o,plugins:a,response:f,request:t===e?u:new Request(t),cacheName:this.t,matchOptions:{ignoreSearch:!0}})}getURLsToCacheKeys(){return this.i}getCachedURLs(){return[...this.i.keys()]}getCacheKeyForURL(t){const e=new URL(t,location.href);return this.i.get(e.href)}async matchPrecache(t){const e=t instanceof Request?t.url:t,n=this.getCacheKeyForURL(e);if(n){return(await self.caches.open(this.t)).match(n)}}createHandler(t=!0){return async({request:e})=>{try{const t=await this.matchPrecache(e);if(t)return t;throw new s.WorkboxError("missing-precache-entry",{cacheName:this.t,url:e instanceof Request?e.url:e})}catch(n){if(t)return fetch(e);throw n}}}createHandlerBoundToURL(t,e=!0){if(!this.getCacheKeyForURL(t))throw new s.WorkboxError("non-precached-url",{url:t});const n=this.createHandler(e),i=new Request(t);return()=>n({request:i})}}let u;const l=()=>(u||(u=new h),u);const f=(t,e)=>{const n=l().getURLsToCacheKeys();for(const i of function*(t,{ignoreURLParametersMatching:e,directoryIndex:n,cleanURLs:i,urlManipulation:s}={}){const c=new URL(t,location.href);c.hash="",yield c.href;const r=function(t,e=[]){for(const n of[...t.searchParams.keys()])e.some(t=>t.test(n))&&t.searchParams.delete(n);return t}(c,e);if(yield r.href,n&&r.pathname.endsWith("/")){const t=new URL(r.href);t.pathname+=n,yield t.href}if(i){const t=new URL(r.href);t.pathname+=".html",yield t.href}if(s){const t=s({url:c});for(const e of t)yield e.href}}(t,e)){const t=n.get(i);if(t)return t}};let w=!1;function d(t){w||((({ignoreURLParametersMatching:t=[/^utm_/],directoryIndex:n="index.html",cleanURLs:i=!0,urlManipulation:s}={})=>{const c=e.cacheNames.getPrecacheName();self.addEventListener("fetch",e=>{const r=f(e.request.url,{cleanURLs:i,directoryIndex:n,ignoreURLParametersMatching:t,urlManipulation:s});if(!r)return;let o=self.caches.open(c).then(t=>t.match(r)).then(t=>t||fetch(r));e.respondWith(o)})})(t),w=!0)}const y=t=>{const e=l(),n=o.get();t.waitUntil(e.install({event:t,plugins:n}).catch(t=>{throw t}))},p=t=>{const e=l();t.waitUntil(e.activate())};function g(t){l().addToCacheList(t),t.length>0&&(self.addEventListener("install",y),self.addEventListener("activate",p))}return t.PrecacheController=h,t.addPlugins=function(t){o.add(t)},t.addRoute=d,t.cleanupOutdatedCaches=function(){self.addEventListener("activate",t=>{const n=e.cacheNames.getPrecacheName();t.waitUntil((async(t,e="-precache-")=>{const n=(await self.caches.keys()).filter(n=>n.includes(e)&&n.includes(self.registration.scope)&&n!==t);return await Promise.all(n.map(t=>self.caches.delete(t))),n})(n).then(t=>{}))})},t.createHandler=function(t=!0){return l().createHandler(t)},t.createHandlerBoundToURL=function(t){return l().createHandlerBoundToURL(t)},t.getCacheKeyForURL=function(t){return l().getCacheKeyForURL(t)},t.matchPrecache=function(t){return l().matchPrecache(t)},t.precache=g,t.precacheAndRoute=function(t,e){g(t),d(e)},t}({},workbox.core._private,workbox.core._private,workbox.core._private,workbox.core._private,workbox.core);
+//# sourceMappingURL=workbox-precaching.prod.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workbox-precaching.prod.js","sources":["../_version.js","../utils/precachePlugins.js","../utils/createCacheKey.js","../PrecacheController.js","../utils/getOrCreatePrecacheController.js","../utils/getCacheKeyForURL.js","../utils/generateURLVariations.js","../utils/removeIgnoredSearchParams.js","../addRoute.js","../utils/addFetchListener.js","../precache.js","../addPlugins.js","../cleanupOutdatedCaches.js","../utils/deleteOutdatedCaches.js","../createHandler.js","../createHandlerBoundToURL.js","../getCacheKeyForURL.js","../matchPrecache.js","../precacheAndRoute.js"],"sourcesContent":["\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:precaching:5.1.4'] && _();\n}\ncatch (e) { }\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 '../_version.js';\nconst plugins = [];\nexport const precachePlugins = {\n    /*\n     * @return {Array}\n     * @private\n     */\n    get() {\n        return plugins;\n    },\n    /*\n     * @param {Array} newPlugins\n     * @private\n     */\n    add(newPlugins) {\n        plugins.push(...newPlugins);\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 { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport '../_version.js';\n// Name of the search parameter used to store revision info.\nconst REVISION_SEARCH_PARAM = '__WB_REVISION__';\n/**\n * Converts a manifest entry into a versioned URL suitable for precaching.\n *\n * @param {Object|string} entry\n * @return {string} A URL with versioning info.\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function createCacheKey(entry) {\n    if (!entry) {\n        throw new WorkboxError('add-to-cache-list-unexpected-type', { entry });\n    }\n    // If a precache manifest entry is a string, it's assumed to be a versioned\n    // URL, like '/app.abcd1234.js'. Return as-is.\n    if (typeof entry === 'string') {\n        const urlObject = new URL(entry, location.href);\n        return {\n            cacheKey: urlObject.href,\n            url: urlObject.href,\n        };\n    }\n    const { revision, url } = entry;\n    if (!url) {\n        throw new WorkboxError('add-to-cache-list-unexpected-type', { entry });\n    }\n    // If there's just a URL and no revision, then it's also assumed to be a\n    // versioned URL.\n    if (!revision) {\n        const urlObject = new URL(url, location.href);\n        return {\n            cacheKey: urlObject.href,\n            url: urlObject.href,\n        };\n    }\n    // Otherwise, construct a properly versioned URL using the custom Workbox\n    // search parameter along with the revision info.\n    const cacheKeyURL = new URL(url, location.href);\n    const originalURL = new URL(url, location.href);\n    cacheKeyURL.searchParams.set(REVISION_SEARCH_PARAM, revision);\n    return {\n        cacheKey: cacheKeyURL.href,\n        url: originalURL.href,\n    };\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 { 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 { logger } from 'workbox-core/_private/logger.js';\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { copyResponse } from 'workbox-core/copyResponse.js';\nimport { createCacheKey } from './utils/createCacheKey.js';\nimport { printCleanupDetails } from './utils/printCleanupDetails.js';\nimport { printInstallDetails } from './utils/printInstallDetails.js';\nimport './_version.js';\n/**\n * Performs efficient precaching of assets.\n *\n * @memberof module:workbox-precaching\n */\nclass PrecacheController {\n    /**\n     * Create a new PrecacheController.\n     *\n     * @param {string} [cacheName] An optional name for the cache, to override\n     * the default precache name.\n     */\n    constructor(cacheName) {\n        this._cacheName = cacheNames.getPrecacheName(cacheName);\n        this._urlsToCacheKeys = new Map();\n        this._urlsToCacheModes = new Map();\n        this._cacheKeysToIntegrities = new Map();\n    }\n    /**\n     * This method will add items to the precache list, removing duplicates\n     * and ensuring the information is valid.\n     *\n     * @param {\n     * Array<module:workbox-precaching.PrecacheController.PrecacheEntry|string>\n     * } entries Array of entries to precache.\n     */\n    addToCacheList(entries) {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isArray(entries, {\n                moduleName: 'workbox-precaching',\n                className: 'PrecacheController',\n                funcName: 'addToCacheList',\n                paramName: 'entries',\n            });\n        }\n        const urlsToWarnAbout = [];\n        for (const entry of entries) {\n            // See https://github.com/GoogleChrome/workbox/issues/2259\n            if (typeof entry === 'string') {\n                urlsToWarnAbout.push(entry);\n            }\n            else if (entry && entry.revision === undefined) {\n                urlsToWarnAbout.push(entry.url);\n            }\n            const { cacheKey, url } = createCacheKey(entry);\n            const cacheMode = (typeof entry !== 'string' && entry.revision) ?\n                'reload' : 'default';\n            if (this._urlsToCacheKeys.has(url) &&\n                this._urlsToCacheKeys.get(url) !== cacheKey) {\n                throw new WorkboxError('add-to-cache-list-conflicting-entries', {\n                    firstEntry: this._urlsToCacheKeys.get(url),\n                    secondEntry: cacheKey,\n                });\n            }\n            if (typeof entry !== 'string' && entry.integrity) {\n                if (this._cacheKeysToIntegrities.has(cacheKey) &&\n                    this._cacheKeysToIntegrities.get(cacheKey) !== entry.integrity) {\n                    throw new WorkboxError('add-to-cache-list-conflicting-integrities', {\n                        url,\n                    });\n                }\n                this._cacheKeysToIntegrities.set(cacheKey, entry.integrity);\n            }\n            this._urlsToCacheKeys.set(url, cacheKey);\n            this._urlsToCacheModes.set(url, cacheMode);\n            if (urlsToWarnAbout.length > 0) {\n                const warningMessage = `Workbox is precaching URLs without revision ` +\n                    `info: ${urlsToWarnAbout.join(', ')}\\nThis is generally NOT safe. ` +\n                    `Learn more at https://bit.ly/wb-precache`;\n                if (process.env.NODE_ENV === 'production') {\n                    // Use console directly to display this warning without bloating\n                    // bundle sizes by pulling in all of the logger codebase in prod.\n                    console.warn(warningMessage);\n                }\n                else {\n                    logger.warn(warningMessage);\n                }\n            }\n        }\n    }\n    /**\n     * Precaches new and updated assets. Call this method from the service worker\n     * install event.\n     *\n     * @param {Object} options\n     * @param {Event} [options.event] The install event (if needed).\n     * @param {Array<Object>} [options.plugins] Plugins to be used for fetching\n     * and caching during install.\n     * @return {Promise<module:workbox-precaching.InstallResult>}\n     */\n    async install({ event, plugins } = {}) {\n        if (process.env.NODE_ENV !== 'production') {\n            if (plugins) {\n                assert.isArray(plugins, {\n                    moduleName: 'workbox-precaching',\n                    className: 'PrecacheController',\n                    funcName: 'install',\n                    paramName: 'plugins',\n                });\n            }\n        }\n        const toBePrecached = [];\n        const alreadyPrecached = [];\n        const cache = await self.caches.open(this._cacheName);\n        const alreadyCachedRequests = await cache.keys();\n        const existingCacheKeys = new Set(alreadyCachedRequests.map((request) => request.url));\n        for (const [url, cacheKey] of this._urlsToCacheKeys) {\n            if (existingCacheKeys.has(cacheKey)) {\n                alreadyPrecached.push(url);\n            }\n            else {\n                toBePrecached.push({ cacheKey, url });\n            }\n        }\n        const precacheRequests = toBePrecached.map(({ cacheKey, url }) => {\n            const integrity = this._cacheKeysToIntegrities.get(cacheKey);\n            const cacheMode = this._urlsToCacheModes.get(url);\n            return this._addURLToCache({\n                cacheKey,\n                cacheMode,\n                event,\n                integrity,\n                plugins,\n                url,\n            });\n        });\n        await Promise.all(precacheRequests);\n        const updatedURLs = toBePrecached.map((item) => item.url);\n        if (process.env.NODE_ENV !== 'production') {\n            printInstallDetails(updatedURLs, alreadyPrecached);\n        }\n        return {\n            updatedURLs,\n            notUpdatedURLs: alreadyPrecached,\n        };\n    }\n    /**\n     * Deletes assets that are no longer present in the current precache manifest.\n     * Call this method from the service worker activate event.\n     *\n     * @return {Promise<module:workbox-precaching.CleanupResult>}\n     */\n    async activate() {\n        const cache = await self.caches.open(this._cacheName);\n        const currentlyCachedRequests = await cache.keys();\n        const expectedCacheKeys = new Set(this._urlsToCacheKeys.values());\n        const deletedURLs = [];\n        for (const request of currentlyCachedRequests) {\n            if (!expectedCacheKeys.has(request.url)) {\n                await cache.delete(request);\n                deletedURLs.push(request.url);\n            }\n        }\n        if (process.env.NODE_ENV !== 'production') {\n            printCleanupDetails(deletedURLs);\n        }\n        return { deletedURLs };\n    }\n    /**\n     * Requests the entry and saves it to the cache if the response is valid.\n     * By default, any response with a status code of less than 400 (including\n     * opaque responses) is considered valid.\n     *\n     * If you need to use custom criteria to determine what's valid and what\n     * isn't, then pass in an item in `options.plugins` that implements the\n     * `cacheWillUpdate()` lifecycle event.\n     *\n     * @private\n     * @param {Object} options\n     * @param {string} options.cacheKey The string to use a cache key.\n     * @param {string} options.url The URL to fetch and cache.\n     * @param {string} [options.cacheMode] The cache mode for the network request.\n     * @param {Event} [options.event] The install event (if passed).\n     * @param {Array<Object>} [options.plugins] An array of plugins to apply to\n     * fetch and caching.\n     * @param {string} [options.integrity] The value to use for the `integrity`\n     * field when making the request.\n     */\n    async _addURLToCache({ cacheKey, url, cacheMode, event, plugins, integrity }) {\n        const request = new Request(url, {\n            integrity,\n            cache: cacheMode,\n            credentials: 'same-origin',\n        });\n        let response = await fetchWrapper.fetch({\n            event,\n            plugins,\n            request,\n        });\n        // Allow developers to override the default logic about what is and isn't\n        // valid by passing in a plugin implementing cacheWillUpdate(), e.g.\n        // a `CacheableResponsePlugin` instance.\n        let cacheWillUpdatePlugin;\n        for (const plugin of (plugins || [])) {\n            if ('cacheWillUpdate' in plugin) {\n                cacheWillUpdatePlugin = plugin;\n            }\n        }\n        const isValidResponse = cacheWillUpdatePlugin ?\n            // Use a callback if provided. It returns a truthy value if valid.\n            // NOTE: invoke the method on the plugin instance so the `this` context\n            // is correct.\n            await cacheWillUpdatePlugin.cacheWillUpdate({ event, request, response }) :\n            // Otherwise, default to considering any response status under 400 valid.\n            // This includes, by default, considering opaque responses valid.\n            response.status < 400;\n        // Consider this a failure, leading to the `install` handler failing, if\n        // we get back an invalid response.\n        if (!isValidResponse) {\n            throw new WorkboxError('bad-precaching-response', {\n                url,\n                status: response.status,\n            });\n        }\n        // Redirected responses cannot be used to satisfy a navigation request, so\n        // any redirected response must be \"copied\" rather than cloned, so the new\n        // response doesn't contain the `redirected` flag. See:\n        // https://bugs.chromium.org/p/chromium/issues/detail?id=669363&desc=2#c1\n        if (response.redirected) {\n            response = await copyResponse(response);\n        }\n        await cacheWrapper.put({\n            event,\n            plugins,\n            response,\n            // `request` already uses `url`. We may be able to reuse it.\n            request: cacheKey === url ? request : new Request(cacheKey),\n            cacheName: this._cacheName,\n            matchOptions: {\n                ignoreSearch: true,\n            },\n        });\n    }\n    /**\n     * Returns a mapping of a precached URL to the corresponding cache key, taking\n     * into account the revision information for the URL.\n     *\n     * @return {Map<string, string>} A URL to cache key mapping.\n     */\n    getURLsToCacheKeys() {\n        return this._urlsToCacheKeys;\n    }\n    /**\n     * Returns a list of all the URLs that have been precached by the current\n     * service worker.\n     *\n     * @return {Array<string>} The precached URLs.\n     */\n    getCachedURLs() {\n        return [...this._urlsToCacheKeys.keys()];\n    }\n    /**\n     * Returns the cache key used for storing a given URL. If that URL is\n     * unversioned, like `/index.html', then the cache key will be the original\n     * URL with a search parameter appended to it.\n     *\n     * @param {string} url A URL whose cache key you want to look up.\n     * @return {string} The versioned URL that corresponds to a cache key\n     * for the original URL, or undefined if that URL isn't precached.\n     */\n    getCacheKeyForURL(url) {\n        const urlObject = new URL(url, location.href);\n        return this._urlsToCacheKeys.get(urlObject.href);\n    }\n    /**\n     * This acts as a drop-in replacement for [`cache.match()`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/match)\n     * with the following differences:\n     *\n     * - It knows what the name of the precache is, and only checks in that cache.\n     * - It allows you to pass in an \"original\" URL without versioning parameters,\n     * and it will automatically look up the correct cache key for the currently\n     * active revision of that URL.\n     *\n     * E.g., `matchPrecache('index.html')` will find the correct precached\n     * response for the currently active service worker, even if the actual cache\n     * key is `'/index.html?__WB_REVISION__=1234abcd'`.\n     *\n     * @param {string|Request} request The key (without revisioning parameters)\n     * to look up in the precache.\n     * @return {Promise<Response|undefined>}\n     */\n    async matchPrecache(request) {\n        const url = request instanceof Request ? request.url : request;\n        const cacheKey = this.getCacheKeyForURL(url);\n        if (cacheKey) {\n            const cache = await self.caches.open(this._cacheName);\n            return cache.match(cacheKey);\n        }\n        return undefined;\n    }\n    /**\n     * Returns a function that can be used within a\n     * {@link module:workbox-routing.Route} that will find a response for the\n     * incoming request against the precache.\n     *\n     * If for an unexpected reason there is a cache miss for the request,\n     * this will fall back to retrieving the `Response` via `fetch()` when\n     * `fallbackToNetwork` is `true`.\n     *\n     * @param {boolean} [fallbackToNetwork=true] Whether to attempt to get the\n     * response from the network if there's a precache miss.\n     * @return {module:workbox-routing~handlerCallback}\n     */\n    createHandler(fallbackToNetwork = true) {\n        return async ({ request }) => {\n            try {\n                const response = await this.matchPrecache(request);\n                if (response) {\n                    return response;\n                }\n                // This shouldn't normally happen, but there are edge cases:\n                // https://github.com/GoogleChrome/workbox/issues/1441\n                throw new WorkboxError('missing-precache-entry', {\n                    cacheName: this._cacheName,\n                    url: request instanceof Request ? request.url : request,\n                });\n            }\n            catch (error) {\n                if (fallbackToNetwork) {\n                    if (process.env.NODE_ENV !== 'production') {\n                        logger.debug(`Unable to respond with precached response. ` +\n                            `Falling back to network.`, error);\n                    }\n                    return fetch(request);\n                }\n                throw error;\n            }\n        };\n    }\n    /**\n     * Returns a function that looks up `url` in the precache (taking into\n     * account revision information), and returns the corresponding `Response`.\n     *\n     * If for an unexpected reason there is a cache miss when looking up `url`,\n     * this will fall back to retrieving the `Response` via `fetch()` when\n     * `fallbackToNetwork` is `true`.\n     *\n     * @param {string} url The precached URL which will be used to lookup the\n     * `Response`.\n     * @param {boolean} [fallbackToNetwork=true] Whether to attempt to get the\n     * response from the network if there's a precache miss.\n     * @return {module:workbox-routing~handlerCallback}\n     */\n    createHandlerBoundToURL(url, fallbackToNetwork = true) {\n        const cacheKey = this.getCacheKeyForURL(url);\n        if (!cacheKey) {\n            throw new WorkboxError('non-precached-url', { url });\n        }\n        const handler = this.createHandler(fallbackToNetwork);\n        const request = new Request(url);\n        return () => handler({ request });\n    }\n}\nexport { PrecacheController };\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 { PrecacheController } from '../PrecacheController.js';\nimport '../_version.js';\nlet precacheController;\n/**\n * @return {PrecacheController}\n * @private\n */\nexport const getOrCreatePrecacheController = () => {\n    if (!precacheController) {\n        precacheController = new PrecacheController();\n    }\n    return precacheController;\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 { getOrCreatePrecacheController } from './getOrCreatePrecacheController.js';\nimport { generateURLVariations } from './generateURLVariations.js';\nimport '../_version.js';\n/**\n * This function will take the request URL and manipulate it based on the\n * configuration options.\n *\n * @param {string} url\n * @param {Object} options\n * @return {string} Returns the URL in the cache that matches the request,\n * if possible.\n *\n * @private\n */\nexport const getCacheKeyForURL = (url, options) => {\n    const precacheController = getOrCreatePrecacheController();\n    const urlsToCacheKeys = precacheController.getURLsToCacheKeys();\n    for (const possibleURL of generateURLVariations(url, options)) {\n        const possibleCacheKey = urlsToCacheKeys.get(possibleURL);\n        if (possibleCacheKey) {\n            return possibleCacheKey;\n        }\n    }\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 { removeIgnoredSearchParams } from './removeIgnoredSearchParams.js';\nimport '../_version.js';\n/**\n * Generator function that yields possible variations on the original URL to\n * check, one at a time.\n *\n * @param {string} url\n * @param {Object} options\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function* generateURLVariations(url, { ignoreURLParametersMatching, directoryIndex, cleanURLs, urlManipulation, } = {}) {\n    const urlObject = new URL(url, location.href);\n    urlObject.hash = '';\n    yield urlObject.href;\n    const urlWithoutIgnoredParams = removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching);\n    yield urlWithoutIgnoredParams.href;\n    if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith('/')) {\n        const directoryURL = new URL(urlWithoutIgnoredParams.href);\n        directoryURL.pathname += directoryIndex;\n        yield directoryURL.href;\n    }\n    if (cleanURLs) {\n        const cleanURL = new URL(urlWithoutIgnoredParams.href);\n        cleanURL.pathname += '.html';\n        yield cleanURL.href;\n    }\n    if (urlManipulation) {\n        const additionalURLs = urlManipulation({ url: urlObject });\n        for (const urlToAttempt of additionalURLs) {\n            yield urlToAttempt.href;\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 '../_version.js';\n/**\n * Removes any URL search parameters that should be ignored.\n *\n * @param {URL} urlObject The original URL.\n * @param {Array<RegExp>} ignoreURLParametersMatching RegExps to test against\n * each search parameter name. Matches mean that the search parameter should be\n * ignored.\n * @return {URL} The URL with any ignored search parameters removed.\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching = []) {\n    // Convert the iterable into an array at the start of the loop to make sure\n    // deletion doesn't mess up iteration.\n    for (const paramName of [...urlObject.searchParams.keys()]) {\n        if (ignoreURLParametersMatching.some((regExp) => regExp.test(paramName))) {\n            urlObject.searchParams.delete(paramName);\n        }\n    }\n    return urlObject;\n}\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 { addFetchListener } from './utils/addFetchListener.js';\nimport './_version.js';\nlet listenerAdded = false;\n/**\n * Add a `fetch` listener to the service worker that will\n * respond to\n * [network requests]{@link https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests}\n * with precached assets.\n *\n * Requests for assets that aren't precached, the `FetchEvent` will not be\n * responded to, allowing the event to fall through to other `fetch` event\n * listeners.\n *\n * @param {Object} [options]\n * @param {string} [options.directoryIndex=index.html] The `directoryIndex` will\n * check cache entries for a URLs ending with '/' to see if there is a hit when\n * appending the `directoryIndex` value.\n * @param {Array<RegExp>} [options.ignoreURLParametersMatching=[/^utm_/]] An\n * array of regex's to remove search params when looking for a cache match.\n * @param {boolean} [options.cleanURLs=true] The `cleanURLs` option will\n * check the cache for the URL with a `.html` added to the end of the end.\n * @param {module:workbox-precaching~urlManipulation} [options.urlManipulation]\n * This is a function that should take a URL and return an array of\n * alternative URLs that should be checked for precache matches.\n *\n * @memberof module:workbox-precaching\n */\nfunction addRoute(options) {\n    if (!listenerAdded) {\n        addFetchListener(options);\n        listenerAdded = true;\n    }\n}\nexport { addRoute };\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 { cacheNames } from 'workbox-core/_private/cacheNames.js';\nimport { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { getCacheKeyForURL } from './getCacheKeyForURL.js';\nimport '../_version.js';\n/**\n * Adds a `fetch` listener to the service worker that will\n * respond to\n * [network requests]{@link https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests}\n * with precached assets.\n *\n * Requests for assets that aren't precached, the `FetchEvent` will not be\n * responded to, allowing the event to fall through to other `fetch` event\n * listeners.\n *\n * NOTE: when called more than once this method will replace the previously set\n * configuration options. Calling it more than once is not recommended outside\n * of tests.\n *\n * @private\n * @param {Object} [options]\n * @param {string} [options.directoryIndex=index.html] The `directoryIndex` will\n * check cache entries for a URLs ending with '/' to see if there is a hit when\n * appending the `directoryIndex` value.\n * @param {Array<RegExp>} [options.ignoreURLParametersMatching=[/^utm_/]] An\n * array of regex's to remove search params when looking for a cache match.\n * @param {boolean} [options.cleanURLs=true] The `cleanURLs` option will\n * check the cache for the URL with a `.html` added to the end of the end.\n * @param {workbox.precaching~urlManipulation} [options.urlManipulation]\n * This is a function that should take a URL and return an array of\n * alternative URLs that should be checked for precache matches.\n */\nexport const addFetchListener = ({ ignoreURLParametersMatching = [/^utm_/], directoryIndex = 'index.html', cleanURLs = true, urlManipulation, } = {}) => {\n    const cacheName = cacheNames.getPrecacheName();\n    // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705\n    self.addEventListener('fetch', ((event) => {\n        const precachedURL = getCacheKeyForURL(event.request.url, {\n            cleanURLs,\n            directoryIndex,\n            ignoreURLParametersMatching,\n            urlManipulation,\n        });\n        if (!precachedURL) {\n            if (process.env.NODE_ENV !== 'production') {\n                logger.debug(`Precaching did not find a match for ` +\n                    getFriendlyURL(event.request.url));\n            }\n            return;\n        }\n        let responsePromise = self.caches.open(cacheName).then((cache) => {\n            return cache.match(precachedURL);\n        }).then((cachedResponse) => {\n            if (cachedResponse) {\n                return cachedResponse;\n            }\n            // Fall back to the network if we don't have a cached response\n            // (perhaps due to manual cache cleanup).\n            if (process.env.NODE_ENV !== 'production') {\n                logger.warn(`The precached response for ` +\n                    `${getFriendlyURL(precachedURL)} in ${cacheName} was not found. ` +\n                    `Falling back to the network instead.`);\n            }\n            return fetch(precachedURL);\n        });\n        if (process.env.NODE_ENV !== 'production') {\n            responsePromise = responsePromise.then((response) => {\n                // Workbox is going to handle the route.\n                // print the routing details to the console.\n                logger.groupCollapsed(`Precaching is responding to: ` +\n                    getFriendlyURL(event.request.url));\n                logger.log(`Serving the precached url: ${precachedURL}`);\n                logger.groupCollapsed(`View request details here.`);\n                logger.log(event.request);\n                logger.groupEnd();\n                logger.groupCollapsed(`View response details here.`);\n                logger.log(response);\n                logger.groupEnd();\n                logger.groupEnd();\n                return response;\n            });\n        }\n        event.respondWith(responsePromise);\n    }));\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 { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';\nimport { precachePlugins } from './utils/precachePlugins.js';\nimport './_version.js';\nconst installListener = (event) => {\n    const precacheController = getOrCreatePrecacheController();\n    const plugins = precachePlugins.get();\n    event.waitUntil(precacheController.install({ event, plugins })\n        .catch((error) => {\n        if (process.env.NODE_ENV !== 'production') {\n            logger.error(`Service worker installation failed. It will ` +\n                `be retried automatically during the next navigation.`);\n        }\n        // Re-throw the error to ensure installation fails.\n        throw error;\n    }));\n};\nconst activateListener = (event) => {\n    const precacheController = getOrCreatePrecacheController();\n    event.waitUntil(precacheController.activate());\n};\n/**\n * Adds items to the precache list, removing any duplicates and\n * stores the files in the\n * [\"precache cache\"]{@link module:workbox-core.cacheNames} when the service\n * worker installs.\n *\n * This method can be called multiple times.\n *\n * Please note: This method **will not** serve any of the cached files for you.\n * It only precaches files. To respond to a network request you call\n * [addRoute()]{@link module:workbox-precaching.addRoute}.\n *\n * If you have a single array of files to precache, you can just call\n * [precacheAndRoute()]{@link module:workbox-precaching.precacheAndRoute}.\n *\n * @param {Array<Object|string>} [entries=[]] Array of entries to precache.\n *\n * @memberof module:workbox-precaching\n */\nfunction precache(entries) {\n    const precacheController = getOrCreatePrecacheController();\n    precacheController.addToCacheList(entries);\n    if (entries.length > 0) {\n        // NOTE: these listeners will only be added once (even if the `precache()`\n        // method is called multiple times) because event listeners are implemented\n        // as a set, where each listener must be unique.\n        // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705\n        self.addEventListener('install', installListener);\n        self.addEventListener('activate', activateListener);\n    }\n}\nexport { precache };\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 { precachePlugins } from './utils/precachePlugins.js';\nimport './_version.js';\n/**\n * Adds plugins to precaching.\n *\n * @param {Array<Object>} newPlugins\n *\n * @memberof module:workbox-precaching\n */\nfunction addPlugins(newPlugins) {\n    precachePlugins.add(newPlugins);\n}\nexport { addPlugins };\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 { cacheNames } from 'workbox-core/_private/cacheNames.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { deleteOutdatedCaches } from './utils/deleteOutdatedCaches.js';\nimport './_version.js';\n/**\n * Adds an `activate` event listener which will clean up incompatible\n * precaches that were created by older versions of Workbox.\n *\n * @memberof module:workbox-precaching\n */\nfunction cleanupOutdatedCaches() {\n    // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705\n    self.addEventListener('activate', ((event) => {\n        const cacheName = cacheNames.getPrecacheName();\n        event.waitUntil(deleteOutdatedCaches(cacheName).then((cachesDeleted) => {\n            if (process.env.NODE_ENV !== 'production') {\n                if (cachesDeleted.length > 0) {\n                    logger.log(`The following out-of-date precaches were cleaned up ` +\n                        `automatically:`, cachesDeleted);\n                }\n            }\n        }));\n    }));\n}\nexport { cleanupOutdatedCaches };\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 SUBSTRING_TO_FIND = '-precache-';\n/**\n * Cleans up incompatible precaches that were created by older versions of\n * Workbox, by a service worker registered under the current scope.\n *\n * This is meant to be called as part of the `activate` event.\n *\n * This should be safe to use as long as you don't include `substringToFind`\n * (defaulting to `-precache-`) in your non-precache cache names.\n *\n * @param {string} currentPrecacheName The cache name currently in use for\n * precaching. This cache won't be deleted.\n * @param {string} [substringToFind='-precache-'] Cache names which include this\n * substring will be deleted (excluding `currentPrecacheName`).\n * @return {Array<string>} A list of all the cache names that were deleted.\n *\n * @private\n * @memberof module:workbox-precaching\n */\nconst deleteOutdatedCaches = async (currentPrecacheName, substringToFind = SUBSTRING_TO_FIND) => {\n    const cacheNames = await self.caches.keys();\n    const cacheNamesToDelete = cacheNames.filter((cacheName) => {\n        return cacheName.includes(substringToFind) &&\n            cacheName.includes(self.registration.scope) &&\n            cacheName !== currentPrecacheName;\n    });\n    await Promise.all(cacheNamesToDelete.map((cacheName) => self.caches.delete(cacheName)));\n    return cacheNamesToDelete;\n};\nexport { deleteOutdatedCaches };\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 { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';\nimport './_version.js';\n/**\n * Helper function that calls\n * {@link PrecacheController#createHandler} on the default\n * {@link PrecacheController} instance.\n *\n * If you are creating your own {@link PrecacheController}, then call the\n * {@link PrecacheController#createHandler} on that instance,\n * instead of using this function.\n *\n * @param {boolean} [fallbackToNetwork=true] Whether to attempt to get the\n * response from the network if there's a precache miss.\n * @return {module:workbox-routing~handlerCallback}\n *\n * @memberof module:workbox-precaching\n */\nfunction createHandler(fallbackToNetwork = true) {\n    const precacheController = getOrCreatePrecacheController();\n    return precacheController.createHandler(fallbackToNetwork);\n}\nexport { createHandler };\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 { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';\nimport './_version.js';\n/**\n * Helper function that calls\n * {@link PrecacheController#createHandlerBoundToURL} on the default\n * {@link PrecacheController} instance.\n *\n * If you are creating your own {@link PrecacheController}, then call the\n * {@link PrecacheController#createHandlerBoundToURL} on that instance,\n * instead of using this function.\n *\n * @param {string} url The precached URL which will be used to lookup the\n * `Response`.\n * @param {boolean} [fallbackToNetwork=true] Whether to attempt to get the\n * response from the network if there's a precache miss.\n * @return {module:workbox-routing~handlerCallback}\n *\n * @memberof module:workbox-precaching\n */\nfunction createHandlerBoundToURL(url) {\n    const precacheController = getOrCreatePrecacheController();\n    return precacheController.createHandlerBoundToURL(url);\n}\nexport { createHandlerBoundToURL };\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 { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';\nimport './_version.js';\n/**\n * Takes in a URL, and returns the corresponding URL that could be used to\n * lookup the entry in the precache.\n *\n * If a relative URL is provided, the location of the service worker file will\n * be used as the base.\n *\n * For precached entries without revision information, the cache key will be the\n * same as the original URL.\n *\n * For precached entries with revision information, the cache key will be the\n * original URL with the addition of a query parameter used for keeping track of\n * the revision info.\n *\n * @param {string} url The URL whose cache key to look up.\n * @return {string} The cache key that corresponds to that URL.\n *\n * @memberof module:workbox-precaching\n */\nfunction getCacheKeyForURL(url) {\n    const precacheController = getOrCreatePrecacheController();\n    return precacheController.getCacheKeyForURL(url);\n}\nexport { getCacheKeyForURL };\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 { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';\nimport './_version.js';\n/**\n * Helper function that calls\n * {@link PrecacheController#matchPrecache} on the default\n * {@link PrecacheController} instance.\n *\n * If you are creating your own {@link PrecacheController}, then call\n * {@link PrecacheController#matchPrecache} on that instance,\n * instead of using this function.\n *\n * @param {string|Request} request The key (without revisioning parameters)\n * to look up in the precache.\n * @return {Promise<Response|undefined>}\n *\n * @memberof module:workbox-precaching\n */\nfunction matchPrecache(request) {\n    const precacheController = getOrCreatePrecacheController();\n    return precacheController.matchPrecache(request);\n}\nexport { matchPrecache };\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 { addRoute } from './addRoute.js';\nimport { precache } from './precache.js';\nimport './_version.js';\n/**\n * This method will add entries to the precache list and add a route to\n * respond to fetch events.\n *\n * This is a convenience method that will call\n * [precache()]{@link module:workbox-precaching.precache} and\n * [addRoute()]{@link module:workbox-precaching.addRoute} in a single call.\n *\n * @param {Array<Object|string>} entries Array of entries to precache.\n * @param {Object} [options] See\n * [addRoute() options]{@link module:workbox-precaching.addRoute}.\n *\n * @memberof module:workbox-precaching\n */\nfunction precacheAndRoute(entries, options) {\n    precache(entries);\n    addRoute(options);\n}\nexport { precacheAndRoute };\n"],"names":["self","_","e","plugins","precachePlugins","get","add","newPlugins","push","createCacheKey","entry","WorkboxError","urlObject","URL","location","href","cacheKey","url","revision","cacheKeyURL","originalURL","searchParams","set","PrecacheController","constructor","cacheName","_cacheName","cacheNames","getPrecacheName","_urlsToCacheKeys","Map","_urlsToCacheModes","_cacheKeysToIntegrities","addToCacheList","entries","urlsToWarnAbout","undefined","cacheMode","this","has","firstEntry","secondEntry","integrity","length","warningMessage","join","console","warn","event","toBePrecached","alreadyPrecached","cache","caches","open","alreadyCachedRequests","keys","existingCacheKeys","Set","map","request","precacheRequests","_addURLToCache","Promise","all","updatedURLs","item","notUpdatedURLs","currentlyCachedRequests","expectedCacheKeys","values","deletedURLs","delete","Request","credentials","cacheWillUpdatePlugin","response","fetchWrapper","fetch","plugin","cacheWillUpdate","status","redirected","copyResponse","cacheWrapper","put","matchOptions","ignoreSearch","getURLsToCacheKeys","getCachedURLs","getCacheKeyForURL","match","createHandler","fallbackToNetwork","async","matchPrecache","error","createHandlerBoundToURL","handler","precacheController","getOrCreatePrecacheController","options","urlsToCacheKeys","possibleURL","ignoreURLParametersMatching","directoryIndex","cleanURLs","urlManipulation","hash","urlWithoutIgnoredParams","paramName","some","regExp","test","removeIgnoredSearchParams","pathname","endsWith","directoryURL","cleanURL","additionalURLs","urlToAttempt","generateURLVariations","possibleCacheKey","listenerAdded","addRoute","addEventListener","precachedURL","responsePromise","then","cachedResponse","respondWith","addFetchListener","installListener","waitUntil","install","catch","activateListener","activate","precache","currentPrecacheName","substringToFind","cacheNamesToDelete","filter","includes","registration","scope","deleteOutdatedCaches","cachesDeleted"],"mappings":"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"}

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

@@ -2,9 +2,8 @@ this.workbox = this.workbox || {};
 this.workbox.rangeRequests = (function (exports, WorkboxError_js, assert_js, logger_js) {
     'use strict';
 
-    // @ts-ignore
     try {
-      self['workbox:range-requests:5.0.0-alpha.0'] && _();
+      self['workbox:range-requests:5.1.4'] && _();
     } catch (e) {}
 
     /*
@@ -47,14 +46,14 @@ this.workbox.rangeRequests = (function (exports, WorkboxError_js, assert_js, log
       let effectiveStart;
       let effectiveEnd;
 
-      if (start && end) {
+      if (start !== undefined && end !== undefined) {
         effectiveStart = start; // Range values are inclusive, so add 1 to the value.
 
         effectiveEnd = end + 1;
-      } else if (start && !end) {
+      } else if (start !== undefined && end === undefined) {
         effectiveStart = start;
         effectiveEnd = blobSize;
-      } else if (end && !start) {
+      } else if (end !== undefined && start === undefined) {
         effectiveStart = blobSize - end;
         effectiveEnd = blobSize;
       }
@@ -144,7 +143,7 @@ this.workbox.rangeRequests = (function (exports, WorkboxError_js, assert_js, log
      * `Range:` header, or a `416 Range Not Satisfiable` response if the
      * conditions of the `Range:` header can't be met.
      *
-     * @memberof workbox.rangeRequests
+     * @memberof module:workbox-range-requests
      */
 
     async function createPartialResponse(request, originalResponse) {
@@ -220,10 +219,10 @@ this.workbox.rangeRequests = (function (exports, WorkboxError_js, assert_js, log
      * It does this by intercepting the `cachedResponseWillBeUsed` plugin callback
      * and returning the appropriate subset of the cached response body.
      *
-     * @memberof workbox.rangeRequests
+     * @memberof module:workbox-range-requests
      */
 
-    class Plugin {
+    class RangeRequestsPlugin {
       constructor() {
         /**
          * @param {Object} options
@@ -254,7 +253,7 @@ this.workbox.rangeRequests = (function (exports, WorkboxError_js, assert_js, log
 
     }
 
-    exports.Plugin = Plugin;
+    exports.RangeRequestsPlugin = RangeRequestsPlugin;
     exports.createPartialResponse = createPartialResponse;
 
     return exports;

data/lib/vendor/workbox-v5.1.4/workbox-range-requests.dev.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workbox-range-requests.dev.js","sources":["../_version.js","../utils/calculateEffectiveBoundaries.js","../utils/parseRangeHeader.js","../createPartialResponse.js","../RangeRequestsPlugin.js"],"sourcesContent":["\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:range-requests:5.1.4'] && _();\n}\ncatch (e) { }\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { assert } from 'workbox-core/_private/assert.js';\nimport '../_version.js';\n/**\n * @param {Blob} blob A source blob.\n * @param {number} [start] The offset to use as the start of the\n * slice.\n * @param {number} [end] The offset to use as the end of the slice.\n * @return {Object} An object with `start` and `end` properties, reflecting\n * the effective boundaries to use given the size of the blob.\n *\n * @private\n */\nfunction calculateEffectiveBoundaries(blob, start, end) {\n    if (process.env.NODE_ENV !== 'production') {\n        assert.isInstance(blob, Blob, {\n            moduleName: 'workbox-range-requests',\n            funcName: 'calculateEffectiveBoundaries',\n            paramName: 'blob',\n        });\n    }\n    const blobSize = blob.size;\n    if ((end && end > blobSize) || (start && start < 0)) {\n        throw new WorkboxError('range-not-satisfiable', {\n            size: blobSize,\n            end,\n            start,\n        });\n    }\n    let effectiveStart;\n    let effectiveEnd;\n    if (start !== undefined && end !== undefined) {\n        effectiveStart = start;\n        // Range values are inclusive, so add 1 to the value.\n        effectiveEnd = end + 1;\n    }\n    else if (start !== undefined && end === undefined) {\n        effectiveStart = start;\n        effectiveEnd = blobSize;\n    }\n    else if (end !== undefined && start === undefined) {\n        effectiveStart = blobSize - end;\n        effectiveEnd = blobSize;\n    }\n    return {\n        start: effectiveStart,\n        end: effectiveEnd,\n    };\n}\nexport { calculateEffectiveBoundaries };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { assert } from 'workbox-core/_private/assert.js';\nimport '../_version.js';\n/**\n * @param {string} rangeHeader A Range: header value.\n * @return {Object} An object with `start` and `end` properties, reflecting\n * the parsed value of the Range: header. If either the `start` or `end` are\n * omitted, then `null` will be returned.\n *\n * @private\n */\nfunction parseRangeHeader(rangeHeader) {\n    if (process.env.NODE_ENV !== 'production') {\n        assert.isType(rangeHeader, 'string', {\n            moduleName: 'workbox-range-requests',\n            funcName: 'parseRangeHeader',\n            paramName: 'rangeHeader',\n        });\n    }\n    const normalizedRangeHeader = rangeHeader.trim().toLowerCase();\n    if (!normalizedRangeHeader.startsWith('bytes=')) {\n        throw new WorkboxError('unit-must-be-bytes', { normalizedRangeHeader });\n    }\n    // Specifying multiple ranges separate by commas is valid syntax, but this\n    // library only attempts to handle a single, contiguous sequence of bytes.\n    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Range#Syntax\n    if (normalizedRangeHeader.includes(',')) {\n        throw new WorkboxError('single-range-only', { normalizedRangeHeader });\n    }\n    const rangeParts = /(\\d*)-(\\d*)/.exec(normalizedRangeHeader);\n    // We need either at least one of the start or end values.\n    if (!rangeParts || !(rangeParts[1] || rangeParts[2])) {\n        throw new WorkboxError('invalid-range-values', { normalizedRangeHeader });\n    }\n    return {\n        start: rangeParts[1] === '' ? undefined : Number(rangeParts[1]),\n        end: rangeParts[2] === '' ? undefined : Number(rangeParts[2]),\n    };\n}\nexport { parseRangeHeader };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { calculateEffectiveBoundaries } from './utils/calculateEffectiveBoundaries.js';\nimport { parseRangeHeader } from './utils/parseRangeHeader.js';\nimport './_version.js';\n/**\n * Given a `Request` and `Response` objects as input, this will return a\n * promise for a new `Response`.\n *\n * If the original `Response` already contains partial content (i.e. it has\n * a status of 206), then this assumes it already fulfills the `Range:`\n * requirements, and will return it as-is.\n *\n * @param {Request} request A request, which should contain a Range:\n * header.\n * @param {Response} originalResponse A response.\n * @return {Promise<Response>} Either a `206 Partial Content` response, with\n * the response body set to the slice of content specified by the request's\n * `Range:` header, or a `416 Range Not Satisfiable` response if the\n * conditions of the `Range:` header can't be met.\n *\n * @memberof module:workbox-range-requests\n */\nasync function createPartialResponse(request, originalResponse) {\n    try {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isInstance(request, Request, {\n                moduleName: 'workbox-range-requests',\n                funcName: 'createPartialResponse',\n                paramName: 'request',\n            });\n            assert.isInstance(originalResponse, Response, {\n                moduleName: 'workbox-range-requests',\n                funcName: 'createPartialResponse',\n                paramName: 'originalResponse',\n            });\n        }\n        if (originalResponse.status === 206) {\n            // If we already have a 206, then just pass it through as-is;\n            // see https://github.com/GoogleChrome/workbox/issues/1720\n            return originalResponse;\n        }\n        const rangeHeader = request.headers.get('range');\n        if (!rangeHeader) {\n            throw new WorkboxError('no-range-header');\n        }\n        const boundaries = parseRangeHeader(rangeHeader);\n        const originalBlob = await originalResponse.blob();\n        const effectiveBoundaries = calculateEffectiveBoundaries(originalBlob, boundaries.start, boundaries.end);\n        const slicedBlob = originalBlob.slice(effectiveBoundaries.start, effectiveBoundaries.end);\n        const slicedBlobSize = slicedBlob.size;\n        const slicedResponse = new Response(slicedBlob, {\n            // Status code 206 is for a Partial Content response.\n            // See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/206\n            status: 206,\n            statusText: 'Partial Content',\n            headers: originalResponse.headers,\n        });\n        slicedResponse.headers.set('Content-Length', String(slicedBlobSize));\n        slicedResponse.headers.set('Content-Range', `bytes ${effectiveBoundaries.start}-${effectiveBoundaries.end - 1}/` +\n            originalBlob.size);\n        return slicedResponse;\n    }\n    catch (error) {\n        if (process.env.NODE_ENV !== 'production') {\n            logger.warn(`Unable to construct a partial response; returning a ` +\n                `416 Range Not Satisfiable response instead.`);\n            logger.groupCollapsed(`View details here.`);\n            logger.log(error);\n            logger.log(request);\n            logger.log(originalResponse);\n            logger.groupEnd();\n        }\n        return new Response('', {\n            status: 416,\n            statusText: 'Range Not Satisfiable',\n        });\n    }\n}\nexport { createPartialResponse };\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 { createPartialResponse } from './createPartialResponse.js';\nimport './_version.js';\n/**\n * The range request plugin makes it easy for a request with a 'Range' header to\n * be fulfilled by a cached response.\n *\n * It does this by intercepting the `cachedResponseWillBeUsed` plugin callback\n * and returning the appropriate subset of the cached response body.\n *\n * @memberof module:workbox-range-requests\n */\nclass RangeRequestsPlugin {\n    constructor() {\n        /**\n         * @param {Object} options\n         * @param {Request} options.request The original request, which may or may not\n         * contain a Range: header.\n         * @param {Response} options.cachedResponse The complete cached response.\n         * @return {Promise<Response>} If request contains a 'Range' header, then a\n         * new response with status 206 whose body is a subset of `cachedResponse` is\n         * returned. Otherwise, `cachedResponse` is returned as-is.\n         *\n         * @private\n         */\n        this.cachedResponseWillBeUsed = async ({ request, cachedResponse }) => {\n            // Only return a sliced response if there's something valid in the cache,\n            // and there's a Range: header in the request.\n            if (cachedResponse && request.headers.has('range')) {\n                return await createPartialResponse(request, cachedResponse);\n            }\n            // If there was no Range: header, or if cachedResponse wasn't valid, just\n            // pass it through as-is.\n            return cachedResponse;\n        };\n    }\n}\nexport { RangeRequestsPlugin };\n"],"names":["self","_","e","calculateEffectiveBoundaries","blob","start","end","assert","isInstance","Blob","moduleName","funcName","paramName","blobSize","size","WorkboxError","effectiveStart","effectiveEnd","undefined","parseRangeHeader","rangeHeader","isType","normalizedRangeHeader","trim","toLowerCase","startsWith","includes","rangeParts","exec","Number","createPartialResponse","request","originalResponse","process","Request","Response","status","headers","get","boundaries","originalBlob","effectiveBoundaries","slicedBlob","slice","slicedBlobSize","slicedResponse","statusText","set","String","error","logger","warn","groupCollapsed","log","groupEnd","RangeRequestsPlugin","constructor","cachedResponseWillBeUsed","cachedResponse","has"],"mappings":"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"}

data/lib/vendor/workbox-v5.1.4/workbox-range-requests.prod.js

@@ -0,0 +1,2 @@
+this.workbox=this.workbox||{},this.workbox.rangeRequests=function(t,e,n){"use strict";try{self["workbox:range-requests:5.1.4"]&&_()}catch(t){}async function r(t,n){try{if(206===n.status)return n;const r=t.headers.get("range");if(!r)throw new e.WorkboxError("no-range-header");const s=function(t){const n=t.trim().toLowerCase();if(!n.startsWith("bytes="))throw new e.WorkboxError("unit-must-be-bytes",{normalizedRangeHeader:n});if(n.includes(","))throw new e.WorkboxError("single-range-only",{normalizedRangeHeader:n});const r=/(\d*)-(\d*)/.exec(n);if(!r||!r[1]&&!r[2])throw new e.WorkboxError("invalid-range-values",{normalizedRangeHeader:n});return{start:""===r[1]?void 0:Number(r[1]),end:""===r[2]?void 0:Number(r[2])}}(r),a=await n.blob(),o=function(t,n,r){const s=t.size;if(r&&r>s||n&&n<0)throw new e.WorkboxError("range-not-satisfiable",{size:s,end:r,start:n});let a,o;return void 0!==n&&void 0!==r?(a=n,o=r+1):void 0!==n&&void 0===r?(a=n,o=s):void 0!==r&&void 0===n&&(a=s-r,o=s),{start:a,end:o}}(a,s.start,s.end),i=a.slice(o.start,o.end),d=i.size,u=new Response(i,{status:206,statusText:"Partial Content",headers:n.headers});return u.headers.set("Content-Length",String(d)),u.headers.set("Content-Range",`bytes ${o.start}-${o.end-1}/`+a.size),u}catch(t){return new Response("",{status:416,statusText:"Range Not Satisfiable"})}}return t.RangeRequestsPlugin=class{constructor(){this.cachedResponseWillBeUsed=async({request:t,cachedResponse:e})=>e&&t.headers.has("range")?await r(t,e):e}},t.createPartialResponse=r,t}({},workbox.core._private,workbox.core._private);
+//# sourceMappingURL=workbox-range-requests.prod.js.map

data/lib/vendor/workbox-v5.1.4/workbox-range-requests.prod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workbox-range-requests.prod.js","sources":["../_version.js","../createPartialResponse.js","../utils/parseRangeHeader.js","../utils/calculateEffectiveBoundaries.js","../RangeRequestsPlugin.js"],"sourcesContent":["\"use strict\";\n// @ts-ignore\ntry {\n    self['workbox:range-requests:5.1.4'] && _();\n}\ncatch (e) { }\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { assert } from 'workbox-core/_private/assert.js';\nimport { logger } from 'workbox-core/_private/logger.js';\nimport { calculateEffectiveBoundaries } from './utils/calculateEffectiveBoundaries.js';\nimport { parseRangeHeader } from './utils/parseRangeHeader.js';\nimport './_version.js';\n/**\n * Given a `Request` and `Response` objects as input, this will return a\n * promise for a new `Response`.\n *\n * If the original `Response` already contains partial content (i.e. it has\n * a status of 206), then this assumes it already fulfills the `Range:`\n * requirements, and will return it as-is.\n *\n * @param {Request} request A request, which should contain a Range:\n * header.\n * @param {Response} originalResponse A response.\n * @return {Promise<Response>} Either a `206 Partial Content` response, with\n * the response body set to the slice of content specified by the request's\n * `Range:` header, or a `416 Range Not Satisfiable` response if the\n * conditions of the `Range:` header can't be met.\n *\n * @memberof module:workbox-range-requests\n */\nasync function createPartialResponse(request, originalResponse) {\n    try {\n        if (process.env.NODE_ENV !== 'production') {\n            assert.isInstance(request, Request, {\n                moduleName: 'workbox-range-requests',\n                funcName: 'createPartialResponse',\n                paramName: 'request',\n            });\n            assert.isInstance(originalResponse, Response, {\n                moduleName: 'workbox-range-requests',\n                funcName: 'createPartialResponse',\n                paramName: 'originalResponse',\n            });\n        }\n        if (originalResponse.status === 206) {\n            // If we already have a 206, then just pass it through as-is;\n            // see https://github.com/GoogleChrome/workbox/issues/1720\n            return originalResponse;\n        }\n        const rangeHeader = request.headers.get('range');\n        if (!rangeHeader) {\n            throw new WorkboxError('no-range-header');\n        }\n        const boundaries = parseRangeHeader(rangeHeader);\n        const originalBlob = await originalResponse.blob();\n        const effectiveBoundaries = calculateEffectiveBoundaries(originalBlob, boundaries.start, boundaries.end);\n        const slicedBlob = originalBlob.slice(effectiveBoundaries.start, effectiveBoundaries.end);\n        const slicedBlobSize = slicedBlob.size;\n        const slicedResponse = new Response(slicedBlob, {\n            // Status code 206 is for a Partial Content response.\n            // See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/206\n            status: 206,\n            statusText: 'Partial Content',\n            headers: originalResponse.headers,\n        });\n        slicedResponse.headers.set('Content-Length', String(slicedBlobSize));\n        slicedResponse.headers.set('Content-Range', `bytes ${effectiveBoundaries.start}-${effectiveBoundaries.end - 1}/` +\n            originalBlob.size);\n        return slicedResponse;\n    }\n    catch (error) {\n        if (process.env.NODE_ENV !== 'production') {\n            logger.warn(`Unable to construct a partial response; returning a ` +\n                `416 Range Not Satisfiable response instead.`);\n            logger.groupCollapsed(`View details here.`);\n            logger.log(error);\n            logger.log(request);\n            logger.log(originalResponse);\n            logger.groupEnd();\n        }\n        return new Response('', {\n            status: 416,\n            statusText: 'Range Not Satisfiable',\n        });\n    }\n}\nexport { createPartialResponse };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { assert } from 'workbox-core/_private/assert.js';\nimport '../_version.js';\n/**\n * @param {string} rangeHeader A Range: header value.\n * @return {Object} An object with `start` and `end` properties, reflecting\n * the parsed value of the Range: header. If either the `start` or `end` are\n * omitted, then `null` will be returned.\n *\n * @private\n */\nfunction parseRangeHeader(rangeHeader) {\n    if (process.env.NODE_ENV !== 'production') {\n        assert.isType(rangeHeader, 'string', {\n            moduleName: 'workbox-range-requests',\n            funcName: 'parseRangeHeader',\n            paramName: 'rangeHeader',\n        });\n    }\n    const normalizedRangeHeader = rangeHeader.trim().toLowerCase();\n    if (!normalizedRangeHeader.startsWith('bytes=')) {\n        throw new WorkboxError('unit-must-be-bytes', { normalizedRangeHeader });\n    }\n    // Specifying multiple ranges separate by commas is valid syntax, but this\n    // library only attempts to handle a single, contiguous sequence of bytes.\n    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Range#Syntax\n    if (normalizedRangeHeader.includes(',')) {\n        throw new WorkboxError('single-range-only', { normalizedRangeHeader });\n    }\n    const rangeParts = /(\\d*)-(\\d*)/.exec(normalizedRangeHeader);\n    // We need either at least one of the start or end values.\n    if (!rangeParts || !(rangeParts[1] || rangeParts[2])) {\n        throw new WorkboxError('invalid-range-values', { normalizedRangeHeader });\n    }\n    return {\n        start: rangeParts[1] === '' ? undefined : Number(rangeParts[1]),\n        end: rangeParts[2] === '' ? undefined : Number(rangeParts[2]),\n    };\n}\nexport { parseRangeHeader };\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\nimport { WorkboxError } from 'workbox-core/_private/WorkboxError.js';\nimport { assert } from 'workbox-core/_private/assert.js';\nimport '../_version.js';\n/**\n * @param {Blob} blob A source blob.\n * @param {number} [start] The offset to use as the start of the\n * slice.\n * @param {number} [end] The offset to use as the end of the slice.\n * @return {Object} An object with `start` and `end` properties, reflecting\n * the effective boundaries to use given the size of the blob.\n *\n * @private\n */\nfunction calculateEffectiveBoundaries(blob, start, end) {\n    if (process.env.NODE_ENV !== 'production') {\n        assert.isInstance(blob, Blob, {\n            moduleName: 'workbox-range-requests',\n            funcName: 'calculateEffectiveBoundaries',\n            paramName: 'blob',\n        });\n    }\n    const blobSize = blob.size;\n    if ((end && end > blobSize) || (start && start < 0)) {\n        throw new WorkboxError('range-not-satisfiable', {\n            size: blobSize,\n            end,\n            start,\n        });\n    }\n    let effectiveStart;\n    let effectiveEnd;\n    if (start !== undefined && end !== undefined) {\n        effectiveStart = start;\n        // Range values are inclusive, so add 1 to the value.\n        effectiveEnd = end + 1;\n    }\n    else if (start !== undefined && end === undefined) {\n        effectiveStart = start;\n        effectiveEnd = blobSize;\n    }\n    else if (end !== undefined && start === undefined) {\n        effectiveStart = blobSize - end;\n        effectiveEnd = blobSize;\n    }\n    return {\n        start: effectiveStart,\n        end: effectiveEnd,\n    };\n}\nexport { calculateEffectiveBoundaries };\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 { createPartialResponse } from './createPartialResponse.js';\nimport './_version.js';\n/**\n * The range request plugin makes it easy for a request with a 'Range' header to\n * be fulfilled by a cached response.\n *\n * It does this by intercepting the `cachedResponseWillBeUsed` plugin callback\n * and returning the appropriate subset of the cached response body.\n *\n * @memberof module:workbox-range-requests\n */\nclass RangeRequestsPlugin {\n    constructor() {\n        /**\n         * @param {Object} options\n         * @param {Request} options.request The original request, which may or may not\n         * contain a Range: header.\n         * @param {Response} options.cachedResponse The complete cached response.\n         * @return {Promise<Response>} If request contains a 'Range' header, then a\n         * new response with status 206 whose body is a subset of `cachedResponse` is\n         * returned. Otherwise, `cachedResponse` is returned as-is.\n         *\n         * @private\n         */\n        this.cachedResponseWillBeUsed = async ({ request, cachedResponse }) => {\n            // Only return a sliced response if there's something valid in the cache,\n            // and there's a Range: header in the request.\n            if (cachedResponse && request.headers.has('range')) {\n                return await createPartialResponse(request, cachedResponse);\n            }\n            // If there was no Range: header, or if cachedResponse wasn't valid, just\n            // pass it through as-is.\n            return cachedResponse;\n        };\n    }\n}\nexport { RangeRequestsPlugin };\n"],"names":["self","_","e","async","createPartialResponse","request","originalResponse","status","rangeHeader","headers","get","WorkboxError","boundaries","normalizedRangeHeader","trim","toLowerCase","startsWith","includes","rangeParts","exec","start","undefined","Number","end","parseRangeHeader","originalBlob","blob","effectiveBoundaries","blobSize","size","effectiveStart","effectiveEnd","calculateEffectiveBoundaries","slicedBlob","slice","slicedBlobSize","slicedResponse","Response","statusText","set","String","error","constructor","cachedResponseWillBeUsed","cachedResponse","has"],"mappings":"sFAEA,IACIA,KAAK,iCAAmCC,IAE5C,MAAOC,IC0BPC,eAAeC,EAAsBC,EAASC,UAcN,MAA5BA,EAAiBC,cAGVD,QAELE,EAAcH,EAAQI,QAAQC,IAAI,aACnCF,QACK,IAAIG,eAAa,yBAErBC,ECpCd,SAA0BJ,SAQhBK,EAAwBL,EAAYM,OAAOC,kBAC5CF,EAAsBG,WAAW,gBAC5B,IAAIL,eAAa,qBAAsB,CAAEE,sBAAAA,OAK/CA,EAAsBI,SAAS,WACzB,IAAIN,eAAa,oBAAqB,CAAEE,sBAAAA,UAE5CK,EAAa,cAAcC,KAAKN,OAEjCK,IAAgBA,EAAW,KAAMA,EAAW,SACvC,IAAIP,eAAa,uBAAwB,CAAEE,sBAAAA,UAE9C,CACHO,MAAyB,KAAlBF,EAAW,QAAYG,EAAYC,OAAOJ,EAAW,IAC5DK,IAAuB,KAAlBL,EAAW,QAAYG,EAAYC,OAAOJ,EAAW,KDWvCM,CAAiBhB,GAC9BiB,QAAqBnB,EAAiBoB,OACtCC,EEpCd,SAAsCD,EAAMN,EAAOG,SAQzCK,EAAWF,EAAKG,QACjBN,GAAOA,EAAMK,GAAcR,GAASA,EAAQ,QACvC,IAAIT,eAAa,wBAAyB,CAC5CkB,KAAMD,EACNL,IAAAA,EACAH,MAAAA,QAGJU,EACAC,cACUV,IAAVD,QAA+BC,IAARE,GACvBO,EAAiBV,EAEjBW,EAAeR,EAAM,QAENF,IAAVD,QAA+BC,IAARE,GAC5BO,EAAiBV,EACjBW,EAAeH,QAEFP,IAARE,QAA+BF,IAAVD,IAC1BU,EAAiBF,EAAWL,EAC5BQ,EAAeH,GAEZ,CACHR,MAAOU,EACPP,IAAKQ,GFGuBC,CAA6BP,EAAcb,EAAWQ,MAAOR,EAAWW,KAC9FU,EAAaR,EAAaS,MAAMP,EAAoBP,MAAOO,EAAoBJ,KAC/EY,EAAiBF,EAAWJ,KAC5BO,EAAiB,IAAIC,SAASJ,EAAY,CAG5C1B,OAAQ,IACR+B,WAAY,kBACZ7B,QAASH,EAAiBG,iBAE9B2B,EAAe3B,QAAQ8B,IAAI,iBAAkBC,OAAOL,IACpDC,EAAe3B,QAAQ8B,IAAI,gBAAkB,SAAQZ,EAAoBP,SAASO,EAAoBJ,IAAM,KACxGE,EAAaI,MACVO,EAEX,MAAOK,UAUI,IAAIJ,SAAS,GAAI,CACpB9B,OAAQ,IACR+B,WAAY,wDGjExB,MACII,mBAYSC,yBAA2BxC,OAASE,QAAAA,EAASuC,eAAAA,KAG1CA,GAAkBvC,EAAQI,QAAQoC,IAAI,eACzBzC,EAAsBC,EAASuC,GAIzCA"}

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

@@ -1,10 +1,9 @@
 this.workbox = this.workbox || {};
-this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js, WorkboxError_js, getFriendlyURL_js) {
+this.workbox.routing = (function (exports, assert_js, logger_js, WorkboxError_js, getFriendlyURL_js) {
     'use strict';
 
-    // @ts-ignore
     try {
-      self['workbox:routing:5.0.0-alpha.0'] && _();
+      self['workbox:routing:5.1.4'] && _();
     } catch (e) {}
 
     /*
@@ -91,17 +90,17 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
      * is called when there is a match and should return a Promise that resolves
      * to a `Response`.
      *
-     * @memberof workbox.routing
+     * @memberof module:workbox-routing
      */
 
     class Route {
       /**
        * Constructor for Route class.
        *
-       * @param {workbox.routing.Route~matchCallback} match
+       * @param {module:workbox-routing~matchCallback} match
        * A callback function that determines whether the route matches a given
        * `fetch` event by returning a non-falsy value.
-       * @param {workbox.routing.Route~handlerCallback} handler A callback
+       * @param {module:workbox-routing~handlerCallback} handler A callback
        * function that returns a Promise resolving to a Response.
        * @param {string} [method='GET'] The HTTP method to match the Route
        * against.
@@ -121,7 +120,7 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
             });
           }
         } // These values are referenced directly by Router so cannot be
-        // altered by minifification.
+        // altered by minificaton.
 
 
         this.handler = normalizeHandler(handler);
@@ -139,8 +138,8 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
       https://opensource.org/licenses/MIT.
     */
     /**
-     * NavigationRoute makes it easy to create a [Route]{@link
-     * workbox.routing.Route} that matches for browser
+     * NavigationRoute makes it easy to create a
+     * [Route]{@link module:workbox-routing.Route} that matches for browser
      * [navigation requests]{@link https://developers.google.com/web/fundamentals/primers/service-workers/high-performance-loading#first_what_are_navigation_requests}.
      *
      * It will only match incoming Requests whose
@@ -148,54 +147,54 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
      * is set to `navigate`.
      *
      * You can optionally only apply this route to a subset of navigation requests
-     * by using one or both of the `blacklist` and `whitelist` parameters.
+     * by using one or both of the `denylist` and `allowlist` parameters.
      *
-     * @memberof workbox.routing
-     * @extends workbox.routing.Route
+     * @memberof module:workbox-routing
+     * @extends module:workbox-routing.Route
      */
 
     class NavigationRoute extends Route {
       /**
-       * If both `blacklist` and `whiltelist` are provided, the `blacklist` will
+       * If both `denylist` and `allowlist` are provided, the `denylist` will
        * take precedence and the request will not match this route.
        *
-       * The regular expressions in `whitelist` and `blacklist`
+       * The regular expressions in `allowlist` and `denylist`
        * are matched against the concatenated
        * [`pathname`]{@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/pathname}
        * and [`search`]{@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/search}
        * portions of the requested URL.
        *
-       * @param {workbox.routing.Route~handlerCallback} handler A callback
+       * @param {module:workbox-routing~handlerCallback} handler A callback
        * function that returns a Promise resulting in a Response.
        * @param {Object} options
-       * @param {Array<RegExp>} [options.blacklist] If any of these patterns match,
-       * the route will not handle the request (even if a whitelist RegExp matches).
-       * @param {Array<RegExp>} [options.whitelist=[/./]] If any of these patterns
+       * @param {Array<RegExp>} [options.denylist] If any of these patterns match,
+       * the route will not handle the request (even if a allowlist RegExp matches).
+       * @param {Array<RegExp>} [options.allowlist=[/./]] If any of these patterns
        * match the URL's pathname and search parameter, the route will handle the
-       * request (assuming the blacklist doesn't match).
+       * request (assuming the denylist doesn't match).
        */
       constructor(handler, {
-        whitelist = [/./],
-        blacklist = []
+        allowlist = [/./],
+        denylist = []
       } = {}) {
         {
-          assert_js.assert.isArrayOfClass(whitelist, RegExp, {
+          assert_js.assert.isArrayOfClass(allowlist, RegExp, {
             moduleName: 'workbox-routing',
             className: 'NavigationRoute',
             funcName: 'constructor',
-            paramName: 'options.whitelist'
+            paramName: 'options.allowlist'
           });
-          assert_js.assert.isArrayOfClass(blacklist, RegExp, {
+          assert_js.assert.isArrayOfClass(denylist, RegExp, {
             moduleName: 'workbox-routing',
             className: 'NavigationRoute',
             funcName: 'constructor',
-            paramName: 'options.blacklist'
+            paramName: 'options.denylist'
           });
         }
 
         super(options => this._match(options), handler);
-        this._whitelist = whitelist;
-        this._blacklist = blacklist;
+        this._allowlist = allowlist;
+        this._denylist = denylist;
       }
       /**
        * Routes match handler.
@@ -219,17 +218,17 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
 
         const pathnameAndSearch = url.pathname + url.search;
 
-        for (const regExp of this._blacklist) {
+        for (const regExp of this._denylist) {
           if (regExp.test(pathnameAndSearch)) {
             {
-              logger_js.logger.log(`The navigation route ${pathnameAndSearch} is not ` + `being used, since the URL matches this blacklist pattern: ` + `${regExp}`);
+              logger_js.logger.log(`The navigation route ${pathnameAndSearch} is not ` + `being used, since the URL matches this denylist pattern: ` + `${regExp}`);
             }
 
             return false;
           }
         }
 
-        if (this._whitelist.some(regExp => regExp.test(pathnameAndSearch))) {
+        if (this._allowlist.some(regExp => regExp.test(pathnameAndSearch))) {
           {
             logger_js.logger.debug(`The navigation route ${pathnameAndSearch} ` + `is being used.`);
           }
@@ -238,7 +237,7 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
         }
 
         {
-          logger_js.logger.log(`The navigation route ${pathnameAndSearch} is not ` + `being used, since the URL being navigated to doesn't ` + `match the whitelist.`);
+          logger_js.logger.log(`The navigation route ${pathnameAndSearch} is not ` + `being used, since the URL being navigated to doesn't ` + `match the allowlist.`);
         }
 
         return false;
@@ -255,7 +254,7 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
     */
     /**
      * RegExpRoute makes it easy to create a regular expression based
-     * [Route]{@link workbox.routing.Route}.
+     * [Route]{@link module:workbox-routing.Route}.
      *
      * For same-origin requests the RegExp only needs to match part of the URL. For
      * requests against third-party servers, you must define a RegExp that matches
@@ -263,20 +262,20 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
      *
      * [See the module docs for info.]{@link https://developers.google.com/web/tools/workbox/modules/workbox-routing}
      *
-     * @memberof workbox.routing
-     * @extends workbox.routing.Route
+     * @memberof module:workbox-routing
+     * @extends module:workbox-routing.Route
      */
 
     class RegExpRoute extends Route {
       /**
-       * If the regulard expression contains
+       * If the regular expression contains
        * [capture groups]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#grouping-back-references},
-       * th ecaptured values will be passed to the
-       * [handler's]{@link workbox.routing.Route~handlerCallback} `params`
+       * the captured values will be passed to the
+       * [handler's]{@link module:workbox-routing~handlerCallback} `params`
        * argument.
        *
        * @param {RegExp} regExp The regular expression to match against URLs.
-       * @param {workbox.routing.Route~handlerCallback} handler A callback
+       * @param {module:workbox-routing~handlerCallback} handler A callback
        * function that returns a Promise resulting in a Response.
        * @param {string} [method='GET'] The HTTP method to match the Route
        * against.
@@ -333,7 +332,7 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
     */
     /**
      * The Router can be used to process a FetchEvent through one or more
-     * [Routes]{@link workbox.routing.Route} responding  with a Request if
+     * [Routes]{@link module:workbox-routing.Route} responding  with a Request if
      * a matching route exists.
      *
      * If no route matches a given a request, the Router will use a "default"
@@ -346,7 +345,7 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
      * If a request matches multiple routes, the **earliest** registered route will
      * be used to respond to the request.
      *
-     * @memberof workbox.routing
+     * @memberof module:workbox-routing
      */
 
     class Router {
@@ -357,7 +356,7 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
         this._routes = new Map();
       }
       /**
-       * @return {Map<string, Array<workbox.routing.Route>>} routes A `Map` of HTTP
+       * @return {Map<string, Array<module:workbox-routing.Route>>} routes A `Map` of HTTP
        * method name ('GET', etc.) to an array of all the corresponding `Route`
        * instances that are registered.
        */
@@ -373,6 +372,7 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
 
 
       addFetchListener() {
+        // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705
         self.addEventListener('fetch', event => {
           const {
             request
@@ -412,7 +412,8 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
 
 
       addCacheListener() {
-        self.addEventListener('message', async event => {
+        // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705
+        self.addEventListener('message', event => {
           if (event.data && event.data.type === 'CACHE_URLS') {
             const {
               payload
@@ -430,16 +431,15 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
               const request = new Request(...entry);
               return this.handleRequest({
                 request
-              }); // TODO(philipwalton): Typescript errors without this typecast for
+              }); // TODO(philipwalton): TypeScript errors without this typecast for
               // some reason (probably a bug). The real type here should work but
               // doesn't: `Array<Promise<Response> | undefined>`.
-            })); // Typescript
+            })); // TypeScript
 
             event.waitUntil(requestPromises); // If a MessageChannel was used, reply to the message on success.
 
             if (event.ports && event.ports[0]) {
-              await requestPromises;
-              event.ports[0].postMessage(true);
+              requestPromises.then(() => event.ports[0].postMessage(true));
             }
           }
         });
@@ -482,7 +482,7 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
           return;
         }
 
-        let {
+        const {
           params,
           route
         } = this.findMatchingRoute({
@@ -491,7 +491,7 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
           event
         });
         let handler = route && route.handler;
-        let debugMessages = [];
+        const debugMessages = [];
 
         {
           if (handler) {
@@ -533,12 +533,7 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
             } else {
               logger_js.logger.log(msg);
             }
-          }); // The Request and Response objects contains a great deal of information,
-          // hide it under a group in case developers want to see it.
-
-          logger_js.logger.groupCollapsed(`View request details here.`);
-          logger_js.logger.log(request);
-          logger_js.logger.groupEnd();
+          });
           logger_js.logger.groupEnd();
         } // Wrap in try and catch in case the handle method throws a synchronous
         // error. It should still callback to the catch handler.
@@ -557,7 +552,7 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
           responsePromise = Promise.reject(err);
         }
 
-        if (responsePromise && this._catchHandler) {
+        if (responsePromise instanceof Promise && this._catchHandler) {
           responsePromise = responsePromise.catch(err => {
             {
               // Still include URL here as it will be async from the console group
@@ -617,19 +612,27 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
 
         for (const route of routes) {
           let params;
-          let matchResult = route.match({
+          const matchResult = route.match({
             url,
             request,
             event
           });
 
           if (matchResult) {
-            if (Array.isArray(matchResult) && matchResult.length > 0) {
+            // See https://github.com/GoogleChrome/workbox/issues/2079
+            params = matchResult;
+
+            if (Array.isArray(matchResult) && matchResult.length === 0) {
               // Instead of passing an empty array in as params, use undefined.
-              params = matchResult;
-            } else if (matchResult.constructor === Object && Object.keys(matchResult).length > 0) {
+              params = undefined;
+            } else if (matchResult.constructor === Object && Object.keys(matchResult).length === 0) {
               // Instead of passing an empty object in as params, use undefined.
-              params = matchResult;
+              params = undefined;
+            } else if (typeof matchResult === 'boolean') {
+              // For the boolean value true (rather than just something truth-y),
+              // don't set params.
+              // See https://github.com/GoogleChrome/workbox/pull/2134#issuecomment-513924353
+              params = undefined;
             } // Return early if have a match.
 
 
@@ -650,7 +653,7 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
        * Without a default handler, unmatched requests will go against the
        * network as if there were no service worker present.
        *
-       * @param {workbox.routing.Route~handlerCallback} handler A callback
+       * @param {module:workbox-routing~handlerCallback} handler A callback
        * function that returns a Promise resulting in a Response.
        */
 
@@ -662,7 +665,7 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
        * If a Route throws an error while handling a request, this `handler`
        * will be called and given a chance to provide a response.
        *
-       * @param {workbox.routing.Route~handlerCallback} handler A callback
+       * @param {module:workbox-routing~handlerCallback} handler A callback
        * function that returns a Promise resulting in a Response.
        */
 
@@ -673,7 +676,7 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
       /**
        * Registers a route with the router.
        *
-       * @param {workbox.routing.Route} route The route to register.
+       * @param {module:workbox-routing.Route} route The route to register.
        */
 
 
@@ -722,7 +725,7 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
       /**
        * Unregisters a route with the router.
        *
-       * @param {workbox.routing.Route} route The route to unregister.
+       * @param {module:workbox-routing.Route} route The route to unregister.
        */
 
 
@@ -771,93 +774,6 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
       return defaultRouter;
     };
 
-    /*
-      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.
-    */
-    /**
-     * Registers a route that will return a precached file for a navigation
-     * request. This is useful for the
-     * [application shell pattern]{@link https://developers.google.com/web/fundamentals/architecture/app-shell}.
-     *
-     * When determining the URL of the precached HTML document, you will likely need
-     * to call `workbox.precaching.getCacheKeyForURL(originalUrl)`, to account for
-     * the fact that Workbox's precaching naming conventions often results in URL
-     * cache keys that contain extra revisioning info.
-     *
-     * This method will generate a
-     * [NavigationRoute]{@link workbox.routing.NavigationRoute}
-     * and call
-     * [Router.registerRoute()]{@link workbox.routing.Router#registerRoute} on a
-     * singleton Router instance.
-     *
-     * @param {string} cachedAssetUrl The cache key to use for the HTML file.
-     * @param {Object} [options]
-     * @param {string} [options.cacheName] Cache name to store and retrieve
-     * requests. Defaults to precache cache name provided by
-     * [workbox-core.cacheNames]{@link workbox.core.cacheNames}.
-     * @param {Array<RegExp>} [options.blacklist=[]] If any of these patterns
-     * match, the route will not handle the request (even if a whitelist entry
-     * matches).
-     * @param {Array<RegExp>} [options.whitelist=[/./]] If any of these patterns
-     * match the URL's pathname and search parameter, the route will handle the
-     * request (assuming the blacklist doesn't match).
-     * @return {workbox.routing.NavigationRoute} Returns the generated
-     * Route.
-     *
-     * @alias workbox.routing.registerNavigationRoute
-     */
-
-    const registerNavigationRoute = (cachedAssetUrl, options = {}) => {
-      {
-        assert_js.assert.isType(cachedAssetUrl, 'string', {
-          moduleName: 'workbox-routing',
-          funcName: 'registerNavigationRoute',
-          paramName: 'cachedAssetUrl'
-        });
-      }
-
-      const cacheName = cacheNames_js.cacheNames.getPrecacheName(options.cacheName);
-
-      const handler = async () => {
-        try {
-          const response = await caches.match(cachedAssetUrl, {
-            cacheName
-          });
-
-          if (response) {
-            return response;
-          } // This shouldn't normally happen, but there are edge cases:
-          // https://github.com/GoogleChrome/workbox/issues/1441
-
-
-          throw new Error(`The cache ${cacheName} did not have an entry for ` + `${cachedAssetUrl}.`);
-        } catch (error) {
-          // If there's either a cache miss, or the caches.match() call threw
-          // an exception, then attempt to fulfill the navigation request with
-          // a response from the network rather than leaving the user with a
-          // failed navigation.
-          {
-            logger_js.logger.debug(`Unable to respond to navigation request with ` + `cached response. Falling back to network.`, error);
-          } // This might still fail if the browser is offline...
-
-
-          return fetch(cachedAssetUrl);
-        }
-      };
-
-      const route = new NavigationRoute(handler, {
-        whitelist: options.whitelist,
-        blacklist: options.blacklist
-      });
-      const defaultRouter = getOrCreateDefaultRouter();
-      defaultRouter.registerRoute(route);
-      return route;
-    };
-
     /*
       Copyright 2019 Google LLC
 
@@ -870,28 +786,22 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
      * strategy to a singleton Router instance.
      *
      * This method will generate a Route for you if needed and
-     * call [Router.registerRoute()]{@link
-     * workbox.routing.Router#registerRoute}.
+     * call [registerRoute()]{@link module:workbox-routing.Router#registerRoute}.
      *
-     * @param {
-     * RegExp|
-     * string|
-     * workbox.routing.Route~matchCallback|
-     * workbox.routing.Route
-     * } capture
+     * @param {RegExp|string|module:workbox-routing.Route~matchCallback|module:workbox-routing.Route} capture
      * If the capture param is a `Route`, all other arguments will be ignored.
-     * @param {workbox.routing.Route~handlerCallback} [handler] A callback
+     * @param {module:workbox-routing~handlerCallback} [handler] A callback
      * function that returns a Promise resulting in a Response. This parameter
      * is required if `capture` is not a `Route` object.
      * @param {string} [method='GET'] The HTTP method to match the Route
      * against.
-     * @return {workbox.routing.Route} The generated `Route`(Useful for
+     * @return {module:workbox-routing.Route} The generated `Route`(Useful for
      * unregistering).
      *
-     * @alias workbox.routing.registerRoute
+     * @memberof module:workbox-routing
      */
 
-    const registerRoute = (capture, handler, method) => {
+    function registerRoute(capture, handler, method) {
       let route;
 
       if (typeof capture === 'string') {
@@ -912,7 +822,7 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
 
           const wildcards = '[*:?+]';
 
-          if (valueToCheck.match(new RegExp(`${wildcards}`))) {
+          if (new RegExp(`${wildcards}`).exec(valueToCheck)) {
             logger_js.logger.debug(`The '$capture' parameter contains an Express-style wildcard ` + `character (${wildcards}). Strings are now always interpreted as ` + `exact matches; use a RegExp for partial or wildcard matches.`);
           }
         }
@@ -950,7 +860,7 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
       const defaultRouter = getOrCreateDefaultRouter();
       defaultRouter.registerRoute(route);
       return route;
-    };
+    }
 
     /*
       Copyright 2019 Google LLC
@@ -963,16 +873,16 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
      * If a Route throws an error while handling a request, this `handler`
      * will be called and given a chance to provide a response.
      *
-     * @param {workbox.routing.Route~handlerCallback} handler A callback
+     * @param {module:workbox-routing~handlerCallback} handler A callback
      * function that returns a Promise resulting in a Response.
      *
-     * @alias workbox.routing.setCatchHandler
+     * @memberof module:workbox-routing
      */
 
-    const setCatchHandler = handler => {
+    function setCatchHandler(handler) {
       const defaultRouter = getOrCreateDefaultRouter();
       defaultRouter.setCatchHandler(handler);
-    };
+    }
 
     /*
       Copyright 2019 Google LLC
@@ -988,39 +898,26 @@ this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js,
      * Without a default handler, unmatched requests will go against the
      * network as if there were no service worker present.
      *
-     * @param {workbox.routing.Route~handlerCallback} handler A callback
+     * @param {module:workbox-routing~handlerCallback} handler A callback
      * function that returns a Promise resulting in a Response.
      *
-     * @alias workbox.routing.setDefaultHandler
+     * @memberof module:workbox-routing
      */
 
-    const setDefaultHandler = handler => {
+    function setDefaultHandler(handler) {
       const defaultRouter = getOrCreateDefaultRouter();
       defaultRouter.setDefaultHandler(handler);
-    };
-
-    /*
-      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.
-    */
-
-    {
-      assert_js.assert.isSWEnv('workbox-routing');
     }
 
     exports.NavigationRoute = NavigationRoute;
     exports.RegExpRoute = RegExpRoute;
     exports.Route = Route;
     exports.Router = Router;
-    exports.registerNavigationRoute = registerNavigationRoute;
     exports.registerRoute = registerRoute;
     exports.setCatchHandler = setCatchHandler;
     exports.setDefaultHandler = setDefaultHandler;
 
     return exports;
 
-}({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private));
+}({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private));
 //# sourceMappingURL=workbox-routing.dev.js.map