@loaders.gl/scan 5.0.0-alpha.10 → 5.0.0-alpha.11

package/dist/iceberg.cjs

@@ -3328,892 +3328,6 @@ var init_compression = __esm({
   }
 });
 
-// ../compression/src/lib/fflate/index.ts
-function deflateSync(data, opts) {
-  return dopt(data, opts || {}, 0, 0);
-}
-function inflateSync(data, out) {
-  return inflt(data, out);
-}
-function gzipSync(data, opts) {
-  if (!opts) opts = {};
-  const c = crc(), l = data.length;
-  c.p(data);
-  const d = dopt(data, opts, gzhl(opts), 8), s = d.length;
-  return gzh(d, opts), wbytes(d, s - 8, c.d()), wbytes(d, s - 4, l), d;
-}
-function gunzipSync(data, out) {
-  return inflt(data.subarray(gzs(data), -8), out || new u8(gzl(data)));
-}
-function zlibSync(data, opts) {
-  if (!opts) opts = {};
-  const a = adler();
-  a.p(data);
-  const d = dopt(data, opts, 2, 4);
-  return zlh(d, opts), wbytes(d, d.length - 4, a.d()), d;
-}
-function unzlibSync(data, out) {
-  return inflt((zlv(data), data.subarray(2, -4)), out);
-}
-var u8, u16, u32, fleb, fdeb, clim, freb, fl, revfl, fd, revfd, rev, hMap, flt, fdt, flm, flrm, fdm, fdrm, max, bits, bits16, shft, slc, ec, err, inflt, wbits, wbits16, hTree, ln, lc, clen, wfblk, wblk, deo, et, dflt, crct, crc, adler, dopt, wbytes, gzh, gzs, gzl, gzhl, zlh, zlv, Deflate, Inflate, Gzip, Gunzip, Zlib, Unzlib;
-var init_fflate = __esm({
-  "../compression/src/lib/fflate/index.ts"() {
-    "use strict";
-    u8 = Uint8Array;
-    u16 = Uint16Array;
-    u32 = Uint32Array;
-    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
-    ]);
-    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
-    ]);
-    clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
-    freb = (eb, start) => {
-      const b = new u16(31);
-      for (let i = 0; i < 31; ++i) {
-        b[i] = start += 1 << eb[i - 1];
-      }
-      const r = new u32(b[30]);
-      for (let i = 1; i < 30; ++i) {
-        for (let j = b[i]; j < b[i + 1]; ++j) {
-          r[j] = j - b[i] << 5 | i;
-        }
-      }
-      return [b, r];
-    };
-    [fl, revfl] = freb(fleb, 2);
-    fl[28] = 258, revfl[258] = 28;
-    [fd, revfd] = freb(fdeb, 0);
-    rev = new u16(32768);
-    for (let i = 0; i < 32768; ++i) {
-      let 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;
-    }
-    hMap = (cd, mb, r) => {
-      const s = cd.length;
-      let i = 0;
-      const l = new u16(mb);
-      for (; i < s; ++i) {
-        if (cd[i]) ++l[cd[i] - 1];
-      }
-      const le = new u16(mb);
-      for (i = 0; i < mb; ++i) {
-        le[i] = le[i - 1] + l[i - 1] << 1;
-      }
-      let co;
-      if (r) {
-        co = new u16(1 << mb);
-        const rvb = 15 - mb;
-        for (i = 0; i < s; ++i) {
-          if (cd[i]) {
-            const sv = i << 4 | cd[i];
-            const r2 = mb - cd[i];
-            let v = le[cd[i] - 1]++ << r2;
-            for (const m = v | (1 << r2) - 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];
-          }
-        }
-      }
-      return co;
-    };
-    flt = new u8(288);
-    for (let i = 0; i < 144; ++i) flt[i] = 8;
-    for (let i = 144; i < 256; ++i) flt[i] = 9;
-    for (let i = 256; i < 280; ++i) flt[i] = 7;
-    for (let i = 280; i < 288; ++i) flt[i] = 8;
-    fdt = new u8(32);
-    for (let i = 0; i < 32; ++i) fdt[i] = 5;
-    flm = /* @__PURE__ */ hMap(flt, 9, 0);
-    flrm = /* @__PURE__ */ hMap(flt, 9, 1);
-    fdm = /* @__PURE__ */ hMap(fdt, 5, 0);
-    fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
-    max = (a) => {
-      let m = a[0];
-      for (let i = 1; i < a.length; ++i) {
-        if (a[i] > m) m = a[i];
-      }
-      return m;
-    };
-    bits = (d, p, m) => {
-      const o = p / 8 | 0;
-      return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
-    };
-    bits16 = (d, p) => {
-      const o = p / 8 | 0;
-      return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
-    };
-    shft = (p) => (p + 7) / 8 | 0;
-    slc = (v, s, e) => {
-      if (s == null || s < 0) s = 0;
-      if (e == null || e > v.length) e = v.length;
-      const n = new (v.BYTES_PER_ELEMENT == 2 ? u16 : v.BYTES_PER_ELEMENT == 4 ? u32 : u8)(e - s);
-      n.set(v.subarray(s, e));
-      return n;
-    };
-    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
-    ];
-    err = (ind, msg, nt) => {
-      const e = new Error(msg || ec[ind]);
-      e.code = ind;
-      if (Error.captureStackTrace) Error.captureStackTrace(e, err);
-      if (!nt) throw e;
-      return e;
-    };
-    inflt = (dat, buf, st) => {
-      const sl = dat.length;
-      if (!sl || st && st.f && !st.l) return buf || new u8(0);
-      const noBuf = !buf || st;
-      const noSt = !st || st.i;
-      if (!st) st = {};
-      if (!buf) buf = new u8(sl * 3);
-      const cbuf = (l) => {
-        let bl = buf.length;
-        if (l > bl) {
-          const nbuf = new u8(Math.max(bl * 2, l));
-          nbuf.set(buf);
-          buf = nbuf;
-        }
-      };
-      let final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
-      const tbts = sl * 8;
-      do {
-        if (!lm) {
-          final = bits(dat, pos, 1);
-          const type = bits(dat, pos + 1, 3);
-          pos += 3;
-          if (!type) {
-            const s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
-            if (t > sl) {
-              if (noSt) err(0);
-              break;
-            }
-            if (noBuf) 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) {
-            const hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
-            const tl = hLit + bits(dat, pos + 5, 31) + 1;
-            pos += 14;
-            const ldt = new u8(tl);
-            const clt = new u8(19);
-            for (let i = 0; i < hcLen; ++i) {
-              clt[clim[i]] = bits(dat, pos + i * 3, 7);
-            }
-            pos += hcLen * 3;
-            const clb = max(clt), clbmsk = (1 << clb) - 1;
-            const clm = hMap(clt, clb, 1);
-            for (let i = 0; i < tl; ) {
-              const r = clm[bits(dat, pos, clbmsk)];
-              pos += r & 15;
-              const s = r >>> 4;
-              if (s < 16) {
-                ldt[i++] = s;
-              } else {
-                let 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;
-              }
-            }
-            const 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 (noBuf) cbuf(bt + 131072);
-        const lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
-        let lpos = pos;
-        for (; ; lpos = pos) {
-          const 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 = void 0;
-            break;
-          } else {
-            let add = sym - 254;
-            if (sym > 264) {
-              const i = sym - 257, b = fleb[i];
-              add = bits(dat, pos, (1 << b) - 1) + fl[i];
-              pos += b;
-            }
-            const d = dm[bits16(dat, pos) & dms], dsym = d >>> 4;
-            if (!d) err(3);
-            pos += d & 15;
-            let dt = fd[dsym];
-            if (dsym > 3) {
-              const b = fdeb[dsym];
-              dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
-            }
-            if (pos > tbts) {
-              if (noSt) err(0);
-              break;
-            }
-            if (noBuf) cbuf(bt + 131072);
-            const end = bt + add;
-            for (; bt < end; bt += 4) {
-              buf[bt] = buf[bt - dt];
-              buf[bt + 1] = buf[bt + 1 - dt];
-              buf[bt + 2] = buf[bt + 2 - dt];
-              buf[bt + 3] = buf[bt + 3 - dt];
-            }
-            bt = end;
-          }
-        }
-        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 ? buf : slc(buf, 0, bt);
-    };
-    wbits = (d, p, v) => {
-      v <<= p & 7;
-      const o = p / 8 | 0;
-      d[o] |= v;
-      d[o + 1] |= v >>> 8;
-    };
-    wbits16 = (d, p, v) => {
-      v <<= p & 7;
-      const o = p / 8 | 0;
-      d[o] |= v;
-      d[o + 1] |= v >>> 8;
-      d[o + 2] |= v >>> 16;
-    };
-    hTree = (d, mb) => {
-      const t = [];
-      for (let i = 0; i < d.length; ++i) {
-        if (d[i]) t.push({ s: i, f: d[i] });
-      }
-      const s = t.length;
-      const t2 = t.slice();
-      if (!s) return [et, 0];
-      if (s == 1) {
-        const v = new u8(t[0].s + 1);
-        v[t[0].s] = 1;
-        return [v, 1];
-      }
-      t.sort((a, b) => a.f - b.f);
-      t.push({ s: -1, f: 25001 });
-      let l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2;
-      t[0] = { s: -1, f: l.f + r.f, l, r };
-      while (i1 != s - 1) {
-        l = t[t[i0].f < t[i2].f ? i0++ : i2++];
-        r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++];
-        t[i1++] = { s: -1, f: l.f + r.f, l, r };
-      }
-      let maxSym = t2[0].s;
-      for (let i = 1; i < s; ++i) {
-        if (t2[i].s > maxSym) maxSym = t2[i].s;
-      }
-      const tr = new u16(maxSym + 1);
-      let mbt = ln(t[i1 - 1], tr, 0);
-      if (mbt > mb) {
-        let i = 0, dt = 0;
-        const lft = mbt - mb, cst = 1 << lft;
-        t2.sort((a, b) => tr[b.s] - tr[a.s] || a.f - b.f);
-        for (; i < s; ++i) {
-          const i22 = t2[i].s;
-          if (tr[i22] > mb) {
-            dt += cst - (1 << mbt - tr[i22]);
-            tr[i22] = mb;
-          } else break;
-        }
-        dt >>>= lft;
-        while (dt > 0) {
-          const i22 = t2[i].s;
-          if (tr[i22] < mb) dt -= 1 << mb - tr[i22]++ - 1;
-          else ++i;
-        }
-        for (; i >= 0 && dt; --i) {
-          const i22 = t2[i].s;
-          if (tr[i22] == mb) {
-            --tr[i22];
-            ++dt;
-          }
-        }
-        mbt = mb;
-      }
-      return [new u8(tr), mbt];
-    };
-    ln = (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;
-    };
-    lc = (c) => {
-      let s = c.length;
-      while (s && !c[--s]) ;
-      const cl = new u16(++s);
-      let cli = 0, cln = c[0], cls = 1;
-      const w = (v) => {
-        cl[cli++] = v;
-      };
-      for (let i = 1; i <= s; ++i) {
-        if (c[i] == cln && i != 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[i];
-        }
-      }
-      return [cl.subarray(0, cli), s];
-    };
-    clen = (cf, cl) => {
-      let l = 0;
-      for (let i = 0; i < cl.length; ++i) l += cf[i] * cl[i];
-      return l;
-    };
-    wfblk = (out, pos, dat) => {
-      const s = dat.length;
-      const 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 (let i = 0; i < s; ++i) out[o + i + 4] = dat[i];
-      return (o + 4 + s) * 8;
-    };
-    wblk = (dat, out, final, syms, lf, df, eb, li, bs, bl, p) => {
-      wbits(out, p++, final);
-      ++lf[256];
-      const [dlt, mlb] = hTree(lf, 15);
-      const [ddt, mdb] = hTree(df, 15);
-      const [lclt, nlc] = lc(dlt);
-      const [lcdt, ndc] = lc(ddt);
-      const lcfreq = new u16(19);
-      for (let i = 0; i < lclt.length; ++i) lcfreq[lclt[i] & 31]++;
-      for (let i = 0; i < lcdt.length; ++i) lcfreq[lcdt[i] & 31]++;
-      const [lct, mlcb] = hTree(lcfreq, 7);
-      let nlcc = 19;
-      for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc) ;
-      const flen = bl + 5 << 3;
-      const ftlen = clen(lf, flt) + clen(df, fdt) + eb;
-      const dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + (2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18]);
-      if (flen <= ftlen && flen <= dtlen) return wfblk(out, p, dat.subarray(bs, bs + bl));
-      let 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;
-        const 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 (let i = 0; i < nlcc; ++i) wbits(out, p + 3 * i, lct[clim[i]]);
-        p += 3 * nlcc;
-        const lcts = [lclt, lcdt];
-        for (let it = 0; it < 2; ++it) {
-          const clct = lcts[it];
-          for (let i = 0; i < clct.length; ++i) {
-            const len = clct[i] & 31;
-            wbits(out, p, llm[len]), p += lct[len];
-            if (len > 15) wbits(out, p, clct[i] >>> 5 & 127), p += clct[i] >>> 12;
-          }
-        }
-      } else {
-        lm = flm, ll = flt, dm = fdm, dl = fdt;
-      }
-      for (let i = 0; i < li; ++i) {
-        if (syms[i] > 255) {
-          const len = syms[i] >>> 18 & 31;
-          wbits16(out, p, lm[len + 257]), p += ll[len + 257];
-          if (len > 7) wbits(out, p, syms[i] >>> 23 & 31), p += fleb[len];
-          const dst = syms[i] & 31;
-          wbits16(out, p, dm[dst]), p += dl[dst];
-          if (dst > 3) wbits16(out, p, syms[i] >>> 5 & 8191), p += fdeb[dst];
-        } else {
-          wbits16(out, p, lm[syms[i]]), p += ll[syms[i]];
-        }
-      }
-      wbits16(out, p, lm[256]);
-      return p + ll[256];
-    };
-    deo = /* @__PURE__ */ new u32([
-      65540,
-      131080,
-      131088,
-      131104,
-      262176,
-      1048704,
-      1048832,
-      2114560,
-      2117632
-    ]);
-    et = /* @__PURE__ */ new u8(0);
-    dflt = (dat, lvl, plvl, pre, post, lst) => {
-      const s = dat.length;
-      const o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7e3)) + post);
-      const w = o.subarray(pre, o.length - post);
-      let pos = 0;
-      if (!lvl || s < 8) {
-        for (let i = 0; i <= s; i += 65535) {
-          const e = i + 65535;
-          if (e >= s) {
-            w[pos >> 3] = lst;
-          }
-          pos = wfblk(w, pos + 1, dat.subarray(i, e));
-        }
-      } else {
-        const opt = deo[lvl - 1];
-        const n = opt >>> 13, c = opt & 8191;
-        const msk = (1 << plvl) - 1;
-        const prev = new u16(32768), head = new u16(msk + 1);
-        const bs1 = Math.ceil(plvl / 3), bs2 = 2 * bs1;
-        const hsh = (i2) => (dat[i2] ^ dat[i2 + 1] << bs1 ^ dat[i2 + 2] << bs2) & msk;
-        const syms = new u32(25e3);
-        const lf = new u16(288), df = new u16(32);
-        let lc2 = 0, eb = 0, i = 0, li = 0, wi = 0, bs = 0;
-        for (; i < s; ++i) {
-          const hv = hsh(i);
-          let imod = i & 32767, pimod = head[hv];
-          prev[imod] = pimod;
-          head[hv] = imod;
-          if (wi <= i) {
-            const rem = s - i;
-            if ((lc2 > 7e3 || li > 24576) && rem > 423) {
-              pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);
-              li = lc2 = eb = 0, bs = i;
-              for (let j = 0; j < 286; ++j) lf[j] = 0;
-              for (let j = 0; j < 30; ++j) df[j] = 0;
-            }
-            let l = 2, d = 0, ch = c, dif = imod - pimod & 32767;
-            if (rem > 2 && hv == hsh(i - dif)) {
-              const maxn = Math.min(n, rem) - 1;
-              const maxd = Math.min(32767, i);
-              const ml = Math.min(258, rem);
-              while (dif <= maxd && --ch && imod != pimod) {
-                if (dat[i + l] == dat[i + l - dif]) {
-                  let nl = 0;
-                  for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl) ;
-                  if (nl > l) {
-                    l = nl, d = dif;
-                    if (nl > maxn) break;
-                    const mmd = Math.min(dif, nl - 2);
-                    let md = 0;
-                    for (let j = 0; j < mmd; ++j) {
-                      const ti = i - dif + j + 32768 & 32767;
-                      const pti = prev[ti];
-                      const cd = ti - pti + 32768 & 32767;
-                      if (cd > md) md = cd, pimod = ti;
-                    }
-                  }
-                }
-                imod = pimod, pimod = prev[imod];
-                dif += imod - pimod + 32768 & 32767;
-              }
-            }
-            if (d) {
-              syms[li++] = 268435456 | revfl[l] << 18 | revfd[d];
-              const lin = revfl[l] & 31, din = revfd[d] & 31;
-              eb += fleb[lin] + fdeb[din];
-              ++lf[257 + lin];
-              ++df[din];
-              wi = i + l;
-              ++lc2;
-            } else {
-              syms[li++] = dat[i];
-              ++lf[dat[i]];
-            }
-          }
-        }
-        pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);
-        if (!lst && pos & 7) pos = wfblk(w, pos + 1, et);
-      }
-      return slc(o, 0, pre + shft(pos) + post);
-    };
-    crct = /* @__PURE__ */ (() => {
-      const t = new Int32Array(256);
-      for (let i = 0; i < 256; ++i) {
-        let c = i, k = 9;
-        while (--k) c = (c & 1 && -306674912) ^ c >>> 1;
-        t[i] = c;
-      }
-      return t;
-    })();
-    crc = () => {
-      let c = -1;
-      return {
-        p(d) {
-          let cr = c;
-          for (let i = 0; i < d.length; ++i) cr = crct[cr & 255 ^ d[i]] ^ cr >>> 8;
-          c = cr;
-        },
-        d() {
-          return ~c;
-        }
-      };
-    };
-    adler = () => {
-      let a = 1, b = 0;
-      return {
-        p(d) {
-          let n = a, m = b;
-          const l = d.length | 0;
-          for (let i = 0; i != l; ) {
-            const e = Math.min(i + 2655, l);
-            for (; i < e; ++i) m += n += d[i];
-            n = (n & 65535) + 15 * (n >> 16), m = (m & 65535) + 15 * (m >> 16);
-          }
-          a = n, b = m;
-        },
-        d() {
-          a %= 65521, b %= 65521;
-          return (a & 255) << 24 | a >>> 8 << 16 | (b & 255) << 8 | b >>> 8;
-        }
-      };
-    };
-    dopt = (dat, opt, pre, post, st) => dflt(
-      dat,
-      opt.level == null ? 6 : opt.level,
-      opt.mem == null ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 12 + opt.mem,
-      pre,
-      post,
-      !st
-    );
-    wbytes = (d, b, v) => {
-      for (; v; ++b) d[b] = v, v >>>= 8;
-    };
-    gzh = (c, o) => {
-      const fn = o.filename;
-      c[0] = 31, c[1] = 139, c[2] = 8, c[8] = o.level < 2 ? 4 : o.level == 9 ? 2 : 0, c[9] = 3;
-      if (o.mtime != 0)
-        wbytes(
-          c,
-          4,
-          Math.floor(new Date(o.mtime || Date.now()) / 1e3)
-        );
-      if (fn) {
-        c[3] = 8;
-        for (let i = 0; i <= fn.length; ++i) c[i + 10] = fn.charCodeAt(i);
-      }
-    };
-    gzs = (d) => {
-      if (d[0] != 31 || d[1] != 139 || d[2] != 8) err(6, "invalid gzip data");
-      const flg = d[3];
-      let st = 10;
-      if (flg & 4) st += d[10] | (d[11] << 8) + 2;
-      for (let zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++]) ;
-      return st + (flg & 2);
-    };
-    gzl = (d) => {
-      const l = d.length;
-      return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
-    };
-    gzhl = (o) => 10 + (o.filename && o.filename.length + 1 || 0);
-    zlh = (c, o) => {
-      const lv = o.level, fl2 = lv == 0 ? 0 : lv < 6 ? 1 : lv == 9 ? 3 : 2;
-      c[0] = 120, c[1] = fl2 << 6 | (fl2 ? 32 - 2 * fl2 : 1);
-    };
-    zlv = (d) => {
-      if ((d[0] & 15) != 8 || d[0] >>> 4 > 7 || (d[0] << 8 | d[1]) % 31) err(6, "invalid zlib data");
-      if (d[1] & 32) err(6, "invalid zlib data: preset dictionaries not supported");
-    };
-    Deflate = class {
-      /** Initializes the stream and its output handler. */
-      constructor(opts, cb) {
-        if (!cb && typeof opts == "function") cb = opts, opts = {};
-        this.ondata = cb;
-        this.o = opts || {};
-      }
-      /** Compression options or retained output window for this stream. */
-      o;
-      /** Whether the stream has received its final chunk. */
-      d;
-      /**
-       * The handler to call whenever data is available
-       */
-      ondata;
-      /** Encodes a chunk and emits its framed output. */
-      p(c, f) {
-        this.ondata(dopt(c, this.o, 0, 0, !f), f);
-      }
-      /**
-       * Pushes a chunk to be deflated
-       * @param chunk The chunk to push
-       * @param final Whether this is the last chunk
-       */
-      push(chunk, final) {
-        if (!this.ondata) err(5);
-        if (this.d) err(4);
-        this.d = final;
-        this.p(chunk, final || false);
-      }
-    };
-    Inflate = class {
-      /**
-       * Creates an inflation stream
-       * @param cb The callback to call whenever data is inflated
-       */
-      constructor(cb) {
-        this.ondata = cb;
-      }
-      /** Persistent bit-reader and Huffman decoding state. */
-      s = {};
-      /** Compression options or retained output window for this stream. */
-      o;
-      /** Compressed bytes pending decoding. */
-      p = new u8(0);
-      /** Whether the stream has received its final chunk. */
-      d;
-      /**
-       * The handler to call whenever data is available
-       */
-      ondata;
-      /** Appends pending input after checking stream lifecycle. */
-      e(c) {
-        if (!this.ondata) err(5);
-        if (this.d) err(4);
-        const l = this.p.length;
-        const n = new u8(l + c.length);
-        n.set(this.p), n.set(c, l), this.p = n;
-      }
-      /** Decodes pending input and retains the sliding window. */
-      c(final) {
-        this.d = this.s.i = final || false;
-        const bts = this.s.b;
-        const dt = inflt(this.p, this.o, this.s);
-        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;
-      }
-      /**
-       * Pushes a chunk to be inflated
-       * @param chunk The chunk to push
-       * @param final Whether this is the final chunk
-       */
-      push(chunk, final) {
-        this.e(chunk), this.c(final);
-      }
-    };
-    Gzip = class extends Deflate {
-      /** Checksum accumulator for the framed output. */
-      c = crc();
-      /** Total uncompressed byte count for the GZIP footer. */
-      l = 0;
-      /** Whether the stream header still needs to be emitted or consumed. */
-      v = 1;
-      /** Initializes the stream and its output handler. */
-      constructor(opts, cb) {
-        super(opts, cb);
-      }
-      /**
-       * Pushes a chunk to be GZIPped
-       * @param chunk The chunk to push
-       * @param final Whether this is the last chunk
-       */
-      push(chunk, final) {
-        Deflate.prototype.push.call(this, chunk, final);
-      }
-      /** Encodes a chunk and emits its framed output. */
-      p(c, f) {
-        this.c.p(c);
-        this.l += c.length;
-        const raw = dopt(c, this.o, this.v ? gzhl(this.o) : 0, f ? 8 : 0, !f);
-        if (this.v) gzh(raw, this.o), this.v = 0;
-        if (f) wbytes(raw, raw.length - 8, this.c.d()), wbytes(raw, raw.length - 4, this.l);
-        this.ondata(raw, f);
-      }
-    };
-    Gunzip = class extends Inflate {
-      /** Whether the stream header still needs to be emitted or consumed. */
-      v = 1;
-      /**
-       * Creates a GUNZIP stream
-       * @param cb The callback to call whenever data is inflated
-       */
-      constructor(cb) {
-        super(cb);
-      }
-      /**
-       * Pushes a chunk to be GUNZIPped
-       * @param chunk The chunk to push
-       * @param final Whether this is the last chunk
-       */
-      push(chunk, final) {
-        Inflate.prototype.e.call(this, chunk);
-        if (this.v) {
-          const s = this.p.length > 3 ? gzs(this.p) : 4;
-          if (s >= this.p.length && !final) return;
-          this.p = this.p.subarray(s), this.v = 0;
-        }
-        if (final) {
-          if (this.p.length < 8) err(6, "invalid gzip data");
-          this.p = this.p.subarray(0, -8);
-        }
-        Inflate.prototype.c.call(this, final);
-      }
-    };
-    Zlib = class extends Deflate {
-      /** Checksum accumulator for the framed output. */
-      c = adler();
-      /** Whether the stream header still needs to be emitted or consumed. */
-      v = 1;
-      /** Initializes the stream and its output handler. */
-      constructor(opts, cb) {
-        super(opts, cb);
-      }
-      /**
-       * Pushes a chunk to be zlibbed
-       * @param chunk The chunk to push
-       * @param final Whether this is the last chunk
-       */
-      push(chunk, final) {
-        Deflate.prototype.push.call(this, chunk, final);
-      }
-      /** Encodes a chunk and emits its framed output. */
-      p(c, f) {
-        this.c.p(c);
-        const raw = dopt(c, this.o, this.v ? 2 : 0, f ? 4 : 0, !f);
-        if (this.v) zlh(raw, this.o), this.v = 0;
-        if (f) wbytes(raw, raw.length - 4, this.c.d());
-        this.ondata(raw, f);
-      }
-    };
-    Unzlib = class extends Inflate {
-      /** Whether the stream header still needs to be emitted or consumed. */
-      v = 1;
-      /**
-       * Creates a Zlib decompression stream
-       * @param cb The callback to call whenever data is inflated
-       */
-      constructor(cb) {
-        super(cb);
-      }
-      /**
-       * Pushes a chunk to be unzlibbed
-       * @param chunk The chunk to push
-       * @param final Whether this is the last chunk
-       */
-      push(chunk, final) {
-        Inflate.prototype.e.call(this, chunk);
-        if (this.v) {
-          if (this.p.length < 2 && !final) return;
-          this.p = this.p.subarray(2), 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);
-      }
-    };
-  }
-});
-
 // ../compression/src/lib/compression-stream.ts
 async function compressWithNativeCompressionStream(input, format) {
   const outputBatches = compressBatchesWithNativeCompressionStream([input], format);
@@ -4396,322 +3510,568 @@ var init_decompression_stream = __esm({
   }
 });
 
-// ../compression/src/lib/deflate-compression.ts
-var deflate_compression_exports = {};
-__export(deflate_compression_exports, {
-  DeflateCompression: () => DeflateCompression
+// ../compression/src/lib/native-decompressor.ts
+var native_decompressor_exports = {};
+__export(native_decompressor_exports, {
+  NativeDecompressor: () => NativeDecompressor
 });
-var import_zlib, DeflateCompression;
-var init_deflate_compression = __esm({
-  "../compression/src/lib/deflate-compression.ts"() {
+var NativeDecompressor;
+var init_native_decompressor = __esm({
+  "../compression/src/lib/native-decompressor.ts"() {
     "use strict";
     init_compression();
-    init_src2();
-    init_fflate();
-    import_zlib = __toESM(require("zlib"), 1);
-    init_compression_stream();
     init_decompression_stream();
-    DeflateCompression = class extends Compression {
-      name = "deflate";
-      extensions = [];
-      contentEncodings = ["deflate"];
+    NativeDecompressor = class extends Decompressor {
+      name;
+      extensions;
+      contentEncodings;
+      isSupported = true;
+      /** Runtime stream format used for every operation. */
+      format;
+      constructor(metadata, format, options = {}) {
+        super(options);
+        this.name = metadata.name;
+        this.extensions = [...metadata.extensions];
+        this.contentEncodings = [...metadata.contentEncodings];
+        this.format = format;
+      }
+      /** Decompresses one buffer with the runtime-provided stream. */
+      async decompress(input) {
+        const output = await decompressWithNativeDecompressionStream(input, this.format);
+        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
+        return output;
+      }
+      /** Decompresses batches incrementally with the runtime-provided stream. */
+      async *decompressBatches(inputBatches) {
+        const output = decompressBatchesWithNativeDecompressionStream(inputBatches, this.format);
+        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
+        yield* output;
+      }
+    };
+  }
+});
+
+// ../compression/src/lib/lazy-compression.ts
+function mergeModules(options, modules) {
+  return { ...options, modules: { ...options.modules, ...modules } };
+}
+var LazyDecompressor;
+var init_lazy_compression = __esm({
+  "../compression/src/lib/lazy-compression.ts"() {
+    "use strict";
+    init_compression();
+    init_decompression_stream();
+    LazyDecompressor = class extends Decompressor {
+      name;
+      extensions;
+      contentEncodings;
       isSupported = true;
+      /** Constructor options retained until a concrete implementation is selected. */
       options;
-      constructor(options = {}) {
+      /** Built-in stream format to probe, or null when the format has no built-in path. */
+      nativeFormat;
+      /** Returns whether built-in selection remains eligible for the merged preload options. */
+      shouldUseNative;
+      /** Dynamically imports the balanced fallback constructor. */
+      loadFallback;
+      /** Selected concrete implementation after preload completes. */
+      implementation = null;
+      /** Shared in-flight selection used by concurrent asynchronous calls. */
+      implementationPromise = null;
+      constructor(metadata, loadFallback, options = {}, nativeFormat = null, shouldUseNative = () => true) {
         super(options);
+        this.name = metadata.name;
+        this.extensions = [...metadata.extensions];
+        this.contentEncodings = [...metadata.contentEncodings];
         this.options = options;
+        this.nativeFormat = nativeFormat;
+        this.shouldUseNative = shouldUseNative;
+        this.loadFallback = loadFallback;
+      }
+      /** Selects and returns the built-in or dynamically imported fallback decompressor. */
+      async preload(modules = {}) {
+        if (this.implementation) return this.implementation;
+        const options = mergeModules(this.options, modules);
+        this.implementationPromise ||= this.loadImplementation(options);
+        try {
+          this.implementation = await this.implementationPromise;
+          return this.implementation;
+        } catch (error) {
+          this.implementationPromise = null;
+          throw error;
+        }
+      }
+      /** Loads the selected concrete decompressor. */
+      async loadImplementation(options) {
+        if (options.useNative !== false && this.nativeFormat && this.shouldUseNative(options) && isNativeDecompressionSupported(this.nativeFormat)) {
+          const { NativeDecompressor: NativeDecompressor2 } = await Promise.resolve().then(() => (init_native_decompressor(), native_decompressor_exports));
+          return new NativeDecompressor2(this, this.nativeFormat, options);
+        }
+        const Decompressor2 = await this.loadFallback();
+        const implementation = new Decompressor2({ ...options, useNative: false });
+        await implementation.preload(options.modules);
+        return implementation;
+      }
+      /** Decompresses after lazily selecting the default implementation. */
+      async decompress(input, size) {
+        return (await this.preload()).decompress(input, size);
+      }
+      /** Decompresses synchronously after an implementation has been preloaded. */
+      decompressSync(input, size) {
+        if (!this.implementation) {
+          throw new Error(`${this.name}: call preload() before decompressSync()`);
+        }
+        return this.implementation.decompressSync(input, size);
+      }
+      /** Decompresses batches after lazily selecting the default implementation. */
+      async *decompressBatches(inputBatches) {
+        yield* (await this.preload()).decompressBatches(inputBatches);
+      }
+    };
+  }
+});
+
+// ../compression/src/lib/fflate/index.ts
+function inflateSync(data, out) {
+  return inflt(data, out);
+}
+function gunzipSync(data, out) {
+  return inflt(data.subarray(gzs(data), -8), out || new u8(gzl(data)));
+}
+function unzlibSync(data, out) {
+  return inflt((zlv(data), data.subarray(2, -4)), out);
+}
+var u8, u16, u32, fleb, fdeb, clim, freb, fl, revfl, fd, revfd, rev, hMap, flt, fdt, flrm, fdrm, max, bits, bits16, shft, slc, ec, err, inflt, gzs, gzl, zlv, Inflate, Gunzip, Unzlib;
+var init_fflate = __esm({
+  "../compression/src/lib/fflate/index.ts"() {
+    "use strict";
+    u8 = Uint8Array;
+    u16 = Uint16Array;
+    u32 = Uint32Array;
+    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
+    ]);
+    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
+    ]);
+    clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+    freb = (eb, start) => {
+      const b = new u16(31);
+      for (let i = 0; i < 31; ++i) {
+        b[i] = start += 1 << eb[i - 1];
       }
-      async compress(input) {
-        var _a, _b, _c;
-        const format = this.options.raw ? null : ((_a = this.options.deflate) == null ? void 0 : _a.gzip) ? "gzip" : "deflate";
-        if (format && ((_b = this.options.deflate) == null ? void 0 : _b.useNative) !== false) {
-          const nativeOutput = await compressWithNativeCompressionStream(input, format);
-          if (nativeOutput) return nativeOutput;
-        }
-        if (!isBrowser && ((_c = this.options.deflate) == null ? void 0 : _c.useZlib)) {
-          const buffer = this.options.deflate.gzip ? await promisify1(import_zlib.default.gzip)(input) : await promisify1(import_zlib.default.deflate)(input);
-          return toArrayBuffer2(buffer);
+      const r = new u32(b[30]);
+      for (let i = 1; i < 30; ++i) {
+        for (let j = b[i]; j < b[i + 1]; ++j) {
+          r[j] = j - b[i] << 5 | i;
         }
-        return this.compressSync(input);
       }
-      async decompress(input) {
-        var _a, _b, _c;
-        const format = this.options.raw ? "deflate-raw" : ((_a = this.options.deflate) == null ? void 0 : _a.gzip) ? "gzip" : "deflate";
-        if (((_b = this.options.deflate) == null ? void 0 : _b.useNative) !== false) {
-          const nativeOutput = await decompressWithNativeDecompressionStream(input, format);
-          if (nativeOutput) return nativeOutput;
-        }
-        if (!isBrowser && ((_c = this.options.deflate) == null ? void 0 : _c.useZlib)) {
-          const buffer = this.options.deflate.gzip ? await promisify1(import_zlib.default.gunzip)(input) : await promisify1(import_zlib.default.inflate)(input);
-          return toArrayBuffer2(buffer);
-        }
-        return this.decompressSync(input);
+      return [b, r];
+    };
+    [fl, revfl] = freb(fleb, 2);
+    fl[28] = 258, revfl[258] = 28;
+    [fd, revfd] = freb(fdeb, 0);
+    rev = new u16(32768);
+    for (let i = 0; i < 32768; ++i) {
+      let 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;
+    }
+    hMap = (cd, mb, r) => {
+      const s = cd.length;
+      let i = 0;
+      const l = new u16(mb);
+      for (; i < s; ++i) {
+        if (cd[i]) ++l[cd[i] - 1];
       }
-      compressSync(input) {
-        var _a, _b, _c;
-        if (!isBrowser && ((_a = this.options.deflate) == null ? void 0 : _a.useZlib)) {
-          const buffer = ((_b = this.options.deflate) == null ? void 0 : _b.gzip) ? import_zlib.default.gzipSync(input) : import_zlib.default.deflateSync(input);
-          return toArrayBuffer2(buffer);
-        }
-        const bytes = new Uint8Array(input);
-        const options = this.options.deflate || {};
-        const output = this.options.raw ? deflateSync(bytes, options) : ((_c = this.options.deflate) == null ? void 0 : _c.gzip) ? gzipSync(bytes, options) : zlibSync(bytes, options);
-        return toArrayBuffer2(output);
+      const le = new u16(mb);
+      for (i = 0; i < mb; ++i) {
+        le[i] = le[i - 1] + l[i - 1] << 1;
       }
-      decompressSync(input) {
-        var _a, _b, _c;
-        if (!isBrowser && ((_a = this.options.deflate) == null ? void 0 : _a.useZlib)) {
-          const buffer = ((_b = this.options.deflate) == null ? void 0 : _b.gzip) ? import_zlib.default.gunzipSync(input) : import_zlib.default.inflateSync(input);
-          return toArrayBuffer2(buffer);
+      let co;
+      if (r) {
+        co = new u16(1 << mb);
+        const rvb = 15 - mb;
+        for (i = 0; i < s; ++i) {
+          if (cd[i]) {
+            const sv = i << 4 | cd[i];
+            const r2 = mb - cd[i];
+            let v = le[cd[i] - 1]++ << r2;
+            for (const m = v | (1 << r2) - 1; v <= m; ++v) {
+              co[rev[v] >>> rvb] = sv;
+            }
+          }
         }
-        const bytes = new Uint8Array(input);
-        const output = this.options.raw ? inflateSync(bytes) : ((_c = this.options.deflate) == null ? void 0 : _c.gzip) ? gunzipSync(bytes) : unzlibSync(bytes);
-        return toArrayBuffer2(output);
-      }
-      async *compressBatches(inputBatches) {
-        var _a, _b, _c;
-        if (!this.options.raw && ((_a = this.options.deflate) == null ? void 0 : _a.useNative) !== false) {
-          const format = ((_b = this.options.deflate) == null ? void 0 : _b.gzip) ? "gzip" : "deflate";
-          const nativeBatches = compressBatchesWithNativeCompressionStream(inputBatches, format);
-          if (nativeBatches) {
-            yield* nativeBatches;
-            return;
+      } else {
+        co = new u16(s);
+        for (i = 0; i < s; ++i) {
+          if (cd[i]) {
+            co[i] = rev[le[cd[i] - 1]++] >>> 15 - cd[i];
           }
         }
-        const options = this.options.deflate || {};
-        const processor = ((_c = this.options.deflate) == null ? void 0 : _c.gzip) ? new Gzip(options) : this.options.raw ? new Deflate(options) : new Zlib(options);
-        yield* this.transformBatches(processor, inputBatches);
       }
-      async *decompressBatches(inputBatches) {
-        var _a, _b, _c;
-        const format = this.options.raw ? "deflate-raw" : ((_a = this.options.deflate) == null ? void 0 : _a.gzip) ? "gzip" : "deflate";
-        if (((_b = this.options.deflate) == null ? void 0 : _b.useNative) !== false) {
-          const nativeBatches = decompressBatchesWithNativeDecompressionStream(inputBatches, format);
-          if (nativeBatches) {
-            yield* nativeBatches;
-            return;
+      return co;
+    };
+    flt = new u8(288);
+    for (let i = 0; i < 144; ++i) flt[i] = 8;
+    for (let i = 144; i < 256; ++i) flt[i] = 9;
+    for (let i = 256; i < 280; ++i) flt[i] = 7;
+    for (let i = 280; i < 288; ++i) flt[i] = 8;
+    fdt = new u8(32);
+    for (let i = 0; i < 32; ++i) fdt[i] = 5;
+    flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+    fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+    max = (a) => {
+      let m = a[0];
+      for (let i = 1; i < a.length; ++i) {
+        if (a[i] > m) m = a[i];
+      }
+      return m;
+    };
+    bits = (d, p, m) => {
+      const o = p / 8 | 0;
+      return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+    };
+    bits16 = (d, p) => {
+      const o = p / 8 | 0;
+      return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+    };
+    shft = (p) => (p + 7) / 8 | 0;
+    slc = (v, s, e) => {
+      if (s == null || s < 0) s = 0;
+      if (e == null || e > v.length) e = v.length;
+      const n = new (v.BYTES_PER_ELEMENT == 2 ? u16 : v.BYTES_PER_ELEMENT == 4 ? u32 : u8)(e - s);
+      n.set(v.subarray(s, e));
+      return n;
+    };
+    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
+    ];
+    err = (ind, msg, nt) => {
+      const e = new Error(msg || ec[ind]);
+      e.code = ind;
+      if (Error.captureStackTrace) Error.captureStackTrace(e, err);
+      if (!nt) throw e;
+      return e;
+    };
+    inflt = (dat, buf, st) => {
+      const sl = dat.length;
+      if (!sl || st && st.f && !st.l) return buf || new u8(0);
+      const noBuf = !buf || st;
+      const noSt = !st || st.i;
+      if (!st) st = {};
+      if (!buf) buf = new u8(sl * 3);
+      const cbuf = (l) => {
+        let bl = buf.length;
+        if (l > bl) {
+          const nbuf = new u8(Math.max(bl * 2, l));
+          nbuf.set(buf);
+          buf = nbuf;
+        }
+      };
+      let final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+      const tbts = sl * 8;
+      do {
+        if (!lm) {
+          final = bits(dat, pos, 1);
+          const type = bits(dat, pos + 1, 3);
+          pos += 3;
+          if (!type) {
+            const s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+            if (t > sl) {
+              if (noSt) err(0);
+              break;
+            }
+            if (noBuf) 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) {
+            const hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+            const tl = hLit + bits(dat, pos + 5, 31) + 1;
+            pos += 14;
+            const ldt = new u8(tl);
+            const clt = new u8(19);
+            for (let i = 0; i < hcLen; ++i) {
+              clt[clim[i]] = bits(dat, pos + i * 3, 7);
+            }
+            pos += hcLen * 3;
+            const clb = max(clt), clbmsk = (1 << clb) - 1;
+            const clm = hMap(clt, clb, 1);
+            for (let i = 0; i < tl; ) {
+              const r = clm[bits(dat, pos, clbmsk)];
+              pos += r & 15;
+              const s = r >>> 4;
+              if (s < 16) {
+                ldt[i++] = s;
+              } else {
+                let 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;
+              }
+            }
+            const 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;
           }
         }
-        const processor = ((_c = this.options.deflate) == null ? void 0 : _c.gzip) ? new Gunzip() : this.options.raw ? new Inflate() : new Unzlib();
-        yield* this.transformBatches(processor, inputBatches);
-      }
-      /**
-       * Streams batches through a DEFLATE-compatible processor.
-       *
-       * @deprecated Prefer `compressBatches` or `decompressBatches`. Retained for
-       * compatibility with callers that supplied a Pako-style processor.
-       */
-      async *transformBatches(processor, inputBatches) {
-        const chunks = [];
-        const appendChunk = (data) => {
-          chunks.push(new Uint8Array(data).slice().buffer);
-        };
-        processor.ondata = appendChunk;
-        processor.onData = appendChunk;
-        processor.onEnd = (status) => {
-          if (status !== 0) {
-            throw new Error(`${this.name}: streaming processor failed with status ${status}`);
+        if (noBuf) cbuf(bt + 131072);
+        const lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+        let lpos = pos;
+        for (; ; lpos = pos) {
+          const c = lm[bits16(dat, pos) & lms], sym = c >>> 4;
+          pos += c & 15;
+          if (pos > tbts) {
+            if (noSt) err(0);
+            break;
           }
-        };
-        for await (const batch of inputBatches) {
-          const result2 = processor.push(new Uint8Array(batch), false);
-          if (result2 === false) {
-            throw new Error(`${this.name}: streaming processor rejected a batch`);
+          if (!c) err(2);
+          if (sym < 256) buf[bt++] = sym;
+          else if (sym == 256) {
+            lpos = pos, lm = void 0;
+            break;
+          } else {
+            let add = sym - 254;
+            if (sym > 264) {
+              const i = sym - 257, b = fleb[i];
+              add = bits(dat, pos, (1 << b) - 1) + fl[i];
+              pos += b;
+            }
+            const d = dm[bits16(dat, pos) & dms], dsym = d >>> 4;
+            if (!d) err(3);
+            pos += d & 15;
+            let dt = fd[dsym];
+            if (dsym > 3) {
+              const b = fdeb[dsym];
+              dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+            }
+            if (pos > tbts) {
+              if (noSt) err(0);
+              break;
+            }
+            if (noBuf) cbuf(bt + 131072);
+            const end = bt + add;
+            for (; bt < end; bt += 4) {
+              buf[bt] = buf[bt - dt];
+              buf[bt + 1] = buf[bt + 1 - dt];
+              buf[bt + 2] = buf[bt + 2 - dt];
+              buf[bt + 3] = buf[bt + 3 - dt];
+            }
+            bt = end;
           }
-          yield* chunks.splice(0);
         }
-        const result = processor.push(new Uint8Array(0), true);
-        if (result === false) {
-          throw new Error(`${this.name}: streaming processor rejected the final batch`);
-        }
-        yield* chunks;
-      }
+        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 ? buf : slc(buf, 0, bt);
     };
-  }
-});
-
-// ../compression/src/lib/gzip-compression.ts
-var gzip_compression_exports = {};
-__export(gzip_compression_exports, {
-  GZipCompression: () => GZipCompression
-});
-var GZipCompression;
-var init_gzip_compression = __esm({
-  "../compression/src/lib/gzip-compression.ts"() {
-    "use strict";
-    init_deflate_compression();
-    GZipCompression = class extends DeflateCompression {
-      name = "gzip";
-      extensions = ["gz", "gzip"];
-      contentEncodings = ["gzip", "x-gzip"];
-      isSupported = true;
-      constructor(options) {
-        var _a;
-        super({
-          ...options,
-          deflate: {
-            ...options == null ? void 0 : options.gzip,
-            gzip: true,
-            useNative: (options == null ? void 0 : options.useNative) ?? ((_a = options == null ? void 0 : options.gzip) == null ? void 0 : _a.useNative)
-          }
-        });
-      }
+    gzs = (d) => {
+      if (d[0] != 31 || d[1] != 139 || d[2] != 8) err(6, "invalid gzip data");
+      const flg = d[3];
+      let st = 10;
+      if (flg & 4) st += d[10] | (d[11] << 8) + 2;
+      for (let zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++]) ;
+      return st + (flg & 2);
     };
-  }
-});
-
-// ../compression/src/lib/no-compression.ts
-var no_compression_exports = {};
-__export(no_compression_exports, {
-  NoCompression: () => NoCompression
-});
-var NoCompression;
-var init_no_compression = __esm({
-  "../compression/src/lib/no-compression.ts"() {
-    "use strict";
-    init_compression();
-    NoCompression = class extends Compression {
-      name = "uncompressed";
-      extensions = [];
-      contentEncodings = [];
-      isSupported = true;
-      options;
-      constructor(options) {
-        super(options);
-        this.options = options || {};
-      }
-      compressSync(input) {
-        return input;
-      }
-      decompressSync(input) {
-        return input;
-      }
-      async *compressBatches(asyncIterator) {
-        return yield* asyncIterator;
-      }
-      async *decompressBatches(asyncIterator) {
-        return yield* asyncIterator;
-      }
+    gzl = (d) => {
+      const l = d.length;
+      return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
     };
-  }
-});
-
-// ../compression/src/lib/native-decompressor.ts
-var native_decompressor_exports = {};
-__export(native_decompressor_exports, {
-  NativeDecompressor: () => NativeDecompressor
-});
-var NativeDecompressor;
-var init_native_decompressor = __esm({
-  "../compression/src/lib/native-decompressor.ts"() {
-    "use strict";
-    init_compression();
-    init_decompression_stream();
-    NativeDecompressor = class extends Decompressor {
-      name;
-      extensions;
-      contentEncodings;
-      isSupported = true;
-      /** Runtime stream format used for every operation. */
-      format;
-      constructor(metadata, format, options = {}) {
-        super(options);
-        this.name = metadata.name;
-        this.extensions = [...metadata.extensions];
-        this.contentEncodings = [...metadata.contentEncodings];
-        this.format = format;
+    zlv = (d) => {
+      if ((d[0] & 15) != 8 || d[0] >>> 4 > 7 || (d[0] << 8 | d[1]) % 31) err(6, "invalid zlib data");
+      if (d[1] & 32) err(6, "invalid zlib data: preset dictionaries not supported");
+    };
+    Inflate = class {
+      /**
+       * Creates an inflation stream
+       * @param cb The callback to call whenever data is inflated
+       */
+      constructor(cb) {
+        this.ondata = cb;
       }
-      /** Decompresses one buffer with the runtime-provided stream. */
-      async decompress(input) {
-        const output = await decompressWithNativeDecompressionStream(input, this.format);
-        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
-        return output;
+      /** Persistent bit-reader and Huffman decoding state. */
+      s = {};
+      /** Compression options or retained output window for this stream. */
+      o;
+      /** Compressed bytes pending decoding. */
+      p = new u8(0);
+      /** Whether the stream has received its final chunk. */
+      d;
+      /**
+       * The handler to call whenever data is available
+       */
+      ondata;
+      /** Appends pending input after checking stream lifecycle. */
+      e(c) {
+        if (!this.ondata) err(5);
+        if (this.d) err(4);
+        const l = this.p.length;
+        const n = new u8(l + c.length);
+        n.set(this.p), n.set(c, l), this.p = n;
       }
-      /** Decompresses batches incrementally with the runtime-provided stream. */
-      async *decompressBatches(inputBatches) {
-        const output = decompressBatchesWithNativeDecompressionStream(inputBatches, this.format);
-        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
-        yield* output;
+      /** Decodes pending input and retains the sliding window. */
+      c(final) {
+        this.d = this.s.i = final || false;
+        const bts = this.s.b;
+        const dt = inflt(this.p, this.o, this.s);
+        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;
+      }
+      /**
+       * Pushes a chunk to be inflated
+       * @param chunk The chunk to push
+       * @param final Whether this is the final chunk
+       */
+      push(chunk, final) {
+        this.e(chunk), this.c(final);
       }
     };
-  }
-});
-
-// ../compression/src/lib/lazy-compression.ts
-function mergeModules(options, modules) {
-  return { ...options, modules: { ...options.modules, ...modules } };
-}
-var LazyDecompressor;
-var init_lazy_compression = __esm({
-  "../compression/src/lib/lazy-compression.ts"() {
-    "use strict";
-    init_compression();
-    init_decompression_stream();
-    LazyDecompressor = class extends Decompressor {
-      name;
-      extensions;
-      contentEncodings;
-      isSupported = true;
-      /** Constructor options retained until a concrete implementation is selected. */
-      options;
-      /** Built-in stream format to probe, or null when the format has no built-in path. */
-      nativeFormat;
-      /** Returns whether built-in selection remains eligible for the merged preload options. */
-      shouldUseNative;
-      /** Dynamically imports the balanced fallback constructor. */
-      loadFallback;
-      /** Selected concrete implementation after preload completes. */
-      implementation = null;
-      /** Shared in-flight selection used by concurrent asynchronous calls. */
-      implementationPromise = null;
-      constructor(metadata, loadFallback, options = {}, nativeFormat = null, shouldUseNative = () => true) {
-        super(options);
-        this.name = metadata.name;
-        this.extensions = [...metadata.extensions];
-        this.contentEncodings = [...metadata.contentEncodings];
-        this.options = options;
-        this.nativeFormat = nativeFormat;
-        this.shouldUseNative = shouldUseNative;
-        this.loadFallback = loadFallback;
+    Gunzip = class extends Inflate {
+      /** Whether the stream header still needs to be emitted or consumed. */
+      v = 1;
+      /**
+       * Creates a GUNZIP stream
+       * @param cb The callback to call whenever data is inflated
+       */
+      constructor(cb) {
+        super(cb);
       }
-      /** Selects and returns the built-in or dynamically imported fallback decompressor. */
-      async preload(modules = {}) {
-        if (this.implementation) return this.implementation;
-        const options = mergeModules(this.options, modules);
-        this.implementationPromise ||= this.loadImplementation(options);
-        try {
-          this.implementation = await this.implementationPromise;
-          return this.implementation;
-        } catch (error) {
-          this.implementationPromise = null;
-          throw error;
+      /**
+       * Pushes a chunk to be GUNZIPped
+       * @param chunk The chunk to push
+       * @param final Whether this is the last chunk
+       */
+      push(chunk, final) {
+        Inflate.prototype.e.call(this, chunk);
+        if (this.v) {
+          const s = this.p.length > 3 ? gzs(this.p) : 4;
+          if (s >= this.p.length && !final) return;
+          this.p = this.p.subarray(s), this.v = 0;
         }
-      }
-      /** Loads the selected concrete decompressor. */
-      async loadImplementation(options) {
-        if (options.useNative !== false && this.nativeFormat && this.shouldUseNative(options) && isNativeDecompressionSupported(this.nativeFormat)) {
-          const { NativeDecompressor: NativeDecompressor2 } = await Promise.resolve().then(() => (init_native_decompressor(), native_decompressor_exports));
-          return new NativeDecompressor2(this, this.nativeFormat, options);
+        if (final) {
+          if (this.p.length < 8) err(6, "invalid gzip data");
+          this.p = this.p.subarray(0, -8);
         }
-        const Decompressor2 = await this.loadFallback();
-        const implementation = new Decompressor2({ ...options, useNative: false });
-        await implementation.preload(options.modules);
-        return implementation;
+        Inflate.prototype.c.call(this, final);
       }
-      /** Decompresses after lazily selecting the default implementation. */
-      async decompress(input, size) {
-        return (await this.preload()).decompress(input, size);
+    };
+    Unzlib = class extends Inflate {
+      /** Whether the stream header still needs to be emitted or consumed. */
+      v = 1;
+      /**
+       * Creates a Zlib decompression stream
+       * @param cb The callback to call whenever data is inflated
+       */
+      constructor(cb) {
+        super(cb);
       }
-      /** Decompresses synchronously after an implementation has been preloaded. */
-      decompressSync(input, size) {
-        if (!this.implementation) {
-          throw new Error(`${this.name}: call preload() before decompressSync()`);
+      /**
+       * Pushes a chunk to be unzlibbed
+       * @param chunk The chunk to push
+       * @param final Whether this is the last chunk
+       */
+      push(chunk, final) {
+        Inflate.prototype.e.call(this, chunk);
+        if (this.v) {
+          if (this.p.length < 2 && !final) return;
+          this.p = this.p.subarray(2), this.v = 0;
         }
-        return this.implementation.decompressSync(input, size);
-      }
-      /** Decompresses batches after lazily selecting the default implementation. */
-      async *decompressBatches(inputBatches) {
-        yield* (await this.preload()).decompressBatches(inputBatches);
+        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);
       }
     };
   }
@@ -4736,6 +4096,79 @@ var init_fflate_stream = __esm({
   }
 });
 
+// ../compression/src/deflate-decompressor-fflate.ts
+var DeflateFflateDecompressor;
+var init_deflate_decompressor_fflate = __esm({
+  "../compression/src/deflate-decompressor-fflate.ts"() {
+    "use strict";
+    init_fflate();
+    init_compression();
+    init_fflate_stream();
+    DeflateFflateDecompressor = class extends Decompressor {
+      name = "deflate";
+      extensions = [];
+      contentEncodings = ["deflate"];
+      isSupported = true;
+      options;
+      constructor(options = {}) {
+        super(options);
+        this.options = options;
+      }
+      /** Decompresses one zlib-wrapped DEFLATE payload synchronously. */
+      decompressSync(input) {
+        const bytes = new Uint8Array(input);
+        const output = this.options.raw ? inflateSync(bytes) : unzlibSync(bytes);
+        return output.slice().buffer;
+      }
+      /** Decompresses DEFLATE batches incrementally. */
+      async *decompressBatches(inputBatches) {
+        const processor = this.options.raw ? new Inflate() : new Unzlib();
+        yield* transformFflateBatches(processor, inputBatches);
+      }
+    };
+  }
+});
+
+// ../compression/src/deflate-decompressor.ts
+var deflate_decompressor_exports = {};
+__export(deflate_decompressor_exports, {
+  DeflateDecompressor: () => DeflateDecompressor
+});
+var DeflateDecompressor;
+var init_deflate_decompressor = __esm({
+  "../compression/src/deflate-decompressor.ts"() {
+    "use strict";
+    init_deflate_decompressor_fflate();
+    init_decompression_stream();
+    DeflateDecompressor = class extends DeflateFflateDecompressor {
+      constructor(options = {}) {
+        super(options);
+      }
+      /** Decompresses with the built-in stream when available, then falls back to fflate. */
+      async decompress(input) {
+        if (this.options.useNative !== false) {
+          const format = this.options.raw ? "deflate-raw" : "deflate";
+          const output = await decompressWithNativeDecompressionStream(input, format);
+          if (output) return output;
+        }
+        return this.decompressSync(input);
+      }
+      /** Decompresses batches with a built-in or fflate stream. */
+      async *decompressBatches(inputBatches) {
+        if (this.options.useNative !== false) {
+          const format = this.options.raw ? "deflate-raw" : "deflate";
+          const output = decompressBatchesWithNativeDecompressionStream(inputBatches, format);
+          if (output) {
+            yield* output;
+            return;
+          }
+        }
+        yield* super.decompressBatches(inputBatches);
+      }
+    };
+  }
+});
+
 // ../compression/src/gzip-decompressor-fflate.ts
 var GZipFflateDecompressor;
 var init_gzip_decompressor_fflate = __esm({
@@ -6890,13 +6323,13 @@ var brotli_compression_exports = {};
 __export(brotli_compression_exports, {
   BrotliCompression: () => BrotliCompression
 });
-var import_zlib2, DEFAULT_BROTLI_OPTIONS, BrotliCompression;
+var import_zlib, DEFAULT_BROTLI_OPTIONS, BrotliCompression;
 var init_brotli_compression = __esm({
   "../compression/src/lib/brotli-compression.ts"() {
     "use strict";
     init_compression();
     init_src2();
-    import_zlib2 = __toESM(require("zlib"), 1);
+    import_zlib = __toESM(require("zlib"), 1);
     init_compression_stream();
     init_decompression_stream();
     DEFAULT_BROTLI_OPTIONS = {
@@ -6940,7 +6373,7 @@ var init_brotli_compression = __esm({
         const nativeOutput = await compressWithNativeCompressionStream(input, "brotli");
         if (nativeOutput) return nativeOutput;
         if (!isBrowser && ((_a = this.options.brotli) == null ? void 0 : _a.useZlib)) {
-          const buffer = await promisify1(import_zlib2.default.brotliCompress)(input);
+          const buffer = await promisify1(import_zlib.default.brotliCompress)(input);
           return toArrayBuffer2(buffer);
         }
         return this.compressSync(input);
@@ -6948,7 +6381,7 @@ var init_brotli_compression = __esm({
       compressSync(input) {
         var _a, _b;
         if (!isBrowser && ((_a = this.options.brotli) == null ? void 0 : _a.useZlib)) {
-          const buffer = import_zlib2.default.brotliCompressSync(input);
+          const buffer = import_zlib.default.brotliCompressSync(input);
           return toArrayBuffer2(buffer);
         }
         const brotliOptions = { ...DEFAULT_BROTLI_OPTIONS.brotli, ...(_b = this.options) == null ? void 0 : _b.brotli };
@@ -6967,7 +6400,7 @@ var init_brotli_compression = __esm({
           if (nativeOutput) return nativeOutput;
         }
         if (!isBrowser && ((_a = this.options.brotli) == null ? void 0 : _a.useZlib)) {
-          const buffer = await promisify1(import_zlib2.default.brotliDecompress)(input);
+          const buffer = await promisify1(import_zlib.default.brotliDecompress)(input);
           return toArrayBuffer2(buffer);
         }
         await this.preload();
@@ -6976,7 +6409,7 @@ var init_brotli_compression = __esm({
       decompressSync(input) {
         var _a, _b;
         if (!isBrowser && ((_a = this.options.brotli) == null ? void 0 : _a.useZlib)) {
-          const buffer = import_zlib2.default.brotliDecompressSync(input);
+          const buffer = import_zlib.default.brotliDecompressSync(input);
           return toArrayBuffer2(buffer);
         }
         const brotliOptions = { ...DEFAULT_BROTLI_OPTIONS.brotli, ...(_b = this.options) == null ? void 0 : _b.brotli };
@@ -7122,10 +6555,6 @@ var init_snappy_decompressor = __esm({
 });
 
 // ../compression/src/lib/lz4-compression.ts
-var lz4_compression_exports = {};
-__export(lz4_compression_exports, {
-  LZ4Compression: () => LZ4Compression
-});
 function readUInt32BE(data, offset) {
   return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
 }
@@ -7528,18 +6957,150 @@ var init_zstd_decompressor = __esm({
   }
 });
 
+// ../compression/src/lib/compress-utils-compression.ts
+async function* transformBatches2(stream, inputBatches) {
+  try {
+    for await (const input of inputBatches) {
+      const output2 = stream.write(new Uint8Array(input));
+      if (output2.byteLength > 0) yield copyArrayBuffer(output2);
+    }
+    const output = stream.finish();
+    if (output.byteLength > 0) yield copyArrayBuffer(output);
+  } finally {
+    stream.destroy();
+  }
+}
+function copyArrayBuffer(bytes) {
+  return bytes.slice().buffer;
+}
+var CompressUtilsDecompressor;
+var init_compress_utils_compression = __esm({
+  "../compression/src/lib/compress-utils-compression.ts"() {
+    "use strict";
+    init_compression();
+    CompressUtilsDecompressor = class extends Decompressor {
+      name;
+      extensions;
+      contentEncodings;
+      isSupported = true;
+      options;
+      loadModule;
+      /** Creates a format-specific compress-utils decoder. */
+      constructor(metadata, loadModule, options = {}) {
+        super(options);
+        this.name = metadata.name;
+        this.extensions = metadata.extensions || [];
+        this.contentEncodings = metadata.contentEncodings || [];
+        this.loadModule = loadModule;
+        this.options = options;
+      }
+      /** Decompresses one buffer with the selected compress-utils decoder. */
+      async decompress(input) {
+        const module2 = await this.loadModule();
+        const output = await module2.decompress(new Uint8Array(input), this.options.compressUtils);
+        return copyArrayBuffer(output);
+      }
+      /** Incrementally decompresses input batches with compress-utils. */
+      async *decompressBatches(inputBatches) {
+        const module2 = await this.loadModule();
+        const stream = await module2.createDecompressStream();
+        yield* transformBatches2(stream, inputBatches);
+      }
+    };
+  }
+});
+
+// ../compression/src/bzip2-decompressor-compress-utils.ts
+var BZip2CompressUtilsDecompressor;
+var init_bzip2_decompressor_compress_utils = __esm({
+  "../compression/src/bzip2-decompressor-compress-utils.ts"() {
+    "use strict";
+    init_compress_utils_compression();
+    BZip2CompressUtilsDecompressor = class extends CompressUtilsDecompressor {
+      constructor(options = {}) {
+        super(
+          { name: "bzip2", extensions: ["bz2"], contentEncodings: ["bzip2"] },
+          () => import("compress-utils/bz2/decompress"),
+          options
+        );
+      }
+    };
+  }
+});
+
+// ../compression/src/bzip2-decompressor.ts
+var bzip2_decompressor_exports = {};
+__export(bzip2_decompressor_exports, {
+  BZip2Decompressor: () => BZip2Decompressor
+});
+var BZip2Decompressor;
+var init_bzip2_decompressor = __esm({
+  "../compression/src/bzip2-decompressor.ts"() {
+    "use strict";
+    init_bzip2_decompressor_compress_utils();
+    BZip2Decompressor = class extends BZip2CompressUtilsDecompressor {
+    };
+  }
+});
+
+// ../compression/src/xz-decompressor-compress-utils.ts
+var XZCompressUtilsDecompressor;
+var init_xz_decompressor_compress_utils = __esm({
+  "../compression/src/xz-decompressor-compress-utils.ts"() {
+    "use strict";
+    init_compress_utils_compression();
+    XZCompressUtilsDecompressor = class extends CompressUtilsDecompressor {
+      constructor(options = {}) {
+        super(
+          { name: "xz", extensions: ["xz", "lzma"], contentEncodings: ["xz"] },
+          () => import("compress-utils/xz/decompress"),
+          options
+        );
+      }
+    };
+  }
+});
+
+// ../compression/src/xz-decompressor.ts
+var xz_decompressor_exports = {};
+__export(xz_decompressor_exports, {
+  XZDecompressor: () => XZDecompressor
+});
+var XZDecompressor;
+var init_xz_decompressor = __esm({
+  "../compression/src/xz-decompressor.ts"() {
+    "use strict";
+    init_xz_decompressor_compress_utils();
+    XZDecompressor = class extends XZCompressUtilsDecompressor {
+    };
+  }
+});
+
 // ../compression/src/default-codecs.ts
-var GZIP, BROTLI, SNAPPY, LZ4, ZSTD, GZipDecompressor2, BrotliDecompressor2, SnappyDecompressor2, LZ4Decompressor2, ZstdDecompressor2;
+var DEFLATE, GZIP, BROTLI, SNAPPY, LZ4, ZSTD, BZIP2, XZ, DeflateDecompressor2, GZipDecompressor2, BrotliDecompressor2, SnappyDecompressor2, LZ4Decompressor2, ZstdDecompressor2, BZip2Decompressor2, XZDecompressor2;
 var init_default_codecs = __esm({
   "../compression/src/default-codecs.ts"() {
     "use strict";
     init_lazy_compression();
     init_src2();
+    DEFLATE = { name: "deflate", extensions: [], contentEncodings: ["deflate"] };
     GZIP = { name: "gzip", extensions: ["gz"], contentEncodings: ["gzip"] };
     BROTLI = { name: "brotli", extensions: ["br"], contentEncodings: ["br"] };
     SNAPPY = { name: "snappy", extensions: [], contentEncodings: [] };
     LZ4 = { name: "lz4", extensions: ["lz4"], contentEncodings: ["x-lz4"] };
     ZSTD = { name: "zstd", extensions: ["zst"], contentEncodings: ["zstd"] };
+    BZIP2 = { name: "bzip2", extensions: ["bz2"], contentEncodings: ["bzip2"] };
+    XZ = { name: "xz", extensions: ["xz", "lzma"], contentEncodings: ["xz"] };
+    DeflateDecompressor2 = class extends LazyDecompressor {
+      constructor(options = {}) {
+        super(
+          DEFLATE,
+          async () => (await Promise.resolve().then(() => (init_deflate_decompressor(), deflate_decompressor_exports))).DeflateDecompressor,
+          options,
+          options.raw ? "deflate-raw" : "deflate"
+        );
+      }
+    };
     GZipDecompressor2 = class extends LazyDecompressor {
       constructor(options = {}) {
         super(
@@ -7588,237 +7149,25 @@ var init_default_codecs = __esm({
         );
       }
     };
-  }
-});
-
-// ../compression/src/lib/snappy-compression.ts
-var snappy_compression_exports = {};
-__export(snappy_compression_exports, {
-  SnappyCompression: () => SnappyCompression
-});
-var SnappyCompression;
-var init_snappy_compression = __esm({
-  "../compression/src/lib/snappy-compression.ts"() {
-    "use strict";
-    init_compression();
-    init_src2();
-    SnappyCompression = class extends Compression {
-      name = "snappy";
-      extensions = [];
-      contentEncodings = [];
-      isSupported = true;
-      options;
-      constructor(options) {
-        super(options);
-        this.options = options || {};
-        registerJSModules(this.options.modules);
-      }
-      compressSync(input) {
-        const snappy = getJSModule("snappyjs", this.name);
-        return snappy.compress(input);
-      }
-      decompressSync(input) {
-        const snappy = getJSModule("snappyjs", this.name);
-        return snappy.uncompress(input);
-      }
-      async preload(modules = {}) {
-        registerJSModules(modules);
-        if (!getJSModuleOrNull("snappyjs")) {
-          const snappy = await import("snappyjs");
-          registerJSModules({ snappyjs: snappy.default || snappy });
-        }
-      }
-    };
-  }
-});
-
-// ../compression/src/lib/bzip2-compression.ts
-var bzip2_compression_exports = {};
-__export(bzip2_compression_exports, {
-  BZip2Compression: () => BZip2Compression
-});
-var BZip2Compression;
-var init_bzip2_compression = __esm({
-  "../compression/src/lib/bzip2-compression.ts"() {
-    "use strict";
-    init_compression();
-    BZip2Compression = class extends Compression {
-      name = "bzip2";
-      extensions = ["bz2"];
-      contentEncodings = ["bzip2"];
-      isSupported = true;
-      options;
+    BZip2Decompressor2 = class extends LazyDecompressor {
       constructor(options = {}) {
-        super(options);
-        this.options = options;
-      }
-      /** Decompresses a bzip2 stream. */
-      async decompress(input) {
-        let decompress4;
-        try {
-          ({ decompress: decompress4 } = await import("compress-utils/bz2/decompress"));
-        } catch (error) {
-          throw new Error(
-            "BZip2Compression requires the optional compress-utils package. Install compress-utils to decode bzip2 data.",
-            { cause: error }
-          );
-        }
-        const output = await decompress4(new Uint8Array(input));
-        return output.slice().buffer;
-      }
-      /** Compresses a bzip2 stream. */
-      async compress(input) {
-        let compress;
-        try {
-          ({ compress } = await import("compress-utils/bz2/compress"));
-        } catch (error) {
-          throw new Error(
-            "BZip2Compression requires the optional compress-utils package. Install compress-utils to encode bzip2 data.",
-            { cause: error }
-          );
-        }
-        const output = await compress(new Uint8Array(input));
-        return output.slice().buffer;
+        super(BZIP2, async () => (await Promise.resolve().then(() => (init_bzip2_decompressor(), bzip2_decompressor_exports))).BZip2Decompressor, options);
       }
     };
-  }
-});
-
-// ../compression/src/lib/xz-compression.ts
-var xz_compression_exports = {};
-__export(xz_compression_exports, {
-  XZCompression: () => XZCompression
-});
-var XZCompression;
-var init_xz_compression = __esm({
-  "../compression/src/lib/xz-compression.ts"() {
-    "use strict";
-    init_compression();
-    XZCompression = class extends Compression {
-      name = "xz";
-      extensions = ["xz", "lzma"];
-      contentEncodings = ["xz"];
-      isSupported = true;
-      options;
+    XZDecompressor2 = class extends LazyDecompressor {
       constructor(options = {}) {
-        super(options);
-        this.options = options;
-      }
-      /** Decompresses an XZ stream. */
-      async decompress(input) {
-        let decompress4;
-        try {
-          ({ decompress: decompress4 } = await import("compress-utils/xz/decompress"));
-        } catch (error) {
-          throw new Error(
-            "XZCompression requires the optional compress-utils package. Install compress-utils to decode XZ data.",
-            { cause: error }
-          );
-        }
-        const output = await decompress4(new Uint8Array(input));
-        return output.slice().buffer;
-      }
-      /** Compresses an XZ stream. */
-      async compress(input) {
-        let compress;
-        try {
-          ({ compress } = await import("compress-utils/xz/compress"));
-        } catch (error) {
-          throw new Error(
-            "XZCompression requires the optional compress-utils package. Install compress-utils to encode XZ data.",
-            { cause: error }
-          );
-        }
-        const output = await compress(new Uint8Array(input));
-        return output.slice().buffer;
+        super(XZ, async () => (await Promise.resolve().then(() => (init_xz_decompressor(), xz_decompressor_exports))).XZDecompressor, options);
       }
     };
   }
 });
 
-// ../compression/src/compression-metadata.ts
-function createCompressionMetadata(name, extensions, contentEncodings, loadCompression) {
-  return {
-    name,
-    extensions,
-    contentEncodings,
-    isSupported: true,
-    async preload(options = {}) {
-      const CompressionConstructor = await loadCompression();
-      const compression = new CompressionConstructor(options);
-      await compression.preload(options.modules);
-      return compression;
-    }
-  };
-}
-var noCompression, deflateCompression, gzipCompression, brotliCompression, snappyCompression, lz4Compression, zstdCompression, bzip2Compression, xzCompression;
-var init_compression_metadata = __esm({
-  "../compression/src/compression-metadata.ts"() {
-    "use strict";
-    noCompression = createCompressionMetadata(
-      "uncompressed",
-      [],
-      [],
-      async () => (await Promise.resolve().then(() => (init_no_compression(), no_compression_exports))).NoCompression
-    );
-    deflateCompression = createCompressionMetadata(
-      "deflate",
-      [],
-      ["deflate"],
-      async () => (await Promise.resolve().then(() => (init_deflate_compression(), deflate_compression_exports))).DeflateCompression
-    );
-    gzipCompression = createCompressionMetadata(
-      "gzip",
-      ["gz"],
-      ["gzip"],
-      async () => (await Promise.resolve().then(() => (init_gzip_compression(), gzip_compression_exports))).GZipCompression
-    );
-    brotliCompression = createCompressionMetadata(
-      "brotli",
-      ["br"],
-      ["br"],
-      async () => (await Promise.resolve().then(() => (init_brotli_compression(), brotli_compression_exports))).BrotliCompression
-    );
-    snappyCompression = createCompressionMetadata(
-      "snappy",
-      [],
-      [],
-      async () => (await Promise.resolve().then(() => (init_snappy_compression(), snappy_compression_exports))).SnappyCompression
-    );
-    lz4Compression = createCompressionMetadata(
-      "lz4",
-      [],
-      [],
-      async () => (await Promise.resolve().then(() => (init_lz4_compression(), lz4_compression_exports))).LZ4Compression
-    );
-    zstdCompression = createCompressionMetadata(
-      "zstd",
-      [],
-      [],
-      async () => (await Promise.resolve().then(() => (init_zstd_compression(), zstd_compression_exports))).ZstdCompression
-    );
-    bzip2Compression = createCompressionMetadata(
-      "bzip2",
-      ["bz2"],
-      ["bzip2"],
-      async () => (await Promise.resolve().then(() => (init_bzip2_compression(), bzip2_compression_exports))).BZip2Compression
-    );
-    xzCompression = createCompressionMetadata(
-      "xz",
-      ["xz", "lzma"],
-      ["xz"],
-      async () => (await Promise.resolve().then(() => (init_xz_compression(), xz_compression_exports))).XZCompression
-    );
-  }
-});
-
 // ../compression/src/index.ts
 var init_src3 = __esm({
   "../compression/src/index.ts"() {
     "use strict";
     init_compression();
     init_default_codecs();
-    init_compression_metadata();
   }
 });
 
@@ -25606,11 +24955,11 @@ function toUint8Array(binary) {
 function toArrayBuffer3(binary) {
   return toUint8Array(binary).slice().buffer;
 }
-var compressionPromises = {};
+var decompressors = {};
 async function decompressAvro(codec, value) {
   if (codec === "null") return value;
   if (!isAvroCodec(codec)) throw new Error(`avro: unsupported compression codec "${codec}"`);
-  const compression = await getAvroCompression(codec);
+  const compression = getAvroDecompressor(codec);
   const compressedValue = codec === "snappy" ? value.subarray(0, -4) : value;
   const output = toUint8Array(await compression.decompress(toArrayBuffer3(compressedValue)));
   if (codec === "snappy") {
@@ -25623,22 +24972,16 @@ async function decompressAvro(codec, value) {
 function isAvroCodec(codec) {
   return codec === "deflate" || codec === "snappy" || codec === "zstandard" || codec === "bzip2" || codec === "xz";
 }
-async function getAvroCompression(codec) {
-  compressionPromises[codec] ||= createAvroCompression(codec);
-  return await compressionPromises[codec];
-}
-async function createAvroCompression(codec) {
-  const metadata = {
-    deflate: deflateCompression,
-    snappy: snappyCompression,
-    zstandard: zstdCompression,
-    bzip2: bzip2Compression,
-    xz: xzCompression
-  }[codec];
-  if (metadata) {
-    return await metadata.preload(codec === "deflate" ? { raw: true } : {});
-  }
-  throw new Error(`avro: unsupported compression codec "${codec}"`);
+function getAvroDecompressor(codec) {
+  const constructors = {
+    deflate: DeflateDecompressor2,
+    snappy: SnappyDecompressor2,
+    zstandard: ZstdDecompressor2,
+    bzip2: BZip2Decompressor2,
+    xz: XZDecompressor2
+  };
+  decompressors[codec] ||= new constructors[codec](codec === "deflate" ? { raw: true } : {});
+  return decompressors[codec];
 }
 function readUInt32BE2(bytes, offset) {
   return bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3];