@nypl/web-reader 3.2.5 → 4.1.0

package/dist/esm/ServiceWorker/sw.js

@@ -1,1749 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-
-// node_modules/workbox-core/_version.js
-try {
-  self["workbox:core:6.2.4"] && _();
-} catch (e) {
-}
-
-// node_modules/workbox-core/_private/logger.js
-var logger = true ? null : (() => {
-  if (!("__WB_DISABLE_DEV_LOGS" in self)) {
-    self.__WB_DISABLE_DEV_LOGS = false;
-  }
-  let inGroup = false;
-  const methodToColorMap = {
-    debug: `#7f8c8d`,
-    log: `#2ecc71`,
-    warn: `#f39c12`,
-    error: `#c0392b`,
-    groupCollapsed: `#3498db`,
-    groupEnd: null
-  };
-  const print = function(method, args) {
-    if (self.__WB_DISABLE_DEV_LOGS) {
-      return;
-    }
-    if (method === "groupCollapsed") {
-      if (/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
-        console[method](...args);
-        return;
-      }
-    }
-    const styles = [
-      `background: ${methodToColorMap[method]}`,
-      `border-radius: 0.5em`,
-      `color: white`,
-      `font-weight: bold`,
-      `padding: 2px 0.5em`
-    ];
-    const logPrefix = inGroup ? [] : ["%cworkbox", styles.join(";")];
-    console[method](...logPrefix, ...args);
-    if (method === "groupCollapsed") {
-      inGroup = true;
-    }
-    if (method === "groupEnd") {
-      inGroup = false;
-    }
-  };
-  const api = {};
-  const loggerMethods = Object.keys(methodToColorMap);
-  for (const key of loggerMethods) {
-    const method = key;
-    api[method] = (...args) => {
-      print(method, args);
-    };
-  }
-  return api;
-})();
-
-// node_modules/workbox-core/models/messages/messageGenerator.js
-var fallback = (code, ...args) => {
-  let msg = code;
-  if (args.length > 0) {
-    msg += ` :: ${JSON.stringify(args)}`;
-  }
-  return msg;
-};
-var messageGenerator = true ? fallback : generatorFunction;
-
-// node_modules/workbox-core/_private/WorkboxError.js
-var WorkboxError = class extends Error {
-  constructor(errorCode, details) {
-    const message = messageGenerator(errorCode, details);
-    super(message);
-    this.name = errorCode;
-    this.details = details;
-  }
-};
-
-// node_modules/workbox-core/models/quotaErrorCallbacks.js
-var quotaErrorCallbacks = /* @__PURE__ */ new Set();
-
-// node_modules/workbox-core/registerQuotaErrorCallback.js
-function registerQuotaErrorCallback(callback) {
-  if (false) {
-    finalAssertExports.isType(callback, "function", {
-      moduleName: "workbox-core",
-      funcName: "register",
-      paramName: "callback"
-    });
-  }
-  quotaErrorCallbacks.add(callback);
-  if (false) {
-    logger.log("Registered a callback to respond to quota errors.", callback);
-  }
-}
-
-// node_modules/workbox-core/_private/cacheNames.js
-var _cacheNameDetails = {
-  googleAnalytics: "googleAnalytics",
-  precache: "precache-v2",
-  prefix: "workbox",
-  runtime: "runtime",
-  suffix: typeof registration !== "undefined" ? registration.scope : ""
-};
-var _createCacheName = (cacheName) => {
-  return [_cacheNameDetails.prefix, cacheName, _cacheNameDetails.suffix].filter((value) => value && value.length > 0).join("-");
-};
-var eachCacheNameDetail = (fn) => {
-  for (const key of Object.keys(_cacheNameDetails)) {
-    fn(key);
-  }
-};
-var cacheNames = {
-  updateDetails: (details) => {
-    eachCacheNameDetail((key) => {
-      if (typeof details[key] === "string") {
-        _cacheNameDetails[key] = details[key];
-      }
-    });
-  },
-  getGoogleAnalyticsName: (userCacheName) => {
-    return userCacheName || _createCacheName(_cacheNameDetails.googleAnalytics);
-  },
-  getPrecacheName: (userCacheName) => {
-    return userCacheName || _createCacheName(_cacheNameDetails.precache);
-  },
-  getPrefix: () => {
-    return _cacheNameDetails.prefix;
-  },
-  getRuntimeName: (userCacheName) => {
-    return userCacheName || _createCacheName(_cacheNameDetails.runtime);
-  },
-  getSuffix: () => {
-    return _cacheNameDetails.suffix;
-  }
-};
-
-// node_modules/workbox-core/_private/cacheMatchIgnoreParams.js
-function stripParams(fullURL, ignoreParams) {
-  const strippedURL = new URL(fullURL);
-  for (const param of ignoreParams) {
-    strippedURL.searchParams.delete(param);
-  }
-  return strippedURL.href;
-}
-function cacheMatchIgnoreParams(cache, request, ignoreParams, matchOptions) {
-  return __async(this, null, function* () {
-    const strippedRequestURL = stripParams(request.url, ignoreParams);
-    if (request.url === strippedRequestURL) {
-      return cache.match(request, matchOptions);
-    }
-    const keysOptions = Object.assign(Object.assign({}, matchOptions), { ignoreSearch: true });
-    const cacheKeys = yield cache.keys(request, keysOptions);
-    for (const cacheKey of cacheKeys) {
-      const strippedCacheKeyURL = stripParams(cacheKey.url, ignoreParams);
-      if (strippedRequestURL === strippedCacheKeyURL) {
-        return cache.match(cacheKey, matchOptions);
-      }
-    }
-    return;
-  });
-}
-
-// node_modules/workbox-core/_private/dontWaitFor.js
-function dontWaitFor(promise) {
-  void promise.then(() => {
-  });
-}
-
-// node_modules/workbox-core/_private/Deferred.js
-var Deferred = class {
-  constructor() {
-    this.promise = new Promise((resolve, reject) => {
-      this.resolve = resolve;
-      this.reject = reject;
-    });
-  }
-};
-
-// node_modules/workbox-core/_private/executeQuotaErrorCallbacks.js
-function executeQuotaErrorCallbacks() {
-  return __async(this, null, function* () {
-    if (false) {
-      logger.log(`About to run ${quotaErrorCallbacks.size} callbacks to clean up caches.`);
-    }
-    for (const callback of quotaErrorCallbacks) {
-      yield callback();
-      if (false) {
-        logger.log(callback, "is complete.");
-      }
-    }
-    if (false) {
-      logger.log("Finished running callbacks.");
-    }
-  });
-}
-
-// node_modules/workbox-core/_private/getFriendlyURL.js
-var getFriendlyURL = (url) => {
-  const urlObj = new URL(String(url), location.href);
-  return urlObj.href.replace(new RegExp(`^${location.origin}`), "");
-};
-
-// node_modules/workbox-core/_private/timeout.js
-function timeout(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// node_modules/workbox-core/clientsClaim.js
-function clientsClaim() {
-  self.addEventListener("activate", () => self.clients.claim());
-}
-
-// node_modules/idb/build/esm/wrap-idb-value.js
-var instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
-var idbProxyableTypes;
-var cursorAdvanceMethods;
-function getIdbProxyableTypes() {
-  return idbProxyableTypes || (idbProxyableTypes = [
-    IDBDatabase,
-    IDBObjectStore,
-    IDBIndex,
-    IDBCursor,
-    IDBTransaction
-  ]);
-}
-function getCursorAdvanceMethods() {
-  return cursorAdvanceMethods || (cursorAdvanceMethods = [
-    IDBCursor.prototype.advance,
-    IDBCursor.prototype.continue,
-    IDBCursor.prototype.continuePrimaryKey
-  ]);
-}
-var cursorRequestMap = /* @__PURE__ */ new WeakMap();
-var transactionDoneMap = /* @__PURE__ */ new WeakMap();
-var transactionStoreNamesMap = /* @__PURE__ */ new WeakMap();
-var transformCache = /* @__PURE__ */ new WeakMap();
-var reverseTransformCache = /* @__PURE__ */ new WeakMap();
-function promisifyRequest(request) {
-  const promise = new Promise((resolve, reject) => {
-    const unlisten = () => {
-      request.removeEventListener("success", success);
-      request.removeEventListener("error", error);
-    };
-    const success = () => {
-      resolve(wrap(request.result));
-      unlisten();
-    };
-    const error = () => {
-      reject(request.error);
-      unlisten();
-    };
-    request.addEventListener("success", success);
-    request.addEventListener("error", error);
-  });
-  promise.then((value) => {
-    if (value instanceof IDBCursor) {
-      cursorRequestMap.set(value, request);
-    }
-  }).catch(() => {
-  });
-  reverseTransformCache.set(promise, request);
-  return promise;
-}
-function cacheDonePromiseForTransaction(tx) {
-  if (transactionDoneMap.has(tx))
-    return;
-  const done = new Promise((resolve, reject) => {
-    const unlisten = () => {
-      tx.removeEventListener("complete", complete);
-      tx.removeEventListener("error", error);
-      tx.removeEventListener("abort", error);
-    };
-    const complete = () => {
-      resolve();
-      unlisten();
-    };
-    const error = () => {
-      reject(tx.error || new DOMException("AbortError", "AbortError"));
-      unlisten();
-    };
-    tx.addEventListener("complete", complete);
-    tx.addEventListener("error", error);
-    tx.addEventListener("abort", error);
-  });
-  transactionDoneMap.set(tx, done);
-}
-var idbProxyTraps = {
-  get(target, prop, receiver) {
-    if (target instanceof IDBTransaction) {
-      if (prop === "done")
-        return transactionDoneMap.get(target);
-      if (prop === "objectStoreNames") {
-        return target.objectStoreNames || transactionStoreNamesMap.get(target);
-      }
-      if (prop === "store") {
-        return receiver.objectStoreNames[1] ? void 0 : receiver.objectStore(receiver.objectStoreNames[0]);
-      }
-    }
-    return wrap(target[prop]);
-  },
-  set(target, prop, value) {
-    target[prop] = value;
-    return true;
-  },
-  has(target, prop) {
-    if (target instanceof IDBTransaction && (prop === "done" || prop === "store")) {
-      return true;
-    }
-    return prop in target;
-  }
-};
-function replaceTraps(callback) {
-  idbProxyTraps = callback(idbProxyTraps);
-}
-function wrapFunction(func) {
-  if (func === IDBDatabase.prototype.transaction && !("objectStoreNames" in IDBTransaction.prototype)) {
-    return function(storeNames, ...args) {
-      const tx = func.call(unwrap(this), storeNames, ...args);
-      transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);
-      return wrap(tx);
-    };
-  }
-  if (getCursorAdvanceMethods().includes(func)) {
-    return function(...args) {
-      func.apply(unwrap(this), args);
-      return wrap(cursorRequestMap.get(this));
-    };
-  }
-  return function(...args) {
-    return wrap(func.apply(unwrap(this), args));
-  };
-}
-function transformCachableValue(value) {
-  if (typeof value === "function")
-    return wrapFunction(value);
-  if (value instanceof IDBTransaction)
-    cacheDonePromiseForTransaction(value);
-  if (instanceOfAny(value, getIdbProxyableTypes()))
-    return new Proxy(value, idbProxyTraps);
-  return value;
-}
-function wrap(value) {
-  if (value instanceof IDBRequest)
-    return promisifyRequest(value);
-  if (transformCache.has(value))
-    return transformCache.get(value);
-  const newValue = transformCachableValue(value);
-  if (newValue !== value) {
-    transformCache.set(value, newValue);
-    reverseTransformCache.set(newValue, value);
-  }
-  return newValue;
-}
-var unwrap = (value) => reverseTransformCache.get(value);
-
-// node_modules/idb/build/esm/index.js
-function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
-  const request = indexedDB.open(name, version);
-  const openPromise = wrap(request);
-  if (upgrade) {
-    request.addEventListener("upgradeneeded", (event) => {
-      upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction));
-    });
-  }
-  if (blocked)
-    request.addEventListener("blocked", () => blocked());
-  openPromise.then((db) => {
-    if (terminated)
-      db.addEventListener("close", () => terminated());
-    if (blocking)
-      db.addEventListener("versionchange", () => blocking());
-  }).catch(() => {
-  });
-  return openPromise;
-}
-function deleteDB(name, { blocked } = {}) {
-  const request = indexedDB.deleteDatabase(name);
-  if (blocked)
-    request.addEventListener("blocked", () => blocked());
-  return wrap(request).then(() => void 0);
-}
-var readMethods = ["get", "getKey", "getAll", "getAllKeys", "count"];
-var writeMethods = ["put", "add", "delete", "clear"];
-var cachedMethods = /* @__PURE__ */ new Map();
-function getMethod(target, prop) {
-  if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === "string")) {
-    return;
-  }
-  if (cachedMethods.get(prop))
-    return cachedMethods.get(prop);
-  const targetFuncName = prop.replace(/FromIndex$/, "");
-  const useIndex = prop !== targetFuncName;
-  const isWrite = writeMethods.includes(targetFuncName);
-  if (!(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) {
-    return;
-  }
-  const method = function(storeName, ...args) {
-    return __async(this, null, function* () {
-      const tx = this.transaction(storeName, isWrite ? "readwrite" : "readonly");
-      let target2 = tx.store;
-      if (useIndex)
-        target2 = target2.index(args.shift());
-      return (yield Promise.all([
-        target2[targetFuncName](...args),
-        isWrite && tx.done
-      ]))[0];
-    });
-  };
-  cachedMethods.set(prop, method);
-  return method;
-}
-replaceTraps((oldTraps) => __spreadProps(__spreadValues({}, oldTraps), {
-  get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
-  has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
-}));
-
-// node_modules/workbox-expiration/_version.js
-try {
-  self["workbox:expiration:6.2.4"] && _();
-} catch (e) {
-}
-
-// node_modules/workbox-expiration/models/CacheTimestampsModel.js
-var DB_NAME = "workbox-expiration";
-var CACHE_OBJECT_STORE = "cache-entries";
-var normalizeURL = (unNormalizedUrl) => {
-  const url = new URL(unNormalizedUrl, location.href);
-  url.hash = "";
-  return url.href;
-};
-var CacheTimestampsModel = class {
-  constructor(cacheName) {
-    this._db = null;
-    this._cacheName = cacheName;
-  }
-  _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);
-    }
-  }
-  setTimestamp(url, timestamp) {
-    return __async(this, null, function* () {
-      url = normalizeURL(url);
-      const entry = {
-        url,
-        timestamp,
-        cacheName: this._cacheName,
-        id: this._getId(url)
-      };
-      const db = yield this.getDb();
-      const tx = db.transaction(CACHE_OBJECT_STORE, "readwrite", { durability: "relaxed" });
-      yield tx.store.put(entry);
-      yield tx.done;
-    });
-  }
-  getTimestamp(url) {
-    return __async(this, null, function* () {
-      const db = yield this.getDb();
-      const entry = yield db.get(CACHE_OBJECT_STORE, this._getId(url));
-      return entry === null || entry === void 0 ? void 0 : entry.timestamp;
-    });
-  }
-  expireEntries(minTimestamp, maxCount) {
-    return __async(this, null, function* () {
-      const db = yield this.getDb();
-      let cursor = yield db.transaction(CACHE_OBJECT_STORE).store.index("timestamp").openCursor(null, "prev");
-      const entriesToDelete = [];
-      let entriesNotDeletedCount = 0;
-      while (cursor) {
-        const result = cursor.value;
-        if (result.cacheName === this._cacheName) {
-          if (minTimestamp && result.timestamp < minTimestamp || maxCount && entriesNotDeletedCount >= maxCount) {
-            entriesToDelete.push(cursor.value);
-          } else {
-            entriesNotDeletedCount++;
-          }
-        }
-        cursor = yield cursor.continue();
-      }
-      const urlsDeleted = [];
-      for (const entry of entriesToDelete) {
-        yield db.delete(CACHE_OBJECT_STORE, entry.id);
-        urlsDeleted.push(entry.url);
-      }
-      return urlsDeleted;
-    });
-  }
-  _getId(url) {
-    return this._cacheName + "|" + normalizeURL(url);
-  }
-  getDb() {
-    return __async(this, null, function* () {
-      if (!this._db) {
-        this._db = yield openDB(DB_NAME, 1, {
-          upgrade: this._upgradeDbAndDeleteOldDbs.bind(this)
-        });
-      }
-      return this._db;
-    });
-  }
-};
-
-// node_modules/workbox-expiration/CacheExpiration.js
-var CacheExpiration = class {
-  constructor(cacheName, config = {}) {
-    this._isRunning = false;
-    this._rerunRequested = false;
-    if (false) {
-      finalAssertExports.isType(cacheName, "string", {
-        moduleName: "workbox-expiration",
-        className: "CacheExpiration",
-        funcName: "constructor",
-        paramName: "cacheName"
-      });
-      if (!(config.maxEntries || config.maxAgeSeconds)) {
-        throw new WorkboxError("max-entries-or-age-required", {
-          moduleName: "workbox-expiration",
-          className: "CacheExpiration",
-          funcName: "constructor"
-        });
-      }
-      if (config.maxEntries) {
-        finalAssertExports.isType(config.maxEntries, "number", {
-          moduleName: "workbox-expiration",
-          className: "CacheExpiration",
-          funcName: "constructor",
-          paramName: "config.maxEntries"
-        });
-      }
-      if (config.maxAgeSeconds) {
-        finalAssertExports.isType(config.maxAgeSeconds, "number", {
-          moduleName: "workbox-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);
-  }
-  expireEntries() {
-    return __async(this, null, function* () {
-      if (this._isRunning) {
-        this._rerunRequested = true;
-        return;
-      }
-      this._isRunning = true;
-      const minTimestamp = this._maxAgeSeconds ? Date.now() - this._maxAgeSeconds * 1e3 : 0;
-      const urlsExpired = yield this._timestampModel.expireEntries(minTimestamp, this._maxEntries);
-      const cache = yield self.caches.open(this._cacheName);
-      for (const url of urlsExpired) {
-        yield cache.delete(url, this._matchOptions);
-      }
-      if (false) {
-        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"}:`);
-          urlsExpired.forEach((url) => 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;
-        dontWaitFor(this.expireEntries());
-      }
-    });
-  }
-  updateTimestamp(url) {
-    return __async(this, null, function* () {
-      if (false) {
-        finalAssertExports.isType(url, "string", {
-          moduleName: "workbox-expiration",
-          className: "CacheExpiration",
-          funcName: "updateTimestamp",
-          paramName: "url"
-        });
-      }
-      yield this._timestampModel.setTimestamp(url, Date.now());
-    });
-  }
-  isURLExpired(url) {
-    return __async(this, null, function* () {
-      if (!this._maxAgeSeconds) {
-        if (false) {
-          throw new WorkboxError(`expired-test-without-max-age`, {
-            methodName: "isURLExpired",
-            paramName: "maxAgeSeconds"
-          });
-        }
-        return false;
-      } else {
-        const timestamp = yield this._timestampModel.getTimestamp(url);
-        const expireOlderThan = Date.now() - this._maxAgeSeconds * 1e3;
-        return timestamp !== void 0 ? timestamp < expireOlderThan : true;
-      }
-    });
-  }
-  delete() {
-    return __async(this, null, function* () {
-      this._rerunRequested = false;
-      yield this._timestampModel.expireEntries(Infinity);
-    });
-  }
-};
-
-// node_modules/workbox-expiration/ExpirationPlugin.js
-var ExpirationPlugin = class {
-  constructor(config = {}) {
-    this.cachedResponseWillBeUsed = (_0) => __async(this, [_0], function* ({ event, request, cacheName, cachedResponse }) {
-      if (!cachedResponse) {
-        return null;
-      }
-      const isFresh = this._isResponseDateFresh(cachedResponse);
-      const cacheExpiration = this._getCacheExpiration(cacheName);
-      dontWaitFor(cacheExpiration.expireEntries());
-      const updateTimestampDone = cacheExpiration.updateTimestamp(request.url);
-      if (event) {
-        try {
-          event.waitUntil(updateTimestampDone);
-        } catch (error) {
-          if (false) {
-            if ("request" in event) {
-              logger.warn(`Unable to ensure service worker stays alive when updating cache entry for '${getFriendlyURL(event.request.url)}'.`);
-            }
-          }
-        }
-      }
-      return isFresh ? cachedResponse : null;
-    });
-    this.cacheDidUpdate = (_0) => __async(this, [_0], function* ({ cacheName, request }) {
-      if (false) {
-        finalAssertExports.isType(cacheName, "string", {
-          moduleName: "workbox-expiration",
-          className: "Plugin",
-          funcName: "cacheDidUpdate",
-          paramName: "cacheName"
-        });
-        finalAssertExports.isInstance(request, Request, {
-          moduleName: "workbox-expiration",
-          className: "Plugin",
-          funcName: "cacheDidUpdate",
-          paramName: "request"
-        });
-      }
-      const cacheExpiration = this._getCacheExpiration(cacheName);
-      yield cacheExpiration.updateTimestamp(request.url);
-      yield cacheExpiration.expireEntries();
-    });
-    if (false) {
-      if (!(config.maxEntries || config.maxAgeSeconds)) {
-        throw new WorkboxError("max-entries-or-age-required", {
-          moduleName: "workbox-expiration",
-          className: "Plugin",
-          funcName: "constructor"
-        });
-      }
-      if (config.maxEntries) {
-        finalAssertExports.isType(config.maxEntries, "number", {
-          moduleName: "workbox-expiration",
-          className: "Plugin",
-          funcName: "constructor",
-          paramName: "config.maxEntries"
-        });
-      }
-      if (config.maxAgeSeconds) {
-        finalAssertExports.isType(config.maxAgeSeconds, "number", {
-          moduleName: "workbox-expiration",
-          className: "Plugin",
-          funcName: "constructor",
-          paramName: "config.maxAgeSeconds"
-        });
-      }
-    }
-    this._config = config;
-    this._maxAgeSeconds = config.maxAgeSeconds;
-    this._cacheExpirations = /* @__PURE__ */ new Map();
-    if (config.purgeOnQuotaError) {
-      registerQuotaErrorCallback(() => this.deleteCacheAndMetadata());
-    }
-  }
-  _getCacheExpiration(cacheName) {
-    if (cacheName === cacheNames.getRuntimeName()) {
-      throw new WorkboxError("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;
-  }
-  _isResponseDateFresh(cachedResponse) {
-    if (!this._maxAgeSeconds) {
-      return true;
-    }
-    const dateHeaderTimestamp = this._getDateHeaderTimestamp(cachedResponse);
-    if (dateHeaderTimestamp === null) {
-      return true;
-    }
-    const now = Date.now();
-    return dateHeaderTimestamp >= now - this._maxAgeSeconds * 1e3;
-  }
-  _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 (isNaN(headerTime)) {
-      return null;
-    }
-    return headerTime;
-  }
-  deleteCacheAndMetadata() {
-    return __async(this, null, function* () {
-      for (const [cacheName, cacheExpiration] of this._cacheExpirations) {
-        yield self.caches.delete(cacheName);
-        yield cacheExpiration.delete();
-      }
-      this._cacheExpirations = /* @__PURE__ */ new Map();
-    });
-  }
-};
-
-// node_modules/workbox-strategies/_version.js
-try {
-  self["workbox:strategies:6.2.4"] && _();
-} catch (e) {
-}
-
-// node_modules/workbox-strategies/StrategyHandler.js
-function toRequest(input) {
-  return typeof input === "string" ? new Request(input) : input;
-}
-var StrategyHandler = class {
-  constructor(strategy, options) {
-    this._cacheKeys = {};
-    if (false) {
-      finalAssertExports.isInstance(options.event, ExtendableEvent, {
-        moduleName: "workbox-strategies",
-        className: "StrategyHandler",
-        funcName: "constructor",
-        paramName: "options.event"
-      });
-    }
-    Object.assign(this, options);
-    this.event = options.event;
-    this._strategy = strategy;
-    this._handlerDeferred = new Deferred();
-    this._extendLifetimePromises = [];
-    this._plugins = [...strategy.plugins];
-    this._pluginStateMap = /* @__PURE__ */ new Map();
-    for (const plugin of this._plugins) {
-      this._pluginStateMap.set(plugin, {});
-    }
-    this.event.waitUntil(this._handlerDeferred.promise);
-  }
-  fetch(input) {
-    return __async(this, null, function* () {
-      const { event } = this;
-      let request = toRequest(input);
-      if (request.mode === "navigate" && event instanceof FetchEvent && event.preloadResponse) {
-        const possiblePreloadResponse = yield event.preloadResponse;
-        if (possiblePreloadResponse) {
-          if (false) {
-            logger.log(`Using a preloaded navigation response for '${getFriendlyURL(request.url)}'`);
-          }
-          return possiblePreloadResponse;
-        }
-      }
-      const originalRequest = this.hasCallback("fetchDidFail") ? request.clone() : null;
-      try {
-        for (const cb of this.iterateCallbacks("requestWillFetch")) {
-          request = yield cb({ request: request.clone(), event });
-        }
-      } catch (err) {
-        if (err instanceof Error) {
-          throw new WorkboxError("plugin-error-request-will-fetch", { thrownErrorMessage: err.message });
-        }
-      }
-      const pluginFilteredRequest = request.clone();
-      try {
-        let fetchResponse;
-        fetchResponse = yield fetch(request, request.mode === "navigate" ? void 0 : this._strategy.fetchOptions);
-        if (false) {
-          logger.debug(`Network request for '${getFriendlyURL(request.url)}' returned a response with status '${fetchResponse.status}'.`);
-        }
-        for (const callback of this.iterateCallbacks("fetchDidSucceed")) {
-          fetchResponse = yield callback({
-            event,
-            request: pluginFilteredRequest,
-            response: fetchResponse
-          });
-        }
-        return fetchResponse;
-      } catch (error) {
-        if (false) {
-          logger.log(`Network request for '${getFriendlyURL(request.url)}' threw an error.`, error);
-        }
-        if (originalRequest) {
-          yield this.runCallbacks("fetchDidFail", {
-            error,
-            event,
-            originalRequest: originalRequest.clone(),
-            request: pluginFilteredRequest.clone()
-          });
-        }
-        throw error;
-      }
-    });
-  }
-  fetchAndCachePut(input) {
-    return __async(this, null, function* () {
-      const response = yield this.fetch(input);
-      const responseClone = response.clone();
-      void this.waitUntil(this.cachePut(input, responseClone));
-      return response;
-    });
-  }
-  cacheMatch(key) {
-    return __async(this, null, function* () {
-      const request = toRequest(key);
-      let cachedResponse;
-      const { cacheName, matchOptions } = this._strategy;
-      const effectiveRequest = yield this.getCacheKey(request, "read");
-      const multiMatchOptions = Object.assign(Object.assign({}, matchOptions), { cacheName });
-      cachedResponse = yield caches.match(effectiveRequest, multiMatchOptions);
-      if (false) {
-        if (cachedResponse) {
-          logger.debug(`Found a cached response in '${cacheName}'.`);
-        } else {
-          logger.debug(`No cached response found in '${cacheName}'.`);
-        }
-      }
-      for (const callback of this.iterateCallbacks("cachedResponseWillBeUsed")) {
-        cachedResponse = (yield callback({
-          cacheName,
-          matchOptions,
-          cachedResponse,
-          request: effectiveRequest,
-          event: this.event
-        })) || void 0;
-      }
-      return cachedResponse;
-    });
-  }
-  cachePut(key, response) {
-    return __async(this, null, function* () {
-      const request = toRequest(key);
-      yield timeout(0);
-      const effectiveRequest = yield this.getCacheKey(request, "write");
-      if (false) {
-        if (effectiveRequest.method && effectiveRequest.method !== "GET") {
-          throw new WorkboxError("attempt-to-cache-non-get-request", {
-            url: getFriendlyURL(effectiveRequest.url),
-            method: effectiveRequest.method
-          });
-        }
-        const vary = response.headers.get("Vary");
-        if (vary) {
-          logger.debug(`The response for ${getFriendlyURL(effectiveRequest.url)} has a 'Vary: ${vary}' header. Consider setting the {ignoreVary: true} option on your strategy to ensure cache matching and deletion works as expected.`);
-        }
-      }
-      if (!response) {
-        if (false) {
-          logger.error(`Cannot cache non-existent response for '${getFriendlyURL(effectiveRequest.url)}'.`);
-        }
-        throw new WorkboxError("cache-put-with-no-response", {
-          url: getFriendlyURL(effectiveRequest.url)
-        });
-      }
-      const responseToCache = yield this._ensureResponseSafeToCache(response);
-      if (!responseToCache) {
-        if (false) {
-          logger.debug(`Response '${getFriendlyURL(effectiveRequest.url)}' will not be cached.`, responseToCache);
-        }
-        return false;
-      }
-      const { cacheName, matchOptions } = this._strategy;
-      const cache = yield self.caches.open(cacheName);
-      const hasCacheUpdateCallback = this.hasCallback("cacheDidUpdate");
-      const oldResponse = hasCacheUpdateCallback ? yield cacheMatchIgnoreParams(cache, effectiveRequest.clone(), ["__WB_REVISION__"], matchOptions) : null;
-      if (false) {
-        logger.debug(`Updating the '${cacheName}' cache with a new Response for ${getFriendlyURL(effectiveRequest.url)}.`);
-      }
-      try {
-        yield cache.put(effectiveRequest, hasCacheUpdateCallback ? responseToCache.clone() : responseToCache);
-      } catch (error) {
-        if (error instanceof Error) {
-          if (error.name === "QuotaExceededError") {
-            yield executeQuotaErrorCallbacks();
-          }
-          throw error;
-        }
-      }
-      for (const callback of this.iterateCallbacks("cacheDidUpdate")) {
-        yield callback({
-          cacheName,
-          oldResponse,
-          newResponse: responseToCache.clone(),
-          request: effectiveRequest,
-          event: this.event
-        });
-      }
-      return true;
-    });
-  }
-  getCacheKey(request, mode) {
-    return __async(this, null, function* () {
-      if (!this._cacheKeys[mode]) {
-        let effectiveRequest = request;
-        for (const callback of this.iterateCallbacks("cacheKeyWillBeUsed")) {
-          effectiveRequest = toRequest(yield callback({
-            mode,
-            request: effectiveRequest,
-            event: this.event,
-            params: this.params
-          }));
-        }
-        this._cacheKeys[mode] = effectiveRequest;
-      }
-      return this._cacheKeys[mode];
-    });
-  }
-  hasCallback(name) {
-    for (const plugin of this._strategy.plugins) {
-      if (name in plugin) {
-        return true;
-      }
-    }
-    return false;
-  }
-  runCallbacks(name, param) {
-    return __async(this, null, function* () {
-      for (const callback of this.iterateCallbacks(name)) {
-        yield callback(param);
-      }
-    });
-  }
-  *iterateCallbacks(name) {
-    for (const plugin of this._strategy.plugins) {
-      if (typeof plugin[name] === "function") {
-        const state = this._pluginStateMap.get(plugin);
-        const statefulCallback = (param) => {
-          const statefulParam = Object.assign(Object.assign({}, param), { state });
-          return plugin[name](statefulParam);
-        };
-        yield statefulCallback;
-      }
-    }
-  }
-  waitUntil(promise) {
-    this._extendLifetimePromises.push(promise);
-    return promise;
-  }
-  doneWaiting() {
-    return __async(this, null, function* () {
-      let promise;
-      while (promise = this._extendLifetimePromises.shift()) {
-        yield promise;
-      }
-    });
-  }
-  destroy() {
-    this._handlerDeferred.resolve(null);
-  }
-  _ensureResponseSafeToCache(response) {
-    return __async(this, null, function* () {
-      let responseToCache = response;
-      let pluginsUsed = false;
-      for (const callback of this.iterateCallbacks("cacheWillUpdate")) {
-        responseToCache = (yield callback({
-          request: this.request,
-          response: responseToCache,
-          event: this.event
-        })) || void 0;
-        pluginsUsed = true;
-        if (!responseToCache) {
-          break;
-        }
-      }
-      if (!pluginsUsed) {
-        if (responseToCache && responseToCache.status !== 200) {
-          responseToCache = void 0;
-        }
-        if (false) {
-          if (responseToCache) {
-            if (responseToCache.status !== 200) {
-              if (responseToCache.status === 0) {
-                logger.warn(`The response for '${this.request.url}' is an opaque response. The caching strategy that you're using will not cache opaque responses by default.`);
-              } else {
-                logger.debug(`The response for '${this.request.url}' returned a status code of '${response.status}' and won't be cached as a result.`);
-              }
-            }
-          }
-        }
-      }
-      return responseToCache;
-    });
-  }
-};
-
-// node_modules/workbox-strategies/Strategy.js
-var Strategy = class {
-  constructor(options = {}) {
-    this.cacheName = cacheNames.getRuntimeName(options.cacheName);
-    this.plugins = options.plugins || [];
-    this.fetchOptions = options.fetchOptions;
-    this.matchOptions = options.matchOptions;
-  }
-  handle(options) {
-    const [responseDone] = this.handleAll(options);
-    return responseDone;
-  }
-  handleAll(options) {
-    if (options instanceof FetchEvent) {
-      options = {
-        event: options,
-        request: options.request
-      };
-    }
-    const event = options.event;
-    const request = typeof options.request === "string" ? new Request(options.request) : options.request;
-    const params = "params" in options ? options.params : void 0;
-    const handler = new StrategyHandler(this, { event, request, params });
-    const responseDone = this._getResponse(handler, request, event);
-    const handlerDone = this._awaitComplete(responseDone, handler, request, event);
-    return [responseDone, handlerDone];
-  }
-  _getResponse(handler, request, event) {
-    return __async(this, null, function* () {
-      yield handler.runCallbacks("handlerWillStart", { event, request });
-      let response = void 0;
-      try {
-        response = yield this._handle(request, handler);
-        if (!response || response.type === "error") {
-          throw new WorkboxError("no-response", { url: request.url });
-        }
-      } catch (error) {
-        if (error instanceof Error) {
-          for (const callback of handler.iterateCallbacks("handlerDidError")) {
-            response = yield callback({ error, event, request });
-            if (response) {
-              break;
-            }
-          }
-        }
-        if (!response) {
-          throw error;
-        } else if (false) {
-          logger.log(`While responding to '${getFriendlyURL(request.url)}', an ${error instanceof Error ? error.toString() : ""} error occurred. Using a fallback response provided by a handlerDidError plugin.`);
-        }
-      }
-      for (const callback of handler.iterateCallbacks("handlerWillRespond")) {
-        response = yield callback({ event, request, response });
-      }
-      return response;
-    });
-  }
-  _awaitComplete(responseDone, handler, request, event) {
-    return __async(this, null, function* () {
-      let response;
-      let error;
-      try {
-        response = yield responseDone;
-      } catch (error2) {
-      }
-      try {
-        yield handler.runCallbacks("handlerDidRespond", {
-          event,
-          request,
-          response
-        });
-        yield handler.doneWaiting();
-      } catch (waitUntilError) {
-        if (waitUntilError instanceof Error) {
-          error = waitUntilError;
-        }
-      }
-      yield handler.runCallbacks("handlerDidComplete", {
-        event,
-        request,
-        response,
-        error
-      });
-      handler.destroy();
-      if (error) {
-        throw error;
-      }
-    });
-  }
-};
-
-// node_modules/workbox-strategies/CacheFirst.js
-var CacheFirst = class extends Strategy {
-  _handle(request, handler) {
-    return __async(this, null, function* () {
-      const logs = [];
-      if (false) {
-        finalAssertExports.isInstance(request, Request, {
-          moduleName: "workbox-strategies",
-          className: this.constructor.name,
-          funcName: "makeRequest",
-          paramName: "request"
-        });
-      }
-      let response = yield handler.cacheMatch(request);
-      let error = void 0;
-      if (!response) {
-        if (false) {
-          logs.push(`No response found in the '${this.cacheName}' cache. Will respond with a network request.`);
-        }
-        try {
-          response = yield handler.fetchAndCachePut(request);
-        } catch (err) {
-          if (err instanceof Error) {
-            error = err;
-          }
-        }
-        if (false) {
-          if (response) {
-            logs.push(`Got response from network.`);
-          } else {
-            logs.push(`Unable to get a response from the network.`);
-          }
-        }
-      } else {
-        if (false) {
-          logs.push(`Found a cached response in the '${this.cacheName}' cache.`);
-        }
-      }
-      if (false) {
-        logger.groupCollapsed(messages2.strategyStart(this.constructor.name, request));
-        for (const log2 of logs) {
-          logger.log(log2);
-        }
-        messages2.printFinalResponse(response);
-        logger.groupEnd();
-      }
-      if (!response) {
-        throw new WorkboxError("no-response", { url: request.url, error });
-      }
-      return response;
-    });
-  }
-};
-
-// node_modules/workbox-strategies/plugins/cacheOkAndOpaquePlugin.js
-var cacheOkAndOpaquePlugin = {
-  cacheWillUpdate: (_0) => __async(void 0, [_0], function* ({ response }) {
-    if (response.status === 200 || response.status === 0) {
-      return response;
-    }
-    return null;
-  })
-};
-
-// node_modules/workbox-strategies/StaleWhileRevalidate.js
-var StaleWhileRevalidate = class extends Strategy {
-  constructor(options = {}) {
-    super(options);
-    if (!this.plugins.some((p) => "cacheWillUpdate" in p)) {
-      this.plugins.unshift(cacheOkAndOpaquePlugin);
-    }
-  }
-  _handle(request, handler) {
-    return __async(this, null, function* () {
-      const logs = [];
-      if (false) {
-        finalAssertExports.isInstance(request, Request, {
-          moduleName: "workbox-strategies",
-          className: this.constructor.name,
-          funcName: "handle",
-          paramName: "request"
-        });
-      }
-      const fetchAndCachePromise = handler.fetchAndCachePut(request).catch(() => {
-      });
-      let response = yield handler.cacheMatch(request);
-      let error;
-      if (response) {
-        if (false) {
-          logs.push(`Found a cached response in the '${this.cacheName}' cache. Will update with the network response in the background.`);
-        }
-      } else {
-        if (false) {
-          logs.push(`No response found in the '${this.cacheName}' cache. Will wait for the network response.`);
-        }
-        try {
-          response = yield fetchAndCachePromise;
-        } catch (err) {
-          if (err instanceof Error) {
-            error = err;
-          }
-        }
-      }
-      if (false) {
-        logger.groupCollapsed(messages2.strategyStart(this.constructor.name, request));
-        for (const log2 of logs) {
-          logger.log(log2);
-        }
-        messages2.printFinalResponse(response);
-        logger.groupEnd();
-      }
-      if (!response) {
-        throw new WorkboxError("no-response", { url: request.url, error });
-      }
-      return response;
-    });
-  }
-};
-
-// src/constants.ts
-var IS_DEV = false;
-var HEADER_HEIGHT = 48;
-var FOOTER_HEIGHT = 48;
-var CHROME_HEIGHT = HEADER_HEIGHT + FOOTER_HEIGHT;
-var DEFAULT_HEIGHT = `calc(100vh - ${CHROME_HEIGHT}px)`;
-
-// src/ServiceWorker/constants.ts
-var WEBPUB_CACHE_NAME = "webpub-cache";
-var PRECACHE_PUBLICATIONS = "PRECACHE_PUBLICATIONS";
-var CACHE_EXPIRATION_SECONDS = 7 * 24 * 60 * 60;
-
-// node_modules/workbox-routing/_version.js
-try {
-  self["workbox:routing:6.2.4"] && _();
-} catch (e) {
-}
-
-// node_modules/workbox-routing/utils/constants.js
-var defaultMethod = "GET";
-
-// node_modules/workbox-routing/utils/normalizeHandler.js
-var normalizeHandler = (handler) => {
-  if (handler && typeof handler === "object") {
-    if (false) {
-      finalAssertExports.hasMethod(handler, "handle", {
-        moduleName: "workbox-routing",
-        className: "Route",
-        funcName: "constructor",
-        paramName: "handler"
-      });
-    }
-    return handler;
-  } else {
-    if (false) {
-      finalAssertExports.isType(handler, "function", {
-        moduleName: "workbox-routing",
-        className: "Route",
-        funcName: "constructor",
-        paramName: "handler"
-      });
-    }
-    return { handle: handler };
-  }
-};
-
-// node_modules/workbox-routing/Route.js
-var Route = class {
-  constructor(match, handler, method = defaultMethod) {
-    if (false) {
-      finalAssertExports.isType(match, "function", {
-        moduleName: "workbox-routing",
-        className: "Route",
-        funcName: "constructor",
-        paramName: "match"
-      });
-      if (method) {
-        finalAssertExports.isOneOf(method, validMethods, { paramName: "method" });
-      }
-    }
-    this.handler = normalizeHandler(handler);
-    this.match = match;
-    this.method = method;
-  }
-  setCatchHandler(handler) {
-    this.catchHandler = normalizeHandler(handler);
-  }
-};
-
-// node_modules/workbox-routing/RegExpRoute.js
-var RegExpRoute = class extends Route {
-  constructor(regExp, handler, method) {
-    if (false) {
-      finalAssertExports.isInstance(regExp, RegExp, {
-        moduleName: "workbox-routing",
-        className: "RegExpRoute",
-        funcName: "constructor",
-        paramName: "pattern"
-      });
-    }
-    const match = ({ url }) => {
-      const result = regExp.exec(url.href);
-      if (!result) {
-        return;
-      }
-      if (url.origin !== location.origin && result.index !== 0) {
-        if (false) {
-          logger.debug(`The regular expression '${regExp.toString()}' only partially matched against the cross-origin URL '${url.toString()}'. RegExpRoute's will only handle cross-origin requests if they match the entire URL.`);
-        }
-        return;
-      }
-      return result.slice(1);
-    };
-    super(match, handler, method);
-  }
-};
-
-// node_modules/workbox-routing/Router.js
-var Router = class {
-  constructor() {
-    this._routes = /* @__PURE__ */ new Map();
-    this._defaultHandlerMap = /* @__PURE__ */ new Map();
-  }
-  get routes() {
-    return this._routes;
-  }
-  addFetchListener() {
-    self.addEventListener("fetch", (event) => {
-      const { request } = event;
-      const responsePromise = this.handleRequest({ request, event });
-      if (responsePromise) {
-        event.respondWith(responsePromise);
-      }
-    });
-  }
-  addCacheListener() {
-    self.addEventListener("message", (event) => {
-      if (event.data && event.data.type === "CACHE_URLS") {
-        const { payload } = event.data;
-        if (false) {
-          logger.debug(`Caching URLs from the window`, payload.urlsToCache);
-        }
-        const requestPromises = Promise.all(payload.urlsToCache.map((entry) => {
-          if (typeof entry === "string") {
-            entry = [entry];
-          }
-          const request = new Request(...entry);
-          return this.handleRequest({ request, event });
-        }));
-        event.waitUntil(requestPromises);
-        if (event.ports && event.ports[0]) {
-          void requestPromises.then(() => event.ports[0].postMessage(true));
-        }
-      }
-    });
-  }
-  handleRequest({ request, event }) {
-    if (false) {
-      finalAssertExports.isInstance(request, Request, {
-        moduleName: "workbox-routing",
-        className: "Router",
-        funcName: "handleRequest",
-        paramName: "options.request"
-      });
-    }
-    const url = new URL(request.url, location.href);
-    if (!url.protocol.startsWith("http")) {
-      if (false) {
-        logger.debug(`Workbox Router only supports URLs that start with 'http'.`);
-      }
-      return;
-    }
-    const sameOrigin = url.origin === location.origin;
-    const { params, route } = this.findMatchingRoute({
-      event,
-      request,
-      sameOrigin,
-      url
-    });
-    let handler = route && route.handler;
-    const debugMessages = [];
-    if (false) {
-      if (handler) {
-        debugMessages.push([
-          `Found a route to handle this request:`,
-          route
-        ]);
-        if (params) {
-          debugMessages.push([
-            `Passing the following params to the route's handler:`,
-            params
-          ]);
-        }
-      }
-    }
-    const method = request.method;
-    if (!handler && this._defaultHandlerMap.has(method)) {
-      if (false) {
-        debugMessages.push(`Failed to find a matching route. Falling back to the default handler for ${method}.`);
-      }
-      handler = this._defaultHandlerMap.get(method);
-    }
-    if (!handler) {
-      if (false) {
-        logger.debug(`No route found for: ${getFriendlyURL(url)}`);
-      }
-      return;
-    }
-    if (false) {
-      logger.groupCollapsed(`Router is responding to: ${getFriendlyURL(url)}`);
-      debugMessages.forEach((msg) => {
-        if (Array.isArray(msg)) {
-          logger.log(...msg);
-        } else {
-          logger.log(msg);
-        }
-      });
-      logger.groupEnd();
-    }
-    let responsePromise;
-    try {
-      responsePromise = handler.handle({ url, request, event, params });
-    } catch (err) {
-      responsePromise = Promise.reject(err);
-    }
-    const catchHandler = route && route.catchHandler;
-    if (responsePromise instanceof Promise && (this._catchHandler || catchHandler)) {
-      responsePromise = responsePromise.catch((err) => __async(this, null, function* () {
-        if (catchHandler) {
-          if (false) {
-            logger.groupCollapsed(`Error thrown when responding to:  ${getFriendlyURL(url)}. Falling back to route's Catch Handler.`);
-            logger.error(`Error thrown by:`, route);
-            logger.error(err);
-            logger.groupEnd();
-          }
-          try {
-            return yield catchHandler.handle({ url, request, event, params });
-          } catch (catchErr) {
-            if (catchErr instanceof Error) {
-              err = catchErr;
-            }
-          }
-        }
-        if (this._catchHandler) {
-          if (false) {
-            logger.groupCollapsed(`Error thrown when responding to:  ${getFriendlyURL(url)}. Falling back to global Catch Handler.`);
-            logger.error(`Error thrown by:`, route);
-            logger.error(err);
-            logger.groupEnd();
-          }
-          return this._catchHandler.handle({ url, request, event });
-        }
-        throw err;
-      }));
-    }
-    return responsePromise;
-  }
-  findMatchingRoute({ url, sameOrigin, request, event }) {
-    const routes = this._routes.get(request.method) || [];
-    for (const route of routes) {
-      let params;
-      const matchResult = route.match({ url, sameOrigin, request, event });
-      if (matchResult) {
-        if (false) {
-          if (matchResult instanceof Promise) {
-            logger.warn(`While routing ${getFriendlyURL(url)}, an async matchCallback function was used. Please convert the following route to use a synchronous matchCallback function:`, route);
-          }
-        }
-        params = matchResult;
-        if (Array.isArray(params) && params.length === 0) {
-          params = void 0;
-        } else if (matchResult.constructor === Object && Object.keys(matchResult).length === 0) {
-          params = void 0;
-        } else if (typeof matchResult === "boolean") {
-          params = void 0;
-        }
-        return { route, params };
-      }
-    }
-    return {};
-  }
-  setDefaultHandler(handler, method = defaultMethod) {
-    this._defaultHandlerMap.set(method, normalizeHandler(handler));
-  }
-  setCatchHandler(handler) {
-    this._catchHandler = normalizeHandler(handler);
-  }
-  registerRoute(route) {
-    if (false) {
-      finalAssertExports.isType(route, "object", {
-        moduleName: "workbox-routing",
-        className: "Router",
-        funcName: "registerRoute",
-        paramName: "route"
-      });
-      finalAssertExports.hasMethod(route, "match", {
-        moduleName: "workbox-routing",
-        className: "Router",
-        funcName: "registerRoute",
-        paramName: "route"
-      });
-      finalAssertExports.isType(route.handler, "object", {
-        moduleName: "workbox-routing",
-        className: "Router",
-        funcName: "registerRoute",
-        paramName: "route"
-      });
-      finalAssertExports.hasMethod(route.handler, "handle", {
-        moduleName: "workbox-routing",
-        className: "Router",
-        funcName: "registerRoute",
-        paramName: "route.handler"
-      });
-      finalAssertExports.isType(route.method, "string", {
-        moduleName: "workbox-routing",
-        className: "Router",
-        funcName: "registerRoute",
-        paramName: "route.method"
-      });
-    }
-    if (!this._routes.has(route.method)) {
-      this._routes.set(route.method, []);
-    }
-    this._routes.get(route.method).push(route);
-  }
-  unregisterRoute(route) {
-    if (!this._routes.has(route.method)) {
-      throw new WorkboxError("unregister-route-but-not-found-with-method", {
-        method: route.method
-      });
-    }
-    const routeIndex = this._routes.get(route.method).indexOf(route);
-    if (routeIndex > -1) {
-      this._routes.get(route.method).splice(routeIndex, 1);
-    } else {
-      throw new WorkboxError("unregister-route-route-not-registered");
-    }
-  }
-};
-
-// node_modules/workbox-routing/utils/getOrCreateDefaultRouter.js
-var defaultRouter;
-var getOrCreateDefaultRouter = () => {
-  if (!defaultRouter) {
-    defaultRouter = new Router();
-    defaultRouter.addFetchListener();
-    defaultRouter.addCacheListener();
-  }
-  return defaultRouter;
-};
-
-// node_modules/workbox-routing/registerRoute.js
-function registerRoute(capture, handler, method) {
-  let route;
-  if (typeof capture === "string") {
-    const captureUrl = new URL(capture, location.href);
-    if (false) {
-      if (!(capture.startsWith("/") || capture.startsWith("http"))) {
-        throw new WorkboxError("invalid-string", {
-          moduleName: "workbox-routing",
-          funcName: "registerRoute",
-          paramName: "capture"
-        });
-      }
-      const valueToCheck = capture.startsWith("http") ? captureUrl.pathname : capture;
-      const wildcards = "[*:?+]";
-      if (new RegExp(`${wildcards}`).exec(valueToCheck)) {
-        logger.debug(`The '$capture' parameter contains an Express-style wildcard character (${wildcards}). Strings are now always interpreted as exact matches; use a RegExp for partial or wildcard matches.`);
-      }
-    }
-    const matchCallback = ({ url }) => {
-      if (false) {
-        if (url.pathname === captureUrl.pathname && url.origin !== captureUrl.origin) {
-          logger.debug(`${capture} only partially matches the cross-origin URL ${url.toString()}. This route will only handle cross-origin requests if they match the entire URL.`);
-        }
-      }
-      return url.href === captureUrl.href;
-    };
-    route = new Route(matchCallback, handler, method);
-  } else if (capture instanceof RegExp) {
-    route = new RegExpRoute(capture, handler, method);
-  } else if (typeof capture === "function") {
-    route = new Route(capture, handler, method);
-  } else if (capture instanceof Route) {
-    route = capture;
-  } else {
-    throw new WorkboxError("unsupported-route-type", {
-      moduleName: "workbox-routing",
-      funcName: "registerRoute",
-      paramName: "capture"
-    });
-  }
-  const defaultRouter2 = getOrCreateDefaultRouter();
-  defaultRouter2.registerRoute(route);
-  return route;
-}
-
-// src/ServiceWorker/sw.ts
-var VERSION = "v2";
-clientsClaim();
-function initWebReaderSW({
-  cacheExpirationSeconds = CACHE_EXPIRATION_SECONDS
-} = {}) {
-  log("INITIALIZING");
-  self.addEventListener("install", (event) => {
-    log("INSTALLING ");
-    function installSW() {
-      return __async(this, null, function* () {
-        yield self.skipWaiting();
-        log("INSTALLED");
-      });
-    }
-    event.waitUntil(installSW());
-  });
-  self.addEventListener("message", (event) => __async(this, null, function* () {
-    if (event.data.type === PRECACHE_PUBLICATIONS) {
-      log("Precaching publications");
-      if (typeof event.data.publications !== "object") {
-        console.error("Precache event missing publications");
-        return;
-      }
-      yield cachePublications(event.data.publications);
-    }
-  }));
-  const cacheFirst = new CacheFirst({
-    cacheName: WEBPUB_CACHE_NAME,
-    plugins: [
-      new ExpirationPlugin({
-        maxAgeSeconds: cacheExpirationSeconds
-      })
-    ]
-  });
-  function cachePublications(publications) {
-    return __async(this, null, function* () {
-      var _a;
-      const cache = yield caches.open(WEBPUB_CACHE_NAME);
-      for (const pub of publications) {
-        for (const url of (_a = pub.swrUrls) != null ? _a : []) {
-          log(`Routing ${url}`);
-          registerRoute(url, new StaleWhileRevalidate({ cacheName: WEBPUB_CACHE_NAME }));
-        }
-      }
-      const pubResults = yield Promise.allSettled(publications.map((pub) => __async(this, null, function* () {
-        const finalManifestUrl = getProxiedUrl(pub.manifestUrl, pub.proxyUrl);
-        registerRoute(finalManifestUrl, cacheFirst);
-        const match = yield cache.match(finalManifestUrl);
-        if (match) {
-          return __spreadProps(__spreadValues({}, pub), { manifest: yield match.json() });
-        }
-        const manifestResponse = yield fetch(finalManifestUrl);
-        handleBadResponse(finalManifestUrl, manifestResponse);
-        yield cache.put(finalManifestUrl, manifestResponse.clone());
-        const manifest = yield manifestResponse.json();
-        return __spreadProps(__spreadValues({}, pub), { manifest });
-      })));
-      const pubs = pubResults.map((result) => result.status === "fulfilled" ? result.value : void 0).filter(isPub);
-      const promises = pubs.map((pub) => __async(this, null, function* () {
-        var _a2, _b;
-        const resourceHrefs = extractHrefs((_a2 = pub.manifest.resources) != null ? _a2 : [], pub.manifestUrl, pub.proxyUrl);
-        const readingOrderHrefs = extractHrefs((_b = pub.manifest.readingOrder) != null ? _b : [], pub.manifestUrl, pub.proxyUrl);
-        const allResourcesToCache = Array.from(/* @__PURE__ */ new Set([...resourceHrefs, ...readingOrderHrefs]));
-        yield Promise.all(allResourcesToCache.map((url) => __async(this, null, function* () {
-          registerRoute(url, cacheFirst);
-          const match = yield cache.match(url);
-          if (match) {
-            return;
-          }
-          const response = yield fetch(url);
-          handleBadResponse(url, response);
-          return yield cache.put(url, response);
-        })));
-      }));
-      return yield Promise.allSettled(promises);
-    });
-  }
-}
-function isPub(maybe) {
-  return !!maybe;
-}
-function handleBadResponse(url, response) {
-  if (!response.ok) {
-    const message = `Bad response status for: ${url}. Status: ${response.status}`;
-    console.warn(message);
-    throw new Error(message);
-  }
-}
-function getProxiedUrl(url, proxyUrl) {
-  return proxyUrl ? `${proxyUrl}${encodeURIComponent(url)}` : url;
-}
-function getAbsoluteUrl(maybeRelative, manifestUrl, proxyUrl) {
-  return getProxiedUrl(new URL(maybeRelative, manifestUrl).toString(), proxyUrl);
-}
-function extractHrefs(links, manifestUrl, proxyUrl) {
-  return links.map((res) => getAbsoluteUrl(res.href, manifestUrl, proxyUrl));
-}
-function log(message) {
-  if (IS_DEV)
-    console.log(`SW (${VERSION}) -`, message);
-}
-export {
-  initWebReaderSW as default
-};
-//# sourceMappingURL=sw.js.map