asd

25_01_07/mai/node_modules/workbox-routing/src/NavigationRoute.ts

@@ -0,0 +1,143 @@
+/*
+  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 {RouteHandler, RouteMatchCallbackOptions} from 'workbox-core/types.js';
+
+import {Route} from './Route.js';
+
+import './_version.js';
+
+export interface NavigationRouteMatchOptions {
+  allowlist?: RegExp[];
+  denylist?: RegExp[];
+}
+
+/**
+ * NavigationRoute makes it easy to create a
+ * {@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
+ * {@link https://fetch.spec.whatwg.org/#concept-request-mode|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 workbox-routing
+ * @extends 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.
+   *
+   * *Note*: These RegExps may be evaluated against every destination URL during
+   * a navigation. Avoid using
+   * [complex RegExps](https://github.com/GoogleChrome/workbox/issues/3077),
+   * or else your users may see delays when navigating your site.
+   *
+   * @param {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: RouteHandler,
+    {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: RouteMatchCallbackOptions) => 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}: RouteMatchCallbackOptions): 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.toString()}`,
+          );
+        }
+        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};

25_01_07/mai/node_modules/workbox-routing/src/RegExpRoute.ts

@@ -0,0 +1,92 @@
+/*
+  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 {
+  RouteHandler,
+  RouteMatchCallback,
+  RouteMatchCallbackOptions,
+} from 'workbox-core/types.js';
+
+import {HTTPMethod} from './utils/constants.js';
+import {Route} from './Route.js';
+
+import './_version.js';
+
+/**
+ * RegExpRoute makes it easy to create a regular expression based
+ * {@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.
+ *
+ * @memberof workbox-routing
+ * @extends 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
+   * {@link workbox-routing~handlerCallback} `params`
+   * argument.
+   *
+   * @param {RegExp} regExp The regular expression to match against URLs.
+   * @param {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: RouteHandler, method?: HTTPMethod) {
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.isInstance(regExp, RegExp, {
+        moduleName: 'workbox-routing',
+        className: 'RegExpRoute',
+        funcName: 'constructor',
+        paramName: 'pattern',
+      });
+    }
+
+    const match: RouteMatchCallback = ({url}: RouteMatchCallbackOptions) => {
+      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.toString()}' only partially matched ` +
+              `against the cross-origin URL '${url.toString()}'. 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};

25_01_07/mai/node_modules/workbox-routing/src/Route.ts

@@ -0,0 +1,80 @@
+/*
+  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 {
+  RouteHandler,
+  RouteHandlerObject,
+  RouteMatchCallback,
+} from 'workbox-core/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 workbox-routing
+ */
+class Route {
+  handler: RouteHandlerObject;
+  match: RouteMatchCallback;
+  method: HTTPMethod;
+  catchHandler?: RouteHandlerObject;
+
+  /**
+   * Constructor for Route class.
+   *
+   * @param {workbox-routing~matchCallback} match
+   * A callback function that determines whether the route matches a given
+   * `fetch` event by returning a non-falsy value.
+   * @param {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: RouteMatchCallback,
+    handler: RouteHandler,
+    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;
+  }
+
+  /**
+   *
+   * @param {workbox-routing-handlerCallback} handler A callback
+   * function that returns a Promise resolving to a Response
+   */
+  setCatchHandler(handler: RouteHandler): void {
+    this.catchHandler = normalizeHandler(handler);
+  }
+}
+
+export {Route};

25_01_07/mai/node_modules/workbox-routing/src/Router.ts

@@ -0,0 +1,489 @@
+/*
+  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 {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.js';
+import {
+  RouteHandler,
+  RouteHandlerObject,
+  RouteHandlerCallbackOptions,
+  RouteMatchCallbackOptions,
+} from 'workbox-core/types.js';
+import {HTTPMethod, defaultMethod} from './utils/constants.js';
+import {logger} from 'workbox-core/_private/logger.js';
+import {normalizeHandler} from './utils/normalizeHandler.js';
+import {Route} from './Route.js';
+import {WorkboxError} from 'workbox-core/_private/WorkboxError.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` using one or more
+ * {@link workbox-routing.Route}, responding with a `Response` 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 {
+  private readonly _routes: Map<HTTPMethod, Route[]>;
+  private readonly _defaultHandlerMap: Map<HTTPMethod, RouteHandlerObject>;
+  private _catchHandler?: RouteHandlerObject;
+
+  /**
+   * Initializes a new Router.
+   */
+  constructor() {
+    this._routes = new Map();
+    this._defaultHandlerMap = new Map();
+  }
+
+  /**
+   * @return {Map<string, Array<workbox-routing.Route>>} routes A `Map` of HTTP
+   * method name ('GET', etc.) to an array of all the corresponding `Route`
+   * instances that are registered.
+   */
+  get routes(): Map<HTTPMethod, Route[]> {
+    return this._routes;
+  }
+
+  /**
+   * Adds a fetch event listener to respond to events when a route matches
+   * the event's request.
+   */
+  addFetchListener(): void {
+    // 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(): void {
+    // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705
+    self.addEventListener('message', ((event: ExtendableMessageEvent) => {
+      // event.data is type 'any'
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      if (event.data && event.data.type === 'CACHE_URLS') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        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, event});
+
+            // 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]) {
+          void 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.
+   * @param {ExtendableEvent} options.event The event that triggered the
+   *     request.
+   * @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 sameOrigin = url.origin === location.origin;
+    const {params, route} = this.findMatchingRoute({
+      event,
+      request,
+      sameOrigin,
+      url,
+    });
+    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.
+    const method = request.method as HTTPMethod;
+    if (!handler && this._defaultHandlerMap.has(method)) {
+      if (process.env.NODE_ENV !== 'production') {
+        debugMessages.push(
+          `Failed to find a matching route. Falling ` +
+            `back to the default handler for ${method}.`,
+        );
+      }
+      handler = this._defaultHandlerMap.get(method);
+    }
+
+    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);
+    }
+
+    // Get route's catch handler, if it exists
+    const catchHandler = route && route.catchHandler;
+
+    if (
+      responsePromise instanceof Promise &&
+      (this._catchHandler || catchHandler)
+    ) {
+      responsePromise = responsePromise.catch(async (err) => {
+        // If there's a route catch handler, process that first
+        if (catchHandler) {
+          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 route's Catch Handler.`,
+            );
+            logger.error(`Error thrown by:`, route);
+            logger.error(err);
+            logger.groupEnd();
+          }
+
+          try {
+            return await catchHandler.handle({url, request, event, params});
+          } catch (catchErr) {
+            if (catchErr instanceof Error) {
+              err = catchErr;
+            }
+          }
+        }
+
+        if (this._catchHandler) {
+          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 global Catch Handler.`,
+            );
+            logger.error(`Error thrown by:`, route);
+            logger.error(err);
+            logger.groupEnd();
+          }
+          return this._catchHandler.handle({url, request, event});
+        }
+
+        throw 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 {boolean} options.sameOrigin The result of comparing `url.origin`
+   *     against the current origin.
+   * @param {Request} options.request The request to match.
+   * @param {Event} options.event The corresponding event.
+   * @return {Object} An object with `route` and `params` properties.
+   *     They are populated if a matching route was found or `undefined`
+   *     otherwise.
+   */
+  findMatchingRoute({
+    url,
+    sameOrigin,
+    request,
+    event,
+  }: RouteMatchCallbackOptions): {
+    route?: Route;
+    params?: RouteHandlerCallbackOptions['params'];
+  } {
+    const routes = this._routes.get(request.method as HTTPMethod) || [];
+    for (const route of routes) {
+      let params: Promise<any> | undefined;
+      // route.match returns type any, not possible to change right now.
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      const matchResult = route.match({url, sameOrigin, request, event});
+      if (matchResult) {
+        if (process.env.NODE_ENV !== 'production') {
+          // Warn developers that using an async matchCallback is almost always
+          // not the right thing to do.
+          if (matchResult instanceof Promise) {
+            logger.warn(
+              `While routing ${getFriendlyURL(url)}, an async ` +
+                `matchCallback function was used. Please convert the ` +
+                `following route to use a synchronous matchCallback function:`,
+              route,
+            );
+          }
+        }
+
+        // See https://github.com/GoogleChrome/workbox/issues/2079
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        params = matchResult;
+        if (Array.isArray(params) && params.length === 0) {
+          // Instead of passing an empty array in as params, use undefined.
+          params = undefined;
+        } else if (
+          matchResult.constructor === Object && // eslint-disable-line
+          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.
+   *
+   * Each HTTP method ('GET', 'POST', etc.) gets its own default handler.
+   *
+   * Without a default handler, unmatched requests will go against the
+   * network as if there were no service worker present.
+   *
+   * @param {workbox-routing~handlerCallback} handler A callback
+   * function that returns a Promise resulting in a Response.
+   * @param {string} [method='GET'] The HTTP method to associate with this
+   * default handler. Each method has its own default.
+   */
+  setDefaultHandler(
+    handler: RouteHandler,
+    method: HTTPMethod = defaultMethod,
+  ): void {
+    this._defaultHandlerMap.set(method, 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~handlerCallback} handler A callback
+   * function that returns a Promise resulting in a Response.
+   */
+  setCatchHandler(handler: RouteHandler): void {
+    this._catchHandler = normalizeHandler(handler);
+  }
+
+  /**
+   * Registers a route with the router.
+   *
+   * @param {workbox-routing.Route} route The route to register.
+   */
+  registerRoute(route: Route): void {
+    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 {workbox-routing.Route} route The route to unregister.
+   */
+  unregisterRoute(route: Route): void {
+    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};

25_01_07/mai/node_modules/workbox-routing/src/_types.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 './_version.js';
+
+// * * * 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` object is supplied in addition to the `url`, `request`,
+ * and `sameOrigin` value. However, since the match callback can be invoked
+ * outside of a fetch event, matching logic should not assume the `event`
+ * object will always be available.
+ *
+ * If the match callback returns a truthy value, the matching route's
+ * {@link 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 {Request} context.request The corresponding request.
+ * @param {URL} context.url The request's URL.
+ * @param {ExtendableEvent} context.event The corresponding event that triggered
+ *     the request.
+ * @param {boolean} context.sameOrigin The result of comparing `url.origin`
+ *     against the current origin.
+ * @return {*} To signify a match, return a truthy value.
+ *
+ * @memberof workbox-routing
+ */
+
+/**
+ * The "handler" callback is invoked whenever a `Router` matches a URL to a
+ * `Route` via its {@link workbox-routing~matchCallback}
+ * callback. This callback should return a Promise that resolves with a
+ * `Response`.
+ *
+ * If a non-empty array or object is returned by the
+ * {@link 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 {ExtendableEvent} context.event The corresponding event that triggered
+ *     the request.
+ * @param {Object} [context.params] Array or Object parameters returned by the
+ *     Route's {@link 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 workbox-routing
+ */

25_01_07/mai/node_modules/workbox-routing/src/_version.ts

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

25_01_07/mai/node_modules/workbox-routing/src/index.ts

@@ -0,0 +1,35 @@
+/*
+  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,
+  NavigationRouteMatchOptions,
+} 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,
+  NavigationRouteMatchOptions,
+};

25_01_07/mai/node_modules/workbox-routing/src/registerRoute.ts

@@ -0,0 +1,115 @@
+/*
+  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 {RouteHandler, RouteMatchCallback} from 'workbox-core/types.js';
+
+import {Route} from './Route.js';
+import {RegExpRoute} from './RegExpRoute.js';
+import {HTTPMethod} from './utils/constants.js';
+import {getOrCreateDefaultRouter} from './utils/getOrCreateDefaultRouter.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 {@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~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`.
+ *
+ * @memberof workbox-routing
+ */
+function registerRoute(
+  capture: RegExp | string | RouteMatchCallback | Route,
+  handler?: RouteHandler,
+  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: RouteMatchCallback = ({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.toString()}. 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};

25_01_07/mai/node_modules/workbox-routing/src/setCatchHandler.ts

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

25_01_07/mai/node_modules/workbox-routing/src/setDefaultHandler.ts

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

25_01_07/mai/node_modules/workbox-routing/src/utils/constants.ts

@@ -0,0 +1,37 @@
+/*
+  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',
+];

25_01_07/mai/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;
+};

25_01_07/mai/node_modules/workbox-routing/src/utils/normalizeHandler.ts

@@ -0,0 +1,43 @@
+/*
+  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 {RouteHandler, RouteHandlerObject} from 'workbox-core/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: RouteHandler): RouteHandlerObject => {
+  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};
+  }
+};