applying transfer to react app

node_modules/workbox-broadcast-update/BroadcastCacheUpdate.d.ts

@@ -0,0 +1,65 @@
+import { CacheDidUpdateCallbackParam } from 'workbox-core/types.js';
+import './_version.js';
+export interface BroadcastCacheUpdateOptions {
+    headersToCheck?: string[];
+    generatePayload?: (options: CacheDidUpdateCallbackParam) => Record<string, any>;
+}
+/**
+ * Uses the `postMessage()` API to inform any open windows/tabs when a cached
+ * response has been updated.
+ *
+ * For efficiency's sake, the underlying response bodies are not compared;
+ * only specific response headers are checked.
+ *
+ * @memberof module:workbox-broadcast-update
+ */
+declare class BroadcastCacheUpdate {
+    private readonly _headersToCheck;
+    private readonly _generatePayload;
+    /**
+     * Construct a BroadcastCacheUpdate instance with a specific `channelName` to
+     * broadcast messages on
+     *
+     * @param {Object} options
+     * @param {Array<string>} [options.headersToCheck=['content-length', 'etag', 'last-modified']]
+     *     A list of headers that will be used to determine whether the responses
+     *     differ.
+     * @param {string} [options.generatePayload] A function whose return value
+     *     will be used as the `payload` field in any cache update messages sent
+     *     to the window clients.
+     */
+    constructor({ headersToCheck, generatePayload, }?: BroadcastCacheUpdateOptions);
+    /**
+     * Compares two [Responses](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+     * and sends a message (via `postMessage()`) to all window clients if the
+     * responses differ (note: neither of the Responses can be
+     * {@link http://stackoverflow.com/questions/39109789|opaque}).
+     *
+     * The message that's posted has the following format (where `payload` can
+     * be customized via the `generatePayload` option the instance is created
+     * with):
+     *
+     * ```
+     * {
+     *   type: 'CACHE_UPDATED',
+     *   meta: 'workbox-broadcast-update',
+     *   payload: {
+     *     cacheName: 'the-cache-name',
+     *     updatedURL: 'https://example.com/'
+     *   }
+     * }
+     * ```
+     *
+     * @param {Object} options
+     * @param {Response} [options.oldResponse] Cached response to compare.
+     * @param {Response} options.newResponse Possibly updated response to compare.
+     * @param {Request} options.request The request.
+     * @param {string} options.cacheName Name of the cache the responses belong
+     *     to. This is included in the broadcast message.
+     * @param {Event} [options.event] event An optional event that triggered
+     *     this possible cache update.
+     * @return {Promise} Resolves once the update is sent.
+     */
+    notifyIfUpdated(options: CacheDidUpdateCallbackParam): Promise<void>;
+}
+export { BroadcastCacheUpdate };

node_modules/workbox-broadcast-update/BroadcastCacheUpdate.js

@@ -0,0 +1,151 @@
+/*
+  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 { timeout } from 'workbox-core/_private/timeout.js';
+import { resultingClientExists } from 'workbox-core/_private/resultingClientExists.js';
+import { logger } from 'workbox-core/_private/logger.js';
+import { responsesAreSame } from './responsesAreSame.js';
+import { CACHE_UPDATED_MESSAGE_TYPE, CACHE_UPDATED_MESSAGE_META, DEFAULT_HEADERS_TO_CHECK } from './utils/constants.js';
+import './_version.js';
+// UA-sniff Safari: https://stackoverflow.com/questions/7944460/detect-safari-browser
+// TODO(philipwalton): remove once this Safari bug fix has been released.
+// https://bugs.webkit.org/show_bug.cgi?id=201169
+const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+/**
+ * Generates the default payload used in update messages. By default the
+ * payload includes the `cacheName` and `updatedURL` fields.
+ *
+ * @return Object
+ * @private
+ */
+function defaultPayloadGenerator(data) {
+    return {
+        cacheName: data.cacheName,
+        updatedURL: data.request.url,
+    };
+}
+/**
+ * Uses the `postMessage()` API to inform any open windows/tabs when a cached
+ * response has been updated.
+ *
+ * For efficiency's sake, the underlying response bodies are not compared;
+ * only specific response headers are checked.
+ *
+ * @memberof module:workbox-broadcast-update
+ */
+class BroadcastCacheUpdate {
+    /**
+     * Construct a BroadcastCacheUpdate instance with a specific `channelName` to
+     * broadcast messages on
+     *
+     * @param {Object} options
+     * @param {Array<string>} [options.headersToCheck=['content-length', 'etag', 'last-modified']]
+     *     A list of headers that will be used to determine whether the responses
+     *     differ.
+     * @param {string} [options.generatePayload] A function whose return value
+     *     will be used as the `payload` field in any cache update messages sent
+     *     to the window clients.
+     */
+    constructor({ headersToCheck, generatePayload, } = {}) {
+        this._headersToCheck = headersToCheck || DEFAULT_HEADERS_TO_CHECK;
+        this._generatePayload = generatePayload || defaultPayloadGenerator;
+    }
+    /**
+     * Compares two [Responses](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+     * and sends a message (via `postMessage()`) to all window clients if the
+     * responses differ (note: neither of the Responses can be
+     * {@link http://stackoverflow.com/questions/39109789|opaque}).
+     *
+     * The message that's posted has the following format (where `payload` can
+     * be customized via the `generatePayload` option the instance is created
+     * with):
+     *
+     * ```
+     * {
+     *   type: 'CACHE_UPDATED',
+     *   meta: 'workbox-broadcast-update',
+     *   payload: {
+     *     cacheName: 'the-cache-name',
+     *     updatedURL: 'https://example.com/'
+     *   }
+     * }
+     * ```
+     *
+     * @param {Object} options
+     * @param {Response} [options.oldResponse] Cached response to compare.
+     * @param {Response} options.newResponse Possibly updated response to compare.
+     * @param {Request} options.request The request.
+     * @param {string} options.cacheName Name of the cache the responses belong
+     *     to. This is included in the broadcast message.
+     * @param {Event} [options.event] event An optional event that triggered
+     *     this possible cache update.
+     * @return {Promise} Resolves once the update is sent.
+     */
+    async notifyIfUpdated(options) {
+        if (process.env.NODE_ENV !== 'production') {
+            assert.isType(options.cacheName, 'string', {
+                moduleName: 'workbox-broadcast-update',
+                className: 'BroadcastCacheUpdate',
+                funcName: 'notifyIfUpdated',
+                paramName: 'cacheName',
+            });
+            assert.isInstance(options.newResponse, Response, {
+                moduleName: 'workbox-broadcast-update',
+                className: 'BroadcastCacheUpdate',
+                funcName: 'notifyIfUpdated',
+                paramName: 'newResponse',
+            });
+            assert.isInstance(options.request, Request, {
+                moduleName: 'workbox-broadcast-update',
+                className: 'BroadcastCacheUpdate',
+                funcName: 'notifyIfUpdated',
+                paramName: 'request',
+            });
+        }
+        // Without two responses there is nothing to compare.
+        if (!options.oldResponse) {
+            return;
+        }
+        if (!responsesAreSame(options.oldResponse, options.newResponse, this._headersToCheck)) {
+            if (process.env.NODE_ENV !== 'production') {
+                logger.log(`Newer response found (and cached) for:`, options.request.url);
+            }
+            const messageData = {
+                type: CACHE_UPDATED_MESSAGE_TYPE,
+                meta: CACHE_UPDATED_MESSAGE_META,
+                payload: this._generatePayload(options),
+            };
+            // For navigation requests, wait until the new window client exists
+            // before sending the message
+            if (options.request.mode === 'navigate') {
+                let resultingClientId;
+                if (options.event instanceof FetchEvent) {
+                    resultingClientId = options.event.resultingClientId;
+                }
+                const resultingWin = await resultingClientExists(resultingClientId);
+                // Safari does not currently implement postMessage buffering and
+                // there's no good way to feature detect that, so to increase the
+                // chances of the message being delivered in Safari, we add a timeout.
+                // We also do this if `resultingClientExists()` didn't return a client,
+                // which means it timed out, so it's worth waiting a bit longer.
+                if (!resultingWin || isSafari) {
+                    // 3500 is chosen because (according to CrUX data) 80% of mobile
+                    // websites hit the DOMContentLoaded event in less than 3.5 seconds.
+                    // And presumably sites implementing service worker are on the
+                    // higher end of the performance spectrum.
+                    await timeout(3500);
+                }
+            }
+            const windows = await self.clients.matchAll({ type: 'window' });
+            for (const win of windows) {
+                win.postMessage(messageData);
+            }
+        }
+    }
+}
+export { BroadcastCacheUpdate };

node_modules/workbox-broadcast-update/BroadcastCacheUpdate.mjs

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

node_modules/workbox-broadcast-update/BroadcastUpdatePlugin.d.ts

@@ -0,0 +1,41 @@
+import { WorkboxPlugin } from 'workbox-core/types.js';
+import { BroadcastCacheUpdateOptions } from './BroadcastCacheUpdate.js';
+import './_version.js';
+/**
+ * This plugin will automatically broadcast a message whenever a cached response
+ * is updated.
+ *
+ * @memberof module:workbox-broadcast-update
+ */
+declare class BroadcastUpdatePlugin implements WorkboxPlugin {
+    private readonly _broadcastUpdate;
+    /**
+     * Construct a BroadcastCacheUpdate instance with the passed options and
+     * calls its [`notifyIfUpdated()`]{@link module:workbox-broadcast-update.BroadcastCacheUpdate~notifyIfUpdated}
+     * method whenever the plugin's `cacheDidUpdate` callback is invoked.
+     *
+     * @param {Object} options
+     * @param {Array<string>} [options.headersToCheck=['content-length', 'etag', 'last-modified']]
+     *     A list of headers that will be used to determine whether the responses
+     *     differ.
+     * @param {string} [options.generatePayload] A function whose return value
+     *     will be used as the `payload` field in any cache update messages sent
+     *     to the window clients.
+     */
+    constructor(options: BroadcastCacheUpdateOptions);
+    /**
+     * A "lifecycle" callback that will be triggered automatically by the
+     * `workbox-sw` and `workbox-runtime-caching` handlers when an entry is
+     * added to a cache.
+     *
+     * @private
+     * @param {Object} options The input object to this function.
+     * @param {string} options.cacheName Name of the cache being updated.
+     * @param {Response} [options.oldResponse] The previous cached value, if any.
+     * @param {Response} options.newResponse The new value in the cache.
+     * @param {Request} options.request The request that triggered the update.
+     * @param {Request} [options.event] The event that triggered the update.
+     */
+    cacheDidUpdate: WorkboxPlugin['cacheDidUpdate'];
+}
+export { BroadcastUpdatePlugin };

node_modules/workbox-broadcast-update/BroadcastUpdatePlugin.js

@@ -0,0 +1,51 @@
+/*
+  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 { dontWaitFor } from 'workbox-core/_private/dontWaitFor.js';
+import { BroadcastCacheUpdate } from './BroadcastCacheUpdate.js';
+import './_version.js';
+/**
+ * This plugin will automatically broadcast a message whenever a cached response
+ * is updated.
+ *
+ * @memberof module:workbox-broadcast-update
+ */
+class BroadcastUpdatePlugin {
+    /**
+     * Construct a BroadcastCacheUpdate instance with the passed options and
+     * calls its [`notifyIfUpdated()`]{@link module:workbox-broadcast-update.BroadcastCacheUpdate~notifyIfUpdated}
+     * method whenever the plugin's `cacheDidUpdate` callback is invoked.
+     *
+     * @param {Object} options
+     * @param {Array<string>} [options.headersToCheck=['content-length', 'etag', 'last-modified']]
+     *     A list of headers that will be used to determine whether the responses
+     *     differ.
+     * @param {string} [options.generatePayload] A function whose return value
+     *     will be used as the `payload` field in any cache update messages sent
+     *     to the window clients.
+     */
+    constructor(options) {
+        /**
+         * A "lifecycle" callback that will be triggered automatically by the
+         * `workbox-sw` and `workbox-runtime-caching` handlers when an entry is
+         * added to a cache.
+         *
+         * @private
+         * @param {Object} options The input object to this function.
+         * @param {string} options.cacheName Name of the cache being updated.
+         * @param {Response} [options.oldResponse] The previous cached value, if any.
+         * @param {Response} options.newResponse The new value in the cache.
+         * @param {Request} options.request The request that triggered the update.
+         * @param {Request} [options.event] The event that triggered the update.
+         */
+        this.cacheDidUpdate = async (options) => {
+            dontWaitFor(this._broadcastUpdate.notifyIfUpdated(options));
+        };
+        this._broadcastUpdate = new BroadcastCacheUpdate(options);
+    }
+}
+export { BroadcastUpdatePlugin };

node_modules/workbox-broadcast-update/BroadcastUpdatePlugin.mjs

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

node_modules/workbox-broadcast-update/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-broadcast-update/README.md

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

node_modules/workbox-broadcast-update/_version.js

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

node_modules/workbox-broadcast-update/_version.mjs

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

node_modules/workbox-broadcast-update/build/workbox-broadcast-update.dev.js

@@ -0,0 +1,288 @@
+this.workbox = this.workbox || {};
+this.workbox.broadcastUpdate = (function (exports, assert_js, timeout_js, resultingClientExists_js, logger_js, WorkboxError_js, dontWaitFor_js) {
+    'use strict';
+
+    try {
+      self['workbox:broadcast-update: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.
+    */
+    /**
+     * Given two `Response's`, compares several header values to see if they are
+     * the same or not.
+     *
+     * @param {Response} firstResponse
+     * @param {Response} secondResponse
+     * @param {Array<string>} headersToCheck
+     * @return {boolean}
+     *
+     * @memberof module:workbox-broadcast-update
+     */
+
+    const responsesAreSame = (firstResponse, secondResponse, headersToCheck) => {
+      {
+        if (!(firstResponse instanceof Response && secondResponse instanceof Response)) {
+          throw new WorkboxError_js.WorkboxError('invalid-responses-are-same-args');
+        }
+      }
+
+      const atLeastOneHeaderAvailable = headersToCheck.some(header => {
+        return firstResponse.headers.has(header) && secondResponse.headers.has(header);
+      });
+
+      if (!atLeastOneHeaderAvailable) {
+        {
+          logger_js.logger.warn(`Unable to determine where the response has been updated ` + `because none of the headers that would be checked are present.`);
+          logger_js.logger.debug(`Attempting to compare the following: `, firstResponse, secondResponse, headersToCheck);
+        } // Just return true, indicating the that responses are the same, since we
+        // can't determine otherwise.
+
+
+        return true;
+      }
+
+      return headersToCheck.every(header => {
+        const headerStateComparison = firstResponse.headers.has(header) === secondResponse.headers.has(header);
+        const headerValueComparison = firstResponse.headers.get(header) === secondResponse.headers.get(header);
+        return headerStateComparison && headerValueComparison;
+      });
+    };
+
+    /*
+      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 CACHE_UPDATED_MESSAGE_TYPE = 'CACHE_UPDATED';
+    const CACHE_UPDATED_MESSAGE_META = 'workbox-broadcast-update';
+    const DEFAULT_HEADERS_TO_CHECK = ['content-length', 'etag', 'last-modified'];
+
+    /*
+      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.
+    */
+    // TODO(philipwalton): remove once this Safari bug fix has been released.
+    // https://bugs.webkit.org/show_bug.cgi?id=201169
+
+    const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+    /**
+     * Generates the default payload used in update messages. By default the
+     * payload includes the `cacheName` and `updatedURL` fields.
+     *
+     * @return Object
+     * @private
+     */
+
+    function defaultPayloadGenerator(data) {
+      return {
+        cacheName: data.cacheName,
+        updatedURL: data.request.url
+      };
+    }
+    /**
+     * Uses the `postMessage()` API to inform any open windows/tabs when a cached
+     * response has been updated.
+     *
+     * For efficiency's sake, the underlying response bodies are not compared;
+     * only specific response headers are checked.
+     *
+     * @memberof module:workbox-broadcast-update
+     */
+
+
+    class BroadcastCacheUpdate {
+      /**
+       * Construct a BroadcastCacheUpdate instance with a specific `channelName` to
+       * broadcast messages on
+       *
+       * @param {Object} options
+       * @param {Array<string>} [options.headersToCheck=['content-length', 'etag', 'last-modified']]
+       *     A list of headers that will be used to determine whether the responses
+       *     differ.
+       * @param {string} [options.generatePayload] A function whose return value
+       *     will be used as the `payload` field in any cache update messages sent
+       *     to the window clients.
+       */
+      constructor({
+        headersToCheck,
+        generatePayload
+      } = {}) {
+        this._headersToCheck = headersToCheck || DEFAULT_HEADERS_TO_CHECK;
+        this._generatePayload = generatePayload || defaultPayloadGenerator;
+      }
+      /**
+       * Compares two [Responses](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+       * and sends a message (via `postMessage()`) to all window clients if the
+       * responses differ (note: neither of the Responses can be
+       * {@link http://stackoverflow.com/questions/39109789|opaque}).
+       *
+       * The message that's posted has the following format (where `payload` can
+       * be customized via the `generatePayload` option the instance is created
+       * with):
+       *
+       * ```
+       * {
+       *   type: 'CACHE_UPDATED',
+       *   meta: 'workbox-broadcast-update',
+       *   payload: {
+       *     cacheName: 'the-cache-name',
+       *     updatedURL: 'https://example.com/'
+       *   }
+       * }
+       * ```
+       *
+       * @param {Object} options
+       * @param {Response} [options.oldResponse] Cached response to compare.
+       * @param {Response} options.newResponse Possibly updated response to compare.
+       * @param {Request} options.request The request.
+       * @param {string} options.cacheName Name of the cache the responses belong
+       *     to. This is included in the broadcast message.
+       * @param {Event} [options.event] event An optional event that triggered
+       *     this possible cache update.
+       * @return {Promise} Resolves once the update is sent.
+       */
+
+
+      async notifyIfUpdated(options) {
+        {
+          assert_js.assert.isType(options.cacheName, 'string', {
+            moduleName: 'workbox-broadcast-update',
+            className: 'BroadcastCacheUpdate',
+            funcName: 'notifyIfUpdated',
+            paramName: 'cacheName'
+          });
+          assert_js.assert.isInstance(options.newResponse, Response, {
+            moduleName: 'workbox-broadcast-update',
+            className: 'BroadcastCacheUpdate',
+            funcName: 'notifyIfUpdated',
+            paramName: 'newResponse'
+          });
+          assert_js.assert.isInstance(options.request, Request, {
+            moduleName: 'workbox-broadcast-update',
+            className: 'BroadcastCacheUpdate',
+            funcName: 'notifyIfUpdated',
+            paramName: 'request'
+          });
+        } // Without two responses there is nothing to compare.
+
+
+        if (!options.oldResponse) {
+          return;
+        }
+
+        if (!responsesAreSame(options.oldResponse, options.newResponse, this._headersToCheck)) {
+          {
+            logger_js.logger.log(`Newer response found (and cached) for:`, options.request.url);
+          }
+
+          const messageData = {
+            type: CACHE_UPDATED_MESSAGE_TYPE,
+            meta: CACHE_UPDATED_MESSAGE_META,
+            payload: this._generatePayload(options)
+          }; // For navigation requests, wait until the new window client exists
+          // before sending the message
+
+          if (options.request.mode === 'navigate') {
+            let resultingClientId;
+
+            if (options.event instanceof FetchEvent) {
+              resultingClientId = options.event.resultingClientId;
+            }
+
+            const resultingWin = await resultingClientExists_js.resultingClientExists(resultingClientId); // Safari does not currently implement postMessage buffering and
+            // there's no good way to feature detect that, so to increase the
+            // chances of the message being delivered in Safari, we add a timeout.
+            // We also do this if `resultingClientExists()` didn't return a client,
+            // which means it timed out, so it's worth waiting a bit longer.
+
+            if (!resultingWin || isSafari) {
+              // 3500 is chosen because (according to CrUX data) 80% of mobile
+              // websites hit the DOMContentLoaded event in less than 3.5 seconds.
+              // And presumably sites implementing service worker are on the
+              // higher end of the performance spectrum.
+              await timeout_js.timeout(3500);
+            }
+          }
+
+          const windows = await self.clients.matchAll({
+            type: 'window'
+          });
+
+          for (const win of windows) {
+            win.postMessage(messageData);
+          }
+        }
+      }
+
+    }
+
+    /*
+      Copyright 2018 Google LLC
+
+      Use of this source code is governed by an MIT-style
+      license that can be found in the LICENSE file or at
+      https://opensource.org/licenses/MIT.
+    */
+    /**
+     * This plugin will automatically broadcast a message whenever a cached response
+     * is updated.
+     *
+     * @memberof module:workbox-broadcast-update
+     */
+
+    class BroadcastUpdatePlugin {
+      /**
+       * Construct a BroadcastCacheUpdate instance with the passed options and
+       * calls its [`notifyIfUpdated()`]{@link module:workbox-broadcast-update.BroadcastCacheUpdate~notifyIfUpdated}
+       * method whenever the plugin's `cacheDidUpdate` callback is invoked.
+       *
+       * @param {Object} options
+       * @param {Array<string>} [options.headersToCheck=['content-length', 'etag', 'last-modified']]
+       *     A list of headers that will be used to determine whether the responses
+       *     differ.
+       * @param {string} [options.generatePayload] A function whose return value
+       *     will be used as the `payload` field in any cache update messages sent
+       *     to the window clients.
+       */
+      constructor(options) {
+        /**
+         * A "lifecycle" callback that will be triggered automatically by the
+         * `workbox-sw` and `workbox-runtime-caching` handlers when an entry is
+         * added to a cache.
+         *
+         * @private
+         * @param {Object} options The input object to this function.
+         * @param {string} options.cacheName Name of the cache being updated.
+         * @param {Response} [options.oldResponse] The previous cached value, if any.
+         * @param {Response} options.newResponse The new value in the cache.
+         * @param {Request} options.request The request that triggered the update.
+         * @param {Request} [options.event] The event that triggered the update.
+         */
+        this.cacheDidUpdate = async options => {
+          dontWaitFor_js.dontWaitFor(this._broadcastUpdate.notifyIfUpdated(options));
+        };
+
+        this._broadcastUpdate = new BroadcastCacheUpdate(options);
+      }
+
+    }
+
+    exports.BroadcastCacheUpdate = BroadcastCacheUpdate;
+    exports.BroadcastUpdatePlugin = BroadcastUpdatePlugin;
+    exports.responsesAreSame = responsesAreSame;
+
+    return exports;
+
+}({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private));
+//# sourceMappingURL=workbox-broadcast-update.dev.js.map

node_modules/workbox-broadcast-update/build/workbox-broadcast-update.prod.js

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

node_modules/workbox-broadcast-update/index.d.ts

@@ -0,0 +1,8 @@
+import { BroadcastCacheUpdate } from './BroadcastCacheUpdate.js';
+import { BroadcastUpdatePlugin } from './BroadcastUpdatePlugin.js';
+import { responsesAreSame } from './responsesAreSame.js';
+import './_version.js';
+/**
+ * @module workbox-broadcast-update
+ */
+export { BroadcastCacheUpdate, BroadcastUpdatePlugin, responsesAreSame, };

node_modules/workbox-broadcast-update/index.js

@@ -0,0 +1,15 @@
+/*
+  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 { BroadcastCacheUpdate } from './BroadcastCacheUpdate.js';
+import { BroadcastUpdatePlugin } from './BroadcastUpdatePlugin.js';
+import { responsesAreSame } from './responsesAreSame.js';
+import './_version.js';
+/**
+ * @module workbox-broadcast-update
+ */
+export { BroadcastCacheUpdate, BroadcastUpdatePlugin, responsesAreSame, };

node_modules/workbox-broadcast-update/index.mjs

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

node_modules/workbox-broadcast-update/package.json

@@ -0,0 +1,65 @@
+{
+  "_from": "workbox-broadcast-update@^5.1.4",
+  "_id": "workbox-broadcast-update@5.1.4",
+  "_inBundle": false,
+  "_integrity": "sha512-HTyTWkqXvHRuqY73XrwvXPud/FN6x3ROzkfFPsRjtw/kGZuZkPzfeH531qdUGfhtwjmtO/ZzXcWErqVzJNdXaA==",
+  "_location": "/workbox-broadcast-update",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "workbox-broadcast-update@^5.1.4",
+    "name": "workbox-broadcast-update",
+    "escapedName": "workbox-broadcast-update",
+    "rawSpec": "^5.1.4",
+    "saveSpec": null,
+    "fetchSpec": "^5.1.4"
+  },
+  "_requiredBy": [
+    "/workbox-build"
+  ],
+  "_resolved": "https://registry.npmjs.org/workbox-broadcast-update/-/workbox-broadcast-update-5.1.4.tgz",
+  "_shasum": "0eeb89170ddca7f6914fa3523fb14462891f2cfc",
+  "_spec": "workbox-broadcast-update@^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"
+  },
+  "deprecated": false,
+  "description": "A service worker helper library that uses the Broadcast Channel API to announce when a cached response has updated",
+  "gitHead": "a95b6fd489c2a66574f1655b2de3acd2ece35fb3",
+  "homepage": "https://github.com/GoogleChrome/workbox",
+  "keywords": [
+    "workbox",
+    "workboxjs",
+    "service worker",
+    "sw",
+    "workbox-plugin"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "module": "index.mjs",
+  "name": "workbox-broadcast-update",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/googlechrome/workbox.git"
+  },
+  "scripts": {
+    "build": "gulp build-packages --package workbox-broadcast-update",
+    "prepare": "npm run build",
+    "version": "npm run build"
+  },
+  "types": "index.d.ts",
+  "version": "5.1.4",
+  "workbox": {
+    "browserNamespace": "workbox.broadcastUpdate",
+    "packageType": "browser"
+  }
+}

node_modules/workbox-broadcast-update/responsesAreSame.d.ts

@@ -0,0 +1,14 @@
+import './_version.js';
+/**
+ * Given two `Response's`, compares several header values to see if they are
+ * the same or not.
+ *
+ * @param {Response} firstResponse
+ * @param {Response} secondResponse
+ * @param {Array<string>} headersToCheck
+ * @return {boolean}
+ *
+ * @memberof module:workbox-broadcast-update
+ */
+declare const responsesAreSame: (firstResponse: Response, secondResponse: Response, headersToCheck: string[]) => boolean;
+export { responsesAreSame };

node_modules/workbox-broadcast-update/responsesAreSame.js

@@ -0,0 +1,51 @@
+/*
+  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 { WorkboxError } from 'workbox-core/_private/WorkboxError.js';
+import { logger } from 'workbox-core/_private/logger.js';
+import './_version.js';
+/**
+ * Given two `Response's`, compares several header values to see if they are
+ * the same or not.
+ *
+ * @param {Response} firstResponse
+ * @param {Response} secondResponse
+ * @param {Array<string>} headersToCheck
+ * @return {boolean}
+ *
+ * @memberof module:workbox-broadcast-update
+ */
+const responsesAreSame = (firstResponse, secondResponse, headersToCheck) => {
+    if (process.env.NODE_ENV !== 'production') {
+        if (!(firstResponse instanceof Response &&
+            secondResponse instanceof Response)) {
+            throw new WorkboxError('invalid-responses-are-same-args');
+        }
+    }
+    const atLeastOneHeaderAvailable = headersToCheck.some((header) => {
+        return firstResponse.headers.has(header) &&
+            secondResponse.headers.has(header);
+    });
+    if (!atLeastOneHeaderAvailable) {
+        if (process.env.NODE_ENV !== 'production') {
+            logger.warn(`Unable to determine where the response has been updated ` +
+                `because none of the headers that would be checked are present.`);
+            logger.debug(`Attempting to compare the following: `, firstResponse, secondResponse, headersToCheck);
+        }
+        // Just return true, indicating the that responses are the same, since we
+        // can't determine otherwise.
+        return true;
+    }
+    return headersToCheck.every((header) => {
+        const headerStateComparison = firstResponse.headers.has(header) ===
+            secondResponse.headers.has(header);
+        const headerValueComparison = firstResponse.headers.get(header) ===
+            secondResponse.headers.get(header);
+        return headerStateComparison && headerValueComparison;
+    });
+};
+export { responsesAreSame };

node_modules/workbox-broadcast-update/responsesAreSame.mjs

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

node_modules/workbox-broadcast-update/src/BroadcastCacheUpdate.ts

@@ -0,0 +1,183 @@
+/*
+  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 {timeout} from 'workbox-core/_private/timeout.js';
+import {resultingClientExists} from 'workbox-core/_private/resultingClientExists.js';
+import {CacheDidUpdateCallbackParam} from 'workbox-core/types.js';
+import {logger} from 'workbox-core/_private/logger.js';
+import {responsesAreSame} from './responsesAreSame.js';
+import {CACHE_UPDATED_MESSAGE_TYPE, CACHE_UPDATED_MESSAGE_META, DEFAULT_HEADERS_TO_CHECK} from './utils/constants.js';
+
+import './_version.js';
+
+
+// UA-sniff Safari: https://stackoverflow.com/questions/7944460/detect-safari-browser
+// TODO(philipwalton): remove once this Safari bug fix has been released.
+// https://bugs.webkit.org/show_bug.cgi?id=201169
+const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+
+
+// Give TypeScript the correct global.
+declare let self: ServiceWorkerGlobalScope;
+
+export interface BroadcastCacheUpdateOptions {
+  headersToCheck?: string[];
+  generatePayload?: (options: CacheDidUpdateCallbackParam) => Record<string, any>;
+}
+
+/**
+ * Generates the default payload used in update messages. By default the
+ * payload includes the `cacheName` and `updatedURL` fields.
+ *
+ * @return Object
+ * @private
+ */
+function defaultPayloadGenerator(data: CacheDidUpdateCallbackParam): Record<string, any> {
+  return {
+    cacheName: data.cacheName,
+    updatedURL: data.request.url,
+  };
+}
+
+/**
+ * Uses the `postMessage()` API to inform any open windows/tabs when a cached
+ * response has been updated.
+ *
+ * For efficiency's sake, the underlying response bodies are not compared;
+ * only specific response headers are checked.
+ *
+ * @memberof module:workbox-broadcast-update
+ */
+class BroadcastCacheUpdate {
+  private readonly _headersToCheck: string[];
+  private readonly _generatePayload: (options: CacheDidUpdateCallbackParam) => Record<string, any>;
+
+  /**
+   * Construct a BroadcastCacheUpdate instance with a specific `channelName` to
+   * broadcast messages on
+   *
+   * @param {Object} options
+   * @param {Array<string>} [options.headersToCheck=['content-length', 'etag', 'last-modified']]
+   *     A list of headers that will be used to determine whether the responses
+   *     differ.
+   * @param {string} [options.generatePayload] A function whose return value
+   *     will be used as the `payload` field in any cache update messages sent
+   *     to the window clients.
+   */
+  constructor({
+    headersToCheck,
+    generatePayload,
+  }: BroadcastCacheUpdateOptions = {}) {
+    this._headersToCheck = headersToCheck || DEFAULT_HEADERS_TO_CHECK;
+    this._generatePayload = generatePayload || defaultPayloadGenerator;
+  }
+
+  /**
+   * Compares two [Responses](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+   * and sends a message (via `postMessage()`) to all window clients if the
+   * responses differ (note: neither of the Responses can be
+   * {@link http://stackoverflow.com/questions/39109789|opaque}).
+   *
+   * The message that's posted has the following format (where `payload` can
+   * be customized via the `generatePayload` option the instance is created
+   * with):
+   *
+   * ```
+   * {
+   *   type: 'CACHE_UPDATED',
+   *   meta: 'workbox-broadcast-update',
+   *   payload: {
+   *     cacheName: 'the-cache-name',
+   *     updatedURL: 'https://example.com/'
+   *   }
+   * }
+   * ```
+   *
+   * @param {Object} options
+   * @param {Response} [options.oldResponse] Cached response to compare.
+   * @param {Response} options.newResponse Possibly updated response to compare.
+   * @param {Request} options.request The request.
+   * @param {string} options.cacheName Name of the cache the responses belong
+   *     to. This is included in the broadcast message.
+   * @param {Event} [options.event] event An optional event that triggered
+   *     this possible cache update.
+   * @return {Promise} Resolves once the update is sent.
+   */
+  async notifyIfUpdated(options: CacheDidUpdateCallbackParam): Promise<void> {
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.isType(options.cacheName, 'string', {
+        moduleName: 'workbox-broadcast-update',
+        className: 'BroadcastCacheUpdate',
+        funcName: 'notifyIfUpdated',
+        paramName: 'cacheName',
+      });
+      assert!.isInstance(options.newResponse, Response, {
+        moduleName: 'workbox-broadcast-update',
+        className: 'BroadcastCacheUpdate',
+        funcName: 'notifyIfUpdated',
+        paramName: 'newResponse',
+      });
+      assert!.isInstance(options.request, Request, {
+        moduleName: 'workbox-broadcast-update',
+        className: 'BroadcastCacheUpdate',
+        funcName: 'notifyIfUpdated',
+        paramName: 'request',
+      });
+    }
+
+    // Without two responses there is nothing to compare.
+    if (!options.oldResponse) {
+      return;
+    }
+
+    if (!responsesAreSame(options.oldResponse, options.newResponse, this._headersToCheck)) {
+      if (process.env.NODE_ENV !== 'production') {
+        logger.log(
+            `Newer response found (and cached) for:`, options.request.url);
+      }
+
+      const messageData = {
+        type: CACHE_UPDATED_MESSAGE_TYPE,
+        meta: CACHE_UPDATED_MESSAGE_META,
+        payload: this._generatePayload(options),
+      };
+
+      // For navigation requests, wait until the new window client exists
+      // before sending the message
+      if (options.request.mode === 'navigate') {
+        let resultingClientId: string | undefined;
+        if (options.event instanceof FetchEvent) {
+          resultingClientId = options.event.resultingClientId;
+        }
+
+        const resultingWin = await resultingClientExists(resultingClientId);
+
+        // Safari does not currently implement postMessage buffering and
+        // there's no good way to feature detect that, so to increase the
+        // chances of the message being delivered in Safari, we add a timeout.
+        // We also do this if `resultingClientExists()` didn't return a client,
+        // which means it timed out, so it's worth waiting a bit longer.
+        if (!resultingWin || isSafari) {
+          // 3500 is chosen because (according to CrUX data) 80% of mobile
+          // websites hit the DOMContentLoaded event in less than 3.5 seconds.
+          // And presumably sites implementing service worker are on the
+          // higher end of the performance spectrum.
+          await timeout(3500);
+        }
+      }
+
+      const windows = await self.clients.matchAll({type: 'window'});
+      for (const win of windows) {
+        win.postMessage(messageData);
+      }
+    }
+  }
+}
+
+export {BroadcastCacheUpdate};

node_modules/workbox-broadcast-update/src/BroadcastUpdatePlugin.ts

@@ -0,0 +1,60 @@
+/*
+  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 {dontWaitFor} from 'workbox-core/_private/dontWaitFor.js';
+import {WorkboxPlugin} from 'workbox-core/types.js';
+
+import {BroadcastCacheUpdate, BroadcastCacheUpdateOptions} from './BroadcastCacheUpdate.js';
+
+import './_version.js';
+
+/**
+ * This plugin will automatically broadcast a message whenever a cached response
+ * is updated.
+ *
+ * @memberof module:workbox-broadcast-update
+ */
+class BroadcastUpdatePlugin implements WorkboxPlugin {
+  private readonly _broadcastUpdate: BroadcastCacheUpdate;
+
+  /**
+   * Construct a BroadcastCacheUpdate instance with the passed options and
+   * calls its [`notifyIfUpdated()`]{@link module:workbox-broadcast-update.BroadcastCacheUpdate~notifyIfUpdated}
+   * method whenever the plugin's `cacheDidUpdate` callback is invoked.
+   *
+   * @param {Object} options
+   * @param {Array<string>} [options.headersToCheck=['content-length', 'etag', 'last-modified']]
+   *     A list of headers that will be used to determine whether the responses
+   *     differ.
+   * @param {string} [options.generatePayload] A function whose return value
+   *     will be used as the `payload` field in any cache update messages sent
+   *     to the window clients.
+   */
+  constructor(options: BroadcastCacheUpdateOptions) {
+    this._broadcastUpdate = new BroadcastCacheUpdate(options);
+  }
+
+  /**
+   * A "lifecycle" callback that will be triggered automatically by the
+   * `workbox-sw` and `workbox-runtime-caching` handlers when an entry is
+   * added to a cache.
+   *
+   * @private
+   * @param {Object} options The input object to this function.
+   * @param {string} options.cacheName Name of the cache being updated.
+   * @param {Response} [options.oldResponse] The previous cached value, if any.
+   * @param {Response} options.newResponse The new value in the cache.
+   * @param {Request} options.request The request that triggered the update.
+   * @param {Request} [options.event] The event that triggered the update.
+   */
+  cacheDidUpdate: WorkboxPlugin['cacheDidUpdate'] = async (options) => {
+    dontWaitFor(this._broadcastUpdate.notifyIfUpdated(options));
+  }
+}
+
+export {BroadcastUpdatePlugin};

node_modules/workbox-broadcast-update/src/_version.ts

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

node_modules/workbox-broadcast-update/src/index.ts

@@ -0,0 +1,23 @@
+/*
+  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 {BroadcastCacheUpdate} from './BroadcastCacheUpdate.js';
+import {BroadcastUpdatePlugin} from './BroadcastUpdatePlugin.js';
+import {responsesAreSame} from './responsesAreSame.js';
+import './_version.js';
+
+
+/**
+ * @module workbox-broadcast-update
+ */
+
+export {
+  BroadcastCacheUpdate,
+  BroadcastUpdatePlugin,
+  responsesAreSame,
+};

node_modules/workbox-broadcast-update/src/responsesAreSame.ts

@@ -0,0 +1,65 @@
+/*
+  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 {WorkboxError} from 'workbox-core/_private/WorkboxError.js';
+import {logger} from 'workbox-core/_private/logger.js';
+import './_version.js';
+
+
+/**
+ * Given two `Response's`, compares several header values to see if they are
+ * the same or not.
+ *
+ * @param {Response} firstResponse
+ * @param {Response} secondResponse
+ * @param {Array<string>} headersToCheck
+ * @return {boolean}
+ *
+ * @memberof module:workbox-broadcast-update
+ */
+const responsesAreSame = (
+  firstResponse: Response,
+  secondResponse: Response,
+  headersToCheck: string[],
+) => {
+  if (process.env.NODE_ENV !== 'production') {
+    if (!(firstResponse instanceof Response &&
+      secondResponse instanceof Response)) {
+      throw new WorkboxError('invalid-responses-are-same-args');
+    }
+  }
+
+  const atLeastOneHeaderAvailable = headersToCheck.some((header) => {
+    return firstResponse.headers.has(header) &&
+      secondResponse.headers.has(header);
+  });
+
+  if (!atLeastOneHeaderAvailable) {
+    if (process.env.NODE_ENV !== 'production') {
+      logger.warn(`Unable to determine where the response has been updated ` +
+        `because none of the headers that would be checked are present.`);
+      logger.debug(`Attempting to compare the following: `,
+          firstResponse, secondResponse, headersToCheck);
+    }
+
+    // Just return true, indicating the that responses are the same, since we
+    // can't determine otherwise.
+    return true;
+  }
+
+  return headersToCheck.every((header) => {
+    const headerStateComparison = firstResponse.headers.has(header) ===
+      secondResponse.headers.has(header);
+    const headerValueComparison = firstResponse.headers.get(header) ===
+      secondResponse.headers.get(header);
+
+    return headerStateComparison && headerValueComparison;
+  });
+};
+
+export {responsesAreSame};

node_modules/workbox-broadcast-update/src/utils/constants.ts

@@ -0,0 +1,17 @@
+/*
+  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 CACHE_UPDATED_MESSAGE_TYPE = 'CACHE_UPDATED';
+export const CACHE_UPDATED_MESSAGE_META = 'workbox-broadcast-update';
+export const DEFAULT_HEADERS_TO_CHECK: string[] = [
+  'content-length',
+  'etag',
+  'last-modified',
+];

node_modules/workbox-broadcast-update/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-broadcast-update/utils/constants.d.ts

@@ -0,0 +1,4 @@
+import '../_version.js';
+export declare const CACHE_UPDATED_MESSAGE_TYPE = "CACHE_UPDATED";
+export declare const CACHE_UPDATED_MESSAGE_META = "workbox-broadcast-update";
+export declare const DEFAULT_HEADERS_TO_CHECK: string[];

node_modules/workbox-broadcast-update/utils/constants.js

@@ -0,0 +1,15 @@
+/*
+  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 CACHE_UPDATED_MESSAGE_TYPE = 'CACHE_UPDATED';
+export const CACHE_UPDATED_MESSAGE_META = 'workbox-broadcast-update';
+export const DEFAULT_HEADERS_TO_CHECK = [
+    'content-length',
+    'etag',
+    'last-modified',
+];

node_modules/workbox-broadcast-update/utils/constants.mjs

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