serwist 10.0.0-preview.1 → 10.0.0-preview.2

package/dist/index.js

@@ -1,1094 +1,1198 @@
-import { S as SerwistError, c as canConstructResponseFromBodyStream, f as finalAssertExports, D as Deferred, l as logger, g as getFriendlyURL, t as timeout, a as cacheMatchIgnoreParams, e as executeQuotaErrorCallbacks, b as cacheNames$1, d as clientsClaim, w as waitUntil, r as resultingClientExists, q as quotaErrorCallbacks } from './chunks/resultingClientExists.js';
+import { f as finalAssertExports, l as logger, S as SerwistError, g as getFriendlyURL, c as canConstructResponseFromBodyStream, D as Deferred, t as timeout, a as cacheMatchIgnoreParams, e as executeQuotaErrorCallbacks, b as cacheNames$1, d as clientsClaim, w as waitUntil, q as quotaErrorCallbacks, r as resultingClientExists } from './chunks/waitUntil.js';
 import { parallel } from '@serwist/utils';
 import { openDB, deleteDB } from 'idb';
 
-const copyResponse = async (response, modifier)=>{
-    let origin = null;
-    if (response.url) {
-        const responseURL = new URL(response.url);
-        origin = responseURL.origin;
+const normalizeHandler = (handler)=>{
+    if (handler && typeof handler === "object") {
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.hasMethod(handler, "handle", {
+                moduleName: "serwist",
+                className: "Route",
+                funcName: "constructor",
+                paramName: "handler"
+            });
+        }
+        return handler;
     }
-    if (origin !== self.location.origin) {
-        throw new SerwistError("cross-origin-copy-response", {
-            origin
+    if (process.env.NODE_ENV !== "production") {
+        finalAssertExports.isType(handler, "function", {
+            moduleName: "serwist",
+            className: "Route",
+            funcName: "constructor",
+            paramName: "handler"
         });
     }
-    const clonedResponse = response.clone();
-    const responseInit = {
-        headers: new Headers(clonedResponse.headers),
-        status: clonedResponse.status,
-        statusText: clonedResponse.statusText
+    return {
+        handle: handler
     };
-    const modifiedResponseInit = modifier ? modifier(responseInit) : responseInit;
-    const body = canConstructResponseFromBodyStream() ? clonedResponse.body : await clonedResponse.blob();
-    return new Response(body, modifiedResponseInit);
 };
 
-function toRequest(input) {
-    return typeof input === "string" ? new Request(input) : input;
+const defaultMethod = "GET";
+const validMethods = [
+    "DELETE",
+    "GET",
+    "HEAD",
+    "PATCH",
+    "POST",
+    "PUT"
+];
+
+class Route {
+    handler;
+    match;
+    method;
+    catchHandler;
+    constructor(match, handler, method = defaultMethod){
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isType(match, "function", {
+                moduleName: "serwist",
+                className: "Route",
+                funcName: "constructor",
+                paramName: "match"
+            });
+            if (method) {
+                finalAssertExports.isOneOf(method, validMethods, {
+                    paramName: "method"
+                });
+            }
+        }
+        this.handler = normalizeHandler(handler);
+        this.match = match;
+        this.method = method;
+    }
+    setCatchHandler(handler) {
+        this.catchHandler = normalizeHandler(handler);
+    }
 }
-class StrategyHandler {
-    event;
-    request;
-    url;
-    params;
-    _cacheKeys = {};
-    _strategy;
-    _handlerDeferred;
-    _extendLifetimePromises;
-    _plugins;
-    _pluginStateMap;
-    constructor(strategy, options){
+
+class NavigationRoute extends Route {
+    _allowlist;
+    _denylist;
+    constructor(handler, { allowlist = [
+        /./
+    ], denylist = [] } = {}){
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isInstance(options.event, ExtendableEvent, {
+            finalAssertExports.isArrayOfClass(allowlist, RegExp, {
                 moduleName: "serwist",
-                className: "StrategyHandler",
+                className: "NavigationRoute",
                 funcName: "constructor",
-                paramName: "options.event"
+                paramName: "options.allowlist"
             });
-            finalAssertExports.isInstance(options.request, Request, {
+            finalAssertExports.isArrayOfClass(denylist, RegExp, {
                 moduleName: "serwist",
-                className: "StrategyHandler",
+                className: "NavigationRoute",
                 funcName: "constructor",
-                paramName: "options.request"
+                paramName: "options.denylist"
             });
         }
-        this.event = options.event;
-        this.request = options.request;
-        if (options.url) {
-            this.url = options.url;
-            this.params = options.params;
-        }
-        this._strategy = strategy;
-        this._handlerDeferred = new Deferred();
-        this._extendLifetimePromises = [];
-        this._plugins = [
-            ...strategy.plugins
-        ];
-        this._pluginStateMap = new Map();
-        for (const plugin of this._plugins){
-            this._pluginStateMap.set(plugin, {});
-        }
-        this.event.waitUntil(this._handlerDeferred.promise);
+        super((options)=>this._match(options), handler);
+        this._allowlist = allowlist;
+        this._denylist = denylist;
     }
-    async fetch(input) {
-        const { event } = this;
-        let request = toRequest(input);
-        const preloadResponse = await this.getPreloadResponse();
-        if (preloadResponse) {
-            return preloadResponse;
+    _match({ url, request }) {
+        if (request && request.mode !== "navigate") {
+            return false;
         }
-        const originalRequest = this.hasCallback("fetchDidFail") ? request.clone() : null;
-        try {
-            for (const cb of this.iterateCallbacks("requestWillFetch")){
-                request = await cb({
-                    request: request.clone(),
-                    event
-                });
-            }
-        } catch (err) {
-            if (err instanceof Error) {
-                throw new SerwistError("plugin-error-request-will-fetch", {
-                    thrownErrorMessage: err.message
-                });
+        const pathnameAndSearch = url.pathname + url.search;
+        for (const regExp of this._denylist){
+            if (regExp.test(pathnameAndSearch)) {
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log(`The navigation route ${pathnameAndSearch} is not being used, since the URL matches this denylist pattern: ${regExp.toString()}`);
+                }
+                return false;
             }
         }
-        const pluginFilteredRequest = request.clone();
-        try {
-            let fetchResponse;
-            fetchResponse = await fetch(request, request.mode === "navigate" ? undefined : this._strategy.fetchOptions);
-            if (process.env.NODE_ENV !== "production") {
-                logger.debug(`Network request for '${getFriendlyURL(request.url)}' returned a response with status '${fetchResponse.status}'.`);
-            }
-            for (const callback of this.iterateCallbacks("fetchDidSucceed")){
-                fetchResponse = await callback({
-                    event,
-                    request: pluginFilteredRequest,
-                    response: fetchResponse
-                });
-            }
-            return fetchResponse;
-        } catch (error) {
+        if (this._allowlist.some((regExp)=>regExp.test(pathnameAndSearch))) {
             if (process.env.NODE_ENV !== "production") {
-                logger.log(`Network request for '${getFriendlyURL(request.url)}' threw an error.`, error);
-            }
-            if (originalRequest) {
-                await this.runCallbacks("fetchDidFail", {
-                    error: error,
-                    event,
-                    originalRequest: originalRequest.clone(),
-                    request: pluginFilteredRequest.clone()
-                });
+                logger.debug(`The navigation route ${pathnameAndSearch} is being used.`);
             }
-            throw error;
+            return true;
         }
-    }
-    async fetchAndCachePut(input) {
-        const response = await this.fetch(input);
-        const responseClone = response.clone();
-        void this.waitUntil(this.cachePut(input, responseClone));
-        return response;
-    }
-    async cacheMatch(key) {
-        const request = toRequest(key);
-        let cachedResponse;
-        const { cacheName, matchOptions } = this._strategy;
-        const effectiveRequest = await this.getCacheKey(request, "read");
-        const multiMatchOptions = {
-            ...matchOptions,
-            ...{
-                cacheName
-            }
-        };
-        cachedResponse = await caches.match(effectiveRequest, multiMatchOptions);
         if (process.env.NODE_ENV !== "production") {
-            if (cachedResponse) {
-                logger.debug(`Found a cached response in '${cacheName}'.`);
-            } else {
-                logger.debug(`No cached response found in '${cacheName}'.`);
-            }
-        }
-        for (const callback of this.iterateCallbacks("cachedResponseWillBeUsed")){
-            cachedResponse = await callback({
-                cacheName,
-                matchOptions,
-                cachedResponse,
-                request: effectiveRequest,
-                event: this.event
-            }) || undefined;
+            logger.log(`The navigation route ${pathnameAndSearch} is not being used, since the URL being navigated to doesn't match the allowlist.`);
         }
-        return cachedResponse;
+        return false;
     }
-    async cachePut(key, response) {
-        const request = toRequest(key);
-        await timeout(0);
-        const effectiveRequest = await this.getCacheKey(request, "write");
+}
+
+class RegExpRoute extends Route {
+    constructor(regExp, handler, method){
         if (process.env.NODE_ENV !== "production") {
-            if (effectiveRequest.method && effectiveRequest.method !== "GET") {
-                throw new SerwistError("attempt-to-cache-non-get-request", {
-                    url: getFriendlyURL(effectiveRequest.url),
-                    method: effectiveRequest.method
-                });
-            }
-        }
-        if (!response) {
-            if (process.env.NODE_ENV !== "production") {
-                logger.error(`Cannot cache non-existent response for '${getFriendlyURL(effectiveRequest.url)}'.`);
-            }
-            throw new SerwistError("cache-put-with-no-response", {
-                url: getFriendlyURL(effectiveRequest.url)
+            finalAssertExports.isInstance(regExp, RegExp, {
+                moduleName: "serwist",
+                className: "RegExpRoute",
+                funcName: "constructor",
+                paramName: "pattern"
             });
         }
-        const responseToCache = await this._ensureResponseSafeToCache(response);
-        if (!responseToCache) {
-            if (process.env.NODE_ENV !== "production") {
-                logger.debug(`Response '${getFriendlyURL(effectiveRequest.url)}' will not be cached.`, responseToCache);
+        const match = ({ url })=>{
+            const result = regExp.exec(url.href);
+            if (!result) {
+                return;
             }
-            return false;
-        }
-        const { cacheName, matchOptions } = this._strategy;
-        const cache = await self.caches.open(cacheName);
-        if (process.env.NODE_ENV !== "production") {
-            const vary = response.headers.get("Vary");
-            if (vary && matchOptions?.ignoreVary !== true) {
-                logger.debug(`The response for ${getFriendlyURL(effectiveRequest.url)} has a 'Vary: ${vary}' header. Consider setting the {ignoreVary: true} option on your strategy to ensure cache matching and deletion works as expected.`);
-            }
-        }
-        const hasCacheUpdateCallback = this.hasCallback("cacheDidUpdate");
-        const oldResponse = hasCacheUpdateCallback ? await cacheMatchIgnoreParams(cache, effectiveRequest.clone(), [
-            "__WB_REVISION__"
-        ], matchOptions) : null;
-        if (process.env.NODE_ENV !== "production") {
-            logger.debug(`Updating the '${cacheName}' cache with a new Response for ${getFriendlyURL(effectiveRequest.url)}.`);
-        }
-        try {
-            await cache.put(effectiveRequest, hasCacheUpdateCallback ? responseToCache.clone() : responseToCache);
-        } catch (error) {
-            if (error instanceof Error) {
-                if (error.name === "QuotaExceededError") {
-                    await executeQuotaErrorCallbacks();
+            if (url.origin !== location.origin && result.index !== 0) {
+                if (process.env.NODE_ENV !== "production") {
+                    logger.debug(`The regular expression '${regExp.toString()}' only partially matched against the cross-origin URL '${url.toString()}'. RegExpRoute's will only handle cross-origin requests if they match the entire URL.`);
                 }
-                throw error;
+                return;
             }
-        }
-        for (const callback of this.iterateCallbacks("cacheDidUpdate")){
-            await callback({
-                cacheName,
-                oldResponse,
-                newResponse: responseToCache.clone(),
-                request: effectiveRequest,
-                event: this.event
-            });
-        }
-        return true;
+            return result.slice(1);
+        };
+        super(match, handler, method);
     }
-    async getCacheKey(request, mode) {
-        const key = `${request.url} | ${mode}`;
-        if (!this._cacheKeys[key]) {
-            let effectiveRequest = request;
-            for (const callback of this.iterateCallbacks("cacheKeyWillBeUsed")){
-                effectiveRequest = toRequest(await callback({
-                    mode,
-                    request: effectiveRequest,
-                    event: this.event,
-                    params: this.params
-                }));
-            }
-            this._cacheKeys[key] = effectiveRequest;
-        }
-        return this._cacheKeys[key];
+}
+
+const REVISION_SEARCH_PARAM = "__WB_REVISION__";
+const createCacheKey = (entry)=>{
+    if (!entry) {
+        throw new SerwistError("add-to-cache-list-unexpected-type", {
+            entry
+        });
     }
-    hasCallback(name) {
-        for (const plugin of this._strategy.plugins){
-            if (name in plugin) {
-                return true;
-            }
-        }
-        return false;
+    if (typeof entry === "string") {
+        const urlObject = new URL(entry, location.href);
+        return {
+            cacheKey: urlObject.href,
+            url: urlObject.href
+        };
     }
-    async runCallbacks(name, param) {
-        for (const callback of this.iterateCallbacks(name)){
-            await callback(param);
-        }
+    const { revision, url } = entry;
+    if (!url) {
+        throw new SerwistError("add-to-cache-list-unexpected-type", {
+            entry
+        });
     }
-    *iterateCallbacks(name) {
-        for (const plugin of this._strategy.plugins){
-            if (typeof plugin[name] === "function") {
-                const state = this._pluginStateMap.get(plugin);
-                const statefulCallback = (param)=>{
-                    const statefulParam = {
-                        ...param,
-                        state
-                    };
-                    return plugin[name](statefulParam);
-                };
-                yield statefulCallback;
-            }
-        }
+    if (!revision) {
+        const urlObject = new URL(url, location.href);
+        return {
+            cacheKey: urlObject.href,
+            url: urlObject.href
+        };
     }
-    waitUntil(promise) {
-        this._extendLifetimePromises.push(promise);
-        return promise;
+    const cacheKeyURL = new URL(url, location.href);
+    const originalURL = new URL(url, location.href);
+    cacheKeyURL.searchParams.set(REVISION_SEARCH_PARAM, revision);
+    return {
+        cacheKey: cacheKeyURL.href,
+        url: originalURL.href
+    };
+};
+
+const logGroup = (groupTitle, deletedURLs)=>{
+    logger.groupCollapsed(groupTitle);
+    for (const url of deletedURLs){
+        logger.log(url);
     }
-    async doneWaiting() {
-        let promise = undefined;
-        while(promise = this._extendLifetimePromises.shift()){
-            await promise;
-        }
+    logger.groupEnd();
+};
+const printCleanupDetails = (deletedURLs)=>{
+    const deletionCount = deletedURLs.length;
+    if (deletionCount > 0) {
+        logger.groupCollapsed(`During precaching cleanup, ${deletionCount} cached request${deletionCount === 1 ? " was" : "s were"} deleted.`);
+        logGroup("Deleted Cache Requests", deletedURLs);
+        logger.groupEnd();
     }
-    destroy() {
-        this._handlerDeferred.resolve(null);
+};
+
+function _nestedGroup(groupTitle, urls) {
+    if (urls.length === 0) {
+        return;
     }
-    async getPreloadResponse() {
-        if (this.event instanceof FetchEvent && this.event.request.mode === "navigate" && "preloadResponse" in this.event) {
-            try {
-                const possiblePreloadResponse = await this.event.preloadResponse;
-                if (possiblePreloadResponse) {
-                    if (process.env.NODE_ENV !== "production") {
-                        logger.log(`Using a preloaded navigation response for '${getFriendlyURL(this.event.request.url)}'`);
-                    }
-                    return possiblePreloadResponse;
-                }
-            } catch (error) {
-                if (process.env.NODE_ENV !== "production") {
-                    logger.error(error);
-                }
-                return undefined;
-            }
+    logger.groupCollapsed(groupTitle);
+    for (const url of urls){
+        logger.log(url);
+    }
+    logger.groupEnd();
+}
+const printInstallDetails = (urlsToPrecache, urlsAlreadyPrecached)=>{
+    const precachedCount = urlsToPrecache.length;
+    const alreadyPrecachedCount = urlsAlreadyPrecached.length;
+    if (precachedCount || alreadyPrecachedCount) {
+        let message = `Precaching ${precachedCount} file${precachedCount === 1 ? "" : "s"}.`;
+        if (alreadyPrecachedCount > 0) {
+            message += ` ${alreadyPrecachedCount} ` + `file${alreadyPrecachedCount === 1 ? " is" : "s are"} already cached.`;
         }
-        return undefined;
+        logger.groupCollapsed(message);
+        _nestedGroup("View newly precached URLs.", urlsToPrecache);
+        _nestedGroup("View previously precached URLs.", urlsAlreadyPrecached);
+        logger.groupEnd();
     }
-    async _ensureResponseSafeToCache(response) {
-        let responseToCache = response;
-        let pluginsUsed = false;
-        for (const callback of this.iterateCallbacks("cacheWillUpdate")){
-            responseToCache = await callback({
-                request: this.request,
-                response: responseToCache,
-                event: this.event
-            }) || undefined;
-            pluginsUsed = true;
-            if (!responseToCache) {
-                break;
-            }
+};
+
+class PrecacheInstallReportPlugin {
+    updatedURLs = [];
+    notUpdatedURLs = [];
+    handlerWillStart = async ({ request, state })=>{
+        if (state) {
+            state.originalRequest = request;
         }
-        if (!pluginsUsed) {
-            if (responseToCache && responseToCache.status !== 200) {
-                if (process.env.NODE_ENV !== "production") {
-                    if (responseToCache.status === 0) {
-                        logger.warn(`The response for '${this.request.url}' is an opaque response. The caching strategy that you're using will not cache opaque responses by default.`);
-                    } else {
-                        logger.debug(`The response for '${this.request.url}' returned a status code of '${response.status}' and won't be cached as a result.`);
-                    }
+    };
+    cachedResponseWillBeUsed = async ({ event, state, cachedResponse })=>{
+        if (event.type === "install") {
+            if (state?.originalRequest && state.originalRequest instanceof Request) {
+                const url = state.originalRequest.url;
+                if (cachedResponse) {
+                    this.notUpdatedURLs.push(url);
+                } else {
+                    this.updatedURLs.push(url);
                 }
-                responseToCache = undefined;
             }
         }
-        return responseToCache;
-    }
+        return cachedResponse;
+    };
 }
 
-class Strategy {
-    cacheName;
-    plugins;
-    fetchOptions;
-    matchOptions;
-    constructor(options = {}){
-        this.cacheName = cacheNames$1.getRuntimeName(options.cacheName);
-        this.plugins = options.plugins || [];
-        this.fetchOptions = options.fetchOptions;
-        this.matchOptions = options.matchOptions;
+const removeIgnoredSearchParams = (urlObject, ignoreURLParametersMatching = [])=>{
+    for (const paramName of [
+        ...urlObject.searchParams.keys()
+    ]){
+        if (ignoreURLParametersMatching.some((regExp)=>regExp.test(paramName))) {
+            urlObject.searchParams.delete(paramName);
+        }
     }
-    handle(options) {
-        const [responseDone] = this.handleAll(options);
-        return responseDone;
+    return urlObject;
+};
+
+function* generateURLVariations(url, { directoryIndex = "index.html", ignoreURLParametersMatching = [
+    /^utm_/,
+    /^fbclid$/
+], cleanURLs = true, urlManipulation } = {}) {
+    const urlObject = new URL(url, location.href);
+    urlObject.hash = "";
+    yield urlObject.href;
+    const urlWithoutIgnoredParams = removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching);
+    yield urlWithoutIgnoredParams.href;
+    if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith("/")) {
+        const directoryURL = new URL(urlWithoutIgnoredParams.href);
+        directoryURL.pathname += directoryIndex;
+        yield directoryURL.href;
     }
-    handleAll(options) {
-        if (options instanceof FetchEvent) {
-            options = {
-                event: options,
-                request: options.request
-            };
-        }
-        const event = options.event;
-        const request = typeof options.request === "string" ? new Request(options.request) : options.request;
-        const handler = new StrategyHandler(this, options.url ? {
-            event,
-            request,
-            url: options.url,
-            params: options.params
-        } : {
-            event,
-            request
-        });
-        const responseDone = this._getResponse(handler, request, event);
-        const handlerDone = this._awaitComplete(responseDone, handler, request, event);
-        return [
-            responseDone,
-            handlerDone
-        ];
+    if (cleanURLs) {
+        const cleanURL = new URL(urlWithoutIgnoredParams.href);
+        cleanURL.pathname += ".html";
+        yield cleanURL.href;
     }
-    async _getResponse(handler, request, event) {
-        await handler.runCallbacks("handlerWillStart", {
-            event,
-            request
+    if (urlManipulation) {
+        const additionalURLs = urlManipulation({
+            url: urlObject
         });
-        let response = undefined;
-        try {
-            response = await this._handle(request, handler);
-            if (response === undefined || response.type === "error") {
-                throw new SerwistError("no-response", {
-                    url: request.url
-                });
-            }
-        } catch (error) {
-            if (error instanceof Error) {
-                for (const callback of handler.iterateCallbacks("handlerDidError")){
-                    response = await callback({
-                        error,
-                        event,
-                        request
-                    });
-                    if (response !== undefined) {
-                        break;
-                    }
+        for (const urlToAttempt of additionalURLs){
+            yield urlToAttempt.href;
+        }
+    }
+}
+
+class PrecacheRoute extends Route {
+    constructor(controller, options){
+        const match = ({ request })=>{
+            const urlsToCacheKeys = controller.getUrlsToPrecacheKeys();
+            for (const possibleURL of generateURLVariations(request.url, options)){
+                const cacheKey = urlsToCacheKeys.get(possibleURL);
+                if (cacheKey) {
+                    const integrity = controller.getIntegrityForPrecacheKey(cacheKey);
+                    return {
+                        cacheKey,
+                        integrity
+                    };
                 }
             }
-            if (!response) {
-                throw error;
-            }
             if (process.env.NODE_ENV !== "production") {
-                throw logger.log(`While responding to '${getFriendlyURL(request.url)}', an ${error instanceof Error ? error.toString() : ""} error occurred. Using a fallback response provided by a handlerDidError plugin.`);
+                logger.debug(`Precaching did not find a match for ${getFriendlyURL(request.url)}.`);
             }
-        }
-        for (const callback of handler.iterateCallbacks("handlerWillRespond")){
-            response = await callback({
-                event,
-                request,
-                response
-            });
-        }
-        return response;
+            return;
+        };
+        super(match, controller.strategy);
     }
-    async _awaitComplete(responseDone, handler, request, event) {
-        let response = undefined;
-        let error = undefined;
-        try {
-            response = await responseDone;
-        } catch (error) {}
-        try {
-            await handler.runCallbacks("handlerDidRespond", {
-                event,
-                request,
-                response
-            });
-            await handler.doneWaiting();
-        } catch (waitUntilError) {
-            if (waitUntilError instanceof Error) {
-                error = waitUntilError;
-            }
-        }
-        await handler.runCallbacks("handlerDidComplete", {
-            event,
-            request,
-            response,
-            error
+}
+
+const copyResponse = async (response, modifier)=>{
+    let origin = null;
+    if (response.url) {
+        const responseURL = new URL(response.url);
+        origin = responseURL.origin;
+    }
+    if (origin !== self.location.origin) {
+        throw new SerwistError("cross-origin-copy-response", {
+            origin
         });
-        handler.destroy();
-        if (error) {
-            throw error;
-        }
     }
-}
+    const clonedResponse = response.clone();
+    const responseInit = {
+        headers: new Headers(clonedResponse.headers),
+        status: clonedResponse.status,
+        statusText: clonedResponse.statusText
+    };
+    const modifiedResponseInit = modifier ? modifier(responseInit) : responseInit;
+    const body = canConstructResponseFromBodyStream() ? clonedResponse.body : await clonedResponse.blob();
+    return new Response(body, modifiedResponseInit);
+};
 
-class PrecacheStrategy extends Strategy {
-    _fallbackToNetwork;
-    static defaultPrecacheCacheabilityPlugin = {
-        async cacheWillUpdate ({ response }) {
-            if (!response || response.status >= 400) {
-                return null;
-            }
-            return response;
+function toRequest(input) {
+    return typeof input === "string" ? new Request(input) : input;
+}
+class StrategyHandler {
+    event;
+    request;
+    url;
+    params;
+    _cacheKeys = {};
+    _strategy;
+    _handlerDeferred;
+    _extendLifetimePromises;
+    _plugins;
+    _pluginStateMap;
+    constructor(strategy, options){
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isInstance(options.event, ExtendableEvent, {
+                moduleName: "serwist",
+                className: "StrategyHandler",
+                funcName: "constructor",
+                paramName: "options.event"
+            });
+            finalAssertExports.isInstance(options.request, Request, {
+                moduleName: "serwist",
+                className: "StrategyHandler",
+                funcName: "constructor",
+                paramName: "options.request"
+            });
         }
-    };
-    static copyRedirectedCacheableResponsesPlugin = {
-        async cacheWillUpdate ({ response }) {
-            return response.redirected ? await copyResponse(response) : response;
+        this.event = options.event;
+        this.request = options.request;
+        if (options.url) {
+            this.url = options.url;
+            this.params = options.params;
         }
-    };
-    constructor(options = {}){
-        options.cacheName = cacheNames$1.getPrecacheName(options.cacheName);
-        super(options);
-        this._fallbackToNetwork = options.fallbackToNetwork !== false;
-        this.plugins.push(PrecacheStrategy.copyRedirectedCacheableResponsesPlugin);
+        this._strategy = strategy;
+        this._handlerDeferred = new Deferred();
+        this._extendLifetimePromises = [];
+        this._plugins = [
+            ...strategy.plugins
+        ];
+        this._pluginStateMap = new Map();
+        for (const plugin of this._plugins){
+            this._pluginStateMap.set(plugin, {});
+        }
+        this.event.waitUntil(this._handlerDeferred.promise);
     }
-    async _handle(request, handler) {
-        const preloadResponse = await handler.getPreloadResponse();
+    async fetch(input) {
+        const { event } = this;
+        let request = toRequest(input);
+        const preloadResponse = await this.getPreloadResponse();
         if (preloadResponse) {
             return preloadResponse;
         }
-        const response = await handler.cacheMatch(request);
-        if (response) {
-            return response;
-        }
-        if (handler.event && handler.event.type === "install") {
-            return await this._handleInstall(request, handler);
+        const originalRequest = this.hasCallback("fetchDidFail") ? request.clone() : null;
+        try {
+            for (const cb of this.iterateCallbacks("requestWillFetch")){
+                request = await cb({
+                    request: request.clone(),
+                    event
+                });
+            }
+        } catch (err) {
+            if (err instanceof Error) {
+                throw new SerwistError("plugin-error-request-will-fetch", {
+                    thrownErrorMessage: err.message
+                });
+            }
         }
-        return await this._handleFetch(request, handler);
-    }
-    async _handleFetch(request, handler) {
-        let response = undefined;
-        const params = handler.params || {};
-        if (this._fallbackToNetwork) {
+        const pluginFilteredRequest = request.clone();
+        try {
+            let fetchResponse;
+            fetchResponse = await fetch(request, request.mode === "navigate" ? undefined : this._strategy.fetchOptions);
             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.`);
+                logger.debug(`Network request for '${getFriendlyURL(request.url)}' returned a response with status '${fetchResponse.status}'.`);
             }
-            const integrityInManifest = params.integrity;
-            const integrityInRequest = request.integrity;
-            const noIntegrityConflict = !integrityInRequest || integrityInRequest === integrityInManifest;
-            response = await handler.fetch(new Request(request, {
-                integrity: request.mode !== "no-cors" ? integrityInRequest || integrityInManifest : undefined
-            }));
-            if (integrityInManifest && noIntegrityConflict && request.mode !== "no-cors") {
-                this._useDefaultCacheabilityPluginIfNeeded();
-                const wasCached = await handler.cachePut(request, response.clone());
-                if (process.env.NODE_ENV !== "production") {
-                    if (wasCached) {
-                        logger.log(`A response for ${getFriendlyURL(request.url)} was used to "repair" the precache.`);
-                    }
-                }
+            for (const callback of this.iterateCallbacks("fetchDidSucceed")){
+                fetchResponse = await callback({
+                    event,
+                    request: pluginFilteredRequest,
+                    response: fetchResponse
+                });
             }
-        } else {
-            throw new SerwistError("missing-precache-entry", {
-                cacheName: this.cacheName,
-                url: request.url
-            });
-        }
-        if (process.env.NODE_ENV !== "production") {
-            const cacheKey = params.cacheKey || await handler.getCacheKey(request, "read");
-            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.");
-            logger.log(request);
-            logger.groupEnd();
-            logger.groupCollapsed("View response details here.");
-            logger.log(response);
-            logger.groupEnd();
-            logger.groupEnd();
+            return fetchResponse;
+        } catch (error) {
+            if (process.env.NODE_ENV !== "production") {
+                logger.log(`Network request for '${getFriendlyURL(request.url)}' threw an error.`, error);
+            }
+            if (originalRequest) {
+                await this.runCallbacks("fetchDidFail", {
+                    error: error,
+                    event,
+                    originalRequest: originalRequest.clone(),
+                    request: pluginFilteredRequest.clone()
+                });
+            }
+            throw error;
         }
-        return response;
     }
-    async _handleInstall(request, handler) {
-        this._useDefaultCacheabilityPluginIfNeeded();
-        const response = await handler.fetch(request);
-        const wasCached = await handler.cachePut(request, response.clone());
-        if (!wasCached) {
-            throw new SerwistError("bad-precaching-response", {
-                url: request.url,
-                status: response.status
-            });
-        }
+    async fetchAndCachePut(input) {
+        const response = await this.fetch(input);
+        const responseClone = response.clone();
+        void this.waitUntil(this.cachePut(input, responseClone));
         return response;
     }
-    _useDefaultCacheabilityPluginIfNeeded() {
-        let defaultPluginIndex = null;
-        let cacheWillUpdatePluginCount = 0;
-        for (const [index, plugin] of this.plugins.entries()){
-            if (plugin === PrecacheStrategy.copyRedirectedCacheableResponsesPlugin) {
-                continue;
-            }
-            if (plugin === PrecacheStrategy.defaultPrecacheCacheabilityPlugin) {
-                defaultPluginIndex = index;
+    async cacheMatch(key) {
+        const request = toRequest(key);
+        let cachedResponse;
+        const { cacheName, matchOptions } = this._strategy;
+        const effectiveRequest = await this.getCacheKey(request, "read");
+        const multiMatchOptions = {
+            ...matchOptions,
+            ...{
+                cacheName
             }
-            if (plugin.cacheWillUpdate) {
-                cacheWillUpdatePluginCount++;
+        };
+        cachedResponse = await caches.match(effectiveRequest, multiMatchOptions);
+        if (process.env.NODE_ENV !== "production") {
+            if (cachedResponse) {
+                logger.debug(`Found a cached response in '${cacheName}'.`);
+            } else {
+                logger.debug(`No cached response found in '${cacheName}'.`);
             }
         }
-        if (cacheWillUpdatePluginCount === 0) {
-            this.plugins.push(PrecacheStrategy.defaultPrecacheCacheabilityPlugin);
-        } else if (cacheWillUpdatePluginCount > 1 && defaultPluginIndex !== null) {
-            this.plugins.splice(defaultPluginIndex, 1);
+        for (const callback of this.iterateCallbacks("cachedResponseWillBeUsed")){
+            cachedResponse = await callback({
+                cacheName,
+                matchOptions,
+                cachedResponse,
+                request: effectiveRequest,
+                event: this.event
+            }) || undefined;
         }
+        return cachedResponse;
     }
-}
-
-const defaultMethod = "GET";
-const validMethods = [
-    "DELETE",
-    "GET",
-    "HEAD",
-    "PATCH",
-    "POST",
-    "PUT"
-];
-
-const normalizeHandler = (handler)=>{
-    if (handler && typeof handler === "object") {
+    async cachePut(key, response) {
+        const request = toRequest(key);
+        await timeout(0);
+        const effectiveRequest = await this.getCacheKey(request, "write");
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.hasMethod(handler, "handle", {
-                moduleName: "serwist",
-                className: "Route",
-                funcName: "constructor",
-                paramName: "handler"
+            if (effectiveRequest.method && effectiveRequest.method !== "GET") {
+                throw new SerwistError("attempt-to-cache-non-get-request", {
+                    url: getFriendlyURL(effectiveRequest.url),
+                    method: effectiveRequest.method
+                });
+            }
+        }
+        if (!response) {
+            if (process.env.NODE_ENV !== "production") {
+                logger.error(`Cannot cache non-existent response for '${getFriendlyURL(effectiveRequest.url)}'.`);
+            }
+            throw new SerwistError("cache-put-with-no-response", {
+                url: getFriendlyURL(effectiveRequest.url)
             });
         }
-        return handler;
-    }
-    if (process.env.NODE_ENV !== "production") {
-        finalAssertExports.isType(handler, "function", {
-            moduleName: "serwist",
-            className: "Route",
-            funcName: "constructor",
-            paramName: "handler"
-        });
-    }
-    return {
-        handle: handler
-    };
-};
-
-class Route {
-    handler;
-    match;
-    method;
-    catchHandler;
-    constructor(match, handler, method = defaultMethod){
+        const responseToCache = await this._ensureResponseSafeToCache(response);
+        if (!responseToCache) {
+            if (process.env.NODE_ENV !== "production") {
+                logger.debug(`Response '${getFriendlyURL(effectiveRequest.url)}' will not be cached.`, responseToCache);
+            }
+            return false;
+        }
+        const { cacheName, matchOptions } = this._strategy;
+        const cache = await self.caches.open(cacheName);
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isType(match, "function", {
-                moduleName: "serwist",
-                className: "Route",
-                funcName: "constructor",
-                paramName: "match"
-            });
-            if (method) {
-                finalAssertExports.isOneOf(method, validMethods, {
-                    paramName: "method"
-                });
+            const vary = response.headers.get("Vary");
+            if (vary && matchOptions?.ignoreVary !== true) {
+                logger.debug(`The response for ${getFriendlyURL(effectiveRequest.url)} has a 'Vary: ${vary}' header. Consider setting the {ignoreVary: true} option on your strategy to ensure cache matching and deletion works as expected.`);
             }
         }
-        this.handler = normalizeHandler(handler);
-        this.match = match;
-        this.method = method;
-    }
-    setCatchHandler(handler) {
-        this.catchHandler = normalizeHandler(handler);
-    }
-}
-
-const removeIgnoredSearchParams = (urlObject, ignoreURLParametersMatching = [])=>{
-    for (const paramName of [
-        ...urlObject.searchParams.keys()
-    ]){
-        if (ignoreURLParametersMatching.some((regExp)=>regExp.test(paramName))) {
-            urlObject.searchParams.delete(paramName);
+        const hasCacheUpdateCallback = this.hasCallback("cacheDidUpdate");
+        const oldResponse = hasCacheUpdateCallback ? await cacheMatchIgnoreParams(cache, effectiveRequest.clone(), [
+            "__WB_REVISION__"
+        ], matchOptions) : null;
+        if (process.env.NODE_ENV !== "production") {
+            logger.debug(`Updating the '${cacheName}' cache with a new Response for ${getFriendlyURL(effectiveRequest.url)}.`);
+        }
+        try {
+            await cache.put(effectiveRequest, hasCacheUpdateCallback ? responseToCache.clone() : responseToCache);
+        } catch (error) {
+            if (error instanceof Error) {
+                if (error.name === "QuotaExceededError") {
+                    await executeQuotaErrorCallbacks();
+                }
+                throw error;
+            }
+        }
+        for (const callback of this.iterateCallbacks("cacheDidUpdate")){
+            await callback({
+                cacheName,
+                oldResponse,
+                newResponse: responseToCache.clone(),
+                request: effectiveRequest,
+                event: this.event
+            });
         }
+        return true;
     }
-    return urlObject;
-};
-
-function* generateURLVariations(url, { directoryIndex = "index.html", ignoreURLParametersMatching = [
-    /^utm_/,
-    /^fbclid$/
-], cleanURLs = true, urlManipulation } = {}) {
-    const urlObject = new URL(url, location.href);
-    urlObject.hash = "";
-    yield urlObject.href;
-    const urlWithoutIgnoredParams = removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching);
-    yield urlWithoutIgnoredParams.href;
-    if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith("/")) {
-        const directoryURL = new URL(urlWithoutIgnoredParams.href);
-        directoryURL.pathname += directoryIndex;
-        yield directoryURL.href;
+    async getCacheKey(request, mode) {
+        const key = `${request.url} | ${mode}`;
+        if (!this._cacheKeys[key]) {
+            let effectiveRequest = request;
+            for (const callback of this.iterateCallbacks("cacheKeyWillBeUsed")){
+                effectiveRequest = toRequest(await callback({
+                    mode,
+                    request: effectiveRequest,
+                    event: this.event,
+                    params: this.params
+                }));
+            }
+            this._cacheKeys[key] = effectiveRequest;
+        }
+        return this._cacheKeys[key];
     }
-    if (cleanURLs) {
-        const cleanURL = new URL(urlWithoutIgnoredParams.href);
-        cleanURL.pathname += ".html";
-        yield cleanURL.href;
+    hasCallback(name) {
+        for (const plugin of this._strategy.plugins){
+            if (name in plugin) {
+                return true;
+            }
+        }
+        return false;
     }
-    if (urlManipulation) {
-        const additionalURLs = urlManipulation({
-            url: urlObject
-        });
-        for (const urlToAttempt of additionalURLs){
-            yield urlToAttempt.href;
+    async runCallbacks(name, param) {
+        for (const callback of this.iterateCallbacks(name)){
+            await callback(param);
         }
     }
-}
-
-class PrecacheRoute extends Route {
-    constructor(controller, options){
-        const match = ({ request })=>{
-            const urlsToCacheKeys = controller.getUrlsToPrecacheKeys();
-            for (const possibleURL of generateURLVariations(request.url, options)){
-                const cacheKey = urlsToCacheKeys.get(possibleURL);
-                if (cacheKey) {
-                    const integrity = controller.getIntegrityForPrecacheKey(cacheKey);
-                    return {
-                        cacheKey,
-                        integrity
+    *iterateCallbacks(name) {
+        for (const plugin of this._strategy.plugins){
+            if (typeof plugin[name] === "function") {
+                const state = this._pluginStateMap.get(plugin);
+                const statefulCallback = (param)=>{
+                    const statefulParam = {
+                        ...param,
+                        state
                     };
-                }
-            }
-            if (process.env.NODE_ENV !== "production") {
-                logger.debug(`Precaching did not find a match for ${getFriendlyURL(request.url)}.`);
+                    return plugin[name](statefulParam);
+                };
+                yield statefulCallback;
             }
-            return;
-        };
-        super(match, controller.strategy);
+        }
     }
-}
-
-class PrecacheFallbackPlugin {
-    _fallbackUrls;
-    _precacheController;
-    constructor({ fallbackUrls, precacheController }){
-        this._fallbackUrls = fallbackUrls;
-        this._precacheController = precacheController;
+    waitUntil(promise) {
+        this._extendLifetimePromises.push(promise);
+        return promise;
     }
-    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;
+    async doneWaiting() {
+        let promise = undefined;
+        while(promise = this._extendLifetimePromises.shift()){
+            await promise;
+        }
+    }
+    destroy() {
+        this._handlerDeferred.resolve(null);
+    }
+    async getPreloadResponse() {
+        if (this.event instanceof FetchEvent && this.event.request.mode === "navigate" && "preloadResponse" in this.event) {
+            try {
+                const possiblePreloadResponse = await this.event.preloadResponse;
+                if (possiblePreloadResponse) {
+                    if (process.env.NODE_ENV !== "production") {
+                        logger.log(`Using a preloaded navigation response for '${getFriendlyURL(this.event.request.url)}'`);
+                    }
+                    return possiblePreloadResponse;
                 }
-            } else if (fallback.matcher(param)) {
-                const fallbackResponse = await this._precacheController.matchPrecache(fallback.url);
-                if (fallbackResponse !== undefined) {
-                    return fallbackResponse;
+            } catch (error) {
+                if (process.env.NODE_ENV !== "production") {
+                    logger.error(error);
                 }
+                return undefined;
             }
         }
         return undefined;
     }
-}
-
-class RuntimeCacheController {
-    _entries;
-    _options;
-    constructor(entries, options = {}){
-        this._entries = entries;
-        this._options = options;
-        this.init = this.init.bind(this);
-        this.install = this.install.bind(this);
-    }
-    init(serwist) {
-        if (this._options.fallbacks !== undefined) {
-            const fallbackPlugin = new PrecacheFallbackPlugin({
-                fallbackUrls: this._options.fallbacks.entries,
-                precacheController: serwist.precache
-            });
-            this._entries.forEach((cacheEntry)=>{
-                if (cacheEntry.handler instanceof Strategy && !cacheEntry.handler.plugins.some((plugin)=>"handlerDidError" in plugin)) {
-                    cacheEntry.handler.plugins.push(fallbackPlugin);
-                }
-            });
-        }
-        for (const entry of this._entries){
-            serwist.registerCapture(entry.matcher, entry.handler, entry.method);
+    async _ensureResponseSafeToCache(response) {
+        let responseToCache = response;
+        let pluginsUsed = false;
+        for (const callback of this.iterateCallbacks("cacheWillUpdate")){
+            responseToCache = await callback({
+                request: this.request,
+                response: responseToCache,
+                event: this.event
+            }) || undefined;
+            pluginsUsed = true;
+            if (!responseToCache) {
+                break;
+            }
         }
-    }
-    async install(event, serwist) {
-        const concurrency = this._options.warmOptions?.concurrency ?? 10;
-        if (this._options.warmEntries) {
-            await parallel(concurrency, this._options.warmEntries, async (entry)=>{
-                const request = entry instanceof Request ? entry : new Request(typeof entry === "string" ? entry : entry.url, {
-                    integrity: typeof entry !== "string" ? entry.integrity : undefined,
-                    credentials: "same-origin"
-                });
-                await serwist.handleRequest({
-                    request,
-                    event
-                });
-            });
+        if (!pluginsUsed) {
+            if (responseToCache && responseToCache.status !== 200) {
+                if (process.env.NODE_ENV !== "production") {
+                    if (responseToCache.status === 0) {
+                        logger.warn(`The response for '${this.request.url}' is an opaque response. The caching strategy that you're using will not cache opaque responses by default.`);
+                    } else {
+                        logger.debug(`The response for '${this.request.url}' returned a status code of '${response.status}' and won't be cached as a result.`);
+                    }
+                }
+                responseToCache = undefined;
+            }
         }
-    }
-    warmRuntimeCache(entries) {
-        if (!this._options.warmEntries) this._options.warmEntries = [];
-        this._options.warmEntries.push(...entries);
+        return responseToCache;
     }
 }
 
-class NavigationRoute extends Route {
-    _allowlist;
-    _denylist;
-    constructor(handler, { allowlist = [
-        /./
-    ], denylist = [] } = {}){
-        if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isArrayOfClass(allowlist, RegExp, {
-                moduleName: "serwist",
-                className: "NavigationRoute",
-                funcName: "constructor",
-                paramName: "options.allowlist"
-            });
-            finalAssertExports.isArrayOfClass(denylist, RegExp, {
-                moduleName: "serwist",
-                className: "NavigationRoute",
-                funcName: "constructor",
-                paramName: "options.denylist"
-            });
-        }
-        super((options)=>this._match(options), handler);
-        this._allowlist = allowlist;
-        this._denylist = denylist;
+class Strategy {
+    cacheName;
+    plugins;
+    fetchOptions;
+    matchOptions;
+    constructor(options = {}){
+        this.cacheName = cacheNames$1.getRuntimeName(options.cacheName);
+        this.plugins = options.plugins || [];
+        this.fetchOptions = options.fetchOptions;
+        this.matchOptions = options.matchOptions;
     }
-    _match({ url, request }) {
-        if (request && request.mode !== "navigate") {
-            return false;
+    handle(options) {
+        const [responseDone] = this.handleAll(options);
+        return responseDone;
+    }
+    handleAll(options) {
+        if (options instanceof FetchEvent) {
+            options = {
+                event: options,
+                request: options.request
+            };
         }
-        const pathnameAndSearch = url.pathname + url.search;
-        for (const regExp of this._denylist){
-            if (regExp.test(pathnameAndSearch)) {
-                if (process.env.NODE_ENV !== "production") {
-                    logger.log(`The navigation route ${pathnameAndSearch} is not being used, since the URL matches this denylist pattern: ${regExp.toString()}`);
+        const event = options.event;
+        const request = typeof options.request === "string" ? new Request(options.request) : options.request;
+        const handler = new StrategyHandler(this, options.url ? {
+            event,
+            request,
+            url: options.url,
+            params: options.params
+        } : {
+            event,
+            request
+        });
+        const responseDone = this._getResponse(handler, request, event);
+        const handlerDone = this._awaitComplete(responseDone, handler, request, event);
+        return [
+            responseDone,
+            handlerDone
+        ];
+    }
+    async _getResponse(handler, request, event) {
+        await handler.runCallbacks("handlerWillStart", {
+            event,
+            request
+        });
+        let response = undefined;
+        try {
+            response = await this._handle(request, handler);
+            if (response === undefined || response.type === "error") {
+                throw new SerwistError("no-response", {
+                    url: request.url
+                });
+            }
+        } catch (error) {
+            if (error instanceof Error) {
+                for (const callback of handler.iterateCallbacks("handlerDidError")){
+                    response = await callback({
+                        error,
+                        event,
+                        request
+                    });
+                    if (response !== undefined) {
+                        break;
+                    }
                 }
-                return false;
             }
-        }
-        if (this._allowlist.some((regExp)=>regExp.test(pathnameAndSearch))) {
+            if (!response) {
+                throw error;
+            }
             if (process.env.NODE_ENV !== "production") {
-                logger.debug(`The navigation route ${pathnameAndSearch} is being used.`);
+                throw logger.log(`While responding to '${getFriendlyURL(request.url)}', an ${error instanceof Error ? error.toString() : ""} error occurred. Using a fallback response provided by a handlerDidError plugin.`);
             }
-            return true;
         }
-        if (process.env.NODE_ENV !== "production") {
-            logger.log(`The navigation route ${pathnameAndSearch} is not being used, since the URL being navigated to doesn't match the allowlist.`);
+        for (const callback of handler.iterateCallbacks("handlerWillRespond")){
+            response = await callback({
+                event,
+                request,
+                response
+            });
         }
-        return false;
+        return response;
     }
-}
-
-class RegExpRoute extends Route {
-    constructor(regExp, handler, method){
-        if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isInstance(regExp, RegExp, {
-                moduleName: "serwist",
-                className: "RegExpRoute",
-                funcName: "constructor",
-                paramName: "pattern"
+    async _awaitComplete(responseDone, handler, request, event) {
+        let response = undefined;
+        let error = undefined;
+        try {
+            response = await responseDone;
+        } catch (error) {}
+        try {
+            await handler.runCallbacks("handlerDidRespond", {
+                event,
+                request,
+                response
             });
-        }
-        const match = ({ url })=>{
-            const result = regExp.exec(url.href);
-            if (!result) {
-                return;
-            }
-            if (url.origin !== location.origin && result.index !== 0) {
-                if (process.env.NODE_ENV !== "production") {
-                    logger.debug(`The regular expression '${regExp.toString()}' only partially matched against the cross-origin URL '${url.toString()}'. RegExpRoute's will only handle cross-origin requests if they match the entire URL.`);
-                }
-                return;
+            await handler.doneWaiting();
+        } catch (waitUntilError) {
+            if (waitUntilError instanceof Error) {
+                error = waitUntilError;
             }
-            return result.slice(1);
-        };
-        super(match, handler, method);
+        }
+        await handler.runCallbacks("handlerDidComplete", {
+            event,
+            request,
+            response,
+            error
+        });
+        handler.destroy();
+        if (error) {
+            throw error;
+        }
     }
 }
 
-const disableDevLogs = ()=>{
-    self.__WB_DISABLE_DEV_LOGS = true;
-};
-
-const cacheOkAndOpaquePlugin = {
-    cacheWillUpdate: async ({ response })=>{
-        if (response.status === 200 || response.status === 0) {
+class PrecacheStrategy extends Strategy {
+    _fallbackToNetwork;
+    static defaultPrecacheCacheabilityPlugin = {
+        async cacheWillUpdate ({ response }) {
+            if (!response || response.status >= 400) {
+                return null;
+            }
             return response;
         }
-        return null;
-    }
-};
-
-const messages = {
-    strategyStart: (strategyName, request)=>`Using ${strategyName} to respond to '${getFriendlyURL(request.url)}'`,
-    printFinalResponse: (response)=>{
-        if (response) {
-            logger.groupCollapsed("View the final response here.");
-            logger.log(response || "[No response returned]");
-            logger.groupEnd();
+    };
+    static copyRedirectedCacheableResponsesPlugin = {
+        async cacheWillUpdate ({ response }) {
+            return response.redirected ? await copyResponse(response) : response;
         }
-    }
-};
-
-class NetworkFirst extends Strategy {
-    _networkTimeoutSeconds;
+    };
     constructor(options = {}){
+        options.cacheName = cacheNames$1.getPrecacheName(options.cacheName);
         super(options);
-        if (!this.plugins.some((p)=>"cacheWillUpdate" in p)) {
-            this.plugins.unshift(cacheOkAndOpaquePlugin);
-        }
-        this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;
-        if (process.env.NODE_ENV !== "production") {
-            if (this._networkTimeoutSeconds) {
-                finalAssertExports.isType(this._networkTimeoutSeconds, "number", {
-                    moduleName: "serwist",
-                    className: this.constructor.name,
-                    funcName: "constructor",
-                    paramName: "networkTimeoutSeconds"
-                });
-            }
-        }
+        this._fallbackToNetwork = options.fallbackToNetwork !== false;
+        this.plugins.push(PrecacheStrategy.copyRedirectedCacheableResponsesPlugin);
     }
     async _handle(request, handler) {
-        const logs = [];
-        if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isInstance(request, Request, {
-                moduleName: "serwist",
-                className: this.constructor.name,
-                funcName: "handle",
-                paramName: "makeRequest"
-            });
+        const preloadResponse = await handler.getPreloadResponse();
+        if (preloadResponse) {
+            return preloadResponse;
         }
-        const promises = [];
-        let timeoutId;
-        if (this._networkTimeoutSeconds) {
-            const { id, promise } = this._getTimeoutPromise({
-                request,
-                logs,
-                handler
+        const response = await handler.cacheMatch(request);
+        if (response) {
+            return response;
+        }
+        if (handler.event && handler.event.type === "install") {
+            return await this._handleInstall(request, handler);
+        }
+        return await this._handleFetch(request, handler);
+    }
+    async _handleFetch(request, handler) {
+        let response = undefined;
+        const params = handler.params || {};
+        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.`);
+            }
+            const integrityInManifest = params.integrity;
+            const integrityInRequest = request.integrity;
+            const noIntegrityConflict = !integrityInRequest || integrityInRequest === integrityInManifest;
+            response = await handler.fetch(new Request(request, {
+                integrity: request.mode !== "no-cors" ? integrityInRequest || integrityInManifest : undefined
+            }));
+            if (integrityInManifest && noIntegrityConflict && request.mode !== "no-cors") {
+                this._useDefaultCacheabilityPluginIfNeeded();
+                const wasCached = await handler.cachePut(request, response.clone());
+                if (process.env.NODE_ENV !== "production") {
+                    if (wasCached) {
+                        logger.log(`A response for ${getFriendlyURL(request.url)} was used to "repair" the precache.`);
+                    }
+                }
+            }
+        } else {
+            throw new SerwistError("missing-precache-entry", {
+                cacheName: this.cacheName,
+                url: request.url
             });
-            timeoutId = id;
-            promises.push(promise);
         }
-        const networkPromise = this._getNetworkPromise({
-            timeoutId,
-            request,
-            logs,
-            handler
-        });
-        promises.push(networkPromise);
-        const response = await handler.waitUntil((async ()=>{
-            return await handler.waitUntil(Promise.race(promises)) || await networkPromise;
-        })());
         if (process.env.NODE_ENV !== "production") {
-            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
-            for (const log of logs){
-                logger.log(log);
-            }
-            messages.printFinalResponse(response);
+            const cacheKey = params.cacheKey || await handler.getCacheKey(request, "read");
+            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.");
+            logger.log(request);
+            logger.groupEnd();
+            logger.groupCollapsed("View response details here.");
+            logger.log(response);
+            logger.groupEnd();
             logger.groupEnd();
         }
-        if (!response) {
-            throw new SerwistError("no-response", {
-                url: request.url
+        return response;
+    }
+    async _handleInstall(request, handler) {
+        this._useDefaultCacheabilityPluginIfNeeded();
+        const response = await handler.fetch(request);
+        const wasCached = await handler.cachePut(request, response.clone());
+        if (!wasCached) {
+            throw new SerwistError("bad-precaching-response", {
+                url: request.url,
+                status: response.status
             });
         }
         return response;
     }
-    _getTimeoutPromise({ request, logs, handler }) {
-        let timeoutId;
-        const timeoutPromise = new Promise((resolve)=>{
-            const onNetworkTimeout = async ()=>{
-                if (process.env.NODE_ENV !== "production") {
-                    logs.push(`Timing out the network response at ${this._networkTimeoutSeconds} seconds.`);
-                }
-                resolve(await handler.cacheMatch(request));
-            };
-            timeoutId = setTimeout(onNetworkTimeout, this._networkTimeoutSeconds * 1000);
-        });
-        return {
-            promise: timeoutPromise,
-            id: timeoutId
-        };
-    }
-    async _getNetworkPromise({ timeoutId, request, logs, handler }) {
-        let error = undefined;
-        let response = undefined;
-        try {
-            response = await handler.fetchAndCachePut(request);
-        } catch (fetchError) {
-            if (fetchError instanceof Error) {
-                error = fetchError;
+    _useDefaultCacheabilityPluginIfNeeded() {
+        let defaultPluginIndex = null;
+        let cacheWillUpdatePluginCount = 0;
+        for (const [index, plugin] of this.plugins.entries()){
+            if (plugin === PrecacheStrategy.copyRedirectedCacheableResponsesPlugin) {
+                continue;
             }
-        }
-        if (timeoutId) {
-            clearTimeout(timeoutId);
-        }
-        if (process.env.NODE_ENV !== "production") {
-            if (response) {
-                logs.push("Got response from network.");
-            } else {
-                logs.push("Unable to get a response from the network. Will respond " + "with a cached response.");
+            if (plugin === PrecacheStrategy.defaultPrecacheCacheabilityPlugin) {
+                defaultPluginIndex = index;
             }
-        }
-        if (error || !response) {
-            response = await handler.cacheMatch(request);
-            if (process.env.NODE_ENV !== "production") {
-                if (response) {
-                    logs.push(`Found a cached response in the '${this.cacheName}' cache.`);
-                } else {
-                    logs.push(`No response found in the '${this.cacheName}' cache.`);
-                }
+            if (plugin.cacheWillUpdate) {
+                cacheWillUpdatePluginCount++;
             }
         }
-        return response;
+        if (cacheWillUpdatePluginCount === 0) {
+            this.plugins.push(PrecacheStrategy.defaultPrecacheCacheabilityPlugin);
+        } else if (cacheWillUpdatePluginCount > 1 && defaultPluginIndex !== null) {
+            this.plugins.splice(defaultPluginIndex, 1);
+        }
     }
 }
 
-class NetworkOnly extends Strategy {
-    _networkTimeoutSeconds;
-    constructor(options = {}){
-        super(options);
-        this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;
+class PrecacheCacheKeyPlugin {
+    _precacheController;
+    constructor({ precacheController }){
+        this._precacheController = precacheController;
     }
-    async _handle(request, handler) {
+    cacheKeyWillBeUsed = async ({ request, params })=>{
+        const cacheKey = params?.cacheKey || this._precacheController.getPrecacheKeyForUrl(request.url);
+        return cacheKey ? new Request(cacheKey, {
+            headers: request.headers
+        }) : request;
+    };
+}
+
+const parsePrecacheOptions = (controller, { cacheName, plugins, fetchOptions, matchOptions, fallbackToNetwork, directoryIndex, ignoreURLParametersMatching, cleanURLs, urlManipulation, cleanupOutdatedCaches, concurrency, navigateFallback, navigateFallbackAllowlist, navigateFallbackDenylist } = {})=>({
+        strategyOptions: {
+            cacheName: cacheNames$1.getPrecacheName(cacheName),
+            plugins: [
+                ...plugins ?? [],
+                new PrecacheCacheKeyPlugin({
+                    precacheController: controller
+                })
+            ],
+            fetchOptions,
+            matchOptions,
+            fallbackToNetwork
+        },
+        routeOptions: {
+            directoryIndex,
+            ignoreURLParametersMatching,
+            cleanURLs,
+            urlManipulation
+        },
+        controllerOptions: {
+            cleanupOutdatedCaches,
+            concurrency: concurrency ?? 10,
+            navigateFallback,
+            navigateFallbackAllowlist,
+            navigateFallbackDenylist
+        }
+    });
+
+class PrecacheController {
+    _urlsToCacheKeys = new Map();
+    _urlsToCacheModes = new Map();
+    _cacheKeysToIntegrities = new Map();
+    _strategy;
+    _options;
+    _routeOptions;
+    constructor(entries, precacheOptions){
+        const { strategyOptions, routeOptions, controllerOptions } = parsePrecacheOptions(this, precacheOptions);
+        this.addToCacheList(entries);
+        this._strategy = new PrecacheStrategy(strategyOptions);
+        this._options = controllerOptions;
+        this._routeOptions = routeOptions;
+    }
+    get strategy() {
+        return this._strategy;
+    }
+    addToCacheList(entries) {
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isInstance(request, Request, {
+            finalAssertExports.isArray(entries, {
                 moduleName: "serwist",
-                className: this.constructor.name,
-                funcName: "_handle",
-                paramName: "request"
+                className: "PrecacheController",
+                funcName: "addEntries",
+                paramName: "entries"
             });
         }
-        let error = undefined;
-        let response;
-        try {
-            const promises = [
-                handler.fetch(request)
-            ];
-            if (this._networkTimeoutSeconds) {
-                const timeoutPromise = timeout(this._networkTimeoutSeconds * 1000);
-                promises.push(timeoutPromise);
+        const urlsToWarnAbout = [];
+        for (const entry of entries){
+            if (typeof entry === "string") {
+                urlsToWarnAbout.push(entry);
+            } else if (entry && !entry.integrity && entry.revision === undefined) {
+                urlsToWarnAbout.push(entry.url);
             }
-            response = await Promise.race(promises);
-            if (!response) {
-                throw new Error(`Timed out the network response after ${this._networkTimeoutSeconds} seconds.`);
+            const { cacheKey, url } = createCacheKey(entry);
+            const cacheMode = typeof entry !== "string" && entry.revision ? "reload" : "default";
+            if (this._urlsToCacheKeys.has(url) && this._urlsToCacheKeys.get(url) !== cacheKey) {
+                throw new SerwistError("add-to-cache-list-conflicting-entries", {
+                    firstEntry: this._urlsToCacheKeys.get(url),
+                    secondEntry: cacheKey
+                });
             }
-        } catch (err) {
-            if (err instanceof Error) {
-                error = err;
+            if (typeof entry !== "string" && entry.integrity) {
+                if (this._cacheKeysToIntegrities.has(cacheKey) && this._cacheKeysToIntegrities.get(cacheKey) !== entry.integrity) {
+                    throw new SerwistError("add-to-cache-list-conflicting-integrities", {
+                        url
+                    });
+                }
+                this._cacheKeysToIntegrities.set(cacheKey, entry.integrity);
             }
-        }
-        if (process.env.NODE_ENV !== "production") {
-            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
-            if (response) {
-                logger.log("Got response from network.");
-            } else {
-                logger.log("Unable to get a response from the network.");
+            this._urlsToCacheKeys.set(url, cacheKey);
+            this._urlsToCacheModes.set(url, cacheMode);
+            if (urlsToWarnAbout.length > 0) {
+                const warningMessage = `Serwist is precaching URLs without revision info: ${urlsToWarnAbout.join(", ")}\nThis is generally NOT safe, as you risk serving outdated assets.`;
+                if (process.env.NODE_ENV === "production") {
+                    console.warn(warningMessage);
+                } else {
+                    logger.warn(warningMessage);
+                }
             }
-            messages.printFinalResponse(response);
-            logger.groupEnd();
         }
-        if (!response) {
-            throw new SerwistError("no-response", {
-                url: request.url,
-                error
-            });
+    }
+    init({ serwist }) {
+        serwist.registerRoute(new PrecacheRoute(this, this._routeOptions));
+        if (this._options.navigateFallback) {
+            serwist.registerRoute(new NavigationRoute(this.createHandlerBoundToUrl(this._options.navigateFallback), {
+                allowlist: this._options.navigateFallbackAllowlist,
+                denylist: this._options.navigateFallbackDenylist
+            }));
         }
-        return response;
     }
-}
-
-const BACKGROUND_SYNC_DB_VERSION = 3;
-const BACKGROUND_SYNC_DB_NAME = "serwist-background-sync";
-const REQUEST_OBJECT_STORE_NAME = "requests";
-const QUEUE_NAME_INDEX = "queueName";
-class BackgroundSyncQueueDb {
-    _db = null;
-    async addEntry(entry) {
-        const db = await this.getDb();
-        const tx = db.transaction(REQUEST_OBJECT_STORE_NAME, "readwrite", {
-            durability: "relaxed"
+    async install({ event }) {
+        const installReportPlugin = new PrecacheInstallReportPlugin();
+        this._strategy.plugins.push(installReportPlugin);
+        await parallel(this._options.concurrency, 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, {
+                integrity,
+                cache: cacheMode,
+                credentials: "same-origin"
+            });
+            await Promise.all(this._strategy.handleAll({
+                event,
+                request,
+                url: new URL(request.url),
+                params: {
+                    cacheKey
+                }
+            }));
         });
-        await tx.store.add(entry);
-        await tx.done;
-    }
-    async getFirstEntryId() {
-        const db = await this.getDb();
-        const cursor = await db.transaction(REQUEST_OBJECT_STORE_NAME).store.openCursor();
-        return cursor?.value.id;
-    }
-    async getAllEntriesByQueueName(queueName) {
-        const db = await this.getDb();
-        const results = await db.getAllFromIndex(REQUEST_OBJECT_STORE_NAME, QUEUE_NAME_INDEX, IDBKeyRange.only(queueName));
-        return results ? results : new Array();
+        const { updatedURLs, notUpdatedURLs } = installReportPlugin;
+        if (process.env.NODE_ENV !== "production") {
+            printInstallDetails(updatedURLs, notUpdatedURLs);
+        }
     }
-    async getEntryCountByQueueName(queueName) {
-        const db = await this.getDb();
-        return db.countFromIndex(REQUEST_OBJECT_STORE_NAME, QUEUE_NAME_INDEX, IDBKeyRange.only(queueName));
+    async activate() {
+        const cache = await self.caches.open(this._strategy.cacheName);
+        const currentlyCachedRequests = await cache.keys();
+        const expectedCacheKeys = new Set(this._urlsToCacheKeys.values());
+        const deletedCacheRequests = [];
+        for (const request of currentlyCachedRequests){
+            if (!expectedCacheKeys.has(request.url)) {
+                await cache.delete(request);
+                deletedCacheRequests.push(request.url);
+            }
+        }
+        if (process.env.NODE_ENV !== "production") {
+            printCleanupDetails(deletedCacheRequests);
+        }
     }
-    async deleteEntry(id) {
-        const db = await this.getDb();
-        await db.delete(REQUEST_OBJECT_STORE_NAME, id);
+    getUrlsToPrecacheKeys() {
+        return this._urlsToCacheKeys;
     }
-    async getFirstEntryByQueueName(queueName) {
-        return await this.getEndEntryFromIndex(IDBKeyRange.only(queueName), "next");
+    getPrecachedUrls() {
+        return [
+            ...this._urlsToCacheKeys.keys()
+        ];
     }
-    async getLastEntryByQueueName(queueName) {
-        return await this.getEndEntryFromIndex(IDBKeyRange.only(queueName), "prev");
+    getPrecacheKeyForUrl(url) {
+        const urlObject = new URL(url, location.href);
+        return this._urlsToCacheKeys.get(urlObject.href);
     }
-    async getEndEntryFromIndex(query, direction) {
-        const db = await this.getDb();
-        const cursor = await db.transaction(REQUEST_OBJECT_STORE_NAME).store.index(QUEUE_NAME_INDEX).openCursor(query, direction);
-        return cursor?.value;
+    getIntegrityForPrecacheKey(cacheKey) {
+        return this._cacheKeysToIntegrities.get(cacheKey);
     }
-    async getDb() {
-        if (!this._db) {
-            this._db = await openDB(BACKGROUND_SYNC_DB_NAME, BACKGROUND_SYNC_DB_VERSION, {
-                upgrade: this._upgradeDb
-            });
+    async matchPrecache(request) {
+        const url = request instanceof Request ? request.url : request;
+        const cacheKey = this.getPrecacheKeyForUrl(url);
+        if (cacheKey) {
+            const cache = await self.caches.open(this._strategy.cacheName);
+            return cache.match(cacheKey);
         }
-        return this._db;
+        return undefined;
     }
-    _upgradeDb(db, oldVersion) {
-        if (oldVersion > 0 && oldVersion < BACKGROUND_SYNC_DB_VERSION) {
-            if (db.objectStoreNames.contains(REQUEST_OBJECT_STORE_NAME)) {
-                db.deleteObjectStore(REQUEST_OBJECT_STORE_NAME);
-            }
+    createHandlerBoundToUrl(url) {
+        const cacheKey = this.getPrecacheKeyForUrl(url);
+        if (!cacheKey) {
+            throw new SerwistError("non-precached-url", {
+                url
+            });
         }
-        const objStore = db.createObjectStore(REQUEST_OBJECT_STORE_NAME, {
-            autoIncrement: true,
-            keyPath: "id"
-        });
-        objStore.createIndex(QUEUE_NAME_INDEX, QUEUE_NAME_INDEX, {
-            unique: false
-        });
+        return (options)=>{
+            options.request = new Request(url);
+            options.params = {
+                cacheKey,
+                ...options.params
+            };
+            return this._strategy.handle(options);
+        };
     }
 }
 
-class BackgroundSyncQueueStore {
-    _queueName;
-    _queueDb;
+class PrecacheFallbackPlugin {
+    _fallbackUrls;
+    _precacheController;
+    constructor({ fallbackUrls, precacheController, serwist }){
+        this._fallbackUrls = fallbackUrls;
+        if (!serwist) {
+            this._precacheController = precacheController;
+        } else {
+            this._precacheController = serwist.precache;
+        }
+    }
+    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;
+    }
+}
+
+class RuntimeCacheController {
+    _entries;
+    _options;
+    constructor(entries, options = {}){
+        this._entries = entries;
+        this._options = options;
+        this.init = this.init.bind(this);
+        this.install = this.install.bind(this);
+    }
+    init({ serwist }) {
+        if (this._options.fallbacks !== undefined) {
+            const fallbackPlugin = new PrecacheFallbackPlugin({
+                fallbackUrls: this._options.fallbacks.entries,
+                precacheController: serwist.precache
+            });
+            this._entries.forEach((cacheEntry)=>{
+                if (cacheEntry.handler instanceof Strategy && !cacheEntry.handler.plugins.some((plugin)=>"handlerDidError" in plugin)) {
+                    cacheEntry.handler.plugins.push(fallbackPlugin);
+                }
+            });
+        }
+        for (const entry of this._entries){
+            serwist.registerCapture(entry.matcher, entry.handler, entry.method);
+        }
+    }
+    async install({ event, serwist }) {
+        const concurrency = this._options.warmOptions?.concurrency ?? 10;
+        if (this._options.warmEntries) {
+            await parallel(concurrency, this._options.warmEntries, async (entry)=>{
+                const request = entry instanceof Request ? entry : new Request(typeof entry === "string" ? entry : entry.url, {
+                    integrity: typeof entry !== "string" ? entry.integrity : undefined,
+                    credentials: "same-origin"
+                });
+                await serwist.handleRequest({
+                    request,
+                    event
+                });
+            });
+        }
+    }
+    warmRuntimeCache(entries) {
+        if (!this._options.warmEntries) this._options.warmEntries = [];
+        this._options.warmEntries.push(...entries);
+    }
+}
+
+const BACKGROUND_SYNC_DB_VERSION = 3;
+const BACKGROUND_SYNC_DB_NAME = "serwist-background-sync";
+const REQUEST_OBJECT_STORE_NAME = "requests";
+const QUEUE_NAME_INDEX = "queueName";
+class BackgroundSyncQueueDb {
+    _db = null;
+    async addEntry(entry) {
+        const db = await this.getDb();
+        const tx = db.transaction(REQUEST_OBJECT_STORE_NAME, "readwrite", {
+            durability: "relaxed"
+        });
+        await tx.store.add(entry);
+        await tx.done;
+    }
+    async getFirstEntryId() {
+        const db = await this.getDb();
+        const cursor = await db.transaction(REQUEST_OBJECT_STORE_NAME).store.openCursor();
+        return cursor?.value.id;
+    }
+    async getAllEntriesByQueueName(queueName) {
+        const db = await this.getDb();
+        const results = await db.getAllFromIndex(REQUEST_OBJECT_STORE_NAME, QUEUE_NAME_INDEX, IDBKeyRange.only(queueName));
+        return results ? results : new Array();
+    }
+    async getEntryCountByQueueName(queueName) {
+        const db = await this.getDb();
+        return db.countFromIndex(REQUEST_OBJECT_STORE_NAME, QUEUE_NAME_INDEX, IDBKeyRange.only(queueName));
+    }
+    async deleteEntry(id) {
+        const db = await this.getDb();
+        await db.delete(REQUEST_OBJECT_STORE_NAME, id);
+    }
+    async getFirstEntryByQueueName(queueName) {
+        return await this.getEndEntryFromIndex(IDBKeyRange.only(queueName), "next");
+    }
+    async getLastEntryByQueueName(queueName) {
+        return await this.getEndEntryFromIndex(IDBKeyRange.only(queueName), "prev");
+    }
+    async getEndEntryFromIndex(query, direction) {
+        const db = await this.getDb();
+        const cursor = await db.transaction(REQUEST_OBJECT_STORE_NAME).store.index(QUEUE_NAME_INDEX).openCursor(query, direction);
+        return cursor?.value;
+    }
+    async getDb() {
+        if (!this._db) {
+            this._db = await openDB(BACKGROUND_SYNC_DB_NAME, BACKGROUND_SYNC_DB_VERSION, {
+                upgrade: this._upgradeDb
+            });
+        }
+        return this._db;
+    }
+    _upgradeDb(db, oldVersion) {
+        if (oldVersion > 0 && oldVersion < BACKGROUND_SYNC_DB_VERSION) {
+            if (db.objectStoreNames.contains(REQUEST_OBJECT_STORE_NAME)) {
+                db.deleteObjectStore(REQUEST_OBJECT_STORE_NAME);
+            }
+        }
+        const objStore = db.createObjectStore(REQUEST_OBJECT_STORE_NAME, {
+            autoIncrement: true,
+            keyPath: "id"
+        });
+        objStore.createIndex(QUEUE_NAME_INDEX, QUEUE_NAME_INDEX, {
+            unique: false
+        });
+    }
+}
+
+class BackgroundSyncQueueStore {
+    _queueName;
+    _queueDb;
     constructor(queueName){
         this._queueName = queueName;
         this._queueDb = new BackgroundSyncQueueDb();
@@ -1456,515 +1560,413 @@ class BackgroundSyncPlugin {
     }
 }
 
-const QUEUE_NAME = "serwist-google-analytics";
-const MAX_RETENTION_TIME = 60 * 48;
-const GOOGLE_ANALYTICS_HOST = "www.google-analytics.com";
-const GTM_HOST = "www.googletagmanager.com";
-const ANALYTICS_JS_PATH = "/analytics.js";
-const GTAG_JS_PATH = "/gtag/js";
-const GTM_JS_PATH = "/gtm.js";
-const COLLECT_PATHS_REGEX = /^\/(\w+\/)?collect/;
-
-const createOnSyncCallback = (config)=>{
-    return async ({ queue })=>{
-        let entry = undefined;
-        while(entry = await queue.shiftRequest()){
-            const { request, timestamp } = entry;
-            const url = new URL(request.url);
-            try {
-                const params = request.method === "POST" ? new URLSearchParams(await request.clone().text()) : url.searchParams;
-                const originalHitTime = timestamp - (Number(params.get("qt")) || 0);
-                const queueTime = Date.now() - originalHitTime;
-                params.set("qt", String(queueTime));
-                if (config.parameterOverrides) {
-                    for (const param of Object.keys(config.parameterOverrides)){
-                        const value = config.parameterOverrides[param];
-                        params.set(param, value);
-                    }
-                }
-                if (typeof config.hitFilter === "function") {
-                    config.hitFilter.call(null, params);
-                }
-                await fetch(new Request(url.origin + url.pathname, {
-                    body: params.toString(),
-                    method: "POST",
-                    mode: "cors",
-                    credentials: "omit",
-                    headers: {
-                        "Content-Type": "text/plain"
-                    }
-                }));
-                if (process.env.NODE_ENV !== "production") {
-                    logger.log(`Request for '${getFriendlyURL(url.href)}' has been replayed`);
-                }
-            } catch (err) {
-                await queue.unshiftRequest(entry);
-                if (process.env.NODE_ENV !== "production") {
-                    logger.log(`Request for '${getFriendlyURL(url.href)}' failed to replay, putting it back in the queue.`);
-                }
-                throw err;
-            }
-        }
-        if (process.env.NODE_ENV !== "production") {
-            logger.log("All Google Analytics request successfully replayed; " + "the queue is now empty!");
+const cacheOkAndOpaquePlugin = {
+    cacheWillUpdate: async ({ response })=>{
+        if (response.status === 200 || response.status === 0) {
+            return response;
         }
-    };
-};
-const createCollectRoutes = (bgSyncPlugin)=>{
-    const match = ({ url })=>url.hostname === GOOGLE_ANALYTICS_HOST && COLLECT_PATHS_REGEX.test(url.pathname);
-    const handler = new NetworkOnly({
-        plugins: [
-            bgSyncPlugin
-        ]
-    });
-    return [
-        new Route(match, handler, "GET"),
-        new Route(match, handler, "POST")
-    ];
-};
-const createAnalyticsJsRoute = (cacheName)=>{
-    const match = ({ url })=>url.hostname === GOOGLE_ANALYTICS_HOST && url.pathname === ANALYTICS_JS_PATH;
-    const handler = new NetworkFirst({
-        cacheName
-    });
-    return new Route(match, handler, "GET");
-};
-const createGtagJsRoute = (cacheName)=>{
-    const match = ({ url })=>url.hostname === GTM_HOST && url.pathname === GTAG_JS_PATH;
-    const handler = new NetworkFirst({
-        cacheName
-    });
-    return new Route(match, handler, "GET");
-};
-const createGtmJsRoute = (cacheName)=>{
-    const match = ({ url })=>url.hostname === GTM_HOST && url.pathname === GTM_JS_PATH;
-    const handler = new NetworkFirst({
-        cacheName
-    });
-    return new Route(match, handler, "GET");
-};
-const initializeGoogleAnalytics = ({ serwist, cacheName, ...options })=>{
-    const resolvedCacheName = cacheNames$1.getGoogleAnalyticsName(cacheName);
-    const bgSyncPlugin = new BackgroundSyncPlugin(QUEUE_NAME, {
-        maxRetentionTime: MAX_RETENTION_TIME,
-        onSync: createOnSyncCallback(options)
-    });
-    const routes = [
-        createGtmJsRoute(resolvedCacheName),
-        createAnalyticsJsRoute(resolvedCacheName),
-        createGtagJsRoute(resolvedCacheName),
-        ...createCollectRoutes(bgSyncPlugin)
-    ];
-    for (const route of routes){
-        serwist.registerRoute(route);
+        return null;
     }
 };
 
-const isNavigationPreloadSupported = ()=>{
-    return Boolean(self.registration?.navigationPreload);
+const messages = {
+    strategyStart: (strategyName, request)=>`Using ${strategyName} to respond to '${getFriendlyURL(request.url)}'`,
+    printFinalResponse: (response)=>{
+        if (response) {
+            logger.groupCollapsed("View the final response here.");
+            logger.log(response || "[No response returned]");
+            logger.groupEnd();
+        }
+    }
 };
-const enableNavigationPreload = (headerValue)=>{
-    if (isNavigationPreloadSupported()) {
-        self.addEventListener("activate", (event)=>{
-            event.waitUntil(self.registration.navigationPreload.enable().then(()=>{
-                if (headerValue) {
-                    void self.registration.navigationPreload.setHeaderValue(headerValue);
-                }
-                if (process.env.NODE_ENV !== "production") {
-                    logger.log("Navigation preloading is enabled.");
-                }
-            }));
-        });
-    } else {
-        if (process.env.NODE_ENV !== "production") {
-            logger.log("Navigation preloading is not supported in this browser.");
+
+class NetworkFirst extends Strategy {
+    _networkTimeoutSeconds;
+    constructor(options = {}){
+        super(options);
+        if (!this.plugins.some((p)=>"cacheWillUpdate" in p)) {
+            this.plugins.unshift(cacheOkAndOpaquePlugin);
         }
-    }
-};
-const disableNavigationPreload = ()=>{
-    if (isNavigationPreloadSupported()) {
-        self.addEventListener("activate", (event)=>{
-            event.waitUntil(self.registration.navigationPreload.disable().then(()=>{
-                if (process.env.NODE_ENV !== "production") {
-                    logger.log("Navigation preloading is disabled.");
-                }
-            }));
-        });
-    } else {
+        this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;
         if (process.env.NODE_ENV !== "production") {
-            logger.log("Navigation preloading is not supported in this browser.");
+            if (this._networkTimeoutSeconds) {
+                finalAssertExports.isType(this._networkTimeoutSeconds, "number", {
+                    moduleName: "serwist",
+                    className: this.constructor.name,
+                    funcName: "constructor",
+                    paramName: "networkTimeoutSeconds"
+                });
+            }
         }
     }
-};
-
-const setCacheNameDetails = (details)=>{
-    if (process.env.NODE_ENV !== "production") {
-        for (const key of Object.keys(details)){
-            finalAssertExports.isType(details[key], "string", {
-                moduleName: "@serwist/core",
-                funcName: "setCacheNameDetails",
-                paramName: `details.${key}`
+    async _handle(request, handler) {
+        const logs = [];
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isInstance(request, Request, {
+                moduleName: "serwist",
+                className: this.constructor.name,
+                funcName: "handle",
+                paramName: "makeRequest"
             });
         }
-        if (details.precache?.length === 0) {
-            throw new SerwistError("invalid-cache-name", {
-                cacheNameId: "precache",
-                value: details.precache
+        const promises = [];
+        let timeoutId;
+        if (this._networkTimeoutSeconds) {
+            const { id, promise } = this._getTimeoutPromise({
+                request,
+                logs,
+                handler
             });
+            timeoutId = id;
+            promises.push(promise);
         }
-        if (details.runtime?.length === 0) {
-            throw new SerwistError("invalid-cache-name", {
-                cacheNameId: "runtime",
-                value: details.runtime
-            });
+        const networkPromise = this._getNetworkPromise({
+            timeoutId,
+            request,
+            logs,
+            handler
+        });
+        promises.push(networkPromise);
+        const response = await handler.waitUntil((async ()=>{
+            return await handler.waitUntil(Promise.race(promises)) || await networkPromise;
+        })());
+        if (process.env.NODE_ENV !== "production") {
+            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
+            for (const log of logs){
+                logger.log(log);
+            }
+            messages.printFinalResponse(response);
+            logger.groupEnd();
         }
-        if (details.googleAnalytics?.length === 0) {
-            throw new SerwistError("invalid-cache-name", {
-                cacheNameId: "googleAnalytics",
-                value: details.googleAnalytics
+        if (!response) {
+            throw new SerwistError("no-response", {
+                url: request.url
             });
         }
+        return response;
     }
-    cacheNames$1.updateDetails(details);
-};
-
-const parseRoute = (capture, handler, method)=>{
-    if (typeof capture === "string") {
-        const captureUrl = new URL(capture, location.href);
-        if (process.env.NODE_ENV !== "production") {
-            if (!(capture.startsWith("/") || capture.startsWith("http"))) {
-                throw new SerwistError("invalid-string", {
-                    moduleName: "serwist",
-                    funcName: "parseRoute",
-                    paramName: "capture"
-                });
-            }
-            const valueToCheck = capture.startsWith("http") ? captureUrl.pathname : capture;
-            const wildcards = "[*:?+]";
-            if (new RegExp(`${wildcards}`).exec(valueToCheck)) {
-                logger.debug(`The '$capture' parameter contains an Express-style wildcard character (${wildcards}). Strings are now always interpreted as exact matches; use a RegExp for partial or wildcard matches.`);
-            }
-        }
-        const matchCallback = ({ url })=>{
-            if (process.env.NODE_ENV !== "production") {
-                if (url.pathname === captureUrl.pathname && url.origin !== captureUrl.origin) {
-                    logger.debug(`${capture} only partially matches the cross-origin URL ${url.toString()}. This route will only handle cross-origin requests if they match the entire URL.`);
+    _getTimeoutPromise({ request, logs, handler }) {
+        let timeoutId;
+        const timeoutPromise = new Promise((resolve)=>{
+            const onNetworkTimeout = async ()=>{
+                if (process.env.NODE_ENV !== "production") {
+                    logs.push(`Timing out the network response at ${this._networkTimeoutSeconds} seconds.`);
                 }
-            }
-            return url.href === captureUrl.href;
-        };
-        return new Route(matchCallback, handler, method);
-    }
-    if (capture instanceof RegExp) {
-        return new RegExpRoute(capture, handler, method);
-    }
-    if (typeof capture === "function") {
-        return new Route(capture, handler, method);
-    }
-    if (capture instanceof Route) {
-        return capture;
-    }
-    throw new SerwistError("unsupported-route-type", {
-        moduleName: "serwist",
-        funcName: "parseRoute",
-        paramName: "capture"
-    });
-};
-
-const REVISION_SEARCH_PARAM = "__WB_REVISION__";
-const createCacheKey = (entry)=>{
-    if (!entry) {
-        throw new SerwistError("add-to-cache-list-unexpected-type", {
-            entry
-        });
-    }
-    if (typeof entry === "string") {
-        const urlObject = new URL(entry, location.href);
-        return {
-            cacheKey: urlObject.href,
-            url: urlObject.href
-        };
-    }
-    const { revision, url } = entry;
-    if (!url) {
-        throw new SerwistError("add-to-cache-list-unexpected-type", {
-            entry
+                resolve(await handler.cacheMatch(request));
+            };
+            timeoutId = setTimeout(onNetworkTimeout, this._networkTimeoutSeconds * 1000);
         });
-    }
-    if (!revision) {
-        const urlObject = new URL(url, location.href);
         return {
-            cacheKey: urlObject.href,
-            url: urlObject.href
+            promise: timeoutPromise,
+            id: timeoutId
         };
     }
-    const cacheKeyURL = new URL(url, location.href);
-    const originalURL = new URL(url, location.href);
-    cacheKeyURL.searchParams.set(REVISION_SEARCH_PARAM, revision);
-    return {
-        cacheKey: cacheKeyURL.href,
-        url: originalURL.href
-    };
-};
-
-class PrecacheInstallReportPlugin {
-    updatedURLs = [];
-    notUpdatedURLs = [];
-    handlerWillStart = async ({ request, state })=>{
-        if (state) {
-            state.originalRequest = request;
+    async _getNetworkPromise({ timeoutId, request, logs, handler }) {
+        let error = undefined;
+        let response = undefined;
+        try {
+            response = await handler.fetchAndCachePut(request);
+        } catch (fetchError) {
+            if (fetchError instanceof Error) {
+                error = fetchError;
+            }
         }
-    };
-    cachedResponseWillBeUsed = async ({ event, state, cachedResponse })=>{
-        if (event.type === "install") {
-            if (state?.originalRequest && state.originalRequest instanceof Request) {
-                const url = state.originalRequest.url;
-                if (cachedResponse) {
-                    this.notUpdatedURLs.push(url);
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        if (process.env.NODE_ENV !== "production") {
+            if (response) {
+                logs.push("Got response from network.");
+            } else {
+                logs.push("Unable to get a response from the network. Will respond " + "with a cached response.");
+            }
+        }
+        if (error || !response) {
+            response = await handler.cacheMatch(request);
+            if (process.env.NODE_ENV !== "production") {
+                if (response) {
+                    logs.push(`Found a cached response in the '${this.cacheName}' cache.`);
                 } else {
-                    this.updatedURLs.push(url);
+                    logs.push(`No response found in the '${this.cacheName}' cache.`);
                 }
             }
         }
-        return cachedResponse;
-    };
+        return response;
+    }
 }
 
-function _nestedGroup(groupTitle, urls) {
-    if (urls.length === 0) {
-        return;
+class NetworkOnly extends Strategy {
+    _networkTimeoutSeconds;
+    constructor(options = {}){
+        super(options);
+        this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;
     }
-    logger.groupCollapsed(groupTitle);
-    for (const url of urls){
-        logger.log(url);
+    async _handle(request, handler) {
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isInstance(request, Request, {
+                moduleName: "serwist",
+                className: this.constructor.name,
+                funcName: "_handle",
+                paramName: "request"
+            });
+        }
+        let error = undefined;
+        let response;
+        try {
+            const promises = [
+                handler.fetch(request)
+            ];
+            if (this._networkTimeoutSeconds) {
+                const timeoutPromise = timeout(this._networkTimeoutSeconds * 1000);
+                promises.push(timeoutPromise);
+            }
+            response = await Promise.race(promises);
+            if (!response) {
+                throw new Error(`Timed out the network response after ${this._networkTimeoutSeconds} seconds.`);
+            }
+        } catch (err) {
+            if (err instanceof Error) {
+                error = err;
+            }
+        }
+        if (process.env.NODE_ENV !== "production") {
+            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
+            if (response) {
+                logger.log("Got response from network.");
+            } else {
+                logger.log("Unable to get a response from the network.");
+            }
+            messages.printFinalResponse(response);
+            logger.groupEnd();
+        }
+        if (!response) {
+            throw new SerwistError("no-response", {
+                url: request.url,
+                error
+            });
+        }
+        return response;
     }
-    logger.groupEnd();
 }
-const printInstallDetails = (urlsToPrecache, urlsAlreadyPrecached)=>{
-    const precachedCount = urlsToPrecache.length;
-    const alreadyPrecachedCount = urlsAlreadyPrecached.length;
-    if (precachedCount || alreadyPrecachedCount) {
-        let message = `Precaching ${precachedCount} file${precachedCount === 1 ? "" : "s"}.`;
-        if (alreadyPrecachedCount > 0) {
-            message += ` ${alreadyPrecachedCount} ` + `file${alreadyPrecachedCount === 1 ? " is" : "s are"} already cached.`;
+
+const QUEUE_NAME = "serwist-google-analytics";
+const MAX_RETENTION_TIME = 60 * 48;
+const GOOGLE_ANALYTICS_HOST = "www.google-analytics.com";
+const GTM_HOST = "www.googletagmanager.com";
+const ANALYTICS_JS_PATH = "/analytics.js";
+const GTAG_JS_PATH = "/gtag/js";
+const GTM_JS_PATH = "/gtm.js";
+const COLLECT_PATHS_REGEX = /^\/(\w+\/)?collect/;
+
+const createOnSyncCallback = (config)=>{
+    return async ({ queue })=>{
+        let entry = undefined;
+        while(entry = await queue.shiftRequest()){
+            const { request, timestamp } = entry;
+            const url = new URL(request.url);
+            try {
+                const params = request.method === "POST" ? new URLSearchParams(await request.clone().text()) : url.searchParams;
+                const originalHitTime = timestamp - (Number(params.get("qt")) || 0);
+                const queueTime = Date.now() - originalHitTime;
+                params.set("qt", String(queueTime));
+                if (config.parameterOverrides) {
+                    for (const param of Object.keys(config.parameterOverrides)){
+                        const value = config.parameterOverrides[param];
+                        params.set(param, value);
+                    }
+                }
+                if (typeof config.hitFilter === "function") {
+                    config.hitFilter.call(null, params);
+                }
+                await fetch(new Request(url.origin + url.pathname, {
+                    body: params.toString(),
+                    method: "POST",
+                    mode: "cors",
+                    credentials: "omit",
+                    headers: {
+                        "Content-Type": "text/plain"
+                    }
+                }));
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log(`Request for '${getFriendlyURL(url.href)}' has been replayed`);
+                }
+            } catch (err) {
+                await queue.unshiftRequest(entry);
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log(`Request for '${getFriendlyURL(url.href)}' failed to replay, putting it back in the queue.`);
+                }
+                throw err;
+            }
         }
-        logger.groupCollapsed(message);
-        _nestedGroup("View newly precached URLs.", urlsToPrecache);
-        _nestedGroup("View previously precached URLs.", urlsAlreadyPrecached);
-        logger.groupEnd();
-    }
+        if (process.env.NODE_ENV !== "production") {
+            logger.log("All Google Analytics request successfully replayed; " + "the queue is now empty!");
+        }
+    };
 };
-
-const logGroup = (groupTitle, deletedURLs)=>{
-    logger.groupCollapsed(groupTitle);
-    for (const url of deletedURLs){
-        logger.log(url);
-    }
-    logger.groupEnd();
+const createCollectRoutes = (bgSyncPlugin)=>{
+    const match = ({ url })=>url.hostname === GOOGLE_ANALYTICS_HOST && COLLECT_PATHS_REGEX.test(url.pathname);
+    const handler = new NetworkOnly({
+        plugins: [
+            bgSyncPlugin
+        ]
+    });
+    return [
+        new Route(match, handler, "GET"),
+        new Route(match, handler, "POST")
+    ];
 };
-const printCleanupDetails = (deletedURLs)=>{
-    const deletionCount = deletedURLs.length;
-    if (deletionCount > 0) {
-        logger.groupCollapsed(`During precaching cleanup, ${deletionCount} cached request${deletionCount === 1 ? " was" : "s were"} deleted.`);
-        logGroup("Deleted Cache Requests", deletedURLs);
-        logger.groupEnd();
-    }
+const createAnalyticsJsRoute = (cacheName)=>{
+    const match = ({ url })=>url.hostname === GOOGLE_ANALYTICS_HOST && url.pathname === ANALYTICS_JS_PATH;
+    const handler = new NetworkFirst({
+        cacheName
+    });
+    return new Route(match, handler, "GET");
 };
-
-class PrecacheCacheKeyPlugin {
-    _precacheController;
-    constructor({ precacheController }){
-        this._precacheController = precacheController;
-    }
-    cacheKeyWillBeUsed = async ({ request, params })=>{
-        const cacheKey = params?.cacheKey || this._precacheController.getPrecacheKeyForUrl(request.url);
-        return cacheKey ? new Request(cacheKey, {
-            headers: request.headers
-        }) : request;
-    };
-}
-
-const parsePrecacheOptions = (controller, { cacheName, plugins, fetchOptions, matchOptions, fallbackToNetwork, directoryIndex, ignoreURLParametersMatching, cleanURLs, urlManipulation, cleanupOutdatedCaches, concurrency, navigateFallback, navigateFallbackAllowlist, navigateFallbackDenylist } = {})=>({
-        strategyOptions: {
-            cacheName: cacheNames$1.getPrecacheName(cacheName),
-            plugins: [
-                ...plugins ?? [],
-                new PrecacheCacheKeyPlugin({
-                    precacheController: controller
-                })
-            ],
-            fetchOptions,
-            matchOptions,
-            fallbackToNetwork
-        },
-        routeOptions: {
-            directoryIndex,
-            ignoreURLParametersMatching,
-            cleanURLs,
-            urlManipulation
-        },
-        controllerOptions: {
-            cleanupOutdatedCaches,
-            concurrency: concurrency ?? 10,
-            navigateFallback,
-            navigateFallbackAllowlist,
-            navigateFallbackDenylist
-        }
+const createGtagJsRoute = (cacheName)=>{
+    const match = ({ url })=>url.hostname === GTM_HOST && url.pathname === GTAG_JS_PATH;
+    const handler = new NetworkFirst({
+        cacheName
     });
-
-class PrecacheController {
-    _urlsToCacheKeys = new Map();
-    _urlsToCacheModes = new Map();
-    _cacheKeysToIntegrities = new Map();
-    _strategy;
-    _options;
-    _routeOptions;
-    constructor(entries, precacheOptions){
-        const { strategyOptions, routeOptions, controllerOptions } = parsePrecacheOptions(this, precacheOptions);
-        this.addToCacheList(entries);
-        this._strategy = new PrecacheStrategy(strategyOptions);
-        this._options = controllerOptions;
-        this._routeOptions = routeOptions;
-        this.install = this.install.bind(this);
-        this.activate = this.activate.bind(this);
-    }
-    get strategy() {
-        return this._strategy;
+    return new Route(match, handler, "GET");
+};
+const createGtmJsRoute = (cacheName)=>{
+    const match = ({ url })=>url.hostname === GTM_HOST && url.pathname === GTM_JS_PATH;
+    const handler = new NetworkFirst({
+        cacheName
+    });
+    return new Route(match, handler, "GET");
+};
+const initializeGoogleAnalytics = ({ serwist, cacheName, ...options })=>{
+    const resolvedCacheName = cacheNames$1.getGoogleAnalyticsName(cacheName);
+    const bgSyncPlugin = new BackgroundSyncPlugin(QUEUE_NAME, {
+        maxRetentionTime: MAX_RETENTION_TIME,
+        onSync: createOnSyncCallback(options)
+    });
+    const routes = [
+        createGtmJsRoute(resolvedCacheName),
+        createAnalyticsJsRoute(resolvedCacheName),
+        createGtagJsRoute(resolvedCacheName),
+        ...createCollectRoutes(bgSyncPlugin)
+    ];
+    for (const route of routes){
+        serwist.registerRoute(route);
     }
-    addToCacheList(entries) {
+};
+
+const parseRoute = (capture, handler, method)=>{
+    if (typeof capture === "string") {
+        const captureUrl = new URL(capture, location.href);
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isArray(entries, {
-                moduleName: "serwist",
-                className: "PrecacheController",
-                funcName: "addEntries",
-                paramName: "entries"
-            });
-        }
-        const urlsToWarnAbout = [];
-        for (const entry of entries){
-            if (typeof entry === "string") {
-                urlsToWarnAbout.push(entry);
-            } else if (entry && !entry.integrity && entry.revision === undefined) {
-                urlsToWarnAbout.push(entry.url);
-            }
-            const { cacheKey, url } = createCacheKey(entry);
-            const cacheMode = typeof entry !== "string" && entry.revision ? "reload" : "default";
-            if (this._urlsToCacheKeys.has(url) && this._urlsToCacheKeys.get(url) !== cacheKey) {
-                throw new SerwistError("add-to-cache-list-conflicting-entries", {
-                    firstEntry: this._urlsToCacheKeys.get(url),
-                    secondEntry: cacheKey
+            if (!(capture.startsWith("/") || capture.startsWith("http"))) {
+                throw new SerwistError("invalid-string", {
+                    moduleName: "serwist",
+                    funcName: "parseRoute",
+                    paramName: "capture"
                 });
             }
-            if (typeof entry !== "string" && entry.integrity) {
-                if (this._cacheKeysToIntegrities.has(cacheKey) && this._cacheKeysToIntegrities.get(cacheKey) !== entry.integrity) {
-                    throw new SerwistError("add-to-cache-list-conflicting-integrities", {
-                        url
-                    });
-                }
-                this._cacheKeysToIntegrities.set(cacheKey, entry.integrity);
+            const valueToCheck = capture.startsWith("http") ? captureUrl.pathname : capture;
+            const wildcards = "[*:?+]";
+            if (new RegExp(`${wildcards}`).exec(valueToCheck)) {
+                logger.debug(`The '$capture' parameter contains an Express-style wildcard character (${wildcards}). Strings are now always interpreted as exact matches; use a RegExp for partial or wildcard matches.`);
             }
-            this._urlsToCacheKeys.set(url, cacheKey);
-            this._urlsToCacheModes.set(url, cacheMode);
-            if (urlsToWarnAbout.length > 0) {
-                const warningMessage = `Serwist is precaching URLs without revision info: ${urlsToWarnAbout.join(", ")}\nThis is generally NOT safe, as you risk serving outdated assets.`;
-                if (process.env.NODE_ENV === "production") {
-                    console.warn(warningMessage);
-                } else {
-                    logger.warn(warningMessage);
+        }
+        const matchCallback = ({ url })=>{
+            if (process.env.NODE_ENV !== "production") {
+                if (url.pathname === captureUrl.pathname && url.origin !== captureUrl.origin) {
+                    logger.debug(`${capture} only partially matches the cross-origin URL ${url.toString()}. This route will only handle cross-origin requests if they match the entire URL.`);
                 }
             }
-        }
+            return url.href === captureUrl.href;
+        };
+        return new Route(matchCallback, handler, method);
     }
-    init(serwist) {
-        serwist.registerRoute(new PrecacheRoute(this, this._routeOptions));
-        if (this._options.navigateFallback) {
-            serwist.registerRoute(new NavigationRoute(this.createHandlerBoundToUrl(this._options.navigateFallback), {
-                allowlist: this._options.navigateFallbackAllowlist,
-                denylist: this._options.navigateFallbackDenylist
+    if (capture instanceof RegExp) {
+        return new RegExpRoute(capture, handler, method);
+    }
+    if (typeof capture === "function") {
+        return new Route(capture, handler, method);
+    }
+    if (capture instanceof Route) {
+        return capture;
+    }
+    throw new SerwistError("unsupported-route-type", {
+        moduleName: "serwist",
+        funcName: "parseRoute",
+        paramName: "capture"
+    });
+};
+
+const disableDevLogs = ()=>{
+    self.__WB_DISABLE_DEV_LOGS = true;
+};
+
+const isNavigationPreloadSupported = ()=>{
+    return Boolean(self.registration?.navigationPreload);
+};
+const enableNavigationPreload = (headerValue)=>{
+    if (isNavigationPreloadSupported()) {
+        self.addEventListener("activate", (event)=>{
+            event.waitUntil(self.registration.navigationPreload.enable().then(()=>{
+                if (headerValue) {
+                    void self.registration.navigationPreload.setHeaderValue(headerValue);
+                }
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log("Navigation preloading is enabled.");
+                }
             }));
+        });
+    } else {
+        if (process.env.NODE_ENV !== "production") {
+            logger.log("Navigation preloading is not supported in this browser.");
         }
     }
-    async install(event) {
-        const installReportPlugin = new PrecacheInstallReportPlugin();
-        this._strategy.plugins.push(installReportPlugin);
-        await parallel(this._options.concurrency, 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, {
-                integrity,
-                cache: cacheMode,
-                credentials: "same-origin"
-            });
-            await Promise.all(this._strategy.handleAll({
-                event,
-                request,
-                url: new URL(request.url),
-                params: {
-                    cacheKey
+};
+const disableNavigationPreload = ()=>{
+    if (isNavigationPreloadSupported()) {
+        self.addEventListener("activate", (event)=>{
+            event.waitUntil(self.registration.navigationPreload.disable().then(()=>{
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log("Navigation preloading is disabled.");
                 }
             }));
         });
-        const { updatedURLs, notUpdatedURLs } = installReportPlugin;
+    } else {
         if (process.env.NODE_ENV !== "production") {
-            printInstallDetails(updatedURLs, notUpdatedURLs);
+            logger.log("Navigation preloading is not supported in this browser.");
         }
     }
-    async activate() {
-        const cache = await self.caches.open(this._strategy.cacheName);
-        const currentlyCachedRequests = await cache.keys();
-        const expectedCacheKeys = new Set(this._urlsToCacheKeys.values());
-        const deletedCacheRequests = [];
-        for (const request of currentlyCachedRequests){
-            if (!expectedCacheKeys.has(request.url)) {
-                await cache.delete(request);
-                deletedCacheRequests.push(request.url);
-            }
+};
+
+const setCacheNameDetails = (details)=>{
+    if (process.env.NODE_ENV !== "production") {
+        for (const key of Object.keys(details)){
+            finalAssertExports.isType(details[key], "string", {
+                moduleName: "@serwist/core",
+                funcName: "setCacheNameDetails",
+                paramName: `details.${key}`
+            });
         }
-        if (process.env.NODE_ENV !== "production") {
-            printCleanupDetails(deletedCacheRequests);
+        if (details.precache?.length === 0) {
+            throw new SerwistError("invalid-cache-name", {
+                cacheNameId: "precache",
+                value: details.precache
+            });
         }
-    }
-    getUrlsToPrecacheKeys() {
-        return this._urlsToCacheKeys;
-    }
-    getPrecachedUrls() {
-        return [
-            ...this._urlsToCacheKeys.keys()
-        ];
-    }
-    getPrecacheKeyForUrl(url) {
-        const urlObject = new URL(url, location.href);
-        return this._urlsToCacheKeys.get(urlObject.href);
-    }
-    getIntegrityForPrecacheKey(cacheKey) {
-        return this._cacheKeysToIntegrities.get(cacheKey);
-    }
-    async matchPrecache(request) {
-        const url = request instanceof Request ? request.url : request;
-        const cacheKey = this.getPrecacheKeyForUrl(url);
-        if (cacheKey) {
-            const cache = await self.caches.open(this._strategy.cacheName);
-            return cache.match(cacheKey);
+        if (details.runtime?.length === 0) {
+            throw new SerwistError("invalid-cache-name", {
+                cacheNameId: "runtime",
+                value: details.runtime
+            });
         }
-        return undefined;
-    }
-    createHandlerBoundToUrl(url) {
-        const cacheKey = this.getPrecacheKeyForUrl(url);
-        if (!cacheKey) {
-            throw new SerwistError("non-precached-url", {
-                url
+        if (details.googleAnalytics?.length === 0) {
+            throw new SerwistError("invalid-cache-name", {
+                cacheNameId: "googleAnalytics",
+                value: details.googleAnalytics
             });
         }
-        return (options)=>{
-            options.request = new Request(url);
-            options.params = {
-                cacheKey,
-                ...options.params
-            };
-            return this._strategy.handle(options);
-        };
     }
-}
+    cacheNames$1.updateDetails(details);
+};
 
 class Serwist {
     _routes;
@@ -2021,7 +2023,9 @@ class Serwist {
             }
         }
         for (const callback of this.iterateControllers("init")){
-            callback(this);
+            callback({
+                serwist: this
+            });
         }
         if (disableDevLogs$1) disableDevLogs();
     }
@@ -2029,7 +2033,10 @@ class Serwist {
         if (!this._controllers) return;
         for (const controller of this._controllers){
             if (typeof controller[name] === "function") {
-                yield controller[name];
+                const callback = (param)=>{
+                    controller[name](param);
+                };
+                yield callback;
             }
         }
     }
@@ -2051,14 +2058,20 @@ class Serwist {
     handleInstall(event) {
         return waitUntil(event, async ()=>{
             for (const callback of this.iterateControllers("install")){
-                await callback(event, this);
+                await callback({
+                    event,
+                    serwist: this
+                });
             }
         });
     }
     handleActivate(event) {
         return waitUntil(event, async ()=>{
             for (const callback of this.iterateControllers("activate")){
-                await callback(event, this);
+                await callback({
+                    event,
+                    serwist: this
+                });
             }
         });
     }
@@ -2346,6 +2359,20 @@ const cacheNames = {
     }
 };
 
+const registerQuotaErrorCallback = (callback)=>{
+    if (process.env.NODE_ENV !== "production") {
+        finalAssertExports.isType(callback, "function", {
+            moduleName: "@serwist/core",
+            funcName: "register",
+            paramName: "callback"
+        });
+    }
+    quotaErrorCallbacks.add(callback);
+    if (process.env.NODE_ENV !== "production") {
+        logger.log("Registered a callback to respond to quota errors.", callback);
+    }
+};
+
 const BROADCAST_UPDATE_MESSAGE_TYPE = "CACHE_UPDATED";
 const BROADCAST_UPDATE_MESSAGE_META = "serwist-broadcast-update";
 const BROADCAST_UPDATE_DEFAULT_NOTIFY = true;
@@ -2747,20 +2774,6 @@ class CacheExpiration {
     }
 }
 
-const registerQuotaErrorCallback = (callback)=>{
-    if (process.env.NODE_ENV !== "production") {
-        finalAssertExports.isType(callback, "function", {
-            moduleName: "@serwist/core",
-            funcName: "register",
-            paramName: "callback"
-        });
-    }
-    quotaErrorCallbacks.add(callback);
-    if (process.env.NODE_ENV !== "production") {
-        logger.log("Registered a callback to respond to quota errors.", callback);
-    }
-};
-
 class ExpirationPlugin {
     _config;
     _cacheExpirations;