serwist 9.0.0-preview.24

package/dist/chunks/Serwist.js

@@ -0,0 +1,1034 @@
+import { c as cacheNames, l as logger, S as SerwistError, f as finalAssertExports, g as getFriendlyURL } from './timeout.js';
+import { c as canConstructResponseFromBodyStream, w as waitUntil } from './waitUntil.js';
+import { R as Route, i as initialize, P as PrecacheFallbackPlugin, n as normalizeHandler, d as defaultMethod } from './PrecacheFallbackPlugin.js';
+import { S as Strategy } from './NetworkOnly.js';
+
+const SUBSTRING_TO_FIND = "-precache-";
+const deleteOutdatedCaches = async (currentPrecacheName, substringToFind = SUBSTRING_TO_FIND)=>{
+    const cacheNames = await self.caches.keys();
+    const cacheNamesToDelete = cacheNames.filter((cacheName)=>{
+        return cacheName.includes(substringToFind) && cacheName.includes(self.registration.scope) && cacheName !== currentPrecacheName;
+    });
+    await Promise.all(cacheNamesToDelete.map((cacheName)=>self.caches.delete(cacheName)));
+    return cacheNamesToDelete;
+};
+
+const cleanupOutdatedCaches = (cacheName)=>{
+    self.addEventListener("activate", (event)=>{
+        event.waitUntil(deleteOutdatedCaches(cacheNames.getPrecacheName(cacheName)).then((cachesDeleted)=>{
+            if (process.env.NODE_ENV !== "production") {
+                if (cachesDeleted.length > 0) {
+                    logger.log("The following out-of-date precaches were cleaned up automatically:", cachesDeleted);
+                }
+            }
+        }));
+    });
+};
+
+const clientsClaim = ()=>{
+    self.addEventListener("activate", ()=>self.clients.claim());
+};
+
+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);
+};
+
+const disableDevLogs = ()=>{
+    self.__WB_DISABLE_DEV_LOGS = true;
+};
+
+const isNavigationPreloadSupported = ()=>{
+    return Boolean(self.registration?.navigationPreload);
+};
+const enableNavigationPreload = (headerValue)=>{
+    if (isNavigationPreloadSupported()) {
+        self.addEventListener("activate", (event)=>{
+            event.waitUntil(self.registration.navigationPreload.enable().then(()=>{
+                if (headerValue) {
+                    void self.registration.navigationPreload.setHeaderValue(headerValue);
+                }
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log("Navigation preloading is enabled.");
+                }
+            }));
+        });
+    } else {
+        if (process.env.NODE_ENV !== "production") {
+            logger.log("Navigation preloading is not supported in this browser.");
+        }
+    }
+};
+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.");
+        }
+    }
+};
+
+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;
+    }
+}
+
+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);
+    }
+}
+
+const parseRoute = (capture, handler, method)=>{
+    let route;
+    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;
+        };
+        route = new Route(matchCallback, handler, method);
+    } else if (capture instanceof RegExp) {
+        route = new RegExpRoute(capture, handler, method);
+    } else if (typeof capture === "function") {
+        route = new Route(capture, handler, method);
+    } else if (capture instanceof Route) {
+        route = capture;
+    } else {
+        throw new SerwistError("unsupported-route-type", {
+            moduleName: "serwist",
+            funcName: "parseRoute",
+            paramName: "capture"
+        });
+    }
+    return route;
+};
+
+const removeIgnoredSearchParams = (urlObject, ignoreURLParametersMatching = [])=>{
+    for (const paramName of [
+        ...urlObject.searchParams.keys()
+    ]){
+        if (ignoreURLParametersMatching.some((regExp)=>regExp.test(paramName))) {
+            urlObject.searchParams.delete(paramName);
+        }
+    }
+    return urlObject;
+};
+
+function* generateURLVariations(url, { directoryIndex = "index.html", ignoreURLParametersMatching = [
+    /^utm_/,
+    /^fbclid$/
+], cleanURLs = true, urlManipulation } = {}) {
+    const urlObject = new URL(url, location.href);
+    urlObject.hash = "";
+    yield urlObject.href;
+    const urlWithoutIgnoredParams = removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching);
+    yield urlWithoutIgnoredParams.href;
+    if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith("/")) {
+        const directoryURL = new URL(urlWithoutIgnoredParams.href);
+        directoryURL.pathname += directoryIndex;
+        yield directoryURL.href;
+    }
+    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;
+        }
+    }
+}
+
+class PrecacheRoute extends Route {
+    constructor(serwist, options){
+        const match = ({ request })=>{
+            const urlsToCacheKeys = serwist.getUrlsToPrecacheKeys();
+            for (const possibleURL of generateURLVariations(request.url, options)){
+                const cacheKey = urlsToCacheKeys.get(possibleURL);
+                if (cacheKey) {
+                    const integrity = serwist.getIntegrityForPrecacheKey(cacheKey);
+                    return {
+                        cacheKey,
+                        integrity
+                    };
+                }
+            }
+            if (process.env.NODE_ENV !== "production") {
+                logger.debug(`Precaching did not find a match for ${getFriendlyURL(request.url)}.`);
+            }
+            return;
+        };
+        super(match, serwist.precacheStrategy);
+    }
+}
+
+class PrecacheStrategy extends Strategy {
+    _fallbackToNetwork;
+    static defaultPrecacheCacheabilityPlugin = {
+        async cacheWillUpdate ({ response }) {
+            if (!response || response.status >= 400) {
+                return null;
+            }
+            return response;
+        }
+    };
+    static copyRedirectedCacheableResponsesPlugin = {
+        async cacheWillUpdate ({ response }) {
+            return response.redirected ? await copyResponse(response) : response;
+        }
+    };
+    constructor(options = {}){
+        options.cacheName = cacheNames.getPrecacheName(options.cacheName);
+        super(options);
+        this._fallbackToNetwork = options.fallbackToNetwork === false ? false : true;
+        this.plugins.push(PrecacheStrategy.copyRedirectedCacheableResponsesPlugin);
+    }
+    async _handle(request, handler) {
+        const response = await handler.cacheMatch(request);
+        if (response) {
+            return response;
+        }
+        if (handler.event && handler.event.type === "install") {
+            return await this._handleInstall(request, handler);
+        }
+        return await this._handleFetch(request, handler);
+    }
+    async _handleFetch(request, handler) {
+        let response = undefined;
+        const params = handler.params || {};
+        if (this._fallbackToNetwork) {
+            if (process.env.NODE_ENV !== "production") {
+                logger.warn(`The precached response for ${getFriendlyURL(request.url)} in ${this.cacheName} was not found. Falling back to the network.`);
+            }
+            const integrityInManifest = params.integrity;
+            const integrityInRequest = request.integrity;
+            const noIntegrityConflict = !integrityInRequest || integrityInRequest === integrityInManifest;
+            response = await handler.fetch(new Request(request, {
+                integrity: request.mode !== "no-cors" ? integrityInRequest || integrityInManifest : undefined
+            }));
+            if (integrityInManifest && noIntegrityConflict && request.mode !== "no-cors") {
+                this._useDefaultCacheabilityPluginIfNeeded();
+                const wasCached = await handler.cachePut(request, response.clone());
+                if (process.env.NODE_ENV !== "production") {
+                    if (wasCached) {
+                        logger.log(`A response for ${getFriendlyURL(request.url)} was used to "repair" the precache.`);
+                    }
+                }
+            }
+        } else {
+            throw new SerwistError("missing-precache-entry", {
+                cacheName: this.cacheName,
+                url: request.url
+            });
+        }
+        if (process.env.NODE_ENV !== "production") {
+            const cacheKey = params.cacheKey || await handler.getCacheKey(request, "read");
+            logger.groupCollapsed(`Precaching is responding to: ${getFriendlyURL(request.url)}`);
+            logger.log(`Serving the precached url: ${getFriendlyURL(cacheKey instanceof Request ? cacheKey.url : cacheKey)}`);
+            logger.groupCollapsed("View request details here.");
+            logger.log(request);
+            logger.groupEnd();
+            logger.groupCollapsed("View response details here.");
+            logger.log(response);
+            logger.groupEnd();
+            logger.groupEnd();
+        }
+        return response;
+    }
+    async _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;
+    }
+    _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);
+        }
+    }
+}
+
+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 (details.precache?.length === 0) {
+            throw new SerwistError("invalid-cache-name", {
+                cacheNameId: "precache",
+                value: details.precache
+            });
+        }
+        if (details.runtime?.length === 0) {
+            throw new SerwistError("invalid-cache-name", {
+                cacheNameId: "runtime",
+                value: details.runtime
+            });
+        }
+        if (details.googleAnalytics?.length === 0) {
+            throw new SerwistError("invalid-cache-name", {
+                cacheNameId: "googleAnalytics",
+                value: details.googleAnalytics
+            });
+        }
+    }
+    cacheNames.updateDetails(details);
+};
+
+const parallel = async (limit, array, func)=>{
+    const work = array.map((item, index)=>({
+            index,
+            item
+        }));
+    const processor = async (res)=>{
+        const results = [];
+        while(true){
+            const next = work.pop();
+            if (!next) {
+                return res(results);
+            }
+            const result = await func(next.item);
+            results.push({
+                result: result,
+                index: next.index
+            });
+        }
+    };
+    const queues = Array.from({
+        length: limit
+    }, ()=>new Promise(processor));
+    const results = (await Promise.all(queues)).flat().sort((a, b)=>a.index < b.index ? -1 : 1).map((res)=>res.result);
+    return results;
+};
+
+class PrecacheCacheKeyPlugin {
+    _precacheController;
+    constructor({ precacheController }){
+        this._precacheController = precacheController;
+    }
+    cacheKeyWillBeUsed = async ({ request, params })=>{
+        const cacheKey = params?.cacheKey || this._precacheController.getPrecacheKeyForUrl(request.url);
+        return cacheKey ? new Request(cacheKey, {
+            headers: request.headers
+        }) : request;
+    };
+}
+
+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 REVISION_SEARCH_PARAM = "__WB_REVISION__";
+const createCacheKey = (entry)=>{
+    if (!entry) {
+        throw new SerwistError("add-to-cache-list-unexpected-type", {
+            entry
+        });
+    }
+    if (typeof entry === "string") {
+        const urlObject = new URL(entry, location.href);
+        return {
+            cacheKey: urlObject.href,
+            url: urlObject.href
+        };
+    }
+    const { revision, url } = entry;
+    if (!url) {
+        throw new SerwistError("add-to-cache-list-unexpected-type", {
+            entry
+        });
+    }
+    if (!revision) {
+        const urlObject = new URL(url, location.href);
+        return {
+            cacheKey: urlObject.href,
+            url: urlObject.href
+        };
+    }
+    const cacheKeyURL = new URL(url, location.href);
+    const originalURL = new URL(url, location.href);
+    cacheKeyURL.searchParams.set(REVISION_SEARCH_PARAM, revision);
+    return {
+        cacheKey: cacheKeyURL.href,
+        url: originalURL.href
+    };
+};
+
+const logGroup = (groupTitle, deletedURLs)=>{
+    logger.groupCollapsed(groupTitle);
+    for (const url of deletedURLs){
+        logger.log(url);
+    }
+    logger.groupEnd();
+};
+const printCleanupDetails = (deletedURLs)=>{
+    const deletionCount = deletedURLs.length;
+    if (deletionCount > 0) {
+        logger.groupCollapsed(`During precaching cleanup, ${deletionCount} cached request${deletionCount === 1 ? " was" : "s were"} deleted.`);
+        logGroup("Deleted Cache Requests", deletedURLs);
+        logger.groupEnd();
+    }
+};
+
+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 Serwist {
+    _urlsToCacheKeys = new Map();
+    _urlsToCacheModes = new Map();
+    _cacheKeysToIntegrities = new Map();
+    _concurrentPrecaching;
+    _precacheStrategy;
+    _routes;
+    _defaultHandlerMap;
+    _catchHandler;
+    constructor({ precacheEntries, precacheOptions, cleanupOutdatedCaches: cleanupOutdatedCaches$1, navigateFallback, navigateFallbackAllowlist, navigateFallbackDenylist, plugins = [], fallbackToNetwork = true, concurrentPrecaching = 1, skipWaiting = false, importScripts, navigationPreload = false, cacheId, clientsClaim: clientsClaim$1 = false, runtimeCaching, offlineAnalyticsConfig, disableDevLogs: disableDevLogs$1 = false, fallbacks } = {}){
+        this._concurrentPrecaching = concurrentPrecaching;
+        this._precacheStrategy = new PrecacheStrategy({
+            cacheName: cacheNames.getPrecacheName(precacheOptions?.cacheName),
+            plugins: [
+                ...plugins,
+                new PrecacheCacheKeyPlugin({
+                    precacheController: this
+                })
+            ],
+            fallbackToNetwork
+        });
+        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
+            });
+        }
+        if (skipWaiting) {
+            self.skipWaiting();
+        } else {
+            self.addEventListener("message", (event)=>{
+                if (event.data && event.data.type === "SKIP_WAITING") {
+                    self.skipWaiting();
+                }
+            });
+        }
+        if (clientsClaim$1) clientsClaim();
+        this.registerRoute(new PrecacheRoute(this, precacheOptions));
+        if (!!precacheEntries && precacheEntries.length > 0) {
+            this.addToPrecacheList(precacheEntries);
+        }
+        if (cleanupOutdatedCaches$1) {
+            cleanupOutdatedCaches(precacheOptions?.cacheName);
+        }
+        if (navigateFallback) {
+            this.registerRoute(new NavigationRoute(this.createHandlerBoundToUrl(navigateFallback), {
+                allowlist: navigateFallbackAllowlist,
+                denylist: navigateFallbackDenylist
+            }));
+        }
+        if (offlineAnalyticsConfig !== undefined) {
+            if (typeof offlineAnalyticsConfig === "boolean") {
+                offlineAnalyticsConfig && initialize({
+                    serwist: this
+                });
+            } else {
+                initialize({
+                    ...offlineAnalyticsConfig,
+                    serwist: this
+                });
+            }
+        }
+        if (runtimeCaching !== undefined) {
+            if (fallbacks !== undefined) {
+                const fallbackPlugin = new PrecacheFallbackPlugin({
+                    fallbackUrls: fallbacks.entries,
+                    serwist: this
+                });
+                runtimeCaching.forEach((cacheEntry)=>{
+                    if (cacheEntry.handler instanceof Strategy && !cacheEntry.handler.plugins.some((plugin)=>"handlerDidError" in plugin)) {
+                        cacheEntry.handler.plugins.push(fallbackPlugin);
+                    }
+                });
+            }
+            for (const entry of runtimeCaching){
+                this.registerCapture(entry.matcher, entry.handler, entry.method);
+            }
+        }
+        if (disableDevLogs$1) disableDevLogs();
+    }
+    get precacheStrategy() {
+        return this._precacheStrategy;
+    }
+    get routes() {
+        return this._routes;
+    }
+    addEventListeners() {
+        self.addEventListener("install", this.handleInstall);
+        self.addEventListener("activate", this.handleActivate);
+        self.addEventListener("fetch", this.handleFetch);
+        self.addEventListener("message", this.handleCache);
+    }
+    addToPrecacheList(entries) {
+        if (process.env.NODE_ENV !== "production") {
+            finalAssertExports.isArray(entries, {
+                moduleName: "serwist",
+                className: "Serwist",
+                funcName: "addToCacheList",
+                paramName: "entries"
+            });
+        }
+        const urlsToWarnAbout = [];
+        for (const entry of entries){
+            if (typeof entry === "string") {
+                urlsToWarnAbout.push(entry);
+            } else if (entry && !entry.integrity && entry.revision === undefined) {
+                urlsToWarnAbout.push(entry.url);
+            }
+            const { cacheKey, url } = createCacheKey(entry);
+            const cacheMode = typeof entry !== "string" && entry.revision ? "reload" : "default";
+            if (this._urlsToCacheKeys.has(url) && this._urlsToCacheKeys.get(url) !== cacheKey) {
+                throw new SerwistError("add-to-cache-list-conflicting-entries", {
+                    firstEntry: this._urlsToCacheKeys.get(url),
+                    secondEntry: cacheKey
+                });
+            }
+            if (typeof entry !== "string" && entry.integrity) {
+                if (this._cacheKeysToIntegrities.has(cacheKey) && this._cacheKeysToIntegrities.get(cacheKey) !== entry.integrity) {
+                    throw new SerwistError("add-to-cache-list-conflicting-integrities", {
+                        url
+                    });
+                }
+                this._cacheKeysToIntegrities.set(cacheKey, entry.integrity);
+            }
+            this._urlsToCacheKeys.set(url, cacheKey);
+            this._urlsToCacheModes.set(url, cacheMode);
+            if (urlsToWarnAbout.length > 0) {
+                const warningMessage = `Serwist is precaching URLs without revision info: ${urlsToWarnAbout.join(", ")}\nThis is generally NOT safe. Learn more at https://bit.ly/wb-precache`;
+                if (process.env.NODE_ENV === "production") {
+                    console.warn(warningMessage);
+                } else {
+                    logger.warn(warningMessage);
+                }
+            }
+        }
+    }
+    handleInstall(event) {
+        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"
+            });
+        }
+        if (!this._routes.has(route.method)) {
+            this._routes.set(route.method, []);
+        }
+        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
+            });
+        }
+        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");
+        }
+    }
+    getUrlsToPrecacheKeys() {
+        return this._urlsToCacheKeys;
+    }
+    getPrecachedUrls() {
+        return [
+            ...this._urlsToCacheKeys.keys()
+        ];
+    }
+    getPrecacheKeyForUrl(url) {
+        const urlObject = new URL(url, location.href);
+        return this._urlsToCacheKeys.get(urlObject.href);
+    }
+    getIntegrityForPrecacheKey(cacheKey) {
+        return this._cacheKeysToIntegrities.get(cacheKey);
+    }
+    async matchPrecache(request) {
+        const url = request instanceof Request ? request.url : request;
+        const cacheKey = this.getPrecacheKeyForUrl(url);
+        if (cacheKey) {
+            const cache = await self.caches.open(this.precacheStrategy.cacheName);
+            return cache.match(cacheKey);
+        }
+        return undefined;
+    }
+    createHandlerBoundToUrl(url) {
+        const cacheKey = this.getPrecacheKeyForUrl(url);
+        if (!cacheKey) {
+            throw new SerwistError("non-precached-url", {
+                url
+            });
+        }
+        return (options)=>{
+            options.request = new Request(url);
+            options.params = {
+                cacheKey,
+                ...options.params
+            };
+            return this.precacheStrategy.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'.");
+            }
+            return;
+        }
+        const sameOrigin = url.origin === location.origin;
+        const { params, route } = this.findMatchingRoute({
+            event,
+            request,
+            sameOrigin,
+            url
+        });
+        let handler = route?.handler;
+        const debugMessages = [];
+        if (process.env.NODE_ENV !== "production") {
+            if (handler) {
+                debugMessages.push([
+                    "Found a route to handle this request:",
+                    route
+                ]);
+                if (params) {
+                    debugMessages.push([
+                        `Passing the following params to the route's handler:`,
+                        params
+                    ]);
+                }
+            }
+        }
+        const method = request.method;
+        if (!handler && this._defaultHandlerMap.has(method)) {
+            if (process.env.NODE_ENV !== "production") {
+                debugMessages.push(`Failed to find a matching route. Falling back to the default handler for ${method}.`);
+            }
+            handler = this._defaultHandlerMap.get(method);
+        }
+        if (!handler) {
+            if (process.env.NODE_ENV !== "production") {
+                logger.debug(`No route found for: ${getFriendlyURL(url)}`);
+            }
+            return;
+        }
+        if (process.env.NODE_ENV !== "production") {
+            logger.groupCollapsed(`Router is responding to: ${getFriendlyURL(url)}`);
+            for (const msg of debugMessages){
+                if (Array.isArray(msg)) {
+                    logger.log(...msg);
+                } else {
+                    logger.log(msg);
+                }
+            }
+            logger.groupEnd();
+        }
+        let responsePromise;
+        try {
+            responsePromise = handler.handle({
+                url,
+                request,
+                event,
+                params
+            });
+        } catch (err) {
+            responsePromise = Promise.reject(err);
+        }
+        const catchHandler = route?.catchHandler;
+        if (responsePromise instanceof Promise && (this._catchHandler || catchHandler)) {
+            responsePromise = responsePromise.catch(async (err)=>{
+                if (catchHandler) {
+                    if (process.env.NODE_ENV !== "production") {
+                        logger.groupCollapsed(`Error thrown when responding to:  ${getFriendlyURL(url)}. Falling back to route's Catch Handler.`);
+                        logger.error("Error thrown by:", route);
+                        logger.error(err);
+                        logger.groupEnd();
+                    }
+                    try {
+                        return await catchHandler.handle({
+                            url,
+                            request,
+                            event,
+                            params
+                        });
+                    } catch (catchErr) {
+                        if (catchErr instanceof Error) {
+                            err = catchErr;
+                        }
+                    }
+                }
+                if (this._catchHandler) {
+                    if (process.env.NODE_ENV !== "production") {
+                        logger.groupCollapsed(`Error thrown when responding to:  ${getFriendlyURL(url)}. Falling back to global Catch Handler.`);
+                        logger.error("Error thrown by:", route);
+                        logger.error(err);
+                        logger.groupEnd();
+                    }
+                    return this._catchHandler.handle({
+                        url,
+                        request,
+                        event
+                    });
+                }
+                throw err;
+            });
+        }
+        return responsePromise;
+    }
+    findMatchingRoute({ url, sameOrigin, request, event }) {
+        const routes = this._routes.get(request.method) || [];
+        for (const route of routes){
+            let params;
+            const matchResult = route.match({
+                url,
+                sameOrigin,
+                request,
+                event
+            });
+            if (matchResult) {
+                if (process.env.NODE_ENV !== "production") {
+                    if (matchResult instanceof Promise) {
+                        logger.warn(`While routing ${getFriendlyURL(url)}, an async matchCallback function was used. Please convert the following route to use a synchronous matchCallback function:`, route);
+                    }
+                }
+                params = matchResult;
+                if (Array.isArray(params) && params.length === 0) {
+                    params = undefined;
+                } else if (matchResult.constructor === Object && Object.keys(matchResult).length === 0) {
+                    params = undefined;
+                } else if (typeof matchResult === "boolean") {
+                    params = undefined;
+                }
+                return {
+                    route,
+                    params
+                };
+            }
+        }
+        return {};
+    }
+}
+
+export { NavigationRoute as N, PrecacheRoute as P, RegExpRoute as R, Serwist as S, clientsClaim as a, copyResponse as b, cleanupOutdatedCaches as c, disableDevLogs as d, disableNavigationPreload as e, enableNavigationPreload as f, PrecacheStrategy as g, createCacheKey as h, isNavigationPreloadSupported as i, parallel as j, printInstallDetails as k, printCleanupDetails as l, PrecacheInstallReportPlugin as m, generateURLVariations as n, parseRoute as p, setCacheNameDetails as s };