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