serwist 9.1.1 → 10.0.0-preview.10

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

@@ -1 +0,0 @@
-{"version":3,"file":"PrecacheController.d.ts","sourceRoot":"","sources":["../../src/legacy/PrecacheController.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAe/E,UAAU,yBAAyB;IACjC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC;IAC1B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;;GAGG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,+BAA+B,CAAC,CAAU;IAClD,OAAO,CAAC,qBAAqB,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IACrC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAkC;IACnE,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA6G;IAC/I,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAkC;IAE1E;;;;OAIG;gBACS,EAAE,SAAS,EAAE,OAAY,EAAE,iBAAwB,EAAE,oBAAwB,EAAE,GAAE,yBAA8B;IAY3H;;;OAGG;IACH,IAAI,QAAQ,IAAI,QAAQ,CAEvB;IAED;;;;;;;;OAQG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,GAAG,IAAI;IAUnD;;;;;OAKG;IACH,cAAc,CAAC,OAAO,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,GAAG,IAAI;IAwDzD;;;;;;;;;OASG;IACH,OAAO,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,aAAa,CAAC;IAmCvD;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,aAAa,CAAC;IAuBxD;;;;;OAKG;IACH,kBAAkB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAIzC;;;;;OAKG;IACH,aAAa,IAAI,MAAM,EAAE;IAIzB;;;;;;;;OAQG;IACH,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAKlD;;;;OAIG;IACH,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI7D;;;;;;;;;;;;;;;;;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/legacy/PrecacheFallbackPlugin.d.ts

@@ -1,61 +0,0 @@
-import type { HandlerDidErrorCallbackParam, SerwistPlugin } from "../types.js";
-import type { PrecacheController } from "./PrecacheController.js";
-/**
- * @deprecated
- */
-export interface PrecacheFallbackEntry {
-    /**
-     * 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;
-}
-/**
- * @deprecated
- */
-export interface PrecacheFallbackPluginOptions {
-    /**
-     * Precached URLs to be used as the fallback
-     * if the associated strategy can't generate a response.
-     */
-    fallbackUrls: (string | PrecacheFallbackEntry)[];
-    /**
-     * An optional {@linkcode PrecacheController} instance. If not provided,
-     * the default {@linkcode PrecacheController} will be used.
-     */
-    precacheController?: PrecacheController;
-}
-/**
- * A class that allows you to specify offline fallbacks
- * to be used when a given strategy is unable to generate a response.
- *
- * It does this by intercepting the `handlerDidError` plugin callback
- * and returning a precached response, taking the expected revision parameter
- * into account automatically.
- *
- * Unless you explicitly pass in a {@linkcode PrecacheController} instance to the
- * constructor, the default instance will be used.
- *
- * @deprecated
- */
-export declare class PrecacheFallbackPlugin implements SerwistPlugin {
-    private readonly _fallbackUrls;
-    private readonly _precacheController;
-    /**
-     * Constructs a new instance with the associated `fallbackUrls`.
-     *
-     * @param config
-     */
-    constructor({ fallbackUrls, precacheController }: PrecacheFallbackPluginOptions);
-    /**
-     * @returns The precache response for one of the fallback URLs, or `undefined` if
-     * nothing satisfies the conditions.
-     * @private
-     */
-    handlerDidError(param: HandlerDidErrorCallbackParam): Promise<Response | undefined>;
-}
-//# sourceMappingURL=PrecacheFallbackPlugin.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"PrecacheFallbackPlugin.d.ts","sourceRoot":"","sources":["../../src/legacy/PrecacheFallbackPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,4BAA4B,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC/E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAGlE;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,OAAO,EAAE,CAAC,KAAK,EAAE,4BAA4B,KAAK,OAAO,CAAC;IAC1D;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,YAAY,EAAE,CAAC,MAAM,GAAG,qBAAqB,CAAC,EAAE,CAAC;IACjD;;;OAGG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;CACzC;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,sBAAuB,YAAW,aAAa;IAC1D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqC;IACnE,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqB;IAEzD;;;;OAIG;gBACS,EAAE,YAAY,EAAE,kBAAkB,EAAE,EAAE,6BAA6B;IAK/E;;;;OAIG;IACG,eAAe,CAAC,KAAK,EAAE,4BAA4B;CAgB1D"}

package/dist/legacy/PrecacheRoute.d.ts

@@ -1,19 +0,0 @@
-import { Route } from "../Route.js";
-import type { PrecacheRouteOptions } from "../types.js";
-import type { PrecacheController } from "./PrecacheController.js";
-/**
- * A subclass of {@linkcode Route} that takes a {@linkcode PrecacheController}
- * instance and uses it to match incoming requests and handle fetching
- * responses from the precache.
- * @deprecated
- */
-export declare class PrecacheRoute extends Route {
-    /**
-     * @param precacheController A {@linkcode 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(precacheController: PrecacheController, options?: PrecacheRouteOptions);
-}
-//# sourceMappingURL=PrecacheRoute.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"PrecacheRoute.d.ts","sourceRoot":"","sources":["../../src/legacy/PrecacheRoute.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAIxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;GAKG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC;;;;;OAKG;gBACS,kBAAkB,EAAE,kBAAkB,EAAE,OAAO,CAAC,EAAE,oBAAoB;CAkBnF"}

package/dist/legacy/Router.d.ts

@@ -1,151 +0,0 @@
-import type { Route } from "../Route.js";
-import type { HTTPMethod } from "../constants.js";
-import type { RouteHandler, RouteHandlerCallbackOptions, RouteMatchCallback, RouteMatchCallbackOptions } from "../types.js";
-/**
- * A class that can be used to process a `fetch` event using one or more route(s), responding with a response
- * if a matching route exists.
- *
- * If no route matches given a request, the router will use the default handler if one is defined.
- *
- * Should the matching route throw an error, the router will use the catch handler if one is defined to
- * gracefully deal with issues and respond with a response.
- *
- * If a request matches multiple routes, the earliest registered route will be used to respond to the it.
- * @deprecated
- */
-export declare class Router {
-    private readonly _routes;
-    private readonly _defaultHandlerMap;
-    private _fetchListenerHandler;
-    private _cacheListenerHandler;
-    private _catchHandler?;
-    /**
-     * Initializes a new Router.
-     */
-    constructor();
-    /**
-     * @returns routes A `Map` of HTTP method name (`'GET'`, etc.) to an array of all
-     * the corresponding {@linkcode Route} instances that are registered.
-     */
-    get routes(): Map<HTTPMethod, Route[]>;
-    /**
-     * Adds a `fetch` event listener to respond to events when a route matches
-     * the event's request. Effectively no-op if `addFetchListener` has been
-     * called, but `removeFetchListener` has not.
-     */
-    addFetchListener(): void;
-    /**
-     * Removes `fetch` event listener added by `addFetchListener`.
-     * Effectively no-op if either `addFetchListener` has not been called or,
-     * if it has, so has `removeFetchListener`.
-     */
-    removeFetchListener(): void;
-    /**
-     * Adds a `message` event listener for URLs to cache from the window.
-     * This is useful to cache resources loaded on the page prior to when the
-     * service worker started controlling it. Effectively no-op if `addCacheListener`
-     * has been called, but `removeCacheListener` hasn't.
-     *
-     * The format of the message data sent from the window should be as follows.
-     * Where the `urlsToCache` array may consist of URL strings or an array of
-     * URL string + `requestInit` object (the same as you'd pass to `fetch()`).
-     *
-     * ```
-     * {
-     *   type: 'CACHE_URLS',
-     *   payload: {
-     *     urlsToCache: [
-     *       './script1.js',
-     *       './script2.js',
-     *       ['./script3.js', {mode: 'no-cors'}],
-     *     ],
-     *   },
-     * }
-     * ```
-     */
-    addCacheListener(): void;
-    /**
-     * Removes the `message` event listener added by `addCacheListener`.
-     * Effectively no-op if either `addCacheListener` has not been called or,
-     * if it has, so has `removeCacheListener`.
-     */
-    removeCacheListener(): void;
-    /**
-     * Apply the routing rules to a `fetch` event 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 `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"];
-    };
-    /**
-     * 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 {@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.
-     */
-    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 from the router.
-     *
-     * @param route The route to unregister.
-     */
-    unregisterRoute(route: Route): void;
-}
-//# sourceMappingURL=Router.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Router.d.ts","sourceRoot":"","sources":["../../src/legacy/Router.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,OAAO,KAAK,EAAE,YAAY,EAAE,2BAA2B,EAAsB,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAmBhJ;;;;;;;;;;;GAWG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;IACnD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAsC;IACzE,OAAO,CAAC,qBAAqB,CAA2C;IACxE,OAAO,CAAC,qBAAqB,CAAuD;IACpF,OAAO,CAAC,aAAa,CAAC,CAAqB;IAE3C;;OAEG;;IAMH;;;OAGG;IACH,IAAI,MAAM,IAAI,GAAG,CAAC,UAAU,EAAE,KAAK,EAAE,CAAC,CAErC;IAED;;;;OAIG;IACH,gBAAgB,IAAI,IAAI;IAaxB;;;;OAIG;IACH,mBAAmB,IAAI,IAAI;IAO3B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,gBAAgB,IAAI,IAAI;IAiCxB;;;;OAIG;IACH,mBAAmB,IAAI,IAAI;IAM3B;;;;;;;;OAQG;IACH,aAAa,CAAC,EACZ,OAAO,EACP,KAAK,GACN,EAAE;QACD;;WAEG;QACH,OAAO,EAAE,OAAO,CAAC;QACjB;;WAEG;QACH,KAAK,EAAE,eAAe,CAAC;KACxB,GAAG,OAAO,CAAC,QAAQ,CAAC,GAAG,SAAS;IA8HjC;;;;;;;;OAQG;IACH,iBAAiB,CAAC,EAAE,GAAG,EAAE,UAAU,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,yBAAyB,GAAG;QACjF,KAAK,CAAC,EAAE,KAAK,CAAC;QACd,MAAM,CAAC,EAAE,2BAA2B,CAAC,QAAQ,CAAC,CAAC;KAChD;IA+CD;;;;;;;;;;;;OAYG;IACH,iBAAiB,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,GAAE,UAA0B,GAAG,IAAI;IAIlF;;;;;;OAMG;IACH,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAI5C;;;;;;;;;OASG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,kBAAkB,GAAG,KAAK,EAAE,OAAO,CAAC,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,UAAU,GAAG,KAAK;IAM1H;;;;OAIG;IACH,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IA+CjC;;;;OAIG;IACH,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;CAcpC"}

package/dist/legacy/addPlugins.d.ts

@@ -1,9 +0,0 @@
-import type { SerwistPlugin } from "../types.js";
-/**
- * Adds plugins to the precaching strategy.
- *
- * @param plugins
- * @deprecated
- */
-export declare const addPlugins: (plugins: SerwistPlugin[]) => void;
-//# sourceMappingURL=addPlugins.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"addPlugins.d.ts","sourceRoot":"","sources":["../../src/legacy/addPlugins.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,SAAS,aAAa,EAAE,KAAG,IAGrD,CAAC"}

package/dist/legacy/addRoute.d.ts

@@ -1,14 +0,0 @@
-import type { PrecacheRouteOptions } from "../types.js";
-/**
- * Add a `fetch` listener that will
- * respond to [network requests](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests)
- * with precached assets to the service worker.
- *
- * As for requests for assets that aren't precached, the `fetch` event will not be
- * responded to, allowing the event to fall through to other `fetch` event listeners.
- *
- * @param options See {@linkcode PrecacheRouteOptions}.
- * @deprecated
- */
-export declare const addRoute: (options?: PrecacheRouteOptions) => void;
-//# sourceMappingURL=addRoute.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"addRoute.d.ts","sourceRoot":"","sources":["../../src/legacy/addRoute.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAKxD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,QAAQ,GAAI,UAAU,oBAAoB,KAAG,IAGzD,CAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/legacy/constants.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,UAAU,6BAA6B,CAAC;AACrD,eAAO,MAAM,kBAAkB,QAAU,CAAC;AAC1C,eAAO,MAAM,qBAAqB,6BAA6B,CAAC;AAChE,eAAO,MAAM,QAAQ,6BAA6B,CAAC;AACnD,eAAO,MAAM,iBAAiB,kBAAkB,CAAC;AACjD,eAAO,MAAM,YAAY,aAAa,CAAC;AACvC,eAAO,MAAM,WAAW,YAAY,CAAC;AACrC,eAAO,MAAM,oBAAoB,aAAa,CAAC;AAM/C,eAAO,MAAM,mBAAmB,QAAuB,CAAC"}

package/dist/legacy/createHandlerBoundToURL.d.ts

@@ -1,17 +0,0 @@
-import type { RouteHandlerCallback } from "../types.js";
-/**
- * Helper function that calls {@linkcode PrecacheController.createHandlerBoundToURL}
- * on the default {@linkcode PrecacheController} instance.
- *
- * If you are creating your own {@linkcode PrecacheController}, then call the
- * {@linkcode PrecacheController.createHandlerBoundToURL} function on that instance
- * instead of using this function.
- *
- * @param url The precached URL which will be used to look up the response.
- * @param fallbackToNetwork Whether to attempt to get the
- * response from the network if there's a precache miss.
- * @return
- * @deprecated
- */
-export declare const createHandlerBoundToURL: (url: string) => RouteHandlerCallback;
-//# sourceMappingURL=createHandlerBoundToURL.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createHandlerBoundToURL.d.ts","sourceRoot":"","sources":["../../src/legacy/createHandlerBoundToURL.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAIxD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uBAAuB,GAAI,KAAK,MAAM,KAAG,oBAGrD,CAAC"}

package/dist/legacy/fallbacks.d.ts

@@ -1,59 +0,0 @@
-import type { PrecacheRouteOptions, RuntimeCaching } from "../types.js";
-import type { PrecacheController } from "./PrecacheController.js";
-import type { PrecacheFallbackEntry } from "./PrecacheFallbackPlugin.js";
-import type { Router } from "./Router.js";
-export interface FallbackEntry extends PrecacheFallbackEntry {
-    /**
-     * The revision used for precaching.
-     */
-    revision: string;
-}
-export interface FallbacksOptions {
-    /**
-     * A list of fallback entries.
-     */
-    entries: FallbackEntry[];
-    /**
-     * Precache options that will be used for your
-     * fallback entries.
-     */
-    precacheOptions?: PrecacheRouteOptions;
-}
-export interface FallbacksOptions {
-    /**
-     * An optional {@linkcode PrecacheController} instance. If not provided, the singleton
-     * {@linkcode PrecacheController} will be used.
-     */
-    precacheController?: PrecacheController;
-    /**
-     * An optional {@linkcode Router} instance. If not provided, the singleton {@linkcode Router}
-     * will be used.
-     */
-    router?: Router;
-    /**
-     * Your previous list of caching strategies.
-     */
-    runtimeCaching: RuntimeCaching[];
-    /**
-     * A list of fallback entries.
-     */
-    entries: FallbackEntry[];
-    /**
-     * Precache options that will be used for your
-     * fallback entries.
-     */
-    precacheOptions?: PrecacheRouteOptions;
-}
-/**
- * Precaches routes so that they can be used as a fallback when
- * a Strategy fails to generate a response.
- *
- * Note: This function mutates `runtimeCaching`. It also precaches the URLs
- * defined in `entries`, so you must NOT precache any of them beforehand.
- *
- * @param options
- * @returns The modified `runtimeCaching` array.
- * @deprecated
- */
-export declare const fallbacks: ({ precacheController, router, runtimeCaching, entries, precacheOptions, }: FallbacksOptions) => RuntimeCaching[];
-//# sourceMappingURL=fallbacks.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"fallbacks.d.ts","sourceRoot":"","sources":["../../src/legacy/fallbacks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAEzE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAI1C,MAAM,WAAW,aAAc,SAAQ,qBAAqB;IAC1D;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB;;;OAGG;IACH,eAAe,CAAC,EAAE,oBAAoB,CAAC;CACxC;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,cAAc,EAAE,cAAc,EAAE,CAAC;IACjC;;OAEG;IACH,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB;;;OAGG;IACH,eAAe,CAAC,EAAE,oBAAoB,CAAC;CACxC;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,GAAI,2EAMvB,gBAAgB,KAAG,cAAc,EAqBnC,CAAC"}

package/dist/legacy/getCacheKeyForURL.d.ts

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

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

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

package/dist/legacy/handlePrecaching.d.ts

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

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

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

package/dist/legacy/initializeGoogleAnalytics.d.ts

@@ -1,38 +0,0 @@
-import type { Router } from "./Router.js";
-/**
- * @deprecated
- */
-export interface GoogleAnalyticsInitializeOptions {
-    /**
-     * An optional {@linkcode Router} instance. If not provided, the singleton {@linkcode Router}
-     * will be used.
-     */
-    router?: Router;
-    /**
-     * The cache name to store and retrieve analytics.js. Defaults to Serwist's default cache names.
-     */
-    cacheName?: string;
-    /**
-     * [Measurement Protocol parameters](https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters),
-     * expressed as key/value pairs, to be added to replayed Google Analytics
-     * requests. This can be used to, e.g., set a custom dimension indicating
-     * that the request was replayed.
-     */
-    parameterOverrides?: {
-        [paramName: string]: string;
-    };
-    /**
-     * A function that allows you to modify the hit parameters prior to replaying
-     * the hit. The function is invoked with the original hit's URLSearchParams
-     * object as its only argument.
-     */
-    hitFilter?: (params: URLSearchParams) => void;
-}
-/**
- * Initialize Serwist's offline Google Analytics v3 support.
- *
- * @param options
- * @deprecated Use `serwist.initializeGoogleAnalytics` instead.
- */
-export declare const initializeGoogleAnalytics: ({ router, cacheName, ...options }?: GoogleAnalyticsInitializeOptions) => void;
-//# sourceMappingURL=initializeGoogleAnalytics.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"initializeGoogleAnalytics.d.ts","sourceRoot":"","sources":["../../src/legacy/initializeGoogleAnalytics.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAa1C;;GAEG;AACH,MAAM,WAAW,gCAAgC;IAC/C;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE;QAAE,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IACrD;;;;OAIG;IACH,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;CAC/C;AAyID;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,GAAI,oCAA0D,gCAAqC,KAAG,IAkB3I,CAAC"}

package/dist/legacy/installSerwist.d.ts

@@ -1,81 +0,0 @@
-import type { RuntimeCaching } from "../types.js";
-import type { PrecacheController } from "./PrecacheController.js";
-import type { Router } from "./Router.js";
-import type { FallbacksOptions } from "./fallbacks.js";
-import { type HandlePrecachingOptions } from "./handlePrecaching.js";
-import type { GoogleAnalyticsInitializeOptions } from "./initializeGoogleAnalytics.js";
-/**
- * Options for {@linkcode installSerwist}.
- *
- * @deprecated
- */
-export interface InstallSerwistOptions extends Omit<HandlePrecachingOptions, "precacheController" | "router"> {
-    /**
-     * An optional {@linkcode PrecacheController} instance. If not provided, the singleton
-     * {@linkcode PrecacheController} will be used.
-     */
-    precacheController?: PrecacheController;
-    /**
-     * An optional {@linkcode Router} instance. If not provided, the singleton {@linkcode Router}
-     * will be used.
-     */
-    router?: Router;
-    /**
-     * 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.
-     */
-    runtimeCaching?: RuntimeCaching[];
-    /**
-     * Your configuration for `@serwist/google-analytics`. This plugin is
-     * only initialized when this option is not `undefined` or `false`.
-     */
-    offlineAnalyticsConfig?: GoogleAnalyticsInitializeOptions | 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.
-     */
-    fallbacks?: Pick<FallbacksOptions, "entries">;
-}
-/**
- * Abstracts away the core APIs of Serwist.
- *
- * @param options - `installSerwist` options.
- * @deprecated
- */
-export declare const installSerwist: ({ precacheController, router, precacheEntries, precacheOptions, cleanupOutdatedCaches, navigateFallback, navigateFallbackAllowlist, navigateFallbackDenylist, skipWaiting, importScripts, navigationPreload, cacheId, clientsClaim, runtimeCaching, offlineAnalyticsConfig, disableDevLogs, fallbacks, }: InstallSerwistOptions) => void;
-//# sourceMappingURL=installSerwist.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"installSerwist.d.ts","sourceRoot":"","sources":["../../src/legacy/installSerwist.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,OAAO,EAAE,KAAK,uBAAuB,EAAoB,MAAM,uBAAuB,CAAC;AAEvF,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,gCAAgC,CAAC;AAOvF;;;;GAIG;AACH,MAAM,WAAW,qBAAsB,SAAQ,IAAI,CAAC,uBAAuB,EAAE,oBAAoB,GAAG,QAAQ,CAAC;IAC3G;;;OAGG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B;;;;;OAKG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;OAEG;IACH,cAAc,CAAC,EAAE,cAAc,EAAE,CAAC;IAClC;;;OAGG;IACH,sBAAsB,CAAC,EAAE,gCAAgC,GAAG,OAAO,CAAC;IACpE;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,SAAS,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,SAAS,CAAC,CAAC;CAC/C;AAED;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,0SAkB5B,qBAAqB,KAAG,IA2D1B,CAAC"}

package/dist/legacy/matchPrecache.d.ts

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

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

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

package/dist/legacy/precache.d.ts

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

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

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

package/dist/legacy/precacheAndRoute.d.ts

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

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

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