serwist 9.2.2 → 9.3.0

package/dist/index.js

@@ -1,1531 +1,1531 @@
-import { R as Route, g as generateURLVariations, B as BackgroundSyncPlugin, N as NetworkFirst, a as NetworkOnly, P as PrecacheStrategy, e as enableNavigationPreload, s as setCacheNameDetails, b as NavigationRoute, S as Strategy, d as disableDevLogs, c as createCacheKey, f as defaultMethod, n as normalizeHandler, p as parseRoute, h as PrecacheInstallReportPlugin, i as parallel, j as printInstallDetails, k as printCleanupDetails, m as messages, l as cacheOkAndOpaquePlugin } from './chunks/printInstallDetails.js';
+import { c as cacheNames$1, S as SerwistError, l as logger, f as finalAssertExports, t as timeout, g as getFriendlyURL, q as quotaErrorCallbacks, a as clientsClaim, b as cleanupOutdatedCaches, w as waitUntil } from './chunks/waitUntil.js';
+import { B as BackgroundSyncPlugin, N as NetworkFirst, R as Route, a as NetworkOnly, S as Strategy, m as messages, c as cacheOkAndOpaquePlugin, g as generateURLVariations, P as PrecacheStrategy, e as enableNavigationPreload, s as setCacheNameDetails, b as NavigationRoute, d as disableDevLogs, f as createCacheKey, h as defaultMethod, n as normalizeHandler, p as parseRoute, i as PrecacheInstallReportPlugin, j as parallel, k as printInstallDetails, l as printCleanupDetails } from './chunks/printInstallDetails.js';
 export { v as BackgroundSyncQueue, w as BackgroundSyncQueueStore, u as RegExpRoute, x as StorableRequest, t as StrategyHandler, o as copyResponse, q as disableNavigationPreload, r as isNavigationPreloadSupported } from './chunks/printInstallDetails.js';
-import { l as logger, g as getFriendlyURL, c as cacheNames$1, a as clientsClaim, b as cleanupOutdatedCaches, f as finalAssertExports, S as SerwistError, w as waitUntil, t as timeout, q as quotaErrorCallbacks } from './chunks/waitUntil.js';
 import { r as resultingClientExists } from './chunks/resultingClientExists.js';
 import { deleteDB, openDB } from 'idb';
 
-class PrecacheRoute extends Route {
-    constructor(serwist, options){
-        const match = ({ request })=>{
-            const urlsToCacheKeys = serwist.getUrlsToPrecacheKeys();
-            for (const possibleURL of generateURLVariations(request.url, options)){
-                const cacheKey = urlsToCacheKeys.get(possibleURL);
-                if (cacheKey) {
-                    const integrity = serwist.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, serwist.precacheStrategy);
+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 QUEUE_NAME = "serwist-google-analytics";
-const MAX_RETENTION_TIME = 60 * 48;
-const GOOGLE_ANALYTICS_HOST = "www.google-analytics.com";
-const GTM_HOST = "www.googletagmanager.com";
-const ANALYTICS_JS_PATH = "/analytics.js";
-const GTAG_JS_PATH = "/gtag/js";
-const GTM_JS_PATH = "/gtm.js";
-const COLLECT_PATHS_REGEX = /^\/(\w+\/)?collect/;
+const BROADCAST_UPDATE_MESSAGE_TYPE = "CACHE_UPDATED";
+const BROADCAST_UPDATE_MESSAGE_META = "serwist-broadcast-update";
+const BROADCAST_UPDATE_DEFAULT_NOTIFY = true;
+const BROADCAST_UPDATE_DEFAULT_HEADERS = [
+    "content-length",
+    "etag",
+    "last-modified"
+];
 
-const createOnSyncCallback = (config)=>{
-    return async ({ queue })=>{
-        let entry;
-        while(entry = await queue.shiftRequest()){
-            const { request, timestamp } = entry;
-            const url = new URL(request.url);
-            try {
-                const params = request.method === "POST" ? new URLSearchParams(await request.clone().text()) : url.searchParams;
-                const originalHitTime = timestamp - (Number(params.get("qt")) || 0);
-                const queueTime = Date.now() - originalHitTime;
-                params.set("qt", String(queueTime));
-                if (config.parameterOverrides) {
-                    for (const param of Object.keys(config.parameterOverrides)){
-                        const value = config.parameterOverrides[param];
-                        params.set(param, value);
-                    }
-                }
-                if (typeof config.hitFilter === "function") {
-                    config.hitFilter.call(null, params);
-                }
-                await fetch(new Request(url.origin + url.pathname, {
-                    body: params.toString(),
-                    method: "POST",
-                    mode: "cors",
-                    credentials: "omit",
-                    headers: {
-                        "Content-Type": "text/plain"
-                    }
-                }));
-                if (process.env.NODE_ENV !== "production") {
-                    logger.log(`Request for '${getFriendlyURL(url.href)}' has been replayed`);
-                }
-            } catch (err) {
-                await queue.unshiftRequest(entry);
-                if (process.env.NODE_ENV !== "production") {
-                    logger.log(`Request for '${getFriendlyURL(url.href)}' failed to replay, putting it back in the queue.`);
-                }
-                throw err;
-            }
+const responsesAreSame = (firstResponse, secondResponse, headersToCheck)=>{
+    if (process.env.NODE_ENV !== "production") {
+        if (!(firstResponse instanceof Response && secondResponse instanceof Response)) {
+            throw new SerwistError("invalid-responses-are-same-args");
         }
+    }
+    const atLeastOneHeaderAvailable = headersToCheck.some((header)=>{
+        return firstResponse.headers.has(header) && secondResponse.headers.has(header);
+    });
+    if (!atLeastOneHeaderAvailable) {
         if (process.env.NODE_ENV !== "production") {
-            logger.log("All Google Analytics request successfully replayed; " + "the queue is now empty!");
+            logger.warn("Unable to determine where the response has been updated because none of the headers that would be checked are present.");
+            logger.debug("Attempting to compare the following: ", firstResponse, secondResponse, headersToCheck);
         }
-    };
-};
-const createCollectRoutes = (bgSyncPlugin)=>{
-    const match = ({ url })=>url.hostname === GOOGLE_ANALYTICS_HOST && COLLECT_PATHS_REGEX.test(url.pathname);
-    const handler = new NetworkOnly({
-        plugins: [
-            bgSyncPlugin
-        ]
-    });
-    return [
-        new Route(match, handler, "GET"),
-        new Route(match, handler, "POST")
-    ];
-};
-const createAnalyticsJsRoute = (cacheName)=>{
-    const match = ({ url })=>url.hostname === GOOGLE_ANALYTICS_HOST && url.pathname === ANALYTICS_JS_PATH;
-    const handler = new NetworkFirst({
-        cacheName
-    });
-    return new Route(match, handler, "GET");
-};
-const createGtagJsRoute = (cacheName)=>{
-    const match = ({ url })=>url.hostname === GTM_HOST && url.pathname === GTAG_JS_PATH;
-    const handler = new NetworkFirst({
-        cacheName
-    });
-    return new Route(match, handler, "GET");
-};
-const createGtmJsRoute = (cacheName)=>{
-    const match = ({ url })=>url.hostname === GTM_HOST && url.pathname === GTM_JS_PATH;
-    const handler = new NetworkFirst({
-        cacheName
-    });
-    return new Route(match, handler, "GET");
-};
-const initializeGoogleAnalytics = ({ serwist, cacheName, ...options })=>{
-    const resolvedCacheName = cacheNames$1.getGoogleAnalyticsName(cacheName);
-    const bgSyncPlugin = new BackgroundSyncPlugin(QUEUE_NAME, {
-        maxRetentionTime: MAX_RETENTION_TIME,
-        onSync: createOnSyncCallback(options)
-    });
-    const routes = [
-        createGtmJsRoute(resolvedCacheName),
-        createAnalyticsJsRoute(resolvedCacheName),
-        createGtagJsRoute(resolvedCacheName),
-        ...createCollectRoutes(bgSyncPlugin)
-    ];
-    for (const route of routes){
-        serwist.registerRoute(route);
+        return true;
     }
+    return headersToCheck.every((header)=>{
+        const headerStateComparison = firstResponse.headers.has(header) === secondResponse.headers.has(header);
+        const headerValueComparison = firstResponse.headers.get(header) === secondResponse.headers.get(header);
+        return headerStateComparison && headerValueComparison;
+    });
 };
 
-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 = await this._serwist.matchPrecache(fallback);
-                if (fallbackResponse !== undefined) {
-                    return fallbackResponse;
-                }
-            } else if (fallback.matcher(param)) {
-                const fallbackResponse = await this._serwist.matchPrecache(fallback.url);
-                if (fallbackResponse !== undefined) {
-                    return fallbackResponse;
-                }
-            }
-        }
-        return undefined;
-    }
-}
-
-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 = (serwist, precacheOptions = {})=>{
-    const { cacheName: precacheCacheName, plugins: precachePlugins = [], fetchOptions: precacheFetchOptions, matchOptions: precacheMatchOptions, fallbackToNetwork: precacheFallbackToNetwork, directoryIndex: precacheDirectoryIndex, ignoreURLParametersMatching: precacheIgnoreUrls, cleanURLs: precacheCleanUrls, urlManipulation: precacheUrlManipulation, cleanupOutdatedCaches, concurrency = 10, navigateFallback, navigateFallbackAllowlist, navigateFallbackDenylist } = precacheOptions ?? {};
+const isSafari = typeof navigator !== "undefined" && /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+const defaultPayloadGenerator = (data)=>{
     return {
-        precacheStrategyOptions: {
-            cacheName: cacheNames$1.getPrecacheName(precacheCacheName),
-            plugins: [
-                ...precachePlugins,
-                new PrecacheCacheKeyPlugin({
-                    precacheController: serwist
-                })
-            ],
-            fetchOptions: precacheFetchOptions,
-            matchOptions: precacheMatchOptions,
-            fallbackToNetwork: precacheFallbackToNetwork
-        },
-        precacheRouteOptions: {
-            directoryIndex: precacheDirectoryIndex,
-            ignoreURLParametersMatching: precacheIgnoreUrls,
-            cleanURLs: precacheCleanUrls,
-            urlManipulation: precacheUrlManipulation
-        },
-        precacheMiscOptions: {
-            cleanupOutdatedCaches,
-            concurrency,
-            navigateFallback,
-            navigateFallbackAllowlist,
-            navigateFallbackDenylist
-        }
+        cacheName: data.cacheName,
+        updatedURL: data.request.url
     };
 };
-
-class Serwist {
-    _urlsToCacheKeys = new Map();
-    _urlsToCacheModes = new Map();
-    _cacheKeysToIntegrities = new Map();
-    _concurrentPrecaching;
-    _precacheStrategy;
-    _routes;
-    _defaultHandlerMap;
-    _catchHandler;
-    _requestRules;
-    constructor({ precacheEntries, precacheOptions, skipWaiting = false, importScripts, navigationPreload = false, cacheId, clientsClaim: clientsClaim$1 = false, runtimeCaching, offlineAnalyticsConfig, disableDevLogs: disableDevLogs$1 = false, fallbacks, requestRules } = {}){
-        const { precacheStrategyOptions, precacheRouteOptions, precacheMiscOptions } = parsePrecacheOptions(this, precacheOptions);
-        this._concurrentPrecaching = precacheMiscOptions.concurrency;
-        this._precacheStrategy = new PrecacheStrategy(precacheStrategyOptions);
-        this._routes = new Map();
-        this._defaultHandlerMap = new Map();
-        this._requestRules = requestRules;
-        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
-            });
-        }
-        if (skipWaiting) {
-            self.skipWaiting();
-        } else {
-            self.addEventListener("message", (event)=>{
-                if (event.data && event.data.type === "SKIP_WAITING") {
-                    self.skipWaiting();
-                }
-            });
-        }
-        if (clientsClaim$1) clientsClaim();
-        if (!!precacheEntries && precacheEntries.length > 0) {
-            this.addToPrecacheList(precacheEntries);
-        }
-        if (precacheMiscOptions.cleanupOutdatedCaches) {
-            cleanupOutdatedCaches(precacheStrategyOptions.cacheName);
-        }
-        this.registerRoute(new PrecacheRoute(this, precacheRouteOptions));
-        if (precacheMiscOptions.navigateFallback) {
-            this.registerRoute(new NavigationRoute(this.createHandlerBoundToUrl(precacheMiscOptions.navigateFallback), {
-                allowlist: precacheMiscOptions.navigateFallbackAllowlist,
-                denylist: precacheMiscOptions.navigateFallbackDenylist
-            }));
-        }
-        if (offlineAnalyticsConfig !== undefined) {
-            if (typeof offlineAnalyticsConfig === "boolean") {
-                offlineAnalyticsConfig && initializeGoogleAnalytics({
-                    serwist: this
-                });
-            } else {
-                initializeGoogleAnalytics({
-                    ...offlineAnalyticsConfig,
-                    serwist: this
-                });
-            }
-        }
-        if (runtimeCaching !== undefined) {
-            if (fallbacks !== undefined) {
-                const fallbackPlugin = new PrecacheFallbackPlugin({
-                    fallbackUrls: fallbacks.entries,
-                    serwist: this
-                });
-                runtimeCaching.forEach((cacheEntry)=>{
-                    if (cacheEntry.handler instanceof Strategy && !cacheEntry.handler.plugins.some((plugin)=>"handlerDidError" in plugin)) {
-                        cacheEntry.handler.plugins.push(fallbackPlugin);
-                    }
-                });
-            }
-            for (const entry of runtimeCaching){
-                this.registerCapture(entry.matcher, entry.handler, entry.method);
-            }
-        }
-        if (disableDevLogs$1) disableDevLogs();
-    }
-    get precacheStrategy() {
-        return this._precacheStrategy;
-    }
-    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);
+class BroadcastCacheUpdate {
+    _headersToCheck;
+    _generatePayload;
+    _notifyAllClients;
+    constructor({ generatePayload, headersToCheck, notifyAllClients } = {}){
+        this._headersToCheck = headersToCheck || BROADCAST_UPDATE_DEFAULT_HEADERS;
+        this._generatePayload = generatePayload || defaultPayloadGenerator;
+        this._notifyAllClients = notifyAllClients ?? BROADCAST_UPDATE_DEFAULT_NOTIFY;
     }
-    addToPrecacheList(entries) {
+    async notifyIfUpdated(options) {
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isArray(entries, {
+            finalAssertExports.isType(options.cacheName, "string", {
                 moduleName: "serwist",
-                className: "Serwist",
-                funcName: "addToCacheList",
-                paramName: "entries"
+                className: "BroadcastCacheUpdate",
+                funcName: "notifyIfUpdated",
+                paramName: "cacheName"
             });
-        }
-        const urlsToWarnAbout = [];
-        for (const entry of entries){
-            if (typeof entry === "string") {
-                urlsToWarnAbout.push(entry);
-            } else if (entry && !entry.integrity && entry.revision === undefined) {
-                urlsToWarnAbout.push(entry.url);
-            }
-            const { cacheKey, url } = createCacheKey(entry);
-            const cacheMode = typeof entry !== "string" && entry.revision ? "reload" : "default";
-            if (this._urlsToCacheKeys.has(url) && this._urlsToCacheKeys.get(url) !== cacheKey) {
-                throw new SerwistError("add-to-cache-list-conflicting-entries", {
-                    firstEntry: this._urlsToCacheKeys.get(url),
-                    secondEntry: cacheKey
-                });
-            }
-            if (typeof entry !== "string" && entry.integrity) {
-                if (this._cacheKeysToIntegrities.has(cacheKey) && this._cacheKeysToIntegrities.get(cacheKey) !== entry.integrity) {
-                    throw new SerwistError("add-to-cache-list-conflicting-integrities", {
-                        url
-                    });
-                }
-                this._cacheKeysToIntegrities.set(cacheKey, entry.integrity);
-            }
-            this._urlsToCacheKeys.set(url, cacheKey);
-            this._urlsToCacheModes.set(url, cacheMode);
-        }
-        if (urlsToWarnAbout.length > 0) {
-            const warningMessage = `Serwist is precaching URLs without revision info: ${urlsToWarnAbout.join(", ")}\nThis is generally NOT safe. Learn more at https://bit.ly/wb-precache`;
-            if (process.env.NODE_ENV === "production") {
-                console.warn(warningMessage);
-            } else {
-                logger.warn(warningMessage);
-            }
-        }
-    }
-    handleInstall(event) {
-        void this.registerRequestRules(event);
-        return waitUntil(event, async ()=>{
-            const installReportPlugin = new PrecacheInstallReportPlugin();
-            this.precacheStrategy.plugins.push(installReportPlugin);
-            await parallel(this._concurrentPrecaching, Array.from(this._urlsToCacheKeys.entries()), async ([url, cacheKey])=>{
-                const integrity = this._cacheKeysToIntegrities.get(cacheKey);
-                const cacheMode = this._urlsToCacheModes.get(url);
-                const request = new Request(url, {
-                    integrity,
-                    cache: cacheMode,
-                    credentials: "same-origin"
-                });
-                await Promise.all(this.precacheStrategy.handleAll({
-                    event,
-                    request,
-                    url: new URL(request.url),
-                    params: {
-                        cacheKey
-                    }
-                }));
+            finalAssertExports.isInstance(options.newResponse, Response, {
+                moduleName: "serwist",
+                className: "BroadcastCacheUpdate",
+                funcName: "notifyIfUpdated",
+                paramName: "newResponse"
+            });
+            finalAssertExports.isInstance(options.request, Request, {
+                moduleName: "serwist",
+                className: "BroadcastCacheUpdate",
+                funcName: "notifyIfUpdated",
+                paramName: "request"
             });
-            const { updatedURLs, notUpdatedURLs } = installReportPlugin;
-            if (process.env.NODE_ENV !== "production") {
-                printInstallDetails(updatedURLs, notUpdatedURLs);
-            }
-            return {
-                updatedURLs,
-                notUpdatedURLs
-            };
-        });
-    }
-    async registerRequestRules(event) {
-        if (!this._requestRules) {
-            return;
         }
-        if (!event?.addRoutes) {
-            if (process.env.NODE_ENV !== "production") {
-                logger.warn("Request rules ignored as the Static Routing API is not supported in this browser. " + "See https://caniuse.com/mdn-api_installevent_addroutes for more information.");
-            }
+        if (!options.oldResponse) {
             return;
         }
-        try {
-            if (process.env.NODE_ENV !== "production") {
-                logger.warn("Request rules may not be supported in all browsers as the Static Routing API is experimental. " + "This feature allows bypassing the service worker for specific requests to improve performance. " + "See https://developer.mozilla.org/en-US/docs/Web/API/InstallEvent/addRoutes for more information.");
-            }
-            await event.addRoutes(this._requestRules);
-            this._requestRules = undefined;
-        } catch (error) {
-            if (process.env.NODE_ENV !== "production") {
-                logger.error(`Failed to register request rules: ${error instanceof Error ? error.message : String(error)}. ` + "This may occur if the browser doesn't support the Static Routing API or if the request rules are invalid.");
-            }
-            throw error;
-        }
-    }
-    handleActivate(event) {
-        return waitUntil(event, async ()=>{
-            const cache = await self.caches.open(this.precacheStrategy.cacheName);
-            const currentlyCachedRequests = await cache.keys();
-            const expectedCacheKeys = new Set(this._urlsToCacheKeys.values());
-            const deletedCacheRequests = [];
-            for (const request of currentlyCachedRequests){
-                if (!expectedCacheKeys.has(request.url)) {
-                    await cache.delete(request);
-                    deletedCacheRequests.push(request.url);
-                }
-            }
+        if (!responsesAreSame(options.oldResponse, options.newResponse, this._headersToCheck)) {
             if (process.env.NODE_ENV !== "production") {
-                printCleanupDetails(deletedCacheRequests);
+                logger.log("Newer response found (and cached) for:", options.request.url);
             }
-            return {
-                deletedCacheRequests
+            const messageData = {
+                type: BROADCAST_UPDATE_MESSAGE_TYPE,
+                meta: BROADCAST_UPDATE_MESSAGE_META,
+                payload: this._generatePayload(options)
             };
-        });
-    }
-    handleFetch(event) {
-        const { request } = event;
-        const responsePromise = this.handleRequest({
-            request,
-            event
-        });
-        if (responsePromise) {
-            event.respondWith(responsePromise);
-        }
-    }
-    handleCache(event) {
-        if (event.data && event.data.type === "CACHE_URLS") {
-            const { payload } = event.data;
-            if (process.env.NODE_ENV !== "production") {
-                logger.debug("Caching URLs from the window", payload.urlsToCache);
-            }
-            const requestPromises = Promise.all(payload.urlsToCache.map((entry)=>{
-                let request;
-                if (typeof entry === "string") {
-                    request = new Request(entry);
-                } else {
-                    request = new Request(...entry);
+            if (options.request.mode === "navigate") {
+                let resultingClientId;
+                if (options.event instanceof FetchEvent) {
+                    resultingClientId = options.event.resultingClientId;
                 }
-                return this.handleRequest({
-                    request,
-                    event
+                const resultingWin = await resultingClientExists(resultingClientId);
+                if (!resultingWin || isSafari) {
+                    await timeout(3500);
+                }
+            }
+            if (this._notifyAllClients) {
+                const windows = await self.clients.matchAll({
+                    type: "window"
                 });
-            }));
-            event.waitUntil(requestPromises);
-            if (event.ports?.[0]) {
-                void requestPromises.then(()=>event.ports[0].postMessage(true));
+                for (const win of windows){
+                    win.postMessage(messageData);
+                }
+            } else {
+                if (options.event instanceof FetchEvent) {
+                    const client = await self.clients.get(options.event.clientId);
+                    client?.postMessage(messageData);
+                }
             }
         }
     }
-    setDefaultHandler(handler, method = defaultMethod) {
-        this._defaultHandlerMap.set(method, normalizeHandler(handler));
-    }
-    setCatchHandler(handler) {
-        this._catchHandler = normalizeHandler(handler);
+}
+
+class BroadcastUpdatePlugin {
+    _broadcastUpdate;
+    constructor(options){
+        this._broadcastUpdate = new BroadcastCacheUpdate(options);
     }
-    registerCapture(capture, handler, method) {
-        const route = parseRoute(capture, handler, method);
-        this.registerRoute(route);
-        return route;
+    cacheDidUpdate(options) {
+        void this._broadcastUpdate.notifyIfUpdated(options);
     }
-    registerRoute(route) {
+}
+
+class CacheableResponse {
+    _statuses;
+    _headers;
+    constructor(config = {}){
         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 (!(config.statuses || config.headers)) {
+                throw new SerwistError("statuses-or-headers-required", {
+                    moduleName: "serwist",
+                    className: "CacheableResponse",
+                    funcName: "constructor"
+                });
+            }
+            if (config.statuses) {
+                finalAssertExports.isArray(config.statuses, {
+                    moduleName: "serwist",
+                    className: "CacheableResponse",
+                    funcName: "constructor",
+                    paramName: "config.statuses"
+                });
+            }
+            if (config.headers) {
+                finalAssertExports.isType(config.headers, "object", {
+                    moduleName: "serwist",
+                    className: "CacheableResponse",
+                    funcName: "constructor",
+                    paramName: "config.headers"
+                });
+            }
         }
-        if (!this._routes.has(route.method)) {
-            this._routes.set(route.method, []);
+        this._statuses = config.statuses;
+        if (config.headers) {
+            this._headers = new Headers(config.headers);
         }
-        this._routes.get(route.method).push(route);
     }
-    unregisterRoute(route) {
-        if (!this._routes.has(route.method)) {
-            throw new SerwistError("unregister-route-but-not-found-with-method", {
-                method: route.method
+    isResponseCacheable(response) {
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isInstance(response, Response, {
+                moduleName: "serwist",
+                className: "CacheableResponse",
+                funcName: "isResponseCacheable",
+                paramName: "response"
             });
         }
-        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");
+        let cacheable = true;
+        if (this._statuses) {
+            cacheable = this._statuses.includes(response.status);
+        }
+        if (this._headers && cacheable) {
+            for (const [headerName, headerValue] of this._headers.entries()){
+                if (response.headers.get(headerName) !== headerValue) {
+                    cacheable = false;
+                    break;
+                }
+            }
+        }
+        if (process.env.NODE_ENV !== "production") {
+            if (!cacheable) {
+                logger.groupCollapsed(`The request for '${getFriendlyURL(response.url)}' returned a response that does not meet the criteria for being cached.`);
+                logger.groupCollapsed("View cacheability criteria here.");
+                logger.log(`Cacheable statuses: ${JSON.stringify(this._statuses)}`);
+                logger.log(`Cacheable headers: ${JSON.stringify(this._headers, null, 2)}`);
+                logger.groupEnd();
+                const logFriendlyHeaders = {};
+                response.headers.forEach((value, key)=>{
+                    logFriendlyHeaders[key] = value;
+                });
+                logger.groupCollapsed("View response status and headers here.");
+                logger.log(`Response status: ${response.status}`);
+                logger.log(`Response headers: ${JSON.stringify(logFriendlyHeaders, null, 2)}`);
+                logger.groupEnd();
+                logger.groupCollapsed("View full response details here.");
+                logger.log(response.headers);
+                logger.log(response);
+                logger.groupEnd();
+                logger.groupEnd();
+            }
         }
+        return cacheable;
     }
-    getUrlsToPrecacheKeys() {
-        return this._urlsToCacheKeys;
+}
+
+class CacheableResponsePlugin {
+    _cacheableResponse;
+    constructor(config){
+        this._cacheableResponse = new CacheableResponse(config);
     }
-    getPrecachedUrls() {
-        return [
-            ...this._urlsToCacheKeys.keys()
-        ];
+    cacheWillUpdate = async ({ response })=>{
+        if (this._cacheableResponse.isResponseCacheable(response)) {
+            return response;
+        }
+        return null;
+    };
+}
+
+const DB_NAME = "serwist-expiration";
+const CACHE_OBJECT_STORE = "cache-entries";
+const normalizeURL = (unNormalizedUrl)=>{
+    const url = new URL(unNormalizedUrl, location.href);
+    url.hash = "";
+    return url.href;
+};
+class CacheTimestampsModel {
+    _cacheName;
+    _db = null;
+    constructor(cacheName){
+        this._cacheName = cacheName;
     }
-    getPrecacheKeyForUrl(url) {
-        const urlObject = new URL(url, location.href);
-        return this._urlsToCacheKeys.get(urlObject.href);
+    _getId(url) {
+        return `${this._cacheName}|${normalizeURL(url)}`;
     }
-    getIntegrityForPrecacheKey(cacheKey) {
-        return this._cacheKeysToIntegrities.get(cacheKey);
+    _upgradeDb(db) {
+        const objStore = db.createObjectStore(CACHE_OBJECT_STORE, {
+            keyPath: "id"
+        });
+        objStore.createIndex("cacheName", "cacheName", {
+            unique: false
+        });
+        objStore.createIndex("timestamp", "timestamp", {
+            unique: false
+        });
     }
-    async matchPrecache(request) {
-        const url = request instanceof Request ? request.url : request;
-        const cacheKey = this.getPrecacheKeyForUrl(url);
-        if (cacheKey) {
-            const cache = await self.caches.open(this.precacheStrategy.cacheName);
-            return cache.match(cacheKey);
+    _upgradeDbAndDeleteOldDbs(db) {
+        this._upgradeDb(db);
+        if (this._cacheName) {
+            void deleteDB(this._cacheName);
         }
-        return undefined;
     }
-    createHandlerBoundToUrl(url) {
-        const cacheKey = this.getPrecacheKeyForUrl(url);
-        if (!cacheKey) {
-            throw new SerwistError("non-precached-url", {
-                url
+    async setTimestamp(url, timestamp) {
+        url = normalizeURL(url);
+        const entry = {
+            id: this._getId(url),
+            cacheName: this._cacheName,
+            url,
+            timestamp
+        };
+        const db = await this.getDb();
+        const tx = db.transaction(CACHE_OBJECT_STORE, "readwrite", {
+            durability: "relaxed"
+        });
+        await tx.store.put(entry);
+        await tx.done;
+    }
+    async getTimestamp(url) {
+        const db = await this.getDb();
+        const entry = await db.get(CACHE_OBJECT_STORE, this._getId(url));
+        return entry?.timestamp;
+    }
+    async expireEntries(minTimestamp, maxCount) {
+        const db = await this.getDb();
+        let cursor = await db.transaction(CACHE_OBJECT_STORE, "readwrite").store.index("timestamp").openCursor(null, "prev");
+        const urlsDeleted = [];
+        let entriesNotDeletedCount = 0;
+        while(cursor){
+            const result = cursor.value;
+            if (result.cacheName === this._cacheName) {
+                if (minTimestamp && result.timestamp < minTimestamp || maxCount && entriesNotDeletedCount >= maxCount) {
+                    cursor.delete();
+                    urlsDeleted.push(result.url);
+                } else {
+                    entriesNotDeletedCount++;
+                }
+            }
+            cursor = await cursor.continue();
+        }
+        return urlsDeleted;
+    }
+    async getDb() {
+        if (!this._db) {
+            this._db = await openDB(DB_NAME, 1, {
+                upgrade: this._upgradeDbAndDeleteOldDbs.bind(this)
             });
         }
-        return (options)=>{
-            options.request = new Request(url);
-            options.params = {
-                cacheKey,
-                ...options.params
-            };
-            return this.precacheStrategy.handle(options);
-        };
+        return this._db;
     }
-    handleRequest({ request, event }) {
+}
+
+class CacheExpiration {
+    _isRunning = false;
+    _rerunRequested = false;
+    _maxEntries;
+    _maxAgeSeconds;
+    _matchOptions;
+    _cacheName;
+    _timestampModel;
+    constructor(cacheName, config = {}){
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isInstance(request, Request, {
+            finalAssertExports.isType(cacheName, "string", {
                 moduleName: "serwist",
-                className: "Serwist",
-                funcName: "handleRequest",
-                paramName: "options.request"
+                className: "CacheExpiration",
+                funcName: "constructor",
+                paramName: "cacheName"
             });
-        }
-        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'.");
+            if (!(config.maxEntries || config.maxAgeSeconds)) {
+                throw new SerwistError("max-entries-or-age-required", {
+                    moduleName: "serwist",
+                    className: "CacheExpiration",
+                    funcName: "constructor"
+                });
             }
-            return;
-        }
-        const sameOrigin = url.origin === location.origin;
-        const { params, route } = this.findMatchingRoute({
-            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
-                    ]);
-                }
+            if (config.maxEntries) {
+                finalAssertExports.isType(config.maxEntries, "number", {
+                    moduleName: "serwist",
+                    className: "CacheExpiration",
+                    funcName: "constructor",
+                    paramName: "config.maxEntries"
+                });
             }
-        }
-        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}.`);
+            if (config.maxAgeSeconds) {
+                finalAssertExports.isType(config.maxAgeSeconds, "number", {
+                    moduleName: "serwist",
+                    className: "CacheExpiration",
+                    funcName: "constructor",
+                    paramName: "config.maxAgeSeconds"
+                });
             }
-            handler = this._defaultHandlerMap.get(method);
         }
-        if (!handler) {
-            if (process.env.NODE_ENV !== "production") {
-                logger.debug(`No route found for: ${getFriendlyURL(url)}`);
-            }
+        this._maxEntries = config.maxEntries;
+        this._maxAgeSeconds = config.maxAgeSeconds;
+        this._matchOptions = config.matchOptions;
+        this._cacheName = cacheName;
+        this._timestampModel = new CacheTimestampsModel(cacheName);
+    }
+    async expireEntries() {
+        if (this._isRunning) {
+            this._rerunRequested = true;
             return;
         }
+        this._isRunning = true;
+        const minTimestamp = this._maxAgeSeconds ? Date.now() - this._maxAgeSeconds * 1000 : 0;
+        const urlsExpired = await this._timestampModel.expireEntries(minTimestamp, this._maxEntries);
+        const cache = await self.caches.open(this._cacheName);
+        for (const url of urlsExpired){
+            await cache.delete(url, this._matchOptions);
+        }
         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);
+            if (urlsExpired.length > 0) {
+                logger.groupCollapsed(`Expired ${urlsExpired.length} ` + `${urlsExpired.length === 1 ? "entry" : "entries"} and removed ` + `${urlsExpired.length === 1 ? "it" : "them"} from the ` + `'${this._cacheName}' cache.`);
+                logger.log(`Expired the following ${urlsExpired.length === 1 ? "URL" : "URLs"}:`);
+                for (const url of urlsExpired){
+                    logger.log(`    ${url}`);
                 }
+                logger.groupEnd();
+            } else {
+                logger.debug("Cache expiration ran and found no entries to remove.");
             }
-            logger.groupEnd();
         }
-        let responsePromise;
-        try {
-            responsePromise = handler.handle({
-                url,
-                request,
-                event,
-                params
-            });
-        } catch (err) {
-            responsePromise = Promise.reject(err);
+        this._isRunning = false;
+        if (this._rerunRequested) {
+            this._rerunRequested = false;
+            void this.expireEntries();
         }
-        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;
+    }
+    async updateTimestamp(url) {
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isType(url, "string", {
+                moduleName: "serwist",
+                className: "CacheExpiration",
+                funcName: "updateTimestamp",
+                paramName: "url"
             });
         }
-        return responsePromise;
+        await this._timestampModel.setTimestamp(url, Date.now());
     }
-    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
-                };
+    async isURLExpired(url) {
+        if (!this._maxAgeSeconds) {
+            if (process.env.NODE_ENV !== "production") {
+                throw new SerwistError("expired-test-without-max-age", {
+                    methodName: "isURLExpired",
+                    paramName: "maxAgeSeconds"
+                });
             }
+            return false;
         }
-        return {};
+        const timestamp = await this._timestampModel.getTimestamp(url);
+        const expireOlderThan = Date.now() - this._maxAgeSeconds * 1000;
+        return timestamp !== undefined ? timestamp < expireOlderThan : true;
+    }
+    async delete() {
+        this._rerunRequested = false;
+        await this._timestampModel.expireEntries(Number.POSITIVE_INFINITY);
     }
 }
 
-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 registerQuotaErrorCallback = (callback)=>{
+    if (process.env.NODE_ENV !== "production") {
+        finalAssertExports.isType(callback, "function", {
+            moduleName: "@serwist/core",
+            funcName: "register",
+            paramName: "callback"
+        });
+    }
+    quotaErrorCallbacks.add(callback);
+    if (process.env.NODE_ENV !== "production") {
+        logger.log("Registered a callback to respond to quota errors.", callback);
     }
 };
 
-const BROADCAST_UPDATE_MESSAGE_TYPE = "CACHE_UPDATED";
-const BROADCAST_UPDATE_MESSAGE_META = "serwist-broadcast-update";
-const BROADCAST_UPDATE_DEFAULT_NOTIFY = true;
-const BROADCAST_UPDATE_DEFAULT_HEADERS = [
-    "content-length",
-    "etag",
-    "last-modified"
-];
-
-const responsesAreSame = (firstResponse, secondResponse, headersToCheck)=>{
-    if (process.env.NODE_ENV !== "production") {
-        if (!(firstResponse instanceof Response && secondResponse instanceof Response)) {
-            throw new SerwistError("invalid-responses-are-same-args");
+class ExpirationPlugin {
+    _config;
+    _cacheExpirations;
+    constructor(config = {}){
+        if (process.env.NODE_ENV !== "production") {
+            if (!(config.maxEntries || config.maxAgeSeconds)) {
+                throw new SerwistError("max-entries-or-age-required", {
+                    moduleName: "serwist",
+                    className: "ExpirationPlugin",
+                    funcName: "constructor"
+                });
+            }
+            if (config.maxEntries) {
+                finalAssertExports.isType(config.maxEntries, "number", {
+                    moduleName: "serwist",
+                    className: "ExpirationPlugin",
+                    funcName: "constructor",
+                    paramName: "config.maxEntries"
+                });
+            }
+            if (config.maxAgeSeconds) {
+                finalAssertExports.isType(config.maxAgeSeconds, "number", {
+                    moduleName: "serwist",
+                    className: "ExpirationPlugin",
+                    funcName: "constructor",
+                    paramName: "config.maxAgeSeconds"
+                });
+            }
+            if (config.maxAgeFrom) {
+                finalAssertExports.isType(config.maxAgeFrom, "string", {
+                    moduleName: "serwist",
+                    className: "ExpirationPlugin",
+                    funcName: "constructor",
+                    paramName: "config.maxAgeFrom"
+                });
+            }
+        }
+        this._config = config;
+        this._cacheExpirations = new Map();
+        if (!this._config.maxAgeFrom) {
+            this._config.maxAgeFrom = "last-fetched";
+        }
+        if (this._config.purgeOnQuotaError) {
+            registerQuotaErrorCallback(()=>this.deleteCacheAndMetadata());
+        }
+    }
+    _getCacheExpiration(cacheName) {
+        if (cacheName === cacheNames$1.getRuntimeName()) {
+            throw new SerwistError("expire-custom-caches-only");
+        }
+        let cacheExpiration = this._cacheExpirations.get(cacheName);
+        if (!cacheExpiration) {
+            cacheExpiration = new CacheExpiration(cacheName, this._config);
+            this._cacheExpirations.set(cacheName, cacheExpiration);
+        }
+        return cacheExpiration;
+    }
+    cachedResponseWillBeUsed({ event, cacheName, request, cachedResponse }) {
+        if (!cachedResponse) {
+            return null;
+        }
+        const isFresh = this._isResponseDateFresh(cachedResponse);
+        const cacheExpiration = this._getCacheExpiration(cacheName);
+        const isMaxAgeFromLastUsed = this._config.maxAgeFrom === "last-used";
+        const done = (async ()=>{
+            if (isMaxAgeFromLastUsed) {
+                await cacheExpiration.updateTimestamp(request.url);
+            }
+            await cacheExpiration.expireEntries();
+        })();
+        try {
+            event.waitUntil(done);
+        } 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)}'.`);
+                }
+            }
+        }
+        return isFresh ? cachedResponse : null;
+    }
+    _isResponseDateFresh(cachedResponse) {
+        const isMaxAgeFromLastUsed = this._config.maxAgeFrom === "last-used";
+        if (isMaxAgeFromLastUsed) {
+            return true;
         }
-    }
-    const atLeastOneHeaderAvailable = headersToCheck.some((header)=>{
-        return firstResponse.headers.has(header) && secondResponse.headers.has(header);
-    });
-    if (!atLeastOneHeaderAvailable) {
-        if (process.env.NODE_ENV !== "production") {
-            logger.warn("Unable to determine where the response has been updated because none of the headers that would be checked are present.");
-            logger.debug("Attempting to compare the following: ", firstResponse, secondResponse, headersToCheck);
+        const now = Date.now();
+        if (!this._config.maxAgeSeconds) {
+            return true;
         }
-        return true;
+        const dateHeaderTimestamp = this._getDateHeaderTimestamp(cachedResponse);
+        if (dateHeaderTimestamp === null) {
+            return true;
+        }
+        return dateHeaderTimestamp >= now - this._config.maxAgeSeconds * 1000;
     }
-    return headersToCheck.every((header)=>{
-        const headerStateComparison = firstResponse.headers.has(header) === secondResponse.headers.has(header);
-        const headerValueComparison = firstResponse.headers.get(header) === secondResponse.headers.get(header);
-        return headerStateComparison && headerValueComparison;
-    });
-};
-
-const isSafari = typeof navigator !== "undefined" && /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
-const defaultPayloadGenerator = (data)=>{
-    return {
-        cacheName: data.cacheName,
-        updatedURL: data.request.url
-    };
-};
-class BroadcastCacheUpdate {
-    _headersToCheck;
-    _generatePayload;
-    _notifyAllClients;
-    constructor({ generatePayload, headersToCheck, notifyAllClients } = {}){
-        this._headersToCheck = headersToCheck || BROADCAST_UPDATE_DEFAULT_HEADERS;
-        this._generatePayload = generatePayload || defaultPayloadGenerator;
-        this._notifyAllClients = notifyAllClients ?? BROADCAST_UPDATE_DEFAULT_NOTIFY;
+    _getDateHeaderTimestamp(cachedResponse) {
+        if (!cachedResponse.headers.has("date")) {
+            return null;
+        }
+        const dateHeader = cachedResponse.headers.get("date");
+        const parsedDate = new Date(dateHeader);
+        const headerTime = parsedDate.getTime();
+        if (Number.isNaN(headerTime)) {
+            return null;
+        }
+        return headerTime;
     }
-    async notifyIfUpdated(options) {
+    async cacheDidUpdate({ cacheName, request }) {
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isType(options.cacheName, "string", {
+            finalAssertExports.isType(cacheName, "string", {
                 moduleName: "serwist",
-                className: "BroadcastCacheUpdate",
-                funcName: "notifyIfUpdated",
+                className: "Plugin",
+                funcName: "cacheDidUpdate",
                 paramName: "cacheName"
             });
-            finalAssertExports.isInstance(options.newResponse, Response, {
-                moduleName: "serwist",
-                className: "BroadcastCacheUpdate",
-                funcName: "notifyIfUpdated",
-                paramName: "newResponse"
-            });
-            finalAssertExports.isInstance(options.request, Request, {
+            finalAssertExports.isInstance(request, Request, {
                 moduleName: "serwist",
-                className: "BroadcastCacheUpdate",
-                funcName: "notifyIfUpdated",
+                className: "Plugin",
+                funcName: "cacheDidUpdate",
                 paramName: "request"
             });
         }
-        if (!options.oldResponse) {
-            return;
+        const cacheExpiration = this._getCacheExpiration(cacheName);
+        await cacheExpiration.updateTimestamp(request.url);
+        await cacheExpiration.expireEntries();
+    }
+    async deleteCacheAndMetadata() {
+        for (const [cacheName, cacheExpiration] of this._cacheExpirations){
+            await self.caches.delete(cacheName);
+            await cacheExpiration.delete();
         }
-        if (!responsesAreSame(options.oldResponse, options.newResponse, this._headersToCheck)) {
-            if (process.env.NODE_ENV !== "production") {
-                logger.log("Newer response found (and cached) for:", options.request.url);
-            }
-            const messageData = {
-                type: BROADCAST_UPDATE_MESSAGE_TYPE,
-                meta: BROADCAST_UPDATE_MESSAGE_META,
-                payload: this._generatePayload(options)
-            };
-            if (options.request.mode === "navigate") {
-                let resultingClientId;
-                if (options.event instanceof FetchEvent) {
-                    resultingClientId = options.event.resultingClientId;
+        this._cacheExpirations = new Map();
+    }
+}
+
+const QUEUE_NAME = "serwist-google-analytics";
+const MAX_RETENTION_TIME = 60 * 48;
+const GOOGLE_ANALYTICS_HOST = "www.google-analytics.com";
+const GTM_HOST = "www.googletagmanager.com";
+const ANALYTICS_JS_PATH = "/analytics.js";
+const GTAG_JS_PATH = "/gtag/js";
+const GTM_JS_PATH = "/gtm.js";
+const COLLECT_PATHS_REGEX = /^\/(\w+\/)?collect/;
+
+const createOnSyncCallback = (config)=>{
+    return async ({ queue })=>{
+        let entry;
+        while(entry = await queue.shiftRequest()){
+            const { request, timestamp } = entry;
+            const url = new URL(request.url);
+            try {
+                const params = request.method === "POST" ? new URLSearchParams(await request.clone().text()) : url.searchParams;
+                const originalHitTime = timestamp - (Number(params.get("qt")) || 0);
+                const queueTime = Date.now() - originalHitTime;
+                params.set("qt", String(queueTime));
+                if (config.parameterOverrides) {
+                    for (const param of Object.keys(config.parameterOverrides)){
+                        const value = config.parameterOverrides[param];
+                        params.set(param, value);
+                    }
                 }
-                const resultingWin = await resultingClientExists(resultingClientId);
-                if (!resultingWin || isSafari) {
-                    await timeout(3500);
+                if (typeof config.hitFilter === "function") {
+                    config.hitFilter.call(null, params);
+                }
+                await fetch(new Request(url.origin + url.pathname, {
+                    body: params.toString(),
+                    method: "POST",
+                    mode: "cors",
+                    credentials: "omit",
+                    headers: {
+                        "Content-Type": "text/plain"
+                    }
+                }));
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log(`Request for '${getFriendlyURL(url.href)}' has been replayed`);
+                }
+            } catch (err) {
+                await queue.unshiftRequest(entry);
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log(`Request for '${getFriendlyURL(url.href)}' failed to replay, putting it back in the queue.`);
                 }
+                throw err;
             }
-            if (this._notifyAllClients) {
-                const windows = await self.clients.matchAll({
-                    type: "window"
-                });
-                for (const win of windows){
-                    win.postMessage(messageData);
+        }
+        if (process.env.NODE_ENV !== "production") {
+            logger.log("All Google Analytics request successfully replayed; " + "the queue is now empty!");
+        }
+    };
+};
+const createCollectRoutes = (bgSyncPlugin)=>{
+    const match = ({ url })=>url.hostname === GOOGLE_ANALYTICS_HOST && COLLECT_PATHS_REGEX.test(url.pathname);
+    const handler = new NetworkOnly({
+        plugins: [
+            bgSyncPlugin
+        ]
+    });
+    return [
+        new Route(match, handler, "GET"),
+        new Route(match, handler, "POST")
+    ];
+};
+const createAnalyticsJsRoute = (cacheName)=>{
+    const match = ({ url })=>url.hostname === GOOGLE_ANALYTICS_HOST && url.pathname === ANALYTICS_JS_PATH;
+    const handler = new NetworkFirst({
+        cacheName
+    });
+    return new Route(match, handler, "GET");
+};
+const createGtagJsRoute = (cacheName)=>{
+    const match = ({ url })=>url.hostname === GTM_HOST && url.pathname === GTAG_JS_PATH;
+    const handler = new NetworkFirst({
+        cacheName
+    });
+    return new Route(match, handler, "GET");
+};
+const createGtmJsRoute = (cacheName)=>{
+    const match = ({ url })=>url.hostname === GTM_HOST && url.pathname === GTM_JS_PATH;
+    const handler = new NetworkFirst({
+        cacheName
+    });
+    return new Route(match, handler, "GET");
+};
+const initializeGoogleAnalytics = ({ serwist, cacheName, ...options })=>{
+    const resolvedCacheName = cacheNames$1.getGoogleAnalyticsName(cacheName);
+    const bgSyncPlugin = new BackgroundSyncPlugin(QUEUE_NAME, {
+        maxRetentionTime: MAX_RETENTION_TIME,
+        onSync: createOnSyncCallback(options)
+    });
+    const routes = [
+        createGtmJsRoute(resolvedCacheName),
+        createAnalyticsJsRoute(resolvedCacheName),
+        createGtagJsRoute(resolvedCacheName),
+        ...createCollectRoutes(bgSyncPlugin)
+    ];
+    for (const route of routes){
+        serwist.registerRoute(route);
+    }
+};
+
+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 = await this._serwist.matchPrecache(fallback);
+                if (fallbackResponse !== undefined) {
+                    return fallbackResponse;
                 }
-            } else {
-                if (options.event instanceof FetchEvent) {
-                    const client = await self.clients.get(options.event.clientId);
-                    client?.postMessage(messageData);
+            } else if (fallback.matcher(param)) {
+                const fallbackResponse = await this._serwist.matchPrecache(fallback.url);
+                if (fallbackResponse !== undefined) {
+                    return fallbackResponse;
                 }
             }
         }
+        return undefined;
+    }
+}
+
+const calculateEffectiveBoundaries = (blob, start, end)=>{
+    if (process.env.NODE_ENV !== "production") {
+        finalAssertExports.isInstance(blob, Blob, {
+            moduleName: "@serwist/range-requests",
+            funcName: "calculateEffectiveBoundaries",
+            paramName: "blob"
+        });
+    }
+    const blobSize = blob.size;
+    if (end && end > blobSize || start && start < 0) {
+        throw new SerwistError("range-not-satisfiable", {
+            size: blobSize,
+            end,
+            start
+        });
+    }
+    let effectiveStart;
+    let effectiveEnd;
+    if (start !== undefined && end !== undefined) {
+        effectiveStart = start;
+        effectiveEnd = end + 1;
+    } else if (start !== undefined && end === undefined) {
+        effectiveStart = start;
+        effectiveEnd = blobSize;
+    } else if (end !== undefined && start === undefined) {
+        effectiveStart = blobSize - end;
+        effectiveEnd = blobSize;
     }
-}
+    return {
+        start: effectiveStart,
+        end: effectiveEnd
+    };
+};
 
-class BroadcastUpdatePlugin {
-    _broadcastUpdate;
-    constructor(options){
-        this._broadcastUpdate = new BroadcastCacheUpdate(options);
+const parseRangeHeader = (rangeHeader)=>{
+    if (process.env.NODE_ENV !== "production") {
+        finalAssertExports.isType(rangeHeader, "string", {
+            moduleName: "@serwist/range-requests",
+            funcName: "parseRangeHeader",
+            paramName: "rangeHeader"
+        });
     }
-    cacheDidUpdate(options) {
-        void this._broadcastUpdate.notifyIfUpdated(options);
+    const normalizedRangeHeader = rangeHeader.trim().toLowerCase();
+    if (!normalizedRangeHeader.startsWith("bytes=")) {
+        throw new SerwistError("unit-must-be-bytes", {
+            normalizedRangeHeader
+        });
     }
-}
-
-class CacheableResponse {
-    _statuses;
-    _headers;
-    constructor(config = {}){
-        if (process.env.NODE_ENV !== "production") {
-            if (!(config.statuses || config.headers)) {
-                throw new SerwistError("statuses-or-headers-required", {
-                    moduleName: "serwist",
-                    className: "CacheableResponse",
-                    funcName: "constructor"
-                });
-            }
-            if (config.statuses) {
-                finalAssertExports.isArray(config.statuses, {
-                    moduleName: "serwist",
-                    className: "CacheableResponse",
-                    funcName: "constructor",
-                    paramName: "config.statuses"
-                });
-            }
-            if (config.headers) {
-                finalAssertExports.isType(config.headers, "object", {
-                    moduleName: "serwist",
-                    className: "CacheableResponse",
-                    funcName: "constructor",
-                    paramName: "config.headers"
-                });
-            }
-        }
-        this._statuses = config.statuses;
-        if (config.headers) {
-            this._headers = new Headers(config.headers);
-        }
+    if (normalizedRangeHeader.includes(",")) {
+        throw new SerwistError("single-range-only", {
+            normalizedRangeHeader
+        });
     }
-    isResponseCacheable(response) {
+    const rangeParts = /(\d*)-(\d*)/.exec(normalizedRangeHeader);
+    if (!rangeParts || !(rangeParts[1] || rangeParts[2])) {
+        throw new SerwistError("invalid-range-values", {
+            normalizedRangeHeader
+        });
+    }
+    return {
+        start: rangeParts[1] === "" ? undefined : Number(rangeParts[1]),
+        end: rangeParts[2] === "" ? undefined : Number(rangeParts[2])
+    };
+};
+
+const createPartialResponse = async (request, originalResponse)=>{
+    try {
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isInstance(response, Response, {
-                moduleName: "serwist",
-                className: "CacheableResponse",
-                funcName: "isResponseCacheable",
-                paramName: "response"
+            finalAssertExports.isInstance(request, Request, {
+                moduleName: "@serwist/range-requests",
+                funcName: "createPartialResponse",
+                paramName: "request"
+            });
+            finalAssertExports.isInstance(originalResponse, Response, {
+                moduleName: "@serwist/range-requests",
+                funcName: "createPartialResponse",
+                paramName: "originalResponse"
             });
         }
-        let cacheable = true;
-        if (this._statuses) {
-            cacheable = this._statuses.includes(response.status);
+        if (originalResponse.status === 206) {
+            return originalResponse;
         }
-        if (this._headers && cacheable) {
-            for (const [headerName, headerValue] of this._headers.entries()){
-                if (response.headers.get(headerName) !== headerValue) {
-                    cacheable = false;
-                    break;
-                }
-            }
+        const rangeHeader = request.headers.get("range");
+        if (!rangeHeader) {
+            throw new SerwistError("no-range-header");
         }
+        const boundaries = parseRangeHeader(rangeHeader);
+        const originalBlob = await originalResponse.blob();
+        const effectiveBoundaries = calculateEffectiveBoundaries(originalBlob, boundaries.start, boundaries.end);
+        const slicedBlob = originalBlob.slice(effectiveBoundaries.start, effectiveBoundaries.end);
+        const slicedBlobSize = slicedBlob.size;
+        const slicedResponse = new Response(slicedBlob, {
+            status: 206,
+            statusText: "Partial Content",
+            headers: originalResponse.headers
+        });
+        slicedResponse.headers.set("Content-Length", String(slicedBlobSize));
+        slicedResponse.headers.set("Content-Range", `bytes ${effectiveBoundaries.start}-${effectiveBoundaries.end - 1}/` + `${originalBlob.size}`);
+        return slicedResponse;
+    } catch (error) {
         if (process.env.NODE_ENV !== "production") {
-            if (!cacheable) {
-                logger.groupCollapsed(`The request for '${getFriendlyURL(response.url)}' returned a response that does not meet the criteria for being cached.`);
-                logger.groupCollapsed("View cacheability criteria here.");
-                logger.log(`Cacheable statuses: ${JSON.stringify(this._statuses)}`);
-                logger.log(`Cacheable headers: ${JSON.stringify(this._headers, null, 2)}`);
-                logger.groupEnd();
-                const logFriendlyHeaders = {};
-                response.headers.forEach((value, key)=>{
-                    logFriendlyHeaders[key] = value;
-                });
-                logger.groupCollapsed("View response status and headers here.");
-                logger.log(`Response status: ${response.status}`);
-                logger.log(`Response headers: ${JSON.stringify(logFriendlyHeaders, null, 2)}`);
-                logger.groupEnd();
-                logger.groupCollapsed("View full response details here.");
-                logger.log(response.headers);
-                logger.log(response);
-                logger.groupEnd();
-                logger.groupEnd();
-            }
+            logger.warn("Unable to construct a partial response; returning a " + "416 Range Not Satisfiable response instead.");
+            logger.groupCollapsed("View details here.");
+            logger.log(error);
+            logger.log(request);
+            logger.log(originalResponse);
+            logger.groupEnd();
         }
-        return cacheable;
+        return new Response("", {
+            status: 416,
+            statusText: "Range Not Satisfiable"
+        });
     }
-}
+};
 
-class CacheableResponsePlugin {
-    _cacheableResponse;
-    constructor(config){
-        this._cacheableResponse = new CacheableResponse(config);
-    }
-    cacheWillUpdate = async ({ response })=>{
-        if (this._cacheableResponse.isResponseCacheable(response)) {
-            return response;
+class RangeRequestsPlugin {
+    cachedResponseWillBeUsed = async ({ request, cachedResponse })=>{
+        if (cachedResponse && request.headers.has("range")) {
+            return await createPartialResponse(request, cachedResponse);
         }
-        return null;
+        return cachedResponse;
     };
 }
 
-const DB_NAME = "serwist-expiration";
-const CACHE_OBJECT_STORE = "cache-entries";
-const normalizeURL = (unNormalizedUrl)=>{
-    const url = new URL(unNormalizedUrl, location.href);
-    url.hash = "";
-    return url.href;
-};
-class CacheTimestampsModel {
-    _cacheName;
-    _db = null;
-    constructor(cacheName){
-        this._cacheName = cacheName;
-    }
-    _getId(url) {
-        return `${this._cacheName}|${normalizeURL(url)}`;
-    }
-    _upgradeDb(db) {
-        const objStore = db.createObjectStore(CACHE_OBJECT_STORE, {
-            keyPath: "id"
-        });
-        objStore.createIndex("cacheName", "cacheName", {
-            unique: false
-        });
-        objStore.createIndex("timestamp", "timestamp", {
-            unique: false
-        });
-    }
-    _upgradeDbAndDeleteOldDbs(db) {
-        this._upgradeDb(db);
-        if (this._cacheName) {
-            void deleteDB(this._cacheName);
+class CacheFirst extends Strategy {
+    async _handle(request, handler) {
+        const logs = [];
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isInstance(request, Request, {
+                moduleName: "serwist",
+                className: this.constructor.name,
+                funcName: "makeRequest",
+                paramName: "request"
+            });
         }
-    }
-    async setTimestamp(url, timestamp) {
-        url = normalizeURL(url);
-        const entry = {
-            id: this._getId(url),
-            cacheName: this._cacheName,
-            url,
-            timestamp
-        };
-        const db = await this.getDb();
-        const tx = db.transaction(CACHE_OBJECT_STORE, "readwrite", {
-            durability: "relaxed"
-        });
-        await tx.store.put(entry);
-        await tx.done;
-    }
-    async getTimestamp(url) {
-        const db = await this.getDb();
-        const entry = await db.get(CACHE_OBJECT_STORE, this._getId(url));
-        return entry?.timestamp;
-    }
-    async expireEntries(minTimestamp, maxCount) {
-        const db = await this.getDb();
-        let cursor = await db.transaction(CACHE_OBJECT_STORE, "readwrite").store.index("timestamp").openCursor(null, "prev");
-        const urlsDeleted = [];
-        let entriesNotDeletedCount = 0;
-        while(cursor){
-            const result = cursor.value;
-            if (result.cacheName === this._cacheName) {
-                if (minTimestamp && result.timestamp < minTimestamp || maxCount && entriesNotDeletedCount >= maxCount) {
-                    cursor.delete();
-                    urlsDeleted.push(result.url);
+        let response = await handler.cacheMatch(request);
+        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.`);
+            }
+            try {
+                response = await handler.fetchAndCachePut(request);
+            } catch (err) {
+                if (err instanceof Error) {
+                    error = err;
+                }
+            }
+            if (process.env.NODE_ENV !== "production") {
+                if (response) {
+                    logs.push("Got response from network.");
                 } else {
-                    entriesNotDeletedCount++;
+                    logs.push("Unable to get a response from the network.");
                 }
             }
-            cursor = await cursor.continue();
+        } else {
+            if (process.env.NODE_ENV !== "production") {
+                logs.push(`Found a cached response in the '${this.cacheName}' cache.`);
+            }
         }
-        return urlsDeleted;
+        if (process.env.NODE_ENV !== "production") {
+            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
+            for (const log of logs){
+                logger.log(log);
+            }
+            messages.printFinalResponse(response);
+            logger.groupEnd();
+        }
+        if (!response) {
+            throw new SerwistError("no-response", {
+                url: request.url,
+                error
+            });
+        }
+        return response;
     }
-    async getDb() {
-        if (!this._db) {
-            this._db = await openDB(DB_NAME, 1, {
-                upgrade: this._upgradeDbAndDeleteOldDbs.bind(this)
+}
+
+class CacheOnly extends Strategy {
+    async _handle(request, handler) {
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isInstance(request, Request, {
+                moduleName: "serwist",
+                className: this.constructor.name,
+                funcName: "makeRequest",
+                paramName: "request"
             });
         }
-        return this._db;
+        const response = await handler.cacheMatch(request);
+        if (process.env.NODE_ENV !== "production") {
+            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
+            if (response) {
+                logger.log(`Found a cached response in the '${this.cacheName}' cache.`);
+                messages.printFinalResponse(response);
+            } else {
+                logger.log(`No response found in the '${this.cacheName}' cache.`);
+            }
+            logger.groupEnd();
+        }
+        if (!response) {
+            throw new SerwistError("no-response", {
+                url: request.url
+            });
+        }
+        return response;
     }
 }
 
-class CacheExpiration {
-    _isRunning = false;
-    _rerunRequested = false;
-    _maxEntries;
-    _maxAgeSeconds;
-    _matchOptions;
-    _cacheName;
-    _timestampModel;
-    constructor(cacheName, config = {}){
+class StaleWhileRevalidate extends Strategy {
+    constructor(options = {}){
+        super(options);
+        if (!this.plugins.some((p)=>"cacheWillUpdate" in p)) {
+            this.plugins.unshift(cacheOkAndOpaquePlugin);
+        }
+    }
+    async _handle(request, handler) {
+        const logs = [];
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isType(cacheName, "string", {
+            finalAssertExports.isInstance(request, Request, {
                 moduleName: "serwist",
-                className: "CacheExpiration",
-                funcName: "constructor",
-                paramName: "cacheName"
+                className: this.constructor.name,
+                funcName: "handle",
+                paramName: "request"
             });
-            if (!(config.maxEntries || config.maxAgeSeconds)) {
-                throw new SerwistError("max-entries-or-age-required", {
-                    moduleName: "serwist",
-                    className: "CacheExpiration",
-                    funcName: "constructor"
-                });
+        }
+        const fetchAndCachePromise = handler.fetchAndCachePut(request).catch(()=>{});
+        void handler.waitUntil(fetchAndCachePromise);
+        let response = await handler.cacheMatch(request);
+        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.`);
             }
-            if (config.maxEntries) {
-                finalAssertExports.isType(config.maxEntries, "number", {
-                    moduleName: "serwist",
-                    className: "CacheExpiration",
-                    funcName: "constructor",
-                    paramName: "config.maxEntries"
-                });
+        } else {
+            if (process.env.NODE_ENV !== "production") {
+                logs.push(`No response found in the '${this.cacheName}' cache. Will wait for the network response.`);
             }
-            if (config.maxAgeSeconds) {
-                finalAssertExports.isType(config.maxAgeSeconds, "number", {
-                    moduleName: "serwist",
-                    className: "CacheExpiration",
-                    funcName: "constructor",
-                    paramName: "config.maxAgeSeconds"
-                });
+            try {
+                response = await fetchAndCachePromise;
+            } catch (err) {
+                if (err instanceof Error) {
+                    error = err;
+                }
             }
         }
-        this._maxEntries = config.maxEntries;
-        this._maxAgeSeconds = config.maxAgeSeconds;
-        this._matchOptions = config.matchOptions;
-        this._cacheName = cacheName;
-        this._timestampModel = new CacheTimestampsModel(cacheName);
+        if (process.env.NODE_ENV !== "production") {
+            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
+            for (const log of logs){
+                logger.log(log);
+            }
+            messages.printFinalResponse(response);
+            logger.groupEnd();
+        }
+        if (!response) {
+            throw new SerwistError("no-response", {
+                url: request.url,
+                error
+            });
+        }
+        return response;
     }
-    async expireEntries() {
-        if (this._isRunning) {
-            this._rerunRequested = true;
+}
+
+class PrecacheRoute extends Route {
+    constructor(serwist, options){
+        const match = ({ request })=>{
+            const urlsToCacheKeys = serwist.getUrlsToPrecacheKeys();
+            for (const possibleURL of generateURLVariations(request.url, options)){
+                const cacheKey = urlsToCacheKeys.get(possibleURL);
+                if (cacheKey) {
+                    const integrity = serwist.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, serwist.precacheStrategy);
+    }
+}
+
+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 = (serwist, precacheOptions = {})=>{
+    const { cacheName: precacheCacheName, plugins: precachePlugins = [], fetchOptions: precacheFetchOptions, matchOptions: precacheMatchOptions, fallbackToNetwork: precacheFallbackToNetwork, directoryIndex: precacheDirectoryIndex, ignoreURLParametersMatching: precacheIgnoreUrls, cleanURLs: precacheCleanUrls, urlManipulation: precacheUrlManipulation, cleanupOutdatedCaches, concurrency = 10, navigateFallback, navigateFallbackAllowlist, navigateFallbackDenylist } = precacheOptions ?? {};
+    return {
+        precacheStrategyOptions: {
+            cacheName: cacheNames$1.getPrecacheName(precacheCacheName),
+            plugins: [
+                ...precachePlugins,
+                new PrecacheCacheKeyPlugin({
+                    precacheController: serwist
+                })
+            ],
+            fetchOptions: precacheFetchOptions,
+            matchOptions: precacheMatchOptions,
+            fallbackToNetwork: precacheFallbackToNetwork
+        },
+        precacheRouteOptions: {
+            directoryIndex: precacheDirectoryIndex,
+            ignoreURLParametersMatching: precacheIgnoreUrls,
+            cleanURLs: precacheCleanUrls,
+            urlManipulation: precacheUrlManipulation
+        },
+        precacheMiscOptions: {
+            cleanupOutdatedCaches,
+            concurrency,
+            navigateFallback,
+            navigateFallbackAllowlist,
+            navigateFallbackDenylist
         }
-        this._isRunning = true;
-        const minTimestamp = this._maxAgeSeconds ? Date.now() - this._maxAgeSeconds * 1000 : 0;
-        const urlsExpired = await this._timestampModel.expireEntries(minTimestamp, this._maxEntries);
-        const cache = await self.caches.open(this._cacheName);
-        for (const url of urlsExpired){
-            await cache.delete(url, this._matchOptions);
+    };
+};
+
+class Serwist {
+    _urlsToCacheKeys = new Map();
+    _urlsToCacheModes = new Map();
+    _cacheKeysToIntegrities = new Map();
+    _concurrentPrecaching;
+    _precacheStrategy;
+    _routes;
+    _defaultHandlerMap;
+    _catchHandler;
+    _requestRules;
+    constructor({ precacheEntries, precacheOptions, skipWaiting = false, importScripts, navigationPreload = false, cacheId, clientsClaim: clientsClaim$1 = false, runtimeCaching, offlineAnalyticsConfig, disableDevLogs: disableDevLogs$1 = false, fallbacks, requestRules } = {}){
+        const { precacheStrategyOptions, precacheRouteOptions, precacheMiscOptions } = parsePrecacheOptions(this, precacheOptions);
+        this._concurrentPrecaching = precacheMiscOptions.concurrency;
+        this._precacheStrategy = new PrecacheStrategy(precacheStrategyOptions);
+        this._routes = new Map();
+        this._defaultHandlerMap = new Map();
+        this._requestRules = requestRules;
+        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
+            });
         }
-        if (process.env.NODE_ENV !== "production") {
-            if (urlsExpired.length > 0) {
-                logger.groupCollapsed(`Expired ${urlsExpired.length} ` + `${urlsExpired.length === 1 ? "entry" : "entries"} and removed ` + `${urlsExpired.length === 1 ? "it" : "them"} from the ` + `'${this._cacheName}' cache.`);
-                logger.log(`Expired the following ${urlsExpired.length === 1 ? "URL" : "URLs"}:`);
-                for (const url of urlsExpired){
-                    logger.log(`    ${url}`);
+        if (skipWaiting) {
+            self.skipWaiting();
+        } else {
+            self.addEventListener("message", (event)=>{
+                if (event.data && event.data.type === "SKIP_WAITING") {
+                    self.skipWaiting();
                 }
-                logger.groupEnd();
-            } else {
-                logger.debug("Cache expiration ran and found no entries to remove.");
-            }
+            });
         }
-        this._isRunning = false;
-        if (this._rerunRequested) {
-            this._rerunRequested = false;
-            void this.expireEntries();
+        if (clientsClaim$1) clientsClaim();
+        if (!!precacheEntries && precacheEntries.length > 0) {
+            this.addToPrecacheList(precacheEntries);
         }
-    }
-    async updateTimestamp(url) {
-        if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isType(url, "string", {
-                moduleName: "serwist",
-                className: "CacheExpiration",
-                funcName: "updateTimestamp",
-                paramName: "url"
-            });
+        if (precacheMiscOptions.cleanupOutdatedCaches) {
+            cleanupOutdatedCaches(precacheStrategyOptions.cacheName);
         }
-        await this._timestampModel.setTimestamp(url, Date.now());
-    }
-    async isURLExpired(url) {
-        if (!this._maxAgeSeconds) {
-            if (process.env.NODE_ENV !== "production") {
-                throw new SerwistError("expired-test-without-max-age", {
-                    methodName: "isURLExpired",
-                    paramName: "maxAgeSeconds"
+        this.registerRoute(new PrecacheRoute(this, precacheRouteOptions));
+        if (precacheMiscOptions.navigateFallback) {
+            this.registerRoute(new NavigationRoute(this.createHandlerBoundToUrl(precacheMiscOptions.navigateFallback), {
+                allowlist: precacheMiscOptions.navigateFallbackAllowlist,
+                denylist: precacheMiscOptions.navigateFallbackDenylist
+            }));
+        }
+        if (offlineAnalyticsConfig !== undefined) {
+            if (typeof offlineAnalyticsConfig === "boolean") {
+                offlineAnalyticsConfig && initializeGoogleAnalytics({
+                    serwist: this
+                });
+            } else {
+                initializeGoogleAnalytics({
+                    ...offlineAnalyticsConfig,
+                    serwist: this
                 });
             }
-            return false;
         }
-        const timestamp = await this._timestampModel.getTimestamp(url);
-        const expireOlderThan = Date.now() - this._maxAgeSeconds * 1000;
-        return timestamp !== undefined ? timestamp < expireOlderThan : true;
+        if (runtimeCaching !== undefined) {
+            if (fallbacks !== undefined) {
+                const fallbackPlugin = new PrecacheFallbackPlugin({
+                    fallbackUrls: fallbacks.entries,
+                    serwist: this
+                });
+                runtimeCaching.forEach((cacheEntry)=>{
+                    if (cacheEntry.handler instanceof Strategy && !cacheEntry.handler.plugins.some((plugin)=>"handlerDidError" in plugin)) {
+                        cacheEntry.handler.plugins.push(fallbackPlugin);
+                    }
+                });
+            }
+            for (const entry of runtimeCaching){
+                this.registerCapture(entry.matcher, entry.handler, entry.method);
+            }
+        }
+        if (disableDevLogs$1) disableDevLogs();
     }
-    async delete() {
-        this._rerunRequested = false;
-        await this._timestampModel.expireEntries(Number.POSITIVE_INFINITY);
+    get precacheStrategy() {
+        return this._precacheStrategy;
     }
-}
-
-const registerQuotaErrorCallback = (callback)=>{
-    if (process.env.NODE_ENV !== "production") {
-        finalAssertExports.isType(callback, "function", {
-            moduleName: "@serwist/core",
-            funcName: "register",
-            paramName: "callback"
-        });
+    get routes() {
+        return this._routes;
     }
-    quotaErrorCallbacks.add(callback);
-    if (process.env.NODE_ENV !== "production") {
-        logger.log("Registered a callback to respond to quota errors.", callback);
+    addEventListeners() {
+        self.addEventListener("install", this.handleInstall);
+        self.addEventListener("activate", this.handleActivate);
+        self.addEventListener("fetch", this.handleFetch);
+        self.addEventListener("message", this.handleCache);
     }
-};
-
-class ExpirationPlugin {
-    _config;
-    _cacheExpirations;
-    constructor(config = {}){
+    addToPrecacheList(entries) {
         if (process.env.NODE_ENV !== "production") {
-            if (!(config.maxEntries || config.maxAgeSeconds)) {
-                throw new SerwistError("max-entries-or-age-required", {
-                    moduleName: "serwist",
-                    className: "ExpirationPlugin",
-                    funcName: "constructor"
-                });
+            finalAssertExports.isArray(entries, {
+                moduleName: "serwist",
+                className: "Serwist",
+                funcName: "addToCacheList",
+                paramName: "entries"
+            });
+        }
+        const urlsToWarnAbout = [];
+        for (const entry of entries){
+            if (typeof entry === "string") {
+                urlsToWarnAbout.push(entry);
+            } else if (entry && !entry.integrity && entry.revision === undefined) {
+                urlsToWarnAbout.push(entry.url);
             }
-            if (config.maxEntries) {
-                finalAssertExports.isType(config.maxEntries, "number", {
-                    moduleName: "serwist",
-                    className: "ExpirationPlugin",
-                    funcName: "constructor",
-                    paramName: "config.maxEntries"
+            const { cacheKey, url } = createCacheKey(entry);
+            const cacheMode = typeof entry !== "string" && entry.revision ? "reload" : "default";
+            if (this._urlsToCacheKeys.has(url) && this._urlsToCacheKeys.get(url) !== cacheKey) {
+                throw new SerwistError("add-to-cache-list-conflicting-entries", {
+                    firstEntry: this._urlsToCacheKeys.get(url),
+                    secondEntry: cacheKey
                 });
             }
-            if (config.maxAgeSeconds) {
-                finalAssertExports.isType(config.maxAgeSeconds, "number", {
-                    moduleName: "serwist",
-                    className: "ExpirationPlugin",
-                    funcName: "constructor",
-                    paramName: "config.maxAgeSeconds"
-                });
+            if (typeof entry !== "string" && entry.integrity) {
+                if (this._cacheKeysToIntegrities.has(cacheKey) && this._cacheKeysToIntegrities.get(cacheKey) !== entry.integrity) {
+                    throw new SerwistError("add-to-cache-list-conflicting-integrities", {
+                        url
+                    });
+                }
+                this._cacheKeysToIntegrities.set(cacheKey, entry.integrity);
             }
-            if (config.maxAgeFrom) {
-                finalAssertExports.isType(config.maxAgeFrom, "string", {
-                    moduleName: "serwist",
-                    className: "ExpirationPlugin",
-                    funcName: "constructor",
-                    paramName: "config.maxAgeFrom"
+            this._urlsToCacheKeys.set(url, cacheKey);
+            this._urlsToCacheModes.set(url, cacheMode);
+        }
+        if (urlsToWarnAbout.length > 0) {
+            const warningMessage = `Serwist is precaching URLs without revision info: ${urlsToWarnAbout.join(", ")}\nThis is generally NOT safe. Learn more at https://bit.ly/wb-precache`;
+            if (process.env.NODE_ENV === "production") {
+                console.warn(warningMessage);
+            } else {
+                logger.warn(warningMessage);
+            }
+        }
+    }
+    handleInstall(event) {
+        void this.registerRequestRules(event);
+        return waitUntil(event, async ()=>{
+            const installReportPlugin = new PrecacheInstallReportPlugin();
+            this.precacheStrategy.plugins.push(installReportPlugin);
+            await parallel(this._concurrentPrecaching, Array.from(this._urlsToCacheKeys.entries()), async ([url, cacheKey])=>{
+                const integrity = this._cacheKeysToIntegrities.get(cacheKey);
+                const cacheMode = this._urlsToCacheModes.get(url);
+                const request = new Request(url, {
+                    integrity,
+                    cache: cacheMode,
+                    credentials: "same-origin"
                 });
+                await Promise.all(this.precacheStrategy.handleAll({
+                    event,
+                    request,
+                    url: new URL(request.url),
+                    params: {
+                        cacheKey
+                    }
+                }));
+            });
+            const { updatedURLs, notUpdatedURLs } = installReportPlugin;
+            if (process.env.NODE_ENV !== "production") {
+                printInstallDetails(updatedURLs, notUpdatedURLs);
             }
+            return {
+                updatedURLs,
+                notUpdatedURLs
+            };
+        });
+    }
+    async registerRequestRules(event) {
+        if (!this._requestRules) {
+            return;
         }
-        this._config = config;
-        this._cacheExpirations = new Map();
-        if (!this._config.maxAgeFrom) {
-            this._config.maxAgeFrom = "last-fetched";
+        if (!event?.addRoutes) {
+            if (process.env.NODE_ENV !== "production") {
+                logger.warn("Request rules ignored as the Static Routing API is not supported in this browser. " + "See https://caniuse.com/mdn-api_installevent_addroutes for more information.");
+            }
+            return;
         }
-        if (this._config.purgeOnQuotaError) {
-            registerQuotaErrorCallback(()=>this.deleteCacheAndMetadata());
+        try {
+            if (process.env.NODE_ENV !== "production") {
+                logger.warn("Request rules may not be supported in all browsers as the Static Routing API is experimental. " + "This feature allows bypassing the service worker for specific requests to improve performance. " + "See https://developer.mozilla.org/en-US/docs/Web/API/InstallEvent/addRoutes for more information.");
+            }
+            await event.addRoutes(this._requestRules);
+            this._requestRules = undefined;
+        } catch (error) {
+            if (process.env.NODE_ENV !== "production") {
+                logger.error(`Failed to register request rules: ${error instanceof Error ? error.message : String(error)}. ` + "This may occur if the browser doesn't support the Static Routing API or if the request rules are invalid.");
+            }
+            throw error;
         }
     }
-    _getCacheExpiration(cacheName) {
-        if (cacheName === cacheNames$1.getRuntimeName()) {
-            throw new SerwistError("expire-custom-caches-only");
-        }
-        let cacheExpiration = this._cacheExpirations.get(cacheName);
-        if (!cacheExpiration) {
-            cacheExpiration = new CacheExpiration(cacheName, this._config);
-            this._cacheExpirations.set(cacheName, cacheExpiration);
-        }
-        return cacheExpiration;
+    handleActivate(event) {
+        return waitUntil(event, async ()=>{
+            const cache = await self.caches.open(this.precacheStrategy.cacheName);
+            const currentlyCachedRequests = await cache.keys();
+            const expectedCacheKeys = new Set(this._urlsToCacheKeys.values());
+            const deletedCacheRequests = [];
+            for (const request of currentlyCachedRequests){
+                if (!expectedCacheKeys.has(request.url)) {
+                    await cache.delete(request);
+                    deletedCacheRequests.push(request.url);
+                }
+            }
+            if (process.env.NODE_ENV !== "production") {
+                printCleanupDetails(deletedCacheRequests);
+            }
+            return {
+                deletedCacheRequests
+            };
+        });
     }
-    cachedResponseWillBeUsed({ event, cacheName, request, cachedResponse }) {
-        if (!cachedResponse) {
-            return null;
+    handleFetch(event) {
+        const { request } = event;
+        const responsePromise = this.handleRequest({
+            request,
+            event
+        });
+        if (responsePromise) {
+            event.respondWith(responsePromise);
         }
-        const isFresh = this._isResponseDateFresh(cachedResponse);
-        const cacheExpiration = this._getCacheExpiration(cacheName);
-        const isMaxAgeFromLastUsed = this._config.maxAgeFrom === "last-used";
-        const done = (async ()=>{
-            if (isMaxAgeFromLastUsed) {
-                await cacheExpiration.updateTimestamp(request.url);
-            }
-            await cacheExpiration.expireEntries();
-        })();
-        try {
-            event.waitUntil(done);
-        } catch  {
+    }
+    handleCache(event) {
+        if (event.data && event.data.type === "CACHE_URLS") {
+            const { payload } = event.data;
             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)}'.`);
+                logger.debug("Caching URLs from the window", payload.urlsToCache);
+            }
+            const requestPromises = Promise.all(payload.urlsToCache.map((entry)=>{
+                let request;
+                if (typeof entry === "string") {
+                    request = new Request(entry);
+                } else {
+                    request = new Request(...entry);
                 }
+                return this.handleRequest({
+                    request,
+                    event
+                });
+            }));
+            event.waitUntil(requestPromises);
+            if (event.ports?.[0]) {
+                void requestPromises.then(()=>event.ports[0].postMessage(true));
             }
         }
-        return isFresh ? cachedResponse : null;
     }
-    _isResponseDateFresh(cachedResponse) {
-        const isMaxAgeFromLastUsed = this._config.maxAgeFrom === "last-used";
-        if (isMaxAgeFromLastUsed) {
-            return true;
-        }
-        const now = Date.now();
-        if (!this._config.maxAgeSeconds) {
-            return true;
-        }
-        const dateHeaderTimestamp = this._getDateHeaderTimestamp(cachedResponse);
-        if (dateHeaderTimestamp === null) {
-            return true;
-        }
-        return dateHeaderTimestamp >= now - this._config.maxAgeSeconds * 1000;
+    setDefaultHandler(handler, method = defaultMethod) {
+        this._defaultHandlerMap.set(method, normalizeHandler(handler));
     }
-    _getDateHeaderTimestamp(cachedResponse) {
-        if (!cachedResponse.headers.has("date")) {
-            return null;
-        }
-        const dateHeader = cachedResponse.headers.get("date");
-        const parsedDate = new Date(dateHeader);
-        const headerTime = parsedDate.getTime();
-        if (Number.isNaN(headerTime)) {
-            return null;
-        }
-        return headerTime;
+    setCatchHandler(handler) {
+        this._catchHandler = normalizeHandler(handler);
     }
-    async cacheDidUpdate({ cacheName, request }) {
+    registerCapture(capture, handler, method) {
+        const route = parseRoute(capture, handler, method);
+        this.registerRoute(route);
+        return route;
+    }
+    registerRoute(route) {
         if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isType(cacheName, "string", {
+            finalAssertExports.isType(route, "object", {
                 moduleName: "serwist",
-                className: "Plugin",
-                funcName: "cacheDidUpdate",
-                paramName: "cacheName"
+                className: "Serwist",
+                funcName: "registerRoute",
+                paramName: "route"
             });
-            finalAssertExports.isInstance(request, Request, {
+            finalAssertExports.hasMethod(route, "match", {
                 moduleName: "serwist",
-                className: "Plugin",
-                funcName: "cacheDidUpdate",
-                paramName: "request"
+                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"
             });
         }
-        const cacheExpiration = this._getCacheExpiration(cacheName);
-        await cacheExpiration.updateTimestamp(request.url);
-        await cacheExpiration.expireEntries();
-    }
-    async deleteCacheAndMetadata() {
-        for (const [cacheName, cacheExpiration] of this._cacheExpirations){
-            await self.caches.delete(cacheName);
-            await cacheExpiration.delete();
+        if (!this._routes.has(route.method)) {
+            this._routes.set(route.method, []);
         }
-        this._cacheExpirations = new Map();
-    }
-}
-
-const calculateEffectiveBoundaries = (blob, start, end)=>{
-    if (process.env.NODE_ENV !== "production") {
-        finalAssertExports.isInstance(blob, Blob, {
-            moduleName: "@serwist/range-requests",
-            funcName: "calculateEffectiveBoundaries",
-            paramName: "blob"
-        });
-    }
-    const blobSize = blob.size;
-    if (end && end > blobSize || start && start < 0) {
-        throw new SerwistError("range-not-satisfiable", {
-            size: blobSize,
-            end,
-            start
-        });
+        this._routes.get(route.method).push(route);
     }
-    let effectiveStart;
-    let effectiveEnd;
-    if (start !== undefined && end !== undefined) {
-        effectiveStart = start;
-        effectiveEnd = end + 1;
-    } else if (start !== undefined && end === undefined) {
-        effectiveStart = start;
-        effectiveEnd = blobSize;
-    } else if (end !== undefined && start === undefined) {
-        effectiveStart = blobSize - end;
-        effectiveEnd = blobSize;
+    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");
+        }
     }
-    return {
-        start: effectiveStart,
-        end: effectiveEnd
-    };
-};
-
-const parseRangeHeader = (rangeHeader)=>{
-    if (process.env.NODE_ENV !== "production") {
-        finalAssertExports.isType(rangeHeader, "string", {
-            moduleName: "@serwist/range-requests",
-            funcName: "parseRangeHeader",
-            paramName: "rangeHeader"
-        });
+    getUrlsToPrecacheKeys() {
+        return this._urlsToCacheKeys;
     }
-    const normalizedRangeHeader = rangeHeader.trim().toLowerCase();
-    if (!normalizedRangeHeader.startsWith("bytes=")) {
-        throw new SerwistError("unit-must-be-bytes", {
-            normalizedRangeHeader
-        });
+    getPrecachedUrls() {
+        return [
+            ...this._urlsToCacheKeys.keys()
+        ];
     }
-    if (normalizedRangeHeader.includes(",")) {
-        throw new SerwistError("single-range-only", {
-            normalizedRangeHeader
-        });
+    getPrecacheKeyForUrl(url) {
+        const urlObject = new URL(url, location.href);
+        return this._urlsToCacheKeys.get(urlObject.href);
     }
-    const rangeParts = /(\d*)-(\d*)/.exec(normalizedRangeHeader);
-    if (!rangeParts || !(rangeParts[1] || rangeParts[2])) {
-        throw new SerwistError("invalid-range-values", {
-            normalizedRangeHeader
-        });
+    getIntegrityForPrecacheKey(cacheKey) {
+        return this._cacheKeysToIntegrities.get(cacheKey);
     }
-    return {
-        start: rangeParts[1] === "" ? undefined : Number(rangeParts[1]),
-        end: rangeParts[2] === "" ? undefined : Number(rangeParts[2])
-    };
-};
-
-const createPartialResponse = async (request, originalResponse)=>{
-    try {
-        if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isInstance(request, Request, {
-                moduleName: "@serwist/range-requests",
-                funcName: "createPartialResponse",
-                paramName: "request"
-            });
-            finalAssertExports.isInstance(originalResponse, Response, {
-                moduleName: "@serwist/range-requests",
-                funcName: "createPartialResponse",
-                paramName: "originalResponse"
-            });
-        }
-        if (originalResponse.status === 206) {
-            return originalResponse;
-        }
-        const rangeHeader = request.headers.get("range");
-        if (!rangeHeader) {
-            throw new SerwistError("no-range-header");
-        }
-        const boundaries = parseRangeHeader(rangeHeader);
-        const originalBlob = await originalResponse.blob();
-        const effectiveBoundaries = calculateEffectiveBoundaries(originalBlob, boundaries.start, boundaries.end);
-        const slicedBlob = originalBlob.slice(effectiveBoundaries.start, effectiveBoundaries.end);
-        const slicedBlobSize = slicedBlob.size;
-        const slicedResponse = new Response(slicedBlob, {
-            status: 206,
-            statusText: "Partial Content",
-            headers: originalResponse.headers
-        });
-        slicedResponse.headers.set("Content-Length", String(slicedBlobSize));
-        slicedResponse.headers.set("Content-Range", `bytes ${effectiveBoundaries.start}-${effectiveBoundaries.end - 1}/` + `${originalBlob.size}`);
-        return slicedResponse;
-    } catch (error) {
-        if (process.env.NODE_ENV !== "production") {
-            logger.warn("Unable to construct a partial response; returning a " + "416 Range Not Satisfiable response instead.");
-            logger.groupCollapsed("View details here.");
-            logger.log(error);
-            logger.log(request);
-            logger.log(originalResponse);
-            logger.groupEnd();
-        }
-        return new Response("", {
-            status: 416,
-            statusText: "Range Not Satisfiable"
-        });
+    async matchPrecache(request) {
+        const url = request instanceof Request ? request.url : request;
+        const cacheKey = this.getPrecacheKeyForUrl(url);
+        if (cacheKey) {
+            const cache = await self.caches.open(this.precacheStrategy.cacheName);
+            return cache.match(cacheKey);
+        }
+        return undefined;
     }
-};
-
-class RangeRequestsPlugin {
-    cachedResponseWillBeUsed = async ({ request, cachedResponse })=>{
-        if (cachedResponse && request.headers.has("range")) {
-            return await createPartialResponse(request, cachedResponse);
+    createHandlerBoundToUrl(url) {
+        const cacheKey = this.getPrecacheKeyForUrl(url);
+        if (!cacheKey) {
+            throw new SerwistError("non-precached-url", {
+                url
+            });
         }
-        return cachedResponse;
-    };
-}
-
-class CacheFirst extends Strategy {
-    async _handle(request, handler) {
-        const logs = [];
+        return (options)=>{
+            options.request = new Request(url);
+            options.params = {
+                cacheKey,
+                ...options.params
+            };
+            return this.precacheStrategy.handle(options);
+        };
+    }
+    handleRequest({ request, event }) {
         if (process.env.NODE_ENV !== "production") {
             finalAssertExports.isInstance(request, Request, {
                 moduleName: "serwist",
-                className: this.constructor.name,
-                funcName: "makeRequest",
-                paramName: "request"
+                className: "Serwist",
+                funcName: "handleRequest",
+                paramName: "options.request"
             });
         }
-        let response = await handler.cacheMatch(request);
-        let error;
-        if (!response) {
+        const url = new URL(request.url, location.href);
+        if (!url.protocol.startsWith("http")) {
             if (process.env.NODE_ENV !== "production") {
-                logs.push(`No response found in the '${this.cacheName}' cache. Will respond with a network request.`);
+                logger.debug("Router only supports URLs that start with 'http'.");
             }
-            try {
-                response = await handler.fetchAndCachePut(request);
-            } catch (err) {
-                if (err instanceof Error) {
-                    error = err;
+            return;
+        }
+        const sameOrigin = url.origin === location.origin;
+        const { params, route } = this.findMatchingRoute({
+            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
+                    ]);
                 }
             }
+        }
+        const method = request.method;
+        if (!handler && this._defaultHandlerMap.has(method)) {
             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.");
-                }
+                debugMessages.push(`Failed to find a matching route. Falling back to the default handler for ${method}.`);
             }
-        } else {
+            handler = this._defaultHandlerMap.get(method);
+        }
+        if (!handler) {
             if (process.env.NODE_ENV !== "production") {
-                logs.push(`Found a cached response in the '${this.cacheName}' cache.`);
+                logger.debug(`No route found for: ${getFriendlyURL(url)}`);
             }
+            return;
         }
         if (process.env.NODE_ENV !== "production") {
-            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
-            for (const log of logs){
-                logger.log(log);
+            logger.groupCollapsed(`Router is responding to: ${getFriendlyURL(url)}`);
+            for (const msg of debugMessages){
+                if (Array.isArray(msg)) {
+                    logger.log(...msg);
+                } else {
+                    logger.log(msg);
+                }
             }
-            messages.printFinalResponse(response);
             logger.groupEnd();
         }
-        if (!response) {
-            throw new SerwistError("no-response", {
-                url: request.url,
-                error
-            });
-        }
-        return response;
-    }
-}
-
-class CacheOnly extends Strategy {
-    async _handle(request, handler) {
-        if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isInstance(request, Request, {
-                moduleName: "serwist",
-                className: this.constructor.name,
-                funcName: "makeRequest",
-                paramName: "request"
+        let responsePromise;
+        try {
+            responsePromise = handler.handle({
+                url,
+                request,
+                event,
+                params
             });
+        } catch (err) {
+            responsePromise = Promise.reject(err);
         }
-        const response = await handler.cacheMatch(request);
-        if (process.env.NODE_ENV !== "production") {
-            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
-            if (response) {
-                logger.log(`Found a cached response in the '${this.cacheName}' cache.`);
-                messages.printFinalResponse(response);
-            } else {
-                logger.log(`No response found in the '${this.cacheName}' cache.`);
-            }
-            logger.groupEnd();
-        }
-        if (!response) {
-            throw new SerwistError("no-response", {
-                url: request.url
+        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 response;
-    }
-}
-
-class StaleWhileRevalidate extends Strategy {
-    constructor(options = {}){
-        super(options);
-        if (!this.plugins.some((p)=>"cacheWillUpdate" in p)) {
-            this.plugins.unshift(cacheOkAndOpaquePlugin);
-        }
+        return responsePromise;
     }
-    async _handle(request, handler) {
-        const logs = [];
-        if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isInstance(request, Request, {
-                moduleName: "serwist",
-                className: this.constructor.name,
-                funcName: "handle",
-                paramName: "request"
+    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
             });
-        }
-        const fetchAndCachePromise = handler.fetchAndCachePut(request).catch(()=>{});
-        void handler.waitUntil(fetchAndCachePromise);
-        let response = await handler.cacheMatch(request);
-        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.`);
-            }
-        } else {
-            if (process.env.NODE_ENV !== "production") {
-                logs.push(`No response found in the '${this.cacheName}' cache. Will wait for the network response.`);
-            }
-            try {
-                response = await fetchAndCachePromise;
-            } catch (err) {
-                if (err instanceof Error) {
-                    error = err;
+            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
+                };
             }
         }
-        if (process.env.NODE_ENV !== "production") {
-            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
-            for (const log of logs){
-                logger.log(log);
-            }
-            messages.printFinalResponse(response);
-            logger.groupEnd();
-        }
-        if (!response) {
-            throw new SerwistError("no-response", {
-                url: request.url,
-                error
-            });
-        }
-        return response;
+        return {};
     }
 }