serwist 9.0.0-preview.25 → 9.0.0

package/dist/lib/backgroundSync/StorableRequest.d.ts

@@ -15,7 +15,7 @@ export declare class StorableRequest {
     private readonly _requestData;
     /**
      * Converts a Request object to a plain object that can be structured
-     * cloned or JSON-stringified.
+     * cloned or stringified to JSON.
      *
      * @param request
      * @returns
@@ -25,12 +25,12 @@ export declare class StorableRequest {
      * Accepts an object of request data that can be used to construct a
      * `Request` but can also be stored in IndexedDB.
      *
-     * @param requestData An object of request data that includes the `url` plus any relevant properties of
-     * [requestInit](https://fetch.spec.whatwg.org/#requestinit).
+     * @param requestData An object of request data that includes the `url` plus any relevant property of
+     * [`requestInit`](https://fetch.spec.whatwg.org/#requestinit).
      */
     constructor(requestData: RequestData);
     /**
-     * Returns a deep clone of the instances `_requestData` object.
+     * Returns a deep clone of the instance's `requestData` object.
      *
      * @returns
      */

package/dist/lib/expiration/ExpirationPlugin.d.ts

@@ -45,7 +45,7 @@ export interface ExpirationPluginOptions {
  * When using `maxEntries`, the least recently requested entry will be removed
  * from the cache.
  *
- * @see https://serwist.pages.dev/docs/serwist/plugins/expiration-plugin
+ * @see https://serwist.pages.dev/docs/serwist/runtime-caching/plugins/expiration-plugin
  */
 export declare class ExpirationPlugin implements SerwistPlugin {
     private readonly _config;

package/dist/lib/precaching/PrecacheFallbackPlugin.d.ts

@@ -29,10 +29,6 @@ export interface PrecacheFallbackPluginOptions {
  * 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.
  */
 export declare class PrecacheFallbackPlugin implements SerwistPlugin {
     private readonly _fallbackUrls;

package/dist/lib/precaching/PrecacheFallbackPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PrecacheFallbackPlugin.d.ts","sourceRoot":"","sources":["../../../src/lib/precaching/PrecacheFallbackPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,KAAK,EAAE,4BAA4B,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAElF,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,OAAO,EAAE,CAAC,KAAK,EAAE,4BAA4B,KAAK,OAAO,CAAC;IAC1D;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,YAAY,EAAE,CAAC,MAAM,GAAG,qBAAqB,CAAC,EAAE,CAAC;IACjD;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,sBAAuB,YAAW,aAAa;IAC1D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqC;IACnE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAU;IAEnC;;;;OAIG;gBACS,EAAE,YAAY,EAAE,OAAO,EAAE,EAAE,6BAA6B;IAKpE;;;;OAIG;IACG,eAAe,CAAC,KAAK,EAAE,4BAA4B;CAgB1D"}
+{"version":3,"file":"PrecacheFallbackPlugin.d.ts","sourceRoot":"","sources":["../../../src/lib/precaching/PrecacheFallbackPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,KAAK,EAAE,4BAA4B,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAElF,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,OAAO,EAAE,CAAC,KAAK,EAAE,4BAA4B,KAAK,OAAO,CAAC;IAC1D;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,YAAY,EAAE,CAAC,MAAM,GAAG,qBAAqB,CAAC,EAAE,CAAC;IACjD;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,qBAAa,sBAAuB,YAAW,aAAa;IAC1D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqC;IACnE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAU;IAEnC;;;;OAIG;gBACS,EAAE,YAAY,EAAE,OAAO,EAAE,EAAE,6BAA6B;IAKpE;;;;OAIG;IACG,eAAe,CAAC,KAAK,EAAE,4BAA4B;CAgB1D"}

package/dist/lib/strategies/CacheFirst.d.ts

@@ -5,7 +5,7 @@ import type { StrategyHandler } from "./StrategyHandler.js";
  * request strategy.
  *
  * A cache first strategy is useful for assets that have been revisioned,
- * such as URLs like `/styles/example.a8f5f1.css`, since they
+ * such as URLs like "/styles/example.a8f5f1.css", since they
  * can be cached for long periods of time.
  *
  * If the network request fails, and there is no cache match, this will throw

package/dist/lib/strategies/CacheOnly.d.ts

@@ -1,10 +1,10 @@
 import { Strategy } from "./Strategy.js";
 import type { StrategyHandler } from "./StrategyHandler.js";
 /**
- * An implementation of the [cache only](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#cache-only)
+ * An implementation of the [cache only](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#cache_only)
  * request strategy.
  *
- * This class is useful if you want to take advantage of any Serwist plugin.
+ * This class is useful if you already have your own precaching step.
  *
  * If there is no cache match, this will throw a `SerwistError` exception.
  */

package/dist/lib/strategies/NetworkFirst.d.ts

@@ -8,11 +8,11 @@ export interface NetworkFirstOptions extends StrategyOptions {
     networkTimeoutSeconds?: number;
 }
 /**
- * An implementation of the [network first](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#network-first-falling-back-to-cache)
+ * An implementation of the [network first](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#network_first_falling_back_to_cache)
  * request strategy.
  *
  * By default, this strategy will cache responses with a 200 status code as
- * well as [opaque responses](https://developer.chrome.com/docs/workbox/caching-resources-during-runtime/#opaque-responses).
+ * well as [opaque responses](https://developer.chrome.com/docs/workbox/caching-resources-during-runtime/#opaque_responses).
  * Opaque responses are are cross-origin requests where the response doesn't
  * support [CORS](https://enable-cors.org/).
  *

package/dist/lib/strategies/NetworkOnly.d.ts

@@ -8,10 +8,10 @@ export interface NetworkOnlyOptions extends Omit<StrategyOptions, "cacheName" |
     networkTimeoutSeconds?: number;
 }
 /**
- * An implementation of the [network only](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#network-only)
+ * An implementation of the [network only](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#network_only)
  * request strategy.
  *
- * This class is useful if you want to take advantage of any Serwist plugin.
+ * 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.
  */

package/dist/lib/strategies/{PrecacheOnly.d.ts → PrecacheStrategy.d.ts}

@@ -16,7 +16,7 @@ interface PrecacheStrategyOptions extends StrategyOptions {
  * Note: an instance of this class is created automatically when creating a
  * `Serwist` instance; it's generally not necessary to create this yourself.
  */
-export declare class PrecacheOnly extends Strategy {
+export declare class PrecacheStrategy extends Strategy {
     private readonly _fallbackToNetwork;
     static readonly defaultPrecacheCacheabilityPlugin: SerwistPlugin;
     static readonly copyRedirectedCacheableResponsesPlugin: SerwistPlugin;
@@ -63,4 +63,4 @@ export declare class PrecacheOnly extends Strategy {
     _useDefaultCacheabilityPluginIfNeeded(): void;
 }
 export {};
-//# sourceMappingURL=PrecacheOnly.d.ts.map
+//# sourceMappingURL=PrecacheStrategy.d.ts.map

package/dist/lib/strategies/PrecacheStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrecacheStrategy.d.ts","sourceRoot":"","sources":["../../../src/lib/strategies/PrecacheStrategy.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAKpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D,UAAU,uBAAwB,SAAQ,eAAe;IACvD;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,qBAAa,gBAAiB,SAAQ,QAAQ;IAC5C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAU;IAE7C,MAAM,CAAC,QAAQ,CAAC,iCAAiC,EAAE,aAAa,CAQ9D;IAEF,MAAM,CAAC,QAAQ,CAAC,sCAAsC,EAAE,aAAa,CAInE;IAEF;;OAEG;gBACS,OAAO,GAAE,uBAA4B;IAcjD;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAkBtE,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAyE3E,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAqBnF;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,qCAAqC,IAAI,IAAI;CA4B9C"}

package/dist/lib/strategies/StaleWhileRevalidate.d.ts

@@ -3,7 +3,7 @@ import { Strategy } from "./Strategy.js";
 import type { StrategyHandler } from "./StrategyHandler.js";
 /**
  * An implementation of the
- * [stale-while-revalidate](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#stale-while-revalidate)
+ * [stale-while-revalidate](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#stale_while_revalidate)
  * request strategy.
  *
  * Resources are requested from both the cache and the network in parallel.

package/dist/lib/strategies/Strategy.d.ts

@@ -6,26 +6,25 @@ export interface StrategyOptions {
      */
     cacheName?: string;
     /**
-     * [Plugins](https://developer.chrome.com/docs/workbox/using-plugins)
-     * to use in conjunction with this caching strategy.
+     * [Plugins](https://serwist.pages.dev/docs/serwist/runtime-caching/plugins) to use in conjunction with this caching strategy.
      */
     plugins?: SerwistPlugin[];
     /**
-     * Values passed along to the [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters)
-     * of [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796) `fetch()` requests made by this strategy.
+     * Options passed to [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796) `fetch()` calls made by
+     * this strategy.
      */
     fetchOptions?: RequestInit;
     /**
      * The [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions)
-     * for any `cache.match()` or `cache.put()` calls made by this strategy.
+     * passed to any `cache.match()` or `cache.put()` call made by this strategy.
      */
     matchOptions?: CacheQueryOptions;
 }
 /**
- * Classes extending the `Strategy` based class should implement this method,
- * and leverage `serwist/strategies`'s `StrategyHandler` arg to perform all
- * fetching and cache logic, which will ensure all relevant cache, cache options,
- * fetch options and plugins are used (per the current strategy instance).
+ * Abstract class for implementing runtime caching strategies.
+ *
+ * Custom strategies should extend this class and leverage `StrategyHandler`, which will ensure all relevant cache options,
+ * fetch options, and plugins are used (per the current strategy instance), to perform all fetching and caching logic.
  */
 export declare abstract class Strategy implements RouteHandlerObject {
     cacheName: string;
@@ -45,7 +44,7 @@ export declare abstract class Strategy implements RouteHandlerObject {
      */
     constructor(options?: StrategyOptions);
     /**
-     * Perform a request strategy and returns a `Promise` that will resolve with
+     * Performs a request strategy and returns a `Promise` that will resolve with
      * a `Response`, invoking all relevant plugin callbacks.
      *
      * When a strategy instance is registered with a `Route`, this method is automatically
@@ -62,12 +61,11 @@ export declare abstract class Strategy implements RouteHandlerObject {
      */
     handle(options: FetchEvent | HandlerCallbackOptions): Promise<Response>;
     /**
-     * Similar to `serwist/strategies`'s `Strategy.handle`, but
-     * instead of just returning a `Promise` that resolves to a `Response` it
-     * it will return an tuple of `[response, done]` promises, where the former
-     * (`response`) is equivalent to what `handle()` returns, and the latter is a
-     * Promise that will resolve once any promises that were added to
-     * `event.waitUntil()` as part of performing the strategy have completed.
+     * 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
+     * of performing the strategy have completed.
      *
      * You can await the `done` promise to ensure any extra work performed by
      * the strategy (usually caching responses) completes successfully.

package/dist/lib/strategies/Strategy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Strategy.d.ts","sourceRoot":"","sources":["../../../src/lib/strategies/Strategy.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAKhG,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC;IAC1B;;;OAGG;IACH,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B;;;OAGG;IACH,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAClC;AAED;;;;;GAKG;AACH,8BAAsB,QAAS,YAAW,kBAAkB;IAC1D,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B,YAAY,CAAC,EAAE,iBAAiB,CAAC;IAEjC,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IAErG;;;;;;;;;OASG;gBACS,OAAO,GAAE,eAAoB;IAOzC;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,OAAO,EAAE,UAAU,GAAG,sBAAsB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAKvE;;;;;;;;;;;;;;OAcG;IACH,SAAS,CAAC,OAAO,EAAE,UAAU,GAAG,sBAAsB,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAqBrF,YAAY,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAyCnG,cAAc,CAAC,YAAY,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;CAqCzI"}
+{"version":3,"file":"Strategy.d.ts","sourceRoot":"","sources":["../../../src/lib/strategies/Strategy.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAKhG,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC;IAC1B;;;OAGG;IACH,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B;;;OAGG;IACH,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAClC;AAED;;;;;GAKG;AACH,8BAAsB,QAAS,YAAW,kBAAkB;IAC1D,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B,YAAY,CAAC,EAAE,iBAAiB,CAAC;IAEjC,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IAErG;;;;;;;;;OASG;gBACS,OAAO,GAAE,eAAoB;IAOzC;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,OAAO,EAAE,UAAU,GAAG,sBAAsB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAKvE;;;;;;;;;;;;;OAaG;IACH,SAAS,CAAC,OAAO,EAAE,UAAU,GAAG,sBAAsB,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAqBrF,YAAY,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAyCnG,cAAc,CAAC,YAAY,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;CAqCzI"}

package/dist/lib/strategies/StrategyHandler.d.ts

@@ -1,9 +1,9 @@
 import type { HandlerCallbackOptions, MapLikeObject, SerwistPlugin, SerwistPluginCallbackParam } from "../../types.js";
 import type { Strategy } from "./Strategy.js";
 /**
- * A class created every time a Strategy instance instance calls `Strategy.handle` or
+ * A class created every time a `Strategy` instance calls `Strategy.handle` or
  * `Strategy.handleAll` that wraps all fetch and cache actions around plugin callbacks
- * and keeps track of when the strategy is "done" (i.e. all added `event.waitUntil()` promises
+ * and keeps track of when the strategy is "done" (i.e. when all added `event.waitUntil()` promises
  * have resolved).
  */
 export declare class StrategyHandler {
@@ -12,23 +12,23 @@ export declare class StrategyHandler {
      */
     event: ExtendableEvent;
     /**
-     * The request the strategy is performing (passed to the strategy's
+     * The request the strategy is processing (passed to the strategy's
      * `handle()` or `handleAll()` method).
      */
     request: Request;
     /**
      * 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 was invoked
+     * Note: the `url` param will be present if the strategy is invoked
      * from a `Route` object.
      */
     url?: URL;
     /**
-     * A `param` value (if passed to the strategy's
+     * Some additional params (if passed to the strategy's
      * `handle()` or `handleAll()` method).
-     * Note: the `param` param will be present if the strategy was invoked
-     * from a `Route` object and the `serwist/strategies.matchCallback`
-     * returned a truthy value (it will be that value).
+     * 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).
      */
     params?: string[] | MapLikeObject;
     private _cacheKeys;
@@ -52,8 +52,8 @@ export declare class StrategyHandler {
     });
     /**
      * Fetches a given request (and invokes any applicable plugin callback
-     * methods) using the `fetchOptions` (for non-navigation requests) and
-     * `plugins` defined on the `Strategy` object.
+     * methods), taking the `fetchOptions` (for non-navigation requests) and
+     * `plugins` provided to the `Strategy` object into account.
      *
      * The following plugin lifecycle methods are invoked when using this method:
      * - `requestWillFetch()`
@@ -65,11 +65,10 @@ export declare class StrategyHandler {
      */
     fetch(input: RequestInfo): Promise<Response>;
     /**
-     * Calls `this.fetch()` and (in the background) runs `this.cachePut()` on
-     * the response generated by `this.fetch()`.
+     * Calls `this.fetch()` and (in the background) caches the generated response.
      *
      * The call to `this.cachePut()` automatically invokes `this.waitUntil()`,
-     * so you do not have to manually call `waitUntil()` on the event.
+     * so you do not have to call `waitUntil()` yourself.
      *
      * @param input The request or URL to fetch and cache.
      * @returns
@@ -77,26 +76,26 @@ export declare class StrategyHandler {
     fetchAndCachePut(input: RequestInfo): Promise<Response>;
     /**
      * Matches a request from the cache (and invokes any applicable plugin
-     * callback methods) using the `cacheName`, `matchOptions`, and `plugins`
-     * defined on the strategy object.
+     * callback method) using the `cacheName`, `matchOptions`, and `plugins`
+     * provided to the `Strategy` object.
      *
-     * The following plugin lifecycle methods are invoked when using this method:
-     * - cacheKeyWillByUsed()
-     * - cachedResponseWillByUsed()
+     * The following lifecycle methods are invoked when using this method:
+     * - `cacheKeyWillByUsed`
+     * - `cachedResponseWillByUsed`
      *
-     * @param key The Request or URL to use as the cache key.
+     * @param key The `Request` or `URL` object to use as the cache key.
      * @returns A matching response, if found.
      */
     cacheMatch(key: RequestInfo): Promise<Response | undefined>;
     /**
-     * Puts a request/response pair in the cache (and invokes any applicable
-     * plugin callback methods) using the `cacheName` and `plugins` defined on
-     * the strategy object.
+     * 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 following plugin lifecycle methods are invoked when using this method:
-     * - cacheKeyWillByUsed()
-     * - cacheWillUpdate()
-     * - cacheDidUpdate()
+     * - `cacheKeyWillByUsed`
+     * - `cacheWillUpdate`
+     * - `cacheDidUpdate`
      *
      * @param key The request or URL to use as the cache key.
      * @param response The response to cache.
@@ -105,11 +104,11 @@ export declare class StrategyHandler {
      */
     cachePut(key: RequestInfo, response: Response): Promise<boolean>;
     /**
-     * Checks the list of plugins for the `cacheKeyWillBeUsed` callback, and
-     * executes any of those callbacks found in sequence. The final `Request`
+     * Checks the `plugins` provided to the `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
-     * been registered, the passed request is returned unmodified
+     * been registered, the passed request is returned unmodified.
      *
      * @param request
      * @param mode
@@ -117,7 +116,7 @@ export declare class StrategyHandler {
      */
     getCacheKey(request: Request, mode: "read" | "write"): Promise<Request>;
     /**
-     * Returns true if the strategy has at least one plugin with the given
+     * Returns `true` if the strategy has at least one plugin with the given
      * callback.
      *
      * @param name The name of the callback to check for.
@@ -126,8 +125,7 @@ export declare class StrategyHandler {
     hasCallback<C extends keyof SerwistPlugin>(name: C): boolean;
     /**
      * Runs all plugin callbacks matching the given name, in order, passing the
-     * given param object (merged ith the current plugin state) as the only
-     * argument.
+     * given param object as the only argument.
      *
      * 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
@@ -139,10 +137,7 @@ export declare class StrategyHandler {
      */
     runCallbacks<C extends keyof NonNullable<SerwistPlugin>>(name: C, param: Omit<SerwistPluginCallbackParam[C], "state">): Promise<void>;
     /**
-     * Accepts a callback and returns an iterable of matching plugin callbacks,
-     * where each callback is wrapped with the current handler state (i.e. when
-     * you call each callback, whatever object parameter you pass it will
-     * be merged with the plugin's current state).
+     * Accepts a callback name and returns an iterable of matching plugin callbacks.
      *
      * @param name The name fo the callback to run
      * @returns
@@ -163,17 +158,16 @@ export declare class StrategyHandler {
     waitUntil<T>(promise: Promise<T>): Promise<T>;
     /**
      * Returns a promise that resolves once all promises passed to
-     * `serwist/strategies.StrategyHandler.waitUntil` have settled.
+     * `this.waitUntil()` have settled.
      *
      * Note: any work done after `doneWaiting()` settles should be manually
-     * passed to an event's `waitUntil()` method (not this handler's
-     * `waitUntil()` method), otherwise the service worker thread my be killed
-     * prior to your work completing.
+     * passed to an event's `waitUntil()` method (not `this.waitUntil()`), otherwise
+     * the service worker thread may be killed prior to your work completing.
      */
     doneWaiting(): Promise<void>;
     /**
      * Stops running the strategy and immediately resolves any pending
-     * `waitUntil()` promises.
+     * `waitUntil()` promise.
      */
     destroy(): void;
     /**

package/dist/lib/strategies/StrategyHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StrategyHandler.d.ts","sourceRoot":"","sources":["../../../src/lib/strategies/StrategyHandler.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,sBAAsB,EAAE,aAAa,EAAE,aAAa,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AASvH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAM9C;;;;;GAKG;AACH,qBAAa,eAAe;IAC1B;;OAEG;IACI,KAAK,EAAE,eAAe,CAAC;IAC9B;;;OAGG;IACI,OAAO,EAAE,OAAO,CAAC;IACxB;;;;;OAKG;IACI,GAAG,CAAC,EAAE,GAAG,CAAC;IACjB;;;;;;OAMG;IACI,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,aAAa,CAAC;IAEzC,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IACrC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAgB;IACjD,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAiB;IACzD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkB;IAC3C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAoC;IAEpE;;;;;;;;;OASG;gBAED,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,sBAAsB,GAAG;QAChC,OAAO,EAAE,sBAAsB,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC;KACtD;IAsCH;;;;;;;;;;;;OAYG;IACG,KAAK,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAyElD;;;;;;;;;OASG;IACG,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAS7D;;;;;;;;;;;OAWG;IACG,UAAU,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IA+BjE;;;;;;;;;;;;;;OAcG;IACG,QAAQ,CAAC,GAAG,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IA8FtE;;;;;;;;;;OAUG;IACG,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAqB7E;;;;;;OAMG;IACH,WAAW,CAAC,CAAC,SAAS,MAAM,aAAa,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO;IAS5D;;;;;;;;;;;;OAYG;IACG,YAAY,CAAC,CAAC,SAAS,MAAM,WAAW,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,0BAA0B,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ3I;;;;;;;;OAQG;IACF,gBAAgB,CAAC,CAAC,SAAS,MAAM,aAAa,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IAgBnG;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAK7C;;;;;;;;OAQG;IACG,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAOlC;;;OAGG;IACH,OAAO,IAAI,IAAI;IAIf;;;;;;;OAOG;IACG,0BAA0B,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;CAuCpF"}
+{"version":3,"file":"StrategyHandler.d.ts","sourceRoot":"","sources":["../../../src/lib/strategies/StrategyHandler.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,sBAAsB,EAAE,aAAa,EAAE,aAAa,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AASvH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAM9C;;;;;GAKG;AACH,qBAAa,eAAe;IAC1B;;OAEG;IACI,KAAK,EAAE,eAAe,CAAC;IAC9B;;;OAGG;IACI,OAAO,EAAE,OAAO,CAAC;IACxB;;;;;OAKG;IACI,GAAG,CAAC,EAAE,GAAG,CAAC;IACjB;;;;;;OAMG;IACI,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,aAAa,CAAC;IAEzC,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IACrC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAgB;IACjD,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAiB;IACzD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkB;IAC3C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAoC;IAEpE;;;;;;;;;OASG;gBAED,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,sBAAsB,GAAG;QAChC,OAAO,EAAE,sBAAsB,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC;KACtD;IAsCH;;;;;;;;;;;;OAYG;IACG,KAAK,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAyElD;;;;;;;;OAQG;IACG,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAS7D;;;;;;;;;;;OAWG;IACG,UAAU,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IA+BjE;;;;;;;;;;;;;;OAcG;IACG,QAAQ,CAAC,GAAG,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IA8FtE;;;;;;;;;;OAUG;IACG,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAqB7E;;;;;;OAMG;IACH,WAAW,CAAC,CAAC,SAAS,MAAM,aAAa,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO;IAS5D;;;;;;;;;;;OAWG;IACG,YAAY,CAAC,CAAC,SAAS,MAAM,WAAW,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,0BAA0B,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ3I;;;;;OAKG;IACF,gBAAgB,CAAC,CAAC,SAAS,MAAM,aAAa,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IAgBnG;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAK7C;;;;;;;OAOG;IACG,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAOlC;;;OAGG;IACH,OAAO,IAAI,IAAI;IAIf;;;;;;;OAOG;IACG,0BAA0B,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;CAuCpF"}

package/dist/utils/cleanupOutdatedCaches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanupOutdatedCaches.d.ts","sourceRoot":"","sources":["../../src/utils/cleanupOutdatedCaches.ts"],"names":[],"mappings":"AAcA;;;GAGG;AACH,eAAO,MAAM,qBAAqB,eAAgB,MAAM,KAAG,IAY1D,CAAC"}

package/dist/utils/clientsClaim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clientsClaim.d.ts","sourceRoot":"","sources":["../../src/utils/clientsClaim.ts"],"names":[],"mappings":"AAWA;;;GAGG;AACH,eAAO,MAAM,YAAY,QAAO,IAE/B,CAAC"}

package/dist/{parseRoute.d.ts → utils/parseRoute.d.ts}

@@ -1,6 +1,6 @@
-import { Route } from "./Route.js";
-import type { HTTPMethod } from "./constants.js";
-import type { RouteHandler, RouteMatchCallback } from "./types.js";
+import { Route } from "../Route.js";
+import type { HTTPMethod } from "../constants.js";
+import type { RouteHandler, RouteMatchCallback } from "../types.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

package/dist/utils/parseRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseRoute.d.ts","sourceRoot":"","sources":["../../src/utils/parseRoute.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAIpE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,YAAa,MAAM,GAAG,MAAM,GAAG,kBAAkB,GAAG,KAAK,YAAY,YAAY,WAAW,UAAU,KAAG,KAyD/H,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serwist",
-  "version": "9.0.0-preview.25",
+  "version": "9.0.0",
   "type": "module",
   "description": "A Swiss Army knife for service workers.",
   "files": [
@@ -51,8 +51,8 @@
   "devDependencies": {
     "rollup": "4.14.3",
     "typescript": "5.5.0-dev.20240415",
-    "@serwist/configs": "9.0.0-preview.25",
-    "@serwist/utils": "9.0.0-preview.25"
+    "@serwist/configs": "9.0.0",
+    "@serwist/utils": "9.0.0"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0"

package/src/NavigationRoute.ts

@@ -27,10 +27,9 @@ export interface NavigationRouteMatchOptions {
 }
 
 /**
- * NavigationRoute makes it easy to create a `Route` that matches for browser
- * [navigation requests](https://developers.google.com/web/fundamentals/primers/service-workers/high-performance-loading#first_what_are_navigation_requests).
+ * `NavigationRoute` makes it easy to create a `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.
@@ -40,8 +39,8 @@ export class NavigationRoute extends Route {
   private readonly _denylist: RegExp[];
 
   /**
-   * If both `denylist` and `allowlist` are provided, the `denylist` will
-   * take precedence and the request will not match this route.
+   * If both `denylist` and `allowlist` are provided, `denylist` will
+   * take precedence.
    *
    * The regular expressions in `allowlist` and `denylist`
    * are matched against the concatenated
@@ -54,7 +53,7 @@ export class NavigationRoute extends Route {
    * [complex RegExps](https://github.com/GoogleChrome/workbox/issues/3077),
    * or else your users may see delays when navigating your site.
    *
-   * @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 options
    */
   constructor(handler: RouteHandler, { allowlist = [/./], denylist = [] }: NavigationRouteMatchOptions = {}) {

package/src/PrecacheRoute.ts

@@ -20,8 +20,8 @@ import { logger } from "./utils/logger.js";
  */
 export class PrecacheRoute extends Route {
   /**
-   * @param serwist A `PrecacheController`
-   * instance used to both match requests and respond to fetch events.
+   * @param serwist A `Serwist` 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/src/RegExpRoute.ts

@@ -13,7 +13,7 @@ import { assert } from "./utils/assert.js";
 import { logger } from "./utils/logger.js";
 
 /**
- * `RegExpRoute` makes it easy to create a regular expression based on a `Route`.
+ * `RegExpRoute` makes it easy to create a `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
@@ -26,8 +26,8 @@ export class RegExpRoute extends Route {
    * the captured values will be passed to the `params` argument.
    *
    * @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, defaults to GET.
+   * @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`.
    * against.
    */
   constructor(regExp: RegExp, handler: RouteHandler, method?: HTTPMethod) {

package/src/Route.ts

@@ -13,10 +13,10 @@ import { assert } from "./utils/assert.js";
 import { normalizeHandler } from "./utils/normalizeHandler.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
+ * 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`.
  */
 export class Route {
@@ -29,11 +29,11 @@ export class Route {
    * Constructor for Route class.
    *
    * @param match A callback function that determines whether the
-   * route matches a given `fetch` event by returning a non-falsy value.
-   * @param handler A callback function that returns a Promise resolving
-   * to a Response.
-   * @param method The HTTP method to match the Route against. Defaults
-   * to GET.
+   * route matches a given `fetch` event by returning a truthy value.
+   * @param handler A callback function that returns a `Promise` resolving
+   * to a `Response`.
+   * @param method The HTTP method to match the route against. Defaults
+   * to `GET`.
    */
   constructor(match: RouteMatchCallback, handler: RouteHandler, method: HTTPMethod = defaultMethod) {
     if (process.env.NODE_ENV !== "production") {

package/src/Serwist.ts

@@ -2,16 +2,13 @@ import { parallel } from "@serwist/utils";
 import { NavigationRoute } from "./NavigationRoute.js";
 import { PrecacheRoute } from "./PrecacheRoute.js";
 import type { Route } from "./Route.js";
-import { cleanupOutdatedCaches as cleanupOutdatedCachesImpl } from "./cleanupOutdatedCaches.js";
-import { clientsClaim as clientsClaimImpl } from "./clientsClaim.js";
 import { type HTTPMethod, defaultMethod } from "./constants.js";
 import { disableDevLogs as disableDevLogsImpl } from "./disableDevLogs.js";
 import { type GoogleAnalyticsInitializeOptions, initializeGoogleAnalytics } from "./lib/googleAnalytics/initializeGoogleAnalytics.js";
 import { type PrecacheFallbackEntry, PrecacheFallbackPlugin } from "./lib/precaching/PrecacheFallbackPlugin.js";
-import { PrecacheOnly } from "./lib/strategies/PrecacheOnly.js";
+import { PrecacheStrategy } from "./lib/strategies/PrecacheStrategy.js";
 import { Strategy } from "./lib/strategies/Strategy.js";
 import { enableNavigationPreload } from "./navigationPreload.js";
-import { parseRoute } from "./parseRoute.js";
 import { setCacheNameDetails } from "./setCacheNameDetails.js";
 import type {
   RouteHandler,
@@ -29,10 +26,13 @@ import { PrecacheInstallReportPlugin } from "./utils/PrecacheInstallReportPlugin
 import { SerwistError } from "./utils/SerwistError.js";
 import { assert } from "./utils/assert.js";
 import { cacheNames as privateCacheNames } from "./utils/cacheNames.js";
+import { cleanupOutdatedCaches as cleanupOutdatedCachesImpl } from "./utils/cleanupOutdatedCaches.js";
+import { clientsClaim as clientsClaimImpl } from "./utils/clientsClaim.js";
 import { createCacheKey } from "./utils/createCacheKey.js";
 import { getFriendlyURL } from "./utils/getFriendlyURL.js";
 import { logger } from "./utils/logger.js";
 import { normalizeHandler } from "./utils/normalizeHandler.js";
+import { parseRoute } from "./utils/parseRoute.js";
 import { printCleanupDetails } from "./utils/printCleanupDetails.js";
 import { printInstallDetails } from "./utils/printInstallDetails.js";
 import { waitUntil } from "./utils/waitUntil.js";
@@ -193,7 +193,7 @@ export class Serwist {
     fallbacks,
   }: SerwistOptions = {}) {
     this._concurrentPrecaching = precacheOptions?.concurrency ?? 10;
-    this._precacheStrategy = new PrecacheOnly({
+    this._precacheStrategy = new PrecacheStrategy({
       cacheName: privateCacheNames.getPrecacheName(precacheOptions?.cacheName),
       plugins: [...(precacheOptions?.plugins ?? []), new PrecacheCacheKeyPlugin({ precacheController: this })],
       fallbackToNetwork: precacheOptions?.fallbackToNetwork,
@@ -532,7 +532,11 @@ export class Serwist {
    * @param method The HTTP method to match the Route against. Defaults to `'GET'`.
    * @returns The generated `Route`.
    */
-  registerCapture(capture: RegExp | string | RouteMatchCallback | Route, handler?: RouteHandler, method?: HTTPMethod): Route {
+  registerCapture<T extends RegExp | string | RouteMatchCallback | Route>(
+    capture: T,
+    handler?: T extends Route ? never : RouteHandler,
+    method?: T extends Route ? never : HTTPMethod,
+  ): Route {
     const route = parseRoute(capture, handler, method);
     this.registerRoute(route);
     return route;

package/src/copyResponse.ts

@@ -11,21 +11,19 @@ import { canConstructResponseFromBodyStream } from "./utils/canConstructResponse
 
 /**
  * Allows developers to copy a response and modify its `headers`, `status`,
- * or `statusText` values (the values settable via a
- * [`ResponseInit`](https://developer.mozilla.org/en-US/docs/Web/API/Response/Response#Syntax)
- * object in the constructor).
+ * or `statusText` values (the [valid options](https://developer.mozilla.org/en-US/docs/Web/API/Response/Response#options)
+ * when constructing a `Response` object).
  * To modify these values, pass a function as the second argument. That
- * function will be invoked with a single object with the response properties
- * `{headers, status, statusText}`. The return value of this function will
- * be used as the `ResponseInit` for the new `Response`. To change the values
- * either modify the passed parameter(s) and return it, or return a totally
+ * function will be invoked with the options of the initial `Response` object.
+ * The return value of this function will be used as the options for the new `Response` object.
+ * To change the values either modify the passed parameter(s) and return it or return a totally
  * new object.
  *
  * This method is intentionally limited to same-origin responses, regardless of
  * whether CORS was used or not.
  *
- * @param response
- * @param modifier
+ * @param response The initial response.
+ * @param modifier The function used to modify the options of the `Response` object.
  */
 export const copyResponse = async (response: Response, modifier?: (responseInit: ResponseInit) => ResponseInit): Promise<Response> => {
   let origin = null;