serwist 10.0.0-preview.1 → 10.0.0-preview.11

package/dist/lib/{precaching/PrecacheFallbackPlugin.d.ts → extensions/precache/plugin-fallback.d.ts}

@@ -1,15 +1,15 @@
-import type { PrecacheController } from "../../controllers/PrecacheController/PrecacheController.js";
-import type { HandlerDidErrorCallbackParam, StrategyPlugin } from "../../types.js";
+import type { Serwist } from "#lib/core.js";
+import type { HandlerDidErrorCallbackParam, StrategyPlugin } from "#lib/types.js";
 export interface PrecacheFallbackEntry {
+    /**
+     * A precached URL to be used as a fallback.
+     */
+    url: string;
     /**
      * A function that checks whether the fallback entry can be used
      * for a request.
      */
     matcher: (param: HandlerDidErrorCallbackParam) => boolean;
-    /**
-     * A precached URL to be used as a fallback.
-     */
-    url: string;
 }
 export interface PrecacheFallbackPluginOptions {
     /**
@@ -18,9 +18,9 @@ export interface PrecacheFallbackPluginOptions {
      */
     fallbackUrls: (string | PrecacheFallbackEntry)[];
     /**
-     * A {@linkcode PrecacheController} instance.
+     * A {@linkcode Serwist} instance.
      */
-    precacheController: PrecacheController;
+    serwist: Serwist;
 }
 /**
  * Allows you to specify offline fallbacks to be used when a given strategy
@@ -32,13 +32,13 @@ export interface PrecacheFallbackPluginOptions {
  */
 export declare class PrecacheFallbackPlugin implements StrategyPlugin {
     private readonly _fallbackUrls;
-    private readonly _precacheController;
+    private readonly _serwist;
     /**
      * Constructs a new instance with the associated `fallbackUrls`.
      *
      * @param config
      */
-    constructor({ fallbackUrls, precacheController }: PrecacheFallbackPluginOptions);
+    constructor({ fallbackUrls, serwist }: PrecacheFallbackPluginOptions);
     /**
      * @returns The precache response for one of the fallback URLs, or `undefined` if
      * nothing satisfies the conditions.
@@ -46,4 +46,4 @@ export declare class PrecacheFallbackPlugin implements StrategyPlugin {
      */
     handlerDidError(param: HandlerDidErrorCallbackParam): Promise<Response | undefined>;
 }
-//# sourceMappingURL=PrecacheFallbackPlugin.d.ts.map
+//# sourceMappingURL=plugin-fallback.d.ts.map

package/dist/lib/extensions/precache/plugin-fallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-fallback.d.ts","sourceRoot":"","sources":["../../../../src/lib/extensions/precache/plugin-fallback.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,OAAO,KAAK,EAAE,4BAA4B,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAElF,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,OAAO,EAAE,CAAC,KAAK,EAAE,4BAA4B,KAAK,OAAO,CAAC;CAC3D;AAED,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,YAAY,EAAE,CAAC,MAAM,GAAG,qBAAqB,CAAC,EAAE,CAAC;IACjD;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,qBAAa,sBAAuB,YAAW,cAAc;IAC3D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqC;IACnE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAU;IAEnC;;;;OAIG;gBACS,EAAE,YAAY,EAAE,OAAO,EAAE,EAAE,6BAA6B;IAKpE;;;;OAIG;IACG,eAAe,CAAC,KAAK,EAAE,4BAA4B;CA0B1D"}

package/dist/{controllers/PrecacheController/PrecacheInstallReportPlugin.d.ts → lib/extensions/precache/plugin-install-report.d.ts}

@@ -1,4 +1,4 @@
-import type { StrategyPlugin } from "../../types.js";
+import type { StrategyPlugin } from "#lib/types.js";
 /**
  * A plugin designed to determine the number of assets that were updated (or not updated)
  * during the `install` event.
@@ -11,4 +11,4 @@ export declare class PrecacheInstallReportPlugin implements StrategyPlugin {
     handlerWillStart: StrategyPlugin["handlerWillStart"];
     cachedResponseWillBeUsed: StrategyPlugin["cachedResponseWillBeUsed"];
 }
-//# sourceMappingURL=PrecacheInstallReportPlugin.d.ts.map
+//# sourceMappingURL=plugin-install-report.d.ts.map

package/dist/lib/extensions/precache/plugin-install-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-install-report.d.ts","sourceRoot":"","sources":["../../../../src/lib/extensions/precache/plugin-install-report.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,cAAc,EAA+B,MAAM,eAAe,CAAC;AAEjF;;;;;GAKG;AACH,qBAAa,2BAA4B,YAAW,cAAc;IAChE,WAAW,EAAE,MAAM,EAAE,CAAM;IAC3B,cAAc,EAAE,MAAM,EAAE,CAAM;IAE9B,gBAAgB,EAAE,cAAc,CAAC,kBAAkB,CAAC,CAKlD;IAEF,wBAAwB,EAAE,cAAc,CAAC,0BAA0B,CAAC,CAkBlE;CACH"}

package/dist/lib/extensions/precache/route.d.ts

@@ -0,0 +1,42 @@
+import { Route } from "../../route.js";
+import type { UrlManipulation } from "../../types.js";
+import type { Precache } from "./extension.js";
+export interface PrecacheRouteOptions {
+    /**
+     * Tells Serwist to check the precache for an entry whose URL is the request URL appended
+     * with the specified value. Only applies if the request URL ends with "/".
+     *
+     * @default "index.html"
+     */
+    directoryIndex?: string | null;
+    /**
+     * An array of `RegExp` objects matching search params that should be removed when looking
+     * for a precache match.
+     */
+    ignoreURLParametersMatching?: RegExp[];
+    /**
+     * Tells Serwist to check the precache for an entry whose URL is the request URL appended
+     * with ".html".
+     *
+     * @default true
+     */
+    cleanURLs?: boolean;
+    /**
+     * A function that should take a URL and return an array of alternative URLs that should
+     * be checked for precache matches.
+     */
+    urlManipulation?: UrlManipulation;
+}
+/**
+ * A subclass of {@linkcode Route} that takes a {@linkcode Serwist} instance and uses it to match
+ * incoming requests and handle fetching responses from the precache.
+ */
+export declare class PrecacheRoute extends Route {
+    /**
+     * @param precache A {@linkcode Precache} instance.
+     * @param options Options to control how requests are matched
+     * against the list of precached URLs.
+     */
+    constructor(precache: Precache, options?: PrecacheRouteOptions);
+}
+//# sourceMappingURL=route.d.ts.map

package/dist/lib/extensions/precache/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../src/lib/extensions/precache/route.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,EAAiD,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACrG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,MAAM,WAAW,oBAAoB;IACnC;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B;;;OAGG;IACH,2BAA2B,CAAC,EAAE,MAAM,EAAE,CAAC;IACvC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC;AAED;;;GAGG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC;;;;OAIG;gBACS,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,oBAAoB;CAkB/D"}

package/dist/{controllers/PrecacheController/PrecacheStrategy.d.ts → lib/extensions/precache/strategy.d.ts}

@@ -1,7 +1,7 @@
-import type { StrategyPlugin } from "../../types.js";
-import type { StrategyOptions } from "../../lib/strategies/Strategy.js";
-import { Strategy } from "../../lib/strategies/Strategy.js";
-import type { StrategyHandler } from "../../lib/strategies/StrategyHandler.js";
+import type { StrategyPlugin } from "#lib/types.js";
+import type { StrategyOptions } from "../../strategies/Strategy.js";
+import { Strategy } from "../../strategies/Strategy.js";
+import type { StrategyHandler } from "../../strategies/StrategyHandler.js";
 export interface PrecacheStrategyOptions extends StrategyOptions {
     /**
      * Plugins to use when precaching as well as responding to `fetch` events for precached assets.
@@ -66,4 +66,4 @@ export declare class PrecacheStrategy extends Strategy {
      */
     _useDefaultCacheabilityPluginIfNeeded(): void;
 }
-//# sourceMappingURL=PrecacheStrategy.d.ts.map
+//# sourceMappingURL=strategy.d.ts.map

package/dist/lib/extensions/precache/strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../../../../src/lib/extensions/precache/strategy.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAMpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAE3E,MAAM,WAAW,uBAAwB,SAAQ,eAAe;IAC9D;;OAEG;IACH,OAAO,CAAC,EAAE,eAAe,CAAC,SAAS,CAAC,CAAC;IACrC;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,qBAAa,gBAAiB,SAAQ,QAAQ;IAC5C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAU;IAE7C,MAAM,CAAC,QAAQ,CAAC,iCAAiC,EAAE,cAAc,CAQ/D;IAEF,MAAM,CAAC,QAAQ,CAAC,sCAAsC,EAAE,cAAc,CAIpE;IAEF;;OAEG;gBACS,OAAO,GAAE,uBAA4B;IAcjD;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAwBtE,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAyE3E,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAqBnF;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,qCAAqC,IAAI,IAAI;CA4B9C"}

package/dist/{controllers/RuntimeCacheController.d.ts → lib/extensions/runtime-cache.d.ts}

@@ -1,6 +1,7 @@
-import { type PrecacheFallbackEntry } from "../lib/precaching/PrecacheFallbackPlugin.js";
-import type { Serwist } from "../Serwist.js";
-import type { Controller, RuntimeCaching } from "../types.js";
+import type { Serwist } from "#lib/core.js";
+import type { Extension } from "#lib/extension.js";
+import type { RuntimeCaching } from "../types.js";
+import { type PrecacheFallbackEntry } from "./precache/plugin-fallback.js";
 export interface WarmRuntimeCacheEntry {
     integrity?: string;
     url: string;
@@ -16,7 +17,7 @@ export interface FallbacksOptions {
      */
     entries: FallbackEntry[];
 }
-export interface RuntimeCacheControllerOptions {
+export interface RuntimeCacheOptions {
     /**
      * URLs that should be cached as the service worker is installed.
      */
@@ -34,12 +35,17 @@ export interface RuntimeCacheControllerOptions {
      */
     fallbacks?: FallbacksOptions;
 }
-export declare class RuntimeCacheController implements Controller {
+export declare class RuntimeCache implements Extension {
     _entries: RuntimeCaching[];
-    _options: RuntimeCacheControllerOptions;
-    constructor(entries: RuntimeCaching[], options?: RuntimeCacheControllerOptions);
-    init(serwist: Serwist): void;
-    install(event: ExtendableEvent, serwist: Serwist): Promise<void>;
+    _options: RuntimeCacheOptions;
+    constructor(entries: RuntimeCaching[], options?: RuntimeCacheOptions);
+    init({ serwist }: {
+        serwist: Serwist;
+    }): void;
+    install({ event, serwist }: {
+        event: ExtendableEvent;
+        serwist: Serwist;
+    }): Promise<void>;
     /**
      * Any assets you wish to cache ahead of time which can't be revisioned
      * should be cached with this method. All assets are cached on install
@@ -62,4 +68,4 @@ export declare class RuntimeCacheController implements Controller {
      */
     warmRuntimeCache(entries: (WarmRuntimeCacheEntry | string | Request)[]): void;
 }
-//# sourceMappingURL=RuntimeCacheController.d.ts.map
+//# sourceMappingURL=runtime-cache.d.ts.map

package/dist/lib/extensions/runtime-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-cache.d.ts","sourceRoot":"","sources":["../../../src/lib/extensions/runtime-cache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAGnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,KAAK,qBAAqB,EAA0B,MAAM,+BAA+B,CAAC;AAEnG,MAAM,WAAW,qBAAqB;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,uBAAuB;IACtC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,aAAc,SAAQ,qBAAqB;CAAG;AAE/D,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,OAAO,EAAE,aAAa,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,WAAW,CAAC,EAAE,CAAC,qBAAqB,GAAG,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC;IAC3D;;OAEG;IACH,WAAW,CAAC,EAAE,uBAAuB,CAAC;IACtC;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAC9B;AAED,qBAAa,YAAa,YAAW,SAAS;IAC5C,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,QAAQ,EAAE,mBAAmB,CAAC;gBAClB,OAAO,EAAE,cAAc,EAAE,EAAE,OAAO,GAAE,mBAAwB;IAOxE,IAAI,CAAC,EAAE,OAAO,EAAE,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI;IAsBvC,OAAO,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;QAAE,KAAK,EAAE,eAAe,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE;IAwB9E;;;;;;;;;;;;;;;;;;;OAmBG;IACH,gBAAgB,CAAC,OAAO,EAAE,CAAC,qBAAqB,GAAG,MAAM,GAAG,OAAO,CAAC,EAAE,GAAG,IAAI;CAI9E"}

package/dist/lib/functions/handlers.d.ts

@@ -0,0 +1,60 @@
+import { type HTTPMethod } from "#lib/constants.js";
+import type { Extension } from "#lib/extension.js";
+import type { RouteHandler } from "#lib/types.js";
+import type { Serwist } from "../core.js";
+export type RequestArgs = string | [string, RequestInit?];
+export interface CacheURLsMessageData {
+    type: string;
+    payload: {
+        urlsToCache: RequestArgs[];
+    };
+}
+/**
+ * Adds Serwist's event listeners. Before calling it, add your own listeners should you need to.
+ */
+export declare const addEventListeners: (state: Serwist) => void;
+export declare const createInstallHandler: (state: Serwist) => (event: ExtendableEvent) => Promise<void>;
+export declare const createActivateHandler: (state: Serwist) => (event: ExtendableEvent) => Promise<void>;
+/**
+ * Gets a `Response` from an appropriate `Route`'s handler. Call this method
+ * from the service worker's `fetch` event.
+ * @param event
+ */
+export declare const createFetchHandler: (state: Serwist) => (event: FetchEvent) => void;
+/**
+ * Caches new URLs on demand. Call this method from the service worker's
+ * `message` event. To trigger the handler, send a message of type `"CACHE_URLS"`
+ * alongside a list of URLs that should be cached as `urlsToCache`.
+ * @param event
+ */
+export declare const createCacheHandler: (state: Serwist) => (event: ExtendableMessageEvent) => void;
+/**
+ * Define a default handler that's called when no routes explicitly
+ * match the incoming request.
+ *
+ * Each HTTP method (`'GET'`, `'POST'`, etc.) gets its own default handler.
+ *
+ * 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`.
+ * @param method The HTTP method to associate with this default handler. Each method
+ * has its own default. Defaults to `'GET'`.
+ */
+export declare const setDefaultHandler: (state: Serwist, handler: RouteHandler, method?: HTTPMethod) => void;
+/**
+ * If a {@linkcode 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`.
+ */
+export declare const setCatchHandler: (state: Serwist, handler: RouteHandler) => void;
+/**
+ * Accepts a callback name and returns an iterable of matching plugin callbacks.
+ *
+ * @param name The name fo the callback to run
+ * @returns
+ */
+export declare function iterateExtensions<C extends keyof Extension>(state: Serwist, name: C): Generator<NonNullable<Extension[C]>>;
+//# sourceMappingURL=handlers.d.ts.map

package/dist/lib/functions/handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../../src/lib/functions/handlers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,mBAAmB,CAAC;AAEnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAIlD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAK1C,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;AAE1D,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE;QACP,WAAW,EAAE,WAAW,EAAE,CAAC;KAC5B,CAAC;CACH;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,OAAO,SAK/C,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,OAAO,OAAO,MACzC,OAAO,eAAe,KAAG,OAAO,CAAC,IAAI,CAO9C,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,OAAO,OAAO,MAC1C,OAAO,eAAe,KAAG,OAAO,CAAC,IAAI,CAO9C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,OAAO,MACvC,OAAO,UAAU,SAO1B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,OAAO,MACvC,OAAO,sBAAsB,SA4BtC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,OAAO,EAAE,SAAS,YAAY,EAAE,SAAQ,UAA0B,KAAG,IAE7G,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,OAAO,EAAE,SAAS,YAAY,KAAG,IAEvE,CAAC;AAEF;;;;;GAKG;AACH,wBAAiB,iBAAiB,CAAC,CAAC,SAAS,MAAM,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAW3H"}

package/dist/lib/functions/router.d.ts

@@ -0,0 +1,60 @@
+import type { HTTPMethod } from "../constants.js";
+import type { Serwist } from "../core.js";
+import type { Route } from "../route.js";
+import type { RouteHandler, RouteHandlerCallbackOptions, RouteMatchCallback, RouteMatchCallbackOptions } from "../types.js";
+/**
+ * Registers a `RegExp`, string, or function with a caching
+ * strategy to the router.
+ *
+ * @param capture If the capture param is a {@linkcode Route} object, 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 {@linkcode Route} object.
+ * @param method The HTTP method to match the route against. Defaults to `'GET'`.
+ * @returns The generated {@linkcode Route} object.
+ */
+export declare const registerCapture: <T extends RegExp | string | RouteMatchCallback | Route>(state: Serwist, capture: T, handler?: T extends Route ? never : RouteHandler, method?: T extends Route ? never : HTTPMethod) => Route;
+/**
+ * Registers a {@linkcode Route} with the router.
+ *
+ * @param route The {@linkcode Route} to register.
+ */
+export declare const registerRoute: (state: Serwist, route: Route) => void;
+/**
+ * Unregisters a route from the router.
+ *
+ * @param route The {@linkcode Route} object to unregister.
+ */
+export declare const unregisterRoute: (state: Serwist, route: Route) => void;
+/**
+ * Applies the routing rules to a `FetchEvent` object to get a response from an
+ * appropriate route.
+ *
+ * @param options
+ * @returns A promise is returned if a registered route can handle the request.
+ * If there is no matching route and there's no default handler, `undefined`
+ * is returned.
+ */
+export declare const handleRequest: (state: Serwist, { request, event, }: {
+    /**
+     * The request to handle.
+     */
+    request: Request;
+    /**
+     * The event that triggered the request.
+     */
+    event: ExtendableEvent;
+}) => Promise<Response> | undefined;
+/**
+ * Checks a request and URL (and optionally an event) against the list of
+ * registered routes, and if there's a match, returns the corresponding
+ * route along with any params generated by the match.
+ *
+ * @param options
+ * @returns An object with `route` and `params` properties. They are populated
+ * if a matching route was found or `undefined` otherwise.
+ */
+export declare const findMatchingRoute: (state: Serwist, { url, sameOrigin, request, event }: RouteMatchCallbackOptions) => {
+    route?: Route;
+    params?: RouteHandlerCallbackOptions["params"];
+};
+//# sourceMappingURL=router.d.ts.map

package/dist/lib/functions/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../../src/lib/functions/router.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,YAAY,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAE5H;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,kBAAkB,GAAG,KAAK,EACpF,OAAO,OAAO,EACd,SAAS,CAAC,EACV,UAAU,CAAC,SAAS,KAAK,GAAG,KAAK,GAAG,YAAY,EAChD,SAAS,CAAC,SAAS,KAAK,GAAG,KAAK,GAAG,UAAU,KAC5C,KAIF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,EAAE,OAAO,KAAK,KAAG,IA6C5D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,OAAO,EAAE,OAAO,KAAK,KAAG,IAa9D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GACxB,OAAO,OAAO,EACd,qBAGG;IACD;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;OAEG;IACH,KAAK,EAAE,eAAe,CAAC;CACxB,KACA,OAAO,CAAC,QAAQ,CAAC,GAAG,SA4HtB,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,GAC5B,OAAO,OAAO,EACd,qCAAqC,yBAAyB,KAC7D;IACD,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,MAAM,CAAC,EAAE,2BAA2B,CAAC,QAAQ,CAAC,CAAC;CA8ChD,CAAC"}

package/dist/{navigationPreload.d.ts → lib/navigation-preload.d.ts}

@@ -21,4 +21,4 @@ export declare const enableNavigationPreload: (headerValue?: string) => void;
  * @see https://serwist.pages.dev/docs/serwist/core/disable-navigation-preload
  */
 export declare const disableNavigationPreload: () => void;
-//# sourceMappingURL=navigationPreload.d.ts.map
+//# sourceMappingURL=navigation-preload.d.ts.map

package/dist/lib/navigation-preload.d.ts.map

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

package/dist/lib/{rangeRequests → range-requests}/RangeRequestsPlugin.d.ts

@@ -1,4 +1,4 @@
-import type { StrategyPlugin } from "../../types.js";
+import type { StrategyPlugin } from "#lib/types.js";
 /**
  * Makes it easy for a request with a `Range` header to be fulfilled by a cached response.
  *

package/dist/lib/range-requests/RangeRequestsPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RangeRequestsPlugin.d.ts","sourceRoot":"","sources":["../../../src/lib/range-requests/RangeRequestsPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD;;;;;GAKG;AACH,qBAAa,mBAAoB,YAAW,cAAc;IACxD;;;;;;OAMG;IACH,wBAAwB,EAAE,cAAc,CAAC,0BAA0B,CAAC,CAUlE;CACH"}

package/dist/lib/range-requests/createPartialResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPartialResponse.d.ts","sourceRoot":"","sources":["../../../src/lib/range-requests/createPartialResponse.ts"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,qBAAqB,GAAU,SAAS,OAAO,EAAE,kBAAkB,QAAQ,KAAG,OAAO,CAAC,QAAQ,CA8D1G,CAAC"}

package/dist/lib/range-requests/index.d.ts

@@ -0,0 +1,3 @@
+export { createPartialResponse } from "./createPartialResponse.js";
+export { RangeRequestsPlugin } from "./RangeRequestsPlugin.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/range-requests/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/range-requests/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/lib/range-requests/utils/calculateEffectiveBoundaries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateEffectiveBoundaries.d.ts","sourceRoot":"","sources":["../../../../src/lib/range-requests/utils/calculateEffectiveBoundaries.ts"],"names":[],"mappings":"AAWA;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,GAAI,MAAM,IAAI,EAAE,QAAQ,MAAM,EAAE,MAAM,MAAM,KAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAsCnH,CAAC"}

package/dist/lib/range-requests/utils/parseRangeHeader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseRangeHeader.d.ts","sourceRoot":"","sources":["../../../../src/lib/range-requests/utils/parseRangeHeader.ts"],"names":[],"mappings":"AAWA;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAC3B,aAAa,MAAM,KAClB;IACD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;CAgCd,CAAC"}

package/dist/lib/route.d.ts

@@ -0,0 +1,106 @@
+import type { HTTPMethod } from "./constants.js";
+import type { RouteHandler, RouteHandlerObject, RouteMatchCallback } from "./types.js";
+/**
+ * A `Route` consists of a pair of callback functions, `match` and `handler`.
+ * The `match` callback determines if a route should be used to handle a
+ * request by returning a truthy value if it can. The `handler` callback
+ * is called when the route matches and should return a promise that resolves
+ * to a response.
+ */
+export declare class Route {
+    handler: RouteHandlerObject;
+    match: RouteMatchCallback;
+    method: HTTPMethod;
+    catchHandler?: RouteHandlerObject;
+    /**
+     * Constructor for Route class.
+     *
+     * @param match A callback function that determines whether the
+     * route matches a given `fetch` event by returning a truthy value.
+     * @param handler A callback function that returns a `Promise` resolving
+     * to a `Response`.
+     * @param method The HTTP method to match the route against. Defaults
+     * to `GET`.
+     */
+    constructor(match: RouteMatchCallback, handler: RouteHandler, method?: HTTPMethod);
+    /**
+     *
+     * @param handler A callback function that returns a Promise resolving
+     * to a Response.
+     */
+    setCatchHandler(handler: RouteHandler): void;
+}
+/**
+ * A class that makes it easy to create a {@linkcode Route} object with a regular expression.
+ *
+ * For same-origin requests the `RegExp` only needs to match part of the URL. For
+ * requests against third-party servers, you must define a `RegExp` that matches
+ * the start of the URL.
+ */
+export declare class RegExpRoute extends Route {
+    /**
+     * If the regular expression contains
+     * [capture groups](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#grouping-back-references),
+     * the captured values will be passed to the `params` argument.
+     *
+     * @param regExp The regular expression to match against URLs.
+     * @param handler A callback function that returns a `Promise` resulting in a `Response`.
+     * @param method The HTTP method to match the {@linkcode Route} against. Defaults to `GET`.
+     * against.
+     */
+    constructor(regExp: RegExp, handler: RouteHandler, method?: HTTPMethod);
+}
+export interface NavigationRouteMatchOptions {
+    /**
+     * If any of these patterns
+     * match the URL's pathname and search parameter, the route will handle the
+     * request (assuming the denylist doesn't match).
+     *
+     * @default [/./]
+     */
+    allowlist?: RegExp[];
+    /**
+     * If any of these patterns match, the route will not handle the request (even if a allowlist RegExp matches).
+     */
+    denylist?: RegExp[];
+}
+/**
+ * A class that makes it easy to create a {@linkcode Route} object that matches navigation requests.
+ *
+ * It will only match incoming requests whose [`mode`](https://fetch.spec.whatwg.org/#concept-request-mode) is set to `"navigate"`.
+ *
+ * You can optionally only apply this route to a subset of navigation requests
+ * by using one or both of the `denylist` and `allowlist` parameters.
+ */
+export declare class NavigationRoute extends Route {
+    private readonly _allowlist;
+    private readonly _denylist;
+    /**
+     * If both `denylist` and `allowlist` are provided, `denylist` will
+     * take precedence.
+     *
+     * The regular expressions in `allowlist` and `denylist`
+     * are matched against the concatenated
+     * [`pathname`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/pathname)
+     * and [`search`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/search)
+     * portions of the requested URL.
+     *
+     * *Note*: These RegExps may be evaluated against every destination URL during
+     * a navigation. Avoid using
+     * [complex RegExps](https://github.com/GoogleChrome/workbox/issues/3077),
+     * or else your users may see delays when navigating your site.
+     *
+     * @param handler A callback function that returns a `Promise` resulting in a `Response`.
+     * @param options
+     */
+    constructor(handler: RouteHandler, { allowlist, denylist }?: NavigationRouteMatchOptions);
+    /**
+     * Routes match handler.
+     *
+     * @param options
+     * @returns
+     * @private
+     */
+    private _match;
+}
+//# sourceMappingURL=route.d.ts.map

package/dist/lib/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../src/lib/route.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,kBAAkB,EAA6B,MAAM,YAAY,CAAC;AAElH;;;;;;GAMG;AACH,qBAAa,KAAK;IAChB,OAAO,EAAE,kBAAkB,CAAC;IAC5B,KAAK,EAAE,kBAAkB,CAAC;IAC1B,MAAM,EAAE,UAAU,CAAC;IACnB,YAAY,CAAC,EAAE,kBAAkB,CAAC;IAElC;;;;;;;;;OASG;gBACS,KAAK,EAAE,kBAAkB,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,GAAE,UAA0B;IAqBhG;;;;OAIG;IACH,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;CAG7C;AAED;;;;;;GAMG;AACH,qBAAa,WAAY,SAAQ,KAAK;IACpC;;;;;;;;;OASG;gBACS,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,UAAU;CAyCvE;AAED,MAAM,WAAW,2BAA2B;IAC1C;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACxC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAW;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IAErC;;;;;;;;;;;;;;;;;OAiBG;gBACS,OAAO,EAAE,YAAY,EAAE,EAAE,SAAiB,EAAE,QAAa,EAAE,GAAE,2BAAgC;IAsBzG;;;;;;OAMG;IACH,OAAO,CAAC,MAAM;CA8Bf"}