@serwist/precaching 9.0.0-preview.1 → 9.0.0-preview.10

package/dist/PrecacheController.d.ts

@@ -16,12 +16,20 @@ interface PrecacheControllerOptions {
      * a precache miss.
      */
     fallbackToNetwork?: boolean;
+    /**
+     * A number of how many precache requests should be made concurrently.
+     * By default, this value is set to 1, but this can be overriden by
+     * setting this option or `self.__WB_CONCURRENT_PRECACHING`. The former takes
+     * precedence over the latter.
+     */
+    concurrentPrecaching?: number;
 }
 /**
  * Performs efficient precaching of assets.
  */
-declare class PrecacheController {
+export declare class PrecacheController {
     private _installAndActiveListenersAdded?;
+    private _concurrentPrecaching;
     private readonly _strategy;
     private readonly _urlsToCacheKeys;
     private readonly _urlsToCacheModes;
@@ -31,7 +39,7 @@ declare class PrecacheController {
      *
      * @param options
      */
-    constructor({ cacheName, plugins, fallbackToNetwork }?: PrecacheControllerOptions);
+    constructor({ cacheName, plugins, fallbackToNetwork, concurrentPrecaching }?: PrecacheControllerOptions);
     /**
      * The strategy created by this controller and
      * used to cache assets and respond to fetch events.
@@ -134,5 +142,5 @@ declare class PrecacheController {
      */
     createHandlerBoundToURL(url: string): RouteHandlerCallback;
 }
-export { PrecacheController };
+export {};
 //# sourceMappingURL=PrecacheController.d.ts.map

package/dist/PrecacheController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PrecacheController.d.ts","sourceRoot":"","sources":["../src/PrecacheController.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEzE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAGpD,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAU/E,UAAU,yBAAyB;IACjC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC;IAC1B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;GAEG;AACH,cAAM,kBAAkB;IACtB,OAAO,CAAC,+BAA+B,CAAC,CAAU;IAClD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IACrC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAkC;IACnE,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA6G;IAC/I,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAkC;IAE1E;;;;OAIG;gBACS,EAAE,SAAS,EAAE,OAAY,EAAE,iBAAwB,EAAE,GAAE,yBAA8B;IAYjG;;;OAGG;IACH,IAAI,QAAQ,IAAI,QAAQ,CAEvB;IAED;;;;;;;;OAQG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,GAAG,IAAI;IAUnD;;;;;OAKG;IACH,cAAc,CAAC,OAAO,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,GAAG,IAAI;IAwDzD;;;;;;;;;OASG;IACH,OAAO,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,aAAa,CAAC;IAsCvD;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,aAAa,CAAC;IAwBxD;;;;;OAKG;IACH,kBAAkB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAIzC;;;;;OAKG;IACH,aAAa,IAAI,MAAM,EAAE;IAIzB;;;;;;;;OAQG;IACH,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAKlD;;;;OAIG;IACH,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI7D;;;;;;;;;;;;;;;;;OAiBG;IACG,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IAU7E;;;;;;OAMG;IACH,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB;CAY3D;AAED,OAAO,EAAE,kBAAkB,EAAE,CAAC"}
+{"version":3,"file":"PrecacheController.d.ts","sourceRoot":"","sources":["../src/PrecacheController.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEzE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAIpD,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAU/E,UAAU,yBAAyB;IACjC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC;IAC1B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,+BAA+B,CAAC,CAAU;IAClD,OAAO,CAAC,qBAAqB,CAAqB;IAClD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IACrC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAkC;IACnE,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA6G;IAC/I,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAkC;IAE1E;;;;OAIG;gBACS,EAAE,SAAS,EAAE,OAAY,EAAE,iBAAwB,EAAE,oBAAoB,EAAE,GAAE,yBAA8B;IAavH;;;OAGG;IACH,IAAI,QAAQ,IAAI,QAAQ,CAEvB;IAED;;;;;;;;OAQG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,GAAG,IAAI;IAUnD;;;;;OAKG;IACH,cAAc,CAAC,OAAO,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,GAAG,IAAI;IAwDzD;;;;;;;;;OASG;IACH,OAAO,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,aAAa,CAAC;IA2CvD;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,aAAa,CAAC;IAuBxD;;;;;OAKG;IACH,kBAAkB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAIzC;;;;;OAKG;IACH,aAAa,IAAI,MAAM,EAAE;IAIzB;;;;;;;;OAQG;IACH,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAKlD;;;;OAIG;IACH,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI7D;;;;;;;;;;;;;;;;;OAiBG;IACG,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IAU7E;;;;;;OAMG;IACH,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB;CAY3D"}

package/dist/PrecacheFallbackPlugin.d.ts

@@ -1,21 +1,31 @@
-import type { SerwistPlugin } from "@serwist/core";
+import type { HandlerDidErrorCallbackParam, SerwistPlugin } from "@serwist/core";
 import type { PrecacheController } from "./PrecacheController.js";
-interface PrecacheFallbackPluginOptions {
+export interface PrecacheFallbackEntry {
     /**
-     * A precached URL to use as the fallback
+     * A function that checks whether the fallback entry can be used
+     * for a request.
+     */
+    matcher: (param: HandlerDidErrorCallbackParam) => boolean;
+    /**
+     * A precached URL to be used as a fallback.
+     */
+    url: string;
+}
+export interface PrecacheFallbackPluginOptions {
+    /**
+     * Precached URLs to use as the fallback
      * if the associated strategy can't generate a response.
      */
-    fallbackURL: string;
+    fallbackUrls: (string | PrecacheFallbackEntry)[];
     /**
-     * An optional
-     * PrecacheController instance. If not provided, the default
-     * PrecacheController will be used.
+     * An optional `PrecacheController` instance. If not provided, the default
+     * `PrecacheController` will be used.
      */
     precacheController?: PrecacheController;
 }
 /**
- * `PrecacheFallbackPlugin` allows you to specify an "offline fallback"
- * response to be used when a given strategy is unable to generate a response.
+ * `PrecacheFallbackPlugin` allows you to specify offline fallbacks
+ * to be used when a given strategy is unable to generate a response.
  *
  * It does this by intercepting the `handlerDidError` plugin callback
  * and returning a precached response, taking the expected revision parameter
@@ -25,20 +35,20 @@ interface PrecacheFallbackPluginOptions {
  * constructor, the default instance will be used. Generally speaking, most
  * developers will end up using the default.
  */
-declare class PrecacheFallbackPlugin implements SerwistPlugin {
-    private readonly _fallbackURL;
+export declare class PrecacheFallbackPlugin implements SerwistPlugin {
+    private readonly _fallbackUrls;
     private readonly _precacheController;
     /**
-     * Constructs a new PrecacheFallbackPlugin with the associated fallbackURL.
+     * Constructs a new `PrecacheFallbackPlugin` with the associated `fallbackUrls`.
      *
      * @param config
      */
-    constructor({ fallbackURL, precacheController }: PrecacheFallbackPluginOptions);
+    constructor({ fallbackUrls, precacheController }: PrecacheFallbackPluginOptions);
     /**
-     * @returns The precache response for the fallback URL.
+     * @returns The precache response for one of the fallback URLs, or `undefined` if
+     * nothing satisfies the conditions.
      * @private
      */
-    handlerDidError: SerwistPlugin["handlerDidError"];
+    handlerDidError(param: HandlerDidErrorCallbackParam): Promise<Response | undefined>;
 }
-export { PrecacheFallbackPlugin };
 //# sourceMappingURL=PrecacheFallbackPlugin.d.ts.map

package/dist/PrecacheFallbackPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PrecacheFallbackPlugin.d.ts","sourceRoot":"","sources":["../src/PrecacheFallbackPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAGlE,UAAU,6BAA6B;IACrC;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;CACzC;AAED;;;;;;;;;;;GAWG;AACH,cAAM,sBAAuB,YAAW,aAAa;IACnD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqB;IAEzD;;;;OAIG;gBACS,EAAE,WAAW,EAAE,kBAAkB,EAAE,EAAE,6BAA6B;IAK9E;;;OAGG;IACH,eAAe,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAmE;CACrH;AAED,OAAO,EAAE,sBAAsB,EAAE,CAAC"}
+{"version":3,"file":"PrecacheFallbackPlugin.d.ts","sourceRoot":"","sources":["../src/PrecacheFallbackPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,4BAA4B,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAGlE,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;;;OAGG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;CACzC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,sBAAuB,YAAW,aAAa;IAC1D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqC;IACnE,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqB;IAEzD;;;;OAIG;gBACS,EAAE,YAAY,EAAE,kBAAkB,EAAE,EAAE,6BAA6B;IAK/E;;;;OAIG;IACG,eAAe,CAAC,KAAK,EAAE,4BAA4B;CAgB1D"}

package/dist/addRoute.d.ts

@@ -11,6 +11,5 @@ import type { PrecacheRouteOptions } from "./_types.js";
  *
  * @param options See the `@serwist/precaching.PrecacheRoute` options.
  */
-declare function addRoute(options?: PrecacheRouteOptions): void;
-export { addRoute };
+export declare const addRoute: (options?: PrecacheRouteOptions) => void;
 //# sourceMappingURL=addRoute.d.ts.map

package/dist/addRoute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"addRoute.d.ts","sourceRoot":"","sources":["../src/addRoute.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAGxD;;;;;;;;;;;GAWG;AACH,iBAAS,QAAQ,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAKtD;AAED,OAAO,EAAE,QAAQ,EAAE,CAAC"}
+{"version":3,"file":"addRoute.d.ts","sourceRoot":"","sources":["../src/addRoute.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAGxD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ,aAAc,oBAAoB,KAAG,IAKzD,CAAC"}

package/dist/cleanupOutdatedCaches.d.ts

@@ -2,6 +2,5 @@
  * Adds an `activate` event listener which will clean up incompatible
  * precaches that were created by older versions of Serwist.
  */
-declare function cleanupOutdatedCaches(): void;
-export { cleanupOutdatedCaches };
+export declare const cleanupOutdatedCaches: () => void;
 //# sourceMappingURL=cleanupOutdatedCaches.d.ts.map

package/dist/cleanupOutdatedCaches.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cleanupOutdatedCaches.d.ts","sourceRoot":"","sources":["../src/cleanupOutdatedCaches.ts"],"names":[],"mappings":"AAYA;;;GAGG;AACH,iBAAS,qBAAqB,IAAI,IAAI,CAerC;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAC"}
+{"version":3,"file":"cleanupOutdatedCaches.d.ts","sourceRoot":"","sources":["../src/cleanupOutdatedCaches.ts"],"names":[],"mappings":"AAcA;;;GAGG;AACH,eAAO,MAAM,qBAAqB,QAAO,IAcxC,CAAC"}

package/dist/createHandlerBoundToURL.d.ts

@@ -13,6 +13,5 @@ import type { RouteHandlerCallback } from "@serwist/core";
  * response from the network if there's a precache miss.
  * @return
  */
-declare function createHandlerBoundToURL(url: string): RouteHandlerCallback;
-export { createHandlerBoundToURL };
+export declare const createHandlerBoundToURL: (url: string) => RouteHandlerCallback;
 //# sourceMappingURL=createHandlerBoundToURL.d.ts.map

package/dist/createHandlerBoundToURL.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createHandlerBoundToURL.d.ts","sourceRoot":"","sources":["../src/createHandlerBoundToURL.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAI1D;;;;;;;;;;;;;GAaG;AACH,iBAAS,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB,CAGlE;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAC"}
+{"version":3,"file":"createHandlerBoundToURL.d.ts","sourceRoot":"","sources":["../src/createHandlerBoundToURL.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAI1D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uBAAuB,QAAS,MAAM,KAAG,oBAGrD,CAAC"}

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { PrecacheController } from "./PrecacheController.js";
 import { PrecacheFallbackPlugin } from "./PrecacheFallbackPlugin.js";
+import type { PrecacheFallbackEntry, PrecacheFallbackPluginOptions } from "./PrecacheFallbackPlugin.js";
 import { PrecacheRoute } from "./PrecacheRoute.js";
 import { PrecacheStrategy } from "./PrecacheStrategy.js";
 import { addPlugins } from "./addPlugins.js";
@@ -21,5 +22,6 @@ import { precacheAndRoute } from "./precacheAndRoute.js";
  * interface.
  */
 export { addPlugins, addRoute, cleanupOutdatedCaches, createHandlerBoundToURL, getCacheKeyForURL, matchPrecache, precache, precacheAndRoute, PrecacheController, PrecacheFallbackPlugin, PrecacheRoute, PrecacheStrategy, };
-export * from "./_types.js";
+export type * from "./_types.js";
+export type { PrecacheFallbackPluginOptions, PrecacheFallbackEntry };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD;;;;;;;;;GASG;AAEH,OAAO,EACL,UAAU,EACV,QAAQ,EACR,qBAAqB,EACrB,uBAAuB,EACvB,iBAAiB,EACjB,aAAa,EACb,QAAQ,EACR,gBAAgB,EAChB,kBAAkB,EAClB,sBAAsB,EACtB,aAAa,EACb,gBAAgB,GACjB,CAAC;AAEF,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,KAAK,EAAE,qBAAqB,EAAE,6BAA6B,EAAE,MAAM,6BAA6B,CAAC;AACxG,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD;;;;;;;;;GASG;AAEH,OAAO,EACL,UAAU,EACV,QAAQ,EACR,qBAAqB,EACrB,uBAAuB,EACvB,iBAAiB,EACjB,aAAa,EACb,QAAQ,EACR,gBAAgB,EAChB,kBAAkB,EAClB,sBAAsB,EACtB,aAAa,EACb,gBAAgB,GACjB,CAAC;AAEF,mBAAmB,aAAa,CAAC;AAEjC,YAAY,EAAE,6BAA6B,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/index.js

@@ -3,6 +3,32 @@ import { copyResponse } from '@serwist/core';
 import { Strategy } from '@serwist/strategies';
 import { Route, registerRoute } from '@serwist/routing';
 
+const parallel = async (limit, array, func)=>{
+    const work = array.map((item, index)=>({
+            index,
+            item
+        }));
+    const processor = async (res)=>{
+        const results = [];
+        while(true){
+            const next = work.pop();
+            if (!next) {
+                return res(results);
+            }
+            const result = await func(next.item);
+            results.push({
+                result: result,
+                index: next.index
+            });
+        }
+    };
+    const queues = Array.from({
+        length: limit
+    }, ()=>new Promise(processor));
+    const results = (await Promise.all(queues)).flat().sort((a, b)=>a.index < b.index ? -1 : 1).map((res)=>res.result);
+    return results;
+};
+
 class PrecacheStrategy extends Strategy {
     _fallbackToNetwork;
     static defaultPrecacheCacheabilityPlugin = {
@@ -225,11 +251,12 @@ function printInstallDetails(urlsToPrecache, urlsAlreadyPrecached) {
 
 class PrecacheController {
     _installAndActiveListenersAdded;
+    _concurrentPrecaching;
     _strategy;
     _urlsToCacheKeys = new Map();
     _urlsToCacheModes = new Map();
     _cacheKeysToIntegrities = new Map();
-    constructor({ cacheName, plugins = [], fallbackToNetwork = true } = {}){
+    constructor({ cacheName, plugins = [], fallbackToNetwork = true, concurrentPrecaching } = {}){
         this._strategy = new PrecacheStrategy({
             cacheName: privateCacheNames.getPrecacheName(cacheName),
             plugins: [
@@ -240,6 +267,7 @@ class PrecacheController {
             ],
             fallbackToNetwork
         });
+        this._concurrentPrecaching = concurrentPrecaching;
         this.install = this.install.bind(this);
         this.activate = this.activate.bind(this);
     }
@@ -302,7 +330,14 @@ class PrecacheController {
         return waitUntil(event, async ()=>{
             const installReportPlugin = new PrecacheInstallReportPlugin();
             this.strategy.plugins.push(installReportPlugin);
-            for (const [url, cacheKey] of this._urlsToCacheKeys){
+            let concurrents = this._concurrentPrecaching;
+            if (concurrents === undefined) {
+                if (!("__WB_CONCURRENT_PRECACHING" in globalThis)) {
+                    self.__WB_CONCURRENT_PRECACHING = 1;
+                }
+                concurrents = self.__WB_CONCURRENT_PRECACHING;
+            }
+            await parallel(concurrents, Array.from(this._urlsToCacheKeys.entries()), async ([url, cacheKey])=>{
                 const integrity = this._cacheKeysToIntegrities.get(cacheKey);
                 const cacheMode = this._urlsToCacheModes.get(url);
                 const request = new Request(url, {
@@ -317,7 +352,7 @@ class PrecacheController {
                     request,
                     event
                 }));
-            }
+            });
             const { updatedURLs, notUpdatedURLs } = installReportPlugin;
             if (process.env.NODE_ENV !== "production") {
                 printInstallDetails(updatedURLs, notUpdatedURLs);
@@ -333,18 +368,18 @@ class PrecacheController {
             const cache = await self.caches.open(this.strategy.cacheName);
             const currentlyCachedRequests = await cache.keys();
             const expectedCacheKeys = new Set(this._urlsToCacheKeys.values());
-            const deletedURLs = [];
+            const deletedCacheRequests = [];
             for (const request of currentlyCachedRequests){
                 if (!expectedCacheKeys.has(request.url)) {
                     await cache.delete(request);
-                    deletedURLs.push(request.url);
+                    deletedCacheRequests.push(request.url);
                 }
             }
             if (process.env.NODE_ENV !== "production") {
-                printCleanupDetails(deletedURLs);
+                printCleanupDetails(deletedCacheRequests);
             }
             return {
-                deletedURLs
+                deletedCacheRequests
             };
         });
     }
@@ -399,13 +434,28 @@ const getOrCreatePrecacheController = ()=>{
 };
 
 class PrecacheFallbackPlugin {
-    _fallbackURL;
+    _fallbackUrls;
     _precacheController;
-    constructor({ fallbackURL, precacheController }){
-        this._fallbackURL = fallbackURL;
+    constructor({ fallbackUrls, precacheController }){
+        this._fallbackUrls = fallbackUrls;
         this._precacheController = precacheController || getOrCreatePrecacheController();
     }
-    handlerDidError = ()=>this._precacheController.matchPrecache(this._fallbackURL);
+    async handlerDidError(param) {
+        for (const fallback of this._fallbackUrls){
+            if (typeof fallback === "string") {
+                const fallbackResponse = await this._precacheController.matchPrecache(fallback);
+                if (fallbackResponse !== undefined) {
+                    return fallbackResponse;
+                }
+            } else if (fallback.matcher(param)) {
+                const fallbackResponse = await this._precacheController.matchPrecache(fallback.url);
+                if (fallbackResponse !== undefined) {
+                    return fallbackResponse;
+                }
+            }
+        }
+        return undefined;
+    }
 }
 
 function removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching = []) {
@@ -476,11 +526,11 @@ function addPlugins(plugins) {
     precacheController.strategy.plugins.push(...plugins);
 }
 
-function addRoute(options) {
+const addRoute = (options)=>{
     const precacheController = getOrCreatePrecacheController();
     const precacheRoute = new PrecacheRoute(precacheController, options);
     registerRoute(precacheRoute);
-}
+};
 
 const SUBSTRING_TO_FIND = "-precache-";
 const deleteOutdatedCaches = async (currentPrecacheName, substringToFind = SUBSTRING_TO_FIND)=>{
@@ -492,23 +542,23 @@ const deleteOutdatedCaches = async (currentPrecacheName, substringToFind = SUBST
     return cacheNamesToDelete;
 };
 
-function cleanupOutdatedCaches() {
+const cleanupOutdatedCaches = ()=>{
     self.addEventListener("activate", (event)=>{
         const cacheName = privateCacheNames.getPrecacheName();
         event.waitUntil(deleteOutdatedCaches(cacheName).then((cachesDeleted)=>{
             if (process.env.NODE_ENV !== "production") {
                 if (cachesDeleted.length > 0) {
-                    logger.log("The following out-of-date precaches were cleaned up " + "automatically:", cachesDeleted);
+                    logger.log("The following out-of-date precaches were cleaned up automatically:", cachesDeleted);
                 }
             }
         }));
     });
-}
+};
 
-function createHandlerBoundToURL(url) {
+const createHandlerBoundToURL = (url)=>{
     const precacheController = getOrCreatePrecacheController();
     return precacheController.createHandlerBoundToURL(url);
-}
+};
 
 function getCacheKeyForURL(url) {
     const precacheController = getOrCreatePrecacheController();
@@ -520,14 +570,14 @@ function matchPrecache(request) {
     return precacheController.matchPrecache(request);
 }
 
-function precache(entries) {
+const precache = (entries)=>{
     const precacheController = getOrCreatePrecacheController();
     precacheController.precache(entries);
-}
+};
 
-function precacheAndRoute(entries, options) {
+const precacheAndRoute = (entries, options)=>{
     precache(entries);
     addRoute(options);
-}
+};
 
 export { PrecacheController, PrecacheFallbackPlugin, PrecacheRoute, PrecacheStrategy, addPlugins, addRoute, cleanupOutdatedCaches, createHandlerBoundToURL, getCacheKeyForURL, matchPrecache, precache, precacheAndRoute };

package/dist/precache.d.ts

@@ -15,6 +15,5 @@ import type { PrecacheEntry } from "./_types.js";
  *
  * @param entries Array of entries to precache.
  */
-declare function precache(entries: (PrecacheEntry | string)[]): void;
-export { precache };
+export declare const precache: (entries: (PrecacheEntry | string)[]) => void;
 //# sourceMappingURL=precache.d.ts.map

package/dist/precache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"precache.d.ts","sourceRoot":"","sources":["../src/precache.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD;;;;;;;;;;;;;;;GAeG;AACH,iBAAS,QAAQ,CAAC,OAAO,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,GAAG,IAAI,CAG3D;AAED,OAAO,EAAE,QAAQ,EAAE,CAAC"}
+{"version":3,"file":"precache.d.ts","sourceRoot":"","sources":["../src/precache.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,QAAQ,YAAa,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,KAAG,IAG9D,CAAC"}

package/dist/precacheAndRoute.d.ts

@@ -10,6 +10,5 @@ import type { PrecacheEntry, PrecacheRouteOptions } from "./_types.js";
  * @param entries Array of entries to precache.
  * @param options See the `@serwist/precaching.PrecacheRoute` options.
  */
-declare function precacheAndRoute(entries: (PrecacheEntry | string)[], options?: PrecacheRouteOptions): void;
-export { precacheAndRoute };
+export declare const precacheAndRoute: (entries: (PrecacheEntry | string)[], options?: PrecacheRouteOptions) => void;
 //# sourceMappingURL=precacheAndRoute.d.ts.map

package/dist/precacheAndRoute.d.ts.map

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

package/dist/utils/deleteOutdatedCaches.d.ts

@@ -14,6 +14,5 @@
  * @returns A list of all the cache names that were deleted.
  * @private
  */
-declare const deleteOutdatedCaches: (currentPrecacheName: string, substringToFind?: string) => Promise<string[]>;
-export { deleteOutdatedCaches };
+export declare const deleteOutdatedCaches: (currentPrecacheName: string, substringToFind?: string) => Promise<string[]>;
 //# sourceMappingURL=deleteOutdatedCaches.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"deleteOutdatedCaches.d.ts","sourceRoot":"","sources":["../../src/utils/deleteOutdatedCaches.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;GAeG;AACH,QAAA,MAAM,oBAAoB,wBAA+B,MAAM,oBAAmB,MAAM,KAAuB,QAAQ,MAAM,EAAE,CAU9H,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,CAAC"}
+{"version":3,"file":"deleteOutdatedCaches.d.ts","sourceRoot":"","sources":["../../src/utils/deleteOutdatedCaches.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB,wBAA+B,MAAM,oBAAmB,MAAM,KAAuB,QAAQ,MAAM,EAAE,CAUrI,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serwist/precaching",
-  "version": "9.0.0-preview.1",
+  "version": "9.0.0-preview.10",
   "type": "module",
   "description": "This module efficiently precaches assets.",
   "files": [
@@ -28,14 +28,15 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@serwist/core": "9.0.0-preview.1",
-    "@serwist/routing": "9.0.0-preview.1",
-    "@serwist/strategies": "9.0.0-preview.1"
+    "@serwist/core": "9.0.0-preview.10",
+    "@serwist/routing": "9.0.0-preview.10",
+    "@serwist/strategies": "9.0.0-preview.10"
   },
   "devDependencies": {
     "rollup": "4.9.6",
-    "typescript": "5.4.0-dev.20240203",
-    "@serwist/constants": "9.0.0-preview.1"
+    "typescript": "5.4.0-dev.20240206",
+    "@serwist/constants": "9.0.0-preview.10",
+    "@serwist/utils": "9.0.0-preview.10"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0"

package/src/PrecacheController.ts

@@ -9,6 +9,7 @@
 import type { RouteHandlerCallback, SerwistPlugin } from "@serwist/core";
 import { assert, SerwistError, logger, privateCacheNames, waitUntil } from "@serwist/core/internal";
 import type { Strategy } from "@serwist/strategies";
+import { parallel } from "@serwist/utils";
 
 import { PrecacheStrategy } from "./PrecacheStrategy.js";
 import type { CleanupResult, InstallResult, PrecacheEntry } from "./_types.js";
@@ -19,7 +20,7 @@ import { printCleanupDetails } from "./utils/printCleanupDetails.js";
 import { printInstallDetails } from "./utils/printInstallDetails.js";
 
 // Give TypeScript the correct global.
-declare let self: ServiceWorkerGlobalScope;
+declare const self: ServiceWorkerGlobalScope;
 
 interface PrecacheControllerOptions {
   /**
@@ -36,13 +37,21 @@ interface PrecacheControllerOptions {
    * a precache miss.
    */
   fallbackToNetwork?: boolean;
+  /**
+   * A number of how many precache requests should be made concurrently.
+   * By default, this value is set to 1, but this can be overriden by
+   * setting this option or `self.__WB_CONCURRENT_PRECACHING`. The former takes
+   * precedence over the latter.
+   */
+  concurrentPrecaching?: number;
 }
 
 /**
  * Performs efficient precaching of assets.
  */
-class PrecacheController {
+export class PrecacheController {
   private _installAndActiveListenersAdded?: boolean;
+  private _concurrentPrecaching: number | undefined;
   private readonly _strategy: Strategy;
   private readonly _urlsToCacheKeys: Map<string, string> = new Map();
   private readonly _urlsToCacheModes: Map<string, "reload" | "default" | "no-store" | "no-cache" | "force-cache" | "only-if-cached"> = new Map();
@@ -53,12 +62,13 @@ class PrecacheController {
    *
    * @param options
    */
-  constructor({ cacheName, plugins = [], fallbackToNetwork = true }: PrecacheControllerOptions = {}) {
+  constructor({ cacheName, plugins = [], fallbackToNetwork = true, concurrentPrecaching }: PrecacheControllerOptions = {}) {
     this._strategy = new PrecacheStrategy({
       cacheName: privateCacheNames.getPrecacheName(cacheName),
       plugins: [...plugins, new PrecacheCacheKeyPlugin({ precacheController: this })],
       fallbackToNetwork,
     });
+    this._concurrentPrecaching = concurrentPrecaching;
 
     // Bind the install and activate methods to the instance.
     this.install = this.install.bind(this);
@@ -165,15 +175,20 @@ class PrecacheController {
    * @returns
    */
   install(event: ExtendableEvent): Promise<InstallResult> {
-    // waitUntil returns Promise<any>
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return waitUntil(event, async () => {
+    return waitUntil<InstallResult>(event, async () => {
       const installReportPlugin = new PrecacheInstallReportPlugin();
       this.strategy.plugins.push(installReportPlugin);
 
-      // Cache entries one at a time.
-      // See https://github.com/GoogleChrome/workbox/issues/2528
-      for (const [url, cacheKey] of this._urlsToCacheKeys) {
+      let concurrents = this._concurrentPrecaching;
+
+      if (concurrents === undefined) {
+        if (!("__WB_CONCURRENT_PRECACHING" in globalThis)) {
+          self.__WB_CONCURRENT_PRECACHING = 1;
+        }
+        concurrents = self.__WB_CONCURRENT_PRECACHING;
+      }
+
+      await parallel(concurrents, Array.from(this._urlsToCacheKeys.entries()), async ([url, cacheKey]) => {
         const integrity = this._cacheKeysToIntegrities.get(cacheKey);
         const cacheMode = this._urlsToCacheModes.get(url);
 
@@ -190,7 +205,7 @@ class PrecacheController {
             event,
           }),
         );
-      }
+      });
 
       const { updatedURLs, notUpdatedURLs } = installReportPlugin;
 
@@ -213,26 +228,25 @@ class PrecacheController {
    * @returns
    */
   activate(event: ExtendableEvent): Promise<CleanupResult> {
-    // waitUntil returns Promise<any>
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return waitUntil(event, async () => {
+    return waitUntil<CleanupResult>(event, async () => {
       const cache = await self.caches.open(this.strategy.cacheName);
       const currentlyCachedRequests = await cache.keys();
       const expectedCacheKeys = new Set(this._urlsToCacheKeys.values());
 
-      const deletedURLs = [];
+      const deletedCacheRequests: string[] = [];
+
       for (const request of currentlyCachedRequests) {
         if (!expectedCacheKeys.has(request.url)) {
           await cache.delete(request);
-          deletedURLs.push(request.url);
+          deletedCacheRequests.push(request.url);
         }
       }
 
       if (process.env.NODE_ENV !== "production") {
-        printCleanupDetails(deletedURLs);
+        printCleanupDetails(deletedCacheRequests);
       }
 
-      return { deletedURLs };
+      return { deletedCacheRequests };
     });
   }
 
@@ -327,5 +341,3 @@ class PrecacheController {
     };
   }
 }
-
-export { PrecacheController };

package/src/PrecacheFallbackPlugin.ts

@@ -6,28 +6,39 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { SerwistPlugin } from "@serwist/core";
+import type { HandlerDidErrorCallbackParam, SerwistPlugin } from "@serwist/core";
 
 import type { PrecacheController } from "./PrecacheController.js";
 import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheController.js";
 
-interface PrecacheFallbackPluginOptions {
+export interface PrecacheFallbackEntry {
   /**
-   * A precached URL to use as the fallback
+   * A function that checks whether the fallback entry can be used
+   * for a request.
+   */
+  matcher: (param: HandlerDidErrorCallbackParam) => boolean;
+  /**
+   * A precached URL to be used as a fallback.
+   */
+  url: string;
+}
+
+export interface PrecacheFallbackPluginOptions {
+  /**
+   * Precached URLs to use as the fallback
    * if the associated strategy can't generate a response.
    */
-  fallbackURL: string;
+  fallbackUrls: (string | PrecacheFallbackEntry)[];
   /**
-   * An optional
-   * PrecacheController instance. If not provided, the default
-   * PrecacheController will be used.
+   * An optional `PrecacheController` instance. If not provided, the default
+   * `PrecacheController` will be used.
    */
   precacheController?: PrecacheController;
 }
 
 /**
- * `PrecacheFallbackPlugin` allows you to specify an "offline fallback"
- * response to be used when a given strategy is unable to generate a response.
+ * `PrecacheFallbackPlugin` allows you to specify offline fallbacks
+ * to be used when a given strategy is unable to generate a response.
  *
  * It does this by intercepting the `handlerDidError` plugin callback
  * and returning a precached response, taking the expected revision parameter
@@ -37,25 +48,39 @@ interface PrecacheFallbackPluginOptions {
  * constructor, the default instance will be used. Generally speaking, most
  * developers will end up using the default.
  */
-class PrecacheFallbackPlugin implements SerwistPlugin {
-  private readonly _fallbackURL: string;
+export class PrecacheFallbackPlugin implements SerwistPlugin {
+  private readonly _fallbackUrls: (string | PrecacheFallbackEntry)[];
   private readonly _precacheController: PrecacheController;
 
   /**
-   * Constructs a new PrecacheFallbackPlugin with the associated fallbackURL.
+   * Constructs a new `PrecacheFallbackPlugin` with the associated `fallbackUrls`.
    *
    * @param config
    */
-  constructor({ fallbackURL, precacheController }: PrecacheFallbackPluginOptions) {
-    this._fallbackURL = fallbackURL;
+  constructor({ fallbackUrls, precacheController }: PrecacheFallbackPluginOptions) {
+    this._fallbackUrls = fallbackUrls;
     this._precacheController = precacheController || getOrCreatePrecacheController();
   }
 
   /**
-   * @returns The precache response for the fallback URL.
+   * @returns The precache response for one of the fallback URLs, or `undefined` if
+   * nothing satisfies the conditions.
    * @private
    */
-  handlerDidError: SerwistPlugin["handlerDidError"] = () => this._precacheController.matchPrecache(this._fallbackURL);
+  async handlerDidError(param: HandlerDidErrorCallbackParam) {
+    for (const fallback of this._fallbackUrls) {
+      if (typeof fallback === "string") {
+        const fallbackResponse = await this._precacheController.matchPrecache(fallback);
+        if (fallbackResponse !== undefined) {
+          return fallbackResponse;
+        }
+      } else if (fallback.matcher(param)) {
+        const fallbackResponse = await this._precacheController.matchPrecache(fallback.url);
+        if (fallbackResponse !== undefined) {
+          return fallbackResponse;
+        }
+      }
+    }
+    return undefined;
+  }
 }
-
-export { PrecacheFallbackPlugin };

package/src/addRoute.ts

@@ -23,11 +23,9 @@ import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheContro
  *
  * @param options See the `@serwist/precaching.PrecacheRoute` options.
  */
-function addRoute(options?: PrecacheRouteOptions): void {
+export const addRoute = (options?: PrecacheRouteOptions): void => {
   const precacheController = getOrCreatePrecacheController();
 
   const precacheRoute = new PrecacheRoute(precacheController, options);
   registerRoute(precacheRoute);
-}
-
-export { addRoute };
+};

package/src/cleanupOutdatedCaches.ts

@@ -10,25 +10,24 @@ import { logger, privateCacheNames } from "@serwist/core/internal";
 
 import { deleteOutdatedCaches } from "./utils/deleteOutdatedCaches.js";
 
+declare const self: ServiceWorkerGlobalScope;
+
 /**
  * Adds an `activate` event listener which will clean up incompatible
  * precaches that were created by older versions of Serwist.
  */
-function cleanupOutdatedCaches(): void {
-  // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705
-  self.addEventListener("activate", ((event: ExtendableEvent) => {
+export const cleanupOutdatedCaches = (): void => {
+  self.addEventListener("activate", (event: ExtendableEvent) => {
     const cacheName = privateCacheNames.getPrecacheName();
 
     event.waitUntil(
       deleteOutdatedCaches(cacheName).then((cachesDeleted) => {
         if (process.env.NODE_ENV !== "production") {
           if (cachesDeleted.length > 0) {
-            logger.log("The following out-of-date precaches were cleaned up " + "automatically:", cachesDeleted);
+            logger.log("The following out-of-date precaches were cleaned up automatically:", cachesDeleted);
           }
         }
       }),
     );
-  }) as EventListener);
-}
-
-export { cleanupOutdatedCaches };
+  });
+};

package/src/createHandlerBoundToURL.ts

@@ -24,9 +24,7 @@ import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheContro
  * response from the network if there's a precache miss.
  * @return
  */
-function createHandlerBoundToURL(url: string): RouteHandlerCallback {
+export const createHandlerBoundToURL = (url: string): RouteHandlerCallback => {
   const precacheController = getOrCreatePrecacheController();
   return precacheController.createHandlerBoundToURL(url);
-}
-
-export { createHandlerBoundToURL };
+};

package/src/index.ts

@@ -8,6 +8,7 @@
 
 import { PrecacheController } from "./PrecacheController.js";
 import { PrecacheFallbackPlugin } from "./PrecacheFallbackPlugin.js";
+import type { PrecacheFallbackEntry, PrecacheFallbackPluginOptions } from "./PrecacheFallbackPlugin.js";
 import { PrecacheRoute } from "./PrecacheRoute.js";
 import { PrecacheStrategy } from "./PrecacheStrategy.js";
 import { addPlugins } from "./addPlugins.js";
@@ -45,4 +46,6 @@ export {
   PrecacheStrategy,
 };
 
-export * from "./_types.js";
+export type * from "./_types.js";
+
+export type { PrecacheFallbackPluginOptions, PrecacheFallbackEntry };

package/src/precache.ts

@@ -25,9 +25,7 @@ import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheContro
  *
  * @param entries Array of entries to precache.
  */
-function precache(entries: (PrecacheEntry | string)[]): void {
+export const precache = (entries: (PrecacheEntry | string)[]): void => {
   const precacheController = getOrCreatePrecacheController();
   precacheController.precache(entries);
-}
-
-export { precache };
+};

package/src/precacheAndRoute.ts

@@ -21,9 +21,7 @@ import { precache } from "./precache.js";
  * @param entries Array of entries to precache.
  * @param options See the `@serwist/precaching.PrecacheRoute` options.
  */
-function precacheAndRoute(entries: (PrecacheEntry | string)[], options?: PrecacheRouteOptions): void {
+export const precacheAndRoute = (entries: (PrecacheEntry | string)[], options?: PrecacheRouteOptions): void => {
   precache(entries);
   addRoute(options);
-}
-
-export { precacheAndRoute };
+};

package/src/utils/deleteOutdatedCaches.ts

@@ -27,7 +27,7 @@ const SUBSTRING_TO_FIND = "-precache-";
  * @returns A list of all the cache names that were deleted.
  * @private
  */
-const deleteOutdatedCaches = async (currentPrecacheName: string, substringToFind: string = SUBSTRING_TO_FIND): Promise<string[]> => {
+export const deleteOutdatedCaches = async (currentPrecacheName: string, substringToFind: string = SUBSTRING_TO_FIND): Promise<string[]> => {
   const cacheNames = await self.caches.keys();
 
   const cacheNamesToDelete = cacheNames.filter((cacheName) => {
@@ -38,5 +38,3 @@ const deleteOutdatedCaches = async (currentPrecacheName: string, substringToFind
 
   return cacheNamesToDelete;
 };
-
-export { deleteOutdatedCaches };