serwist 9.0.0-preview.24

package/dist/plugins/expiration/CacheExpiration.d.ts

@@ -0,0 +1,66 @@
+interface CacheExpirationConfig {
+    /**
+     * The maximum number of entries to cache. Entries used the least will
+     * be removed as the maximum is reached.
+     */
+    maxEntries?: number;
+    /**
+     * The maximum age of an entry before it's treated as stale and removed.
+     */
+    maxAgeSeconds?: number;
+    /**
+     * The [`CacheQueryOptions`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/delete#Parameters)
+     * that will be used when calling `delete()` on the cache.
+     */
+    matchOptions?: CacheQueryOptions;
+}
+/**
+ * Allows you to expires cached responses based on age or maximum number of entries.
+ * @see https://serwist.pages.dev/docs/expiration/cache-expiration
+ */
+export declare class CacheExpiration {
+    private _isRunning;
+    private _rerunRequested;
+    private readonly _maxEntries?;
+    private readonly _maxAgeSeconds?;
+    private readonly _matchOptions?;
+    private readonly _cacheName;
+    private readonly _timestampModel;
+    /**
+     * To construct a new CacheExpiration instance you must provide at least
+     * one of the `config` properties.
+     *
+     * @param cacheName Name of the cache to apply restrictions to.
+     * @param config
+     */
+    constructor(cacheName: string, config?: CacheExpirationConfig);
+    /**
+     * Expires entries for the given cache and given criteria.
+     */
+    expireEntries(): Promise<void>;
+    /**
+     * Updates the timestamp for the given URL, allowing it to be correctly
+     * tracked by the class.
+     *
+     * @param url
+     */
+    updateTimestamp(url: string): Promise<void>;
+    /**
+     * Checks if a URL has expired or not before it's used.
+     *
+     * This looks the timestamp up in IndexedDB and can be slow.
+     *
+     * Note: This method does not remove an expired entry, call
+     * `expireEntries()` to remove such entries instead.
+     *
+     * @param url
+     * @returns
+     */
+    isURLExpired(url: string): Promise<boolean>;
+    /**
+     * Removes the IndexedDB used to keep track of cache expiration metadata.
+     */
+    delete(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=CacheExpiration.d.ts.map

package/dist/plugins/expiration/CacheExpiration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheExpiration.d.ts","sourceRoot":"","sources":["../../../src/plugins/expiration/CacheExpiration.ts"],"names":[],"mappings":"AAaA,UAAU,qBAAqB;IAC7B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAClC;AAED;;;GAGG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAoB;IACnD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAuB;IAEvD;;;;;;OAMG;gBACS,SAAS,EAAE,MAAM,EAAE,MAAM,GAAE,qBAA0B;IA2CjE;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IA0CpC;;;;;OAKG;IACG,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAajD;;;;;;;;;;OAUG;IACG,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAejD;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAM9B"}

package/dist/plugins/expiration/ExpirationPlugin.d.ts

@@ -0,0 +1,116 @@
+import type { CacheDidUpdateCallbackParam, CachedResponseWillBeUsedCallbackParam, SerwistPlugin } from "../../types.js";
+export interface ExpirationPluginOptions {
+    /**
+     * The maximum number of entries to cache. Entries used the least will be removed
+     * as the maximum is reached.
+     */
+    maxEntries?: number;
+    /**
+     * The maximum number of seconds before an entry is treated as stale and removed.
+     */
+    maxAgeSeconds?: number;
+    /**
+     * Determines whether `maxAgeSeconds` should be calculated from when an
+     * entry was last fetched or when it was last used.
+     *
+     * @default "last-fetched"
+     */
+    maxAgeFrom?: "last-fetched" | "last-used";
+    /**
+     * The [`CacheQueryOptions`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/delete#Parameters)
+     * that will be used when calling `delete()` on the cache.
+     */
+    matchOptions?: CacheQueryOptions;
+    /**
+     * Whether to opt this cache into automatic deletion if the available storage quota has been exceeded.
+     */
+    purgeOnQuotaError?: boolean;
+}
+/**
+ * This plugin can be used in a `serwist/strategies` Strategy to regularly enforce a
+ * limit on the age and/or the number of cached requests.
+ *
+ * It can only be used with Strategy instances that have a custom `cacheName` property set.
+ * In other words, it can't be used to expire entries in strategies that use the default runtime
+ * cache name.
+ *
+ * Whenever a cached response is used or updated, this plugin will look
+ * at the associated cache and remove any old or extra responses.
+ *
+ * When using `maxAgeSeconds`, responses may be used *once* after expiring
+ * because the expiration clean up will not have occurred until *after* the
+ * cached response has been used. If the response has a "Date" header, then a lightweight expiration
+ * check is performed, and the response will not be used immediately.
+ *
+ * When using `maxEntries`, the least recently requested entry will be removed
+ * from the cache.
+ *
+ * @see https://serwist.pages.dev/docs/expiration/expiration-plugin
+ */
+export declare class ExpirationPlugin implements SerwistPlugin {
+    private readonly _config;
+    private _cacheExpirations;
+    /**
+     * @param config
+     */
+    constructor(config?: ExpirationPluginOptions);
+    /**
+     * A simple helper method to return a CacheExpiration instance for a given
+     * cache name.
+     *
+     * @param cacheName
+     * @returns
+     * @private
+     */
+    private _getCacheExpiration;
+    /**
+     * A "lifecycle" callback that will be triggered automatically by the
+     * `serwist/strategies` handlers when a `Response` is about to be returned
+     * from a [Cache](https://developer.mozilla.org/en-US/docs/Web/API/Cache) to
+     * the handler. It allows the `Response` to be inspected for freshness and
+     * prevents it from being used if the `Response`'s `Date` header value is
+     * older than the configured `maxAgeSeconds`.
+     *
+     * @param options
+     * @returns `cachedResponse` if it is fresh and `null` if it is stale or
+     * not available.
+     * @private
+     */
+    cachedResponseWillBeUsed({ event, cacheName, request, cachedResponse }: CachedResponseWillBeUsedCallbackParam): Response | null;
+    /**
+     * @param cachedResponse
+     * @returns
+     * @private
+     */
+    private _isResponseDateFresh;
+    /**
+     * Extracts the `Date` header and parse it into an useful value.
+     *
+     * @param cachedResponse
+     * @returns
+     * @private
+     */
+    private _getDateHeaderTimestamp;
+    /**
+     * A "lifecycle" callback that will be triggered automatically by the
+     * `serwist/strategies` handlers when an entry is added to a cache.
+     *
+     * @param options
+     * @private
+     */
+    cacheDidUpdate({ cacheName, request }: CacheDidUpdateCallbackParam): Promise<void>;
+    /**
+     * Deletes the underlying `Cache` instance associated with this instance and the metadata
+     * from IndexedDB used to keep track of expiration details for each `Cache` instance.
+     *
+     * When using cache expiration, calling this method is preferable to calling
+     * `caches.delete()` directly, since this will ensure that the IndexedDB
+     * metadata is also cleanly removed and that open IndexedDB instances are deleted.
+     *
+     * Note that if you're *not* using cache expiration for a given cache, calling
+     * `caches.delete()` and passing in the cache's name should be sufficient.
+     * There is no Serwist-specific method needed for cleanup in that case.
+     */
+    deleteCacheAndMetadata(): Promise<void>;
+}
+//# sourceMappingURL=ExpirationPlugin.d.ts.map

package/dist/plugins/expiration/ExpirationPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpirationPlugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/expiration/ExpirationPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,2BAA2B,EAAE,qCAAqC,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AASxH,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,cAAc,GAAG,WAAW,CAAC;IAC1C;;;OAGG;IACH,YAAY,CAAC,EAAE,iBAAiB,CAAC;IACjC;;OAEG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,gBAAiB,YAAW,aAAa;IACpD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;IAClD,OAAO,CAAC,iBAAiB,CAA+B;IAExD;;OAEG;gBACS,MAAM,GAAE,uBAA4B;IAkDhD;;;;;;;OAOG;IACH,OAAO,CAAC,mBAAmB;IAa3B;;;;;;;;;;;;OAYG;IACH,wBAAwB,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,cAAc,EAAE,EAAE,qCAAqC;IAqC7G;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAwB5B;;;;;;OAMG;IACH,OAAO,CAAC,uBAAuB;IAkB/B;;;;;;OAMG;IACG,cAAc,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,2BAA2B;IAqBxE;;;;;;;;;;;OAWG;IACG,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC;CAW9C"}

package/dist/plugins/expiration/models/CacheTimestampsModel.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Returns the timestamp model.
+ *
+ * @private
+ */
+export declare class CacheTimestampsModel {
+    private readonly _cacheName;
+    private _db;
+    /**
+     *
+     * @param cacheName
+     *
+     * @private
+     */
+    constructor(cacheName: string);
+    /**
+     * Takes a URL and returns an ID that will be unique in the object store.
+     *
+     * @param url
+     * @returns
+     * @private
+     */
+    private _getId;
+    /**
+     * Performs an upgrade of indexedDB.
+     *
+     * @param db
+     *
+     * @private
+     */
+    private _upgradeDb;
+    /**
+     * Performs an upgrade of indexedDB and deletes deprecated DBs.
+     *
+     * @param db
+     *
+     * @private
+     */
+    private _upgradeDbAndDeleteOldDbs;
+    /**
+     * @param url
+     * @param timestamp
+     *
+     * @private
+     */
+    setTimestamp(url: string, timestamp: number): Promise<void>;
+    /**
+     * Returns the timestamp stored for a given URL.
+     *
+     * @param url
+     * @returns
+     * @private
+     */
+    getTimestamp(url: string): Promise<number | undefined>;
+    /**
+     * Iterates through all the entries in the object store (from newest to
+     * oldest) and removes entries once either `maxCount` is reached or the
+     * entry's timestamp is less than `minTimestamp`.
+     *
+     * @param minTimestamp
+     * @param maxCount
+     * @returns
+     * @private
+     */
+    expireEntries(minTimestamp: number, maxCount?: number): Promise<string[]>;
+    /**
+     * Returns an open connection to the database.
+     *
+     * @private
+     */
+    private getDb;
+}
+//# sourceMappingURL=CacheTimestampsModel.d.ts.map

package/dist/plugins/expiration/models/CacheTimestampsModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheTimestampsModel.d.ts","sourceRoot":"","sources":["../../../../src/plugins/expiration/models/CacheTimestampsModel.ts"],"names":[],"mappings":"AAoCA;;;;GAIG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,GAAG,CAA4C;IAEvD;;;;;OAKG;gBACS,SAAS,EAAE,MAAM;IAI7B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM;IAId;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAYlB;;;;;;OAMG;IACH,OAAO,CAAC,yBAAyB;IAOjC;;;;;OAKG;IACG,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBjE;;;;;;OAMG;IACG,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAM5D;;;;;;;;;OASG;IACG,aAAa,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAyB/E;;;;OAIG;YACW,KAAK;CAQpB"}

package/dist/plugins/googleAnalytics/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const QUEUE_NAME = "serwist-google-analytics";
+export declare const MAX_RETENTION_TIME: number;
+export declare const GOOGLE_ANALYTICS_HOST = "www.google-analytics.com";
+export declare const GTM_HOST = "www.googletagmanager.com";
+export declare const ANALYTICS_JS_PATH = "/analytics.js";
+export declare const GTAG_JS_PATH = "/gtag/js";
+export declare const GTM_JS_PATH = "/gtm.js";
+export declare const COLLECT_DEFAULT_PATH = "/collect";
+export declare const COLLECT_PATHS_REGEX: RegExp;
+//# sourceMappingURL=constants.d.ts.map

package/dist/plugins/googleAnalytics/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/plugins/googleAnalytics/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/plugins/googleAnalytics/initialize.d.ts

@@ -0,0 +1,30 @@
+import type { Serwist } from "../../Serwist.js";
+export interface GoogleAnalyticsInitializeOptions {
+    serwist: Serwist;
+    /**
+     * 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
+ */
+export declare const initialize: ({ serwist, cacheName, ...options }: GoogleAnalyticsInitializeOptions) => void;
+//# sourceMappingURL=initialize.d.ts.map

package/dist/plugins/googleAnalytics/initialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../src/plugins/googleAnalytics/initialize.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAEhD,MAAM,WAAW,gCAAgC;IAC/C,OAAO,EAAE,OAAO,CAAC;IACjB;;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;;;;GAIG;AACH,eAAO,MAAM,UAAU,uCAAwC,gCAAgC,KAAG,IAkBjG,CAAC"}

package/dist/plugins/precaching/PrecacheFallbackPlugin.d.ts

@@ -0,0 +1,53 @@
+import type { HandlerDidErrorCallbackParam, SerwistPlugin } from "../../types.js";
+import type { Serwist } from "../../Serwist.js";
+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;
+}
+export interface PrecacheFallbackPluginOptions {
+    /**
+     * Precached URLs to be used as the fallback
+     * if the associated strategy can't generate a response.
+     */
+    fallbackUrls: (string | PrecacheFallbackEntry)[];
+    /**
+     * Your `Serwist` instance.
+     */
+    serwist: Serwist;
+}
+/**
+ * `PrecacheFallbackPlugin` 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 `PrecacheController` instance to the
+ * constructor, the default instance will be used. Generally speaking, most
+ * developers will end up using the default.
+ */
+export declare class PrecacheFallbackPlugin implements SerwistPlugin {
+    private readonly _fallbackUrls;
+    private readonly _serwist;
+    /**
+     * Constructs a new `PrecacheFallbackPlugin` with the associated `fallbackUrls`.
+     *
+     * @param config
+     */
+    constructor({ fallbackUrls, serwist }: 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/plugins/precaching/PrecacheFallbackPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrecacheFallbackPlugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/precaching/PrecacheFallbackPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,4BAA4B,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAClF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAEhD,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,OAAO,EAAE,CAAC,KAAK,EAAE,4BAA4B,KAAK,OAAO,CAAC;IAC1D;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb;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;;;;;;;;;;;GAWG;AACH,qBAAa,sBAAuB,YAAW,aAAa;IAC1D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqC;IACnE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAU;IAEnC;;;;OAIG;gBACS,EAAE,YAAY,EAAE,OAAO,EAAE,EAAE,6BAA6B;IAKpE;;;;OAIG;IACG,eAAe,CAAC,KAAK,EAAE,4BAA4B;CAgB1D"}

package/dist/plugins/rangeRequests/RangeRequestsPlugin.d.ts

@@ -0,0 +1,19 @@
+import type { SerwistPlugin } from "../../types.js";
+/**
+ * The range request plugin 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 {
+    /**
+     * @param options
+     * @returns If request contains a 'Range' header, then a
+     * new response with status 206 whose body is a subset of `cachedResponse` is
+     * returned. Otherwise, `cachedResponse` is returned as-is.
+     * @private
+     */
+    cachedResponseWillBeUsed: SerwistPlugin["cachedResponseWillBeUsed"];
+}
+//# sourceMappingURL=RangeRequestsPlugin.d.ts.map

package/dist/plugins/rangeRequests/RangeRequestsPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RangeRequestsPlugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/rangeRequests/RangeRequestsPlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGpD;;;;;;GAMG;AACH,qBAAa,mBAAoB,YAAW,aAAa;IACvD;;;;;;OAMG;IACH,wBAAwB,EAAE,aAAa,CAAC,0BAA0B,CAAC,CAUjE;CACH"}

package/dist/plugins/rangeRequests/createPartialResponse.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Given a `Request` and `Response` objects as input, this will return a
+ * promise for a new `Response`.
+ *
+ * If the original `Response` already contains partial content (i.e. it has
+ * a status of 206), then this assumes it already fulfills the `Range:`
+ * requirements, and will return it as-is.
+ *
+ * @param request A request, which should contain a Range:
+ * header.
+ * @param originalResponse A response.
+ * @returns Either a `206 Partial Content` response, with
+ * the response body set to the slice of content specified by the request's
+ * `Range:` header, or a `416 Range Not Satisfiable` response if the
+ * conditions of the `Range:` header can't be met.
+ */
+export declare const createPartialResponse: (request: Request, originalResponse: Response) => Promise<Response>;
+//# sourceMappingURL=createPartialResponse.d.ts.map

package/dist/plugins/rangeRequests/createPartialResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPartialResponse.d.ts","sourceRoot":"","sources":["../../../src/plugins/rangeRequests/createPartialResponse.ts"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,qBAAqB,YAAmB,OAAO,oBAAoB,QAAQ,KAAG,QAAQ,QAAQ,CA8D1G,CAAC"}

package/dist/plugins/rangeRequests/utils/calculateEffectiveBoundaries.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @param blob A source blob.
+ * @param start The offset to use as the start of the
+ * slice.
+ * @param end The offset to use as the end of the slice.
+ * @returns An object with `start` and `end` properties, reflecting
+ * the effective boundaries to use given the size of the blob.
+ * @private
+ */
+export declare const calculateEffectiveBoundaries: (blob: Blob, start?: number, end?: number) => {
+    start: number;
+    end: number;
+};
+//# sourceMappingURL=calculateEffectiveBoundaries.d.ts.map

package/dist/plugins/rangeRequests/utils/calculateEffectiveBoundaries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateEffectiveBoundaries.d.ts","sourceRoot":"","sources":["../../../../src/plugins/rangeRequests/utils/calculateEffectiveBoundaries.ts"],"names":[],"mappings":"AAWA;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,SAAU,IAAI,UAAU,MAAM,QAAQ,MAAM;WAAY,MAAM;SAAO,MAAM;CAsCnH,CAAC"}

package/dist/plugins/rangeRequests/utils/parseRangeHeader.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param rangeHeader A Range: header value.
+ * @returns An object with `start` and `end` properties, reflecting
+ * the parsed value of the Range: header. If either the `start` or `end` are
+ * omitted, then `null` will be returned.
+ * @private
+ */
+export declare const parseRangeHeader: (rangeHeader: string) => {
+    start?: number;
+    end?: number;
+};
+//# sourceMappingURL=parseRangeHeader.d.ts.map

package/dist/plugins/rangeRequests/utils/parseRangeHeader.d.ts.map

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

package/dist/registerQuotaErrorCallback.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Adds a function to the set of quotaErrorCallbacks that will be executed if
+ * there's a quota error.
+ *
+ * @param callback
+ */
+export declare const registerQuotaErrorCallback: (callback: Function) => void;
+//# sourceMappingURL=registerQuotaErrorCallback.d.ts.map

package/dist/registerQuotaErrorCallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerQuotaErrorCallback.d.ts","sourceRoot":"","sources":["../src/registerQuotaErrorCallback.ts"],"names":[],"mappings":"AAYA;;;;;GAKG;AAEH,eAAO,MAAM,0BAA0B,aAAc,QAAQ,KAAG,IAc/D,CAAC"}

package/dist/setCacheNameDetails.d.ts

@@ -0,0 +1,9 @@
+import type { PartialCacheNameDetails } from "./utils/cacheNames.js";
+/**
+ * Modifies the default cache names used by Serwist packages.
+ * Cache names are generated as `<prefix>-<Cache Name>-<suffix>`.
+ *
+ * @param details
+ */
+export declare const setCacheNameDetails: (details: PartialCacheNameDetails) => void;
+//# sourceMappingURL=setCacheNameDetails.d.ts.map

package/dist/setCacheNameDetails.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setCacheNameDetails.d.ts","sourceRoot":"","sources":["../src/setCacheNameDetails.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAGrE;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,YAAa,uBAAuB,KAAG,IAiCtE,CAAC"}

package/dist/strategies/CacheFirst.d.ts

@@ -0,0 +1,23 @@
+import { Strategy } from "./Strategy.js";
+import type { StrategyHandler } from "./StrategyHandler.js";
+/**
+ * An implementation of the [cache first](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#cache_first_falling_back_to_network)
+ * request strategy.
+ *
+ * A cache first strategy is useful for assets that have been revisioned,
+ * such as URLs like `/styles/example.a8f5f1.css`, since they
+ * can be cached for long periods of time.
+ *
+ * If the network request fails, and there is no cache match, this will throw
+ * a `SerwistError` exception.
+ */
+export declare class CacheFirst extends Strategy {
+    /**
+     * @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>;
+}
+//# sourceMappingURL=CacheFirst.d.ts.map

package/dist/strategies/CacheFirst.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheFirst.d.ts","sourceRoot":"","sources":["../../src/strategies/CacheFirst.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG5D;;;;;;;;;;GAUG;AACH,qBAAa,UAAW,SAAQ,QAAQ;IACtC;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;CAsD7E"}

package/dist/strategies/CacheOnly.d.ts

@@ -0,0 +1,20 @@
+import { Strategy } from "./Strategy.js";
+import type { StrategyHandler } from "./StrategyHandler.js";
+/**
+ * An implementation of the [cache only](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#cache-only)
+ * request strategy.
+ *
+ * This class is useful if you want to take advantage of any Serwist plugin.
+ *
+ * If there is no cache match, this will throw a `SerwistError` exception.
+ */
+export declare class CacheOnly extends Strategy {
+    /**
+     * @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>;
+}
+//# sourceMappingURL=CacheOnly.d.ts.map

package/dist/strategies/CacheOnly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheOnly.d.ts","sourceRoot":"","sources":["../../src/strategies/CacheOnly.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG5D;;;;;;;GAOG;AACH,qBAAa,SAAU,SAAQ,QAAQ;IACrC;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;CA4B7E"}

package/dist/strategies/NetworkFirst.d.ts

@@ -0,0 +1,61 @@
+import type { StrategyOptions } from "./Strategy.js";
+import { Strategy } from "./Strategy.js";
+import type { StrategyHandler } from "./StrategyHandler.js";
+export interface NetworkFirstOptions extends StrategyOptions {
+    /**
+     * If set, any network requests that fail to respond within the timeout will fallback to the cache.
+     */
+    networkTimeoutSeconds?: number;
+}
+/**
+ * An implementation of the [network first](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#network-first-falling-back-to-cache)
+ * request strategy.
+ *
+ * By default, this strategy will cache responses with a 200 status code as
+ * well as [opaque responses](https://developer.chrome.com/docs/workbox/caching-resources-during-runtime/#opaque-responses).
+ * Opaque responses are are cross-origin requests where the response doesn't
+ * support [CORS](https://enable-cors.org/).
+ *
+ * If the network request fails, and there is no cache match, this will throw
+ * a `SerwistError` exception.
+ */
+export declare class NetworkFirst extends Strategy {
+    private readonly _networkTimeoutSeconds;
+    /**
+     * @param options
+     * This option can be used to combat
+     * "[lie-fi](https://developers.google.com/web/fundamentals/performance/poor-connectivity/#lie-fi)"
+     * scenarios.
+     */
+    constructor(options?: NetworkFirstOptions);
+    /**
+     * @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>;
+    /**
+     * @param options
+     * @returns
+     * @private
+     */
+    private _getTimeoutPromise;
+    /**
+     * @param options
+     * @param options.timeoutId
+     * @param options.request
+     * @param options.logs A reference to the logs Array.
+     * @param options.event
+     * @returns
+     *
+     * @private
+     */
+    _getNetworkPromise({ timeoutId, request, logs, handler, }: {
+        request: Request;
+        logs: any[];
+        timeoutId?: number;
+        handler: StrategyHandler;
+    }): Promise<Response | undefined>;
+}
+//# sourceMappingURL=NetworkFirst.d.ts.map

package/dist/strategies/NetworkFirst.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkFirst.d.ts","sourceRoot":"","sources":["../../src/strategies/NetworkFirst.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAI5D,MAAM,WAAW,mBAAoB,SAAQ,eAAe;IAC1D;;OAEG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,YAAa,SAAQ,QAAQ;IACxC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAS;IAChD;;;;;OAKG;gBACS,OAAO,GAAE,mBAAwB;IAsB7C;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAgE5E;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IA8B1B;;;;;;;;;OASG;IACG,kBAAkB,CAAC,EACvB,SAAS,EACT,OAAO,EACP,IAAI,EACJ,OAAO,GACR,EAAE;QACD,OAAO,EAAE,OAAO,CAAC;QACjB,IAAI,EAAE,GAAG,EAAE,CAAC;QACZ,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,eAAe,CAAC;KAC1B,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;CAqClC"}

package/dist/strategies/NetworkOnly.d.ts

@@ -0,0 +1,32 @@
+import type { StrategyOptions } from "./Strategy.js";
+import { Strategy } from "./Strategy.js";
+import type { StrategyHandler } from "./StrategyHandler.js";
+export interface NetworkOnlyOptions extends Omit<StrategyOptions, "cacheName" | "matchOptions"> {
+    /**
+     * If set, any network requests that fail to respond within the timeout will result in a network error.
+     */
+    networkTimeoutSeconds?: number;
+}
+/**
+ * An implementation of the [network only](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#network-only)
+ * request strategy.
+ *
+ * This class is useful if you want to take advantage of any Serwist plugin.
+ *
+ * If the network request fails, this will throw a `SerwistError` exception.
+ */
+export declare class NetworkOnly extends Strategy {
+    private readonly _networkTimeoutSeconds;
+    /**
+     * @param options
+     */
+    constructor(options?: NetworkOnlyOptions);
+    /**
+     * @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>;
+}
+//# sourceMappingURL=NetworkOnly.d.ts.map

package/dist/strategies/NetworkOnly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkOnly.d.ts","sourceRoot":"","sources":["../../src/strategies/NetworkOnly.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG5D,MAAM,WAAW,kBAAmB,SAAQ,IAAI,CAAC,eAAe,EAAE,WAAW,GAAG,cAAc,CAAC;IAC7F;;OAEG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,qBAAa,WAAY,SAAQ,QAAQ;IACvC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAS;IAEhD;;OAEG;gBACS,OAAO,GAAE,kBAAuB;IAM5C;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;CA+C7E"}