@lls/offline 24.27.0-bbbcfe5a → 24.27.0-d7760203

package/lib/assets/fetch-worker.js

@@ -1,21 +1,3 @@
-// src/utils/stream.ts
-var parseRange = (range, size) => {
-  const parts = range.replace("bytes=", "").split("-");
-  let start = Number.parseInt(parts[0], 10);
-  let end = Number.parseInt(parts[1], 10);
-  if (isNaN(start)) {
-    start = size - end;
-    end = size - 1;
-  } else if (isNaN(end)) {
-    end = size - 1;
-  }
-  if (end > size - 1) {
-    end = size - 1;
-  }
-  const chunkSize = end - start + 1;
-  return { start, end, chunkSize };
-};
-
 // src/utils/worker.ts
 var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
   const dic = {};
@@ -38,18 +20,7 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
     return ({ ports, ...arg } = {}) => {
       return new Promise((resolve, reject) => {
         const eventId = `${methodName}:${Date.now()}-${Math.random().toFixed(5)}`;
-        let resolved = false;
-        const timeout = setTimeout(() => {
-          console.warn("slow request for", methodName, arg);
-        }, 3e3);
-        const doResolve = (arg2) => {
-          if (!resolved) {
-            resolved = true;
-            clearTimeout(timeout);
-            resolve(arg2);
-          }
-        };
-        dic[eventId] = { resolve: doResolve, reject };
+        dic[eventId] = { resolve, reject };
         offlineWorker2.postMessage({ eventId, methodName, arg }, ports);
       });
     };
@@ -106,7 +77,7 @@ var cocoreFetchPartialPageScreen = async (_ev, { offlineWorkerSync: offlineWorke
   const key = `gqls/${zipSlugName(variables.slugs[0] || "")}.json`;
   const entryId = knownLinks2.get(key);
   if (!entryId) {
-    throw new Error(`slug not found ${key}, links size: ${knownLinks2.size}`);
+    throw new Error(`slug not found ${key}`);
   }
   const gqlPage = await offlineWorkerSync2.loadPageContent({ entryId });
   return { data: gqlPage };
@@ -231,90 +202,22 @@ var coreFetchPagesApi = async (ev, { offlineWorkerSync: offlineWorkerSync2, vari
     }
   }
 };
-var cocoreFetchPrimaryMethod = async (_ev, { offlineWorkerSync: offlineWorkerSync2, variables }) => {
-  const uri = variables.uris?.[0];
-  if (!uri) {
-    throw new Error("invalid uri");
-  }
-  const method = await offlineWorkerSync2.readZipEntry({ bookId: uri, entryName: "gqls/method.json", asJson: true });
-  return {
-    data: method
-  };
-};
-var cocoreCreateLexicalFlower = async (_ev, { variables }) => {
-  const flower = variables.flower;
-  if (!flower) {
-    throw new Error("invalid flower");
-  }
-  const back = {
-    viewer: {
-      createLexicalFlower: {
-        ...flower,
-        id: Date.now(),
-        user: null,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    }
-  };
-  return {
-    data: back
-  };
-};
-var cocoreUpdateLexicalFlower = async (_ev, { variables }) => {
-  const flower = variables.flower;
-  if (!flower) {
-    throw new Error("invalid flower");
-  }
-  const back = {
-    viewer: {
-      updateLexicalFlower: {
-        ...flower,
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    }
-  };
-  return {
-    data: back
-  };
-};
-var cocoreDeleteLexicalFlower = async (_ev, { variables }) => {
-  const flower = variables.flower;
-  if (!flower) {
-    throw new Error("invalid flower");
-  }
-  const back = {
-    viewer: {
-      deleteLexicalFlower: flower
-    }
-  };
-  return {
-    data: back
-  };
-};
 var handles = {
   coreFetchBookDrawerScreen,
   cocoreFetchBookScreen,
   coreFetchPagesApi,
   cocoreFetchPartialPageScreen,
-  cocoreFetchPartialPageSiblingsScreen,
-  cocoreFetchPrimaryMethod,
-  cocoreCreateLexicalFlower,
-  cocoreUpdateLexicalFlower,
-  cocoreDeleteLexicalFlower
+  cocoreFetchPartialPageSiblingsScreen
 };
 var canHandleScreenCall = (url) => new RegExp(Object.keys(handles).join("|")).test(url);
 var handleScreenCall = async (ev, { offlineWorkerSync: offlineWorkerSync2, knownLinks: knownLinks2 }) => {
   try {
-    let variables;
-    const searchParamsVariables = new URLSearchParams(new URL(ev.request.url).search).get("variables");
-    if (searchParamsVariables) {
-      variables = JSON.parse(searchParamsVariables);
-    } else {
-      const body = await new Response(ev.request.body).json();
-      variables = body.variables;
-    }
+    const variables = (
+      // @ts-expect-error TODO: handle variables from body(stream) properly!!
+      ev.request.body?.variables || JSON.parse(new URLSearchParams(new URL(ev.request.url).search).get("variables") || "{}")
+    );
+    console.debug("variables are", variables, "vs", ev.request.body);
     const key = ev.request.url.match(Object.keys(handles).join("|"))?.[0];
-    console.debug("screencall", key, "qs", variables, "vs body", ev.request.body);
     if (!key) {
       throw new Error("unknown ev");
     }
@@ -335,39 +238,17 @@ var setKnownLinks = (knownLinks2, { entryNames, bookId }) => {
 // src/worker/fetch-worker.ts
 var STORAGE = "cache";
 var CONF_ENV = "development";
-var fetchAsset = async (ev, { entryId, mimeType, offlineWorkerSync: offlineWorkerSync2 }) => {
+var fetchAsset = async (_ev, { entryId, mimeType, offlineWorkerSync: offlineWorkerSync2 }) => {
   try {
-    const [buf, maybeRangeHeaders] = await offlineWorkerSync2.readZipEntry(entryId).then((buf2) => {
-      const range = ev.request.headers.get("Range");
-      if (!ev.request.url.endsWith(".mp4") && !ev.request.url.endsWith(".webm")) {
-        return [buf2, {}];
-      }
-      if (!range) {
-        return [
-          buf2,
-          {
-            "Accept-Ranges": "bytes",
-            "Content-Range": `bytes ${0}-${buf2.byteLength}/${buf2.byteLength}`
-          }
-        ];
-      }
-      const { start, end, chunkSize } = parseRange(range, buf2.byteLength);
-      const rangeHeaders = {
-        "Content-Length": chunkSize,
-        "Accept-Ranges": "bytes",
-        "Content-Range": `bytes ${start}-${end}/${buf2.byteLength}`
-      };
-      return [buf2.slice(start, end + 1), rangeHeaders];
-    });
+    const buf = await offlineWorkerSync2.readZipEntry(entryId);
     return new Response(buf, {
       headers: {
         "Cache-Control": "max-age=600, s-maxage=600, public, proxy-revalidate",
         "Content-Length": buf.byteLength,
-        "Content-Type": mimeType,
-        ...maybeRangeHeaders
+        "Content-Type": mimeType
       },
       // @ts-ignore: poor ts typing
-      status: maybeRangeHeaders["Content-Range"] ? 206 : 200,
+      status: 200,
       statusText: "OK"
     });
   } catch (e) {
@@ -424,30 +305,23 @@ var putInCache = async (request, response) => {
   const cache = await openCache(CONF_ENV);
   await cache.put(request, response);
 };
-var tryOnline = async (request, event) => {
-  const responseFromNetwork = await fetch(request);
-  if (isValidZipName(request.url) && !isValidS3Zip(responseFromNetwork)) {
-    throw new Error(`zip is invalid: got ${responseFromNetwork.headers.get("Content-Length")} bytes`);
-  }
-  const cached = request.method === "HEAD" ? Promise.resolve() : putInCache(request, responseFromNetwork.clone());
-  if (request.url.endsWith(".zip")) {
-    await cached;
-    event.waitUntil(Promise.resolve());
-  } else {
-    event.waitUntil(cached);
-  }
-  return responseFromNetwork;
-};
-var tryOffline = async (request, _event) => {
-  const over = /\/\?story=basic/.test(request.url) ? request.url.replace(/\/\?story=.*$/, "") : request;
-  const responseFromCache = await caches.match(over);
-  return responseFromCache;
-};
 var onlineFirst = async (request, event) => {
   try {
-    return await tryOnline(request, event);
+    const responseFromNetwork = await fetch(request);
+    if (isValidZipName(request.url) && !isValidS3Zip(responseFromNetwork)) {
+      throw new Error(`zip is invalid: got ${responseFromNetwork.headers.get("Content-Length")} bytes`);
+    }
+    const cached = request.method === "HEAD" ? Promise.resolve() : putInCache(request, responseFromNetwork.clone());
+    if (request.url.endsWith(".zip")) {
+      await cached;
+      event.waitUntil(Promise.resolve());
+    } else {
+      event.waitUntil(cached);
+    }
+    return responseFromNetwork;
   } catch (e) {
-    const responseFromCache = await tryOffline(request, event);
+    const over = /\/\?story=basic/.test(request.url) ? request.url.replace(/\/\?story=.*$/, "") : request;
+    const responseFromCache = await caches.match(over);
     if (!responseFromCache) {
       return new Response(
         `FAILED fetch ${e && typeof e === "object" && "message" in e ? e.message : e?.toString?.()}`,
@@ -469,23 +343,18 @@ swSelf.addEventListener("fetch", (ev) => {
   const extension = url.match(/\.[^.]+$/)?.[0];
   const mimeType = extension && extension in ACCEPTED_EXTENSIONS ? ACCEPTED_EXTENSIONS[extension] : "";
   const isValidScreenCall = canHandleScreenCall(url);
-  if (url.endsWith(".zip")) {
-    if (STORAGE === "cache") {
-      return ev.respondWith(onlineFirst(ev.request, ev));
-    }
+  if (STORAGE !== "cache" && url.endsWith(".zip")) {
     return;
   }
   if (!mimeType && !isValidScreenCall) {
-    if (!/\.(css|tsx?|[mj]sx?|woff2|wasm|fr|(web)?manifest)(\??|$)|@(vite|react|id)|(:6019\/?$)/.test(url)) {
+    if (!/\.(css|tsx?|jsx?|woff2|fr|manifest)(\??|$)|@(vite|react|id)/.test(url)) {
       console.debug("no ext", extension || url);
     }
     return ev.respondWith(onlineFirst(ev.request, ev));
   }
-  if (/http:\/\/localhost:\d+\/(favicon\.svg|assets\/)/.test(url)) {
-    return;
-  }
   const entryId = knownLinks.get(url.replace(/https:\/\/.*?\//, "")) || knownLinks.get(`medias/${url.replace(/https:\/\/.*?\//, "")}`);
   if (isValidScreenCall) {
+    console.debug("screencall!");
     return ev.respondWith(fetchScreenCall(ev, { offlineWorkerSync, knownLinks }));
   }
   if (entryId) {
@@ -494,7 +363,6 @@ swSelf.addEventListener("fetch", (ev) => {
   if (/lls|lelivrescolaire/.test(url)) {
     console.info("no link for", url.replace(/https:\/\/.*?\//, ""), `medias/${url.replace(/https:\/\/.*?\//, "")}`);
   }
-  console.debug("unintercepted url", url);
   return;
 });
 swSelf.addEventListener("install", (_event) => {
@@ -515,10 +383,7 @@ var initChannel = async (__, { ports }) => {
   );
   offlineWorkerSync = sender;
   offlineWorker.onmessage = handler.handle;
-  offlineWorkerSync.on("setKnownLinks", ({ entryNames, bookId, eventId }) => {
-    setKnownLinks(knownLinks, { entryNames, bookId });
-    offlineWorker.postMessage({ methodName: "setKnownLinks:back", eventId });
-  });
+  offlineWorkerSync.on("setKnownLinks", setKnownLinks.bind(null, knownLinks));
   offlineWorker.postMessage({ methodName: "sendAppReady" });
 };
 var knownLinks = /* @__PURE__ */ new Map();

package/lib/assets/offline-worker.js

@@ -31,18 +31,7 @@ var makeSyncWorker = (offlineWorker, methodNames, dbg) => {
     return ({ ports, ...arg } = {}) => {
       return new Promise((resolve, reject) => {
         const eventId = `${methodName}:${Date.now()}-${Math.random().toFixed(5)}`;
-        let resolved = false;
-        const timeout = setTimeout(() => {
-          console.warn("slow request for", methodName, arg);
-        }, 3e3);
-        const doResolve = (arg2) => {
-          if (!resolved) {
-            resolved = true;
-            clearTimeout(timeout);
-            resolve(arg2);
-          }
-        };
-        dic[eventId] = { resolve: doResolve, reject };
+        dic[eventId] = { resolve, reject };
         offlineWorker.postMessage({ eventId, methodName, arg }, ports);
       });
     };
@@ -95,6 +84,16 @@ var combineHandlers = (...handlers) => {
   };
 };
 var openCache = async (mode) => caches.open(`LLS_OFFLINE_${mode}`);
+var concatArrayBuffers = (buffers) => {
+  const totalLength = buffers.reduce((sum, buf) => sum + buf.byteLength, 0);
+  const concatenated = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const buffer of buffers) {
+    concatenated.set(new Uint8Array(buffer), offset);
+    offset += buffer.byteLength;
+  }
+  return concatenated.buffer;
+};
 var isStoryZip = (name) => /story-.*?\.zip/.test(name);
 var isValidZipName = (name) => {
   return /lecture-cp\.zip/.test(name) || isStoryZip(name);
@@ -171,72 +170,615 @@ var loadPreload = (json) => {
   });
 };
 
-// src/utils/zipDecoder.ts
-var getEOCDStart = (buf) => {
-  for (let i = buf.length - 1; i > 0; --i) {
-    if (buf[i] === 6) {
-      if (buf[i - 1] === 5) {
-        if (buf[i - 2] === 75) {
-          if (buf[i - 3] === 80) {
-            return i - 3;
-          }
+// ../../node_modules/.pnpm/fflate@0.8.2/node_modules/fflate/esm/browser.js
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var fleb = new u8([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0,
+  /* unused */
+  0,
+  0,
+  /* impossible */
+  0
+]);
+var fdeb = new u8([
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13,
+  /* unused */
+  0,
+  0
+]);
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+var freb = function(eb, start) {
+  var b = new u16(31);
+  for (var i = 0; i < 31; ++i) {
+    b[i] = start += 1 << eb[i - 1];
+  }
+  var r = new i32(b[30]);
+  for (var i = 1; i < 30; ++i) {
+    for (var j = b[i]; j < b[i + 1]; ++j) {
+      r[j] = j - b[i] << 5 | i;
+    }
+  }
+  return { b, r };
+};
+var _a = freb(fleb, 2);
+var fl = _a.b;
+var revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0);
+var fd = _b.b;
+var revfd = _b.r;
+var rev = new u16(32768);
+for (i = 0; i < 32768; ++i) {
+  x = (i & 43690) >> 1 | (i & 21845) << 1;
+  x = (x & 52428) >> 2 | (x & 13107) << 2;
+  x = (x & 61680) >> 4 | (x & 3855) << 4;
+  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var x;
+var i;
+var hMap = function(cd, mb, r) {
+  var s = cd.length;
+  var i = 0;
+  var l = new u16(mb);
+  for (; i < s; ++i) {
+    if (cd[i])
+      ++l[cd[i] - 1];
+  }
+  var le = new u16(mb);
+  for (i = 1; i < mb; ++i) {
+    le[i] = le[i - 1] + l[i - 1] << 1;
+  }
+  var co;
+  if (r) {
+    co = new u16(1 << mb);
+    var rvb = 15 - mb;
+    for (i = 0; i < s; ++i) {
+      if (cd[i]) {
+        var sv = i << 4 | cd[i];
+        var r_1 = mb - cd[i];
+        var v = le[cd[i] - 1]++ << r_1;
+        for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
+          co[rev[v] >> rvb] = sv;
         }
       }
     }
+  } else {
+    co = new u16(s);
+    for (i = 0; i < s; ++i) {
+      if (cd[i]) {
+        co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
+      }
+    }
   }
-  throw new Error("failed to read EOCDstart");
+  return co;
 };
-var readIndex = (buf, offset, nBytes) => {
-  let idx = 0;
-  for (let i = 0; i < nBytes; ++i) {
-    const next = buf[offset + i] * 256 ** i;
-    idx += next;
-  }
-  return idx;
-};
-var getSOCDStart = (buf, eocdIdx) => {
-  return readIndex(buf, eocdIdx + 16, 4);
-};
-var readEntryNames = (buf, socdIdx, nRecords) => {
-  const records = Array.from({ length: nRecords });
-  for (let i = 0; i < nRecords; ++i) {
-    const n = readIndex(buf, socdIdx + 28, 2);
-    const m = readIndex(buf, socdIdx + 30, 2);
-    const k = readIndex(buf, socdIdx + 32, 2);
-    records[i] = {
-      sofh: readIndex(buf, socdIdx + 42, 4),
-      name: buf.slice(socdIdx + 46, socdIdx + 46 + n)
-    };
-    socdIdx += 46 + n + m + k;
+var flt = new u8(288);
+for (i = 0; i < 144; ++i)
+  flt[i] = 8;
+var i;
+for (i = 144; i < 256; ++i)
+  flt[i] = 9;
+var i;
+for (i = 256; i < 280; ++i)
+  flt[i] = 7;
+var i;
+for (i = 280; i < 288; ++i)
+  flt[i] = 8;
+var i;
+var fdt = new u8(32);
+for (i = 0; i < 32; ++i)
+  fdt[i] = 5;
+var i;
+var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+var max = function(a2) {
+  var m = a2[0];
+  for (var i = 1; i < a2.length; ++i) {
+    if (a2[i] > m)
+      m = a2[i];
   }
-  return records;
+  return m;
+};
+var bits = function(d, p, m) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+};
+var bits16 = function(d, p) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
 };
-var readRecordData = (buf, { sofh }) => {
-  const dataSize = readIndex(buf, sofh + 22, 4);
-  const n = readIndex(buf, sofh + 26, 2);
-  const m = readIndex(buf, sofh + 28, 2);
-  return buf.slice(sofh + 30 + n + m, sofh + 30 + n + m + dataSize);
+var shft = function(p) {
+  return (p + 7) / 8 | 0;
 };
-var getHeaders = (buf) => {
-  const eocdIdx = getEOCDStart(buf);
-  const nbRecords = readIndex(buf, eocdIdx + 10, 2);
-  const socdIdx = getSOCDStart(buf, eocdIdx);
-  const records = readEntryNames(buf, socdIdx, nbRecords);
-  return records;
+var slc = function(v, s, e) {
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  return new u8(v.subarray(s, e));
 };
+var ec = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  "no callback",
+  "invalid UTF-8 data",
+  "extra field too long",
+  "date not in range 1980-2099",
+  "filename too long",
+  "stream finishing",
+  "invalid zip data"
+  // determined by unknown compression method
+];
+var err = function(ind, msg, nt) {
+  var e = new Error(msg || ec[ind]);
+  e.code = ind;
+  if (Error.captureStackTrace)
+    Error.captureStackTrace(e, err);
+  if (!nt)
+    throw e;
+  return e;
+};
+var inflt = function(dat, st, buf, dict) {
+  var sl = dat.length, dl = dict ? dict.length : 0;
+  if (!sl || st.f && !st.l)
+    return buf || new u8(0);
+  var noBuf = !buf;
+  var resize = noBuf || st.i != 2;
+  var noSt = st.i;
+  if (noBuf)
+    buf = new u8(sl * 3);
+  var cbuf = function(l2) {
+    var bl = buf.length;
+    if (l2 > bl) {
+      var nbuf = new u8(Math.max(bl * 2, l2));
+      nbuf.set(buf);
+      buf = nbuf;
+    }
+  };
+  var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+  var tbts = sl * 8;
+  do {
+    if (!lm) {
+      final = bits(dat, pos, 1);
+      var type = bits(dat, pos + 1, 3);
+      pos += 3;
+      if (!type) {
+        var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+        if (t > sl) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + l);
+        buf.set(dat.subarray(s, t), bt);
+        st.b = bt += l, st.p = pos = t * 8, st.f = final;
+        continue;
+      } else if (type == 1)
+        lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+      else if (type == 2) {
+        var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+        var tl = hLit + bits(dat, pos + 5, 31) + 1;
+        pos += 14;
+        var ldt = new u8(tl);
+        var clt = new u8(19);
+        for (var i = 0; i < hcLen; ++i) {
+          clt[clim[i]] = bits(dat, pos + i * 3, 7);
+        }
+        pos += hcLen * 3;
+        var clb = max(clt), clbmsk = (1 << clb) - 1;
+        var clm = hMap(clt, clb, 1);
+        for (var i = 0; i < tl; ) {
+          var r = clm[bits(dat, pos, clbmsk)];
+          pos += r & 15;
+          var s = r >> 4;
+          if (s < 16) {
+            ldt[i++] = s;
+          } else {
+            var c = 0, n = 0;
+            if (s == 16)
+              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+            else if (s == 17)
+              n = 3 + bits(dat, pos, 7), pos += 3;
+            else if (s == 18)
+              n = 11 + bits(dat, pos, 127), pos += 7;
+            while (n--)
+              ldt[i++] = c;
+          }
+        }
+        var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+        lbt = max(lt);
+        dbt = max(dt);
+        lm = hMap(lt, lbt, 1);
+        dm = hMap(dt, dbt, 1);
+      } else
+        err(1);
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+    }
+    if (resize)
+      cbuf(bt + 131072);
+    var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+    var lpos = pos;
+    for (; ; lpos = pos) {
+      var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+      pos += c & 15;
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+      if (!c)
+        err(2);
+      if (sym < 256)
+        buf[bt++] = sym;
+      else if (sym == 256) {
+        lpos = pos, lm = null;
+        break;
+      } else {
+        var add = sym - 254;
+        if (sym > 264) {
+          var i = sym - 257, b = fleb[i];
+          add = bits(dat, pos, (1 << b) - 1) + fl[i];
+          pos += b;
+        }
+        var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+        if (!d)
+          err(3);
+        pos += d & 15;
+        var dt = fd[dsym];
+        if (dsym > 3) {
+          var b = fdeb[dsym];
+          dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+        }
+        if (pos > tbts) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + 131072);
+        var end = bt + add;
+        if (bt < dt) {
+          var shift = dl - dt, dend = Math.min(dt, end);
+          if (shift + bt < 0)
+            err(3);
+          for (; bt < dend; ++bt)
+            buf[bt] = dict[shift + bt];
+        }
+        for (; bt < end; ++bt)
+          buf[bt] = buf[bt - dt];
+      }
+    }
+    st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+    if (lm)
+      final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+  } while (!final);
+  return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+var et = /* @__PURE__ */ new u8(0);
+var b2 = function(d, b) {
+  return d[b] | d[b + 1] << 8;
+};
+var b4 = function(d, b) {
+  return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+};
+var b8 = function(d, b) {
+  return b4(d, b) + b4(d, b + 4) * 4294967296;
+};
+var Inflate = /* @__PURE__ */ function() {
+  function Inflate2(opts, cb) {
+    if (typeof opts == "function")
+      cb = opts, opts = {};
+    this.ondata = cb;
+    var dict = opts && opts.dictionary && opts.dictionary.subarray(-32768);
+    this.s = { i: 0, b: dict ? dict.length : 0 };
+    this.o = new u8(32768);
+    this.p = new u8(0);
+    if (dict)
+      this.o.set(dict);
+  }
+  Inflate2.prototype.e = function(c) {
+    if (!this.ondata)
+      err(5);
+    if (this.d)
+      err(4);
+    if (!this.p.length)
+      this.p = c;
+    else if (c.length) {
+      var n = new u8(this.p.length + c.length);
+      n.set(this.p), n.set(c, this.p.length), this.p = n;
+    }
+  };
+  Inflate2.prototype.c = function(final) {
+    this.s.i = +(this.d = final || false);
+    var bts = this.s.b;
+    var dt = inflt(this.p, this.s, this.o);
+    this.ondata(slc(dt, bts, this.s.b), this.d);
+    this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;
+    this.p = slc(this.p, this.s.p / 8 | 0), this.s.p &= 7;
+  };
+  Inflate2.prototype.push = function(chunk, final) {
+    this.e(chunk), this.c(final);
+  };
+  return Inflate2;
+}();
+var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+var tds = 0;
+try {
+  td.decode(et, { stream: true });
+  tds = 1;
+} catch (e) {
+}
+var dutf8 = function(d) {
+  for (var r = "", i = 0; ; ) {
+    var c = d[i++];
+    var eb = (c > 127) + (c > 223) + (c > 239);
+    if (i + eb > d.length)
+      return { s: r, r: slc(d, i - 1) };
+    if (!eb)
+      r += String.fromCharCode(c);
+    else if (eb == 3) {
+      c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | d[i++] & 63) - 65536, r += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
+    } else if (eb & 1)
+      r += String.fromCharCode((c & 31) << 6 | d[i++] & 63);
+    else
+      r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | d[i++] & 63);
+  }
+};
+function strFromU8(dat, latin1) {
+  if (latin1) {
+    var r = "";
+    for (var i = 0; i < dat.length; i += 16384)
+      r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));
+    return r;
+  } else if (td) {
+    return td.decode(dat);
+  } else {
+    var _a2 = dutf8(dat), s = _a2.s, r = _a2.r;
+    if (r.length)
+      err(8);
+    return s;
+  }
+}
+var z64e = function(d, b) {
+  for (; b2(d, b) != 1; b += 4 + b2(d, b + 2))
+    ;
+  return [b8(d, b + 12), b8(d, b + 4), b8(d, b + 20)];
+};
+var UnzipPassThrough = /* @__PURE__ */ function() {
+  function UnzipPassThrough2() {
+  }
+  UnzipPassThrough2.prototype.push = function(data, final) {
+    this.ondata(null, data, final);
+  };
+  UnzipPassThrough2.compression = 0;
+  return UnzipPassThrough2;
+}();
+var UnzipInflate = /* @__PURE__ */ function() {
+  function UnzipInflate2() {
+    var _this = this;
+    this.i = new Inflate(function(dat, final) {
+      _this.ondata(null, dat, final);
+    });
+  }
+  UnzipInflate2.prototype.push = function(data, final) {
+    try {
+      this.i.push(data, final);
+    } catch (e) {
+      this.ondata(e, null, final);
+    }
+  };
+  UnzipInflate2.compression = 8;
+  return UnzipInflate2;
+}();
+var Unzip = /* @__PURE__ */ function() {
+  function Unzip2(cb) {
+    this.onfile = cb;
+    this.k = [];
+    this.o = {
+      0: UnzipPassThrough
+    };
+    this.p = et;
+  }
+  Unzip2.prototype.push = function(chunk, final) {
+    var _this = this;
+    if (!this.onfile)
+      err(5);
+    if (!this.p)
+      err(4);
+    if (this.c > 0) {
+      var len = Math.min(this.c, chunk.length);
+      var toAdd = chunk.subarray(0, len);
+      this.c -= len;
+      if (this.d)
+        this.d.push(toAdd, !this.c);
+      else
+        this.k[0].push(toAdd);
+      chunk = chunk.subarray(len);
+      if (chunk.length)
+        return this.push(chunk, final);
+    } else {
+      var f = 0, i = 0, is = void 0, buf = void 0;
+      if (!this.p.length)
+        buf = chunk;
+      else if (!chunk.length)
+        buf = this.p;
+      else {
+        buf = new u8(this.p.length + chunk.length);
+        buf.set(this.p), buf.set(chunk, this.p.length);
+      }
+      var l = buf.length, oc = this.c, add = oc && this.d;
+      var _loop_2 = function() {
+        var _a2;
+        var sig = b4(buf, i);
+        if (sig == 67324752) {
+          f = 1, is = i;
+          this_1.d = null;
+          this_1.c = 0;
+          var bf = b2(buf, i + 6), cmp_1 = b2(buf, i + 8), u = bf & 2048, dd = bf & 8, fnl = b2(buf, i + 26), es = b2(buf, i + 28);
+          if (l > i + 30 + fnl + es) {
+            var chks_3 = [];
+            this_1.k.unshift(chks_3);
+            f = 2;
+            var sc_1 = b4(buf, i + 18), su_1 = b4(buf, i + 22);
+            var fn_1 = strFromU8(buf.subarray(i + 30, i += 30 + fnl), !u);
+            if (sc_1 == 4294967295) {
+              _a2 = dd ? [-2] : z64e(buf, i), sc_1 = _a2[0], su_1 = _a2[1];
+            } else if (dd)
+              sc_1 = -1;
+            i += es;
+            this_1.c = sc_1;
+            var d_1;
+            var file_1 = {
+              name: fn_1,
+              compression: cmp_1,
+              start: function() {
+                if (!file_1.ondata)
+                  err(5);
+                if (!sc_1)
+                  file_1.ondata(null, et, true);
+                else {
+                  var ctr = _this.o[cmp_1];
+                  if (!ctr)
+                    file_1.ondata(err(14, "unknown compression type " + cmp_1, 1), null, false);
+                  d_1 = sc_1 < 0 ? new ctr(fn_1) : new ctr(fn_1, sc_1, su_1);
+                  d_1.ondata = function(err2, dat3, final2) {
+                    file_1.ondata(err2, dat3, final2);
+                  };
+                  for (var _i = 0, chks_4 = chks_3; _i < chks_4.length; _i++) {
+                    var dat2 = chks_4[_i];
+                    d_1.push(dat2, false);
+                  }
+                  if (_this.k[0] == chks_3 && _this.c)
+                    _this.d = d_1;
+                  else
+                    d_1.push(et, true);
+                }
+              },
+              terminate: function() {
+                if (d_1 && d_1.terminate)
+                  d_1.terminate();
+              }
+            };
+            if (sc_1 >= 0)
+              file_1.size = sc_1, file_1.originalSize = su_1;
+            this_1.onfile(file_1);
+          }
+          return "break";
+        } else if (oc) {
+          if (sig == 134695760) {
+            is = i += 12 + (oc == -2 && 8), f = 3, this_1.c = 0;
+            return "break";
+          } else if (sig == 33639248) {
+            is = i -= 4, f = 3, this_1.c = 0;
+            return "break";
+          }
+        }
+      };
+      var this_1 = this;
+      for (; i < l - 4; ++i) {
+        var state_1 = _loop_2();
+        if (state_1 === "break")
+          break;
+      }
+      this.p = et;
+      if (oc < 0) {
+        var dat = f ? buf.subarray(0, is - 12 - (oc == -2 && 8) - (b4(buf, is - 16) == 134695760 && 4)) : buf.subarray(0, i);
+        if (add)
+          add.push(dat, !!f);
+        else
+          this.k[+(f == 2)].push(dat);
+      }
+      if (f & 2)
+        return this.push(buf.subarray(i), final);
+      this.p = buf.subarray(i);
+    }
+    if (final) {
+      if (this.c)
+        err(13);
+      this.p = null;
+    }
+  };
+  Unzip2.prototype.register = function(decoder) {
+    this.o[decoder.compression] = decoder;
+  };
+  return Unzip2;
+}();
 
 // src/worker/wwZip.ts
 var key = new Uint8Array([..."4c6520636f6e74656e7520646573206c".matchAll(/../g)].map(([c]) => Number(`0x${c}`)));
 var iv = new Uint8Array(16).fill(0);
 async function decryptData(encryptedData, key2, iv2) {
-  const cryptoKey = await crypto.subtle.importKey("raw", key2.buffer, { name: "AES-CBC" }, false, [
-    "decrypt"
-  ]);
-  const decryptedData = await crypto.subtle.decrypt(
-    { name: "AES-CBC", iv: iv2.buffer },
-    cryptoKey,
-    encryptedData
-  );
+  const cryptoKey = await crypto.subtle.importKey("raw", key2.buffer, { name: "AES-CBC" }, false, ["decrypt"]);
+  const decryptedData = await crypto.subtle.decrypt({ name: "AES-CBC", iv: iv2.buffer }, cryptoKey, encryptedData);
   return decryptedData;
 }
 var BOOKS = {};
@@ -260,14 +802,12 @@ var readZipEntry = async ({
       const originalName = manifest.medias[zipName];
       overridenName = `medias/${originalName}`;
     } else {
-      if (entryName !== "manifest.json") {
-        console.error("any media should exist in manifest", zipName, entryName, bookId);
-      }
+      console.error("any media should exist in manifest", zipName, entryName, bookId);
     }
   }
   const bookEntry = BOOKS[bookId].map.get(overridenName);
   if (!bookEntry) {
-    console.info("no bookEntry", entryName, "overridingName:", overridenName, "for book", bookId);
+    console.info("no bookEntry", entryName, "found", overridenName);
     return null;
   }
   if (!bookEntry.decoded) {
@@ -280,19 +820,43 @@ var hasZip = (bookId) => {
 };
 var loadZip = async (buf, bookId) => {
   const m = /* @__PURE__ */ new Map();
-  const headers = getHeaders(buf);
-  for (const header of headers) {
-    const name = new TextDecoder().decode(header.name);
-    if (!name.includes(".")) {
-      continue;
+  const unzipper = new Unzip();
+  unzipper.register(UnzipInflate);
+  unzipper.onfile = (file) => {
+    if (!file.name.includes(".")) {
+      return;
     }
-    m.set(name, {
+    m.set(file.name, {
       decoded: null,
       zipEntry: {
-        getData: async () => readRecordData(buf, header).buffer
+        getData: () => {
+          return new Promise((resolve) => {
+            const buffers = [];
+            file.ondata = (err2, data, final) => {
+              if (err2) {
+                console.error("failed to read zip data", file.name, err2);
+              }
+              if (data.byteLength) {
+                buffers.push(data);
+              }
+              if (final) {
+                return resolve(concatArrayBuffers(buffers));
+              }
+            };
+            file.start();
+          });
+        }
       }
     });
+  };
+  const chunkSize = 32 * 1024 * 1024;
+  const nChunks = Math.max(1, Math.floor(buf.byteLength / chunkSize));
+  const sleep = new Promise((resolve) => setTimeout(resolve, 0));
+  for (let i = 0; i < nChunks - 1; ++i) {
+    unzipper.push(buf.slice(i * chunkSize, (i + 1) * chunkSize));
+    await sleep;
   }
+  unzipper.push(buf.slice((nChunks - 1) * chunkSize, buf.byteLength), true);
   BOOKS[bookId] = {
     map: m,
     manifest: null
@@ -322,8 +886,7 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
       return back;
     }
     if (STORAGE === "cache") {
-      const cache = await openCache(CONF_ENV);
-      const response = await cache.match(zipUrl);
+      const response = await caches.match(zipUrl);
       if (!response) {
         throw new Error(`missing zip ${zipUrl}`);
       }
@@ -347,11 +910,7 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
     const buf = await readArrayBuffer();
     if (CHECK_UPDATES) {
       const response = await fetch(zipUrl, { method: "HEAD" });
-      let remoteSize = Number.parseInt(response.headers.get("content-length") ?? "");
-      if (!remoteSize) {
-        console.info("remoteSize not found. will skip update. Is the server up at", zipUrl);
-        remoteSize = buf.byteLength;
-      }
+      const remoteSize = Number.parseInt(response.headers.get("content-length") || "0", 10);
       if (remoteSize !== buf.byteLength) {
         const error = `new ${fileName} available, refetching (opfs:${buf.byteLength} vs remote:${remoteSize})`;
         console.debug(error);
@@ -359,7 +918,6 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
         throw new Error(`new ${fileName} available, refetching`);
       }
     }
-    self.postMessage({ methodName: "opfsProgress", arg: { total: buf.byteLength, bytes: buf.byteLength } });
     return buf;
   } catch (e) {
     if (e instanceof Error && e.message !== "forceRefresh" && !e.message.includes("refetching")) {
@@ -389,7 +947,6 @@ var fetchZipFile = async (zipUrl, { forceRefresh } = {}) => {
         self.postMessage({ methodName: "opfsProgress", arg: { total: contentLength, bytes: position } });
       }
     }
-    console.debug("zip loaded:", arrayBuffer.byteLength);
     if (STORAGE === "native") {
       await sender.nativeWriteFile({ fname: fileName, buffer: arrayBuffer });
     } else if (STORAGE === "opfs") {
@@ -434,15 +991,8 @@ var loadBook2 = async ({ id: bookId, forceRefresh }) => {
     tryCatch(async () => {
       const buf = await fetchZipFile(`${ZIP_BASE_URL}/${bookId}.zip`, { forceRefresh });
       try {
-        console.time("loadzip");
         const entryNames = await loadZip(new Uint8Array(buf), bookId);
-        console.timeEnd("loadzip");
-        const eventId = `setKnownLinks:${Date.now()}-${Math.random().toFixed(5)}`;
-        const responseForEventId = new Promise((resolve, reject) => {
-          dicFetchWorkerCallback[eventId] = { resolve, reject };
-        });
-        fetchWorker.postMessage({ methodName: "setKnownLinks", arg: { entryNames, bookId, eventId } });
-        await responseForEventId;
+        fetchWorker.postMessage({ methodName: "setKnownLinks", arg: { entryNames, bookId } });
         if (isOldZip(bookId)) {
           const json = await readZipEntry({
             entryName: `preload/${bookId}.json`,
@@ -450,13 +1000,6 @@ var loadBook2 = async ({ id: bookId, forceRefresh }) => {
             asJson: true
           });
           loadBook(json);
-        } else {
-          try {
-            const { createdAt } = await readZipEntry({ bookId, entryName: "manifest.json", asJson: true });
-            console.debug("zipversion", createdAt);
-          } catch (e) {
-            console.debug("failed to read manifest.json", e);
-          }
         }
         return true;
       } catch (e) {
@@ -486,14 +1029,6 @@ var loadPageContent2 = async ({
   return await loadPageContent({ chapterId, json });
 };
 var fetchWorker;
-var dicFetchWorkerCallback = {};
-var handleFetchWorkerCallback = ({ data: { eventId } }) => {
-  if (dicFetchWorkerCallback[eventId]) {
-    dicFetchWorkerCallback[eventId].resolve();
-  } else {
-    console.debug("unknown eventId", eventId);
-  }
-};
 var initChannel = (__, { ports }) => {
   fetchWorker = ports[0];
   const { canHandle, handle } = makeSyncHandler(fetchWorker, {
@@ -508,14 +1043,6 @@ var initChannel = (__, { ports }) => {
       self.postMessage({ methodName: "ready" });
       return;
     }
-    if (dataObj.data?.methodName === "setKnownLinks:back") {
-      if (typeof dataObj?.data?.eventId !== "string") {
-        console.debug("missing eventId to get response back for setKnownLinks:back");
-        return;
-      }
-      handleFetchWorkerCallback(dataObj);
-      return;
-    }
     if (canHandle(dataObj.data?.methodName || "")) {
       return handle(dataObj);
     }
@@ -589,18 +1116,13 @@ var loadPreload2 = async () => {
     console.error("failed to load preload", e);
   }
 };
-var reset = async () => {
-  await (await navigator.storage.getDirectory()).remove({ recursive: true });
-  console.info("opfs cleared");
-};
 var mainHandle = makeSyncHandler(self, {
   initChannel,
   loadPreload: loadPreload2,
   readZipEntry,
   loadBooks,
   loadBook: loadBook2,
-  configure,
-  reset
+  configure
 });
 var { handler, ...sender } = makeSyncWorker(self, ["nativeWriteFile", "nativeReadFile", "nativeListZips"]);
 self.onmessage = combineHandlers(mainHandle, handler);

package/lib/index.js

@@ -31,18 +31,7 @@ var makeSyncWorker = (offlineWorker2, methodNames, dbg) => {
     return ({ ports, ...arg } = {}) => {
       return new Promise((resolve, reject) => {
         const eventId = `${methodName}:${Date.now()}-${Math.random().toFixed(5)}`;
-        let resolved = false;
-        const timeout = setTimeout(() => {
-          console.warn("slow request for", methodName, arg);
-        }, 3e3);
-        const doResolve = (arg2) => {
-          if (!resolved) {
-            resolved = true;
-            clearTimeout(timeout);
-            resolve(arg2);
-          }
-        };
-        dic[eventId] = { resolve: doResolve, reject };
+        dic[eventId] = { resolve, reject };
         offlineWorker2.postMessage({ eventId, methodName, arg }, ports);
       });
     };
@@ -93,14 +82,13 @@ var combineHandlers = (...handlers) => {
     console.error("no handlers matched", methodName);
   };
 };
-var clearCache = async (mode) => caches.delete(`LLS_OFFLINE_${mode}`);
 
 // src/hooks/useOfflineWorker.ts
 import { useCallback, useEffect, useState } from "react";
 var offlineWorker = new Worker("/src/worker/offline-worker.js", { type: "module" });
 var { handler, ...offlineWorkerSync } = makeSyncWorker(
   offlineWorker,
-  ["initChannel", "readZipEntry", "configure", "loadPreload", "loadBooks", "loadBook", "reset"],
+  ["initChannel", "readZipEntry", "configure", "loadPreload", "loadBooks", "loadBook"],
   "app:offlineWorker"
 );
 var fetchWorkerPromise = new Promise(
@@ -172,7 +160,6 @@ var installWorker = async ({
   setBooksLoaded();
 };
 var useOfflineWorker_default = ({
-  skipLoadBooks,
   primaryOnly = false,
   nativeReadFile,
   nativeWriteFile,
@@ -186,7 +173,6 @@ var useOfflineWorker_default = ({
   useEffect(() => {
     const fn = async () => {
       await installWorker({
-        skipLoadBooks,
         primaryOnly,
         nativeReadFile,
         nativeWriteFile,
@@ -201,69 +187,19 @@ var useOfflineWorker_default = ({
       setReady(true);
     };
     fn();
-  }, [
-    skipLoadBooks,
-    primaryOnly,
-    nativeReadFile,
-    nativeWriteFile,
-    nativeListZips,
-    storage,
-    zipBaseUrl,
-    checkUpdates,
-    confEnv
-  ]);
+  }, [primaryOnly, nativeReadFile, nativeWriteFile, nativeListZips, storage, zipBaseUrl, checkUpdates, confEnv]);
   const loadBook = useCallback(
-    async ({ forceRefresh, ...idOrUri }, cbk) => {
-      cbk && offlineWorkerSync.on("opfsProgress", cbk);
-      return await offlineWorkerSync.loadBook({ id: "id" in idOrUri ? idOrUri.id : idOrUri.uri, forceRefresh });
+    async ({ id, forceRefresh }, cbk) => {
+      offlineWorkerSync.on("opfsProgress", cbk);
+      return await offlineWorkerSync.loadBook({ id, forceRefresh });
     },
     []
   );
-  const reset = useCallback(async () => {
-    await offlineWorkerSync.reset();
-    await clearCache(confEnv || "development");
-    console.debug("reset: keys:", await caches.keys());
-  }, [confEnv]);
   return {
     ready,
-    loadBook,
-    reset
+    loadBook
   };
 };
-
-// src/store/index.ts
-import { persistReducer } from "redux-persist";
-var persistEntitiesReducer = (entitiesReducer, CONF_ENV) => {
-  const getKey = (key) => `store:${CONF_ENV}:${key}`;
-  return persistReducer(
-    {
-      key: "entities",
-      storage: {
-        getItem: async (key) => localStorage.getItem(getKey(key)) || "{}",
-        setItem: async (key, item) => localStorage.setItem(getKey(key), item),
-        removeItem: async (key) => localStorage.removeItem(getKey(key))
-      },
-      whitelist: ["lexicalFlowers"],
-      version: 1,
-      debug: true,
-      throttle: 1e3
-      // lexicalFlowers is small, we may persist it fast
-    },
-    entitiesReducer
-  );
-};
-
-// src/store/offlinePersist.tsx
-import { persistStore } from "redux-persist";
-import { PersistGate } from "redux-persist/integration/react";
-import { useMemo } from "react";
-import { jsx } from "react/jsx-runtime";
-var OfflinePersist = ({ store, children }) => {
-  const persistor = useMemo(() => persistStore(store), [store]);
-  return /* @__PURE__ */ jsx(PersistGate, { loading: null, persistor, children });
-};
 export {
-  OfflinePersist,
-  persistEntitiesReducer,
   useOfflineWorker_default as useOfflineWorker
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lls/offline",
-  "version": "24.27.0-bbbcfe5a",
+  "version": "24.27.0-d7760203",
   "description": "offline",
   "main": "./lib/index.js",
   "module": "./lib/index.js",
@@ -48,15 +48,14 @@
     "nock": "14.0.5",
     "react": "18.3.1",
     "react-dom": "18.3.1",
-    "redux": "5.0.1",
     "typescript": "5.8.3",
     "vite": "7.0.7",
     "vite-tsconfig-paths": "5.1.4",
     "zod": "3.25.50",
-    "@lls/vitescripts": "24.27.0-bbbcfe5a"
+    "@lls/vitescripts": "24.27.0-d7760203"
   },
   "dependencies": {
-    "redux-persist": "6.0.0"
+    "fflate": "0.8.2"
   },
   "scripts": {
     "start": "pnpm ladle serve",