@namzu/cli 34.1.1 → 36.0.0

package/dist/chunks/lib-KXZZJJG2.js

@@ -0,0 +1,2657 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  __name
+} from "./chunk-76FLAFCG.js";
+
+// ../../node_modules/.pnpm/fflate@0.8.3/node_modules/fflate/esm/index.mjs
+import { createRequire } from "module";
+var require2 = createRequire("/");
+var _a;
+var Worker;
+var isMarkedAsUntransferable;
+try {
+  _a = require2("worker_threads"), Worker = _a.Worker, isMarkedAsUntransferable = _a.isMarkedAsUntransferable;
+} catch (e) {
+}
+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 = /* @__PURE__ */ __name(function(eb, start) {
+  var b = new u16(31);
+  for (var i2 = 0; i2 < 31; ++i2) {
+    b[i2] = start += 1 << eb[i2 - 1];
+  }
+  var r = new i32(b[30]);
+  for (var i2 = 1; i2 < 30; ++i2) {
+    for (var j = b[i2]; j < b[i2 + 1]; ++j) {
+      r[j] = j - b[i2] << 5 | i2;
+    }
+  }
+  return { b, r };
+}, "freb");
+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 = /* @__PURE__ */ __name((function(cd, mb, r) {
+  var s = cd.length;
+  var i2 = 0;
+  var l = new u16(mb);
+  for (; i2 < s; ++i2) {
+    if (cd[i2])
+      ++l[cd[i2] - 1];
+  }
+  var le = new u16(mb);
+  for (i2 = 1; i2 < mb; ++i2) {
+    le[i2] = le[i2 - 1] + l[i2 - 1] << 1;
+  }
+  var co;
+  if (r) {
+    co = new u16(1 << mb);
+    var rvb = 15 - mb;
+    for (i2 = 0; i2 < s; ++i2) {
+      if (cd[i2]) {
+        var sv = i2 << 4 | cd[i2];
+        var r_1 = mb - cd[i2];
+        var v = le[cd[i2] - 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 (i2 = 0; i2 < s; ++i2) {
+      if (cd[i2]) {
+        co[i2] = rev[le[cd[i2] - 1]++] >> 15 - cd[i2];
+      }
+    }
+  }
+  return co;
+}), "hMap");
+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 flm = /* @__PURE__ */ hMap(flt, 9, 0);
+var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+var fdm = /* @__PURE__ */ hMap(fdt, 5, 0);
+var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+var max = /* @__PURE__ */ __name(function(a) {
+  var m = a[0];
+  for (var i2 = 1; i2 < a.length; ++i2) {
+    if (a[i2] > m)
+      m = a[i2];
+  }
+  return m;
+}, "max");
+var bits = /* @__PURE__ */ __name(function(d, p, m) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+}, "bits");
+var bits16 = /* @__PURE__ */ __name(function(d, p) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+}, "bits16");
+var shft = /* @__PURE__ */ __name(function(p) {
+  return (p + 7) / 8 | 0;
+}, "shft");
+var slc = /* @__PURE__ */ __name(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));
+}, "slc");
+var ec = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  // determined by compression function
+  "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 = /* @__PURE__ */ __name(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;
+}, "err");
+var inflt = /* @__PURE__ */ __name(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 = /* @__PURE__ */ __name(function(l2) {
+    var bl = buf.length;
+    if (l2 > bl) {
+      var nbuf = new u8(Math.max(bl * 2, l2));
+      nbuf.set(buf);
+      buf = nbuf;
+    }
+  }, "cbuf");
+  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 i2 = 0; i2 < hcLen; ++i2) {
+          clt[clim[i2]] = bits(dat, pos + i2 * 3, 7);
+        }
+        pos += hcLen * 3;
+        var clb = max(clt), clbmsk = (1 << clb) - 1;
+        var clm = hMap(clt, clb, 1);
+        for (var i2 = 0; i2 < tl; ) {
+          var r = clm[bits(dat, pos, clbmsk)];
+          pos += r & 15;
+          var s = r >> 4;
+          if (s < 16) {
+            ldt[i2++] = s;
+          } else {
+            var c = 0, n = 0;
+            if (s == 16)
+              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i2 - 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[i2++] = 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 i2 = sym - 257, b = fleb[i2];
+          add = bits(dat, pos, (1 << b) - 1) + fl[i2];
+          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);
+}, "inflt");
+var wbits = /* @__PURE__ */ __name(function(d, p, v) {
+  v <<= p & 7;
+  var o = p / 8 | 0;
+  d[o] |= v;
+  d[o + 1] |= v >> 8;
+}, "wbits");
+var wbits16 = /* @__PURE__ */ __name(function(d, p, v) {
+  v <<= p & 7;
+  var o = p / 8 | 0;
+  d[o] |= v;
+  d[o + 1] |= v >> 8;
+  d[o + 2] |= v >> 16;
+}, "wbits16");
+var hTree = /* @__PURE__ */ __name(function(d, mb) {
+  var t = [];
+  for (var i2 = 0; i2 < d.length; ++i2) {
+    if (d[i2])
+      t.push({ s: i2, f: d[i2] });
+  }
+  var s = t.length;
+  var t2 = t.slice();
+  if (!s)
+    return { t: et, l: 0 };
+  if (s == 1) {
+    var v = new u8(t[0].s + 1);
+    v[t[0].s] = 1;
+    return { t: v, l: 1 };
+  }
+  t.sort(function(a, b) {
+    return a.f - b.f;
+  });
+  t.push({ s: -1, f: 25001 });
+  var l = t[0], r = t[1], i0 = 0, i1 = 1, i22 = 2;
+  t[0] = { s: -1, f: l.f + r.f, l, r };
+  while (i1 != s - 1) {
+    l = t[t[i0].f < t[i22].f ? i0++ : i22++];
+    r = t[i0 != i1 && t[i0].f < t[i22].f ? i0++ : i22++];
+    t[i1++] = { s: -1, f: l.f + r.f, l, r };
+  }
+  var maxSym = t2[0].s;
+  for (var i2 = 1; i2 < s; ++i2) {
+    if (t2[i2].s > maxSym)
+      maxSym = t2[i2].s;
+  }
+  var tr = new u16(maxSym + 1);
+  var mbt = ln(t[i1 - 1], tr, 0);
+  if (mbt > mb) {
+    var i2 = 0, dt = 0;
+    var lft = mbt - mb, cst = 1 << lft;
+    t2.sort(function(a, b) {
+      return tr[b.s] - tr[a.s] || a.f - b.f;
+    });
+    for (; i2 < s; ++i2) {
+      var i2_1 = t2[i2].s;
+      if (tr[i2_1] > mb) {
+        dt += cst - (1 << mbt - tr[i2_1]);
+        tr[i2_1] = mb;
+      } else
+        break;
+    }
+    dt >>= lft;
+    while (dt > 0) {
+      var i2_2 = t2[i2].s;
+      if (tr[i2_2] < mb)
+        dt -= 1 << mb - tr[i2_2]++ - 1;
+      else
+        ++i2;
+    }
+    for (; i2 >= 0 && dt; --i2) {
+      var i2_3 = t2[i2].s;
+      if (tr[i2_3] == mb) {
+        --tr[i2_3];
+        ++dt;
+      }
+    }
+    mbt = mb;
+  }
+  return { t: new u8(tr), l: mbt };
+}, "hTree");
+var ln = /* @__PURE__ */ __name(function(n, l, d) {
+  return n.s == -1 ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) : l[n.s] = d;
+}, "ln");
+var lc = /* @__PURE__ */ __name(function(c) {
+  var s = c.length;
+  while (s && !c[--s])
+    ;
+  var cl = new u16(++s);
+  var cli = 0, cln = c[0], cls = 1;
+  var w = /* @__PURE__ */ __name(function(v) {
+    cl[cli++] = v;
+  }, "w");
+  for (var i2 = 1; i2 <= s; ++i2) {
+    if (c[i2] == cln && i2 != s)
+      ++cls;
+    else {
+      if (!cln && cls > 2) {
+        for (; cls > 138; cls -= 138)
+          w(32754);
+        if (cls > 2) {
+          w(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
+          cls = 0;
+        }
+      } else if (cls > 3) {
+        w(cln), --cls;
+        for (; cls > 6; cls -= 6)
+          w(8304);
+        if (cls > 2)
+          w(cls - 3 << 5 | 8208), cls = 0;
+      }
+      while (cls--)
+        w(cln);
+      cls = 1;
+      cln = c[i2];
+    }
+  }
+  return { c: cl.subarray(0, cli), n: s };
+}, "lc");
+var clen = /* @__PURE__ */ __name(function(cf, cl) {
+  var l = 0;
+  for (var i2 = 0; i2 < cl.length; ++i2)
+    l += cf[i2] * cl[i2];
+  return l;
+}, "clen");
+var wfblk = /* @__PURE__ */ __name(function(out, pos, dat) {
+  var s = dat.length;
+  var o = shft(pos + 2);
+  out[o] = s & 255;
+  out[o + 1] = s >> 8;
+  out[o + 2] = out[o] ^ 255;
+  out[o + 3] = out[o + 1] ^ 255;
+  for (var i2 = 0; i2 < s; ++i2)
+    out[o + i2 + 4] = dat[i2];
+  return (o + 4 + s) * 8;
+}, "wfblk");
+var wblk = /* @__PURE__ */ __name(function(dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
+  wbits(out, p++, final);
+  ++lf[256];
+  var _a2 = hTree(lf, 15), dlt = _a2.t, mlb = _a2.l;
+  var _b2 = hTree(df, 15), ddt = _b2.t, mdb = _b2.l;
+  var _c = lc(dlt), lclt = _c.c, nlc = _c.n;
+  var _d = lc(ddt), lcdt = _d.c, ndc = _d.n;
+  var lcfreq = new u16(19);
+  for (var i2 = 0; i2 < lclt.length; ++i2)
+    ++lcfreq[lclt[i2] & 31];
+  for (var i2 = 0; i2 < lcdt.length; ++i2)
+    ++lcfreq[lcdt[i2] & 31];
+  var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l;
+  var nlcc = 19;
+  for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
+    ;
+  var flen = bl + 5 << 3;
+  var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
+  var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
+  if (bs >= 0 && flen <= ftlen && flen <= dtlen)
+    return wfblk(out, p, dat.subarray(bs, bs + bl));
+  var lm, ll, dm, dl;
+  wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
+  if (dtlen < ftlen) {
+    lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;
+    var llm = hMap(lct, mlcb, 0);
+    wbits(out, p, nlc - 257);
+    wbits(out, p + 5, ndc - 1);
+    wbits(out, p + 10, nlcc - 4);
+    p += 14;
+    for (var i2 = 0; i2 < nlcc; ++i2)
+      wbits(out, p + 3 * i2, lct[clim[i2]]);
+    p += 3 * nlcc;
+    var lcts = [lclt, lcdt];
+    for (var it = 0; it < 2; ++it) {
+      var clct = lcts[it];
+      for (var i2 = 0; i2 < clct.length; ++i2) {
+        var len = clct[i2] & 31;
+        wbits(out, p, llm[len]), p += lct[len];
+        if (len > 15)
+          wbits(out, p, clct[i2] >> 5 & 127), p += clct[i2] >> 12;
+      }
+    }
+  } else {
+    lm = flm, ll = flt, dm = fdm, dl = fdt;
+  }
+  for (var i2 = 0; i2 < li; ++i2) {
+    var sym = syms[i2];
+    if (sym > 255) {
+      var len = sym >> 18 & 31;
+      wbits16(out, p, lm[len + 257]), p += ll[len + 257];
+      if (len > 7)
+        wbits(out, p, sym >> 23 & 31), p += fleb[len];
+      var dst = sym & 31;
+      wbits16(out, p, dm[dst]), p += dl[dst];
+      if (dst > 3)
+        wbits16(out, p, sym >> 5 & 8191), p += fdeb[dst];
+    } else {
+      wbits16(out, p, lm[sym]), p += ll[sym];
+    }
+  }
+  wbits16(out, p, lm[256]);
+  return p + ll[256];
+}, "wblk");
+var deo = /* @__PURE__ */ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
+var et = /* @__PURE__ */ new u8(0);
+var dflt = /* @__PURE__ */ __name(function(dat, lvl, plvl, pre, post, st) {
+  var s = st.z || dat.length;
+  var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7e3)) + post);
+  var w = o.subarray(pre, o.length - post);
+  var lst = st.l;
+  var pos = (st.r || 0) & 7;
+  if (lvl) {
+    if (pos)
+      w[0] = st.r >> 3;
+    var opt = deo[lvl - 1];
+    var n = opt >> 13, c = opt & 8191;
+    var msk_1 = (1 << plvl) - 1;
+    var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);
+    var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
+    var hsh = /* @__PURE__ */ __name(function(i3) {
+      return (dat[i3] ^ dat[i3 + 1] << bs1_1 ^ dat[i3 + 2] << bs2_1) & msk_1;
+    }, "hsh");
+    var syms = new i32(25e3);
+    var lf = new u16(288), df = new u16(32);
+    var lc_1 = 0, eb = 0, i2 = st.i || 0, li = 0, wi = st.w || 0, bs = 0;
+    for (; i2 + 2 < s; ++i2) {
+      var hv = hsh(i2);
+      var imod = i2 & 32767, pimod = head[hv];
+      prev[imod] = pimod;
+      head[hv] = imod;
+      if (wi <= i2) {
+        var rem = s - i2;
+        if ((lc_1 > 7e3 || li > 24576) && (rem > 423 || !lst)) {
+          pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i2 - bs, pos);
+          li = lc_1 = eb = 0, bs = i2;
+          for (var j = 0; j < 286; ++j)
+            lf[j] = 0;
+          for (var j = 0; j < 30; ++j)
+            df[j] = 0;
+        }
+        var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
+        if (rem > 2 && hv == hsh(i2 - dif)) {
+          var maxn = Math.min(n, rem) - 1;
+          var maxd = Math.min(32767, i2);
+          var ml = Math.min(258, rem);
+          while (dif <= maxd && --ch_1 && imod != pimod) {
+            if (dat[i2 + l] == dat[i2 + l - dif]) {
+              var nl = 0;
+              for (; nl < ml && dat[i2 + nl] == dat[i2 + nl - dif]; ++nl)
+                ;
+              if (nl > l) {
+                l = nl, d = dif;
+                if (nl > maxn)
+                  break;
+                var mmd = Math.min(dif, nl - 2);
+                var md = 0;
+                for (var j = 0; j < mmd; ++j) {
+                  var ti = i2 - dif + j & 32767;
+                  var pti = prev[ti];
+                  var cd = ti - pti & 32767;
+                  if (cd > md)
+                    md = cd, pimod = ti;
+                }
+              }
+            }
+            imod = pimod, pimod = prev[imod];
+            dif += imod - pimod & 32767;
+          }
+        }
+        if (d) {
+          syms[li++] = 268435456 | revfl[l] << 18 | revfd[d];
+          var lin = revfl[l] & 31, din = revfd[d] & 31;
+          eb += fleb[lin] + fdeb[din];
+          ++lf[257 + lin];
+          ++df[din];
+          wi = i2 + l;
+          ++lc_1;
+        } else {
+          syms[li++] = dat[i2];
+          ++lf[dat[i2]];
+        }
+      }
+    }
+    for (i2 = Math.max(i2, wi); i2 < s; ++i2) {
+      syms[li++] = dat[i2];
+      ++lf[dat[i2]];
+    }
+    pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i2 - bs, pos);
+    if (!lst) {
+      st.r = pos & 7 | w[pos / 8 | 0] << 3;
+      pos -= 7;
+      st.h = head, st.p = prev, st.i = i2, st.w = wi;
+    }
+  } else {
+    for (var i2 = st.w || 0; i2 < s + lst; i2 += 65535) {
+      var e = i2 + 65535;
+      if (e >= s) {
+        w[pos / 8 | 0] = lst;
+        e = s;
+      }
+      pos = wfblk(w, pos + 1, dat.subarray(i2, e));
+    }
+    st.i = s;
+  }
+  return slc(o, 0, pre + shft(pos) + post);
+}, "dflt");
+var adler = /* @__PURE__ */ __name(function() {
+  var a = 1, b = 0;
+  return {
+    p: /* @__PURE__ */ __name(function(d) {
+      var n = a, m = b;
+      var l = d.length | 0;
+      for (var i2 = 0; i2 != l; ) {
+        var e = Math.min(i2 + 2655, l);
+        for (; i2 < e; ++i2)
+          m += n += d[i2];
+        n = (n & 65535) + 15 * (n >> 16), m = (m & 65535) + 15 * (m >> 16);
+      }
+      a = n, b = m;
+    }, "p"),
+    d: /* @__PURE__ */ __name(function() {
+      a %= 65521, b %= 65521;
+      return (a & 255) << 24 | (a & 65280) << 8 | (b & 255) << 8 | b >> 8;
+    }, "d")
+  };
+}, "adler");
+var dopt = /* @__PURE__ */ __name(function(dat, opt, pre, post, st) {
+  if (!st) {
+    st = { l: 1 };
+    if (opt.dictionary) {
+      var dict = opt.dictionary.subarray(-32768);
+      var newDat = new u8(dict.length + dat.length);
+      newDat.set(dict);
+      newDat.set(dat, dict.length);
+      dat = newDat;
+      st.w = dict.length;
+    }
+  }
+  return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20 : 12 + opt.mem, pre, post, st);
+}, "dopt");
+var wbytes = /* @__PURE__ */ __name(function(d, b, v) {
+  for (; v; ++b)
+    d[b] = v, v >>>= 8;
+}, "wbytes");
+var zlh = /* @__PURE__ */ __name(function(c, o) {
+  var lv = o.level, fl2 = lv == 0 ? 0 : lv < 6 ? 1 : lv == 9 ? 3 : 2;
+  c[0] = 120, c[1] = fl2 << 6 | (o.dictionary && 32);
+  c[1] |= 31 - (c[0] << 8 | c[1]) % 31;
+  if (o.dictionary) {
+    var h = adler();
+    h.p(o.dictionary);
+    wbytes(c, 2, h.d());
+  }
+}, "zlh");
+var zls = /* @__PURE__ */ __name(function(d, dict) {
+  if ((d[0] & 15) != 8 || d[0] >> 4 > 7 || (d[0] << 8 | d[1]) % 31)
+    err(6, "invalid zlib data");
+  if ((d[1] >> 5 & 1) == +!dict)
+    err(6, "invalid zlib data: " + (d[1] & 32 ? "need" : "unexpected") + " dictionary");
+  return (d[1] >> 3 & 4) + 2;
+}, "zls");
+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);
+  }
+  __name(Inflate2, "Inflate");
+  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;
+})();
+function zlibSync(data, opts) {
+  if (!opts)
+    opts = {};
+  var a = adler();
+  a.p(data);
+  var d = dopt(data, opts, opts.dictionary ? 6 : 2, 4);
+  return zlh(d, opts), wbytes(d, d.length - 4, a.d()), d;
+}
+__name(zlibSync, "zlibSync");
+var Unzlib = /* @__PURE__ */ (function() {
+  function Unzlib2(opts, cb) {
+    Inflate.call(this, opts, cb);
+    this.v = opts && opts.dictionary ? 2 : 1;
+  }
+  __name(Unzlib2, "Unzlib");
+  Unzlib2.prototype.push = function(chunk, final) {
+    Inflate.prototype.e.call(this, chunk);
+    if (this.v) {
+      if (this.p.length < 6 && !final)
+        return;
+      this.p = this.p.subarray(zls(this.p, this.v - 1)), this.v = 0;
+    }
+    if (final) {
+      if (this.p.length < 4)
+        err(6, "invalid zlib data");
+      this.p = this.p.subarray(0, -4);
+    }
+    Inflate.prototype.c.call(this, final);
+  };
+  return Unzlib2;
+})();
+function unzlibSync(data, opts) {
+  return inflt(data.subarray(zls(data, opts && opts.dictionary), -4), { i: 2 }, opts && opts.out, opts && opts.dictionary);
+}
+__name(unzlibSync, "unzlibSync");
+var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+var tds = 0;
+try {
+  td.decode(et, { stream: true });
+  tds = 1;
+} catch (e) {
+}
+
+// ../../node_modules/.pnpm/iobuffer@6.0.1/node_modules/iobuffer/lib/text.js
+function decode(bytes, encoding = "utf8") {
+  const decoder = new TextDecoder(encoding);
+  return decoder.decode(bytes);
+}
+__name(decode, "decode");
+var encoder = new TextEncoder();
+function encode(str) {
+  return encoder.encode(str);
+}
+__name(encode, "encode");
+
+// ../../node_modules/.pnpm/iobuffer@6.0.1/node_modules/iobuffer/lib/iobuffer.js
+var defaultByteLength = 1024 * 8;
+var hostBigEndian = (() => {
+  const array = new Uint8Array(4);
+  const view = new Uint32Array(array.buffer);
+  return !((view[0] = 1) & array[0]);
+})();
+var typedArrays = {
+  int8: globalThis.Int8Array,
+  uint8: globalThis.Uint8Array,
+  int16: globalThis.Int16Array,
+  uint16: globalThis.Uint16Array,
+  int32: globalThis.Int32Array,
+  uint32: globalThis.Uint32Array,
+  uint64: globalThis.BigUint64Array,
+  int64: globalThis.BigInt64Array,
+  float32: globalThis.Float32Array,
+  float64: globalThis.Float64Array
+};
+var IOBuffer = class _IOBuffer {
+  static {
+    __name(this, "IOBuffer");
+  }
+  /**
+   * Reference to the internal ArrayBuffer object.
+   */
+  buffer;
+  /**
+   * Byte length of the internal ArrayBuffer.
+   */
+  byteLength;
+  /**
+   * Byte offset of the internal ArrayBuffer.
+   */
+  byteOffset;
+  /**
+   * Byte length of the internal ArrayBuffer.
+   */
+  length;
+  /**
+   * The current offset of the buffer's pointer.
+   */
+  offset;
+  lastWrittenByte;
+  littleEndian;
+  _data;
+  _mark;
+  _marks;
+  /**
+   * Create a new IOBuffer.
+   * @param data - The data to construct the IOBuffer with.
+   * If data is a number, it will be the new buffer's length<br>
+   * If data is `undefined`, the buffer will be initialized with a default length of 8Kb<br>
+   * If data is an ArrayBuffer, SharedArrayBuffer, an ArrayBufferView (Typed Array), an IOBuffer instance,
+   * or a Node.js Buffer, a view will be created over the underlying ArrayBuffer.
+   * @param options - An object for the options.
+   * @returns A new IOBuffer instance.
+   */
+  constructor(data = defaultByteLength, options = {}) {
+    let dataIsGiven = false;
+    if (typeof data === "number") {
+      data = new ArrayBuffer(data);
+    } else {
+      dataIsGiven = true;
+      this.lastWrittenByte = data.byteLength;
+    }
+    const offset = options.offset ? options.offset >>> 0 : 0;
+    const byteLength = data.byteLength - offset;
+    let dvOffset = offset;
+    if (ArrayBuffer.isView(data) || data instanceof _IOBuffer) {
+      if (data.byteLength !== data.buffer.byteLength) {
+        dvOffset = data.byteOffset + offset;
+      }
+      data = data.buffer;
+    }
+    if (dataIsGiven) {
+      this.lastWrittenByte = byteLength;
+    } else {
+      this.lastWrittenByte = 0;
+    }
+    this.buffer = data;
+    this.length = byteLength;
+    this.byteLength = byteLength;
+    this.byteOffset = dvOffset;
+    this.offset = 0;
+    this.littleEndian = true;
+    this._data = new DataView(this.buffer, dvOffset, byteLength);
+    this._mark = 0;
+    this._marks = [];
+  }
+  /**
+   * Checks if the memory allocated to the buffer is sufficient to store more
+   * bytes after the offset.
+   * @param byteLength - The needed memory in bytes.
+   * @returns `true` if there is sufficient space and `false` otherwise.
+   */
+  available(byteLength = 1) {
+    return this.offset + byteLength <= this.length;
+  }
+  /**
+   * Check if little-endian mode is used for reading and writing multi-byte
+   * values.
+   * @returns `true` if little-endian mode is used, `false` otherwise.
+   */
+  isLittleEndian() {
+    return this.littleEndian;
+  }
+  /**
+   * Set little-endian mode for reading and writing multi-byte values.
+   * @returns This.
+   */
+  setLittleEndian() {
+    this.littleEndian = true;
+    return this;
+  }
+  /**
+   * Check if big-endian mode is used for reading and writing multi-byte values.
+   * @returns `true` if big-endian mode is used, `false` otherwise.
+   */
+  isBigEndian() {
+    return !this.littleEndian;
+  }
+  /**
+   * Switches to big-endian mode for reading and writing multi-byte values.
+   * @returns This.
+   */
+  setBigEndian() {
+    this.littleEndian = false;
+    return this;
+  }
+  /**
+   * Move the pointer n bytes forward.
+   * @param n - Number of bytes to skip.
+   * @returns This.
+   */
+  skip(n = 1) {
+    this.offset += n;
+    return this;
+  }
+  /**
+   * Move the pointer n bytes backward.
+   * @param n - Number of bytes to move back.
+   * @returns This.
+   */
+  back(n = 1) {
+    this.offset -= n;
+    return this;
+  }
+  /**
+   * Move the pointer to the given offset.
+   * @param offset - The offset to move to.
+   * @returns This.
+   */
+  seek(offset) {
+    this.offset = offset;
+    return this;
+  }
+  /**
+   * Store the current pointer offset.
+   * @see {@link IOBuffer#reset}
+   * @returns This.
+   */
+  mark() {
+    this._mark = this.offset;
+    return this;
+  }
+  /**
+   * Move the pointer back to the last pointer offset set by mark.
+   * @see {@link IOBuffer#mark}
+   * @returns This.
+   */
+  reset() {
+    this.offset = this._mark;
+    return this;
+  }
+  /**
+   * Push the current pointer offset to the mark stack.
+   * @see {@link IOBuffer#popMark}
+   * @returns This.
+   */
+  pushMark() {
+    this._marks.push(this.offset);
+    return this;
+  }
+  /**
+   * Pop the last pointer offset from the mark stack, and set the current
+   * pointer offset to the popped value.
+   * @see {@link IOBuffer#pushMark}
+   * @returns This.
+   */
+  popMark() {
+    const offset = this._marks.pop();
+    if (offset === void 0) {
+      throw new Error("Mark stack empty");
+    }
+    this.seek(offset);
+    return this;
+  }
+  /**
+   * Move the pointer offset back to 0.
+   * @returns This.
+   */
+  rewind() {
+    this.offset = 0;
+    return this;
+  }
+  /**
+   * Make sure the buffer has sufficient memory to write a given byteLength at
+   * the current pointer offset.
+   * If the buffer's memory is insufficient, this method will create a new
+   * buffer (a copy) with a length that is twice (byteLength + current offset).
+   * @param byteLength - The needed memory in bytes.
+   * @returns This.
+   */
+  ensureAvailable(byteLength = 1) {
+    if (!this.available(byteLength)) {
+      const lengthNeeded = this.offset + byteLength;
+      const newLength = lengthNeeded * 2;
+      const newArray = new Uint8Array(newLength);
+      newArray.set(new Uint8Array(this.buffer));
+      this.buffer = newArray.buffer;
+      this.length = newLength;
+      this.byteLength = newLength;
+      this._data = new DataView(this.buffer);
+    }
+    return this;
+  }
+  /**
+   * Read a byte and return false if the byte's value is 0, or true otherwise.
+   * Moves pointer forward by one byte.
+   * @returns The read boolean.
+   */
+  readBoolean() {
+    return this.readUint8() !== 0;
+  }
+  /**
+   * Read a signed 8-bit integer and move pointer forward by 1 byte.
+   * @returns The read byte.
+   */
+  readInt8() {
+    return this._data.getInt8(this.offset++);
+  }
+  /**
+   * Read an unsigned 8-bit integer and move pointer forward by 1 byte.
+   * @returns The read byte.
+   */
+  readUint8() {
+    return this._data.getUint8(this.offset++);
+  }
+  /**
+   * Alias for {@link IOBuffer#readUint8}.
+   * @returns The read byte.
+   */
+  readByte() {
+    return this.readUint8();
+  }
+  /**
+   * Read `n` bytes and move pointer forward by `n` bytes.
+   * @param n - Number of bytes to read.
+   * @returns The read bytes.
+   */
+  readBytes(n = 1) {
+    return this.readArray(n, "uint8");
+  }
+  /**
+   * Creates an array of corresponding to the type `type` and size `size`.
+   * For example, type `uint8` will create a `Uint8Array`.
+   * @param size - size of the resulting array
+   * @param type - number type of elements to read
+   * @returns The read array.
+   */
+  readArray(size, type) {
+    const bytes = typedArrays[type].BYTES_PER_ELEMENT * size;
+    const offset = this.byteOffset + this.offset;
+    const slice = this.buffer.slice(offset, offset + bytes);
+    if (this.littleEndian === hostBigEndian && type !== "uint8" && type !== "int8") {
+      const slice2 = new Uint8Array(this.buffer.slice(offset, offset + bytes));
+      slice2.reverse();
+      const returnArray2 = new typedArrays[type](slice2.buffer);
+      this.offset += bytes;
+      returnArray2.reverse();
+      return returnArray2;
+    }
+    const returnArray = new typedArrays[type](slice);
+    this.offset += bytes;
+    return returnArray;
+  }
+  /**
+   * Read a 16-bit signed integer and move pointer forward by 2 bytes.
+   * @returns The read value.
+   */
+  readInt16() {
+    const value = this._data.getInt16(this.offset, this.littleEndian);
+    this.offset += 2;
+    return value;
+  }
+  /**
+   * Read a 16-bit unsigned integer and move pointer forward by 2 bytes.
+   * @returns The read value.
+   */
+  readUint16() {
+    const value = this._data.getUint16(this.offset, this.littleEndian);
+    this.offset += 2;
+    return value;
+  }
+  /**
+   * Read a 32-bit signed integer and move pointer forward by 4 bytes.
+   * @returns The read value.
+   */
+  readInt32() {
+    const value = this._data.getInt32(this.offset, this.littleEndian);
+    this.offset += 4;
+    return value;
+  }
+  /**
+   * Read a 32-bit unsigned integer and move pointer forward by 4 bytes.
+   * @returns The read value.
+   */
+  readUint32() {
+    const value = this._data.getUint32(this.offset, this.littleEndian);
+    this.offset += 4;
+    return value;
+  }
+  /**
+   * Read a 32-bit floating number and move pointer forward by 4 bytes.
+   * @returns The read value.
+   */
+  readFloat32() {
+    const value = this._data.getFloat32(this.offset, this.littleEndian);
+    this.offset += 4;
+    return value;
+  }
+  /**
+   * Read a 64-bit floating number and move pointer forward by 8 bytes.
+   * @returns The read value.
+   */
+  readFloat64() {
+    const value = this._data.getFloat64(this.offset, this.littleEndian);
+    this.offset += 8;
+    return value;
+  }
+  /**
+   * Read a 64-bit signed integer number and move pointer forward by 8 bytes.
+   * @returns The read value.
+   */
+  readBigInt64() {
+    const value = this._data.getBigInt64(this.offset, this.littleEndian);
+    this.offset += 8;
+    return value;
+  }
+  /**
+   * Read a 64-bit unsigned integer number and move pointer forward by 8 bytes.
+   * @returns The read value.
+   */
+  readBigUint64() {
+    const value = this._data.getBigUint64(this.offset, this.littleEndian);
+    this.offset += 8;
+    return value;
+  }
+  /**
+   * Read a 1-byte ASCII character and move pointer forward by 1 byte.
+   * @returns The read character.
+   */
+  readChar() {
+    return String.fromCharCode(this.readInt8());
+  }
+  /**
+   * Read `n` 1-byte ASCII characters and move pointer forward by `n` bytes.
+   * @param n - Number of characters to read.
+   * @returns The read characters.
+   */
+  readChars(n = 1) {
+    let result = "";
+    for (let i2 = 0; i2 < n; i2++) {
+      result += this.readChar();
+    }
+    return result;
+  }
+  /**
+   * Read the next `n` bytes, return a UTF-8 decoded string and move pointer
+   * forward by `n` bytes.
+   * @param n - Number of bytes to read.
+   * @returns The decoded string.
+   */
+  readUtf8(n = 1) {
+    return decode(this.readBytes(n));
+  }
+  /**
+   * Read the next `n` bytes, return a string decoded with `encoding` and move pointer
+   * forward by `n` bytes.
+   * If no encoding is passed, the function is equivalent to @see {@link IOBuffer#readUtf8}
+   * @param n - Number of bytes to read.
+   * @param encoding - The encoding to use. Default is 'utf8'.
+   * @returns The decoded string.
+   */
+  decodeText(n = 1, encoding = "utf8") {
+    return decode(this.readBytes(n), encoding);
+  }
+  /**
+   * Write 0xff if the passed value is truthy, 0x00 otherwise and move pointer
+   * forward by 1 byte.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeBoolean(value) {
+    this.writeUint8(value ? 255 : 0);
+    return this;
+  }
+  /**
+   * Write `value` as an 8-bit signed integer and move pointer forward by 1 byte.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeInt8(value) {
+    this.ensureAvailable(1);
+    this._data.setInt8(this.offset++, value);
+    this._updateLastWrittenByte();
+    return this;
+  }
+  /**
+   * Write `value` as an 8-bit unsigned integer and move pointer forward by 1
+   * byte.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeUint8(value) {
+    this.ensureAvailable(1);
+    this._data.setUint8(this.offset++, value);
+    this._updateLastWrittenByte();
+    return this;
+  }
+  /**
+   * An alias for {@link IOBuffer#writeUint8}.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeByte(value) {
+    return this.writeUint8(value);
+  }
+  /**
+   * Write all elements of `bytes` as uint8 values and move pointer forward by
+   * `bytes.length` bytes.
+   * @param bytes - The array of bytes to write.
+   * @returns This.
+   */
+  writeBytes(bytes) {
+    this.ensureAvailable(bytes.length);
+    for (let i2 = 0; i2 < bytes.length; i2++) {
+      this._data.setUint8(this.offset++, bytes[i2]);
+    }
+    this._updateLastWrittenByte();
+    return this;
+  }
+  /**
+   * Write `value` as a 16-bit signed integer and move pointer forward by 2
+   * bytes.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeInt16(value) {
+    this.ensureAvailable(2);
+    this._data.setInt16(this.offset, value, this.littleEndian);
+    this.offset += 2;
+    this._updateLastWrittenByte();
+    return this;
+  }
+  /**
+   * Write `value` as a 16-bit unsigned integer and move pointer forward by 2
+   * bytes.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeUint16(value) {
+    this.ensureAvailable(2);
+    this._data.setUint16(this.offset, value, this.littleEndian);
+    this.offset += 2;
+    this._updateLastWrittenByte();
+    return this;
+  }
+  /**
+   * Write `value` as a 32-bit signed integer and move pointer forward by 4
+   * bytes.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeInt32(value) {
+    this.ensureAvailable(4);
+    this._data.setInt32(this.offset, value, this.littleEndian);
+    this.offset += 4;
+    this._updateLastWrittenByte();
+    return this;
+  }
+  /**
+   * Write `value` as a 32-bit unsigned integer and move pointer forward by 4
+   * bytes.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeUint32(value) {
+    this.ensureAvailable(4);
+    this._data.setUint32(this.offset, value, this.littleEndian);
+    this.offset += 4;
+    this._updateLastWrittenByte();
+    return this;
+  }
+  /**
+   * Write `value` as a 32-bit floating number and move pointer forward by 4
+   * bytes.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeFloat32(value) {
+    this.ensureAvailable(4);
+    this._data.setFloat32(this.offset, value, this.littleEndian);
+    this.offset += 4;
+    this._updateLastWrittenByte();
+    return this;
+  }
+  /**
+   * Write `value` as a 64-bit floating number and move pointer forward by 8
+   * bytes.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeFloat64(value) {
+    this.ensureAvailable(8);
+    this._data.setFloat64(this.offset, value, this.littleEndian);
+    this.offset += 8;
+    this._updateLastWrittenByte();
+    return this;
+  }
+  /**
+   * Write `value` as a 64-bit signed bigint and move pointer forward by 8
+   * bytes.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeBigInt64(value) {
+    this.ensureAvailable(8);
+    this._data.setBigInt64(this.offset, value, this.littleEndian);
+    this.offset += 8;
+    this._updateLastWrittenByte();
+    return this;
+  }
+  /**
+   * Write `value` as a 64-bit unsigned bigint and move pointer forward by 8
+   * bytes.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeBigUint64(value) {
+    this.ensureAvailable(8);
+    this._data.setBigUint64(this.offset, value, this.littleEndian);
+    this.offset += 8;
+    this._updateLastWrittenByte();
+    return this;
+  }
+  /**
+   * Write the charCode of `str`'s first character as an 8-bit unsigned integer
+   * and move pointer forward by 1 byte.
+   * @param str - The character to write.
+   * @returns This.
+   */
+  writeChar(str) {
+    return this.writeUint8(str.charCodeAt(0));
+  }
+  /**
+   * Write the charCodes of all `str`'s characters as 8-bit unsigned integers
+   * and move pointer forward by `str.length` bytes.
+   * @param str - The characters to write.
+   * @returns This.
+   */
+  writeChars(str) {
+    for (let i2 = 0; i2 < str.length; i2++) {
+      this.writeUint8(str.charCodeAt(i2));
+    }
+    return this;
+  }
+  /**
+   * UTF-8 encode and write `str` to the current pointer offset and move pointer
+   * forward according to the encoded length.
+   * @param str - The string to write.
+   * @returns This.
+   */
+  writeUtf8(str) {
+    return this.writeBytes(encode(str));
+  }
+  /**
+   * Export a Uint8Array view of the internal buffer.
+   * The view starts at the byte offset and its length
+   * is calculated to stop at the last written byte or the original length.
+   * @returns A new Uint8Array view.
+   */
+  toArray() {
+    return new Uint8Array(this.buffer, this.byteOffset, this.lastWrittenByte);
+  }
+  /**
+   *  Get the total number of bytes written so far, regardless of the current offset.
+   * @returns - Total number of bytes.
+   */
+  getWrittenByteLength() {
+    return this.lastWrittenByte - this.byteOffset;
+  }
+  /**
+   * Update the last written byte offset
+   * @private
+   */
+  _updateLastWrittenByte() {
+    if (this.offset > this.lastWrittenByte) {
+      this.lastWrittenByte = this.offset;
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/fast-png@8.0.0/node_modules/fast-png/lib/helpers/crc.js
+var crcTable = [];
+for (let n = 0; n < 256; n++) {
+  let c = n;
+  for (let k = 0; k < 8; k++) {
+    if (c & 1) {
+      c = 3988292384 ^ c >>> 1;
+    } else {
+      c = c >>> 1;
+    }
+  }
+  crcTable[n] = c;
+}
+var initialCrc = 4294967295;
+function updateCrc(currentCrc, data, length) {
+  let c = currentCrc;
+  for (let n = 0; n < length; n++) {
+    c = crcTable[(c ^ data[n]) & 255] ^ c >>> 8;
+  }
+  return c;
+}
+__name(updateCrc, "updateCrc");
+function crc(data, length) {
+  return (updateCrc(initialCrc, data, length) ^ initialCrc) >>> 0;
+}
+__name(crc, "crc");
+function checkCrc(buffer, crcLength, chunkName) {
+  const expectedCrc = buffer.readUint32();
+  const actualCrc = crc(new Uint8Array(buffer.buffer, buffer.byteOffset + buffer.offset - crcLength - 4, crcLength), crcLength);
+  if (actualCrc !== expectedCrc) {
+    throw new Error(`CRC mismatch for chunk ${chunkName}. Expected ${expectedCrc}, found ${actualCrc}`);
+  }
+}
+__name(checkCrc, "checkCrc");
+function writeCrc(buffer, length) {
+  buffer.writeUint32(crc(new Uint8Array(buffer.buffer, buffer.byteOffset + buffer.offset - length, length), length));
+}
+__name(writeCrc, "writeCrc");
+
+// ../../node_modules/.pnpm/fast-png@8.0.0/node_modules/fast-png/lib/helpers/unfilter.js
+function unfilterNone(currentLine, newLine, bytesPerLine) {
+  for (let i2 = 0; i2 < bytesPerLine; i2++) {
+    newLine[i2] = currentLine[i2];
+  }
+}
+__name(unfilterNone, "unfilterNone");
+function unfilterSub(currentLine, newLine, bytesPerLine, bytesPerPixel) {
+  let i2 = 0;
+  for (; i2 < bytesPerPixel; i2++) {
+    newLine[i2] = currentLine[i2];
+  }
+  for (; i2 < bytesPerLine; i2++) {
+    newLine[i2] = currentLine[i2] + newLine[i2 - bytesPerPixel] & 255;
+  }
+}
+__name(unfilterSub, "unfilterSub");
+function unfilterUp(currentLine, newLine, prevLine, bytesPerLine) {
+  let i2 = 0;
+  if (prevLine.length === 0) {
+    for (; i2 < bytesPerLine; i2++) {
+      newLine[i2] = currentLine[i2];
+    }
+  } else {
+    for (; i2 < bytesPerLine; i2++) {
+      newLine[i2] = currentLine[i2] + prevLine[i2] & 255;
+    }
+  }
+}
+__name(unfilterUp, "unfilterUp");
+function unfilterAverage(currentLine, newLine, prevLine, bytesPerLine, bytesPerPixel) {
+  let i2 = 0;
+  if (prevLine.length === 0) {
+    for (; i2 < bytesPerPixel; i2++) {
+      newLine[i2] = currentLine[i2];
+    }
+    for (; i2 < bytesPerLine; i2++) {
+      newLine[i2] = currentLine[i2] + (newLine[i2 - bytesPerPixel] >> 1) & 255;
+    }
+  } else {
+    for (; i2 < bytesPerPixel; i2++) {
+      newLine[i2] = currentLine[i2] + (prevLine[i2] >> 1) & 255;
+    }
+    for (; i2 < bytesPerLine; i2++) {
+      newLine[i2] = currentLine[i2] + (newLine[i2 - bytesPerPixel] + prevLine[i2] >> 1) & 255;
+    }
+  }
+}
+__name(unfilterAverage, "unfilterAverage");
+function unfilterPaeth(currentLine, newLine, prevLine, bytesPerLine, bytesPerPixel) {
+  let i2 = 0;
+  if (prevLine.length === 0) {
+    for (; i2 < bytesPerPixel; i2++) {
+      newLine[i2] = currentLine[i2];
+    }
+    for (; i2 < bytesPerLine; i2++) {
+      newLine[i2] = currentLine[i2] + newLine[i2 - bytesPerPixel] & 255;
+    }
+  } else {
+    for (; i2 < bytesPerPixel; i2++) {
+      newLine[i2] = currentLine[i2] + prevLine[i2] & 255;
+    }
+    for (; i2 < bytesPerLine; i2++) {
+      newLine[i2] = currentLine[i2] + paethPredictor(newLine[i2 - bytesPerPixel], prevLine[i2], prevLine[i2 - bytesPerPixel]) & 255;
+    }
+  }
+}
+__name(unfilterPaeth, "unfilterPaeth");
+function paethPredictor(a, b, c) {
+  const p = a + b - c;
+  const pa = Math.abs(p - a);
+  const pb = Math.abs(p - b);
+  const pc = Math.abs(p - c);
+  if (pa <= pb && pa <= pc)
+    return a;
+  else if (pb <= pc)
+    return b;
+  else
+    return c;
+}
+__name(paethPredictor, "paethPredictor");
+
+// ../../node_modules/.pnpm/fast-png@8.0.0/node_modules/fast-png/lib/helpers/apply_unfilter.js
+function applyUnfilter(filterType, currentLine, newLine, prevLine, passLineBytes, bytesPerPixel) {
+  switch (filterType) {
+    case 0:
+      unfilterNone(currentLine, newLine, passLineBytes);
+      break;
+    case 1:
+      unfilterSub(currentLine, newLine, passLineBytes, bytesPerPixel);
+      break;
+    case 2:
+      unfilterUp(currentLine, newLine, prevLine, passLineBytes);
+      break;
+    case 3:
+      unfilterAverage(currentLine, newLine, prevLine, passLineBytes, bytesPerPixel);
+      break;
+    case 4:
+      unfilterPaeth(currentLine, newLine, prevLine, passLineBytes, bytesPerPixel);
+      break;
+    default:
+      throw new Error(`Unsupported filter: ${filterType}`);
+  }
+}
+__name(applyUnfilter, "applyUnfilter");
+
+// ../../node_modules/.pnpm/fast-png@8.0.0/node_modules/fast-png/lib/helpers/decode_interlace_adam7.js
+var uint16 = new Uint16Array([255]);
+var uint8 = new Uint8Array(uint16.buffer);
+var osIsLittleEndian = uint8[0] === 255;
+function decodeInterlaceAdam7(params) {
+  const { data, width, height, channels, depth } = params;
+  const passes = [
+    { x: 0, y: 0, xStep: 8, yStep: 8 },
+    // Pass 1
+    { x: 4, y: 0, xStep: 8, yStep: 8 },
+    // Pass 2
+    { x: 0, y: 4, xStep: 4, yStep: 8 },
+    // Pass 3
+    { x: 2, y: 0, xStep: 4, yStep: 4 },
+    // Pass 4
+    { x: 0, y: 2, xStep: 2, yStep: 4 },
+    // Pass 5
+    { x: 1, y: 0, xStep: 2, yStep: 2 },
+    // Pass 6
+    { x: 0, y: 1, xStep: 1, yStep: 2 }
+    // Pass 7
+  ];
+  const bytesPerPixel = Math.ceil(depth / 8) * channels;
+  const resultData = new Uint8Array(height * width * bytesPerPixel);
+  let offset = 0;
+  for (let passIndex = 0; passIndex < 7; passIndex++) {
+    const pass = passes[passIndex];
+    const passWidth = Math.ceil((width - pass.x) / pass.xStep);
+    const passHeight = Math.ceil((height - pass.y) / pass.yStep);
+    if (passWidth <= 0 || passHeight <= 0)
+      continue;
+    const passLineBytes = passWidth * bytesPerPixel;
+    const prevLine = new Uint8Array(passLineBytes);
+    for (let y = 0; y < passHeight; y++) {
+      const filterType = data[offset++];
+      const currentLine = data.subarray(offset, offset + passLineBytes);
+      offset += passLineBytes;
+      const newLine = new Uint8Array(passLineBytes);
+      applyUnfilter(filterType, currentLine, newLine, prevLine, passLineBytes, bytesPerPixel);
+      prevLine.set(newLine);
+      for (let x2 = 0; x2 < passWidth; x2++) {
+        const outputX = pass.x + x2 * pass.xStep;
+        const outputY = pass.y + y * pass.yStep;
+        if (outputX >= width || outputY >= height)
+          continue;
+        for (let i2 = 0; i2 < bytesPerPixel; i2++) {
+          resultData[(outputY * width + outputX) * bytesPerPixel + i2] = newLine[x2 * bytesPerPixel + i2];
+        }
+      }
+    }
+  }
+  if (depth === 16) {
+    const uint16Data = new Uint16Array(resultData.buffer);
+    if (osIsLittleEndian) {
+      for (let k = 0; k < uint16Data.length; k++) {
+        uint16Data[k] = swap16(uint16Data[k]);
+      }
+    }
+    return uint16Data;
+  } else {
+    return resultData;
+  }
+}
+__name(decodeInterlaceAdam7, "decodeInterlaceAdam7");
+function swap16(val) {
+  return (val & 255) << 8 | val >> 8 & 255;
+}
+__name(swap16, "swap16");
+
+// ../../node_modules/.pnpm/fast-png@8.0.0/node_modules/fast-png/lib/helpers/decode_interlace_null.js
+var uint162 = new Uint16Array([255]);
+var uint82 = new Uint8Array(uint162.buffer);
+var osIsLittleEndian2 = uint82[0] === 255;
+var empty = new Uint8Array(0);
+function decodeInterlaceNull(params) {
+  const { data, width, height, channels, depth } = params;
+  const bytesPerPixel = Math.ceil(depth / 8) * channels;
+  const bytesPerLine = Math.ceil(depth / 8 * channels * width);
+  const newData = new Uint8Array(height * bytesPerLine);
+  let prevLine = empty;
+  let offset = 0;
+  let currentLine;
+  let newLine;
+  for (let i2 = 0; i2 < height; i2++) {
+    currentLine = data.subarray(offset + 1, offset + 1 + bytesPerLine);
+    newLine = newData.subarray(i2 * bytesPerLine, (i2 + 1) * bytesPerLine);
+    switch (data[offset]) {
+      case 0:
+        unfilterNone(currentLine, newLine, bytesPerLine);
+        break;
+      case 1:
+        unfilterSub(currentLine, newLine, bytesPerLine, bytesPerPixel);
+        break;
+      case 2:
+        unfilterUp(currentLine, newLine, prevLine, bytesPerLine);
+        break;
+      case 3:
+        unfilterAverage(currentLine, newLine, prevLine, bytesPerLine, bytesPerPixel);
+        break;
+      case 4:
+        unfilterPaeth(currentLine, newLine, prevLine, bytesPerLine, bytesPerPixel);
+        break;
+      default:
+        throw new Error(`Unsupported filter: ${data[offset]}`);
+    }
+    prevLine = newLine;
+    offset += bytesPerLine + 1;
+  }
+  if (depth === 16) {
+    const uint16Data = new Uint16Array(newData.buffer);
+    if (osIsLittleEndian2) {
+      for (let k = 0; k < uint16Data.length; k++) {
+        uint16Data[k] = swap162(uint16Data[k]);
+      }
+    }
+    return uint16Data;
+  } else {
+    return newData;
+  }
+}
+__name(decodeInterlaceNull, "decodeInterlaceNull");
+function swap162(val) {
+  return (val & 255) << 8 | val >> 8 & 255;
+}
+__name(swap162, "swap16");
+
+// ../../node_modules/.pnpm/fast-png@8.0.0/node_modules/fast-png/lib/helpers/signature.js
+var pngSignature = Uint8Array.of(137, 80, 78, 71, 13, 10, 26, 10);
+function writeSignature(buffer) {
+  buffer.writeBytes(pngSignature);
+}
+__name(writeSignature, "writeSignature");
+function checkSignature(buffer) {
+  if (!hasPngSignature(buffer.readBytes(pngSignature.length))) {
+    throw new Error("wrong PNG signature");
+  }
+}
+__name(checkSignature, "checkSignature");
+function hasPngSignature(array) {
+  if (array.length < pngSignature.length) {
+    return false;
+  }
+  for (let i2 = 0; i2 < pngSignature.length; i2++) {
+    if (array[i2] !== pngSignature[i2]) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(hasPngSignature, "hasPngSignature");
+
+// ../../node_modules/.pnpm/fast-png@8.0.0/node_modules/fast-png/lib/helpers/text.js
+var textChunkName = "tEXt";
+var NULL = 0;
+var latin1Decoder = new TextDecoder("latin1");
+function validateKeyword(keyword) {
+  validateLatin1(keyword);
+  if (keyword.length === 0 || keyword.length > 79) {
+    throw new Error("keyword length must be between 1 and 79");
+  }
+}
+__name(validateKeyword, "validateKeyword");
+var latin1Regex = /^[\u0000-\u00FF]*$/;
+function validateLatin1(text) {
+  if (!latin1Regex.test(text)) {
+    throw new Error("invalid latin1 text");
+  }
+}
+__name(validateLatin1, "validateLatin1");
+function decodetEXt(text, buffer, length) {
+  const keyword = readKeyword(buffer);
+  text[keyword] = readLatin1(buffer, length - keyword.length - 1);
+}
+__name(decodetEXt, "decodetEXt");
+function encodetEXt(buffer, keyword, text) {
+  validateKeyword(keyword);
+  validateLatin1(text);
+  const length = keyword.length + 1 + text.length;
+  buffer.writeUint32(length);
+  buffer.writeChars(textChunkName);
+  buffer.writeChars(keyword);
+  buffer.writeByte(NULL);
+  buffer.writeChars(text);
+  writeCrc(buffer, length + 4);
+}
+__name(encodetEXt, "encodetEXt");
+function readKeyword(buffer) {
+  buffer.mark();
+  while (buffer.readByte() !== NULL) {
+  }
+  const end = buffer.offset;
+  buffer.reset();
+  const keyword = latin1Decoder.decode(buffer.readBytes(end - buffer.offset - 1));
+  buffer.skip(1);
+  validateKeyword(keyword);
+  return keyword;
+}
+__name(readKeyword, "readKeyword");
+function readLatin1(buffer, length) {
+  return latin1Decoder.decode(buffer.readBytes(length));
+}
+__name(readLatin1, "readLatin1");
+
+// ../../node_modules/.pnpm/fast-png@8.0.0/node_modules/fast-png/lib/internal_types.js
+var ColorType = {
+  UNKNOWN: -1,
+  GREYSCALE: 0,
+  TRUECOLOUR: 2,
+  INDEXED_COLOUR: 3,
+  GREYSCALE_ALPHA: 4,
+  TRUECOLOUR_ALPHA: 6
+};
+var CompressionMethod = {
+  UNKNOWN: -1,
+  DEFLATE: 0
+};
+var FilterMethod = {
+  UNKNOWN: -1,
+  ADAPTIVE: 0
+};
+var InterlaceMethod = {
+  UNKNOWN: -1,
+  NO_INTERLACE: 0,
+  ADAM7: 1
+};
+var DisposeOpType = {
+  NONE: 0,
+  BACKGROUND: 1,
+  PREVIOUS: 2
+};
+var BlendOpType = {
+  SOURCE: 0,
+  OVER: 1
+};
+
+// ../../node_modules/.pnpm/fast-png@8.0.0/node_modules/fast-png/lib/png_decoder.js
+var PngDecoder = class extends IOBuffer {
+  static {
+    __name(this, "PngDecoder");
+  }
+  _checkCrc;
+  _inflator;
+  _png;
+  _apng;
+  _end;
+  _hasPalette;
+  _palette;
+  _hasTransparency;
+  _transparency;
+  _compressionMethod;
+  _filterMethod;
+  _interlaceMethod;
+  _colorType;
+  _isAnimated;
+  _numberOfFrames;
+  _numberOfPlays;
+  _frames;
+  _writingDataChunks;
+  _chunks;
+  _inflatorResult;
+  constructor(data, options = {}) {
+    super(data);
+    const { checkCrc: checkCrc2 = false } = options;
+    this._checkCrc = checkCrc2;
+    this._inflator = new Unzlib((chunk, final) => {
+      this._chunks.push(chunk);
+      if (final) {
+        const totalLength = this._chunks.reduce((sum, c) => sum + c.length, 0);
+        this._inflatorResult = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk2 of this._chunks) {
+          this._inflatorResult.set(chunk2, offset);
+          offset += chunk2.length;
+        }
+        this._chunks = [];
+      }
+    });
+    this._chunks = [];
+    this._png = {
+      width: -1,
+      height: -1,
+      channels: -1,
+      data: new Uint8Array(0),
+      depth: 1,
+      text: {}
+    };
+    this._apng = {
+      width: -1,
+      height: -1,
+      channels: -1,
+      depth: 1,
+      numberOfFrames: 1,
+      numberOfPlays: 0,
+      text: {},
+      frames: []
+    };
+    this._end = false;
+    this._hasPalette = false;
+    this._palette = [];
+    this._hasTransparency = false;
+    this._transparency = new Uint16Array(0);
+    this._compressionMethod = CompressionMethod.UNKNOWN;
+    this._filterMethod = FilterMethod.UNKNOWN;
+    this._interlaceMethod = InterlaceMethod.UNKNOWN;
+    this._colorType = ColorType.UNKNOWN;
+    this._isAnimated = false;
+    this._numberOfFrames = 1;
+    this._numberOfPlays = 0;
+    this._frames = [];
+    this._writingDataChunks = false;
+    this._inflatorResult = new Uint8Array(0);
+    this.setBigEndian();
+  }
+  decode() {
+    checkSignature(this);
+    while (!this._end) {
+      const length = this.readUint32();
+      const type = this.readChars(4);
+      this.decodeChunk(length, type);
+    }
+    this._inflator.push(new Uint8Array(0), true);
+    this.decodeImage();
+    return this._png;
+  }
+  decodeApng() {
+    checkSignature(this);
+    while (!this._end) {
+      const length = this.readUint32();
+      const type = this.readChars(4);
+      this.decodeApngChunk(length, type);
+    }
+    this.decodeApngImage();
+    return this._apng;
+  }
+  // https://www.w3.org/TR/PNG/#5Chunk-layout
+  decodeChunk(length, type) {
+    const offset = this.offset;
+    switch (type) {
+      // 11.2 Critical chunks
+      case "IHDR":
+        this.decodeIHDR();
+        break;
+      case "PLTE":
+        this.decodePLTE(length);
+        break;
+      case "IDAT":
+        this.decodeIDAT(length);
+        break;
+      case "IEND":
+        this._end = true;
+        break;
+      // 11.3 Ancillary chunks
+      case "tRNS":
+        this.decodetRNS(length);
+        break;
+      case "iCCP":
+        this.decodeiCCP(length);
+        break;
+      case textChunkName:
+        decodetEXt(this._png.text, this, length);
+        break;
+      case "pHYs":
+        this.decodepHYs();
+        break;
+      default:
+        this.skip(length);
+        break;
+    }
+    if (this.offset - offset !== length) {
+      throw new Error(`Length mismatch while decoding chunk ${type}`);
+    }
+    if (this._checkCrc) {
+      checkCrc(this, length + 4, type);
+    } else {
+      this.skip(4);
+    }
+  }
+  decodeApngChunk(length, type) {
+    const offset = this.offset;
+    if (type !== "fdAT" && type !== "IDAT" && this._writingDataChunks) {
+      this.pushDataToFrame();
+    }
+    switch (type) {
+      case "acTL":
+        this.decodeACTL();
+        break;
+      case "fcTL":
+        this.decodeFCTL();
+        break;
+      case "fdAT":
+        this.decodeFDAT(length);
+        break;
+      default:
+        this.decodeChunk(length, type);
+        this.offset = offset + length;
+        break;
+    }
+    if (this.offset - offset !== length) {
+      throw new Error(`Length mismatch while decoding chunk ${type}`);
+    }
+    if (this._checkCrc) {
+      checkCrc(this, length + 4, type);
+    } else {
+      this.skip(4);
+    }
+  }
+  // https://www.w3.org/TR/PNG/#11IHDR
+  decodeIHDR() {
+    const image = this._png;
+    image.width = this.readUint32();
+    image.height = this.readUint32();
+    image.depth = checkBitDepth(this.readUint8());
+    const colorType = this.readUint8();
+    this._colorType = colorType;
+    let channels;
+    switch (colorType) {
+      case ColorType.GREYSCALE:
+        channels = 1;
+        break;
+      case ColorType.TRUECOLOUR:
+        channels = 3;
+        break;
+      case ColorType.INDEXED_COLOUR:
+        channels = 1;
+        break;
+      case ColorType.GREYSCALE_ALPHA:
+        channels = 2;
+        break;
+      case ColorType.TRUECOLOUR_ALPHA:
+        channels = 4;
+        break;
+      // Kept for exhaustiveness.
+      // eslint-disable-next-line unicorn/no-useless-switch-case
+      case ColorType.UNKNOWN:
+      default:
+        throw new Error(`Unknown color type: ${colorType}`);
+    }
+    this._png.channels = channels;
+    this._compressionMethod = this.readUint8();
+    if (this._compressionMethod !== CompressionMethod.DEFLATE) {
+      throw new Error(`Unsupported compression method: ${this._compressionMethod}`);
+    }
+    this._filterMethod = this.readUint8();
+    this._interlaceMethod = this.readUint8();
+  }
+  decodeACTL() {
+    this._numberOfFrames = this.readUint32();
+    this._numberOfPlays = this.readUint32();
+    this._isAnimated = true;
+  }
+  decodeFCTL() {
+    const image = {
+      sequenceNumber: this.readUint32(),
+      width: this.readUint32(),
+      height: this.readUint32(),
+      xOffset: this.readUint32(),
+      yOffset: this.readUint32(),
+      delayNumber: this.readUint16(),
+      delayDenominator: this.readUint16(),
+      disposeOp: this.readUint8(),
+      blendOp: this.readUint8(),
+      data: new Uint8Array(0)
+    };
+    this._frames.push(image);
+  }
+  // https://www.w3.org/TR/PNG/#11PLTE
+  decodePLTE(length) {
+    if (length % 3 !== 0) {
+      throw new RangeError(`PLTE field length must be a multiple of 3. Got ${length}`);
+    }
+    const l = length / 3;
+    this._hasPalette = true;
+    const palette = [];
+    this._palette = palette;
+    for (let i2 = 0; i2 < l; i2++) {
+      palette.push([this.readUint8(), this.readUint8(), this.readUint8()]);
+    }
+  }
+  // https://www.w3.org/TR/PNG/#11IDAT
+  decodeIDAT(length) {
+    this._writingDataChunks = true;
+    const dataLength = length;
+    const dataOffset = this.offset + this.byteOffset;
+    try {
+      this._inflator.push(new Uint8Array(this.buffer, dataOffset, dataLength), false);
+    } catch (error) {
+      throw new Error("Error while decompressing the data:", { cause: error });
+    }
+    this.skip(length);
+  }
+  decodeFDAT(length) {
+    this._writingDataChunks = true;
+    let dataLength = length;
+    let dataOffset = this.offset + this.byteOffset;
+    dataOffset += 4;
+    dataLength -= 4;
+    try {
+      this._inflator.push(new Uint8Array(this.buffer, dataOffset, dataLength), false);
+    } catch (error) {
+      throw new Error("Error while decompressing the data:", { cause: error });
+    }
+    this.skip(length);
+  }
+  // https://www.w3.org/TR/PNG/#11tRNS
+  decodetRNS(length) {
+    switch (this._colorType) {
+      case ColorType.GREYSCALE:
+      case ColorType.TRUECOLOUR: {
+        if (length % 2 !== 0) {
+          throw new RangeError(`tRNS chunk length must be a multiple of 2. Got ${length}`);
+        }
+        if (length / 2 > this._png.width * this._png.height) {
+          throw new Error(`tRNS chunk contains more alpha values than there are pixels (${length / 2} vs ${this._png.width * this._png.height})`);
+        }
+        this._hasTransparency = true;
+        this._transparency = new Uint16Array(length / 2);
+        for (let i2 = 0; i2 < length / 2; i2++) {
+          this._transparency[i2] = this.readUint16();
+        }
+        break;
+      }
+      case ColorType.INDEXED_COLOUR: {
+        if (length > this._palette.length) {
+          throw new Error(`tRNS chunk contains more alpha values than there are palette colors (${length} vs ${this._palette.length})`);
+        }
+        let i2 = 0;
+        for (; i2 < length; i2++) {
+          const alpha = this.readByte();
+          this._palette[i2].push(alpha);
+        }
+        for (; i2 < this._palette.length; i2++) {
+          this._palette[i2].push(255);
+        }
+        break;
+      }
+      // Kept for exhaustiveness.
+      /* eslint-disable unicorn/no-useless-switch-case */
+      case ColorType.UNKNOWN:
+      case ColorType.GREYSCALE_ALPHA:
+      case ColorType.TRUECOLOUR_ALPHA:
+      default: {
+        throw new Error(`tRNS chunk is not supported for color type ${this._colorType}`);
+      }
+    }
+  }
+  // https://www.w3.org/TR/PNG/#11iCCP
+  decodeiCCP(length) {
+    const name = readKeyword(this);
+    const compressionMethod = this.readUint8();
+    if (compressionMethod !== CompressionMethod.DEFLATE) {
+      throw new Error(`Unsupported iCCP compression method: ${compressionMethod}`);
+    }
+    const compressedProfile = this.readBytes(length - name.length - 2);
+    this._png.iccEmbeddedProfile = {
+      name,
+      profile: unzlibSync(compressedProfile)
+    };
+  }
+  // https://www.w3.org/TR/PNG/#11pHYs
+  decodepHYs() {
+    const ppuX = this.readUint32();
+    const ppuY = this.readUint32();
+    const unitSpecifier = this.readByte();
+    this._png.resolution = {
+      x: ppuX,
+      y: ppuY,
+      unit: unitSpecifier
+    };
+  }
+  decodeApngImage() {
+    this._apng.width = this._png.width;
+    this._apng.height = this._png.height;
+    this._apng.channels = this._png.channels;
+    this._apng.depth = this._png.depth;
+    this._apng.numberOfFrames = this._numberOfFrames;
+    this._apng.numberOfPlays = this._numberOfPlays;
+    this._apng.text = this._png.text;
+    this._apng.resolution = this._png.resolution;
+    for (let i2 = 0; i2 < this._numberOfFrames; i2++) {
+      const newFrame = {
+        sequenceNumber: this._frames[i2].sequenceNumber,
+        delayNumber: this._frames[i2].delayNumber,
+        delayDenominator: this._frames[i2].delayDenominator,
+        data: this._apng.depth === 8 ? new Uint8Array(this._apng.width * this._apng.height * this._apng.channels) : new Uint16Array(this._apng.width * this._apng.height * this._apng.channels)
+      };
+      const frame = this._frames.at(i2);
+      if (frame) {
+        frame.data = decodeInterlaceNull({
+          data: frame.data,
+          width: frame.width,
+          height: frame.height,
+          channels: this._apng.channels,
+          depth: this._apng.depth
+        });
+        if (this._hasPalette) {
+          this._apng.palette = this._palette;
+        }
+        if (this._hasTransparency) {
+          this._apng.transparency = this._transparency;
+        }
+        if (i2 === 0 || frame.xOffset === 0 && frame.yOffset === 0 && frame.width === this._png.width && frame.height === this._png.height) {
+          newFrame.data = frame.data;
+        } else {
+          const prevFrame = this._apng.frames.at(i2 - 1);
+          this.disposeFrame(frame, prevFrame, newFrame);
+          this.addFrameDataToCanvas(newFrame, frame);
+        }
+        this._apng.frames.push(newFrame);
+      }
+    }
+    return this._apng;
+  }
+  disposeFrame(frame, prevFrame, imageFrame) {
+    switch (frame.disposeOp) {
+      case DisposeOpType.NONE:
+        break;
+      case DisposeOpType.BACKGROUND:
+        for (let row = 0; row < this._png.height; row++) {
+          for (let col = 0; col < this._png.width; col++) {
+            const index = (row * frame.width + col) * this._png.channels;
+            for (let channel = 0; channel < this._png.channels; channel++) {
+              imageFrame.data[index + channel] = 0;
+            }
+          }
+        }
+        break;
+      case DisposeOpType.PREVIOUS:
+        imageFrame.data.set(prevFrame.data);
+        break;
+      default:
+        throw new Error("Unknown disposeOp");
+    }
+  }
+  addFrameDataToCanvas(imageFrame, frame) {
+    const maxValue = 1 << this._png.depth;
+    const calculatePixelIndices = /* @__PURE__ */ __name((row, col) => {
+      const index = ((row + frame.yOffset) * this._png.width + frame.xOffset + col) * this._png.channels;
+      const frameIndex = (row * frame.width + col) * this._png.channels;
+      return { index, frameIndex };
+    }, "calculatePixelIndices");
+    switch (frame.blendOp) {
+      case BlendOpType.SOURCE:
+        for (let row = 0; row < frame.height; row++) {
+          for (let col = 0; col < frame.width; col++) {
+            const { index, frameIndex } = calculatePixelIndices(row, col);
+            for (let channel = 0; channel < this._png.channels; channel++) {
+              imageFrame.data[index + channel] = frame.data[frameIndex + channel];
+            }
+          }
+        }
+        break;
+      // https://www.w3.org/TR/png-3/#13Alpha-channel-processing
+      case BlendOpType.OVER:
+        for (let row = 0; row < frame.height; row++) {
+          for (let col = 0; col < frame.width; col++) {
+            const { index, frameIndex } = calculatePixelIndices(row, col);
+            for (let channel = 0; channel < this._png.channels; channel++) {
+              const sourceAlpha = frame.data[frameIndex + this._png.channels - 1] / maxValue;
+              const foregroundValue = channel % (this._png.channels - 1) === 0 ? 1 : frame.data[frameIndex + channel];
+              const value = Math.floor(sourceAlpha * foregroundValue + (1 - sourceAlpha) * imageFrame.data[index + channel]);
+              imageFrame.data[index + channel] += value;
+            }
+          }
+        }
+        break;
+      default:
+        throw new Error("Unknown blendOp");
+    }
+  }
+  decodeImage() {
+    const data = this._inflatorResult;
+    if (this._filterMethod !== FilterMethod.ADAPTIVE) {
+      throw new Error(`Filter method ${this._filterMethod} not supported`);
+    }
+    if (this._interlaceMethod === InterlaceMethod.NO_INTERLACE) {
+      this._png.data = decodeInterlaceNull({
+        data,
+        width: this._png.width,
+        height: this._png.height,
+        channels: this._png.channels,
+        depth: this._png.depth
+      });
+    } else if (this._interlaceMethod === InterlaceMethod.ADAM7) {
+      this._png.data = decodeInterlaceAdam7({
+        data,
+        width: this._png.width,
+        height: this._png.height,
+        channels: this._png.channels,
+        depth: this._png.depth
+      });
+    } else {
+      throw new Error(`Interlace method ${this._interlaceMethod} not supported`);
+    }
+    if (this._hasPalette) {
+      this._png.palette = this._palette;
+    }
+    if (this._hasTransparency) {
+      this._png.transparency = this._transparency;
+    }
+  }
+  pushDataToFrame() {
+    this._inflator.push(new Uint8Array(0), true);
+    const result = this._inflatorResult;
+    const lastFrame = this._frames.at(-1);
+    if (lastFrame) {
+      lastFrame.data = result;
+    } else {
+      this._frames.push({
+        sequenceNumber: 0,
+        width: this._png.width,
+        height: this._png.height,
+        xOffset: 0,
+        yOffset: 0,
+        delayNumber: 0,
+        delayDenominator: 0,
+        disposeOp: DisposeOpType.NONE,
+        blendOp: BlendOpType.SOURCE,
+        data: result
+      });
+    }
+    this._inflator = new Unzlib((chunk, final) => {
+      this._chunks.push(chunk);
+      if (final) {
+        const totalLength = this._chunks.reduce((sum, c) => sum + c.length, 0);
+        this._inflatorResult = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk2 of this._chunks) {
+          this._inflatorResult.set(chunk2, offset);
+          offset += chunk2.length;
+        }
+        this._chunks = [];
+      }
+    });
+    this._chunks = [];
+    this._writingDataChunks = false;
+  }
+};
+function checkBitDepth(value) {
+  if (value !== 1 && value !== 2 && value !== 4 && value !== 8 && value !== 16) {
+    throw new Error(`invalid bit depth: ${value}`);
+  }
+  return value;
+}
+__name(checkBitDepth, "checkBitDepth");
+
+// ../../node_modules/.pnpm/fast-png@8.0.0/node_modules/fast-png/lib/png_encoder.js
+var defaultZlibOptions = {
+  level: 3
+};
+var PngEncoder = class extends IOBuffer {
+  static {
+    __name(this, "PngEncoder");
+  }
+  _png;
+  _zlibOptions;
+  _colorType;
+  _interlaceMethod;
+  constructor(data, options = {}) {
+    super();
+    this._colorType = ColorType.UNKNOWN;
+    this._zlibOptions = { ...defaultZlibOptions, ...options.zlib };
+    this._png = this._checkData(data);
+    this._interlaceMethod = (options.interlace === "Adam7" ? InterlaceMethod.ADAM7 : InterlaceMethod.NO_INTERLACE) ?? InterlaceMethod.NO_INTERLACE;
+    this.setBigEndian();
+  }
+  encode() {
+    writeSignature(this);
+    this.encodeIHDR();
+    if (this._png.palette) {
+      this.encodePLTE();
+      if (this._png.palette[0].length === 4) {
+        this.encodeTRNS();
+      }
+    }
+    this.encodeData();
+    if (this._png.text) {
+      for (const [keyword, text] of Object.entries(this._png.text)) {
+        encodetEXt(this, keyword, text);
+      }
+    }
+    this.encodeIEND();
+    return this.toArray();
+  }
+  // https://www.w3.org/TR/PNG/#11IHDR
+  encodeIHDR() {
+    this.writeUint32(13);
+    this.writeChars("IHDR");
+    this.writeUint32(this._png.width);
+    this.writeUint32(this._png.height);
+    this.writeByte(this._png.depth);
+    this.writeByte(this._colorType);
+    this.writeByte(CompressionMethod.DEFLATE);
+    this.writeByte(FilterMethod.ADAPTIVE);
+    this.writeByte(this._interlaceMethod);
+    writeCrc(this, 17);
+  }
+  // https://www.w3.org/TR/PNG/#11IEND
+  encodeIEND() {
+    this.writeUint32(0);
+    this.writeChars("IEND");
+    writeCrc(this, 4);
+  }
+  encodePLTE() {
+    const paletteLength = this._png.palette?.length * 3;
+    this.writeUint32(paletteLength);
+    this.writeChars("PLTE");
+    for (const color of this._png.palette) {
+      this.writeByte(color[0]);
+      this.writeByte(color[1]);
+      this.writeByte(color[2]);
+    }
+    writeCrc(this, 4 + paletteLength);
+  }
+  encodeTRNS() {
+    const alpha = this._png.palette.filter((color) => {
+      return color.at(-1) !== 255;
+    });
+    this.writeUint32(alpha.length);
+    this.writeChars("tRNS");
+    for (const el of alpha) {
+      this.writeByte(el.at(-1));
+    }
+    writeCrc(this, 4 + alpha.length);
+  }
+  // https://www.w3.org/TR/PNG/#11IDAT
+  encodeIDAT(data) {
+    this.writeUint32(data.length);
+    this.writeChars("IDAT");
+    this.writeBytes(data);
+    writeCrc(this, data.length + 4);
+  }
+  encodeData() {
+    const { width, height, channels, depth, data } = this._png;
+    const slotsPerLine = depth <= 8 ? Math.ceil(width * depth / 8) * channels : Math.ceil(width * depth / 8 * channels / 2);
+    const newData = new IOBuffer().setBigEndian();
+    let offset = 0;
+    if (this._interlaceMethod === InterlaceMethod.NO_INTERLACE) {
+      for (let i2 = 0; i2 < height; i2++) {
+        newData.writeByte(0);
+        if (depth === 16) {
+          offset = writeDataUint16(data, newData, slotsPerLine, offset);
+        } else {
+          offset = writeDataBytes(data, newData, slotsPerLine, offset);
+        }
+      }
+    } else if (this._interlaceMethod === InterlaceMethod.ADAM7) {
+      offset = writeDataInterlaced(this._png, data, newData, offset);
+    }
+    const buffer = newData.toArray();
+    const compressed = zlibSync(buffer, this._zlibOptions);
+    this.encodeIDAT(compressed);
+  }
+  _checkData(data) {
+    const { colorType, channels, depth } = getColorType(data, data.palette);
+    const png = {
+      width: checkInteger(data.width, "width"),
+      height: checkInteger(data.height, "height"),
+      channels,
+      data: data.data,
+      depth,
+      text: data.text,
+      palette: data.palette
+    };
+    this._colorType = colorType;
+    const expectedSize = depth < 8 ? Math.ceil(png.width * depth / 8) * png.height * channels : png.width * png.height * channels;
+    if (png.data.length !== expectedSize) {
+      throw new RangeError(`wrong data size. Found ${png.data.length}, expected ${expectedSize}`);
+    }
+    return png;
+  }
+};
+function checkInteger(value, name) {
+  if (Number.isInteger(value) && value > 0) {
+    return value;
+  }
+  throw new TypeError(`${name} must be a positive integer`);
+}
+__name(checkInteger, "checkInteger");
+function getColorType(data, palette) {
+  const { channels = 4, depth = 8 } = data;
+  if (channels !== 4 && channels !== 3 && channels !== 2 && channels !== 1) {
+    throw new RangeError(`unsupported number of channels: ${channels}`);
+  }
+  const returnValue = {
+    channels,
+    depth,
+    colorType: ColorType.UNKNOWN
+  };
+  switch (channels) {
+    case 4:
+      returnValue.colorType = ColorType.TRUECOLOUR_ALPHA;
+      break;
+    case 3:
+      returnValue.colorType = ColorType.TRUECOLOUR;
+      break;
+    case 1:
+      if (palette) {
+        returnValue.colorType = ColorType.INDEXED_COLOUR;
+      } else {
+        returnValue.colorType = ColorType.GREYSCALE;
+      }
+      break;
+    case 2:
+      returnValue.colorType = ColorType.GREYSCALE_ALPHA;
+      break;
+    default:
+      throw new Error("unsupported number of channels");
+  }
+  return returnValue;
+}
+__name(getColorType, "getColorType");
+function writeDataBytes(data, newData, slotsPerLine, offset) {
+  for (let j = 0; j < slotsPerLine; j++) {
+    newData.writeByte(data[offset++]);
+  }
+  return offset;
+}
+__name(writeDataBytes, "writeDataBytes");
+function writeDataInterlaced(imageData, data, newData, offset) {
+  const passes = [
+    { x: 0, y: 0, xStep: 8, yStep: 8 },
+    { x: 4, y: 0, xStep: 8, yStep: 8 },
+    { x: 0, y: 4, xStep: 4, yStep: 8 },
+    { x: 2, y: 0, xStep: 4, yStep: 4 },
+    { x: 0, y: 2, xStep: 2, yStep: 4 },
+    { x: 1, y: 0, xStep: 2, yStep: 2 },
+    { x: 0, y: 1, xStep: 1, yStep: 2 }
+  ];
+  const { width, height, channels, depth } = imageData;
+  let pixelSize;
+  if (depth === 16) {
+    pixelSize = channels * depth / 8 / 2;
+  } else {
+    pixelSize = channels * depth / 8;
+  }
+  for (let passIndex = 0; passIndex < 7; passIndex++) {
+    const pass = passes[passIndex];
+    const passWidth = Math.floor((width - pass.x + pass.xStep - 1) / pass.xStep);
+    const passHeight = Math.floor((height - pass.y + pass.yStep - 1) / pass.yStep);
+    if (passWidth <= 0 || passHeight <= 0)
+      continue;
+    const passLineBytes = passWidth * pixelSize;
+    for (let y = 0; y < passHeight; y++) {
+      const imageY = pass.y + y * pass.yStep;
+      const rawScanline = depth <= 8 ? new Uint8Array(passLineBytes) : new Uint16Array(passLineBytes);
+      let rawOffset = 0;
+      for (let x2 = 0; x2 < passWidth; x2++) {
+        const imageX = pass.x + x2 * pass.xStep;
+        if (imageX < width && imageY < height) {
+          const srcPos = (imageY * width + imageX) * pixelSize;
+          for (let i2 = 0; i2 < pixelSize; i2++) {
+            rawScanline[rawOffset++] = data[srcPos + i2];
+          }
+        }
+      }
+      newData.writeByte(0);
+      if (depth === 8) {
+        newData.writeBytes(rawScanline);
+      } else if (depth === 16) {
+        for (const value of rawScanline) {
+          newData.writeByte(value >> 8 & 255);
+          newData.writeByte(value & 255);
+        }
+      }
+    }
+  }
+  return offset;
+}
+__name(writeDataInterlaced, "writeDataInterlaced");
+function writeDataUint16(data, newData, slotsPerLine, offset) {
+  for (let j = 0; j < slotsPerLine; j++) {
+    newData.writeUint16(data[offset++]);
+  }
+  return offset;
+}
+__name(writeDataUint16, "writeDataUint16");
+
+// ../../node_modules/.pnpm/fast-png@8.0.0/node_modules/fast-png/lib/types.js
+var ResolutionUnitSpecifier = {
+  /**
+   * Unit is unknown.
+   */
+  UNKNOWN: 0,
+  /**
+   * Unit is the metre.
+   */
+  METRE: 1
+};
+
+// ../../node_modules/.pnpm/fast-png@8.0.0/node_modules/fast-png/lib/convert_indexed_to_rgb.js
+function convertIndexedToRgb(decodedImage) {
+  const palette = decodedImage.palette;
+  const depth = decodedImage.depth;
+  if (!palette) {
+    throw new Error("Color palette is undefined.");
+  }
+  checkDataSize(decodedImage);
+  const indexSize = decodedImage.width * decodedImage.height;
+  const resSize = indexSize * palette[0].length;
+  const res = new Uint8Array(resSize);
+  let indexPos = 0;
+  let offset = 0;
+  const indexes = new Uint8Array(indexSize);
+  let bit = 255;
+  switch (depth) {
+    case 1:
+      bit = 128;
+      break;
+    case 2:
+      bit = 192;
+      break;
+    case 4:
+      bit = 240;
+      break;
+    case 8:
+      bit = 255;
+      break;
+    default:
+      throw new Error("Incorrect depth value");
+  }
+  for (const byte of decodedImage.data) {
+    let bit2 = bit;
+    let shift = 8;
+    while (bit2) {
+      shift -= depth;
+      indexes[indexPos++] = (byte & bit2) >> shift;
+      bit2 = bit2 >> depth;
+      if (indexPos % decodedImage.width === 0) {
+        break;
+      }
+    }
+  }
+  if (decodedImage.palette) {
+    for (const index of indexes) {
+      const color = decodedImage.palette.at(index);
+      if (!color) {
+        throw new Error("Incorrect index of palette color");
+      }
+      res.set(color, offset);
+      offset += color.length;
+    }
+  }
+  return res;
+}
+__name(convertIndexedToRgb, "convertIndexedToRgb");
+function checkDataSize(image) {
+  const expectedSize = image.depth < 8 ? Math.ceil(image.width * image.depth / 8) * image.height * image.channels : image.width * image.height * image.channels;
+  if (image.data.length !== expectedSize) {
+    throw new RangeError(`wrong data size. Found ${image.data.length}, expected ${expectedSize}`);
+  }
+}
+__name(checkDataSize, "checkDataSize");
+
+// ../../node_modules/.pnpm/fast-png@8.0.0/node_modules/fast-png/lib/index.js
+function decodePng(data, options) {
+  const decoder = new PngDecoder(data, options);
+  return decoder.decode();
+}
+__name(decodePng, "decodePng");
+function encodePng(png, options) {
+  const encoder2 = new PngEncoder(png, options);
+  return encoder2.encode();
+}
+__name(encodePng, "encodePng");
+function decodeApng(data, options) {
+  const decoder = new PngDecoder(data, options);
+  return decoder.decodeApng();
+}
+__name(decodeApng, "decodeApng");
+export {
+  ResolutionUnitSpecifier,
+  convertIndexedToRgb,
+  decodePng as decode,
+  decodeApng,
+  encodePng as encode,
+  hasPngSignature
+};
+//# sourceMappingURL=lib-KXZZJJG2.js.map