0.2.0 - Mid migration

web/node_modules/workbox-routing/src/NavigationRoute.ts

@@ -0,0 +1,126 @@
+/*
+  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.
+*/
+
+import {assert} from 'workbox-core/_private/assert.js';
+import {logger} from 'workbox-core/_private/logger.js';
+import {Route} from './Route.js';
+import {Handler, MatchCallbackOptions} from './_types.js';
+import './_version.js';
+
+export interface NavigationRouteMatchOptions {
+  allowlist?: RegExp[];
+  denylist?: RegExp[];
+}
+
+/**
+ * NavigationRoute makes it easy to create a
+ * [Route]{@link module: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 `denylist` and `allowlist` parameters.
+ *
+ * @memberof module:workbox-routing
+ * @extends module:workbox-routing.Route
+ */
+class NavigationRoute extends Route {
+  private readonly _allowlist: RegExp[];
+  private readonly _denylist: RegExp[];
+
+  /**
+   * If both `denylist` and `allowlist` are provided, the `denylist` will
+   * take precedence and the request will not match this route.
+   *
+   * The regular expressions in `allowlist` and `denylist`
+   * 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 {module:workbox-routing~handlerCallback} handler A callback
+   * function that returns a Promise resulting in a Response.
+   * @param {Object} options
+   * @param {Array<RegExp>} [options.denylist] If any of these patterns match,
+   * the route will not handle the request (even if a allowlist RegExp matches).
+   * @param {Array<RegExp>} [options.allowlist=[/./]] If any of these patterns
+   * match the URL's pathname and search parameter, the route will handle the
+   * request (assuming the denylist doesn't match).
+   */
+  constructor(handler: Handler,
+      {allowlist = [/./], denylist = []}: NavigationRouteMatchOptions = {}) {
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.isArrayOfClass(allowlist, RegExp, {
+        moduleName: 'workbox-routing',
+        className: 'NavigationRoute',
+        funcName: 'constructor',
+        paramName: 'options.allowlist',
+      });
+      assert!.isArrayOfClass(denylist, RegExp, {
+        moduleName: 'workbox-routing',
+        className: 'NavigationRoute',
+        funcName: 'constructor',
+        paramName: 'options.denylist',
+      });
+    }
+
+    super((options: MatchCallbackOptions) => this._match(options), handler);
+
+    this._allowlist = allowlist;
+    this._denylist = denylist;
+  }
+
+  /**
+   * Routes match handler.
+   *
+   * @param {Object} options
+   * @param {URL} options.url
+   * @param {Request} options.request
+   * @return {boolean}
+   *
+   * @private
+   */
+  private _match({url, request}: MatchCallbackOptions): boolean {
+    if (request && request.mode !== 'navigate') {
+      return false;
+    }
+
+    const pathnameAndSearch = url.pathname + url.search;
+
+    for (const regExp of this._denylist) {
+      if (regExp.test(pathnameAndSearch)) {
+        if (process.env.NODE_ENV !== 'production') {
+          logger.log(`The navigation route ${pathnameAndSearch} is not ` +
+              `being used, since the URL matches this denylist pattern: ` +
+              `${regExp}`);
+        }
+        return false;
+      }
+    }
+
+    if (this._allowlist.some((regExp) => regExp.test(pathnameAndSearch))) {
+      if (process.env.NODE_ENV !== 'production') {
+        logger.debug(`The navigation route ${pathnameAndSearch} ` +
+            `is being used.`);
+      }
+      return true;
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      logger.log(`The navigation route ${pathnameAndSearch} is not ` +
+          `being used, since the URL being navigated to doesn't ` +
+          `match the allowlist.`);
+    }
+    return false;
+  }
+}
+
+export {NavigationRoute};

web/node_modules/workbox-routing/src/RegExpRoute.ts

@@ -0,0 +1,89 @@
+/*
+  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.
+*/
+
+import {assert} from 'workbox-core/_private/assert.js';
+import {logger} from 'workbox-core/_private/logger.js';
+import {HTTPMethod} from './utils/constants.js';
+import {Route} from './Route.js';
+import {Handler, MatchCallbackOptions, MatchCallback} from './_types.js';
+import './_version.js';
+
+
+/**
+ * RegExpRoute makes it easy to create a regular expression based
+ * [Route]{@link module: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 module:workbox-routing
+ * @extends module:workbox-routing.Route
+ */
+class RegExpRoute extends Route {
+  /**
+   * If the regular expression contains
+   * [capture groups]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#grouping-back-references},
+   * the captured values will be passed to the
+   * [handler's]{@link module:workbox-routing~handlerCallback} `params`
+   * argument.
+   *
+   * @param {RegExp} regExp The regular expression to match against URLs.
+   * @param {module:workbox-routing~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: RegExp, handler: Handler, method?: HTTPMethod) {
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.isInstance(regExp, RegExp, {
+        moduleName: 'workbox-routing',
+        className: 'RegExpRoute',
+        funcName: 'constructor',
+        paramName: 'pattern',
+      });
+    }
+
+    const match: MatchCallback = ({url}: MatchCallbackOptions) => {
+      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)) {
+        if (process.env.NODE_ENV !== 'production') {
+          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);
+  }
+}
+
+export {RegExpRoute};

web/node_modules/workbox-routing/src/Route.ts

@@ -0,0 +1,66 @@
+/*
+  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.
+*/
+
+import {assert} from 'workbox-core/_private/assert.js';
+import {HTTPMethod, defaultMethod, validMethods} from './utils/constants.js';
+import {normalizeHandler} from './utils/normalizeHandler.js';
+import {Handler, HandlerObject, MatchCallback} from './_types.js';
+import './_version.js';
+
+
+/**
+ * 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 module:workbox-routing
+ */
+class Route {
+  handler: HandlerObject;
+  match: MatchCallback;
+  method: HTTPMethod;
+
+  /**
+   * Constructor for Route class.
+   *
+   * @param {module:workbox-routing~matchCallback} match
+   * A callback function that determines whether the route matches a given
+   * `fetch` event by returning a non-falsy value.
+   * @param {module:workbox-routing~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: MatchCallback,
+      handler: Handler,
+      method: HTTPMethod = defaultMethod) {
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.isType(match, 'function', {
+        moduleName: 'workbox-routing',
+        className: 'Route',
+        funcName: 'constructor',
+        paramName: 'match',
+      });
+
+      if (method) {
+        assert!.isOneOf(method, validMethods, {paramName: 'method'});
+      }
+    }
+
+    // These values are referenced directly by Router so cannot be
+    // altered by minificaton.
+    this.handler = normalizeHandler(handler);
+    this.match = match;
+    this.method = method;
+  }
+}
+
+export {Route};

web/node_modules/workbox-routing/src/Router.ts

@@ -0,0 +1,416 @@
+/*
+  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.
+*/
+
+import {assert} from 'workbox-core/_private/assert.js';
+import {logger} from 'workbox-core/_private/logger.js';
+import {WorkboxError} from 'workbox-core/_private/WorkboxError.js';
+import {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.js';
+import {Route} from './Route.js';
+import {HTTPMethod} from './utils/constants.js';
+import {normalizeHandler} from './utils/normalizeHandler.js';
+import {Handler, HandlerObject, HandlerCallbackOptions} from './_types.js';
+import './_version.js';
+
+
+type RequestArgs = string | [string, RequestInit?];
+
+
+interface CacheURLsMessageData {
+  type: string;
+  payload: {
+    urlsToCache: RequestArgs[];
+  };
+}
+
+/**
+ * The Router can be used to process a FetchEvent through one or more
+ * [Routes]{@link module: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 module:workbox-routing
+ */
+class Router {
+  private readonly _routes: Map<HTTPMethod, Route[]>;
+  private _defaultHandler?: HandlerObject;
+  private _catchHandler?: HandlerObject;
+
+  /**
+   * Initializes a new Router.
+   */
+  constructor() {
+    this._routes = new Map();
+  }
+
+  /**
+   * @return {Map<string, Array<module:workbox-routing.Route>>} routes A `Map` of HTTP
+   * method name ('GET', etc.) to an array of all the corresponding `Route`
+   * instances that are registered.
+   */
+  get routes() {
+    return this._routes;
+  }
+
+  /**
+   * Adds a fetch event listener to respond to events when a route matches
+   * the event's request.
+   */
+  addFetchListener() {
+    // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705
+    self.addEventListener('fetch', ((event: FetchEvent) => {
+      const {request} = event;
+      const responsePromise = this.handleRequest({request, event});
+      if (responsePromise) {
+        event.respondWith(responsePromise);
+      }
+    }) as EventListener);
+  }
+
+  /**
+   * Adds a message event listener for URLs to cache from the window.
+   * This is useful to cache resources loaded on the page prior to when the
+   * service worker started controlling it.
+   *
+   * The format of the message data sent from the window should be as follows.
+   * Where the `urlsToCache` array may consist of URL strings or an array of
+   * URL string + `requestInit` object (the same as you'd pass to `fetch()`).
+   *
+   * ```
+   * {
+   *   type: 'CACHE_URLS',
+   *   payload: {
+   *     urlsToCache: [
+   *       './script1.js',
+   *       './script2.js',
+   *       ['./script3.js', {mode: 'no-cors'}],
+   *     ],
+   *   },
+   * }
+   * ```
+   */
+  addCacheListener() {
+    // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705
+    self.addEventListener('message', ((event: ExtendableMessageEvent) => {
+      if (event.data && event.data.type === 'CACHE_URLS') {
+        const {payload}: CacheURLsMessageData = event.data;
+
+        if (process.env.NODE_ENV !== 'production') {
+          logger.debug(`Caching URLs from the window`, payload.urlsToCache);
+        }
+
+        const requestPromises = Promise.all(payload.urlsToCache.map(
+            (entry: string | [string, RequestInit?]) => {
+          if (typeof entry === 'string') {
+            entry = [entry];
+          }
+
+          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>`.
+        }) as any[]); // TypeScript
+
+        event.waitUntil(requestPromises);
+
+        // If a MessageChannel was used, reply to the message on success.
+        if (event.ports && event.ports[0]) {
+          requestPromises.then(() => event.ports[0].postMessage(true));
+        }
+      }
+    }) as EventListener);
+  }
+
+  /**
+   * Apply the routing rules to a FetchEvent object to get a Response from an
+   * appropriate Route's handler.
+   *
+   * @param {Object} options
+   * @param {Request} options.request The request to handle (this is usually
+   *     from a fetch event, but it does not have to be).
+   * @param {FetchEvent} [options.event] The event that triggered the request,
+   *     if applicable.
+   * @return {Promise<Response>|undefined} A promise is returned if a
+   *     registered route can handle the request. If there is no matching
+   *     route and there's no `defaultHandler`, `undefined` is returned.
+   */
+  handleRequest({request, event}: {
+    request: Request;
+    event?: ExtendableEvent;
+  }): Promise<Response> | undefined {
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.isInstance(request, Request, {
+        moduleName: 'workbox-routing',
+        className: 'Router',
+        funcName: 'handleRequest',
+        paramName: 'options.request',
+      });
+    }
+
+    const url = new URL(request.url, location.href);
+    if (!url.protocol.startsWith('http')) {
+      if (process.env.NODE_ENV !== 'production') {
+        logger.debug(
+            `Workbox Router only supports URLs that start with 'http'.`);
+      }
+      return;
+    }
+
+    const {params, route} = this.findMatchingRoute({url, request, event});
+    let handler = route && route.handler;
+
+    const debugMessages = [];
+    if (process.env.NODE_ENV !== 'production') {
+      if (handler) {
+        debugMessages.push([
+          `Found a route to handle this request:`, route,
+        ]);
+
+        if (params) {
+          debugMessages.push([
+            `Passing the following params to the route's handler:`, params,
+          ]);
+        }
+      }
+    }
+
+    // If we don't have a handler because there was no matching route, then
+    // fall back to defaultHandler if that's defined.
+    if (!handler && this._defaultHandler) {
+      if (process.env.NODE_ENV !== 'production') {
+        debugMessages.push(`Failed to find a matching route. Falling ` +
+          `back to the default handler.`);
+      }
+      handler = this._defaultHandler;
+    }
+
+    if (!handler) {
+      if (process.env.NODE_ENV !== 'production') {
+        // No handler so Workbox will do nothing. If logs is set of debug
+        // i.e. verbose, we should print out this information.
+        logger.debug(`No route found for: ${getFriendlyURL(url)}`);
+      }
+      return;
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      // We have a handler, meaning Workbox is going to handle the route.
+      // print the routing details to the console.
+      logger.groupCollapsed(`Router is responding to: ${getFriendlyURL(url)}`);
+
+      debugMessages.forEach((msg) => {
+        if (Array.isArray(msg)) {
+          logger.log(...msg);
+        } else {
+          logger.log(msg);
+        }
+      });
+
+      logger.groupEnd();
+    }
+
+    // Wrap in try and catch in case the handle method throws a synchronous
+    // error. It should still callback to the catch handler.
+    let responsePromise;
+    try {
+      responsePromise = handler.handle({url, request, event, params});
+    } catch (err) {
+      responsePromise = Promise.reject(err);
+    }
+
+    if (responsePromise instanceof Promise && this._catchHandler) {
+      responsePromise = responsePromise.catch((err) => {
+        if (process.env.NODE_ENV !== 'production') {
+          // Still include URL here as it will be async from the console group
+          // and may not make sense without the URL
+          logger.groupCollapsed(`Error thrown when responding to: ` +
+            ` ${getFriendlyURL(url)}. Falling back to Catch Handler.`);
+          logger.error(`Error thrown by:`, route);
+          logger.error(err);
+          logger.groupEnd();
+        }
+        return this._catchHandler!.handle({url, request, event});
+      });
+    }
+
+    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.
+   */
+  findMatchingRoute({url, request, event}: {
+    url: URL;
+    request: Request;
+    event?: ExtendableEvent;
+  }): {route?: Route; params?: HandlerCallbackOptions['params']} {
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.isInstance(url, URL, {
+        moduleName: 'workbox-routing',
+        className: 'Router',
+        funcName: 'findMatchingRoute',
+        paramName: 'options.url',
+      });
+      assert!.isInstance(request, Request, {
+        moduleName: 'workbox-routing',
+        className: 'Router',
+        funcName: 'findMatchingRoute',
+        paramName: 'options.request',
+      });
+    }
+
+    const routes = this._routes.get(request.method as HTTPMethod) || [];
+    for (const route of routes) {
+      let params;
+      const matchResult = route.match({url, request, event});
+      if (matchResult) {
+        // See https://github.com/GoogleChrome/workbox/issues/2079
+        params = matchResult;
+        if (Array.isArray(matchResult) && matchResult.length === 0) {
+          // Instead of passing an empty array in as params, use undefined.
+          params = undefined;
+        } else if ((matchResult.constructor === Object &&
+            Object.keys(matchResult).length === 0)) {
+          // Instead of passing an empty object in as params, use undefined.
+          params = undefined;
+        } else if (typeof matchResult === 'boolean') {
+          // For the boolean value true (rather than just something truth-y),
+          // don't set params.
+          // See https://github.com/GoogleChrome/workbox/pull/2134#issuecomment-513924353
+          params = undefined;
+        }
+
+        // Return early if have a match.
+        return {route, params};
+      }
+    }
+    // If no match was found above, return and empty object.
+    return {};
+  }
+
+  /**
+   * Define a default `handler` that's called when no routes explicitly
+   * match the incoming request.
+   *
+   * Without a default handler, unmatched requests will go against the
+   * network as if there were no service worker present.
+   *
+   * @param {module:workbox-routing~handlerCallback} handler A callback
+   * function that returns a Promise resulting in a Response.
+   */
+  setDefaultHandler(handler: 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 {module:workbox-routing~handlerCallback} handler A callback
+   * function that returns a Promise resulting in a Response.
+   */
+  setCatchHandler(handler: Handler) {
+    this._catchHandler = normalizeHandler(handler);
+  }
+
+  /**
+   * Registers a route with the router.
+   *
+   * @param {module:workbox-routing.Route} route The route to register.
+   */
+  registerRoute(route: Route) {
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.isType(route, 'object', {
+        moduleName: 'workbox-routing',
+        className: 'Router',
+        funcName: 'registerRoute',
+        paramName: 'route',
+      });
+
+      assert!.hasMethod(route, 'match', {
+        moduleName: 'workbox-routing',
+        className: 'Router',
+        funcName: 'registerRoute',
+        paramName: 'route',
+      });
+
+      assert!.isType(route.handler, 'object', {
+        moduleName: 'workbox-routing',
+        className: 'Router',
+        funcName: 'registerRoute',
+        paramName: 'route',
+      });
+
+      assert!.hasMethod(route.handler, 'handle', {
+        moduleName: 'workbox-routing',
+        className: 'Router',
+        funcName: 'registerRoute',
+        paramName: 'route.handler',
+      });
+
+      assert!.isType(route.method, 'string', {
+        moduleName: 'workbox-routing',
+        className: 'Router',
+        funcName: 'registerRoute',
+        paramName: 'route.method',
+      });
+    }
+
+    if (!this._routes.has(route.method)) {
+      this._routes.set(route.method, []);
+    }
+
+    // Give precedence to all of the earlier routes by adding this additional
+    // route to the end of the array.
+    this._routes.get(route.method)!.push(route);
+  }
+
+  /**
+   * Unregisters a route with the router.
+   *
+   * @param {module:workbox-routing.Route} route The route to unregister.
+   */
+  unregisterRoute(route: Route) {
+    if (!this._routes.has(route.method)) {
+      throw new 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('unregister-route-route-not-registered');
+    }
+  }
+}
+
+export {Router};

web/node_modules/workbox-routing/src/_types.ts

@@ -0,0 +1,81 @@
+/*
+  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.
+*/
+
+import {
+  RouteHandler,
+  RouteHandlerObject,
+  RouteHandlerCallback,
+  RouteHandlerCallbackOptions,
+  RouteMatchCallback,
+  RouteMatchCallbackOptions
+} from 'workbox-core/types.js';
+import './_version.js';
+
+ export {
+  RouteHandler as Handler,
+  RouteHandlerObject as HandlerObject,
+  RouteHandlerCallback as HandlerCallback,
+  RouteHandlerCallbackOptions as HandlerCallbackOptions,
+  RouteMatchCallback as MatchCallback,
+  RouteMatchCallbackOptions as MatchCallbackOptions,
+}
+
+// * * * IMPORTANT! * * *
+// ------------------------------------------------------------------------- //
+// jdsoc type definitions cannot be declared above TypeScript definitions or
+// they'll be stripped from the built `.js` files, and they'll only be in the
+// `d.ts` files, which aren't read by the jsdoc generator. As a result we
+// have to put declare them below.
+
+/**
+ * The "match" callback is used to determine if a `Route` should apply for a
+ * particular URL. When matching occurs in response to a fetch event from the
+ * client, the `event` and `request` objects are supplied in addition to the
+ * URL. However, since the match callback can be invoked outside of a fetch
+ * event, matching logic should not assume the `event` or `request` objects
+ * will always be available (unlike URL, which is always available).
+ * If the match callback returns a truthy value, the matching route's
+ * [handler callback]{@link module:workbox-routing~handlerCallback} will be
+ * invoked immediately. If the value returned is a non-empty array or object,
+ * that value will be set on the handler's `context.params` argument.
+ *
+ * @callback ~matchCallback
+ * @param {Object} context
+ * @param {URL} context.url The request's URL.
+ * @param {Request} [context.request] The corresponding request,
+ *     if available.
+ * @param {FetchEvent} [context.event] The corresponding event that triggered
+ *     the request, if available.
+ * @return {*} To signify a match, return a truthy value.
+ *
+ * @memberof module:workbox-routing
+ */
+
+/**
+ * The "handler" callback is invoked whenever a `Router` matches a URL to a
+ * `Route` via its [match]{@link module:workbox-routing~handlerCallback}
+ * callback. This callback should return a Promise that resolves with a
+ * `Response`.
+ *
+ * If a non-empty array or object is returned by the
+ * [match callback]{@link module:workbox-routing~matchCallback} it
+ * will be passed in as the handler's `context.params` argument.
+ *
+ * @callback ~handlerCallback
+ * @param {Object} context
+ * @param {Request|string} context.request The corresponding request.
+ * @param {URL} [context.url] The URL that matched, if available.
+ * @param {FetchEvent} [context.event] The corresponding event that triggered
+ *     the request, if available.
+ * @param {Object} [context.params] Array or Object parameters returned by the
+ *     Route's [match callback]{@link module:workbox-routing~matchCallback}.
+ *     This will be undefined if an empty array or object were returned.
+ * @return {Promise<Response>} The response that will fulfill the request.
+ *
+ * @memberof module:workbox-routing
+ */

web/node_modules/workbox-routing/src/_version.ts

@@ -0,0 +1,2 @@
+// @ts-ignore
+try{self['workbox:routing:5.1.4']&&_()}catch(e){}

web/node_modules/workbox-routing/src/index.ts

@@ -0,0 +1,32 @@
+/*
+  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.
+*/
+
+import {NavigationRoute} from './NavigationRoute.js';
+import {RegExpRoute} from './RegExpRoute.js';
+import {registerRoute} from './registerRoute.js';
+import {Route} from './Route.js';
+import {Router} from './Router.js';
+import {setCatchHandler} from './setCatchHandler.js';
+import {setDefaultHandler} from './setDefaultHandler.js';
+
+import './_version.js';
+
+
+/**
+ * @module workbox-routing
+ */
+
+export {
+  NavigationRoute,
+  RegExpRoute,
+  registerRoute,
+  Route,
+  Router,
+  setCatchHandler,
+  setDefaultHandler,
+};

web/node_modules/workbox-routing/src/registerRoute.ts

@@ -0,0 +1,110 @@
+/*
+  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.
+*/
+
+import {logger} from 'workbox-core/_private/logger.js';
+import {WorkboxError} from 'workbox-core/_private/WorkboxError.js';
+import {Route} from './Route.js';
+import {RegExpRoute} from './RegExpRoute.js';
+import {HTTPMethod} from './utils/constants.js';
+import {getOrCreateDefaultRouter} from './utils/getOrCreateDefaultRouter.js';
+import {Handler, MatchCallback} from './_types.js';
+import './_version.js';
+
+
+/**
+ * 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 [registerRoute()]{@link module:workbox-routing.Router#registerRoute}.
+ *
+ * @param {RegExp|string|module:workbox-routing.Route~matchCallback|module:workbox-routing.Route} capture
+ * If the capture param is a `Route`, all other arguments will be ignored.
+ * @param {module:workbox-routing~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 {module:workbox-routing.Route} The generated `Route`(Useful for
+ * unregistering).
+ *
+ * @memberof module:workbox-routing
+ */
+function registerRoute(
+    capture: RegExp | string | MatchCallback | Route,
+    handler?: Handler,
+    method?: HTTPMethod): Route {
+  let route;
+
+  if (typeof capture === 'string') {
+    const captureUrl = new URL(capture, location.href);
+
+    if (process.env.NODE_ENV !== 'production') {
+      if (!(capture.startsWith('/') || capture.startsWith('http'))) {
+        throw new WorkboxError('invalid-string', {
+          moduleName: 'workbox-routing',
+          funcName: 'registerRoute',
+          paramName: 'capture',
+        });
+      }
+
+      // We want to check if Express-style wildcards are in the pathname only.
+      // TODO: Remove this log message in v4.
+      const valueToCheck = capture.startsWith('http') ?
+          captureUrl.pathname : capture;
+
+      // See https://github.com/pillarjs/path-to-regexp#parameters
+      const wildcards = '[*:?+]';
+      if ((new RegExp(`${wildcards}`)).exec(valueToCheck)) {
+        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: MatchCallback = ({url}) => {
+      if (process.env.NODE_ENV !== 'production') {
+        if ((url.pathname === captureUrl.pathname) &&
+            (url.origin !== captureUrl.origin)) {
+          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;
+    };
+
+    // If `capture` is a string then `handler` and `method` must be present.
+    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('unsupported-route-type', {
+      moduleName: 'workbox-routing',
+      funcName: 'registerRoute',
+      paramName: 'capture',
+    });
+  }
+
+  const defaultRouter = getOrCreateDefaultRouter();
+  defaultRouter.registerRoute(route);
+
+  return route;
+}
+
+export {registerRoute}

web/node_modules/workbox-routing/src/setCatchHandler.ts

@@ -0,0 +1,27 @@
+/*
+  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.
+*/
+
+import {getOrCreateDefaultRouter} from './utils/getOrCreateDefaultRouter.js';
+import {Handler} from './_types.js';
+import './_version.js';
+
+/**
+ * If a Route throws an error while handling a request, this `handler`
+ * will be called and given a chance to provide a response.
+ *
+ * @param {module:workbox-routing~handlerCallback} handler A callback
+ * function that returns a Promise resulting in a Response.
+ *
+ * @memberof module:workbox-routing
+ */
+function setCatchHandler(handler: Handler) {
+  const defaultRouter = getOrCreateDefaultRouter();
+  defaultRouter.setCatchHandler(handler);
+}
+
+export {setCatchHandler}

web/node_modules/workbox-routing/src/setDefaultHandler.ts

@@ -0,0 +1,31 @@
+/*
+  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.
+*/
+
+import {getOrCreateDefaultRouter} from './utils/getOrCreateDefaultRouter.js';
+import {Handler} from './_types.js';
+import './_version.js';
+
+
+/**
+ * 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 {module:workbox-routing~handlerCallback} handler A callback
+ * function that returns a Promise resulting in a Response.
+ *
+ * @memberof module:workbox-routing
+ */
+function setDefaultHandler(handler: Handler) {
+  const defaultRouter = getOrCreateDefaultRouter();
+  defaultRouter.setDefaultHandler(handler);
+}
+
+export {setDefaultHandler}

web/node_modules/workbox-routing/src/utils/constants.ts

@@ -0,0 +1,38 @@
+/*
+  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.
+*/
+
+import '../_version.js';
+
+
+export type HTTPMethod = 'DELETE' | 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT';
+
+/**
+ * The default HTTP method, 'GET', used when there's no specific method
+ * configured for a route.
+ *
+ * @type {string}
+ *
+ * @private
+ */
+export const defaultMethod: HTTPMethod = 'GET';
+
+/**
+ * The list of valid HTTP methods associated with requests that could be routed.
+ *
+ * @type {Array<string>}
+ *
+ * @private
+ */
+export const validMethods: HTTPMethod[] = [
+  'DELETE',
+  'GET',
+  'HEAD',
+  'PATCH',
+  'POST',
+  'PUT',
+];

web/node_modules/workbox-routing/src/utils/getOrCreateDefaultRouter.ts

@@ -0,0 +1,30 @@
+/*
+  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.
+*/
+
+import {Router} from '../Router.js';
+import '../_version.js';
+
+let defaultRouter: Router;
+
+/**
+ * Creates a new, singleton Router instance if one does not exist. If one
+ * does already exist, that instance is returned.
+ *
+ * @private
+ * @return {Router}
+ */
+export const getOrCreateDefaultRouter = (): Router => {
+  if (!defaultRouter) {
+    defaultRouter = new Router();
+
+    // The helpers that use the default Router assume these listeners exist.
+    defaultRouter.addFetchListener();
+    defaultRouter.addCacheListener();
+  }
+  return defaultRouter;
+};

web/node_modules/workbox-routing/src/utils/normalizeHandler.ts

@@ -0,0 +1,45 @@
+/*
+  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.
+*/
+
+import {assert} from 'workbox-core/_private/assert.js';
+import {Handler, HandlerObject} from '../_types.js';
+import '../_version.js';
+
+
+/**
+ * @param {function()|Object} handler Either a function, or an object with a
+ * 'handle' method.
+ * @return {Object} An object with a handle method.
+ *
+ * @private
+ */
+export const normalizeHandler = (
+  handler: Handler
+): HandlerObject => {
+  if (handler && typeof handler === 'object') {
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.hasMethod(handler, 'handle', {
+        moduleName: 'workbox-routing',
+        className: 'Route',
+        funcName: 'constructor',
+        paramName: 'handler',
+      });
+    }
+    return handler;
+  } else {
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.isType(handler, 'function', {
+        moduleName: 'workbox-routing',
+        className: 'Route',
+        funcName: 'constructor',
+        paramName: 'handler',
+      });
+    }
+    return {handle: handler};
+  }
+};