workbox-v4.3.1/workbox-broadcast-update.dev.js - incubator-liminal-site - Git at Google

 this.workbox = this.workbox || {};
 this.workbox.broadcastUpdate = (function (exports, assert_mjs, getFriendlyURL_mjs, logger_mjs, Deferred_mjs, WorkboxError_mjs) {
   'use strict';

   try {
     self['workbox:broadcast-update:4.3.1'] && _();
   } catch (e) {} // eslint-disable-line

   /*
     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 workbox.broadcastUpdate
    * @private
    */

   const responsesAreSame = (firstResponse, secondResponse, headersToCheck) => {
     {
       if (!(firstResponse instanceof Response && secondResponse instanceof Response)) {
         throw new WorkboxError_mjs.WorkboxError('invalid-responses-are-same-args');
       }
     }

     const atLeastOneHeaderAvailable = headersToCheck.some(header => {
       return firstResponse.headers.has(header) && secondResponse.headers.has(header);
     });

     if (!atLeastOneHeaderAvailable) {
       {
         logger_mjs.logger.warn(`Unable to determine where the response has been updated ` + `because none of the headers that would be checked are present.`);
         logger_mjs.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_BROADCAST_CHANNEL_NAME = 'workbox';
   const DEFAULT_DEFER_NOTIFICATION_TIMEOUT = 10000;
   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.
   */
   /**
    * You would not normally call this method directly; it's called automatically
    * by an instance of the {@link BroadcastCacheUpdate} class. It's exposed here
    * for the benefit of developers who would rather not use the full
    * `BroadcastCacheUpdate` implementation.
    *
    * Calling this will dispatch a message on the provided
    * {@link https://developers.google.com/web/updates/2016/09/broadcastchannel|Broadcast Channel}
    * to notify interested subscribers about a change to a cached resource.
    *
    * The message that's posted has a formation inspired by the
    * [Flux standard action](https://github.com/acdlite/flux-standard-action#introduction)
    * format like so:
    *
    * ```
    * {
    *   type: 'CACHE_UPDATED',
    *   meta: 'workbox-broadcast-update',
    *   payload: {
    *     cacheName: 'the-cache-name',
    *     updatedURL: 'https://example.com/'
    *   }
    * }
    * ```
    *
    * (Usage of [Flux](https://facebook.github.io/flux/) itself is not at
    * all required.)
    *
    * @param {Object} options
    * @param {string} options.cacheName The name of the cache in which the updated
    *     `Response` was stored.
    * @param {string} options.url The URL associated with the updated `Response`.
    * @param {BroadcastChannel} [options.channel] The `BroadcastChannel` to use.
    *     If no channel is set or the browser doesn't support the BroadcastChannel
    *     api, then an attempt will be made to `postMessage` each window client.
    *
    * @memberof workbox.broadcastUpdate
    */

   const broadcastUpdate = async ({
     channel,
     cacheName,
     url
   }) => {
     {
       assert_mjs.assert.isType(cacheName, 'string', {
         moduleName: 'workbox-broadcast-update',
         className: '~',
         funcName: 'broadcastUpdate',
         paramName: 'cacheName'
       });
       assert_mjs.assert.isType(url, 'string', {
         moduleName: 'workbox-broadcast-update',
         className: '~',
         funcName: 'broadcastUpdate',
         paramName: 'url'
       });
     }

     const data = {
       type: CACHE_UPDATED_MESSAGE_TYPE,
       meta: CACHE_UPDATED_MESSAGE_META,
       payload: {
         cacheName: cacheName,
         updatedURL: url
       }
     };

     if (channel) {
       channel.postMessage(data);
     } else {
       const windows = await clients.matchAll({
         type: 'window'
       });

       for (const win of windows) {
         win.postMessage(data);
       }
     }
   };

   /*
     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.
   */
   /**
    * Uses the [Broadcast Channel API]{@link https://developers.google.com/web/updates/2016/09/broadcastchannel}
    * to notify interested parties when a cached response has been updated.
    * In browsers that do not support the Broadcast Channel API, the instance
    * falls back to sending the update via `postMessage()` to all window clients.
    *
    * For efficiency's sake, the underlying response bodies are not compared;
    * only specific response headers are checked.
    *
    * @memberof workbox.broadcastUpdate
    */

   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.channelName='workbox'] The name that will be used
      *.    when creating the `BroadcastChannel`, which defaults to 'workbox' (the
      *     channel name used by the `workbox-window` package).
      * @param {string} [options.deferNoticationTimeout=10000] The amount of time
      *     to wait for a ready message from the window on navigation requests
      *     before sending the update.
      */
     constructor({
       headersToCheck,
       channelName,
       deferNoticationTimeout
     } = {}) {
       this._headersToCheck = headersToCheck || DEFAULT_HEADERS_TO_CHECK;
       this._channelName = channelName || DEFAULT_BROADCAST_CHANNEL_NAME;
       this._deferNoticationTimeout = deferNoticationTimeout || DEFAULT_DEFER_NOTIFICATION_TIMEOUT;

       {
         assert_mjs.assert.isType(this._channelName, 'string', {
           moduleName: 'workbox-broadcast-update',
           className: 'BroadcastCacheUpdate',
           funcName: 'constructor',
           paramName: 'channelName'
         });
         assert_mjs.assert.isArray(this._headersToCheck, {
           moduleName: 'workbox-broadcast-update',
           className: 'BroadcastCacheUpdate',
           funcName: 'constructor',
           paramName: 'headersToCheck'
         });
       }

       this._initWindowReadyDeferreds();
     }
     /**
      * Compare two [Responses](https://developer.mozilla.org/en-US/docs/Web/API/Response)
      * and send a message via the
      * {@link https://developers.google.com/web/updates/2016/09/broadcastchannel|Broadcast Channel API}
      * if they differ.
      *
      * Neither of the Responses can be {@link http://stackoverflow.com/questions/39109789|opaque}.
      *
      * @param {Object} options
      * @param {Response} options.oldResponse Cached response to compare.
      * @param {Response} options.newResponse Possibly updated response to compare.
      * @param {string} options.url The URL of 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({
       oldResponse,
       newResponse,
       url,
       cacheName,
       event
     }) {
       if (!responsesAreSame(oldResponse, newResponse, this._headersToCheck)) {
         {
           logger_mjs.logger.log(`Newer response found (and cached) for:`, url);
         }

         const sendUpdate = async () => {
           // In the case of a navigation request, the requesting page will likely
           // not have loaded its JavaScript in time to recevied the update
           // notification, so we defer it until ready (or we timeout waiting).
           if (event && event.request && event.request.mode === 'navigate') {
             {
               logger_mjs.logger.debug(`Original request was a navigation request, ` + `waiting for a ready message from the window`, event.request);
             }

             await this._windowReadyOrTimeout(event);
           }

           await this._broadcastUpdate({
             channel: this._getChannel(),
             cacheName,
             url
           });
         }; // Send the update and ensure the SW stays alive until it's sent.


         const done = sendUpdate();

         if (event) {
           try {
             event.waitUntil(done);
           } catch (error) {
             {
               logger_mjs.logger.warn(`Unable to ensure service worker stays alive ` + `when broadcasting cache update for ` + `${getFriendlyURL_mjs.getFriendlyURL(event.request.url)}'.`);
             }
           }
         }

         return done;
       }
     }
     /**
      * NOTE: this is exposed on the instance primarily so it can be spied on
      * in tests.
      *
      * @param {Object} opts
      * @private
      */


     async _broadcastUpdate(opts) {
       await broadcastUpdate(opts);
     }
     /**
      * @return {BroadcastChannel|undefined} The BroadcastChannel instance used for
      * broadcasting updates, or undefined if the browser doesn't support the
      * Broadcast Channel API.
      *
      * @private
      */


     _getChannel() {
       if ('BroadcastChannel' in self && !this._channel) {
         this._channel = new BroadcastChannel(this._channelName);
       }

       return this._channel;
     }
     /**
      * Waits for a message from the window indicating that it's capable of
      * receiving broadcasts. By default, this will only wait for the amount of
      * time specified via the `deferNoticationTimeout` option.
      *
      * @param {Event} event The navigation fetch event.
      * @return {Promise}
      * @private
      */


     _windowReadyOrTimeout(event) {
       if (!this._navigationEventsDeferreds.has(event)) {
         const deferred = new Deferred_mjs.Deferred(); // Set the deferred on the `_navigationEventsDeferreds` map so it will
         // be resolved when the next ready message event comes.

         this._navigationEventsDeferreds.set(event, deferred); // But don't wait too long for the message since it may never come.


         const timeout = setTimeout(() => {
           {
             logger_mjs.logger.debug(`Timed out after ${this._deferNoticationTimeout}` + `ms waiting for message from window`);
           }

           deferred.resolve();
         }, this._deferNoticationTimeout); // Ensure the timeout is cleared if the deferred promise is resolved.

         deferred.promise.then(() => clearTimeout(timeout));
       }

       return this._navigationEventsDeferreds.get(event).promise;
     }
     /**
      * Creates a mapping between navigation fetch events and deferreds, and adds
      * a listener for message events from the window. When message events arrive,
      * all deferreds in the mapping are resolved.
      *
      * Note: it would be easier if we could only resolve the deferred of
      * navigation fetch event whose client ID matched the source ID of the
      * message event, but currently client IDs are not exposed on navigation
      * fetch events: https://www.chromestatus.com/feature/4846038800138240
      *
      * @private
      */


     _initWindowReadyDeferreds() {
       // A mapping between navigation events and their deferreds.
       this._navigationEventsDeferreds = new Map(); // The message listener needs to be added in the initial run of the
       // service worker, but since we don't actually need to be listening for
       // messages until the cache updates, we only invoke the callback if set.

       self.addEventListener('message', event => {
         if (event.data.type === 'WINDOW_READY' && event.data.meta === 'workbox-window' && this._navigationEventsDeferreds.size > 0) {
           {
             logger_mjs.logger.debug(`Received WINDOW_READY event: `, event);
           } // Resolve any pending deferreds.


           for (const deferred of this._navigationEventsDeferreds.values()) {
             deferred.resolve();
           }

           this._navigationEventsDeferreds.clear();
         }
       });
     }

   }

   /*
     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 workbox.broadcastUpdate
    */

   class Plugin {
     /**
      * Construct a BroadcastCacheUpdate instance with the passed options and
      * calls its `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.channelName='workbox'] The name that will be used
      *.    when creating the `BroadcastChannel`, which defaults to 'workbox' (the
      *     channel name used by the `workbox-window` package).
      * @param {string} [options.deferNoticationTimeout=10000] The amount of time
      *     to wait for a ready message from the window on navigation requests
      *     before sending the update.
      */
     constructor(options) {
       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 udpate.
      * @param {Request} [options.event] The event that triggered the update.
      */


     cacheDidUpdate({
       cacheName,
       oldResponse,
       newResponse,
       request,
       event
     }) {
       {
         assert_mjs.assert.isType(cacheName, 'string', {
           moduleName: 'workbox-broadcast-update',
           className: 'Plugin',
           funcName: 'cacheDidUpdate',
           paramName: 'cacheName'
         });
         assert_mjs.assert.isInstance(newResponse, Response, {
           moduleName: 'workbox-broadcast-update',
           className: 'Plugin',
           funcName: 'cacheDidUpdate',
           paramName: 'newResponse'
         });
         assert_mjs.assert.isInstance(request, Request, {
           moduleName: 'workbox-broadcast-update',
           className: 'Plugin',
           funcName: 'cacheDidUpdate',
           paramName: 'request'
         });
       }

       if (!oldResponse) {
         // Without a two responses there is nothing to compare.
         return;
       }

       this._broadcastUpdate.notifyIfUpdated({
         cacheName,
         oldResponse,
         newResponse,
         event,
         url: request.url
       });
     }

   }

   /*
     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.
   */

   exports.BroadcastCacheUpdate = BroadcastCacheUpdate;
   exports.Plugin = Plugin;
   exports.broadcastUpdate = broadcastUpdate;
   exports.responsesAreSame = responsesAreSame;

   return exports;

 }({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private));
 //# sourceMappingURL=workbox-broadcast-update.dev.js.map
	this.workbox = this.workbox \|\| {};
	this.workbox.broadcastUpdate = (function (exports, assert_mjs, getFriendlyURL_mjs, logger_mjs, Deferred_mjs, WorkboxError_mjs) {
	'use strict';

	try {
	self['workbox:broadcast-update:4.3.1'] && _();
	} catch (e) {} // eslint-disable-line

	/*
	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 workbox.broadcastUpdate
	* @private
	*/

	const responsesAreSame = (firstResponse, secondResponse, headersToCheck) => {
	{
	if (!(firstResponse instanceof Response && secondResponse instanceof Response)) {
	throw new WorkboxError_mjs.WorkboxError('invalid-responses-are-same-args');
	}
	}

	const atLeastOneHeaderAvailable = headersToCheck.some(header => {
	return firstResponse.headers.has(header) && secondResponse.headers.has(header);
	});

	if (!atLeastOneHeaderAvailable) {
	{
	logger_mjs.logger.warn(`Unable to determine where the response has been updated ` + `because none of the headers that would be checked are present.`);
	logger_mjs.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_BROADCAST_CHANNEL_NAME = 'workbox';
	const DEFAULT_DEFER_NOTIFICATION_TIMEOUT = 10000;
	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.
	*/
	/**
	* You would not normally call this method directly; it's called automatically
	* by an instance of the {@link BroadcastCacheUpdate} class. It's exposed here
	* for the benefit of developers who would rather not use the full
	* `BroadcastCacheUpdate` implementation.
	*
	* Calling this will dispatch a message on the provided
	* {@link https://developers.google.com/web/updates/2016/09/broadcastchannel\|Broadcast Channel}
	* to notify interested subscribers about a change to a cached resource.
	*
	* The message that's posted has a formation inspired by the
	* [Flux standard action](https://github.com/acdlite/flux-standard-action#introduction)
	* format like so:
	*
	* ```
	* {
	* type: 'CACHE_UPDATED',
	* meta: 'workbox-broadcast-update',
	* payload: {
	* cacheName: 'the-cache-name',
	* updatedURL: 'https://example.com/'
	* }
	* }
	* ```
	*
	* (Usage of [Flux](https://facebook.github.io/flux/) itself is not at
	* all required.)
	*
	* @param {Object} options
	* @param {string} options.cacheName The name of the cache in which the updated
	* `Response` was stored.
	* @param {string} options.url The URL associated with the updated `Response`.
	* @param {BroadcastChannel} [options.channel] The `BroadcastChannel` to use.
	* If no channel is set or the browser doesn't support the BroadcastChannel
	* api, then an attempt will be made to `postMessage` each window client.
	*
	* @memberof workbox.broadcastUpdate
	*/

	const broadcastUpdate = async ({
	channel,
	cacheName,
	url
	}) => {
	{
	assert_mjs.assert.isType(cacheName, 'string', {
	moduleName: 'workbox-broadcast-update',
	className: '~',
	funcName: 'broadcastUpdate',
	paramName: 'cacheName'
	});
	assert_mjs.assert.isType(url, 'string', {
	moduleName: 'workbox-broadcast-update',
	className: '~',
	funcName: 'broadcastUpdate',
	paramName: 'url'
	});
	}

	const data = {
	type: CACHE_UPDATED_MESSAGE_TYPE,
	meta: CACHE_UPDATED_MESSAGE_META,
	payload: {
	cacheName: cacheName,
	updatedURL: url
	}
	};

	if (channel) {
	channel.postMessage(data);
	} else {
	const windows = await clients.matchAll({
	type: 'window'
	});

	for (const win of windows) {
	win.postMessage(data);
	}
	}
	};

	/*
	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.
	*/
	/**
	* Uses the [Broadcast Channel API]{@link https://developers.google.com/web/updates/2016/09/broadcastchannel}
	* to notify interested parties when a cached response has been updated.
	* In browsers that do not support the Broadcast Channel API, the instance
	* falls back to sending the update via `postMessage()` to all window clients.
	*
	* For efficiency's sake, the underlying response bodies are not compared;
	* only specific response headers are checked.
	*
	* @memberof workbox.broadcastUpdate
	*/

	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.channelName='workbox'] The name that will be used
	*. when creating the `BroadcastChannel`, which defaults to 'workbox' (the
	* channel name used by the `workbox-window` package).
	* @param {string} [options.deferNoticationTimeout=10000] The amount of time
	* to wait for a ready message from the window on navigation requests
	* before sending the update.
	*/
	constructor({
	headersToCheck,
	channelName,
	deferNoticationTimeout
	} = {}) {
	this._headersToCheck = headersToCheck \|\| DEFAULT_HEADERS_TO_CHECK;
	this._channelName = channelName \|\| DEFAULT_BROADCAST_CHANNEL_NAME;
	this._deferNoticationTimeout = deferNoticationTimeout \|\| DEFAULT_DEFER_NOTIFICATION_TIMEOUT;

	{
	assert_mjs.assert.isType(this._channelName, 'string', {
	moduleName: 'workbox-broadcast-update',
	className: 'BroadcastCacheUpdate',
	funcName: 'constructor',
	paramName: 'channelName'
	});
	assert_mjs.assert.isArray(this._headersToCheck, {
	moduleName: 'workbox-broadcast-update',
	className: 'BroadcastCacheUpdate',
	funcName: 'constructor',
	paramName: 'headersToCheck'
	});
	}

	this._initWindowReadyDeferreds();
	}
	/**
	* Compare two [Responses](https://developer.mozilla.org/en-US/docs/Web/API/Response)
	* and send a message via the
	* {@link https://developers.google.com/web/updates/2016/09/broadcastchannel\|Broadcast Channel API}
	* if they differ.
	*
	* Neither of the Responses can be {@link http://stackoverflow.com/questions/39109789\|opaque}.
	*
	* @param {Object} options
	* @param {Response} options.oldResponse Cached response to compare.
	* @param {Response} options.newResponse Possibly updated response to compare.
	* @param {string} options.url The URL of 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({
	oldResponse,
	newResponse,
	url,
	cacheName,
	event
	}) {
	if (!responsesAreSame(oldResponse, newResponse, this._headersToCheck)) {
	{
	logger_mjs.logger.log(`Newer response found (and cached) for:`, url);
	}

	const sendUpdate = async () => {
	// In the case of a navigation request, the requesting page will likely
	// not have loaded its JavaScript in time to recevied the update
	// notification, so we defer it until ready (or we timeout waiting).
	if (event && event.request && event.request.mode === 'navigate') {
	{
	logger_mjs.logger.debug(`Original request was a navigation request, ` + `waiting for a ready message from the window`, event.request);
	}

	await this._windowReadyOrTimeout(event);
	}

	await this._broadcastUpdate({
	channel: this._getChannel(),
	cacheName,
	url
	});
	}; // Send the update and ensure the SW stays alive until it's sent.


	const done = sendUpdate();

	if (event) {
	try {
	event.waitUntil(done);
	} catch (error) {
	{
	logger_mjs.logger.warn(`Unable to ensure service worker stays alive ` + `when broadcasting cache update for ` + `${getFriendlyURL_mjs.getFriendlyURL(event.request.url)}'.`);
	}
	}
	}

	return done;
	}
	}
	/**
	* NOTE: this is exposed on the instance primarily so it can be spied on
	* in tests.
	*
	* @param {Object} opts
	* @private
	*/


	async _broadcastUpdate(opts) {
	await broadcastUpdate(opts);
	}
	/**
	* @return {BroadcastChannel\|undefined} The BroadcastChannel instance used for
	* broadcasting updates, or undefined if the browser doesn't support the
	* Broadcast Channel API.
	*
	* @private
	*/


	_getChannel() {
	if ('BroadcastChannel' in self && !this._channel) {
	this._channel = new BroadcastChannel(this._channelName);
	}

	return this._channel;
	}
	/**
	* Waits for a message from the window indicating that it's capable of
	* receiving broadcasts. By default, this will only wait for the amount of
	* time specified via the `deferNoticationTimeout` option.
	*
	* @param {Event} event The navigation fetch event.
	* @return {Promise}
	* @private
	*/


	_windowReadyOrTimeout(event) {
	if (!this._navigationEventsDeferreds.has(event)) {
	const deferred = new Deferred_mjs.Deferred(); // Set the deferred on the `_navigationEventsDeferreds` map so it will
	// be resolved when the next ready message event comes.

	this._navigationEventsDeferreds.set(event, deferred); // But don't wait too long for the message since it may never come.


	const timeout = setTimeout(() => {
	{
	logger_mjs.logger.debug(`Timed out after ${this._deferNoticationTimeout}` + `ms waiting for message from window`);
	}

	deferred.resolve();
	}, this._deferNoticationTimeout); // Ensure the timeout is cleared if the deferred promise is resolved.

	deferred.promise.then(() => clearTimeout(timeout));
	}

	return this._navigationEventsDeferreds.get(event).promise;
	}
	/**
	* Creates a mapping between navigation fetch events and deferreds, and adds
	* a listener for message events from the window. When message events arrive,
	* all deferreds in the mapping are resolved.
	*
	* Note: it would be easier if we could only resolve the deferred of
	* navigation fetch event whose client ID matched the source ID of the
	* message event, but currently client IDs are not exposed on navigation
	* fetch events: https://www.chromestatus.com/feature/4846038800138240
	*
	* @private
	*/


	_initWindowReadyDeferreds() {
	// A mapping between navigation events and their deferreds.
	this._navigationEventsDeferreds = new Map(); // The message listener needs to be added in the initial run of the
	// service worker, but since we don't actually need to be listening for
	// messages until the cache updates, we only invoke the callback if set.

	self.addEventListener('message', event => {
	if (event.data.type === 'WINDOW_READY' && event.data.meta === 'workbox-window' && this._navigationEventsDeferreds.size > 0) {
	{
	logger_mjs.logger.debug(`Received WINDOW_READY event: `, event);
	} // Resolve any pending deferreds.


	for (const deferred of this._navigationEventsDeferreds.values()) {
	deferred.resolve();
	}

	this._navigationEventsDeferreds.clear();
	}
	});
	}

	}

	/*
	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 workbox.broadcastUpdate
	*/

	class Plugin {
	/**
	* Construct a BroadcastCacheUpdate instance with the passed options and
	* calls its `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.channelName='workbox'] The name that will be used
	*. when creating the `BroadcastChannel`, which defaults to 'workbox' (the
	* channel name used by the `workbox-window` package).
	* @param {string} [options.deferNoticationTimeout=10000] The amount of time
	* to wait for a ready message from the window on navigation requests
	* before sending the update.
	*/
	constructor(options) {
	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 udpate.
	* @param {Request} [options.event] The event that triggered the update.
	*/


	cacheDidUpdate({
	cacheName,
	oldResponse,
	newResponse,
	request,
	event
	}) {
	{
	assert_mjs.assert.isType(cacheName, 'string', {
	moduleName: 'workbox-broadcast-update',
	className: 'Plugin',
	funcName: 'cacheDidUpdate',
	paramName: 'cacheName'
	});
	assert_mjs.assert.isInstance(newResponse, Response, {
	moduleName: 'workbox-broadcast-update',
	className: 'Plugin',
	funcName: 'cacheDidUpdate',
	paramName: 'newResponse'
	});
	assert_mjs.assert.isInstance(request, Request, {
	moduleName: 'workbox-broadcast-update',
	className: 'Plugin',
	funcName: 'cacheDidUpdate',
	paramName: 'request'
	});
	}

	if (!oldResponse) {
	// Without a two responses there is nothing to compare.
	return;
	}

	this._broadcastUpdate.notifyIfUpdated({
	cacheName,
	oldResponse,
	newResponse,
	event,
	url: request.url
	});
	}

	}

	/*
	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.
	*/

	exports.BroadcastCacheUpdate = BroadcastCacheUpdate;
	exports.Plugin = Plugin;
	exports.broadcastUpdate = broadcastUpdate;
	exports.responsesAreSame = responsesAreSame;

	return exports;

	}({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private));
	//# sourceMappingURL=workbox-broadcast-update.dev.js.map