workbox-routing - npm Package Compare versions

		this.workbox = this.workbox \|\| {};
		this.workbox.routing = (function (exports, assert_mjs, logger_mjs, cacheNames_mjs, WorkboxError_mjs, getFriendlyURL_mjs) {
		'use strict';
		this.workbox.routing = (function (exports, assert_js, logger_js, cacheNames_js, WorkboxError_js, getFriendlyURL_js) {
		'use strict';

		try {
		self['workbox:routing:5.0.0-alpha.0'] && _();
		} catch (e) {} // eslint-disable-line
		// @ts-ignore
		try {
		self['workbox:routing:5.0.0-alpha.1'] && _();
		} catch (e) {}

		/*
		Copyright 2018 Google LLC
		/*
		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
		*/
		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 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'];
		const validMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT'];

		/*
		Copyright 2018 Google LLC
		/*
		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
		*/
		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'
		});
		}
		const normalizeHandler = handler => {
		if (handler && typeof handler === 'object') {
		{
		assert_js.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 handler;
		} else {
		{
		assert_js.assert.isType(handler, 'function', {
		moduleName: 'workbox-routing',
		className: 'Route',
		funcName: 'constructor',
		paramName: 'handler'
		});
		}

		return {
		handle: handler
		};
		}
		};

		return {
		handle: handler
		};
		}
		};
		/*
		Copyright 2018 Google LLC

		/*
		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 {
		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.
		*/
		/**
		* Constructor for Route class.
		* 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`.
		*
		* @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.
		* @memberof workbox.routing
		*/
		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'
		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 = defaultMethod) {
		{
		assert_js.assert.isType(match, 'function', {
		moduleName: 'workbox-routing',
		className: 'Route',
		funcName: 'constructor',
		paramName: 'match'
		});
		}
		} // These values are referenced directly by Router so cannot be
		// altered by minifification.

		if (method) {
		assert_js.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;
		}

		}
		this.handler = normalizeHandler(handler);
		this.match = match;
		this.method = 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.
		*/
		/**
		* 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
		*/
		/*
		Copyright 2018 Google LLC

		class NavigationRoute extends Route {
		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 both `blacklist` and `whiltelist` are provided, the `blacklist` will
		* take precedence and the request will not match this route.
		* 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}.
		*
		* 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.
		* It will only match incoming Requests whose
		* [`mode`]{@link https://fetch.spec.whatwg.org/#concept-request-mode}
		* is set to `navigate`.
		*
		* @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.
		* You can optionally only apply this route to a subset of navigation requests
		* by using one or both of the `blacklist` and `whitelist` parameters.
		*
		* @param {Object} options
		* @param {URL} options.url
		* @param {Request} options.request
		* @return {boolean}
		*
		* @private
		* @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_js.assert.isArrayOfClass(whitelist, RegExp, {
		moduleName: 'workbox-routing',
		className: 'NavigationRoute',
		funcName: 'constructor',
		paramName: 'options.whitelist'
		});
		assert_js.assert.isArrayOfClass(blacklist, RegExp, {
		moduleName: 'workbox-routing',
		className: 'NavigationRoute',
		funcName: 'constructor',
		paramName: 'options.blacklist'
		});
		}

		_match({
		url,
		request
		}) {
		if (request.mode !== 'navigate') {
		return false;
		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
		*/

		const pathnameAndSearch = url.pathname + url.search;

		for (const regExp of this._blacklist) {
		if (regExp.test(pathnameAndSearch)) {
		_match({
		url,
		request
		}) {
		if (request && request.mode !== 'navigate') {
		return false;
		}

		const pathnameAndSearch = url.pathname + url.search;

		for (const regExp of this._blacklist) {
		if (regExp.test(pathnameAndSearch)) {
		{
		logger_js.logger.log(`The navigation route ${pathnameAndSearch} 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.log(`The navigation route is not being used, since the ` + `URL matches this blacklist pattern: ${regExp}`);
		logger_js.logger.debug(`The navigation route ${pathnameAndSearch} ` + `is being used.`);
		}

		return false;
		return true;
		}
		}

		if (this._whitelist.some(regExp => regExp.test(pathnameAndSearch))) {
		{
		logger_mjs.logger.debug(`The navigation route is being used.`);
		logger_js.logger.log(`The navigation route ${pathnameAndSearch} is not ` + `being used, since the URL being navigated to doesn't ` + `match the whitelist.`);
		}

		return true;
		return false;
		}

		{
		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

		/*
		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 {
		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 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.
		* RegExpRoute makes it easy to create a regular expression based
		* [Route]{@link workbox.routing.Route}.
		*
		* @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.
		* 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
		*/
		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.
		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_js.assert.isInstance(regExp, RegExp, {
		moduleName: 'workbox-routing',
		className: 'RegExpRoute',
		funcName: 'constructor',
		paramName: 'pattern'
		});
		}

		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.
		const match = ({
		url
		}) => {
		const result = regExp.exec(url.href); // Return immediately if there's no match.

		if (!result) {
		return;
		} // 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.
		if (url.origin !== location.origin && result.index !== 0) {
		{
		logger_js.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;
		} // 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);
		}
		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.
		*/

		/*
		Copyright 2018 Google LLC

		get routes() {
		return this._routes;
		}
		Use of this source code is governed by an MIT-style
		license that can be found in the LICENSE file or at
		https://opensource.org/licenses/MIT.
		*/
		/**
		* Adds a fetch event listener to respond to events when a route matches
		* the event's request.
		* 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.
		*/

		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'}],
		* ],
		* },
		* }
		* ```
		*/
		get routes() {
		return this._routes;
		}
		/**
		* Adds a fetch event listener to respond to events when a route matches
		* the event's request.
		*/


		addCacheListener() {
		self.addEventListener('message', async event => {
		if (event.data && event.data.type === 'CACHE_URLS') {
		addFetchListener() {
		self.addEventListener('fetch', event => {
		const {
		payload
		} = event.data;
		request
		} = event;
		const responsePromise = this.handleRequest({
		request,
		event
		});

		{
		logger_mjs.logger.debug(`Caching URLs from the window`, payload.urlsToCache);
		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'}],
		* ],
		* },
		* }
		* ```
		*/

		const requestPromises = Promise.all(payload.urlsToCache.map(entry => {
		if (typeof entry === 'string') {
		entry = [entry];

		addCacheListener() {
		self.addEventListener('message', async event => {
		if (event.data && event.data.type === 'CACHE_URLS') {
		const {
		payload
		} = event.data;

		{
		logger_js.logger.debug(`Caching URLs from the window`, payload.urlsToCache);
		}

		const request = new Request(...entry);
		return this.handleRequest({
		request
		});
		}));
		event.waitUntil(requestPromises); // If a MessageChannel was used, reply to the message on success.
		const requestPromises = Promise.all(payload.urlsToCache.map(entry => {
		if (typeof entry === 'string') {
		entry = [entry];
		}

		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.
		*/
		const request = new Request(...entry);
		return this.handleRequest({
		request
		}); // TODO(philipwalton): Typescript errors without this typecast for
		// some reason (probably a bug). The real type here should work but
		// doesn't: `Array<Promise<Response> \| undefined>`.
		})); // Typescript

		event.waitUntil(requestPromises); // If a MessageChannel was used, reply to the message on success.

		handleRequest({
		request,
		event
		}) {
		{
		assert_mjs.assert.isInstance(request, Request, {
		moduleName: 'workbox-routing',
		className: 'Router',
		funcName: 'handleRequest',
		paramName: 'options.request'
		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.
		*/

		const url = new URL(request.url, location);

		if (!url.protocol.startsWith('http')) {
		handleRequest({
		request,
		event
		}) {
		{
		logger_mjs.logger.debug(`Workbox Router only supports URLs that start with 'http'.`);
		assert_js.assert.isInstance(request, Request, {
		moduleName: 'workbox-routing',
		className: 'Router',
		funcName: 'handleRequest',
		paramName: 'options.request'
		});
		}

		return;
		}
		const url = new URL(request.url, location.href);

		let {
		params,
		route
		} = this.findMatchingRoute({
		url,
		request,
		event
		});
		let handler = route && route.handler;
		let debugMessages = [];
		if (!url.protocol.startsWith('http')) {
		{
		logger_js.logger.debug(`Workbox Router only supports URLs that start with 'http'.`);
		}

		{
		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]);
		}
		return;
		}
		} // If we don't have a handler because there was no matching route, then
		// fall back to defaultHandler if that's defined.

		let {
		params,
		route
		} = this.findMatchingRoute({
		url,
		request,
		event
		});
		let handler = route && route.handler;
		let debugMessages = [];

		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.
		if (handler) {
		debugMessages.push([`Found a route to handle this request:`, route]);

		route = '[Default Handler]';
		}
		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.

		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)}`);
		if (!handler && this._defaultHandler) {
		{
		debugMessages.push(`Failed to find a matching route. Falling ` + `back to the default handler.`);
		}

		handler = this._defaultHandler;
		}

		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);
		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_js.logger.debug(`No route found for: ${getFriendlyURL_js.getFriendlyURL(url)}`);
		}
		}); // 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.
		return;
		}

		{
		// We have a handler, meaning Workbox is going to handle the route.
		// print the routing details to the console.
		logger_js.logger.groupCollapsed(`Router is responding to: ${getFriendlyURL_js.getFriendlyURL(url)}`);
		debugMessages.forEach(msg => {
		if (Array.isArray(msg)) {
		logger_js.logger.log(...msg);
		} else {
		logger_js.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.

		let responsePromise;
		logger_js.logger.groupCollapsed(`View request details here.`);
		logger_js.logger.log(request);
		logger_js.logger.groupEnd();
		logger_js.logger.groupEnd();
		} // Wrap in try and catch in case the handle method throws a synchronous
		// error. It should still callback to the catch handler.

		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();
		}
		let responsePromise;

		return this._catchHandler.handle({
		try {
		responsePromise = handler.handle({
		url,
		request,
		event,
		err
		params
		});
		});
		}
		} catch (err) {
		responsePromise = Promise.reject(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.
		*/
		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_js.logger.groupCollapsed(`Error thrown when responding to: ` + ` ${getFriendlyURL_js.getFriendlyURL(url)}. Falling back to Catch Handler.`);
		logger_js.logger.error(`Error thrown by:`, route);
		logger_js.logger.error(err);
		logger_js.logger.groupEnd();
		}

		return this._catchHandler.handle({
		url,
		request,
		event
		});
		});
		}

		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'
		});
		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 {Event} [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.
		*/

		const routes = this._routes.get(request.method) \|\| [];

		for (const route of routes) {
		let params;
		let matchResult = route.match({
		url,
		request,
		event
		});
		findMatchingRoute({
		url,
		request,
		event
		}) {
		{
		assert_js.assert.isInstance(url, URL, {
		moduleName: 'workbox-routing',
		className: 'Router',
		funcName: 'findMatchingRoute',
		paramName: 'options.url'
		});
		assert_js.assert.isInstance(request, Request, {
		moduleName: 'workbox-routing',
		className: 'Router',
		funcName: 'findMatchingRoute',
		paramName: 'options.request'
		});
		}

		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.
		const routes = this._routes.get(request.method) \|\| [];

		for (const route of routes) {
		let params;
		let matchResult = route.match({
		url,
		request,
		event
		});

		return {
		route,
		params
		};
		}
		} // If no match was found above, return and empty object.
		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 {};
		}
		/**
		* 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.
		*/
		return {
		route,
		params
		};
		}
		} // If no match was found above, return and empty object.


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


		setCatchHandler(handler) {
		this._catchHandler = normalizeHandler(handler);
		}
		/**
		* Registers a route with the router.
		*
		* @param {workbox.routing.Route} route The route to register.
		*/
		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.
		*/


		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'
		});
		setCatchHandler(handler) {
		this._catchHandler = normalizeHandler(handler);
		}
		/**
		* Registers a route with the router.
		*
		* @param {workbox.routing.Route} route The route to register.
		*/

		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.

		registerRoute(route) {
		{
		assert_js.assert.isType(route, 'object', {
		moduleName: 'workbox-routing',
		className: 'Router',
		funcName: 'registerRoute',
		paramName: 'route'
		});
		assert_js.assert.hasMethod(route, 'match', {
		moduleName: 'workbox-routing',
		className: 'Router',
		funcName: 'registerRoute',
		paramName: 'route'
		});
		assert_js.assert.isType(route.handler, 'object', {
		moduleName: 'workbox-routing',
		className: 'Router',
		funcName: 'registerRoute',
		paramName: 'route'
		});
		assert_js.assert.hasMethod(route.handler, 'handle', {
		moduleName: 'workbox-routing',
		className: 'Router',
		funcName: 'registerRoute',
		paramName: 'route.handler'
		});
		assert_js.assert.isType(route.method, 'string', {
		moduleName: 'workbox-routing',
		className: 'Router',
		funcName: 'registerRoute',
		paramName: 'route.method'
		});
		}

		this._routes.get(route.method).push(route);
		}
		/**
		* Unregisters a route with the router.
		*
		* @param {workbox.routing.Route} route The route to unregister.
		*/
		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.


		unregisterRoute(route) {
		if (!this._routes.has(route.method)) {
		throw new WorkboxError_mjs.WorkboxError('unregister-route-but-not-found-with-method', {
		method: route.method
		});
		this._routes.get(route.method).push(route);
		}
		/**
		* Unregisters a route with the router.
		*
		* @param {workbox.routing.Route} route The route to unregister.
		*/

		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');
		unregisterRoute(route) {
		if (!this._routes.has(route.method)) {
		throw new WorkboxError_js.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_js.WorkboxError('unregister-route-route-not-registered');
		}
		}

		}

		}
		/*
		Copyright 2019 Google LLC

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

		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.

		const getOrCreateDefaultRouter = () => {
		if (!defaultRouter) {
		defaultRouter = new Router(); // The helpers that use the default Router assume these listeners exist.
		defaultRouter.addFetchListener();
		defaultRouter.addCacheListener();
		}

		defaultRouter.addFetchListener();
		defaultRouter.addCacheListener();
		}
		return defaultRouter;
		};

		return defaultRouter;
		};
		/*
		Copyright 2019 Google LLC

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

		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_js.assert.isType(cachedAssetUrl, 'string', {
		moduleName: 'workbox-routing',
		funcName: 'registerNavigationRoute',
		paramName: 'cachedAssetUrl'
		});
		}

		const registerNavigationRoute = (cachedAssetUrl, options = {}) => {
		{
		assert_mjs.assert.isType(cachedAssetUrl, 'string', {
		moduleName: 'workbox-routing',
		funcName: 'registerNavigationRoute',
		paramName: 'cachedAssetUrl'
		});
		}
		const cacheName = cacheNames_js.cacheNames.getPrecacheName(options.cacheName);

		const cacheName = cacheNames_mjs.cacheNames.getPrecacheName(options.cacheName);
		const handler = async () => {
		try {
		const response = await caches.match(cachedAssetUrl, {
		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

		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_js.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...

		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);
		}
		};

		return fetch(cachedAssetUrl);
		}
		const route = new NavigationRoute(handler, {
		whitelist: options.whitelist,
		blacklist: options.blacklist
		});
		const defaultRouter = getOrCreateDefaultRouter();
		defaultRouter.registerRoute(route);
		return route;
		};

		const route = new NavigationRoute(handler, {
		whitelist: options.whitelist,
		blacklist: options.blacklist
		});
		const defaultRouter = getOrCreateDefaultRouter();
		defaultRouter.registerRoute(route);
		return route;
		};
		/*
		Copyright 2019 Google LLC

		/*
		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. This parameter
		* is required if `capture` is not a `Route` object.
		* @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
		*/

		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) => {
		let route;

		const registerRoute = (capture, handler, method = 'GET') => {
		let route;
		if (typeof capture === 'string') {
		const captureUrl = new URL(capture, location.href);

		if (typeof capture === 'string') {
		const captureUrl = new URL(capture, location);
		{
		if (!(capture.startsWith('/') \|\| capture.startsWith('http'))) {
		throw new WorkboxError_js.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.

		{
		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 valueToCheck = capture.startsWith('http') ? captureUrl.pathname : capture; // See https://github.com/pillarjs/path-to-regexp#parameters
		const wildcards = '[*:?+]';

		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.`);
		if (valueToCheck.match(new RegExp(`${wildcards}`))) {
		logger_js.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.`);
		const matchCallback = ({
		url
		}) => {
		{
		if (url.pathname === captureUrl.pathname && url.origin !== captureUrl.origin) {
		logger_js.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;
		};
		return url.href === captureUrl.href;
		}; // If `capture` is a string then `handler` and `method` must be present.

		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;
		};
		route = new Route(matchCallback, handler, method);
		} else if (capture instanceof RegExp) {
		// If `capture` is a `RegExp` then `handler` and `method` must be present.
		route = new RegExpRoute(capture, handler, method);
		} else if (typeof capture === 'function') {
		// If `capture` is a function then `handler` and `method` must be present.
		route = new Route(capture, handler, method);
		} else if (capture instanceof Route) {
		route = capture;
		} else {
		throw new WorkboxError_js.WorkboxError('unsupported-route-type', {
		moduleName: 'workbox-routing',
		funcName: 'registerRoute',
		paramName: 'capture'
		});
		}

		/*
		Copyright 2019 Google LLC
		const defaultRouter = getOrCreateDefaultRouter();
		defaultRouter.registerRoute(route);
		return route;
		};

		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
		*/
		/*
		Copyright 2019 Google LLC

		const setCatchHandler = handler => {
		const defaultRouter = getOrCreateDefaultRouter();
		defaultRouter.setCatchHandler(handler);
		};
		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
		*/

		/*
		Copyright 2019 Google LLC
		const setCatchHandler = handler => {
		const defaultRouter = getOrCreateDefaultRouter();
		defaultRouter.setCatchHandler(handler);
		};

		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
		*/
		/*
		Copyright 2019 Google LLC

		const setDefaultHandler = handler => {
		const defaultRouter = getOrCreateDefaultRouter();
		defaultRouter.setDefaultHandler(handler);
		};
		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
		*/

		/*
		Copyright 2018 Google LLC
		const setDefaultHandler = handler => {
		const defaultRouter = getOrCreateDefaultRouter();
		defaultRouter.setDefaultHandler(handler);
		};

		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.
		*/
		/*
		Copyright 2018 Google LLC

		{
		assert_mjs.assert.isSWEnv('workbox-routing');
		}
		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.NavigationRoute = NavigationRoute;
		exports.RegExpRoute = RegExpRoute;
		exports.registerNavigationRoute = registerNavigationRoute;
		exports.registerRoute = registerRoute;
		exports.Route = Route;
		exports.Router = Router;
		exports.setCatchHandler = setCatchHandler;
		exports.setDefaultHandler = setDefaultHandler;
		{
		assert_js.assert.isSWEnv('workbox-routing');
		}

		return exports;
		exports.NavigationRoute = NavigationRoute;
		exports.RegExpRoute = RegExpRoute;
		exports.Route = Route;
		exports.Router = Router;
		exports.registerNavigationRoute = registerNavigationRoute;
		exports.registerRoute = registerRoute;
		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

build/workbox-routing.prod.js

		@@ -1,2 +0,2 @@
		this.workbox=this.workbox\|\|{},this.workbox.routing=function(t,e,r){"use strict";try{self["workbox:routing:5.0.0-alpha.0"]&&_()}catch(t){}const s="GET",n=t=>t&&"object"==typeof t?t:{handle:t};class o{constructor(t,e,r){this.handler=n(e),this.match=t,this.method=r\|\|s}}class i extends o{constructor(t,{whitelist:e=[/./],blacklist:r=[]}={}){super(t=>this.t(t),t),this.s=e,this.o=r}t({url:t,request:e}){if("navigate"!==e.mode)return!1;const r=t.pathname+t.search;for(const t of this.o)if(t.test(r))return!1;return!!this.s.some(t=>t.test(r))}}class u extends o{constructor(t,e,r){super(({url:e})=>{const r=t.exec(e.href);return r?e.origin!==location.origin&&0!==r.index?null:r.slice(1):null},e,r)}}class c{constructor(){this.i=new Map}get routes(){return this.i}addFetchListener(){self.addEventListener("fetch",t=>{const{request:e}=t,r=this.handleRequest({request:e,event:t});r&&t.respondWith(r)})}addCacheListener(){self.addEventListener("message",async t=>{if(t.data&&"CACHE_URLS"===t.data.type){const{payload:e}=t.data,r=Promise.all(e.urlsToCache.map(t=>{"string"==typeof t&&(t=[t]);const e=new Request(...t);return this.handleRequest({request:e})}));t.waitUntil(r),t.ports&&t.ports[0]&&(await r,t.ports[0].postMessage(!0))}})}handleRequest({request:t,event:e}){const r=new URL(t.url,location);if(!r.protocol.startsWith("http"))return;let s,{params:n,route:o}=this.findMatchingRoute({url:r,request:t,event:e}),i=o&&o.handler;if(!i&&this.u&&(i=this.u),i){try{s=i.handle({url:r,request:t,event:e,params:n})}catch(t){s=Promise.reject(t)}return s&&this.h&&(s=s.catch(t=>this.h.handle({url:r,event:e,err:t}))),s}}findMatchingRoute({url:t,request:e,event:r}){const s=this.i.get(e.method)\|\|[];for(const n of s){let s,o=n.match({url:t,request:e,event:r});if(o)return Array.isArray(o)&&o.length>0?s=o:o.constructor===Object&&Object.keys(o).length>0&&(s=o),{route:n,params:s}}return{}}setDefaultHandler(t){this.u=n(t)}setCatchHandler(t){this.h=n(t)}registerRoute(t){this.i.has(t.method)\|\|this.i.set(t.method,[]),this.i.get(t.method).push(t)}unregisterRoute(t){if(!this.i.has(t.method))throw new r.WorkboxError("unregister-route-but-not-found-with-method",{method:t.method});const e=this.i.get(t.method).indexOf(t);if(!(e>-1))throw new r.WorkboxError("unregister-route-route-not-registered");this.i.get(t.method).splice(e,1)}}let a;const h=()=>(a\|\|((a=new c).addFetchListener(),a.addCacheListener()),a);return t.NavigationRoute=i,t.RegExpRoute=u,t.registerNavigationRoute=((t,r={})=>{const s=e.cacheNames.getPrecacheName(r.cacheName),n=new i(async()=>{try{const e=await caches.match(t,{cacheName:s});if(e)return e;throw new Error(`The cache ${s} did not have an entry for `+`${t}.`)}catch(e){return fetch(t)}},{whitelist:r.whitelist,blacklist:r.blacklist});return h().registerRoute(n),n}),t.registerRoute=((t,e,s="GET")=>{let n;if("string"==typeof t){const r=new URL(t,location);n=new o(({url:t})=>t.href===r.href,e,s)}else if(t instanceof RegExp)n=new u(t,e,s);else if("function"==typeof t)n=new o(t,e,s);else{if(!(t instanceof o))throw new r.WorkboxError("unsupported-route-type",{moduleName:"workbox-routing",funcName:"registerRoute",paramName:"capture"});n=t}return h().registerRoute(n),n}),t.Route=o,t.Router=c,t.setCatchHandler=(t=>{h().setCatchHandler(t)}),t.setDefaultHandler=(t=>{h().setDefaultHandler(t)}),t}({},workbox.core._private,workbox.core._private);
		this.workbox=this.workbox\|\|{},this.workbox.routing=function(t,e,r){"use strict";try{self["workbox:routing:5.0.0-alpha.1"]&&_()}catch(t){}const s="GET",n=t=>t&&"object"==typeof t?t:{handle:t};class i{constructor(t,e,r=s){this.handler=n(e),this.match=t,this.method=r}}class o extends i{constructor(t,{whitelist:e=[/./],blacklist:r=[]}={}){super(t=>this.t(t),t),this.s=e,this.i=r}t({url:t,request:e}){if(e&&"navigate"!==e.mode)return!1;const r=t.pathname+t.search;for(const t of this.i)if(t.test(r))return!1;return!!this.s.some(t=>t.test(r))}}class u extends i{constructor(t,e,r){super(({url:e})=>{const r=t.exec(e.href);if(r&&(e.origin===location.origin\|\|0===r.index))return r.slice(1)},e,r)}}class c{constructor(){this.o=new Map}get routes(){return this.o}addFetchListener(){self.addEventListener("fetch",t=>{const{request:e}=t,r=this.handleRequest({request:e,event:t});r&&t.respondWith(r)})}addCacheListener(){self.addEventListener("message",async t=>{if(t.data&&"CACHE_URLS"===t.data.type){const{payload:e}=t.data,r=Promise.all(e.urlsToCache.map(t=>{"string"==typeof t&&(t=[t]);const e=new Request(...t);return this.handleRequest({request:e})}));t.waitUntil(r),t.ports&&t.ports[0]&&(await r,t.ports[0].postMessage(!0))}})}handleRequest({request:t,event:e}){const r=new URL(t.url,location.href);if(!r.protocol.startsWith("http"))return;let s,{params:n,route:i}=this.findMatchingRoute({url:r,request:t,event:e}),o=i&&i.handler;if(!o&&this.u&&(o=this.u),o){try{s=o.handle({url:r,request:t,event:e,params:n})}catch(t){s=Promise.reject(t)}return s&&this.h&&(s=s.catch(s=>this.h.handle({url:r,request:t,event:e}))),s}}findMatchingRoute({url:t,request:e,event:r}){const s=this.o.get(e.method)\|\|[];for(const n of s){let s,i=n.match({url:t,request:e,event:r});if(i)return Array.isArray(i)&&i.length>0?s=i:i.constructor===Object&&Object.keys(i).length>0&&(s=i),{route:n,params:s}}return{}}setDefaultHandler(t){this.u=n(t)}setCatchHandler(t){this.h=n(t)}registerRoute(t){this.o.has(t.method)\|\|this.o.set(t.method,[]),this.o.get(t.method).push(t)}unregisterRoute(t){if(!this.o.has(t.method))throw new r.WorkboxError("unregister-route-but-not-found-with-method",{method:t.method});const e=this.o.get(t.method).indexOf(t);if(!(e>-1))throw new r.WorkboxError("unregister-route-route-not-registered");this.o.get(t.method).splice(e,1)}}let a;const h=()=>(a\|\|((a=new c).addFetchListener(),a.addCacheListener()),a);return t.NavigationRoute=o,t.RegExpRoute=u,t.Route=i,t.Router=c,t.registerNavigationRoute=((t,r={})=>{const s=e.cacheNames.getPrecacheName(r.cacheName),n=new o(async()=>{try{const e=await caches.match(t,{cacheName:s});if(e)return e;throw new Error(`The cache ${s} did not have an entry for `+`${t}.`)}catch(e){return fetch(t)}},{whitelist:r.whitelist,blacklist:r.blacklist});return h().registerRoute(n),n}),t.registerRoute=((t,e,s)=>{let n;if("string"==typeof t){const r=new URL(t,location.href);n=new i(({url:t})=>t.href===r.href,e,s)}else if(t instanceof RegExp)n=new u(t,e,s);else if("function"==typeof t)n=new i(t,e,s);else{if(!(t instanceof i))throw new r.WorkboxError("unsupported-route-type",{moduleName:"workbox-routing",funcName:"registerRoute",paramName:"capture"});n=t}return h().registerRoute(n),n}),t.setCatchHandler=(t=>{h().setCatchHandler(t)}),t.setDefaultHandler=(t=>{h().setDefaultHandler(t)}),t}({},workbox.core._private,workbox.core._private);
		//# sourceMappingURL=workbox-routing.prod.js.map

package.json

		{
		"name": "workbox-routing",
		"version": "5.0.0-alpha.0",
		"version": "5.0.0-alpha.1",
		"license": "MIT",
		@@ -27,8 +27,9 @@ "author": "Google's Web DevRel Team",
		},
		"main": "build/workbox-routing.prod.js",
		"main": "index.js",
		"module": "index.mjs",
		"types": "index.d.ts",
		"dependencies": {
		"workbox-core": "^5.0.0-alpha.0"
		"workbox-core": "^5.0.0-alpha.1"
		},
		"gitHead": "7f231c04023669bc42d5a939d1359b0867e2efda"
		"gitHead": "20d2110ddace710a46af06addd4977cae08f5942"
		}

_types.mjs