@serwist/core 9.0.0-preview.9 → 9.0.1

package/dist/_private/resultingClientExists.d.ts

@@ -1,12 +0,0 @@
-/**
- * Returns a promise that resolves to a window client matching the passed
- * `resultingClientId`. For browsers that don't support `resultingClientId`
- * or if waiting for the resulting client to apper takes too long, resolve to
- * `undefined`.
- *
- * @param resultingClientId
- * @returns
- * @private
- */
-export declare function resultingClientExists(resultingClientId?: string): Promise<Client | undefined>;
-//# sourceMappingURL=resultingClientExists.d.ts.map

package/dist/_private/resultingClientExists.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resultingClientExists.d.ts","sourceRoot":"","sources":["../../src/_private/resultingClientExists.ts"],"names":[],"mappings":"AAcA;;;;;;;;;GASG;AACH,wBAAsB,qBAAqB,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAiCnG"}

package/dist/_private/timeout.d.ts

@@ -1,10 +0,0 @@
-/**
- * Returns a promise that resolves and the passed number of milliseconds.
- * This utility is an async/await-friendly version of `setTimeout`.
- *
- * @param ms
- * @returns
- * @private
- */
-export declare function timeout(ms: number): Promise<unknown>;
-//# sourceMappingURL=timeout.d.ts.map

package/dist/_private/timeout.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../../src/_private/timeout.ts"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AAEH,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAEpD"}

package/dist/_private/waitUntil.d.ts

@@ -1,11 +0,0 @@
-/**
- * A utility method that makes it easier to use `event.waitUntil` with
- * async functions and return the result.
- *
- * @param event
- * @param asyncFn
- * @returns
- * @private
- */
-export declare const waitUntil: <T = any>(event: ExtendableEvent, asyncFn: () => Promise<T>) => Promise<T>;
-//# sourceMappingURL=waitUntil.d.ts.map

package/dist/_private/waitUntil.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"waitUntil.d.ts","sourceRoot":"","sources":["../../src/_private/waitUntil.ts"],"names":[],"mappings":"AAOA;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,mBAAoB,eAAe,0CAIxD,CAAC"}

package/dist/cacheNames.d.ts

@@ -1,21 +0,0 @@
-/**
- * Get the current cache names and prefix/suffix used by Workbox.
- *
- * `cacheNames.precache` is used for precached assets,
- * `cacheNames.googleAnalytics` is used by `@serwist/google-analytics` to
- * store `analytics.js`, and `cacheNames.runtime` is used for everything else.
- *
- * `cacheNames.prefix` can be used to retrieve just the current prefix value.
- * `cacheNames.suffix` can be used to retrieve just the current suffix value.
- *
- * @returns An object with `precache`, `runtime`, `prefix`, and `googleAnalytics` properties.
- */
-declare const cacheNames: {
-    readonly googleAnalytics: string;
-    readonly precache: string;
-    readonly prefix: string;
-    readonly runtime: string;
-    readonly suffix: string;
-};
-export { cacheNames };
-//# sourceMappingURL=cacheNames.d.ts.map

package/dist/cacheNames.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cacheNames.d.ts","sourceRoot":"","sources":["../src/cacheNames.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,UAAU;;;;;;CAgBf,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/chunks/quotaErrorCallbacks.js

@@ -1,355 +0,0 @@
-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 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/precaching.PrecacheController.addToCacheList()' 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/precaching.PrecacheController.addToCacheList()' 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.maxAgeSecondsin ${moduleName}.${className}.${funcName}`;
-    },
-    "statuses-or-headers-required": ({ moduleName, className, funcName })=>{
-        return `You must define either config.statuses or config.headersin ${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/precaching.PrecacheController.addToCacheList()' 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;
-    }
-}
-
-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 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 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 quotaErrorCallbacks = new Set();
-
-export { SerwistError as S, canConstructResponseFromBodyStream as a, cacheNames as c, finalAssertExports as f, logger as l, quotaErrorCallbacks as q };

package/dist/clientsClaim.d.ts

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

package/dist/clientsClaim.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"clientsClaim.d.ts","sourceRoot":"","sources":["../src/clientsClaim.ts"],"names":[],"mappings":"AAWA;;;GAGG;AACH,iBAAS,YAAY,IAAI,IAAI,CAE5B;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/copyResponse.d.ts

@@ -1,21 +0,0 @@
-/**
- * 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
- */
-declare function copyResponse(response: Response, modifier?: (responseInit: ResponseInit) => ResponseInit): Promise<Response>;
-export { copyResponse };
-//# sourceMappingURL=copyResponse.d.ts.map

package/dist/copyResponse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"copyResponse.d.ts","sourceRoot":"","sources":["../src/copyResponse.ts"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;GAiBG;AACH,iBAAe,YAAY,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,YAAY,GAAG,OAAO,CAAC,QAAQ,CAAC,CA8B1H;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/models/messages/messageGenerator.d.ts

@@ -1,4 +0,0 @@
-import type { MapLikeObject } from "../../types.js";
-import { type MessageKey } from "./messages.js";
-export declare const messageGenerator: ((code: string, ...args: any[]) => string) | ((code: MessageKey, details?: MapLikeObject) => string);
-//# sourceMappingURL=messageGenerator.d.ts.map

package/dist/models/messages/messageGenerator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"messageGenerator.d.ts","sourceRoot":"","sources":["../../../src/models/messages/messageGenerator.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,KAAK,UAAU,EAAY,MAAM,eAAe,CAAC;AAmB1D,eAAO,MAAM,gBAAgB,UAjBL,MAAM,WAAW,GAAG,EAAE,uBAQb,UAAU,YAAW,aAAa,YASiC,CAAC"}

package/dist/models/messages/messages.d.ts

@@ -1,44 +0,0 @@
-interface LoggableObject {
-    [key: string]: string | number;
-}
-export declare const messages: {
-    "invalid-value": ({ paramName, validValueDescription, value }: LoggableObject) => string;
-    "not-an-array": ({ moduleName, className, funcName, paramName }: LoggableObject) => string;
-    "incorrect-type": ({ expectedType, paramName, moduleName, className, funcName }: LoggableObject) => string;
-    "incorrect-class": ({ expectedClassName, paramName, moduleName, className, funcName, isReturnValueProblem }: LoggableObject) => string;
-    "missing-a-method": ({ expectedMethod, paramName, moduleName, className, funcName }: LoggableObject) => string;
-    "add-to-cache-list-unexpected-type": ({ entry }: LoggableObject) => string;
-    "add-to-cache-list-conflicting-entries": ({ firstEntry, secondEntry }: LoggableObject) => string;
-    "plugin-error-request-will-fetch": ({ thrownErrorMessage }: LoggableObject) => string;
-    "invalid-cache-name": ({ cacheNameId, value }: LoggableObject) => string;
-    "unregister-route-but-not-found-with-method": ({ method }: LoggableObject) => string;
-    "unregister-route-route-not-registered": () => string;
-    "queue-replay-failed": ({ name }: LoggableObject) => string;
-    "duplicate-queue-name": ({ name }: LoggableObject) => string;
-    "expired-test-without-max-age": ({ methodName, paramName }: LoggableObject) => string;
-    "unsupported-route-type": ({ moduleName, className, funcName, paramName }: LoggableObject) => string;
-    "not-array-of-class": ({ value, expectedClass, moduleName, className, funcName, paramName }: LoggableObject) => string;
-    "max-entries-or-age-required": ({ moduleName, className, funcName }: LoggableObject) => string;
-    "statuses-or-headers-required": ({ moduleName, className, funcName }: LoggableObject) => string;
-    "invalid-string": ({ moduleName, funcName, paramName }: LoggableObject) => string;
-    "channel-name-required": () => string;
-    "invalid-responses-are-same-args": () => string;
-    "expire-custom-caches-only": () => string;
-    "unit-must-be-bytes": ({ normalizedRangeHeader }: LoggableObject) => string;
-    "single-range-only": ({ normalizedRangeHeader }: LoggableObject) => string;
-    "invalid-range-values": ({ normalizedRangeHeader }: LoggableObject) => string;
-    "no-range-header": () => string;
-    "range-not-satisfiable": ({ size, start, end }: LoggableObject) => string;
-    "attempt-to-cache-non-get-request": ({ url, method }: LoggableObject) => string;
-    "cache-put-with-no-response": ({ url }: LoggableObject) => string;
-    "no-response": ({ url, error }: LoggableObject) => string;
-    "bad-precaching-response": ({ url, status }: LoggableObject) => string;
-    "non-precached-url": ({ url }: LoggableObject) => string;
-    "add-to-cache-list-conflicting-integrities": ({ url }: LoggableObject) => string;
-    "missing-precache-entry": ({ cacheName, url }: LoggableObject) => string;
-    "cross-origin-copy-response": ({ origin }: LoggableObject) => string;
-    "opaque-streams-source": ({ type }: LoggableObject) => string;
-};
-export type MessageKey = keyof typeof messages;
-export {};
-//# sourceMappingURL=messages.d.ts.map

package/dist/models/messages/messages.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/models/messages/messages.ts"],"names":[],"mappings":"AAQA,UAAU,cAAc;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;CAChC;AAKD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuNC,CAAC;AAEvB,MAAM,MAAM,UAAU,GAAG,MAAM,OAAO,QAAQ,CAAC"}

package/dist/models/pluginEvents.d.ts

@@ -1,10 +0,0 @@
-export declare enum pluginEvents {
-    CACHE_DID_UPDATE = "cacheDidUpdate",
-    CACHE_KEY_WILL_BE_USED = "cacheKeyWillBeUsed",
-    CACHE_WILL_UPDATE = "cacheWillUpdate",
-    CACHED_RESPONSE_WILL_BE_USED = "cachedResponseWillBeUsed",
-    FETCH_DID_FAIL = "fetchDidFail",
-    FETCH_DID_SUCCEED = "fetchDidSucceed",
-    REQUEST_WILL_FETCH = "requestWillFetch"
-}
-//# sourceMappingURL=pluginEvents.d.ts.map

package/dist/models/pluginEvents.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pluginEvents.d.ts","sourceRoot":"","sources":["../../src/models/pluginEvents.ts"],"names":[],"mappings":"AAQA,oBAAY,YAAY;IACtB,gBAAgB,mBAAmB;IACnC,sBAAsB,uBAAuB;IAC7C,iBAAiB,oBAAoB;IACrC,4BAA4B,6BAA6B;IACzD,cAAc,iBAAiB;IAC/B,iBAAiB,oBAAoB;IACrC,kBAAkB,qBAAqB;CACxC"}

package/dist/models/quotaErrorCallbacks.d.ts

@@ -1,3 +0,0 @@
-declare const quotaErrorCallbacks: Set<Function>;
-export { quotaErrorCallbacks };
-//# sourceMappingURL=quotaErrorCallbacks.d.ts.map

package/dist/models/quotaErrorCallbacks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"quotaErrorCallbacks.d.ts","sourceRoot":"","sources":["../../src/models/quotaErrorCallbacks.ts"],"names":[],"mappings":"AAUA,QAAA,MAAM,mBAAmB,EAAE,GAAG,CAAC,QAAQ,CAAa,CAAC;AAErD,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/registerQuotaErrorCallback.d.ts

@@ -1,9 +0,0 @@
-/**
- * Adds a function to the set of quotaErrorCallbacks that will be executed if
- * there's a quota error.
- *
- * @param callback
- */
-declare function registerQuotaErrorCallback(callback: Function): void;
-export { registerQuotaErrorCallback };
-//# sourceMappingURL=registerQuotaErrorCallback.d.ts.map

package/dist/registerQuotaErrorCallback.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registerQuotaErrorCallback.d.ts","sourceRoot":"","sources":["../src/registerQuotaErrorCallback.ts"],"names":[],"mappings":"AAYA;;;;;GAKG;AAEH,iBAAS,0BAA0B,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAc5D;AAED,OAAO,EAAE,0BAA0B,EAAE,CAAC"}

package/dist/setCacheNameDetails.d.ts

@@ -1,10 +0,0 @@
-import type { PartialCacheNameDetails } from "./_private/cacheNames.js";
-/**
- * Modifies the default cache names used by Serwist packages.
- * Cache names are generated as `<prefix>-<Cache Name>-<suffix>`.
- *
- * @param details
- */
-declare function setCacheNameDetails(details: PartialCacheNameDetails): void;
-export { setCacheNameDetails };
-//# sourceMappingURL=setCacheNameDetails.d.ts.map

package/dist/setCacheNameDetails.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setCacheNameDetails.d.ts","sourceRoot":"","sources":["../src/setCacheNameDetails.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAGxE;;;;;GAKG;AACH,iBAAS,mBAAmB,CAAC,OAAO,EAAE,uBAAuB,GAAG,IAAI,CAiCnE;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAC"}