serwist 9.0.2 → 9.0.4

package/dist/NavigationRoute.d.ts

@@ -15,9 +15,9 @@ export interface NavigationRouteMatchOptions {
     denylist?: RegExp[];
 }
 /**
- * `NavigationRoute` makes it easy to create a `Route` object that matches navigation requests.
+ * A class that makes it easy to create a {@linkcode Route} object that matches navigation requests.
  *
- * It will only match incoming Requests whose [`mode`](https://fetch.spec.whatwg.org/#concept-request-mode) is set to `"navigate"`.
+ * It will only match incoming requests whose [`mode`](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.

package/dist/PrecacheRoute.d.ts

@@ -2,13 +2,12 @@ import { Route } from "./Route.js";
 import type { Serwist } from "./Serwist.js";
 import type { PrecacheRouteOptions } from "./types.js";
 /**
- * A subclass of `Route` that takes a `serwist.Serwist` instance and uses it to match
+ * A subclass of {@linkcode Route} that takes a {@linkcode Serwist} instance and uses it to match
  * incoming requests and handle fetching responses from the precache.
  */
 export declare class PrecacheRoute extends Route {
     /**
-     * @param serwist A `Serwist` instance used to both match requests
-     * and respond to fetch events.
+     * @param serwist A {@linkcode Serwist} instance.
      * @param options Options to control how requests are matched
      * against the list of precached URLs.
      */

package/dist/PrecacheRoute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PrecacheRoute.d.ts","sourceRoot":"","sources":["../src/PrecacheRoute.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAKvD;;;GAGG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC;;;;;OAKG;gBACS,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,oBAAoB;CAkB7D"}
+{"version":3,"file":"PrecacheRoute.d.ts","sourceRoot":"","sources":["../src/PrecacheRoute.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAKvD;;;GAGG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC;;;;OAIG;gBACS,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,oBAAoB;CAkB7D"}

package/dist/RegExpRoute.d.ts

@@ -2,7 +2,7 @@ import { Route } from "./Route.js";
 import type { HTTPMethod } from "./constants.js";
 import type { RouteHandler } from "./types.js";
 /**
- * `RegExpRoute` makes it easy to create a `Route` object with a regular expression.
+ * A class that makes it easy to create a {@linkcode Route} object with a regular expression.
  *
  * 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
@@ -16,7 +16,7 @@ export declare class RegExpRoute extends Route {
      *
      * @param regExp The regular expression to match against URLs.
      * @param handler A callback function that returns a `Promise` resulting in a `Response`.
-     * @param method The HTTP method to match the route against. Defaults to `GET`.
+     * @param method The HTTP method to match the {@linkcode Route} against. Defaults to `GET`.
      * against.
      */
     constructor(regExp: RegExp, handler: RouteHandler, method?: HTTPMethod);

package/dist/Route.d.ts

@@ -1,11 +1,11 @@
 import type { HTTPMethod } from "./constants.js";
 import type { RouteHandler, RouteHandlerObject, RouteMatchCallback } from "./types.js";
 /**
- * A `Route` consists of a pair of callback functions, `match and `handler.
+ * A `Route` consists of a pair of callback functions, `match` and `handler`.
  * The `match` callback determines if a route should be used to handle a
- * request by returning a truthy value if it can. The `handler callback
- * is called when the route matches and should return a `Promise` that resolves
- * to a `Response`.
+ * request by returning a truthy value if it can. The `handler` callback
+ * is called when the route matches and should return a promise that resolves
+ * to a response.
  */
 export declare class Route {
     handler: RouteHandlerObject;

package/dist/Serwist.d.ts

@@ -100,7 +100,7 @@ export interface SerwistOptions {
      */
     runtimeCaching?: RuntimeCaching[];
     /**
-     * Your configuration for `initializeGoogleAnalytics`. This plugin is
+     * Your configuration for {@linkcode initializeGoogleAnalytics}. This plugin is
      * only initialized when this option is not `undefined` or `false`.
      */
     offlineAnalyticsConfig?: Omit<GoogleAnalyticsInitializeOptions, "serwist"> | boolean;
@@ -112,7 +112,7 @@ export interface SerwistOptions {
     disableDevLogs?: boolean;
     /**
      * Precaches routes so that they can be used as a fallback when
-     * a `Strategy` fails to generate a response.
+     * a {@linkcode Strategy} fails to generate a response.
      *
      * Note: This option mutates `runtimeCaching`. It also expects the URLs
      * defined in `entries` to have been precached beforehand.
@@ -135,11 +135,11 @@ export declare class Serwist {
     private _catchHandler?;
     constructor({ precacheEntries, precacheOptions, skipWaiting, importScripts, navigationPreload, cacheId, clientsClaim, runtimeCaching, offlineAnalyticsConfig, disableDevLogs, fallbacks, }?: SerwistOptions);
     /**
-     * The strategy used to precache assets and respond to fetch events.
+     * The strategy used to precache assets and respond to `fetch` events.
      */
     get precacheStrategy(): Strategy;
     /**
-     * A `Map` of HTTP method name (`'GET'`, etc.) to an array of all corresponding registered `Route`
+     * A `Map` of HTTP method name (`'GET'`, etc.) to an array of all corresponding registered {@linkcode Route}
      * instances.
      */
     get routes(): Map<HTTPMethod, Route[]>;
@@ -189,7 +189,7 @@ export declare class Serwist {
      */
     handleCache(event: ExtendableMessageEvent): void;
     /**
-     * Define a default `handler` that's called when no routes explicitly
+     * 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.
@@ -203,34 +203,34 @@ export declare class Serwist {
      */
     setDefaultHandler(handler: RouteHandler, method?: HTTPMethod): void;
     /**
-     * If a `Route` throws an error while handling a request, this `handler`
+     * If a {@linkcode Route} throws an error while handling a request, this handler
      * will be called and given a chance to provide a response.
      *
-     * @param handler A callback function that returns a Promise resulting
-     * in a Response.
+     * @param handler A callback function that returns a `Promise` resulting
+     * in a `Response`.
      */
     setCatchHandler(handler: RouteHandler): void;
     /**
      * Registers a `RegExp`, string, or function with a caching
      * strategy to the router.
      *
-     * @param capture If the capture param is a `Route`, all other arguments will be ignored.
+     * @param capture If the capture param is a {@linkcode Route} object, all other arguments will be ignored.
      * @param handler A callback function that returns a `Promise` resulting in a `Response`.
-     * This parameter is required if `capture` is not a `Route` object.
-     * @param method The HTTP method to match the Route against. Defaults to `'GET'`.
-     * @returns The generated `Route`.
+     * This parameter is required if `capture` is not a {@linkcode Route} object.
+     * @param method The HTTP method to match the route against. Defaults to `'GET'`.
+     * @returns The generated {@linkcode Route} object.
      */
     registerCapture<T extends RegExp | string | RouteMatchCallback | Route>(capture: T, handler?: T extends Route ? never : RouteHandler, method?: T extends Route ? never : HTTPMethod): Route;
     /**
-     * Registers a `Route` with the router.
+     * Registers a {@linkcode Route} with the router.
      *
-     * @param route The `Route` to register.
+     * @param route The {@linkcode Route} to register.
      */
     registerRoute(route: Route): void;
     /**
-     * Unregisters a `Route` with the router.
+     * Unregisters a route from the router.
      *
-     * @param route The `Route` to unregister.
+     * @param route The {@linkcode Route} object to unregister.
      */
     unregisterRoute(route: Route): void;
     /**
@@ -291,12 +291,12 @@ export declare class Serwist {
      */
     createHandlerBoundToUrl(url: string): RouteHandlerCallback;
     /**
-     * Applies the routing rules to a `FetchEvent` object to get a `Response` from an
-     * appropriate `Route`'s handler.
+     * Applies the routing rules to a `FetchEvent` object to get a response from an
+     * appropriate route.
      *
      * @param options
      * @returns A promise is returned if a registered route can handle the request.
-     * If there is no matching route and there's no `defaultHandler`, `undefined`
+     * If there is no matching route and there's no default handler, `undefined`
      * is returned.
      */
     handleRequest({ request, event, }: {

package/dist/chunks/printInstallDetails.js

@@ -487,18 +487,14 @@ class StrategyHandler {
         }
         if (!pluginsUsed) {
             if (responseToCache && responseToCache.status !== 200) {
-                responseToCache = undefined;
-            }
-            if (process.env.NODE_ENV !== "production") {
-                if (responseToCache) {
-                    if (responseToCache.status !== 200) {
-                        if (responseToCache.status === 0) {
-                            logger.warn(`The response for '${this.request.url}' is an opaque response. The caching strategy that you're using will not cache opaque responses by default.`);
-                        } else {
-                            logger.debug(`The response for '${this.request.url}' returned a status code of '${response.status}' and won't be cached as a result.`);
-                        }
+                if (process.env.NODE_ENV !== "production") {
+                    if (responseToCache.status === 0) {
+                        logger.warn(`The response for '${this.request.url}' is an opaque response. The caching strategy that you're using will not cache opaque responses by default.`);
+                    } else {
+                        logger.debug(`The response for '${this.request.url}' returned a status code of '${response.status}' and won't be cached as a result.`);
                     }
                 }
+                responseToCache = undefined;
             }
         }
         return responseToCache;

package/dist/copyResponse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"copyResponse.d.ts","sourceRoot":"","sources":["../src/copyResponse.ts"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,aAAoB,QAAQ,aAAa,CAAC,YAAY,EAAE,YAAY,KAAK,YAAY,KAAG,QAAQ,QAAQ,CA8BhI,CAAC"}
+{"version":3,"file":"copyResponse.d.ts","sourceRoot":"","sources":["../src/copyResponse.ts"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,aAAoB,QAAQ,aAAa,CAAC,YAAY,EAAE,YAAY,KAAK,YAAY,KAAG,OAAO,CAAC,QAAQ,CA8BhI,CAAC"}

package/dist/legacy/PrecacheController.d.ts

@@ -42,7 +42,7 @@ export declare class PrecacheController {
     constructor({ cacheName, plugins, fallbackToNetwork, concurrentPrecaching }?: PrecacheControllerOptions);
     /**
      * The strategy created by this controller and
-     * used to cache assets and respond to fetch events.
+     * used to cache assets and respond to `fetch` events.
      */
     get strategy(): Strategy;
     /**

package/dist/legacy/PrecacheFallbackPlugin.d.ts

@@ -24,22 +24,21 @@ export interface PrecacheFallbackPluginOptions {
      */
     fallbackUrls: (string | PrecacheFallbackEntry)[];
     /**
-     * An optional `PrecacheController` instance. If not provided, the default
-     * `PrecacheController` will be used.
+     * An optional {@linkcode PrecacheController} instance. If not provided,
+     * the default {@linkcode PrecacheController} will be used.
      */
     precacheController?: PrecacheController;
 }
 /**
- * `PrecacheFallbackPlugin` allows you to specify offline fallbacks
+ * A class that allows you to specify offline fallbacks
  * to be used when a given strategy is unable to generate a response.
  *
  * It does this by intercepting the `handlerDidError` plugin callback
  * and returning a precached response, taking the expected revision parameter
  * into account automatically.
  *
- * Unless you explicitly pass in a `PrecacheController` instance to the
- * constructor, the default instance will be used. Generally speaking, most
- * developers will end up using the default.
+ * Unless you explicitly pass in a {@linkcode PrecacheController} instance to the
+ * constructor, the default instance will be used.
  *
  * @deprecated
  */
@@ -47,7 +46,7 @@ export declare class PrecacheFallbackPlugin implements SerwistPlugin {
     private readonly _fallbackUrls;
     private readonly _precacheController;
     /**
-     * Constructs a new `PrecacheFallbackPlugin` with the associated `fallbackUrls`.
+     * Constructs a new instance with the associated `fallbackUrls`.
      *
      * @param config
      */

package/dist/legacy/PrecacheFallbackPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PrecacheFallbackPlugin.d.ts","sourceRoot":"","sources":["../../src/legacy/PrecacheFallbackPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,4BAA4B,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC/E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAGlE;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,OAAO,EAAE,CAAC,KAAK,EAAE,4BAA4B,KAAK,OAAO,CAAC;IAC1D;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,YAAY,EAAE,CAAC,MAAM,GAAG,qBAAqB,CAAC,EAAE,CAAC;IACjD;;;OAGG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;CACzC;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,sBAAuB,YAAW,aAAa;IAC1D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqC;IACnE,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqB;IAEzD;;;;OAIG;gBACS,EAAE,YAAY,EAAE,kBAAkB,EAAE,EAAE,6BAA6B;IAK/E;;;;OAIG;IACG,eAAe,CAAC,KAAK,EAAE,4BAA4B;CAgB1D"}
+{"version":3,"file":"PrecacheFallbackPlugin.d.ts","sourceRoot":"","sources":["../../src/legacy/PrecacheFallbackPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,4BAA4B,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC/E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAGlE;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,OAAO,EAAE,CAAC,KAAK,EAAE,4BAA4B,KAAK,OAAO,CAAC;IAC1D;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,YAAY,EAAE,CAAC,MAAM,GAAG,qBAAqB,CAAC,EAAE,CAAC;IACjD;;;OAGG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;CACzC;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,sBAAuB,YAAW,aAAa;IAC1D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqC;IACnE,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqB;IAEzD;;;;OAIG;gBACS,EAAE,YAAY,EAAE,kBAAkB,EAAE,EAAE,6BAA6B;IAK/E;;;;OAIG;IACG,eAAe,CAAC,KAAK,EAAE,4BAA4B;CAgB1D"}

package/dist/legacy/PrecacheRoute.d.ts

@@ -2,15 +2,15 @@ import { Route } from "../Route.js";
 import type { PrecacheRouteOptions } from "../types.js";
 import type { PrecacheController } from "./PrecacheController.js";
 /**
- * A subclass of `serwist.Route` that takes a `serwist/legacy.PrecacheController`
+ * A subclass of {@linkcode Route} that takes a {@linkcode PrecacheController}
  * instance and uses it to match incoming requests and handle fetching
  * responses from the precache.
  * @deprecated
  */
 export declare class PrecacheRoute extends Route {
     /**
-     * @param precacheController A `PrecacheController`
-     * instance used to both match requests and respond to fetch events.
+     * @param precacheController A {@linkcode PrecacheController}
+     * instance used to both match requests and respond to `fetch` events.
      * @param options Options to control how requests are matched
      * against the list of precached URLs.
      */

package/dist/legacy/Router.d.ts

@@ -2,15 +2,15 @@ import type { Route } from "../Route.js";
 import type { HTTPMethod } from "../constants.js";
 import type { RouteHandler, RouteHandlerCallbackOptions, RouteMatchCallback, RouteMatchCallbackOptions } from "../types.js";
 /**
- * `Router` can be used to process a `FetchEvent` using one or more `Route`(s), responding with a `Response`
+ * A class that can be used to process a `fetch` event using one or more route(s), responding with a response
  * if a matching route exists.
  *
- * If no `Route` matches given a `Request`, the `Router` will use the default handler if one is defined.
+ * If no route matches given a request, the router will use the default handler if one is defined.
  *
- * Should the matching Route throw an error, the Router will use the catch handler if one is defined to
- * gracefully deal with issues and respond with a `Request`.
+ * Should the matching route throw an error, the router will use the catch handler if one is defined to
+ * gracefully deal with issues and respond with a response.
  *
- * If a `Request` matches multiple routes, the earliest registered route will be used to respond to the `Request`.
+ * If a request matches multiple routes, the earliest registered route will be used to respond to the it.
  * @deprecated
  */
 export declare class Router {
@@ -24,13 +24,13 @@ export declare class Router {
      */
     constructor();
     /**
-     * @returns routes A `Map` of HTTP method name (`'GET'`, etc.) to an array of all the corresponding `Route`
-     * instances that are registered.
+     * @returns routes A `Map` of HTTP method name (`'GET'`, etc.) to an array of all
+     * the corresponding {@linkcode Route} instances that are registered.
      */
     get routes(): Map<HTTPMethod, Route[]>;
     /**
-     * Adds a `fetch` event listener to respond to events when a `Route` matches
-     * the event's request. Effectively no-op if `addFEtchListener` has been
+     * Adds a `fetch` event listener to respond to events when a route matches
+     * the event's request. Effectively no-op if `addFetchListener` has been
      * called, but `removeFetchListener` has not.
      */
     addFetchListener(): void;
@@ -71,8 +71,8 @@ export declare class Router {
      */
     removeCacheListener(): void;
     /**
-     * Apply the routing rules to a `FetchEvent` object to get a `Response` from an
-     * appropriate `Route`'s handler.
+     * Apply the routing rules to a `fetch` event to get a response from an
+     * appropriate route.
      *
      * @param options
      * @returns A promise is returned if a registered route can handle the request.
@@ -103,7 +103,7 @@ export declare class Router {
         params?: RouteHandlerCallbackOptions["params"];
     };
     /**
-     * Define a default `handler` that's called when no routes explicitly
+     * 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.
@@ -111,7 +111,7 @@ export declare class Router {
      * Without a default handler, unmatched requests will go against the
      * network as if there were no service worker present.
      *
-     * @param handler A callback function that returns a `Promise` resulting in a `Response`.
+     * @param handler A callback function that returns a promise resulting in a response.
      * @param method The HTTP method to associate with this default handler. Each method
      * has its own default. Defaults to `'GET'`.
      */
@@ -126,25 +126,25 @@ export declare class Router {
     setCatchHandler(handler: RouteHandler): void;
     /**
      * Registers a `RegExp`, string, or function with a caching
-     * strategy to the `Router`.
+     * strategy to the router.
      *
-     * @param capture If the capture param is a `Route`, all other arguments will be ignored.
-     * @param handler A callback function that returns a `Promise` resulting in a `Response`.
-     * This parameter is required if `capture` is not a `Route` object.
-     * @param method The HTTP method to match the Route against. Defaults to `'GET'`.
-     * @returns The generated `Route`.
+     * @param capture If the capture param is a {@linkcode Route} object, all other arguments will be ignored.
+     * @param handler A callback function that returns a promise resulting in a response.
+     * This parameter is required if `capture` is not a {@linkcode Route} object.
+     * @param method The HTTP method to match the route against. Defaults to `'GET'`.
+     * @returns The generated {@linkcode Route} object.
      */
     registerCapture(capture: RegExp | string | RouteMatchCallback | Route, handler?: RouteHandler, method?: HTTPMethod): Route;
     /**
-     * Registers a `Route` with the router.
+     * Registers a route with the router.
      *
-     * @param route The `Route` to register.
+     * @param route The route to register.
      */
     registerRoute(route: Route): void;
     /**
-     * Unregisters a `Route` with the `Router`.
+     * Unregisters a route from the router.
      *
-     * @param route The `Route` to unregister.
+     * @param route The route to unregister.
      */
     unregisterRoute(route: Route): void;
 }

package/dist/legacy/addRoute.d.ts

@@ -1,15 +1,13 @@
 import type { PrecacheRouteOptions } from "../types.js";
 /**
- * Add a `fetch` listener to the service worker that will
- * respond to
- * [network requests](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests)
- * with precached assets.
+ * Add a `fetch` listener that will
+ * respond to [network requests](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests)
+ * with precached assets to the service worker.
  *
- * Requests for assets that aren't precached, the `FetchEvent` will not be
- * responded to, allowing the event to fall through to other `fetch` event
- * listeners.
+ * As for requests for assets that aren't precached, the `fetch` event will not be
+ * responded to, allowing the event to fall through to other `fetch` event listeners.
  *
- * @param options See `serwist.PrecacheRouteOptions`.
+ * @param options See {@linkcode PrecacheRouteOptions}.
  * @deprecated
  */
 export declare const addRoute: (options?: PrecacheRouteOptions) => void;

package/dist/legacy/addRoute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"addRoute.d.ts","sourceRoot":"","sources":["../../src/legacy/addRoute.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAKxD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,aAAc,oBAAoB,KAAG,IAGzD,CAAC"}
+{"version":3,"file":"addRoute.d.ts","sourceRoot":"","sources":["../../src/legacy/addRoute.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAKxD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,QAAQ,aAAc,oBAAoB,KAAG,IAGzD,CAAC"}

package/dist/legacy/createHandlerBoundToURL.d.ts

@@ -1,14 +1,13 @@
 import type { RouteHandlerCallback } from "../types.js";
 /**
- * Helper function that calls `PrecacheController#createHandlerBoundToURL`
- * on the default `PrecacheController` instance.
+ * Helper function that calls {@linkcode PrecacheController.createHandlerBoundToURL}
+ * on the default {@linkcode PrecacheController} instance.
  *
- * If you are creating your own `PrecacheController`, then call the
- * `PrecacheController#createHandlerBoundToURL` on that instance,
+ * If you are creating your own {@linkcode PrecacheController}, then call the
+ * {@linkcode PrecacheController.createHandlerBoundToURL} function on that instance
  * instead of using this function.
  *
- * @param url The precached URL which will be used to lookup the
- * `Response`.
+ * @param url The precached URL which will be used to look up the response.
  * @param fallbackToNetwork Whether to attempt to get the
  * response from the network if there's a precache miss.
  * @return

package/dist/legacy/createHandlerBoundToURL.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createHandlerBoundToURL.d.ts","sourceRoot":"","sources":["../../src/legacy/createHandlerBoundToURL.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAGxD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,uBAAuB,QAAS,MAAM,KAAG,oBAGrD,CAAC"}
+{"version":3,"file":"createHandlerBoundToURL.d.ts","sourceRoot":"","sources":["../../src/legacy/createHandlerBoundToURL.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAIxD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uBAAuB,QAAS,MAAM,KAAG,oBAGrD,CAAC"}

package/dist/legacy/fallbacks.d.ts

@@ -21,12 +21,12 @@ export interface FallbacksOptions {
 }
 export interface FallbacksOptions {
     /**
-     * An optional `PrecacheController` instance. If not provided, the singleton
-     * `PrecacheController` will be used.
+     * An optional {@linkcode PrecacheController} instance. If not provided, the singleton
+     * {@linkcode PrecacheController} will be used.
      */
     precacheController?: PrecacheController;
     /**
-     * An optional `Router` instance. If not provided, the singleton `Router`
+     * An optional {@linkcode Router} instance. If not provided, the singleton {@linkcode Router}
      * will be used.
      */
     router?: Router;

package/dist/legacy/handlePrecaching.d.ts

@@ -6,12 +6,12 @@ import type { Router } from "./Router.js";
  */
 export interface HandlePrecachingOptions {
     /**
-     * An optional `PrecacheController` instance. If not provided, the singleton
-     * `PrecacheController` will be used.
+     * An optional {@linkcode PrecacheController} instance. If not provided, the singleton
+     * {@linkcode PrecacheController} will be used.
      */
     precacheController?: PrecacheController;
     /**
-     * An optional `Router` instance. If not provided, the singleton `Router`
+     * An optional {@linkcode Router} instance. If not provided, the singleton {@linkcode Router}
      * will be used.
      */
     router?: Router;

package/dist/legacy/initializeGoogleAnalytics.d.ts

@@ -4,7 +4,7 @@ import { Router } from "./Router.js";
  */
 export interface GoogleAnalyticsInitializeOptions {
     /**
-     * An optional `Router` instance. If not provided, the singleton `Router`
+     * An optional {@linkcode Router} instance. If not provided, the singleton {@linkcode Router}
      * will be used.
      */
     router?: Router;

package/dist/legacy/installSerwist.d.ts

@@ -5,18 +5,18 @@ import type { FallbacksOptions } from "./fallbacks.js";
 import { type HandlePrecachingOptions } from "./handlePrecaching.js";
 import type { GoogleAnalyticsInitializeOptions } from "./initializeGoogleAnalytics.js";
 /**
- * Options for `installSerwist`.
+ * Options for {@linkcode installSerwist}.
  *
  * @deprecated
  */
 export interface InstallSerwistOptions extends Omit<HandlePrecachingOptions, "precacheController" | "router"> {
     /**
-     * An optional `PrecacheController` instance. If not provided, the singleton
-     * `PrecacheController` will be used.
+     * An optional {@linkcode PrecacheController} instance. If not provided, the singleton
+     * {@linkcode PrecacheController} will be used.
      */
     precacheController?: PrecacheController;
     /**
-     * An optional `Router` instance. If not provided, the singleton `Router`
+     * An optional {@linkcode Router} instance. If not provided, the singleton {@linkcode Router}
      * will be used.
      */
     router?: Router;

package/dist/legacy/matchPrecache.d.ts

@@ -1,9 +1,9 @@
 /**
- * Helper function that calls `PrecacheController#matchPrecache`
- * on the default `PrecacheController` instance.
+ * Helper function that calls {@linkcode PrecacheController.matchPrecache}
+ * on the default {@linkcode PrecacheController} instance.
  *
- * If you are creating your own `PrecacheController`, then call
- * `PrecacheController#matchPrecache` on that instance,
+ * If you are creating your own {@linkcode PrecacheController}, then call
+ * the {@linkcode PrecacheController.matchPrecache} function on that instance
  * instead of using this function.
  *
  * @param request The key (without revisioning parameters)

package/dist/legacy/matchPrecache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matchPrecache.d.ts","sourceRoot":"","sources":["../../src/legacy/matchPrecache.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,YAAa,MAAM,GAAG,OAAO,KAAG,QAAQ,QAAQ,GAAG,SAAS,CAErF,CAAC"}
+{"version":3,"file":"matchPrecache.d.ts","sourceRoot":"","sources":["../../src/legacy/matchPrecache.ts"],"names":[],"mappings":"AAWA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,YAAa,MAAM,GAAG,OAAO,KAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAErF,CAAC"}

package/dist/legacy/precache.d.ts

@@ -8,10 +8,10 @@ import type { PrecacheEntry } from "../types.js";
  *
  * Please note: This method **will not** serve any of the cached files for you.
  * It only precaches files. To respond to a network request you call
- * `serwist/legacy.addRoute`.
+ * {@linkcode addRoute}.
  *
  * If you have a single array of files to precache, you can just call
- * `serwist/legacy.precacheAndRoute`.
+ * {@linkcode precacheAndRoute}.
  *
  * @param entries Array of entries to precache.
  * @deprecated

package/dist/legacy/precache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"precache.d.ts","sourceRoot":"","sources":["../../src/legacy/precache.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,QAAQ,YAAa,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,KAAG,IAE9D,CAAC"}
+{"version":3,"file":"precache.d.ts","sourceRoot":"","sources":["../../src/legacy/precache.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAKjD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,QAAQ,YAAa,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,KAAG,IAE9D,CAAC"}

package/dist/legacy/precacheAndRoute.d.ts

@@ -1,14 +1,13 @@
 import type { PrecacheEntry, PrecacheRouteOptions } from "../types.js";
 /**
  * This method will add entries to the precache list and add a route to
- * respond to fetch events.
+ * respond to `fetch` events.
  *
  * This is a convenience method that will call
- * `serwist/legacy.precache` and
- * `serwist/legacy.addRoute` in a single call.
+ * {@linkcode precache} and {@linkcode addRoute} in a single call.
  *
  * @param entries Array of entries to precache.
- * @param options See the `serwist.PrecacheRouteOptions` options.
+ * @param options See the {@linkcode PrecacheRouteOptions} options.
  * @deprecated
  */
 export declare const precacheAndRoute: (entries: (PrecacheEntry | string)[], options?: PrecacheRouteOptions) => void;

package/dist/legacy/precacheAndRoute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"precacheAndRoute.d.ts","sourceRoot":"","sources":["../../src/legacy/precacheAndRoute.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAIvE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,YAAa,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,YAAY,oBAAoB,KAAG,IAGtG,CAAC"}
+{"version":3,"file":"precacheAndRoute.d.ts","sourceRoot":"","sources":["../../src/legacy/precacheAndRoute.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAIvE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,YAAa,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,YAAY,oBAAoB,KAAG,IAGtG,CAAC"}

package/dist/legacy/registerRoute.d.ts

@@ -3,13 +3,13 @@ import type { HTTPMethod } from "../constants.js";
 import type { RouteHandler, RouteMatchCallback } from "../types.js";
 /**
  * Registers a `RegExp`, string, or function with a caching
- * strategy to a singleton `Router` instance.
+ * strategy to a singleton {@linkcode Router} instance.
  *
- * @param capture If the capture param is a `Route`, all other arguments will be ignored.
- * @param handler A callback function that returns a `Promise` resulting in a `Response`.
- * This parameter is required if `capture` is not a `Route` object.
- * @param method The HTTP method to match the `Route` against. Defaults to `'GET'`.
- * @returns The generated `Route`, which can then be provided to `unregisterRoute` if needed.
+ * @param capture If the capture param is a {@linkcode Route}, all other arguments will be ignored.
+ * @param handler A callback function that returns a promise resulting in a response.
+ * This parameter is required if `capture` is not a {@linkcode Route} object.
+ * @param method The HTTP method to match the route against. Defaults to `'GET'`.
+ * @returns The generated {@linkcode Route} object, which can then be provided to {@linkcode unregisterRoute} if needed.
  * @deprecated
  */
 export declare const registerRoute: (capture: RegExp | string | RouteMatchCallback | Route, handler?: RouteHandler, method?: HTTPMethod) => Route;

package/dist/legacy/registerRoute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registerRoute.d.ts","sourceRoot":"","sources":["../../src/legacy/registerRoute.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAGpE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,YAAa,MAAM,GAAG,MAAM,GAAG,kBAAkB,GAAG,KAAK,YAAY,YAAY,WAAW,UAAU,KAAG,KAElI,CAAC"}
+{"version":3,"file":"registerRoute.d.ts","sourceRoot":"","sources":["../../src/legacy/registerRoute.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAIpE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,YAAa,MAAM,GAAG,MAAM,GAAG,kBAAkB,GAAG,KAAK,YAAY,YAAY,WAAW,UAAU,KAAG,KAElI,CAAC"}

package/dist/legacy/registerRuntimeCaching.d.ts

@@ -1,7 +1,7 @@
 import type { RuntimeCaching } from "../types.js";
 /**
  * Registers caching strategies to a singleton Router instance. It is a simple
- * syntatic sugar for `serwist/legacy.registerRoute`.
+ * syntatic sugar for {@linkcode registerRoute}.
  *
  * @param runtimeCachingList
  * @returns

package/dist/legacy/setCatchHandler.d.ts

@@ -1,9 +1,9 @@
 import type { RouteHandler } from "../types.js";
 /**
- * If a `Route` throws an error while handling a request, this `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 handler A callback function that returns a Promise resulting in a Response.
+ * @param handler A callback function that returns a promise resulting in a response.
  * @deprecated
  */
 export declare const setCatchHandler: (handler: RouteHandler) => void;