serwist 9.0.0-preview.24

package/dist/legacy/getCacheKeyForURL.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Takes in a URL, and returns the corresponding URL that could be used to
+ * lookup the entry in the precache.
+ *
+ * If a relative URL is provided, the location of the service worker file will
+ * be used as the base.
+ *
+ * For precached entries without revision information, the cache key will be the
+ * same as the original URL.
+ *
+ * For precached entries with revision information, the cache key will be the
+ * original URL with the addition of a query parameter used for keeping track of
+ * the revision info.
+ *
+ * @param url The URL whose cache key to look up.
+ * @returns The cache key that corresponds to that URL.
+ * @deprecated
+ */
+export declare const getCacheKeyForURL: (url: string) => string | undefined;
+//# sourceMappingURL=getCacheKeyForURL.d.ts.map

package/dist/legacy/getCacheKeyForURL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getCacheKeyForURL.d.ts","sourceRoot":"","sources":["../../src/legacy/getCacheKeyForURL.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,iBAAiB,QAAS,MAAM,KAAG,MAAM,GAAG,SAGxD,CAAC"}

package/dist/legacy/handlePrecaching.d.ts

@@ -0,0 +1,54 @@
+import type { PrecacheEntry, PrecacheRouteOptions } from "../types.js";
+import type { PrecacheController } from "./PrecacheController.js";
+import type { Router } from "./Router.js";
+/**
+ * @deprecated
+ */
+export interface HandlePrecachingOptions {
+    /**
+     * An optional `PrecacheController` instance. If not provided, the singleton
+     * `PrecacheController` will be used.
+     */
+    precacheController?: PrecacheController;
+    /**
+     * An optional `Router` instance. If not provided, the singleton `Router`
+     * will be used.
+     */
+    router?: Router;
+    /**
+     * A list of URLs that should be cached.
+     */
+    precacheEntries?: (PrecacheEntry | string)[];
+    /**
+     * Options to customize how Serwist precaches the URLs.
+     */
+    precacheOptions?: PrecacheRouteOptions;
+    /**
+     * Whether outdated caches should be removed.
+     *
+     * @default false
+     */
+    cleanupOutdatedCaches?: boolean;
+    /**
+     * An URL that should point to a HTML file with which navigation requests for URLs that aren't
+     * precached will be fulfilled.
+     */
+    navigateFallback?: string;
+    /**
+     * URLs that should be allowed to use the `navigateFallback` handler.
+     */
+    navigateFallbackAllowlist?: RegExp[];
+    /**
+     * URLs that should not be allowed to use the `navigateFallback` handler. This takes precedence
+     * over `navigateFallbackAllowlist`.
+     */
+    navigateFallbackDenylist?: RegExp[];
+}
+/**
+ * Handles a list of precache entries and cleans up outdated caches.
+ *
+ * @param options
+ * @deprecated
+ */
+export declare const handlePrecaching: ({ precacheController, router, precacheEntries, precacheOptions, cleanupOutdatedCaches, navigateFallback, navigateFallbackAllowlist, navigateFallbackDenylist, }: HandlePrecachingOptions) => void;
+//# sourceMappingURL=handlePrecaching.d.ts.map

package/dist/legacy/handlePrecaching.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlePrecaching.d.ts","sourceRoot":"","sources":["../../src/legacy/handlePrecaching.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACvE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAK1C;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,eAAe,CAAC,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,CAAC;IAC7C;;OAEG;IACH,eAAe,CAAC,EAAE,oBAAoB,CAAC;IACvC;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;OAEG;IACH,yBAAyB,CAAC,EAAE,MAAM,EAAE,CAAC;IACrC;;;OAGG;IACH,wBAAwB,CAAC,EAAE,MAAM,EAAE,CAAC;CACrC;AAED;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,oKAS1B,uBAAuB,KAAG,IAgB5B,CAAC"}

package/dist/legacy/installSerwist.d.ts

@@ -0,0 +1,15 @@
+import { type SerwistOptions } from "../Serwist.js";
+/**
+ * Options for `installSerwist`.
+ *
+ * @deprecated
+ */
+export type InstallSerwistOptions = SerwistOptions;
+/**
+ * Abstracts away the core APIs of Serwist.
+ *
+ * @param options - `installSerwist` options.
+ * @deprecated
+ */
+export declare const installSerwist: (options: InstallSerwistOptions) => void;
+//# sourceMappingURL=installSerwist.d.ts.map

package/dist/legacy/installSerwist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installSerwist.d.ts","sourceRoot":"","sources":["../../src/legacy/installSerwist.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAE7D;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,cAAc,CAAC;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,cAAc,YAAa,qBAAqB,KAAG,IAG/D,CAAC"}

package/dist/legacy/matchPrecache.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Helper function that calls `PrecacheController#matchPrecache`
+ * on the default `PrecacheController` instance.
+ *
+ * If you are creating your own `PrecacheController`, then call
+ * `PrecacheController#matchPrecache` on that instance,
+ * instead of using this function.
+ *
+ * @param request The key (without revisioning parameters)
+ * to look up in the precache.
+ * @returns
+ * @deprecated
+ */
+export declare const matchPrecache: (request: string | Request) => Promise<Response | undefined>;
+//# sourceMappingURL=matchPrecache.d.ts.map

package/dist/legacy/matchPrecache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchPrecache.d.ts","sourceRoot":"","sources":["../../src/legacy/matchPrecache.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,YAAa,MAAM,GAAG,OAAO,KAAG,QAAQ,QAAQ,GAAG,SAAS,CAErF,CAAC"}

package/dist/legacy/precache.d.ts

@@ -0,0 +1,20 @@
+import type { PrecacheEntry } from "../types.js";
+/**
+ * Adds items to the precache list, removing any duplicates and
+ * stores the files in the precache cache when the service
+ * worker installs.
+ *
+ * This method can be called multiple times.
+ *
+ * Please note: This method **will not** serve any of the cached files for you.
+ * It only precaches files. To respond to a network request you call
+ * `serwist/legacy.addRoute`.
+ *
+ * If you have a single array of files to precache, you can just call
+ * `serwist/legacy.precacheAndRoute`.
+ *
+ * @param entries Array of entries to precache.
+ * @deprecated
+ */
+export declare const precache: (entries: (PrecacheEntry | string)[]) => void;
+//# sourceMappingURL=precache.d.ts.map

package/dist/legacy/precache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"precache.d.ts","sourceRoot":"","sources":["../../src/legacy/precache.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,QAAQ,YAAa,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,KAAG,IAE9D,CAAC"}

package/dist/legacy/precacheAndRoute.d.ts

@@ -0,0 +1,15 @@
+import type { PrecacheEntry, PrecacheRouteOptions } from "../types.js";
+/**
+ * This method will add entries to the precache list and add a route to
+ * respond to fetch events.
+ *
+ * This is a convenience method that will call
+ * `serwist/legacy.precache` and
+ * `serwist/legacy.addRoute` in a single call.
+ *
+ * @param entries Array of entries to precache.
+ * @param options See the `serwist.PrecacheRouteOptions` options.
+ * @deprecated
+ */
+export declare const precacheAndRoute: (entries: (PrecacheEntry | string)[], options?: PrecacheRouteOptions) => void;
+//# sourceMappingURL=precacheAndRoute.d.ts.map

package/dist/legacy/precacheAndRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"precacheAndRoute.d.ts","sourceRoot":"","sources":["../../src/legacy/precacheAndRoute.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAIvE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,YAAa,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,YAAY,oBAAoB,KAAG,IAGtG,CAAC"}

package/dist/legacy/registerRoute.d.ts

@@ -0,0 +1,16 @@
+import type { RouteHandler, RouteMatchCallback } from "../types.js";
+import type { Route } from "../Route.js";
+import type { HTTPMethod } from "../constants.js";
+/**
+ * Registers a `RegExp`, string, or function with a caching
+ * strategy to a singleton `Router` instance.
+ *
+ * @param capture If the capture param is a `Route`, all other arguments will be ignored.
+ * @param handler A callback function that returns a `Promise` resulting in a `Response`.
+ * This parameter is required if `capture` is not a `Route` object.
+ * @param method The HTTP method to match the `Route` against. Defaults to `'GET'`.
+ * @returns The generated `Route`, which can then be provided to `unregisterRoute` if needed.
+ * @deprecated
+ */
+export declare const registerRoute: (capture: RegExp | string | RouteMatchCallback | Route, handler?: RouteHandler, method?: HTTPMethod) => Route;
+//# sourceMappingURL=registerRoute.d.ts.map

package/dist/legacy/registerRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerRoute.d.ts","sourceRoot":"","sources":["../../src/legacy/registerRoute.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAGlD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,YAAa,MAAM,GAAG,MAAM,GAAG,kBAAkB,GAAG,KAAK,YAAY,YAAY,WAAW,UAAU,KAAG,KAElI,CAAC"}

package/dist/legacy/registerRuntimeCaching.d.ts

@@ -0,0 +1,11 @@
+import type { RuntimeCaching } from "../types.js";
+/**
+ * Registers caching strategies to a singleton Router instance. It is a simple
+ * syntatic sugar for `serwist/legacy.registerRoute`.
+ *
+ * @param runtimeCachingList
+ * @returns
+ * @deprecated
+ */
+export declare const registerRuntimeCaching: (...runtimeCachingList: RuntimeCaching[]) => void;
+//# sourceMappingURL=registerRuntimeCaching.d.ts.map

package/dist/legacy/registerRuntimeCaching.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerRuntimeCaching.d.ts","sourceRoot":"","sources":["../../src/legacy/registerRuntimeCaching.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,0BAA2B,cAAc,EAAE,KAAG,IAIhF,CAAC"}

package/dist/legacy/setCatchHandler.d.ts

@@ -0,0 +1,10 @@
+import type { RouteHandler } from "../types.js";
+/**
+ * If a `Route` throws an error while handling a request, this `handler`
+ * will be called and given a chance to provide a response.
+ *
+ * @param handler A callback function that returns a Promise resulting in a Response.
+ * @deprecated
+ */
+export declare const setCatchHandler: (handler: RouteHandler) => void;
+//# sourceMappingURL=setCatchHandler.d.ts.map

package/dist/legacy/setCatchHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setCatchHandler.d.ts","sourceRoot":"","sources":["../../src/legacy/setCatchHandler.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,YAAa,YAAY,KAAG,IAEvD,CAAC"}

package/dist/legacy/setDefaultHandler.d.ts

@@ -0,0 +1,13 @@
+import type { RouteHandler } from "../types.js";
+/**
+ * Defines a default `handler` that's called when no routes explicitly
+ * match the incoming request.
+ *
+ * Without a default `handler`, unmatched requests will go against the
+ * network as if there were no service worker present.
+ *
+ * @param handler A callback function that returns a Promise resulting in a Response.
+ * @deprecated
+ */
+export declare const setDefaultHandler: (handler: RouteHandler) => void;
+//# sourceMappingURL=setDefaultHandler.d.ts.map

package/dist/legacy/setDefaultHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setDefaultHandler.d.ts","sourceRoot":"","sources":["../../src/legacy/setDefaultHandler.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,YAAa,YAAY,KAAG,IAEzD,CAAC"}

package/dist/legacy/singletonPrecacheController.d.ts

@@ -0,0 +1,34 @@
+import { PrecacheController } from "./PrecacheController.js";
+/**
+ * Creates a new, singleton `PrecacheController` if one does not exist. If one does
+ * already exist, that instance is returned. This instance is used by Serwist's
+ * `PrecacheController`-dependent functions and classes unless you provide a different
+ * `Router` to them.
+ *
+ * @returns The singleton `PrecacheController`.
+ * @deprecated
+ */
+export declare const getSingletonPrecacheController: () => PrecacheController;
+/**
+ * Changes the singleton `PrecacheController` to a different instance. This is meant for when you do not
+ * want to pass your own `PrecacheController` to every one of Serwist's `PrecacheController`-dependent
+ * functions and classes.
+ *
+ * It is highly recommended that you call this before anything else, if you plan on doing so.
+ *
+ * @example
+ * ```js
+ * import { PrecacheController, setSingletonPrecacheController } from "serwist/legacy";
+ *
+ * const controller = new PrecacheController();
+ *
+ * setSingletonPrecacheController(controller);
+ *
+ * // Do something with your controller...
+ * ```
+ * @param router
+ * @returns The new singleton `PrecacheController`.
+ * @deprecated
+ */
+export declare const setSingletonPrecacheController: (precacheController: PrecacheController) => PrecacheController;
+//# sourceMappingURL=singletonPrecacheController.d.ts.map

package/dist/legacy/singletonPrecacheController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singletonPrecacheController.d.ts","sourceRoot":"","sources":["../../src/legacy/singletonPrecacheController.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAI7D;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B,QAAO,kBAKjD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,8BAA8B,uBAAwB,kBAAkB,KAAG,kBAGvF,CAAC"}

package/dist/legacy/singletonRouter.d.ts

@@ -0,0 +1,41 @@
+import { Router } from "./Router.js";
+/**
+ * Creates a new, singleton `Router` if one does not exist. If one does
+ * already exist, that instance is returned. This instance is used by
+ * Serwist's `Router`-dependent functions and classes unless you provide
+ * a different `Router` to them.
+ *
+ * @returns The singleton `Router`.
+ * @deprecated
+ */
+export declare const getSingletonRouter: () => Router;
+/**
+ * Changes the singleton `Router` to a different instance. This is meant for when you do not
+ * want to pass your own `Router` to every one of Serwist's `Router`-dependent functions and classes.
+ * If this or `getSingletonRouter` has been called before, it removes the listeners of the
+ * previous singleton `Router`. It also adds those of the new one, so you need not do that yourself.
+ *
+ * It is highly recommended that you call this before anything else, if you plan on doing so.
+ *
+ * @example
+ * ```js
+ * import { Router, setSingletonRouter } from "serwist/legacy";
+ *
+ * const router = new Router();
+ *
+ * setSingletonRouter(router);
+ *
+ * router.registerRoute(
+ *   new Route(
+ *     /\/api\/.*\/*.json/,
+ *     new NetworkOnly(),
+ *     "POST",
+ *   ),
+ * );
+ * ```
+ * @param router
+ * @returns The new singleton `Router`.
+ * @deprecated
+ */
+export declare const setSingletonRouter: (router: Router) => Router;
+//# sourceMappingURL=singletonRouter.d.ts.map

package/dist/legacy/singletonRouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singletonRouter.d.ts","sourceRoot":"","sources":["../../src/legacy/singletonRouter.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAIrC;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,QAAO,MASrC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,kBAAkB,WAAY,MAAM,KAAG,MASnD,CAAC"}

package/dist/legacy/unregisterRoute.d.ts

@@ -0,0 +1,9 @@
+import type { Route } from "../Route.js";
+/**
+ * Unregisters a route from the singleton `Router` instance.
+ *
+ * @param route The route to unregister.
+ * @deprecated
+ */
+export declare const unregisterRoute: (route: Route) => void;
+//# sourceMappingURL=unregisterRoute.d.ts.map

package/dist/legacy/unregisterRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unregisterRoute.d.ts","sourceRoot":"","sources":["../../src/legacy/unregisterRoute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGzC;;;;;GAKG;AACH,eAAO,MAAM,eAAe,UAAW,KAAK,KAAG,IAE9C,CAAC"}

package/dist/legacy/utils/PrecacheCacheKeyPlugin.d.ts

@@ -0,0 +1,16 @@
+import type { SerwistPlugin } from "../../types.js";
+import type { PrecacheController } from "../PrecacheController.js";
+/**
+ * A plugin, designed to be used with PrecacheController, to translate URLs into
+ * the corresponding cache key, based on the current revision info.
+ *
+ * @private
+ */
+export declare class PrecacheCacheKeyPlugin implements SerwistPlugin {
+    private readonly _precacheController;
+    constructor({ precacheController }: {
+        precacheController: PrecacheController;
+    });
+    cacheKeyWillBeUsed: SerwistPlugin["cacheKeyWillBeUsed"];
+}
+//# sourceMappingURL=PrecacheCacheKeyPlugin.d.ts.map

package/dist/legacy/utils/PrecacheCacheKeyPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrecacheCacheKeyPlugin.d.ts","sourceRoot":"","sources":["../../../src/legacy/utils/PrecacheCacheKeyPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAA8B,MAAM,gBAAgB,CAAC;AAChF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE;;;;;GAKG;AACH,qBAAa,sBAAuB,YAAW,aAAa;IAC1D,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqB;gBAE7C,EAAE,kBAAkB,EAAE,EAAE;QAAE,kBAAkB,EAAE,kBAAkB,CAAA;KAAE;IAI9E,kBAAkB,EAAE,aAAa,CAAC,oBAAoB,CAAC,CAOrD;CACH"}

package/dist/legacy/utils/getCacheKeyForURL.d.ts

@@ -0,0 +1,14 @@
+import type { PrecacheRouteOptions } from "../../types.js";
+/**
+ * This function will take the request URL and manipulate it based on the
+ * configuration options.
+ *
+ * @param url
+ * @param options
+ * @returns Returns the URL in the cache that matches the request,
+ * if possible.
+ *
+ * @private
+ */
+export declare const getCacheKeyForURL: (url: string, options: PrecacheRouteOptions) => string | undefined;
+//# sourceMappingURL=getCacheKeyForURL.d.ts.map

package/dist/legacy/utils/getCacheKeyForURL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getCacheKeyForURL.d.ts","sourceRoot":"","sources":["../../../src/legacy/utils/getCacheKeyForURL.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAI3D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,QAAS,MAAM,WAAW,oBAAoB,KAAG,MAAM,GAAG,SAYvF,CAAC"}

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"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/navigationPreload.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Checks whether the current browser supports
+ * navigation preloading.
+ *
+ * @returns
+ * @see https://serwist.pages.dev/docs/sw/navigation-preloading/is-navigation-preload-supported
+ */
+export declare const isNavigationPreloadSupported: () => boolean;
+/**
+ * If the browser supports navigation preloading, then this will enable it.
+ *
+ * @param headerValue Optional. Allows developers to override the value of
+ * the `Service-Worker-Navigation-Preload` header which will be sent to the
+ * server when making the navigation request.
+ * @see https://serwist.pages.dev/docs/sw/navigation-preloading/enable-navigation-preload
+ */
+export declare const enableNavigationPreload: (headerValue?: string) => void;
+/**
+ * If the browser supports navigation preloading, then this will disable it.
+ *
+ * @see https://serwist.pages.dev/docs/sw/navigation-preloading/disable-navigation-preload
+ */
+export declare const disableNavigationPreload: () => void;
+//# sourceMappingURL=navigationPreload.d.ts.map

package/dist/navigationPreload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigationPreload.d.ts","sourceRoot":"","sources":["../src/navigationPreload.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,QAAO,OAE/C,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,iBAAkB,MAAM,KAAG,IAqB9D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,QAAO,IAgB3C,CAAC"}

package/dist/parseRoute.d.ts

@@ -0,0 +1,16 @@
+import type { RouteHandler, RouteMatchCallback } from "./types.js";
+import { Route } from "./Route.js";
+import type { HTTPMethod } from "./constants.js";
+/**
+ * Parses a `RegExp`, string, or function with a caching strategy into a `Route`. This is for
+ * when you want to create a `Route`, but you don't want to register it just yet: sometimes
+ * you want to call `setCatchHandler` first, for example.
+ *
+ * @param capture If the capture param is a `Route`, all other arguments will be ignored.
+ * @param handler A callback function that returns a `Promise` resulting in a `Response`.
+ * This parameter is required if `capture` is not a `Route` object.
+ * @param method The HTTP method to match the `Route` against. Defaults to `'GET'`.
+ * @returns The generated `Route`.
+ */
+export declare const parseRoute: (capture: RegExp | string | RouteMatchCallback | Route, handler?: RouteHandler, method?: HTTPMethod) => Route;
+//# sourceMappingURL=parseRoute.d.ts.map

package/dist/parseRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseRoute.d.ts","sourceRoot":"","sources":["../src/parseRoute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAInE,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,YAAa,MAAM,GAAG,MAAM,GAAG,kBAAkB,GAAG,KAAK,YAAY,YAAY,WAAW,UAAU,KAAG,KA2D/H,CAAC"}

package/dist/plugins/backgroundSync/BackgroundSyncPlugin.d.ts

@@ -0,0 +1,23 @@
+import type { FetchDidFailCallbackParam, SerwistPlugin } from "../../types.js";
+import type { QueueOptions } from "./Queue.js";
+/**
+ * A class implementing the `fetchDidFail` lifecycle callback. This makes it
+ * easier to add failed requests to a background sync Queue.
+ */
+export declare class BackgroundSyncPlugin implements SerwistPlugin {
+    private readonly _queue;
+    /**
+     * @param name See the `serwist/plugins.BackgroundSyncQueue`
+     * documentation for parameter details.
+     * @param options See the `serwist/plugins.BackgroundSyncQueue`
+     * documentation for parameter details.
+     * @see https://serwist.pages.dev/docs/background-sync/queue
+     */
+    constructor(name: string, options?: QueueOptions);
+    /**
+     * @param options
+     * @private
+     */
+    fetchDidFail({ request }: FetchDidFailCallbackParam): Promise<void>;
+}
+//# sourceMappingURL=BackgroundSyncPlugin.d.ts.map

package/dist/plugins/backgroundSync/BackgroundSyncPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BackgroundSyncPlugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/backgroundSync/BackgroundSyncPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,yBAAyB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C;;;GAGG;AACH,qBAAa,oBAAqB,YAAW,aAAa;IACxD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAE/B;;;;;;OAMG;gBACS,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;IAIhD;;;OAGG;IACG,YAAY,CAAC,EAAE,OAAO,EAAE,EAAE,yBAAyB;CAG1D"}