jekyll-pwa-workbox 0.0.6 → 0.0.7.alpha

data/lib/vendor/workbox-v4.3.1/workbox-broadcast-update.dev.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"workbox-broadcast-update.dev.js","sources":["../_version.mjs","../responsesAreSame.mjs","../utils/constants.mjs","../broadcastUpdate.mjs","../BroadcastCacheUpdate.mjs","../Plugin.mjs","../index.mjs"],"sourcesContent":["try{self['workbox:broadcast-update:4.3.1']&&_()}catch(e){}// eslint-disable-line","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\n\nimport {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';\nimport {logger} from 'workbox-core/_private/logger.mjs';\nimport './_version.mjs';\n\n/**\n * Given two `Response's`, compares several header values to see if they are\n * the same or not.\n *\n * @param {Response} firstResponse\n * @param {Response} secondResponse\n * @param {Array<string>} headersToCheck\n * @return {boolean}\n *\n * @memberof workbox.broadcastUpdate\n * @private\n */\nconst responsesAreSame = (firstResponse, secondResponse, headersToCheck) => {\n  if (process.env.NODE_ENV !== 'production') {\n    if (!(firstResponse instanceof Response &&\n      secondResponse instanceof Response)) {\n      throw new WorkboxError('invalid-responses-are-same-args');\n    }\n  }\n\n  const atLeastOneHeaderAvailable = headersToCheck.some((header) => {\n    return firstResponse.headers.has(header) &&\n      secondResponse.headers.has(header);\n  });\n\n  if (!atLeastOneHeaderAvailable) {\n    if (process.env.NODE_ENV !== 'production') {\n      logger.warn(`Unable to determine where the response has been updated ` +\n        `because none of the headers that would be checked are present.`);\n      logger.debug(`Attempting to compare the following: `,\n          firstResponse, secondResponse, headersToCheck);\n    }\n\n    // Just return true, indicating the that responses are the same, since we\n    // can't determine otherwise.\n    return true;\n  }\n\n  return headersToCheck.every((header) => {\n    const headerStateComparison = firstResponse.headers.has(header) ===\n      secondResponse.headers.has(header);\n    const headerValueComparison = firstResponse.headers.get(header) ===\n      secondResponse.headers.get(header);\n\n    return headerStateComparison && headerValueComparison;\n  });\n};\n\nexport {responsesAreSame};\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\n\nimport '../_version.mjs';\n\nexport const CACHE_UPDATED_MESSAGE_TYPE = 'CACHE_UPDATED';\nexport const CACHE_UPDATED_MESSAGE_META = 'workbox-broadcast-update';\nexport const DEFAULT_BROADCAST_CHANNEL_NAME = 'workbox';\nexport const DEFAULT_DEFER_NOTIFICATION_TIMEOUT = 10000;\nexport const DEFAULT_HEADERS_TO_CHECK = [\n  'content-length',\n  'etag',\n  'last-modified',\n];\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\n\nimport {assert} from 'workbox-core/_private/assert.mjs';\nimport {CACHE_UPDATED_MESSAGE_TYPE, CACHE_UPDATED_MESSAGE_META}\n  from './utils/constants.mjs';\n\nimport './_version.mjs';\n\n/**\n * You would not normally call this method directly; it's called automatically\n * by an instance of the {@link BroadcastCacheUpdate} class. It's exposed here\n * for the benefit of developers who would rather not use the full\n * `BroadcastCacheUpdate` implementation.\n *\n * Calling this will dispatch a message on the provided\n * {@link https://developers.google.com/web/updates/2016/09/broadcastchannel|Broadcast Channel}\n * to notify interested subscribers about a change to a cached resource.\n *\n * The message that's posted has a formation inspired by the\n * [Flux standard action](https://github.com/acdlite/flux-standard-action#introduction)\n * format like so:\n *\n * ```\n * {\n *   type: 'CACHE_UPDATED',\n *   meta: 'workbox-broadcast-update',\n *   payload: {\n *     cacheName: 'the-cache-name',\n *     updatedURL: 'https://example.com/'\n *   }\n * }\n * ```\n *\n * (Usage of [Flux](https://facebook.github.io/flux/) itself is not at\n * all required.)\n *\n * @param {Object} options\n * @param {string} options.cacheName The name of the cache in which the updated\n *     `Response` was stored.\n * @param {string} options.url The URL associated with the updated `Response`.\n * @param {BroadcastChannel} [options.channel] The `BroadcastChannel` to use.\n *     If no channel is set or the browser doesn't support the BroadcastChannel\n *     api, then an attempt will be made to `postMessage` each window client.\n *\n * @memberof workbox.broadcastUpdate\n */\nconst broadcastUpdate = async ({channel, cacheName, url}) => {\n  if (process.env.NODE_ENV !== 'production') {\n    assert.isType(cacheName, 'string', {\n      moduleName: 'workbox-broadcast-update',\n      className: '~',\n      funcName: 'broadcastUpdate',\n      paramName: 'cacheName',\n    });\n    assert.isType(url, 'string', {\n      moduleName: 'workbox-broadcast-update',\n      className: '~',\n      funcName: 'broadcastUpdate',\n      paramName: 'url',\n    });\n  }\n\n  const data = {\n    type: CACHE_UPDATED_MESSAGE_TYPE,\n    meta: CACHE_UPDATED_MESSAGE_META,\n    payload: {\n      cacheName: cacheName,\n      updatedURL: url,\n    },\n  };\n\n  if (channel) {\n    channel.postMessage(data);\n  } else {\n    const windows = await clients.matchAll({type: 'window'});\n    for (const win of windows) {\n      win.postMessage(data);\n    }\n  }\n};\n\nexport {broadcastUpdate};\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\n\nimport {assert} from 'workbox-core/_private/assert.mjs';\nimport {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.mjs';\nimport {logger} from 'workbox-core/_private/logger.mjs';\nimport {Deferred} from 'workbox-core/_private/Deferred.mjs';\nimport {responsesAreSame} from './responsesAreSame.mjs';\nimport {broadcastUpdate} from './broadcastUpdate.mjs';\n\nimport {DEFAULT_HEADERS_TO_CHECK, DEFAULT_BROADCAST_CHANNEL_NAME,\n  DEFAULT_DEFER_NOTIFICATION_TIMEOUT} from './utils/constants.mjs';\n\nimport './_version.mjs';\n\n/**\n * Uses the [Broadcast Channel API]{@link https://developers.google.com/web/updates/2016/09/broadcastchannel}\n * to notify interested parties when a cached response has been updated.\n * In browsers that do not support the Broadcast Channel API, the instance\n * falls back to sending the update via `postMessage()` to all window clients.\n *\n * For efficiency's sake, the underlying response bodies are not compared;\n * only specific response headers are checked.\n *\n * @memberof workbox.broadcastUpdate\n */\nclass BroadcastCacheUpdate {\n  /**\n   * Construct a BroadcastCacheUpdate instance with a specific `channelName` to\n   * broadcast messages on\n   *\n   * @param {Object} options\n   * @param {Array<string>}\n   *     [options.headersToCheck=['content-length', 'etag', 'last-modified']]\n   *     A list of headers that will be used to determine whether the responses\n   *     differ.\n   * @param {string} [options.channelName='workbox'] The name that will be used\n   *.    when creating the `BroadcastChannel`, which defaults to 'workbox' (the\n   *     channel name used by the `workbox-window` package).\n   * @param {string} [options.deferNoticationTimeout=10000] The amount of time\n   *     to wait for a ready message from the window on navigation requests\n   *     before sending the update.\n   */\n  constructor({headersToCheck, channelName, deferNoticationTimeout} = {}) {\n    this._headersToCheck = headersToCheck || DEFAULT_HEADERS_TO_CHECK;\n    this._channelName = channelName || DEFAULT_BROADCAST_CHANNEL_NAME;\n    this._deferNoticationTimeout =\n        deferNoticationTimeout || DEFAULT_DEFER_NOTIFICATION_TIMEOUT;\n\n    if (process.env.NODE_ENV !== 'production') {\n      assert.isType(this._channelName, 'string', {\n        moduleName: 'workbox-broadcast-update',\n        className: 'BroadcastCacheUpdate',\n        funcName: 'constructor',\n        paramName: 'channelName',\n      });\n      assert.isArray(this._headersToCheck, {\n        moduleName: 'workbox-broadcast-update',\n        className: 'BroadcastCacheUpdate',\n        funcName: 'constructor',\n        paramName: 'headersToCheck',\n      });\n    }\n\n    this._initWindowReadyDeferreds();\n  }\n\n  /**\n   * Compare two [Responses](https://developer.mozilla.org/en-US/docs/Web/API/Response)\n   * and send a message via the\n   * {@link https://developers.google.com/web/updates/2016/09/broadcastchannel|Broadcast Channel API}\n   * if they differ.\n   *\n   * Neither of the Responses can be {@link http://stackoverflow.com/questions/39109789|opaque}.\n   *\n   * @param {Object} options\n   * @param {Response} options.oldResponse Cached response to compare.\n   * @param {Response} options.newResponse Possibly updated response to compare.\n   * @param {string} options.url The URL of the request.\n   * @param {string} options.cacheName Name of the cache the responses belong\n   *     to. This is included in the broadcast message.\n   * @param {Event} [options.event] event An optional event that triggered\n   *     this possible cache update.\n   * @return {Promise} Resolves once the update is sent.\n   */\n  notifyIfUpdated({oldResponse, newResponse, url, cacheName, event}) {\n    if (!responsesAreSame(oldResponse, newResponse, this._headersToCheck)) {\n      if (process.env.NODE_ENV !== 'production') {\n        logger.log(`Newer response found (and cached) for:`, url);\n      }\n\n      const sendUpdate = async () => {\n        // In the case of a navigation request, the requesting page will likely\n        // not have loaded its JavaScript in time to recevied the update\n        // notification, so we defer it until ready (or we timeout waiting).\n        if (event && event.request && event.request.mode === 'navigate') {\n          if (process.env.NODE_ENV !== 'production') {\n            logger.debug(`Original request was a navigation request, ` +\n                `waiting for a ready message from the window`, event.request);\n          }\n          await this._windowReadyOrTimeout(event);\n        }\n        await this._broadcastUpdate({\n          channel: this._getChannel(),\n          cacheName,\n          url,\n        });\n      };\n\n      // Send the update and ensure the SW stays alive until it's sent.\n      const done = sendUpdate();\n\n      if (event) {\n        try {\n          event.waitUntil(done);\n        } catch (error) {\n          if (process.env.NODE_ENV !== 'production') {\n            logger.warn(`Unable to ensure service worker stays alive ` +\n                `when broadcasting cache update for ` +\n                `${getFriendlyURL(event.request.url)}'.`);\n          }\n        }\n      }\n      return done;\n    }\n  }\n\n  /**\n   * NOTE: this is exposed on the instance primarily so it can be spied on\n   * in tests.\n   *\n   * @param {Object} opts\n   * @private\n   */\n  async _broadcastUpdate(opts) {\n    await broadcastUpdate(opts);\n  }\n\n  /**\n   * @return {BroadcastChannel|undefined} The BroadcastChannel instance used for\n   * broadcasting updates, or undefined if the browser doesn't support the\n   * Broadcast Channel API.\n   *\n   * @private\n   */\n  _getChannel() {\n    if (('BroadcastChannel' in self) && !this._channel) {\n      this._channel = new BroadcastChannel(this._channelName);\n    }\n    return this._channel;\n  }\n\n  /**\n   * Waits for a message from the window indicating that it's capable of\n   * receiving broadcasts. By default, this will only wait for the amount of\n   * time specified via the `deferNoticationTimeout` option.\n   *\n   * @param {Event} event The navigation fetch event.\n   * @return {Promise}\n   * @private\n   */\n  _windowReadyOrTimeout(event) {\n    if (!this._navigationEventsDeferreds.has(event)) {\n      const deferred = new Deferred();\n\n      // Set the deferred on the `_navigationEventsDeferreds` map so it will\n      // be resolved when the next ready message event comes.\n      this._navigationEventsDeferreds.set(event, deferred);\n\n      // But don't wait too long for the message since it may never come.\n      const timeout = setTimeout(() => {\n        if (process.env.NODE_ENV !== 'production') {\n          logger.debug(`Timed out after ${this._deferNoticationTimeout}` +\n              `ms waiting for message from window`);\n        }\n        deferred.resolve();\n      }, this._deferNoticationTimeout);\n\n      // Ensure the timeout is cleared if the deferred promise is resolved.\n      deferred.promise.then(() => clearTimeout(timeout));\n    }\n    return this._navigationEventsDeferreds.get(event).promise;\n  }\n\n  /**\n   * Creates a mapping between navigation fetch events and deferreds, and adds\n   * a listener for message events from the window. When message events arrive,\n   * all deferreds in the mapping are resolved.\n   *\n   * Note: it would be easier if we could only resolve the deferred of\n   * navigation fetch event whose client ID matched the source ID of the\n   * message event, but currently client IDs are not exposed on navigation\n   * fetch events: https://www.chromestatus.com/feature/4846038800138240\n   *\n   * @private\n   */\n  _initWindowReadyDeferreds() {\n    // A mapping between navigation events and their deferreds.\n    this._navigationEventsDeferreds = new Map();\n\n    // The message listener needs to be added in the initial run of the\n    // service worker, but since we don't actually need to be listening for\n    // messages until the cache updates, we only invoke the callback if set.\n    self.addEventListener('message', (event) => {\n      if (event.data.type === 'WINDOW_READY' &&\n          event.data.meta === 'workbox-window' &&\n          this._navigationEventsDeferreds.size > 0) {\n        if (process.env.NODE_ENV !== 'production') {\n          logger.debug(`Received WINDOW_READY event: `, event);\n        }\n        // Resolve any pending deferreds.\n        for (const deferred of this._navigationEventsDeferreds.values()) {\n          deferred.resolve();\n        }\n        this._navigationEventsDeferreds.clear();\n      }\n    });\n  }\n}\n\nexport {BroadcastCacheUpdate};\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\n\nimport {assert} from 'workbox-core/_private/assert.mjs';\nimport {BroadcastCacheUpdate} from './BroadcastCacheUpdate.mjs';\nimport './_version.mjs';\n\n/**\n * This plugin will automatically broadcast a message whenever a cached response\n * is updated.\n *\n * @memberof workbox.broadcastUpdate\n */\nclass Plugin {\n  /**\n   * Construct a BroadcastCacheUpdate instance with the passed options and\n   * calls its `notifyIfUpdated()` method whenever the plugin's\n   * `cacheDidUpdate` callback is invoked.\n   *\n   * @param {Object} options\n   * @param {Array<string>}\n   *     [options.headersToCheck=['content-length', 'etag', 'last-modified']]\n   *     A list of headers that will be used to determine whether the responses\n   *     differ.\n   * @param {string} [options.channelName='workbox'] The name that will be used\n   *.    when creating the `BroadcastChannel`, which defaults to 'workbox' (the\n   *     channel name used by the `workbox-window` package).\n   * @param {string} [options.deferNoticationTimeout=10000] The amount of time\n   *     to wait for a ready message from the window on navigation requests\n   *     before sending the update.\n   */\n  constructor(options) {\n    this._broadcastUpdate = new BroadcastCacheUpdate(options);\n  }\n\n  /**\n   * A \"lifecycle\" callback that will be triggered automatically by the\n   * `workbox-sw` and `workbox-runtime-caching` handlers when an entry is\n   * added to a cache.\n   *\n   * @private\n   * @param {Object} options The input object to this function.\n   * @param {string} options.cacheName Name of the cache being updated.\n   * @param {Response} [options.oldResponse] The previous cached value, if any.\n   * @param {Response} options.newResponse The new value in the cache.\n   * @param {Request} options.request The request that triggered the udpate.\n   * @param {Request} [options.event] The event that triggered the update.\n   */\n  cacheDidUpdate({cacheName, oldResponse, newResponse, request, event}) {\n    if (process.env.NODE_ENV !== 'production') {\n      assert.isType(cacheName, 'string', {\n        moduleName: 'workbox-broadcast-update',\n        className: 'Plugin',\n        funcName: 'cacheDidUpdate',\n        paramName: 'cacheName',\n      });\n      assert.isInstance(newResponse, Response, {\n        moduleName: 'workbox-broadcast-update',\n        className: 'Plugin',\n        funcName: 'cacheDidUpdate',\n        paramName: 'newResponse',\n      });\n      assert.isInstance(request, Request, {\n        moduleName: 'workbox-broadcast-update',\n        className: 'Plugin',\n        funcName: 'cacheDidUpdate',\n        paramName: 'request',\n      });\n    }\n\n    if (!oldResponse) {\n      // Without a two responses there is nothing to compare.\n      return;\n    }\n    this._broadcastUpdate.notifyIfUpdated({\n      cacheName,\n      oldResponse,\n      newResponse,\n      event,\n      url: request.url,\n    });\n  }\n}\n\nexport {Plugin};\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\n\nimport {BroadcastCacheUpdate} from './BroadcastCacheUpdate.mjs';\nimport {Plugin} from './Plugin.mjs';\nimport {broadcastUpdate} from './broadcastUpdate.mjs';\nimport {responsesAreSame} from './responsesAreSame.mjs';\nimport './_version.mjs';\n\n\n/**\n * @namespace workbox.broadcastUpdate\n */\n\nexport {\n  BroadcastCacheUpdate,\n  Plugin,\n  broadcastUpdate,\n  responsesAreSame,\n};\n"],"names":["self","_","e","responsesAreSame","firstResponse","secondResponse","headersToCheck","Response","WorkboxError","atLeastOneHeaderAvailable","some","header","headers","has","logger","warn","debug","every","headerStateComparison","headerValueComparison","get","CACHE_UPDATED_MESSAGE_TYPE","CACHE_UPDATED_MESSAGE_META","DEFAULT_BROADCAST_CHANNEL_NAME","DEFAULT_DEFER_NOTIFICATION_TIMEOUT","DEFAULT_HEADERS_TO_CHECK","broadcastUpdate","channel","cacheName","url","assert","isType","moduleName","className","funcName","paramName","data","type","meta","payload","updatedURL","postMessage","windows","clients","matchAll","win","BroadcastCacheUpdate","constructor","channelName","deferNoticationTimeout","_headersToCheck","_channelName","_deferNoticationTimeout","isArray","_initWindowReadyDeferreds","notifyIfUpdated","oldResponse","newResponse","event","log","sendUpdate","request","mode","_windowReadyOrTimeout","_broadcastUpdate","_getChannel","done","waitUntil","error","getFriendlyURL","opts","_channel","BroadcastChannel","_navigationEventsDeferreds","deferred","Deferred","set","timeout","setTimeout","resolve","promise","then","clearTimeout","Map","addEventListener","size","values","clear","Plugin","options","cacheDidUpdate","isInstance","Request"],"mappings":"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"}

data/lib/vendor/workbox-v4.3.1/workbox-broadcast-update.prod.js

@@ -1,2 +0,0 @@
-this.workbox=this.workbox||{},this.workbox.broadcastUpdate=function(e,t){"use strict";try{self["workbox:broadcast-update:4.3.1"]&&_()}catch(e){}const s=(e,t,s)=>{return!s.some(s=>e.headers.has(s)&&t.headers.has(s))||s.every(s=>{const n=e.headers.has(s)===t.headers.has(s),a=e.headers.get(s)===t.headers.get(s);return n&&a})},n="workbox",a=1e4,i=["content-length","etag","last-modified"],o=async({channel:e,cacheName:t,url:s})=>{const n={type:"CACHE_UPDATED",meta:"workbox-broadcast-update",payload:{cacheName:t,updatedURL:s}};if(e)e.postMessage(n);else{const e=await clients.matchAll({type:"window"});for(const t of e)t.postMessage(n)}};class c{constructor({headersToCheck:e,channelName:t,deferNoticationTimeout:s}={}){this.t=e||i,this.s=t||n,this.i=s||a,this.o()}notifyIfUpdated({oldResponse:e,newResponse:t,url:n,cacheName:a,event:i}){if(!s(e,t,this.t)){const e=(async()=>{i&&i.request&&"navigate"===i.request.mode&&await this.h(i),await this.l({channel:this.u(),cacheName:a,url:n})})();if(i)try{i.waitUntil(e)}catch(e){}return e}}async l(e){await o(e)}u(){return"BroadcastChannel"in self&&!this.p&&(this.p=new BroadcastChannel(this.s)),this.p}h(e){if(!this.m.has(e)){const s=new t.Deferred;this.m.set(e,s);const n=setTimeout(()=>{s.resolve()},this.i);s.promise.then(()=>clearTimeout(n))}return this.m.get(e).promise}o(){this.m=new Map,self.addEventListener("message",e=>{if("WINDOW_READY"===e.data.type&&"workbox-window"===e.data.meta&&this.m.size>0){for(const e of this.m.values())e.resolve();this.m.clear()}})}}return e.BroadcastCacheUpdate=c,e.Plugin=class{constructor(e){this.l=new c(e)}cacheDidUpdate({cacheName:e,oldResponse:t,newResponse:s,request:n,event:a}){t&&this.l.notifyIfUpdated({cacheName:e,oldResponse:t,newResponse:s,event:a,url:n.url})}},e.broadcastUpdate=o,e.responsesAreSame=s,e}({},workbox.core._private);
-//# sourceMappingURL=workbox-broadcast-update.prod.js.map

data/lib/vendor/workbox-v4.3.1/workbox-broadcast-update.prod.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"workbox-broadcast-update.prod.js","sources":["../_version.mjs","../responsesAreSame.mjs","../utils/constants.mjs","../broadcastUpdate.mjs","../BroadcastCacheUpdate.mjs","../Plugin.mjs"],"sourcesContent":["try{self['workbox:broadcast-update:4.3.1']&&_()}catch(e){}// eslint-disable-line","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\n\nimport {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';\nimport {logger} from 'workbox-core/_private/logger.mjs';\nimport './_version.mjs';\n\n/**\n * Given two `Response's`, compares several header values to see if they are\n * the same or not.\n *\n * @param {Response} firstResponse\n * @param {Response} secondResponse\n * @param {Array<string>} headersToCheck\n * @return {boolean}\n *\n * @memberof workbox.broadcastUpdate\n * @private\n */\nconst responsesAreSame = (firstResponse, secondResponse, headersToCheck) => {\n  if (process.env.NODE_ENV !== 'production') {\n    if (!(firstResponse instanceof Response &&\n      secondResponse instanceof Response)) {\n      throw new WorkboxError('invalid-responses-are-same-args');\n    }\n  }\n\n  const atLeastOneHeaderAvailable = headersToCheck.some((header) => {\n    return firstResponse.headers.has(header) &&\n      secondResponse.headers.has(header);\n  });\n\n  if (!atLeastOneHeaderAvailable) {\n    if (process.env.NODE_ENV !== 'production') {\n      logger.warn(`Unable to determine where the response has been updated ` +\n        `because none of the headers that would be checked are present.`);\n      logger.debug(`Attempting to compare the following: `,\n          firstResponse, secondResponse, headersToCheck);\n    }\n\n    // Just return true, indicating the that responses are the same, since we\n    // can't determine otherwise.\n    return true;\n  }\n\n  return headersToCheck.every((header) => {\n    const headerStateComparison = firstResponse.headers.has(header) ===\n      secondResponse.headers.has(header);\n    const headerValueComparison = firstResponse.headers.get(header) ===\n      secondResponse.headers.get(header);\n\n    return headerStateComparison && headerValueComparison;\n  });\n};\n\nexport {responsesAreSame};\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\n\nimport '../_version.mjs';\n\nexport const CACHE_UPDATED_MESSAGE_TYPE = 'CACHE_UPDATED';\nexport const CACHE_UPDATED_MESSAGE_META = 'workbox-broadcast-update';\nexport const DEFAULT_BROADCAST_CHANNEL_NAME = 'workbox';\nexport const DEFAULT_DEFER_NOTIFICATION_TIMEOUT = 10000;\nexport const DEFAULT_HEADERS_TO_CHECK = [\n  'content-length',\n  'etag',\n  'last-modified',\n];\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\n\nimport {assert} from 'workbox-core/_private/assert.mjs';\nimport {CACHE_UPDATED_MESSAGE_TYPE, CACHE_UPDATED_MESSAGE_META}\n  from './utils/constants.mjs';\n\nimport './_version.mjs';\n\n/**\n * You would not normally call this method directly; it's called automatically\n * by an instance of the {@link BroadcastCacheUpdate} class. It's exposed here\n * for the benefit of developers who would rather not use the full\n * `BroadcastCacheUpdate` implementation.\n *\n * Calling this will dispatch a message on the provided\n * {@link https://developers.google.com/web/updates/2016/09/broadcastchannel|Broadcast Channel}\n * to notify interested subscribers about a change to a cached resource.\n *\n * The message that's posted has a formation inspired by the\n * [Flux standard action](https://github.com/acdlite/flux-standard-action#introduction)\n * format like so:\n *\n * ```\n * {\n *   type: 'CACHE_UPDATED',\n *   meta: 'workbox-broadcast-update',\n *   payload: {\n *     cacheName: 'the-cache-name',\n *     updatedURL: 'https://example.com/'\n *   }\n * }\n * ```\n *\n * (Usage of [Flux](https://facebook.github.io/flux/) itself is not at\n * all required.)\n *\n * @param {Object} options\n * @param {string} options.cacheName The name of the cache in which the updated\n *     `Response` was stored.\n * @param {string} options.url The URL associated with the updated `Response`.\n * @param {BroadcastChannel} [options.channel] The `BroadcastChannel` to use.\n *     If no channel is set or the browser doesn't support the BroadcastChannel\n *     api, then an attempt will be made to `postMessage` each window client.\n *\n * @memberof workbox.broadcastUpdate\n */\nconst broadcastUpdate = async ({channel, cacheName, url}) => {\n  if (process.env.NODE_ENV !== 'production') {\n    assert.isType(cacheName, 'string', {\n      moduleName: 'workbox-broadcast-update',\n      className: '~',\n      funcName: 'broadcastUpdate',\n      paramName: 'cacheName',\n    });\n    assert.isType(url, 'string', {\n      moduleName: 'workbox-broadcast-update',\n      className: '~',\n      funcName: 'broadcastUpdate',\n      paramName: 'url',\n    });\n  }\n\n  const data = {\n    type: CACHE_UPDATED_MESSAGE_TYPE,\n    meta: CACHE_UPDATED_MESSAGE_META,\n    payload: {\n      cacheName: cacheName,\n      updatedURL: url,\n    },\n  };\n\n  if (channel) {\n    channel.postMessage(data);\n  } else {\n    const windows = await clients.matchAll({type: 'window'});\n    for (const win of windows) {\n      win.postMessage(data);\n    }\n  }\n};\n\nexport {broadcastUpdate};\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\n\nimport {assert} from 'workbox-core/_private/assert.mjs';\nimport {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.mjs';\nimport {logger} from 'workbox-core/_private/logger.mjs';\nimport {Deferred} from 'workbox-core/_private/Deferred.mjs';\nimport {responsesAreSame} from './responsesAreSame.mjs';\nimport {broadcastUpdate} from './broadcastUpdate.mjs';\n\nimport {DEFAULT_HEADERS_TO_CHECK, DEFAULT_BROADCAST_CHANNEL_NAME,\n  DEFAULT_DEFER_NOTIFICATION_TIMEOUT} from './utils/constants.mjs';\n\nimport './_version.mjs';\n\n/**\n * Uses the [Broadcast Channel API]{@link https://developers.google.com/web/updates/2016/09/broadcastchannel}\n * to notify interested parties when a cached response has been updated.\n * In browsers that do not support the Broadcast Channel API, the instance\n * falls back to sending the update via `postMessage()` to all window clients.\n *\n * For efficiency's sake, the underlying response bodies are not compared;\n * only specific response headers are checked.\n *\n * @memberof workbox.broadcastUpdate\n */\nclass BroadcastCacheUpdate {\n  /**\n   * Construct a BroadcastCacheUpdate instance with a specific `channelName` to\n   * broadcast messages on\n   *\n   * @param {Object} options\n   * @param {Array<string>}\n   *     [options.headersToCheck=['content-length', 'etag', 'last-modified']]\n   *     A list of headers that will be used to determine whether the responses\n   *     differ.\n   * @param {string} [options.channelName='workbox'] The name that will be used\n   *.    when creating the `BroadcastChannel`, which defaults to 'workbox' (the\n   *     channel name used by the `workbox-window` package).\n   * @param {string} [options.deferNoticationTimeout=10000] The amount of time\n   *     to wait for a ready message from the window on navigation requests\n   *     before sending the update.\n   */\n  constructor({headersToCheck, channelName, deferNoticationTimeout} = {}) {\n    this._headersToCheck = headersToCheck || DEFAULT_HEADERS_TO_CHECK;\n    this._channelName = channelName || DEFAULT_BROADCAST_CHANNEL_NAME;\n    this._deferNoticationTimeout =\n        deferNoticationTimeout || DEFAULT_DEFER_NOTIFICATION_TIMEOUT;\n\n    if (process.env.NODE_ENV !== 'production') {\n      assert.isType(this._channelName, 'string', {\n        moduleName: 'workbox-broadcast-update',\n        className: 'BroadcastCacheUpdate',\n        funcName: 'constructor',\n        paramName: 'channelName',\n      });\n      assert.isArray(this._headersToCheck, {\n        moduleName: 'workbox-broadcast-update',\n        className: 'BroadcastCacheUpdate',\n        funcName: 'constructor',\n        paramName: 'headersToCheck',\n      });\n    }\n\n    this._initWindowReadyDeferreds();\n  }\n\n  /**\n   * Compare two [Responses](https://developer.mozilla.org/en-US/docs/Web/API/Response)\n   * and send a message via the\n   * {@link https://developers.google.com/web/updates/2016/09/broadcastchannel|Broadcast Channel API}\n   * if they differ.\n   *\n   * Neither of the Responses can be {@link http://stackoverflow.com/questions/39109789|opaque}.\n   *\n   * @param {Object} options\n   * @param {Response} options.oldResponse Cached response to compare.\n   * @param {Response} options.newResponse Possibly updated response to compare.\n   * @param {string} options.url The URL of the request.\n   * @param {string} options.cacheName Name of the cache the responses belong\n   *     to. This is included in the broadcast message.\n   * @param {Event} [options.event] event An optional event that triggered\n   *     this possible cache update.\n   * @return {Promise} Resolves once the update is sent.\n   */\n  notifyIfUpdated({oldResponse, newResponse, url, cacheName, event}) {\n    if (!responsesAreSame(oldResponse, newResponse, this._headersToCheck)) {\n      if (process.env.NODE_ENV !== 'production') {\n        logger.log(`Newer response found (and cached) for:`, url);\n      }\n\n      const sendUpdate = async () => {\n        // In the case of a navigation request, the requesting page will likely\n        // not have loaded its JavaScript in time to recevied the update\n        // notification, so we defer it until ready (or we timeout waiting).\n        if (event && event.request && event.request.mode === 'navigate') {\n          if (process.env.NODE_ENV !== 'production') {\n            logger.debug(`Original request was a navigation request, ` +\n                `waiting for a ready message from the window`, event.request);\n          }\n          await this._windowReadyOrTimeout(event);\n        }\n        await this._broadcastUpdate({\n          channel: this._getChannel(),\n          cacheName,\n          url,\n        });\n      };\n\n      // Send the update and ensure the SW stays alive until it's sent.\n      const done = sendUpdate();\n\n      if (event) {\n        try {\n          event.waitUntil(done);\n        } catch (error) {\n          if (process.env.NODE_ENV !== 'production') {\n            logger.warn(`Unable to ensure service worker stays alive ` +\n                `when broadcasting cache update for ` +\n                `${getFriendlyURL(event.request.url)}'.`);\n          }\n        }\n      }\n      return done;\n    }\n  }\n\n  /**\n   * NOTE: this is exposed on the instance primarily so it can be spied on\n   * in tests.\n   *\n   * @param {Object} opts\n   * @private\n   */\n  async _broadcastUpdate(opts) {\n    await broadcastUpdate(opts);\n  }\n\n  /**\n   * @return {BroadcastChannel|undefined} The BroadcastChannel instance used for\n   * broadcasting updates, or undefined if the browser doesn't support the\n   * Broadcast Channel API.\n   *\n   * @private\n   */\n  _getChannel() {\n    if (('BroadcastChannel' in self) && !this._channel) {\n      this._channel = new BroadcastChannel(this._channelName);\n    }\n    return this._channel;\n  }\n\n  /**\n   * Waits for a message from the window indicating that it's capable of\n   * receiving broadcasts. By default, this will only wait for the amount of\n   * time specified via the `deferNoticationTimeout` option.\n   *\n   * @param {Event} event The navigation fetch event.\n   * @return {Promise}\n   * @private\n   */\n  _windowReadyOrTimeout(event) {\n    if (!this._navigationEventsDeferreds.has(event)) {\n      const deferred = new Deferred();\n\n      // Set the deferred on the `_navigationEventsDeferreds` map so it will\n      // be resolved when the next ready message event comes.\n      this._navigationEventsDeferreds.set(event, deferred);\n\n      // But don't wait too long for the message since it may never come.\n      const timeout = setTimeout(() => {\n        if (process.env.NODE_ENV !== 'production') {\n          logger.debug(`Timed out after ${this._deferNoticationTimeout}` +\n              `ms waiting for message from window`);\n        }\n        deferred.resolve();\n      }, this._deferNoticationTimeout);\n\n      // Ensure the timeout is cleared if the deferred promise is resolved.\n      deferred.promise.then(() => clearTimeout(timeout));\n    }\n    return this._navigationEventsDeferreds.get(event).promise;\n  }\n\n  /**\n   * Creates a mapping between navigation fetch events and deferreds, and adds\n   * a listener for message events from the window. When message events arrive,\n   * all deferreds in the mapping are resolved.\n   *\n   * Note: it would be easier if we could only resolve the deferred of\n   * navigation fetch event whose client ID matched the source ID of the\n   * message event, but currently client IDs are not exposed on navigation\n   * fetch events: https://www.chromestatus.com/feature/4846038800138240\n   *\n   * @private\n   */\n  _initWindowReadyDeferreds() {\n    // A mapping between navigation events and their deferreds.\n    this._navigationEventsDeferreds = new Map();\n\n    // The message listener needs to be added in the initial run of the\n    // service worker, but since we don't actually need to be listening for\n    // messages until the cache updates, we only invoke the callback if set.\n    self.addEventListener('message', (event) => {\n      if (event.data.type === 'WINDOW_READY' &&\n          event.data.meta === 'workbox-window' &&\n          this._navigationEventsDeferreds.size > 0) {\n        if (process.env.NODE_ENV !== 'production') {\n          logger.debug(`Received WINDOW_READY event: `, event);\n        }\n        // Resolve any pending deferreds.\n        for (const deferred of this._navigationEventsDeferreds.values()) {\n          deferred.resolve();\n        }\n        this._navigationEventsDeferreds.clear();\n      }\n    });\n  }\n}\n\nexport {BroadcastCacheUpdate};\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\n\nimport {assert} from 'workbox-core/_private/assert.mjs';\nimport {BroadcastCacheUpdate} from './BroadcastCacheUpdate.mjs';\nimport './_version.mjs';\n\n/**\n * This plugin will automatically broadcast a message whenever a cached response\n * is updated.\n *\n * @memberof workbox.broadcastUpdate\n */\nclass Plugin {\n  /**\n   * Construct a BroadcastCacheUpdate instance with the passed options and\n   * calls its `notifyIfUpdated()` method whenever the plugin's\n   * `cacheDidUpdate` callback is invoked.\n   *\n   * @param {Object} options\n   * @param {Array<string>}\n   *     [options.headersToCheck=['content-length', 'etag', 'last-modified']]\n   *     A list of headers that will be used to determine whether the responses\n   *     differ.\n   * @param {string} [options.channelName='workbox'] The name that will be used\n   *.    when creating the `BroadcastChannel`, which defaults to 'workbox' (the\n   *     channel name used by the `workbox-window` package).\n   * @param {string} [options.deferNoticationTimeout=10000] The amount of time\n   *     to wait for a ready message from the window on navigation requests\n   *     before sending the update.\n   */\n  constructor(options) {\n    this._broadcastUpdate = new BroadcastCacheUpdate(options);\n  }\n\n  /**\n   * A \"lifecycle\" callback that will be triggered automatically by the\n   * `workbox-sw` and `workbox-runtime-caching` handlers when an entry is\n   * added to a cache.\n   *\n   * @private\n   * @param {Object} options The input object to this function.\n   * @param {string} options.cacheName Name of the cache being updated.\n   * @param {Response} [options.oldResponse] The previous cached value, if any.\n   * @param {Response} options.newResponse The new value in the cache.\n   * @param {Request} options.request The request that triggered the udpate.\n   * @param {Request} [options.event] The event that triggered the update.\n   */\n  cacheDidUpdate({cacheName, oldResponse, newResponse, request, event}) {\n    if (process.env.NODE_ENV !== 'production') {\n      assert.isType(cacheName, 'string', {\n        moduleName: 'workbox-broadcast-update',\n        className: 'Plugin',\n        funcName: 'cacheDidUpdate',\n        paramName: 'cacheName',\n      });\n      assert.isInstance(newResponse, Response, {\n        moduleName: 'workbox-broadcast-update',\n        className: 'Plugin',\n        funcName: 'cacheDidUpdate',\n        paramName: 'newResponse',\n      });\n      assert.isInstance(request, Request, {\n        moduleName: 'workbox-broadcast-update',\n        className: 'Plugin',\n        funcName: 'cacheDidUpdate',\n        paramName: 'request',\n      });\n    }\n\n    if (!oldResponse) {\n      // Without a two responses there is nothing to compare.\n      return;\n    }\n    this._broadcastUpdate.notifyIfUpdated({\n      cacheName,\n      oldResponse,\n      newResponse,\n      event,\n      url: request.url,\n    });\n  }\n}\n\nexport {Plugin};\n"],"names":["self","_","e","responsesAreSame","firstResponse","secondResponse","headersToCheck","some","header","headers","has","every","headerStateComparison","headerValueComparison","get","DEFAULT_BROADCAST_CHANNEL_NAME","DEFAULT_DEFER_NOTIFICATION_TIMEOUT","DEFAULT_HEADERS_TO_CHECK","broadcastUpdate","async","channel","cacheName","url","data","type","meta","payload","updatedURL","postMessage","windows","clients","matchAll","win","BroadcastCacheUpdate","constructor","channelName","deferNoticationTimeout","_headersToCheck","_channelName","_deferNoticationTimeout","_initWindowReadyDeferreds","notifyIfUpdated","oldResponse","newResponse","event","this","done","request","mode","_windowReadyOrTimeout","_broadcastUpdate","_getChannel","sendUpdate","waitUntil","error","opts","_channel","BroadcastChannel","_navigationEventsDeferreds","deferred","Deferred","set","timeout","setTimeout","resolve","promise","then","clearTimeout","Map","addEventListener","size","values","clear","options","cacheDidUpdate"],"mappings":"sFAAA,IAAIA,KAAK,mCAAmCC,IAAI,MAAMC,UCwBhDC,EAAmB,CAACC,EAAeC,EAAgBC,YAQrBA,EAAeC,KAAMC,GAC9CJ,EAAcK,QAAQC,IAAIF,IAC/BH,EAAeI,QAAQC,IAAIF,KAgBxBF,EAAeK,MAAOH,UACrBI,EAAwBR,EAAcK,QAAQC,IAAIF,KACtDH,EAAeI,QAAQC,IAAIF,GACvBK,EAAwBT,EAAcK,QAAQK,IAAIN,KACtDH,EAAeI,QAAQK,IAAIN,UAEtBI,GAAyBC,KC5CvBE,EAAiC,UACjCC,EAAqC,IACrCC,EAA2B,CACtC,iBACA,OACA,iBCmCIC,EAAkBC,OAAQC,QAAAA,EAASC,UAAAA,EAAWC,IAAAA,YAgB5CC,EAAO,CACXC,KD3DsC,gBC4DtCC,KD3DsC,2BC4DtCC,QAAS,CACPL,UAAWA,EACXM,WAAYL,OAIZF,EACFA,EAAQQ,YAAYL,OACf,OACCM,QAAgBC,QAAQC,SAAS,CAACP,KAAM,eACzC,MAAMQ,KAAOH,EAChBG,EAAIJ,YAAYL,KCnDtB,MAAMU,EAiBJC,aAAY5B,eAACA,EAAD6B,YAAiBA,EAAjBC,uBAA8BA,GAA0B,SAC7DC,EAAkB/B,GAAkBW,OACpCqB,EAAeH,GAAepB,OAC9BwB,EACDH,GAA0BpB,OAiBzBwB,IAqBPC,iBAAgBC,YAACA,EAADC,YAAcA,EAAdrB,IAA2BA,EAA3BD,UAAgCA,EAAhCuB,MAA2CA,QACpDzC,EAAiBuC,EAAaC,EAAaE,KAAKR,GAAkB,OAwB/DS,EAnBa3B,WAIbyB,GAASA,EAAMG,SAAkC,aAAvBH,EAAMG,QAAQC,YAKpCH,KAAKI,EAAsBL,SAE7BC,KAAKK,EAAiB,CAC1B9B,QAASyB,KAAKM,IACd9B,UAAAA,EACAC,IAAAA,KAKS8B,MAETR,MAEAA,EAAMS,UAAUP,GAChB,MAAOQ,WAQJR,WAWYS,SACfrC,EAAgBqC,GAUxBJ,UACO,qBAAsBnD,OAAU6C,KAAKW,SACnCA,EAAW,IAAIC,iBAAiBZ,KAAKP,IAErCO,KAAKW,EAYdP,EAAsBL,OACfC,KAAKa,EAA2BhD,IAAIkC,GAAQ,OACzCe,EAAW,IAAIC,gBAIhBF,EAA2BG,IAAIjB,EAAOe,SAGrCG,EAAUC,WAAW,KAKzBJ,EAASK,WACRnB,KAAKN,GAGRoB,EAASM,QAAQC,KAAK,IAAMC,aAAaL,WAEpCjB,KAAKa,EAA2B5C,IAAI8B,GAAOqB,QAepDzB,SAEOkB,EAA6B,IAAIU,IAKtCpE,KAAKqE,iBAAiB,UAAYzB,OACR,iBAApBA,EAAMrB,KAAKC,MACS,mBAApBoB,EAAMrB,KAAKE,MACXoB,KAAKa,EAA2BY,KAAO,EAAG,KAKvC,MAAMX,KAAYd,KAAKa,EAA2Ba,SACrDZ,EAASK,eAENN,EAA2Bc,qDCzMxC,MAkBEtC,YAAYuC,QACLvB,EAAmB,IAAIjB,EAAqBwC,GAgBnDC,gBAAerD,UAACA,EAADqB,YAAYA,EAAZC,YAAyBA,EAAzBI,QAAsCA,EAAtCH,MAA+CA,IAsBvDF,QAIAQ,EAAiBT,gBAAgB,CACpCpB,UAAAA,EACAqB,YAAAA,EACAC,YAAAA,EACAC,MAAAA,EACAtB,IAAKyB,EAAQzB"}

data/lib/vendor/workbox-v4.3.1/workbox-cacheable-response.dev.js

@@ -1,200 +0,0 @@
-this.workbox = this.workbox || {};
-this.workbox.cacheableResponse = (function (exports, WorkboxError_mjs, assert_mjs, getFriendlyURL_mjs, logger_mjs) {
-  'use strict';
-
-  try {
-    self['workbox:cacheable-response: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.
-  */
-  /**
-   * This class allows you to set up rules determining what
-   * status codes and/or headers need to be present in order for a
-   * [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
-   * to be considered cacheable.
-   *
-   * @memberof workbox.cacheableResponse
-   */
-
-  class CacheableResponse {
-    /**
-     * To construct a new CacheableResponse instance you must provide at least
-     * one of the `config` properties.
-     *
-     * If both `statuses` and `headers` are specified, then both conditions must
-     * be met for the `Response` to be considered cacheable.
-     *
-     * @param {Object} config
-     * @param {Array<number>} [config.statuses] One or more status codes that a
-     * `Response` can have and be considered cacheable.
-     * @param {Object<string,string>} [config.headers] A mapping of header names
-     * and expected values that a `Response` can have and be considered cacheable.
-     * If multiple headers are provided, only one needs to be present.
-     */
-    constructor(config = {}) {
-      {
-        if (!(config.statuses || config.headers)) {
-          throw new WorkboxError_mjs.WorkboxError('statuses-or-headers-required', {
-            moduleName: 'workbox-cacheable-response',
-            className: 'CacheableResponse',
-            funcName: 'constructor'
-          });
-        }
-
-        if (config.statuses) {
-          assert_mjs.assert.isArray(config.statuses, {
-            moduleName: 'workbox-cacheable-response',
-            className: 'CacheableResponse',
-            funcName: 'constructor',
-            paramName: 'config.statuses'
-          });
-        }
-
-        if (config.headers) {
-          assert_mjs.assert.isType(config.headers, 'object', {
-            moduleName: 'workbox-cacheable-response',
-            className: 'CacheableResponse',
-            funcName: 'constructor',
-            paramName: 'config.headers'
-          });
-        }
-      }
-
-      this._statuses = config.statuses;
-      this._headers = config.headers;
-    }
-    /**
-     * Checks a response to see whether it's cacheable or not, based on this
-     * object's configuration.
-     *
-     * @param {Response} response The response whose cacheability is being
-     * checked.
-     * @return {boolean} `true` if the `Response` is cacheable, and `false`
-     * otherwise.
-     */
-
-
-    isResponseCacheable(response) {
-      {
-        assert_mjs.assert.isInstance(response, Response, {
-          moduleName: 'workbox-cacheable-response',
-          className: 'CacheableResponse',
-          funcName: 'isResponseCacheable',
-          paramName: 'response'
-        });
-      }
-
-      let cacheable = true;
-
-      if (this._statuses) {
-        cacheable = this._statuses.includes(response.status);
-      }
-
-      if (this._headers && cacheable) {
-        cacheable = Object.keys(this._headers).some(headerName => {
-          return response.headers.get(headerName) === this._headers[headerName];
-        });
-      }
-
-      {
-        if (!cacheable) {
-          logger_mjs.logger.groupCollapsed(`The request for ` + `'${getFriendlyURL_mjs.getFriendlyURL(response.url)}' returned a response that does ` + `not meet the criteria for being cached.`);
-          logger_mjs.logger.groupCollapsed(`View cacheability criteria here.`);
-          logger_mjs.logger.log(`Cacheable statuses: ` + JSON.stringify(this._statuses));
-          logger_mjs.logger.log(`Cacheable headers: ` + JSON.stringify(this._headers, null, 2));
-          logger_mjs.logger.groupEnd();
-          const logFriendlyHeaders = {};
-          response.headers.forEach((value, key) => {
-            logFriendlyHeaders[key] = value;
-          });
-          logger_mjs.logger.groupCollapsed(`View response status and headers here.`);
-          logger_mjs.logger.log(`Response status: ` + response.status);
-          logger_mjs.logger.log(`Response headers: ` + JSON.stringify(logFriendlyHeaders, null, 2));
-          logger_mjs.logger.groupEnd();
-          logger_mjs.logger.groupCollapsed(`View full response details here.`);
-          logger_mjs.logger.log(response.headers);
-          logger_mjs.logger.log(response);
-          logger_mjs.logger.groupEnd();
-          logger_mjs.logger.groupEnd();
-        }
-      }
-
-      return cacheable;
-    }
-
-  }
-
-  /*
-    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.
-  */
-  /**
-   * A class implementing the `cacheWillUpdate` lifecycle callback. This makes it
-   * easier to add in cacheability checks to requests made via Workbox's built-in
-   * strategies.
-   *
-   * @memberof workbox.cacheableResponse
-   */
-
-  class Plugin {
-    /**
-     * To construct a new cacheable response Plugin instance you must provide at
-     * least one of the `config` properties.
-     *
-     * If both `statuses` and `headers` are specified, then both conditions must
-     * be met for the `Response` to be considered cacheable.
-     *
-     * @param {Object} config
-     * @param {Array<number>} [config.statuses] One or more status codes that a
-     * `Response` can have and be considered cacheable.
-     * @param {Object<string,string>} [config.headers] A mapping of header names
-     * and expected values that a `Response` can have and be considered cacheable.
-     * If multiple headers are provided, only one needs to be present.
-     */
-    constructor(config) {
-      this._cacheableResponse = new CacheableResponse(config);
-    }
-    /**
-     * @param {Object} options
-     * @param {Response} options.response
-     * @return {boolean}
-     * @private
-     */
-
-
-    cacheWillUpdate({
-      response
-    }) {
-      if (this._cacheableResponse.isResponseCacheable(response)) {
-        return response;
-      }
-
-      return null;
-    }
-
-  }
-
-  /*
-    Copyright 2018 Google LLC
-
-    Use of this source code is governed by an MIT-style
-    license that can be found in the LICENSE file or at
-    https://opensource.org/licenses/MIT.
-  */
-
-  exports.CacheableResponse = CacheableResponse;
-  exports.Plugin = Plugin;
-
-  return exports;
-
-}({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private));
-//# sourceMappingURL=workbox-cacheable-response.dev.js.map

data/lib/vendor/workbox-v4.3.1/workbox-cacheable-response.dev.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"workbox-cacheable-response.dev.js","sources":["../_version.mjs","../CacheableResponse.mjs","../Plugin.mjs","../index.mjs"],"sourcesContent":["try{self['workbox:cacheable-response:4.3.1']&&_()}catch(e){}// eslint-disable-line","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\n\nimport {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';\nimport {assert} from 'workbox-core/_private/assert.mjs';\nimport {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.mjs';\nimport {logger} from 'workbox-core/_private/logger.mjs';\nimport './_version.mjs';\n\n/**\n * This class allows you to set up rules determining what\n * status codes and/or headers need to be present in order for a\n * [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)\n * to be considered cacheable.\n *\n * @memberof workbox.cacheableResponse\n */\nclass CacheableResponse {\n  /**\n   * To construct a new CacheableResponse instance you must provide at least\n   * one of the `config` properties.\n   *\n   * If both `statuses` and `headers` are specified, then both conditions must\n   * be met for the `Response` to be considered cacheable.\n   *\n   * @param {Object} config\n   * @param {Array<number>} [config.statuses] One or more status codes that a\n   * `Response` can have and be considered cacheable.\n   * @param {Object<string,string>} [config.headers] A mapping of header names\n   * and expected values that a `Response` can have and be considered cacheable.\n   * If multiple headers are provided, only one needs to be present.\n   */\n  constructor(config = {}) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (!(config.statuses || config.headers)) {\n        throw new WorkboxError('statuses-or-headers-required', {\n          moduleName: 'workbox-cacheable-response',\n          className: 'CacheableResponse',\n          funcName: 'constructor',\n        });\n      }\n\n      if (config.statuses) {\n        assert.isArray(config.statuses, {\n          moduleName: 'workbox-cacheable-response',\n          className: 'CacheableResponse',\n          funcName: 'constructor',\n          paramName: 'config.statuses',\n        });\n      }\n\n      if (config.headers) {\n        assert.isType(config.headers, 'object', {\n          moduleName: 'workbox-cacheable-response',\n          className: 'CacheableResponse',\n          funcName: 'constructor',\n          paramName: 'config.headers',\n        });\n      }\n    }\n\n    this._statuses = config.statuses;\n    this._headers = config.headers;\n  }\n\n  /**\n   * Checks a response to see whether it's cacheable or not, based on this\n   * object's configuration.\n   *\n   * @param {Response} response The response whose cacheability is being\n   * checked.\n   * @return {boolean} `true` if the `Response` is cacheable, and `false`\n   * otherwise.\n   */\n  isResponseCacheable(response) {\n    if (process.env.NODE_ENV !== 'production') {\n      assert.isInstance(response, Response, {\n        moduleName: 'workbox-cacheable-response',\n        className: 'CacheableResponse',\n        funcName: 'isResponseCacheable',\n        paramName: 'response',\n      });\n    }\n\n    let cacheable = true;\n\n    if (this._statuses) {\n      cacheable = this._statuses.includes(response.status);\n    }\n\n    if (this._headers && cacheable) {\n      cacheable = Object.keys(this._headers).some((headerName) => {\n        return response.headers.get(headerName) === this._headers[headerName];\n      });\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (!cacheable) {\n        logger.groupCollapsed(`The request for ` +\n          `'${getFriendlyURL(response.url)}' returned a response that does ` +\n          `not meet the criteria for being cached.`);\n\n        logger.groupCollapsed(`View cacheability criteria here.`);\n        logger.log(`Cacheable statuses: ` +\n          JSON.stringify(this._statuses));\n        logger.log(`Cacheable headers: ` +\n          JSON.stringify(this._headers, null, 2));\n        logger.groupEnd();\n\n        const logFriendlyHeaders = {};\n        response.headers.forEach((value, key) => {\n          logFriendlyHeaders[key] = value;\n        });\n\n        logger.groupCollapsed(`View response status and headers here.`);\n        logger.log(`Response status: ` + response.status);\n        logger.log(`Response headers: ` +\n          JSON.stringify(logFriendlyHeaders, null, 2));\n        logger.groupEnd();\n\n        logger.groupCollapsed(`View full response details here.`);\n        logger.log(response.headers);\n        logger.log(response);\n        logger.groupEnd();\n\n        logger.groupEnd();\n      }\n    }\n\n    return cacheable;\n  }\n}\n\nexport {CacheableResponse};\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\n\nimport {CacheableResponse} from './CacheableResponse.mjs';\nimport './_version.mjs';\n\n/**\n * A class implementing the `cacheWillUpdate` lifecycle callback. This makes it\n * easier to add in cacheability checks to requests made via Workbox's built-in\n * strategies.\n *\n * @memberof workbox.cacheableResponse\n */\nclass Plugin {\n  /**\n   * To construct a new cacheable response Plugin instance you must provide at\n   * least one of the `config` properties.\n   *\n   * If both `statuses` and `headers` are specified, then both conditions must\n   * be met for the `Response` to be considered cacheable.\n   *\n   * @param {Object} config\n   * @param {Array<number>} [config.statuses] One or more status codes that a\n   * `Response` can have and be considered cacheable.\n   * @param {Object<string,string>} [config.headers] A mapping of header names\n   * and expected values that a `Response` can have and be considered cacheable.\n   * If multiple headers are provided, only one needs to be present.\n   */\n  constructor(config) {\n    this._cacheableResponse = new CacheableResponse(config);\n  }\n\n  /**\n   * @param {Object} options\n   * @param {Response} options.response\n   * @return {boolean}\n   * @private\n   */\n  cacheWillUpdate({response}) {\n    if (this._cacheableResponse.isResponseCacheable(response)) {\n      return response;\n    }\n    return null;\n  }\n}\n\nexport {Plugin};\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\n\nimport {CacheableResponse} from './CacheableResponse.mjs';\nimport {Plugin} from './Plugin.mjs';\nimport './_version.mjs';\n\n\n/**\n * @namespace workbox.cacheableResponse\n */\n\nexport {\n  CacheableResponse,\n  Plugin,\n};\n"],"names":["self","_","e","CacheableResponse","constructor","config","statuses","headers","WorkboxError","moduleName","className","funcName","assert","isArray","paramName","isType","_statuses","_headers","isResponseCacheable","response","isInstance","Response","cacheable","includes","status","Object","keys","some","headerName","get","logger","groupCollapsed","getFriendlyURL","url","log","JSON","stringify","groupEnd","logFriendlyHeaders","forEach","value","key","Plugin","_cacheableResponse","cacheWillUpdate"],"mappings":";;;;EAAA,IAAG;EAACA,EAAAA,IAAI,CAAC,kCAAD,CAAJ,IAA0CC,CAAC,EAA3C;EAA8C,CAAlD,CAAkD,OAAMC,CAAN,EAAQ;;ECA1D;;;;;;;AAQA,EAMA;;;;;;;;;EAQA,MAAMC,iBAAN,CAAwB;EACtB;;;;;;;;;;;;;;EAcAC,EAAAA,WAAW,CAACC,MAAM,GAAG,EAAV,EAAc;EACvB,IAA2C;EACzC,UAAI,EAAEA,MAAM,CAACC,QAAP,IAAmBD,MAAM,CAACE,OAA5B,CAAJ,EAA0C;EACxC,cAAM,IAAIC,6BAAJ,CAAiB,8BAAjB,EAAiD;EACrDC,UAAAA,UAAU,EAAE,4BADyC;EAErDC,UAAAA,SAAS,EAAE,mBAF0C;EAGrDC,UAAAA,QAAQ,EAAE;EAH2C,SAAjD,CAAN;EAKD;;EAED,UAAIN,MAAM,CAACC,QAAX,EAAqB;EACnBM,QAAAA,iBAAM,CAACC,OAAP,CAAeR,MAAM,CAACC,QAAtB,EAAgC;EAC9BG,UAAAA,UAAU,EAAE,4BADkB;EAE9BC,UAAAA,SAAS,EAAE,mBAFmB;EAG9BC,UAAAA,QAAQ,EAAE,aAHoB;EAI9BG,UAAAA,SAAS,EAAE;EAJmB,SAAhC;EAMD;;EAED,UAAIT,MAAM,CAACE,OAAX,EAAoB;EAClBK,QAAAA,iBAAM,CAACG,MAAP,CAAcV,MAAM,CAACE,OAArB,EAA8B,QAA9B,EAAwC;EACtCE,UAAAA,UAAU,EAAE,4BAD0B;EAEtCC,UAAAA,SAAS,EAAE,mBAF2B;EAGtCC,UAAAA,QAAQ,EAAE,aAH4B;EAItCG,UAAAA,SAAS,EAAE;EAJ2B,SAAxC;EAMD;EACF;;EAED,SAAKE,SAAL,GAAiBX,MAAM,CAACC,QAAxB;EACA,SAAKW,QAAL,GAAgBZ,MAAM,CAACE,OAAvB;EACD;EAED;;;;;;;;;;;EASAW,EAAAA,mBAAmB,CAACC,QAAD,EAAW;EAC5B,IAA2C;EACzCP,MAAAA,iBAAM,CAACQ,UAAP,CAAkBD,QAAlB,EAA4BE,QAA5B,EAAsC;EACpCZ,QAAAA,UAAU,EAAE,4BADwB;EAEpCC,QAAAA,SAAS,EAAE,mBAFyB;EAGpCC,QAAAA,QAAQ,EAAE,qBAH0B;EAIpCG,QAAAA,SAAS,EAAE;EAJyB,OAAtC;EAMD;;EAED,QAAIQ,SAAS,GAAG,IAAhB;;EAEA,QAAI,KAAKN,SAAT,EAAoB;EAClBM,MAAAA,SAAS,GAAG,KAAKN,SAAL,CAAeO,QAAf,CAAwBJ,QAAQ,CAACK,MAAjC,CAAZ;EACD;;EAED,QAAI,KAAKP,QAAL,IAAiBK,SAArB,EAAgC;EAC9BA,MAAAA,SAAS,GAAGG,MAAM,CAACC,IAAP,CAAY,KAAKT,QAAjB,EAA2BU,IAA3B,CAAiCC,UAAD,IAAgB;EAC1D,eAAOT,QAAQ,CAACZ,OAAT,CAAiBsB,GAAjB,CAAqBD,UAArB,MAAqC,KAAKX,QAAL,CAAcW,UAAd,CAA5C;EACD,OAFW,CAAZ;EAGD;;EAED,IAA2C;EACzC,UAAI,CAACN,SAAL,EAAgB;EACdQ,QAAAA,iBAAM,CAACC,cAAP,CAAuB,kBAAD,GACnB,IAAGC,iCAAc,CAACb,QAAQ,CAACc,GAAV,CAAe,kCADb,GAEnB,yCAFH;EAIAH,QAAAA,iBAAM,CAACC,cAAP,CAAuB,kCAAvB;EACAD,QAAAA,iBAAM,CAACI,GAAP,CAAY,sBAAD,GACTC,IAAI,CAACC,SAAL,CAAe,KAAKpB,SAApB,CADF;EAEAc,QAAAA,iBAAM,CAACI,GAAP,CAAY,qBAAD,GACTC,IAAI,CAACC,SAAL,CAAe,KAAKnB,QAApB,EAA8B,IAA9B,EAAoC,CAApC,CADF;EAEAa,QAAAA,iBAAM,CAACO,QAAP;EAEA,cAAMC,kBAAkB,GAAG,EAA3B;EACAnB,QAAAA,QAAQ,CAACZ,OAAT,CAAiBgC,OAAjB,CAAyB,CAACC,KAAD,EAAQC,GAAR,KAAgB;EACvCH,UAAAA,kBAAkB,CAACG,GAAD,CAAlB,GAA0BD,KAA1B;EACD,SAFD;EAIAV,QAAAA,iBAAM,CAACC,cAAP,CAAuB,wCAAvB;EACAD,QAAAA,iBAAM,CAACI,GAAP,CAAY,mBAAD,GAAsBf,QAAQ,CAACK,MAA1C;EACAM,QAAAA,iBAAM,CAACI,GAAP,CAAY,oBAAD,GACTC,IAAI,CAACC,SAAL,CAAeE,kBAAf,EAAmC,IAAnC,EAAyC,CAAzC,CADF;EAEAR,QAAAA,iBAAM,CAACO,QAAP;EAEAP,QAAAA,iBAAM,CAACC,cAAP,CAAuB,kCAAvB;EACAD,QAAAA,iBAAM,CAACI,GAAP,CAAWf,QAAQ,CAACZ,OAApB;EACAuB,QAAAA,iBAAM,CAACI,GAAP,CAAWf,QAAX;EACAW,QAAAA,iBAAM,CAACO,QAAP;EAEAP,QAAAA,iBAAM,CAACO,QAAP;EACD;EACF;;EAED,WAAOf,SAAP;EACD;;EAjHqB;;ECtBxB;;;;;;;AAQA,EAGA;;;;;;;;EAOA,MAAMoB,MAAN,CAAa;EACX;;;;;;;;;;;;;;EAcAtC,EAAAA,WAAW,CAACC,MAAD,EAAS;EAClB,SAAKsC,kBAAL,GAA0B,IAAIxC,iBAAJ,CAAsBE,MAAtB,CAA1B;EACD;EAED;;;;;;;;EAMAuC,EAAAA,eAAe,CAAC;EAACzB,IAAAA;EAAD,GAAD,EAAa;EAC1B,QAAI,KAAKwB,kBAAL,CAAwBzB,mBAAxB,CAA4CC,QAA5C,CAAJ,EAA2D;EACzD,aAAOA,QAAP;EACD;;EACD,WAAO,IAAP;EACD;;EA9BU;;EClBb;;;;;;;;;;;;;;;;;"}

data/lib/vendor/workbox-v4.3.1/workbox-cacheable-response.prod.js

@@ -1,2 +0,0 @@
-this.workbox=this.workbox||{},this.workbox.cacheableResponse=function(t){"use strict";try{self["workbox:cacheable-response:4.3.1"]&&_()}catch(t){}class s{constructor(t={}){this.t=t.statuses,this.s=t.headers}isResponseCacheable(t){let s=!0;return this.t&&(s=this.t.includes(t.status)),this.s&&s&&(s=Object.keys(this.s).some(s=>t.headers.get(s)===this.s[s])),s}}return t.CacheableResponse=s,t.Plugin=class{constructor(t){this.i=new s(t)}cacheWillUpdate({response:t}){return this.i.isResponseCacheable(t)?t:null}},t}({});
-//# sourceMappingURL=workbox-cacheable-response.prod.js.map

data/lib/vendor/workbox-v4.3.1/workbox-cacheable-response.prod.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"workbox-cacheable-response.prod.js","sources":["../_version.mjs","../CacheableResponse.mjs","../Plugin.mjs"],"sourcesContent":["try{self['workbox:cacheable-response:4.3.1']&&_()}catch(e){}// eslint-disable-line","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\n\nimport {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';\nimport {assert} from 'workbox-core/_private/assert.mjs';\nimport {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.mjs';\nimport {logger} from 'workbox-core/_private/logger.mjs';\nimport './_version.mjs';\n\n/**\n * This class allows you to set up rules determining what\n * status codes and/or headers need to be present in order for a\n * [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)\n * to be considered cacheable.\n *\n * @memberof workbox.cacheableResponse\n */\nclass CacheableResponse {\n  /**\n   * To construct a new CacheableResponse instance you must provide at least\n   * one of the `config` properties.\n   *\n   * If both `statuses` and `headers` are specified, then both conditions must\n   * be met for the `Response` to be considered cacheable.\n   *\n   * @param {Object} config\n   * @param {Array<number>} [config.statuses] One or more status codes that a\n   * `Response` can have and be considered cacheable.\n   * @param {Object<string,string>} [config.headers] A mapping of header names\n   * and expected values that a `Response` can have and be considered cacheable.\n   * If multiple headers are provided, only one needs to be present.\n   */\n  constructor(config = {}) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (!(config.statuses || config.headers)) {\n        throw new WorkboxError('statuses-or-headers-required', {\n          moduleName: 'workbox-cacheable-response',\n          className: 'CacheableResponse',\n          funcName: 'constructor',\n        });\n      }\n\n      if (config.statuses) {\n        assert.isArray(config.statuses, {\n          moduleName: 'workbox-cacheable-response',\n          className: 'CacheableResponse',\n          funcName: 'constructor',\n          paramName: 'config.statuses',\n        });\n      }\n\n      if (config.headers) {\n        assert.isType(config.headers, 'object', {\n          moduleName: 'workbox-cacheable-response',\n          className: 'CacheableResponse',\n          funcName: 'constructor',\n          paramName: 'config.headers',\n        });\n      }\n    }\n\n    this._statuses = config.statuses;\n    this._headers = config.headers;\n  }\n\n  /**\n   * Checks a response to see whether it's cacheable or not, based on this\n   * object's configuration.\n   *\n   * @param {Response} response The response whose cacheability is being\n   * checked.\n   * @return {boolean} `true` if the `Response` is cacheable, and `false`\n   * otherwise.\n   */\n  isResponseCacheable(response) {\n    if (process.env.NODE_ENV !== 'production') {\n      assert.isInstance(response, Response, {\n        moduleName: 'workbox-cacheable-response',\n        className: 'CacheableResponse',\n        funcName: 'isResponseCacheable',\n        paramName: 'response',\n      });\n    }\n\n    let cacheable = true;\n\n    if (this._statuses) {\n      cacheable = this._statuses.includes(response.status);\n    }\n\n    if (this._headers && cacheable) {\n      cacheable = Object.keys(this._headers).some((headerName) => {\n        return response.headers.get(headerName) === this._headers[headerName];\n      });\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (!cacheable) {\n        logger.groupCollapsed(`The request for ` +\n          `'${getFriendlyURL(response.url)}' returned a response that does ` +\n          `not meet the criteria for being cached.`);\n\n        logger.groupCollapsed(`View cacheability criteria here.`);\n        logger.log(`Cacheable statuses: ` +\n          JSON.stringify(this._statuses));\n        logger.log(`Cacheable headers: ` +\n          JSON.stringify(this._headers, null, 2));\n        logger.groupEnd();\n\n        const logFriendlyHeaders = {};\n        response.headers.forEach((value, key) => {\n          logFriendlyHeaders[key] = value;\n        });\n\n        logger.groupCollapsed(`View response status and headers here.`);\n        logger.log(`Response status: ` + response.status);\n        logger.log(`Response headers: ` +\n          JSON.stringify(logFriendlyHeaders, null, 2));\n        logger.groupEnd();\n\n        logger.groupCollapsed(`View full response details here.`);\n        logger.log(response.headers);\n        logger.log(response);\n        logger.groupEnd();\n\n        logger.groupEnd();\n      }\n    }\n\n    return cacheable;\n  }\n}\n\nexport {CacheableResponse};\n","/*\n  Copyright 2018 Google LLC\n\n  Use of this source code is governed by an MIT-style\n  license that can be found in the LICENSE file or at\n  https://opensource.org/licenses/MIT.\n*/\n\nimport {CacheableResponse} from './CacheableResponse.mjs';\nimport './_version.mjs';\n\n/**\n * A class implementing the `cacheWillUpdate` lifecycle callback. This makes it\n * easier to add in cacheability checks to requests made via Workbox's built-in\n * strategies.\n *\n * @memberof workbox.cacheableResponse\n */\nclass Plugin {\n  /**\n   * To construct a new cacheable response Plugin instance you must provide at\n   * least one of the `config` properties.\n   *\n   * If both `statuses` and `headers` are specified, then both conditions must\n   * be met for the `Response` to be considered cacheable.\n   *\n   * @param {Object} config\n   * @param {Array<number>} [config.statuses] One or more status codes that a\n   * `Response` can have and be considered cacheable.\n   * @param {Object<string,string>} [config.headers] A mapping of header names\n   * and expected values that a `Response` can have and be considered cacheable.\n   * If multiple headers are provided, only one needs to be present.\n   */\n  constructor(config) {\n    this._cacheableResponse = new CacheableResponse(config);\n  }\n\n  /**\n   * @param {Object} options\n   * @param {Response} options.response\n   * @return {boolean}\n   * @private\n   */\n  cacheWillUpdate({response}) {\n    if (this._cacheableResponse.isResponseCacheable(response)) {\n      return response;\n    }\n    return null;\n  }\n}\n\nexport {Plugin};\n"],"names":["self","_","e","CacheableResponse","constructor","config","_statuses","statuses","_headers","headers","isResponseCacheable","response","cacheable","this","includes","status","Object","keys","some","headerName","get","_cacheableResponse","cacheWillUpdate"],"mappings":"sFAAA,IAAIA,KAAK,qCAAqCC,IAAI,MAAMC,ICsBxD,MAAMC,EAeJC,YAAYC,EAAS,SA6BdC,EAAYD,EAAOE,cACnBC,EAAWH,EAAOI,QAYzBC,oBAAoBC,OAUdC,GAAY,SAEZC,KAAKP,IACPM,EAAYC,KAAKP,EAAUQ,SAASH,EAASI,SAG3CF,KAAKL,GAAYI,IACnBA,EAAYI,OAAOC,KAAKJ,KAAKL,GAAUU,KAAMC,GACpCR,EAASF,QAAQW,IAAID,KAAgBN,KAAKL,EAASW,KAqCvDP,yCCpHX,MAeER,YAAYC,QACLgB,EAAqB,IAAIlB,EAAkBE,GASlDiB,iBAAgBX,SAACA,WACXE,KAAKQ,EAAmBX,oBAAoBC,GACvCA,EAEF"}

data/lib/vendor/workbox-v4.3.1/workbox-core.dev.js

@@ -1,1712 +0,0 @@
-this.workbox = this.workbox || {};
-this.workbox.core = (function (exports) {
-  'use strict';
-
-  try {
-    self['workbox:core:4.3.1'] && _();
-  } catch (e) {} // eslint-disable-line
-
-  /*
-    Copyright 2019 Google LLC
-    Use of this source code is governed by an MIT-style
-    license that can be found in the LICENSE file or at
-    https://opensource.org/licenses/MIT.
-  */
-  const logger = (() => {
-    let inGroup = false;
-    const methodToColorMap = {
-      debug: `#7f8c8d`,
-      // Gray
-      log: `#2ecc71`,
-      // Green
-      warn: `#f39c12`,
-      // Yellow
-      error: `#c0392b`,
-      // Red
-      groupCollapsed: `#3498db`,
-      // Blue
-      groupEnd: null // No colored prefix on groupEnd
-
-    };
-
-    const print = function (method, args) {
-      if (method === 'groupCollapsed') {
-        // Safari doesn't print all console.groupCollapsed() arguments:
-        // https://bugs.webkit.org/show_bug.cgi?id=182754
-        if (/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
-          console[method](...args);
-          return;
-        }
-      }
-
-      const styles = [`background: ${methodToColorMap[method]}`, `border-radius: 0.5em`, `color: white`, `font-weight: bold`, `padding: 2px 0.5em`]; // When in a group, the workbox prefix is not displayed.
-
-      const logPrefix = inGroup ? [] : ['%cworkbox', styles.join(';')];
-      console[method](...logPrefix, ...args);
-
-      if (method === 'groupCollapsed') {
-        inGroup = true;
-      }
-
-      if (method === 'groupEnd') {
-        inGroup = false;
-      }
-    };
-
-    const api = {};
-
-    for (const method of Object.keys(methodToColorMap)) {
-      api[method] = (...args) => {
-        print(method, args);
-      };
-    }
-
-    return api;
-  })();
-
-  /*
-    Copyright 2018 Google LLC
-
-    Use of this source code is governed by an MIT-style
-    license that can be found in the LICENSE file or at
-    https://opensource.org/licenses/MIT.
-  */
-  const messages = {
-    'invalid-value': ({
-      paramName,
-      validValueDescription,
-      value
-    }) => {
-      if (!paramName || !validValueDescription) {
-        throw new Error(`Unexpected input to 'invalid-value' error.`);
-      }
-
-      return `The '${paramName}' parameter was given a value with an ` + `unexpected value. ${validValueDescription} Received a value of ` + `${JSON.stringify(value)}.`;
-    },
-    'not-in-sw': ({
-      moduleName
-    }) => {
-      if (!moduleName) {
-        throw new Error(`Unexpected input to 'not-in-sw' error.`);
-      }
-
-      return `The '${moduleName}' must be used in a service worker.`;
-    },
-    'not-an-array': ({
-      moduleName,
-      className,
-      funcName,
-      paramName
-    }) => {
-      if (!moduleName || !className || !funcName || !paramName) {
-        throw new Error(`Unexpected input to 'not-an-array' error.`);
-      }
-
-      return `The parameter '${paramName}' passed into ` + `'${moduleName}.${className}.${funcName}()' must be an array.`;
-    },
-    'incorrect-type': ({
-      expectedType,
-      paramName,
-      moduleName,
-      className,
-      funcName
-    }) => {
-      if (!expectedType || !paramName || !moduleName || !funcName) {
-        throw new Error(`Unexpected input to 'incorrect-type' error.`);
-      }
-
-      return `The parameter '${paramName}' passed into ` + `'${moduleName}.${className ? className + '.' : ''}` + `${funcName}()' must be of type ${expectedType}.`;
-    },
-    'incorrect-class': ({
-      expectedClass,
-      paramName,
-      moduleName,
-      className,
-      funcName,
-      isReturnValueProblem
-    }) => {
-      if (!expectedClass || !moduleName || !funcName) {
-        throw new Error(`Unexpected input to 'incorrect-class' error.`);
-      }
-
-      if (isReturnValueProblem) {
-        return `The return value from ` + `'${moduleName}.${className ? className + '.' : ''}${funcName}()' ` + `must be an instance of class ${expectedClass.name}.`;
-      }
-
-      return `The parameter '${paramName}' passed into ` + `'${moduleName}.${className ? className + '.' : ''}${funcName}()' ` + `must be an instance of class ${expectedClass.name}.`;
-    },
-    'missing-a-method': ({
-      expectedMethod,
-      paramName,
-      moduleName,
-      className,
-      funcName
-    }) => {
-      if (!expectedMethod || !paramName || !moduleName || !className || !funcName) {
-        throw new Error(`Unexpected input to 'missing-a-method' error.`);
-      }
-
-      return `${moduleName}.${className}.${funcName}() expected the ` + `'${paramName}' parameter to expose a '${expectedMethod}' method.`;
-    },
-    'add-to-cache-list-unexpected-type': ({
-      entry
-    }) => {
-      return `An unexpected entry was passed to ` + `'workbox-precaching.PrecacheController.addToCacheList()' The entry ` + `'${JSON.stringify(entry)}' isn't supported. You must supply an array of ` + `strings with one or more characters, objects with a url property or ` + `Request objects.`;
-    },
-    'add-to-cache-list-conflicting-entries': ({
-      firstEntry,
-      secondEntry
-    }) => {
-      if (!firstEntry || !secondEntry) {
-        throw new Error(`Unexpected input to ` + `'add-to-cache-list-duplicate-entries' error.`);
-      }
-
-      return `Two of the entries passed to ` + `'workbox-precaching.PrecacheController.addToCacheList()' had the URL ` + `${firstEntry._entryId} but different revision details. Workbox is ` + `is unable to cache and version the asset correctly. Please remove one ` + `of the entries.`;
-    },
-    'plugin-error-request-will-fetch': ({
-      thrownError
-    }) => {
-      if (!thrownError) {
-        throw new Error(`Unexpected input to ` + `'plugin-error-request-will-fetch', error.`);
-      }
-
-      return `An error was thrown by a plugins 'requestWillFetch()' method. ` + `The thrown error message was: '${thrownError.message}'.`;
-    },
-    'invalid-cache-name': ({
-      cacheNameId,
-      value
-    }) => {
-      if (!cacheNameId) {
-        throw new Error(`Expected a 'cacheNameId' for error 'invalid-cache-name'`);
-      }
-
-      return `You must provide a name containing at least one character for ` + `setCacheDeatils({${cacheNameId}: '...'}). Received a value of ` + `'${JSON.stringify(value)}'`;
-    },
-    'unregister-route-but-not-found-with-method': ({
-      method
-    }) => {
-      if (!method) {
-        throw new Error(`Unexpected input to ` + `'unregister-route-but-not-found-with-method' error.`);
-      }
-
-      return `The route you're trying to unregister was not  previously ` + `registered for the method type '${method}'.`;
-    },
-    'unregister-route-route-not-registered': () => {
-      return `The route you're trying to unregister was not previously ` + `registered.`;
-    },
-    'queue-replay-failed': ({
-      name
-    }) => {
-      return `Replaying the background sync queue '${name}' failed.`;
-    },
-    'duplicate-queue-name': ({
-      name
-    }) => {
-      return `The Queue name '${name}' is already being used. ` + `All instances of backgroundSync.Queue must be given unique names.`;
-    },
-    'expired-test-without-max-age': ({
-      methodName,
-      paramName
-    }) => {
-      return `The '${methodName}()' method can only be used when the ` + `'${paramName}' is used in the constructor.`;
-    },
-    'unsupported-route-type': ({
-      moduleName,
-      className,
-      funcName,
-      paramName
-    }) => {
-      return `The supplied '${paramName}' parameter was an unsupported type. ` + `Please check the docs for ${moduleName}.${className}.${funcName} for ` + `valid input types.`;
-    },
-    'not-array-of-class': ({
-      value,
-      expectedClass,
-      moduleName,
-      className,
-      funcName,
-      paramName
-    }) => {
-      return `The supplied '${paramName}' parameter must be an array of ` + `'${expectedClass}' objects. Received '${JSON.stringify(value)},'. ` + `Please check the call to ${moduleName}.${className}.${funcName}() ` + `to fix the issue.`;
-    },
-    'max-entries-or-age-required': ({
-      moduleName,
-      className,
-      funcName
-    }) => {
-      return `You must define either config.maxEntries or config.maxAgeSeconds` + `in ${moduleName}.${className}.${funcName}`;
-    },
-    'statuses-or-headers-required': ({
-      moduleName,
-      className,
-      funcName
-    }) => {
-      return `You must define either config.statuses or config.headers` + `in ${moduleName}.${className}.${funcName}`;
-    },
-    'invalid-string': ({
-      moduleName,
-      className,
-      funcName,
-      paramName
-    }) => {
-      if (!paramName || !moduleName || !funcName) {
-        throw new Error(`Unexpected input to 'invalid-string' error.`);
-      }
-
-      return `When using strings, the '${paramName}' parameter must start with ` + `'http' (for cross-origin matches) or '/' (for same-origin matches). ` + `Please see the docs for ${moduleName}.${funcName}() for ` + `more info.`;
-    },
-    'channel-name-required': () => {
-      return `You must provide a channelName to construct a ` + `BroadcastCacheUpdate instance.`;
-    },
-    'invalid-responses-are-same-args': () => {
-      return `The arguments passed into responsesAreSame() appear to be ` + `invalid. Please ensure valid Responses are used.`;
-    },
-    'expire-custom-caches-only': () => {
-      return `You must provide a 'cacheName' property when using the ` + `expiration plugin with a runtime caching strategy.`;
-    },
-    'unit-must-be-bytes': ({
-      normalizedRangeHeader
-    }) => {
-      if (!normalizedRangeHeader) {
-        throw new Error(`Unexpected input to 'unit-must-be-bytes' error.`);
-      }
-
-      return `The 'unit' portion of the Range header must be set to 'bytes'. ` + `The Range header provided was "${normalizedRangeHeader}"`;
-    },
-    'single-range-only': ({
-      normalizedRangeHeader
-    }) => {
-      if (!normalizedRangeHeader) {
-        throw new Error(`Unexpected input to 'single-range-only' error.`);
-      }
-
-      return `Multiple ranges are not supported. Please use a  single start ` + `value, and optional end value. The Range header provided was ` + `"${normalizedRangeHeader}"`;
-    },
-    'invalid-range-values': ({
-      normalizedRangeHeader
-    }) => {
-      if (!normalizedRangeHeader) {
-        throw new Error(`Unexpected input to 'invalid-range-values' error.`);
-      }
-
-      return `The Range header is missing both start and end values. At least ` + `one of those values is needed. The Range header provided was ` + `"${normalizedRangeHeader}"`;
-    },
-    'no-range-header': () => {
-      return `No Range header was found in the Request provided.`;
-    },
-    'range-not-satisfiable': ({
-      size,
-      start,
-      end
-    }) => {
-      return `The start (${start}) and end (${end}) values in the Range are ` + `not satisfiable by the cached response, which is ${size} bytes.`;
-    },
-    'attempt-to-cache-non-get-request': ({
-      url,
-      method
-    }) => {
-      return `Unable to cache '${url}' because it is a '${method}' request and ` + `only 'GET' requests can be cached.`;
-    },
-    'cache-put-with-no-response': ({
-      url
-    }) => {
-      return `There was an attempt to cache '${url}' but the response was not ` + `defined.`;
-    },
-    'no-response': ({
-      url,
-      error
-    }) => {
-      let message = `The strategy could not generate a response for '${url}'.`;
-
-      if (error) {
-        message += ` The underlying error is ${error}.`;
-      }
-
-      return message;
-    },
-    'bad-precaching-response': ({
-      url,
-      status
-    }) => {
-      return `The precaching request for '${url}' failed with an HTTP ` + `status of ${status}.`;
-    }
-  };
-
-  /*
-    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 generatorFunction = (code, ...args) => {
-    const message = messages[code];
-
-    if (!message) {
-      throw new Error(`Unable to find message for code '${code}'.`);
-    }
-
-    return message(...args);
-  };
-
-  const messageGenerator = generatorFunction;
-
-  /*
-    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.
-  */
-  /**
-   * Workbox errors should be thrown with this class.
-   * This allows use to ensure the type easily in tests,
-   * helps developers identify errors from workbox
-   * easily and allows use to optimise error
-   * messages correctly.
-   *
-   * @private
-   */
-
-  class WorkboxError extends Error {
-    /**
-     *
-     * @param {string} errorCode The error code that
-     * identifies this particular error.
-     * @param {Object=} details Any relevant arguments
-     * that will help developers identify issues should
-     * be added as a key on the context object.
-     */
-    constructor(errorCode, details) {
-      let message = messageGenerator(errorCode, details);
-      super(message);
-      this.name = errorCode;
-      this.details = details;
-    }
-
-  }
-
-  /*
-    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 method returns true if the current context is a service worker.
-   */
-
-  const isSWEnv = moduleName => {
-    if (!('ServiceWorkerGlobalScope' in self)) {
-      throw new WorkboxError('not-in-sw', {
-        moduleName
-      });
-    }
-  };
-  /*
-   * This method throws if the supplied value is not an array.
-   * The destructed values are required to produce a meaningful error for users.
-   * The destructed and restructured object is so it's clear what is
-   * needed.
-   */
-
-
-  const isArray = (value, {
-    moduleName,
-    className,
-    funcName,
-    paramName
-  }) => {
-    if (!Array.isArray(value)) {
-      throw new WorkboxError('not-an-array', {
-        moduleName,
-        className,
-        funcName,
-        paramName
-      });
-    }
-  };
-
-  const hasMethod = (object, expectedMethod, {
-    moduleName,
-    className,
-    funcName,
-    paramName
-  }) => {
-    const type = typeof object[expectedMethod];
-
-    if (type !== 'function') {
-      throw new WorkboxError('missing-a-method', {
-        paramName,
-        expectedMethod,
-        moduleName,
-        className,
-        funcName
-      });
-    }
-  };
-
-  const isType = (object, expectedType, {
-    moduleName,
-    className,
-    funcName,
-    paramName
-  }) => {
-    if (typeof object !== expectedType) {
-      throw new WorkboxError('incorrect-type', {
-        paramName,
-        expectedType,
-        moduleName,
-        className,
-        funcName
-      });
-    }
-  };
-
-  const isInstance = (object, expectedClass, {
-    moduleName,
-    className,
-    funcName,
-    paramName,
-    isReturnValueProblem
-  }) => {
-    if (!(object instanceof expectedClass)) {
-      throw new WorkboxError('incorrect-class', {
-        paramName,
-        expectedClass,
-        moduleName,
-        className,
-        funcName,
-        isReturnValueProblem
-      });
-    }
-  };
-
-  const isOneOf = (value, validValues, {
-    paramName
-  }) => {
-    if (!validValues.includes(value)) {
-      throw new WorkboxError('invalid-value', {
-        paramName,
-        value,
-        validValueDescription: `Valid values are ${JSON.stringify(validValues)}.`
-      });
-    }
-  };
-
-  const isArrayOfClass = (value, expectedClass, {
-    moduleName,
-    className,
-    funcName,
-    paramName
-  }) => {
-    const error = new WorkboxError('not-array-of-class', {
-      value,
-      expectedClass,
-      moduleName,
-      className,
-      funcName,
-      paramName
-    });
-
-    if (!Array.isArray(value)) {
-      throw error;
-    }
-
-    for (let item of value) {
-      if (!(item instanceof expectedClass)) {
-        throw error;
-      }
-    }
-  };
-
-  const finalAssertExports = {
-    hasMethod,
-    isArray,
-    isInstance,
-    isOneOf,
-    isSWEnv,
-    isType,
-    isArrayOfClass
-  };
-
-  /*
-    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 quotaErrorCallbacks = new Set();
-
-  /*
-    Copyright 2019 Google LLC
-
-    Use of this source code is governed by an MIT-style
-    license that can be found in the LICENSE file or at
-    https://opensource.org/licenses/MIT.
-  */
-  /**
-   * Adds a function to the set of quotaErrorCallbacks that will be executed if
-   * there's a quota error.
-   *
-   * @param {Function} callback
-   * @memberof workbox.core
-   */
-
-  function registerQuotaErrorCallback(callback) {
-    {
-      finalAssertExports.isType(callback, 'function', {
-        moduleName: 'workbox-core',
-        funcName: 'register',
-        paramName: 'callback'
-      });
-    }
-
-    quotaErrorCallbacks.add(callback);
-
-    {
-      logger.log('Registered a callback to respond to quota errors.', callback);
-    }
-  }
-
-  /*
-    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 _cacheNameDetails = {
-    googleAnalytics: 'googleAnalytics',
-    precache: 'precache-v2',
-    prefix: 'workbox',
-    runtime: 'runtime',
-    suffix: self.registration.scope
-  };
-
-  const _createCacheName = cacheName => {
-    return [_cacheNameDetails.prefix, cacheName, _cacheNameDetails.suffix].filter(value => value.length > 0).join('-');
-  };
-
-  const cacheNames = {
-    updateDetails: details => {
-      Object.keys(_cacheNameDetails).forEach(key => {
-        if (typeof details[key] !== 'undefined') {
-          _cacheNameDetails[key] = details[key];
-        }
-      });
-    },
-    getGoogleAnalyticsName: userCacheName => {
-      return userCacheName || _createCacheName(_cacheNameDetails.googleAnalytics);
-    },
-    getPrecacheName: userCacheName => {
-      return userCacheName || _createCacheName(_cacheNameDetails.precache);
-    },
-    getPrefix: () => {
-      return _cacheNameDetails.prefix;
-    },
-    getRuntimeName: userCacheName => {
-      return userCacheName || _createCacheName(_cacheNameDetails.runtime);
-    },
-    getSuffix: () => {
-      return _cacheNameDetails.suffix;
-    }
-  };
-
-  /*
-    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 getFriendlyURL = url => {
-    const urlObj = new URL(url, location);
-
-    if (urlObj.origin === location.origin) {
-      return urlObj.pathname;
-    }
-
-    return urlObj.href;
-  };
-
-  /*
-    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.
-  */
-  /**
-   * Runs all of the callback functions, one at a time sequentially, in the order
-   * in which they were registered.
-   *
-   * @memberof workbox.core
-   * @private
-   */
-
-  async function executeQuotaErrorCallbacks() {
-    {
-      logger.log(`About to run ${quotaErrorCallbacks.size} ` + `callbacks to clean up caches.`);
-    }
-
-    for (const callback of quotaErrorCallbacks) {
-      await callback();
-
-      {
-        logger.log(callback, 'is complete.');
-      }
-    }
-
-    {
-      logger.log('Finished running callbacks.');
-    }
-  }
-
-  /*
-    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 pluginEvents = {
-    CACHE_DID_UPDATE: 'cacheDidUpdate',
-    CACHE_KEY_WILL_BE_USED: 'cacheKeyWillBeUsed',
-    CACHE_WILL_UPDATE: 'cacheWillUpdate',
-    CACHED_RESPONSE_WILL_BE_USED: 'cachedResponseWillBeUsed',
-    FETCH_DID_FAIL: 'fetchDidFail',
-    FETCH_DID_SUCCEED: 'fetchDidSucceed',
-    REQUEST_WILL_FETCH: 'requestWillFetch'
-  };
-
-  /*
-    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 pluginUtils = {
-    filter: (plugins, callbackName) => {
-      return plugins.filter(plugin => callbackName in plugin);
-    }
-  };
-
-  /*
-    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.
-  */
-  /**
-   * Wrapper around cache.put().
-   *
-   * Will call `cacheDidUpdate` on plugins if the cache was updated, using
-   * `matchOptions` when determining what the old entry is.
-   *
-   * @param {Object} options
-   * @param {string} options.cacheName
-   * @param {Request} options.request
-   * @param {Response} options.response
-   * @param {Event} [options.event]
-   * @param {Array<Object>} [options.plugins=[]]
-   * @param {Object} [options.matchOptions]
-   *
-   * @private
-   * @memberof module:workbox-core
-   */
-
-  const putWrapper = async ({
-    cacheName,
-    request,
-    response,
-    event,
-    plugins = [],
-    matchOptions
-  } = {}) => {
-    {
-      if (request.method && request.method !== 'GET') {
-        throw new WorkboxError('attempt-to-cache-non-get-request', {
-          url: getFriendlyURL(request.url),
-          method: request.method
-        });
-      }
-    }
-
-    const effectiveRequest = await _getEffectiveRequest({
-      plugins,
-      request,
-      mode: 'write'
-    });
-
-    if (!response) {
-      {
-        logger.error(`Cannot cache non-existent response for ` + `'${getFriendlyURL(effectiveRequest.url)}'.`);
-      }
-
-      throw new WorkboxError('cache-put-with-no-response', {
-        url: getFriendlyURL(effectiveRequest.url)
-      });
-    }
-
-    let responseToCache = await _isResponseSafeToCache({
-      event,
-      plugins,
-      response,
-      request: effectiveRequest
-    });
-
-    if (!responseToCache) {
-      {
-        logger.debug(`Response '${getFriendlyURL(effectiveRequest.url)}' will ` + `not be cached.`, responseToCache);
-      }
-
-      return;
-    }
-
-    const cache = await caches.open(cacheName);
-    const updatePlugins = pluginUtils.filter(plugins, pluginEvents.CACHE_DID_UPDATE);
-    let oldResponse = updatePlugins.length > 0 ? await matchWrapper({
-      cacheName,
-      matchOptions,
-      request: effectiveRequest
-    }) : null;
-
-    {
-      logger.debug(`Updating the '${cacheName}' cache with a new Response for ` + `${getFriendlyURL(effectiveRequest.url)}.`);
-    }
-
-    try {
-      await cache.put(effectiveRequest, responseToCache);
-    } catch (error) {
-      // See https://developer.mozilla.org/en-US/docs/Web/API/DOMException#exception-QuotaExceededError
-      if (error.name === 'QuotaExceededError') {
-        await executeQuotaErrorCallbacks();
-      }
-
-      throw error;
-    }
-
-    for (let plugin of updatePlugins) {
-      await plugin[pluginEvents.CACHE_DID_UPDATE].call(plugin, {
-        cacheName,
-        event,
-        oldResponse,
-        newResponse: responseToCache,
-        request: effectiveRequest
-      });
-    }
-  };
-  /**
-   * This is a wrapper around cache.match().
-   *
-   * @param {Object} options
-   * @param {string} options.cacheName Name of the cache to match against.
-   * @param {Request} options.request The Request that will be used to look up
-   *     cache entries.
-   * @param {Event} [options.event] The event that propted the action.
-   * @param {Object} [options.matchOptions] Options passed to cache.match().
-   * @param {Array<Object>} [options.plugins=[]] Array of plugins.
-   * @return {Response} A cached response if available.
-   *
-   * @private
-   * @memberof module:workbox-core
-   */
-
-
-  const matchWrapper = async ({
-    cacheName,
-    request,
-    event,
-    matchOptions,
-    plugins = []
-  }) => {
-    const cache = await caches.open(cacheName);
-    const effectiveRequest = await _getEffectiveRequest({
-      plugins,
-      request,
-      mode: 'read'
-    });
-    let cachedResponse = await cache.match(effectiveRequest, matchOptions);
-
-    {
-      if (cachedResponse) {
-        logger.debug(`Found a cached response in '${cacheName}'.`);
-      } else {
-        logger.debug(`No cached response found in '${cacheName}'.`);
-      }
-    }
-
-    for (const plugin of plugins) {
-      if (pluginEvents.CACHED_RESPONSE_WILL_BE_USED in plugin) {
-        cachedResponse = await plugin[pluginEvents.CACHED_RESPONSE_WILL_BE_USED].call(plugin, {
-          cacheName,
-          event,
-          matchOptions,
-          cachedResponse,
-          request: effectiveRequest
-        });
-
-        {
-          if (cachedResponse) {
-            finalAssertExports.isInstance(cachedResponse, Response, {
-              moduleName: 'Plugin',
-              funcName: pluginEvents.CACHED_RESPONSE_WILL_BE_USED,
-              isReturnValueProblem: true
-            });
-          }
-        }
-      }
-    }
-
-    return cachedResponse;
-  };
-  /**
-   * This method will call cacheWillUpdate on the available plugins (or use
-   * status === 200) to determine if the Response is safe and valid to cache.
-   *
-   * @param {Object} options
-   * @param {Request} options.request
-   * @param {Response} options.response
-   * @param {Event} [options.event]
-   * @param {Array<Object>} [options.plugins=[]]
-   * @return {Promise<Response>}
-   *
-   * @private
-   * @memberof module:workbox-core
-   */
-
-
-  const _isResponseSafeToCache = async ({
-    request,
-    response,
-    event,
-    plugins
-  }) => {
-    let responseToCache = response;
-    let pluginsUsed = false;
-
-    for (let plugin of plugins) {
-      if (pluginEvents.CACHE_WILL_UPDATE in plugin) {
-        pluginsUsed = true;
-        responseToCache = await plugin[pluginEvents.CACHE_WILL_UPDATE].call(plugin, {
-          request,
-          response: responseToCache,
-          event
-        });
-
-        {
-          if (responseToCache) {
-            finalAssertExports.isInstance(responseToCache, Response, {
-              moduleName: 'Plugin',
-              funcName: pluginEvents.CACHE_WILL_UPDATE,
-              isReturnValueProblem: true
-            });
-          }
-        }
-
-        if (!responseToCache) {
-          break;
-        }
-      }
-    }
-
-    if (!pluginsUsed) {
-      {
-        if (!responseToCache.status === 200) {
-          if (responseToCache.status === 0) {
-            logger.warn(`The response for '${request.url}' is an opaque ` + `response. The caching strategy that you're using will not ` + `cache opaque responses by default.`);
-          } else {
-            logger.debug(`The response for '${request.url}' returned ` + `a status code of '${response.status}' and won't be cached as a ` + `result.`);
-          }
-        }
-      }
-
-      responseToCache = responseToCache.status === 200 ? responseToCache : null;
-    }
-
-    return responseToCache ? responseToCache : null;
-  };
-  /**
-   * Checks the list of plugins for the cacheKeyWillBeUsed callback, and
-   * executes any of those callbacks found in sequence. The final `Request` object
-   * returned by the last plugin is treated as the cache key for cache reads
-   * and/or writes.
-   *
-   * @param {Object} options
-   * @param {Request} options.request
-   * @param {string} options.mode
-   * @param {Array<Object>} [options.plugins=[]]
-   * @return {Promise<Request>}
-   *
-   * @private
-   * @memberof module:workbox-core
-   */
-
-
-  const _getEffectiveRequest = async ({
-    request,
-    mode,
-    plugins
-  }) => {
-    const cacheKeyWillBeUsedPlugins = pluginUtils.filter(plugins, pluginEvents.CACHE_KEY_WILL_BE_USED);
-    let effectiveRequest = request;
-
-    for (const plugin of cacheKeyWillBeUsedPlugins) {
-      effectiveRequest = await plugin[pluginEvents.CACHE_KEY_WILL_BE_USED].call(plugin, {
-        mode,
-        request: effectiveRequest
-      });
-
-      if (typeof effectiveRequest === 'string') {
-        effectiveRequest = new Request(effectiveRequest);
-      }
-
-      {
-        finalAssertExports.isInstance(effectiveRequest, Request, {
-          moduleName: 'Plugin',
-          funcName: pluginEvents.CACHE_KEY_WILL_BE_USED,
-          isReturnValueProblem: true
-        });
-      }
-    }
-
-    return effectiveRequest;
-  };
-
-  const cacheWrapper = {
-    put: putWrapper,
-    match: matchWrapper
-  };
-
-  /*
-    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.
-  */
-  /**
-   * A class that wraps common IndexedDB functionality in a promise-based API.
-   * It exposes all the underlying power and functionality of IndexedDB, but
-   * wraps the most commonly used features in a way that's much simpler to use.
-   *
-   * @private
-   */
-
-  class DBWrapper {
-    /**
-     * @param {string} name
-     * @param {number} version
-     * @param {Object=} [callback]
-     * @param {!Function} [callbacks.onupgradeneeded]
-     * @param {!Function} [callbacks.onversionchange] Defaults to
-     *     DBWrapper.prototype._onversionchange when not specified.
-     * @private
-     */
-    constructor(name, version, {
-      onupgradeneeded,
-      onversionchange = this._onversionchange
-    } = {}) {
-      this._name = name;
-      this._version = version;
-      this._onupgradeneeded = onupgradeneeded;
-      this._onversionchange = onversionchange; // If this is null, it means the database isn't open.
-
-      this._db = null;
-    }
-    /**
-     * Returns the IDBDatabase instance (not normally needed).
-     *
-     * @private
-     */
-
-
-    get db() {
-      return this._db;
-    }
-    /**
-     * Opens a connected to an IDBDatabase, invokes any onupgradedneeded
-     * callback, and added an onversionchange callback to the database.
-     *
-     * @return {IDBDatabase}
-     * @private
-     */
-
-
-    async open() {
-      if (this._db) return;
-      this._db = await new Promise((resolve, reject) => {
-        // This flag is flipped to true if the timeout callback runs prior
-        // to the request failing or succeeding. Note: we use a timeout instead
-        // of an onblocked handler since there are cases where onblocked will
-        // never never run. A timeout better handles all possible scenarios:
-        // https://github.com/w3c/IndexedDB/issues/223
-        let openRequestTimedOut = false;
-        setTimeout(() => {
-          openRequestTimedOut = true;
-          reject(new Error('The open request was blocked and timed out'));
-        }, this.OPEN_TIMEOUT);
-        const openRequest = indexedDB.open(this._name, this._version);
-
-        openRequest.onerror = () => reject(openRequest.error);
-
-        openRequest.onupgradeneeded = evt => {
-          if (openRequestTimedOut) {
-            openRequest.transaction.abort();
-            evt.target.result.close();
-          } else if (this._onupgradeneeded) {
-            this._onupgradeneeded(evt);
-          }
-        };
-
-        openRequest.onsuccess = ({
-          target
-        }) => {
-          const db = target.result;
-
-          if (openRequestTimedOut) {
-            db.close();
-          } else {
-            db.onversionchange = this._onversionchange.bind(this);
-            resolve(db);
-          }
-        };
-      });
-      return this;
-    }
-    /**
-     * Polyfills the native `getKey()` method. Note, this is overridden at
-     * runtime if the browser supports the native method.
-     *
-     * @param {string} storeName
-     * @param {*} query
-     * @return {Array}
-     * @private
-     */
-
-
-    async getKey(storeName, query) {
-      return (await this.getAllKeys(storeName, query, 1))[0];
-    }
-    /**
-     * Polyfills the native `getAll()` method. Note, this is overridden at
-     * runtime if the browser supports the native method.
-     *
-     * @param {string} storeName
-     * @param {*} query
-     * @param {number} count
-     * @return {Array}
-     * @private
-     */
-
-
-    async getAll(storeName, query, count) {
-      return await this.getAllMatching(storeName, {
-        query,
-        count
-      });
-    }
-    /**
-     * Polyfills the native `getAllKeys()` method. Note, this is overridden at
-     * runtime if the browser supports the native method.
-     *
-     * @param {string} storeName
-     * @param {*} query
-     * @param {number} count
-     * @return {Array}
-     * @private
-     */
-
-
-    async getAllKeys(storeName, query, count) {
-      return (await this.getAllMatching(storeName, {
-        query,
-        count,
-        includeKeys: true
-      })).map(({
-        key
-      }) => key);
-    }
-    /**
-     * Supports flexible lookup in an object store by specifying an index,
-     * query, direction, and count. This method returns an array of objects
-     * with the signature .
-     *
-     * @param {string} storeName
-     * @param {Object} [opts]
-     * @param {string} [opts.index] The index to use (if specified).
-     * @param {*} [opts.query]
-     * @param {IDBCursorDirection} [opts.direction]
-     * @param {number} [opts.count] The max number of results to return.
-     * @param {boolean} [opts.includeKeys] When true, the structure of the
-     *     returned objects is changed from an array of values to an array of
-     *     objects in the form {key, primaryKey, value}.
-     * @return {Array}
-     * @private
-     */
-
-
-    async getAllMatching(storeName, {
-      index,
-      query = null,
-      // IE errors if query === `undefined`.
-      direction = 'next',
-      count,
-      includeKeys
-    } = {}) {
-      return await this.transaction([storeName], 'readonly', (txn, done) => {
-        const store = txn.objectStore(storeName);
-        const target = index ? store.index(index) : store;
-        const results = [];
-
-        target.openCursor(query, direction).onsuccess = ({
-          target
-        }) => {
-          const cursor = target.result;
-
-          if (cursor) {
-            const {
-              primaryKey,
-              key,
-              value
-            } = cursor;
-            results.push(includeKeys ? {
-              primaryKey,
-              key,
-              value
-            } : value);
-
-            if (count && results.length >= count) {
-              done(results);
-            } else {
-              cursor.continue();
-            }
-          } else {
-            done(results);
-          }
-        };
-      });
-    }
-    /**
-     * Accepts a list of stores, a transaction type, and a callback and
-     * performs a transaction. A promise is returned that resolves to whatever
-     * value the callback chooses. The callback holds all the transaction logic
-     * and is invoked with two arguments:
-     *   1. The IDBTransaction object
-     *   2. A `done` function, that's used to resolve the promise when
-     *      when the transaction is done, if passed a value, the promise is
-     *      resolved to that value.
-     *
-     * @param {Array<string>} storeNames An array of object store names
-     *     involved in the transaction.
-     * @param {string} type Can be `readonly` or `readwrite`.
-     * @param {!Function} callback
-     * @return {*} The result of the transaction ran by the callback.
-     * @private
-     */
-
-
-    async transaction(storeNames, type, callback) {
-      await this.open();
-      return await new Promise((resolve, reject) => {
-        const txn = this._db.transaction(storeNames, type);
-
-        txn.onabort = ({
-          target
-        }) => reject(target.error);
-
-        txn.oncomplete = () => resolve();
-
-        callback(txn, value => resolve(value));
-      });
-    }
-    /**
-     * Delegates async to a native IDBObjectStore method.
-     *
-     * @param {string} method The method name.
-     * @param {string} storeName The object store name.
-     * @param {string} type Can be `readonly` or `readwrite`.
-     * @param {...*} args The list of args to pass to the native method.
-     * @return {*} The result of the transaction.
-     * @private
-     */
-
-
-    async _call(method, storeName, type, ...args) {
-      const callback = (txn, done) => {
-        txn.objectStore(storeName)[method](...args).onsuccess = ({
-          target
-        }) => {
-          done(target.result);
-        };
-      };
-
-      return await this.transaction([storeName], type, callback);
-    }
-    /**
-     * The default onversionchange handler, which closes the database so other
-     * connections can open without being blocked.
-     *
-     * @private
-     */
-
-
-    _onversionchange() {
-      this.close();
-    }
-    /**
-     * Closes the connection opened by `DBWrapper.open()`. Generally this method
-     * doesn't need to be called since:
-     *   1. It's usually better to keep a connection open since opening
-     *      a new connection is somewhat slow.
-     *   2. Connections are automatically closed when the reference is
-     *      garbage collected.
-     * The primary use case for needing to close a connection is when another
-     * reference (typically in another tab) needs to upgrade it and would be
-     * blocked by the current, open connection.
-     *
-     * @private
-     */
-
-
-    close() {
-      if (this._db) {
-        this._db.close();
-
-        this._db = null;
-      }
-    }
-
-  } // Exposed to let users modify the default timeout on a per-instance
-  // or global basis.
-
-  DBWrapper.prototype.OPEN_TIMEOUT = 2000; // Wrap native IDBObjectStore methods according to their mode.
-
-  const methodsToWrap = {
-    'readonly': ['get', 'count', 'getKey', 'getAll', 'getAllKeys'],
-    'readwrite': ['add', 'put', 'clear', 'delete']
-  };
-
-  for (const [mode, methods] of Object.entries(methodsToWrap)) {
-    for (const method of methods) {
-      if (method in IDBObjectStore.prototype) {
-        // Don't use arrow functions here since we're outside of the class.
-        DBWrapper.prototype[method] = async function (storeName, ...args) {
-          return await this._call(method, storeName, mode, ...args);
-        };
-      }
-    }
-  }
-
-  /*
-    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.
-  */
-  /**
-   * The Deferred class composes Promises in a way that allows for them to be
-   * resolved or rejected from outside the constructor. In most cases promises
-   * should be used directly, but Deferreds can be necessary when the logic to
-   * resolve a promise must be separate.
-   *
-   * @private
-   */
-
-  class Deferred {
-    /**
-     * Creates a promise and exposes its resolve and reject functions as methods.
-     */
-    constructor() {
-      this.promise = new Promise((resolve, reject) => {
-        this.resolve = resolve;
-        this.reject = reject;
-      });
-    }
-
-  }
-
-  /*
-    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.
-  */
-  /**
-   * Deletes the database.
-   * Note: this is exported separately from the DBWrapper module because most
-   * usages of IndexedDB in workbox dont need deleting, and this way it can be
-   * reused in tests to delete databases without creating DBWrapper instances.
-   *
-   * @param {string} name The database name.
-   * @private
-   */
-
-  const deleteDatabase = async name => {
-    await new Promise((resolve, reject) => {
-      const request = indexedDB.deleteDatabase(name);
-
-      request.onerror = ({
-        target
-      }) => {
-        reject(target.error);
-      };
-
-      request.onblocked = () => {
-        reject(new Error('Delete blocked'));
-      };
-
-      request.onsuccess = () => {
-        resolve();
-      };
-    });
-  };
-
-  /*
-    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.
-  */
-  /**
-   * Wrapper around the fetch API.
-   *
-   * Will call requestWillFetch on available plugins.
-   *
-   * @param {Object} options
-   * @param {Request|string} options.request
-   * @param {Object} [options.fetchOptions]
-   * @param {Event} [options.event]
-   * @param {Array<Object>} [options.plugins=[]]
-   * @return {Promise<Response>}
-   *
-   * @private
-   * @memberof module:workbox-core
-   */
-
-  const wrappedFetch = async ({
-    request,
-    fetchOptions,
-    event,
-    plugins = []
-  }) => {
-    // We *should* be able to call `await event.preloadResponse` even if it's
-    // undefined, but for some reason, doing so leads to errors in our Node unit
-    // tests. To work around that, explicitly check preloadResponse's value first.
-    if (event && event.preloadResponse) {
-      const possiblePreloadResponse = await event.preloadResponse;
-
-      if (possiblePreloadResponse) {
-        {
-          logger.log(`Using a preloaded navigation response for ` + `'${getFriendlyURL(request.url)}'`);
-        }
-
-        return possiblePreloadResponse;
-      }
-    }
-
-    if (typeof request === 'string') {
-      request = new Request(request);
-    }
-
-    {
-      finalAssertExports.isInstance(request, Request, {
-        paramName: request,
-        expectedClass: 'Request',
-        moduleName: 'workbox-core',
-        className: 'fetchWrapper',
-        funcName: 'wrappedFetch'
-      });
-    }
-
-    const failedFetchPlugins = pluginUtils.filter(plugins, pluginEvents.FETCH_DID_FAIL); // If there is a fetchDidFail plugin, we need to save a clone of the
-    // original request before it's either modified by a requestWillFetch
-    // plugin or before the original request's body is consumed via fetch().
-
-    const originalRequest = failedFetchPlugins.length > 0 ? request.clone() : null;
-
-    try {
-      for (let plugin of plugins) {
-        if (pluginEvents.REQUEST_WILL_FETCH in plugin) {
-          request = await plugin[pluginEvents.REQUEST_WILL_FETCH].call(plugin, {
-            request: request.clone(),
-            event
-          });
-
-          {
-            if (request) {
-              finalAssertExports.isInstance(request, Request, {
-                moduleName: 'Plugin',
-                funcName: pluginEvents.CACHED_RESPONSE_WILL_BE_USED,
-                isReturnValueProblem: true
-              });
-            }
-          }
-        }
-      }
-    } catch (err) {
-      throw new WorkboxError('plugin-error-request-will-fetch', {
-        thrownError: err
-      });
-    } // The request can be altered by plugins with `requestWillFetch` making
-    // the original request (Most likely from a `fetch` event) to be different
-    // to the Request we make. Pass both to `fetchDidFail` to aid debugging.
-
-
-    let pluginFilteredRequest = request.clone();
-
-    try {
-      let fetchResponse; // See https://github.com/GoogleChrome/workbox/issues/1796
-
-      if (request.mode === 'navigate') {
-        fetchResponse = await fetch(request);
-      } else {
-        fetchResponse = await fetch(request, fetchOptions);
-      }
-
-      {
-        logger.debug(`Network request for ` + `'${getFriendlyURL(request.url)}' returned a response with ` + `status '${fetchResponse.status}'.`);
-      }
-
-      for (const plugin of plugins) {
-        if (pluginEvents.FETCH_DID_SUCCEED in plugin) {
-          fetchResponse = await plugin[pluginEvents.FETCH_DID_SUCCEED].call(plugin, {
-            event,
-            request: pluginFilteredRequest,
-            response: fetchResponse
-          });
-
-          {
-            if (fetchResponse) {
-              finalAssertExports.isInstance(fetchResponse, Response, {
-                moduleName: 'Plugin',
-                funcName: pluginEvents.FETCH_DID_SUCCEED,
-                isReturnValueProblem: true
-              });
-            }
-          }
-        }
-      }
-
-      return fetchResponse;
-    } catch (error) {
-      {
-        logger.error(`Network request for ` + `'${getFriendlyURL(request.url)}' threw an error.`, error);
-      }
-
-      for (const plugin of failedFetchPlugins) {
-        await plugin[pluginEvents.FETCH_DID_FAIL].call(plugin, {
-          error,
-          event,
-          originalRequest: originalRequest.clone(),
-          request: pluginFilteredRequest.clone()
-        });
-      }
-
-      throw error;
-    }
-  };
-
-  const fetchWrapper = {
-    fetch: wrappedFetch
-  };
-
-  /*
-    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.
-  */
-
-  var _private = /*#__PURE__*/Object.freeze({
-    assert: finalAssertExports,
-    cacheNames: cacheNames,
-    cacheWrapper: cacheWrapper,
-    DBWrapper: DBWrapper,
-    Deferred: Deferred,
-    deleteDatabase: deleteDatabase,
-    executeQuotaErrorCallbacks: executeQuotaErrorCallbacks,
-    fetchWrapper: fetchWrapper,
-    getFriendlyURL: getFriendlyURL,
-    logger: logger,
-    WorkboxError: WorkboxError
-  });
-
-  /*
-    Copyright 2019 Google LLC
-
-    Use of this source code is governed by an MIT-style
-    license that can be found in the LICENSE file or at
-    https://opensource.org/licenses/MIT.
-  */
-  /**
-   * Claim any currently available clients once the service worker
-   * becomes active. This is normally used in conjunction with `skipWaiting()`.
-   *
-   * @alias workbox.core.clientsClaim
-   */
-
-  const clientsClaim = () => {
-    addEventListener('activate', () => clients.claim());
-  };
-
-  /*
-    Copyright 2019 Google LLC
-
-    Use of this source code is governed by an MIT-style
-    license that can be found in the LICENSE file or at
-    https://opensource.org/licenses/MIT.
-  */
-  /**
-   * Get the current cache names and prefix/suffix used by Workbox.
-   *
-   * `cacheNames.precache` is used for precached assets,
-   * `cacheNames.googleAnalytics` is used by `workbox-google-analytics` to
-   * store `analytics.js`, and `cacheNames.runtime` is used for everything else.
-   *
-   * `cacheNames.prefix` can be used to retrieve just the current prefix value.
-   * `cacheNames.suffix` can be used to retrieve just the current suffix value.
-   *
-   * @return {Object} An object with `precache`, `runtime`, `prefix`, and
-   *     `googleAnalytics` properties.
-   *
-   * @alias workbox.core.cacheNames
-   */
-
-  const cacheNames$1 = {
-    get googleAnalytics() {
-      return cacheNames.getGoogleAnalyticsName();
-    },
-
-    get precache() {
-      return cacheNames.getPrecacheName();
-    },
-
-    get prefix() {
-      return cacheNames.getPrefix();
-    },
-
-    get runtime() {
-      return cacheNames.getRuntimeName();
-    },
-
-    get suffix() {
-      return cacheNames.getSuffix();
-    }
-
-  };
-
-  /*
-    Copyright 2019 Google LLC
-
-    Use of this source code is governed by an MIT-style
-    license that can be found in the LICENSE file or at
-    https://opensource.org/licenses/MIT.
-  */
-  /**
-   * Modifies the default cache names used by the Workbox packages.
-   * Cache names are generated as `<prefix>-<Cache Name>-<suffix>`.
-   *
-   * @param {Object} details
-   * @param {Object} [details.prefix] The string to add to the beginning of
-   *     the precache and runtime cache names.
-   * @param {Object} [details.suffix] The string to add to the end of
-   *     the precache and runtime cache names.
-   * @param {Object} [details.precache] The cache name to use for precache
-   *     caching.
-   * @param {Object} [details.runtime] The cache name to use for runtime caching.
-   * @param {Object} [details.googleAnalytics] The cache name to use for
-   *     `workbox-google-analytics` caching.
-   *
-   * @alias workbox.core.setCacheNameDetails
-   */
-
-  const setCacheNameDetails = details => {
-    {
-      Object.keys(details).forEach(key => {
-        finalAssertExports.isType(details[key], 'string', {
-          moduleName: 'workbox-core',
-          funcName: 'setCacheNameDetails',
-          paramName: `details.${key}`
-        });
-      });
-
-      if ('precache' in details && details.precache.length === 0) {
-        throw new WorkboxError('invalid-cache-name', {
-          cacheNameId: 'precache',
-          value: details.precache
-        });
-      }
-
-      if ('runtime' in details && details.runtime.length === 0) {
-        throw new WorkboxError('invalid-cache-name', {
-          cacheNameId: 'runtime',
-          value: details.runtime
-        });
-      }
-
-      if ('googleAnalytics' in details && details.googleAnalytics.length === 0) {
-        throw new WorkboxError('invalid-cache-name', {
-          cacheNameId: 'googleAnalytics',
-          value: details.googleAnalytics
-        });
-      }
-    }
-
-    cacheNames.updateDetails(details);
-  };
-
-  /*
-    Copyright 2019 Google LLC
-
-    Use of this source code is governed by an MIT-style
-    license that can be found in the LICENSE file or at
-    https://opensource.org/licenses/MIT.
-  */
-  /**
-   * Force a service worker to become active, instead of waiting. This is
-   * normally used in conjunction with `clientsClaim()`.
-   *
-   * @alias workbox.core.skipWaiting
-   */
-
-  const skipWaiting = () => {
-    // We need to explicitly call `self.skipWaiting()` here because we're
-    // shadowing `skipWaiting` with this local function.
-    addEventListener('install', () => self.skipWaiting());
-  };
-
-  /*
-    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.
-  */
-
-  try {
-    self.workbox.v = self.workbox.v || {};
-  } catch (errer) {} // NOOP
-
-  exports._private = _private;
-  exports.clientsClaim = clientsClaim;
-  exports.cacheNames = cacheNames$1;
-  exports.registerQuotaErrorCallback = registerQuotaErrorCallback;
-  exports.setCacheNameDetails = setCacheNameDetails;
-  exports.skipWaiting = skipWaiting;
-
-  return exports;
-
-}({}));
-//# sourceMappingURL=workbox-core.dev.js.map