@nypl/web-reader 3.2.3 → 3.2.4

package/dist/esm/ServiceWorker/sw.js

@@ -174,77 +174,12 @@ var cacheNames = {
   }
 };
 
-// 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());
@@ -494,9 +429,7 @@ var CacheTimestampsModel = class {
         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;
+      yield db.put(CACHE_OBJECT_STORE, entry);
     });
   }
   getTimestamp(url) {
@@ -776,9 +709,195 @@ var ExpirationPlugin = class {
   }
 };
 
+// node_modules/workbox-strategies/node_modules/workbox-core/_version.js
+try {
+  self["workbox:core:6.5.3"] && _();
+} catch (e) {
+}
+
+// node_modules/workbox-strategies/node_modules/workbox-core/models/messages/messageGenerator.js
+var fallback2 = (code, ...args) => {
+  let msg = code;
+  if (args.length > 0) {
+    msg += ` :: ${JSON.stringify(args)}`;
+  }
+  return msg;
+};
+var messageGenerator2 = true ? fallback2 : generatorFunction;
+
+// node_modules/workbox-strategies/node_modules/workbox-core/_private/WorkboxError.js
+var WorkboxError2 = class extends Error {
+  constructor(errorCode, details) {
+    const message = messageGenerator2(errorCode, details);
+    super(message);
+    this.name = errorCode;
+    this.details = details;
+  }
+};
+
+// node_modules/workbox-strategies/node_modules/workbox-core/_private/logger.js
+var logger2 = 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-strategies/node_modules/workbox-core/_private/cacheNames.js
+var _cacheNameDetails2 = {
+  googleAnalytics: "googleAnalytics",
+  precache: "precache-v2",
+  prefix: "workbox",
+  runtime: "runtime",
+  suffix: typeof registration !== "undefined" ? registration.scope : ""
+};
+var _createCacheName2 = (cacheName) => {
+  return [_cacheNameDetails2.prefix, cacheName, _cacheNameDetails2.suffix].filter((value) => value && value.length > 0).join("-");
+};
+var eachCacheNameDetail2 = (fn) => {
+  for (const key of Object.keys(_cacheNameDetails2)) {
+    fn(key);
+  }
+};
+var cacheNames3 = {
+  updateDetails: (details) => {
+    eachCacheNameDetail2((key) => {
+      if (typeof details[key] === "string") {
+        _cacheNameDetails2[key] = details[key];
+      }
+    });
+  },
+  getGoogleAnalyticsName: (userCacheName) => {
+    return userCacheName || _createCacheName2(_cacheNameDetails2.googleAnalytics);
+  },
+  getPrecacheName: (userCacheName) => {
+    return userCacheName || _createCacheName2(_cacheNameDetails2.precache);
+  },
+  getPrefix: () => {
+    return _cacheNameDetails2.prefix;
+  },
+  getRuntimeName: (userCacheName) => {
+    return userCacheName || _createCacheName2(_cacheNameDetails2.runtime);
+  },
+  getSuffix: () => {
+    return _cacheNameDetails2.suffix;
+  }
+};
+
+// node_modules/workbox-strategies/node_modules/workbox-core/_private/getFriendlyURL.js
+var getFriendlyURL2 = (url) => {
+  const urlObj = new URL(String(url), location.href);
+  return urlObj.href.replace(new RegExp(`^${location.origin}`), "");
+};
+
+// node_modules/workbox-strategies/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 cacheMatchIgnoreParams2(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-strategies/node_modules/workbox-core/_private/Deferred.js
+var Deferred2 = class {
+  constructor() {
+    this.promise = new Promise((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+  }
+};
+
+// node_modules/workbox-strategies/node_modules/workbox-core/models/quotaErrorCallbacks.js
+var quotaErrorCallbacks2 = /* @__PURE__ */ new Set();
+
+// node_modules/workbox-strategies/node_modules/workbox-core/_private/executeQuotaErrorCallbacks.js
+function executeQuotaErrorCallbacks2() {
+  return __async(this, null, function* () {
+    if (false) {
+      logger2.log(`About to run ${quotaErrorCallbacks2.size} callbacks to clean up caches.`);
+    }
+    for (const callback of quotaErrorCallbacks2) {
+      yield callback();
+      if (false) {
+        logger2.log(callback, "is complete.");
+      }
+    }
+    if (false) {
+      logger2.log("Finished running callbacks.");
+    }
+  });
+}
+
+// node_modules/workbox-strategies/node_modules/workbox-core/_private/timeout.js
+function timeout2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 // node_modules/workbox-strategies/_version.js
 try {
-  self["workbox:strategies:6.2.4"] && _();
+  self["workbox:strategies:6.5.3"] && _();
 } catch (e) {
 }
 
@@ -790,7 +909,7 @@ var StrategyHandler = class {
   constructor(strategy, options) {
     this._cacheKeys = {};
     if (false) {
-      finalAssertExports.isInstance(options.event, ExtendableEvent, {
+      finalAssertExports2.isInstance(options.event, ExtendableEvent, {
         moduleName: "workbox-strategies",
         className: "StrategyHandler",
         funcName: "constructor",
@@ -800,7 +919,7 @@ var StrategyHandler = class {
     Object.assign(this, options);
     this.event = options.event;
     this._strategy = strategy;
-    this._handlerDeferred = new Deferred();
+    this._handlerDeferred = new Deferred2();
     this._extendLifetimePromises = [];
     this._plugins = [...strategy.plugins];
     this._pluginStateMap = /* @__PURE__ */ new Map();
@@ -817,7 +936,7 @@ var StrategyHandler = class {
         const possiblePreloadResponse = yield event.preloadResponse;
         if (possiblePreloadResponse) {
           if (false) {
-            logger.log(`Using a preloaded navigation response for '${getFriendlyURL(request.url)}'`);
+            logger2.log(`Using a preloaded navigation response for '${getFriendlyURL2(request.url)}'`);
           }
           return possiblePreloadResponse;
         }
@@ -829,7 +948,9 @@ var StrategyHandler = class {
         }
       } catch (err) {
         if (err instanceof Error) {
-          throw new WorkboxError("plugin-error-request-will-fetch", { thrownErrorMessage: err.message });
+          throw new WorkboxError2("plugin-error-request-will-fetch", {
+            thrownErrorMessage: err.message
+          });
         }
       }
       const pluginFilteredRequest = request.clone();
@@ -837,7 +958,7 @@ var StrategyHandler = class {
         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}'.`);
+          logger2.debug(`Network request for '${getFriendlyURL2(request.url)}' returned a response with status '${fetchResponse.status}'.`);
         }
         for (const callback of this.iterateCallbacks("fetchDidSucceed")) {
           fetchResponse = yield callback({
@@ -849,7 +970,7 @@ var StrategyHandler = class {
         return fetchResponse;
       } catch (error) {
         if (false) {
-          logger.log(`Network request for '${getFriendlyURL(request.url)}' threw an error.`, error);
+          logger2.log(`Network request for '${getFriendlyURL2(request.url)}' threw an error.`, error);
         }
         if (originalRequest) {
           yield this.runCallbacks("fetchDidFail", {
@@ -881,9 +1002,9 @@ var StrategyHandler = class {
       cachedResponse = yield caches.match(effectiveRequest, multiMatchOptions);
       if (false) {
         if (cachedResponse) {
-          logger.debug(`Found a cached response in '${cacheName}'.`);
+          logger2.debug(`Found a cached response in '${cacheName}'.`);
         } else {
-          logger.debug(`No cached response found in '${cacheName}'.`);
+          logger2.debug(`No cached response found in '${cacheName}'.`);
         }
       }
       for (const callback of this.iterateCallbacks("cachedResponseWillBeUsed")) {
@@ -901,48 +1022,48 @@ var StrategyHandler = class {
   cachePut(key, response) {
     return __async(this, null, function* () {
       const request = toRequest(key);
-      yield timeout(0);
+      yield timeout2(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),
+          throw new WorkboxError2("attempt-to-cache-non-get-request", {
+            url: getFriendlyURL2(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.`);
+          logger2.debug(`The response for ${getFriendlyURL2(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)}'.`);
+          logger2.error(`Cannot cache non-existent response for '${getFriendlyURL2(effectiveRequest.url)}'.`);
         }
-        throw new WorkboxError("cache-put-with-no-response", {
-          url: getFriendlyURL(effectiveRequest.url)
+        throw new WorkboxError2("cache-put-with-no-response", {
+          url: getFriendlyURL2(effectiveRequest.url)
         });
       }
       const responseToCache = yield this._ensureResponseSafeToCache(response);
       if (!responseToCache) {
         if (false) {
-          logger.debug(`Response '${getFriendlyURL(effectiveRequest.url)}' will not be cached.`, responseToCache);
+          logger2.debug(`Response '${getFriendlyURL2(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;
+      const oldResponse = hasCacheUpdateCallback ? yield cacheMatchIgnoreParams2(cache, effectiveRequest.clone(), ["__WB_REVISION__"], matchOptions) : null;
       if (false) {
-        logger.debug(`Updating the '${cacheName}' cache with a new Response for ${getFriendlyURL(effectiveRequest.url)}.`);
+        logger2.debug(`Updating the '${cacheName}' cache with a new Response for ${getFriendlyURL2(effectiveRequest.url)}.`);
       }
       try {
         yield cache.put(effectiveRequest, hasCacheUpdateCallback ? responseToCache.clone() : responseToCache);
       } catch (error) {
         if (error instanceof Error) {
           if (error.name === "QuotaExceededError") {
-            yield executeQuotaErrorCallbacks();
+            yield executeQuotaErrorCallbacks2();
           }
           throw error;
         }
@@ -961,7 +1082,8 @@ var StrategyHandler = class {
   }
   getCacheKey(request, mode) {
     return __async(this, null, function* () {
-      if (!this._cacheKeys[mode]) {
+      const key = `${request.url} | ${mode}`;
+      if (!this._cacheKeys[key]) {
         let effectiveRequest = request;
         for (const callback of this.iterateCallbacks("cacheKeyWillBeUsed")) {
           effectiveRequest = toRequest(yield callback({
@@ -971,9 +1093,9 @@ var StrategyHandler = class {
             params: this.params
           }));
         }
-        this._cacheKeys[mode] = effectiveRequest;
+        this._cacheKeys[key] = effectiveRequest;
       }
-      return this._cacheKeys[mode];
+      return this._cacheKeys[key];
     });
   }
   hasCallback(name) {
@@ -1041,9 +1163,9 @@ var StrategyHandler = class {
           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.`);
+                logger2.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.`);
+                logger2.debug(`The response for '${this.request.url}' returned a status code of '${response.status}' and won't be cached as a result.`);
               }
             }
           }
@@ -1057,7 +1179,7 @@ var StrategyHandler = class {
 // node_modules/workbox-strategies/Strategy.js
 var Strategy = class {
   constructor(options = {}) {
-    this.cacheName = cacheNames.getRuntimeName(options.cacheName);
+    this.cacheName = cacheNames3.getRuntimeName(options.cacheName);
     this.plugins = options.plugins || [];
     this.fetchOptions = options.fetchOptions;
     this.matchOptions = options.matchOptions;
@@ -1088,7 +1210,7 @@ var Strategy = class {
       try {
         response = yield this._handle(request, handler);
         if (!response || response.type === "error") {
-          throw new WorkboxError("no-response", { url: request.url });
+          throw new WorkboxError2("no-response", { url: request.url });
         }
       } catch (error) {
         if (error instanceof Error) {
@@ -1102,7 +1224,7 @@ var Strategy = class {
         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.`);
+          logger2.log(`While responding to '${getFriendlyURL2(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")) {
@@ -1151,7 +1273,7 @@ var CacheFirst = class extends Strategy {
     return __async(this, null, function* () {
       const logs = [];
       if (false) {
-        finalAssertExports.isInstance(request, Request, {
+        finalAssertExports2.isInstance(request, Request, {
           moduleName: "workbox-strategies",
           className: this.constructor.name,
           funcName: "makeRequest",
@@ -1184,15 +1306,15 @@ var CacheFirst = class extends Strategy {
         }
       }
       if (false) {
-        logger.groupCollapsed(messages2.strategyStart(this.constructor.name, request));
+        logger2.groupCollapsed(messages3.strategyStart(this.constructor.name, request));
         for (const log2 of logs) {
-          logger.log(log2);
+          logger2.log(log2);
         }
-        messages2.printFinalResponse(response);
-        logger.groupEnd();
+        messages3.printFinalResponse(response);
+        logger2.groupEnd();
       }
       if (!response) {
-        throw new WorkboxError("no-response", { url: request.url, error });
+        throw new WorkboxError2("no-response", { url: request.url, error });
       }
       return response;
     });
@@ -1221,7 +1343,7 @@ var StaleWhileRevalidate = class extends Strategy {
     return __async(this, null, function* () {
       const logs = [];
       if (false) {
-        finalAssertExports.isInstance(request, Request, {
+        finalAssertExports2.isInstance(request, Request, {
           moduleName: "workbox-strategies",
           className: this.constructor.name,
           funcName: "handle",
@@ -1230,6 +1352,7 @@ var StaleWhileRevalidate = class extends Strategy {
       }
       const fetchAndCachePromise = handler.fetchAndCachePut(request).catch(() => {
       });
+      void handler.waitUntil(fetchAndCachePromise);
       let response = yield handler.cacheMatch(request);
       let error;
       if (response) {
@@ -1249,15 +1372,15 @@ var StaleWhileRevalidate = class extends Strategy {
         }
       }
       if (false) {
-        logger.groupCollapsed(messages2.strategyStart(this.constructor.name, request));
+        logger2.groupCollapsed(messages3.strategyStart(this.constructor.name, request));
         for (const log2 of logs) {
-          logger.log(log2);
+          logger2.log(log2);
         }
-        messages2.printFinalResponse(response);
-        logger.groupEnd();
+        messages3.printFinalResponse(response);
+        logger2.groupEnd();
       }
       if (!response) {
-        throw new WorkboxError("no-response", { url: request.url, error });
+        throw new WorkboxError2("no-response", { url: request.url, error });
       }
       return response;
     });
@@ -1276,9 +1399,86 @@ var WEBPUB_CACHE_NAME = "webpub-cache";
 var PRECACHE_PUBLICATIONS = "PRECACHE_PUBLICATIONS";
 var CACHE_EXPIRATION_SECONDS = 7 * 24 * 60 * 60;
 
+// node_modules/workbox-routing/node_modules/workbox-core/_version.js
+try {
+  self["workbox:core:6.5.3"] && _();
+} catch (e) {
+}
+
+// node_modules/workbox-routing/node_modules/workbox-core/models/messages/messageGenerator.js
+var fallback3 = (code, ...args) => {
+  let msg = code;
+  if (args.length > 0) {
+    msg += ` :: ${JSON.stringify(args)}`;
+  }
+  return msg;
+};
+var messageGenerator3 = true ? fallback3 : generatorFunction;
+
+// node_modules/workbox-routing/node_modules/workbox-core/_private/WorkboxError.js
+var WorkboxError3 = class extends Error {
+  constructor(errorCode, details) {
+    const message = messageGenerator3(errorCode, details);
+    super(message);
+    this.name = errorCode;
+    this.details = details;
+  }
+};
+
+// node_modules/workbox-routing/node_modules/workbox-core/_private/logger.js
+var logger3 = 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-routing/_version.js
 try {
-  self["workbox:routing:6.2.4"] && _();
+  self["workbox:routing:6.5.3"] && _();
 } catch (e) {
 }
 
@@ -1289,7 +1489,7 @@ var defaultMethod = "GET";
 var normalizeHandler = (handler) => {
   if (handler && typeof handler === "object") {
     if (false) {
-      finalAssertExports.hasMethod(handler, "handle", {
+      finalAssertExports3.hasMethod(handler, "handle", {
         moduleName: "workbox-routing",
         className: "Route",
         funcName: "constructor",
@@ -1299,7 +1499,7 @@ var normalizeHandler = (handler) => {
     return handler;
   } else {
     if (false) {
-      finalAssertExports.isType(handler, "function", {
+      finalAssertExports3.isType(handler, "function", {
         moduleName: "workbox-routing",
         className: "Route",
         funcName: "constructor",
@@ -1314,14 +1514,14 @@ var normalizeHandler = (handler) => {
 var Route = class {
   constructor(match, handler, method = defaultMethod) {
     if (false) {
-      finalAssertExports.isType(match, "function", {
+      finalAssertExports3.isType(match, "function", {
         moduleName: "workbox-routing",
         className: "Route",
         funcName: "constructor",
         paramName: "match"
       });
       if (method) {
-        finalAssertExports.isOneOf(method, validMethods, { paramName: "method" });
+        finalAssertExports3.isOneOf(method, validMethods, { paramName: "method" });
       }
     }
     this.handler = normalizeHandler(handler);
@@ -1337,7 +1537,7 @@ var Route = class {
 var RegExpRoute = class extends Route {
   constructor(regExp, handler, method) {
     if (false) {
-      finalAssertExports.isInstance(regExp, RegExp, {
+      finalAssertExports3.isInstance(regExp, RegExp, {
         moduleName: "workbox-routing",
         className: "RegExpRoute",
         funcName: "constructor",
@@ -1351,7 +1551,7 @@ var RegExpRoute = class extends Route {
       }
       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.`);
+          logger3.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;
       }
@@ -1384,7 +1584,7 @@ var Router = class {
       if (event.data && event.data.type === "CACHE_URLS") {
         const { payload } = event.data;
         if (false) {
-          logger.debug(`Caching URLs from the window`, payload.urlsToCache);
+          logger3.debug(`Caching URLs from the window`, payload.urlsToCache);
         }
         const requestPromises = Promise.all(payload.urlsToCache.map((entry) => {
           if (typeof entry === "string") {
@@ -1402,7 +1602,7 @@ var Router = class {
   }
   handleRequest({ request, event }) {
     if (false) {
-      finalAssertExports.isInstance(request, Request, {
+      finalAssertExports3.isInstance(request, Request, {
         moduleName: "workbox-routing",
         className: "Router",
         funcName: "handleRequest",
@@ -1412,7 +1612,7 @@ var Router = class {
     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'.`);
+        logger3.debug(`Workbox Router only supports URLs that start with 'http'.`);
       }
       return;
     }
@@ -1427,10 +1627,7 @@ var Router = class {
     const debugMessages = [];
     if (false) {
       if (handler) {
-        debugMessages.push([
-          `Found a route to handle this request:`,
-          route
-        ]);
+        debugMessages.push([`Found a route to handle this request:`, route]);
         if (params) {
           debugMessages.push([
             `Passing the following params to the route's handler:`,
@@ -1448,20 +1645,20 @@ var Router = class {
     }
     if (!handler) {
       if (false) {
-        logger.debug(`No route found for: ${getFriendlyURL(url)}`);
+        logger3.debug(`No route found for: ${getFriendlyURL3(url)}`);
       }
       return;
     }
     if (false) {
-      logger.groupCollapsed(`Router is responding to: ${getFriendlyURL(url)}`);
+      logger3.groupCollapsed(`Router is responding to: ${getFriendlyURL3(url)}`);
       debugMessages.forEach((msg) => {
         if (Array.isArray(msg)) {
-          logger.log(...msg);
+          logger3.log(...msg);
         } else {
-          logger.log(msg);
+          logger3.log(msg);
         }
       });
-      logger.groupEnd();
+      logger3.groupEnd();
     }
     let responsePromise;
     try {
@@ -1474,10 +1671,10 @@ var Router = class {
       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();
+            logger3.groupCollapsed(`Error thrown when responding to:  ${getFriendlyURL3(url)}. Falling back to route's Catch Handler.`);
+            logger3.error(`Error thrown by:`, route);
+            logger3.error(err);
+            logger3.groupEnd();
           }
           try {
             return yield catchHandler.handle({ url, request, event, params });
@@ -1489,10 +1686,10 @@ var Router = class {
         }
         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();
+            logger3.groupCollapsed(`Error thrown when responding to:  ${getFriendlyURL3(url)}. Falling back to global Catch Handler.`);
+            logger3.error(`Error thrown by:`, route);
+            logger3.error(err);
+            logger3.groupEnd();
           }
           return this._catchHandler.handle({ url, request, event });
         }
@@ -1509,7 +1706,7 @@ var Router = class {
       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);
+            logger3.warn(`While routing ${getFriendlyURL3(url)}, an async matchCallback function was used. Please convert the following route to use a synchronous matchCallback function:`, route);
           }
         }
         params = matchResult;
@@ -1533,31 +1730,31 @@ var Router = class {
   }
   registerRoute(route) {
     if (false) {
-      finalAssertExports.isType(route, "object", {
+      finalAssertExports3.isType(route, "object", {
         moduleName: "workbox-routing",
         className: "Router",
         funcName: "registerRoute",
         paramName: "route"
       });
-      finalAssertExports.hasMethod(route, "match", {
+      finalAssertExports3.hasMethod(route, "match", {
         moduleName: "workbox-routing",
         className: "Router",
         funcName: "registerRoute",
         paramName: "route"
       });
-      finalAssertExports.isType(route.handler, "object", {
+      finalAssertExports3.isType(route.handler, "object", {
         moduleName: "workbox-routing",
         className: "Router",
         funcName: "registerRoute",
         paramName: "route"
       });
-      finalAssertExports.hasMethod(route.handler, "handle", {
+      finalAssertExports3.hasMethod(route.handler, "handle", {
         moduleName: "workbox-routing",
         className: "Router",
         funcName: "registerRoute",
         paramName: "route.handler"
       });
-      finalAssertExports.isType(route.method, "string", {
+      finalAssertExports3.isType(route.method, "string", {
         moduleName: "workbox-routing",
         className: "Router",
         funcName: "registerRoute",
@@ -1571,7 +1768,7 @@ var Router = class {
   }
   unregisterRoute(route) {
     if (!this._routes.has(route.method)) {
-      throw new WorkboxError("unregister-route-but-not-found-with-method", {
+      throw new WorkboxError3("unregister-route-but-not-found-with-method", {
         method: route.method
       });
     }
@@ -1579,7 +1776,7 @@ var Router = class {
     if (routeIndex > -1) {
       this._routes.get(route.method).splice(routeIndex, 1);
     } else {
-      throw new WorkboxError("unregister-route-route-not-registered");
+      throw new WorkboxError3("unregister-route-route-not-registered");
     }
   }
 };
@@ -1602,7 +1799,7 @@ function registerRoute(capture, handler, method) {
     const captureUrl = new URL(capture, location.href);
     if (false) {
       if (!(capture.startsWith("/") || capture.startsWith("http"))) {
-        throw new WorkboxError("invalid-string", {
+        throw new WorkboxError3("invalid-string", {
           moduleName: "workbox-routing",
           funcName: "registerRoute",
           paramName: "capture"
@@ -1611,13 +1808,13 @@ function registerRoute(capture, handler, method) {
       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.`);
+        logger3.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.`);
+          logger3.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;
@@ -1630,7 +1827,7 @@ function registerRoute(capture, handler, method) {
   } else if (capture instanceof Route) {
     route = capture;
   } else {
-    throw new WorkboxError("unsupported-route-type", {
+    throw new WorkboxError3("unsupported-route-type", {
       moduleName: "workbox-routing",
       funcName: "registerRoute",
       paramName: "capture"