applying transfer to react app

node_modules/workbox-strategies/CacheFirst.d.ts

@@ -0,0 +1,62 @@
+import { RouteHandlerObject, RouteHandlerCallbackOptions, WorkboxPlugin } from 'workbox-core/types.js';
+import './_version.js';
+interface CacheFirstOptions {
+    cacheName?: string;
+    plugins?: WorkboxPlugin[];
+    fetchOptions?: RequestInit;
+    matchOptions?: CacheQueryOptions;
+}
+/**
+ * An implementation of a [cache-first]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#cache-falling-back-to-network}
+ * request strategy.
+ *
+ * A cache first strategy is useful for assets that have been revisioned,
+ * such as URLs like `/styles/example.a8f5f1.css`, since they
+ * can be cached for long periods of time.
+ *
+ * If the network request fails, and there is no cache match, this will throw
+ * a `WorkboxError` exception.
+ *
+ * @memberof module:workbox-strategies
+ */
+declare class CacheFirst implements RouteHandlerObject {
+    private readonly _cacheName;
+    private readonly _plugins;
+    private readonly _fetchOptions?;
+    private readonly _matchOptions?;
+    /**
+     * @param {Object} options
+     * @param {string} options.cacheName Cache name to store and retrieve
+     * requests. Defaults to cache names provided by
+     * [workbox-core]{@link module:workbox-core.cacheNames}.
+     * @param {Array<Object>} options.plugins [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}
+     * to use in conjunction with this caching strategy.
+     * @param {Object} options.fetchOptions Values passed along to the
+     * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)
+     * of all fetch() requests made by this strategy.
+     * @param {Object} options.matchOptions [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)
+     */
+    constructor(options?: CacheFirstOptions);
+    /**
+     * This method will perform a request strategy and follows an API that
+     * will work with the
+     * [Workbox Router]{@link module:workbox-routing.Router}.
+     *
+     * @param {Object} options
+     * @param {Request|string} options.request A request to run this strategy for.
+     * @param {Event} [options.event] The event that triggered the request.
+     * @return {Promise<Response>}
+     */
+    handle({ event, request }: RouteHandlerCallbackOptions): Promise<Response>;
+    /**
+     * Handles the network and cache part of CacheFirst.
+     *
+     * @param {Request} request
+     * @param {Event} [event]
+     * @return {Promise<Response>}
+     *
+     * @private
+     */
+    _getFromNetwork(request: Request, event?: ExtendableEvent): Promise<any>;
+}
+export { CacheFirst };

node_modules/workbox-strategies/CacheFirst.js

@@ -0,0 +1,157 @@
+/*
+  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.
+*/
+import { assert } from 'workbox-core/_private/assert.js';
+import { cacheNames } from 'workbox-core/_private/cacheNames.js';
+import { cacheWrapper } from 'workbox-core/_private/cacheWrapper.js';
+import { fetchWrapper } from 'workbox-core/_private/fetchWrapper.js';
+import { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';
+import { logger } from 'workbox-core/_private/logger.js';
+import { WorkboxError } from 'workbox-core/_private/WorkboxError.js';
+import { messages } from './utils/messages.js';
+import './_version.js';
+/**
+ * An implementation of a [cache-first]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#cache-falling-back-to-network}
+ * request strategy.
+ *
+ * A cache first strategy is useful for assets that have been revisioned,
+ * such as URLs like `/styles/example.a8f5f1.css`, since they
+ * can be cached for long periods of time.
+ *
+ * If the network request fails, and there is no cache match, this will throw
+ * a `WorkboxError` exception.
+ *
+ * @memberof module:workbox-strategies
+ */
+class CacheFirst {
+    /**
+     * @param {Object} options
+     * @param {string} options.cacheName Cache name to store and retrieve
+     * requests. Defaults to cache names provided by
+     * [workbox-core]{@link module:workbox-core.cacheNames}.
+     * @param {Array<Object>} options.plugins [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}
+     * to use in conjunction with this caching strategy.
+     * @param {Object} options.fetchOptions Values passed along to the
+     * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)
+     * of all fetch() requests made by this strategy.
+     * @param {Object} options.matchOptions [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)
+     */
+    constructor(options = {}) {
+        this._cacheName = cacheNames.getRuntimeName(options.cacheName);
+        this._plugins = options.plugins || [];
+        this._fetchOptions = options.fetchOptions;
+        this._matchOptions = options.matchOptions;
+    }
+    /**
+     * This method will perform a request strategy and follows an API that
+     * will work with the
+     * [Workbox Router]{@link module:workbox-routing.Router}.
+     *
+     * @param {Object} options
+     * @param {Request|string} options.request A request to run this strategy for.
+     * @param {Event} [options.event] The event that triggered the request.
+     * @return {Promise<Response>}
+     */
+    async handle({ event, request }) {
+        const logs = [];
+        if (typeof request === 'string') {
+            request = new Request(request);
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            assert.isInstance(request, Request, {
+                moduleName: 'workbox-strategies',
+                className: 'CacheFirst',
+                funcName: 'makeRequest',
+                paramName: 'request',
+            });
+        }
+        let response = await cacheWrapper.match({
+            cacheName: this._cacheName,
+            request,
+            event,
+            matchOptions: this._matchOptions,
+            plugins: this._plugins,
+        });
+        let error;
+        if (!response) {
+            if (process.env.NODE_ENV !== 'production') {
+                logs.push(`No response found in the '${this._cacheName}' cache. ` +
+                    `Will respond with a network request.`);
+            }
+            try {
+                response = await this._getFromNetwork(request, event);
+            }
+            catch (err) {
+                error = err;
+            }
+            if (process.env.NODE_ENV !== 'production') {
+                if (response) {
+                    logs.push(`Got response from network.`);
+                }
+                else {
+                    logs.push(`Unable to get a response from the network.`);
+                }
+            }
+        }
+        else {
+            if (process.env.NODE_ENV !== 'production') {
+                logs.push(`Found a cached response in the '${this._cacheName}' cache.`);
+            }
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            logger.groupCollapsed(messages.strategyStart('CacheFirst', request));
+            for (const log of logs) {
+                logger.log(log);
+            }
+            messages.printFinalResponse(response);
+            logger.groupEnd();
+        }
+        if (!response) {
+            throw new WorkboxError('no-response', { url: request.url, error });
+        }
+        return response;
+    }
+    /**
+     * Handles the network and cache part of CacheFirst.
+     *
+     * @param {Request} request
+     * @param {Event} [event]
+     * @return {Promise<Response>}
+     *
+     * @private
+     */
+    async _getFromNetwork(request, event) {
+        const response = await fetchWrapper.fetch({
+            request,
+            event,
+            fetchOptions: this._fetchOptions,
+            plugins: this._plugins,
+        });
+        // Keep the service worker while we put the request to the cache
+        const responseClone = response.clone();
+        const cachePutPromise = cacheWrapper.put({
+            cacheName: this._cacheName,
+            request,
+            response: responseClone,
+            event,
+            plugins: this._plugins,
+        });
+        if (event) {
+            try {
+                event.waitUntil(cachePutPromise);
+            }
+            catch (error) {
+                if (process.env.NODE_ENV !== 'production') {
+                    logger.warn(`Unable to ensure service worker stays alive when ` +
+                        `updating cache for '${getFriendlyURL(request.url)}'.`);
+                }
+            }
+        }
+        return response;
+    }
+}
+export { CacheFirst };

node_modules/workbox-strategies/CacheFirst.mjs

@@ -0,0 +1 @@
+export * from './CacheFirst.js';

node_modules/workbox-strategies/CacheOnly.d.ts

@@ -0,0 +1,46 @@
+import { RouteHandlerObject, RouteHandlerCallbackOptions, WorkboxPlugin } from 'workbox-core/types.js';
+import './_version.js';
+interface CacheOnlyOptions {
+    cacheName?: string;
+    plugins?: WorkboxPlugin[];
+    matchOptions?: CacheQueryOptions;
+}
+/**
+ * An implementation of a
+ * [cache-only]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#cache-only}
+ * request strategy.
+ *
+ * This class is useful if you want to take advantage of any
+ * [Workbox plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}.
+ *
+ * If there is no cache match, this will throw a `WorkboxError` exception.
+ *
+ * @memberof module:workbox-strategies
+ */
+declare class CacheOnly implements RouteHandlerObject {
+    private readonly _cacheName;
+    private readonly _plugins;
+    private readonly _matchOptions?;
+    /**
+     * @param {Object} options
+     * @param {string} options.cacheName Cache name to store and retrieve
+     * requests. Defaults to cache names provided by
+     * [workbox-core]{@link module:workbox-core.cacheNames}.
+     * @param {Array<Object>} options.plugins [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}
+     * to use in conjunction with this caching strategy.
+     * @param {Object} options.matchOptions [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)
+     */
+    constructor(options?: CacheOnlyOptions);
+    /**
+     * This method will perform a request strategy and follows an API that
+     * will work with the
+     * [Workbox Router]{@link module:workbox-routing.Router}.
+     *
+     * @param {Object} options
+     * @param {Request|string} options.request A request to run this strategy for.
+     * @param {Event} [options.event] The event that triggered the request.
+     * @return {Promise<Response>}
+     */
+    handle({ event, request }: RouteHandlerCallbackOptions): Promise<Response>;
+}
+export { CacheOnly };

node_modules/workbox-strategies/CacheOnly.js

@@ -0,0 +1,89 @@
+/*
+  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.
+*/
+import { assert } from 'workbox-core/_private/assert.js';
+import { cacheNames } from 'workbox-core/_private/cacheNames.js';
+import { cacheWrapper } from 'workbox-core/_private/cacheWrapper.js';
+import { logger } from 'workbox-core/_private/logger.js';
+import { WorkboxError } from 'workbox-core/_private/WorkboxError.js';
+import { messages } from './utils/messages.js';
+import './_version.js';
+/**
+ * An implementation of a
+ * [cache-only]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#cache-only}
+ * request strategy.
+ *
+ * This class is useful if you want to take advantage of any
+ * [Workbox plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}.
+ *
+ * If there is no cache match, this will throw a `WorkboxError` exception.
+ *
+ * @memberof module:workbox-strategies
+ */
+class CacheOnly {
+    /**
+     * @param {Object} options
+     * @param {string} options.cacheName Cache name to store and retrieve
+     * requests. Defaults to cache names provided by
+     * [workbox-core]{@link module:workbox-core.cacheNames}.
+     * @param {Array<Object>} options.plugins [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}
+     * to use in conjunction with this caching strategy.
+     * @param {Object} options.matchOptions [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)
+     */
+    constructor(options = {}) {
+        this._cacheName = cacheNames.getRuntimeName(options.cacheName);
+        this._plugins = options.plugins || [];
+        this._matchOptions = options.matchOptions;
+    }
+    /**
+     * This method will perform a request strategy and follows an API that
+     * will work with the
+     * [Workbox Router]{@link module:workbox-routing.Router}.
+     *
+     * @param {Object} options
+     * @param {Request|string} options.request A request to run this strategy for.
+     * @param {Event} [options.event] The event that triggered the request.
+     * @return {Promise<Response>}
+     */
+    async handle({ event, request }) {
+        if (typeof request === 'string') {
+            request = new Request(request);
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            assert.isInstance(request, Request, {
+                moduleName: 'workbox-strategies',
+                className: 'CacheOnly',
+                funcName: 'makeRequest',
+                paramName: 'request',
+            });
+        }
+        const response = await cacheWrapper.match({
+            cacheName: this._cacheName,
+            request,
+            event,
+            matchOptions: this._matchOptions,
+            plugins: this._plugins,
+        });
+        if (process.env.NODE_ENV !== 'production') {
+            logger.groupCollapsed(messages.strategyStart('CacheOnly', request));
+            if (response) {
+                logger.log(`Found a cached response in the '${this._cacheName}'` +
+                    ` cache.`);
+                messages.printFinalResponse(response);
+            }
+            else {
+                logger.log(`No response found in the '${this._cacheName}' cache.`);
+            }
+            logger.groupEnd();
+        }
+        if (!response) {
+            throw new WorkboxError('no-response', { url: request.url });
+        }
+        return response;
+    }
+}
+export { CacheOnly };

node_modules/workbox-strategies/CacheOnly.mjs

@@ -0,0 +1 @@
+export * from './CacheOnly.js';

node_modules/workbox-strategies/LICENSE

@@ -0,0 +1,19 @@
+Copyright 2018 Google LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/workbox-strategies/NetworkFirst.d.ts

@@ -0,0 +1,99 @@
+import { RouteHandlerObject, RouteHandlerCallbackOptions, WorkboxPlugin } from 'workbox-core/types.js';
+import './_version.js';
+interface NetworkFirstOptions {
+    cacheName?: string;
+    plugins?: WorkboxPlugin[];
+    fetchOptions?: RequestInit;
+    matchOptions?: CacheQueryOptions;
+    networkTimeoutSeconds?: number;
+}
+/**
+ * An implementation of a
+ * [network first]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#network-falling-back-to-cache}
+ * request strategy.
+ *
+ * By default, this strategy will cache responses with a 200 status code as
+ * well as [opaque responses]{@link https://developers.google.com/web/tools/workbox/guides/handle-third-party-requests}.
+ * Opaque responses are are cross-origin requests where the response doesn't
+ * support [CORS]{@link https://enable-cors.org/}.
+ *
+ * If the network request fails, and there is no cache match, this will throw
+ * a `WorkboxError` exception.
+ *
+ * @memberof module:workbox-strategies
+ */
+declare class NetworkFirst implements RouteHandlerObject {
+    private readonly _cacheName;
+    private readonly _plugins;
+    private readonly _fetchOptions?;
+    private readonly _matchOptions?;
+    private readonly _networkTimeoutSeconds;
+    /**
+     * @param {Object} options
+     * @param {string} options.cacheName Cache name to store and retrieve
+     * requests. Defaults to cache names provided by
+     * [workbox-core]{@link module:workbox-core.cacheNames}.
+     * @param {Array<Object>} options.plugins [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}
+     * to use in conjunction with this caching strategy.
+     * @param {Object} options.fetchOptions Values passed along to the
+     * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)
+     * of all fetch() requests made by this strategy.
+     * @param {Object} options.matchOptions [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)
+     * @param {number} options.networkTimeoutSeconds If set, any network requests
+     * that fail to respond within the timeout will fallback to the cache.
+     *
+     * This option can be used to combat
+     * "[lie-fi]{@link https://developers.google.com/web/fundamentals/performance/poor-connectivity/#lie-fi}"
+     * scenarios.
+     */
+    constructor(options?: NetworkFirstOptions);
+    /**
+     * This method will perform a request strategy and follows an API that
+     * will work with the
+     * [Workbox Router]{@link module:workbox-routing.Router}.
+     *
+     * @param {Object} options
+     * @param {Request|string} options.request A request to run this strategy for.
+     * @param {Event} [options.event] The event that triggered the request.
+     * @return {Promise<Response>}
+     */
+    handle({ event, request }: RouteHandlerCallbackOptions): Promise<Response>;
+    /**
+     * @param {Object} options
+     * @param {Request} options.request
+     * @param {Array} options.logs A reference to the logs array
+     * @param {Event} [options.event]
+     * @return {Promise<Response>}
+     *
+     * @private
+     */
+    private _getTimeoutPromise;
+    /**
+     * @param {Object} options
+     * @param {number|undefined} options.timeoutId
+     * @param {Request} options.request
+     * @param {Array} options.logs A reference to the logs Array.
+     * @param {Event} [options.event]
+     * @return {Promise<Response>}
+     *
+     * @private
+     */
+    _getNetworkPromise({ timeoutId, request, logs, event }: {
+        request: Request;
+        logs: any[];
+        timeoutId?: number;
+        event?: ExtendableEvent;
+    }): Promise<Response>;
+    /**
+     * Used if the network timeouts or fails to make the request.
+     *
+     * @param {Object} options
+     * @param {Request} request The request to match in the cache
+     * @param {Event} [options.event]
+     * @return {Promise<Object>}
+     *
+     * @private
+     */
+    private _respondFromCache;
+}
+export { NetworkFirst };

node_modules/workbox-strategies/NetworkFirst.js

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

node_modules/workbox-strategies/NetworkFirst.mjs

@@ -0,0 +1 @@
+export * from './NetworkFirst.js';

node_modules/workbox-strategies/NetworkOnly.d.ts

@@ -0,0 +1,46 @@
+import { RouteHandlerObject, RouteHandlerCallbackOptions, WorkboxPlugin } from 'workbox-core/types.js';
+import './_version.js';
+interface NetworkFirstOptions {
+    plugins?: WorkboxPlugin[];
+    fetchOptions?: RequestInit;
+}
+/**
+ * An implementation of a
+ * [network-only]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#network-only}
+ * request strategy.
+ *
+ * This class is useful if you want to take advantage of any
+ * [Workbox plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}.
+ *
+ * If the network request fails, this will throw a `WorkboxError` exception.
+ *
+ * @memberof module:workbox-strategies
+ */
+declare class NetworkOnly implements RouteHandlerObject {
+    private readonly _plugins;
+    private readonly _fetchOptions?;
+    /**
+     * @param {Object} options
+     * @param {string} options.cacheName Cache name to store and retrieve
+     * requests. Defaults to cache names provided by
+     * [workbox-core]{@link module:workbox-core.cacheNames}.
+     * @param {Array<Object>} options.plugins [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}
+     * to use in conjunction with this caching strategy.
+     * @param {Object} options.fetchOptions Values passed along to the
+     * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)
+     * of all fetch() requests made by this strategy.
+     */
+    constructor(options?: NetworkFirstOptions);
+    /**
+     * This method will perform a request strategy and follows an API that
+     * will work with the
+     * [Workbox Router]{@link module:workbox-routing.Router}.
+     *
+     * @param {Object} options
+     * @param {Request|string} options.request The request to run this strategy for.
+     * @param {Event} [options.event] The event that triggered the request.
+     * @return {Promise<Response>}
+     */
+    handle({ event, request }: RouteHandlerCallbackOptions): Promise<Response>;
+}
+export { NetworkOnly };

node_modules/workbox-strategies/NetworkOnly.js

@@ -0,0 +1,94 @@
+/*
+  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.
+*/
+import { assert } from 'workbox-core/_private/assert.js';
+import { fetchWrapper } from 'workbox-core/_private/fetchWrapper.js';
+import { logger } from 'workbox-core/_private/logger.js';
+import { WorkboxError } from 'workbox-core/_private/WorkboxError.js';
+import { messages } from './utils/messages.js';
+import './_version.js';
+/**
+ * An implementation of a
+ * [network-only]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#network-only}
+ * request strategy.
+ *
+ * This class is useful if you want to take advantage of any
+ * [Workbox plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}.
+ *
+ * If the network request fails, this will throw a `WorkboxError` exception.
+ *
+ * @memberof module:workbox-strategies
+ */
+class NetworkOnly {
+    /**
+     * @param {Object} options
+     * @param {string} options.cacheName Cache name to store and retrieve
+     * requests. Defaults to cache names provided by
+     * [workbox-core]{@link module:workbox-core.cacheNames}.
+     * @param {Array<Object>} options.plugins [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}
+     * to use in conjunction with this caching strategy.
+     * @param {Object} options.fetchOptions Values passed along to the
+     * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)
+     * of all fetch() requests made by this strategy.
+     */
+    constructor(options = {}) {
+        this._plugins = options.plugins || [];
+        this._fetchOptions = options.fetchOptions;
+    }
+    /**
+     * This method will perform a request strategy and follows an API that
+     * will work with the
+     * [Workbox Router]{@link module:workbox-routing.Router}.
+     *
+     * @param {Object} options
+     * @param {Request|string} options.request The request to run this strategy for.
+     * @param {Event} [options.event] The event that triggered the request.
+     * @return {Promise<Response>}
+     */
+    async handle({ event, request }) {
+        if (typeof request === 'string') {
+            request = new Request(request);
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            assert.isInstance(request, Request, {
+                moduleName: 'workbox-strategies',
+                className: 'NetworkOnly',
+                funcName: 'handle',
+                paramName: 'request',
+            });
+        }
+        let error;
+        let response;
+        try {
+            response = await fetchWrapper.fetch({
+                request,
+                event,
+                fetchOptions: this._fetchOptions,
+                plugins: this._plugins,
+            });
+        }
+        catch (err) {
+            error = err;
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            logger.groupCollapsed(messages.strategyStart('NetworkOnly', request));
+            if (response) {
+                logger.log(`Got response from network.`);
+            }
+            else {
+                logger.log(`Unable to get a response from the network.`);
+            }
+            messages.printFinalResponse(response);
+            logger.groupEnd();
+        }
+        if (!response) {
+            throw new WorkboxError('no-response', { url: request.url, error });
+        }
+        return response;
+    }
+}
+export { NetworkOnly };

node_modules/workbox-strategies/NetworkOnly.mjs

@@ -0,0 +1 @@
+export * from './NetworkOnly.js';

node_modules/workbox-strategies/README.md

@@ -0,0 +1 @@
+This module's documentation can be found at https://developers.google.com/web/tools/workbox/modules/workbox-strategies

node_modules/workbox-strategies/StaleWhileRevalidate.d.ts

@@ -0,0 +1,71 @@
+import { RouteHandlerObject, RouteHandlerCallbackOptions, WorkboxPlugin } from 'workbox-core/types.js';
+import './_version.js';
+interface StaleWhileRevalidateOptions {
+    cacheName?: string;
+    plugins?: WorkboxPlugin[];
+    fetchOptions?: RequestInit;
+    matchOptions?: CacheQueryOptions;
+}
+/**
+ * An implementation of a
+ * [stale-while-revalidate]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#stale-while-revalidate}
+ * request strategy.
+ *
+ * Resources are requested from both the cache and the network in parallel.
+ * The strategy will respond with the cached version if available, otherwise
+ * wait for the network response. The cache is updated with the network response
+ * with each successful request.
+ *
+ * By default, this strategy will cache responses with a 200 status code as
+ * well as [opaque responses]{@link https://developers.google.com/web/tools/workbox/guides/handle-third-party-requests}.
+ * Opaque responses are cross-origin requests where the response doesn't
+ * support [CORS]{@link https://enable-cors.org/}.
+ *
+ * If the network request fails, and there is no cache match, this will throw
+ * a `WorkboxError` exception.
+ *
+ * @memberof module:workbox-strategies
+ */
+declare class StaleWhileRevalidate implements RouteHandlerObject {
+    private readonly _cacheName;
+    private readonly _plugins;
+    private readonly _fetchOptions?;
+    private readonly _matchOptions?;
+    /**
+     * @param {Object} options
+     * @param {string} options.cacheName Cache name to store and retrieve
+     * requests. Defaults to cache names provided by
+     * [workbox-core]{@link module:workbox-core.cacheNames}.
+     * @param {Array<Object>} options.plugins [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}
+     * to use in conjunction with this caching strategy.
+     * @param {Object} options.fetchOptions Values passed along to the
+     * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)
+     * of all fetch() requests made by this strategy.
+     * @param {Object} options.matchOptions [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)
+     */
+    constructor(options?: StaleWhileRevalidateOptions);
+    /**
+     * This method will perform a request strategy and follows an API that
+     * will work with the
+     * [Workbox Router]{@link module:workbox-routing.Router}.
+     *
+     * @param {Object} options
+     * @param {Request|string} options.request A request to run this strategy for.
+     * @param {Event} [options.event] The event that triggered the request.
+     * @return {Promise<Response>}
+     */
+    handle({ event, request }: RouteHandlerCallbackOptions): Promise<Response>;
+    /**
+     * @param {Object} options
+     * @param {Request} options.request
+     * @param {Event} [options.event]
+     * @return {Promise<Response>}
+     *
+     * @private
+     */
+    _getFromNetwork({ request, event }: {
+        request: Request;
+        event?: ExtendableEvent;
+    }): Promise<Response>;
+}
+export { StaleWhileRevalidate };

node_modules/workbox-strategies/StaleWhileRevalidate.js

@@ -0,0 +1,176 @@
+/*
+  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.
+*/
+import { assert } from 'workbox-core/_private/assert.js';
+import { cacheNames } from 'workbox-core/_private/cacheNames.js';
+import { cacheWrapper } from 'workbox-core/_private/cacheWrapper.js';
+import { fetchWrapper } from 'workbox-core/_private/fetchWrapper.js';
+import { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';
+import { logger } from 'workbox-core/_private/logger.js';
+import { WorkboxError } from 'workbox-core/_private/WorkboxError.js';
+import { messages } from './utils/messages.js';
+import { cacheOkAndOpaquePlugin } from './plugins/cacheOkAndOpaquePlugin.js';
+import './_version.js';
+/**
+ * An implementation of a
+ * [stale-while-revalidate]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#stale-while-revalidate}
+ * request strategy.
+ *
+ * Resources are requested from both the cache and the network in parallel.
+ * The strategy will respond with the cached version if available, otherwise
+ * wait for the network response. The cache is updated with the network response
+ * with each successful request.
+ *
+ * By default, this strategy will cache responses with a 200 status code as
+ * well as [opaque responses]{@link https://developers.google.com/web/tools/workbox/guides/handle-third-party-requests}.
+ * Opaque responses are cross-origin requests where the response doesn't
+ * support [CORS]{@link https://enable-cors.org/}.
+ *
+ * If the network request fails, and there is no cache match, this will throw
+ * a `WorkboxError` exception.
+ *
+ * @memberof module:workbox-strategies
+ */
+class StaleWhileRevalidate {
+    /**
+     * @param {Object} options
+     * @param {string} options.cacheName Cache name to store and retrieve
+     * requests. Defaults to cache names provided by
+     * [workbox-core]{@link module:workbox-core.cacheNames}.
+     * @param {Array<Object>} options.plugins [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}
+     * to use in conjunction with this caching strategy.
+     * @param {Object} options.fetchOptions Values passed along to the
+     * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)
+     * of all fetch() requests made by this strategy.
+     * @param {Object} options.matchOptions [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)
+     */
+    constructor(options = {}) {
+        this._cacheName = cacheNames.getRuntimeName(options.cacheName);
+        this._plugins = options.plugins || [];
+        if (options.plugins) {
+            const isUsingCacheWillUpdate = options.plugins.some((plugin) => !!plugin.cacheWillUpdate);
+            this._plugins = isUsingCacheWillUpdate ?
+                options.plugins : [cacheOkAndOpaquePlugin, ...options.plugins];
+        }
+        else {
+            // No plugins passed in, use the default plugin.
+            this._plugins = [cacheOkAndOpaquePlugin];
+        }
+        this._fetchOptions = options.fetchOptions;
+        this._matchOptions = options.matchOptions;
+    }
+    /**
+     * This method will perform a request strategy and follows an API that
+     * will work with the
+     * [Workbox Router]{@link module:workbox-routing.Router}.
+     *
+     * @param {Object} options
+     * @param {Request|string} options.request A request to run this strategy for.
+     * @param {Event} [options.event] The event that triggered the request.
+     * @return {Promise<Response>}
+     */
+    async handle({ event, request }) {
+        const logs = [];
+        if (typeof request === 'string') {
+            request = new Request(request);
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            assert.isInstance(request, Request, {
+                moduleName: 'workbox-strategies',
+                className: 'StaleWhileRevalidate',
+                funcName: 'handle',
+                paramName: 'request',
+            });
+        }
+        const fetchAndCachePromise = this._getFromNetwork({ request, event });
+        let response = await cacheWrapper.match({
+            cacheName: this._cacheName,
+            request,
+            event,
+            matchOptions: this._matchOptions,
+            plugins: this._plugins,
+        });
+        let error;
+        if (response) {
+            if (process.env.NODE_ENV !== 'production') {
+                logs.push(`Found a cached response in the '${this._cacheName}'` +
+                    ` cache. Will update with the network response in the background.`);
+            }
+            if (event) {
+                try {
+                    event.waitUntil(fetchAndCachePromise);
+                }
+                catch (error) {
+                    if (process.env.NODE_ENV !== 'production') {
+                        logger.warn(`Unable to ensure service worker stays alive when ` +
+                            `updating cache for '${getFriendlyURL(request.url)}'.`);
+                    }
+                }
+            }
+        }
+        else {
+            if (process.env.NODE_ENV !== 'production') {
+                logs.push(`No response found in the '${this._cacheName}' cache. ` +
+                    `Will wait for the network response.`);
+            }
+            try {
+                response = await fetchAndCachePromise;
+            }
+            catch (err) {
+                error = err;
+            }
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            logger.groupCollapsed(messages.strategyStart('StaleWhileRevalidate', request));
+            for (const log of logs) {
+                logger.log(log);
+            }
+            messages.printFinalResponse(response);
+            logger.groupEnd();
+        }
+        if (!response) {
+            throw new WorkboxError('no-response', { url: request.url, error });
+        }
+        return response;
+    }
+    /**
+     * @param {Object} options
+     * @param {Request} options.request
+     * @param {Event} [options.event]
+     * @return {Promise<Response>}
+     *
+     * @private
+     */
+    async _getFromNetwork({ request, event }) {
+        const response = await fetchWrapper.fetch({
+            request,
+            event,
+            fetchOptions: this._fetchOptions,
+            plugins: this._plugins,
+        });
+        const cachePutPromise = cacheWrapper.put({
+            cacheName: this._cacheName,
+            request,
+            response: response.clone(),
+            event,
+            plugins: this._plugins,
+        });
+        if (event) {
+            try {
+                event.waitUntil(cachePutPromise);
+            }
+            catch (error) {
+                if (process.env.NODE_ENV !== 'production') {
+                    logger.warn(`Unable to ensure service worker stays alive when ` +
+                        `updating cache for '${getFriendlyURL(request.url)}'.`);
+                }
+            }
+        }
+        return response;
+    }
+}
+export { StaleWhileRevalidate };

node_modules/workbox-strategies/StaleWhileRevalidate.mjs

@@ -0,0 +1 @@
+export * from './StaleWhileRevalidate.js';

node_modules/workbox-strategies/_version.js

@@ -0,0 +1,6 @@
+"use strict";
+// @ts-ignore
+try {
+    self['workbox:strategies:5.1.4'] && _();
+}
+catch (e) { }

node_modules/workbox-strategies/_version.mjs

@@ -0,0 +1 @@
+try{self['workbox:strategies:5.1.4']&&_()}catch(e){}// eslint-disable-line

node_modules/workbox-strategies/build/workbox-strategies.dev.js

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

node_modules/workbox-strategies/build/workbox-strategies.prod.js

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

node_modules/workbox-strategies/index.d.ts

@@ -0,0 +1,13 @@
+import { CacheFirst } from './CacheFirst.js';
+import { CacheOnly } from './CacheOnly.js';
+import { NetworkFirst } from './NetworkFirst.js';
+import { NetworkOnly } from './NetworkOnly.js';
+import { StaleWhileRevalidate } from './StaleWhileRevalidate.js';
+import './_version.js';
+/**
+ * There are common caching strategies that most service workers will need
+ * and use. This module provides simple implementations of these strategies.
+ *
+ * @module workbox-strategies
+ */
+export { CacheFirst, CacheOnly, NetworkFirst, NetworkOnly, StaleWhileRevalidate, };

node_modules/workbox-strategies/index.js

@@ -0,0 +1,20 @@
+/*
+  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.
+*/
+import { CacheFirst } from './CacheFirst.js';
+import { CacheOnly } from './CacheOnly.js';
+import { NetworkFirst } from './NetworkFirst.js';
+import { NetworkOnly } from './NetworkOnly.js';
+import { StaleWhileRevalidate } from './StaleWhileRevalidate.js';
+import './_version.js';
+/**
+ * There are common caching strategies that most service workers will need
+ * and use. This module provides simple implementations of these strategies.
+ *
+ * @module workbox-strategies
+ */
+export { CacheFirst, CacheOnly, NetworkFirst, NetworkOnly, StaleWhileRevalidate, };

node_modules/workbox-strategies/index.mjs

@@ -0,0 +1 @@
+export * from './index.js';

node_modules/workbox-strategies/package.json

@@ -0,0 +1,68 @@
+{
+  "_from": "workbox-strategies@^5.1.4",
+  "_id": "workbox-strategies@5.1.4",
+  "_inBundle": false,
+  "_integrity": "sha512-VVS57LpaJTdjW3RgZvPwX0NlhNmscR7OQ9bP+N/34cYMDzXLyA6kqWffP6QKXSkca1OFo/v6v7hW7zrrguo6EA==",
+  "_location": "/workbox-strategies",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "workbox-strategies@^5.1.4",
+    "name": "workbox-strategies",
+    "escapedName": "workbox-strategies",
+    "rawSpec": "^5.1.4",
+    "saveSpec": null,
+    "fetchSpec": "^5.1.4"
+  },
+  "_requiredBy": [
+    "/workbox-build",
+    "/workbox-google-analytics"
+  ],
+  "_resolved": "https://registry.npmjs.org/workbox-strategies/-/workbox-strategies-5.1.4.tgz",
+  "_shasum": "96b1418ccdfde5354612914964074d466c52d08c",
+  "_spec": "workbox-strategies@^5.1.4",
+  "_where": "/Users/tylerkoenig/Code/personal/react-scss2/node_modules/workbox-build",
+  "author": {
+    "name": "Google's Web DevRel Team"
+  },
+  "bugs": {
+    "url": "https://github.com/googlechrome/workbox/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "workbox-core": "^5.1.4",
+    "workbox-routing": "^5.1.4"
+  },
+  "deprecated": false,
+  "description": "A service worker helper library implementing common caching strategies.",
+  "gitHead": "a95b6fd489c2a66574f1655b2de3acd2ece35fb3",
+  "homepage": "https://github.com/GoogleChrome/workbox",
+  "keywords": [
+    "workbox",
+    "workboxjs",
+    "service worker",
+    "sw",
+    "router",
+    "routing"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "module": "index.mjs",
+  "name": "workbox-strategies",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/googlechrome/workbox.git"
+  },
+  "scripts": {
+    "build": "gulp build-packages --package workbox-strategies",
+    "prepare": "npm run build",
+    "version": "npm run build"
+  },
+  "types": "index.d.ts",
+  "version": "5.1.4",
+  "workbox": {
+    "browserNamespace": "workbox.strategies",
+    "packageType": "browser"
+  }
+}

node_modules/workbox-strategies/plugins/cacheOkAndOpaquePlugin.d.ts

@@ -0,0 +1,3 @@
+import { WorkboxPlugin } from 'workbox-core/types.js';
+import '../_version.js';
+export declare const cacheOkAndOpaquePlugin: WorkboxPlugin;

node_modules/workbox-strategies/plugins/cacheOkAndOpaquePlugin.js

@@ -0,0 +1,26 @@
+/*
+  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.
+*/
+import '../_version.js';
+export const cacheOkAndOpaquePlugin = {
+    /**
+     * Returns a valid response (to allow caching) if the status is 200 (OK) or
+     * 0 (opaque).
+     *
+     * @param {Object} options
+     * @param {Response} options.response
+     * @return {Response|null}
+     *
+     * @private
+     */
+    cacheWillUpdate: async ({ response }) => {
+        if (response.status === 200 || response.status === 0) {
+            return response;
+        }
+        return null;
+    },
+};

node_modules/workbox-strategies/plugins/cacheOkAndOpaquePlugin.mjs

@@ -0,0 +1 @@
+export * from './cacheOkAndOpaquePlugin.js';

node_modules/workbox-strategies/src/CacheFirst.ts

@@ -0,0 +1,185 @@
+/*
+  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.
+*/
+
+import {assert} from 'workbox-core/_private/assert.js';
+import {cacheNames} from 'workbox-core/_private/cacheNames.js';
+import {cacheWrapper} from 'workbox-core/_private/cacheWrapper.js';
+import {fetchWrapper} from 'workbox-core/_private/fetchWrapper.js';
+import {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.js';
+import {logger} from 'workbox-core/_private/logger.js';
+import {WorkboxError} from 'workbox-core/_private/WorkboxError.js';
+import {RouteHandlerObject, RouteHandlerCallbackOptions, WorkboxPlugin} from 'workbox-core/types.js';
+import {messages} from './utils/messages.js';
+import './_version.js';
+
+
+interface CacheFirstOptions {
+  cacheName?: string;
+  plugins?: WorkboxPlugin[];
+  fetchOptions?: RequestInit;
+  matchOptions?: CacheQueryOptions;
+}
+
+/**
+ * An implementation of a [cache-first]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#cache-falling-back-to-network}
+ * request strategy.
+ *
+ * A cache first strategy is useful for assets that have been revisioned,
+ * such as URLs like `/styles/example.a8f5f1.css`, since they
+ * can be cached for long periods of time.
+ *
+ * If the network request fails, and there is no cache match, this will throw
+ * a `WorkboxError` exception.
+ *
+ * @memberof module:workbox-strategies
+ */
+class CacheFirst implements RouteHandlerObject {
+  private readonly _cacheName: string;
+  private readonly _plugins: WorkboxPlugin[];
+  private readonly _fetchOptions?: RequestInit;
+  private readonly _matchOptions?: CacheQueryOptions;
+
+  /**
+   * @param {Object} options
+   * @param {string} options.cacheName Cache name to store and retrieve
+   * requests. Defaults to cache names provided by
+   * [workbox-core]{@link module:workbox-core.cacheNames}.
+   * @param {Array<Object>} options.plugins [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}
+   * to use in conjunction with this caching strategy.
+   * @param {Object} options.fetchOptions Values passed along to the
+   * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)
+   * of all fetch() requests made by this strategy.
+   * @param {Object} options.matchOptions [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)
+   */
+  constructor(options: CacheFirstOptions = {}) {
+    this._cacheName = cacheNames.getRuntimeName(options.cacheName);
+    this._plugins = options.plugins || [];
+    this._fetchOptions = options.fetchOptions;
+    this._matchOptions = options.matchOptions;
+  }
+
+  /**
+   * This method will perform a request strategy and follows an API that
+   * will work with the
+   * [Workbox Router]{@link module:workbox-routing.Router}.
+   *
+   * @param {Object} options
+   * @param {Request|string} options.request A request to run this strategy for.
+   * @param {Event} [options.event] The event that triggered the request.
+   * @return {Promise<Response>}
+   */
+  async handle({event, request}: RouteHandlerCallbackOptions): Promise<Response> {
+    const logs = [];
+
+    if (typeof request === 'string') {
+      request = new Request(request);
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.isInstance(request, Request, {
+        moduleName: 'workbox-strategies',
+        className: 'CacheFirst',
+        funcName: 'makeRequest',
+        paramName: 'request',
+      });
+    }
+
+    let response = await cacheWrapper.match({
+      cacheName: this._cacheName,
+      request,
+      event,
+      matchOptions: this._matchOptions,
+      plugins: this._plugins,
+    });
+
+    let error;
+    if (!response) {
+      if (process.env.NODE_ENV !== 'production') {
+        logs.push(
+            `No response found in the '${this._cacheName}' cache. ` +
+          `Will respond with a network request.`);
+      }
+      try {
+        response = await this._getFromNetwork(request, event);
+      } catch (err) {
+        error = err;
+      }
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (response) {
+          logs.push(`Got response from network.`);
+        } else {
+          logs.push(`Unable to get a response from the network.`);
+        }
+      }
+    } else {
+      if (process.env.NODE_ENV !== 'production') {
+        logs.push(
+            `Found a cached response in the '${this._cacheName}' cache.`);
+      }
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      logger.groupCollapsed(
+          messages.strategyStart('CacheFirst', request));
+      for (const log of logs) {
+        logger.log(log);
+      }
+      messages.printFinalResponse(response);
+      logger.groupEnd();
+    }
+
+    if (!response) {
+      throw new WorkboxError('no-response', {url: request.url, error});
+    }
+    return response;
+  }
+
+  /**
+   * Handles the network and cache part of CacheFirst.
+   *
+   * @param {Request} request
+   * @param {Event} [event]
+   * @return {Promise<Response>}
+   *
+   * @private
+   */
+  async _getFromNetwork(request: Request, event?: ExtendableEvent) {
+    const response = await fetchWrapper.fetch({
+      request,
+      event,
+      fetchOptions: this._fetchOptions,
+      plugins: this._plugins,
+    });
+
+    // Keep the service worker while we put the request to the cache
+    const responseClone = response.clone();
+    const cachePutPromise = cacheWrapper.put({
+      cacheName: this._cacheName,
+      request,
+      response: responseClone,
+      event,
+      plugins: this._plugins,
+    });
+
+    if (event) {
+      try {
+        event.waitUntil(cachePutPromise);
+      } catch (error) {
+        if (process.env.NODE_ENV !== 'production') {
+          logger.warn(`Unable to ensure service worker stays alive when ` +
+            `updating cache for '${getFriendlyURL(request.url)}'.`);
+        }
+      }
+    }
+
+    return response;
+  }
+}
+
+export {CacheFirst};

node_modules/workbox-strategies/src/CacheOnly.ts

@@ -0,0 +1,109 @@
+/*
+  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.
+*/
+
+import {assert} from 'workbox-core/_private/assert.js';
+import {cacheNames} from 'workbox-core/_private/cacheNames.js';
+import {cacheWrapper} from 'workbox-core/_private/cacheWrapper.js';
+import {logger} from 'workbox-core/_private/logger.js';
+import {WorkboxError} from 'workbox-core/_private/WorkboxError.js';
+import {RouteHandlerObject, RouteHandlerCallbackOptions, WorkboxPlugin} from 'workbox-core/types.js';
+import {messages} from './utils/messages.js';
+import './_version.js';
+
+
+interface CacheOnlyOptions {
+  cacheName?: string;
+  plugins?: WorkboxPlugin[];
+  matchOptions?: CacheQueryOptions;
+}
+
+/**
+ * An implementation of a
+ * [cache-only]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#cache-only}
+ * request strategy.
+ *
+ * This class is useful if you want to take advantage of any
+ * [Workbox plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}.
+ *
+ * If there is no cache match, this will throw a `WorkboxError` exception.
+ *
+ * @memberof module:workbox-strategies
+ */
+class CacheOnly implements RouteHandlerObject {
+  private readonly _cacheName: string;
+  private readonly _plugins: WorkboxPlugin[];
+  private readonly _matchOptions?: CacheQueryOptions;
+
+  /**
+   * @param {Object} options
+   * @param {string} options.cacheName Cache name to store and retrieve
+   * requests. Defaults to cache names provided by
+   * [workbox-core]{@link module:workbox-core.cacheNames}.
+   * @param {Array<Object>} options.plugins [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}
+   * to use in conjunction with this caching strategy.
+   * @param {Object} options.matchOptions [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)
+   */
+  constructor(options: CacheOnlyOptions = {}) {
+    this._cacheName = cacheNames.getRuntimeName(options.cacheName);
+    this._plugins = options.plugins || [];
+    this._matchOptions = options.matchOptions;
+  }
+
+  /**
+   * This method will perform a request strategy and follows an API that
+   * will work with the
+   * [Workbox Router]{@link module:workbox-routing.Router}.
+   *
+   * @param {Object} options
+   * @param {Request|string} options.request A request to run this strategy for.
+   * @param {Event} [options.event] The event that triggered the request.
+   * @return {Promise<Response>}
+   */
+  async handle({event, request}: RouteHandlerCallbackOptions): Promise<Response> {
+    if (typeof request === 'string') {
+      request = new Request(request);
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.isInstance(request, Request, {
+        moduleName: 'workbox-strategies',
+        className: 'CacheOnly',
+        funcName: 'makeRequest',
+        paramName: 'request',
+      });
+    }
+
+    const response = await cacheWrapper.match({
+      cacheName: this._cacheName,
+      request,
+      event,
+      matchOptions: this._matchOptions,
+      plugins: this._plugins,
+    });
+
+    if (process.env.NODE_ENV !== 'production') {
+      logger.groupCollapsed(
+          messages.strategyStart('CacheOnly', request));
+      if (response) {
+        logger.log(`Found a cached response in the '${this._cacheName}'` +
+          ` cache.`);
+        messages.printFinalResponse(response);
+      } else {
+        logger.log(`No response found in the '${this._cacheName}' cache.`);
+      }
+      logger.groupEnd();
+    }
+
+    if (!response) {
+      throw new WorkboxError('no-response', {url: request.url});
+    }
+    return response;
+  }
+}
+
+export {CacheOnly};

node_modules/workbox-strategies/src/NetworkFirst.ts

@@ -0,0 +1,306 @@
+/*
+  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.
+*/
+
+import {assert} from 'workbox-core/_private/assert.js';
+import {cacheNames} from 'workbox-core/_private/cacheNames.js';
+import {cacheWrapper} from 'workbox-core/_private/cacheWrapper.js';
+import {fetchWrapper} from 'workbox-core/_private/fetchWrapper.js';
+import {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.js';
+import {logger} from 'workbox-core/_private/logger.js';
+import {WorkboxError} from 'workbox-core/_private/WorkboxError.js';
+import {RouteHandlerObject, RouteHandlerCallbackOptions, WorkboxPlugin} from 'workbox-core/types.js';
+import {messages} from './utils/messages.js';
+import {cacheOkAndOpaquePlugin} from './plugins/cacheOkAndOpaquePlugin.js';
+import './_version.js';
+
+
+interface NetworkFirstOptions {
+  cacheName?: string;
+  plugins?: WorkboxPlugin[];
+  fetchOptions?: RequestInit;
+  matchOptions?: CacheQueryOptions;
+  networkTimeoutSeconds?: number;
+}
+
+/**
+ * An implementation of a
+ * [network first]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#network-falling-back-to-cache}
+ * request strategy.
+ *
+ * By default, this strategy will cache responses with a 200 status code as
+ * well as [opaque responses]{@link https://developers.google.com/web/tools/workbox/guides/handle-third-party-requests}.
+ * Opaque responses are are cross-origin requests where the response doesn't
+ * support [CORS]{@link https://enable-cors.org/}.
+ *
+ * If the network request fails, and there is no cache match, this will throw
+ * a `WorkboxError` exception.
+ *
+ * @memberof module:workbox-strategies
+ */
+class NetworkFirst implements RouteHandlerObject {
+  private readonly _cacheName: string;
+  private readonly _plugins: WorkboxPlugin[];
+  private readonly _fetchOptions?: RequestInit;
+  private readonly _matchOptions?: CacheQueryOptions;
+  private readonly _networkTimeoutSeconds: number;
+
+  /**
+   * @param {Object} options
+   * @param {string} options.cacheName Cache name to store and retrieve
+   * requests. Defaults to cache names provided by
+   * [workbox-core]{@link module:workbox-core.cacheNames}.
+   * @param {Array<Object>} options.plugins [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}
+   * to use in conjunction with this caching strategy.
+   * @param {Object} options.fetchOptions Values passed along to the
+   * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)
+   * of all fetch() requests made by this strategy.
+   * @param {Object} options.matchOptions [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)
+   * @param {number} options.networkTimeoutSeconds If set, any network requests
+   * that fail to respond within the timeout will fallback to the cache.
+   *
+   * This option can be used to combat
+   * "[lie-fi]{@link https://developers.google.com/web/fundamentals/performance/poor-connectivity/#lie-fi}"
+   * scenarios.
+   */
+  constructor(options: NetworkFirstOptions = {}) {
+    this._cacheName = cacheNames.getRuntimeName(options.cacheName);
+
+    if (options.plugins) {
+      const isUsingCacheWillUpdate =
+        options.plugins.some((plugin) => !!plugin.cacheWillUpdate);
+      this._plugins = isUsingCacheWillUpdate ?
+        options.plugins : [cacheOkAndOpaquePlugin, ...options.plugins];
+    } else {
+      // No plugins passed in, use the default plugin.
+      this._plugins = [cacheOkAndOpaquePlugin];
+    }
+
+    this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;
+    if (process.env.NODE_ENV !== 'production') {
+      if (this._networkTimeoutSeconds) {
+        assert!.isType(this._networkTimeoutSeconds, 'number', {
+          moduleName: 'workbox-strategies',
+          className: 'NetworkFirst',
+          funcName: 'constructor',
+          paramName: 'networkTimeoutSeconds',
+        });
+      }
+    }
+
+    this._fetchOptions = options.fetchOptions;
+    this._matchOptions = options.matchOptions;
+  }
+
+  /**
+   * This method will perform a request strategy and follows an API that
+   * will work with the
+   * [Workbox Router]{@link module:workbox-routing.Router}.
+   *
+   * @param {Object} options
+   * @param {Request|string} options.request A request to run this strategy for.
+   * @param {Event} [options.event] The event that triggered the request.
+   * @return {Promise<Response>}
+   */
+  async handle({event, request}: RouteHandlerCallbackOptions): Promise<Response> {
+    const logs: any[] = [];
+   
+    if (typeof request === 'string') {
+      request = new Request(request);
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.isInstance(request, Request, {
+        moduleName: 'workbox-strategies',
+        className: 'NetworkFirst',
+        funcName: 'handle',
+        paramName: 'makeRequest',
+      });
+    }
+
+    const promises = [];
+    let timeoutId: number | undefined;
+
+    if (this._networkTimeoutSeconds) {
+      const {id, promise} = this._getTimeoutPromise({request, event, logs});
+      timeoutId = id;
+      promises.push(promise);
+    }
+
+    const networkPromise =
+        this._getNetworkPromise({timeoutId, request, event, logs});
+    promises.push(networkPromise);
+
+    // Promise.race() will resolve as soon as the first promise resolves.
+    let response = await Promise.race(promises);
+    // If Promise.race() resolved with null, it might be due to a network
+    // timeout + a cache miss. If that were to happen, we'd rather wait until
+    // the networkPromise resolves instead of returning null.
+    // Note that it's fine to await an already-resolved promise, so we don't
+    // have to check to see if it's still "in flight".
+    if (!response) {
+      response = await networkPromise;
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      logger.groupCollapsed(
+          messages.strategyStart('NetworkFirst', request));
+      for (const log of logs) {
+        logger.log(log);
+      }
+      messages.printFinalResponse(response);
+      logger.groupEnd();
+    }
+
+    if (!response) {
+      throw new WorkboxError('no-response', {url: request.url});
+    }
+    return response;
+  }
+
+  /**
+   * @param {Object} options
+   * @param {Request} options.request
+   * @param {Array} options.logs A reference to the logs array
+   * @param {Event} [options.event]
+   * @return {Promise<Response>}
+   *
+   * @private
+   */
+  private _getTimeoutPromise({request, logs, event}: {
+    request: Request;
+    logs: any[];
+    event?: ExtendableEvent;
+  }): {promise: Promise<Response | undefined>; id?: number} {
+    let timeoutId;
+    const timeoutPromise: Promise<Response | undefined> = new Promise((resolve) => {
+      const onNetworkTimeout = async () => {
+        if (process.env.NODE_ENV !== 'production') {
+          logs.push(`Timing out the network response at ` +
+            `${this._networkTimeoutSeconds} seconds.`);
+        }
+
+        resolve(await this._respondFromCache({request, event}));
+      };
+
+      timeoutId = setTimeout(
+          onNetworkTimeout,
+          this._networkTimeoutSeconds * 1000,
+      );
+    });
+
+    return {
+      promise: timeoutPromise,
+      id: timeoutId,
+    };
+  }
+
+  /**
+   * @param {Object} options
+   * @param {number|undefined} options.timeoutId
+   * @param {Request} options.request
+   * @param {Array} options.logs A reference to the logs Array.
+   * @param {Event} [options.event]
+   * @return {Promise<Response>}
+   *
+   * @private
+   */
+  async _getNetworkPromise({timeoutId, request, logs, event}: {
+    request: Request;
+    logs: any[];
+    timeoutId?: number;
+    event?: ExtendableEvent;
+  }): Promise<Response> {
+    let error;
+    let response;
+    try {
+      response = await fetchWrapper.fetch({
+        request,
+        event,
+        fetchOptions: this._fetchOptions,
+        plugins: this._plugins,
+      });
+    } catch (err) {
+      error = err;
+    }
+
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      if (response) {
+        logs.push(`Got response from network.`);
+      } else {
+        logs.push(`Unable to get a response from the network. Will respond ` +
+          `with a cached response.`);
+      }
+    }
+
+    if (error || !response) {
+      response = await this._respondFromCache({request, event});
+      if (process.env.NODE_ENV !== 'production') {
+        if (response) {
+          logs.push(`Found a cached response in the '${this._cacheName}'` +
+            ` cache.`);
+        } else {
+          logs.push(`No response found in the '${this._cacheName}' cache.`);
+        }
+      }
+    } else {
+      // Keep the service worker alive while we put the request in the cache
+      const responseClone = response.clone();
+      const cachePut = cacheWrapper.put({
+        cacheName: this._cacheName,
+        request,
+        response: responseClone,
+        event,
+        plugins: this._plugins,
+      });
+
+      if (event) {
+        try {
+          // The event has been responded to so we can keep the SW alive to
+          // respond to the request
+          event.waitUntil(cachePut);
+        } catch (err) {
+          if (process.env.NODE_ENV !== 'production') {
+            logger.warn(`Unable to ensure service worker stays alive when ` +
+              `updating cache for '${getFriendlyURL(request.url)}'.`);
+          }
+        }
+      }
+    }
+
+    return response;
+  }
+
+  /**
+   * Used if the network timeouts or fails to make the request.
+   *
+   * @param {Object} options
+   * @param {Request} request The request to match in the cache
+   * @param {Event} [options.event]
+   * @return {Promise<Object>}
+   *
+   * @private
+   */
+  private _respondFromCache({event, request}: {
+    request: Request;
+    event?: ExtendableEvent;
+  }): Promise<Response | undefined> {
+    return cacheWrapper.match({
+      cacheName: this._cacheName,
+      request,
+      event,
+      matchOptions: this._matchOptions,
+      plugins: this._plugins,
+    });
+  }
+}
+
+export {NetworkFirst};

node_modules/workbox-strategies/src/NetworkOnly.ts

@@ -0,0 +1,111 @@
+/*
+  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.
+*/
+
+import {assert} from 'workbox-core/_private/assert.js';
+import {fetchWrapper} from 'workbox-core/_private/fetchWrapper.js';
+import {logger} from 'workbox-core/_private/logger.js';
+import {WorkboxError} from 'workbox-core/_private/WorkboxError.js';
+import {RouteHandlerObject, RouteHandlerCallbackOptions, WorkboxPlugin} from 'workbox-core/types.js';
+import {messages} from './utils/messages.js';
+import './_version.js';
+
+
+interface NetworkFirstOptions {
+  plugins?: WorkboxPlugin[];
+  fetchOptions?: RequestInit;
+}
+
+/**
+ * An implementation of a
+ * [network-only]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#network-only}
+ * request strategy.
+ *
+ * This class is useful if you want to take advantage of any
+ * [Workbox plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}.
+ *
+ * If the network request fails, this will throw a `WorkboxError` exception.
+ *
+ * @memberof module:workbox-strategies
+ */
+class NetworkOnly implements RouteHandlerObject {
+  private readonly _plugins: WorkboxPlugin[];
+  private readonly _fetchOptions?: RequestInit;
+
+  /**
+   * @param {Object} options
+   * @param {string} options.cacheName Cache name to store and retrieve
+   * requests. Defaults to cache names provided by
+   * [workbox-core]{@link module:workbox-core.cacheNames}.
+   * @param {Array<Object>} options.plugins [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}
+   * to use in conjunction with this caching strategy.
+   * @param {Object} options.fetchOptions Values passed along to the
+   * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)
+   * of all fetch() requests made by this strategy.
+   */
+  constructor(options: NetworkFirstOptions = {}) {
+    this._plugins = options.plugins || [];
+    this._fetchOptions = options.fetchOptions;
+  }
+
+  /**
+   * This method will perform a request strategy and follows an API that
+   * will work with the
+   * [Workbox Router]{@link module:workbox-routing.Router}.
+   *
+   * @param {Object} options
+   * @param {Request|string} options.request The request to run this strategy for.
+   * @param {Event} [options.event] The event that triggered the request.
+   * @return {Promise<Response>}
+   */
+  async handle({event, request}: RouteHandlerCallbackOptions): Promise<Response> {
+    if (typeof request === 'string') {
+      request = new Request(request);
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.isInstance(request, Request, {
+        moduleName: 'workbox-strategies',
+        className: 'NetworkOnly',
+        funcName: 'handle',
+        paramName: 'request',
+      });
+    }
+
+    let error;
+    let response;
+    try {
+      response = await fetchWrapper.fetch({
+        request,
+        event,
+        fetchOptions: this._fetchOptions,
+        plugins: this._plugins,
+      });
+    } catch (err) {
+      error = err;
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      logger.groupCollapsed(
+          messages.strategyStart('NetworkOnly', request));
+      if (response) {
+        logger.log(`Got response from network.`);
+      } else {
+        logger.log(`Unable to get a response from the network.`);
+      }
+      messages.printFinalResponse(response);
+      logger.groupEnd();
+    }
+
+    if (!response) {
+      throw new WorkboxError('no-response', {url: request.url, error});
+    }
+    return response;
+  }
+}
+
+export {NetworkOnly};

node_modules/workbox-strategies/src/StaleWhileRevalidate.ts

@@ -0,0 +1,207 @@
+/*
+  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.
+*/
+
+import {assert} from 'workbox-core/_private/assert.js';
+import {cacheNames} from 'workbox-core/_private/cacheNames.js';
+import {cacheWrapper} from 'workbox-core/_private/cacheWrapper.js';
+import {fetchWrapper} from 'workbox-core/_private/fetchWrapper.js';
+import {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.js';
+import {logger} from 'workbox-core/_private/logger.js';
+import {WorkboxError} from 'workbox-core/_private/WorkboxError.js';
+import {RouteHandlerObject, RouteHandlerCallbackOptions, WorkboxPlugin} from 'workbox-core/types.js';
+import {messages} from './utils/messages.js';
+import {cacheOkAndOpaquePlugin} from './plugins/cacheOkAndOpaquePlugin.js';
+import './_version.js';
+
+
+interface StaleWhileRevalidateOptions {
+  cacheName?: string;
+  plugins?: WorkboxPlugin[];
+  fetchOptions?: RequestInit;
+  matchOptions?: CacheQueryOptions;
+}
+
+/**
+ * An implementation of a
+ * [stale-while-revalidate]{@link https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook/#stale-while-revalidate}
+ * request strategy.
+ *
+ * Resources are requested from both the cache and the network in parallel.
+ * The strategy will respond with the cached version if available, otherwise
+ * wait for the network response. The cache is updated with the network response
+ * with each successful request.
+ *
+ * By default, this strategy will cache responses with a 200 status code as
+ * well as [opaque responses]{@link https://developers.google.com/web/tools/workbox/guides/handle-third-party-requests}.
+ * Opaque responses are cross-origin requests where the response doesn't
+ * support [CORS]{@link https://enable-cors.org/}.
+ *
+ * If the network request fails, and there is no cache match, this will throw
+ * a `WorkboxError` exception.
+ *
+ * @memberof module:workbox-strategies
+ */
+class StaleWhileRevalidate implements RouteHandlerObject {
+  private readonly _cacheName: string;
+  private readonly _plugins: WorkboxPlugin[];
+  private readonly _fetchOptions?: RequestInit;
+  private readonly _matchOptions?: CacheQueryOptions;
+
+  /**
+   * @param {Object} options
+   * @param {string} options.cacheName Cache name to store and retrieve
+   * requests. Defaults to cache names provided by
+   * [workbox-core]{@link module:workbox-core.cacheNames}.
+   * @param {Array<Object>} options.plugins [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins}
+   * to use in conjunction with this caching strategy.
+   * @param {Object} options.fetchOptions Values passed along to the
+   * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)
+   * of all fetch() requests made by this strategy.
+   * @param {Object} options.matchOptions [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)
+   */
+  constructor(options: StaleWhileRevalidateOptions = {}) {
+    this._cacheName = cacheNames.getRuntimeName(options.cacheName);
+    this._plugins = options.plugins || [];
+
+    if (options.plugins) {
+      const isUsingCacheWillUpdate =
+        options.plugins.some((plugin) => !!plugin.cacheWillUpdate);
+      this._plugins = isUsingCacheWillUpdate ?
+        options.plugins : [cacheOkAndOpaquePlugin, ...options.plugins];
+    } else {
+      // No plugins passed in, use the default plugin.
+      this._plugins = [cacheOkAndOpaquePlugin];
+    }
+
+    this._fetchOptions = options.fetchOptions;
+    this._matchOptions = options.matchOptions;
+  }
+
+  /**
+   * This method will perform a request strategy and follows an API that
+   * will work with the
+   * [Workbox Router]{@link module:workbox-routing.Router}.
+   *
+   * @param {Object} options
+   * @param {Request|string} options.request A request to run this strategy for.
+   * @param {Event} [options.event] The event that triggered the request.
+   * @return {Promise<Response>}
+   */
+  async handle({event, request}: RouteHandlerCallbackOptions): Promise<Response> {
+    const logs = [];
+
+    if (typeof request === 'string') {
+      request = new Request(request);
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.isInstance(request, Request, {
+        moduleName: 'workbox-strategies',
+        className: 'StaleWhileRevalidate',
+        funcName: 'handle',
+        paramName: 'request',
+      });
+    }
+
+    const fetchAndCachePromise = this._getFromNetwork({request, event});
+
+    let response = await cacheWrapper.match({
+      cacheName: this._cacheName,
+      request,
+      event,
+      matchOptions: this._matchOptions,
+      plugins: this._plugins,
+    });
+    let error;
+    if (response) {
+      if (process.env.NODE_ENV !== 'production') {
+        logs.push(`Found a cached response in the '${this._cacheName}'` +
+          ` cache. Will update with the network response in the background.`);
+      }
+
+      if (event) {
+        try {
+          event.waitUntil(fetchAndCachePromise);
+        } catch (error) {
+          if (process.env.NODE_ENV !== 'production') {
+            logger.warn(`Unable to ensure service worker stays alive when ` +
+              `updating cache for '${getFriendlyURL(request.url)}'.`);
+          }
+        }
+      }
+    } else {
+      if (process.env.NODE_ENV !== 'production') {
+        logs.push(`No response found in the '${this._cacheName}' cache. ` +
+          `Will wait for the network response.`);
+      }
+      try {
+        response = await fetchAndCachePromise;
+      } catch (err) {
+        error = err;
+      }
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      logger.groupCollapsed(
+          messages.strategyStart('StaleWhileRevalidate', request));
+      for (const log of logs) {
+        logger.log(log);
+      }
+      messages.printFinalResponse(response);
+      logger.groupEnd();
+    }
+
+    if (!response) {
+      throw new WorkboxError('no-response', {url: request.url, error});
+    }
+    return response;
+  }
+
+  /**
+   * @param {Object} options
+   * @param {Request} options.request
+   * @param {Event} [options.event]
+   * @return {Promise<Response>}
+   *
+   * @private
+   */
+  async _getFromNetwork({request, event}: {
+    request: Request;
+    event?: ExtendableEvent;
+  }): Promise<Response> {
+    const response = await fetchWrapper.fetch({
+      request,
+      event,
+      fetchOptions: this._fetchOptions,
+      plugins: this._plugins,
+    });
+
+    const cachePutPromise = cacheWrapper.put({
+      cacheName: this._cacheName,
+      request,
+      response: response.clone(),
+      event,
+      plugins: this._plugins,
+    });
+
+    if (event) {
+      try {
+        event.waitUntil(cachePutPromise);
+      } catch (error) {
+        if (process.env.NODE_ENV !== 'production') {
+          logger.warn(`Unable to ensure service worker stays alive when ` +
+            `updating cache for '${getFriendlyURL(request.url)}'.`);
+        }
+      }
+    }
+
+    return response;
+  }
+}
+
+export {StaleWhileRevalidate};

node_modules/workbox-strategies/src/_version.ts

@@ -0,0 +1,2 @@
+// @ts-ignore
+try{self['workbox:strategies:5.1.4']&&_()}catch(e){}

node_modules/workbox-strategies/src/index.ts

@@ -0,0 +1,31 @@
+/*
+  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.
+*/
+
+import {CacheFirst} from './CacheFirst.js';
+import {CacheOnly} from './CacheOnly.js';
+import {NetworkFirst} from './NetworkFirst.js';
+import {NetworkOnly} from './NetworkOnly.js';
+import {StaleWhileRevalidate} from './StaleWhileRevalidate.js';
+import './_version.js';
+
+
+/**
+ * There are common caching strategies that most service workers will need
+ * and use. This module provides simple implementations of these strategies.
+ *
+ * @module workbox-strategies
+ */
+
+export {
+  CacheFirst,
+  CacheOnly,
+  NetworkFirst,
+  NetworkOnly,
+  StaleWhileRevalidate,
+};
+

node_modules/workbox-strategies/src/plugins/cacheOkAndOpaquePlugin.ts

@@ -0,0 +1,30 @@
+/*
+  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.
+*/
+
+import {WorkboxPlugin} from 'workbox-core/types.js';
+import '../_version.js';
+
+
+export const cacheOkAndOpaquePlugin: WorkboxPlugin = {
+  /**
+   * Returns a valid response (to allow caching) if the status is 200 (OK) or
+   * 0 (opaque).
+   *
+   * @param {Object} options
+   * @param {Response} options.response
+   * @return {Response|null}
+   *
+   * @private
+   */
+  cacheWillUpdate: async ({response}) => {
+    if (response.status === 200 || response.status === 0) {
+      return response;
+    }
+    return null;
+  },
+};

node_modules/workbox-strategies/src/utils/messages.ts

@@ -0,0 +1,24 @@
+/*
+  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.
+*/
+
+import {logger} from 'workbox-core/_private/logger.js';
+import {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.js';
+import '../_version.js';
+
+
+export const messages = {
+  strategyStart: (strategyName: string, request: Request) =>
+    `Using ${strategyName} to respond to '${getFriendlyURL(request.url)}'`,
+  printFinalResponse: (response?: Response) => {
+    if (response) {
+      logger.groupCollapsed(`View the final response here.`);
+      logger.log(response || '[No response returned]');
+      logger.groupEnd();
+    }
+  },
+};

node_modules/workbox-strategies/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../tsconfig",
+  "compilerOptions": {
+    "outDir": "./",
+    "rootDir": "./src",
+    "tsBuildInfoFile": "./tsconfig.tsbuildinfo"
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "references": [
+    { "path": "../workbox-core/" }
+  ]
+}

node_modules/workbox-strategies/utils/messages.d.ts

@@ -0,0 +1,5 @@
+import '../_version.js';
+export declare const messages: {
+    strategyStart: (strategyName: string, request: Request) => string;
+    printFinalResponse: (response?: Response | undefined) => void;
+};

node_modules/workbox-strategies/utils/messages.js

@@ -0,0 +1,20 @@
+/*
+  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.
+*/
+import { logger } from 'workbox-core/_private/logger.js';
+import { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';
+import '../_version.js';
+export const messages = {
+    strategyStart: (strategyName, request) => `Using ${strategyName} to respond to '${getFriendlyURL(request.url)}'`,
+    printFinalResponse: (response) => {
+        if (response) {
+            logger.groupCollapsed(`View the final response here.`);
+            logger.log(response || '[No response returned]');
+            logger.groupEnd();
+        }
+    },
+};

node_modules/workbox-strategies/utils/messages.mjs

@@ -0,0 +1 @@
+export * from './messages.js';