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

package/dist/index.js

@@ -3,15 +3,33 @@ import { copyResponse } from '@serwist/core';
 import { Strategy } from '@serwist/strategies';
 import { Route, registerRoute } from '@serwist/routing';
 
-/**
- * A `@serwist/strategies.Strategy` implementation
- * specifically designed to work with
- * `@serwist/precaching.PrecacheController`
- * to both cache and fetch precached assets.
- *
- * Note: an instance of this class is created automatically when creating a
- * `PrecacheController`; it's generally not necessary to create this yourself.
- */ class PrecacheStrategy extends Strategy {
+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 = {
         async cacheWillUpdate ({ response }) {
@@ -26,41 +44,25 @@ import { Route, registerRoute } from '@serwist/routing';
             return response.redirected ? await copyResponse(response) : response;
         }
     };
-    /**
-   * @param options
-   */ constructor(options = {}){
+    constructor(options = {}){
         options.cacheName = privateCacheNames.getPrecacheName(options.cacheName);
         super(options);
         this._fallbackToNetwork = options.fallbackToNetwork === false ? false : true;
-        // Redirected responses cannot be used to satisfy a navigation request, so
-        // any redirected response must be "copied" rather than cloned, so the new
-        // response doesn't contain the `redirected` flag. See:
-        // https://bugs.chromium.org/p/chromium/issues/detail?id=669363&desc=2#c1
         this.plugins.push(PrecacheStrategy.copyRedirectedCacheableResponsesPlugin);
     }
-    /**
-   * @private
-   * @param request A request to run this strategy for.
-   * @param handler The event that triggered the request.
-   * @returns
-   */ async _handle(request, handler) {
+    async _handle(request, handler) {
         const response = await handler.cacheMatch(request);
         if (response) {
             return response;
         }
-        // If this is an `install` event for an entry that isn't already cached,
-        // then populate the cache.
         if (handler.event && handler.event.type === "install") {
             return await this._handleInstall(request, handler);
         }
-        // Getting here means something went wrong. An entry that should have been
-        // precached wasn't found in the cache.
         return await this._handleFetch(request, handler);
     }
     async _handleFetch(request, handler) {
         let response = undefined;
         const params = handler.params || {};
-        // Fallback to the network if we're configured to do so.
         if (this._fallbackToNetwork) {
             if (process.env.NODE_ENV !== "production") {
                 logger.warn(`The precached response for ${getFriendlyURL(request.url)} in ${this.cacheName} was not found. Falling back to the network.`);
@@ -68,18 +70,9 @@ import { Route, registerRoute } from '@serwist/routing';
             const integrityInManifest = params.integrity;
             const integrityInRequest = request.integrity;
             const noIntegrityConflict = !integrityInRequest || integrityInRequest === integrityInManifest;
-            // Do not add integrity if the original request is no-cors
-            // See https://github.com/GoogleChrome/workbox/issues/3096
             response = await handler.fetch(new Request(request, {
                 integrity: request.mode !== "no-cors" ? integrityInRequest || integrityInManifest : undefined
             }));
-            // It's only "safe" to repair the cache if we're using SRI to guarantee
-            // that the response matches the precache manifest's expectations,
-            // and there's either a) no integrity property in the incoming request
-            // or b) there is an integrity, and it matches the precache manifest.
-            // See https://github.com/GoogleChrome/workbox/issues/2858
-            // Also if the original request users no-cors we don't use integrity.
-            // See https://github.com/GoogleChrome/workbox/issues/3096
             if (integrityInManifest && noIntegrityConflict && request.mode !== "no-cors") {
                 this._useDefaultCacheabilityPluginIfNeeded();
                 const wasCached = await handler.cachePut(request, response.clone());
@@ -90,8 +83,6 @@ import { Route, registerRoute } from '@serwist/routing';
                 }
             }
         } else {
-            // This shouldn't normally happen, but there are edge cases:
-            // https://github.com/GoogleChrome/workbox/issues/1441
             throw new SerwistError("missing-precache-entry", {
                 cacheName: this.cacheName,
                 url: request.url
@@ -99,8 +90,6 @@ import { Route, registerRoute } from '@serwist/routing';
         }
         if (process.env.NODE_ENV !== "production") {
             const cacheKey = params.cacheKey || await handler.getCacheKey(request, "read");
-            // Serwist is going to handle the route.
-            // print the routing details to the console.
             logger.groupCollapsed(`Precaching is responding to: ${getFriendlyURL(request.url)}`);
             logger.log(`Serving the precached url: ${getFriendlyURL(cacheKey instanceof Request ? cacheKey.url : cacheKey)}`);
             logger.groupCollapsed("View request details here.");
@@ -116,12 +105,8 @@ import { Route, registerRoute } from '@serwist/routing';
     async _handleInstall(request, handler) {
         this._useDefaultCacheabilityPluginIfNeeded();
         const response = await handler.fetch(request);
-        // Make sure we defer cachePut() until after we know the response
-        // should be cached; see https://github.com/GoogleChrome/workbox/issues/2737
         const wasCached = await handler.cachePut(request, response.clone());
         if (!wasCached) {
-            // Throwing here will lead to the `install` handler failing, which
-            // we want to do if *any* of the responses aren't safe to cache.
             throw new SerwistError("bad-precaching-response", {
                 url: request.url,
                 status: response.status
@@ -129,41 +114,13 @@ import { Route, registerRoute } from '@serwist/routing';
         }
         return response;
     }
-    /**
-   * This method is complex, as there a number of things to account for:
-   *
-   * The `plugins` array can be set at construction, and/or it might be added to
-   * to at any time before the strategy is used.
-   *
-   * At the time the strategy is used (i.e. during an `install` event), there
-   * needs to be at least one plugin that implements `cacheWillUpdate` in the
-   * array, other than `copyRedirectedCacheableResponsesPlugin`.
-   *
-   * - If this method is called and there are no suitable `cacheWillUpdate`
-   * plugins, we need to add `defaultPrecacheCacheabilityPlugin`.
-   *
-   * - If this method is called and there is exactly one `cacheWillUpdate`, then
-   * we don't have to do anything (this might be a previously added
-   * `defaultPrecacheCacheabilityPlugin`, or it might be a custom plugin).
-   *
-   * - If this method is called and there is more than one `cacheWillUpdate`,
-   * then we need to check if one is `defaultPrecacheCacheabilityPlugin`. If so,
-   * we need to remove it. (This situation is unlikely, but it could happen if
-   * the strategy is used multiple times, the first without a `cacheWillUpdate`,
-   * and then later on after manually adding a custom `cacheWillUpdate`.)
-   *
-   * See https://github.com/GoogleChrome/workbox/issues/2737 for more context.
-   *
-   * @private
-   */ _useDefaultCacheabilityPluginIfNeeded() {
+    _useDefaultCacheabilityPluginIfNeeded() {
         let defaultPluginIndex = null;
         let cacheWillUpdatePluginCount = 0;
         for (const [index, plugin] of this.plugins.entries()){
-            // Ignore the copy redirected plugin when determining what to do.
             if (plugin === PrecacheStrategy.copyRedirectedCacheableResponsesPlugin) {
                 continue;
             }
-            // Save the default plugin's index, in case it needs to be removed.
             if (plugin === PrecacheStrategy.defaultPrecacheCacheabilityPlugin) {
                 defaultPluginIndex = index;
             }
@@ -174,54 +131,28 @@ import { Route, registerRoute } from '@serwist/routing';
         if (cacheWillUpdatePluginCount === 0) {
             this.plugins.push(PrecacheStrategy.defaultPrecacheCacheabilityPlugin);
         } else if (cacheWillUpdatePluginCount > 1 && defaultPluginIndex !== null) {
-            // Only remove the default plugin; multiple custom plugins are allowed.
             this.plugins.splice(defaultPluginIndex, 1);
         }
-    // Nothing needs to be done if cacheWillUpdatePluginCount is 1
     }
 }
 
-/*
-  Copyright 2020 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.
-*/ /**
- * A plugin, designed to be used with PrecacheController, to translate URLs into
- * the corresponding cache key, based on the current revision info.
- *
- * @private
- */ class PrecacheCacheKeyPlugin {
+class PrecacheCacheKeyPlugin {
     _precacheController;
     constructor({ precacheController }){
         this._precacheController = precacheController;
     }
     cacheKeyWillBeUsed = async ({ request, params })=>{
-        // Params is type any, can't change right now.
-        /* eslint-disable */ const cacheKey = params?.cacheKey || this._precacheController.getCacheKeyForURL(request.url);
-        /* eslint-enable */ return cacheKey ? new Request(cacheKey, {
+        const cacheKey = params?.cacheKey || this._precacheController.getCacheKeyForURL(request.url);
+        return cacheKey ? new Request(cacheKey, {
             headers: request.headers
         }) : request;
     };
 }
 
-/*
-  Copyright 2020 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.
-*/ /**
- * A plugin, designed to be used with PrecacheController, to determine the
- * of assets that were updated (or not updated) during the install event.
- *
- * @private
- */ class PrecacheInstallReportPlugin {
+class PrecacheInstallReportPlugin {
     updatedURLs = [];
     notUpdatedURLs = [];
     handlerWillStart = async ({ request, state })=>{
-        // TODO: `state` should never be undefined...
         if (state) {
             state.originalRequest = request;
         }
@@ -229,7 +160,6 @@ import { Route, registerRoute } from '@serwist/routing';
     cachedResponseWillBeUsed = async ({ event, state, cachedResponse })=>{
         if (event.type === "install") {
             if (state?.originalRequest && state.originalRequest instanceof Request) {
-                // TODO: `state` should never be undefined...
                 const url = state.originalRequest.url;
                 if (cachedResponse) {
                     this.notUpdatedURLs.push(url);
@@ -242,23 +172,13 @@ import { Route, registerRoute } from '@serwist/routing';
     };
 }
 
-// Name of the search parameter used to store revision info.
 const REVISION_SEARCH_PARAM = "__WB_REVISION__";
-/**
- * Converts a manifest entry into a versioned URL suitable for precaching.
- *
- * @param entry
- * @returns A URL with versioning info.
- *
- * @private
- */ function createCacheKey(entry) {
+function createCacheKey(entry) {
     if (!entry) {
         throw new SerwistError("add-to-cache-list-unexpected-type", {
             entry
         });
     }
-    // If a precache manifest entry is a string, it's assumed to be a versioned
-    // URL, like '/app.abcd1234.js'. Return as-is.
     if (typeof entry === "string") {
         const urlObject = new URL(entry, location.href);
         return {
@@ -272,8 +192,6 @@ const REVISION_SEARCH_PARAM = "__WB_REVISION__";
             entry
         });
     }
-    // If there's just a URL and no revision, then it's also assumed to be a
-    // versioned URL.
     if (!revision) {
         const urlObject = new URL(url, location.href);
         return {
@@ -281,8 +199,6 @@ const REVISION_SEARCH_PARAM = "__WB_REVISION__";
             url: urlObject.href
         };
     }
-    // Otherwise, construct a properly versioned URL using the custom Serwist
-    // search parameter along with the revision info.
     const cacheKeyURL = new URL(url, location.href);
     const originalURL = new URL(url, location.href);
     cacheKeyURL.searchParams.set(REVISION_SEARCH_PARAM, revision);
@@ -292,22 +208,14 @@ const REVISION_SEARCH_PARAM = "__WB_REVISION__";
     };
 }
 
-/**
- * @param groupTitle
- * @param deletedURLs
- *
- * @private
- */ const logGroup = (groupTitle, deletedURLs)=>{
+const logGroup = (groupTitle, deletedURLs)=>{
     logger.groupCollapsed(groupTitle);
     for (const url of deletedURLs){
         logger.log(url);
     }
     logger.groupEnd();
 };
-/**
- * @param deletedURLs
- * @private
- */ function printCleanupDetails(deletedURLs) {
+function printCleanupDetails(deletedURLs) {
     const deletionCount = deletedURLs.length;
     if (deletionCount > 0) {
         logger.groupCollapsed(`During precaching cleanup, ${deletionCount} cached request${deletionCount === 1 ? " was" : "s were"} deleted.`);
@@ -316,12 +224,7 @@ const REVISION_SEARCH_PARAM = "__WB_REVISION__";
     }
 }
 
-/**
- * @param groupTitle
- * @param urls
- *
- * @private
- */ function _nestedGroup(groupTitle, urls) {
+function _nestedGroup(groupTitle, urls) {
     if (urls.length === 0) {
         return;
     }
@@ -331,11 +234,7 @@ const REVISION_SEARCH_PARAM = "__WB_REVISION__";
     }
     logger.groupEnd();
 }
-/**
- * @param urlsToPrecache
- * @param  urlsAlreadyPrecached
- * @private
- */ function printInstallDetails(urlsToPrecache, urlsAlreadyPrecached) {
+function printInstallDetails(urlsToPrecache, urlsAlreadyPrecached) {
     const precachedCount = urlsToPrecache.length;
     const alreadyPrecachedCount = urlsAlreadyPrecached.length;
     if (precachedCount || alreadyPrecachedCount) {
@@ -350,19 +249,14 @@ const REVISION_SEARCH_PARAM = "__WB_REVISION__";
     }
 }
 
-/**
- * Performs efficient precaching of assets.
- */ class PrecacheController {
+class PrecacheController {
     _installAndActiveListenersAdded;
+    _concurrentPrecaching;
     _strategy;
     _urlsToCacheKeys = new Map();
     _urlsToCacheModes = new Map();
     _cacheKeysToIntegrities = new Map();
-    /**
-   * Create a new PrecacheController.
-   *
-   * @param options
-   */ constructor({ cacheName, plugins = [], fallbackToNetwork = true } = {}){
+    constructor({ cacheName, plugins = [], fallbackToNetwork = true, concurrentPrecaching } = {}){
         this._strategy = new PrecacheStrategy({
             cacheName: privateCacheNames.getPrecacheName(cacheName),
             plugins: [
@@ -373,25 +267,14 @@ const REVISION_SEARCH_PARAM = "__WB_REVISION__";
             ],
             fallbackToNetwork
         });
-        // Bind the install and activate methods to the instance.
+        this._concurrentPrecaching = concurrentPrecaching;
         this.install = this.install.bind(this);
         this.activate = this.activate.bind(this);
     }
-    /**
-   * The strategy created by this controller and
-   * used to cache assets and respond to fetch events.
-   */ get strategy() {
+    get strategy() {
         return this._strategy;
     }
-    /**
-   * Adds items to the precache list, removing any duplicates and
-   * stores the files in the precache cache when the service
-   * worker installs.
-   *
-   * This method can be called multiple times.
-   *
-   * @param entries Array of entries to precache.
-   */ precache(entries) {
+    precache(entries) {
         this.addToCacheList(entries);
         if (!this._installAndActiveListenersAdded) {
             self.addEventListener("install", this.install);
@@ -399,12 +282,7 @@ const REVISION_SEARCH_PARAM = "__WB_REVISION__";
             this._installAndActiveListenersAdded = true;
         }
     }
-    /**
-   * This method will add items to the precache list, removing duplicates
-   * and ensuring the information is valid.
-   *
-   * @param entries Array of entries to precache.
-   */ addToCacheList(entries) {
+    addToCacheList(entries) {
         if (process.env.NODE_ENV !== "production") {
             assert.isArray(entries, {
                 moduleName: "@serwist/precaching",
@@ -415,7 +293,6 @@ const REVISION_SEARCH_PARAM = "__WB_REVISION__";
         }
         const urlsToWarnAbout = [];
         for (const entry of entries){
-            // See https://github.com/GoogleChrome/workbox/issues/2259
             if (typeof entry === "string") {
                 urlsToWarnAbout.push(entry);
             } else if (entry && entry.revision === undefined) {
@@ -442,8 +319,6 @@ const REVISION_SEARCH_PARAM = "__WB_REVISION__";
             if (urlsToWarnAbout.length > 0) {
                 const warningMessage = `Serwist is precaching URLs without revision info: ${urlsToWarnAbout.join(", ")}\nThis is generally NOT safe. Learn more at https://bit.ly/wb-precache`;
                 if (process.env.NODE_ENV === "production") {
-                    // Use console directly to display this warning without bloating
-                    // bundle sizes by pulling in all of the logger codebase in prod.
                     console.warn(warningMessage);
                 } else {
                     logger.warn(warningMessage);
@@ -451,24 +326,18 @@ const REVISION_SEARCH_PARAM = "__WB_REVISION__";
             }
         }
     }
-    /**
-   * Precaches new and updated assets. Call this method from the service worker
-   * install event.
-   *
-   * Note: this method calls `event.waitUntil()` for you, so you do not need
-   * to call it yourself in your event handlers.
-   *
-   * @param event
-   * @returns
-   */ install(event) {
-        // waitUntil returns Promise<any>
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    install(event) {
         return waitUntil(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);
                 const request = new Request(url, {
@@ -483,7 +352,7 @@ const REVISION_SEARCH_PARAM = "__WB_REVISION__";
                     request,
                     event
                 }));
-            }
+            });
             const { updatedURLs, notUpdatedURLs } = installReportPlugin;
             if (process.env.NODE_ENV !== "production") {
                 printInstallDetails(updatedURLs, notUpdatedURLs);
@@ -494,92 +363,42 @@ const REVISION_SEARCH_PARAM = "__WB_REVISION__";
             };
         });
     }
-    /**
-   * Deletes assets that are no longer present in the current precache manifest.
-   * Call this method from the service worker activate event.
-   *
-   * Note: this method calls `event.waitUntil()` for you, so you do not need
-   * to call it yourself in your event handlers.
-   *
-   * @param event
-   * @returns
-   */ activate(event) {
-        // waitUntil returns Promise<any>
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    activate(event) {
         return waitUntil(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 = [];
             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
             };
         });
     }
-    /**
-   * Returns a mapping of a precached URL to the corresponding cache key, taking
-   * into account the revision information for the URL.
-   *
-   * @returns A URL to cache key mapping.
-   */ getURLsToCacheKeys() {
+    getURLsToCacheKeys() {
         return this._urlsToCacheKeys;
     }
-    /**
-   * Returns a list of all the URLs that have been precached by the current
-   * service worker.
-   *
-   * @returns The precached URLs.
-   */ getCachedURLs() {
+    getCachedURLs() {
         return [
             ...this._urlsToCacheKeys.keys()
         ];
     }
-    /**
-   * Returns the cache key used for storing a given URL. If that URL is
-   * unversioned, like `/index.html', then the cache key will be the original
-   * URL with a search parameter appended to it.
-   *
-   * @param url A URL whose cache key you want to look up.
-   * @returns The versioned URL that corresponds to a cache key
-   * for the original URL, or undefined if that URL isn't precached.
-   */ getCacheKeyForURL(url) {
+    getCacheKeyForURL(url) {
         const urlObject = new URL(url, location.href);
         return this._urlsToCacheKeys.get(urlObject.href);
     }
-    /**
-   * @param url A cache key whose SRI you want to look up.
-   * @returns The subresource integrity associated with the cache key,
-   * or undefined if it's not set.
-   */ getIntegrityForCacheKey(cacheKey) {
+    getIntegrityForCacheKey(cacheKey) {
         return this._cacheKeysToIntegrities.get(cacheKey);
     }
-    /**
-   * This acts as a drop-in replacement for
-   * [`cache.match()`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/match)
-   * with the following differences:
-   *
-   * - It knows what the name of the precache is, and only checks in that cache.
-   * - It allows you to pass in an "original" URL without versioning parameters,
-   * and it will automatically look up the correct cache key for the currently
-   * active revision of that URL.
-   *
-   * E.g., `matchPrecache('index.html')` will find the correct precached
-   * response for the currently active service worker, even if the actual cache
-   * key is `'/index.html?__WB_REVISION__=1234abcd'`.
-   *
-   * @param request The key (without revisioning parameters)
-   * to look up in the precache.
-   * @returns
-   */ async matchPrecache(request) {
+    async matchPrecache(request) {
         const url = request instanceof Request ? request.url : request;
         const cacheKey = this.getCacheKeyForURL(url);
         if (cacheKey) {
@@ -588,13 +407,7 @@ const REVISION_SEARCH_PARAM = "__WB_REVISION__";
         }
         return undefined;
     }
-    /**
-   * Returns a function that looks up `url` in the precache (taking into
-   * account revision information), and returns the corresponding `Response`.
-   *
-   * @param url The precached URL which will be used to lookup the response.
-   * @return
-   */ createHandlerBoundToURL(url) {
+    createHandlerBoundToURL(url) {
         const cacheKey = this.getCacheKeyForURL(url);
         if (!cacheKey) {
             throw new SerwistError("non-precached-url", {
@@ -613,62 +426,39 @@ const REVISION_SEARCH_PARAM = "__WB_REVISION__";
 }
 
 let precacheController;
-/**
- * @returns
- * @private
- */ const getOrCreatePrecacheController = ()=>{
+const getOrCreatePrecacheController = ()=>{
     if (!precacheController) {
         precacheController = new PrecacheController();
     }
     return precacheController;
 };
 
-/**
- * `PrecacheFallbackPlugin` allows you to specify an "offline fallback"
- * response 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
- * into account automatically.
- *
- * Unless you explicitly pass in a `PrecacheController` instance to the
- * constructor, the default instance will be used. Generally speaking, most
- * developers will end up using the default.
- */ class PrecacheFallbackPlugin {
-    _fallbackURL;
+class PrecacheFallbackPlugin {
+    _fallbackUrls;
     _precacheController;
-    /**
-   * Constructs a new PrecacheFallbackPlugin with the associated fallbackURL.
-   *
-   * @param config
-   */ constructor({ fallbackURL, precacheController }){
-        this._fallbackURL = fallbackURL;
+    constructor({ fallbackUrls, precacheController }){
+        this._fallbackUrls = fallbackUrls;
         this._precacheController = precacheController || getOrCreatePrecacheController();
     }
-    /**
-   * @returns The precache response for the fallback URL.
-   * @private
-   */ 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;
+    }
 }
 
-/*
-  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.
-*/ /**
- * Removes any URL search parameters that should be ignored.
- *
- * @param urlObject The original URL.
- * @param ignoreURLParametersMatching RegExps to test against
- * each search parameter name. Matches mean that the search parameter should be
- * ignored.
- * @returns The URL with any ignored search parameters removed.
- * @private
- */ function removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching = []) {
-    // Convert the iterable into an array at the start of the loop to make sure
-    // deletion doesn't mess up iteration.
+function removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching = []) {
     for (const paramName of [
         ...urlObject.searchParams.keys()
     ]){
@@ -679,15 +469,7 @@ let precacheController;
     return urlObject;
 }
 
-/**
- * Generator function that yields possible variations on the original URL to
- * check, one at a time.
- *
- * @param url
- * @param options
- *
- * @private
- */ function* generateURLVariations(url, { ignoreURLParametersMatching = [
+function* generateURLVariations(url, { ignoreURLParametersMatching = [
     /^utm_/,
     /^fbclid$/
 ], directoryIndex = "index.html", cleanURLs = true, urlManipulation } = {}) {
@@ -716,18 +498,8 @@ let precacheController;
     }
 }
 
-/**
- * A subclass of `@serwist/routing.Route` that takes a
- * `@serwist/precaching.PrecacheController`
- * instance and uses it to match incoming requests and handle fetching
- * responses from the precache.
- */ class PrecacheRoute extends Route {
-    /**
-   * @param precacheController A `PrecacheController`
-   * instance used to both match requests and respond to fetch events.
-   * @param options Options to control how requests are matched
-   * against the list of precached URLs.
-   */ constructor(precacheController, options){
+class PrecacheRoute extends Route {
+    constructor(precacheController, options){
         const match = ({ request })=>{
             const urlsToCacheKeys = precacheController.getURLsToCacheKeys();
             for (const possibleURL of generateURLVariations(request.url, options)){
@@ -749,56 +521,19 @@ let precacheController;
     }
 }
 
-/**
- * Adds plugins to the precaching strategy.
- *
- * @param plugins
- */ function addPlugins(plugins) {
+function addPlugins(plugins) {
     const precacheController = getOrCreatePrecacheController();
     precacheController.strategy.plugins.push(...plugins);
 }
 
-/**
- * Add a `fetch` listener to the service worker that will
- * respond to
- * [network requests](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests)
- * with precached assets.
- *
- * Requests for assets that aren't precached, the `FetchEvent` will not be
- * responded to, allowing the event to fall through to other `fetch` event
- * listeners.
- *
- * @param options See the `@serwist/precaching.PrecacheRoute` options.
- */ function addRoute(options) {
+const addRoute = (options)=>{
     const precacheController = getOrCreatePrecacheController();
     const precacheRoute = new PrecacheRoute(precacheController, options);
     registerRoute(precacheRoute);
-}
-
-/*
-  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.
-*/ // Give TypeScript the correct global.
 const SUBSTRING_TO_FIND = "-precache-";
-/**
- * Cleans up incompatible precaches that were created by older versions of
- * Serwist, by a service worker registered under the current scope.
- *
- * This is meant to be called as part of the `activate` event.
- *
- * This should be safe to use as long as you don't include `substringToFind`
- * (defaulting to `-precache-`) in your non-precache cache names.
- *
- * @param currentPrecacheName The cache name currently in use for
- * precaching. This cache won't be deleted.
- * @param substringToFind Cache names which include this
- * substring will be deleted (excluding `currentPrecacheName`).
- * @returns A list of all the cache names that were deleted.
- * @private
- */ const deleteOutdatedCaches = async (currentPrecacheName, substringToFind = SUBSTRING_TO_FIND)=>{
+const deleteOutdatedCaches = async (currentPrecacheName, substringToFind = SUBSTRING_TO_FIND)=>{
     const cacheNames = await self.caches.keys();
     const cacheNamesToDelete = cacheNames.filter((cacheName)=>{
         return cacheName.includes(substringToFind) && cacheName.includes(self.registration.scope) && cacheName !== currentPrecacheName;
@@ -807,111 +542,42 @@ const SUBSTRING_TO_FIND = "-precache-";
     return cacheNamesToDelete;
 };
 
-/**
- * Adds an `activate` event listener which will clean up incompatible
- * precaches that were created by older versions of Serwist.
- */ function cleanupOutdatedCaches() {
-    // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705
+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);
                 }
             }
         }));
     });
-}
+};
 
-/**
- * Helper function that calls `PrecacheController#createHandlerBoundToURL`
- * on the default `PrecacheController` instance.
- *
- * If you are creating your own `PrecacheController`, then call the
- * `PrecacheController#createHandlerBoundToURL` on that instance,
- * instead of using this function.
- *
- * @param url The precached URL which will be used to lookup the
- * `Response`.
- * @param fallbackToNetwork Whether to attempt to get the
- * response from the network if there's a precache miss.
- * @return
- */ function createHandlerBoundToURL(url) {
+const createHandlerBoundToURL = (url)=>{
     const precacheController = getOrCreatePrecacheController();
     return precacheController.createHandlerBoundToURL(url);
-}
+};
 
-/**
- * Takes in a URL, and returns the corresponding URL that could be used to
- * lookup the entry in the precache.
- *
- * If a relative URL is provided, the location of the service worker file will
- * be used as the base.
- *
- * For precached entries without revision information, the cache key will be the
- * same as the original URL.
- *
- * For precached entries with revision information, the cache key will be the
- * original URL with the addition of a query parameter used for keeping track of
- * the revision info.
- *
- * @param url The URL whose cache key to look up.
- * @returns The cache key that corresponds to that URL.
- */ function getCacheKeyForURL(url) {
+function getCacheKeyForURL(url) {
     const precacheController = getOrCreatePrecacheController();
     return precacheController.getCacheKeyForURL(url);
 }
 
-/**
- * Helper function that calls `PrecacheController#matchPrecache`
- * on the default `PrecacheController` instance.
- *
- * If you are creating your own `PrecacheController`, then call
- * `PrecacheController#matchPrecache` on that instance,
- * instead of using this function.
- *
- * @param request The key (without revisioning parameters)
- * to look up in the precache.
- * @returns
- */ function matchPrecache(request) {
+function matchPrecache(request) {
     const precacheController = getOrCreatePrecacheController();
     return precacheController.matchPrecache(request);
 }
 
-/**
- * Adds items to the precache list, removing any duplicates and
- * stores the files in the precache cache when the service
- * worker installs.
- *
- * This method can be called multiple times.
- *
- * Please note: This method **will not** serve any of the cached files for you.
- * It only precaches files. To respond to a network request you call
- * `@serwist/precaching.addRoute`.
- *
- * If you have a single array of files to precache, you can just call
- * `@serwist/precaching.precacheAndRoute`.
- *
- * @param entries Array of entries to precache.
- */ function precache(entries) {
+const precache = (entries)=>{
     const precacheController = getOrCreatePrecacheController();
     precacheController.precache(entries);
-}
+};
 
-/**
- * This method will add entries to the precache list and add a route to
- * respond to fetch events.
- *
- * This is a convenience method that will call
- * `@serwist/precaching.precache` and
- * `@serwist/precaching.addRoute` in a single call.
- *
- * @param entries Array of entries to precache.
- * @param options See the `@serwist/precaching.PrecacheRoute` options.
- */ 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 };