@serwist/core 8.4.0 → 8.4.2

package/dist/_private/getFriendlyURL.d.cts

@@ -0,0 +1,2 @@
+declare const getFriendlyURL: (url: URL | string) => string;
+export { getFriendlyURL };

package/dist/_private/resultingClientExists.d.cts

@@ -0,0 +1,11 @@
+/**
+ * Returns a promise that resolves to a window client matching the passed
+ * `resultingClientId`. For browsers that don't support `resultingClientId`
+ * or if waiting for the resulting client to apper takes too long, resolve to
+ * `undefined`.
+ *
+ * @param resultingClientId
+ * @returns
+ * @private
+ */
+export declare function resultingClientExists(resultingClientId?: string): Promise<Client | undefined>;

package/dist/_private/timeout.d.cts

@@ -0,0 +1,9 @@
+/**
+ * Returns a promise that resolves and the passed number of milliseconds.
+ * This utility is an async/await-friendly version of `setTimeout`.
+ *
+ * @param ms
+ * @returns
+ * @private
+ */
+export declare function timeout(ms: number): Promise<unknown>;

package/dist/_private/waitUntil.d.cts

@@ -0,0 +1,11 @@
+/**
+ * A utility method that makes it easier to use `event.waitUntil` with
+ * async functions and return the result.
+ *
+ * @param event
+ * @param asyncFn
+ * @returns
+ * @private
+ */
+declare function waitUntil(event: ExtendableEvent, asyncFn: () => Promise<any>): Promise<any>;
+export { waitUntil };

package/dist/index.cjs

@@ -95,8 +95,7 @@ var quotaErrorCallbacks = require('./quotaErrorCallbacks.cjs');
  * there's a quota error.
  *
  * @param callback
- */ // Can't change Function type
-// eslint-disable-next-line @typescript-eslint/ban-types
+ */ // biome-ignore lint/complexity/noBannedTypes: Can't change Function type
 function registerQuotaErrorCallback(callback) {
     if (process.env.NODE_ENV !== "production") {
         quotaErrorCallbacks.finalAssertExports.isType(callback, "function", {
@@ -118,29 +117,29 @@ function registerQuotaErrorCallback(callback) {
  * @param details
  */ function setCacheNameDetails(details) {
     if (process.env.NODE_ENV !== "production") {
-        Object.keys(details).forEach((key)=>{
+        for (const key of Object.keys(details)){
             quotaErrorCallbacks.finalAssertExports.isType(details[key], "string", {
                 moduleName: "@serwist/core",
                 funcName: "setCacheNameDetails",
                 paramName: `details.${key}`
             });
-        });
-        if (details["precache"]?.length === 0) {
+        }
+        if (details.precache?.length === 0) {
             throw new quotaErrorCallbacks.SerwistError("invalid-cache-name", {
                 cacheNameId: "precache",
-                value: details["precache"]
+                value: details.precache
             });
         }
-        if (details["runtime"]?.length === 0) {
+        if (details.runtime?.length === 0) {
             throw new quotaErrorCallbacks.SerwistError("invalid-cache-name", {
                 cacheNameId: "runtime",
-                value: details["runtime"]
+                value: details.runtime
             });
         }
-        if (details["googleAnalytics"]?.length === 0) {
+        if (details.googleAnalytics?.length === 0) {
             throw new quotaErrorCallbacks.SerwistError("invalid-cache-name", {
                 cacheNameId: "googleAnalytics",
-                value: details["googleAnalytics"]
+                value: details.googleAnalytics
             });
         }
     }

package/dist/index.internal.cjs

@@ -2,6 +2,33 @@
 
 var quotaErrorCallbacks = require('./quotaErrorCallbacks.cjs');
 
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/ /**
+ * The Deferred class composes Promises in a way that allows for them to be
+ * resolved or rejected from outside the constructor. In most cases promises
+ * should be used directly, but Deferreds can be necessary when the logic to
+ * resolve a promise must be separate.
+ *
+ * @private
+ */ class Deferred {
+    promise;
+    resolve;
+    reject;
+    /**
+   * Creates a promise and exposes its resolve and reject functions as methods.
+   */ constructor(){
+        this.promise = new Promise((resolve, reject)=>{
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+}
+
 /*
   Copyright 2020 Google LLC
   Use of this source code is governed by an MIT-style
@@ -76,33 +103,6 @@ var quotaErrorCallbacks = require('./quotaErrorCallbacks.cjs');
     return supportStatus;
 }
 
-/*
-  Copyright 2018 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/ /**
- * The Deferred class composes Promises in a way that allows for them to be
- * resolved or rejected from outside the constructor. In most cases promises
- * should be used directly, but Deferreds can be necessary when the logic to
- * resolve a promise must be separate.
- *
- * @private
- */ class Deferred {
-    promise;
-    resolve;
-    reject;
-    /**
-   * Creates a promise and exposes its resolve and reject functions as methods.
-   */ constructor(){
-        this.promise = new Promise((resolve, reject)=>{
-            this.resolve = resolve;
-            this.reject = reject;
-        });
-    }
-}
-
 /*
   Copyright 2019 Google LLC
   Use of this source code is governed by an MIT-style
@@ -124,7 +124,7 @@ var quotaErrorCallbacks = require('./quotaErrorCallbacks.cjs');
  * @private
  */ async function executeQuotaErrorCallbacks() {
     if (process.env.NODE_ENV !== "production") {
-        quotaErrorCallbacks.logger.log(`About to run ${quotaErrorCallbacks.quotaErrorCallbacks.size} ` + `callbacks to clean up caches.`);
+        quotaErrorCallbacks.logger.log(`About to run ${quotaErrorCallbacks.quotaErrorCallbacks.size} callbacks to clean up caches.`);
     }
     for (const callback of quotaErrorCallbacks.quotaErrorCallbacks){
         await callback();
@@ -184,7 +184,7 @@ const MAX_RETRY_TIME = 2000;
         type: "window"
     });
     const existingWindowIds = new Set(existingWindows.map((w)=>w.id));
-    let resultingWindow;
+    let resultingWindow = undefined;
     const startTime = performance.now();
     // Only wait up to `MAX_RETRY_TIME` to find a matching client.
     while(performance.now() - startTime < MAX_RETRY_TIME){
@@ -195,10 +195,9 @@ const MAX_RETRY_TIME = 2000;
             if (resultingClientId) {
                 // If we have a `resultingClientId`, we can match on that.
                 return w.id === resultingClientId;
-            } else {
-                // Otherwise match on finding a window not in `existingWindowIds`.
-                return !existingWindowIds.has(w.id);
             }
+            // Otherwise match on finding a window not in `existingWindowIds`.
+            return !existingWindowIds.has(w.id);
         });
         if (resultingWindow) {
             break;

package/dist/index.internal.d.cts

@@ -0,0 +1,15 @@
+import { Deferred } from "./_private/Deferred.js";
+import { SerwistError } from "./_private/SerwistError.js";
+import { assert } from "./_private/assert.js";
+import { cacheMatchIgnoreParams } from "./_private/cacheMatchIgnoreParams.js";
+import { cacheNames as privateCacheNames } from "./_private/cacheNames.js";
+import { canConstructReadableStream } from "./_private/canConstructReadableStream.js";
+import { canConstructResponseFromBodyStream } from "./_private/canConstructResponseFromBodyStream.js";
+import { dontWaitFor } from "./_private/dontWaitFor.js";
+import { executeQuotaErrorCallbacks } from "./_private/executeQuotaErrorCallbacks.js";
+import { getFriendlyURL } from "./_private/getFriendlyURL.js";
+import { logger } from "./_private/logger.js";
+import { resultingClientExists } from "./_private/resultingClientExists.js";
+import { timeout } from "./_private/timeout.js";
+import { waitUntil } from "./_private/waitUntil.js";
+export { assert, cacheMatchIgnoreParams, canConstructReadableStream, canConstructResponseFromBodyStream, Deferred, dontWaitFor, executeQuotaErrorCallbacks, getFriendlyURL, logger, privateCacheNames, resultingClientExists, SerwistError, timeout, waitUntil, };

package/dist/index.internal.d.ts

@@ -1,15 +1,15 @@
+import { Deferred } from "./_private/Deferred.js";
+import { SerwistError } from "./_private/SerwistError.js";
 import { assert } from "./_private/assert.js";
 import { cacheMatchIgnoreParams } from "./_private/cacheMatchIgnoreParams.js";
 import { cacheNames as privateCacheNames } from "./_private/cacheNames.js";
 import { canConstructReadableStream } from "./_private/canConstructReadableStream.js";
 import { canConstructResponseFromBodyStream } from "./_private/canConstructResponseFromBodyStream.js";
-import { Deferred } from "./_private/Deferred.js";
 import { dontWaitFor } from "./_private/dontWaitFor.js";
 import { executeQuotaErrorCallbacks } from "./_private/executeQuotaErrorCallbacks.js";
 import { getFriendlyURL } from "./_private/getFriendlyURL.js";
 import { logger } from "./_private/logger.js";
 import { resultingClientExists } from "./_private/resultingClientExists.js";
-import { SerwistError } from "./_private/SerwistError.js";
 import { timeout } from "./_private/timeout.js";
 import { waitUntil } from "./_private/waitUntil.js";
 export { assert, cacheMatchIgnoreParams, canConstructReadableStream, canConstructResponseFromBodyStream, Deferred, dontWaitFor, executeQuotaErrorCallbacks, getFriendlyURL, logger, privateCacheNames, resultingClientExists, SerwistError, timeout, waitUntil, };

package/dist/index.internal.js

@@ -1,6 +1,33 @@
 import { l as logger, q as quotaErrorCallbacks } from './quotaErrorCallbacks.js';
 export { S as SerwistError, f as assert, a as canConstructResponseFromBodyStream, c as privateCacheNames } from './quotaErrorCallbacks.js';
 
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/ /**
+ * The Deferred class composes Promises in a way that allows for them to be
+ * resolved or rejected from outside the constructor. In most cases promises
+ * should be used directly, but Deferreds can be necessary when the logic to
+ * resolve a promise must be separate.
+ *
+ * @private
+ */ class Deferred {
+    promise;
+    resolve;
+    reject;
+    /**
+   * Creates a promise and exposes its resolve and reject functions as methods.
+   */ constructor(){
+        this.promise = new Promise((resolve, reject)=>{
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+}
+
 /*
   Copyright 2020 Google LLC
   Use of this source code is governed by an MIT-style
@@ -75,33 +102,6 @@ export { S as SerwistError, f as assert, a as canConstructResponseFromBodyStream
     return supportStatus;
 }
 
-/*
-  Copyright 2018 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/ /**
- * The Deferred class composes Promises in a way that allows for them to be
- * resolved or rejected from outside the constructor. In most cases promises
- * should be used directly, but Deferreds can be necessary when the logic to
- * resolve a promise must be separate.
- *
- * @private
- */ class Deferred {
-    promise;
-    resolve;
-    reject;
-    /**
-   * Creates a promise and exposes its resolve and reject functions as methods.
-   */ constructor(){
-        this.promise = new Promise((resolve, reject)=>{
-            this.resolve = resolve;
-            this.reject = reject;
-        });
-    }
-}
-
 /*
   Copyright 2019 Google LLC
   Use of this source code is governed by an MIT-style
@@ -123,7 +123,7 @@ export { S as SerwistError, f as assert, a as canConstructResponseFromBodyStream
  * @private
  */ async function executeQuotaErrorCallbacks() {
     if (process.env.NODE_ENV !== "production") {
-        logger.log(`About to run ${quotaErrorCallbacks.size} ` + `callbacks to clean up caches.`);
+        logger.log(`About to run ${quotaErrorCallbacks.size} callbacks to clean up caches.`);
     }
     for (const callback of quotaErrorCallbacks){
         await callback();
@@ -183,7 +183,7 @@ const MAX_RETRY_TIME = 2000;
         type: "window"
     });
     const existingWindowIds = new Set(existingWindows.map((w)=>w.id));
-    let resultingWindow;
+    let resultingWindow = undefined;
     const startTime = performance.now();
     // Only wait up to `MAX_RETRY_TIME` to find a matching client.
     while(performance.now() - startTime < MAX_RETRY_TIME){
@@ -194,10 +194,9 @@ const MAX_RETRY_TIME = 2000;
             if (resultingClientId) {
                 // If we have a `resultingClientId`, we can match on that.
                 return w.id === resultingClientId;
-            } else {
-                // Otherwise match on finding a window not in `existingWindowIds`.
-                return !existingWindowIds.has(w.id);
             }
+            // Otherwise match on finding a window not in `existingWindowIds`.
+            return !existingWindowIds.has(w.id);
         });
         if (resultingWindow) {
             break;

package/dist/index.js

@@ -93,8 +93,7 @@ import { c as cacheNames$1, S as SerwistError, a as canConstructResponseFromBody
  * there's a quota error.
  *
  * @param callback
- */ // Can't change Function type
-// eslint-disable-next-line @typescript-eslint/ban-types
+ */ // biome-ignore lint/complexity/noBannedTypes: Can't change Function type
 function registerQuotaErrorCallback(callback) {
     if (process.env.NODE_ENV !== "production") {
         finalAssertExports.isType(callback, "function", {
@@ -116,29 +115,29 @@ function registerQuotaErrorCallback(callback) {
  * @param details
  */ function setCacheNameDetails(details) {
     if (process.env.NODE_ENV !== "production") {
-        Object.keys(details).forEach((key)=>{
+        for (const key of Object.keys(details)){
             finalAssertExports.isType(details[key], "string", {
                 moduleName: "@serwist/core",
                 funcName: "setCacheNameDetails",
                 paramName: `details.${key}`
             });
-        });
-        if (details["precache"]?.length === 0) {
+        }
+        if (details.precache?.length === 0) {
             throw new SerwistError("invalid-cache-name", {
                 cacheNameId: "precache",
-                value: details["precache"]
+                value: details.precache
             });
         }
-        if (details["runtime"]?.length === 0) {
+        if (details.runtime?.length === 0) {
             throw new SerwistError("invalid-cache-name", {
                 cacheNameId: "runtime",
-                value: details["runtime"]
+                value: details.runtime
             });
         }
-        if (details["googleAnalytics"]?.length === 0) {
+        if (details.googleAnalytics?.length === 0) {
             throw new SerwistError("invalid-cache-name", {
                 cacheNameId: "googleAnalytics",
-                value: details["googleAnalytics"]
+                value: details.googleAnalytics
             });
         }
     }

package/dist/models/pluginEvents.d.cts

@@ -1,4 +1,4 @@
-export declare const enum pluginEvents {
+export declare enum pluginEvents {
     CACHE_DID_UPDATE = "cacheDidUpdate",
     CACHE_KEY_WILL_BE_USED = "cacheKeyWillBeUsed",
     CACHE_WILL_UPDATE = "cacheWillUpdate",

package/dist/models/pluginEvents.d.ts

@@ -1,4 +1,4 @@
-export declare const enum pluginEvents {
+export declare enum pluginEvents {
     CACHE_DID_UPDATE = "cacheDidUpdate",
     CACHE_KEY_WILL_BE_USED = "cacheKeyWillBeUsed",
     CACHE_WILL_UPDATE = "cacheWillUpdate",

package/dist/quotaErrorCallbacks.cjs

@@ -51,36 +51,6 @@ const cacheNames = {
     }
 };
 
-/*
-  Copyright 2019 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/ let supportStatus;
-/**
- * A utility function that determines whether the current browser supports
- * 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.
- * @private
- */ function canConstructResponseFromBodyStream() {
-    if (supportStatus === undefined) {
-        const testResponse = new Response("");
-        if ("body" in testResponse) {
-            try {
-                new Response(testResponse.body);
-                supportStatus = true;
-            } catch (error) {
-                supportStatus = false;
-            }
-        }
-        supportStatus = false;
-    }
-    return supportStatus;
-}
-
 /*
   Copyright 2018 Google LLC
 
@@ -113,7 +83,7 @@ const cacheNames = {
         }
         const classNameStr = className ? `${className}.` : "";
         if (isReturnValueProblem) {
-            return `The return value from ` + `'${moduleName}.${classNameStr}${funcName}()' ` + `must be an instance of class ${expectedClassName}.`;
+            return `The return value from '${moduleName}.${classNameStr}${funcName}()' must be an instance of class ${expectedClassName}.`;
         }
         return `The parameter '${paramName}' passed into ` + `'${moduleName}.${classNameStr}${funcName}()' ` + `must be an instance of class ${expectedClassName}.`;
     },
@@ -124,100 +94,100 @@ const cacheNames = {
         return `${moduleName}.${className}.${funcName}() expected the ` + `'${paramName}' parameter to expose a '${expectedMethod}' method.`;
     },
     "add-to-cache-list-unexpected-type": ({ entry })=>{
-        return `An unexpected entry was passed to ` + `'@serwist/precaching.PrecacheController.addToCacheList()' The entry ` + `'${JSON.stringify(entry)}' isn't supported. You must supply an array of ` + `strings with one or more characters, objects with a url property or ` + `Request objects.`;
+        return `An unexpected entry was passed to '@serwist/precaching.PrecacheController.addToCacheList()' The entry '${JSON.stringify(entry)}' isn't supported. You must supply an array of strings with one or more characters, objects with a url property or Request objects.`;
     },
     "add-to-cache-list-conflicting-entries": ({ firstEntry, secondEntry })=>{
         if (!firstEntry || !secondEntry) {
-            throw new Error(`Unexpected input to ` + `'add-to-cache-list-duplicate-entries' error.`);
+            throw new Error("Unexpected input to " + `'add-to-cache-list-duplicate-entries' error.`);
         }
-        return `Two of the entries passed to ` + `'@serwist/precaching.PrecacheController.addToCacheList()' had the URL ` + `${firstEntry} but different revision details. Serwist is ` + `unable to cache and version the asset correctly. Please remove one ` + `of the entries.`;
+        return `Two of the entries passed to '@serwist/precaching.PrecacheController.addToCacheList()' had the URL ${firstEntry} but different revision details. Serwist is unable to cache and version the asset correctly. Please remove one of the entries.`;
     },
     "plugin-error-request-will-fetch": ({ thrownErrorMessage })=>{
         if (!thrownErrorMessage) {
-            throw new Error(`Unexpected input to ` + `'plugin-error-request-will-fetch', error.`);
+            throw new Error("Unexpected input to " + `'plugin-error-request-will-fetch', error.`);
         }
-        return `An error was thrown by a plugins 'requestWillFetch()' method. ` + `The thrown error message was: '${thrownErrorMessage}'.`;
+        return `An error was thrown by a plugins 'requestWillFetch()' method. The thrown error message was: '${thrownErrorMessage}'.`;
     },
     "invalid-cache-name": ({ cacheNameId, value })=>{
         if (!cacheNameId) {
             throw new Error(`Expected a 'cacheNameId' for error 'invalid-cache-name'`);
         }
-        return `You must provide a name containing at least one character for ` + `setCacheDetails({${cacheNameId}: '...'}). Received a value of ` + `'${JSON.stringify(value)}'`;
+        return `You must provide a name containing at least one character for setCacheDetails({${cacheNameId}: '...'}). Received a value of '${JSON.stringify(value)}'`;
     },
     "unregister-route-but-not-found-with-method": ({ method })=>{
         if (!method) {
-            throw new Error(`Unexpected input to ` + `'unregister-route-but-not-found-with-method' error.`);
+            throw new Error("Unexpected input to " + `'unregister-route-but-not-found-with-method' error.`);
         }
-        return `The route you're trying to unregister was not  previously ` + `registered for the method type '${method}'.`;
+        return `The route you're trying to unregister was not  previously registered for the method type '${method}'.`;
     },
     "unregister-route-route-not-registered": ()=>{
-        return `The route you're trying to unregister was not previously ` + `registered.`;
+        return `The route you're trying to unregister was not previously ` + "registered.";
     },
     "queue-replay-failed": ({ name })=>{
         return `Replaying the background sync queue '${name}' failed.`;
     },
     "duplicate-queue-name": ({ name })=>{
-        return `The Queue name '${name}' is already being used. ` + `All instances of backgroundSync.Queue must be given unique names.`;
+        return `The Queue name '${name}' is already being used. All instances of backgroundSync.Queue must be given unique names.`;
     },
     "expired-test-without-max-age": ({ methodName, paramName })=>{
         return `The '${methodName}()' method can only be used when the ` + `'${paramName}' is used in the constructor.`;
     },
     "unsupported-route-type": ({ moduleName, className, funcName, paramName })=>{
-        return `The supplied '${paramName}' parameter was an unsupported type. ` + `Please check the docs for ${moduleName}.${className}.${funcName} for ` + `valid input types.`;
+        return `The supplied '${paramName}' parameter was an unsupported type. Please check the docs for ${moduleName}.${className}.${funcName} for valid input types.`;
     },
     "not-array-of-class": ({ value, expectedClass, moduleName, className, funcName, paramName })=>{
-        return `The supplied '${paramName}' parameter must be an array of ` + `'${expectedClass}' objects. Received '${JSON.stringify(value)},'. ` + `Please check the call to ${moduleName}.${className}.${funcName}() ` + `to fix the issue.`;
+        return `The supplied '${paramName}' parameter must be an array of '${expectedClass}' objects. Received '${JSON.stringify(value)},'. Please check the call to ${moduleName}.${className}.${funcName}() to fix the issue.`;
     },
     "max-entries-or-age-required": ({ moduleName, className, funcName })=>{
-        return `You must define either config.maxEntries or config.maxAgeSeconds` + `in ${moduleName}.${className}.${funcName}`;
+        return `You must define either config.maxEntries or config.maxAgeSecondsin ${moduleName}.${className}.${funcName}`;
     },
     "statuses-or-headers-required": ({ moduleName, className, funcName })=>{
-        return `You must define either config.statuses or config.headers` + `in ${moduleName}.${className}.${funcName}`;
+        return `You must define either config.statuses or config.headersin ${moduleName}.${className}.${funcName}`;
     },
     "invalid-string": ({ moduleName, funcName, paramName })=>{
         if (!paramName || !moduleName || !funcName) {
             throw new Error(`Unexpected input to 'invalid-string' error.`);
         }
-        return `When using strings, the '${paramName}' parameter must start with ` + `'http' (for cross-origin matches) or '/' (for same-origin matches). ` + `Please see the docs for ${moduleName}.${funcName}() for ` + `more info.`;
+        return `When using strings, the '${paramName}' parameter must start with 'http' (for cross-origin matches) or '/' (for same-origin matches). Please see the docs for ${moduleName}.${funcName}() for more info.`;
     },
     "channel-name-required": ()=>{
-        return `You must provide a channelName to construct a ` + `BroadcastCacheUpdate instance.`;
+        return "You must provide a channelName to construct a " + "BroadcastCacheUpdate instance.";
     },
     "invalid-responses-are-same-args": ()=>{
-        return `The arguments passed into responsesAreSame() appear to be ` + `invalid. Please ensure valid Responses are used.`;
+        return "The arguments passed into responsesAreSame() appear to be " + "invalid. Please ensure valid Responses are used.";
     },
     "expire-custom-caches-only": ()=>{
-        return `You must provide a 'cacheName' property when using the ` + `expiration plugin with a runtime caching strategy.`;
+        return `You must provide a 'cacheName' property when using the ` + "expiration plugin with a runtime caching strategy.";
     },
     "unit-must-be-bytes": ({ normalizedRangeHeader })=>{
         if (!normalizedRangeHeader) {
             throw new Error(`Unexpected input to 'unit-must-be-bytes' error.`);
         }
-        return `The 'unit' portion of the Range header must be set to 'bytes'. ` + `The Range header provided was "${normalizedRangeHeader}"`;
+        return `The 'unit' portion of the Range header must be set to 'bytes'. The Range header provided was "${normalizedRangeHeader}"`;
     },
     "single-range-only": ({ normalizedRangeHeader })=>{
         if (!normalizedRangeHeader) {
             throw new Error(`Unexpected input to 'single-range-only' error.`);
         }
-        return `Multiple ranges are not supported. Please use a  single start ` + `value, and optional end value. The Range header provided was ` + `"${normalizedRangeHeader}"`;
+        return `Multiple ranges are not supported. Please use a  single start value, and optional end value. The Range header provided was "${normalizedRangeHeader}"`;
     },
     "invalid-range-values": ({ normalizedRangeHeader })=>{
         if (!normalizedRangeHeader) {
             throw new Error(`Unexpected input to 'invalid-range-values' error.`);
         }
-        return `The Range header is missing both start and end values. At least ` + `one of those values is needed. The Range header provided was ` + `"${normalizedRangeHeader}"`;
+        return `The Range header is missing both start and end values. At least one of those values is needed. The Range header provided was "${normalizedRangeHeader}"`;
     },
     "no-range-header": ()=>{
-        return `No Range header was found in the Request provided.`;
+        return "No Range header was found in the Request provided.";
     },
     "range-not-satisfiable": ({ size, start, end })=>{
         return `The start (${start}) and end (${end}) values in the Range are ` + `not satisfiable by the cached response, which is ${size} bytes.`;
     },
     "attempt-to-cache-non-get-request": ({ url, method })=>{
-        return `Unable to cache '${url}' because it is a '${method}' request and ` + `only 'GET' requests can be cached.`;
+        return `Unable to cache '${url}' because it is a '${method}' request and only 'GET' requests can be cached.`;
     },
     "cache-put-with-no-response": ({ url })=>{
-        return `There was an attempt to cache '${url}' but the response was not ` + `defined.`;
+        return `There was an attempt to cache '${url}' but the response was not defined.`;
     },
     "no-response": ({ url, error })=>{
         let message = `The strategy could not generate a response for '${url}'.`;
@@ -227,24 +197,24 @@ const cacheNames = {
         return message;
     },
     "bad-precaching-response": ({ url, status })=>{
-        return `The precaching request for '${url}' failed` + (status ? ` with an HTTP status of ${status}.` : `.`);
+        return `The precaching request for '${url}' failed${status ? ` with an HTTP status of ${status}.` : "."}`;
     },
     "non-precached-url": ({ url })=>{
-        return `createHandlerBoundToURL('${url}') was called, but that URL is ` + `not precached. Please pass in a URL that is precached instead.`;
+        return `createHandlerBoundToURL('${url}') was called, but that URL is not precached. Please pass in a URL that is precached instead.`;
     },
     "add-to-cache-list-conflicting-integrities": ({ url })=>{
-        return `Two of the entries passed to ` + `'@serwist/precaching.PrecacheController.addToCacheList()' had the URL ` + `${url} with different integrity values. Please remove one of them.`;
+        return `Two of the entries passed to '@serwist/precaching.PrecacheController.addToCacheList()' had the URL ${url} with different integrity values. Please remove one of them.`;
     },
     "missing-precache-entry": ({ cacheName, url })=>{
         return `Unable to find a precached response in ${cacheName} for ${url}.`;
     },
     "cross-origin-copy-response": ({ origin })=>{
-        return `@serwist/core.copyResponse() can only be used with same-origin ` + `responses. It was passed a response with origin ${origin}.`;
+        return `@serwist/core.copyResponse() can only be used with same-origin responses. It was passed a response with origin ${origin}.`;
     },
     "opaque-streams-source": ({ type })=>{
-        const message = `One of the @serwist/streams sources resulted in an ` + `'${type}' response.`;
+        const message = `One of the @serwist/streams sources resulted in an '${type}' response.`;
         if (type === "opaqueredirect") {
-            return `${message} Please do not use a navigation request that results ` + `in a redirect as a source.`;
+            return `${message} Please do not use a navigation request that results in a redirect as a source.`;
         }
         return `${message} Please ensure your sources are CORS-enabled.`;
     }
@@ -291,6 +261,36 @@ const messageGenerator = process.env.NODE_ENV === "production" ? fallback : gene
     }
 }
 
+/*
+  Copyright 2019 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/ let supportStatus;
+/**
+ * A utility function that determines whether the current browser supports
+ * 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.
+ * @private
+ */ function canConstructResponseFromBodyStream() {
+    if (supportStatus === undefined) {
+        const testResponse = new Response("");
+        if ("body" in testResponse) {
+            try {
+                new Response(testResponse.body);
+                supportStatus = true;
+            } catch (error) {
+                supportStatus = false;
+            }
+        }
+        supportStatus = false;
+    }
+    return supportStatus;
+}
+
 /*
  * This method throws if the supplied value is not an array.
  * The destructed values are required to produce a meaningful error for users.
@@ -304,31 +304,31 @@ const messageGenerator = process.env.NODE_ENV === "production" ? fallback : gene
 const hasMethod = (object, expectedMethod, details)=>{
     const type = typeof object[expectedMethod];
     if (type !== "function") {
-        details["expectedMethod"] = expectedMethod;
+        details.expectedMethod = expectedMethod;
         throw new SerwistError("missing-a-method", details);
     }
 };
 const isType = (object, expectedType, details)=>{
+    // biome-ignore lint/suspicious/useValidTypeof: Know to not make a mistake...
     if (typeof object !== expectedType) {
-        details["expectedType"] = expectedType;
+        details.expectedType = expectedType;
         throw new SerwistError("incorrect-type", details);
     }
 };
-const isInstance = (object, // Need the general type to do the check later.
-// eslint-disable-next-line @typescript-eslint/ban-types
+const isInstance = (object, // biome-ignore lint/complexity/noBannedTypes: Need the general type to do the check later.
 expectedClass, details)=>{
     if (!(object instanceof expectedClass)) {
-        details["expectedClassName"] = expectedClass.name;
+        details.expectedClassName = expectedClass.name;
         throw new SerwistError("incorrect-class", details);
     }
 };
 const isOneOf = (value, validValues, details)=>{
     if (!validValues.includes(value)) {
-        details["validValueDescription"] = `Valid values are ${JSON.stringify(validValues)}.`;
+        details.validValueDescription = `Valid values are ${JSON.stringify(validValues)}.`;
         throw new SerwistError("invalid-value", details);
     }
 };
-const isArrayOfClass = (value, // Need general type to do check later.
+const isArrayOfClass = (value, // biome-ignore lint/complexity/noBannedTypes: Need general type to do check later.
 expectedClass, details)=>{
     const error = new SerwistError("not-array-of-class", details);
     if (!Array.isArray(value)) {
@@ -363,14 +363,14 @@ const logger = process.env.NODE_ENV === "production" ? null : (()=>{
     }
     let inGroup = false;
     const methodToColorMap = {
-        debug: `#7f8c8d`,
-        log: `#2ecc71`,
-        warn: `#f39c12`,
-        error: `#c0392b`,
-        groupCollapsed: `#3498db`,
+        debug: "#7f8c8d",
+        log: "#2ecc71",
+        warn: "#f39c12",
+        error: "#c0392b",
+        groupCollapsed: "#3498db",
         groupEnd: null
     };
-    const print = function(method, args) {
+    const print = (method, args)=>{
         if (self.__WB_DISABLE_DEV_LOGS) {
             return;
         }
@@ -384,10 +384,10 @@ const logger = process.env.NODE_ENV === "production" ? null : (()=>{
         }
         const styles = [
             `background: ${methodToColorMap[method]}`,
-            `border-radius: 0.5em`,
-            `color: white`,
-            `font-weight: bold`,
-            `padding: 2px 0.5em`
+            "border-radius: 0.5em",
+            "color: white",
+            "font-weight: bold",
+            "padding: 2px 0.5em"
         ];
         // When in a group, the serwist prefix is not displayed.
         const logPrefix = inGroup ? [] : [
@@ -402,7 +402,7 @@ const logger = process.env.NODE_ENV === "production" ? null : (()=>{
             inGroup = false;
         }
     };
-    // eslint-disable-next-line @typescript-eslint/ban-types
+    // biome-ignore lint/complexity/noBannedTypes: Unknown reason
     const api = {};
     const loggerMethods = Object.keys(methodToColorMap);
     for (const key of loggerMethods){
@@ -421,8 +421,7 @@ const logger = process.env.NODE_ENV === "production" ? null : (()=>{
   license that can be found in the LICENSE file or at
   https://opensource.org/licenses/MIT.
 */ // Callbacks to be executed whenever there's a quota error.
-// Can't change Function type right now.
-// eslint-disable-next-line @typescript-eslint/ban-types
+// biome-ignore lint/complexity/noBannedTypes: Can't change Function type right now.
 const quotaErrorCallbacks = new Set();
 
 exports.SerwistError = SerwistError;

package/dist/quotaErrorCallbacks.js

@@ -49,36 +49,6 @@ const cacheNames = {
     }
 };
 
-/*
-  Copyright 2019 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/ let supportStatus;
-/**
- * A utility function that determines whether the current browser supports
- * 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.
- * @private
- */ function canConstructResponseFromBodyStream() {
-    if (supportStatus === undefined) {
-        const testResponse = new Response("");
-        if ("body" in testResponse) {
-            try {
-                new Response(testResponse.body);
-                supportStatus = true;
-            } catch (error) {
-                supportStatus = false;
-            }
-        }
-        supportStatus = false;
-    }
-    return supportStatus;
-}
-
 /*
   Copyright 2018 Google LLC
 
@@ -111,7 +81,7 @@ const cacheNames = {
         }
         const classNameStr = className ? `${className}.` : "";
         if (isReturnValueProblem) {
-            return `The return value from ` + `'${moduleName}.${classNameStr}${funcName}()' ` + `must be an instance of class ${expectedClassName}.`;
+            return `The return value from '${moduleName}.${classNameStr}${funcName}()' must be an instance of class ${expectedClassName}.`;
         }
         return `The parameter '${paramName}' passed into ` + `'${moduleName}.${classNameStr}${funcName}()' ` + `must be an instance of class ${expectedClassName}.`;
     },
@@ -122,100 +92,100 @@ const cacheNames = {
         return `${moduleName}.${className}.${funcName}() expected the ` + `'${paramName}' parameter to expose a '${expectedMethod}' method.`;
     },
     "add-to-cache-list-unexpected-type": ({ entry })=>{
-        return `An unexpected entry was passed to ` + `'@serwist/precaching.PrecacheController.addToCacheList()' The entry ` + `'${JSON.stringify(entry)}' isn't supported. You must supply an array of ` + `strings with one or more characters, objects with a url property or ` + `Request objects.`;
+        return `An unexpected entry was passed to '@serwist/precaching.PrecacheController.addToCacheList()' The entry '${JSON.stringify(entry)}' isn't supported. You must supply an array of strings with one or more characters, objects with a url property or Request objects.`;
     },
     "add-to-cache-list-conflicting-entries": ({ firstEntry, secondEntry })=>{
         if (!firstEntry || !secondEntry) {
-            throw new Error(`Unexpected input to ` + `'add-to-cache-list-duplicate-entries' error.`);
+            throw new Error("Unexpected input to " + `'add-to-cache-list-duplicate-entries' error.`);
         }
-        return `Two of the entries passed to ` + `'@serwist/precaching.PrecacheController.addToCacheList()' had the URL ` + `${firstEntry} but different revision details. Serwist is ` + `unable to cache and version the asset correctly. Please remove one ` + `of the entries.`;
+        return `Two of the entries passed to '@serwist/precaching.PrecacheController.addToCacheList()' had the URL ${firstEntry} but different revision details. Serwist is unable to cache and version the asset correctly. Please remove one of the entries.`;
     },
     "plugin-error-request-will-fetch": ({ thrownErrorMessage })=>{
         if (!thrownErrorMessage) {
-            throw new Error(`Unexpected input to ` + `'plugin-error-request-will-fetch', error.`);
+            throw new Error("Unexpected input to " + `'plugin-error-request-will-fetch', error.`);
         }
-        return `An error was thrown by a plugins 'requestWillFetch()' method. ` + `The thrown error message was: '${thrownErrorMessage}'.`;
+        return `An error was thrown by a plugins 'requestWillFetch()' method. The thrown error message was: '${thrownErrorMessage}'.`;
     },
     "invalid-cache-name": ({ cacheNameId, value })=>{
         if (!cacheNameId) {
             throw new Error(`Expected a 'cacheNameId' for error 'invalid-cache-name'`);
         }
-        return `You must provide a name containing at least one character for ` + `setCacheDetails({${cacheNameId}: '...'}). Received a value of ` + `'${JSON.stringify(value)}'`;
+        return `You must provide a name containing at least one character for setCacheDetails({${cacheNameId}: '...'}). Received a value of '${JSON.stringify(value)}'`;
     },
     "unregister-route-but-not-found-with-method": ({ method })=>{
         if (!method) {
-            throw new Error(`Unexpected input to ` + `'unregister-route-but-not-found-with-method' error.`);
+            throw new Error("Unexpected input to " + `'unregister-route-but-not-found-with-method' error.`);
         }
-        return `The route you're trying to unregister was not  previously ` + `registered for the method type '${method}'.`;
+        return `The route you're trying to unregister was not  previously registered for the method type '${method}'.`;
     },
     "unregister-route-route-not-registered": ()=>{
-        return `The route you're trying to unregister was not previously ` + `registered.`;
+        return `The route you're trying to unregister was not previously ` + "registered.";
     },
     "queue-replay-failed": ({ name })=>{
         return `Replaying the background sync queue '${name}' failed.`;
     },
     "duplicate-queue-name": ({ name })=>{
-        return `The Queue name '${name}' is already being used. ` + `All instances of backgroundSync.Queue must be given unique names.`;
+        return `The Queue name '${name}' is already being used. All instances of backgroundSync.Queue must be given unique names.`;
     },
     "expired-test-without-max-age": ({ methodName, paramName })=>{
         return `The '${methodName}()' method can only be used when the ` + `'${paramName}' is used in the constructor.`;
     },
     "unsupported-route-type": ({ moduleName, className, funcName, paramName })=>{
-        return `The supplied '${paramName}' parameter was an unsupported type. ` + `Please check the docs for ${moduleName}.${className}.${funcName} for ` + `valid input types.`;
+        return `The supplied '${paramName}' parameter was an unsupported type. Please check the docs for ${moduleName}.${className}.${funcName} for valid input types.`;
     },
     "not-array-of-class": ({ value, expectedClass, moduleName, className, funcName, paramName })=>{
-        return `The supplied '${paramName}' parameter must be an array of ` + `'${expectedClass}' objects. Received '${JSON.stringify(value)},'. ` + `Please check the call to ${moduleName}.${className}.${funcName}() ` + `to fix the issue.`;
+        return `The supplied '${paramName}' parameter must be an array of '${expectedClass}' objects. Received '${JSON.stringify(value)},'. Please check the call to ${moduleName}.${className}.${funcName}() to fix the issue.`;
     },
     "max-entries-or-age-required": ({ moduleName, className, funcName })=>{
-        return `You must define either config.maxEntries or config.maxAgeSeconds` + `in ${moduleName}.${className}.${funcName}`;
+        return `You must define either config.maxEntries or config.maxAgeSecondsin ${moduleName}.${className}.${funcName}`;
     },
     "statuses-or-headers-required": ({ moduleName, className, funcName })=>{
-        return `You must define either config.statuses or config.headers` + `in ${moduleName}.${className}.${funcName}`;
+        return `You must define either config.statuses or config.headersin ${moduleName}.${className}.${funcName}`;
     },
     "invalid-string": ({ moduleName, funcName, paramName })=>{
         if (!paramName || !moduleName || !funcName) {
             throw new Error(`Unexpected input to 'invalid-string' error.`);
         }
-        return `When using strings, the '${paramName}' parameter must start with ` + `'http' (for cross-origin matches) or '/' (for same-origin matches). ` + `Please see the docs for ${moduleName}.${funcName}() for ` + `more info.`;
+        return `When using strings, the '${paramName}' parameter must start with 'http' (for cross-origin matches) or '/' (for same-origin matches). Please see the docs for ${moduleName}.${funcName}() for more info.`;
     },
     "channel-name-required": ()=>{
-        return `You must provide a channelName to construct a ` + `BroadcastCacheUpdate instance.`;
+        return "You must provide a channelName to construct a " + "BroadcastCacheUpdate instance.";
     },
     "invalid-responses-are-same-args": ()=>{
-        return `The arguments passed into responsesAreSame() appear to be ` + `invalid. Please ensure valid Responses are used.`;
+        return "The arguments passed into responsesAreSame() appear to be " + "invalid. Please ensure valid Responses are used.";
     },
     "expire-custom-caches-only": ()=>{
-        return `You must provide a 'cacheName' property when using the ` + `expiration plugin with a runtime caching strategy.`;
+        return `You must provide a 'cacheName' property when using the ` + "expiration plugin with a runtime caching strategy.";
     },
     "unit-must-be-bytes": ({ normalizedRangeHeader })=>{
         if (!normalizedRangeHeader) {
             throw new Error(`Unexpected input to 'unit-must-be-bytes' error.`);
         }
-        return `The 'unit' portion of the Range header must be set to 'bytes'. ` + `The Range header provided was "${normalizedRangeHeader}"`;
+        return `The 'unit' portion of the Range header must be set to 'bytes'. The Range header provided was "${normalizedRangeHeader}"`;
     },
     "single-range-only": ({ normalizedRangeHeader })=>{
         if (!normalizedRangeHeader) {
             throw new Error(`Unexpected input to 'single-range-only' error.`);
         }
-        return `Multiple ranges are not supported. Please use a  single start ` + `value, and optional end value. The Range header provided was ` + `"${normalizedRangeHeader}"`;
+        return `Multiple ranges are not supported. Please use a  single start value, and optional end value. The Range header provided was "${normalizedRangeHeader}"`;
     },
     "invalid-range-values": ({ normalizedRangeHeader })=>{
         if (!normalizedRangeHeader) {
             throw new Error(`Unexpected input to 'invalid-range-values' error.`);
         }
-        return `The Range header is missing both start and end values. At least ` + `one of those values is needed. The Range header provided was ` + `"${normalizedRangeHeader}"`;
+        return `The Range header is missing both start and end values. At least one of those values is needed. The Range header provided was "${normalizedRangeHeader}"`;
     },
     "no-range-header": ()=>{
-        return `No Range header was found in the Request provided.`;
+        return "No Range header was found in the Request provided.";
     },
     "range-not-satisfiable": ({ size, start, end })=>{
         return `The start (${start}) and end (${end}) values in the Range are ` + `not satisfiable by the cached response, which is ${size} bytes.`;
     },
     "attempt-to-cache-non-get-request": ({ url, method })=>{
-        return `Unable to cache '${url}' because it is a '${method}' request and ` + `only 'GET' requests can be cached.`;
+        return `Unable to cache '${url}' because it is a '${method}' request and only 'GET' requests can be cached.`;
     },
     "cache-put-with-no-response": ({ url })=>{
-        return `There was an attempt to cache '${url}' but the response was not ` + `defined.`;
+        return `There was an attempt to cache '${url}' but the response was not defined.`;
     },
     "no-response": ({ url, error })=>{
         let message = `The strategy could not generate a response for '${url}'.`;
@@ -225,24 +195,24 @@ const cacheNames = {
         return message;
     },
     "bad-precaching-response": ({ url, status })=>{
-        return `The precaching request for '${url}' failed` + (status ? ` with an HTTP status of ${status}.` : `.`);
+        return `The precaching request for '${url}' failed${status ? ` with an HTTP status of ${status}.` : "."}`;
     },
     "non-precached-url": ({ url })=>{
-        return `createHandlerBoundToURL('${url}') was called, but that URL is ` + `not precached. Please pass in a URL that is precached instead.`;
+        return `createHandlerBoundToURL('${url}') was called, but that URL is not precached. Please pass in a URL that is precached instead.`;
     },
     "add-to-cache-list-conflicting-integrities": ({ url })=>{
-        return `Two of the entries passed to ` + `'@serwist/precaching.PrecacheController.addToCacheList()' had the URL ` + `${url} with different integrity values. Please remove one of them.`;
+        return `Two of the entries passed to '@serwist/precaching.PrecacheController.addToCacheList()' had the URL ${url} with different integrity values. Please remove one of them.`;
     },
     "missing-precache-entry": ({ cacheName, url })=>{
         return `Unable to find a precached response in ${cacheName} for ${url}.`;
     },
     "cross-origin-copy-response": ({ origin })=>{
-        return `@serwist/core.copyResponse() can only be used with same-origin ` + `responses. It was passed a response with origin ${origin}.`;
+        return `@serwist/core.copyResponse() can only be used with same-origin responses. It was passed a response with origin ${origin}.`;
     },
     "opaque-streams-source": ({ type })=>{
-        const message = `One of the @serwist/streams sources resulted in an ` + `'${type}' response.`;
+        const message = `One of the @serwist/streams sources resulted in an '${type}' response.`;
         if (type === "opaqueredirect") {
-            return `${message} Please do not use a navigation request that results ` + `in a redirect as a source.`;
+            return `${message} Please do not use a navigation request that results in a redirect as a source.`;
         }
         return `${message} Please ensure your sources are CORS-enabled.`;
     }
@@ -289,6 +259,36 @@ const messageGenerator = process.env.NODE_ENV === "production" ? fallback : gene
     }
 }
 
+/*
+  Copyright 2019 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/ let supportStatus;
+/**
+ * A utility function that determines whether the current browser supports
+ * 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.
+ * @private
+ */ function canConstructResponseFromBodyStream() {
+    if (supportStatus === undefined) {
+        const testResponse = new Response("");
+        if ("body" in testResponse) {
+            try {
+                new Response(testResponse.body);
+                supportStatus = true;
+            } catch (error) {
+                supportStatus = false;
+            }
+        }
+        supportStatus = false;
+    }
+    return supportStatus;
+}
+
 /*
  * This method throws if the supplied value is not an array.
  * The destructed values are required to produce a meaningful error for users.
@@ -302,31 +302,31 @@ const messageGenerator = process.env.NODE_ENV === "production" ? fallback : gene
 const hasMethod = (object, expectedMethod, details)=>{
     const type = typeof object[expectedMethod];
     if (type !== "function") {
-        details["expectedMethod"] = expectedMethod;
+        details.expectedMethod = expectedMethod;
         throw new SerwistError("missing-a-method", details);
     }
 };
 const isType = (object, expectedType, details)=>{
+    // biome-ignore lint/suspicious/useValidTypeof: Know to not make a mistake...
     if (typeof object !== expectedType) {
-        details["expectedType"] = expectedType;
+        details.expectedType = expectedType;
         throw new SerwistError("incorrect-type", details);
     }
 };
-const isInstance = (object, // Need the general type to do the check later.
-// eslint-disable-next-line @typescript-eslint/ban-types
+const isInstance = (object, // biome-ignore lint/complexity/noBannedTypes: Need the general type to do the check later.
 expectedClass, details)=>{
     if (!(object instanceof expectedClass)) {
-        details["expectedClassName"] = expectedClass.name;
+        details.expectedClassName = expectedClass.name;
         throw new SerwistError("incorrect-class", details);
     }
 };
 const isOneOf = (value, validValues, details)=>{
     if (!validValues.includes(value)) {
-        details["validValueDescription"] = `Valid values are ${JSON.stringify(validValues)}.`;
+        details.validValueDescription = `Valid values are ${JSON.stringify(validValues)}.`;
         throw new SerwistError("invalid-value", details);
     }
 };
-const isArrayOfClass = (value, // Need general type to do check later.
+const isArrayOfClass = (value, // biome-ignore lint/complexity/noBannedTypes: Need general type to do check later.
 expectedClass, details)=>{
     const error = new SerwistError("not-array-of-class", details);
     if (!Array.isArray(value)) {
@@ -361,14 +361,14 @@ const logger = process.env.NODE_ENV === "production" ? null : (()=>{
     }
     let inGroup = false;
     const methodToColorMap = {
-        debug: `#7f8c8d`,
-        log: `#2ecc71`,
-        warn: `#f39c12`,
-        error: `#c0392b`,
-        groupCollapsed: `#3498db`,
+        debug: "#7f8c8d",
+        log: "#2ecc71",
+        warn: "#f39c12",
+        error: "#c0392b",
+        groupCollapsed: "#3498db",
         groupEnd: null
     };
-    const print = function(method, args) {
+    const print = (method, args)=>{
         if (self.__WB_DISABLE_DEV_LOGS) {
             return;
         }
@@ -382,10 +382,10 @@ const logger = process.env.NODE_ENV === "production" ? null : (()=>{
         }
         const styles = [
             `background: ${methodToColorMap[method]}`,
-            `border-radius: 0.5em`,
-            `color: white`,
-            `font-weight: bold`,
-            `padding: 2px 0.5em`
+            "border-radius: 0.5em",
+            "color: white",
+            "font-weight: bold",
+            "padding: 2px 0.5em"
         ];
         // When in a group, the serwist prefix is not displayed.
         const logPrefix = inGroup ? [] : [
@@ -400,7 +400,7 @@ const logger = process.env.NODE_ENV === "production" ? null : (()=>{
             inGroup = false;
         }
     };
-    // eslint-disable-next-line @typescript-eslint/ban-types
+    // biome-ignore lint/complexity/noBannedTypes: Unknown reason
     const api = {};
     const loggerMethods = Object.keys(methodToColorMap);
     for (const key of loggerMethods){
@@ -419,8 +419,7 @@ const logger = process.env.NODE_ENV === "production" ? null : (()=>{
   license that can be found in the LICENSE file or at
   https://opensource.org/licenses/MIT.
 */ // Callbacks to be executed whenever there's a quota error.
-// Can't change Function type right now.
-// eslint-disable-next-line @typescript-eslint/ban-types
+// biome-ignore lint/complexity/noBannedTypes: Can't change Function type right now.
 const quotaErrorCallbacks = new Set();
 
 export { SerwistError as S, canConstructResponseFromBodyStream as a, cacheNames as c, finalAssertExports as f, logger as l, quotaErrorCallbacks as q };

package/dist/registerQuotaErrorCallback.d.cts

@@ -0,0 +1,8 @@
+/**
+ * Adds a function to the set of quotaErrorCallbacks that will be executed if
+ * there's a quota error.
+ *
+ * @param callback
+ */
+declare function registerQuotaErrorCallback(callback: Function): void;
+export { registerQuotaErrorCallback };

package/dist/setCacheNameDetails.d.cts

@@ -0,0 +1,9 @@
+import type { PartialCacheNameDetails } from "./_private/cacheNames.js";
+/**
+ * Modifies the default cache names used by the Serwist packages.
+ * Cache names are generated as `<prefix>-<Cache Name>-<suffix>`.
+ *
+ * @param details
+ */
+declare function setCacheNameDetails(details: PartialCacheNameDetails): void;
+export { setCacheNameDetails };

package/dist/types.d.cts

@@ -104,7 +104,7 @@ export interface HandlerWillStartCallbackParam {
     state?: PluginState;
 }
 export interface HandlerWillStartCallback {
-    (param: HandlerWillStartCallbackParam): Promise<void | null | undefined>;
+    (param: HandlerWillStartCallbackParam): Promise<any>;
 }
 export interface CacheDidUpdateCallbackParam {
     /**
@@ -131,7 +131,7 @@ export interface CacheDidUpdateCallbackParam {
     state?: PluginState;
 }
 export interface CacheDidUpdateCallback {
-    (param: CacheDidUpdateCallbackParam): Promise<void | null | undefined>;
+    (param: CacheDidUpdateCallbackParam): Promise<any>;
 }
 export interface CacheKeyWillBeUsedCallbackParam {
     mode: string;
@@ -150,7 +150,7 @@ export interface CacheWillUpdateCallbackParam {
     state?: PluginState;
 }
 export interface CacheWillUpdateCallback {
-    (param: CacheWillUpdateCallbackParam): Promise<Response | void | null | undefined>;
+    (param: CacheWillUpdateCallbackParam): Promise<any>;
 }
 export interface CachedResponseWillBeUsedCallbackParam {
     /**
@@ -172,7 +172,7 @@ export interface CachedResponseWillBeUsedCallbackParam {
     state?: PluginState;
 }
 export interface CachedResponseWillBeUsedCallback {
-    (param: CachedResponseWillBeUsedCallbackParam): Promise<Response | void | null | undefined>;
+    (param: CachedResponseWillBeUsedCallbackParam): Promise<any>;
 }
 export interface FetchDidFailCallbackParam {
     error: Error;
@@ -182,7 +182,7 @@ export interface FetchDidFailCallbackParam {
     state?: PluginState;
 }
 export interface FetchDidFailCallback {
-    (param: FetchDidFailCallbackParam): Promise<void | null | undefined>;
+    (param: FetchDidFailCallbackParam): Promise<any>;
 }
 export interface FetchDidSucceedCallbackParam {
     request: Request;
@@ -226,7 +226,7 @@ export interface HandlerDidRespondCallbackParam {
     state?: PluginState;
 }
 export interface HandlerDidRespondCallback {
-    (param: HandlerDidRespondCallbackParam): Promise<void | null | undefined>;
+    (param: HandlerDidRespondCallbackParam): Promise<any>;
 }
 export interface HandlerDidCompleteCallbackParam {
     request: Request;
@@ -236,7 +236,7 @@ export interface HandlerDidCompleteCallbackParam {
     state?: PluginState;
 }
 export interface HandlerDidCompleteCallback {
-    (param: HandlerDidCompleteCallbackParam): Promise<void | null | undefined>;
+    (param: HandlerDidCompleteCallbackParam): Promise<any>;
 }
 /**
  * An object with optional lifecycle callback properties for the fetch and

package/dist/types.d.ts

@@ -104,7 +104,7 @@ export interface HandlerWillStartCallbackParam {
     state?: PluginState;
 }
 export interface HandlerWillStartCallback {
-    (param: HandlerWillStartCallbackParam): Promise<void | null | undefined>;
+    (param: HandlerWillStartCallbackParam): Promise<any>;
 }
 export interface CacheDidUpdateCallbackParam {
     /**
@@ -131,7 +131,7 @@ export interface CacheDidUpdateCallbackParam {
     state?: PluginState;
 }
 export interface CacheDidUpdateCallback {
-    (param: CacheDidUpdateCallbackParam): Promise<void | null | undefined>;
+    (param: CacheDidUpdateCallbackParam): Promise<any>;
 }
 export interface CacheKeyWillBeUsedCallbackParam {
     mode: string;
@@ -150,7 +150,7 @@ export interface CacheWillUpdateCallbackParam {
     state?: PluginState;
 }
 export interface CacheWillUpdateCallback {
-    (param: CacheWillUpdateCallbackParam): Promise<Response | void | null | undefined>;
+    (param: CacheWillUpdateCallbackParam): Promise<any>;
 }
 export interface CachedResponseWillBeUsedCallbackParam {
     /**
@@ -172,7 +172,7 @@ export interface CachedResponseWillBeUsedCallbackParam {
     state?: PluginState;
 }
 export interface CachedResponseWillBeUsedCallback {
-    (param: CachedResponseWillBeUsedCallbackParam): Promise<Response | void | null | undefined>;
+    (param: CachedResponseWillBeUsedCallbackParam): Promise<any>;
 }
 export interface FetchDidFailCallbackParam {
     error: Error;
@@ -182,7 +182,7 @@ export interface FetchDidFailCallbackParam {
     state?: PluginState;
 }
 export interface FetchDidFailCallback {
-    (param: FetchDidFailCallbackParam): Promise<void | null | undefined>;
+    (param: FetchDidFailCallbackParam): Promise<any>;
 }
 export interface FetchDidSucceedCallbackParam {
     request: Request;
@@ -226,7 +226,7 @@ export interface HandlerDidRespondCallbackParam {
     state?: PluginState;
 }
 export interface HandlerDidRespondCallback {
-    (param: HandlerDidRespondCallbackParam): Promise<void | null | undefined>;
+    (param: HandlerDidRespondCallbackParam): Promise<any>;
 }
 export interface HandlerDidCompleteCallbackParam {
     request: Request;
@@ -236,7 +236,7 @@ export interface HandlerDidCompleteCallbackParam {
     state?: PluginState;
 }
 export interface HandlerDidCompleteCallback {
-    (param: HandlerDidCompleteCallbackParam): Promise<void | null | undefined>;
+    (param: HandlerDidCompleteCallbackParam): Promise<any>;
 }
 /**
  * An object with optional lifecycle callback properties for the fetch and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serwist/core",
-  "version": "8.4.0",
+  "version": "8.4.2",
   "type": "module",
   "description": "This module is used by a number of the other Serwist modules to share common code.",
   "files": [
@@ -52,12 +52,12 @@
   },
   "devDependencies": {
     "rollup": "4.9.1",
-    "@serwist/constants": "8.4.0"
+    "@serwist/constants": "8.4.2"
   },
   "scripts": {
     "build": "rimraf dist && cross-env NODE_ENV=production rollup --config rollup.config.js",
     "dev": "rollup --config rollup.config.js --watch",
-    "lint": "eslint src --ext ts,tsx,js,jsx,cjs,mjs",
+    "lint": "biome lint ./src",
     "typecheck": "tsc"
   }
 }