serwist 9.0.0-preview.24

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Google LLC, 2019 ShadowWalker w@weiw.io https://weiw.io, 2023 Serwist
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+This module's documentation can be found at https://serwist.pages.dev/docs/serwist

package/dist/NavigationRoute.d.ts

@@ -0,0 +1,57 @@
+import type { RouteHandler } from "./types.js";
+import { Route } from "./Route.js";
+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[];
+}
+/**
+ * NavigationRoute makes it easy to create a `Route` that matches for browser
+ * [navigation requests](https://developers.google.com/web/fundamentals/primers/service-workers/high-performance-loading#first_what_are_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, the `denylist` will
+     * take precedence and the request will not match this route.
+     *
+     * 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=NavigationRoute.d.ts.map

package/dist/NavigationRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NavigationRoute.d.ts","sourceRoot":"","sources":["../src/NavigationRoute.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAA6B,MAAM,YAAY,CAAC;AAG1E,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,MAAM,WAAW,2BAA2B;IAC1C;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;;;;GAQG;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"}

package/dist/PrecacheRoute.d.ts

@@ -0,0 +1,17 @@
+import { Route } from "./Route.js";
+import type { Serwist } from "./Serwist.js";
+import type { PrecacheRouteOptions } from "./types.js";
+/**
+ * A subclass of `Route` that takes a `serwist.Serwist` instance and uses it to match
+ * incoming requests and handle fetching responses from the precache.
+ */
+export declare class PrecacheRoute extends Route {
+    /**
+     * @param serwist A `PrecacheController`
+     * instance used to both match requests and respond to fetch events.
+     * @param options Options to control how requests are matched
+     * against the list of precached URLs.
+     */
+    constructor(serwist: Serwist, options?: PrecacheRouteOptions);
+}
+//# sourceMappingURL=PrecacheRoute.d.ts.map

package/dist/PrecacheRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrecacheRoute.d.ts","sourceRoot":"","sources":["../src/PrecacheRoute.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAGvD;;;GAGG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC;;;;;OAKG;gBACS,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,oBAAoB;CAkB7D"}

package/dist/PrecacheStrategy.d.ts

@@ -0,0 +1,66 @@
+import type { SerwistPlugin } from "./types.js";
+import type { StrategyOptions } from "./strategies/Strategy.js";
+import { Strategy } from "./strategies/Strategy.js";
+import type { StrategyHandler } from "./strategies/StrategyHandler.js";
+interface PrecacheStrategyOptions extends StrategyOptions {
+    /**
+     * Whether to attempt to get the response from the network
+     * if there's a precache miss.
+     */
+    fallbackToNetwork?: boolean;
+}
+/**
+ * A `serwist/strategies.Strategy` implementation
+ * specifically designed to both cache and fetch precached assets.
+ *
+ * Note: an instance of this class is created automatically when creating a
+ * `PrecacheController`; it's generally not necessary to create this yourself.
+ */
+export declare class PrecacheStrategy extends Strategy {
+    private readonly _fallbackToNetwork;
+    static readonly defaultPrecacheCacheabilityPlugin: SerwistPlugin;
+    static readonly copyRedirectedCacheableResponsesPlugin: SerwistPlugin;
+    /**
+     * @param options
+     */
+    constructor(options?: PrecacheStrategyOptions);
+    /**
+     * @private
+     * @param request A request to run this strategy for.
+     * @param handler The event that triggered the request.
+     * @returns
+     */
+    _handle(request: Request, handler: StrategyHandler): Promise<Response>;
+    _handleFetch(request: Request, handler: StrategyHandler): Promise<Response>;
+    _handleInstall(request: Request, handler: StrategyHandler): Promise<Response>;
+    /**
+     * This method is complex, as there a number of things to account for:
+     *
+     * The `plugins` array can be set at construction, and/or it might be added to
+     * to at any time before the strategy is used.
+     *
+     * At the time the strategy is used (i.e. during an `install` event), there
+     * needs to be at least one plugin that implements `cacheWillUpdate` in the
+     * array, other than `copyRedirectedCacheableResponsesPlugin`.
+     *
+     * - If this method is called and there are no suitable `cacheWillUpdate`
+     * plugins, we need to add `defaultPrecacheCacheabilityPlugin`.
+     *
+     * - If this method is called and there is exactly one `cacheWillUpdate`, then
+     * we don't have to do anything (this might be a previously added
+     * `defaultPrecacheCacheabilityPlugin`, or it might be a custom plugin).
+     *
+     * - If this method is called and there is more than one `cacheWillUpdate`,
+     * then we need to check if one is `defaultPrecacheCacheabilityPlugin`. If so,
+     * we need to remove it. (This situation is unlikely, but it could happen if
+     * the strategy is used multiple times, the first without a `cacheWillUpdate`,
+     * and then later on after manually adding a custom `cacheWillUpdate`.)
+     *
+     * See https://github.com/GoogleChrome/workbox/issues/2737 for more context.
+     *
+     * @private
+     */
+    _useDefaultCacheabilityPluginIfNeeded(): void;
+}
+export {};
+//# sourceMappingURL=PrecacheStrategy.d.ts.map

package/dist/PrecacheStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrecacheStrategy.d.ts","sourceRoot":"","sources":["../src/PrecacheStrategy.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAMhD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAEvE,UAAU,uBAAwB,SAAQ,eAAe;IACvD;;;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,aAAa,CAQ9D;IAEF,MAAM,CAAC,QAAQ,CAAC,sCAAsC,EAAE,aAAa,CAInE;IAEF;;OAEG;gBACS,OAAO,GAAE,uBAA4B;IAajD;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAiBtE,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAwE3E,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAoBnF;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,qCAAqC,IAAI,IAAI;CA4B9C"}

package/dist/RegExpRoute.d.ts

@@ -0,0 +1,24 @@
+import type { RouteHandler } from "./types.js";
+import { Route } from "./Route.js";
+import type { HTTPMethod } from "./constants.js";
+/**
+ * `RegExpRoute` makes it easy to create a regular expression based on a `Route`.
+ *
+ * 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 Route, defaults to GET.
+     * against.
+     */
+    constructor(regExp: RegExp, handler: RouteHandler, method?: HTTPMethod);
+}
+//# sourceMappingURL=RegExpRoute.d.ts.map

package/dist/RegExpRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegExpRoute.d.ts","sourceRoot":"","sources":["../src/RegExpRoute.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAiD,MAAM,YAAY,CAAC;AAG9F,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD;;;;;;GAMG;AACH,qBAAa,WAAY,SAAQ,KAAK;IACpC;;;;;;;;;OASG;gBACS,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,UAAU;CAyCvE"}

package/dist/Route.d.ts

@@ -0,0 +1,33 @@
+import type { RouteHandler, RouteHandlerObject, RouteMatchCallback } from "./types.js";
+import type { HTTPMethod } from "./constants.js";
+/**
+ * A `Route` consists of a pair of callback functions, "match" and "handler".
+ * The "match" callback determine if a route should be used to "handle" a
+ * request by returning a non-falsy value if it can. The "handler" callback
+ * is called when there is a match 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 non-falsy 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;
+}
+//# sourceMappingURL=Route.d.ts.map

package/dist/Route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Route.d.ts","sourceRoot":"","sources":["../src/Route.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEvF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAIjD;;;;;;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"}

package/dist/Serwist.d.ts

@@ -0,0 +1,331 @@
+import type { RouteHandler, RouteHandlerCallback, RouteHandlerCallbackOptions, RouteMatchCallback, RouteMatchCallbackOptions, SerwistPlugin } from "./types.js";
+import type { Route } from "./Route.js";
+import { type HTTPMethod } from "./constants.js";
+import { type GoogleAnalyticsInitializeOptions } from "./plugins/googleAnalytics/initialize.js";
+import { type PrecacheFallbackEntry } from "./plugins/precaching/PrecacheFallbackPlugin.js";
+import { Strategy } from "./strategies/Strategy.js";
+import type { PrecacheRouteOptions, RuntimeCaching } from "./types.js";
+import type { CleanupResult, InstallResult, PrecacheEntry } from "./types.js";
+export interface FallbackEntry extends PrecacheFallbackEntry {
+}
+export interface FallbacksOptions {
+    /**
+     * A list of fallback entries.
+     */
+    entries: FallbackEntry[];
+}
+export interface PrecacheOptions extends PrecacheRouteOptions {
+    /**
+     * The cache to use for precaching.
+     */
+    cacheName?: string;
+}
+export interface SerwistOptions {
+    /**
+     * A list of URLs that should be cached.
+     */
+    precacheEntries?: (PrecacheEntry | string)[];
+    /**
+     * Options to customize how Serwist precaches the URLs in the precache list.
+     */
+    precacheOptions?: PrecacheOptions;
+    /**
+     * 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[];
+    /**
+     * 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.
+     */
+    fallbackToNetwork?: boolean;
+    /**
+     * The number of precache requests that should be made concurrently.
+     *
+     * @default 1
+     */
+    concurrentPrecaching?: number;
+    /**
+     * Forces the waiting service worker to become the active one.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope/skipWaiting
+     */
+    skipWaiting?: boolean;
+    /**
+     * Imports external scripts. They are executed in the order they
+     * are passed.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope/importScripts
+     */
+    importScripts?: string[];
+    /**
+     * Enables navigation preloading if it is supported.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerRegistration/navigationPreload
+     */
+    navigationPreload?: boolean;
+    /**
+     * Modifies the prefix of the default cache names used by Serwist packages.
+     */
+    cacheId?: string | undefined;
+    /**
+     * Claims any currently available clients once the service worker
+     * becomes active. This is normally used in conjunction with `skipWaiting()`.
+     *
+     * @default false
+     */
+    clientsClaim?: boolean;
+    /**
+     * A list of caching strategies.
+     *
+     * @see https://serwist.pages.dev/docs/sw/runtime-caching
+     */
+    runtimeCaching?: RuntimeCaching[];
+    /**
+     * Your configuration for `@serwist/google-analytics`. This plugin is
+     * only initialized when this option is not `undefined` or `false`.
+     */
+    offlineAnalyticsConfig?: Omit<GoogleAnalyticsInitializeOptions, "serwist"> | boolean;
+    /**
+     * Disables Serwist's logging in development mode.
+     *
+     * @default false
+     */
+    disableDevLogs?: boolean;
+    /**
+     * Precaches routes so that they can be used as a fallback when
+     * a Strategy fails to generate a response.
+     *
+     * Note: This option mutates `runtimeCaching`. It also precaches the URLs
+     * defined in `entries`, so you must NOT precache any of them beforehand.
+     *
+     * @see https://serwist.pages.dev/docs/sw/abstractions/fallbacks
+     */
+    fallbacks?: FallbacksOptions;
+}
+/**
+ * A class that helps bootstrap the service worker.
+ */
+export declare class Serwist {
+    private readonly _urlsToCacheKeys;
+    private readonly _urlsToCacheModes;
+    private readonly _cacheKeysToIntegrities;
+    private _concurrentPrecaching;
+    private readonly _precacheStrategy;
+    private readonly _routes;
+    private readonly _defaultHandlerMap;
+    private _catchHandler?;
+    constructor({ precacheEntries, precacheOptions, cleanupOutdatedCaches, navigateFallback, navigateFallbackAllowlist, navigateFallbackDenylist, plugins, fallbackToNetwork, concurrentPrecaching, skipWaiting, importScripts, navigationPreload, cacheId, clientsClaim, runtimeCaching, offlineAnalyticsConfig, disableDevLogs, fallbacks, }?: SerwistOptions);
+    /**
+     * The strategy created by this controller and
+     * used to cache assets and respond to fetch events.
+     */
+    get precacheStrategy(): Strategy;
+    /**
+     * A `Map` of HTTP method name (`'GET'`, etc.) to an array of all the corresponding `Route`
+     * instances that are registered.
+     */
+    get routes(): Map<HTTPMethod, Route[]>;
+    /**
+     * This function adds Serwist's event listeners for you. Before calling it, add your own listeners
+     * should you need to.
+     */
+    addEventListeners(): void;
+    /**
+     * This method will add items to the precache list, removing duplicates
+     * and ensuring the information is valid.
+     *
+     * @param entries Array of entries to precache.
+     */
+    addToPrecacheList(entries: (PrecacheEntry | string)[]): void;
+    /**
+     * Precaches new and updated assets. Call this method from the service worker's
+     * `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
+     */
+    handleInstall(event: ExtendableEvent): Promise<InstallResult>;
+    /**
+     * Deletes assets that are no longer present in the current precache manifest.
+     * Call this method from the service worker's `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
+     */
+    handleActivate(event: ExtendableEvent): Promise<CleanupResult>;
+    /**
+     * Gets a `Response` from an appropriate `Route`'s handler. Call this method
+     * from the service worker's `fetch` event.
+     * @param event
+     */
+    handleFetch(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
+     */
+    handleCache(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'`.
+     */
+    setDefaultHandler(handler: RouteHandler, method?: HTTPMethod): void;
+    /**
+     * 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.
+     */
+    setCatchHandler(handler: RouteHandler): void;
+    /**
+     * Registers a `RegExp`, string, or function with a caching
+     * strategy to the `Router`.
+     *
+     * @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`.
+     */
+    registerCapture(capture: RegExp | string | RouteMatchCallback | Route, handler?: RouteHandler, method?: HTTPMethod): Route;
+    /**
+     * Registers a `Route` with the router.
+     *
+     * @param route The `Route` to register.
+     */
+    registerRoute(route: Route): void;
+    /**
+     * Unregisters a `Route` with the `Router`.
+     *
+     * @param route The `Route` to unregister.
+     */
+    unregisterRoute(route: Route): 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.
+     */
+    getUrlsToPrecacheKeys(): Map<string, string>;
+    /**
+     * Returns a list of all the URLs that have been precached by the current
+     * service worker.
+     *
+     * @returns The precached URLs.
+     */
+    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
+     * 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.
+     */
+    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.
+     */
+    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)
+     * with the following differences:
+     *
+     * - It knows what the name of the precache is, and only checks in that cache.
+     * - It allows you to pass in an "original" URL without versioning parameters,
+     * and it will automatically look up the correct cache key for the currently
+     * active revision of that URL.
+     *
+     * E.g., `matchPrecache('index.html')` will find the correct precached
+     * response for the currently active service worker, even if the actual cache
+     * key is `'/index.html?__WB_REVISION__=1234abcd'`.
+     *
+     * @param request The key (without revisioning parameters)
+     * to look up in the precache.
+     * @returns
+     */
+    matchPrecache(request: string | Request): Promise<Response | undefined>;
+    /**
+     * Returns a function that looks up `url` in the precache (taking into
+     * account revision information), and returns the corresponding `Response`.
+     *
+     * @param url The precached URL which will be used to lookup the response.
+     * @return
+     */
+    createHandlerBoundToUrl(url: string): RouteHandlerCallback;
+    /**
+     * Apply the routing rules to a `FetchEvent` object to get a `Response` from an
+     * appropriate `Route`'s handler.
+     *
+     * @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 `defaultHandler`, `undefined`
+     * is returned.
+     */
+    handleRequest({ 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.
+     */
+    findMatchingRoute({ url, sameOrigin, request, event }: RouteMatchCallbackOptions): {
+        route?: Route;
+        params?: RouteHandlerCallbackOptions["params"];
+    };
+}
+//# sourceMappingURL=Serwist.d.ts.map

package/dist/Serwist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Serwist.d.ts","sourceRoot":"","sources":["../src/Serwist.ts"],"names":[],"mappings":"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"}

package/dist/cacheNames.d.ts

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

package/dist/cacheNames.d.ts.map

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