serwist 9.0.2 → 9.0.4

package/src/lib/expiration/ExpirationPlugin.ts

@@ -14,11 +14,13 @@ import { cacheNames as privateCacheNames } from "../../utils/cacheNames.js";
 import { getFriendlyURL } from "../../utils/getFriendlyURL.js";
 import { logger } from "../../utils/logger.js";
 import { CacheExpiration } from "./CacheExpiration.js";
+import type { Strategy } from "../strategies/Strategy.js";
 
 export interface ExpirationPluginOptions {
   /**
-   * The maximum number of entries to cache. Entries used the least will be removed
-   * as the maximum is reached.
+   * The maximum number of entries to cache. Entries used (if `maxAgeFrom` is
+   * `"last-used"`) or fetched from the network (if `maxAgeFrom` is `"last-fetched"`)
+   * least recently will be removed as the maximum is reached.
    */
   maxEntries?: number;
   /**
@@ -44,10 +46,10 @@ export interface ExpirationPluginOptions {
 }
 
 /**
- * This plugin can be used in a `serwist/strategies` Strategy to regularly enforce a
+ * This plugin can be used in a {@linkcode Strategy} to regularly enforce a
  * limit on the age and/or the number of cached requests.
  *
- * It can only be used with Strategy instances that have a custom `cacheName` property set.
+ * It can only be used with {@linkcode Strategy} instances that have a custom `cacheName` property set.
  * In other words, it can't be used to expire entries in strategies that use the default runtime
  * cache name.
  *
@@ -143,11 +145,10 @@ export class ExpirationPlugin implements SerwistPlugin {
   }
 
   /**
-   * A "lifecycle" callback that will be triggered automatically by the
-   * `serwist/strategies` handlers when a `Response` is about to be returned
-   * from a [Cache](https://developer.mozilla.org/en-US/docs/Web/API/Cache) to
-   * the handler. It allows the `Response` to be inspected for freshness and
-   * prevents it from being used if the `Response`'s `Date` header value is
+   * A lifecycle callback that will be triggered automatically when a 
+   * response is about to be returned from a [`Cache`](https://developer.mozilla.org/en-US/docs/Web/API/Cache).
+   * It allows the response to be inspected for freshness and
+   * prevents it from being used if the response's `Date` header value is
    * older than the configured `maxAgeSeconds`.
    *
    * @param options
@@ -247,8 +248,8 @@ export class ExpirationPlugin implements SerwistPlugin {
   }
 
   /**
-   * A "lifecycle" callback that will be triggered automatically by the
-   * `serwist/strategies` handlers when an entry is added to a cache.
+   * A lifecycle callback that will be triggered automatically when an entry is added
+   * to a cache.
    *
    * @param options
    * @private

package/src/lib/precaching/PrecacheFallbackPlugin.ts

@@ -28,14 +28,14 @@ export interface PrecacheFallbackPluginOptions {
    */
   fallbackUrls: (string | PrecacheFallbackEntry)[];
   /**
-   * Your `Serwist` instance.
+   * A {@linkcode Serwist} instance.
    */
   serwist: Serwist;
 }
 
 /**
- * `PrecacheFallbackPlugin` allows you to specify offline fallbacks
- * to be used when a given strategy is unable to generate a response.
+ * 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
@@ -46,7 +46,7 @@ export class PrecacheFallbackPlugin implements SerwistPlugin {
   private readonly _serwist: Serwist;
 
   /**
-   * Constructs a new `PrecacheFallbackPlugin` with the associated `fallbackUrls`.
+   * Constructs a new instance with the associated `fallbackUrls`.
    *
    * @param config
    */

package/src/lib/rangeRequests/RangeRequestsPlugin.ts

@@ -10,8 +10,7 @@ import type { SerwistPlugin } from "../../types.js";
 import { createPartialResponse } from "./createPartialResponse.js";
 
 /**
- * The range request plugin makes it easy for a request with a 'Range' header to
- * be fulfilled by a cached response.
+ * Makes it easy for a request with a `Range` header to be fulfilled by a cached response.
  *
  * It does this by intercepting the `cachedResponseWillBeUsed` plugin callback
  * and returning the appropriate subset of the cached response body.
@@ -19,8 +18,8 @@ import { createPartialResponse } from "./createPartialResponse.js";
 export class RangeRequestsPlugin implements SerwistPlugin {
   /**
    * @param options
-   * @returns If request contains a 'Range' header, then a
-   * new response with status 206 whose body is a subset of `cachedResponse` is
+   * @returns If request contains a `Range` header, then a
+   * partial response whose body is a subset of `cachedResponse` is
    * returned. Otherwise, `cachedResponse` is returned as-is.
    * @private
    */

package/src/lib/rangeRequests/createPartialResponse.ts

@@ -13,20 +13,20 @@ import { calculateEffectiveBoundaries } from "./utils/calculateEffectiveBoundari
 import { parseRangeHeader } from "./utils/parseRangeHeader.js";
 
 /**
- * Given a `Request` and `Response` objects as input, this will return a
- * promise for a new `Response`.
+ * Given a request and a response, this will return a
+ * promise that resolves to a partial response.
  *
- * If the original `Response` already contains partial content (i.e. it has
- * a status of 206), then this assumes it already fulfills the `Range:`
+ * If the original response already contains partial content (i.e. it has
+ * a status of 206), then this assumes it already fulfills the `Range`
  * requirements, and will return it as-is.
  *
- * @param request A request, which should contain a Range:
+ * @param request A request, which should contain a `Range`
  * header.
  * @param originalResponse A response.
  * @returns Either a `206 Partial Content` response, with
  * the response body set to the slice of content specified by the request's
- * `Range:` header, or a `416 Range Not Satisfiable` response if the
- * conditions of the `Range:` header can't be met.
+ * `Range` header, or a `416 Range Not Satisfiable` response if the
+ * conditions of the `Range` header can't be met.
  */
 export const createPartialResponse = async (request: Request, originalResponse: Response): Promise<Response> => {
   try {

package/src/lib/rangeRequests/utils/parseRangeHeader.ts

@@ -10,9 +10,9 @@ import { SerwistError } from "../../../utils/SerwistError.js";
 import { assert } from "../../../utils/assert.js";
 
 /**
- * @param rangeHeader A Range: header value.
+ * @param rangeHeader A `Range` header value.
  * @returns An object with `start` and `end` properties, reflecting
- * the parsed value of the Range: header. If either the `start` or `end` are
+ * the parsed value of the `Range` header. If either the `start` or `end` are
  * omitted, then `null` will be returned.
  * @private
  */

package/src/lib/strategies/CacheFirst.ts

@@ -22,7 +22,7 @@ import { messages } from "./utils/messages.js";
  * can be cached for long periods of time.
  *
  * If the network request fails, and there is no cache match, this will throw
- * a `SerwistError` exception.
+ * a {@linkcode SerwistError} exception.
  */
 export class CacheFirst extends Strategy {
   /**

package/src/lib/strategies/CacheOnly.ts

@@ -19,7 +19,7 @@ import { messages } from "./utils/messages.js";
  *
  * This class is useful if you already have your own precaching step.
  *
- * If there is no cache match, this will throw a `SerwistError` exception.
+ * If there is no cache match, this will throw a {@linkcode SerwistError} exception.
  */
 export class CacheOnly extends Strategy {
   /**

package/src/lib/strategies/NetworkFirst.ts

@@ -32,7 +32,7 @@ export interface NetworkFirstOptions extends StrategyOptions {
  * support [CORS](https://enable-cors.org/).
  *
  * If the network request fails, and there is no cache match, this will throw
- * a `SerwistError` exception.
+ * a {@linkcode SerwistError} exception.
  */
 export class NetworkFirst extends Strategy {
   private readonly _networkTimeoutSeconds: number;

package/src/lib/strategies/NetworkOnly.ts

@@ -28,7 +28,7 @@ export interface NetworkOnlyOptions extends Omit<StrategyOptions, "cacheName" |
  *
  * This class is useful if you require specific requests to only be fulfilled from the network.
  *
- * If the network request fails, this will throw a `SerwistError` exception.
+ * If the network request fails, this will throw a {@linkcode SerwistError} exception.
  */
 export class NetworkOnly extends Strategy {
   private readonly _networkTimeoutSeconds: number;

package/src/lib/strategies/PrecacheStrategy.ts

@@ -12,6 +12,7 @@ import { SerwistError } from "../../utils/SerwistError.js";
 import { cacheNames as privateCacheNames } from "../../utils/cacheNames.js";
 import { getFriendlyURL } from "../../utils/getFriendlyURL.js";
 import { logger } from "../../utils/logger.js";
+import type { Serwist } from "../../Serwist.js";
 import type { StrategyOptions } from "./Strategy.js";
 import { Strategy } from "./Strategy.js";
 import type { StrategyHandler } from "./StrategyHandler.js";
@@ -25,11 +26,11 @@ interface PrecacheStrategyOptions extends StrategyOptions {
 }
 
 /**
- * A `serwist/strategies.Strategy` implementation
- * specifically designed to both cache and fetch precached assets.
+ * A {@linkcode Strategy} implementation specifically designed to both cache
+ * and fetch precached assets.
  *
  * Note: an instance of this class is created automatically when creating a
- * `Serwist` instance; it's generally not necessary to create this yourself.
+ * {@linkcode Serwist} instance; it's generally not necessary to create this yourself.
  */
 export class PrecacheStrategy extends Strategy {
   private readonly _fallbackToNetwork: boolean;

package/src/lib/strategies/StaleWhileRevalidate.ts

@@ -31,7 +31,7 @@ import { messages } from "./utils/messages.js";
  * support [CORS](https://enable-cors.org/).
  *
  * If the network request fails, and there is no cache match, this will throw
- * a `SerwistError` exception.
+ * a {@linkcode SerwistError} exception.
  */
 export class StaleWhileRevalidate extends Strategy {
   /**

package/src/lib/strategies/Strategy.ts

@@ -66,13 +66,13 @@ export abstract class Strategy implements RouteHandlerObject {
   }
 
   /**
-   * Performs a request strategy and returns a `Promise` that will resolve with
-   * a `Response`, invoking all relevant plugin callbacks.
+   * Performs a request strategy and returns a promise that will resolve to
+   * a response, invoking all relevant plugin callbacks.
    *
-   * When a strategy instance is registered with a `Route`, this method is automatically
+   * When a strategy instance is registered with a route, this method is automatically
    * called when the route matches.
    *
-   * Alternatively, this method can be used in a standalone `FetchEvent`
+   * Alternatively, this method can be used in a standalone `fetch` event
    * listener by passing it to `event.respondWith()`.
    *
    * @param options A `FetchEvent` or an object with the properties listed below.
@@ -87,10 +87,10 @@ export abstract class Strategy implements RouteHandlerObject {
   }
 
   /**
-   * Similar to `handle()`, but instead of just returning a `Promise` that
-   * resolves to a `Response`, it will return an tuple of `[response, done]` promises,
+   * Similar to `handle()`, but instead of just returning a promise that
+   * resolves to a response, it will return an tuple of `[response, done]` promises,
    * where `response` is equivalent to what `handle()` returns, and `done` is a
-   * `Promise` that will resolve once all promises added to `event.waitUntil()` as a part
+   * promise that will resolve once all promises added to `event.waitUntil()` as a part
    * of performing the strategy have completed.
    *
    * You can await the `done` promise to ensure any extra work performed by

package/src/lib/strategies/StrategyHandler.ts

@@ -16,14 +16,15 @@ import { getFriendlyURL } from "../../utils/getFriendlyURL.js";
 import { logger } from "../../utils/logger.js";
 import { timeout } from "../../utils/timeout.js";
 import type { Strategy } from "./Strategy.js";
+import type { Route } from "../../Route.js";
 
 function toRequest(input: RequestInfo) {
   return typeof input === "string" ? new Request(input) : input;
 }
 
 /**
- * A class created every time a `Strategy` instance calls `Strategy.handle` or
- * `Strategy.handleAll` that wraps all fetch and cache actions around plugin callbacks
+ * A class created every time a {@linkcode Strategy} instance calls {@linkcode Strategy.handle} or
+ * {@linkcode Strategy.handleAll} that wraps all fetch and cache actions around plugin callbacks
  * and keeps track of when the strategy is "done" (i.e. when all added `event.waitUntil()` promises
  * have resolved).
  */
@@ -41,15 +42,16 @@ export class StrategyHandler {
    * A `URL` instance of `request.url` (if passed to the strategy's
    * `handle()` or `handleAll()` method).
    * Note: the `url` param will be present if the strategy is invoked
-   * from a `Route` object.
+   * from a {@linkcode Route} object.
    */
   public url?: URL;
   /**
    * Some additional params (if passed to the strategy's
    * `handle()` or `handleAll()` method).
+   * 
    * Note: the `params` param will be present if the strategy is invoked
-   * from a `Route` object and that route's matcher returned a truthy value
-   * (it will be that value).
+   * from a {@linkcode Route} object and that route's matcher returned a truthy
+   * value (it will be that value).
    */
   public params?: string[] | MapLikeObject;
 
@@ -115,7 +117,7 @@ export class StrategyHandler {
   /**
    * Fetches a given request (and invokes any applicable plugin callback
    * methods), taking the `fetchOptions` (for non-navigation requests) and
-   * `plugins` provided to the `Strategy` object into account.
+   * `plugins` provided to the {@linkcode Strategy} object into account.
    *
    * The following plugin lifecycle methods are invoked when using this method:
    * - `requestWillFetch()`
@@ -262,7 +264,7 @@ export class StrategyHandler {
   /**
    * Puts a request/response pair into the cache (and invokes any applicable
    * plugin callback method) using the `cacheName` and `plugins` provided to
-   * the `Strategy` object.
+   * the {@linkcode Strategy} object.
    *
    * The following plugin lifecycle methods are invoked when using this method:
    * - `cacheKeyWillBeUsed`
@@ -271,7 +273,7 @@ export class StrategyHandler {
    *
    * @param key The request or URL to use as the cache key.
    * @param response The response to cache.
-   * @returns `false` if a cacheWillUpdate caused the response
+   * @returns `false` if a `cacheWillUpdate` caused the response to
    * not be cached, and `true` otherwise.
    */
   async cachePut(key: RequestInfo, response: Response): Promise<boolean> {
@@ -369,7 +371,7 @@ export class StrategyHandler {
   }
 
   /**
-   * Checks the `plugins` provided to the `Strategy` object for `cacheKeyWillBeUsed`
+   * Checks the `plugins` provided to the {@linkcode Strategy} object for `cacheKeyWillBeUsed`
    * callbacks and executes found callbacks in sequence. The final `Request`
    * object returned by the last plugin is treated as the cache key for cache
    * reads and/or writes. If no `cacheKeyWillBeUsed` plugin callbacks have
@@ -422,7 +424,7 @@ export class StrategyHandler {
    *
    * Note: since this method runs all plugins, it's not suitable for cases
    * where the return value of a callback needs to be applied prior to calling
-   * the next callback. See `serwist/strategies.iterateCallbacks` for how to handle that case.
+   * the next callback. See {@linkcode StrategyHandler.iterateCallbacks} for how to handle that case.
    *
    * @param name The name of the callback to run within each plugin.
    * @param param The object to pass as the first (and only) param when executing each callback. This object will be merged with the
@@ -463,9 +465,7 @@ export class StrategyHandler {
    * [extend lifetime promises](https://w3c.github.io/ServiceWorker/#extendableevent-extend-lifetime-promises)
    * of the event event associated with the request being handled (usually a `FetchEvent`).
    *
-   * Note: you can await
-   * `serwist/strategies.StrategyHandler.doneWaiting`
-   * to know when all added promises have settled.
+   * Note: you can await {@linkcode StrategyHandler.doneWaiting} to know when all added promises have settled.
    *
    * @param promise A promise to add to the extend lifetime promises of
    * the event that triggered the request.
@@ -526,20 +526,16 @@ export 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;
       }
     }
 

package/src/types.ts

@@ -1,4 +1,6 @@
 import type { HTTPMethod } from "./constants.js";
+import type { Route } from "./Route.js";
+import type { Serwist } from "./Serwist.js";
 
 export type PromiseOrNot<T> = T | Promise<T>;
 
@@ -7,13 +9,13 @@ export interface MapLikeObject {
 }
 
 /**
- * Using a plain `MapLikeObject` for now, but could extend/restrict this
+ * Using a plain {@linkcode MapLikeObject} for now, but could extend/restrict this
  * in the future.
  */
 export type PluginState = MapLikeObject;
 
 /**
- * Options passed to a `RouteMatchCallback` function.
+ * Options passed to a {@linkcode RouteMatchCallback} function.
  */
 export interface RouteMatchCallbackOptions {
   event: ExtendableEvent;
@@ -23,20 +25,22 @@ export interface RouteMatchCallbackOptions {
 }
 
 /**
- * The "match" callback is used to determine if a `Route` should apply for a
- * particular URL and request. When matching occurs in response to a fetch
- * event from the client, the `event` object is also supplied. 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.
+ * The match callback is used to determine if a route should apply for a
+ * particular URL and request. 
+ * 
+ * When matching occurs in response to a `fetch` event from the client, the `event`
+ * object is also supplied. 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
- * `RouteHandlerCallback` will be invoked immediately. If the value returned
- * is a non-empty array or object, that value will be set on the handler's
- * `options.params` argument.
+ * handler will be invoked immediately. If the value returned is a non-empty array
+ * or object, that value will be the handler's `options.params` argument.
  */
 export type RouteMatchCallback = (options: RouteMatchCallbackOptions) => any;
 
 /**
- * Options passed to a `RouteHandlerCallback` function.
+ * Options passed to a {@linkcode RouteHandlerCallback} function.
  */
 export interface RouteHandlerCallbackOptions {
   /**
@@ -51,7 +55,7 @@ export interface RouteHandlerCallbackOptions {
   params?: string[] | MapLikeObject;
 }
 /**
- * Options passed to a `ManualHandlerCallback` function.
+ * Options passed to a {@linkcode ManualHandlerCallback} function.
  */
 export interface ManualHandlerCallbackOptions {
   /**
@@ -64,7 +68,7 @@ export interface ManualHandlerCallbackOptions {
   request: Request | string;
   url?: never;
   /**
-   * The return value from `serwist.matchCallback` (if applicable).
+   * The return value from {@linkcode RouteMatchCallback} (if applicable).
    */
   params?: never;
 }
@@ -72,38 +76,37 @@ export interface ManualHandlerCallbackOptions {
 export type HandlerCallbackOptions = RouteHandlerCallbackOptions | ManualHandlerCallbackOptions;
 
 /**
- * The "handler" callback is invoked whenever a `Router` matches a URL/Request
- * to a `Route` via its `RouteMatchCallback`. This handler callback should
- * return a `Promise` that resolves with a `Response`.
+ * The "handler" callback is invoked whenever a request is matched to a 
+ * {@linkcode Route} via its {@linkcode RouteMatchCallback} This handler
+ * callback should return a promise that resolves to a response.
  *
- * If a non-empty array or object is returned by the `RouteMatchCallback` it
+ * If a non-empty array or object is returned by the matcher, it
  * will be passed in as this handler's `options.params` argument.
  */
 export type RouteHandlerCallback = (options: RouteHandlerCallbackOptions) => Promise<Response>;
 
 /**
- * The "handler" callback is invoked whenever a `Router` matches a URL/Request
- * to a `Route` via its `RouteMatchCallback`. This handler callback should
- * return a `Promise` that resolves with a `Response`.
+ * The "handler" callback is invoked whenever a request is matched to a 
+ * {@linkcode Route} via its {@linkcode RouteMatchCallback} This handler
+ * callback should return a promise that resolves to a response.
  *
- * If a non-empty array or object is returned by the `RouteMatchCallback` it
+ * If a non-empty array or object is returned by the matcher, it
  * will be passed in as this handler's `options.params` argument.
  */
 export type ManualHandlerCallback = (options: ManualHandlerCallbackOptions) => Promise<Response>;
 
 /**
- * An object with a `handle` method of type `RouteHandlerCallback`.
+ * An object with a `handle` method of type {@linkcode RouteHandlerCallback}.
  *
- * A `Route` object can be created with either an `RouteHandlerCallback`
- * function or this `RouteHandler` object. The benefit of the `RouteHandler`
- * is it can be extended (as is done by the `serwist/strategies` package).
+ * A {@linkcode Route} object can be created with either an `RouteHandlerCallback`
+ * function or this {@linkcode RouteHandler} object.
  */
 export interface RouteHandlerObject {
   handle: RouteHandlerCallback;
 }
 
 /**
- * Either a `RouteHandlerCallback` or a `RouteHandlerObject`.
+ * Either a {@linkcode RouteHandlerCallback} or a {@linkcode RouteHandlerObject}.
  * Most APIs that accept route handlers take either.
  */
 export type RouteHandler = RouteHandlerCallback | RouteHandlerObject;
@@ -123,11 +126,11 @@ export interface CacheDidUpdateCallbackParam {
    */
   cacheName: string;
   /**
-   * Possibly updated response to compare.
+   * The possibly updated response.
    */
   newResponse: Response;
   /**
-   * The `Request` object for the cached entry.
+   * The request for the cached entry.
    */
   request: Request;
   /**
@@ -135,7 +138,7 @@ export interface CacheDidUpdateCallbackParam {
    */
   event: ExtendableEvent;
   /**
-   * Cached response to compare.
+   * The previous cached response.
    */
   oldResponse?: Response | null;
   state?: PluginState;
@@ -300,19 +303,19 @@ export interface RuntimeCaching {
    */
   method?: HTTPMethod;
   /**
-   * This match criteria determines whether the configured handler will
-   * generate a response for any requests that don't match one of the precached
-   * URLs. If multiple `RuntimeCaching` routes are defined, then the first one
-   * whose `matcher` matches will be the one that responds.
+   * The match callback determines whether the configured handler will be used to
+   * generate a response for any request that doesn't match one of the precached
+   * URLs. If multiple routes are defined, then the first one to match the request
+   * will be the one that responds.
    *
    * This value directly maps to the first parameter passed to
-   * `Serwist.registerRoute`. It's recommended to use a
-   * `serwist.RouteMatchCallback` function for greatest flexibility.
+   * {@linkcode Serwist.registerRoute}. It's recommended to use a
+   * {@linkcode RouteMatchCallback} function for greatest flexibility.
    */
   matcher: RegExp | string | RouteMatchCallback;
   /**
    * This determines how the runtime route will generate a response. It
-   * can be a `serwist.RouteHandler` callback function with custom
+   * can be a {@linkcode RouteHandler} callback function with custom
    * response logic.
    */
   handler: RouteHandler;

package/src/utils/cacheNames.ts

@@ -5,6 +5,7 @@
   license that can be found in the LICENSE file or at
   https://opensource.org/licenses/MIT.
 */
+import type { initializeGoogleAnalytics } from "../lib/googleAnalytics/initializeGoogleAnalytics.js";
 
 declare let registration: ServiceWorkerRegistration | undefined;
 
@@ -34,7 +35,7 @@ export interface PartialCacheNameDetails {
    */
   runtime?: string;
   /**
-   * The cache name to use for `@serwist/google-analytics` caching.
+   * The cache name to use for {@linkcode initializeGoogleAnalytics}.
    */
   googleAnalytics?: string;
   [propName: string]: string | undefined;

package/src/utils/canConstructResponseFromBodyStream.ts

@@ -10,10 +10,10 @@ let supportStatus: boolean | undefined;
 
 /**
  * A utility function that determines whether the current browser supports
- * constructing a new `Response` from a `response.body` stream.
+ * constructing a new response from a `response.body` stream.
  *
  * @returns `true`, if the current browser can successfully construct
- * a `Response` from a `response.body` stream, `false` otherwise.
+ * a response from a `response.body` stream, `false` otherwise.
  * @private
  */
 function canConstructResponseFromBodyStream(): boolean {

package/src/utils/parseRoute.ts

@@ -6,15 +6,15 @@ import { SerwistError } from "./SerwistError.js";
 import { logger } from "./logger.js";
 
 /**
- * Parses a `RegExp`, string, or function with a caching strategy into a `Route`. This is for
- * when you want to create a `Route`, but you don't want to register it just yet: sometimes
- * you want to call `setCatchHandler` first, for example.
+ * Parses a `RegExp`, string, or function with a caching strategy into a {@linkcode Route}. This is for
+ * when you want to create a {@linkcode Route}, but you don't want to register it just yet: sometimes
+ * you want to call {@linkcode Route.setCatchHandler} first, for example.
  *
- * @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}.
  */
 export const parseRoute = (capture: RegExp | string | RouteMatchCallback | Route, handler?: RouteHandler, method?: HTTPMethod): Route => {
   if (typeof capture === "string") {