serwist 9.1.1 → 10.0.0-preview.10

package/dist/index.js

@@ -1,29 +1,1487 @@
-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';
-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';
+import { c as cacheNames$1, l as logger, f as finalAssertExports, S as SerwistError, g as getFriendlyURL, D as Deferred, t as timeout, a as cacheMatchIgnoreParams, e as executeQuotaErrorCallbacks, b as canConstructResponseFromBodyStream, q as quotaErrorCallbacks, w as waitUntil, d as clientsClaim, r as resultingClientExists } from './chunks/waitUntil.js';
+import { openDB, deleteDB } from 'idb';
+import { parallel } from '@serwist/utils';
 
-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
+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 isNavigationPreloadSupported = ()=>{
+    return Boolean(self.registration?.navigationPreload);
+};
+const enableNavigationPreload = (headerValue)=>{
+    if (isNavigationPreloadSupported()) {
+        self.addEventListener("activate", (event)=>{
+            event.waitUntil(self.registration.navigationPreload.enable().then(()=>{
+                if (headerValue) {
+                    void self.registration.navigationPreload.setHeaderValue(headerValue);
+                }
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log("Navigation preloading is enabled.");
+                }
+            }));
+        });
+    } else {
+        if (process.env.NODE_ENV !== "production") {
+            logger.log("Navigation preloading is not supported in this browser.");
+        }
+    }
+};
+const disableNavigationPreload = ()=>{
+    if (isNavigationPreloadSupported()) {
+        self.addEventListener("activate", (event)=>{
+            event.waitUntil(self.registration.navigationPreload.disable().then(()=>{
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log("Navigation preloading is disabled.");
+                }
+            }));
+        });
+    } else {
+        if (process.env.NODE_ENV !== "production") {
+            logger.log("Navigation preloading is not supported in this browser.");
+        }
+    }
+};
+
+const normalizeHandler = (handler)=>{
+    if (handler && typeof handler === "object") {
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.hasMethod(handler, "handle", {
+                moduleName: "serwist",
+                className: "Route",
+                funcName: "constructor",
+                paramName: "handler"
+            });
+        }
+        return handler;
+    }
+    if (process.env.NODE_ENV !== "production") {
+        finalAssertExports.isType(handler, "function", {
+            moduleName: "serwist",
+            className: "Route",
+            funcName: "constructor",
+            paramName: "handler"
+        });
+    }
+    return {
+        handle: handler
+    };
+};
+
+const defaultMethod = "GET";
+const validMethods = [
+    "DELETE",
+    "GET",
+    "HEAD",
+    "PATCH",
+    "POST",
+    "PUT"
+];
+
+class Route {
+    handler;
+    match;
+    method;
+    catchHandler;
+    constructor(match, handler, method = defaultMethod){
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isType(match, "function", {
+                moduleName: "serwist",
+                className: "Route",
+                funcName: "constructor",
+                paramName: "match"
+            });
+            if (method) {
+                finalAssertExports.isOneOf(method, validMethods, {
+                    paramName: "method"
+                });
+            }
+        }
+        this.handler = normalizeHandler(handler);
+        this.match = match;
+        this.method = method;
+    }
+    setCatchHandler(handler) {
+        this.catchHandler = normalizeHandler(handler);
+    }
+}
+class RegExpRoute extends Route {
+    constructor(regExp, handler, method){
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isInstance(regExp, RegExp, {
+                moduleName: "serwist",
+                className: "RegExpRoute",
+                funcName: "constructor",
+                paramName: "pattern"
+            });
+        }
+        const match = ({ url })=>{
+            const result = regExp.exec(url.href);
+            if (!result) {
+                return;
+            }
+            if (url.origin !== location.origin && result.index !== 0) {
+                if (process.env.NODE_ENV !== "production") {
+                    logger.debug(`The regular expression '${regExp.toString()}' only partially matched against the cross-origin URL '${url.toString()}'. RegExpRoute's will only handle cross-origin requests if they match the entire URL.`);
+                }
+                return;
+            }
+            return result.slice(1);
+        };
+        super(match, handler, method);
+    }
+}
+class NavigationRoute extends Route {
+    _allowlist;
+    _denylist;
+    constructor(handler, { allowlist = [
+        /./
+    ], denylist = [] } = {}){
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isArrayOfClass(allowlist, RegExp, {
+                moduleName: "serwist",
+                className: "NavigationRoute",
+                funcName: "constructor",
+                paramName: "options.allowlist"
+            });
+            finalAssertExports.isArrayOfClass(denylist, RegExp, {
+                moduleName: "serwist",
+                className: "NavigationRoute",
+                funcName: "constructor",
+                paramName: "options.denylist"
+            });
+        }
+        super((options)=>this._match(options), handler);
+        this._allowlist = allowlist;
+        this._denylist = denylist;
+    }
+    _match({ url, request }) {
+        if (request && request.mode !== "navigate") {
+            return false;
+        }
+        const pathnameAndSearch = url.pathname + url.search;
+        for (const regExp of this._denylist){
+            if (regExp.test(pathnameAndSearch)) {
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log(`The navigation route ${pathnameAndSearch} is not being used, since the URL matches this denylist pattern: ${regExp.toString()}`);
+                }
+                return false;
+            }
+        }
+        if (this._allowlist.some((regExp)=>regExp.test(pathnameAndSearch))) {
+            if (process.env.NODE_ENV !== "production") {
+                logger.debug(`The navigation route ${pathnameAndSearch} is being used.`);
+            }
+            return true;
+        }
+        if (process.env.NODE_ENV !== "production") {
+            logger.log(`The navigation route ${pathnameAndSearch} is not being used, since the URL being navigated to doesn't match the allowlist.`);
+        }
+        return false;
+    }
+}
+
+const BACKGROUND_SYNC_DB_VERSION = 3;
+const BACKGROUND_SYNC_DB_NAME = "serwist-background-sync";
+const REQUEST_OBJECT_STORE_NAME = "requests";
+const QUEUE_NAME_INDEX = "queueName";
+class BackgroundSyncQueueDb {
+    _db = null;
+    async addEntry(entry) {
+        const db = await this.getDb();
+        const tx = db.transaction(REQUEST_OBJECT_STORE_NAME, "readwrite", {
+            durability: "relaxed"
+        });
+        await tx.store.add(entry);
+        await tx.done;
+    }
+    async getFirstEntryId() {
+        const db = await this.getDb();
+        const cursor = await db.transaction(REQUEST_OBJECT_STORE_NAME).store.openCursor();
+        return cursor?.value.id;
+    }
+    async getAllEntriesByQueueName(queueName) {
+        const db = await this.getDb();
+        const results = await db.getAllFromIndex(REQUEST_OBJECT_STORE_NAME, QUEUE_NAME_INDEX, IDBKeyRange.only(queueName));
+        return results ? results : [];
+    }
+    async getEntryCountByQueueName(queueName) {
+        const db = await this.getDb();
+        return db.countFromIndex(REQUEST_OBJECT_STORE_NAME, QUEUE_NAME_INDEX, IDBKeyRange.only(queueName));
+    }
+    async deleteEntry(id) {
+        const db = await this.getDb();
+        await db.delete(REQUEST_OBJECT_STORE_NAME, id);
+    }
+    async getFirstEntryByQueueName(queueName) {
+        return await this.getEndEntryFromIndex(IDBKeyRange.only(queueName), "next");
+    }
+    async getLastEntryByQueueName(queueName) {
+        return await this.getEndEntryFromIndex(IDBKeyRange.only(queueName), "prev");
+    }
+    async getEndEntryFromIndex(query, direction) {
+        const db = await this.getDb();
+        const cursor = await db.transaction(REQUEST_OBJECT_STORE_NAME).store.index(QUEUE_NAME_INDEX).openCursor(query, direction);
+        return cursor?.value;
+    }
+    async getDb() {
+        if (!this._db) {
+            this._db = await openDB(BACKGROUND_SYNC_DB_NAME, BACKGROUND_SYNC_DB_VERSION, {
+                upgrade: this._upgradeDb
+            });
+        }
+        return this._db;
+    }
+    _upgradeDb(db, oldVersion) {
+        if (oldVersion > 0 && oldVersion < BACKGROUND_SYNC_DB_VERSION) {
+            if (db.objectStoreNames.contains(REQUEST_OBJECT_STORE_NAME)) {
+                db.deleteObjectStore(REQUEST_OBJECT_STORE_NAME);
+            }
+        }
+        const objStore = db.createObjectStore(REQUEST_OBJECT_STORE_NAME, {
+            autoIncrement: true,
+            keyPath: "id"
+        });
+        objStore.createIndex(QUEUE_NAME_INDEX, QUEUE_NAME_INDEX, {
+            unique: false
+        });
+    }
+}
+
+class BackgroundSyncQueueStore {
+    _queueName;
+    _queueDb;
+    constructor(queueName){
+        this._queueName = queueName;
+        this._queueDb = new BackgroundSyncQueueDb();
+    }
+    async pushEntry(entry) {
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isType(entry, "object", {
+                moduleName: "serwist",
+                className: "BackgroundSyncQueueStore",
+                funcName: "pushEntry",
+                paramName: "entry"
+            });
+            finalAssertExports.isType(entry.requestData, "object", {
+                moduleName: "serwist",
+                className: "BackgroundSyncQueueStore",
+                funcName: "pushEntry",
+                paramName: "entry.requestData"
+            });
+        }
+        delete entry.id;
+        entry.queueName = this._queueName;
+        await this._queueDb.addEntry(entry);
+    }
+    async unshiftEntry(entry) {
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isType(entry, "object", {
+                moduleName: "serwist",
+                className: "BackgroundSyncQueueStore",
+                funcName: "unshiftEntry",
+                paramName: "entry"
+            });
+            finalAssertExports.isType(entry.requestData, "object", {
+                moduleName: "serwist",
+                className: "BackgroundSyncQueueStore",
+                funcName: "unshiftEntry",
+                paramName: "entry.requestData"
+            });
+        }
+        const firstId = await this._queueDb.getFirstEntryId();
+        if (firstId) {
+            entry.id = firstId - 1;
+        } else {
+            delete entry.id;
+        }
+        entry.queueName = this._queueName;
+        await this._queueDb.addEntry(entry);
+    }
+    async popEntry() {
+        return this._removeEntry(await this._queueDb.getLastEntryByQueueName(this._queueName));
+    }
+    async shiftEntry() {
+        return this._removeEntry(await this._queueDb.getFirstEntryByQueueName(this._queueName));
+    }
+    async getAll() {
+        return await this._queueDb.getAllEntriesByQueueName(this._queueName);
+    }
+    async size() {
+        return await this._queueDb.getEntryCountByQueueName(this._queueName);
+    }
+    async deleteEntry(id) {
+        await this._queueDb.deleteEntry(id);
+    }
+    async _removeEntry(entry) {
+        if (entry) {
+            await this.deleteEntry(entry.id);
+        }
+        return entry;
+    }
+}
+
+const serializableProperties = [
+    "method",
+    "referrer",
+    "referrerPolicy",
+    "mode",
+    "credentials",
+    "cache",
+    "redirect",
+    "integrity",
+    "keepalive"
+];
+class StorableRequest {
+    _requestData;
+    static async fromRequest(request) {
+        const requestData = {
+            url: request.url,
+            headers: {}
+        };
+        if (request.method !== "GET") {
+            requestData.body = await request.clone().arrayBuffer();
+        }
+        request.headers.forEach((value, key)=>{
+            requestData.headers[key] = value;
+        });
+        for (const prop of serializableProperties){
+            if (request[prop] !== undefined) {
+                requestData[prop] = request[prop];
+            }
+        }
+        return new StorableRequest(requestData);
+    }
+    constructor(requestData){
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isType(requestData, "object", {
+                moduleName: "serwist",
+                className: "StorableRequest",
+                funcName: "constructor",
+                paramName: "requestData"
+            });
+            finalAssertExports.isType(requestData.url, "string", {
+                moduleName: "serwist",
+                className: "StorableRequest",
+                funcName: "constructor",
+                paramName: "requestData.url"
+            });
+        }
+        if (requestData.mode === "navigate") {
+            requestData.mode = "same-origin";
+        }
+        this._requestData = requestData;
+    }
+    toObject() {
+        const requestData = Object.assign({}, this._requestData);
+        requestData.headers = Object.assign({}, this._requestData.headers);
+        if (requestData.body) {
+            requestData.body = requestData.body.slice(0);
+        }
+        return requestData;
+    }
+    toRequest() {
+        return new Request(this._requestData.url, this._requestData);
+    }
+    clone() {
+        return new StorableRequest(this.toObject());
+    }
+}
+
+const TAG_PREFIX = "serwist-background-sync";
+const MAX_RETENTION_TIME$1 = 60 * 24 * 7;
+const queueNames = new Set();
+const convertEntry = (queueStoreEntry)=>{
+    const queueEntry = {
+        request: new StorableRequest(queueStoreEntry.requestData).toRequest(),
+        timestamp: queueStoreEntry.timestamp
+    };
+    if (queueStoreEntry.metadata) {
+        queueEntry.metadata = queueStoreEntry.metadata;
+    }
+    return queueEntry;
+};
+class BackgroundSyncQueue {
+    _name;
+    _onSync;
+    _maxRetentionTime;
+    _queueStore;
+    _forceSyncFallback;
+    _syncInProgress = false;
+    _requestsAddedDuringSync = false;
+    constructor(name, { forceSyncFallback, onSync, maxRetentionTime } = {}){
+        if (queueNames.has(name)) {
+            throw new SerwistError("duplicate-queue-name", {
+                name
+            });
+        }
+        queueNames.add(name);
+        this._name = name;
+        this._onSync = onSync || this.replayRequests;
+        this._maxRetentionTime = maxRetentionTime || MAX_RETENTION_TIME$1;
+        this._forceSyncFallback = Boolean(forceSyncFallback);
+        this._queueStore = new BackgroundSyncQueueStore(this._name);
+        this._addSyncListener();
+    }
+    get name() {
+        return this._name;
+    }
+    async pushRequest(entry) {
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isType(entry, "object", {
+                moduleName: "serwist",
+                className: "BackgroundSyncQueue",
+                funcName: "pushRequest",
+                paramName: "entry"
+            });
+            finalAssertExports.isInstance(entry.request, Request, {
+                moduleName: "serwist",
+                className: "BackgroundSyncQueue",
+                funcName: "pushRequest",
+                paramName: "entry.request"
+            });
+        }
+        await this._addRequest(entry, "push");
+    }
+    async unshiftRequest(entry) {
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isType(entry, "object", {
+                moduleName: "serwist",
+                className: "BackgroundSyncQueue",
+                funcName: "unshiftRequest",
+                paramName: "entry"
+            });
+            finalAssertExports.isInstance(entry.request, Request, {
+                moduleName: "serwist",
+                className: "BackgroundSyncQueue",
+                funcName: "unshiftRequest",
+                paramName: "entry.request"
+            });
+        }
+        await this._addRequest(entry, "unshift");
+    }
+    async popRequest() {
+        return this._removeRequest("pop");
+    }
+    async shiftRequest() {
+        return this._removeRequest("shift");
+    }
+    async getAll() {
+        const allEntries = await this._queueStore.getAll();
+        const now = Date.now();
+        const unexpiredEntries = [];
+        for (const entry of allEntries){
+            const maxRetentionTimeInMs = this._maxRetentionTime * 60 * 1000;
+            if (now - entry.timestamp > maxRetentionTimeInMs) {
+                await this._queueStore.deleteEntry(entry.id);
+            } else {
+                unexpiredEntries.push(convertEntry(entry));
+            }
+        }
+        return unexpiredEntries;
+    }
+    async size() {
+        return await this._queueStore.size();
+    }
+    async _addRequest({ request, metadata, timestamp = Date.now() }, operation) {
+        const storableRequest = await StorableRequest.fromRequest(request.clone());
+        const entry = {
+            requestData: storableRequest.toObject(),
+            timestamp
+        };
+        if (metadata) {
+            entry.metadata = metadata;
+        }
+        switch(operation){
+            case "push":
+                await this._queueStore.pushEntry(entry);
+                break;
+            case "unshift":
+                await this._queueStore.unshiftEntry(entry);
+                break;
+        }
+        if (process.env.NODE_ENV !== "production") {
+            logger.log(`Request for '${getFriendlyURL(request.url)}' has ` + `been added to background sync queue '${this._name}'.`);
+        }
+        if (this._syncInProgress) {
+            this._requestsAddedDuringSync = true;
+        } else {
+            await this.registerSync();
+        }
+    }
+    async _removeRequest(operation) {
+        const now = Date.now();
+        let entry;
+        switch(operation){
+            case "pop":
+                entry = await this._queueStore.popEntry();
+                break;
+            case "shift":
+                entry = await this._queueStore.shiftEntry();
+                break;
+        }
+        if (entry) {
+            const maxRetentionTimeInMs = this._maxRetentionTime * 60 * 1000;
+            if (now - entry.timestamp > maxRetentionTimeInMs) {
+                return this._removeRequest(operation);
+            }
+            return convertEntry(entry);
+        }
+        return undefined;
+    }
+    async replayRequests() {
+        let entry;
+        while(entry = await this.shiftRequest()){
+            try {
+                await fetch(entry.request.clone());
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log(`Request for '${getFriendlyURL(entry.request.url)}' ` + `has been replayed in queue '${this._name}'`);
+                }
+            } catch  {
+                await this.unshiftRequest(entry);
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log(`Request for '${getFriendlyURL(entry.request.url)}' ` + `failed to replay, putting it back in queue '${this._name}'`);
+                }
+                throw new SerwistError("queue-replay-failed", {
+                    name: this._name
+                });
+            }
+        }
+        if (process.env.NODE_ENV !== "production") {
+            logger.log(`All requests in queue '${this.name}' have successfully replayed; the queue is now empty!`);
+        }
+    }
+    async registerSync() {
+        if ("sync" in self.registration && !this._forceSyncFallback) {
+            try {
+                await self.registration.sync.register(`${TAG_PREFIX}:${this._name}`);
+            } catch (err) {
+                if (process.env.NODE_ENV !== "production") {
+                    logger.warn(`Unable to register sync event for '${this._name}'.`, err);
+                }
+            }
+        }
+    }
+    _addSyncListener() {
+        if ("sync" in self.registration && !this._forceSyncFallback) {
+            self.addEventListener("sync", (event)=>{
+                if (event.tag === `${TAG_PREFIX}:${this._name}`) {
+                    if (process.env.NODE_ENV !== "production") {
+                        logger.log(`Background sync for tag '${event.tag}' has been received`);
+                    }
+                    const syncComplete = async ()=>{
+                        this._syncInProgress = true;
+                        let syncError;
+                        try {
+                            await this._onSync({
+                                queue: this
+                            });
+                        } catch (error) {
+                            if (error instanceof Error) {
+                                syncError = error;
+                                throw syncError;
+                            }
+                        } finally{
+                            if (this._requestsAddedDuringSync && !(syncError && !event.lastChance)) {
+                                await this.registerSync();
+                            }
+                            this._syncInProgress = false;
+                            this._requestsAddedDuringSync = false;
+                        }
+                    };
+                    event.waitUntil(syncComplete());
+                }
+            });
+        } else {
+            if (process.env.NODE_ENV !== "production") {
+                logger.log("Background sync replaying without background sync event");
+            }
+            void this._onSync({
+                queue: this
+            });
+        }
+    }
+    static get _queueNames() {
+        return queueNames;
+    }
+}
+
+class BackgroundSyncPlugin {
+    _queue;
+    constructor(name, options){
+        this._queue = new BackgroundSyncQueue(name, options);
+    }
+    async fetchDidFail({ request }) {
+        await this._queue.pushRequest({
+            request
+        });
+    }
+}
+
+const parseRoute = (capture, handler, method)=>{
+    if (typeof capture === "string") {
+        const captureUrl = new URL(capture, location.href);
+        if (process.env.NODE_ENV !== "production") {
+            if (!(capture.startsWith("/") || capture.startsWith("http"))) {
+                throw new SerwistError("invalid-string", {
+                    moduleName: "serwist",
+                    funcName: "parseRoute",
+                    paramName: "capture"
+                });
+            }
+            const valueToCheck = capture.startsWith("http") ? captureUrl.pathname : capture;
+            const wildcards = "[*:?+]";
+            if (new RegExp(`${wildcards}`).exec(valueToCheck)) {
+                logger.debug(`The '$capture' parameter contains an Express-style wildcard character (${wildcards}). Strings are now always interpreted as exact matches; use a RegExp for partial or wildcard matches.`);
+            }
+        }
+        const matchCallback = ({ url })=>{
+            if (process.env.NODE_ENV !== "production") {
+                if (url.pathname === captureUrl.pathname && url.origin !== captureUrl.origin) {
+                    logger.debug(`${capture} only partially matches the cross-origin URL ${url.toString()}. This route will only handle cross-origin requests if they match the entire URL.`);
+                }
+            }
+            return url.href === captureUrl.href;
+        };
+        return new Route(matchCallback, handler, method);
+    }
+    if (capture instanceof RegExp) {
+        return new RegExpRoute(capture, handler, method);
+    }
+    if (typeof capture === "function") {
+        return new Route(capture, handler, method);
+    }
+    if (capture instanceof Route) {
+        return capture;
+    }
+    throw new SerwistError("unsupported-route-type", {
+        moduleName: "serwist",
+        funcName: "parseRoute",
+        paramName: "capture"
+    });
+};
+
+const registerCapture = (state, capture, handler, method)=>{
+    const route = parseRoute(capture, handler, method);
+    registerRoute(state, route);
+    return route;
+};
+const registerRoute = (state, route)=>{
+    if (process.env.NODE_ENV !== "production") {
+        finalAssertExports.isType(route, "object", {
+            moduleName: "serwist",
+            className: "Serwist",
+            funcName: "registerRoute",
+            paramName: "route"
+        });
+        finalAssertExports.hasMethod(route, "match", {
+            moduleName: "serwist",
+            className: "Serwist",
+            funcName: "registerRoute",
+            paramName: "route"
+        });
+        finalAssertExports.isType(route.handler, "object", {
+            moduleName: "serwist",
+            className: "Serwist",
+            funcName: "registerRoute",
+            paramName: "route"
+        });
+        finalAssertExports.hasMethod(route.handler, "handle", {
+            moduleName: "serwist",
+            className: "Serwist",
+            funcName: "registerRoute",
+            paramName: "route.handler"
+        });
+        finalAssertExports.isType(route.method, "string", {
+            moduleName: "serwist",
+            className: "Serwist",
+            funcName: "registerRoute",
+            paramName: "route.method"
+        });
+    }
+    if (!state.routes.has(route.method)) {
+        state.routes.set(route.method, []);
+    }
+    state.routes.get(route.method).push(route);
+};
+const unregisterRoute = (state, route)=>{
+    if (!state.routes.has(route.method)) {
+        throw new SerwistError("unregister-route-but-not-found-with-method", {
+            method: route.method
+        });
+    }
+    const routeIndex = state.routes.get(route.method).indexOf(route);
+    if (routeIndex > -1) {
+        state.routes.get(route.method).splice(routeIndex, 1);
+    } else {
+        throw new SerwistError("unregister-route-route-not-registered");
+    }
+};
+const handleRequest = (state, { request, event })=>{
+    if (process.env.NODE_ENV !== "production") {
+        finalAssertExports.isInstance(request, Request, {
+            moduleName: "serwist",
+            className: "Serwist",
+            funcName: "handleRequest",
+            paramName: "options.request"
+        });
+    }
+    const url = new URL(request.url, location.href);
+    if (!url.protocol.startsWith("http")) {
+        if (process.env.NODE_ENV !== "production") {
+            logger.debug("Router only supports URLs that start with 'http'.");
+        }
+        return;
+    }
+    const sameOrigin = url.origin === location.origin;
+    const { params, route } = findMatchingRoute(state, {
+        event,
+        request,
+        sameOrigin,
+        url
+    });
+    let handler = route?.handler;
+    const debugMessages = [];
+    if (process.env.NODE_ENV !== "production") {
+        if (handler) {
+            debugMessages.push([
+                "Found a route to handle this request:",
+                route
+            ]);
+            if (params) {
+                debugMessages.push([
+                    `Passing the following params to the route's handler:`,
+                    params
+                ]);
+            }
+        }
+    }
+    const method = request.method;
+    if (!handler && state.defaultHandlerMap.has(method)) {
+        if (process.env.NODE_ENV !== "production") {
+            debugMessages.push(`Failed to find a matching route. Falling back to the default handler for ${method}.`);
+        }
+        handler = state.defaultHandlerMap.get(method);
+    }
+    if (!handler) {
+        if (process.env.NODE_ENV !== "production") {
+            logger.debug(`No route found for: ${getFriendlyURL(url)}`);
+        }
+        return;
+    }
+    if (process.env.NODE_ENV !== "production") {
+        logger.groupCollapsed(`Router is responding to: ${getFriendlyURL(url)}`);
+        for (const msg of debugMessages){
+            if (Array.isArray(msg)) {
+                logger.log(...msg);
+            } else {
+                logger.log(msg);
+            }
+        }
+        logger.groupEnd();
+    }
+    let responsePromise;
+    try {
+        responsePromise = handler.handle({
+            url,
+            request,
+            event,
+            params
+        });
+    } catch (err) {
+        responsePromise = Promise.reject(err);
+    }
+    const catchHandler = route?.catchHandler;
+    if (responsePromise instanceof Promise && (state.catchHandler || catchHandler)) {
+        responsePromise = responsePromise.catch(async (err)=>{
+            if (catchHandler) {
+                if (process.env.NODE_ENV !== "production") {
+                    logger.groupCollapsed(`Error thrown when responding to:  ${getFriendlyURL(url)}. Falling back to route's Catch Handler.`);
+                    logger.error("Error thrown by:", route);
+                    logger.error(err);
+                    logger.groupEnd();
+                }
+                try {
+                    return await catchHandler.handle({
+                        url,
+                        request,
+                        event,
+                        params
+                    });
+                } catch (catchErr) {
+                    if (catchErr instanceof Error) {
+                        err = catchErr;
+                    }
+                }
+            }
+            if (state.catchHandler) {
+                if (process.env.NODE_ENV !== "production") {
+                    logger.groupCollapsed(`Error thrown when responding to:  ${getFriendlyURL(url)}. Falling back to global Catch Handler.`);
+                    logger.error("Error thrown by:", route);
+                    logger.error(err);
+                    logger.groupEnd();
+                }
+                return state.catchHandler.handle({
+                    url,
+                    request,
+                    event
+                });
+            }
+            throw err;
+        });
+    }
+    return responsePromise;
+};
+const findMatchingRoute = (state, { url, sameOrigin, request, event })=>{
+    const routes = state.routes.get(request.method) || [];
+    for (const route of routes){
+        let params;
+        const matchResult = route.match({
+            url,
+            sameOrigin,
+            request,
+            event
+        });
+        if (matchResult) {
+            if (process.env.NODE_ENV !== "production") {
+                if (matchResult instanceof Promise) {
+                    logger.warn(`While routing ${getFriendlyURL(url)}, an async matchCallback function was used. Please convert the following route to use a synchronous matchCallback function:`, route);
+                }
+            }
+            params = matchResult;
+            if (Array.isArray(params) && params.length === 0) {
+                params = undefined;
+            } else if (matchResult.constructor === Object && Object.keys(matchResult).length === 0) {
+                params = undefined;
+            } else if (typeof matchResult === "boolean") {
+                params = undefined;
+            }
+            return {
+                route,
+                params
+            };
+        }
+    }
+    return {};
+};
+
+const cacheOkAndOpaquePlugin = {
+    cacheWillUpdate: async ({ response })=>{
+        if (response.status === 200 || response.status === 0) {
+            return response;
+        }
+        return null;
+    }
+};
+
+function toRequest(input) {
+    return typeof input === "string" ? new Request(input) : input;
+}
+class StrategyHandler {
+    event;
+    request;
+    url;
+    params;
+    _cacheKeys = {};
+    _strategy;
+    _handlerDeferred;
+    _extendLifetimePromises;
+    _plugins;
+    _pluginStateMap;
+    constructor(strategy, options){
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isInstance(options.event, ExtendableEvent, {
+                moduleName: "serwist",
+                className: "StrategyHandler",
+                funcName: "constructor",
+                paramName: "options.event"
+            });
+            finalAssertExports.isInstance(options.request, Request, {
+                moduleName: "serwist",
+                className: "StrategyHandler",
+                funcName: "constructor",
+                paramName: "options.request"
+            });
+        }
+        this.event = options.event;
+        this.request = options.request;
+        if (options.url) {
+            this.url = options.url;
+            this.params = options.params;
+        }
+        this._strategy = strategy;
+        this._handlerDeferred = new Deferred();
+        this._extendLifetimePromises = [];
+        this._plugins = [
+            ...strategy.plugins
+        ];
+        this._pluginStateMap = new Map();
+        for (const plugin of this._plugins){
+            this._pluginStateMap.set(plugin, {});
+        }
+        this.event.waitUntil(this._handlerDeferred.promise);
+    }
+    async fetch(input) {
+        const { event } = this;
+        let request = toRequest(input);
+        const preloadResponse = await this.getPreloadResponse();
+        if (preloadResponse) {
+            return preloadResponse;
+        }
+        const originalRequest = this.hasCallback("fetchDidFail") ? request.clone() : null;
+        try {
+            for (const cb of this.iterateCallbacks("requestWillFetch")){
+                request = await cb({
+                    request: request.clone(),
+                    event
+                });
+            }
+        } catch (err) {
+            if (err instanceof Error) {
+                throw new SerwistError("plugin-error-request-will-fetch", {
+                    thrownErrorMessage: err.message
+                });
+            }
+        }
+        const pluginFilteredRequest = request.clone();
+        try {
+            let fetchResponse;
+            fetchResponse = await fetch(request, request.mode === "navigate" ? undefined : this._strategy.fetchOptions);
+            if (process.env.NODE_ENV !== "production") {
+                logger.debug(`Network request for '${getFriendlyURL(request.url)}' returned a response with status '${fetchResponse.status}'.`);
+            }
+            for (const callback of this.iterateCallbacks("fetchDidSucceed")){
+                fetchResponse = await callback({
+                    event,
+                    request: pluginFilteredRequest,
+                    response: fetchResponse
+                });
+            }
+            return fetchResponse;
+        } catch (error) {
+            if (process.env.NODE_ENV !== "production") {
+                logger.log(`Network request for '${getFriendlyURL(request.url)}' threw an error.`, error);
+            }
+            if (originalRequest) {
+                await this.runCallbacks("fetchDidFail", {
+                    error: error,
+                    event,
+                    originalRequest: originalRequest.clone(),
+                    request: pluginFilteredRequest.clone()
+                });
+            }
+            throw error;
+        }
+    }
+    async fetchAndCachePut(input) {
+        const response = await this.fetch(input);
+        const responseClone = response.clone();
+        void this.waitUntil(this.cachePut(input, responseClone));
+        return response;
+    }
+    async cacheMatch(key) {
+        const request = toRequest(key);
+        let cachedResponse;
+        const { cacheName, matchOptions } = this._strategy;
+        const effectiveRequest = await this.getCacheKey(request, "read");
+        const multiMatchOptions = {
+            ...matchOptions,
+            ...{
+                cacheName
+            }
+        };
+        cachedResponse = await caches.match(effectiveRequest, multiMatchOptions);
+        if (process.env.NODE_ENV !== "production") {
+            if (cachedResponse) {
+                logger.debug(`Found a cached response in '${cacheName}'.`);
+            } else {
+                logger.debug(`No cached response found in '${cacheName}'.`);
+            }
+        }
+        for (const callback of this.iterateCallbacks("cachedResponseWillBeUsed")){
+            cachedResponse = await callback({
+                cacheName,
+                matchOptions,
+                cachedResponse,
+                request: effectiveRequest,
+                event: this.event
+            }) || undefined;
+        }
+        return cachedResponse;
+    }
+    async cachePut(key, response) {
+        const request = toRequest(key);
+        await timeout(0);
+        const effectiveRequest = await this.getCacheKey(request, "write");
+        if (process.env.NODE_ENV !== "production") {
+            if (effectiveRequest.method && effectiveRequest.method !== "GET") {
+                throw new SerwistError("attempt-to-cache-non-get-request", {
+                    url: getFriendlyURL(effectiveRequest.url),
+                    method: effectiveRequest.method
+                });
+            }
+        }
+        if (!response) {
+            if (process.env.NODE_ENV !== "production") {
+                logger.error(`Cannot cache non-existent response for '${getFriendlyURL(effectiveRequest.url)}'.`);
+            }
+            throw new SerwistError("cache-put-with-no-response", {
+                url: getFriendlyURL(effectiveRequest.url)
+            });
+        }
+        const responseToCache = await this._ensureResponseSafeToCache(response);
+        if (!responseToCache) {
+            if (process.env.NODE_ENV !== "production") {
+                logger.debug(`Response '${getFriendlyURL(effectiveRequest.url)}' will not be cached.`, responseToCache);
+            }
+            return false;
+        }
+        const { cacheName, matchOptions } = this._strategy;
+        const cache = await self.caches.open(cacheName);
+        if (process.env.NODE_ENV !== "production") {
+            const vary = response.headers.get("Vary");
+            if (vary && matchOptions?.ignoreVary !== true) {
+                logger.debug(`The response for ${getFriendlyURL(effectiveRequest.url)} has a 'Vary: ${vary}' header. Consider setting the {ignoreVary: true} option on your strategy to ensure cache matching and deletion works as expected.`);
+            }
+        }
+        const hasCacheUpdateCallback = this.hasCallback("cacheDidUpdate");
+        const oldResponse = hasCacheUpdateCallback ? await cacheMatchIgnoreParams(cache, effectiveRequest.clone(), [
+            "__WB_REVISION__"
+        ], matchOptions) : null;
+        if (process.env.NODE_ENV !== "production") {
+            logger.debug(`Updating the '${cacheName}' cache with a new Response for ${getFriendlyURL(effectiveRequest.url)}.`);
+        }
+        try {
+            await cache.put(effectiveRequest, hasCacheUpdateCallback ? responseToCache.clone() : responseToCache);
+        } catch (error) {
+            if (error instanceof Error) {
+                if (error.name === "QuotaExceededError") {
+                    await executeQuotaErrorCallbacks();
+                }
+                throw error;
+            }
+        }
+        for (const callback of this.iterateCallbacks("cacheDidUpdate")){
+            await callback({
+                cacheName,
+                oldResponse,
+                newResponse: responseToCache.clone(),
+                request: effectiveRequest,
+                event: this.event
+            });
+        }
+        return true;
+    }
+    async getCacheKey(request, mode) {
+        const key = `${request.url} | ${mode}`;
+        if (!this._cacheKeys[key]) {
+            let effectiveRequest = request;
+            for (const callback of this.iterateCallbacks("cacheKeyWillBeUsed")){
+                effectiveRequest = toRequest(await callback({
+                    mode,
+                    request: effectiveRequest,
+                    event: this.event,
+                    params: this.params
+                }));
+            }
+            this._cacheKeys[key] = effectiveRequest;
+        }
+        return this._cacheKeys[key];
+    }
+    hasCallback(name) {
+        for (const plugin of this._strategy.plugins){
+            if (name in plugin) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async runCallbacks(name, param) {
+        for (const callback of this.iterateCallbacks(name)){
+            await callback(param);
+        }
+    }
+    *iterateCallbacks(name) {
+        for (const plugin of this._strategy.plugins){
+            if (typeof plugin[name] === "function") {
+                const state = this._pluginStateMap.get(plugin);
+                const statefulCallback = (param)=>{
+                    const statefulParam = {
+                        ...param,
+                        state
                     };
+                    return plugin[name](statefulParam);
+                };
+                yield statefulCallback;
+            }
+        }
+    }
+    waitUntil(promise) {
+        this._extendLifetimePromises.push(promise);
+        return promise;
+    }
+    async doneWaiting() {
+        let promise;
+        while(promise = this._extendLifetimePromises.shift()){
+            await promise;
+        }
+    }
+    destroy() {
+        this._handlerDeferred.resolve(null);
+    }
+    async getPreloadResponse() {
+        if (this.event instanceof FetchEvent && this.event.request.mode === "navigate" && "preloadResponse" in this.event) {
+            try {
+                const possiblePreloadResponse = await this.event.preloadResponse;
+                if (possiblePreloadResponse) {
+                    if (process.env.NODE_ENV !== "production") {
+                        logger.log(`Using a preloaded navigation response for '${getFriendlyURL(this.event.request.url)}'`);
+                    }
+                    return possiblePreloadResponse;
+                }
+            } catch (error) {
+                if (process.env.NODE_ENV !== "production") {
+                    logger.error(error);
+                }
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    async _ensureResponseSafeToCache(response) {
+        let responseToCache = response;
+        let pluginsUsed = false;
+        for (const callback of this.iterateCallbacks("cacheWillUpdate")){
+            responseToCache = await callback({
+                request: this.request,
+                response: responseToCache,
+                event: this.event
+            }) || undefined;
+            pluginsUsed = true;
+            if (!responseToCache) {
+                break;
+            }
+        }
+        if (!pluginsUsed) {
+            if (responseToCache && responseToCache.status !== 200) {
+                if (process.env.NODE_ENV !== "production") {
+                    if (responseToCache.status === 0) {
+                        logger.warn(`The response for '${this.request.url}' is an opaque response. The caching strategy that you're using will not cache opaque responses by default.`);
+                    } else {
+                        logger.debug(`The response for '${this.request.url}' returned a status code of '${response.status}' and won't be cached as a result.`);
+                    }
+                }
+                responseToCache = undefined;
+            }
+        }
+        return responseToCache;
+    }
+}
+
+class Strategy {
+    cacheName;
+    plugins;
+    fetchOptions;
+    matchOptions;
+    constructor(options = {}){
+        this.cacheName = cacheNames$1.getRuntimeName(options.cacheName);
+        this.plugins = options.plugins || [];
+        this.fetchOptions = options.fetchOptions;
+        this.matchOptions = options.matchOptions;
+    }
+    handle(options) {
+        const [responseDone] = this.handleAll(options);
+        return responseDone;
+    }
+    handleAll(options) {
+        if (options instanceof FetchEvent) {
+            options = {
+                event: options,
+                request: options.request
+            };
+        }
+        const event = options.event;
+        const request = typeof options.request === "string" ? new Request(options.request) : options.request;
+        const handler = new StrategyHandler(this, options.url ? {
+            event,
+            request,
+            url: options.url,
+            params: options.params
+        } : {
+            event,
+            request
+        });
+        const responseDone = this._getResponse(handler, request, event);
+        const handlerDone = this._awaitComplete(responseDone, handler, request, event);
+        return [
+            responseDone,
+            handlerDone
+        ];
+    }
+    async _getResponse(handler, request, event) {
+        await handler.runCallbacks("handlerWillStart", {
+            event,
+            request
+        });
+        let response;
+        try {
+            response = await this._handle(request, handler);
+            if (response === undefined || response.type === "error") {
+                throw new SerwistError("no-response", {
+                    url: request.url
+                });
+            }
+        } catch (error) {
+            if (error instanceof Error) {
+                for (const callback of handler.iterateCallbacks("handlerDidError")){
+                    response = await callback({
+                        error,
+                        event,
+                        request
+                    });
+                    if (response !== undefined) {
+                        break;
+                    }
                 }
             }
+            if (!response) {
+                throw error;
+            }
             if (process.env.NODE_ENV !== "production") {
-                logger.debug(`Precaching did not find a match for ${getFriendlyURL(request.url)}.`);
+                throw logger.log(`While responding to '${getFriendlyURL(request.url)}', an ${error instanceof Error ? error.toString() : ""} error occurred. Using a fallback response provided by a handlerDidError plugin.`);
             }
-            return;
+        }
+        for (const callback of handler.iterateCallbacks("handlerWillRespond")){
+            response = await callback({
+                event,
+                request,
+                response
+            });
+        }
+        return response;
+    }
+    async _awaitComplete(responseDone, handler, request, event) {
+        let response;
+        let error;
+        try {
+            response = await responseDone;
+        } catch  {}
+        try {
+            await handler.runCallbacks("handlerDidRespond", {
+                event,
+                request,
+                response
+            });
+            await handler.doneWaiting();
+        } catch (waitUntilError) {
+            if (waitUntilError instanceof Error) {
+                error = waitUntilError;
+            }
+        }
+        await handler.runCallbacks("handlerDidComplete", {
+            event,
+            request,
+            response,
+            error
+        });
+        handler.destroy();
+        if (error) {
+            throw error;
+        }
+    }
+}
+
+const messages = {
+    strategyStart: (strategyName, request)=>`Using ${strategyName} to respond to '${getFriendlyURL(request.url)}'`,
+    printFinalResponse: (response)=>{
+        if (response) {
+            logger.groupCollapsed("View the final response here.");
+            logger.log(response || "[No response returned]");
+            logger.groupEnd();
+        }
+    }
+};
+
+class NetworkFirst extends Strategy {
+    _networkTimeoutSeconds;
+    constructor(options = {}){
+        super(options);
+        if (!this.plugins.some((p)=>"cacheWillUpdate" in p)) {
+            this.plugins.unshift(cacheOkAndOpaquePlugin);
+        }
+        this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;
+        if (process.env.NODE_ENV !== "production") {
+            if (this._networkTimeoutSeconds) {
+                finalAssertExports.isType(this._networkTimeoutSeconds, "number", {
+                    moduleName: "serwist",
+                    className: this.constructor.name,
+                    funcName: "constructor",
+                    paramName: "networkTimeoutSeconds"
+                });
+            }
+        }
+    }
+    async _handle(request, handler) {
+        const logs = [];
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isInstance(request, Request, {
+                moduleName: "serwist",
+                className: this.constructor.name,
+                funcName: "handle",
+                paramName: "makeRequest"
+            });
+        }
+        const promises = [];
+        let timeoutId;
+        if (this._networkTimeoutSeconds) {
+            const { id, promise } = this._getTimeoutPromise({
+                request,
+                logs,
+                handler
+            });
+            timeoutId = id;
+            promises.push(promise);
+        }
+        const networkPromise = this._getNetworkPromise({
+            timeoutId,
+            request,
+            logs,
+            handler
+        });
+        promises.push(networkPromise);
+        const response = await handler.waitUntil((async ()=>{
+            return await handler.waitUntil(Promise.race(promises)) || await networkPromise;
+        })());
+        if (process.env.NODE_ENV !== "production") {
+            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
+            for (const log of logs){
+                logger.log(log);
+            }
+            messages.printFinalResponse(response);
+            logger.groupEnd();
+        }
+        if (!response) {
+            throw new SerwistError("no-response", {
+                url: request.url
+            });
+        }
+        return response;
+    }
+    _getTimeoutPromise({ request, logs, handler }) {
+        let timeoutId;
+        const timeoutPromise = new Promise((resolve)=>{
+            const onNetworkTimeout = async ()=>{
+                if (process.env.NODE_ENV !== "production") {
+                    logs.push(`Timing out the network response at ${this._networkTimeoutSeconds} seconds.`);
+                }
+                resolve(await handler.cacheMatch(request));
+            };
+            timeoutId = setTimeout(onNetworkTimeout, this._networkTimeoutSeconds * 1000);
+        });
+        return {
+            promise: timeoutPromise,
+            id: timeoutId
         };
-        super(match, serwist.precacheStrategy);
+    }
+    async _getNetworkPromise({ timeoutId, request, logs, handler }) {
+        let error;
+        let response;
+        try {
+            response = await handler.fetchAndCachePut(request);
+        } catch (fetchError) {
+            if (fetchError instanceof Error) {
+                error = fetchError;
+            }
+        }
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        if (process.env.NODE_ENV !== "production") {
+            if (response) {
+                logs.push("Got response from network.");
+            } else {
+                logs.push("Unable to get a response from the network. Will respond " + "with a cached response.");
+            }
+        }
+        if (error || !response) {
+            response = await handler.cacheMatch(request);
+            if (process.env.NODE_ENV !== "production") {
+                if (response) {
+                    logs.push(`Found a cached response in the '${this.cacheName}' cache.`);
+                } else {
+                    logs.push(`No response found in the '${this.cacheName}' cache.`);
+                }
+            }
+        }
+        return response;
+    }
+}
+
+class NetworkOnly extends Strategy {
+    _networkTimeoutSeconds;
+    constructor(options = {}){
+        super(options);
+        this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0;
+    }
+    async _handle(request, handler) {
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isInstance(request, Request, {
+                moduleName: "serwist",
+                className: this.constructor.name,
+                funcName: "_handle",
+                paramName: "request"
+            });
+        }
+        let error;
+        let response;
+        try {
+            const promises = [
+                handler.fetch(request)
+            ];
+            if (this._networkTimeoutSeconds) {
+                const timeoutPromise = timeout(this._networkTimeoutSeconds * 1000);
+                promises.push(timeoutPromise);
+            }
+            response = await Promise.race(promises);
+            if (!response) {
+                throw new Error(`Timed out the network response after ${this._networkTimeoutSeconds} seconds.`);
+            }
+        } catch (err) {
+            if (err instanceof Error) {
+                error = err;
+            }
+        }
+        if (process.env.NODE_ENV !== "production") {
+            logger.groupCollapsed(messages.strategyStart(this.constructor.name, request));
+            if (response) {
+                logger.log("Got response from network.");
+            } else {
+                logger.log("Unable to get a response from the network.");
+            }
+            messages.printFinalResponse(response);
+            logger.groupEnd();
+        }
+        if (!response) {
+            throw new SerwistError("no-response", {
+                url: request.url,
+                error
+            });
+        }
+        return response;
     }
 }
 
@@ -114,6 +1572,29 @@ const createGtmJsRoute = (cacheName)=>{
     });
     return new Route(match, handler, "GET");
 };
+class GoogleAnalytics {
+    _options;
+    constructor(options = {}){
+        this._options = options;
+    }
+    init({ serwist }) {
+        const resolvedCacheName = cacheNames$1.getGoogleAnalyticsName(this._options.cacheName);
+        const bgSyncPlugin = new BackgroundSyncPlugin(QUEUE_NAME, {
+            maxRetentionTime: MAX_RETENTION_TIME,
+            onSync: createOnSyncCallback(this._options)
+        });
+        const routes = [
+            createGtmJsRoute(resolvedCacheName),
+            createAnalyticsJsRoute(resolvedCacheName),
+            createGtagJsRoute(resolvedCacheName),
+            ...createCollectRoutes(bgSyncPlugin)
+        ];
+        for (const route of routes){
+            registerRoute(serwist, route);
+        }
+    }
+}
+
 const initializeGoogleAnalytics = ({ serwist, cacheName, ...options })=>{
     const resolvedCacheName = cacheNames$1.getGoogleAnalyticsName(cacheName);
     const bgSyncPlugin = new BackgroundSyncPlugin(QUEUE_NAME, {
@@ -131,30 +1612,82 @@ const initializeGoogleAnalytics = ({ serwist, cacheName, ...options })=>{
     }
 };
 
-class PrecacheFallbackPlugin {
-    _fallbackUrls;
-    _serwist;
-    constructor({ fallbackUrls, serwist }){
-        this._fallbackUrls = fallbackUrls;
-        this._serwist = serwist;
+const REVISION_SEARCH_PARAM = "__WB_REVISION__";
+const createCacheKey = (entry)=>{
+    if (!entry) {
+        throw new SerwistError("add-to-cache-list-unexpected-type", {
+            entry
+        });
     }
-    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;
+    if (typeof entry === "string") {
+        const urlObject = new URL(entry, location.href);
+        return {
+            cacheKey: urlObject.href,
+            url: urlObject.href
+        };
+    }
+    const { revision, url } = entry;
+    if (!url) {
+        throw new SerwistError("add-to-cache-list-unexpected-type", {
+            entry
+        });
+    }
+    if (!revision) {
+        const urlObject = new URL(url, location.href);
+        return {
+            cacheKey: urlObject.href,
+            url: urlObject.href
+        };
+    }
+    const cacheKeyURL = new URL(url, location.href);
+    const originalURL = new URL(url, location.href);
+    cacheKeyURL.searchParams.set(REVISION_SEARCH_PARAM, revision);
+    return {
+        cacheKey: cacheKeyURL.href,
+        url: originalURL.href
+    };
+};
+
+const logGroup = (groupTitle, deletedURLs)=>{
+    logger.groupCollapsed(groupTitle);
+    for (const url of deletedURLs){
+        logger.log(url);
+    }
+    logger.groupEnd();
+};
+const printCleanupDetails = (deletedURLs)=>{
+    const deletionCount = deletedURLs.length;
+    if (deletionCount > 0) {
+        logger.groupCollapsed(`During precaching cleanup, ${deletionCount} cached request${deletionCount === 1 ? " was" : "s were"} deleted.`);
+        logGroup("Deleted Cache Requests", deletedURLs);
+        logger.groupEnd();
+    }
+};
+
+function _nestedGroup(groupTitle, urls) {
+    if (urls.length === 0) {
+        return;
+    }
+    logger.groupCollapsed(groupTitle);
+    for (const url of urls){
+        logger.log(url);
     }
+    logger.groupEnd();
 }
+const printInstallDetails = (urlsToPrecache, urlsAlreadyPrecached)=>{
+    const precachedCount = urlsToPrecache.length;
+    const alreadyPrecachedCount = urlsAlreadyPrecached.length;
+    if (precachedCount || alreadyPrecachedCount) {
+        let message = `Precaching ${precachedCount} file${precachedCount === 1 ? "" : "s"}.`;
+        if (alreadyPrecachedCount > 0) {
+            message += ` ${alreadyPrecachedCount} ` + `file${alreadyPrecachedCount === 1 ? " is" : "s are"} already cached.`;
+        }
+        logger.groupCollapsed(message);
+        _nestedGroup("View newly precached URLs.", urlsToPrecache);
+        _nestedGroup("View previously precached URLs.", urlsAlreadyPrecached);
+        logger.groupEnd();
+    }
+};
 
 class PrecacheCacheKeyPlugin {
     _precacheController;
@@ -169,134 +1702,323 @@ class PrecacheCacheKeyPlugin {
     };
 }
 
-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),
+const parsePrecacheOptions = (controller, { entries, cacheName, plugins, fetchOptions, matchOptions, fallbackToNetwork, directoryIndex, ignoreURLParametersMatching, cleanURLs, urlManipulation, cleanupOutdatedCaches, concurrency, navigateFallback, navigateFallbackAllowlist, navigateFallbackDenylist })=>({
+        entries: entries ?? [],
+        strategyOptions: {
+            cacheName: cacheNames$1.getPrecacheName(cacheName),
             plugins: [
-                ...precachePlugins,
+                ...plugins ?? [],
                 new PrecacheCacheKeyPlugin({
-                    precacheController: serwist
+                    precacheController: controller
                 })
             ],
-            fetchOptions: precacheFetchOptions,
-            matchOptions: precacheMatchOptions,
-            fallbackToNetwork: precacheFallbackToNetwork
+            fetchOptions,
+            matchOptions,
+            fallbackToNetwork
         },
-        precacheRouteOptions: {
-            directoryIndex: precacheDirectoryIndex,
-            ignoreURLParametersMatching: precacheIgnoreUrls,
-            cleanURLs: precacheCleanUrls,
-            urlManipulation: precacheUrlManipulation
+        routeOptions: {
+            directoryIndex,
+            ignoreURLParametersMatching,
+            cleanURLs,
+            urlManipulation
         },
-        precacheMiscOptions: {
+        extensionOptions: {
             cleanupOutdatedCaches,
-            concurrency,
+            concurrency: concurrency ?? 10,
             navigateFallback,
             navigateFallbackAllowlist,
             navigateFallbackDenylist
         }
+    });
+
+class PrecacheInstallReportPlugin {
+    updatedURLs = [];
+    notUpdatedURLs = [];
+    handlerWillStart = async ({ request, state })=>{
+        if (state) {
+            state.originalRequest = request;
+        }
     };
+    cachedResponseWillBeUsed = async ({ event, state, cachedResponse })=>{
+        if (event.type === "install") {
+            if (state?.originalRequest && state.originalRequest instanceof Request) {
+                const url = state.originalRequest.url;
+                if (cachedResponse) {
+                    this.notUpdatedURLs.push(url);
+                } else {
+                    this.updatedURLs.push(url);
+                }
+            }
+        }
+        return cachedResponse;
+    };
+}
+
+const removeIgnoredSearchParams = (urlObject, ignoreURLParametersMatching = [])=>{
+    for (const paramName of [
+        ...urlObject.searchParams.keys()
+    ]){
+        if (ignoreURLParametersMatching.some((regExp)=>regExp.test(paramName))) {
+            urlObject.searchParams.delete(paramName);
+        }
+    }
+    return urlObject;
 };
 
-class Serwist {
-    _urlsToCacheKeys = new Map();
-    _urlsToCacheModes = new Map();
-    _cacheKeysToIntegrities = new Map();
-    _concurrentPrecaching;
-    _precacheStrategy;
-    _routes;
-    _defaultHandlerMap;
-    _catchHandler;
-    constructor({ precacheEntries, precacheOptions, skipWaiting = false, importScripts, navigationPreload = false, cacheId, clientsClaim: clientsClaim$1 = false, runtimeCaching, offlineAnalyticsConfig, disableDevLogs: disableDevLogs$1 = false, fallbacks } = {}){
-        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.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
-            });
+function* generateURLVariations(url, { directoryIndex = "index.html", ignoreURLParametersMatching = [
+    /^utm_/,
+    /^fbclid$/
+], cleanURLs = true, urlManipulation } = {}) {
+    const urlObject = new URL(url, location.href);
+    urlObject.hash = "";
+    yield urlObject.href;
+    const urlWithoutIgnoredParams = removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching);
+    yield urlWithoutIgnoredParams.href;
+    if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith("/")) {
+        const directoryURL = new URL(urlWithoutIgnoredParams.href);
+        directoryURL.pathname += directoryIndex;
+        yield directoryURL.href;
+    }
+    if (cleanURLs) {
+        const cleanURL = new URL(urlWithoutIgnoredParams.href);
+        cleanURL.pathname += ".html";
+        yield cleanURL.href;
+    }
+    if (urlManipulation) {
+        const additionalURLs = urlManipulation({
+            url: urlObject
+        });
+        for (const urlToAttempt of additionalURLs){
+            yield urlToAttempt.href;
         }
-        if (skipWaiting) {
-            self.skipWaiting();
-        } else {
-            self.addEventListener("message", (event)=>{
-                if (event.data && event.data.type === "SKIP_WAITING") {
-                    self.skipWaiting();
+    }
+}
+
+class PrecacheRoute extends Route {
+    constructor(precache, options){
+        const match = ({ request })=>{
+            const urlsToCacheKeys = precache.getUrlsToPrecacheKeys();
+            for (const possibleURL of generateURLVariations(request.url, options)){
+                const cacheKey = urlsToCacheKeys.get(possibleURL);
+                if (cacheKey) {
+                    const integrity = precache.getIntegrityForPrecacheKey(cacheKey);
+                    return {
+                        cacheKey,
+                        integrity
+                    };
                 }
+            }
+            if (process.env.NODE_ENV !== "production") {
+                logger.debug(`Precaching did not find a match for ${getFriendlyURL(request.url)}.`);
+            }
+            return;
+        };
+        super(match, precache.strategy);
+    }
+}
+
+const disableDevLogs = ()=>{
+    self.__WB_DISABLE_DEV_LOGS = true;
+};
+const setCacheNameDetails = (details)=>{
+    if (process.env.NODE_ENV !== "production") {
+        for (const key of Object.keys(details)){
+            finalAssertExports.isType(details[key], "string", {
+                moduleName: "@serwist/core",
+                funcName: "setCacheNameDetails",
+                paramName: `details.${key}`
             });
         }
-        if (clientsClaim$1) clientsClaim();
-        if (!!precacheEntries && precacheEntries.length > 0) {
-            this.addToPrecacheList(precacheEntries);
+        if (details.precache?.length === 0) {
+            throw new SerwistError("invalid-cache-name", {
+                cacheNameId: "precache",
+                value: details.precache
+            });
         }
-        if (precacheMiscOptions.cleanupOutdatedCaches) {
-            cleanupOutdatedCaches(precacheStrategyOptions.cacheName);
+        if (details.runtime?.length === 0) {
+            throw new SerwistError("invalid-cache-name", {
+                cacheNameId: "runtime",
+                value: details.runtime
+            });
         }
-        this.registerRoute(new PrecacheRoute(this, precacheRouteOptions));
-        if (precacheMiscOptions.navigateFallback) {
-            this.registerRoute(new NavigationRoute(this.createHandlerBoundToUrl(precacheMiscOptions.navigateFallback), {
-                allowlist: precacheMiscOptions.navigateFallbackAllowlist,
-                denylist: precacheMiscOptions.navigateFallbackDenylist
-            }));
+        if (details.googleAnalytics?.length === 0) {
+            throw new SerwistError("invalid-cache-name", {
+                cacheNameId: "googleAnalytics",
+                value: details.googleAnalytics
+            });
         }
-        if (offlineAnalyticsConfig !== undefined) {
-            if (typeof offlineAnalyticsConfig === "boolean") {
-                offlineAnalyticsConfig && initializeGoogleAnalytics({
-                    serwist: this
-                });
-            } else {
-                initializeGoogleAnalytics({
-                    ...offlineAnalyticsConfig,
-                    serwist: this
-                });
+    }
+    cacheNames$1.updateDetails(details);
+};
+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 copyResponse = async (response, modifier)=>{
+    let origin = null;
+    if (response.url) {
+        const responseURL = new URL(response.url);
+        origin = responseURL.origin;
+    }
+    if (origin !== self.location.origin) {
+        throw new SerwistError("cross-origin-copy-response", {
+            origin
+        });
+    }
+    const clonedResponse = response.clone();
+    const responseInit = {
+        headers: new Headers(clonedResponse.headers),
+        status: clonedResponse.status,
+        statusText: clonedResponse.statusText
+    };
+    const modifiedResponseInit = modifier ? modifier(responseInit) : responseInit;
+    const body = canConstructResponseFromBodyStream() ? clonedResponse.body : await clonedResponse.blob();
+    return new Response(body, modifiedResponseInit);
+};
+
+class PrecacheStrategy extends Strategy {
+    _fallbackToNetwork;
+    static defaultPrecacheCacheabilityPlugin = {
+        async cacheWillUpdate ({ response }) {
+            if (!response || response.status >= 400) {
+                return null;
             }
+            return response;
         }
-        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);
-                    }
-                });
+    };
+    static copyRedirectedCacheableResponsesPlugin = {
+        async cacheWillUpdate ({ response }) {
+            return response.redirected ? await copyResponse(response) : response;
+        }
+    };
+    constructor(options = {}){
+        options.cacheName = cacheNames$1.getPrecacheName(options.cacheName);
+        super(options);
+        this._fallbackToNetwork = options.fallbackToNetwork !== false;
+        this.plugins.push(PrecacheStrategy.copyRedirectedCacheableResponsesPlugin);
+    }
+    async _handle(request, handler) {
+        const preloadResponse = await handler.getPreloadResponse();
+        if (preloadResponse) {
+            return preloadResponse;
+        }
+        const response = await handler.cacheMatch(request);
+        if (response) {
+            return response;
+        }
+        if (handler.event && handler.event.type === "install") {
+            return await this._handleInstall(request, handler);
+        }
+        return await this._handleFetch(request, handler);
+    }
+    async _handleFetch(request, handler) {
+        let response;
+        const params = handler.params || {};
+        if (this._fallbackToNetwork) {
+            if (process.env.NODE_ENV !== "production") {
+                logger.warn(`The precached response for ${getFriendlyURL(request.url)} in ${this.cacheName} was not found. Falling back to the network.`);
             }
-            for (const entry of runtimeCaching){
-                this.registerCapture(entry.matcher, entry.handler, entry.method);
+            const integrityInManifest = params.integrity;
+            const integrityInRequest = request.integrity;
+            const noIntegrityConflict = !integrityInRequest || integrityInRequest === integrityInManifest;
+            response = await handler.fetch(new Request(request, {
+                integrity: request.mode !== "no-cors" ? integrityInRequest || integrityInManifest : undefined
+            }));
+            if (integrityInManifest && noIntegrityConflict && request.mode !== "no-cors") {
+                this._useDefaultCacheabilityPluginIfNeeded();
+                const wasCached = await handler.cachePut(request, response.clone());
+                if (process.env.NODE_ENV !== "production") {
+                    if (wasCached) {
+                        logger.log(`A response for ${getFriendlyURL(request.url)} was used to "repair" the precache.`);
+                    }
+                }
             }
+        } else {
+            throw new SerwistError("missing-precache-entry", {
+                cacheName: this.cacheName,
+                url: request.url
+            });
         }
-        if (disableDevLogs$1) disableDevLogs();
-    }
-    get precacheStrategy() {
-        return this._precacheStrategy;
+        if (process.env.NODE_ENV !== "production") {
+            const cacheKey = params.cacheKey || await handler.getCacheKey(request, "read");
+            logger.groupCollapsed(`Precaching is responding to: ${getFriendlyURL(request.url)}`);
+            logger.log(`Serving the precached url: ${getFriendlyURL(cacheKey instanceof Request ? cacheKey.url : cacheKey)}`);
+            logger.groupCollapsed("View request details here.");
+            logger.log(request);
+            logger.groupEnd();
+            logger.groupCollapsed("View response details here.");
+            logger.log(response);
+            logger.groupEnd();
+            logger.groupEnd();
+        }
+        return response;
     }
-    get routes() {
-        return this._routes;
+    async _handleInstall(request, handler) {
+        this._useDefaultCacheabilityPluginIfNeeded();
+        const response = await handler.fetch(request);
+        const wasCached = await handler.cachePut(request, response.clone());
+        if (!wasCached) {
+            throw new SerwistError("bad-precaching-response", {
+                url: request.url,
+                status: response.status
+            });
+        }
+        return response;
     }
-    addEventListeners() {
-        self.addEventListener("install", this.handleInstall);
-        self.addEventListener("activate", this.handleActivate);
-        self.addEventListener("fetch", this.handleFetch);
-        self.addEventListener("message", this.handleCache);
+    _useDefaultCacheabilityPluginIfNeeded() {
+        let defaultPluginIndex = null;
+        let cacheWillUpdatePluginCount = 0;
+        for (const [index, plugin] of this.plugins.entries()){
+            if (plugin === PrecacheStrategy.copyRedirectedCacheableResponsesPlugin) {
+                continue;
+            }
+            if (plugin === PrecacheStrategy.defaultPrecacheCacheabilityPlugin) {
+                defaultPluginIndex = index;
+            }
+            if (plugin.cacheWillUpdate) {
+                cacheWillUpdatePluginCount++;
+            }
+        }
+        if (cacheWillUpdatePluginCount === 0) {
+            this.plugins.push(PrecacheStrategy.defaultPrecacheCacheabilityPlugin);
+        } else if (cacheWillUpdatePluginCount > 1 && defaultPluginIndex !== null) {
+            this.plugins.splice(defaultPluginIndex, 1);
+        }
     }
-    addToPrecacheList(entries) {
+}
+
+class Precache {
+    _urlsToCacheKeys = new Map();
+    _urlsToCacheModes = new Map();
+    _cacheKeysToIntegrities = new Map();
+    _strategy;
+    _options;
+    _routeOptions;
+    constructor(precacheOptions){
+        const { entries, strategyOptions, routeOptions, extensionOptions: controllerOptions } = parsePrecacheOptions(this, precacheOptions);
+        this.addToCacheList(entries);
+        this._strategy = new PrecacheStrategy(strategyOptions);
+        this._options = controllerOptions;
+        this._routeOptions = routeOptions;
+    }
+    get strategy() {
+        return this._strategy;
+    }
+    addToCacheList(entries) {
         if (process.env.NODE_ENV !== "production") {
             finalAssertExports.isArray(entries, {
                 moduleName: "serwist",
-                className: "Serwist",
-                funcName: "addToCacheList",
+                className: "PrecacheController",
+                funcName: "addEntries",
                 paramName: "entries"
             });
         }
@@ -323,163 +2045,65 @@ class Serwist {
                 }
                 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) {
-        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
-            };
-        });
-    }
-    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
-            };
-        });
-    }
-    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);
-                }
-                return this.handleRequest({
-                    request,
-                    event
-                });
-            }));
-            event.waitUntil(requestPromises);
-            if (event.ports?.[0]) {
-                void requestPromises.then(()=>event.ports[0].postMessage(true));
-            }
-        }
-    }
-    setDefaultHandler(handler, method = defaultMethod) {
-        this._defaultHandlerMap.set(method, normalizeHandler(handler));
-    }
-    setCatchHandler(handler) {
-        this._catchHandler = normalizeHandler(handler);
-    }
-    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(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"
-            });
+            this._urlsToCacheKeys.set(url, cacheKey);
+            this._urlsToCacheModes.set(url, cacheMode);
+            if (urlsToWarnAbout.length > 0) {
+                const warningMessage = `Serwist is precaching URLs without revision info: ${urlsToWarnAbout.join(", ")}\nThis is generally NOT safe, as you risk serving outdated assets.`;
+                if (process.env.NODE_ENV === "production") {
+                    console.warn(warningMessage);
+                } else {
+                    logger.warn(warningMessage);
+                }
+            }
         }
-        if (!this._routes.has(route.method)) {
-            this._routes.set(route.method, []);
+    }
+    init({ serwist }) {
+        registerRoute(serwist, new PrecacheRoute(this, this._routeOptions));
+        if (this._options.navigateFallback) {
+            registerRoute(serwist, new NavigationRoute(this.createHandlerBoundToUrl(this._options.navigateFallback), {
+                allowlist: this._options.navigateFallbackAllowlist,
+                denylist: this._options.navigateFallbackDenylist
+            }));
         }
-        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
+    async install({ event }) {
+        const installReportPlugin = new PrecacheInstallReportPlugin();
+        this._strategy.plugins.push(installReportPlugin);
+        await parallel(this._options.concurrency, Array.from(this._urlsToCacheKeys.entries()), async ([url, cacheKey])=>{
+            const integrity = this._cacheKeysToIntegrities.get(cacheKey);
+            const cacheMode = this._urlsToCacheModes.get(url);
+            const request = new Request(url, {
+                integrity,
+                cache: cacheMode,
+                credentials: "same-origin"
             });
+            await Promise.all(this._strategy.handleAll({
+                event,
+                request,
+                url: new URL(request.url),
+                params: {
+                    cacheKey
+                }
+            }));
+        });
+        const { updatedURLs, notUpdatedURLs } = installReportPlugin;
+        if (process.env.NODE_ENV !== "production") {
+            printInstallDetails(updatedURLs, notUpdatedURLs);
+        }
+    }
+    async activate() {
+        const cache = await self.caches.open(this._strategy.cacheName);
+        const currentlyCachedRequests = await cache.keys();
+        const expectedCacheKeys = new Set(this._urlsToCacheKeys.values());
+        const deletedCacheRequests = [];
+        for (const request of currentlyCachedRequests){
+            if (!expectedCacheKeys.has(request.url)) {
+                await cache.delete(request);
+                deletedCacheRequests.push(request.url);
+            }
         }
-        const 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");
+        if (process.env.NODE_ENV !== "production") {
+            printCleanupDetails(deletedCacheRequests);
         }
     }
     getUrlsToPrecacheKeys() {
@@ -501,7 +2125,7 @@ class Serwist {
         const url = request instanceof Request ? request.url : request;
         const cacheKey = this.getPrecacheKeyForUrl(url);
         if (cacheKey) {
-            const cache = await self.caches.open(this.precacheStrategy.cacheName);
+            const cache = await self.caches.open(this._strategy.cacheName);
             return cache.match(cacheKey);
         }
         return undefined;
@@ -519,175 +2143,344 @@ class Serwist {
                 cacheKey,
                 ...options.params
             };
-            return this.precacheStrategy.handle(options);
+            return this._strategy.handle(options);
         };
     }
-    handleRequest({ request, event }) {
-        if (process.env.NODE_ENV !== "production") {
-            finalAssertExports.isInstance(request, Request, {
-                moduleName: "serwist",
-                className: "Serwist",
-                funcName: "handleRequest",
-                paramName: "options.request"
-            });
-        }
-        const url = new URL(request.url, location.href);
-        if (!url.protocol.startsWith("http")) {
-            if (process.env.NODE_ENV !== "production") {
-                logger.debug("Router only supports URLs that start with 'http'.");
+}
+
+class PrecacheFallbackPlugin {
+    _fallbackUrls;
+    _serwist;
+    constructor({ fallbackUrls, serwist }){
+        this._fallbackUrls = fallbackUrls;
+        this._serwist = serwist;
+    }
+    async handlerDidError(param) {
+        for (const fallback of this._fallbackUrls){
+            if (typeof fallback === "string") {
+                const fallbackResponse = handleRequest(this._serwist, {
+                    request: new Request(fallback, {
+                        credentials: "same-origin"
+                    }),
+                    event: param.event
+                });
+                if (fallbackResponse !== undefined) {
+                    return await fallbackResponse;
+                }
+            } else if (fallback.matcher(param)) {
+                const fallbackResponse = handleRequest(this._serwist, {
+                    request: new Request(fallback.url, {
+                        credentials: "same-origin"
+                    }),
+                    event: param.event
+                });
+                if (fallbackResponse !== undefined) {
+                    return await fallbackResponse;
+                }
             }
-            return;
         }
-        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
-                    ]);
+        return undefined;
+    }
+}
+
+class RuntimeCache {
+    _entries;
+    _options;
+    constructor(entries, options = {}){
+        this._entries = entries;
+        this._options = options;
+        this.init = this.init.bind(this);
+        this.install = this.install.bind(this);
+    }
+    init({ serwist }) {
+        if (this._options.fallbacks !== undefined) {
+            const fallbackPlugin = new PrecacheFallbackPlugin({
+                fallbackUrls: this._options.fallbacks.entries,
+                serwist
+            });
+            this._entries.forEach((cacheEntry)=>{
+                if (cacheEntry.handler instanceof Strategy && !cacheEntry.handler.plugins.some((plugin)=>"handlerDidError" in plugin)) {
+                    cacheEntry.handler.plugins.push(fallbackPlugin);
                 }
-            }
+            });
         }
-        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}.`);
+        for (const entry of this._entries){
+            registerCapture(serwist, entry.matcher, entry.handler, entry.method);
+        }
+    }
+    async install({ event, serwist }) {
+        const concurrency = this._options.warmOptions?.concurrency ?? 10;
+        if (this._options.warmEntries) {
+            await parallel(concurrency, this._options.warmEntries, async (entry)=>{
+                const request = entry instanceof Request ? entry : typeof entry === "string" ? new Request(entry, {
+                    credentials: "same-origin"
+                }) : new Request(entry.url, {
+                    integrity: entry.integrity,
+                    credentials: "same-origin"
+                });
+                await handleRequest(serwist, {
+                    request,
+                    event
+                });
+            });
+        }
+    }
+    warmRuntimeCache(entries) {
+        if (!this._options.warmEntries) this._options.warmEntries = [];
+        this._options.warmEntries.push(...entries);
+    }
+}
+
+const addEventListeners = (state)=>{
+    self.addEventListener("install", createInstallHandler(state));
+    self.addEventListener("activate", createActivateHandler(state));
+    self.addEventListener("fetch", createFetchHandler(state));
+    self.addEventListener("message", createCacheHandler(state));
+};
+const createInstallHandler = (state)=>{
+    return (event)=>{
+        return waitUntil(event, async ()=>{
+            for (const callback of iterateExtensions(state, "install")){
+                await callback({
+                    event,
+                    serwist: state
+                });
+            }
+        });
+    };
+};
+const createActivateHandler = (state)=>{
+    return (event)=>{
+        return waitUntil(event, async ()=>{
+            for (const callback of iterateExtensions(state, "activate")){
+                await callback({
+                    event,
+                    serwist: state
+                });
             }
-            handler = this._defaultHandlerMap.get(method);
+        });
+    };
+};
+const createFetchHandler = (state)=>{
+    return (event)=>{
+        const { request } = event;
+        const responsePromise = handleRequest(state, {
+            request,
+            event
+        });
+        if (responsePromise) {
+            event.respondWith(responsePromise);
         }
-        if (!handler) {
+    };
+};
+const createCacheHandler = (state)=>{
+    return (event)=>{
+        if (event.data && event.data.type === "CACHE_URLS") {
+            const { payload } = event.data;
             if (process.env.NODE_ENV !== "production") {
-                logger.debug(`No route found for: ${getFriendlyURL(url)}`);
+                logger.debug("Caching URLs from the window", payload.urlsToCache);
             }
-            return;
-        }
-        if (process.env.NODE_ENV !== "production") {
-            logger.groupCollapsed(`Router is responding to: ${getFriendlyURL(url)}`);
-            for (const msg of debugMessages){
-                if (Array.isArray(msg)) {
-                    logger.log(...msg);
+            const requestPromises = Promise.all(payload.urlsToCache.map((entry)=>{
+                let request;
+                if (typeof entry === "string") {
+                    request = new Request(entry);
                 } else {
-                    logger.log(msg);
+                    request = new Request(...entry);
                 }
+                return handleRequest(state, {
+                    request,
+                    event
+                });
+            }));
+            event.waitUntil(requestPromises);
+            if (event.ports?.[0]) {
+                void requestPromises.then(()=>event.ports[0].postMessage(true));
             }
-            logger.groupEnd();
         }
-        let responsePromise;
-        try {
-            responsePromise = handler.handle({
-                url,
-                request,
-                event,
-                params
-            });
-        } catch (err) {
-            responsePromise = Promise.reject(err);
-        }
-        const catchHandler = route?.catchHandler;
-        if (responsePromise instanceof Promise && (this._catchHandler || catchHandler)) {
-            responsePromise = responsePromise.catch(async (err)=>{
-                if (catchHandler) {
-                    if (process.env.NODE_ENV !== "production") {
-                        logger.groupCollapsed(`Error thrown when responding to:  ${getFriendlyURL(url)}. Falling back to route's Catch Handler.`);
-                        logger.error("Error thrown by:", route);
-                        logger.error(err);
-                        logger.groupEnd();
-                    }
-                    try {
-                        return await catchHandler.handle({
-                            url,
-                            request,
-                            event,
-                            params
-                        });
-                    } catch (catchErr) {
-                        if (catchErr instanceof Error) {
-                            err = catchErr;
-                        }
-                    }
-                }
-                if (this._catchHandler) {
-                    if (process.env.NODE_ENV !== "production") {
-                        logger.groupCollapsed(`Error thrown when responding to:  ${getFriendlyURL(url)}. Falling back to global Catch Handler.`);
-                        logger.error("Error thrown by:", route);
-                        logger.error(err);
-                        logger.groupEnd();
-                    }
-                    return this._catchHandler.handle({
-                        url,
-                        request,
-                        event
-                    });
-                }
-                throw err;
-            });
+    };
+};
+const setDefaultHandler = (state, handler, method = defaultMethod)=>{
+    state.defaultHandlerMap.set(method, normalizeHandler(handler));
+};
+const setCatchHandler = (state, handler)=>{
+    state.catchHandler = normalizeHandler(handler);
+};
+function* iterateExtensions(state, name) {
+    if (!state.extensions) return;
+    for (const controller of state.extensions){
+        if (typeof controller[name] === "function") {
+            const callback = (param)=>{
+                controller[name](param);
+            };
+            yield callback;
         }
-        return responsePromise;
     }
-    findMatchingRoute({ url, sameOrigin, request, event }) {
-        const routes = this._routes.get(request.method) || [];
-        for (const route of routes){
-            let params;
-            const matchResult = route.match({
-                url,
-                sameOrigin,
-                request,
-                event
-            });
-            if (matchResult) {
-                if (process.env.NODE_ENV !== "production") {
-                    if (matchResult instanceof Promise) {
-                        logger.warn(`While routing ${getFriendlyURL(url)}, an async matchCallback function was used. Please convert the following route to use a synchronous matchCallback function:`, route);
-                    }
-                }
-                params = matchResult;
-                if (Array.isArray(params) && params.length === 0) {
-                    params = undefined;
-                } else if (matchResult.constructor === Object && Object.keys(matchResult).length === 0) {
-                    params = undefined;
-                } else if (typeof matchResult === "boolean") {
-                    params = undefined;
-                }
-                return {
-                    route,
-                    params
-                };
+}
+
+const createSerwist = ({ precache, skipWaiting = false, importScripts, navigationPreload = false, cacheId, clientsClaim: clientsClaim$1 = false, disableDevLogs: disableDevLogs$1 = false, extensions = [] } = {})=>{
+    if (importScripts?.length) self.importScripts(...importScripts);
+    if (navigationPreload) enableNavigationPreload();
+    if (cacheId) setCacheNameDetails({
+        prefix: cacheId
+    });
+    if (skipWaiting) {
+        self.skipWaiting();
+    } else {
+        self.addEventListener("message", (event)=>{
+            if (event.data?.type === "SKIP_WAITING") {
+                self.skipWaiting();
             }
+        });
+    }
+    if (clientsClaim$1) clientsClaim();
+    const precacheExtension = new Precache(precache ?? {
+        entries: []
+    });
+    const routes = new Map();
+    const defaultHandlerMap = new Map();
+    const exts = [
+        precacheExtension,
+        ...extensions
+    ];
+    const state = {
+        get routes () {
+            return routes;
+        },
+        get defaultHandlerMap () {
+            return defaultHandlerMap;
+        },
+        get precache () {
+            return precacheExtension;
+        },
+        get extensions () {
+            return exts;
         }
-        return {};
+    };
+    for (const callback of iterateExtensions(state, "init")){
+        callback({
+            serwist: state
+        });
     }
-}
+    if (disableDevLogs$1) disableDevLogs();
+    return state;
+};
 
-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();
+class Serwist {
+    _state;
+    _installHandler;
+    _activateHandler;
+    _fetchHandler;
+    _cacheHandler;
+    constructor({ precacheEntries, precacheOptions, skipWaiting = false, importScripts, navigationPreload = false, cacheId, clientsClaim = false, runtimeCaching, offlineAnalyticsConfig, disableDevLogs = false, fallbacks, extensions } = {}){
+        this.handleInstall = this.handleInstall.bind(this);
+        this.handleActivate = this.handleActivate.bind(this);
+        this.handleFetch = this.handleFetch.bind(this);
+        this.handleCache = this.handleCache.bind(this);
+        this._state = createSerwist({
+            precache: {
+                entries: precacheEntries ?? [],
+                ...precacheOptions
+            },
+            extensions: [
+                !extensions?.some((ext)=>ext instanceof RuntimeCache) && runtimeCaching !== undefined ? new RuntimeCache(runtimeCaching, {
+                    fallbacks
+                }) : undefined,
+                !extensions?.some((ext)=>ext instanceof GoogleAnalytics) && offlineAnalyticsConfig !== undefined ? typeof offlineAnalyticsConfig === "boolean" ? offlineAnalyticsConfig ? new GoogleAnalytics() : undefined : new GoogleAnalytics(offlineAnalyticsConfig) : undefined,
+                ...extensions ?? []
+            ].filter((extension)=>extension !== undefined),
+            skipWaiting,
+            importScripts,
+            navigationPreload,
+            cacheId,
+            clientsClaim,
+            disableDevLogs
+        });
+        this._installHandler = createInstallHandler(this._state);
+        this._activateHandler = createActivateHandler(this._state);
+        this._fetchHandler = createFetchHandler(this._state);
+        this._cacheHandler = createCacheHandler(this._state);
     }
-};
+    get precache() {
+        return this._state.precache;
+    }
+    get precacheStrategy() {
+        return this._state.precache.strategy;
+    }
+    get routes() {
+        return this._state.routes;
+    }
+    get state() {
+        return this._state;
+    }
+    addEventListeners() {
+        self.addEventListener("install", this._installHandler);
+        self.addEventListener("activate", this._activateHandler);
+        self.addEventListener("fetch", this._fetchHandler);
+        self.addEventListener("message", this._cacheHandler);
+    }
+    handleInstall(event) {
+        return this._installHandler(event);
+    }
+    handleActivate(event) {
+        return this._activateHandler(event);
+    }
+    handleFetch(event) {
+        return this._fetchHandler(event);
+    }
+    handleCache(event) {
+        return this._cacheHandler(event);
+    }
+    setDefaultHandler(handler, method) {
+        setDefaultHandler(this._state, handler, method);
+    }
+    setCatchHandler(handler) {
+        setCatchHandler(this._state, handler);
+    }
+    registerCapture(capture, handler, method) {
+        return registerCapture(this._state, capture, handler, method);
+    }
+    registerRoute(route) {
+        registerRoute(this._state, route);
+    }
+    unregisterRoute(route) {
+        unregisterRoute(this._state, route);
+    }
+    handleRequest({ request, event }) {
+        return handleRequest(this._state, {
+            request,
+            event
+        });
+    }
+    findMatchingRoute({ url, sameOrigin, request, event }) {
+        return findMatchingRoute(this._state, {
+            url,
+            sameOrigin,
+            request,
+            event
+        });
+    }
+    addToPrecacheList(entries) {
+        this.precache.addToCacheList(entries);
+    }
+    getUrlsToPrecacheKeys() {
+        return this.precache.getUrlsToPrecacheKeys();
+    }
+    getPrecachedUrls() {
+        return this.precache.getPrecachedUrls();
+    }
+    getPrecacheKeyForUrl(url) {
+        return this.precache.getPrecacheKeyForUrl(url);
+    }
+    getIntegrityForPrecacheKey(cacheKey) {
+        return this.precache.getIntegrityForPrecacheKey(cacheKey);
+    }
+    matchPrecache(request) {
+        return this.precache.matchPrecache(request);
+    }
+    createHandlerBoundToUrl(url) {
+        return this.precache.createHandlerBoundToUrl(url);
+    }
+}
 
 const BROADCAST_UPDATE_MESSAGE_TYPE = "CACHE_UPDATED";
 const BROADCAST_UPDATE_MESSAGE_META = "serwist-broadcast-update";
@@ -1090,20 +2883,6 @@ class CacheExpiration {
     }
 }
 
-const registerQuotaErrorCallback = (callback)=>{
-    if (process.env.NODE_ENV !== "production") {
-        finalAssertExports.isType(callback, "function", {
-            moduleName: "@serwist/core",
-            funcName: "register",
-            paramName: "callback"
-        });
-    }
-    quotaErrorCallbacks.add(callback);
-    if (process.env.NODE_ENV !== "production") {
-        logger.log("Registered a callback to respond to quota errors.", callback);
-    }
-};
-
 class ExpirationPlugin {
     _config;
     _cacheExpirations;
@@ -1503,4 +3282,4 @@ class StaleWhileRevalidate extends Strategy {
     }
 }
 
-export { BROADCAST_UPDATE_DEFAULT_HEADERS, BackgroundSyncPlugin, BroadcastCacheUpdate, BroadcastUpdatePlugin, CacheExpiration, CacheFirst, CacheOnly, CacheableResponse, CacheableResponsePlugin, ExpirationPlugin, NavigationRoute, NetworkFirst, NetworkOnly, PrecacheFallbackPlugin, PrecacheRoute, PrecacheStrategy, RangeRequestsPlugin, Route, Serwist, StaleWhileRevalidate, Strategy, cacheNames, createPartialResponse, disableDevLogs, enableNavigationPreload, initializeGoogleAnalytics, registerQuotaErrorCallback, responsesAreSame, setCacheNameDetails };
+export { BROADCAST_UPDATE_DEFAULT_HEADERS, BackgroundSyncPlugin, BackgroundSyncQueue, BackgroundSyncQueueStore, BroadcastCacheUpdate, BroadcastUpdatePlugin, CacheExpiration, CacheFirst, CacheOnly, CacheableResponse, CacheableResponsePlugin, ExpirationPlugin, GoogleAnalytics, NavigationRoute, NetworkFirst, NetworkOnly, PrecacheFallbackPlugin, PrecacheRoute, PrecacheStrategy, RangeRequestsPlugin, RegExpRoute, Route, RuntimeCache, Serwist, StaleWhileRevalidate, StorableRequest, Strategy, StrategyHandler, addEventListeners, cacheNames, copyResponse, createActivateHandler, createCacheHandler, createFetchHandler, createInstallHandler, createPartialResponse, createSerwist, disableDevLogs, disableNavigationPreload, enableNavigationPreload, findMatchingRoute, handleRequest, initializeGoogleAnalytics, isNavigationPreloadSupported, iterateExtensions, registerCapture, registerQuotaErrorCallback, registerRoute, responsesAreSame, setCacheNameDetails, setCatchHandler, setDefaultHandler, unregisterRoute };