serwist 10.0.0-preview.1 → 10.0.0-preview.11

package/dist/index.js

@@ -1,1458 +1,1487 @@
-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 { parallel } from '@serwist/utils';
+import { c as cacheNames$1, l as logger, f as finalAssertExports, S as SerwistError, g as getFriendlyURL, D as Deferred, t as timeout, a as cacheMatchIgnoreParams, e as executeQuotaErrorCallbacks, b as canConstructResponseFromBodyStream, q as quotaErrorCallbacks, w as waitUntil, d as clientsClaim, r as resultingClientExists } from './chunks/waitUntil.js';
 import { openDB, deleteDB } from 'idb';
+import { parallel } from '@serwist/utils';
 
-const copyResponse = async (response, modifier)=>{
-    let origin = null;
-    if (response.url) {
-        const responseURL = new URL(response.url);
-        origin = responseURL.origin;
+const cacheNames = {
+    get googleAnalytics () {
+        return cacheNames$1.getGoogleAnalyticsName();
+    },
+    get precache () {
+        return cacheNames$1.getPrecacheName();
+    },
+    get prefix () {
+        return cacheNames$1.getPrefix();
+    },
+    get runtime () {
+        return cacheNames$1.getRuntimeName();
+    },
+    get suffix () {
+        return cacheNames$1.getSuffix();
     }
-    if (origin !== self.location.origin) {
-        throw new SerwistError("cross-origin-copy-response", {
-            origin
+};
+
+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.");
+        }
+    }
+};
+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 {
+        if (process.env.NODE_ENV !== "production") {
+            logger.log("Navigation preloading is not supported in this browser.");
+        }
     }
-    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);
 };
 
-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){
+const normalizeHandler = (handler)=>{
+    if (handler && typeof handler === "object") {
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isInstance(options.event, ExtendableEvent, {
+            finalAssertExports.hasMethod(handler, "handle", {
                 moduleName: "serwist",
-                className: "StrategyHandler",
+                className: "Route",
                 funcName: "constructor",
-                paramName: "options.event"
+                paramName: "handler"
             });
-            finalAssertExports.isInstance(options.request, Request, {
+        }
+        return handler;
+    }
+    if (process.env.NODE_ENV !== "production") {
+        finalAssertExports.isType(handler, "function", {
+            moduleName: "serwist",
+            className: "Route",
+            funcName: "constructor",
+            paramName: "handler"
+        });
+    }
+    return {
+        handle: handler
+    };
+};
+
+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: "StrategyHandler",
+                className: "Route",
                 funcName: "constructor",
-                paramName: "options.request"
+                paramName: "match"
             });
+            if (method) {
+                finalAssertExports.isOneOf(method, validMethods, {
+                    paramName: "method"
+                });
+            }
         }
-        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);
+        this.handler = normalizeHandler(handler);
+        this.match = match;
+        this.method = method;
     }
-    async fetch(input) {
-        const { event } = this;
-        let request = toRequest(input);
-        const preloadResponse = await this.getPreloadResponse();
-        if (preloadResponse) {
-            return preloadResponse;
+    setCatchHandler(handler) {
+        this.catchHandler = normalizeHandler(handler);
+    }
+}
+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"
+            });
         }
-        const originalRequest = this.hasCallback("fetchDidFail") ? request.clone() : null;
-        try {
-            for (const cb of this.iterateCallbacks("requestWillFetch")){
-                request = await cb({
-                    request: request.clone(),
-                    event
-                });
+        const match = ({ url })=>{
+            const result = regExp.exec(url.href);
+            if (!result) {
+                return;
             }
-        } catch (err) {
-            if (err instanceof Error) {
-                throw new SerwistError("plugin-error-request-will-fetch", {
-                    thrownErrorMessage: err.message
-                });
+            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;
             }
+            return result.slice(1);
+        };
+        super(match, handler, method);
+    }
+}
+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"
+            });
         }
-        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
-                });
+        super((options)=>this._match(options), handler);
+        this._allowlist = allowlist;
+        this._denylist = denylist;
+    }
+    _match({ url, request }) {
+        if (request && request.mode !== "navigate") {
+            return false;
+        }
+        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;
             }
-            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()
-                });
-            }
-            throw error;
-        }
-    }
-    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;
-        }
-        return cachedResponse;
-    }
-    async cachePut(key, response) {
-        const request = toRequest(key);
-        await timeout(0);
-        const effectiveRequest = await this.getCacheKey(request, "write");
-        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)
-            });
-        }
-        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") {
-            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.`);
+                logger.debug(`The navigation route ${pathnameAndSearch} is being used.`);
             }
+            return true;
         }
-        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;
-    }
-    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];
-    }
-    hasCallback(name) {
-        for (const plugin of this._strategy.plugins){
-            if (name in plugin) {
-                return true;
-            }
+            logger.log(`The navigation route ${pathnameAndSearch} is not being used, since the URL being navigated to doesn't match the allowlist.`);
         }
         return false;
     }
-    async runCallbacks(name, param) {
-        for (const callback of this.iterateCallbacks(name)){
-            await callback(param);
-        }
-    }
-    *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;
-            }
-        }
-    }
-    waitUntil(promise) {
-        this._extendLifetimePromises.push(promise);
-        return promise;
-    }
-    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;
-                }
-            } catch (error) {
-                if (process.env.NODE_ENV !== "production") {
-                    logger.error(error);
-                }
-                return undefined;
-            }
-        }
-        return undefined;
-    }
-    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;
-            }
-        }
-        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;
-            }
-        }
-        return responseToCache;
-    }
 }
 
-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;
-    }
-    handle(options) {
-        const [responseDone] = this.handleAll(options);
-        return responseDone;
-    }
-    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
-        ];
-    }
-    async _getResponse(handler, request, event) {
-        await handler.runCallbacks("handlerWillStart", {
-            event,
-            request
+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"
         });
-        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;
-                    }
-                }
-            }
-            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.`);
-            }
-        }
-        for (const callback of handler.iterateCallbacks("handlerWillRespond")){
-            response = await callback({
-                event,
-                request,
-                response
-            });
-        }
-        return response;
+        await tx.store.add(entry);
+        await tx.done;
     }
-    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
-        });
-        handler.destroy();
-        if (error) {
-            throw error;
-        }
+    async getFirstEntryId() {
+        const db = await this.getDb();
+        const cursor = await db.transaction(REQUEST_OBJECT_STORE_NAME).store.openCursor();
+        return cursor?.value.id;
     }
-}
-
-class PrecacheStrategy extends Strategy {
-    _fallbackToNetwork;
-    static defaultPrecacheCacheabilityPlugin = {
-        async cacheWillUpdate ({ response }) {
-            if (!response || response.status >= 400) {
-                return null;
-            }
-            return response;
-        }
-    };
-    static copyRedirectedCacheableResponsesPlugin = {
-        async cacheWillUpdate ({ response }) {
-            return response.redirected ? await copyResponse(response) : response;
-        }
-    };
-    constructor(options = {}){
-        options.cacheName = cacheNames$1.getPrecacheName(options.cacheName);
-        super(options);
-        this._fallbackToNetwork = options.fallbackToNetwork !== false;
-        this.plugins.push(PrecacheStrategy.copyRedirectedCacheableResponsesPlugin);
+    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 : [];
     }
-    async _handle(request, handler) {
-        const preloadResponse = await handler.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);
-        }
-        return await this._handleFetch(request, handler);
+    async getEntryCountByQueueName(queueName) {
+        const db = await this.getDb();
+        return db.countFromIndex(REQUEST_OBJECT_STORE_NAME, QUEUE_NAME_INDEX, IDBKeyRange.only(queueName));
     }
-    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
-            });
-        }
-        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 response;
+    async deleteEntry(id) {
+        const db = await this.getDb();
+        await db.delete(REQUEST_OBJECT_STORE_NAME, id);
     }
-    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 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 response;
+        return this._db;
     }
-    _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;
-            }
-            if (plugin.cacheWillUpdate) {
-                cacheWillUpdatePluginCount++;
+    _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);
             }
         }
-        if (cacheWillUpdatePluginCount === 0) {
-            this.plugins.push(PrecacheStrategy.defaultPrecacheCacheabilityPlugin);
-        } else if (cacheWillUpdatePluginCount > 1 && defaultPluginIndex !== null) {
-            this.plugins.splice(defaultPluginIndex, 1);
-        }
+        const objStore = db.createObjectStore(REQUEST_OBJECT_STORE_NAME, {
+            autoIncrement: true,
+            keyPath: "id"
+        });
+        objStore.createIndex(QUEUE_NAME_INDEX, QUEUE_NAME_INDEX, {
+            unique: false
+        });
     }
 }
 
-const defaultMethod = "GET";
-const validMethods = [
-    "DELETE",
-    "GET",
-    "HEAD",
-    "PATCH",
-    "POST",
-    "PUT"
-];
-
-const normalizeHandler = (handler)=>{
-    if (handler && typeof handler === "object") {
+class BackgroundSyncQueueStore {
+    _queueName;
+    _queueDb;
+    constructor(queueName){
+        this._queueName = queueName;
+        this._queueDb = new BackgroundSyncQueueDb();
+    }
+    async pushEntry(entry) {
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.hasMethod(handler, "handle", {
+            finalAssertExports.isType(entry, "object", {
                 moduleName: "serwist",
-                className: "Route",
-                funcName: "constructor",
-                paramName: "handler"
+                className: "BackgroundSyncQueueStore",
+                funcName: "pushEntry",
+                paramName: "entry"
+            });
+            finalAssertExports.isType(entry.requestData, "object", {
+                moduleName: "serwist",
+                className: "BackgroundSyncQueueStore",
+                funcName: "pushEntry",
+                paramName: "entry.requestData"
             });
         }
-        return handler;
-    }
-    if (process.env.NODE_ENV !== "production") {
-        finalAssertExports.isType(handler, "function", {
-            moduleName: "serwist",
-            className: "Route",
-            funcName: "constructor",
-            paramName: "handler"
-        });
+        delete entry.id;
+        entry.queueName = this._queueName;
+        await this._queueDb.addEntry(entry);
     }
-    return {
-        handle: handler
-    };
-};
-
-class Route {
-    handler;
-    match;
-    method;
-    catchHandler;
-    constructor(match, handler, method = defaultMethod){
+    async unshiftEntry(entry) {
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isType(match, "function", {
+            finalAssertExports.isType(entry, "object", {
                 moduleName: "serwist",
-                className: "Route",
-                funcName: "constructor",
-                paramName: "match"
+                className: "BackgroundSyncQueueStore",
+                funcName: "unshiftEntry",
+                paramName: "entry"
+            });
+            finalAssertExports.isType(entry.requestData, "object", {
+                moduleName: "serwist",
+                className: "BackgroundSyncQueueStore",
+                funcName: "unshiftEntry",
+                paramName: "entry.requestData"
             });
-            if (method) {
-                finalAssertExports.isOneOf(method, validMethods, {
-                    paramName: "method"
-                });
-            }
         }
-        this.handler = normalizeHandler(handler);
-        this.match = match;
-        this.method = method;
+        const firstId = await this._queueDb.getFirstEntryId();
+        if (firstId) {
+            entry.id = firstId - 1;
+        } else {
+            delete entry.id;
+        }
+        entry.queueName = this._queueName;
+        await this._queueDb.addEntry(entry);
     }
-    setCatchHandler(handler) {
-        this.catchHandler = normalizeHandler(handler);
+    async popEntry() {
+        return this._removeEntry(await this._queueDb.getLastEntryByQueueName(this._queueName));
     }
-}
-
-const removeIgnoredSearchParams = (urlObject, ignoreURLParametersMatching = [])=>{
-    for (const paramName of [
-        ...urlObject.searchParams.keys()
-    ]){
-        if (ignoreURLParametersMatching.some((regExp)=>regExp.test(paramName))) {
-            urlObject.searchParams.delete(paramName);
-        }
+    async shiftEntry() {
+        return this._removeEntry(await this._queueDb.getFirstEntryByQueueName(this._queueName));
     }
-    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 getAll() {
+        return await this._queueDb.getAllEntriesByQueueName(this._queueName);
     }
-    if (cleanURLs) {
-        const cleanURL = new URL(urlWithoutIgnoredParams.href);
-        cleanURL.pathname += ".html";
-        yield cleanURL.href;
+    async size() {
+        return await this._queueDb.getEntryCountByQueueName(this._queueName);
     }
-    if (urlManipulation) {
-        const additionalURLs = urlManipulation({
-            url: urlObject
-        });
-        for (const urlToAttempt of additionalURLs){
-            yield urlToAttempt.href;
+    async deleteEntry(id) {
+        await this._queueDb.deleteEntry(id);
+    }
+    async _removeEntry(entry) {
+        if (entry) {
+            await this.deleteEntry(entry.id);
         }
+        return entry;
     }
 }
 
-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 (process.env.NODE_ENV !== "production") {
-                logger.debug(`Precaching did not find a match for ${getFriendlyURL(request.url)}.`);
-            }
-            return;
+const serializableProperties = [
+    "method",
+    "referrer",
+    "referrerPolicy",
+    "mode",
+    "credentials",
+    "cache",
+    "redirect",
+    "integrity",
+    "keepalive"
+];
+class StorableRequest {
+    _requestData;
+    static async fromRequest(request) {
+        const requestData = {
+            url: request.url,
+            headers: {}
         };
-        super(match, controller.strategy);
+        if (request.method !== "GET") {
+            requestData.body = await request.clone().arrayBuffer();
+        }
+        request.headers.forEach((value, key)=>{
+            requestData.headers[key] = value;
+        });
+        for (const prop of serializableProperties){
+            if (request[prop] !== undefined) {
+                requestData[prop] = request[prop];
+            }
+        }
+        return new StorableRequest(requestData);
     }
-}
-
-class PrecacheFallbackPlugin {
-    _fallbackUrls;
-    _precacheController;
-    constructor({ fallbackUrls, precacheController }){
-        this._fallbackUrls = fallbackUrls;
-        this._precacheController = precacheController;
+    constructor(requestData){
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isType(requestData, "object", {
+                moduleName: "serwist",
+                className: "StorableRequest",
+                funcName: "constructor",
+                paramName: "requestData"
+            });
+            finalAssertExports.isType(requestData.url, "string", {
+                moduleName: "serwist",
+                className: "StorableRequest",
+                funcName: "constructor",
+                paramName: "requestData.url"
+            });
+        }
+        if (requestData.mode === "navigate") {
+            requestData.mode = "same-origin";
+        }
+        this._requestData = requestData;
     }
-    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;
-                }
-            }
+    toObject() {
+        const requestData = Object.assign({}, this._requestData);
+        requestData.headers = Object.assign({}, this._requestData.headers);
+        if (requestData.body) {
+            requestData.body = requestData.body.slice(0);
         }
-        return undefined;
+        return requestData;
+    }
+    toRequest() {
+        return new Request(this._requestData.url, this._requestData);
+    }
+    clone() {
+        return new StorableRequest(this.toObject());
     }
 }
 
-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);
+const TAG_PREFIX = "serwist-background-sync";
+const MAX_RETENTION_TIME$1 = 60 * 24 * 7;
+const queueNames = new Set();
+const convertEntry = (queueStoreEntry)=>{
+    const queueEntry = {
+        request: new StorableRequest(queueStoreEntry.requestData).toRequest(),
+        timestamp: queueStoreEntry.timestamp
+    };
+    if (queueStoreEntry.metadata) {
+        queueEntry.metadata = queueStoreEntry.metadata;
     }
-    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);
-                }
+    return queueEntry;
+};
+class BackgroundSyncQueue {
+    _name;
+    _onSync;
+    _maxRetentionTime;
+    _queueStore;
+    _forceSyncFallback;
+    _syncInProgress = false;
+    _requestsAddedDuringSync = false;
+    constructor(name, { forceSyncFallback, onSync, maxRetentionTime } = {}){
+        if (queueNames.has(name)) {
+            throw new SerwistError("duplicate-queue-name", {
+                name
             });
         }
-        for (const entry of this._entries){
-            serwist.registerCapture(entry.matcher, entry.handler, entry.method);
-        }
+        queueNames.add(name);
+        this._name = name;
+        this._onSync = onSync || this.replayRequests;
+        this._maxRetentionTime = maxRetentionTime || MAX_RETENTION_TIME$1;
+        this._forceSyncFallback = Boolean(forceSyncFallback);
+        this._queueStore = new BackgroundSyncQueueStore(this._name);
+        this._addSyncListener();
     }
-    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
-                });
+    get name() {
+        return this._name;
+    }
+    async pushRequest(entry) {
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isType(entry, "object", {
+                moduleName: "serwist",
+                className: "BackgroundSyncQueue",
+                funcName: "pushRequest",
+                paramName: "entry"
+            });
+            finalAssertExports.isInstance(entry.request, Request, {
+                moduleName: "serwist",
+                className: "BackgroundSyncQueue",
+                funcName: "pushRequest",
+                paramName: "entry.request"
             });
         }
+        await this._addRequest(entry, "push");
     }
-    warmRuntimeCache(entries) {
-        if (!this._options.warmEntries) this._options.warmEntries = [];
-        this._options.warmEntries.push(...entries);
-    }
-}
-
-class NavigationRoute extends Route {
-    _allowlist;
-    _denylist;
-    constructor(handler, { allowlist = [
-        /./
-    ], denylist = [] } = {}){
+    async unshiftRequest(entry) {
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isArrayOfClass(allowlist, RegExp, {
+            finalAssertExports.isType(entry, "object", {
                 moduleName: "serwist",
-                className: "NavigationRoute",
-                funcName: "constructor",
-                paramName: "options.allowlist"
+                className: "BackgroundSyncQueue",
+                funcName: "unshiftRequest",
+                paramName: "entry"
             });
-            finalAssertExports.isArrayOfClass(denylist, RegExp, {
+            finalAssertExports.isInstance(entry.request, Request, {
                 moduleName: "serwist",
-                className: "NavigationRoute",
-                funcName: "constructor",
-                paramName: "options.denylist"
+                className: "BackgroundSyncQueue",
+                funcName: "unshiftRequest",
+                paramName: "entry.request"
             });
         }
-        super((options)=>this._match(options), handler);
-        this._allowlist = allowlist;
-        this._denylist = denylist;
+        await this._addRequest(entry, "unshift");
     }
-    _match({ url, request }) {
-        if (request && request.mode !== "navigate") {
-            return false;
+    async popRequest() {
+        return this._removeRequest("pop");
+    }
+    async shiftRequest() {
+        return this._removeRequest("shift");
+    }
+    async getAll() {
+        const allEntries = await this._queueStore.getAll();
+        const now = Date.now();
+        const unexpiredEntries = [];
+        for (const entry of allEntries){
+            const maxRetentionTimeInMs = this._maxRetentionTime * 60 * 1000;
+            if (now - entry.timestamp > maxRetentionTimeInMs) {
+                await this._queueStore.deleteEntry(entry.id);
+            } else {
+                unexpiredEntries.push(convertEntry(entry));
+            }
         }
-        const pathnameAndSearch = url.pathname + url.search;
-        for (const regExp of this._denylist){
-            if (regExp.test(pathnameAndSearch)) {
+        return unexpiredEntries;
+    }
+    async size() {
+        return await this._queueStore.size();
+    }
+    async _addRequest({ request, metadata, timestamp = Date.now() }, operation) {
+        const storableRequest = await StorableRequest.fromRequest(request.clone());
+        const entry = {
+            requestData: storableRequest.toObject(),
+            timestamp
+        };
+        if (metadata) {
+            entry.metadata = metadata;
+        }
+        switch(operation){
+            case "push":
+                await this._queueStore.pushEntry(entry);
+                break;
+            case "unshift":
+                await this._queueStore.unshiftEntry(entry);
+                break;
+        }
+        if (process.env.NODE_ENV !== "production") {
+            logger.log(`Request for '${getFriendlyURL(request.url)}' has ` + `been added to background sync queue '${this._name}'.`);
+        }
+        if (this._syncInProgress) {
+            this._requestsAddedDuringSync = true;
+        } else {
+            await this.registerSync();
+        }
+    }
+    async _removeRequest(operation) {
+        const now = Date.now();
+        let entry;
+        switch(operation){
+            case "pop":
+                entry = await this._queueStore.popEntry();
+                break;
+            case "shift":
+                entry = await this._queueStore.shiftEntry();
+                break;
+        }
+        if (entry) {
+            const maxRetentionTimeInMs = this._maxRetentionTime * 60 * 1000;
+            if (now - entry.timestamp > maxRetentionTimeInMs) {
+                return this._removeRequest(operation);
+            }
+            return convertEntry(entry);
+        }
+        return undefined;
+    }
+    async replayRequests() {
+        let entry;
+        while(entry = await this.shiftRequest()){
+            try {
+                await fetch(entry.request.clone());
                 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()}`);
+                    logger.log(`Request for '${getFriendlyURL(entry.request.url)}' ` + `has been replayed in queue '${this._name}'`);
+                }
+            } catch  {
+                await this.unshiftRequest(entry);
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log(`Request for '${getFriendlyURL(entry.request.url)}' ` + `failed to replay, putting it back in queue '${this._name}'`);
+                }
+                throw new SerwistError("queue-replay-failed", {
+                    name: this._name
+                });
+            }
+        }
+        if (process.env.NODE_ENV !== "production") {
+            logger.log(`All requests in queue '${this.name}' have successfully replayed; the queue is now empty!`);
+        }
+    }
+    async registerSync() {
+        if ("sync" in self.registration && !this._forceSyncFallback) {
+            try {
+                await self.registration.sync.register(`${TAG_PREFIX}:${this._name}`);
+            } catch (err) {
+                if (process.env.NODE_ENV !== "production") {
+                    logger.warn(`Unable to register sync event for '${this._name}'.`, err);
+                }
+            }
+        }
+    }
+    _addSyncListener() {
+        if ("sync" in self.registration && !this._forceSyncFallback) {
+            self.addEventListener("sync", (event)=>{
+                if (event.tag === `${TAG_PREFIX}:${this._name}`) {
+                    if (process.env.NODE_ENV !== "production") {
+                        logger.log(`Background sync for tag '${event.tag}' has been received`);
+                    }
+                    const syncComplete = async ()=>{
+                        this._syncInProgress = true;
+                        let syncError;
+                        try {
+                            await this._onSync({
+                                queue: this
+                            });
+                        } catch (error) {
+                            if (error instanceof Error) {
+                                syncError = error;
+                                throw syncError;
+                            }
+                        } finally{
+                            if (this._requestsAddedDuringSync && !(syncError && !event.lastChance)) {
+                                await this.registerSync();
+                            }
+                            this._syncInProgress = false;
+                            this._requestsAddedDuringSync = false;
+                        }
+                    };
+                    event.waitUntil(syncComplete());
                 }
-                return false;
-            }
-        }
-        if (this._allowlist.some((regExp)=>regExp.test(pathnameAndSearch))) {
+            });
+        } else {
             if (process.env.NODE_ENV !== "production") {
-                logger.debug(`The navigation route ${pathnameAndSearch} is being used.`);
+                logger.log("Background sync replaying without background sync event");
             }
-            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.`);
+            void this._onSync({
+                queue: this
+            });
         }
-        return false;
+    }
+    static get _queueNames() {
+        return queueNames;
     }
 }
 
-class RegExpRoute extends Route {
-    constructor(regExp, handler, method){
+class BackgroundSyncPlugin {
+    _queue;
+    constructor(name, options){
+        this._queue = new BackgroundSyncQueue(name, options);
+    }
+    async fetchDidFail({ request }) {
+        await this._queue.pushRequest({
+            request
+        });
+    }
+}
+
+const parseRoute = (capture, handler, method)=>{
+    if (typeof capture === "string") {
+        const captureUrl = new URL(capture, location.href);
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isInstance(regExp, RegExp, {
-                moduleName: "serwist",
-                className: "RegExpRoute",
-                funcName: "constructor",
-                paramName: "pattern"
-            });
-        }
-        const match = ({ url })=>{
-            const result = regExp.exec(url.href);
-            if (!result) {
-                return;
+            if (!(capture.startsWith("/") || capture.startsWith("http"))) {
+                throw new SerwistError("invalid-string", {
+                    moduleName: "serwist",
+                    funcName: "parseRoute",
+                    paramName: "capture"
+                });
             }
-            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.`);
+            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.`);
                 }
-                return;
             }
-            return result.slice(1);
+            return url.href === captureUrl.href;
         };
-        super(match, handler, method);
+        return new Route(matchCallback, handler, method);
     }
-}
-
-const disableDevLogs = ()=>{
-    self.__WB_DISABLE_DEV_LOGS = true;
+    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 cacheOkAndOpaquePlugin = {
-    cacheWillUpdate: async ({ response })=>{
-        if (response.status === 200 || response.status === 0) {
-            return response;
-        }
-        return null;
+const registerCapture = (state, capture, handler, method)=>{
+    const route = parseRoute(capture, handler, method);
+    registerRoute(state, route);
+    return route;
+};
+const registerRoute = (state, route)=>{
+    if (process.env.NODE_ENV !== "production") {
+        finalAssertExports.isType(route, "object", {
+            moduleName: "serwist",
+            className: "Serwist",
+            funcName: "registerRoute",
+            paramName: "route"
+        });
+        finalAssertExports.hasMethod(route, "match", {
+            moduleName: "serwist",
+            className: "Serwist",
+            funcName: "registerRoute",
+            paramName: "route"
+        });
+        finalAssertExports.isType(route.handler, "object", {
+            moduleName: "serwist",
+            className: "Serwist",
+            funcName: "registerRoute",
+            paramName: "route"
+        });
+        finalAssertExports.hasMethod(route.handler, "handle", {
+            moduleName: "serwist",
+            className: "Serwist",
+            funcName: "registerRoute",
+            paramName: "route.handler"
+        });
+        finalAssertExports.isType(route.method, "string", {
+            moduleName: "serwist",
+            className: "Serwist",
+            funcName: "registerRoute",
+            paramName: "route.method"
+        });
+    }
+    if (!state.routes.has(route.method)) {
+        state.routes.set(route.method, []);
     }
+    state.routes.get(route.method).push(route);
 };
-
-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 unregisterRoute = (state, route)=>{
+    if (!state.routes.has(route.method)) {
+        throw new SerwistError("unregister-route-but-not-found-with-method", {
+            method: route.method
+        });
+    }
+    const routeIndex = state.routes.get(route.method).indexOf(route);
+    if (routeIndex > -1) {
+        state.routes.get(route.method).splice(routeIndex, 1);
+    } else {
+        throw new SerwistError("unregister-route-route-not-registered");
     }
 };
-
-class NetworkFirst extends Strategy {
-    _networkTimeoutSeconds;
-    constructor(options = {}){
-        super(options);
-        if (!this.plugins.some((p)=>"cacheWillUpdate" in p)) {
-            this.plugins.unshift(cacheOkAndOpaquePlugin);
-        }
-        this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;
+const handleRequest = (state, { request, event })=>{
+    if (process.env.NODE_ENV !== "production") {
+        finalAssertExports.isInstance(request, Request, {
+            moduleName: "serwist",
+            className: "Serwist",
+            funcName: "handleRequest",
+            paramName: "options.request"
+        });
+    }
+    const url = new URL(request.url, location.href);
+    if (!url.protocol.startsWith("http")) {
         if (process.env.NODE_ENV !== "production") {
-            if (this._networkTimeoutSeconds) {
-                finalAssertExports.isType(this._networkTimeoutSeconds, "number", {
-                    moduleName: "serwist",
-                    className: this.constructor.name,
-                    funcName: "constructor",
-                    paramName: "networkTimeoutSeconds"
-                });
+            logger.debug("Router only supports URLs that start with 'http'.");
+        }
+        return;
+    }
+    const sameOrigin = url.origin === location.origin;
+    const { params, route } = findMatchingRoute(state, {
+        event,
+        request,
+        sameOrigin,
+        url
+    });
+    let handler = route?.handler;
+    const debugMessages = [];
+    if (process.env.NODE_ENV !== "production") {
+        if (handler) {
+            debugMessages.push([
+                "Found a route to handle this request:",
+                route
+            ]);
+            if (params) {
+                debugMessages.push([
+                    `Passing the following params to the route's handler:`,
+                    params
+                ]);
             }
         }
     }
-    async _handle(request, handler) {
-        const logs = [];
+    const method = request.method;
+    if (!handler && state.defaultHandlerMap.has(method)) {
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isInstance(request, Request, {
-                moduleName: "serwist",
-                className: this.constructor.name,
-                funcName: "handle",
-                paramName: "makeRequest"
-            });
-        }
-        const promises = [];
-        let timeoutId;
-        if (this._networkTimeoutSeconds) {
-            const { id, promise } = this._getTimeoutPromise({
-                request,
-                logs,
-                handler
-            });
-            timeoutId = id;
-            promises.push(promise);
+            debugMessages.push(`Failed to find a matching route. Falling back to the default handler for ${method}.`);
         }
-        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;
-        })());
+        handler = state.defaultHandlerMap.get(method);
+    }
+    if (!handler) {
         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();
+            logger.debug(`No route found for: ${getFriendlyURL(url)}`);
         }
-        if (!response) {
-            throw new SerwistError("no-response", {
-                url: request.url
-            });
+        return;
+    }
+    if (process.env.NODE_ENV !== "production") {
+        logger.groupCollapsed(`Router is responding to: ${getFriendlyURL(url)}`);
+        for (const msg of debugMessages){
+            if (Array.isArray(msg)) {
+                logger.log(...msg);
+            } else {
+                logger.log(msg);
+            }
         }
-        return response;
+        logger.groupEnd();
     }
-    _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);
+    let responsePromise;
+    try {
+        responsePromise = handler.handle({
+            url,
+            request,
+            event,
+            params
         });
-        return {
-            promise: timeoutPromise,
-            id: timeoutId
-        };
+    } catch (err) {
+        responsePromise = Promise.reject(err);
     }
-    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;
+    const catchHandler = route?.catchHandler;
+    if (responsePromise instanceof Promise && (state.catchHandler || catchHandler)) {
+        responsePromise = responsePromise.catch(async (err)=>{
+            if (catchHandler) {
+                if (process.env.NODE_ENV !== "production") {
+                    logger.groupCollapsed(`Error thrown when responding to:  ${getFriendlyURL(url)}. Falling back to route's Catch Handler.`);
+                    logger.error("Error thrown by:", route);
+                    logger.error(err);
+                    logger.groupEnd();
+                }
+                try {
+                    return await catchHandler.handle({
+                        url,
+                        request,
+                        event,
+                        params
+                    });
+                } catch (catchErr) {
+                    if (catchErr instanceof Error) {
+                        err = catchErr;
+                    }
+                }
             }
-        }
-        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 (state.catchHandler) {
+                if (process.env.NODE_ENV !== "production") {
+                    logger.groupCollapsed(`Error thrown when responding to:  ${getFriendlyURL(url)}. Falling back to global Catch Handler.`);
+                    logger.error("Error thrown by:", route);
+                    logger.error(err);
+                    logger.groupEnd();
+                }
+                return state.catchHandler.handle({
+                    url,
+                    request,
+                    event
+                });
             }
-        }
-        if (error || !response) {
-            response = await handler.cacheMatch(request);
+            throw err;
+        });
+    }
+    return responsePromise;
+};
+const findMatchingRoute = (state, { url, sameOrigin, request, event })=>{
+    const routes = state.routes.get(request.method) || [];
+    for (const route of routes){
+        let params;
+        const matchResult = route.match({
+            url,
+            sameOrigin,
+            request,
+            event
+        });
+        if (matchResult) {
             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 (matchResult instanceof Promise) {
+                    logger.warn(`While routing ${getFriendlyURL(url)}, an async matchCallback function was used. Please convert the following route to use a synchronous matchCallback function:`, route);
                 }
             }
+            params = matchResult;
+            if (Array.isArray(params) && params.length === 0) {
+                params = undefined;
+            } else if (matchResult.constructor === Object && Object.keys(matchResult).length === 0) {
+                params = undefined;
+            } else if (typeof matchResult === "boolean") {
+                params = undefined;
+            }
+            return {
+                route,
+                params
+            };
         }
-        return response;
     }
-}
+    return {};
+};
 
-class NetworkOnly extends Strategy {
-    _networkTimeoutSeconds;
-    constructor(options = {}){
-        super(options);
-        this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;
+const cacheOkAndOpaquePlugin = {
+    cacheWillUpdate: async ({ response })=>{
+        if (response.status === 200 || response.status === 0) {
+            return response;
+        }
+        return null;
     }
-    async _handle(request, handler) {
+};
+
+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(request, Request, {
+            finalAssertExports.isInstance(options.event, ExtendableEvent, {
                 moduleName: "serwist",
-                className: this.constructor.name,
-                funcName: "_handle",
-                paramName: "request"
+                className: "StrategyHandler",
+                funcName: "constructor",
+                paramName: "options.event"
+            });
+            finalAssertExports.isInstance(options.request, Request, {
+                moduleName: "serwist",
+                className: "StrategyHandler",
+                funcName: "constructor",
+                paramName: "options.request"
             });
         }
-        let error = undefined;
-        let response;
+        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);
+    }
+    async fetch(input) {
+        const { event } = this;
+        let request = toRequest(input);
+        const preloadResponse = await this.getPreloadResponse();
+        if (preloadResponse) {
+            return preloadResponse;
+        }
+        const originalRequest = this.hasCallback("fetchDidFail") ? request.clone() : null;
         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.`);
+            for (const cb of this.iterateCallbacks("requestWillFetch")){
+                request = await cb({
+                    request: request.clone(),
+                    event
+                });
             }
         } catch (err) {
             if (err instanceof Error) {
-                error = err;
+                throw new SerwistError("plugin-error-request-will-fetch", {
+                    thrownErrorMessage: err.message
+                });
+            }
+        }
+        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 (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;
         }
+    }
+    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") {
-            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
-            if (response) {
-                logger.log("Got response from network.");
+            if (cachedResponse) {
+                logger.debug(`Found a cached response in '${cacheName}'.`);
             } else {
-                logger.log("Unable to get a response from the network.");
+                logger.debug(`No cached response found in '${cacheName}'.`);
             }
-            messages.printFinalResponse(response);
-            logger.groupEnd();
         }
-        if (!response) {
-            throw new SerwistError("no-response", {
-                url: request.url,
-                error
-            });
+        for (const callback of this.iterateCallbacks("cachedResponseWillBeUsed")){
+            cachedResponse = await callback({
+                cacheName,
+                matchOptions,
+                cachedResponse,
+                request: effectiveRequest,
+                event: this.event
+            }) || undefined;
         }
-        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"
-        });
-        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;
+        return cachedResponse;
     }
-    async getDb() {
-        if (!this._db) {
-            this._db = await openDB(BACKGROUND_SYNC_DB_NAME, BACKGROUND_SYNC_DB_VERSION, {
-                upgrade: this._upgradeDb
+    async cachePut(key, response) {
+        const request = toRequest(key);
+        await timeout(0);
+        const effectiveRequest = await this.getCacheKey(request, "write");
+        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)
             });
         }
-        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 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") {
+            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 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();
-    }
-    async pushEntry(entry) {
+        const hasCacheUpdateCallback = this.hasCallback("cacheDidUpdate");
+        const oldResponse = hasCacheUpdateCallback ? await cacheMatchIgnoreParams(cache, effectiveRequest.clone(), [
+            "__WB_REVISION__"
+        ], matchOptions) : null;
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isType(entry, "object", {
-                moduleName: "serwist",
-                className: "BackgroundSyncQueueStore",
-                funcName: "pushEntry",
-                paramName: "entry"
-            });
-            finalAssertExports.isType(entry.requestData, "object", {
-                moduleName: "serwist",
-                className: "BackgroundSyncQueueStore",
-                funcName: "pushEntry",
-                paramName: "entry.requestData"
+            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
             });
         }
-        delete entry.id;
-        entry.queueName = this._queueName;
-        await this._queueDb.addEntry(entry);
+        return true;
     }
-    async unshiftEntry(entry) {
-        if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isType(entry, "object", {
-                moduleName: "serwist",
-                className: "BackgroundSyncQueueStore",
-                funcName: "unshiftEntry",
-                paramName: "entry"
-            });
-            finalAssertExports.isType(entry.requestData, "object", {
-                moduleName: "serwist",
-                className: "BackgroundSyncQueueStore",
-                funcName: "unshiftEntry",
-                paramName: "entry.requestData"
-            });
+    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;
         }
-        const firstId = await this._queueDb.getFirstEntryId();
-        if (firstId) {
-            entry.id = firstId - 1;
-        } else {
-            delete entry.id;
+        return this._cacheKeys[key];
+    }
+    hasCallback(name) {
+        for (const plugin of this._strategy.plugins){
+            if (name in plugin) {
+                return true;
+            }
         }
-        entry.queueName = this._queueName;
-        await this._queueDb.addEntry(entry);
+        return false;
     }
-    async popEntry() {
-        return this._removeEntry(await this._queueDb.getLastEntryByQueueName(this._queueName));
+    async runCallbacks(name, param) {
+        for (const callback of this.iterateCallbacks(name)){
+            await callback(param);
+        }
     }
-    async shiftEntry() {
-        return this._removeEntry(await this._queueDb.getFirstEntryByQueueName(this._queueName));
+    *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;
+            }
+        }
     }
-    async getAll() {
-        return await this._queueDb.getAllEntriesByQueueName(this._queueName);
+    waitUntil(promise) {
+        this._extendLifetimePromises.push(promise);
+        return promise;
     }
-    async size() {
-        return await this._queueDb.getEntryCountByQueueName(this._queueName);
+    async doneWaiting() {
+        let promise;
+        while(promise = this._extendLifetimePromises.shift()){
+            await promise;
+        }
     }
-    async deleteEntry(id) {
-        await this._queueDb.deleteEntry(id);
+    destroy() {
+        this._handlerDeferred.resolve(null);
     }
-    async _removeEntry(entry) {
-        if (entry) {
-            await this.deleteEntry(entry.id);
+    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;
+            }
         }
-        return entry;
+        return undefined;
+    }
+    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;
+            }
+        }
+        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;
+            }
+        }
+        return responseToCache;
     }
 }
 
-const serializableProperties = [
-    "method",
-    "referrer",
-    "referrerPolicy",
-    "mode",
-    "credentials",
-    "cache",
-    "redirect",
-    "integrity",
-    "keepalive"
-];
-class StorableRequest {
-    _requestData;
-    static async fromRequest(request) {
-        const requestData = {
-            url: request.url,
-            headers: {}
-        };
-        if (request.method !== "GET") {
-            requestData.body = await request.clone().arrayBuffer();
+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;
+    }
+    handle(options) {
+        const [responseDone] = this.handleAll(options);
+        return responseDone;
+    }
+    handleAll(options) {
+        if (options instanceof FetchEvent) {
+            options = {
+                event: options,
+                request: options.request
+            };
         }
-        request.headers.forEach((value, key)=>{
-            requestData.headers[key] = value;
+        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
         });
-        for (const prop of serializableProperties){
-            if (request[prop] !== undefined) {
-                requestData[prop] = request[prop];
+        let response;
+        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;
+                    }
+                }
+            }
+            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.`);
             }
         }
-        return new StorableRequest(requestData);
-    }
-    constructor(requestData){
-        if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isType(requestData, "object", {
-                moduleName: "serwist",
-                className: "StorableRequest",
-                funcName: "constructor",
-                paramName: "requestData"
-            });
-            finalAssertExports.isType(requestData.url, "string", {
-                moduleName: "serwist",
-                className: "StorableRequest",
-                funcName: "constructor",
-                paramName: "requestData.url"
+        for (const callback of handler.iterateCallbacks("handlerWillRespond")){
+            response = await callback({
+                event,
+                request,
+                response
             });
         }
-        if (requestData.mode === "navigate") {
-            requestData.mode = "same-origin";
-        }
-        this._requestData = requestData;
+        return response;
     }
-    toObject() {
-        const requestData = Object.assign({}, this._requestData);
-        requestData.headers = Object.assign({}, this._requestData.headers);
-        if (requestData.body) {
-            requestData.body = requestData.body.slice(0);
+    async _awaitComplete(responseDone, handler, request, event) {
+        let response;
+        let error;
+        try {
+            response = await responseDone;
+        } catch  {}
+        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
+        });
+        handler.destroy();
+        if (error) {
+            throw error;
         }
-        return requestData;
-    }
-    toRequest() {
-        return new Request(this._requestData.url, this._requestData);
-    }
-    clone() {
-        return new StorableRequest(this.toObject());
     }
 }
 
-const TAG_PREFIX = "serwist-background-sync";
-const MAX_RETENTION_TIME$1 = 60 * 24 * 7;
-const queueNames = new Set();
-const convertEntry = (queueStoreEntry)=>{
-    const queueEntry = {
-        request: new StorableRequest(queueStoreEntry.requestData).toRequest(),
-        timestamp: queueStoreEntry.timestamp
-    };
-    if (queueStoreEntry.metadata) {
-        queueEntry.metadata = queueStoreEntry.metadata;
+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();
+        }
     }
-    return queueEntry;
 };
-class BackgroundSyncQueue {
-    _name;
-    _onSync;
-    _maxRetentionTime;
-    _queueStore;
-    _forceSyncFallback;
-    _syncInProgress = false;
-    _requestsAddedDuringSync = false;
-    constructor(name, { forceSyncFallback, onSync, maxRetentionTime } = {}){
-        if (queueNames.has(name)) {
-            throw new SerwistError("duplicate-queue-name", {
-                name
-            });
+
+class NetworkFirst extends Strategy {
+    _networkTimeoutSeconds;
+    constructor(options = {}){
+        super(options);
+        if (!this.plugins.some((p)=>"cacheWillUpdate" in p)) {
+            this.plugins.unshift(cacheOkAndOpaquePlugin);
         }
-        queueNames.add(name);
-        this._name = name;
-        this._onSync = onSync || this.replayRequests;
-        this._maxRetentionTime = maxRetentionTime || MAX_RETENTION_TIME$1;
-        this._forceSyncFallback = Boolean(forceSyncFallback);
-        this._queueStore = new BackgroundSyncQueueStore(this._name);
-        this._addSyncListener();
-    }
-    get name() {
-        return this._name;
-    }
-    async pushRequest(entry) {
+        this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isType(entry, "object", {
-                moduleName: "serwist",
-                className: "BackgroundSyncQueue",
-                funcName: "pushRequest",
-                paramName: "entry"
-            });
-            finalAssertExports.isInstance(entry.request, Request, {
-                moduleName: "serwist",
-                className: "BackgroundSyncQueue",
-                funcName: "pushRequest",
-                paramName: "entry.request"
-            });
+            if (this._networkTimeoutSeconds) {
+                finalAssertExports.isType(this._networkTimeoutSeconds, "number", {
+                    moduleName: "serwist",
+                    className: this.constructor.name,
+                    funcName: "constructor",
+                    paramName: "networkTimeoutSeconds"
+                });
+            }
         }
-        await this._addRequest(entry, "push");
     }
-    async unshiftRequest(entry) {
+    async _handle(request, handler) {
+        const logs = [];
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isType(entry, "object", {
-                moduleName: "serwist",
-                className: "BackgroundSyncQueue",
-                funcName: "unshiftRequest",
-                paramName: "entry"
-            });
-            finalAssertExports.isInstance(entry.request, Request, {
+            finalAssertExports.isInstance(request, Request, {
                 moduleName: "serwist",
-                className: "BackgroundSyncQueue",
-                funcName: "unshiftRequest",
-                paramName: "entry.request"
+                className: this.constructor.name,
+                funcName: "handle",
+                paramName: "makeRequest"
             });
         }
-        await this._addRequest(entry, "unshift");
-    }
-    async popRequest() {
-        return this._removeRequest("pop");
-    }
-    async shiftRequest() {
-        return this._removeRequest("shift");
-    }
-    async getAll() {
-        const allEntries = await this._queueStore.getAll();
-        const now = Date.now();
-        const unexpiredEntries = [];
-        for (const entry of allEntries){
-            const maxRetentionTimeInMs = this._maxRetentionTime * 60 * 1000;
-            if (now - entry.timestamp > maxRetentionTimeInMs) {
-                await this._queueStore.deleteEntry(entry.id);
-            } else {
-                unexpiredEntries.push(convertEntry(entry));
-            }
-        }
-        return unexpiredEntries;
-    }
-    async size() {
-        return await this._queueStore.size();
-    }
-    async _addRequest({ request, metadata, timestamp = Date.now() }, operation) {
-        const storableRequest = await StorableRequest.fromRequest(request.clone());
-        const entry = {
-            requestData: storableRequest.toObject(),
-            timestamp
-        };
-        if (metadata) {
-            entry.metadata = metadata;
-        }
-        switch(operation){
-            case "push":
-                await this._queueStore.pushEntry(entry);
-                break;
-            case "unshift":
-                await this._queueStore.unshiftEntry(entry);
-                break;
-        }
-        if (process.env.NODE_ENV !== "production") {
-            logger.log(`Request for '${getFriendlyURL(request.url)}' has ` + `been added to background sync queue '${this._name}'.`);
-        }
-        if (this._syncInProgress) {
-            this._requestsAddedDuringSync = true;
-        } else {
-            await this.registerSync();
-        }
-    }
-    async _removeRequest(operation) {
-        const now = Date.now();
-        let entry;
-        switch(operation){
-            case "pop":
-                entry = await this._queueStore.popEntry();
-                break;
-            case "shift":
-                entry = await this._queueStore.shiftEntry();
-                break;
+        const promises = [];
+        let timeoutId;
+        if (this._networkTimeoutSeconds) {
+            const { id, promise } = this._getTimeoutPromise({
+                request,
+                logs,
+                handler
+            });
+            timeoutId = id;
+            promises.push(promise);
         }
-        if (entry) {
-            const maxRetentionTimeInMs = this._maxRetentionTime * 60 * 1000;
-            if (now - entry.timestamp > maxRetentionTimeInMs) {
-                return this._removeRequest(operation);
+        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);
             }
-            return convertEntry(entry);
+            messages.printFinalResponse(response);
+            logger.groupEnd();
         }
-        return undefined;
+        if (!response) {
+            throw new SerwistError("no-response", {
+                url: request.url
+            });
+        }
+        return response;
     }
-    async replayRequests() {
-        let entry = undefined;
-        while(entry = await this.shiftRequest()){
-            try {
-                await fetch(entry.request.clone());
-                if (process.env.NODE_ENV !== "production") {
-                    logger.log(`Request for '${getFriendlyURL(entry.request.url)}' ` + `has been replayed in queue '${this._name}'`);
-                }
-            } catch (error) {
-                await this.unshiftRequest(entry);
+    _getTimeoutPromise({ request, logs, handler }) {
+        let timeoutId;
+        const timeoutPromise = new Promise((resolve)=>{
+            const onNetworkTimeout = async ()=>{
                 if (process.env.NODE_ENV !== "production") {
-                    logger.log(`Request for '${getFriendlyURL(entry.request.url)}' ` + `failed to replay, putting it back in queue '${this._name}'`);
+                    logs.push(`Timing out the network response at ${this._networkTimeoutSeconds} seconds.`);
                 }
-                throw new SerwistError("queue-replay-failed", {
-                    name: this._name
-                });
+                resolve(await handler.cacheMatch(request));
+            };
+            timeoutId = setTimeout(onNetworkTimeout, this._networkTimeoutSeconds * 1000);
+        });
+        return {
+            promise: timeoutPromise,
+            id: timeoutId
+        };
+    }
+    async _getNetworkPromise({ timeoutId, request, logs, handler }) {
+        let error;
+        let response;
+        try {
+            response = await handler.fetchAndCachePut(request);
+        } catch (fetchError) {
+            if (fetchError instanceof Error) {
+                error = fetchError;
             }
         }
-        if (process.env.NODE_ENV !== "production") {
-            logger.log(`All requests in queue '${this.name}' have successfully replayed; the queue is now empty!`);
+        if (timeoutId) {
+            clearTimeout(timeoutId);
         }
-    }
-    async registerSync() {
-        if ("sync" in self.registration && !this._forceSyncFallback) {
-            try {
-                await self.registration.sync.register(`${TAG_PREFIX}:${this._name}`);
-            } catch (err) {
-                if (process.env.NODE_ENV !== "production") {
-                    logger.warn(`Unable to register sync event for '${this._name}'.`, err);
-                }
+        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.");
             }
         }
-    }
-    _addSyncListener() {
-        if ("sync" in self.registration && !this._forceSyncFallback) {
-            self.addEventListener("sync", (event)=>{
-                if (event.tag === `${TAG_PREFIX}:${this._name}`) {
-                    if (process.env.NODE_ENV !== "production") {
-                        logger.log(`Background sync for tag '${event.tag}' has been received`);
-                    }
-                    const syncComplete = async ()=>{
-                        this._syncInProgress = true;
-                        let syncError = undefined;
-                        try {
-                            await this._onSync({
-                                queue: this
-                            });
-                        } catch (error) {
-                            if (error instanceof Error) {
-                                syncError = error;
-                                throw syncError;
-                            }
-                        } finally{
-                            if (this._requestsAddedDuringSync && !(syncError && !event.lastChance)) {
-                                await this.registerSync();
-                            }
-                            this._syncInProgress = false;
-                            this._requestsAddedDuringSync = false;
-                        }
-                    };
-                    event.waitUntil(syncComplete());
-                }
-            });
-        } else {
+        if (error || !response) {
+            response = await handler.cacheMatch(request);
             if (process.env.NODE_ENV !== "production") {
-                logger.log("Background sync replaying without background sync event");
+                if (response) {
+                    logs.push(`Found a cached response in the '${this.cacheName}' cache.`);
+                } else {
+                    logs.push(`No response found in the '${this.cacheName}' cache.`);
+                }
             }
-            void this._onSync({
-                queue: this
-            });
         }
-    }
-    static get _queueNames() {
-        return queueNames;
+        return response;
     }
 }
 
-class BackgroundSyncPlugin {
-    _queue;
-    constructor(name, options){
-        this._queue = new BackgroundSyncQueue(name, options);
+class NetworkOnly extends Strategy {
+    _networkTimeoutSeconds;
+    constructor(options = {}){
+        super(options);
+        this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;
     }
-    async fetchDidFail({ request }) {
-        await this._queue.pushRequest({
-            request
-        });
+    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;
+        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;
     }
 }
 
@@ -1467,7 +1496,7 @@ const COLLECT_PATHS_REGEX = /^\/(\w+\/)?collect/;
 
 const createOnSyncCallback = (config)=>{
     return async ({ queue })=>{
-        let entry = undefined;
+        let entry;
         while(entry = await queue.shiftRequest()){
             const { request, timestamp } = entry;
             const url = new URL(request.url);
@@ -1543,60 +1572,254 @@ const createGtmJsRoute = (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);
+class GoogleAnalytics {
+    _options;
+    constructor(options = {}){
+        this._options = options;
+    }
+    init({ serwist }) {
+        const resolvedCacheName = cacheNames$1.getGoogleAnalyticsName(this._options.cacheName);
+        const bgSyncPlugin = new BackgroundSyncPlugin(QUEUE_NAME, {
+            maxRetentionTime: MAX_RETENTION_TIME,
+            onSync: createOnSyncCallback(this._options)
+        });
+        const routes = [
+            createGtmJsRoute(resolvedCacheName),
+            createAnalyticsJsRoute(resolvedCacheName),
+            createGtagJsRoute(resolvedCacheName),
+            ...createCollectRoutes(bgSyncPlugin)
+        ];
+        for (const route of routes){
+            registerRoute(serwist, route);
+        }
+    }
+}
+
+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);
+    }
+};
+
+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
+        });
+    }
+    if (!revision) {
+        const urlObject = new URL(url, location.href);
+        return {
+            cacheKey: urlObject.href,
+            url: urlObject.href
+        };
+    }
+    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);
+    }
+    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();
     }
 };
 
-const isNavigationPreloadSupported = ()=>{
-    return Boolean(self.registration?.navigationPreload);
+function _nestedGroup(groupTitle, urls) {
+    if (urls.length === 0) {
+        return;
+    }
+    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.`;
+        }
+        logger.groupCollapsed(message);
+        _nestedGroup("View newly precached URLs.", urlsToPrecache);
+        _nestedGroup("View previously precached URLs.", urlsAlreadyPrecached);
+        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.");
+
+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, { entries, cacheName, plugins, fetchOptions, matchOptions, fallbackToNetwork, directoryIndex, ignoreURLParametersMatching, cleanURLs, urlManipulation, cleanupOutdatedCaches, concurrency, navigateFallback, navigateFallbackAllowlist, navigateFallbackDenylist })=>({
+        entries: entries ?? [],
+        strategyOptions: {
+            cacheName: cacheNames$1.getPrecacheName(cacheName),
+            plugins: [
+                ...plugins ?? [],
+                new PrecacheCacheKeyPlugin({
+                    precacheController: controller
+                })
+            ],
+            fetchOptions,
+            matchOptions,
+            fallbackToNetwork
+        },
+        routeOptions: {
+            directoryIndex,
+            ignoreURLParametersMatching,
+            cleanURLs,
+            urlManipulation
+        },
+        extensionOptions: {
+            cleanupOutdatedCaches,
+            concurrency: concurrency ?? 10,
+            navigateFallback,
+            navigateFallbackAllowlist,
+            navigateFallbackDenylist
+        }
+    });
+
+class PrecacheInstallReportPlugin {
+    updatedURLs = [];
+    notUpdatedURLs = [];
+    handlerWillStart = async ({ request, state })=>{
+        if (state) {
+            state.originalRequest = request;
+        }
+    };
+    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);
                 }
-            }));
-        });
-    } else {
-        if (process.env.NODE_ENV !== "production") {
-            logger.log("Navigation preloading is not supported in this browser.");
+            }
+        }
+        return cachedResponse;
+    };
+}
+
+const removeIgnoredSearchParams = (urlObject, ignoreURLParametersMatching = [])=>{
+    for (const paramName of [
+        ...urlObject.searchParams.keys()
+    ]){
+        if (ignoreURLParametersMatching.some((regExp)=>regExp.test(paramName))) {
+            urlObject.searchParams.delete(paramName);
         }
     }
+    return urlObject;
 };
-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.");
-                }
-            }));
+
+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;
+    }
+    if (cleanURLs) {
+        const cleanURL = new URL(urlWithoutIgnoredParams.href);
+        cleanURL.pathname += ".html";
+        yield cleanURL.href;
+    }
+    if (urlManipulation) {
+        const additionalURLs = urlManipulation({
+            url: urlObject
         });
-    } else {
-        if (process.env.NODE_ENV !== "production") {
-            logger.log("Navigation preloading is not supported in this browser.");
+        for (const urlToAttempt of additionalURLs){
+            yield urlToAttempt.href;
         }
     }
-};
+}
+
+class PrecacheRoute extends Route {
+    constructor(precache, options){
+        const match = ({ request })=>{
+            const urlsToCacheKeys = precache.getUrlsToPrecacheKeys();
+            for (const possibleURL of generateURLVariations(request.url, options)){
+                const cacheKey = urlsToCacheKeys.get(possibleURL);
+                if (cacheKey) {
+                    const integrity = precache.getIntegrityForPrecacheKey(cacheKey);
+                    return {
+                        cacheKey,
+                        integrity
+                    };
+                }
+            }
+            if (process.env.NODE_ENV !== "production") {
+                logger.debug(`Precaching did not find a match for ${getFriendlyURL(request.url)}.`);
+            }
+            return;
+        };
+        super(match, precache.strategy);
+    }
+}
 
+const disableDevLogs = ()=>{
+    self.__WB_DISABLE_DEV_LOGS = true;
+};
 const setCacheNameDetails = (details)=>{
     if (process.env.NODE_ENV !== "production") {
         for (const key of Object.keys(details)){
@@ -1627,206 +1850,165 @@ const setCacheNameDetails = (details)=>{
     }
     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.`);
-                }
-            }
-            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);
+const registerQuotaErrorCallback = (callback)=>{
+    if (process.env.NODE_ENV !== "production") {
+        finalAssertExports.isType(callback, "function", {
+            moduleName: "@serwist/core",
+            funcName: "register",
+            paramName: "callback"
+        });
     }
-    if (capture instanceof Route) {
-        return capture;
+    quotaErrorCallbacks.add(callback);
+    if (process.env.NODE_ENV !== "production") {
+        logger.log("Registered a callback to respond to quota errors.", callback);
     }
-    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 copyResponse = async (response, modifier)=>{
+    let origin = null;
+    if (response.url) {
+        const responseURL = new URL(response.url);
+        origin = responseURL.origin;
     }
-    const { revision, url } = entry;
-    if (!url) {
-        throw new SerwistError("add-to-cache-list-unexpected-type", {
-            entry
+    if (origin !== self.location.origin) {
+        throw new SerwistError("cross-origin-copy-response", {
+            origin
         });
     }
-    if (!revision) {
-        const urlObject = new URL(url, location.href);
-        return {
-            cacheKey: urlObject.href,
-            url: urlObject.href
-        };
-    }
-    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 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 PrecacheInstallReportPlugin {
-    updatedURLs = [];
-    notUpdatedURLs = [];
-    handlerWillStart = async ({ request, state })=>{
-        if (state) {
-            state.originalRequest = request;
+class PrecacheStrategy extends Strategy {
+    _fallbackToNetwork;
+    static defaultPrecacheCacheabilityPlugin = {
+        async cacheWillUpdate ({ response }) {
+            if (!response || response.status >= 400) {
+                return null;
+            }
+            return response;
         }
     };
-    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);
-                }
-            }
+    static copyRedirectedCacheableResponsesPlugin = {
+        async cacheWillUpdate ({ response }) {
+            return response.redirected ? await copyResponse(response) : response;
         }
-        return cachedResponse;
     };
-}
-
-function _nestedGroup(groupTitle, urls) {
-    if (urls.length === 0) {
-        return;
-    }
-    logger.groupCollapsed(groupTitle);
-    for (const url of urls){
-        logger.log(url);
+    constructor(options = {}){
+        options.cacheName = cacheNames$1.getPrecacheName(options.cacheName);
+        super(options);
+        this._fallbackToNetwork = options.fallbackToNetwork !== false;
+        this.plugins.push(PrecacheStrategy.copyRedirectedCacheableResponsesPlugin);
     }
-    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.`;
+    async _handle(request, handler) {
+        const preloadResponse = await handler.getPreloadResponse();
+        if (preloadResponse) {
+            return preloadResponse;
         }
-        logger.groupCollapsed(message);
-        _nestedGroup("View newly precached URLs.", urlsToPrecache);
-        _nestedGroup("View previously precached URLs.", urlsAlreadyPrecached);
-        logger.groupEnd();
+        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);
     }
-};
-
-const logGroup = (groupTitle, deletedURLs)=>{
-    logger.groupCollapsed(groupTitle);
-    for (const url of deletedURLs){
-        logger.log(url);
+    async _handleFetch(request, handler) {
+        let response;
+        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
+            });
+        }
+        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 response;
     }
-    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();
+    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;
     }
-};
-
-class PrecacheCacheKeyPlugin {
-    _precacheController;
-    constructor({ precacheController }){
-        this._precacheController = precacheController;
+    _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;
+            }
+            if (plugin.cacheWillUpdate) {
+                cacheWillUpdatePluginCount++;
+            }
+        }
+        if (cacheWillUpdatePluginCount === 0) {
+            this.plugins.push(PrecacheStrategy.defaultPrecacheCacheabilityPlugin);
+        } else if (cacheWillUpdatePluginCount > 1 && defaultPluginIndex !== null) {
+            this.plugins.splice(defaultPluginIndex, 1);
+        }
     }
-    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 {
+class Precache {
     _urlsToCacheKeys = new Map();
     _urlsToCacheModes = new Map();
     _cacheKeysToIntegrities = new Map();
     _strategy;
     _options;
     _routeOptions;
-    constructor(entries, precacheOptions){
-        const { strategyOptions, routeOptions, controllerOptions } = parsePrecacheOptions(this, precacheOptions);
+    constructor(precacheOptions){
+        const { entries, strategyOptions, routeOptions, extensionOptions: 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;
@@ -1875,16 +2057,16 @@ class PrecacheController {
             }
         }
     }
-    init(serwist) {
-        serwist.registerRoute(new PrecacheRoute(this, this._routeOptions));
+    init({ serwist }) {
+        registerRoute(serwist, new PrecacheRoute(this, this._routeOptions));
         if (this._options.navigateFallback) {
-            serwist.registerRoute(new NavigationRoute(this.createHandlerBoundToUrl(this._options.navigateFallback), {
+            registerRoute(serwist, new NavigationRoute(this.createHandlerBoundToUrl(this._options.navigateFallback), {
                 allowlist: this._options.navigateFallbackAllowlist,
                 denylist: this._options.navigateFallbackDenylist
             }));
         }
     }
-    async install(event) {
+    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])=>{
@@ -1948,131 +2130,151 @@ class PrecacheController {
         }
         return undefined;
     }
-    createHandlerBoundToUrl(url) {
-        const cacheKey = this.getPrecacheKeyForUrl(url);
-        if (!cacheKey) {
-            throw new SerwistError("non-precached-url", {
-                url
-            });
-        }
-        return (options)=>{
-            options.request = new Request(url);
-            options.params = {
-                cacheKey,
-                ...options.params
-            };
-            return this._strategy.handle(options);
-        };
-    }
+    createHandlerBoundToUrl(url) {
+        const cacheKey = this.getPrecacheKeyForUrl(url);
+        if (!cacheKey) {
+            throw new SerwistError("non-precached-url", {
+                url
+            });
+        }
+        return (options)=>{
+            options.request = new Request(url);
+            options.params = {
+                cacheKey,
+                ...options.params
+            };
+            return this._strategy.handle(options);
+        };
+    }
+}
+
+class PrecacheFallbackPlugin {
+    _fallbackUrls;
+    _serwist;
+    constructor({ fallbackUrls, serwist }){
+        this._fallbackUrls = fallbackUrls;
+        this._serwist = serwist;
+    }
+    async handlerDidError(param) {
+        for (const fallback of this._fallbackUrls){
+            if (typeof fallback === "string") {
+                const fallbackResponse = handleRequest(this._serwist, {
+                    request: new Request(fallback, {
+                        credentials: "same-origin"
+                    }),
+                    event: param.event
+                });
+                if (fallbackResponse !== undefined) {
+                    return await fallbackResponse;
+                }
+            } else if (fallback.matcher(param)) {
+                const fallbackResponse = handleRequest(this._serwist, {
+                    request: new Request(fallback.url, {
+                        credentials: "same-origin"
+                    }),
+                    event: param.event
+                });
+                if (fallbackResponse !== undefined) {
+                    return await fallbackResponse;
+                }
+            }
+        }
+        return undefined;
+    }
 }
 
-class Serwist {
-    _routes;
-    _defaultHandlerMap;
-    _precacheController;
-    _controllers;
-    _catchHandler;
-    constructor({ precacheEntries, precacheOptions, controllers = [], skipWaiting = false, importScripts, navigationPreload = false, cacheId, clientsClaim: clientsClaim$1 = false, runtimeCaching, offlineAnalyticsConfig, disableDevLogs: disableDevLogs$1 = false, fallbacks } = {}){
-        this._routes = new Map();
-        this._defaultHandlerMap = new Map();
-        this._controllers = controllers;
-        this.handleInstall = this.handleInstall.bind(this);
-        this.handleActivate = this.handleActivate.bind(this);
-        this.handleFetch = this.handleFetch.bind(this);
-        this.handleCache = this.handleCache.bind(this);
-        if (!!importScripts && importScripts.length > 0) self.importScripts(...importScripts);
-        if (navigationPreload) enableNavigationPreload();
-        if (cacheId !== undefined) {
-            setCacheNameDetails({
-                prefix: cacheId
+class RuntimeCache {
+    _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,
+                serwist
             });
-        }
-        if (skipWaiting) {
-            self.skipWaiting();
-        } else {
-            self.addEventListener("message", (event)=>{
-                if (event.data && event.data.type === "SKIP_WAITING") {
-                    self.skipWaiting();
+            this._entries.forEach((cacheEntry)=>{
+                if (cacheEntry.handler instanceof Strategy && !cacheEntry.handler.plugins.some((plugin)=>"handlerDidError" in plugin)) {
+                    cacheEntry.handler.plugins.push(fallbackPlugin);
                 }
             });
         }
-        if (clientsClaim$1) clientsClaim();
-        this._precacheController = new PrecacheController(precacheEntries ?? [], precacheOptions);
-        if (runtimeCaching) {
-            if (!this._controllers?.some((controller)=>controller instanceof RuntimeCacheController)) {
-                this._controllers.unshift(new RuntimeCacheController(runtimeCaching, {
-                    fallbacks
-                }));
-            } else if (process.env.NODE_ENV !== "production") {
-                logger.warn("You have migrated to the Controller pattern, so setting `runtimeCaching` is a no-op.");
-            }
+        for (const entry of this._entries){
+            registerCapture(serwist, entry.matcher, entry.handler, entry.method);
         }
-        this._controllers.unshift(this._precacheController);
-        if (offlineAnalyticsConfig !== undefined) {
-            if (typeof offlineAnalyticsConfig === "boolean") {
-                offlineAnalyticsConfig && initializeGoogleAnalytics({
-                    serwist: this
+    }
+    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 : typeof entry === "string" ? new Request(entry, {
+                    credentials: "same-origin"
+                }) : new Request(entry.url, {
+                    integrity: entry.integrity,
+                    credentials: "same-origin"
                 });
-            } else {
-                initializeGoogleAnalytics({
-                    ...offlineAnalyticsConfig,
-                    serwist: this
+                await handleRequest(serwist, {
+                    request,
+                    event
                 });
-            }
-        }
-        for (const callback of this.iterateControllers("init")){
-            callback(this);
-        }
-        if (disableDevLogs$1) disableDevLogs();
-    }
-    *iterateControllers(name) {
-        if (!this._controllers) return;
-        for (const controller of this._controllers){
-            if (typeof controller[name] === "function") {
-                yield controller[name];
-            }
+            });
         }
     }
-    get precache() {
-        return this._precacheController;
-    }
-    get precacheStrategy() {
-        return this._precacheController.strategy;
-    }
-    get routes() {
-        return this._routes;
-    }
-    addEventListeners() {
-        self.addEventListener("install", this.handleInstall);
-        self.addEventListener("activate", this.handleActivate);
-        self.addEventListener("fetch", this.handleFetch);
-        self.addEventListener("message", this.handleCache);
+    warmRuntimeCache(entries) {
+        if (!this._options.warmEntries) this._options.warmEntries = [];
+        this._options.warmEntries.push(...entries);
     }
-    handleInstall(event) {
+}
+
+const addEventListeners = (state)=>{
+    self.addEventListener("install", createInstallHandler(state));
+    self.addEventListener("activate", createActivateHandler(state));
+    self.addEventListener("fetch", createFetchHandler(state));
+    self.addEventListener("message", createCacheHandler(state));
+};
+const createInstallHandler = (state)=>{
+    return (event)=>{
         return waitUntil(event, async ()=>{
-            for (const callback of this.iterateControllers("install")){
-                await callback(event, this);
+            for (const callback of iterateExtensions(state, "install")){
+                await callback({
+                    event,
+                    serwist: state
+                });
             }
         });
-    }
-    handleActivate(event) {
+    };
+};
+const createActivateHandler = (state)=>{
+    return (event)=>{
         return waitUntil(event, async ()=>{
-            for (const callback of this.iterateControllers("activate")){
-                await callback(event, this);
+            for (const callback of iterateExtensions(state, "activate")){
+                await callback({
+                    event,
+                    serwist: state
+                });
             }
         });
-    }
-    handleFetch(event) {
+    };
+};
+const createFetchHandler = (state)=>{
+    return (event)=>{
         const { request } = event;
-        const responsePromise = this.handleRequest({
+        const responsePromise = handleRequest(state, {
             request,
             event
         });
         if (responsePromise) {
             event.respondWith(responsePromise);
         }
-    }
-    handleCache(event) {
+    };
+};
+const createCacheHandler = (state)=>{
+    return (event)=>{
         if (event.data && event.data.type === "CACHE_URLS") {
             const { payload } = event.data;
             if (process.env.NODE_ENV !== "production") {
@@ -2085,7 +2287,7 @@ class Serwist {
                 } else {
                     request = new Request(...entry);
                 }
-                return this.handleRequest({
+                return handleRequest(state, {
                     request,
                     event
                 });
@@ -2095,218 +2297,170 @@ class Serwist {
                 void requestPromises.then(()=>event.ports[0].postMessage(true));
             }
         }
+    };
+};
+const setDefaultHandler = (state, handler, method = defaultMethod)=>{
+    state.defaultHandlerMap.set(method, normalizeHandler(handler));
+};
+const setCatchHandler = (state, handler)=>{
+    state.catchHandler = normalizeHandler(handler);
+};
+function* iterateExtensions(state, name) {
+    if (!state.extensions) return;
+    for (const controller of state.extensions){
+        if (typeof controller[name] === "function") {
+            const callback = (param)=>{
+                controller[name](param);
+            };
+            yield callback;
+        }
+    }
+}
+
+const createSerwist = ({ precache, skipWaiting = false, importScripts, navigationPreload = false, cacheId, clientsClaim: clientsClaim$1 = false, disableDevLogs: disableDevLogs$1 = false, extensions = [] } = {})=>{
+    if (importScripts?.length) self.importScripts(...importScripts);
+    if (navigationPreload) enableNavigationPreload();
+    if (cacheId) setCacheNameDetails({
+        prefix: cacheId
+    });
+    if (skipWaiting) {
+        self.skipWaiting();
+    } else {
+        self.addEventListener("message", (event)=>{
+            if (event.data?.type === "SKIP_WAITING") {
+                self.skipWaiting();
+            }
+        });
+    }
+    if (clientsClaim$1) clientsClaim();
+    const precacheExtension = new Precache(precache ?? {
+        entries: []
+    });
+    const routes = new Map();
+    const defaultHandlerMap = new Map();
+    const exts = [
+        precacheExtension,
+        ...extensions
+    ];
+    const state = {
+        get routes () {
+            return routes;
+        },
+        get defaultHandlerMap () {
+            return defaultHandlerMap;
+        },
+        get precache () {
+            return precacheExtension;
+        },
+        get extensions () {
+            return exts;
+        }
+    };
+    for (const callback of iterateExtensions(state, "init")){
+        callback({
+            serwist: state
+        });
+    }
+    if (disableDevLogs$1) disableDevLogs();
+    return state;
+};
+
+class Serwist {
+    _state;
+    _installHandler;
+    _activateHandler;
+    _fetchHandler;
+    _cacheHandler;
+    constructor({ precacheEntries, precacheOptions, skipWaiting = false, importScripts, navigationPreload = false, cacheId, clientsClaim = false, runtimeCaching, offlineAnalyticsConfig, disableDevLogs = false, fallbacks, extensions } = {}){
+        this.handleInstall = this.handleInstall.bind(this);
+        this.handleActivate = this.handleActivate.bind(this);
+        this.handleFetch = this.handleFetch.bind(this);
+        this.handleCache = this.handleCache.bind(this);
+        this._state = createSerwist({
+            precache: {
+                entries: precacheEntries ?? [],
+                ...precacheOptions
+            },
+            extensions: [
+                !extensions?.some((ext)=>ext instanceof RuntimeCache) && runtimeCaching !== undefined ? new RuntimeCache(runtimeCaching, {
+                    fallbacks
+                }) : undefined,
+                !extensions?.some((ext)=>ext instanceof GoogleAnalytics) && offlineAnalyticsConfig !== undefined ? typeof offlineAnalyticsConfig === "boolean" ? offlineAnalyticsConfig ? new GoogleAnalytics() : undefined : new GoogleAnalytics(offlineAnalyticsConfig) : undefined,
+                ...extensions ?? []
+            ].filter((extension)=>extension !== undefined),
+            skipWaiting,
+            importScripts,
+            navigationPreload,
+            cacheId,
+            clientsClaim,
+            disableDevLogs
+        });
+        this._installHandler = createInstallHandler(this._state);
+        this._activateHandler = createActivateHandler(this._state);
+        this._fetchHandler = createFetchHandler(this._state);
+        this._cacheHandler = createCacheHandler(this._state);
+    }
+    get precache() {
+        return this._state.precache;
+    }
+    get precacheStrategy() {
+        return this._state.precache.strategy;
+    }
+    get routes() {
+        return this._state.routes;
+    }
+    get state() {
+        return this._state;
+    }
+    addEventListeners() {
+        self.addEventListener("install", this._installHandler);
+        self.addEventListener("activate", this._activateHandler);
+        self.addEventListener("fetch", this._fetchHandler);
+        self.addEventListener("message", this._cacheHandler);
     }
-    setDefaultHandler(handler, method = defaultMethod) {
-        this._defaultHandlerMap.set(method, normalizeHandler(handler));
+    handleInstall(event) {
+        return this._installHandler(event);
+    }
+    handleActivate(event) {
+        return this._activateHandler(event);
+    }
+    handleFetch(event) {
+        return this._fetchHandler(event);
+    }
+    handleCache(event) {
+        return this._cacheHandler(event);
+    }
+    setDefaultHandler(handler, method) {
+        setDefaultHandler(this._state, handler, method);
     }
     setCatchHandler(handler) {
-        this._catchHandler = normalizeHandler(handler);
+        setCatchHandler(this._state, handler);
     }
     registerCapture(capture, handler, method) {
-        const route = parseRoute(capture, handler, method);
-        this.registerRoute(route);
-        return route;
+        return registerCapture(this._state, capture, handler, method);
     }
     registerRoute(route) {
-        if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isType(route, "object", {
-                moduleName: "serwist",
-                className: "Serwist",
-                funcName: "registerRoute",
-                paramName: "route"
-            });
-            finalAssertExports.hasMethod(route, "match", {
-                moduleName: "serwist",
-                className: "Serwist",
-                funcName: "registerRoute",
-                paramName: "route"
-            });
-            finalAssertExports.isType(route.handler, "object", {
-                moduleName: "serwist",
-                className: "Serwist",
-                funcName: "registerRoute",
-                paramName: "route"
-            });
-            finalAssertExports.hasMethod(route.handler, "handle", {
-                moduleName: "serwist",
-                className: "Serwist",
-                funcName: "registerRoute",
-                paramName: "route.handler"
-            });
-            finalAssertExports.isType(route.method, "string", {
-                moduleName: "serwist",
-                className: "Serwist",
-                funcName: "registerRoute",
-                paramName: "route.method"
-            });
-        }
-        if (!this._routes.has(route.method)) {
-            this._routes.set(route.method, []);
-        }
-        this._routes.get(route.method).push(route);
+        registerRoute(this._state, route);
     }
     unregisterRoute(route) {
-        if (!this._routes.has(route.method)) {
-            throw new SerwistError("unregister-route-but-not-found-with-method", {
-                method: route.method
-            });
-        }
-        const routeIndex = this._routes.get(route.method).indexOf(route);
-        if (routeIndex > -1) {
-            this._routes.get(route.method).splice(routeIndex, 1);
-        } else {
-            throw new SerwistError("unregister-route-route-not-registered");
-        }
+        unregisterRoute(this._state, route);
     }
     handleRequest({ request, event }) {
-        if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isInstance(request, Request, {
-                moduleName: "serwist",
-                className: "Serwist",
-                funcName: "handleRequest",
-                paramName: "options.request"
-            });
-        }
-        const url = new URL(request.url, location.href);
-        if (!url.protocol.startsWith("http")) {
-            if (process.env.NODE_ENV !== "production") {
-                logger.debug("Router only supports URLs that start with 'http'.");
-            }
-            return;
-        }
-        const sameOrigin = url.origin === location.origin;
-        const { params, route } = this.findMatchingRoute({
-            event,
+        return handleRequest(this._state, {
             request,
-            sameOrigin,
-            url
+            event
         });
-        let handler = route?.handler;
-        const debugMessages = [];
-        if (process.env.NODE_ENV !== "production") {
-            if (handler) {
-                debugMessages.push([
-                    "Found a route to handle this request:",
-                    route
-                ]);
-                if (params) {
-                    debugMessages.push([
-                        `Passing the following params to the route's handler:`,
-                        params
-                    ]);
-                }
-            }
-        }
-        const method = request.method;
-        if (!handler && this._defaultHandlerMap.has(method)) {
-            if (process.env.NODE_ENV !== "production") {
-                debugMessages.push(`Failed to find a matching route. Falling back to the default handler for ${method}.`);
-            }
-            handler = this._defaultHandlerMap.get(method);
-        }
-        if (!handler) {
-            if (process.env.NODE_ENV !== "production") {
-                logger.debug(`No route found for: ${getFriendlyURL(url)}`);
-            }
-            return;
-        }
-        if (process.env.NODE_ENV !== "production") {
-            logger.groupCollapsed(`Router is responding to: ${getFriendlyURL(url)}`);
-            for (const msg of debugMessages){
-                if (Array.isArray(msg)) {
-                    logger.log(...msg);
-                } else {
-                    logger.log(msg);
-                }
-            }
-            logger.groupEnd();
-        }
-        let responsePromise;
-        try {
-            responsePromise = handler.handle({
-                url,
-                request,
-                event,
-                params
-            });
-        } catch (err) {
-            responsePromise = Promise.reject(err);
-        }
-        const catchHandler = route?.catchHandler;
-        if (responsePromise instanceof Promise && (this._catchHandler || catchHandler)) {
-            responsePromise = responsePromise.catch(async (err)=>{
-                if (catchHandler) {
-                    if (process.env.NODE_ENV !== "production") {
-                        logger.groupCollapsed(`Error thrown when responding to:  ${getFriendlyURL(url)}. Falling back to route's Catch Handler.`);
-                        logger.error("Error thrown by:", route);
-                        logger.error(err);
-                        logger.groupEnd();
-                    }
-                    try {
-                        return await catchHandler.handle({
-                            url,
-                            request,
-                            event,
-                            params
-                        });
-                    } catch (catchErr) {
-                        if (catchErr instanceof Error) {
-                            err = catchErr;
-                        }
-                    }
-                }
-                if (this._catchHandler) {
-                    if (process.env.NODE_ENV !== "production") {
-                        logger.groupCollapsed(`Error thrown when responding to:  ${getFriendlyURL(url)}. Falling back to global Catch Handler.`);
-                        logger.error("Error thrown by:", route);
-                        logger.error(err);
-                        logger.groupEnd();
-                    }
-                    return this._catchHandler.handle({
-                        url,
-                        request,
-                        event
-                    });
-                }
-                throw err;
-            });
-        }
-        return responsePromise;
     }
     findMatchingRoute({ url, sameOrigin, request, event }) {
-        const routes = this._routes.get(request.method) || [];
-        for (const route of routes){
-            let params;
-            const matchResult = route.match({
-                url,
-                sameOrigin,
-                request,
-                event
-            });
-            if (matchResult) {
-                if (process.env.NODE_ENV !== "production") {
-                    if (matchResult instanceof Promise) {
-                        logger.warn(`While routing ${getFriendlyURL(url)}, an async matchCallback function was used. Please convert the following route to use a synchronous matchCallback function:`, route);
-                    }
-                }
-                params = matchResult;
-                if (Array.isArray(params) && params.length === 0) {
-                    params = undefined;
-                } else if (matchResult.constructor === Object && Object.keys(matchResult).length === 0) {
-                    params = undefined;
-                } else if (typeof matchResult === "boolean") {
-                    params = undefined;
-                }
-                return {
-                    route,
-                    params
-                };
-            }
-        }
-        return {};
+        return findMatchingRoute(this._state, {
+            url,
+            sameOrigin,
+            request,
+            event
+        });
     }
     addToPrecacheList(entries) {
-        this._precacheController.addToCacheList(entries);
+        this.precache.addToCacheList(entries);
     }
     getUrlsToPrecacheKeys() {
         return this.precache.getUrlsToPrecacheKeys();
@@ -2328,24 +2482,6 @@ class Serwist {
     }
 }
 
-const cacheNames = {
-    get googleAnalytics () {
-        return cacheNames$1.getGoogleAnalyticsName();
-    },
-    get precache () {
-        return cacheNames$1.getPrecacheName();
-    },
-    get prefix () {
-        return cacheNames$1.getPrefix();
-    },
-    get runtime () {
-        return cacheNames$1.getRuntimeName();
-    },
-    get suffix () {
-        return cacheNames$1.getSuffix();
-    }
-};
-
 const BROADCAST_UPDATE_MESSAGE_TYPE = "CACHE_UPDATED";
 const BROADCAST_UPDATE_MESSAGE_META = "serwist-broadcast-update";
 const BROADCAST_UPDATE_DEFAULT_NOTIFY = true;
@@ -2747,20 +2883,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;
@@ -2833,7 +2955,7 @@ class ExpirationPlugin {
         })();
         try {
             event.waitUntil(done);
-        } catch (error) {
+        } catch  {
             if (process.env.NODE_ENV !== "production") {
                 if (event instanceof FetchEvent) {
                     logger.warn(`Unable to ensure service worker stays alive when updating cache entry for '${getFriendlyURL(event.request.url)}'.`);
@@ -3033,7 +3155,7 @@ class CacheFirst extends Strategy {
             });
         }
         let response = await handler.cacheMatch(request);
-        let error = undefined;
+        let error;
         if (!response) {
             if (process.env.NODE_ENV !== "production") {
                 logs.push(`No response found in the '${this.cacheName}' cache. Will respond with a network request.`);
@@ -3125,7 +3247,7 @@ class StaleWhileRevalidate extends Strategy {
         const fetchAndCachePromise = handler.fetchAndCachePut(request).catch(()=>{});
         void handler.waitUntil(fetchAndCachePromise);
         let response = await handler.cacheMatch(request);
-        let error = undefined;
+        let error;
         if (response) {
             if (process.env.NODE_ENV !== "production") {
                 logs.push(`Found a cached response in the '${this.cacheName}' cache. Will update with the network response in the background.`);
@@ -3160,4 +3282,4 @@ class StaleWhileRevalidate extends Strategy {
     }
 }
 
-export { BROADCAST_UPDATE_DEFAULT_HEADERS, BackgroundSyncPlugin, BackgroundSyncQueue, BackgroundSyncQueueStore, BroadcastCacheUpdate, BroadcastUpdatePlugin, CacheExpiration, CacheFirst, CacheOnly, CacheableResponse, CacheableResponsePlugin, ExpirationPlugin, NavigationRoute, NetworkFirst, NetworkOnly, PrecacheFallbackPlugin, PrecacheRoute, PrecacheStrategy, RangeRequestsPlugin, RegExpRoute, Route, RuntimeCacheController, Serwist, StaleWhileRevalidate, StorableRequest, Strategy, StrategyHandler, cacheNames, copyResponse, createPartialResponse, disableDevLogs, disableNavigationPreload, enableNavigationPreload, initializeGoogleAnalytics, isNavigationPreloadSupported, registerQuotaErrorCallback, responsesAreSame, setCacheNameDetails };
+export { BROADCAST_UPDATE_DEFAULT_HEADERS, BackgroundSyncPlugin, BackgroundSyncQueue, BackgroundSyncQueueStore, BroadcastCacheUpdate, BroadcastUpdatePlugin, CacheExpiration, CacheFirst, CacheOnly, CacheableResponse, CacheableResponsePlugin, ExpirationPlugin, GoogleAnalytics, NavigationRoute, NetworkFirst, NetworkOnly, PrecacheFallbackPlugin, PrecacheRoute, PrecacheStrategy, RangeRequestsPlugin, RegExpRoute, Route, RuntimeCache, Serwist, StaleWhileRevalidate, StorableRequest, Strategy, StrategyHandler, addEventListeners, cacheNames, copyResponse, createActivateHandler, createCacheHandler, createFetchHandler, createInstallHandler, createPartialResponse, createSerwist, disableDevLogs, disableNavigationPreload, enableNavigationPreload, findMatchingRoute, handleRequest, initializeGoogleAnalytics, isNavigationPreloadSupported, iterateExtensions, registerCapture, registerQuotaErrorCallback, registerRoute, responsesAreSame, setCacheNameDetails, setCatchHandler, setDefaultHandler, unregisterRoute };