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