serwist 9.0.0-preview.24

package/dist/chunks/registerQuotaErrorCallback.js

@@ -0,0 +1,17 @@
+import { f as finalAssertExports, q as quotaErrorCallbacks, l as logger } from './timeout.js';
+
+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);
+    }
+};
+
+export { registerQuotaErrorCallback as r };

package/dist/chunks/resultingClientExists.js

@@ -0,0 +1,32 @@
+import { t as timeout } from './timeout.js';
+
+const MAX_RETRY_TIME = 2000;
+async function resultingClientExists(resultingClientId) {
+    if (!resultingClientId) {
+        return;
+    }
+    let existingWindows = await self.clients.matchAll({
+        type: "window"
+    });
+    const existingWindowIds = new Set(existingWindows.map((w)=>w.id));
+    let resultingWindow = undefined;
+    const startTime = performance.now();
+    while(performance.now() - startTime < MAX_RETRY_TIME){
+        existingWindows = await self.clients.matchAll({
+            type: "window"
+        });
+        resultingWindow = existingWindows.find((w)=>{
+            if (resultingClientId) {
+                return w.id === resultingClientId;
+            }
+            return !existingWindowIds.has(w.id);
+        });
+        if (resultingWindow) {
+            break;
+        }
+        await timeout(100);
+    }
+    return resultingWindow;
+}
+
+export { resultingClientExists as r };

package/dist/chunks/timeout.js

@@ -0,0 +1,400 @@
+const _cacheNameDetails = {
+    googleAnalytics: "googleAnalytics",
+    precache: "precache-v2",
+    prefix: "serwist",
+    runtime: "runtime",
+    suffix: typeof registration !== "undefined" ? registration.scope : ""
+};
+const _createCacheName = (cacheName)=>{
+    return [
+        _cacheNameDetails.prefix,
+        cacheName,
+        _cacheNameDetails.suffix
+    ].filter((value)=>value && value.length > 0).join("-");
+};
+const eachCacheNameDetail = (fn)=>{
+    for (const key of Object.keys(_cacheNameDetails)){
+        fn(key);
+    }
+};
+const cacheNames = {
+    updateDetails: (details)=>{
+        eachCacheNameDetail((key)=>{
+            const detail = details[key];
+            if (typeof detail === "string") {
+                _cacheNameDetails[key] = detail;
+            }
+        });
+    },
+    getGoogleAnalyticsName: (userCacheName)=>{
+        return userCacheName || _createCacheName(_cacheNameDetails.googleAnalytics);
+    },
+    getPrecacheName: (userCacheName)=>{
+        return userCacheName || _createCacheName(_cacheNameDetails.precache);
+    },
+    getPrefix: ()=>{
+        return _cacheNameDetails.prefix;
+    },
+    getRuntimeName: (userCacheName)=>{
+        return userCacheName || _createCacheName(_cacheNameDetails.runtime);
+    },
+    getSuffix: ()=>{
+        return _cacheNameDetails.suffix;
+    }
+};
+
+const logger = process.env.NODE_ENV === "production" ? null : (()=>{
+    if (!("__WB_DISABLE_DEV_LOGS" in globalThis)) {
+        self.__WB_DISABLE_DEV_LOGS = false;
+    }
+    let inGroup = false;
+    const methodToColorMap = {
+        debug: "#7f8c8d",
+        log: "#2ecc71",
+        warn: "#f39c12",
+        error: "#c0392b",
+        groupCollapsed: "#3498db",
+        groupEnd: null
+    };
+    const print = (method, args)=>{
+        if (self.__WB_DISABLE_DEV_LOGS) {
+            return;
+        }
+        if (method === "groupCollapsed") {
+            if (typeof navigator !== "undefined" && /^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
+                console[method](...args);
+                return;
+            }
+        }
+        const styles = [
+            `background: ${methodToColorMap[method]}`,
+            "border-radius: 0.5em",
+            "color: white",
+            "font-weight: bold",
+            "padding: 2px 0.5em"
+        ];
+        const logPrefix = inGroup ? [] : [
+            "%cserwist",
+            styles.join(";")
+        ];
+        console[method](...logPrefix, ...args);
+        if (method === "groupCollapsed") {
+            inGroup = true;
+        }
+        if (method === "groupEnd") {
+            inGroup = false;
+        }
+    };
+    const loggerMethods = Object.keys(methodToColorMap);
+    return loggerMethods.reduce((api, method)=>{
+        api[method] = (...args)=>{
+            print(method, args);
+        };
+        return api;
+    }, {});
+})();
+
+const messages = {
+    "invalid-value": ({ paramName, validValueDescription, value })=>{
+        if (!paramName || !validValueDescription) {
+            throw new Error(`Unexpected input to 'invalid-value' error.`);
+        }
+        return `The '${paramName}' parameter was given a value with an ` + `unexpected value. ${validValueDescription} Received a value of ` + `${JSON.stringify(value)}.`;
+    },
+    "not-an-array": ({ moduleName, className, funcName, paramName })=>{
+        if (!moduleName || !className || !funcName || !paramName) {
+            throw new Error(`Unexpected input to 'not-an-array' error.`);
+        }
+        return `The parameter '${paramName}' passed into ` + `'${moduleName}.${className}.${funcName}()' must be an array.`;
+    },
+    "incorrect-type": ({ expectedType, paramName, moduleName, className, funcName })=>{
+        if (!expectedType || !paramName || !moduleName || !funcName) {
+            throw new Error(`Unexpected input to 'incorrect-type' error.`);
+        }
+        const classNameStr = className ? `${className}.` : "";
+        return `The parameter '${paramName}' passed into ` + `'${moduleName}.${classNameStr}` + `${funcName}()' must be of type ${expectedType}.`;
+    },
+    "incorrect-class": ({ expectedClassName, paramName, moduleName, className, funcName, isReturnValueProblem })=>{
+        if (!expectedClassName || !moduleName || !funcName) {
+            throw new Error(`Unexpected input to 'incorrect-class' error.`);
+        }
+        const classNameStr = className ? `${className}.` : "";
+        if (isReturnValueProblem) {
+            return `The return value from '${moduleName}.${classNameStr}${funcName}()' must be an instance of class ${expectedClassName}.`;
+        }
+        return `The parameter '${paramName}' passed into ` + `'${moduleName}.${classNameStr}${funcName}()' ` + `must be an instance of class ${expectedClassName}.`;
+    },
+    "missing-a-method": ({ expectedMethod, paramName, moduleName, className, funcName })=>{
+        if (!expectedMethod || !paramName || !moduleName || !className || !funcName) {
+            throw new Error(`Unexpected input to 'missing-a-method' error.`);
+        }
+        return `${moduleName}.${className}.${funcName}() expected the ` + `'${paramName}' parameter to expose a '${expectedMethod}' method.`;
+    },
+    "add-to-cache-list-unexpected-type": ({ entry })=>{
+        return `An unexpected entry was passed to 'serwist.Serwist.addToPrecacheList()' The entry '${JSON.stringify(entry)}' isn't supported. You must supply an array of strings with one or more characters, objects with a url property or Request objects.`;
+    },
+    "add-to-cache-list-conflicting-entries": ({ firstEntry, secondEntry })=>{
+        if (!firstEntry || !secondEntry) {
+            throw new Error("Unexpected input to " + `'add-to-cache-list-duplicate-entries' error.`);
+        }
+        return `Two of the entries passed to 'serwist.Serwist.addToPrecacheList()' had the URL ${firstEntry} but different revision details. Serwist is unable to cache and version the asset correctly. Please remove one of the entries.`;
+    },
+    "plugin-error-request-will-fetch": ({ thrownErrorMessage })=>{
+        if (!thrownErrorMessage) {
+            throw new Error("Unexpected input to " + `'plugin-error-request-will-fetch', error.`);
+        }
+        return `An error was thrown by a plugin's 'requestWillFetch()' method. The thrown error message was: '${thrownErrorMessage}'.`;
+    },
+    "invalid-cache-name": ({ cacheNameId, value })=>{
+        if (!cacheNameId) {
+            throw new Error(`Expected a 'cacheNameId' for error 'invalid-cache-name'`);
+        }
+        return `You must provide a name containing at least one character for setCacheDetails({${cacheNameId}: '...'}). Received a value of '${JSON.stringify(value)}'`;
+    },
+    "unregister-route-but-not-found-with-method": ({ method })=>{
+        if (!method) {
+            throw new Error("Unexpected input to " + `'unregister-route-but-not-found-with-method' error.`);
+        }
+        return `The route you're trying to unregister was not  previously registered for the method type '${method}'.`;
+    },
+    "unregister-route-route-not-registered": ()=>{
+        return `The route you're trying to unregister was not previously ` + "registered.";
+    },
+    "queue-replay-failed": ({ name })=>{
+        return `Replaying the background sync queue '${name}' failed.`;
+    },
+    "duplicate-queue-name": ({ name })=>{
+        return `The Queue name '${name}' is already being used. All instances of backgroundSync.Queue must be given unique names.`;
+    },
+    "expired-test-without-max-age": ({ methodName, paramName })=>{
+        return `The '${methodName}()' method can only be used when the ` + `'${paramName}' is used in the constructor.`;
+    },
+    "unsupported-route-type": ({ moduleName, className, funcName, paramName })=>{
+        return `The supplied '${paramName}' parameter was an unsupported type. Please check the docs for ${moduleName}.${className}.${funcName} for valid input types.`;
+    },
+    "not-array-of-class": ({ value, expectedClass, moduleName, className, funcName, paramName })=>{
+        return `The supplied '${paramName}' parameter must be an array of '${expectedClass}' objects. Received '${JSON.stringify(value)},'. Please check the call to ${moduleName}.${className}.${funcName}() to fix the issue.`;
+    },
+    "max-entries-or-age-required": ({ moduleName, className, funcName })=>{
+        return `You must define either 'config.maxEntries' or 'config.maxAgeSeconds' in '${moduleName}.${className}.${funcName}'`;
+    },
+    "statuses-or-headers-required": ({ moduleName, className, funcName })=>{
+        return `You must define either 'config.statuses' or 'config.headers' in '${moduleName}.${className}.${funcName}'`;
+    },
+    "invalid-string": ({ moduleName, funcName, paramName })=>{
+        if (!paramName || !moduleName || !funcName) {
+            throw new Error(`Unexpected input to 'invalid-string' error.`);
+        }
+        return `When using strings, the '${paramName}' parameter must start with 'http' (for cross-origin matches) or '/' (for same-origin matches). Please see the docs for ${moduleName}.${funcName}() for more info.`;
+    },
+    "channel-name-required": ()=>{
+        return "You must provide a channelName to construct a " + "BroadcastCacheUpdate instance.";
+    },
+    "invalid-responses-are-same-args": ()=>{
+        return "The arguments passed into responsesAreSame() appear to be " + "invalid. Please ensure valid Responses are used.";
+    },
+    "expire-custom-caches-only": ()=>{
+        return `You must provide a 'cacheName' property when using the ` + "expiration plugin with a runtime caching strategy.";
+    },
+    "unit-must-be-bytes": ({ normalizedRangeHeader })=>{
+        if (!normalizedRangeHeader) {
+            throw new Error(`Unexpected input to 'unit-must-be-bytes' error.`);
+        }
+        return `The 'unit' portion of the Range header must be set to 'bytes'. The Range header provided was "${normalizedRangeHeader}"`;
+    },
+    "single-range-only": ({ normalizedRangeHeader })=>{
+        if (!normalizedRangeHeader) {
+            throw new Error(`Unexpected input to 'single-range-only' error.`);
+        }
+        return `Multiple ranges are not supported. Please use a  single start value, and optional end value. The Range header provided was "${normalizedRangeHeader}"`;
+    },
+    "invalid-range-values": ({ normalizedRangeHeader })=>{
+        if (!normalizedRangeHeader) {
+            throw new Error(`Unexpected input to 'invalid-range-values' error.`);
+        }
+        return `The Range header is missing both start and end values. At least one of those values is needed. The Range header provided was "${normalizedRangeHeader}"`;
+    },
+    "no-range-header": ()=>{
+        return "No Range header was found in the Request provided.";
+    },
+    "range-not-satisfiable": ({ size, start, end })=>{
+        return `The start (${start}) and end (${end}) values in the Range are ` + `not satisfiable by the cached response, which is ${size} bytes.`;
+    },
+    "attempt-to-cache-non-get-request": ({ url, method })=>{
+        return `Unable to cache '${url}' because it is a '${method}' request and only 'GET' requests can be cached.`;
+    },
+    "cache-put-with-no-response": ({ url })=>{
+        return `There was an attempt to cache '${url}' but the response was not defined.`;
+    },
+    "no-response": ({ url, error })=>{
+        let message = `The strategy could not generate a response for '${url}'.`;
+        if (error) {
+            message += ` The underlying error is ${error}.`;
+        }
+        return message;
+    },
+    "bad-precaching-response": ({ url, status })=>{
+        return `The precaching request for '${url}' failed${status ? ` with an HTTP status of ${status}.` : "."}`;
+    },
+    "non-precached-url": ({ url })=>{
+        return `'createHandlerBoundToURL("${url}")' was called, but that URL is not precached. Please pass in a URL that is precached instead.`;
+    },
+    "add-to-cache-list-conflicting-integrities": ({ url })=>{
+        return `Two of the entries passed to 'serwist.Serwist.addToPrecacheList()' had the URL ${url} with different integrity values. Please remove one of them.`;
+    },
+    "missing-precache-entry": ({ cacheName, url })=>{
+        return `Unable to find a precached response in ${cacheName} for ${url}.`;
+    },
+    "cross-origin-copy-response": ({ origin })=>{
+        return `'@serwist/core.copyResponse()' can only be used with same-origin responses. It was passed a response with origin ${origin}.`;
+    },
+    "opaque-streams-source": ({ type })=>{
+        const message = `One of the '@serwist/streams' sources resulted in an '${type}' response.`;
+        if (type === "opaqueredirect") {
+            return `${message} Please do not use a navigation request that results in a redirect as a source.`;
+        }
+        return `${message} Please ensure your sources are CORS-enabled.`;
+    }
+};
+
+const fallback = (code, ...args)=>{
+    let msg = code;
+    if (args.length > 0) {
+        msg += ` :: ${JSON.stringify(args)}`;
+    }
+    return msg;
+};
+const generatorFunction = (code, details = {})=>{
+    const message = messages[code];
+    if (!message) {
+        throw new Error(`Unable to find message for code '${code}'.`);
+    }
+    return message(details);
+};
+const messageGenerator = process.env.NODE_ENV === "production" ? fallback : generatorFunction;
+
+class SerwistError extends Error {
+    details;
+    constructor(errorCode, details){
+        const message = messageGenerator(errorCode, details);
+        super(message);
+        this.name = errorCode;
+        this.details = details;
+    }
+}
+
+const isArray = (value, details)=>{
+    if (!Array.isArray(value)) {
+        throw new SerwistError("not-an-array", details);
+    }
+};
+const hasMethod = (object, expectedMethod, details)=>{
+    const type = typeof object[expectedMethod];
+    if (type !== "function") {
+        details.expectedMethod = expectedMethod;
+        throw new SerwistError("missing-a-method", details);
+    }
+};
+const isType = (object, expectedType, details)=>{
+    if (typeof object !== expectedType) {
+        details.expectedType = expectedType;
+        throw new SerwistError("incorrect-type", details);
+    }
+};
+const isInstance = (object, expectedClass, details)=>{
+    if (!(object instanceof expectedClass)) {
+        details.expectedClassName = expectedClass.name;
+        throw new SerwistError("incorrect-class", details);
+    }
+};
+const isOneOf = (value, validValues, details)=>{
+    if (!validValues.includes(value)) {
+        details.validValueDescription = `Valid values are ${JSON.stringify(validValues)}.`;
+        throw new SerwistError("invalid-value", details);
+    }
+};
+const isArrayOfClass = (value, expectedClass, details)=>{
+    const error = new SerwistError("not-array-of-class", details);
+    if (!Array.isArray(value)) {
+        throw error;
+    }
+    for (const item of value){
+        if (!(item instanceof expectedClass)) {
+            throw error;
+        }
+    }
+};
+const finalAssertExports = process.env.NODE_ENV === "production" ? null : {
+    hasMethod,
+    isArray,
+    isInstance,
+    isOneOf,
+    isType,
+    isArrayOfClass
+};
+
+const getFriendlyURL = (url)=>{
+    const urlObj = new URL(String(url), location.href);
+    return urlObj.href.replace(new RegExp(`^${location.origin}`), "");
+};
+
+class Deferred {
+    promise;
+    resolve;
+    reject;
+    constructor(){
+        this.promise = new Promise((resolve, reject)=>{
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+}
+
+function stripParams(fullURL, ignoreParams) {
+    const strippedURL = new URL(fullURL);
+    for (const param of ignoreParams){
+        strippedURL.searchParams.delete(param);
+    }
+    return strippedURL.href;
+}
+async function cacheMatchIgnoreParams(cache, request, ignoreParams, matchOptions) {
+    const strippedRequestURL = stripParams(request.url, ignoreParams);
+    if (request.url === strippedRequestURL) {
+        return cache.match(request, matchOptions);
+    }
+    const keysOptions = {
+        ...matchOptions,
+        ignoreSearch: true
+    };
+    const cacheKeys = await cache.keys(request, keysOptions);
+    for (const cacheKey of cacheKeys){
+        const strippedCacheKeyURL = stripParams(cacheKey.url, ignoreParams);
+        if (strippedRequestURL === strippedCacheKeyURL) {
+            return cache.match(cacheKey, matchOptions);
+        }
+    }
+    return;
+}
+
+const quotaErrorCallbacks = new Set();
+
+const executeQuotaErrorCallbacks = async ()=>{
+    if (process.env.NODE_ENV !== "production") {
+        logger.log(`About to run ${quotaErrorCallbacks.size} callbacks to clean up caches.`);
+    }
+    for (const callback of quotaErrorCallbacks){
+        await callback();
+        if (process.env.NODE_ENV !== "production") {
+            logger.log(callback, "is complete.");
+        }
+    }
+    if (process.env.NODE_ENV !== "production") {
+        logger.log("Finished running callbacks.");
+    }
+};
+
+function timeout(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+}
+
+export { Deferred as D, SerwistError as S, cacheMatchIgnoreParams as a, cacheNames as c, executeQuotaErrorCallbacks as e, finalAssertExports as f, getFriendlyURL as g, logger as l, quotaErrorCallbacks as q, timeout as t };

package/dist/chunks/waitUntil.js

@@ -0,0 +1,24 @@
+let supportStatus;
+function canConstructResponseFromBodyStream() {
+    if (supportStatus === undefined) {
+        const testResponse = new Response("");
+        if ("body" in testResponse) {
+            try {
+                new Response(testResponse.body);
+                supportStatus = true;
+            } catch (error) {
+                supportStatus = false;
+            }
+        }
+        supportStatus = false;
+    }
+    return supportStatus;
+}
+
+const waitUntil = (event, asyncFn)=>{
+    const returnPromise = asyncFn();
+    event.waitUntil(returnPromise);
+    return returnPromise;
+};
+
+export { canConstructResponseFromBodyStream as c, waitUntil as w };

package/dist/cleanupOutdatedCaches.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Adds an `activate` event listener which will clean up incompatible
+ * precaches that were created by older versions of Serwist.
+ */
+export declare const cleanupOutdatedCaches: (cacheName?: string) => void;
+//# sourceMappingURL=cleanupOutdatedCaches.d.ts.map

package/dist/cleanupOutdatedCaches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanupOutdatedCaches.d.ts","sourceRoot":"","sources":["../src/cleanupOutdatedCaches.ts"],"names":[],"mappings":"AAeA;;;GAGG;AACH,eAAO,MAAM,qBAAqB,eAAgB,MAAM,KAAG,IAY1D,CAAC"}

package/dist/clientsClaim.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Claims any currently available clients once the service worker
+ * becomes active. This is normally used in conjunction with `skipWaiting()`.
+ */
+export declare const clientsClaim: () => void;
+//# sourceMappingURL=clientsClaim.d.ts.map

package/dist/clientsClaim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clientsClaim.d.ts","sourceRoot":"","sources":["../src/clientsClaim.ts"],"names":[],"mappings":"AAWA;;;GAGG;AACH,eAAO,MAAM,YAAY,QAAO,IAE/B,CAAC"}

package/dist/constants.d.ts

@@ -0,0 +1,15 @@
+export type HTTPMethod = "DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT";
+/**
+ * The default HTTP method, 'GET', used when there's no specific method
+ * configured for a route.
+ *
+ * @private
+ */
+export declare const defaultMethod = "GET";
+/**
+ * The list of valid HTTP methods associated with requests that could be routed.
+ *
+ * @private
+ */
+export declare const validMethods: ("DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT")[];
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;AAE9E;;;;;GAKG;AACH,eAAO,MAAM,aAAa,QAA6B,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,YAAY,0DAA2E,CAAC"}

package/dist/copyResponse.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Allows developers to copy a response and modify its `headers`, `status`,
+ * or `statusText` values (the values settable via a
+ * [`ResponseInit`](https://developer.mozilla.org/en-US/docs/Web/API/Response/Response#Syntax)
+ * object in the constructor).
+ * To modify these values, pass a function as the second argument. That
+ * function will be invoked with a single object with the response properties
+ * `{headers, status, statusText}`. The return value of this function will
+ * be used as the `ResponseInit` for the new `Response`. To change the values
+ * either modify the passed parameter(s) and return it, or return a totally
+ * new object.
+ *
+ * This method is intentionally limited to same-origin responses, regardless of
+ * whether CORS was used or not.
+ *
+ * @param response
+ * @param modifier
+ */
+export declare const copyResponse: (response: Response, modifier?: ((responseInit: ResponseInit) => ResponseInit) | undefined) => Promise<Response>;
+//# sourceMappingURL=copyResponse.d.ts.map

package/dist/copyResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copyResponse.d.ts","sourceRoot":"","sources":["../src/copyResponse.ts"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,YAAY,aAAoB,QAAQ,6BAA4B,YAAY,KAAK,YAAY,kBAAG,QAAQ,QAAQ,CA8BhI,CAAC"}

package/dist/disableDevLogs.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Disables Serwist's logging in development mode.
+ *
+ * @see https://serwist.pages.dev/docs/sw/abstractions/disable-dev-logs
+ */
+export declare const disableDevLogs: () => void;
+//# sourceMappingURL=disableDevLogs.d.ts.map

package/dist/disableDevLogs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disableDevLogs.d.ts","sourceRoot":"","sources":["../src/disableDevLogs.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,cAAc,QAAO,IAEjC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import type { HTTPMethod } from "./constants.js";
+import { cacheNames } from "./cacheNames.js";
+import { cleanupOutdatedCaches } from "./cleanupOutdatedCaches.js";
+import { clientsClaim } from "./clientsClaim.js";
+import { copyResponse } from "./copyResponse.js";
+import { disableDevLogs } from "./disableDevLogs.js";
+import { disableNavigationPreload, enableNavigationPreload, isNavigationPreloadSupported } from "./navigationPreload.js";
+import type { NavigationRouteMatchOptions } from "./NavigationRoute.js";
+import { NavigationRoute } from "./NavigationRoute.js";
+import { parseRoute } from "./parseRoute.js";
+import { PrecacheRoute } from "./PrecacheRoute.js";
+import { PrecacheStrategy } from "./PrecacheStrategy.js";
+import { RegExpRoute } from "./RegExpRoute.js";
+import { registerQuotaErrorCallback } from "./registerQuotaErrorCallback.js";
+import { Route } from "./Route.js";
+import { Serwist, type SerwistOptions } from "./Serwist.js";
+import { setCacheNameDetails } from "./setCacheNameDetails.js";
+export { NavigationRoute, cacheNames, cleanupOutdatedCaches, clientsClaim, copyResponse, disableDevLogs, disableNavigationPreload, enableNavigationPreload, isNavigationPreloadSupported, parseRoute, PrecacheRoute, PrecacheStrategy, RegExpRoute, registerQuotaErrorCallback, Route, Serwist, setCacheNameDetails, };
+export type { HTTPMethod, NavigationRouteMatchOptions, SerwistOptions };
+export type * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,4BAA4B,EAAE,MAAM,wBAAwB,CAAC;AACzH,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAC7E,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAE/D,OAAO,EACL,eAAe,EACf,UAAU,EACV,qBAAqB,EACrB,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,wBAAwB,EACxB,uBAAuB,EACvB,4BAA4B,EAC5B,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,WAAW,EACX,0BAA0B,EAC1B,KAAK,EACL,OAAO,EACP,mBAAmB,GACpB,CAAC;AACF,YAAY,EAAE,UAAU,EAAE,2BAA2B,EAAE,cAAc,EAAE,CAAC;AACxE,mBAAmB,YAAY,CAAC"}

package/dist/index.internal.d.ts

@@ -0,0 +1,16 @@
+import { Deferred } from "./utils/Deferred.js";
+import { SerwistError } from "./utils/SerwistError.js";
+import { assert } from "./utils/assert.js";
+import { cacheMatchIgnoreParams } from "./utils/cacheMatchIgnoreParams.js";
+import { cacheNames as privateCacheNames } from "./utils/cacheNames.js";
+import { canConstructReadableStream } from "./utils/canConstructReadableStream.js";
+import { canConstructResponseFromBodyStream } from "./utils/canConstructResponseFromBodyStream.js";
+import { dontWaitFor } from "./utils/dontWaitFor.js";
+import { executeQuotaErrorCallbacks } from "./utils/executeQuotaErrorCallbacks.js";
+import { getFriendlyURL } from "./utils/getFriendlyURL.js";
+import { logger } from "./utils/logger.js";
+import { resultingClientExists } from "./utils/resultingClientExists.js";
+import { timeout } from "./utils/timeout.js";
+import { waitUntil } from "./utils/waitUntil.js";
+export { Deferred, SerwistError, assert, cacheMatchIgnoreParams, privateCacheNames, canConstructReadableStream, canConstructResponseFromBodyStream, dontWaitFor, executeQuotaErrorCallbacks, getFriendlyURL, logger, resultingClientExists, timeout, waitUntil, };
+//# sourceMappingURL=index.internal.d.ts.map

package/dist/index.internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.internal.d.ts","sourceRoot":"","sources":["../src/index.internal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EAAE,UAAU,IAAI,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AACxE,OAAO,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AACnF,OAAO,EAAE,kCAAkC,EAAE,MAAM,+CAA+C,CAAC;AACnG,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AACnF,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAIjD,OAAO,EACL,QAAQ,EACR,YAAY,EACZ,MAAM,EACN,sBAAsB,EACtB,iBAAiB,EACjB,0BAA0B,EAC1B,kCAAkC,EAClC,WAAW,EACX,0BAA0B,EAC1B,cAAc,EACd,MAAM,EACN,qBAAqB,EACrB,OAAO,EACP,SAAS,GACV,CAAC"}

package/dist/index.internal.js

@@ -0,0 +1,24 @@
+export { D as Deferred, S as SerwistError, f as assert, a as cacheMatchIgnoreParams, e as executeQuotaErrorCallbacks, g as getFriendlyURL, l as logger, c as privateCacheNames, t as timeout } from './chunks/timeout.js';
+export { c as canConstructResponseFromBodyStream, w as waitUntil } from './chunks/waitUntil.js';
+export { r as resultingClientExists } from './chunks/resultingClientExists.js';
+
+let supportStatus;
+function canConstructReadableStream() {
+    if (supportStatus === undefined) {
+        try {
+            new ReadableStream({
+                start () {}
+            });
+            supportStatus = true;
+        } catch (error) {
+            supportStatus = false;
+        }
+    }
+    return supportStatus;
+}
+
+function dontWaitFor(promise) {
+    void promise.then(()=>{});
+}
+
+export { canConstructReadableStream, dontWaitFor };

package/dist/index.js

@@ -0,0 +1,27 @@
+import { c as cacheNames$1 } from './chunks/timeout.js';
+export { N as NavigationRoute, P as PrecacheRoute, g as PrecacheStrategy, R as RegExpRoute, S as Serwist, c as cleanupOutdatedCaches, a as clientsClaim, b as copyResponse, d as disableDevLogs, e as disableNavigationPreload, f as enableNavigationPreload, i as isNavigationPreloadSupported, p as parseRoute, s as setCacheNameDetails } from './chunks/Serwist.js';
+export { r as registerQuotaErrorCallback } from './chunks/registerQuotaErrorCallback.js';
+export { R as Route } from './chunks/PrecacheFallbackPlugin.js';
+import './chunks/waitUntil.js';
+import './chunks/NetworkOnly.js';
+import 'idb';
+
+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();
+    }
+};
+
+export { cacheNames };