serwist 9.0.2 → 9.0.4

package/src/legacy/Router.ts

@@ -29,15 +29,15 @@ interface CacheURLsMessageData {
 }
 
 /**
- * `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 class Router {
@@ -56,16 +56,16 @@ export class Router {
   }
 
   /**
-   * @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[]> {
     return this._routes;
   }
 
   /**
-   * 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 {
@@ -161,8 +161,8 @@ export class Router {
   }
 
   /**
-   * 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.
@@ -367,7 +367,7 @@ export class Router {
   }
 
   /**
-   * 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.
@@ -375,7 +375,7 @@ export 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'`.
    */
@@ -396,13 +396,13 @@ export class Router {
 
   /**
    * 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 {
     const route = parseRoute(capture, handler, method);
@@ -411,9 +411,9 @@ export class Router {
   }
 
   /**
-   * 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 {
     if (process.env.NODE_ENV !== "production") {
@@ -463,9 +463,9 @@ export class Router {
   }
 
   /**
-   * 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 {
     if (!this._routes.has(route.method)) {

package/src/legacy/addRoute.ts

@@ -11,16 +11,14 @@ import { registerRoute } from "./registerRoute.js";
 import { getSingletonPrecacheController } from "./singletonPrecacheController.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 const addRoute = (options?: PrecacheRouteOptions): void => {

package/src/legacy/createHandlerBoundToURL.ts

@@ -7,18 +7,18 @@
 */
 
 import type { RouteHandlerCallback } from "../types.js";
+import type { PrecacheController } from "./PrecacheController.js";
 import { getSingletonPrecacheController } from "./singletonPrecacheController.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/src/legacy/fallbacks.ts

@@ -29,12 +29,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/src/legacy/handlePrecaching.ts

@@ -13,12 +13,12 @@ import { getSingletonRouter } from "./singletonRouter.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/src/legacy/initializeGoogleAnalytics.ts

@@ -33,7 +33,7 @@ import { getSingletonRouter } from "./singletonRouter.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/src/legacy/installSerwist.ts

@@ -17,18 +17,18 @@ import { getSingletonRouter } from "./singletonRouter.js";
 declare const self: ServiceWorkerGlobalScope;
 
 /**
- * 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/src/legacy/matchPrecache.ts

@@ -7,13 +7,14 @@
 */
 
 import { getSingletonPrecacheController } from "./singletonPrecacheController.js";
+import type { PrecacheController } from "./PrecacheController.js";
 
 /**
- * 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/src/legacy/precache.ts

@@ -8,6 +8,8 @@
 
 import type { PrecacheEntry } from "../types.js";
 import { getSingletonPrecacheController } from "./singletonPrecacheController.js";
+import type { addRoute } from "./addRoute.js";
+import type { precacheAndRoute } from "./precacheAndRoute.js";
 
 /**
  * Adds items to the precache list, removing any duplicates and
@@ -18,10 +20,10 @@ import { getSingletonPrecacheController } from "./singletonPrecacheController.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/src/legacy/precacheAndRoute.ts

@@ -12,14 +12,13 @@ import { precache } from "./precache.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 const precacheAndRoute = (entries: (PrecacheEntry | string)[], options?: PrecacheRouteOptions): void => {

package/src/legacy/registerRoute.ts

@@ -5,21 +5,22 @@
   license that can be found in the LICENSE file or at
   https://opensource.org/licenses/MIT.
 */
-
+import type { Router } from "./Router.js";
 import type { Route } from "../Route.js";
 import type { HTTPMethod } from "../constants.js";
 import type { RouteHandler, RouteMatchCallback } from "../types.js";
+import type { unregisterRoute } from "./unregisterRoute.js";
 import { getSingletonRouter } from "./singletonRouter.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 const registerRoute = (capture: RegExp | string | RouteMatchCallback | Route, handler?: RouteHandler, method?: HTTPMethod): Route => {

package/src/legacy/registerRuntimeCaching.ts

@@ -4,7 +4,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/src/legacy/setCatchHandler.ts

@@ -10,10 +10,10 @@ import type { RouteHandler } from "../types.js";
 import { getSingletonRouter } from "./singletonRouter.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 const setCatchHandler = (handler: RouteHandler): void => {

package/src/legacy/setDefaultHandler.ts

@@ -10,13 +10,13 @@ import type { RouteHandler } from "../types.js";
 import { getSingletonRouter } from "./singletonRouter.js";
 
 /**
- * Defines a default `handler` that's called when no routes explicitly
+ * Defines a default handler that's called when no routes explicitly
  * match the incoming request.
  *
- * Without a default `handler`, unmatched requests will go against the
+ * 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.
  * @deprecated
  */
 export const setDefaultHandler = (handler: RouteHandler): void => {

package/src/legacy/singletonPrecacheController.ts

@@ -11,12 +11,12 @@ import { PrecacheController } from "./PrecacheController.js";
 let defaultPrecacheController: PrecacheController | undefined = undefined;
 
 /**
- * Creates a new, singleton `PrecacheController` if one does not exist. If one does
+ * Creates a new, singleton {@linkcode PrecacheController} if one does not exist. If one does
  * already exist, that instance is returned. This instance is used by Serwist's
- * `PrecacheController`-dependent functions and classes unless you provide a different
- * `Router` to them.
+ * {@linkcode PrecacheController}-dependent functions and classes unless you provide a different
+ * {@linkcode PrecacheController} to them.
  *
- * @returns The singleton `PrecacheController`.
+ * @returns The singleton {@linkcode PrecacheController}.
  * @deprecated
  */
 export const getSingletonPrecacheController = (): PrecacheController => {
@@ -27,8 +27,8 @@ export const getSingletonPrecacheController = (): PrecacheController => {
 };
 
 /**
- * Changes the singleton `PrecacheController` to a different instance. This is meant for when you do not
- * want to pass your own `PrecacheController` to every one of Serwist's `PrecacheController`-dependent
+ * Changes the singleton {@linkcode PrecacheController} to a different instance. This is meant for when you do not
+ * want to pass your own {@linkcode PrecacheController} to every one of Serwist's {@linkcode PrecacheController}-dependent
  * functions and classes.
  *
  * It is highly recommended that you call this before anything else, if you plan on doing so.
@@ -44,7 +44,7 @@ export const getSingletonPrecacheController = (): PrecacheController => {
  * // Do something with your controller...
  * ```
  * @param router
- * @returns The new singleton `PrecacheController`.
+ * @returns The new singleton {@linkcode PrecacheController}.
  * @deprecated
  */
 export const setSingletonPrecacheController = (precacheController: PrecacheController): PrecacheController => {

package/src/legacy/singletonRouter.ts

@@ -11,12 +11,12 @@ import { Router } from "./Router.js";
 let defaultRouter: Router | undefined = undefined;
 
 /**
- * Creates a new, singleton `Router` if one does not exist. If one does
+ * Creates a new, singleton {@linkcode Router} if one does not exist. If one does
  * already exist, that instance is returned. This instance is used by
- * Serwist's `Router`-dependent functions and classes unless you provide
- * a different `Router` to them.
+ * Serwist's {@linkcode Router}-dependent functions and classes unless you provide
+ * a different {@linkcode Router} to them.
  *
- * @returns The singleton `Router`.
+ * @returns The singleton {@linkcode Router}.
  * @deprecated
  */
 export const getSingletonRouter = (): Router => {
@@ -31,10 +31,10 @@ export const getSingletonRouter = (): Router => {
 };
 
 /**
- * Changes the singleton `Router` to a different instance. This is meant for when you do not
- * want to pass your own `Router` to every one of Serwist's `Router`-dependent functions and classes.
- * If this or `getSingletonRouter` has been called before, it removes the listeners of the
- * previous singleton `Router`. It also adds those of the new one, so you need not do that yourself.
+ * Changes the singleton {@linkcode Router} to a different instance. This is meant for when you do not
+ * want to pass your own {@linkcode Router} to every one of Serwist's {@linkcode Router}-dependent functions and classes.
+ * If this or {@linkcode getSingletonRouter} has been called before, it removes the listeners of the
+ * previous singleton {@linkcode Router}. It also adds those of the new one, so you need not do that yourself.
  *
  * It is highly recommended that you call this before anything else, if you plan on doing so.
  *
@@ -55,7 +55,7 @@ export const getSingletonRouter = (): Router => {
  * );
  * ```
  * @param router
- * @returns The new singleton `Router`.
+ * @returns The new singleton {@linkcode Router}.
  * @deprecated
  */
 export const setSingletonRouter = (router: Router): Router => {

package/src/legacy/unregisterRoute.ts

@@ -1,8 +1,9 @@
 import type { Route } from "../Route.js";
+import type { Router } from "./Router.js";
 import { getSingletonRouter } from "./singletonRouter.js";
 
 /**
- * Unregisters a route from the singleton `Router` instance.
+ * Unregisters a route from the singleton {@linkcode Router} instance.
  *
  * @param route The route to unregister.
  * @deprecated

package/src/lib/backgroundSync/BackgroundSyncPlugin.ts

@@ -12,15 +12,15 @@ import { BackgroundSyncQueue } from "./BackgroundSyncQueue.js";
 
 /**
  * A class implementing the `fetchDidFail` lifecycle callback. This makes it
- * easier to add failed requests to a background sync Queue.
+ * easier to add failed requests to a {@linkcode BackgroundSyncQueue}.
  */
 export class BackgroundSyncPlugin implements SerwistPlugin {
   private readonly _queue: BackgroundSyncQueue;
 
   /**
-   * @param name See the `serwist/plugins.BackgroundSyncQueue`
+   * @param name See the {@linkcode BackgroundSyncQueue}
    * documentation for parameter details.
-   * @param options See the `serwist/plugins.BackgroundSyncQueue`
+   * @param options See the {@linkcode BackgroundSyncQueue}
    * documentation for parameter details.
    * @see https://serwist.pages.dev/docs/core/background-sync-queue
    */

package/src/lib/backgroundSync/BackgroundSyncQueue.ts

@@ -312,7 +312,7 @@ export class BackgroundSyncQueue {
 
   /**
    * Removes and returns the first or last (depending on `operation`) entry
-   * from the QueueStore that's not older than the `maxRetentionTime`.
+   * from the {@linkcode BackgroundSyncQueueStore} that's not older than the `maxRetentionTime`.
    *
    * @param operation
    * @returns

package/src/lib/backgroundSync/StorableRequest.ts

@@ -77,7 +77,7 @@ export class StorableRequest {
 
   /**
    * Accepts an object of request data that can be used to construct a
-   * `Request` but can also be stored in IndexedDB.
+   * `Request` object but can also be stored in IndexedDB.
    *
    * @param requestData An object of request data that includes the `url` plus any relevant property of
    * [`requestInit`](https://fetch.spec.whatwg.org/#requestinit).

package/src/lib/broadcastUpdate/BroadcastCacheUpdate.ts

@@ -54,8 +54,7 @@ export class BroadcastCacheUpdate {
   private readonly _notifyAllClients: boolean;
 
   /**
-   * Construct a BroadcastCacheUpdate instance with a specific `channelName` to
-   * broadcast messages on
+   * Construct an instance of `BroadcastCacheUpdate`.
    *
    * @param options
    */

package/src/lib/broadcastUpdate/BroadcastUpdatePlugin.ts

@@ -18,9 +18,10 @@ export class BroadcastUpdatePlugin implements SerwistPlugin {
   private readonly _broadcastUpdate: BroadcastCacheUpdate;
 
   /**
-   * Construct a `serwist.BroadcastCacheUpdate` instance with
-   * the passed options and calls its `notifyIfUpdated` method whenever the
-   * plugin's `cacheDidUpdate` callback is invoked.
+   * Construct a {@linkcode BroadcastCacheUpdate} instance with
+   * the passed options and calls its {@linkcode BroadcastCacheUpdate.notifyIfUpdated}
+   * method whenever the plugin's {@linkcode BroadcastUpdatePlugin.cacheDidUpdate} callback
+   * is invoked.
    *
    * @param options
    */
@@ -29,10 +30,6 @@ export class BroadcastUpdatePlugin implements SerwistPlugin {
   }
 
   /**
-   * A "lifecycle" callback that will be triggered automatically by
-   * `@serwist/build.RuntimeCaching` handlers when an entry is
-   * added to a cache.
-   *
    * @private
    * @param options The input object to this function.
    */

package/src/lib/broadcastUpdate/types.ts

@@ -6,7 +6,8 @@ export interface BroadcastCacheUpdateOptions {
    * A list of headers that will be used to determine whether the responses
    * differ.
    *
-   * @default ['content-length', 'etag', 'last-modified']
+   * @default
+   * ['content-length', 'etag', 'last-modified']`
    */
   headersToCheck?: string[];
   /**

package/src/lib/cacheableResponse/CacheableResponse.ts

@@ -13,11 +13,11 @@ import { logger } from "../../utils/logger.js";
 
 export interface CacheableResponseOptions {
   /**
-   * One or more status codes that a `Response` can have to be considered cacheable.
+   * One or more HTTP status codes that a response can have to be considered cacheable.
    */
   statuses?: number[];
   /**
-   * A mapping of header names and expected values that a `Response` can have and be
+   * A mapping of header names and expected values that a response can have and be
    * considered cacheable. If multiple headers are provided, only one needs to be present.
    */
   headers?: HeadersInit;
@@ -25,7 +25,7 @@ export interface CacheableResponseOptions {
 
 /**
  * Allows you to set up rules determining what status codes and/or headers need
- * to be present in order for a [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * to be present in order for a [response](https://developer.mozilla.org/en-US/docs/Web/API/Response)
  * to be considered cacheable.
  */
 export class CacheableResponse {
@@ -33,11 +33,11 @@ export class CacheableResponse {
   private readonly _headers?: Headers;
 
   /**
-   * To construct a new CacheableResponse instance you must provide at least
+   * To construct a new `CacheableResponse` instance you must provide at least
    * one of the `config` properties.
    *
    * If both `statuses` and `headers` are specified, then both conditions must
-   * be met for the `Response` to be considered cacheable.
+   * be met for the response to be considered cacheable.
    *
    * @param config
    */
@@ -81,7 +81,7 @@ export class CacheableResponse {
    *
    * @param response The response whose cacheability is being
    * checked.
-   * @returns `true` if the `Response` is cacheable, and `false`
+   * @returns `true` if the response is cacheable, and `false`
    * otherwise.
    */
   isResponseCacheable(response: Response): boolean {

package/src/lib/cacheableResponse/CacheableResponsePlugin.ts

@@ -19,11 +19,11 @@ export class CacheableResponsePlugin implements SerwistPlugin {
   private readonly _cacheableResponse: CacheableResponse;
 
   /**
-   * To construct a new CacheableResponsePlugin instance you must provide at
+   * To construct a new `CacheableResponsePlugin` instance you must provide at
    * least one of the `config` properties.
    *
    * If both `statuses` and `headers` are specified, then both conditions must
-   * be met for the `Response` to be considered cacheable.
+   * be met for the response to be considered cacheable.
    *
    * @param config
    */

package/src/lib/expiration/CacheExpiration.ts

@@ -13,7 +13,7 @@ import { CacheTimestampsModel } from "./models/CacheTimestampsModel.js";
 
 interface CacheExpirationConfig {
   /**
-   * The maximum number of entries to cache. Entries used the least will
+   * The maximum number of entries to cache. Entries used least recently will
    * be removed as the maximum is reached.
    */
   maxEntries?: number;
@@ -42,7 +42,7 @@ export class CacheExpiration {
   private readonly _timestampModel: CacheTimestampsModel;
 
   /**
-   * To construct a new CacheExpiration instance you must provide at least
+   * To construct a new `CacheExpiration` instance you must provide at least
    * one of the `config` properties.
    *
    * @param cacheName Name of the cache to apply restrictions to.