@swoff/cli 0.3.13 → 0.3.15

package/dist/runtime/server-push.js

@@ -1,9 +1,9 @@
-import { T, R } from "./utils.js";
+import { T, R, AS } from "./utils.js";
 export function generateServerPushCode(ctx, pushType, endpoint, reconnectDelayMs) {
     const { ext, ts } = ctx;
     const invalidate = `
   // Forward to SW for cache invalidation
-  if (navigator.serviceWorker.controller) {
+  if (navigator.serviceWorker?.controller) {
     for (const tag of tags) {
       navigator.serviceWorker.controller.postMessage({ type: "INVALIDATE_TAG", tag });
     }
@@ -15,6 +15,8 @@ export function generateServerPushCode(ctx, pushType, endpoint, reconnectDelayMs
       credentials: "include",
       signal: options.signal,
     }).then(async (response) => {
+      currentFetchController = null;
+      if (!active) { resolve(); return; }
       if (!response.ok || !response.body) { resolve(); return; }
       notifyStatus(true);
       const reader = response.body.getReader();
@@ -51,14 +53,15 @@ export function generateServerPushCode(ctx, pushType, endpoint, reconnectDelayMs
   return new Promise((resolve) => {
     try {
       const ws = new WebSocket(API_BASE + "${endpoint}");
+      currentWs = ws;
       ws.onopen = () => notifyStatus(true);
       ws.onmessage = (event) => {
         try { const d = JSON.parse(event.data); if (d.type === "invalidate" && d.tags) handleInvalidation(d.tags); } catch {}
       };
-      ws.onclose = () => { notifyStatus(false); resolve(); };
-      ws.onerror = () => { ws.close(); resolve(); };
+      ws.onclose = () => { currentWs = null; notifyStatus(false); resolve(); };
+      ws.onerror = () => { currentWs = null; ws.close(); resolve(); };
       if (options.signal) {
-        options.signal.addEventListener("abort", () => ws.close());
+        options.signal.addEventListener("abort", () => { ws.close(); currentWs = null; });
       }
     } catch { resolve(); }
   });`;
@@ -70,7 +73,7 @@ export function generateServerPushCode(ctx, pushType, endpoint, reconnectDelayMs
  * This client-side helper provides status tracking and a manual start/stop API.
  *
  * Usage:
- *   import { startPushEvents, stopPushEvents, isPushConnected } from "./realtime/server-push.${ext}";
+ *   import { startPushEvents, stopPushEvents, isPushConnected } from "./server-push/client.${ext}";
  *   startPushEvents();
  *
  * Server sends:
@@ -87,6 +90,8 @@ type PushEventOptions= {
 let active${T(ts, "boolean")} = false;
 let swConnected${T(ts, "boolean")} = false;
 let reconnectTimer${T(ts, "ReturnType<typeof setTimeout> | null")} = null;
+let currentWs${T(ts, "WebSocket | null")} = null;
+let currentFetchController${T(ts, "AbortController | null")} = null;
 
 function handleInvalidation(tags${T(ts, "string[]")})${R(ts, "void")}{${invalidate}
   window.dispatchEvent(new CustomEvent("cache-invalidated", { detail: { tags } }));
@@ -97,7 +102,7 @@ function notifyStatus(connected${T(ts, "boolean")})${R(ts, "void")}{
 }
 
 // Listen for SSE status from the SW
-if (typeof navigator !== "undefined" && navigator.serviceWorker) {
+if (typeof navigator !== "undefined" && "serviceWorker" in navigator) {
   navigator.serviceWorker.addEventListener("message", (event) => {
     if (event.data?.type === "SSE_STATUS") {
       swConnected = event.data.connected;
@@ -106,7 +111,10 @@ if (typeof navigator !== "undefined" && navigator.serviceWorker) {
   });
 }
 
-async function connect(options${T(ts, "PushEventOptions")} = {} as PushEventOptions)${R(ts, "Promise<void>")}{
+async function connect()${R(ts, "Promise<void>")}{
+  const controller = new AbortController();
+  currentFetchController = controller;
+  const options = { signal: controller.signal }${AS(ts, "PushEventOptions")};
   ${pushType === "sse" ? sseConnect : wsConnect}
 }
 
@@ -115,14 +123,14 @@ export async function startPushEvents(){
   if (active) return;
 
   // If SW is already controlling the page, skip client-side connection — the SW handles push events.
-  if (navigator.serviceWorker.controller) return;
+  if (navigator.serviceWorker?.controller) return;
 
   // Listen for SW activation — if SW takes over, disconnect the client fallback.
   const onControllerChange = () => { stopPushEvents(); };
-  navigator.serviceWorker.addEventListener("controllerchange", onControllerChange);
+  navigator.serviceWorker?.addEventListener("controllerchange", onControllerChange);
 
   active = true;
-  let delay = ${reconnectDelayMs};
+  let delay = Math.max(1000, ${reconnectDelayMs});
   while (active) {
     await connect();
     if (!active) break;
@@ -130,13 +138,15 @@ export async function startPushEvents(){
     delay = Math.min(delay * 1.5, 30000); // cap at 30s
   }
 
-  navigator.serviceWorker.removeEventListener("controllerchange", onControllerChange);
+  navigator.serviceWorker?.removeEventListener("controllerchange", onControllerChange);
 }
 
-/** Stop listening for push events. */
+/** Stop listening for push events and close the active connection. */
 export function stopPushEvents(){
   active = false;
   if (reconnectTimer) { clearTimeout(reconnectTimer); reconnectTimer = null; }
+  if (currentWs) { currentWs.close(); currentWs = null; }
+  if (currentFetchController) { currentFetchController.abort(); currentFetchController = null; }
 }
 
 /** Check if the push connection is currently established. */

package/dist/runtime/server-push.js.map

@@ -1 +1 @@
-{"version":3,"file":"server-push.js","sourceRoot":"","sources":["../../src/runtime/server-push.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,YAAY,CAAC;AAElC,MAAM,UAAU,sBAAsB,CACpC,GAAmB,EACnB,QAAgB,EAChB,QAAgB,EAChB,gBAAwB;IAExB,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IAExB,MAAM,UAAU,GAAG;;;;;;IAMjB,CAAC;IAEH,MAAM,UAAU,GAAG;;wBAEG,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAoC1B,CAAC;IAEL,MAAM,SAAS,GAAG;;;6CAGyB,QAAQ;;;;;;;;;;;MAW/C,CAAC;IAEL,OAAO;;;oCAG2B,QAAQ;;;;;gGAKoD,GAAG;;;;;;;;sCAQ7D,GAAG;;;UAG/B,CAAC,CAAC,EAAE,EAAE,aAAa,CAAC;;;YAGlB,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;iBACX,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;oBACb,CAAC,CAAC,EAAE,EAAE,sCAAsC,CAAC;;kCAE/B,CAAC,CAAC,EAAE,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,MAAM,CAAC,IAAI,UAAU;;;;iCAIjD,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,MAAM,CAAC;;;;;;;;;;;;;;gCAclC,CAAC,CAAC,EAAE,EAAE,kBAAkB,CAAC,6BAA6B,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;IACxG,QAAQ,KAAK,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS;;;;;;;;;;;;;;;gBAe/B,gBAAgB;;;;;;;;;;;;;;;;;;;;;CAqB/B,CAAC;AACF,CAAC"}
+{"version":3,"file":"server-push.js","sourceRoot":"","sources":["../../src/runtime/server-push.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,MAAM,YAAY,CAAC;AAEtC,MAAM,UAAU,sBAAsB,CACpC,GAAmB,EACnB,QAAgB,EAChB,QAAgB,EAChB,gBAAwB;IAExB,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IAExB,MAAM,UAAU,GAAG;;;;;;IAMjB,CAAC;IAEH,MAAM,UAAU,GAAG;;wBAEG,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAsC1B,CAAC;IAEL,MAAM,SAAS,GAAG;;;6CAGyB,QAAQ;;;;;;;;;;;;MAY/C,CAAC;IAEL,OAAO;;;oCAG2B,QAAQ;;;;;8FAKkD,GAAG;;;;;;;;sCAQ3D,GAAG;;;UAG/B,CAAC,CAAC,EAAE,EAAE,aAAa,CAAC;;;YAGlB,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;iBACX,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;oBACb,CAAC,CAAC,EAAE,EAAE,sCAAsC,CAAC;eAClD,CAAC,CAAC,EAAE,EAAE,kBAAkB,CAAC;4BACZ,CAAC,CAAC,EAAE,EAAE,wBAAwB,CAAC;;kCAEzB,CAAC,CAAC,EAAE,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,MAAM,CAAC,IAAI,UAAU;;;;iCAIjD,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,MAAM,CAAC;;;;;;;;;;;;;;0BAcxC,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;iDAGC,EAAE,CAAC,EAAE,EAAE,kBAAkB,CAAC;IACvE,QAAQ,KAAK,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS;;;;;;;;;;;;;;;+BAehB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;CAuB9C,CAAC;AACF,CAAC"}

package/dist/runtime/storage.js

@@ -0,0 +1,32 @@
+import { T, R } from "./utils.js";
+export function generateStorageCode(ctx) {
+    const { ext, ts } = ctx;
+    return `/**
+ * Swoff Storage
+ * Pure utility functions for storage estimation and formatting.
+ *
+ * Usage:
+ *   import { getStorageEstimate, formatBytes } from "./swoff/storage.${ext}";
+ *   const { usage, quota, percentUsed } = await getStorageEstimate();
+ */
+
+/** Get raw storage estimate. */
+export async function getStorageEstimate()${R(ts, "Promise<{ usage: number; quota: number; percentUsed: number }>")}{
+  if (!navigator.storage?.estimate) {
+    return { usage: 0, quota: 0, percentUsed: 0 };
+  }
+  const { usage = 0, quota = 0 } = await navigator.storage.estimate();
+  const percentUsed = quota > 0 ? Math.round((usage / quota) * 100) : 0;
+  return { usage, quota, percentUsed };
+}
+
+/** Format bytes to a human-readable string (e.g. "1.5 MB"). */
+export function formatBytes(bytes${T(ts, "number")})${R(ts, "string")}{
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return \`\${(bytes / Math.pow(1024, i)).toFixed(1)} \${units[i]}\`;
+}
+`;
+}
+//# sourceMappingURL=storage.js.map

package/dist/runtime/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../src/runtime/storage.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,YAAY,CAAC;AAElC,MAAM,UAAU,mBAAmB,CAAC,GAAmB;IACrD,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IACxB,OAAO;;;;;wEAK+D,GAAG;;;;;4CAK/B,CAAC,CAAC,EAAE,EAAE,gEAAgE,CAAC;;;;;;;;;;mCAUhF,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC;;;;;;CAMpE,CAAC;AACF,CAAC"}

package/dist/runtime/sw-injector.js

@@ -1,103 +1,21 @@
-import { T, R } from "./utils.js";
+import { R } from "./utils.js";
 export function generateSwInjectorCode(ctx) {
-    const { ext, ts, autoUpdate, autoActivate, versionEnabled, swFilename } = ctx;
-    if (!versionEnabled) {
-        return `/**
- * Swoff SW Injector (Simple Mode)
- * Fixed SW URL with hash-based cache name — no versioned URLs or update events.
- *
- * Usage:
- *   import { initServiceWorker } from './swoff/sw/injector.${ext}';
- *   initServiceWorker();
- *
- * Window events:
- *   sw-ready  - SW active and controlling page
- *   sw-error  - SW registration failed
- *
- * Window properties:
- *   window.currentSWVersion  - "simple"
- *   window.swReady           - SW is active
- *   window.swError           - Registration failed
- */
-async function waitForController()${R(ts, "Promise<void>")}{
-  return new Promise<void>((resolve) => {
-    if (navigator.serviceWorker.controller) {
-      resolve();
-    } else {
-      const timeout = setTimeout(() => resolve(), 30000);
-      navigator.serviceWorker.addEventListener("controllerchange", () => {
-        clearTimeout(timeout);
-        resolve();
-      }, { once: true });
-    }
-  });
-}
-
-/** Register the SW with a fixed URL (non-versioned mode). Dispatches sw-ready/sw-error. */
-export async function initServiceWorker()${R(ts, "Promise<void>")}{
-  if (!("serviceWorker" in navigator)) {
-    console.warn("Service Workers not supported");
-    return;
-  }
-  try {
-    const registration = await navigator.serviceWorker.register("/${swFilename}.js");
-    window.currentSWVersion = "simple";
-    window.dispatchEvent(new CustomEvent("sw-version-detected"));
-    await waitForController();
-    window.dispatchEvent(new CustomEvent("sw-ready"));
-  } catch (error) {
-    console.error("Service Worker registration failed:", error);
-    window.swError = true;
-    window.dispatchEvent(new CustomEvent("sw-error"));
-  }
-}
-`;
-    }
+    const { ext, ts, autoActivate, swFilename } = ctx;
     return `/**
  * Swoff SW Injector
- * Framework-agnostic SW registration with versioned URLs and update flow.
+ * Registers the service worker and tracks installation progress.
  *
  * Usage:
  *   import { initServiceWorker } from './swoff/sw/injector.${ext}';
  *   initServiceWorker();
  *
  * Window events:
- *   sw-version-detected  - Version info available on window
- *   sw-update-available  - New version ready for user consent (detail: { version })
  *   sw-progress          - Download progress (detail: { percent, downloaded, total })
  *   sw-ready             - SW active and controlling page
  *   sw-error             - SW registration failed
- *
- * Window properties:
- *   window.latestSWVersion       - Latest version from version.json
- *   window.currentSWVersion      - Active SW version
- *   window.swAvailableVersion    - Pending update version
- *   window.swUpdateRequired      - Forced update needed (version < minSupportedVersion)
- *   window.swMinSupportedVersion - Minimum supported version
- *   window.swReady               - SW is active
- *   window.swError               - Registration failed
  */
-const AUTO_UPDATE = ${autoUpdate};
 const AUTO_ACTIVATE = ${autoActivate};
 
-function semverCompare(a${T(ts, "string")}, b${T(ts, "string")})${R(ts, "number")}{
-  const pa = a.split('.').map(Number);
-  const pb = b.split('.').map(Number);
-  for (let i = 0; i < 3; i++) {
-    if (pa[i] > pb[i]) return 1;
-    if (pa[i] < pb[i]) return -1;
-  }
-  return 0;
-}
-
-async function checkForUpdate() {
-  const response = await fetch("/version.json?t=" + Date.now());
-  if (!response.ok) {
-    throw new Error("Failed to fetch version.json");
-  }
-  return response.json();
-}
-
 async function waitForController()${R(ts, "Promise<void>")}{
   return new Promise<void>((resolve) => {
     if (navigator.serviceWorker.controller) {
@@ -112,19 +30,7 @@ async function waitForController()${R(ts, "Promise<void>")}{
   });
 }
 
-async function doRegisterServiceWorker(version${T(ts, "string")})${R(ts, "Promise<ServiceWorkerRegistration>")}{
-  const swUrl = \`/sw-v\${version}.js\`;
-  const registration = await navigator.serviceWorker.register(swUrl);
-  localStorage.setItem("swRegisteredVersion", version);
-  window.currentSWVersion = version;
-  window.swRegisteredVersion = version;
-  window.dispatchEvent(new CustomEvent("sw-version-detected"));
-  await waitForController();
-  window.dispatchEvent(new CustomEvent("sw-ready"));
-  return registration;
-}
-
-/** Register the SW with version checking and update flow. Checks version.json, handles updates, and dispatches sw-ready/sw-error events. */
+/** Register the SW. The browser detects updates by comparing SW file bytes. */
 export async function initServiceWorker()${R(ts, "Promise<void>")}{
   if (!("serviceWorker" in navigator)) {
     console.warn("Service Workers not supported");
@@ -132,98 +38,33 @@ export async function initServiceWorker()${R(ts, "Promise<void>")}{
   }
 
   try {
-    const manifest = await checkForUpdate();
-    const currentVersion = localStorage.getItem("swRegisteredVersion");
-    window.latestSWVersion = manifest.version;
-    window.swMinSupportedVersion = manifest.minSupportedVersion || "0.0.0";
-
-    if (currentVersion === manifest.version) {
-      const registration = await navigator.serviceWorker.getRegistration();
-      if (registration && registration.active) {
-        window.currentSWVersion = currentVersion ?? undefined;
-        window.dispatchEvent(new CustomEvent("sw-version-detected"));
-        await waitForController();
-        if (!window.swReady) {
-          window.dispatchEvent(new CustomEvent("sw-ready"));
-        }
-      }
-    } else if (currentVersion && currentVersion !== manifest.version) {
-      window.swAvailableVersion = manifest.version;
-      window.swUpdateRequired =
-        semverCompare(currentVersion, manifest.minSupportedVersion || "0.0.0") < 0;
+    const registration = await navigator.serviceWorker.register("/${swFilename}.js");
 
-      if (AUTO_UPDATE) {
-        const registration = await navigator.serviceWorker.getRegistration();
-        if (registration && registration.waiting) {
+    var swReadyDispatched = false;
+    if (registration.installing) {
+      const installingWorker = registration.installing;
+      installingWorker.addEventListener("statechange", () => {
+        if (installingWorker.state === "installed") {
           if (AUTO_ACTIVATE) {
-            registration.waiting.postMessage({ type: "SKIP_WAITING" });
-          } else {
-            window.dispatchEvent(
-              new CustomEvent("sw-update-available", {
-                detail: { version: manifest.version },
-              })
-            );
-          }
-        } else {
-          const newReg = await doRegisterServiceWorker(manifest.version);
-          if (AUTO_ACTIVATE && newReg.waiting) {
-            newReg.waiting.postMessage({ type: "SKIP_WAITING" });
-          } else {
-            window.dispatchEvent(
-              new CustomEvent("sw-update-available", {
-                detail: { version: manifest.version },
-              })
-            );
+            registration.waiting?.postMessage({ type: "SKIP_WAITING" });
           }
-        }
-      } else {
-        window.dispatchEvent(
-          new CustomEvent("sw-update-available", {
-            detail: { version: manifest.version },
-          })
-        );
-      }
-    } else {
-      await doRegisterServiceWorker(manifest.version);
-    }
-  } catch (error) {
-    try {
-      const existing = await navigator.serviceWorker.getRegistration();
-      if (existing && existing.active) {
-        window.currentSWVersion = localStorage.getItem("swRegisteredVersion") || "unknown";
-        window.dispatchEvent(new CustomEvent("sw-version-detected"));
-        await waitForController();
-        if (!window.swReady) {
+          swReadyDispatched = true;
           window.dispatchEvent(new CustomEvent("sw-ready"));
         }
-        return;
-      }
-    } catch {
-      // Handle the case where no existing active registration is found
+      });
     }
 
-    console.error("Service Worker initialization failed:", error);
+    await waitForController();
+    if (!swReadyDispatched) {
+      window.dispatchEvent(new CustomEvent("sw-ready"));
+    }
+  } catch (error) {
+    console.error("Service Worker registration failed:", error);
     window.swError = true;
     window.dispatchEvent(new CustomEvent("sw-error"));
   }
 }
 
-/** Accept a pending SW update. Reloads the page once the new SW takes control. */
-export async function handleUpdateApproved(newVersion${T(ts, "string")})${R(ts, "Promise<void>")}{
-  const registration = await navigator.serviceWorker.getRegistration();
-  if (registration && registration.waiting) {
-    registration.waiting.postMessage({ type: "SKIP_WAITING" });
-    registration.addEventListener("controllerchange", () => {
-      window.location.reload();
-    });
-  } else {
-    await doRegisterServiceWorker(newVersion);
-    navigator.serviceWorker.addEventListener("controllerchange", () => {
-      window.location.reload();
-    });
-  }
-}
-
 /** Activate a waiting SW without reloading. Useful when you handle the transition yourself. */
 export async function skipWaiting()${R(ts, "Promise<void>")}{
   const registration = await navigator.serviceWorker.ready;

package/dist/runtime/sw-injector.js.map

@@ -1 +1 @@
-{"version":3,"file":"sw-injector.js","sourceRoot":"","sources":["../../src/runtime/sw-injector.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,YAAY,CAAC;AAElC,MAAM,UAAU,sBAAsB,CACpC,GAAiH;IAEjH,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,UAAU,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,GAAG,GAAG,CAAC;IAE9E,IAAI,CAAC,cAAc,EAAE,CAAC;QACpB,OAAO;;;;;8DAKmD,GAAG;;;;;;;;;;;;oCAY7B,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;;;;;;;2CAef,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;oEAMG,UAAU;;;;;;;;;;;CAW7E,CAAC;IACA,CAAC;IAED,OAAO;;;;;8DAKqD,GAAG;;;;;;;;;;;;;;;;;;;sBAmB3C,UAAU;wBACR,YAAY;;0BAEV,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC;;;;;;;;;;;;;;;;;;oCAkB7C,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;;;;;;gDAcV,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,oCAAoC,CAAC;;;;;;;;;;;;;2CAanE,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDAoFV,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;;;;;;;;qCAgB3D,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;CAM1D,CAAC;AACF,CAAC"}
+{"version":3,"file":"sw-injector.js","sourceRoot":"","sources":["../../src/runtime/sw-injector.ts"],"names":[],"mappings":"AACA,OAAO,EAAK,CAAC,EAAE,MAAM,YAAY,CAAC;AAElC,MAAM,UAAU,sBAAsB,CACpC,GAAmE;IAEnE,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,YAAY,EAAE,UAAU,EAAE,GAAG,GAAG,CAAC;IAElD,OAAO;;;;;8DAKqD,GAAG;;;;;;;;wBAQzC,YAAY;;oCAEA,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;;;;;;;2CAef,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;oEAOG,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BzC,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;CAM1D,CAAC;AACF,CAAC"}