@nypl/web-reader 0.1.4 → 0.2.0-alpha.3

package/dist/esm/ServiceWorker/sw.js

@@ -0,0 +1,1263 @@
+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 __require = typeof require !== "undefined" ? require : (x) => {
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+};
+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
+"use strict";
+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 = 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 = new WeakMap();
+var transactionDoneMap = new WeakMap();
+var transactionStoreNamesMap = new WeakMap();
+var transformCache = new WeakMap();
+var reverseTransformCache = 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 = 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
+"use strict";
+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 = 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 = new Map();
+    });
+  }
+};
+
+// node_modules/workbox-strategies/_version.js
+"use strict";
+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 = 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;
+    });
+  }
+};
+
+// src/constants.ts
+var IS_DEV = false;
+
+// src/ServiceWorker/constants.ts
+var WEBPUB_CACHE_NAME = "webpub-cache";
+var CACHE_EXPIRATION_SECONDS = 7 * 24 * 60 * 60;
+
+// src/ServiceWorker/sw.ts
+var VERSION = "v1";
+clientsClaim();
+function initWebReaderSW({
+  cacheExpirationSeconds = CACHE_EXPIRATION_SECONDS
+} = {}) {
+  log("INITIALIZING");
+  self.addEventListener("install", (event) => {
+    log("INSTALLING ");
+    function installSW() {
+      return __async(this, null, function* () {
+        self.skipWaiting();
+        log("INSTALLED");
+      });
+    }
+    event.waitUntil(installSW);
+  });
+  self.addEventListener("fetch", (event) => {
+    if (event.request.method !== "GET") {
+      return;
+    }
+    function matchOrFetch() {
+      return __async(this, null, function* () {
+        const pubCache = yield caches.open(WEBPUB_CACHE_NAME);
+        const match = yield pubCache.match(event.request);
+        if (match) {
+          return new CacheFirst({
+            cacheName: WEBPUB_CACHE_NAME,
+            plugins: [
+              new ExpirationPlugin({
+                maxAgeSeconds: cacheExpirationSeconds
+              })
+            ]
+          }).handle(event);
+        }
+        return fetch(event.request);
+      });
+    }
+    event.respondWith(matchOrFetch());
+  });
+}
+function log(message) {
+  if (IS_DEV)
+    console.log(`SW (${VERSION}) -`, message);
+}
+export {
+  initWebReaderSW as default
+};
+//# sourceMappingURL=sw.js.map