@serwist/sw 9.0.0-preview.21 → 9.0.0-preview.25

package/dist/index.plugins.js

@@ -1,671 +0,0 @@
-export { B as BackgroundSyncPlugin, Q as BackgroundSyncQueue, a as BackgroundSyncQueueStore, P as PrecacheFallbackPlugin, S as StorableRequest, i as initializeGoogleAnalytics } from './chunks/PrecacheFallbackPlugin.js';
-import { SerwistError, logger, assert, resultingClientExists, timeout, getFriendlyURL, privateCacheNames } from '@serwist/core/internal';
-import { deleteDB, openDB } from 'idb';
-import { registerQuotaErrorCallback } from '@serwist/core';
-import './chunks/singletonRouter.js';
-import './chunks/NetworkOnly.js';
-import './chunks/Strategy.js';
-import './chunks/singletonPrecacheController.js';
-
-const CACHE_UPDATED_MESSAGE_TYPE = "CACHE_UPDATED";
-const CACHE_UPDATED_MESSAGE_META = "serwist-broadcast-update";
-const defaultNotifyAllClients = true;
-const defaultHeadersToCheck = [
-    "content-length",
-    "etag",
-    "last-modified"
-];
-
-const responsesAreSame = (firstResponse, secondResponse, headersToCheck)=>{
-    if (process.env.NODE_ENV !== "production") {
-        if (!(firstResponse instanceof Response && secondResponse instanceof Response)) {
-            throw new SerwistError("invalid-responses-are-same-args");
-        }
-    }
-    const atLeastOneHeaderAvailable = headersToCheck.some((header)=>{
-        return firstResponse.headers.has(header) && secondResponse.headers.has(header);
-    });
-    if (!atLeastOneHeaderAvailable) {
-        if (process.env.NODE_ENV !== "production") {
-            logger.warn("Unable to determine where the response has been updated because none of the headers that would be checked are present.");
-            logger.debug("Attempting to compare the following: ", firstResponse, secondResponse, headersToCheck);
-        }
-        return true;
-    }
-    return headersToCheck.every((header)=>{
-        const headerStateComparison = firstResponse.headers.has(header) === secondResponse.headers.has(header);
-        const headerValueComparison = firstResponse.headers.get(header) === secondResponse.headers.get(header);
-        return headerStateComparison && headerValueComparison;
-    });
-};
-
-const isSafari = typeof navigator !== "undefined" && /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
-const defaultPayloadGenerator = (data)=>{
-    return {
-        cacheName: data.cacheName,
-        updatedURL: data.request.url
-    };
-};
-class BroadcastCacheUpdate {
-    _headersToCheck;
-    _generatePayload;
-    _notifyAllClients;
-    constructor({ generatePayload, headersToCheck, notifyAllClients } = {}){
-        this._headersToCheck = headersToCheck || defaultHeadersToCheck;
-        this._generatePayload = generatePayload || defaultPayloadGenerator;
-        this._notifyAllClients = notifyAllClients ?? defaultNotifyAllClients;
-    }
-    async notifyIfUpdated(options) {
-        if (process.env.NODE_ENV !== "production") {
-            assert.isType(options.cacheName, "string", {
-                moduleName: "@serwist/broadcast-update",
-                className: "BroadcastCacheUpdate",
-                funcName: "notifyIfUpdated",
-                paramName: "cacheName"
-            });
-            assert.isInstance(options.newResponse, Response, {
-                moduleName: "@serwist/broadcast-update",
-                className: "BroadcastCacheUpdate",
-                funcName: "notifyIfUpdated",
-                paramName: "newResponse"
-            });
-            assert.isInstance(options.request, Request, {
-                moduleName: "@serwist/broadcast-update",
-                className: "BroadcastCacheUpdate",
-                funcName: "notifyIfUpdated",
-                paramName: "request"
-            });
-        }
-        if (!options.oldResponse) {
-            return;
-        }
-        if (!responsesAreSame(options.oldResponse, options.newResponse, this._headersToCheck)) {
-            if (process.env.NODE_ENV !== "production") {
-                logger.log("Newer response found (and cached) for:", options.request.url);
-            }
-            const messageData = {
-                type: CACHE_UPDATED_MESSAGE_TYPE,
-                meta: CACHE_UPDATED_MESSAGE_META,
-                payload: this._generatePayload(options)
-            };
-            if (options.request.mode === "navigate") {
-                let resultingClientId;
-                if (options.event instanceof FetchEvent) {
-                    resultingClientId = options.event.resultingClientId;
-                }
-                const resultingWin = await resultingClientExists(resultingClientId);
-                if (!resultingWin || isSafari) {
-                    await timeout(3500);
-                }
-            }
-            if (this._notifyAllClients) {
-                const windows = await self.clients.matchAll({
-                    type: "window"
-                });
-                for (const win of windows){
-                    win.postMessage(messageData);
-                }
-            } else {
-                if (options.event instanceof FetchEvent) {
-                    const client = await self.clients.get(options.event.clientId);
-                    client?.postMessage(messageData);
-                }
-            }
-        }
-    }
-}
-
-class BroadcastUpdatePlugin {
-    _broadcastUpdate;
-    constructor(options){
-        this._broadcastUpdate = new BroadcastCacheUpdate(options);
-    }
-    cacheDidUpdate(options) {
-        void this._broadcastUpdate.notifyIfUpdated(options);
-    }
-}
-
-class CacheableResponse {
-    _statuses;
-    _headers;
-    constructor(config = {}){
-        if (process.env.NODE_ENV !== "production") {
-            if (!(config.statuses || config.headers)) {
-                throw new SerwistError("statuses-or-headers-required", {
-                    moduleName: "@serwist/cacheable-response",
-                    className: "CacheableResponse",
-                    funcName: "constructor"
-                });
-            }
-            if (config.statuses) {
-                assert.isArray(config.statuses, {
-                    moduleName: "@serwist/cacheable-response",
-                    className: "CacheableResponse",
-                    funcName: "constructor",
-                    paramName: "config.statuses"
-                });
-            }
-            if (config.headers) {
-                assert.isType(config.headers, "object", {
-                    moduleName: "@serwist/cacheable-response",
-                    className: "CacheableResponse",
-                    funcName: "constructor",
-                    paramName: "config.headers"
-                });
-            }
-        }
-        this._statuses = config.statuses;
-        if (config.headers) {
-            this._headers = new Headers(config.headers);
-        }
-    }
-    isResponseCacheable(response) {
-        if (process.env.NODE_ENV !== "production") {
-            assert.isInstance(response, Response, {
-                moduleName: "@serwist/cacheable-response",
-                className: "CacheableResponse",
-                funcName: "isResponseCacheable",
-                paramName: "response"
-            });
-        }
-        let cacheable = true;
-        if (this._statuses) {
-            cacheable = this._statuses.includes(response.status);
-        }
-        if (this._headers && cacheable) {
-            for (const [headerName, headerValue] of this._headers.entries()){
-                if (response.headers.get(headerName) !== headerValue) {
-                    cacheable = false;
-                    break;
-                }
-            }
-        }
-        if (process.env.NODE_ENV !== "production") {
-            if (!cacheable) {
-                logger.groupCollapsed(`The request for '${getFriendlyURL(response.url)}' returned a response that does not meet the criteria for being cached.`);
-                logger.groupCollapsed("View cacheability criteria here.");
-                logger.log(`Cacheable statuses: ${JSON.stringify(this._statuses)}`);
-                logger.log(`Cacheable headers: ${JSON.stringify(this._headers, null, 2)}`);
-                logger.groupEnd();
-                const logFriendlyHeaders = {};
-                response.headers.forEach((value, key)=>{
-                    logFriendlyHeaders[key] = value;
-                });
-                logger.groupCollapsed("View response status and headers here.");
-                logger.log(`Response status: ${response.status}`);
-                logger.log(`Response headers: ${JSON.stringify(logFriendlyHeaders, null, 2)}`);
-                logger.groupEnd();
-                logger.groupCollapsed("View full response details here.");
-                logger.log(response.headers);
-                logger.log(response);
-                logger.groupEnd();
-                logger.groupEnd();
-            }
-        }
-        return cacheable;
-    }
-}
-
-class CacheableResponsePlugin {
-    _cacheableResponse;
-    constructor(config){
-        this._cacheableResponse = new CacheableResponse(config);
-    }
-    cacheWillUpdate = async ({ response })=>{
-        if (this._cacheableResponse.isResponseCacheable(response)) {
-            return response;
-        }
-        return null;
-    };
-}
-
-const DB_NAME = "serwist-expiration";
-const CACHE_OBJECT_STORE = "cache-entries";
-const normalizeURL = (unNormalizedUrl)=>{
-    const url = new URL(unNormalizedUrl, location.href);
-    url.hash = "";
-    return url.href;
-};
-class CacheTimestampsModel {
-    _cacheName;
-    _db = null;
-    constructor(cacheName){
-        this._cacheName = cacheName;
-    }
-    _getId(url) {
-        return `${this._cacheName}|${normalizeURL(url)}`;
-    }
-    _upgradeDb(db) {
-        const objStore = db.createObjectStore(CACHE_OBJECT_STORE, {
-            keyPath: "id"
-        });
-        objStore.createIndex("cacheName", "cacheName", {
-            unique: false
-        });
-        objStore.createIndex("timestamp", "timestamp", {
-            unique: false
-        });
-    }
-    _upgradeDbAndDeleteOldDbs(db) {
-        this._upgradeDb(db);
-        if (this._cacheName) {
-            void deleteDB(this._cacheName);
-        }
-    }
-    async setTimestamp(url, timestamp) {
-        url = normalizeURL(url);
-        const entry = {
-            id: this._getId(url),
-            cacheName: this._cacheName,
-            url,
-            timestamp
-        };
-        const db = await this.getDb();
-        const tx = db.transaction(CACHE_OBJECT_STORE, "readwrite", {
-            durability: "relaxed"
-        });
-        await tx.store.put(entry);
-        await tx.done;
-    }
-    async getTimestamp(url) {
-        const db = await this.getDb();
-        const entry = await db.get(CACHE_OBJECT_STORE, this._getId(url));
-        return entry?.timestamp;
-    }
-    async expireEntries(minTimestamp, maxCount) {
-        const db = await this.getDb();
-        let cursor = await db.transaction(CACHE_OBJECT_STORE, "readwrite").store.index("timestamp").openCursor(null, "prev");
-        const urlsDeleted = [];
-        let entriesNotDeletedCount = 0;
-        while(cursor){
-            const result = cursor.value;
-            if (result.cacheName === this._cacheName) {
-                if (minTimestamp && result.timestamp < minTimestamp || maxCount && entriesNotDeletedCount >= maxCount) {
-                    cursor.delete();
-                    urlsDeleted.push(result.url);
-                } else {
-                    entriesNotDeletedCount++;
-                }
-            }
-            cursor = await cursor.continue();
-        }
-        return urlsDeleted;
-    }
-    async getDb() {
-        if (!this._db) {
-            this._db = await openDB(DB_NAME, 1, {
-                upgrade: this._upgradeDbAndDeleteOldDbs.bind(this)
-            });
-        }
-        return this._db;
-    }
-}
-
-class CacheExpiration {
-    _isRunning = false;
-    _rerunRequested = false;
-    _maxEntries;
-    _maxAgeSeconds;
-    _matchOptions;
-    _cacheName;
-    _timestampModel;
-    constructor(cacheName, config = {}){
-        if (process.env.NODE_ENV !== "production") {
-            assert.isType(cacheName, "string", {
-                moduleName: "@serwist/expiration",
-                className: "CacheExpiration",
-                funcName: "constructor",
-                paramName: "cacheName"
-            });
-            if (!(config.maxEntries || config.maxAgeSeconds)) {
-                throw new SerwistError("max-entries-or-age-required", {
-                    moduleName: "@serwist/expiration",
-                    className: "CacheExpiration",
-                    funcName: "constructor"
-                });
-            }
-            if (config.maxEntries) {
-                assert.isType(config.maxEntries, "number", {
-                    moduleName: "@serwist/expiration",
-                    className: "CacheExpiration",
-                    funcName: "constructor",
-                    paramName: "config.maxEntries"
-                });
-            }
-            if (config.maxAgeSeconds) {
-                assert.isType(config.maxAgeSeconds, "number", {
-                    moduleName: "@serwist/expiration",
-                    className: "CacheExpiration",
-                    funcName: "constructor",
-                    paramName: "config.maxAgeSeconds"
-                });
-            }
-        }
-        this._maxEntries = config.maxEntries;
-        this._maxAgeSeconds = config.maxAgeSeconds;
-        this._matchOptions = config.matchOptions;
-        this._cacheName = cacheName;
-        this._timestampModel = new CacheTimestampsModel(cacheName);
-    }
-    async expireEntries() {
-        if (this._isRunning) {
-            this._rerunRequested = true;
-            return;
-        }
-        this._isRunning = true;
-        const minTimestamp = this._maxAgeSeconds ? Date.now() - this._maxAgeSeconds * 1000 : 0;
-        const urlsExpired = await this._timestampModel.expireEntries(minTimestamp, this._maxEntries);
-        const cache = await self.caches.open(this._cacheName);
-        for (const url of urlsExpired){
-            await cache.delete(url, this._matchOptions);
-        }
-        if (process.env.NODE_ENV !== "production") {
-            if (urlsExpired.length > 0) {
-                logger.groupCollapsed(`Expired ${urlsExpired.length} ` + `${urlsExpired.length === 1 ? "entry" : "entries"} and removed ` + `${urlsExpired.length === 1 ? "it" : "them"} from the ` + `'${this._cacheName}' cache.`);
-                logger.log(`Expired the following ${urlsExpired.length === 1 ? "URL" : "URLs"}:`);
-                for (const url of urlsExpired){
-                    logger.log(`    ${url}`);
-                }
-                logger.groupEnd();
-            } else {
-                logger.debug("Cache expiration ran and found no entries to remove.");
-            }
-        }
-        this._isRunning = false;
-        if (this._rerunRequested) {
-            this._rerunRequested = false;
-            void this.expireEntries();
-        }
-    }
-    async updateTimestamp(url) {
-        if (process.env.NODE_ENV !== "production") {
-            assert.isType(url, "string", {
-                moduleName: "@serwist/expiration",
-                className: "CacheExpiration",
-                funcName: "updateTimestamp",
-                paramName: "url"
-            });
-        }
-        await this._timestampModel.setTimestamp(url, Date.now());
-    }
-    async isURLExpired(url) {
-        if (!this._maxAgeSeconds) {
-            if (process.env.NODE_ENV !== "production") {
-                throw new SerwistError("expired-test-without-max-age", {
-                    methodName: "isURLExpired",
-                    paramName: "maxAgeSeconds"
-                });
-            }
-            return false;
-        }
-        const timestamp = await this._timestampModel.getTimestamp(url);
-        const expireOlderThan = Date.now() - this._maxAgeSeconds * 1000;
-        return timestamp !== undefined ? timestamp < expireOlderThan : true;
-    }
-    async delete() {
-        this._rerunRequested = false;
-        await this._timestampModel.expireEntries(Number.POSITIVE_INFINITY);
-    }
-}
-
-class ExpirationPlugin {
-    _config;
-    _cacheExpirations;
-    constructor(config = {}){
-        if (process.env.NODE_ENV !== "production") {
-            if (!(config.maxEntries || config.maxAgeSeconds)) {
-                throw new SerwistError("max-entries-or-age-required", {
-                    moduleName: "@serwist/expiration",
-                    className: "ExpirationPlugin",
-                    funcName: "constructor"
-                });
-            }
-            if (config.maxEntries) {
-                assert.isType(config.maxEntries, "number", {
-                    moduleName: "@serwist/expiration",
-                    className: "ExpirationPlugin",
-                    funcName: "constructor",
-                    paramName: "config.maxEntries"
-                });
-            }
-            if (config.maxAgeSeconds) {
-                assert.isType(config.maxAgeSeconds, "number", {
-                    moduleName: "@serwist/expiration",
-                    className: "ExpirationPlugin",
-                    funcName: "constructor",
-                    paramName: "config.maxAgeSeconds"
-                });
-            }
-            if (config.maxAgeFrom) {
-                assert.isType(config.maxAgeFrom, "string", {
-                    moduleName: "@serwist/expiration",
-                    className: "ExpirationPlugin",
-                    funcName: "constructor",
-                    paramName: "config.maxAgeFrom"
-                });
-            }
-        }
-        this._config = config;
-        this._cacheExpirations = new Map();
-        if (!this._config.maxAgeFrom) {
-            this._config.maxAgeFrom = "last-fetched";
-        }
-        if (this._config.purgeOnQuotaError) {
-            registerQuotaErrorCallback(()=>this.deleteCacheAndMetadata());
-        }
-    }
-    _getCacheExpiration(cacheName) {
-        if (cacheName === privateCacheNames.getRuntimeName()) {
-            throw new SerwistError("expire-custom-caches-only");
-        }
-        let cacheExpiration = this._cacheExpirations.get(cacheName);
-        if (!cacheExpiration) {
-            cacheExpiration = new CacheExpiration(cacheName, this._config);
-            this._cacheExpirations.set(cacheName, cacheExpiration);
-        }
-        return cacheExpiration;
-    }
-    cachedResponseWillBeUsed({ event, cacheName, request, cachedResponse }) {
-        if (!cachedResponse) {
-            return null;
-        }
-        const isFresh = this._isResponseDateFresh(cachedResponse);
-        const cacheExpiration = this._getCacheExpiration(cacheName);
-        const isMaxAgeFromLastUsed = this._config.maxAgeFrom === "last-used";
-        const done = (async ()=>{
-            if (isMaxAgeFromLastUsed) {
-                await cacheExpiration.updateTimestamp(request.url);
-            }
-            await cacheExpiration.expireEntries();
-        })();
-        try {
-            event.waitUntil(done);
-        } catch (error) {
-            if (process.env.NODE_ENV !== "production") {
-                if (event instanceof FetchEvent) {
-                    logger.warn(`Unable to ensure service worker stays alive when updating cache entry for '${getFriendlyURL(event.request.url)}'.`);
-                }
-            }
-        }
-        return isFresh ? cachedResponse : null;
-    }
-    _isResponseDateFresh(cachedResponse) {
-        const isMaxAgeFromLastUsed = this._config.maxAgeFrom === "last-used";
-        if (isMaxAgeFromLastUsed) {
-            return true;
-        }
-        const now = Date.now();
-        if (!this._config.maxAgeSeconds) {
-            return true;
-        }
-        const dateHeaderTimestamp = this._getDateHeaderTimestamp(cachedResponse);
-        if (dateHeaderTimestamp === null) {
-            return true;
-        }
-        return dateHeaderTimestamp >= now - this._config.maxAgeSeconds * 1000;
-    }
-    _getDateHeaderTimestamp(cachedResponse) {
-        if (!cachedResponse.headers.has("date")) {
-            return null;
-        }
-        const dateHeader = cachedResponse.headers.get("date");
-        const parsedDate = new Date(dateHeader);
-        const headerTime = parsedDate.getTime();
-        if (Number.isNaN(headerTime)) {
-            return null;
-        }
-        return headerTime;
-    }
-    async cacheDidUpdate({ cacheName, request }) {
-        if (process.env.NODE_ENV !== "production") {
-            assert.isType(cacheName, "string", {
-                moduleName: "@serwist/expiration",
-                className: "Plugin",
-                funcName: "cacheDidUpdate",
-                paramName: "cacheName"
-            });
-            assert.isInstance(request, Request, {
-                moduleName: "@serwist/expiration",
-                className: "Plugin",
-                funcName: "cacheDidUpdate",
-                paramName: "request"
-            });
-        }
-        const cacheExpiration = this._getCacheExpiration(cacheName);
-        await cacheExpiration.updateTimestamp(request.url);
-        await cacheExpiration.expireEntries();
-    }
-    async deleteCacheAndMetadata() {
-        for (const [cacheName, cacheExpiration] of this._cacheExpirations){
-            await self.caches.delete(cacheName);
-            await cacheExpiration.delete();
-        }
-        this._cacheExpirations = new Map();
-    }
-}
-
-const calculateEffectiveBoundaries = (blob, start, end)=>{
-    if (process.env.NODE_ENV !== "production") {
-        assert.isInstance(blob, Blob, {
-            moduleName: "@serwist/range-requests",
-            funcName: "calculateEffectiveBoundaries",
-            paramName: "blob"
-        });
-    }
-    const blobSize = blob.size;
-    if (end && end > blobSize || start && start < 0) {
-        throw new SerwistError("range-not-satisfiable", {
-            size: blobSize,
-            end,
-            start
-        });
-    }
-    let effectiveStart;
-    let effectiveEnd;
-    if (start !== undefined && end !== undefined) {
-        effectiveStart = start;
-        effectiveEnd = end + 1;
-    } else if (start !== undefined && end === undefined) {
-        effectiveStart = start;
-        effectiveEnd = blobSize;
-    } else if (end !== undefined && start === undefined) {
-        effectiveStart = blobSize - end;
-        effectiveEnd = blobSize;
-    }
-    return {
-        start: effectiveStart,
-        end: effectiveEnd
-    };
-};
-
-const parseRangeHeader = (rangeHeader)=>{
-    if (process.env.NODE_ENV !== "production") {
-        assert.isType(rangeHeader, "string", {
-            moduleName: "@serwist/range-requests",
-            funcName: "parseRangeHeader",
-            paramName: "rangeHeader"
-        });
-    }
-    const normalizedRangeHeader = rangeHeader.trim().toLowerCase();
-    if (!normalizedRangeHeader.startsWith("bytes=")) {
-        throw new SerwistError("unit-must-be-bytes", {
-            normalizedRangeHeader
-        });
-    }
-    if (normalizedRangeHeader.includes(",")) {
-        throw new SerwistError("single-range-only", {
-            normalizedRangeHeader
-        });
-    }
-    const rangeParts = /(\d*)-(\d*)/.exec(normalizedRangeHeader);
-    if (!rangeParts || !(rangeParts[1] || rangeParts[2])) {
-        throw new SerwistError("invalid-range-values", {
-            normalizedRangeHeader
-        });
-    }
-    return {
-        start: rangeParts[1] === "" ? undefined : Number(rangeParts[1]),
-        end: rangeParts[2] === "" ? undefined : Number(rangeParts[2])
-    };
-};
-
-const createPartialResponse = async (request, originalResponse)=>{
-    try {
-        if (process.env.NODE_ENV !== "production") {
-            assert.isInstance(request, Request, {
-                moduleName: "@serwist/range-requests",
-                funcName: "createPartialResponse",
-                paramName: "request"
-            });
-            assert.isInstance(originalResponse, Response, {
-                moduleName: "@serwist/range-requests",
-                funcName: "createPartialResponse",
-                paramName: "originalResponse"
-            });
-        }
-        if (originalResponse.status === 206) {
-            return originalResponse;
-        }
-        const rangeHeader = request.headers.get("range");
-        if (!rangeHeader) {
-            throw new SerwistError("no-range-header");
-        }
-        const boundaries = parseRangeHeader(rangeHeader);
-        const originalBlob = await originalResponse.blob();
-        const effectiveBoundaries = calculateEffectiveBoundaries(originalBlob, boundaries.start, boundaries.end);
-        const slicedBlob = originalBlob.slice(effectiveBoundaries.start, effectiveBoundaries.end);
-        const slicedBlobSize = slicedBlob.size;
-        const slicedResponse = new Response(slicedBlob, {
-            status: 206,
-            statusText: "Partial Content",
-            headers: originalResponse.headers
-        });
-        slicedResponse.headers.set("Content-Length", String(slicedBlobSize));
-        slicedResponse.headers.set("Content-Range", `bytes ${effectiveBoundaries.start}-${effectiveBoundaries.end - 1}/` + `${originalBlob.size}`);
-        return slicedResponse;
-    } catch (error) {
-        if (process.env.NODE_ENV !== "production") {
-            logger.warn("Unable to construct a partial response; returning a " + "416 Range Not Satisfiable response instead.");
-            logger.groupCollapsed("View details here.");
-            logger.log(error);
-            logger.log(request);
-            logger.log(originalResponse);
-            logger.groupEnd();
-        }
-        return new Response("", {
-            status: 416,
-            statusText: "Range Not Satisfiable"
-        });
-    }
-};
-
-class RangeRequestsPlugin {
-    cachedResponseWillBeUsed = async ({ request, cachedResponse })=>{
-        if (cachedResponse && request.headers.has("range")) {
-            return await createPartialResponse(request, cachedResponse);
-        }
-        return cachedResponse;
-    };
-}
-
-export { defaultHeadersToCheck as BROADCAST_UPDATE_DEFAULT_HEADERS, CACHE_UPDATED_MESSAGE_META as BROADCAST_UPDATE_MESSAGE_META, CACHE_UPDATED_MESSAGE_TYPE as BROADCAST_UPDATE_MESSAGE_TYPE, BroadcastCacheUpdate, BroadcastUpdatePlugin, CacheExpiration, CacheableResponse, CacheableResponsePlugin, ExpirationPlugin, RangeRequestsPlugin, createPartialResponse, responsesAreSame };

package/dist/index.precaching.d.ts

@@ -1,25 +0,0 @@
-import { PrecacheController } from "./precaching/PrecacheController.js";
-import { PrecacheRoute } from "./precaching/PrecacheRoute.js";
-import { PrecacheStrategy } from "./precaching/PrecacheStrategy.js";
-import { addPlugins } from "./precaching/addPlugins.js";
-import { addRoute } from "./precaching/addRoute.js";
-import { cleanupOutdatedCaches } from "./precaching/cleanupOutdatedCaches.js";
-import { createHandlerBoundToURL } from "./precaching/createHandlerBoundToURL.js";
-import { getCacheKeyForURL } from "./precaching/getCacheKeyForURL.js";
-import { matchPrecache } from "./precaching/matchPrecache.js";
-import { precache } from "./precaching/precache.js";
-import { precacheAndRoute } from "./precaching/precacheAndRoute.js";
-import { getSingletonPrecacheController, setSingletonPrecacheController } from "./precaching/singletonPrecacheController.js";
-/**
- * Most consumers of this module will want to use the
- * `@serwist/sw/precaching.precacheAndRoute`
- * method to add assets to the cache and respond to network requests with these
- * cached assets.
- *
- * If you require more control over caching and routing, you can use the
- * `@serwist/precaching.PrecacheController`
- * interface.
- */
-export { addPlugins, addRoute, cleanupOutdatedCaches, createHandlerBoundToURL, getCacheKeyForURL, matchPrecache, precache, precacheAndRoute, PrecacheController, PrecacheRoute, PrecacheStrategy, getSingletonPrecacheController, setSingletonPrecacheController, };
-export type * from "./precaching/types.js";
-//# sourceMappingURL=index.precaching.d.ts.map