serwist 9.1.1 → 10.0.0-preview.10

package/dist/{legacy/PrecacheController.d.ts → lib/extensions/precache/extension.d.ts}

@@ -1,119 +1,110 @@
-import type { Strategy } from "../lib/strategies/Strategy.js";
-import type { RouteHandlerCallback, SerwistPlugin } from "../types.js";
-import type { CleanupResult, InstallResult, PrecacheEntry } from "../types.js";
-interface PrecacheControllerOptions {
+import type { Serwist } from "#lib/core.js";
+import type { Extension } from "#lib/extension.js";
+import type { Strategy } from "../../strategies/Strategy.js";
+import type { RouteHandlerCallback } from "../../types.js";
+import { type PrecacheRouteOptions } from "./route.js";
+import type { PrecacheStrategyOptions } from "./strategy.js";
+export interface PrecacheEntry {
+    integrity?: string;
+    url: string;
+    revision?: string | null;
+}
+export interface PrecacheExtensionOptions {
     /**
      * The cache to use for precaching.
      */
     cacheName?: string;
     /**
-     * Plugins to use when precaching as well as responding to fetch
-     * events for precached assets.
-     */
-    plugins?: SerwistPlugin[];
-    /**
-     * Whether to attempt to get the response from the network if there's
-     * a precache miss.
+     * Whether outdated caches should be removed.
+     *
+     * @default false
      */
-    fallbackToNetwork?: boolean;
+    cleanupOutdatedCaches?: boolean;
     /**
      * The number of precache requests that should be made concurrently.
      *
-     * @default 1
+     * @default 10
+     */
+    concurrency?: number;
+    /**
+     * 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`.
      */
-    concurrentPrecaching?: number;
+    navigateFallbackDenylist?: RegExp[];
 }
-/**
- * Performs efficient precaching of assets.
- * @deprecated
- */
-export declare class PrecacheController {
-    private _installAndActiveListenersAdded?;
-    private _concurrentPrecaching;
-    private readonly _strategy;
+export interface PrecacheOptions extends PrecacheStrategyOptions, PrecacheRouteOptions, PrecacheExtensionOptions {
+    entries: (PrecacheEntry | string)[] | undefined;
+}
+export declare class Precache implements Extension {
     private readonly _urlsToCacheKeys;
     private readonly _urlsToCacheModes;
     private readonly _cacheKeysToIntegrities;
+    private readonly _strategy;
+    private _options;
+    private _routeOptions;
     /**
-     * Create a new PrecacheController.
+     * Create a new {@linkcode Precache} instance.
      *
      * @param options
      */
-    constructor({ cacheName, plugins, fallbackToNetwork, concurrentPrecaching }?: PrecacheControllerOptions);
+    constructor(precacheOptions: PrecacheOptions);
     /**
      * The strategy created by this controller and
      * used to cache assets and respond to `fetch` events.
      */
     get strategy(): Strategy;
     /**
-     * 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.
-     *
-     * @param entries Array of entries to precache.
-     */
-    precache(entries: (PrecacheEntry | string)[]): void;
-    /**
-     * This method will add items to the precache list, removing duplicates
-     * and ensuring the information is valid.
+     * Adds items to the cache list, removing duplicates and ensuring the information is valid.
      *
      * @param entries Array of entries to precache.
      */
     addToCacheList(entries: (PrecacheEntry | string)[]): void;
-    /**
-     * Precaches new and updated assets. Call this method from the service worker
-     * install event.
-     *
-     * Note: this method calls `event.waitUntil()` for you, so you do not need
-     * to call it yourself in your event handlers.
-     *
-     * @param event
-     * @returns
-     */
-    install(event: ExtendableEvent): Promise<InstallResult>;
-    /**
-     * Deletes assets that are no longer present in the current precache manifest.
-     * Call this method from the service worker activate event.
-     *
-     * Note: this method calls `event.waitUntil()` for you, so you do not need
-     * to call it yourself in your event handlers.
-     *
-     * @param event
-     * @returns
-     */
-    activate(event: ExtendableEvent): Promise<CleanupResult>;
+    init({ serwist }: {
+        serwist: Serwist;
+    }): void;
+    install({ event }: {
+        event: ExtendableEvent;
+    }): Promise<void>;
+    activate(): Promise<void>;
     /**
      * Returns a mapping of a precached URL to the corresponding cache key, taking
      * into account the revision information for the URL.
      *
      * @returns A URL to cache key mapping.
      */
-    getURLsToCacheKeys(): Map<string, string>;
+    getUrlsToPrecacheKeys(): Map<string, string>;
     /**
      * Returns a list of all the URLs that have been precached by the current
      * service worker.
      *
      * @returns The precached URLs.
      */
-    getCachedURLs(): string[];
+    getPrecachedUrls(): string[];
     /**
      * Returns the cache key used for storing a given URL. If that URL is
-     * unversioned, like `/index.html', then the cache key will be the original
+     * unversioned, like "/index.html", then the cache key will be the original
      * URL with a search parameter appended to it.
      *
      * @param url A URL whose cache key you want to look up.
      * @returns The versioned URL that corresponds to a cache key
      * for the original URL, or undefined if that URL isn't precached.
      */
-    getCacheKeyForURL(url: string): string | undefined;
+    getPrecacheKeyForUrl(url: string): string | undefined;
     /**
      * @param url A cache key whose SRI you want to look up.
      * @returns The subresource integrity associated with the cache key,
      * or undefined if it's not set.
      */
-    getIntegrityForCacheKey(cacheKey: string): string | undefined;
+    getIntegrityForPrecacheKey(cacheKey: string): string | undefined;
     /**
      * This acts as a drop-in replacement for
      * [`cache.match()`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/match)
@@ -140,7 +131,6 @@ export declare class PrecacheController {
      * @param url The precached URL which will be used to lookup the response.
      * @return
      */
-    createHandlerBoundToURL(url: string): RouteHandlerCallback;
+    createHandlerBoundToUrl(url: string): RouteHandlerCallback;
 }
-export {};
-//# sourceMappingURL=PrecacheController.d.ts.map
+//# sourceMappingURL=extension.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extension.d.ts","sourceRoot":"","sources":["../../../../src/lib/extensions/precache/extension.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AASnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAG3D,OAAO,EAAiB,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACtE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAG7D,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,wBAAwB;IACvC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;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,MAAM,WAAW,eAAgB,SAAQ,uBAAuB,EAAE,oBAAoB,EAAE,wBAAwB;IAC9G,OAAO,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,GAAG,SAAS,CAAC;CACjD;AAED,qBAAa,QAAS,YAAW,SAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAkC;IACnE,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA6G;IAC/I,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAkC;IAC1E,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IACrC,OAAO,CAAC,QAAQ,CAA2B;IAC3C,OAAO,CAAC,aAAa,CAAuB;IAE5C;;;;OAIG;gBACS,eAAe,EAAE,eAAe;IAQ5C;;;OAGG;IACH,IAAI,QAAQ,IAAI,QAAQ,CAEvB;IAED;;;;OAIG;IACH,cAAc,CAAC,OAAO,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,GAAG,IAAI;IAwDzD,IAAI,CAAC,EAAE,OAAO,EAAE,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI;IAcvC,OAAO,CAAC,EAAE,KAAK,EAAE,EAAE;QAAE,KAAK,EAAE,eAAe,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA8B7D,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAmB/B;;;;;OAKG;IACH,qBAAqB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAI5C;;;;;OAKG;IACH,gBAAgB,IAAI,MAAM,EAAE;IAI5B;;;;;;;;OAQG;IACH,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAKrD;;;;OAIG;IACH,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIhE;;;;;;;;;;;;;;;;;OAiBG;IACG,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IAU7E;;;;;;OAMG;IACH,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB;CAY3D"}

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

@@ -0,0 +1,26 @@
+import type { Precache, PrecacheOptions } from "./extension.js";
+import { PrecacheCacheKeyPlugin } from "./plugin-cache-key.js";
+export declare const parsePrecacheOptions: (controller: Precache, { entries, cacheName, plugins, fetchOptions, matchOptions, fallbackToNetwork, directoryIndex, ignoreURLParametersMatching, cleanURLs, urlManipulation, cleanupOutdatedCaches, concurrency, navigateFallback, navigateFallbackAllowlist, navigateFallbackDenylist, }: PrecacheOptions) => {
+    entries: (string | import("./extension.js").PrecacheEntry)[];
+    strategyOptions: {
+        cacheName: string;
+        plugins: (import("../../types.js").StrategyPlugin | PrecacheCacheKeyPlugin)[];
+        fetchOptions: RequestInit | undefined;
+        matchOptions: CacheQueryOptions | undefined;
+        fallbackToNetwork: boolean | undefined;
+    };
+    routeOptions: {
+        directoryIndex: string | null | undefined;
+        ignoreURLParametersMatching: RegExp[] | undefined;
+        cleanURLs: boolean | undefined;
+        urlManipulation: import("../../types.js").UrlManipulation | undefined;
+    };
+    extensionOptions: {
+        cleanupOutdatedCaches: boolean | undefined;
+        concurrency: number;
+        navigateFallback: string | undefined;
+        navigateFallbackAllowlist: RegExp[] | undefined;
+        navigateFallbackDenylist: RegExp[] | undefined;
+    };
+};
+//# sourceMappingURL=options.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../../src/lib/extensions/precache/options.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAA4B,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC1F,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAI/D,eAAO,MAAM,oBAAoB,GAC/B,YAAY,QAAQ,EACpB,qQAgBG,eAAe;;;;;;;;;;;;;;;;;;;;;;CAuBlB,CAAC"}

package/dist/lib/extensions/precache/plugin-cache-key.d.ts

@@ -0,0 +1,16 @@
+import type { StrategyPlugin } from "#lib/types.js";
+import type { Precache } from "./extension.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 StrategyPlugin {
+    private readonly _precacheController;
+    constructor({ precacheController }: {
+        precacheController: Precache;
+    });
+    cacheKeyWillBeUsed: StrategyPlugin["cacheKeyWillBeUsed"];
+}
+//# sourceMappingURL=plugin-cache-key.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-cache-key.d.ts","sourceRoot":"","sources":["../../../../src/lib/extensions/precache/plugin-cache-key.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAA+B,MAAM,eAAe,CAAC;AACjF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C;;;;;GAKG;AACH,qBAAa,sBAAuB,YAAW,cAAc;IAC3D,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAW;gBAEnC,EAAE,kBAAkB,EAAE,EAAE;QAAE,kBAAkB,EAAE,QAAQ,CAAA;KAAE;IAIpE,kBAAkB,EAAE,cAAc,CAAC,oBAAoB,CAAC,CAOtD;CACH"}

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

@@ -1,5 +1,5 @@
-import type { Serwist } from "../../Serwist.js";
-import type { HandlerDidErrorCallbackParam, SerwistPlugin } 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.
@@ -30,7 +30,7 @@ export interface PrecacheFallbackPluginOptions {
  * and returning a precached response, taking the expected revision parameter
  * into account automatically.
  */
-export declare class PrecacheFallbackPlugin implements SerwistPlugin {
+export declare class PrecacheFallbackPlugin implements StrategyPlugin {
     private readonly _fallbackUrls;
     private readonly _serwist;
     /**
@@ -46,4 +46,4 @@ export declare class PrecacheFallbackPlugin implements SerwistPlugin {
      */
     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;IAMpE;;;;OAIG;IACG,eAAe,CAAC,KAAK,EAAE,4BAA4B;CA0B1D"}

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

@@ -0,0 +1,14 @@
+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.
+ *
+ * @private
+ */
+export declare class PrecacheInstallReportPlugin implements StrategyPlugin {
+    updatedURLs: string[];
+    notUpdatedURLs: string[];
+    handlerWillStart: StrategyPlugin["handlerWillStart"];
+    cachedResponseWillBeUsed: StrategyPlugin["cachedResponseWillBeUsed"];
+}
+//# 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/lib/{strategies/PrecacheStrategy.d.ts → extensions/precache/strategy.d.ts}

@@ -1,7 +1,7 @@
-import type { SerwistPlugin } from "../../types.js";
-import type { StrategyOptions } from "./Strategy.js";
-import { Strategy } from "./Strategy.js";
-import type { StrategyHandler } from "./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.
@@ -22,8 +22,8 @@ export interface PrecacheStrategyOptions extends StrategyOptions {
  */
 export declare class PrecacheStrategy extends Strategy {
     private readonly _fallbackToNetwork;
-    static readonly defaultPrecacheCacheabilityPlugin: SerwistPlugin;
-    static readonly copyRedirectedCacheableResponsesPlugin: SerwistPlugin;
+    static readonly defaultPrecacheCacheabilityPlugin: StrategyPlugin;
+    static readonly copyRedirectedCacheableResponsesPlugin: StrategyPlugin;
     /**
      * @param options
      */
@@ -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/lib/extensions/runtime-cache.d.ts

@@ -0,0 +1,71 @@
+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;
+}
+export interface WarmRuntimeCacheOptions {
+    concurrency?: number;
+}
+export interface FallbackEntry extends PrecacheFallbackEntry {
+}
+export interface FallbacksOptions {
+    /**
+     * A list of fallback entries.
+     */
+    entries: FallbackEntry[];
+}
+export interface RuntimeCacheOptions {
+    /**
+     * URLs that should be cached as the service worker is installed.
+     */
+    warmEntries?: (WarmRuntimeCacheEntry | string | Request)[];
+    /**
+     * Options for `warmEntries`.
+     */
+    warmOptions?: WarmRuntimeCacheOptions;
+    /**
+     * Precaches routes so that they can be used as a fallback when
+     * a {@linkcode Strategy} fails to generate a response.
+     *
+     * Note: This option mutates `runtimeCaching`. It also expects the URLs
+     * defined in `entries` to have been precached beforehand.
+     */
+    fallbacks?: FallbacksOptions;
+}
+export declare class RuntimeCache implements Extension {
+    _entries: RuntimeCaching[];
+    _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
+     * regardless of whether an older version of the request is in the cache.
+     *
+     * The input can be a string or a [Request](https://developer.mozilla.org/en-US/docs/Web/API/Request).
+     *
+     * @example
+     * ```js
+     * // For unrevisioned assets that should always be downloaded
+     * // with every service worker update, use this method.
+     * serwist.warmRuntimeCache([
+     *   "/scripts/main.js',
+     *   "/images/default-avater.png",
+     *   new Request("/images/logo.png"),
+     *   new Request("/api/data.json"),
+     * ]);
+     * ```
+     * @param entries A set of urls to cache when the service worker is installed.
+     */
+    warmRuntimeCache(entries: (WarmRuntimeCacheEntry | string | Request)[]): void;
+}
+//# 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,11 +1,11 @@
-import type { SerwistPlugin } 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.
  *
  * It does this by intercepting the `cachedResponseWillBeUsed` plugin callback
  * and returning the appropriate subset of the cached response body.
  */
-export declare class RangeRequestsPlugin implements SerwistPlugin {
+export declare class RangeRequestsPlugin implements StrategyPlugin {
     /**
      * @param options
      * @returns If request contains a `Range` header, then a
@@ -13,6 +13,6 @@ export declare class RangeRequestsPlugin implements SerwistPlugin {
      * returned. Otherwise, `cachedResponse` is returned as-is.
      * @private
      */
-    cachedResponseWillBeUsed: SerwistPlugin["cachedResponseWillBeUsed"];
+    cachedResponseWillBeUsed: StrategyPlugin["cachedResponseWillBeUsed"];
 }
 //# sourceMappingURL=RangeRequestsPlugin.d.ts.map

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"}