jekyll-pwa-workbox 0.0.6 → 0.0.7.alpha

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

@@ -1 +0,0 @@
-{"version":3,"file":"workbox-precaching.dev.js","sources":["../_version.mjs","../utils/precachePlugins.mjs","../addPlugins.mjs","../utils/cleanRedirect.mjs","../utils/createCacheKey.mjs","../utils/printCleanupDetails.mjs","../utils/printInstallDetails.mjs","../PrecacheController.mjs","../utils/getOrCreatePrecacheController.mjs","../utils/removeIgnoredSearchParams.mjs","../utils/generateURLVariations.mjs","../utils/getCacheKeyForURL.mjs","../utils/addFetchListener.mjs","../addRoute.mjs","../utils/deleteOutdatedCaches.mjs","../cleanupOutdatedCaches.mjs","../getCacheKeyForURL.mjs","../precache.mjs","../precacheAndRoute.mjs","../index.mjs"],"sourcesContent":["try{self['workbox:precaching:4.3.1']&&_()}catch(e){}// eslint-disable-line","/*\n  Copyright 2019 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\n\nconst plugins = [];\n\nexport const precachePlugins = {\n  /*\n   * @return {Array}\n   * @private\n   */\n  get() {\n    return plugins;\n  },\n\n  /*\n   * @param {Array} newPlugins\n   * @private\n   */\n  add(newPlugins) {\n    plugins.push(...newPlugins);\n  },\n};\n","/*\n  Copyright 2019 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 {precachePlugins} from './utils/precachePlugins.mjs';\nimport './_version.mjs';\n\n\n/**\n * Adds plugins to precaching.\n *\n * @param {Array<Object>} newPlugins\n *\n * @alias workbox.precaching.addPlugins\n */\nconst addPlugins = (newPlugins) => {\n  precachePlugins.add(newPlugins);\n};\n\nexport {addPlugins};\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\n/**\n * @param {Response} response\n * @return {Response}\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport async function cleanRedirect(response) {\n  const clonedResponse = response.clone();\n\n  // Not all browsers support the Response.body stream, so fall back\n  // to reading the entire body into memory as a blob.\n  const bodyPromise = 'body' in clonedResponse ?\n    Promise.resolve(clonedResponse.body) :\n    clonedResponse.blob();\n\n  const body = await bodyPromise;\n\n  // new Response() is happy when passed either a stream or a Blob.\n  return new Response(body, {\n    headers: clonedResponse.headers,\n    status: clonedResponse.status,\n    statusText: clonedResponse.statusText,\n  });\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 {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';\n\nimport '../_version.mjs';\n\n// Name of the search parameter used to store revision info.\nconst REVISION_SEARCH_PARAM = '__WB_REVISION__';\n\n/**\n * Converts a manifest entry into a versioned URL suitable for precaching.\n *\n * @param {Object} entry\n * @return {string} A URL with versioning info.\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function createCacheKey(entry) {\n  if (!entry) {\n    throw new WorkboxError('add-to-cache-list-unexpected-type', {entry});\n  }\n\n  // If a precache manifest entry is a string, it's assumed to be a versioned\n  // URL, like '/app.abcd1234.js'. Return as-is.\n  if (typeof entry === 'string') {\n    const urlObject = new URL(entry, location);\n    return {\n      cacheKey: urlObject.href,\n      url: urlObject.href,\n    };\n  }\n\n  const {revision, url} = entry;\n  if (!url) {\n    throw new WorkboxError('add-to-cache-list-unexpected-type', {entry});\n  }\n\n  // If there's just a URL and no revision, then it's also assumed to be a\n  // versioned URL.\n  if (!revision) {\n    const urlObject = new URL(url, location);\n    return {\n      cacheKey: urlObject.href,\n      url: urlObject.href,\n    };\n  }\n\n  // Otherwise, construct a properly versioned URL using the custom Workbox\n  // search parameter along with the revision info.\n  const originalURL = new URL(url, location);\n  const cacheKeyURL = new URL(url, location);\n  cacheKeyURL.searchParams.set(REVISION_SEARCH_PARAM, revision);\n  return {\n    cacheKey: cacheKeyURL.href,\n    url: originalURL.href,\n  };\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 {logger} from 'workbox-core/_private/logger.mjs';\n\nimport '../_version.mjs';\n\nconst logGroup = (groupTitle, deletedURLs) => {\n  logger.groupCollapsed(groupTitle);\n\n  for (const url of deletedURLs) {\n    logger.log(url);\n  }\n\n  logger.groupEnd();\n};\n\n/**\n * @param {Array<string>} deletedURLs\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function printCleanupDetails(deletedURLs) {\n  const deletionCount = deletedURLs.length;\n  if (deletionCount > 0) {\n    logger.groupCollapsed(`During precaching cleanup, ` +\n        `${deletionCount} cached ` +\n        `request${deletionCount === 1 ? ' was' : 's were'} deleted.`);\n    logGroup('Deleted Cache Requests', deletedURLs);\n    logger.groupEnd();\n  }\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 {logger} from 'workbox-core/_private/logger.mjs';\n\nimport '../_version.mjs';\n\n/**\n * @param {string} groupTitle\n * @param {Array<string>} urls\n *\n * @private\n */\nfunction _nestedGroup(groupTitle, urls) {\n  if (urls.length === 0) {\n    return;\n  }\n\n  logger.groupCollapsed(groupTitle);\n\n  for (const url of urls) {\n    logger.log(url);\n  }\n\n  logger.groupEnd();\n}\n\n/**\n * @param {Array<string>} urlsToPrecache\n * @param {Array<string>} urlsAlreadyPrecached\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function printInstallDetails(urlsToPrecache, urlsAlreadyPrecached) {\n  const precachedCount = urlsToPrecache.length;\n  const alreadyPrecachedCount = urlsAlreadyPrecached.length;\n\n  if (precachedCount || alreadyPrecachedCount) {\n    let message =\n        `Precaching ${precachedCount} file${precachedCount === 1 ? '' : 's'}.`;\n\n    if (alreadyPrecachedCount > 0) {\n      message += ` ${alreadyPrecachedCount} ` +\n        `file${alreadyPrecachedCount === 1 ? ' is' : 's are'} already cached.`;\n    }\n\n    logger.groupCollapsed(message);\n\n    _nestedGroup(`View newly precached URLs.`, urlsToPrecache);\n    _nestedGroup(`View previously precached URLs.`, urlsAlreadyPrecached);\n    logger.groupEnd();\n  }\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 {cacheNames} from 'workbox-core/_private/cacheNames.mjs';\nimport {cacheWrapper} from 'workbox-core/_private/cacheWrapper.mjs';\nimport {fetchWrapper} from 'workbox-core/_private/fetchWrapper.mjs';\nimport {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';\n\nimport {cleanRedirect} from './utils/cleanRedirect.mjs';\nimport {createCacheKey} from './utils/createCacheKey.mjs';\nimport {printCleanupDetails} from './utils/printCleanupDetails.mjs';\nimport {printInstallDetails} from './utils/printInstallDetails.mjs';\n\nimport './_version.mjs';\n\n\n/**\n * Performs efficient precaching of assets.\n *\n * @memberof module:workbox-precaching\n */\nclass PrecacheController {\n  /**\n   * Create a new PrecacheController.\n   *\n   * @param {string} [cacheName] An optional name for the cache, to override\n   * the default precache name.\n   */\n  constructor(cacheName) {\n    this._cacheName = cacheNames.getPrecacheName(cacheName);\n    this._urlsToCacheKeys = new Map();\n  }\n\n  /**\n   * This method will add items to the precache list, removing duplicates\n   * and ensuring the information is valid.\n   *\n   * @param {\n   * Array<module:workbox-precaching.PrecacheController.PrecacheEntry|string>\n   * } entries Array of entries to precache.\n   */\n  addToCacheList(entries) {\n    if (process.env.NODE_ENV !== 'production') {\n      assert.isArray(entries, {\n        moduleName: 'workbox-precaching',\n        className: 'PrecacheController',\n        funcName: 'addToCacheList',\n        paramName: 'entries',\n      });\n    }\n\n    for (const entry of entries) {\n      const {cacheKey, url} = createCacheKey(entry);\n      if (this._urlsToCacheKeys.has(url) &&\n          this._urlsToCacheKeys.get(url) !== cacheKey) {\n        throw new WorkboxError('add-to-cache-list-conflicting-entries', {\n          firstEntry: this._urlsToCacheKeys.get(url),\n          secondEntry: cacheKey,\n        });\n      }\n      this._urlsToCacheKeys.set(url, cacheKey);\n    }\n  }\n\n  /**\n   * Precaches new and updated assets. Call this method from the service worker\n   * install event.\n   *\n   * @param {Object} options\n   * @param {Event} [options.event] The install event (if needed).\n   * @param {Array<Object>} [options.plugins] Plugins to be used for fetching\n   * and caching during install.\n   * @return {Promise<workbox.precaching.InstallResult>}\n   */\n  async install({event, plugins} = {}) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (plugins) {\n        assert.isArray(plugins, {\n          moduleName: 'workbox-precaching',\n          className: 'PrecacheController',\n          funcName: 'install',\n          paramName: 'plugins',\n        });\n      }\n    }\n\n    const urlsToPrecache = [];\n    const urlsAlreadyPrecached = [];\n\n    const cache = await caches.open(this._cacheName);\n    const alreadyCachedRequests = await cache.keys();\n    const alreadyCachedURLs = new Set(alreadyCachedRequests.map(\n        (request) => request.url));\n\n    for (const cacheKey of this._urlsToCacheKeys.values()) {\n      if (alreadyCachedURLs.has(cacheKey)) {\n        urlsAlreadyPrecached.push(cacheKey);\n      } else {\n        urlsToPrecache.push(cacheKey);\n      }\n    }\n\n    const precacheRequests = urlsToPrecache.map((url) => {\n      return this._addURLToCache({event, plugins, url});\n    });\n    await Promise.all(precacheRequests);\n\n    if (process.env.NODE_ENV !== 'production') {\n      printInstallDetails(urlsToPrecache, urlsAlreadyPrecached);\n    }\n\n    return {\n      updatedURLs: urlsToPrecache,\n      notUpdatedURLs: urlsAlreadyPrecached,\n    };\n  }\n\n  /**\n   * Deletes assets that are no longer present in the current precache manifest.\n   * Call this method from the service worker activate event.\n   *\n   * @return {Promise<workbox.precaching.CleanupResult>}\n   */\n  async activate() {\n    const cache = await caches.open(this._cacheName);\n    const currentlyCachedRequests = await cache.keys();\n    const expectedCacheKeys = new Set(this._urlsToCacheKeys.values());\n\n    const deletedURLs = [];\n    for (const request of currentlyCachedRequests) {\n      if (!expectedCacheKeys.has(request.url)) {\n        await cache.delete(request);\n        deletedURLs.push(request.url);\n      }\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n      printCleanupDetails(deletedURLs);\n    }\n\n    return {deletedURLs};\n  }\n\n  /**\n   * Requests the entry and saves it to the cache if the response is valid.\n   * By default, any response with a status code of less than 400 (including\n   * opaque responses) is considered valid.\n   *\n   * If you need to use custom criteria to determine what's valid and what\n   * isn't, then pass in an item in `options.plugins` that implements the\n   * `cacheWillUpdate()` lifecycle event.\n   *\n   * @private\n   * @param {Object} options\n   * @param {string} options.url The URL to fetch and cache.\n   * @param {Event} [options.event] The install event (if passed).\n   * @param {Array<Object>} [options.plugins] An array of plugins to apply to\n   * fetch and caching.\n   */\n  async _addURLToCache({url, event, plugins}) {\n    const request = new Request(url, {credentials: 'same-origin'});\n    let response = await fetchWrapper.fetch({\n      event,\n      plugins,\n      request,\n    });\n\n    // Allow developers to override the default logic about what is and isn't\n    // valid by passing in a plugin implementing cacheWillUpdate(), e.g.\n    // a workbox.cacheableResponse.Plugin instance.\n    let cacheWillUpdateCallback;\n    for (const plugin of (plugins || [])) {\n      if ('cacheWillUpdate' in plugin) {\n        cacheWillUpdateCallback = plugin.cacheWillUpdate.bind(plugin);\n      }\n    }\n\n    const isValidResponse = cacheWillUpdateCallback ?\n      // Use a callback if provided. It returns a truthy value if valid.\n      cacheWillUpdateCallback({event, request, response}) :\n      // Otherwise, default to considering any response status under 400 valid.\n      // This includes, by default, considering opaque responses valid.\n      response.status < 400;\n\n    // Consider this a failure, leading to the `install` handler failing, if\n    // we get back an invalid response.\n    if (!isValidResponse) {\n      throw new WorkboxError('bad-precaching-response', {\n        url,\n        status: response.status,\n      });\n    }\n\n    if (response.redirected) {\n      response = await cleanRedirect(response);\n    }\n\n    await cacheWrapper.put({\n      event,\n      plugins,\n      request,\n      response,\n      cacheName: this._cacheName,\n      matchOptions: {\n        ignoreSearch: true,\n      },\n    });\n  }\n\n  /**\n   * Returns a mapping of a precached URL to the corresponding cache key, taking\n   * into account the revision information for the URL.\n   *\n   * @return {Map<string, string>} A URL to cache key mapping.\n   */\n  getURLsToCacheKeys() {\n    return this._urlsToCacheKeys;\n  }\n\n  /**\n   * Returns a list of all the URLs that have been precached by the current\n   * service worker.\n   *\n   * @return {Array<string>} The precached URLs.\n   */\n  getCachedURLs() {\n    return [...this._urlsToCacheKeys.keys()];\n  }\n\n  /**\n   * Returns the cache key used for storing a given URL. If that URL is\n   * unversioned, like `/index.html', then the cache key will be the original\n   * URL with a search parameter appended to it.\n   *\n   * @param {string} url A URL whose cache key you want to look up.\n   * @return {string} The versioned URL that corresponds to a cache key\n   * for the original URL, or undefined if that URL isn't precached.\n   */\n  getCacheKeyForURL(url) {\n    const urlObject = new URL(url, location);\n    return this._urlsToCacheKeys.get(urlObject.href);\n  }\n}\n\nexport {PrecacheController};\n","/*\n  Copyright 2019 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 {PrecacheController} from '../PrecacheController.mjs';\nimport '../_version.mjs';\n\n\nlet precacheController;\n\n/**\n * @return {PrecacheController}\n * @private\n */\nexport const getOrCreatePrecacheController = () => {\n  if (!precacheController) {\n    precacheController = new PrecacheController();\n  }\n  return precacheController;\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 '../_version.mjs';\n\n/**\n * Removes any URL search parameters that should be ignored.\n *\n * @param {URL} urlObject The original URL.\n * @param {Array<RegExp>} ignoreURLParametersMatching RegExps to test against\n * each search parameter name. Matches mean that the search parameter should be\n * ignored.\n * @return {URL} The URL with any ignored search parameters removed.\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function removeIgnoredSearchParams(urlObject,\n    ignoreURLParametersMatching) {\n  // Convert the iterable into an array at the start of the loop to make sure\n  // deletion doesn't mess up iteration.\n  for (const paramName of [...urlObject.searchParams.keys()]) {\n    if (ignoreURLParametersMatching.some((regExp) => regExp.test(paramName))) {\n      urlObject.searchParams.delete(paramName);\n    }\n  }\n\n  return urlObject;\n}\n","/*\n  Copyright 2019 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 {removeIgnoredSearchParams} from './removeIgnoredSearchParams.mjs';\n\nimport '../_version.mjs';\n\n/**\n * Generator function that yields possible variations on the original URL to\n * check, one at a time.\n *\n * @param {string} url\n * @param {Object} options\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function* generateURLVariations(url, {\n  ignoreURLParametersMatching,\n  directoryIndex,\n  cleanURLs,\n  urlManipulation,\n} = {}) {\n  const urlObject = new URL(url, location);\n  urlObject.hash = '';\n  yield urlObject.href;\n\n  const urlWithoutIgnoredParams = removeIgnoredSearchParams(\n      urlObject, ignoreURLParametersMatching);\n  yield urlWithoutIgnoredParams.href;\n\n  if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith('/')) {\n    const directoryURL = new URL(urlWithoutIgnoredParams);\n    directoryURL.pathname += directoryIndex;\n    yield directoryURL.href;\n  }\n\n  if (cleanURLs) {\n    const cleanURL = new URL(urlWithoutIgnoredParams);\n    cleanURL.pathname += '.html';\n    yield cleanURL.href;\n  }\n\n  if (urlManipulation) {\n    const additionalURLs = urlManipulation({url: urlObject});\n    for (const urlToAttempt of additionalURLs) {\n      yield urlToAttempt.href;\n    }\n  }\n}\n","/*\n  Copyright 2019 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 {getOrCreatePrecacheController}\n  from './getOrCreatePrecacheController.mjs';\nimport {generateURLVariations} from './generateURLVariations.mjs';\nimport '../_version.mjs';\n\n/**\n * This function will take the request URL and manipulate it based on the\n * configuration options.\n *\n * @param {string} url\n * @param {Object} options\n * @return {string} Returns the URL in the cache that matches the request,\n * if possible.\n *\n * @private\n */\nexport const getCacheKeyForURL = (url, options) => {\n  const precacheController = getOrCreatePrecacheController();\n\n  const urlsToCacheKeys = precacheController.getURLsToCacheKeys();\n  for (const possibleURL of generateURLVariations(url, options)) {\n    const possibleCacheKey = urlsToCacheKeys.get(possibleURL);\n    if (possibleCacheKey) {\n      return possibleCacheKey;\n    }\n  }\n};\n","/*\n  Copyright 2019 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 {cacheNames} from 'workbox-core/_private/cacheNames.mjs';\nimport {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.mjs';\nimport {logger} from 'workbox-core/_private/logger.mjs';\nimport {getCacheKeyForURL} from './getCacheKeyForURL.mjs';\nimport '../_version.mjs';\n\n\n/**\n * Adds a `fetch` listener to the service worker that will\n * respond to\n * [network requests]{@link https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests}\n * with precached assets.\n *\n * Requests for assets that aren't precached, the `FetchEvent` will not be\n * responded to, allowing the event to fall through to other `fetch` event\n * listeners.\n *\n * NOTE: when called more than once this method will replace the previously set\n * configuration options. Calling it more than once is not recommended outside\n * of tests.\n *\n * @private\n * @param {Object} options\n * @param {string} [options.directoryIndex=index.html] The `directoryIndex` will\n * check cache entries for a URLs ending with '/' to see if there is a hit when\n * appending the `directoryIndex` value.\n * @param {Array<RegExp>} [options.ignoreURLParametersMatching=[/^utm_/]] An\n * array of regex's to remove search params when looking for a cache match.\n * @param {boolean} [options.cleanURLs=true] The `cleanURLs` option will\n * check the cache for the URL with a `.html` added to the end of the end.\n * @param {workbox.precaching~urlManipulation} [options.urlManipulation]\n * This is a function that should take a URL and return an array of\n * alternative URL's that should be checked for precache matches.\n */\nexport const addFetchListener = ({\n  ignoreURLParametersMatching = [/^utm_/],\n  directoryIndex = 'index.html',\n  cleanURLs = true,\n  urlManipulation = null,\n} = {}) => {\n  const cacheName = cacheNames.getPrecacheName();\n\n  addEventListener('fetch', (event) => {\n    const precachedURL = getCacheKeyForURL(event.request.url, {\n      cleanURLs,\n      directoryIndex,\n      ignoreURLParametersMatching,\n      urlManipulation,\n    });\n    if (!precachedURL) {\n      if (process.env.NODE_ENV !== 'production') {\n        logger.debug(`Precaching did not find a match for ` +\n          getFriendlyURL(event.request.url));\n      }\n      return;\n    }\n\n    let responsePromise = caches.open(cacheName).then((cache) => {\n      return cache.match(precachedURL);\n    }).then((cachedResponse) => {\n      if (cachedResponse) {\n        return cachedResponse;\n      }\n\n      // Fall back to the network if we don't have a cached response\n      // (perhaps due to manual cache cleanup).\n      if (process.env.NODE_ENV !== 'production') {\n        logger.warn(`The precached response for ` +\n        `${getFriendlyURL(precachedURL)} in ${cacheName} was not found. ` +\n        `Falling back to the network instead.`);\n      }\n\n      return fetch(precachedURL);\n    });\n\n    if (process.env.NODE_ENV !== 'production') {\n      responsePromise = responsePromise.then((response) => {\n        // Workbox is going to handle the route.\n        // print the routing details to the console.\n        logger.groupCollapsed(`Precaching is responding to: ` +\n          getFriendlyURL(event.request.url));\n        logger.log(`Serving the precached url: ${precachedURL}`);\n\n        logger.groupCollapsed(`View request details here.`);\n        logger.log(event.request);\n        logger.groupEnd();\n\n        logger.groupCollapsed(`View response details here.`);\n        logger.log(response);\n        logger.groupEnd();\n\n        logger.groupEnd();\n        return response;\n      });\n    }\n\n    event.respondWith(responsePromise);\n  });\n};\n","\n/*\n  Copyright 2019 Google LLC\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 {addFetchListener} from './utils/addFetchListener.mjs';\nimport './_version.mjs';\n\n\nlet listenerAdded = false;\n\n/**\n * Add a `fetch` listener to the service worker that will\n * respond to\n * [network requests]{@link https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests}\n * with precached assets.\n *\n * Requests for assets that aren't precached, the `FetchEvent` will not be\n * responded to, allowing the event to fall through to other `fetch` event\n * listeners.\n *\n * @param {Object} options\n * @param {string} [options.directoryIndex=index.html] The `directoryIndex` will\n * check cache entries for a URLs ending with '/' to see if there is a hit when\n * appending the `directoryIndex` value.\n * @param {Array<RegExp>} [options.ignoreURLParametersMatching=[/^utm_/]] An\n * array of regex's to remove search params when looking for a cache match.\n * @param {boolean} [options.cleanURLs=true] The `cleanURLs` option will\n * check the cache for the URL with a `.html` added to the end of the end.\n * @param {workbox.precaching~urlManipulation} [options.urlManipulation]\n * This is a function that should take a URL and return an array of\n * alternative URL's that should be checked for precache matches.\n *\n * @alias workbox.precaching.addRoute\n */\nexport const addRoute = (options) => {\n  if (!listenerAdded) {\n    addFetchListener(options);\n    listenerAdded = true;\n  }\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 '../_version.mjs';\n\nconst SUBSTRING_TO_FIND = '-precache-';\n\n/**\n * Cleans up incompatible precaches that were created by older versions of\n * Workbox, by a service worker registered under the current scope.\n *\n * This is meant to be called as part of the `activate` event.\n *\n * This should be safe to use as long as you don't include `substringToFind`\n * (defaulting to `-precache-`) in your non-precache cache names.\n *\n * @param {string} currentPrecacheName The cache name currently in use for\n * precaching. This cache won't be deleted.\n * @param {string} [substringToFind='-precache-'] Cache names which include this\n * substring will be deleted (excluding `currentPrecacheName`).\n * @return {Array<string>} A list of all the cache names that were deleted.\n *\n * @private\n * @memberof module:workbox-precaching\n */\nconst deleteOutdatedCaches = async (\n  currentPrecacheName,\n  substringToFind = SUBSTRING_TO_FIND) => {\n  const cacheNames = await caches.keys();\n\n  const cacheNamesToDelete = cacheNames.filter((cacheName) => {\n    return cacheName.includes(substringToFind) &&\n           cacheName.includes(self.registration.scope) &&\n           cacheName !== currentPrecacheName;\n  });\n\n  await Promise.all(\n      cacheNamesToDelete.map((cacheName) => caches.delete(cacheName)));\n\n  return cacheNamesToDelete;\n};\n\nexport {deleteOutdatedCaches};\n\n","/*\n  Copyright 2019 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 {cacheNames} from 'workbox-core/_private/cacheNames.mjs';\nimport {logger} from 'workbox-core/_private/logger.mjs';\nimport {deleteOutdatedCaches} from './utils/deleteOutdatedCaches.mjs';\nimport './_version.mjs';\n\n\n/**\n * Adds an `activate` event listener which will clean up incompatible\n * precaches that were created by older versions of Workbox.\n *\n * @alias workbox.precaching.cleanupOutdatedCaches\n */\nexport const cleanupOutdatedCaches = () => {\n  addEventListener('activate', (event) => {\n    const cacheName = cacheNames.getPrecacheName();\n\n    event.waitUntil(deleteOutdatedCaches(cacheName).then((cachesDeleted) => {\n      if (process.env.NODE_ENV !== 'production') {\n        if (cachesDeleted.length > 0) {\n          logger.log(`The following out-of-date precaches were cleaned up ` +\n              `automatically:`, cachesDeleted);\n        }\n      }\n    }));\n  });\n};\n","/*\n  Copyright 2019 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 {getOrCreatePrecacheController}\n  from './utils/getOrCreatePrecacheController.mjs';\nimport './_version.mjs';\n\n\n/**\n * Takes in a URL, and returns the corresponding URL that could be used to\n * lookup the entry in the precache.\n *\n * If a relative URL is provided, the location of the service worker file will\n * be used as the base.\n *\n * For precached entries without revision information, the cache key will be the\n * same as the original URL.\n *\n * For precached entries with revision information, the cache key will be the\n * original URL with the addition of a query parameter used for keeping track of\n * the revision info.\n *\n * @param {string} url The URL whose cache key to look up.\n * @return {string} The cache key that corresponds to that URL.\n *\n * @alias workbox.precaching.getCacheKeyForURL\n */\nexport const getCacheKeyForURL = (url) => {\n  const precacheController = getOrCreatePrecacheController();\n  return precacheController.getCacheKeyForURL(url);\n};\n","/*\n  Copyright 2019 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 {logger} from 'workbox-core/_private/logger.mjs';\nimport {getOrCreatePrecacheController} from './utils/getOrCreatePrecacheController.mjs';\nimport {precachePlugins} from './utils/precachePlugins.mjs';\nimport './_version.mjs';\n\n\nconst installListener = (event) => {\n  const precacheController = getOrCreatePrecacheController();\n  const plugins = precachePlugins.get();\n\n  event.waitUntil(\n      precacheController.install({event, plugins})\n          .catch((error) => {\n            if (process.env.NODE_ENV !== 'production') {\n              logger.error(`Service worker installation failed. It will ` +\n              `be retried automatically during the next navigation.`);\n            }\n            // Re-throw the error to ensure installation fails.\n            throw error;\n          })\n  );\n};\n\nconst activateListener = (event) => {\n  const precacheController = getOrCreatePrecacheController();\n  const plugins = precachePlugins.get();\n\n  event.waitUntil(precacheController.activate({event, plugins}));\n};\n\n/**\n * Adds items to the precache list, removing any duplicates and\n * stores the files in the\n * [\"precache cache\"]{@link module:workbox-core.cacheNames} when the service\n * worker installs.\n *\n * This method can be called multiple times.\n *\n * Please note: This method **will not** serve any of the cached files for you.\n * It only precaches files. To respond to a network request you call\n * [addRoute()]{@link module:workbox-precaching.addRoute}.\n *\n * If you have a single array of files to precache, you can just call\n * [precacheAndRoute()]{@link module:workbox-precaching.precacheAndRoute}.\n *\n * @param {Array<Object|string>} entries Array of entries to precache.\n *\n * @alias workbox.precaching.precache\n */\nexport const precache = (entries) => {\n  const precacheController = getOrCreatePrecacheController();\n  precacheController.addToCacheList(entries);\n\n  if (entries.length > 0) {\n    // NOTE: these listeners will only be added once (even if the `precache()`\n    // method is called multiple times) because event listeners are implemented\n    // as a set, where each listener must be unique.\n    addEventListener('install', installListener);\n    addEventListener('activate', activateListener);\n  }\n};\n","/*\n  Copyright 2019 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 {addRoute} from './addRoute.mjs';\nimport {precache} from './precache.mjs';\nimport './_version.mjs';\n\n\n/**\n * This method will add entries to the precache list and add a route to\n * respond to fetch events.\n *\n * This is a convenience method that will call\n * [precache()]{@link module:workbox-precaching.precache} and\n * [addRoute()]{@link module:workbox-precaching.addRoute} in a single call.\n *\n * @param {Array<Object|string>} entries Array of entries to precache.\n * @param {Object} options See\n * [addRoute() options]{@link module:workbox-precaching.addRoute}.\n *\n * @alias workbox.precaching.precacheAndRoute\n */\nexport const precacheAndRoute = (entries, options) => {\n  precache(entries);\n  addRoute(options);\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 {addPlugins} from './addPlugins.mjs';\nimport {addRoute} from './addRoute.mjs';\nimport {cleanupOutdatedCaches} from './cleanupOutdatedCaches.mjs';\nimport {getCacheKeyForURL} from './getCacheKeyForURL.mjs';\nimport {precache} from './precache.mjs';\nimport {precacheAndRoute} from './precacheAndRoute.mjs';\nimport {PrecacheController} from './PrecacheController.mjs';\nimport './_version.mjs';\n\n\nif (process.env.NODE_ENV !== 'production') {\n  assert.isSWEnv('workbox-precaching');\n}\n\n/**\n * Most consumers of this module will want to use the\n * [precacheAndRoute()]{@link workbox.precaching.precacheAndRoute}\n * method to add assets to the Cache and respond to network requests with these\n * cached assets.\n *\n * If you require finer grained control, you can use the\n * [PrecacheController]{@link workbox.precaching.PrecacheController}\n * to determine when performed.\n *\n * @namespace workbox.precaching\n */\n\nexport {\n  addPlugins,\n  addRoute,\n  cleanupOutdatedCaches,\n  getCacheKeyForURL,\n  precache,\n  precacheAndRoute,\n  PrecacheController,\n};\n"],"names":["self","_","e","plugins","precachePlugins","get","add","newPlugins","push","addPlugins","cleanRedirect","response","clonedResponse","clone","bodyPromise","Promise","resolve","body","blob","Response","headers","status","statusText","REVISION_SEARCH_PARAM","createCacheKey","entry","WorkboxError","urlObject","URL","location","cacheKey","href","url","revision","originalURL","cacheKeyURL","searchParams","set","logGroup","groupTitle","deletedURLs","logger","groupCollapsed","log","groupEnd","printCleanupDetails","deletionCount","length","_nestedGroup","urls","printInstallDetails","urlsToPrecache","urlsAlreadyPrecached","precachedCount","alreadyPrecachedCount","message","PrecacheController","constructor","cacheName","_cacheName","cacheNames","getPrecacheName","_urlsToCacheKeys","Map","addToCacheList","entries","assert","isArray","moduleName","className","funcName","paramName","has","firstEntry","secondEntry","install","event","cache","caches","open","alreadyCachedRequests","keys","alreadyCachedURLs","Set","map","request","values","precacheRequests","_addURLToCache","all","updatedURLs","notUpdatedURLs","activate","currentlyCachedRequests","expectedCacheKeys","delete","Request","credentials","fetchWrapper","fetch","cacheWillUpdateCallback","plugin","cacheWillUpdate","bind","isValidResponse","redirected","cacheWrapper","put","matchOptions","ignoreSearch","getURLsToCacheKeys","getCachedURLs","getCacheKeyForURL","precacheController","getOrCreatePrecacheController","removeIgnoredSearchParams","ignoreURLParametersMatching","some","regExp","test","generateURLVariations","directoryIndex","cleanURLs","urlManipulation","hash","urlWithoutIgnoredParams","pathname","endsWith","directoryURL","cleanURL","additionalURLs","urlToAttempt","options","urlsToCacheKeys","possibleURL","possibleCacheKey","addFetchListener","addEventListener","precachedURL","debug","getFriendlyURL","responsePromise","then","match","cachedResponse","warn","respondWith","listenerAdded","addRoute","SUBSTRING_TO_FIND","deleteOutdatedCaches","currentPrecacheName","substringToFind","cacheNamesToDelete","filter","includes","registration","scope","cleanupOutdatedCaches","waitUntil","cachesDeleted","installListener","catch","error","activateListener","precache","precacheAndRoute","isSWEnv"],"mappings":"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"}

data/lib/vendor/workbox-v4.3.1/workbox-precaching.prod.js

@@ -1,2 +0,0 @@
-this.workbox=this.workbox||{},this.workbox.precaching=function(t,e,n,s,c){"use strict";try{self["workbox:precaching:4.3.1"]&&_()}catch(t){}const o=[],i={get:()=>o,add(t){o.push(...t)}};const a="__WB_REVISION__";function r(t){if(!t)throw new c.WorkboxError("add-to-cache-list-unexpected-type",{entry:t});if("string"==typeof t){const e=new URL(t,location);return{cacheKey:e.href,url:e.href}}const{revision:e,url:n}=t;if(!n)throw new c.WorkboxError("add-to-cache-list-unexpected-type",{entry:t});if(!e){const t=new URL(n,location);return{cacheKey:t.href,url:t.href}}const s=new URL(n,location),o=new URL(n,location);return o.searchParams.set(a,e),{cacheKey:o.href,url:s.href}}class l{constructor(t){this.t=e.cacheNames.getPrecacheName(t),this.s=new Map}addToCacheList(t){for(const e of t){const{cacheKey:t,url:n}=r(e);if(this.s.has(n)&&this.s.get(n)!==t)throw new c.WorkboxError("add-to-cache-list-conflicting-entries",{firstEntry:this.s.get(n),secondEntry:t});this.s.set(n,t)}}async install({event:t,plugins:e}={}){const n=[],s=[],c=await caches.open(this.t),o=await c.keys(),i=new Set(o.map(t=>t.url));for(const t of this.s.values())i.has(t)?s.push(t):n.push(t);const a=n.map(n=>this.o({event:t,plugins:e,url:n}));return await Promise.all(a),{updatedURLs:n,notUpdatedURLs:s}}async activate(){const t=await caches.open(this.t),e=await t.keys(),n=new Set(this.s.values()),s=[];for(const c of e)n.has(c.url)||(await t.delete(c),s.push(c.url));return{deletedURLs:s}}async o({url:t,event:e,plugins:o}){const i=new Request(t,{credentials:"same-origin"});let a,r=await s.fetchWrapper.fetch({event:e,plugins:o,request:i});for(const t of o||[])"cacheWillUpdate"in t&&(a=t.cacheWillUpdate.bind(t));if(!(a?a({event:e,request:i,response:r}):r.status<400))throw new c.WorkboxError("bad-precaching-response",{url:t,status:r.status});r.redirected&&(r=await async function(t){const e=t.clone(),n="body"in e?Promise.resolve(e.body):e.blob(),s=await n;return new Response(s,{headers:e.headers,status:e.status,statusText:e.statusText})}(r)),await n.cacheWrapper.put({event:e,plugins:o,request:i,response:r,cacheName:this.t,matchOptions:{ignoreSearch:!0}})}getURLsToCacheKeys(){return this.s}getCachedURLs(){return[...this.s.keys()]}getCacheKeyForURL(t){const e=new URL(t,location);return this.s.get(e.href)}}let u;const h=()=>(u||(u=new l),u);const d=(t,e)=>{const n=h().getURLsToCacheKeys();for(const s of function*(t,{ignoreURLParametersMatching:e,directoryIndex:n,cleanURLs:s,urlManipulation:c}={}){const o=new URL(t,location);o.hash="",yield o.href;const i=function(t,e){for(const n of[...t.searchParams.keys()])e.some(t=>t.test(n))&&t.searchParams.delete(n);return t}(o,e);if(yield i.href,n&&i.pathname.endsWith("/")){const t=new URL(i);t.pathname+=n,yield t.href}if(s){const t=new URL(i);t.pathname+=".html",yield t.href}if(c){const t=c({url:o});for(const e of t)yield e.href}}(t,e)){const t=n.get(s);if(t)return t}};let w=!1;const f=t=>{w||((({ignoreURLParametersMatching:t=[/^utm_/],directoryIndex:n="index.html",cleanURLs:s=!0,urlManipulation:c=null}={})=>{const o=e.cacheNames.getPrecacheName();addEventListener("fetch",e=>{const i=d(e.request.url,{cleanURLs:s,directoryIndex:n,ignoreURLParametersMatching:t,urlManipulation:c});if(!i)return;let a=caches.open(o).then(t=>t.match(i)).then(t=>t||fetch(i));e.respondWith(a)})})(t),w=!0)},y=t=>{const e=h(),n=i.get();t.waitUntil(e.install({event:t,plugins:n}).catch(t=>{throw t}))},p=t=>{const e=h(),n=i.get();t.waitUntil(e.activate({event:t,plugins:n}))},L=t=>{h().addToCacheList(t),t.length>0&&(addEventListener("install",y),addEventListener("activate",p))};return t.addPlugins=(t=>{i.add(t)}),t.addRoute=f,t.cleanupOutdatedCaches=(()=>{addEventListener("activate",t=>{const n=e.cacheNames.getPrecacheName();t.waitUntil((async(t,e="-precache-")=>{const n=(await caches.keys()).filter(n=>n.includes(e)&&n.includes(self.registration.scope)&&n!==t);return await Promise.all(n.map(t=>caches.delete(t))),n})(n).then(t=>{}))})}),t.getCacheKeyForURL=(t=>{return h().getCacheKeyForURL(t)}),t.precache=L,t.precacheAndRoute=((t,e)=>{L(t),f(e)}),t.PrecacheController=l,t}({},workbox.core._private,workbox.core._private,workbox.core._private,workbox.core._private);
-//# sourceMappingURL=workbox-precaching.prod.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"workbox-precaching.prod.js","sources":["../_version.mjs","../utils/precachePlugins.mjs","../utils/createCacheKey.mjs","../PrecacheController.mjs","../utils/cleanRedirect.mjs","../utils/getOrCreatePrecacheController.mjs","../utils/getCacheKeyForURL.mjs","../utils/generateURLVariations.mjs","../utils/removeIgnoredSearchParams.mjs","../addRoute.mjs","../utils/addFetchListener.mjs","../precache.mjs","../addPlugins.mjs","../cleanupOutdatedCaches.mjs","../utils/deleteOutdatedCaches.mjs","../getCacheKeyForURL.mjs","../precacheAndRoute.mjs"],"sourcesContent":["try{self['workbox:precaching:4.3.1']&&_()}catch(e){}// eslint-disable-line","/*\n  Copyright 2019 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\n\nconst plugins = [];\n\nexport const precachePlugins = {\n  /*\n   * @return {Array}\n   * @private\n   */\n  get() {\n    return plugins;\n  },\n\n  /*\n   * @param {Array} newPlugins\n   * @private\n   */\n  add(newPlugins) {\n    plugins.push(...newPlugins);\n  },\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 {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';\n\nimport '../_version.mjs';\n\n// Name of the search parameter used to store revision info.\nconst REVISION_SEARCH_PARAM = '__WB_REVISION__';\n\n/**\n * Converts a manifest entry into a versioned URL suitable for precaching.\n *\n * @param {Object} entry\n * @return {string} A URL with versioning info.\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function createCacheKey(entry) {\n  if (!entry) {\n    throw new WorkboxError('add-to-cache-list-unexpected-type', {entry});\n  }\n\n  // If a precache manifest entry is a string, it's assumed to be a versioned\n  // URL, like '/app.abcd1234.js'. Return as-is.\n  if (typeof entry === 'string') {\n    const urlObject = new URL(entry, location);\n    return {\n      cacheKey: urlObject.href,\n      url: urlObject.href,\n    };\n  }\n\n  const {revision, url} = entry;\n  if (!url) {\n    throw new WorkboxError('add-to-cache-list-unexpected-type', {entry});\n  }\n\n  // If there's just a URL and no revision, then it's also assumed to be a\n  // versioned URL.\n  if (!revision) {\n    const urlObject = new URL(url, location);\n    return {\n      cacheKey: urlObject.href,\n      url: urlObject.href,\n    };\n  }\n\n  // Otherwise, construct a properly versioned URL using the custom Workbox\n  // search parameter along with the revision info.\n  const originalURL = new URL(url, location);\n  const cacheKeyURL = new URL(url, location);\n  cacheKeyURL.searchParams.set(REVISION_SEARCH_PARAM, revision);\n  return {\n    cacheKey: cacheKeyURL.href,\n    url: originalURL.href,\n  };\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 {cacheNames} from 'workbox-core/_private/cacheNames.mjs';\nimport {cacheWrapper} from 'workbox-core/_private/cacheWrapper.mjs';\nimport {fetchWrapper} from 'workbox-core/_private/fetchWrapper.mjs';\nimport {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';\n\nimport {cleanRedirect} from './utils/cleanRedirect.mjs';\nimport {createCacheKey} from './utils/createCacheKey.mjs';\nimport {printCleanupDetails} from './utils/printCleanupDetails.mjs';\nimport {printInstallDetails} from './utils/printInstallDetails.mjs';\n\nimport './_version.mjs';\n\n\n/**\n * Performs efficient precaching of assets.\n *\n * @memberof module:workbox-precaching\n */\nclass PrecacheController {\n  /**\n   * Create a new PrecacheController.\n   *\n   * @param {string} [cacheName] An optional name for the cache, to override\n   * the default precache name.\n   */\n  constructor(cacheName) {\n    this._cacheName = cacheNames.getPrecacheName(cacheName);\n    this._urlsToCacheKeys = new Map();\n  }\n\n  /**\n   * This method will add items to the precache list, removing duplicates\n   * and ensuring the information is valid.\n   *\n   * @param {\n   * Array<module:workbox-precaching.PrecacheController.PrecacheEntry|string>\n   * } entries Array of entries to precache.\n   */\n  addToCacheList(entries) {\n    if (process.env.NODE_ENV !== 'production') {\n      assert.isArray(entries, {\n        moduleName: 'workbox-precaching',\n        className: 'PrecacheController',\n        funcName: 'addToCacheList',\n        paramName: 'entries',\n      });\n    }\n\n    for (const entry of entries) {\n      const {cacheKey, url} = createCacheKey(entry);\n      if (this._urlsToCacheKeys.has(url) &&\n          this._urlsToCacheKeys.get(url) !== cacheKey) {\n        throw new WorkboxError('add-to-cache-list-conflicting-entries', {\n          firstEntry: this._urlsToCacheKeys.get(url),\n          secondEntry: cacheKey,\n        });\n      }\n      this._urlsToCacheKeys.set(url, cacheKey);\n    }\n  }\n\n  /**\n   * Precaches new and updated assets. Call this method from the service worker\n   * install event.\n   *\n   * @param {Object} options\n   * @param {Event} [options.event] The install event (if needed).\n   * @param {Array<Object>} [options.plugins] Plugins to be used for fetching\n   * and caching during install.\n   * @return {Promise<workbox.precaching.InstallResult>}\n   */\n  async install({event, plugins} = {}) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (plugins) {\n        assert.isArray(plugins, {\n          moduleName: 'workbox-precaching',\n          className: 'PrecacheController',\n          funcName: 'install',\n          paramName: 'plugins',\n        });\n      }\n    }\n\n    const urlsToPrecache = [];\n    const urlsAlreadyPrecached = [];\n\n    const cache = await caches.open(this._cacheName);\n    const alreadyCachedRequests = await cache.keys();\n    const alreadyCachedURLs = new Set(alreadyCachedRequests.map(\n        (request) => request.url));\n\n    for (const cacheKey of this._urlsToCacheKeys.values()) {\n      if (alreadyCachedURLs.has(cacheKey)) {\n        urlsAlreadyPrecached.push(cacheKey);\n      } else {\n        urlsToPrecache.push(cacheKey);\n      }\n    }\n\n    const precacheRequests = urlsToPrecache.map((url) => {\n      return this._addURLToCache({event, plugins, url});\n    });\n    await Promise.all(precacheRequests);\n\n    if (process.env.NODE_ENV !== 'production') {\n      printInstallDetails(urlsToPrecache, urlsAlreadyPrecached);\n    }\n\n    return {\n      updatedURLs: urlsToPrecache,\n      notUpdatedURLs: urlsAlreadyPrecached,\n    };\n  }\n\n  /**\n   * Deletes assets that are no longer present in the current precache manifest.\n   * Call this method from the service worker activate event.\n   *\n   * @return {Promise<workbox.precaching.CleanupResult>}\n   */\n  async activate() {\n    const cache = await caches.open(this._cacheName);\n    const currentlyCachedRequests = await cache.keys();\n    const expectedCacheKeys = new Set(this._urlsToCacheKeys.values());\n\n    const deletedURLs = [];\n    for (const request of currentlyCachedRequests) {\n      if (!expectedCacheKeys.has(request.url)) {\n        await cache.delete(request);\n        deletedURLs.push(request.url);\n      }\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n      printCleanupDetails(deletedURLs);\n    }\n\n    return {deletedURLs};\n  }\n\n  /**\n   * Requests the entry and saves it to the cache if the response is valid.\n   * By default, any response with a status code of less than 400 (including\n   * opaque responses) is considered valid.\n   *\n   * If you need to use custom criteria to determine what's valid and what\n   * isn't, then pass in an item in `options.plugins` that implements the\n   * `cacheWillUpdate()` lifecycle event.\n   *\n   * @private\n   * @param {Object} options\n   * @param {string} options.url The URL to fetch and cache.\n   * @param {Event} [options.event] The install event (if passed).\n   * @param {Array<Object>} [options.plugins] An array of plugins to apply to\n   * fetch and caching.\n   */\n  async _addURLToCache({url, event, plugins}) {\n    const request = new Request(url, {credentials: 'same-origin'});\n    let response = await fetchWrapper.fetch({\n      event,\n      plugins,\n      request,\n    });\n\n    // Allow developers to override the default logic about what is and isn't\n    // valid by passing in a plugin implementing cacheWillUpdate(), e.g.\n    // a workbox.cacheableResponse.Plugin instance.\n    let cacheWillUpdateCallback;\n    for (const plugin of (plugins || [])) {\n      if ('cacheWillUpdate' in plugin) {\n        cacheWillUpdateCallback = plugin.cacheWillUpdate.bind(plugin);\n      }\n    }\n\n    const isValidResponse = cacheWillUpdateCallback ?\n      // Use a callback if provided. It returns a truthy value if valid.\n      cacheWillUpdateCallback({event, request, response}) :\n      // Otherwise, default to considering any response status under 400 valid.\n      // This includes, by default, considering opaque responses valid.\n      response.status < 400;\n\n    // Consider this a failure, leading to the `install` handler failing, if\n    // we get back an invalid response.\n    if (!isValidResponse) {\n      throw new WorkboxError('bad-precaching-response', {\n        url,\n        status: response.status,\n      });\n    }\n\n    if (response.redirected) {\n      response = await cleanRedirect(response);\n    }\n\n    await cacheWrapper.put({\n      event,\n      plugins,\n      request,\n      response,\n      cacheName: this._cacheName,\n      matchOptions: {\n        ignoreSearch: true,\n      },\n    });\n  }\n\n  /**\n   * Returns a mapping of a precached URL to the corresponding cache key, taking\n   * into account the revision information for the URL.\n   *\n   * @return {Map<string, string>} A URL to cache key mapping.\n   */\n  getURLsToCacheKeys() {\n    return this._urlsToCacheKeys;\n  }\n\n  /**\n   * Returns a list of all the URLs that have been precached by the current\n   * service worker.\n   *\n   * @return {Array<string>} The precached URLs.\n   */\n  getCachedURLs() {\n    return [...this._urlsToCacheKeys.keys()];\n  }\n\n  /**\n   * Returns the cache key used for storing a given URL. If that URL is\n   * unversioned, like `/index.html', then the cache key will be the original\n   * URL with a search parameter appended to it.\n   *\n   * @param {string} url A URL whose cache key you want to look up.\n   * @return {string} The versioned URL that corresponds to a cache key\n   * for the original URL, or undefined if that URL isn't precached.\n   */\n  getCacheKeyForURL(url) {\n    const urlObject = new URL(url, location);\n    return this._urlsToCacheKeys.get(urlObject.href);\n  }\n}\n\nexport {PrecacheController};\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\n/**\n * @param {Response} response\n * @return {Response}\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport async function cleanRedirect(response) {\n  const clonedResponse = response.clone();\n\n  // Not all browsers support the Response.body stream, so fall back\n  // to reading the entire body into memory as a blob.\n  const bodyPromise = 'body' in clonedResponse ?\n    Promise.resolve(clonedResponse.body) :\n    clonedResponse.blob();\n\n  const body = await bodyPromise;\n\n  // new Response() is happy when passed either a stream or a Blob.\n  return new Response(body, {\n    headers: clonedResponse.headers,\n    status: clonedResponse.status,\n    statusText: clonedResponse.statusText,\n  });\n}\n","/*\n  Copyright 2019 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 {PrecacheController} from '../PrecacheController.mjs';\nimport '../_version.mjs';\n\n\nlet precacheController;\n\n/**\n * @return {PrecacheController}\n * @private\n */\nexport const getOrCreatePrecacheController = () => {\n  if (!precacheController) {\n    precacheController = new PrecacheController();\n  }\n  return precacheController;\n};\n","/*\n  Copyright 2019 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 {getOrCreatePrecacheController}\n  from './getOrCreatePrecacheController.mjs';\nimport {generateURLVariations} from './generateURLVariations.mjs';\nimport '../_version.mjs';\n\n/**\n * This function will take the request URL and manipulate it based on the\n * configuration options.\n *\n * @param {string} url\n * @param {Object} options\n * @return {string} Returns the URL in the cache that matches the request,\n * if possible.\n *\n * @private\n */\nexport const getCacheKeyForURL = (url, options) => {\n  const precacheController = getOrCreatePrecacheController();\n\n  const urlsToCacheKeys = precacheController.getURLsToCacheKeys();\n  for (const possibleURL of generateURLVariations(url, options)) {\n    const possibleCacheKey = urlsToCacheKeys.get(possibleURL);\n    if (possibleCacheKey) {\n      return possibleCacheKey;\n    }\n  }\n};\n","/*\n  Copyright 2019 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 {removeIgnoredSearchParams} from './removeIgnoredSearchParams.mjs';\n\nimport '../_version.mjs';\n\n/**\n * Generator function that yields possible variations on the original URL to\n * check, one at a time.\n *\n * @param {string} url\n * @param {Object} options\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function* generateURLVariations(url, {\n  ignoreURLParametersMatching,\n  directoryIndex,\n  cleanURLs,\n  urlManipulation,\n} = {}) {\n  const urlObject = new URL(url, location);\n  urlObject.hash = '';\n  yield urlObject.href;\n\n  const urlWithoutIgnoredParams = removeIgnoredSearchParams(\n      urlObject, ignoreURLParametersMatching);\n  yield urlWithoutIgnoredParams.href;\n\n  if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith('/')) {\n    const directoryURL = new URL(urlWithoutIgnoredParams);\n    directoryURL.pathname += directoryIndex;\n    yield directoryURL.href;\n  }\n\n  if (cleanURLs) {\n    const cleanURL = new URL(urlWithoutIgnoredParams);\n    cleanURL.pathname += '.html';\n    yield cleanURL.href;\n  }\n\n  if (urlManipulation) {\n    const additionalURLs = urlManipulation({url: urlObject});\n    for (const urlToAttempt of additionalURLs) {\n      yield urlToAttempt.href;\n    }\n  }\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 '../_version.mjs';\n\n/**\n * Removes any URL search parameters that should be ignored.\n *\n * @param {URL} urlObject The original URL.\n * @param {Array<RegExp>} ignoreURLParametersMatching RegExps to test against\n * each search parameter name. Matches mean that the search parameter should be\n * ignored.\n * @return {URL} The URL with any ignored search parameters removed.\n *\n * @private\n * @memberof module:workbox-precaching\n */\nexport function removeIgnoredSearchParams(urlObject,\n    ignoreURLParametersMatching) {\n  // Convert the iterable into an array at the start of the loop to make sure\n  // deletion doesn't mess up iteration.\n  for (const paramName of [...urlObject.searchParams.keys()]) {\n    if (ignoreURLParametersMatching.some((regExp) => regExp.test(paramName))) {\n      urlObject.searchParams.delete(paramName);\n    }\n  }\n\n  return urlObject;\n}\n","\n/*\n  Copyright 2019 Google LLC\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 {addFetchListener} from './utils/addFetchListener.mjs';\nimport './_version.mjs';\n\n\nlet listenerAdded = false;\n\n/**\n * Add a `fetch` listener to the service worker that will\n * respond to\n * [network requests]{@link https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests}\n * with precached assets.\n *\n * Requests for assets that aren't precached, the `FetchEvent` will not be\n * responded to, allowing the event to fall through to other `fetch` event\n * listeners.\n *\n * @param {Object} options\n * @param {string} [options.directoryIndex=index.html] The `directoryIndex` will\n * check cache entries for a URLs ending with '/' to see if there is a hit when\n * appending the `directoryIndex` value.\n * @param {Array<RegExp>} [options.ignoreURLParametersMatching=[/^utm_/]] An\n * array of regex's to remove search params when looking for a cache match.\n * @param {boolean} [options.cleanURLs=true] The `cleanURLs` option will\n * check the cache for the URL with a `.html` added to the end of the end.\n * @param {workbox.precaching~urlManipulation} [options.urlManipulation]\n * This is a function that should take a URL and return an array of\n * alternative URL's that should be checked for precache matches.\n *\n * @alias workbox.precaching.addRoute\n */\nexport const addRoute = (options) => {\n  if (!listenerAdded) {\n    addFetchListener(options);\n    listenerAdded = true;\n  }\n};\n","/*\n  Copyright 2019 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 {cacheNames} from 'workbox-core/_private/cacheNames.mjs';\nimport {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.mjs';\nimport {logger} from 'workbox-core/_private/logger.mjs';\nimport {getCacheKeyForURL} from './getCacheKeyForURL.mjs';\nimport '../_version.mjs';\n\n\n/**\n * Adds a `fetch` listener to the service worker that will\n * respond to\n * [network requests]{@link https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests}\n * with precached assets.\n *\n * Requests for assets that aren't precached, the `FetchEvent` will not be\n * responded to, allowing the event to fall through to other `fetch` event\n * listeners.\n *\n * NOTE: when called more than once this method will replace the previously set\n * configuration options. Calling it more than once is not recommended outside\n * of tests.\n *\n * @private\n * @param {Object} options\n * @param {string} [options.directoryIndex=index.html] The `directoryIndex` will\n * check cache entries for a URLs ending with '/' to see if there is a hit when\n * appending the `directoryIndex` value.\n * @param {Array<RegExp>} [options.ignoreURLParametersMatching=[/^utm_/]] An\n * array of regex's to remove search params when looking for a cache match.\n * @param {boolean} [options.cleanURLs=true] The `cleanURLs` option will\n * check the cache for the URL with a `.html` added to the end of the end.\n * @param {workbox.precaching~urlManipulation} [options.urlManipulation]\n * This is a function that should take a URL and return an array of\n * alternative URL's that should be checked for precache matches.\n */\nexport const addFetchListener = ({\n  ignoreURLParametersMatching = [/^utm_/],\n  directoryIndex = 'index.html',\n  cleanURLs = true,\n  urlManipulation = null,\n} = {}) => {\n  const cacheName = cacheNames.getPrecacheName();\n\n  addEventListener('fetch', (event) => {\n    const precachedURL = getCacheKeyForURL(event.request.url, {\n      cleanURLs,\n      directoryIndex,\n      ignoreURLParametersMatching,\n      urlManipulation,\n    });\n    if (!precachedURL) {\n      if (process.env.NODE_ENV !== 'production') {\n        logger.debug(`Precaching did not find a match for ` +\n          getFriendlyURL(event.request.url));\n      }\n      return;\n    }\n\n    let responsePromise = caches.open(cacheName).then((cache) => {\n      return cache.match(precachedURL);\n    }).then((cachedResponse) => {\n      if (cachedResponse) {\n        return cachedResponse;\n      }\n\n      // Fall back to the network if we don't have a cached response\n      // (perhaps due to manual cache cleanup).\n      if (process.env.NODE_ENV !== 'production') {\n        logger.warn(`The precached response for ` +\n        `${getFriendlyURL(precachedURL)} in ${cacheName} was not found. ` +\n        `Falling back to the network instead.`);\n      }\n\n      return fetch(precachedURL);\n    });\n\n    if (process.env.NODE_ENV !== 'production') {\n      responsePromise = responsePromise.then((response) => {\n        // Workbox is going to handle the route.\n        // print the routing details to the console.\n        logger.groupCollapsed(`Precaching is responding to: ` +\n          getFriendlyURL(event.request.url));\n        logger.log(`Serving the precached url: ${precachedURL}`);\n\n        logger.groupCollapsed(`View request details here.`);\n        logger.log(event.request);\n        logger.groupEnd();\n\n        logger.groupCollapsed(`View response details here.`);\n        logger.log(response);\n        logger.groupEnd();\n\n        logger.groupEnd();\n        return response;\n      });\n    }\n\n    event.respondWith(responsePromise);\n  });\n};\n","/*\n  Copyright 2019 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 {logger} from 'workbox-core/_private/logger.mjs';\nimport {getOrCreatePrecacheController} from './utils/getOrCreatePrecacheController.mjs';\nimport {precachePlugins} from './utils/precachePlugins.mjs';\nimport './_version.mjs';\n\n\nconst installListener = (event) => {\n  const precacheController = getOrCreatePrecacheController();\n  const plugins = precachePlugins.get();\n\n  event.waitUntil(\n      precacheController.install({event, plugins})\n          .catch((error) => {\n            if (process.env.NODE_ENV !== 'production') {\n              logger.error(`Service worker installation failed. It will ` +\n              `be retried automatically during the next navigation.`);\n            }\n            // Re-throw the error to ensure installation fails.\n            throw error;\n          })\n  );\n};\n\nconst activateListener = (event) => {\n  const precacheController = getOrCreatePrecacheController();\n  const plugins = precachePlugins.get();\n\n  event.waitUntil(precacheController.activate({event, plugins}));\n};\n\n/**\n * Adds items to the precache list, removing any duplicates and\n * stores the files in the\n * [\"precache cache\"]{@link module:workbox-core.cacheNames} when the service\n * worker installs.\n *\n * This method can be called multiple times.\n *\n * Please note: This method **will not** serve any of the cached files for you.\n * It only precaches files. To respond to a network request you call\n * [addRoute()]{@link module:workbox-precaching.addRoute}.\n *\n * If you have a single array of files to precache, you can just call\n * [precacheAndRoute()]{@link module:workbox-precaching.precacheAndRoute}.\n *\n * @param {Array<Object|string>} entries Array of entries to precache.\n *\n * @alias workbox.precaching.precache\n */\nexport const precache = (entries) => {\n  const precacheController = getOrCreatePrecacheController();\n  precacheController.addToCacheList(entries);\n\n  if (entries.length > 0) {\n    // NOTE: these listeners will only be added once (even if the `precache()`\n    // method is called multiple times) because event listeners are implemented\n    // as a set, where each listener must be unique.\n    addEventListener('install', installListener);\n    addEventListener('activate', activateListener);\n  }\n};\n","/*\n  Copyright 2019 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 {precachePlugins} from './utils/precachePlugins.mjs';\nimport './_version.mjs';\n\n\n/**\n * Adds plugins to precaching.\n *\n * @param {Array<Object>} newPlugins\n *\n * @alias workbox.precaching.addPlugins\n */\nconst addPlugins = (newPlugins) => {\n  precachePlugins.add(newPlugins);\n};\n\nexport {addPlugins};\n","/*\n  Copyright 2019 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 {cacheNames} from 'workbox-core/_private/cacheNames.mjs';\nimport {logger} from 'workbox-core/_private/logger.mjs';\nimport {deleteOutdatedCaches} from './utils/deleteOutdatedCaches.mjs';\nimport './_version.mjs';\n\n\n/**\n * Adds an `activate` event listener which will clean up incompatible\n * precaches that were created by older versions of Workbox.\n *\n * @alias workbox.precaching.cleanupOutdatedCaches\n */\nexport const cleanupOutdatedCaches = () => {\n  addEventListener('activate', (event) => {\n    const cacheName = cacheNames.getPrecacheName();\n\n    event.waitUntil(deleteOutdatedCaches(cacheName).then((cachesDeleted) => {\n      if (process.env.NODE_ENV !== 'production') {\n        if (cachesDeleted.length > 0) {\n          logger.log(`The following out-of-date precaches were cleaned up ` +\n              `automatically:`, cachesDeleted);\n        }\n      }\n    }));\n  });\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 '../_version.mjs';\n\nconst SUBSTRING_TO_FIND = '-precache-';\n\n/**\n * Cleans up incompatible precaches that were created by older versions of\n * Workbox, by a service worker registered under the current scope.\n *\n * This is meant to be called as part of the `activate` event.\n *\n * This should be safe to use as long as you don't include `substringToFind`\n * (defaulting to `-precache-`) in your non-precache cache names.\n *\n * @param {string} currentPrecacheName The cache name currently in use for\n * precaching. This cache won't be deleted.\n * @param {string} [substringToFind='-precache-'] Cache names which include this\n * substring will be deleted (excluding `currentPrecacheName`).\n * @return {Array<string>} A list of all the cache names that were deleted.\n *\n * @private\n * @memberof module:workbox-precaching\n */\nconst deleteOutdatedCaches = async (\n  currentPrecacheName,\n  substringToFind = SUBSTRING_TO_FIND) => {\n  const cacheNames = await caches.keys();\n\n  const cacheNamesToDelete = cacheNames.filter((cacheName) => {\n    return cacheName.includes(substringToFind) &&\n           cacheName.includes(self.registration.scope) &&\n           cacheName !== currentPrecacheName;\n  });\n\n  await Promise.all(\n      cacheNamesToDelete.map((cacheName) => caches.delete(cacheName)));\n\n  return cacheNamesToDelete;\n};\n\nexport {deleteOutdatedCaches};\n\n","/*\n  Copyright 2019 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 {getOrCreatePrecacheController}\n  from './utils/getOrCreatePrecacheController.mjs';\nimport './_version.mjs';\n\n\n/**\n * Takes in a URL, and returns the corresponding URL that could be used to\n * lookup the entry in the precache.\n *\n * If a relative URL is provided, the location of the service worker file will\n * be used as the base.\n *\n * For precached entries without revision information, the cache key will be the\n * same as the original URL.\n *\n * For precached entries with revision information, the cache key will be the\n * original URL with the addition of a query parameter used for keeping track of\n * the revision info.\n *\n * @param {string} url The URL whose cache key to look up.\n * @return {string} The cache key that corresponds to that URL.\n *\n * @alias workbox.precaching.getCacheKeyForURL\n */\nexport const getCacheKeyForURL = (url) => {\n  const precacheController = getOrCreatePrecacheController();\n  return precacheController.getCacheKeyForURL(url);\n};\n","/*\n  Copyright 2019 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 {addRoute} from './addRoute.mjs';\nimport {precache} from './precache.mjs';\nimport './_version.mjs';\n\n\n/**\n * This method will add entries to the precache list and add a route to\n * respond to fetch events.\n *\n * This is a convenience method that will call\n * [precache()]{@link module:workbox-precaching.precache} and\n * [addRoute()]{@link module:workbox-precaching.addRoute} in a single call.\n *\n * @param {Array<Object|string>} entries Array of entries to precache.\n * @param {Object} options See\n * [addRoute() options]{@link module:workbox-precaching.addRoute}.\n *\n * @alias workbox.precaching.precacheAndRoute\n */\nexport const precacheAndRoute = (entries, options) => {\n  precache(entries);\n  addRoute(options);\n};\n"],"names":["self","_","e","plugins","precachePlugins","get","add","newPlugins","push","REVISION_SEARCH_PARAM","createCacheKey","entry","WorkboxError","urlObject","URL","location","cacheKey","href","url","revision","originalURL","cacheKeyURL","searchParams","set","PrecacheController","constructor","cacheName","_cacheName","cacheNames","getPrecacheName","_urlsToCacheKeys","Map","addToCacheList","entries","this","has","firstEntry","secondEntry","event","urlsToPrecache","urlsAlreadyPrecached","cache","caches","open","alreadyCachedRequests","keys","alreadyCachedURLs","Set","map","request","values","precacheRequests","_addURLToCache","Promise","all","updatedURLs","notUpdatedURLs","currentlyCachedRequests","expectedCacheKeys","deletedURLs","delete","Request","credentials","cacheWillUpdateCallback","response","fetchWrapper","fetch","plugin","cacheWillUpdate","bind","status","redirected","async","clonedResponse","clone","bodyPromise","resolve","body","blob","Response","headers","statusText","cleanRedirect","cacheWrapper","put","matchOptions","ignoreSearch","getURLsToCacheKeys","getCachedURLs","getCacheKeyForURL","precacheController","getOrCreatePrecacheController","options","urlsToCacheKeys","possibleURL","ignoreURLParametersMatching","directoryIndex","cleanURLs","urlManipulation","hash","urlWithoutIgnoredParams","paramName","some","regExp","test","removeIgnoredSearchParams","pathname","endsWith","directoryURL","cleanURL","additionalURLs","urlToAttempt","generateURLVariations","possibleCacheKey","listenerAdded","addRoute","addEventListener","precachedURL","responsePromise","then","match","cachedResponse","respondWith","addFetchListener","installListener","waitUntil","install","catch","error","activateListener","activate","precache","length","currentPrecacheName","substringToFind","cacheNamesToDelete","filter","includes","registration","scope","deleteOutdatedCaches","cachesDeleted"],"mappings":"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"}

data/lib/vendor/workbox-v4.3.1/workbox-range-requests.dev.js

@@ -1,268 +0,0 @@
-this.workbox = this.workbox || {};
-this.workbox.rangeRequests = (function (exports, WorkboxError_mjs, assert_mjs, logger_mjs) {
-  'use strict';
-
-  try {
-    self['workbox:range-requests: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.
-  */
-  /**
-   * @param {Blob} blob A source blob.
-   * @param {number|null} start The offset to use as the start of the
-   * slice.
-   * @param {number|null} end The offset to use as the end of the slice.
-   * @return {Object} An object with `start` and `end` properties, reflecting
-   * the effective boundaries to use given the size of the blob.
-   *
-   * @private
-   */
-
-  function calculateEffectiveBoundaries(blob, start, end) {
-    {
-      assert_mjs.assert.isInstance(blob, Blob, {
-        moduleName: 'workbox-range-requests',
-        funcName: 'calculateEffectiveBoundaries',
-        paramName: 'blob'
-      });
-    }
-
-    const blobSize = blob.size;
-
-    if (end > blobSize || start < 0) {
-      throw new WorkboxError_mjs.WorkboxError('range-not-satisfiable', {
-        size: blobSize,
-        end,
-        start
-      });
-    }
-
-    let effectiveStart;
-    let effectiveEnd;
-
-    if (start === null) {
-      effectiveStart = blobSize - end;
-      effectiveEnd = blobSize;
-    } else if (end === null) {
-      effectiveStart = start;
-      effectiveEnd = blobSize;
-    } else {
-      effectiveStart = start; // Range values are inclusive, so add 1 to the value.
-
-      effectiveEnd = end + 1;
-    }
-
-    return {
-      start: effectiveStart,
-      end: effectiveEnd
-    };
-  }
-
-  /*
-    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.
-  */
-  /**
-   * @param {string} rangeHeader A Range: header value.
-   * @return {Object} An object with `start` and `end` properties, reflecting
-   * the parsed value of the Range: header. If either the `start` or `end` are
-   * omitted, then `null` will be returned.
-   *
-   * @private
-   */
-
-  function parseRangeHeader(rangeHeader) {
-    {
-      assert_mjs.assert.isType(rangeHeader, 'string', {
-        moduleName: 'workbox-range-requests',
-        funcName: 'parseRangeHeader',
-        paramName: 'rangeHeader'
-      });
-    }
-
-    const normalizedRangeHeader = rangeHeader.trim().toLowerCase();
-
-    if (!normalizedRangeHeader.startsWith('bytes=')) {
-      throw new WorkboxError_mjs.WorkboxError('unit-must-be-bytes', {
-        normalizedRangeHeader
-      });
-    } // Specifying multiple ranges separate by commas is valid syntax, but this
-    // library only attempts to handle a single, contiguous sequence of bytes.
-    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Range#Syntax
-
-
-    if (normalizedRangeHeader.includes(',')) {
-      throw new WorkboxError_mjs.WorkboxError('single-range-only', {
-        normalizedRangeHeader
-      });
-    }
-
-    const rangeParts = /(\d*)-(\d*)/.exec(normalizedRangeHeader); // We need either at least one of the start or end values.
-
-    if (rangeParts === null || !(rangeParts[1] || rangeParts[2])) {
-      throw new WorkboxError_mjs.WorkboxError('invalid-range-values', {
-        normalizedRangeHeader
-      });
-    }
-
-    return {
-      start: rangeParts[1] === '' ? null : Number(rangeParts[1]),
-      end: rangeParts[2] === '' ? null : Number(rangeParts[2])
-    };
-  }
-
-  /*
-    Copyright 2018 Google LLC
-
-    Use of this source code is governed by an MIT-style
-    license that can be found in the LICENSE file or at
-    https://opensource.org/licenses/MIT.
-  */
-  /**
-   * Given a `Request` and `Response` objects as input, this will return a
-   * promise for a new `Response`.
-   *
-   * If the original `Response` already contains partial content (i.e. it has
-   * a status of 206), then this assumes it already fulfills the `Range:`
-   * requirements, and will return it as-is.
-   *
-   * @param {Request} request A request, which should contain a Range:
-   * header.
-   * @param {Response} originalResponse A response.
-   * @return {Promise<Response>} Either a `206 Partial Content` response, with
-   * the response body set to the slice of content specified by the request's
-   * `Range:` header, or a `416 Range Not Satisfiable` response if the
-   * conditions of the `Range:` header can't be met.
-   *
-   * @memberof workbox.rangeRequests
-   */
-
-  async function createPartialResponse(request, originalResponse) {
-    try {
-      {
-        assert_mjs.assert.isInstance(request, Request, {
-          moduleName: 'workbox-range-requests',
-          funcName: 'createPartialResponse',
-          paramName: 'request'
-        });
-        assert_mjs.assert.isInstance(originalResponse, Response, {
-          moduleName: 'workbox-range-requests',
-          funcName: 'createPartialResponse',
-          paramName: 'originalResponse'
-        });
-      }
-
-      if (originalResponse.status === 206) {
-        // If we already have a 206, then just pass it through as-is;
-        // see https://github.com/GoogleChrome/workbox/issues/1720
-        return originalResponse;
-      }
-
-      const rangeHeader = request.headers.get('range');
-
-      if (!rangeHeader) {
-        throw new WorkboxError_mjs.WorkboxError('no-range-header');
-      }
-
-      const boundaries = parseRangeHeader(rangeHeader);
-      const originalBlob = await originalResponse.blob();
-      const effectiveBoundaries = calculateEffectiveBoundaries(originalBlob, boundaries.start, boundaries.end);
-      const slicedBlob = originalBlob.slice(effectiveBoundaries.start, effectiveBoundaries.end);
-      const slicedBlobSize = slicedBlob.size;
-      const slicedResponse = new Response(slicedBlob, {
-        // Status code 206 is for a Partial Content response.
-        // See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/206
-        status: 206,
-        statusText: 'Partial Content',
-        headers: originalResponse.headers
-      });
-      slicedResponse.headers.set('Content-Length', slicedBlobSize);
-      slicedResponse.headers.set('Content-Range', `bytes ${effectiveBoundaries.start}-${effectiveBoundaries.end - 1}/` + originalBlob.size);
-      return slicedResponse;
-    } catch (error) {
-      {
-        logger_mjs.logger.warn(`Unable to construct a partial response; returning a ` + `416 Range Not Satisfiable response instead.`);
-        logger_mjs.logger.groupCollapsed(`View details here.`);
-        logger_mjs.logger.log(error);
-        logger_mjs.logger.log(request);
-        logger_mjs.logger.log(originalResponse);
-        logger_mjs.logger.groupEnd();
-      }
-
-      return new Response('', {
-        status: 416,
-        statusText: 'Range Not Satisfiable'
-      });
-    }
-  }
-
-  /*
-    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 range request plugin makes it easy for a request with a 'Range' header to
-   * be fulfilled by a cached response.
-   *
-   * It does this by intercepting the `cachedResponseWillBeUsed` plugin callback
-   * and returning the appropriate subset of the cached response body.
-   *
-   * @memberof workbox.rangeRequests
-   */
-
-  class Plugin {
-    /**
-     * @param {Object} options
-     * @param {Request} options.request The original request, which may or may not
-     * contain a Range: header.
-     * @param {Response} options.cachedResponse The complete cached response.
-     * @return {Promise<Response>} If request contains a 'Range' header, then a
-     * new response with status 206 whose body is a subset of `cachedResponse` is
-     * returned. Otherwise, `cachedResponse` is returned as-is.
-     *
-     * @private
-     */
-    async cachedResponseWillBeUsed({
-      request,
-      cachedResponse
-    }) {
-      // Only return a sliced response if there's something valid in the cache,
-      // and there's a Range: header in the request.
-      if (cachedResponse && request.headers.has('range')) {
-        return await createPartialResponse(request, cachedResponse);
-      } // If there was no Range: header, or if cachedResponse wasn't valid, just
-      // pass it through as-is.
-
-
-      return cachedResponse;
-    }
-
-  }
-
-  /*
-    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.createPartialResponse = createPartialResponse;
-  exports.Plugin = Plugin;
-
-  return exports;
-
-}({}, workbox.core._private, workbox.core._private, workbox.core._private));
-//# sourceMappingURL=workbox-range-requests.dev.js.map

data/lib/vendor/workbox-v4.3.1/workbox-range-requests.dev.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"workbox-range-requests.dev.js","sources":["../_version.mjs","../utils/calculateEffectiveBoundaries.mjs","../utils/parseRangeHeader.mjs","../createPartialResponse.mjs","../Plugin.mjs","../index.mjs"],"sourcesContent":["try{self['workbox:range-requests: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';\n\nimport '../_version.mjs';\n\n/**\n * @param {Blob} blob A source blob.\n * @param {number|null} start The offset to use as the start of the\n * slice.\n * @param {number|null} end The offset to use as the end of the slice.\n * @return {Object} An object with `start` and `end` properties, reflecting\n * the effective boundaries to use given the size of the blob.\n *\n * @private\n */\nfunction calculateEffectiveBoundaries(blob, start, end) {\n  if (process.env.NODE_ENV !== 'production') {\n    assert.isInstance(blob, Blob, {\n      moduleName: 'workbox-range-requests',\n      funcName: 'calculateEffectiveBoundaries',\n      paramName: 'blob',\n    });\n  }\n\n  const blobSize = blob.size;\n\n  if (end > blobSize || start < 0) {\n    throw new WorkboxError('range-not-satisfiable', {\n      size: blobSize,\n      end,\n      start,\n    });\n  }\n\n  let effectiveStart;\n  let effectiveEnd;\n\n  if (start === null) {\n    effectiveStart = blobSize - end;\n    effectiveEnd = blobSize;\n  } else if (end === null) {\n    effectiveStart = start;\n    effectiveEnd = blobSize;\n  } else {\n    effectiveStart = start;\n    // Range values are inclusive, so add 1 to the value.\n    effectiveEnd = end + 1;\n  }\n\n  return {\n    start: effectiveStart,\n    end: effectiveEnd,\n  };\n}\n\nexport {calculateEffectiveBoundaries};\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 {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';\nimport {assert} from 'workbox-core/_private/assert.mjs';\n\nimport '../_version.mjs';\n\n/**\n * @param {string} rangeHeader A Range: header value.\n * @return {Object} An object with `start` and `end` properties, reflecting\n * the parsed value of the Range: header. If either the `start` or `end` are\n * omitted, then `null` will be returned.\n *\n * @private\n */\nfunction parseRangeHeader(rangeHeader) {\n  if (process.env.NODE_ENV !== 'production') {\n    assert.isType(rangeHeader, 'string', {\n      moduleName: 'workbox-range-requests',\n      funcName: 'parseRangeHeader',\n      paramName: 'rangeHeader',\n    });\n  }\n\n  const normalizedRangeHeader = rangeHeader.trim().toLowerCase();\n  if (!normalizedRangeHeader.startsWith('bytes=')) {\n    throw new WorkboxError('unit-must-be-bytes', {normalizedRangeHeader});\n  }\n\n  // Specifying multiple ranges separate by commas is valid syntax, but this\n  // library only attempts to handle a single, contiguous sequence of bytes.\n  // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Range#Syntax\n  if (normalizedRangeHeader.includes(',')) {\n    throw new WorkboxError('single-range-only', {normalizedRangeHeader});\n  }\n\n  const rangeParts = /(\\d*)-(\\d*)/.exec(normalizedRangeHeader);\n  // We need either at least one of the start or end values.\n  if (rangeParts === null || !(rangeParts[1] || rangeParts[2])) {\n    throw new WorkboxError('invalid-range-values', {normalizedRangeHeader});\n  }\n\n  return {\n    start: rangeParts[1] === '' ? null : Number(rangeParts[1]),\n    end: rangeParts[2] === '' ? null : Number(rangeParts[2]),\n  };\n}\n\nexport {parseRangeHeader};\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 {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';\nimport {assert} from 'workbox-core/_private/assert.mjs';\nimport {logger} from 'workbox-core/_private/logger.mjs';\n\nimport {calculateEffectiveBoundaries} from\n  './utils/calculateEffectiveBoundaries.mjs';\nimport {parseRangeHeader} from './utils/parseRangeHeader.mjs';\n\nimport './_version.mjs';\n\n/**\n * Given a `Request` and `Response` objects as input, this will return a\n * promise for a new `Response`.\n *\n * If the original `Response` already contains partial content (i.e. it has\n * a status of 206), then this assumes it already fulfills the `Range:`\n * requirements, and will return it as-is.\n *\n * @param {Request} request A request, which should contain a Range:\n * header.\n * @param {Response} originalResponse A response.\n * @return {Promise<Response>} Either a `206 Partial Content` response, with\n * the response body set to the slice of content specified by the request's\n * `Range:` header, or a `416 Range Not Satisfiable` response if the\n * conditions of the `Range:` header can't be met.\n *\n * @memberof workbox.rangeRequests\n */\nasync function createPartialResponse(request, originalResponse) {\n  try {\n    if (process.env.NODE_ENV !== 'production') {\n      assert.isInstance(request, Request, {\n        moduleName: 'workbox-range-requests',\n        funcName: 'createPartialResponse',\n        paramName: 'request',\n      });\n\n      assert.isInstance(originalResponse, Response, {\n        moduleName: 'workbox-range-requests',\n        funcName: 'createPartialResponse',\n        paramName: 'originalResponse',\n      });\n    }\n\n    if (originalResponse.status === 206) {\n      // If we already have a 206, then just pass it through as-is;\n      // see https://github.com/GoogleChrome/workbox/issues/1720\n      return originalResponse;\n    }\n\n    const rangeHeader = request.headers.get('range');\n    if (!rangeHeader) {\n      throw new WorkboxError('no-range-header');\n    }\n\n    const boundaries = parseRangeHeader(rangeHeader);\n    const originalBlob = await originalResponse.blob();\n\n    const effectiveBoundaries = calculateEffectiveBoundaries(\n        originalBlob, boundaries.start, boundaries.end);\n\n    const slicedBlob = originalBlob.slice(effectiveBoundaries.start,\n        effectiveBoundaries.end);\n    const slicedBlobSize = slicedBlob.size;\n\n    const slicedResponse = new Response(slicedBlob, {\n      // Status code 206 is for a Partial Content response.\n      // See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/206\n      status: 206,\n      statusText: 'Partial Content',\n      headers: originalResponse.headers,\n    });\n\n    slicedResponse.headers.set('Content-Length', slicedBlobSize);\n    slicedResponse.headers.set('Content-Range',\n        `bytes ${effectiveBoundaries.start}-${effectiveBoundaries.end - 1}/` +\n      originalBlob.size);\n\n    return slicedResponse;\n  } catch (error) {\n    if (process.env.NODE_ENV !== 'production') {\n      logger.warn(`Unable to construct a partial response; returning a ` +\n        `416 Range Not Satisfiable response instead.`);\n      logger.groupCollapsed(`View details here.`);\n      logger.log(error);\n      logger.log(request);\n      logger.log(originalResponse);\n      logger.groupEnd();\n    }\n\n    return new Response('', {\n      status: 416,\n      statusText: 'Range Not Satisfiable',\n    });\n  }\n}\n\nexport {createPartialResponse};\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 {createPartialResponse} from './createPartialResponse.mjs';\n\nimport './_version.mjs';\n\n/**\n * The range request plugin makes it easy for a request with a 'Range' header to\n * be fulfilled by a cached response.\n *\n * It does this by intercepting the `cachedResponseWillBeUsed` plugin callback\n * and returning the appropriate subset of the cached response body.\n *\n * @memberof workbox.rangeRequests\n */\nclass Plugin {\n  /**\n   * @param {Object} options\n   * @param {Request} options.request The original request, which may or may not\n   * contain a Range: header.\n   * @param {Response} options.cachedResponse The complete cached response.\n   * @return {Promise<Response>} If request contains a 'Range' header, then a\n   * new response with status 206 whose body is a subset of `cachedResponse` is\n   * returned. Otherwise, `cachedResponse` is returned as-is.\n   *\n   * @private\n   */\n  async cachedResponseWillBeUsed({request, cachedResponse}) {\n    // Only return a sliced response if there's something valid in the cache,\n    // and there's a Range: header in the request.\n    if (cachedResponse && request.headers.has('range')) {\n      return await createPartialResponse(request, cachedResponse);\n    }\n\n    // If there was no Range: header, or if cachedResponse wasn't valid, just\n    // pass it through as-is.\n    return cachedResponse;\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 {createPartialResponse} from './createPartialResponse.mjs';\nimport {Plugin} from './Plugin.mjs';\nimport './_version.mjs';\n\n\n/**\n * @namespace workbox.rangeRequests\n */\n\nexport {\n  createPartialResponse,\n  Plugin,\n};\n"],"names":["self","_","e","calculateEffectiveBoundaries","blob","start","end","assert","isInstance","Blob","moduleName","funcName","paramName","blobSize","size","WorkboxError","effectiveStart","effectiveEnd","parseRangeHeader","rangeHeader","isType","normalizedRangeHeader","trim","toLowerCase","startsWith","includes","rangeParts","exec","Number","createPartialResponse","request","originalResponse","Request","Response","status","headers","get","boundaries","originalBlob","effectiveBoundaries","slicedBlob","slice","slicedBlobSize","slicedResponse","statusText","set","error","logger","warn","groupCollapsed","log","groupEnd","Plugin","cachedResponseWillBeUsed","cachedResponse","has"],"mappings":"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"}

data/lib/vendor/workbox-v4.3.1/workbox-range-requests.prod.js

@@ -1,2 +0,0 @@
-this.workbox=this.workbox||{},this.workbox.rangeRequests=function(e,n){"use strict";try{self["workbox:range-requests:4.3.1"]&&_()}catch(e){}async function t(e,t){try{if(206===t.status)return t;const s=e.headers.get("range");if(!s)throw new n.WorkboxError("no-range-header");const a=function(e){const t=e.trim().toLowerCase();if(!t.startsWith("bytes="))throw new n.WorkboxError("unit-must-be-bytes",{normalizedRangeHeader:t});if(t.includes(","))throw new n.WorkboxError("single-range-only",{normalizedRangeHeader:t});const s=/(\d*)-(\d*)/.exec(t);if(null===s||!s[1]&&!s[2])throw new n.WorkboxError("invalid-range-values",{normalizedRangeHeader:t});return{start:""===s[1]?null:Number(s[1]),end:""===s[2]?null:Number(s[2])}}(s),r=await t.blob(),i=function(e,t,s){const a=e.size;if(s>a||t<0)throw new n.WorkboxError("range-not-satisfiable",{size:a,end:s,start:t});let r,i;return null===t?(r=a-s,i=a):null===s?(r=t,i=a):(r=t,i=s+1),{start:r,end:i}}(r,a.start,a.end),o=r.slice(i.start,i.end),u=o.size,l=new Response(o,{status:206,statusText:"Partial Content",headers:t.headers});return l.headers.set("Content-Length",u),l.headers.set("Content-Range",`bytes ${i.start}-${i.end-1}/`+r.size),l}catch(e){return new Response("",{status:416,statusText:"Range Not Satisfiable"})}}return e.createPartialResponse=t,e.Plugin=class{async cachedResponseWillBeUsed({request:e,cachedResponse:n}){return n&&e.headers.has("range")?await t(e,n):n}},e}({},workbox.core._private);
-//# sourceMappingURL=workbox-range-requests.prod.js.map

data/lib/vendor/workbox-v4.3.1/workbox-range-requests.prod.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"workbox-range-requests.prod.js","sources":["../_version.mjs","../createPartialResponse.mjs","../utils/parseRangeHeader.mjs","../utils/calculateEffectiveBoundaries.mjs","../Plugin.mjs"],"sourcesContent":["try{self['workbox:range-requests: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 {logger} from 'workbox-core/_private/logger.mjs';\n\nimport {calculateEffectiveBoundaries} from\n  './utils/calculateEffectiveBoundaries.mjs';\nimport {parseRangeHeader} from './utils/parseRangeHeader.mjs';\n\nimport './_version.mjs';\n\n/**\n * Given a `Request` and `Response` objects as input, this will return a\n * promise for a new `Response`.\n *\n * If the original `Response` already contains partial content (i.e. it has\n * a status of 206), then this assumes it already fulfills the `Range:`\n * requirements, and will return it as-is.\n *\n * @param {Request} request A request, which should contain a Range:\n * header.\n * @param {Response} originalResponse A response.\n * @return {Promise<Response>} Either a `206 Partial Content` response, with\n * the response body set to the slice of content specified by the request's\n * `Range:` header, or a `416 Range Not Satisfiable` response if the\n * conditions of the `Range:` header can't be met.\n *\n * @memberof workbox.rangeRequests\n */\nasync function createPartialResponse(request, originalResponse) {\n  try {\n    if (process.env.NODE_ENV !== 'production') {\n      assert.isInstance(request, Request, {\n        moduleName: 'workbox-range-requests',\n        funcName: 'createPartialResponse',\n        paramName: 'request',\n      });\n\n      assert.isInstance(originalResponse, Response, {\n        moduleName: 'workbox-range-requests',\n        funcName: 'createPartialResponse',\n        paramName: 'originalResponse',\n      });\n    }\n\n    if (originalResponse.status === 206) {\n      // If we already have a 206, then just pass it through as-is;\n      // see https://github.com/GoogleChrome/workbox/issues/1720\n      return originalResponse;\n    }\n\n    const rangeHeader = request.headers.get('range');\n    if (!rangeHeader) {\n      throw new WorkboxError('no-range-header');\n    }\n\n    const boundaries = parseRangeHeader(rangeHeader);\n    const originalBlob = await originalResponse.blob();\n\n    const effectiveBoundaries = calculateEffectiveBoundaries(\n        originalBlob, boundaries.start, boundaries.end);\n\n    const slicedBlob = originalBlob.slice(effectiveBoundaries.start,\n        effectiveBoundaries.end);\n    const slicedBlobSize = slicedBlob.size;\n\n    const slicedResponse = new Response(slicedBlob, {\n      // Status code 206 is for a Partial Content response.\n      // See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/206\n      status: 206,\n      statusText: 'Partial Content',\n      headers: originalResponse.headers,\n    });\n\n    slicedResponse.headers.set('Content-Length', slicedBlobSize);\n    slicedResponse.headers.set('Content-Range',\n        `bytes ${effectiveBoundaries.start}-${effectiveBoundaries.end - 1}/` +\n      originalBlob.size);\n\n    return slicedResponse;\n  } catch (error) {\n    if (process.env.NODE_ENV !== 'production') {\n      logger.warn(`Unable to construct a partial response; returning a ` +\n        `416 Range Not Satisfiable response instead.`);\n      logger.groupCollapsed(`View details here.`);\n      logger.log(error);\n      logger.log(request);\n      logger.log(originalResponse);\n      logger.groupEnd();\n    }\n\n    return new Response('', {\n      status: 416,\n      statusText: 'Range Not Satisfiable',\n    });\n  }\n}\n\nexport {createPartialResponse};\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 {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';\nimport {assert} from 'workbox-core/_private/assert.mjs';\n\nimport '../_version.mjs';\n\n/**\n * @param {string} rangeHeader A Range: header value.\n * @return {Object} An object with `start` and `end` properties, reflecting\n * the parsed value of the Range: header. If either the `start` or `end` are\n * omitted, then `null` will be returned.\n *\n * @private\n */\nfunction parseRangeHeader(rangeHeader) {\n  if (process.env.NODE_ENV !== 'production') {\n    assert.isType(rangeHeader, 'string', {\n      moduleName: 'workbox-range-requests',\n      funcName: 'parseRangeHeader',\n      paramName: 'rangeHeader',\n    });\n  }\n\n  const normalizedRangeHeader = rangeHeader.trim().toLowerCase();\n  if (!normalizedRangeHeader.startsWith('bytes=')) {\n    throw new WorkboxError('unit-must-be-bytes', {normalizedRangeHeader});\n  }\n\n  // Specifying multiple ranges separate by commas is valid syntax, but this\n  // library only attempts to handle a single, contiguous sequence of bytes.\n  // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Range#Syntax\n  if (normalizedRangeHeader.includes(',')) {\n    throw new WorkboxError('single-range-only', {normalizedRangeHeader});\n  }\n\n  const rangeParts = /(\\d*)-(\\d*)/.exec(normalizedRangeHeader);\n  // We need either at least one of the start or end values.\n  if (rangeParts === null || !(rangeParts[1] || rangeParts[2])) {\n    throw new WorkboxError('invalid-range-values', {normalizedRangeHeader});\n  }\n\n  return {\n    start: rangeParts[1] === '' ? null : Number(rangeParts[1]),\n    end: rangeParts[2] === '' ? null : Number(rangeParts[2]),\n  };\n}\n\nexport {parseRangeHeader};\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 {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs';\nimport {assert} from 'workbox-core/_private/assert.mjs';\n\nimport '../_version.mjs';\n\n/**\n * @param {Blob} blob A source blob.\n * @param {number|null} start The offset to use as the start of the\n * slice.\n * @param {number|null} end The offset to use as the end of the slice.\n * @return {Object} An object with `start` and `end` properties, reflecting\n * the effective boundaries to use given the size of the blob.\n *\n * @private\n */\nfunction calculateEffectiveBoundaries(blob, start, end) {\n  if (process.env.NODE_ENV !== 'production') {\n    assert.isInstance(blob, Blob, {\n      moduleName: 'workbox-range-requests',\n      funcName: 'calculateEffectiveBoundaries',\n      paramName: 'blob',\n    });\n  }\n\n  const blobSize = blob.size;\n\n  if (end > blobSize || start < 0) {\n    throw new WorkboxError('range-not-satisfiable', {\n      size: blobSize,\n      end,\n      start,\n    });\n  }\n\n  let effectiveStart;\n  let effectiveEnd;\n\n  if (start === null) {\n    effectiveStart = blobSize - end;\n    effectiveEnd = blobSize;\n  } else if (end === null) {\n    effectiveStart = start;\n    effectiveEnd = blobSize;\n  } else {\n    effectiveStart = start;\n    // Range values are inclusive, so add 1 to the value.\n    effectiveEnd = end + 1;\n  }\n\n  return {\n    start: effectiveStart,\n    end: effectiveEnd,\n  };\n}\n\nexport {calculateEffectiveBoundaries};\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 {createPartialResponse} from './createPartialResponse.mjs';\n\nimport './_version.mjs';\n\n/**\n * The range request plugin makes it easy for a request with a 'Range' header to\n * be fulfilled by a cached response.\n *\n * It does this by intercepting the `cachedResponseWillBeUsed` plugin callback\n * and returning the appropriate subset of the cached response body.\n *\n * @memberof workbox.rangeRequests\n */\nclass Plugin {\n  /**\n   * @param {Object} options\n   * @param {Request} options.request The original request, which may or may not\n   * contain a Range: header.\n   * @param {Response} options.cachedResponse The complete cached response.\n   * @return {Promise<Response>} If request contains a 'Range' header, then a\n   * new response with status 206 whose body is a subset of `cachedResponse` is\n   * returned. Otherwise, `cachedResponse` is returned as-is.\n   *\n   * @private\n   */\n  async cachedResponseWillBeUsed({request, cachedResponse}) {\n    // Only return a sliced response if there's something valid in the cache,\n    // and there's a Range: header in the request.\n    if (cachedResponse && request.headers.has('range')) {\n      return await createPartialResponse(request, cachedResponse);\n    }\n\n    // If there was no Range: header, or if cachedResponse wasn't valid, just\n    // pass it through as-is.\n    return cachedResponse;\n  }\n}\n\nexport {Plugin};\n"],"names":["self","_","e","async","createPartialResponse","request","originalResponse","status","rangeHeader","headers","get","WorkboxError","boundaries","normalizedRangeHeader","trim","toLowerCase","startsWith","includes","rangeParts","exec","start","Number","end","parseRangeHeader","originalBlob","blob","effectiveBoundaries","blobSize","size","effectiveStart","effectiveEnd","calculateEffectiveBoundaries","slicedBlob","slice","slicedBlobSize","slicedResponse","Response","statusText","set","error","cachedResponse","has"],"mappings":"oFAAA,IAAIA,KAAK,iCAAiCC,IAAI,MAAMC,ICoCpDC,eAAeC,EAAsBC,EAASC,UAgBV,MAA5BA,EAAiBC,cAGZD,QAGHE,EAAcH,EAAQI,QAAQC,IAAI,aACnCF,QACG,IAAIG,eAAa,yBAGnBC,EC1CV,SAA0BJ,SASlBK,EAAwBL,EAAYM,OAAOC,kBAC5CF,EAAsBG,WAAW,gBAC9B,IAAIL,eAAa,qBAAsB,CAACE,sBAAAA,OAM5CA,EAAsBI,SAAS,WAC3B,IAAIN,eAAa,oBAAqB,CAACE,sBAAAA,UAGzCK,EAAa,cAAcC,KAAKN,MAEnB,OAAfK,IAAyBA,EAAW,KAAMA,EAAW,SACjD,IAAIP,eAAa,uBAAwB,CAACE,sBAAAA,UAG3C,CACLO,MAAyB,KAAlBF,EAAW,GAAY,KAAOG,OAAOH,EAAW,IACvDI,IAAuB,KAAlBJ,EAAW,GAAY,KAAOG,OAAOH,EAAW,KDalCK,CAAiBf,GAC9BgB,QAAqBlB,EAAiBmB,OAEtCC,EE3CV,SAAsCD,EAAML,EAAOE,SAS3CK,EAAWF,EAAKG,QAElBN,EAAMK,GAAYP,EAAQ,QACtB,IAAIT,eAAa,wBAAyB,CAC9CiB,KAAMD,EACNL,IAAAA,EACAF,MAAAA,QAIAS,EACAC,SAEU,OAAVV,GACFS,EAAiBF,EAAWL,EAC5BQ,EAAeH,GACE,OAARL,GACTO,EAAiBT,EACjBU,EAAeH,IAEfE,EAAiBT,EAEjBU,EAAeR,EAAM,GAGhB,CACLF,MAAOS,EACPP,IAAKQ,GFOuBC,CACxBP,EAAcZ,EAAWQ,MAAOR,EAAWU,KAEzCU,EAAaR,EAAaS,MAAMP,EAAoBN,MACtDM,EAAoBJ,KAClBY,EAAiBF,EAAWJ,KAE5BO,EAAiB,IAAIC,SAASJ,EAAY,CAG9CzB,OAAQ,IACR8B,WAAY,kBACZ5B,QAASH,EAAiBG,iBAG5B0B,EAAe1B,QAAQ6B,IAAI,iBAAkBJ,GAC7CC,EAAe1B,QAAQ6B,IAAI,yBACdZ,EAAoBN,SAASM,EAAoBJ,IAAM,KAClEE,EAAaI,MAERO,EACP,MAAOI,UAWA,IAAIH,SAAS,GAAI,CACtB7B,OAAQ,IACR8B,WAAY,qEG/ElB,sCAYiChC,QAACA,EAADmC,eAAUA,WAGnCA,GAAkBnC,EAAQI,QAAQgC,IAAI,eAC3BrC,EAAsBC,EAASmC,GAKvCA"}

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

@@ -1,1020 +0,0 @@
-this.workbox = this.workbox || {};
-this.workbox.routing = (function (exports, assert_mjs, logger_mjs, cacheNames_mjs, WorkboxError_mjs, getFriendlyURL_mjs) {
-  'use strict';
-
-  try {
-    self['workbox:routing: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.
-  */
-  /**
-   * The default HTTP method, 'GET', used when there's no specific method
-   * configured for a route.
-   *
-   * @type {string}
-   *
-   * @private
-   */
-
-  const defaultMethod = 'GET';
-  /**
-   * The list of valid HTTP methods associated with requests that could be routed.
-   *
-   * @type {Array<string>}
-   *
-   * @private
-   */
-
-  const validMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT'];
-
-  /*
-    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.
-  */
-  /**
-   * @param {function()|Object} handler Either a function, or an object with a
-   * 'handle' method.
-   * @return {Object} An object with a handle method.
-   *
-   * @private
-   */
-
-  const normalizeHandler = handler => {
-    if (handler && typeof handler === 'object') {
-      {
-        assert_mjs.assert.hasMethod(handler, 'handle', {
-          moduleName: 'workbox-routing',
-          className: 'Route',
-          funcName: 'constructor',
-          paramName: 'handler'
-        });
-      }
-
-      return handler;
-    } else {
-      {
-        assert_mjs.assert.isType(handler, 'function', {
-          moduleName: 'workbox-routing',
-          className: 'Route',
-          funcName: 'constructor',
-          paramName: 'handler'
-        });
-      }
-
-      return {
-        handle: handler
-      };
-    }
-  };
-
-  /*
-    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 `Route` consists of a pair of callback functions, "match" and "handler".
-   * The "match" callback determine if a route should be used to "handle" a
-   * request by returning a non-falsy value if it can. The "handler" callback
-   * is called when there is a match and should return a Promise that resolves
-   * to a `Response`.
-   *
-   * @memberof workbox.routing
-   */
-
-  class Route {
-    /**
-     * Constructor for Route class.
-     *
-     * @param {workbox.routing.Route~matchCallback} match
-     * A callback function that determines whether the route matches a given
-     * `fetch` event by returning a non-falsy value.
-     * @param {workbox.routing.Route~handlerCallback} handler A callback
-     * function that returns a Promise resolving to a Response.
-     * @param {string} [method='GET'] The HTTP method to match the Route
-     * against.
-     */
-    constructor(match, handler, method) {
-      {
-        assert_mjs.assert.isType(match, 'function', {
-          moduleName: 'workbox-routing',
-          className: 'Route',
-          funcName: 'constructor',
-          paramName: 'match'
-        });
-
-        if (method) {
-          assert_mjs.assert.isOneOf(method, validMethods, {
-            paramName: 'method'
-          });
-        }
-      } // These values are referenced directly by Router so cannot be
-      // altered by minifification.
-
-
-      this.handler = normalizeHandler(handler);
-      this.match = match;
-      this.method = method || defaultMethod;
-    }
-
-  }
-
-  /*
-    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.
-  */
-  /**
-   * NavigationRoute makes it easy to create a [Route]{@link
-   * workbox.routing.Route} that matches for browser
-   * [navigation requests]{@link https://developers.google.com/web/fundamentals/primers/service-workers/high-performance-loading#first_what_are_navigation_requests}.
-   *
-   * It will only match incoming Requests whose
-   * [`mode`]{@link https://fetch.spec.whatwg.org/#concept-request-mode}
-   * is set to `navigate`.
-   *
-   * You can optionally only apply this route to a subset of navigation requests
-   * by using one or both of the `blacklist` and `whitelist` parameters.
-   *
-   * @memberof workbox.routing
-   * @extends workbox.routing.Route
-   */
-
-  class NavigationRoute extends Route {
-    /**
-     * If both `blacklist` and `whiltelist` are provided, the `blacklist` will
-     * take precedence and the request will not match this route.
-     *
-     * The regular expressions in `whitelist` and `blacklist`
-     * are matched against the concatenated
-     * [`pathname`]{@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/pathname}
-     * and [`search`]{@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/search}
-     * portions of the requested URL.
-     *
-     * @param {workbox.routing.Route~handlerCallback} handler A callback
-     * function that returns a Promise resulting in a Response.
-     * @param {Object} options
-     * @param {Array<RegExp>} [options.blacklist] If any of these patterns match,
-     * the route will not handle the request (even if a whitelist RegExp matches).
-     * @param {Array<RegExp>} [options.whitelist=[/./]] If any of these patterns
-     * match the URL's pathname and search parameter, the route will handle the
-     * request (assuming the blacklist doesn't match).
-     */
-    constructor(handler, {
-      whitelist = [/./],
-      blacklist = []
-    } = {}) {
-      {
-        assert_mjs.assert.isArrayOfClass(whitelist, RegExp, {
-          moduleName: 'workbox-routing',
-          className: 'NavigationRoute',
-          funcName: 'constructor',
-          paramName: 'options.whitelist'
-        });
-        assert_mjs.assert.isArrayOfClass(blacklist, RegExp, {
-          moduleName: 'workbox-routing',
-          className: 'NavigationRoute',
-          funcName: 'constructor',
-          paramName: 'options.blacklist'
-        });
-      }
-
-      super(options => this._match(options), handler);
-      this._whitelist = whitelist;
-      this._blacklist = blacklist;
-    }
-    /**
-     * Routes match handler.
-     *
-     * @param {Object} options
-     * @param {URL} options.url
-     * @param {Request} options.request
-     * @return {boolean}
-     *
-     * @private
-     */
-
-
-    _match({
-      url,
-      request
-    }) {
-      if (request.mode !== 'navigate') {
-        return false;
-      }
-
-      const pathnameAndSearch = url.pathname + url.search;
-
-      for (const regExp of this._blacklist) {
-        if (regExp.test(pathnameAndSearch)) {
-          {
-            logger_mjs.logger.log(`The navigation route is not being used, since the ` + `URL matches this blacklist pattern: ${regExp}`);
-          }
-
-          return false;
-        }
-      }
-
-      if (this._whitelist.some(regExp => regExp.test(pathnameAndSearch))) {
-        {
-          logger_mjs.logger.debug(`The navigation route is being used.`);
-        }
-
-        return true;
-      }
-
-      {
-        logger_mjs.logger.log(`The navigation route is not being used, since the URL ` + `being navigated to doesn't match the whitelist.`);
-      }
-
-      return false;
-    }
-
-  }
-
-  /*
-    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.
-  */
-  /**
-   * RegExpRoute makes it easy to create a regular expression based
-   * [Route]{@link workbox.routing.Route}.
-   *
-   * For same-origin requests the RegExp only needs to match part of the URL. For
-   * requests against third-party servers, you must define a RegExp that matches
-   * the start of the URL.
-   *
-   * [See the module docs for info.]{@link https://developers.google.com/web/tools/workbox/modules/workbox-routing}
-   *
-   * @memberof workbox.routing
-   * @extends workbox.routing.Route
-   */
-
-  class RegExpRoute extends Route {
-    /**
-     * If the regulard expression contains
-     * [capture groups]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#grouping-back-references},
-     * th ecaptured values will be passed to the
-     * [handler's]{@link workbox.routing.Route~handlerCallback} `params`
-     * argument.
-     *
-     * @param {RegExp} regExp The regular expression to match against URLs.
-     * @param {workbox.routing.Route~handlerCallback} handler A callback
-     * function that returns a Promise resulting in a Response.
-     * @param {string} [method='GET'] The HTTP method to match the Route
-     * against.
-     */
-    constructor(regExp, handler, method) {
-      {
-        assert_mjs.assert.isInstance(regExp, RegExp, {
-          moduleName: 'workbox-routing',
-          className: 'RegExpRoute',
-          funcName: 'constructor',
-          paramName: 'pattern'
-        });
-      }
-
-      const match = ({
-        url
-      }) => {
-        const result = regExp.exec(url.href); // Return null immediately if there's no match.
-
-        if (!result) {
-          return null;
-        } // Require that the match start at the first character in the URL string
-        // if it's a cross-origin request.
-        // See https://github.com/GoogleChrome/workbox/issues/281 for the context
-        // behind this behavior.
-
-
-        if (url.origin !== location.origin && result.index !== 0) {
-          {
-            logger_mjs.logger.debug(`The regular expression '${regExp}' only partially matched ` + `against the cross-origin URL '${url}'. RegExpRoute's will only ` + `handle cross-origin requests if they match the entire URL.`);
-          }
-
-          return null;
-        } // If the route matches, but there aren't any capture groups defined, then
-        // this will return [], which is truthy and therefore sufficient to
-        // indicate a match.
-        // If there are capture groups, then it will return their values.
-
-
-        return result.slice(1);
-      };
-
-      super(match, handler, method);
-    }
-
-  }
-
-  /*
-    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 Router can be used to process a FetchEvent through one or more
-   * [Routes]{@link workbox.routing.Route} responding  with a Request if
-   * a matching route exists.
-   *
-   * If no route matches a given a request, the Router will use a "default"
-   * handler if one is defined.
-   *
-   * Should the matching Route throw an error, the Router will use a "catch"
-   * handler if one is defined to gracefully deal with issues and respond with a
-   * Request.
-   *
-   * If a request matches multiple routes, the **earliest** registered route will
-   * be used to respond to the request.
-   *
-   * @memberof workbox.routing
-   */
-
-  class Router {
-    /**
-     * Initializes a new Router.
-     */
-    constructor() {
-      this._routes = new Map();
-    }
-    /**
-     * @return {Map<string, Array<workbox.routing.Route>>} routes A `Map` of HTTP
-     * method name ('GET', etc.) to an array of all the corresponding `Route`
-     * instances that are registered.
-     */
-
-
-    get routes() {
-      return this._routes;
-    }
-    /**
-     * Adds a fetch event listener to respond to events when a route matches
-     * the event's request.
-     */
-
-
-    addFetchListener() {
-      self.addEventListener('fetch', event => {
-        const {
-          request
-        } = event;
-        const responsePromise = this.handleRequest({
-          request,
-          event
-        });
-
-        if (responsePromise) {
-          event.respondWith(responsePromise);
-        }
-      });
-    }
-    /**
-     * Adds a message event listener for URLs to cache from the window.
-     * This is useful to cache resources loaded on the page prior to when the
-     * service worker started controlling it.
-     *
-     * The format of the message data sent from the window should be as follows.
-     * Where the `urlsToCache` array may consist of URL strings or an array of
-     * URL string + `requestInit` object (the same as you'd pass to `fetch()`).
-     *
-     * ```
-     * {
-     *   type: 'CACHE_URLS',
-     *   payload: {
-     *     urlsToCache: [
-     *       './script1.js',
-     *       './script2.js',
-     *       ['./script3.js', {mode: 'no-cors'}],
-     *     ],
-     *   },
-     * }
-     * ```
-     */
-
-
-    addCacheListener() {
-      self.addEventListener('message', async event => {
-        if (event.data && event.data.type === 'CACHE_URLS') {
-          const {
-            payload
-          } = event.data;
-
-          {
-            logger_mjs.logger.debug(`Caching URLs from the window`, payload.urlsToCache);
-          }
-
-          const requestPromises = Promise.all(payload.urlsToCache.map(entry => {
-            if (typeof entry === 'string') {
-              entry = [entry];
-            }
-
-            const request = new Request(...entry);
-            return this.handleRequest({
-              request
-            });
-          }));
-          event.waitUntil(requestPromises); // If a MessageChannel was used, reply to the message on success.
-
-          if (event.ports && event.ports[0]) {
-            await requestPromises;
-            event.ports[0].postMessage(true);
-          }
-        }
-      });
-    }
-    /**
-     * Apply the routing rules to a FetchEvent object to get a Response from an
-     * appropriate Route's handler.
-     *
-     * @param {Object} options
-     * @param {Request} options.request The request to handle (this is usually
-     *     from a fetch event, but it does not have to be).
-     * @param {FetchEvent} [options.event] The event that triggered the request,
-     *     if applicable.
-     * @return {Promise<Response>|undefined} A promise is returned if a
-     *     registered route can handle the request. If there is no matching
-     *     route and there's no `defaultHandler`, `undefined` is returned.
-     */
-
-
-    handleRequest({
-      request,
-      event
-    }) {
-      {
-        assert_mjs.assert.isInstance(request, Request, {
-          moduleName: 'workbox-routing',
-          className: 'Router',
-          funcName: 'handleRequest',
-          paramName: 'options.request'
-        });
-      }
-
-      const url = new URL(request.url, location);
-
-      if (!url.protocol.startsWith('http')) {
-        {
-          logger_mjs.logger.debug(`Workbox Router only supports URLs that start with 'http'.`);
-        }
-
-        return;
-      }
-
-      let {
-        params,
-        route
-      } = this.findMatchingRoute({
-        url,
-        request,
-        event
-      });
-      let handler = route && route.handler;
-      let debugMessages = [];
-
-      {
-        if (handler) {
-          debugMessages.push([`Found a route to handle this request:`, route]);
-
-          if (params) {
-            debugMessages.push([`Passing the following params to the route's handler:`, params]);
-          }
-        }
-      } // If we don't have a handler because there was no matching route, then
-      // fall back to defaultHandler if that's defined.
-
-
-      if (!handler && this._defaultHandler) {
-        {
-          debugMessages.push(`Failed to find a matching route. Falling ` + `back to the default handler.`); // This is used for debugging in logs in the case of an error.
-
-          route = '[Default Handler]';
-        }
-
-        handler = this._defaultHandler;
-      }
-
-      if (!handler) {
-        {
-          // No handler so Workbox will do nothing. If logs is set of debug
-          // i.e. verbose, we should print out this information.
-          logger_mjs.logger.debug(`No route found for: ${getFriendlyURL_mjs.getFriendlyURL(url)}`);
-        }
-
-        return;
-      }
-
-      {
-        // We have a handler, meaning Workbox is going to handle the route.
-        // print the routing details to the console.
-        logger_mjs.logger.groupCollapsed(`Router is responding to: ${getFriendlyURL_mjs.getFriendlyURL(url)}`);
-        debugMessages.forEach(msg => {
-          if (Array.isArray(msg)) {
-            logger_mjs.logger.log(...msg);
-          } else {
-            logger_mjs.logger.log(msg);
-          }
-        }); // The Request and Response objects contains a great deal of information,
-        // hide it under a group in case developers want to see it.
-
-        logger_mjs.logger.groupCollapsed(`View request details here.`);
-        logger_mjs.logger.log(request);
-        logger_mjs.logger.groupEnd();
-        logger_mjs.logger.groupEnd();
-      } // Wrap in try and catch in case the handle method throws a synchronous
-      // error. It should still callback to the catch handler.
-
-
-      let responsePromise;
-
-      try {
-        responsePromise = handler.handle({
-          url,
-          request,
-          event,
-          params
-        });
-      } catch (err) {
-        responsePromise = Promise.reject(err);
-      }
-
-      if (responsePromise && this._catchHandler) {
-        responsePromise = responsePromise.catch(err => {
-          {
-            // Still include URL here as it will be async from the console group
-            // and may not make sense without the URL
-            logger_mjs.logger.groupCollapsed(`Error thrown when responding to: ` + ` ${getFriendlyURL_mjs.getFriendlyURL(url)}. Falling back to Catch Handler.`);
-            logger_mjs.logger.error(`Error thrown by:`, route);
-            logger_mjs.logger.error(err);
-            logger_mjs.logger.groupEnd();
-          }
-
-          return this._catchHandler.handle({
-            url,
-            event,
-            err
-          });
-        });
-      }
-
-      return responsePromise;
-    }
-    /**
-     * Checks a request and URL (and optionally an event) against the list of
-     * registered routes, and if there's a match, returns the corresponding
-     * route along with any params generated by the match.
-     *
-     * @param {Object} options
-     * @param {URL} options.url
-     * @param {Request} options.request The request to match.
-     * @param {FetchEvent} [options.event] The corresponding event (unless N/A).
-     * @return {Object} An object with `route` and `params` properties.
-     *     They are populated if a matching route was found or `undefined`
-     *     otherwise.
-     */
-
-
-    findMatchingRoute({
-      url,
-      request,
-      event
-    }) {
-      {
-        assert_mjs.assert.isInstance(url, URL, {
-          moduleName: 'workbox-routing',
-          className: 'Router',
-          funcName: 'findMatchingRoute',
-          paramName: 'options.url'
-        });
-        assert_mjs.assert.isInstance(request, Request, {
-          moduleName: 'workbox-routing',
-          className: 'Router',
-          funcName: 'findMatchingRoute',
-          paramName: 'options.request'
-        });
-      }
-
-      const routes = this._routes.get(request.method) || [];
-
-      for (const route of routes) {
-        let params;
-        let matchResult = route.match({
-          url,
-          request,
-          event
-        });
-
-        if (matchResult) {
-          if (Array.isArray(matchResult) && matchResult.length > 0) {
-            // Instead of passing an empty array in as params, use undefined.
-            params = matchResult;
-          } else if (matchResult.constructor === Object && Object.keys(matchResult).length > 0) {
-            // Instead of passing an empty object in as params, use undefined.
-            params = matchResult;
-          } // Return early if have a match.
-
-
-          return {
-            route,
-            params
-          };
-        }
-      } // If no match was found above, return and empty object.
-
-
-      return {};
-    }
-    /**
-     * Define a default `handler` that's called when no routes explicitly
-     * match the incoming request.
-     *
-     * Without a default handler, unmatched requests will go against the
-     * network as if there were no service worker present.
-     *
-     * @param {workbox.routing.Route~handlerCallback} handler A callback
-     * function that returns a Promise resulting in a Response.
-     */
-
-
-    setDefaultHandler(handler) {
-      this._defaultHandler = normalizeHandler(handler);
-    }
-    /**
-     * If a Route throws an error while handling a request, this `handler`
-     * will be called and given a chance to provide a response.
-     *
-     * @param {workbox.routing.Route~handlerCallback} handler A callback
-     * function that returns a Promise resulting in a Response.
-     */
-
-
-    setCatchHandler(handler) {
-      this._catchHandler = normalizeHandler(handler);
-    }
-    /**
-     * Registers a route with the router.
-     *
-     * @param {workbox.routing.Route} route The route to register.
-     */
-
-
-    registerRoute(route) {
-      {
-        assert_mjs.assert.isType(route, 'object', {
-          moduleName: 'workbox-routing',
-          className: 'Router',
-          funcName: 'registerRoute',
-          paramName: 'route'
-        });
-        assert_mjs.assert.hasMethod(route, 'match', {
-          moduleName: 'workbox-routing',
-          className: 'Router',
-          funcName: 'registerRoute',
-          paramName: 'route'
-        });
-        assert_mjs.assert.isType(route.handler, 'object', {
-          moduleName: 'workbox-routing',
-          className: 'Router',
-          funcName: 'registerRoute',
-          paramName: 'route'
-        });
-        assert_mjs.assert.hasMethod(route.handler, 'handle', {
-          moduleName: 'workbox-routing',
-          className: 'Router',
-          funcName: 'registerRoute',
-          paramName: 'route.handler'
-        });
-        assert_mjs.assert.isType(route.method, 'string', {
-          moduleName: 'workbox-routing',
-          className: 'Router',
-          funcName: 'registerRoute',
-          paramName: 'route.method'
-        });
-      }
-
-      if (!this._routes.has(route.method)) {
-        this._routes.set(route.method, []);
-      } // Give precedence to all of the earlier routes by adding this additional
-      // route to the end of the array.
-
-
-      this._routes.get(route.method).push(route);
-    }
-    /**
-     * Unregisters a route with the router.
-     *
-     * @param {workbox.routing.Route} route The route to unregister.
-     */
-
-
-    unregisterRoute(route) {
-      if (!this._routes.has(route.method)) {
-        throw new WorkboxError_mjs.WorkboxError('unregister-route-but-not-found-with-method', {
-          method: route.method
-        });
-      }
-
-      const routeIndex = this._routes.get(route.method).indexOf(route);
-
-      if (routeIndex > -1) {
-        this._routes.get(route.method).splice(routeIndex, 1);
-      } else {
-        throw new WorkboxError_mjs.WorkboxError('unregister-route-route-not-registered');
-      }
-    }
-
-  }
-
-  /*
-    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.
-  */
-  let defaultRouter;
-  /**
-   * Creates a new, singleton Router instance if one does not exist. If one
-   * does already exist, that instance is returned.
-   *
-   * @private
-   * @return {Router}
-   */
-
-  const getOrCreateDefaultRouter = () => {
-    if (!defaultRouter) {
-      defaultRouter = new Router(); // The helpers that use the default Router assume these listeners exist.
-
-      defaultRouter.addFetchListener();
-      defaultRouter.addCacheListener();
-    }
-
-    return defaultRouter;
-  };
-
-  /*
-    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.
-  */
-  /**
-   * Registers a route that will return a precached file for a navigation
-   * request. This is useful for the
-   * [application shell pattern]{@link https://developers.google.com/web/fundamentals/architecture/app-shell}.
-   *
-   * When determining the URL of the precached HTML document, you will likely need
-   * to call `workbox.precaching.getCacheKeyForURL(originalUrl)`, to account for
-   * the fact that Workbox's precaching naming conventions often results in URL
-   * cache keys that contain extra revisioning info.
-   *
-   * This method will generate a
-   * [NavigationRoute]{@link workbox.routing.NavigationRoute}
-   * and call
-   * [Router.registerRoute()]{@link workbox.routing.Router#registerRoute} on a
-   * singleton Router instance.
-   *
-   * @param {string} cachedAssetUrl The cache key to use for the HTML file.
-   * @param {Object} [options]
-   * @param {string} [options.cacheName] Cache name to store and retrieve
-   * requests. Defaults to precache cache name provided by
-   * [workbox-core.cacheNames]{@link workbox.core.cacheNames}.
-   * @param {Array<RegExp>} [options.blacklist=[]] If any of these patterns
-   * match, the route will not handle the request (even if a whitelist entry
-   * matches).
-   * @param {Array<RegExp>} [options.whitelist=[/./]] If any of these patterns
-   * match the URL's pathname and search parameter, the route will handle the
-   * request (assuming the blacklist doesn't match).
-   * @return {workbox.routing.NavigationRoute} Returns the generated
-   * Route.
-   *
-   * @alias workbox.routing.registerNavigationRoute
-   */
-
-  const registerNavigationRoute = (cachedAssetUrl, options = {}) => {
-    {
-      assert_mjs.assert.isType(cachedAssetUrl, 'string', {
-        moduleName: 'workbox-routing',
-        funcName: 'registerNavigationRoute',
-        paramName: 'cachedAssetUrl'
-      });
-    }
-
-    const cacheName = cacheNames_mjs.cacheNames.getPrecacheName(options.cacheName);
-
-    const handler = async () => {
-      try {
-        const response = await caches.match(cachedAssetUrl, {
-          cacheName
-        });
-
-        if (response) {
-          return response;
-        } // This shouldn't normally happen, but there are edge cases:
-        // https://github.com/GoogleChrome/workbox/issues/1441
-
-
-        throw new Error(`The cache ${cacheName} did not have an entry for ` + `${cachedAssetUrl}.`);
-      } catch (error) {
-        // If there's either a cache miss, or the caches.match() call threw
-        // an exception, then attempt to fulfill the navigation request with
-        // a response from the network rather than leaving the user with a
-        // failed navigation.
-        {
-          logger_mjs.logger.debug(`Unable to respond to navigation request with ` + `cached response. Falling back to network.`, error);
-        } // This might still fail if the browser is offline...
-
-
-        return fetch(cachedAssetUrl);
-      }
-    };
-
-    const route = new NavigationRoute(handler, {
-      whitelist: options.whitelist,
-      blacklist: options.blacklist
-    });
-    const defaultRouter = getOrCreateDefaultRouter();
-    defaultRouter.registerRoute(route);
-    return route;
-  };
-
-  /*
-    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.
-  */
-  /**
-   * Easily register a RegExp, string, or function with a caching
-   * strategy to a singleton Router instance.
-   *
-   * This method will generate a Route for you if needed and
-   * call [Router.registerRoute()]{@link
-   * workbox.routing.Router#registerRoute}.
-   *
-   * @param {
-   * RegExp|
-   * string|
-   * workbox.routing.Route~matchCallback|
-   * workbox.routing.Route
-   * } capture
-   * If the capture param is a `Route`, all other arguments will be ignored.
-   * @param {workbox.routing.Route~handlerCallback} handler A callback
-   * function that returns a Promise resulting in a Response.
-   * @param {string} [method='GET'] The HTTP method to match the Route
-   * against.
-   * @return {workbox.routing.Route} The generated `Route`(Useful for
-   * unregistering).
-   *
-   * @alias workbox.routing.registerRoute
-   */
-
-  const registerRoute = (capture, handler, method = 'GET') => {
-    let route;
-
-    if (typeof capture === 'string') {
-      const captureUrl = new URL(capture, location);
-
-      {
-        if (!(capture.startsWith('/') || capture.startsWith('http'))) {
-          throw new WorkboxError_mjs.WorkboxError('invalid-string', {
-            moduleName: 'workbox-routing',
-            funcName: 'registerRoute',
-            paramName: 'capture'
-          });
-        } // We want to check if Express-style wildcards are in the pathname only.
-        // TODO: Remove this log message in v4.
-
-
-        const valueToCheck = capture.startsWith('http') ? captureUrl.pathname : capture; // See https://github.com/pillarjs/path-to-regexp#parameters
-
-        const wildcards = '[*:?+]';
-
-        if (valueToCheck.match(new RegExp(`${wildcards}`))) {
-          logger_mjs.logger.debug(`The '$capture' parameter contains an Express-style wildcard ` + `character (${wildcards}). Strings are now always interpreted as ` + `exact matches; use a RegExp for partial or wildcard matches.`);
-        }
-      }
-
-      const matchCallback = ({
-        url
-      }) => {
-        {
-          if (url.pathname === captureUrl.pathname && url.origin !== captureUrl.origin) {
-            logger_mjs.logger.debug(`${capture} only partially matches the cross-origin URL ` + `${url}. This route will only handle cross-origin requests ` + `if they match the entire URL.`);
-          }
-        }
-
-        return url.href === captureUrl.href;
-      };
-
-      route = new Route(matchCallback, handler, method);
-    } else if (capture instanceof RegExp) {
-      route = new RegExpRoute(capture, handler, method);
-    } else if (typeof capture === 'function') {
-      route = new Route(capture, handler, method);
-    } else if (capture instanceof Route) {
-      route = capture;
-    } else {
-      throw new WorkboxError_mjs.WorkboxError('unsupported-route-type', {
-        moduleName: 'workbox-routing',
-        funcName: 'registerRoute',
-        paramName: 'capture'
-      });
-    }
-
-    const defaultRouter = getOrCreateDefaultRouter();
-    defaultRouter.registerRoute(route);
-    return route;
-  };
-
-  /*
-    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.
-  */
-  /**
-   * If a Route throws an error while handling a request, this `handler`
-   * will be called and given a chance to provide a response.
-   *
-   * @param {workbox.routing.Route~handlerCallback} handler A callback
-   * function that returns a Promise resulting in a Response.
-   *
-   * @alias workbox.routing.setCatchHandler
-   */
-
-  const setCatchHandler = handler => {
-    const defaultRouter = getOrCreateDefaultRouter();
-    defaultRouter.setCatchHandler(handler);
-  };
-
-  /*
-    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.
-  */
-  /**
-   * Define a default `handler` that's called when no routes explicitly
-   * match the incoming request.
-   *
-   * Without a default handler, unmatched requests will go against the
-   * network as if there were no service worker present.
-   *
-   * @param {workbox.routing.Route~handlerCallback} handler A callback
-   * function that returns a Promise resulting in a Response.
-   *
-   * @alias workbox.routing.setDefaultHandler
-   */
-
-  const setDefaultHandler = handler => {
-    const defaultRouter = getOrCreateDefaultRouter();
-    defaultRouter.setDefaultHandler(handler);
-  };
-
-  /*
-    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.
-  */
-
-  {
-    assert_mjs.assert.isSWEnv('workbox-routing');
-  }
-
-  exports.NavigationRoute = NavigationRoute;
-  exports.RegExpRoute = RegExpRoute;
-  exports.registerNavigationRoute = registerNavigationRoute;
-  exports.registerRoute = registerRoute;
-  exports.Route = Route;
-  exports.Router = Router;
-  exports.setCatchHandler = setCatchHandler;
-  exports.setDefaultHandler = setDefaultHandler;
-
-  return exports;
-
-}({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private));
-//# sourceMappingURL=workbox-routing.dev.js.map