@loaders.gl/splats 5.0.0-alpha.10 → 5.0.0-alpha.12

package/dist/index.cjs

@@ -5,12 +5,12 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res, err2) => function __init() {
-  if (err2) throw err2[0];
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
   try {
     return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
   } catch (e) {
-    throw err2 = [e], e;
+    throw err = [e], e;
   }
 };
 var __export = (target, all) => {
@@ -103,13 +103,12 @@ var init_log = __esm({
 });
 
 // ../loader-utils/src/lib/javascript-utils/is-type.ts
-var isObject, isPureObject, isSharedArrayBuffer;
+var isObject, isPureObject;
 var init_is_type = __esm({
   "../loader-utils/src/lib/javascript-utils/is-type.ts"() {
     "use strict";
     isObject = (value) => value !== null && typeof value === "object";
     isPureObject = (value) => isObject(value) && value.constructor === {}.constructor;
-    isSharedArrayBuffer = (value) => typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer;
   }
 });
 
@@ -148,19 +147,6 @@ function registerJSModules(modules) {
   globalThis.loaders.modules ||= {};
   Object.assign(globalThis.loaders.modules, modules);
 }
-function getJSModule(name, caller) {
-  var _a, _b;
-  const module2 = (_b = (_a = globalThis.loaders) == null ? void 0 : _a.modules) == null ? void 0 : _b[name];
-  if (!module2) {
-    throw new Error(`${caller}: ${name} library not installed`);
-  }
-  return module2;
-}
-function getJSModuleOrNull(name) {
-  var _a, _b;
-  const module2 = (_b = (_a = globalThis.loaders) == null ? void 0 : _a.modules) == null ? void 0 : _b[name];
-  return module2 || null;
-}
 var init_js_module_utils = __esm({
   "../loader-utils/src/lib/module-utils/js-module-utils.ts"() {
     "use strict";
@@ -523,33 +509,6 @@ var init_file_aliases = __esm({
   }
 });
 
-// ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
-function ensureArrayBuffer(bufferSource) {
-  if (bufferSource instanceof ArrayBuffer) {
-    return bufferSource;
-  }
-  if (isSharedArrayBuffer(bufferSource)) {
-    return copyToArrayBuffer2(bufferSource);
-  }
-  const { buffer, byteOffset, byteLength } = bufferSource;
-  if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {
-    return buffer;
-  }
-  return copyToArrayBuffer2(buffer, byteOffset, byteLength);
-}
-function copyToArrayBuffer2(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
-  const view = new Uint8Array(buffer, byteOffset, byteLength);
-  const copy = new Uint8Array(view.length);
-  copy.set(view);
-  return copy.buffer;
-}
-var init_memory_conversion_utils = __esm({
-  "../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts"() {
-    "use strict";
-    init_is_type();
-  }
-});
-
 // ../loader-utils/src/lib/sources/data-source.ts
 function getFetchFunction(options) {
   return getAuthenticatedFetch(options);
@@ -698,15 +657,13 @@ var init_src = __esm({
   "../loader-utils/src/index.ts"() {
     "use strict";
     init_js_module_utils();
-    init_js_module_utils();
     init_async_iteration();
-    init_memory_conversion_utils();
     init_data_source();
   }
 });
 
 // ../compression/src/lib/compression.ts
-var CompressionTransform, Compressor, Decompressor, Compression;
+var CompressionTransform, Decompressor;
 var init_compression = __esm({
   "../compression/src/lib/compression.ts"() {
     "use strict";
@@ -728,26 +685,6 @@ var init_compression = __esm({
         return error;
       }
     };
-    Compressor = class extends CompressionTransform {
-      constructor(options) {
-        super();
-        this.compressBatches = this.compressBatches.bind(this);
-      }
-      /** Asynchronously compresses data. */
-      async compress(input) {
-        await this.preload();
-        return this.compressSync(input);
-      }
-      /** Synchronously compresses data. */
-      compressSync(input) {
-        throw new Error(`${this.name}: sync compression not supported`);
-      }
-      /** Compresses batches. */
-      async *compressBatches(asyncIterator) {
-        const input = await this.concatenate(asyncIterator);
-        yield this.compress(input);
-      }
-    };
     Decompressor = class extends CompressionTransform {
       constructor(options) {
         super();
@@ -768,558 +705,6 @@ var init_compression = __esm({
         yield this.decompress(input);
       }
     };
-    Compression = class extends Compressor {
-      constructor(options) {
-        super(options);
-        this.decompressBatches = this.decompressBatches.bind(this);
-      }
-      /** Asynchronously decompresses data. */
-      async decompress(input, size) {
-        await this.preload();
-        return this.decompressSync(input, size);
-      }
-      /** Synchronously decompresses data. */
-      decompressSync(input, size) {
-        throw new Error(`${this.name}: sync decompression not supported`);
-      }
-      /** Decompresses batches. */
-      async *decompressBatches(asyncIterator) {
-        const input = await this.concatenate(asyncIterator);
-        yield this.decompress(input);
-      }
-    };
-  }
-});
-
-// ../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];
-      }
-      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;
-    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;
-          }
-        }
-        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);
-    };
-    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;
-    };
-    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;
-      }
-      /** 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);
-      }
-    };
-    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);
-      }
-    };
-    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);
-  return outputBatches ? await concatenateBatches(outputBatches) : null;
-}
-function compressBatchesWithNativeCompressionStream(inputBatches, format) {
-  const compressionStream = createNativeCompressionStream(format);
-  return compressionStream ? transformBatches(inputBatches, compressionStream) : null;
-}
-function createNativeCompressionStream(format) {
-  if (typeof globalThis.CompressionStream === "undefined") {
-    return null;
-  }
-  try {
-    const CompressionStreamConstructor = globalThis.CompressionStream;
-    return new CompressionStreamConstructor(format);
-  } catch (error) {
-    if (error instanceof TypeError || (error == null ? void 0 : error.name) === "TypeError") {
-      return null;
-    }
-    throw error;
-  }
-}
-async function* transformBatches(inputBatches, compressionStream) {
-  const writer = compressionStream.writable.getWriter();
-  const reader = compressionStream.readable.getReader();
-  const writePromise = writeBatches(inputBatches, writer);
-  writePromise.catch(() => {
-  });
-  let outputCompleted = false;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        outputCompleted = true;
-        break;
-      }
-      yield new Uint8Array(value).buffer;
-    }
-    await writePromise;
-  } finally {
-    if (!outputCompleted) {
-      await reader.cancel().catch(() => {
-      });
-      await writer.abort().catch(() => {
-      });
-      await writePromise.catch(() => {
-      });
-    }
-    reader.releaseLock();
-  }
-}
-async function writeBatches(inputBatches, writer) {
-  try {
-    for await (const inputBatch of inputBatches) {
-      await writer.write(new Uint8Array(inputBatch));
-    }
-    await writer.close();
-  } catch (error) {
-    await writer.abort(error).catch(() => {
-    });
-    throw error;
-  }
-}
-async function concatenateBatches(batches) {
-  const output = [];
-  let byteLength = 0;
-  for await (const batch of batches) {
-    const bytes = new Uint8Array(batch);
-    output.push(bytes);
-    byteLength += bytes.byteLength;
-  }
-  const result = new Uint8Array(byteLength);
-  let offset = 0;
-  for (const batch of output) {
-    result.set(batch, offset);
-    offset += batch.byteLength;
-  }
-  return result.buffer;
-}
-var init_compression_stream = __esm({
-  "../compression/src/lib/compression-stream.ts"() {
-    "use strict";
   }
 });
 
@@ -1540,48 +925,121 @@ var init_lazy_compression = __esm({
   }
 });
 
-// ../compression/src/lib/fflate-stream.ts
-async function* transformFflateBatches(processor, inputBatches) {
-  const chunks = [];
-  processor.ondata = (data) => {
-    chunks.push(data.slice().buffer);
-  };
-  for await (const batch of inputBatches) {
-    processor.push(new Uint8Array(batch), false);
-    yield* chunks.splice(0);
+// ../compression/src/lib/compress-utils-compression.ts
+async function* transformBatches(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();
   }
-  processor.push(new Uint8Array(0), true);
-  yield* chunks;
 }
-var init_fflate_stream = __esm({
-  "../compression/src/lib/fflate-stream.ts"() {
-    "use strict";
-  }
-});
-
-// ../compression/src/gzip-decompressor-fflate.ts
-var GZipFflateDecompressor;
-var init_gzip_decompressor_fflate = __esm({
-  "../compression/src/gzip-decompressor-fflate.ts"() {
+function copyArrayBuffer(bytes) {
+  return bytes.slice().buffer;
+}
+function getDecompressOptions(options, size) {
+  const decodeOptions = {
+    ...options.compressUtils,
+    ...size === void 0 ? {} : { expectedSize: size }
+  };
+  const capacity = decodeOptions.expectedSize;
+  const maximum = options.maxOutputByteLength ?? 512 * 1024 * 1024;
+  if (!Number.isSafeInteger(maximum) || maximum < 0 || maximum > 2147483647)
+    throw new RangeError("Invalid maxOutputByteLength");
+  if (capacity !== void 0 && (!Number.isSafeInteger(capacity) || capacity < 0 || capacity > maximum)) {
+    throw new RangeError("expectedSize exceeds the configured output capacity limit");
+  }
+  return decodeOptions;
+}
+var CompressUtilsDecompressor;
+var init_compress_utils_compression = __esm({
+  "../compression/src/lib/compress-utils-compression.ts"() {
     "use strict";
-    init_fflate();
     init_compression();
-    init_fflate_stream();
-    GZipFflateDecompressor = class extends Decompressor {
-      name = "gzip";
-      extensions = ["gz", "gzip"];
-      contentEncodings = ["gzip", "x-gzip"];
+    CompressUtilsDecompressor = class extends Decompressor {
+      name;
+      extensions;
+      contentEncodings;
       isSupported = true;
-      constructor(options = {}) {
+      options;
+      loadModule;
+      /** Module initialized for synchronous operations. */
+      module = null;
+      /** Shared import and WASM initialization for concurrent callers. */
+      modulePromise = null;
+      /** 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 GZIP payload synchronously. */
-      decompressSync(input) {
-        return gunzipSync(new Uint8Array(input)).slice().buffer;
+      /** Imports and initializes the codec without loading the opposite direction. */
+      async preload(modules = {}) {
+        await super.preload(modules);
+        this.modulePromise ||= this.loadModule().then(async (module2) => {
+          var _a;
+          await ((_a = module2.preload) == null ? void 0 : _a.call(module2));
+          this.module = module2;
+        });
+        try {
+          await this.modulePromise;
+        } catch (error) {
+          this.modulePromise = null;
+          throw error;
+        }
+      }
+      /** Runs synchronously after preload has initialized the WASM codec. */
+      decompressSync(input, size) {
+        var _a;
+        if (!((_a = this.module) == null ? void 0 : _a.decompressSync))
+          throw new Error(`${this.name}: call preload() before decompressSync()`);
+        return copyArrayBuffer(
+          this.module.decompressSync(new Uint8Array(input), getDecompressOptions(this.options, size))
+        );
       }
-      /** Decompresses GZIP batches incrementally. */
+      /** Decompresses one buffer with the selected compress-utils decoder. */
+      async decompress(input, size) {
+        const decodeOptions = getDecompressOptions(this.options, size);
+        await this.preload();
+        const module2 = this.module;
+        const output = await module2.decompress(new Uint8Array(input), decodeOptions);
+        return copyArrayBuffer(output);
+      }
+      /** Incrementally decompresses input batches with compress-utils. */
       async *decompressBatches(inputBatches) {
-        yield* transformFflateBatches(new Gunzip(), inputBatches);
+        await this.preload();
+        const module2 = this.module;
+        if (!module2.createDecompressStream) {
+          yield await this.decompress(await this.concatenate(inputBatches));
+          return;
+        }
+        const stream = await module2.createDecompressStream();
+        yield* transformBatches(stream, inputBatches);
+      }
+    };
+  }
+});
+
+// ../compression/src/gzip-decompressor-compress-utils.ts
+var GZipCompressUtilsDecompressor;
+var init_gzip_decompressor_compress_utils = __esm({
+  "../compression/src/gzip-decompressor-compress-utils.ts"() {
+    "use strict";
+    init_compress_utils_compression();
+    GZipCompressUtilsDecompressor = class extends CompressUtilsDecompressor {
+      constructor(options = {}) {
+        super(
+          { name: "gzip", extensions: ["gz", "gzip"], contentEncodings: ["gzip", "x-gzip"] },
+          () => import("compress-utils/gzip/decompress"),
+          options
+        );
       }
     };
   }
@@ -1596,23 +1054,18 @@ var GZipDecompressor;
 var init_gzip_decompressor = __esm({
   "../compression/src/gzip-decompressor.ts"() {
     "use strict";
-    init_gzip_decompressor_fflate();
+    init_gzip_decompressor_compress_utils();
     init_decompression_stream();
-    GZipDecompressor = class extends GZipFflateDecompressor {
-      options;
-      constructor(options = {}) {
-        super(options);
-        this.options = options;
-      }
-      /** Decompresses with the built-in stream when available, then falls back to fflate. */
-      async decompress(input) {
+    GZipDecompressor = class extends GZipCompressUtilsDecompressor {
+      /** Decompresses with native streams when available, otherwise lazily initializes WASM. */
+      async decompress(input, size) {
         if (this.options.useNative !== false) {
           const output = await decompressWithNativeDecompressionStream(input, "gzip");
           if (output) return output;
         }
-        return this.decompressSync(input);
+        return super.decompress(input, size);
       }
-      /** Decompresses batches with a built-in or fflate stream. */
+      /** Streams native batches when available, otherwise uses the WASM stream. */
       async *decompressBatches(inputBatches) {
         if (this.options.useNative !== false) {
           const output = decompressBatchesWithNativeDecompressionStream(inputBatches, "gzip");
@@ -1627,126 +1080,19 @@ var init_gzip_decompressor = __esm({
   }
 });
 
-// ../compression/src/zstd-decompressor-fzstd.ts
-var import_fzstd, ZstdFzstdDecompressor;
-var init_zstd_decompressor_fzstd = __esm({
-  "../compression/src/zstd-decompressor-fzstd.ts"() {
+// ../compression/src/zstd-decompressor-compress-utils.ts
+var ZstdCompressUtilsDecompressor;
+var init_zstd_decompressor_compress_utils = __esm({
+  "../compression/src/zstd-decompressor-compress-utils.ts"() {
     "use strict";
-    init_compression();
-    import_fzstd = require("fzstd");
-    ZstdFzstdDecompressor = class extends Decompressor {
-      name = "zstd";
-      extensions = ["zst"];
-      contentEncodings = ["zstd"];
-      isSupported = true;
+    init_compress_utils_compression();
+    ZstdCompressUtilsDecompressor = class extends CompressUtilsDecompressor {
       constructor(options = {}) {
-        super(options);
-      }
-      /** Decompresses one Zstandard frame synchronously. */
-      decompressSync(input) {
-        return (0, import_fzstd.decompress)(new Uint8Array(input)).slice().buffer;
-      }
-    };
-  }
-});
-
-// ../compression/src/zstd-fallback.ts
-var zstd_fallback_exports = {};
-__export(zstd_fallback_exports, {
-  decompressZstd: () => decompressZstd
-});
-function decompressZstd(input) {
-  return (0, import_fzstd2.decompress)(input);
-}
-var import_fzstd2;
-var init_zstd_fallback = __esm({
-  "../compression/src/zstd-fallback.ts"() {
-    "use strict";
-    import_fzstd2 = require("fzstd");
-  }
-});
-
-// ../compression/src/lib/zstd-compression.ts
-var zstd_compression_exports = {};
-__export(zstd_compression_exports, {
-  ZstdCompression: () => ZstdCompression
-});
-var CHUNK_SIZE, zstdPromise, zstd, ZstdCompression;
-var init_zstd_compression = __esm({
-  "../compression/src/lib/zstd-compression.ts"() {
-    "use strict";
-    init_compression();
-    init_src();
-    init_compression_stream();
-    init_decompression_stream();
-    CHUNK_SIZE = 1e6;
-    ZstdCompression = class extends Compression {
-      name = "zstd";
-      extensions = [];
-      contentEncodings = [];
-      isSupported = true;
-      options;
-      /**
-       * zstd-codec is an injectable dependency due to big size
-       * @param options
-       */
-      constructor(options = {}) {
-        super(options);
-        this.options = options;
-        registerJSModules(options == null ? void 0 : options.modules);
-      }
-      async preload(modules = {}) {
-        registerJSModules(modules);
-        const ZstdCodec = getJSModuleOrNull("zstd-codec");
-        if (!zstdPromise && ZstdCodec) {
-          zstdPromise = new Promise((resolve) => ZstdCodec.run((zstd2) => resolve(zstd2)));
-        }
-        if (zstdPromise) {
-          zstd = await zstdPromise;
-        }
-      }
-      compressSync(input) {
-        getJSModule("zstd-codec", this.name);
-        const simpleZstd = new zstd.Simple();
-        const inputArray = new Uint8Array(input);
-        return simpleZstd.compress(inputArray).buffer;
-      }
-      async compress(input) {
-        var _a;
-        if (this.options.useNative !== false && ((_a = this.options.zstd) == null ? void 0 : _a.useNative) !== false) {
-          const nativeOutput = await compressWithNativeCompressionStream(input, "zstd");
-          if (nativeOutput) return nativeOutput;
-        }
-        await this.preload();
-        return this.compressSync(input);
-      }
-      decompressSync(input) {
-        getJSModule("zstd-codec", this.name);
-        const simpleZstd = new zstd.Simple();
-        const inputArray = new Uint8Array(input);
-        return simpleZstd.decompress(inputArray).buffer;
-      }
-      async decompress(input, size) {
-        var _a;
-        if (!getJSModuleOrNull("zstd-codec") && this.options.useNative !== false && ((_a = this.options.zstd) == null ? void 0 : _a.useNative) !== false) {
-          const nativeOutput = await decompressWithNativeDecompressionStream(input, "zstd");
-          if (nativeOutput) return nativeOutput;
-        }
-        await this.preload();
-        const inputArray = new Uint8Array(input);
-        if (!zstd) {
-          const { decompressZstd: decompressZstd2 } = await Promise.resolve().then(() => (init_zstd_fallback(), zstd_fallback_exports));
-          return ensureArrayBuffer(decompressZstd2(inputArray));
-        }
-        const simpleZstd = new zstd.Streaming();
-        const chunks = [];
-        for (let i = 0; i <= inputArray.length; i += CHUNK_SIZE) {
-          const chunkView = inputArray.subarray(i, i + CHUNK_SIZE);
-          const chunkArrayBuffer = ensureArrayBuffer(chunkView);
-          chunks.push(new Uint8Array(chunkArrayBuffer));
-        }
-        const decompressResult = await simpleZstd.decompressChunks(chunks);
-        return decompressResult.buffer;
+        super(
+          { name: "zstd", extensions: ["zst"], contentEncodings: ["zstd"] },
+          () => import("compress-utils/zstd/decompress"),
+          options
+        );
       }
     };
   }
@@ -1761,48 +1107,18 @@ var ZstdDecompressor;
 var init_zstd_decompressor = __esm({
   "../compression/src/zstd-decompressor.ts"() {
     "use strict";
-    init_zstd_decompressor_fzstd();
+    init_zstd_decompressor_compress_utils();
     init_decompression_stream();
-    init_src();
-    ZstdDecompressor = class extends ZstdFzstdDecompressor {
-      options;
-      compatibility = null;
-      constructor(options = {}) {
-        super(options);
-        this.options = options;
-        registerJSModules(options.modules);
-      }
-      /** Preloads an injected zstd-codec implementation when supplied. */
-      async preload(modules = {}) {
-        registerJSModules(modules);
-        if (getJSModuleOrNull("zstd-codec")) {
-          const { ZstdCompression: ZstdCompression2 } = await Promise.resolve().then(() => (init_zstd_compression(), zstd_compression_exports));
-          this.compatibility ||= new ZstdCompression2(this.options);
-          await this.compatibility.preload(modules);
-        }
-      }
-      /** Decompresses with the built-in stream when available, then falls back to fzstd. */
-      async decompress(input) {
+    ZstdDecompressor = class extends ZstdCompressUtilsDecompressor {
+      /** Decompresses with native streams when available, otherwise lazily initializes WASM. */
+      async decompress(input, size) {
         if (this.options.useNative !== false) {
           const output = await decompressWithNativeDecompressionStream(input, "zstd");
           if (output) return output;
         }
-        if (getJSModuleOrNull("zstd-codec")) {
-          await this.preload(this.options.modules);
-        }
-        return this.decompressSync(input);
+        return super.decompress(input, size);
       }
-      /** Decompresses with a preloaded zstd-codec implementation or compact fzstd. */
-      decompressSync(input) {
-        if (this.compatibility) {
-          return this.compatibility.decompressSync(input);
-        }
-        if (getJSModuleOrNull("zstd-codec")) {
-          throw new Error("zstd: call preload() before synchronous decompression with zstd-codec");
-        }
-        return super.decompressSync(input);
-      }
-      /** Decompresses batches with a built-in stream or compact fzstd fallback. */
+      /** Streams native batches when available, otherwise uses the WASM stream. */
       async *decompressBatches(inputBatches) {
         if (this.options.useNative !== false) {
           const output = decompressBatchesWithNativeDecompressionStream(inputBatches, "zstd");
@@ -1811,10 +1127,6 @@ var init_zstd_decompressor = __esm({
             return;
           }
         }
-        if (getJSModuleOrNull("zstd-codec")) {
-          yield this.decompress(await this.concatenate(inputBatches));
-          return;
-        }
         yield* super.decompressBatches(inputBatches);
       }
     };
@@ -1827,7 +1139,6 @@ var init_default_codecs = __esm({
   "../compression/src/default-codecs.ts"() {
     "use strict";
     init_lazy_compression();
-    init_src();
     GZIP = { name: "gzip", extensions: ["gz"], contentEncodings: ["gzip"] };
     ZSTD = { name: "zstd", extensions: ["zst"], contentEncodings: ["zstd"] };
     GZipDecompressor2 = class extends LazyDecompressor {
@@ -1846,11 +1157,7 @@ var init_default_codecs = __esm({
           ZSTD,
           async () => (await Promise.resolve().then(() => (init_zstd_decompressor(), zstd_decompressor_exports))).ZstdDecompressor,
           options,
-          "zstd",
-          (preloadOptions) => {
-            var _a;
-            return !((_a = preloadOptions.modules) == null ? void 0 : _a["zstd-codec"]) && !getJSModuleOrNull("zstd-codec");
-          }
+          "zstd"
         );
       }
     };
@@ -2499,7 +1806,7 @@ var init_splat_loader_types = __esm({
   "dist/splat-loader-types.js"() {
     "use strict";
     init_splats_format();
-    VERSION2 = true ? "5.0.0-alpha.10" : "latest";
+    VERSION2 = true ? "5.0.0-alpha.12" : "latest";
     SPLATLoader = {
       dataType: null,
       batchType: null,
@@ -2824,7 +2131,7 @@ var init_ksplat_loader_types = __esm({
   "dist/ksplat-loader-types.js"() {
     "use strict";
     init_splats_format();
-    VERSION3 = true ? "5.0.0-alpha.10" : "latest";
+    VERSION3 = true ? "5.0.0-alpha.12" : "latest";
     KSPLATLoader = {
       dataType: null,
       batchType: null,
@@ -2869,7 +2176,7 @@ var init_spz_loader_types = __esm({
   "dist/spz-loader-types.js"() {
     "use strict";
     init_splats_format();
-    VERSION4 = true ? "5.0.0-alpha.10" : "latest";
+    VERSION4 = true ? "5.0.0-alpha.12" : "latest";
     SPZLoader = {
       dataType: null,
       batchType: null,
@@ -3043,34 +2350,19 @@ var init_parse_rad = __esm({
   }
 });
 
-// ../compression/src/deflate-decompressor-fflate.ts
-var DeflateFflateDecompressor;
-var init_deflate_decompressor_fflate = __esm({
-  "../compression/src/deflate-decompressor-fflate.ts"() {
+// ../compression/src/deflate-decompressor-compress-utils.ts
+var DeflateCompressUtilsDecompressor;
+var init_deflate_decompressor_compress_utils = __esm({
+  "../compression/src/deflate-decompressor-compress-utils.ts"() {
     "use strict";
-    init_fflate();
-    init_compression();
-    init_fflate_stream();
-    DeflateFflateDecompressor = class extends Decompressor {
-      name = "deflate";
-      extensions = [];
-      contentEncodings = ["deflate"];
-      isSupported = true;
-      options;
+    init_compress_utils_compression();
+    DeflateCompressUtilsDecompressor = class extends CompressUtilsDecompressor {
       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);
+        super(
+          { name: "deflate", contentEncodings: ["deflate"] },
+          () => options.raw ? import("compress-utils/deflate/decompress") : import("compress-utils/zlib/decompress"),
+          options
+        );
       }
     };
   }
@@ -3081,26 +2373,27 @@ var DeflateDecompressor2;
 var init_deflate_decompressor = __esm({
   "../compression/src/deflate-decompressor.ts"() {
     "use strict";
-    init_deflate_decompressor_fflate();
+    init_deflate_decompressor_compress_utils();
     init_decompression_stream();
-    DeflateDecompressor2 = class extends DeflateFflateDecompressor {
-      constructor(options = {}) {
-        super(options);
-      }
-      /** Decompresses with the built-in stream when available, then falls back to fflate. */
-      async decompress(input) {
+    DeflateDecompressor2 = class extends DeflateCompressUtilsDecompressor {
+      /** Decompresses with native streams when available, otherwise lazily initializes WASM. */
+      async decompress(input, size) {
         if (this.options.useNative !== false) {
-          const format = this.options.raw ? "deflate-raw" : "deflate";
-          const output = await decompressWithNativeDecompressionStream(input, format);
+          const output = await decompressWithNativeDecompressionStream(
+            input,
+            this.options.raw ? "deflate-raw" : "deflate"
+          );
           if (output) return output;
         }
-        return this.decompressSync(input);
+        return super.decompress(input, size);
       }
-      /** Decompresses batches with a built-in or fflate stream. */
+      /** Streams native batches when available, otherwise uses the WASM stream. */
       async *decompressBatches(inputBatches) {
         if (this.options.useNative !== false) {
-          const format = this.options.raw ? "deflate-raw" : "deflate";
-          const output = decompressBatchesWithNativeDecompressionStream(inputBatches, format);
+          const output = decompressBatchesWithNativeDecompressionStream(
+            inputBatches,
+            this.options.raw ? "deflate-raw" : "deflate"
+          );
           if (output) {
             yield* output;
             return;
@@ -3113,6 +2406,9 @@ var init_deflate_decompressor = __esm({
 });
 
 // dist/lib/parse-rad-chunk.js
+async function preloadRADCompression() {
+  await Promise.all([RAD_PROPERTY_DEFLATE.preload(), RAD_PROPERTY_RAW_DEFLATE.preload()]);
+}
 function parseRADChunk(data, options) {
   return makeGaussianSplatsArrowTable(parseRADChunkToGaussianSplats(data, options));
 }
@@ -3320,7 +2616,7 @@ function getRADPropertyBytes(bytes, metadata, property) {
   return decompressRADProperty(propertyBytes, property.property);
 }
 function decompressRADProperty(bytes, propertyName) {
-  const arrayBuffer = copyToArrayBuffer3(bytes);
+  const arrayBuffer = copyToArrayBuffer2(bytes);
   try {
     return new Uint8Array(RAD_PROPERTY_DEFLATE.decompressSync(arrayBuffer));
   } catch {
@@ -3378,9 +2674,9 @@ function decodeLeBytesFloat16(bytes, dimensions, count) {
   }
   return values;
 }
-function decodeR8(bytes, dimensions, count, min, max2) {
+function decodeR8(bytes, dimensions, count, min, max) {
   const values = new Float32Array(count * dimensions);
-  const range = max2 - min;
+  const range = max - min;
   for (let rowIndex = 0; rowIndex < count; rowIndex++) {
     for (let dimension = 0; dimension < dimensions; dimension++) {
       values[rowIndex * dimensions + dimension] = bytes[dimension * count + rowIndex] / 255 * range + min;
@@ -3388,9 +2684,9 @@ function decodeR8(bytes, dimensions, count, min, max2) {
   }
   return values;
 }
-function decodeR8Delta(bytes, dimensions, count, min, max2) {
+function decodeR8Delta(bytes, dimensions, count, min, max) {
   const values = new Float32Array(count * dimensions);
-  const range = max2 - min;
+  const range = max - min;
   const last = new Uint8Array(dimensions);
   for (let rowIndex = 0; rowIndex < count; rowIndex++) {
     for (let dimension = 0; dimension < dimensions; dimension++) {
@@ -3402,17 +2698,17 @@ function decodeR8Delta(bytes, dimensions, count, min, max2) {
   }
   return values;
 }
-function decodeS8(bytes, dimensions, count, max2) {
+function decodeS8(bytes, dimensions, count, max) {
   const values = new Float32Array(count * dimensions);
   for (let rowIndex = 0; rowIndex < count; rowIndex++) {
     for (let dimension = 0; dimension < dimensions; dimension++) {
       const byte = bytes[dimension * count + rowIndex];
-      values[rowIndex * dimensions + dimension] = (byte << 24 >> 24) / 127 * max2;
+      values[rowIndex * dimensions + dimension] = (byte << 24 >> 24) / 127 * max;
     }
   }
   return values;
 }
-function decodeS8Delta(bytes, dimensions, count, max2) {
+function decodeS8Delta(bytes, dimensions, count, max) {
   const values = new Float32Array(count * dimensions);
   const last = new Uint8Array(dimensions);
   for (let rowIndex = 0; rowIndex < count; rowIndex++) {
@@ -3420,16 +2716,16 @@ function decodeS8Delta(bytes, dimensions, count, max2) {
       const byteOffset = dimension * count + rowIndex;
       const value = last[dimension] + bytes[byteOffset] & 255;
       last[dimension] = value;
-      values[rowIndex * dimensions + dimension] = (value << 24 >> 24) / 127 * max2;
+      values[rowIndex * dimensions + dimension] = (value << 24 >> 24) / 127 * max;
     }
   }
   return values;
 }
-function decodeScaleR8(bytes, dimensions, count, min, max2) {
+function decodeScaleR8(bytes, dimensions, count, min, max) {
   const values = new Float32Array(count * dimensions);
   for (let rowIndex = 0; rowIndex < count; rowIndex++) {
     for (let dimension = 0; dimension < dimensions; dimension++) {
-      values[rowIndex * dimensions + dimension] = decodeScale8(bytes[dimension * count + rowIndex], min, max2);
+      values[rowIndex * dimensions + dimension] = decodeScale8(bytes[dimension * count + rowIndex], min, max);
     }
   }
   return values;
@@ -3467,11 +2763,11 @@ function makeIdentityRotations(count) {
   }
   return rotations;
 }
-function decodeScale8(scale, min, max2) {
+function decodeScale8(scale, min, max) {
   if (scale === 0) {
     return 0;
   }
-  const logScaleStep = (max2 - min) / 254;
+  const logScaleStep = (max - min) / 254;
   return Math.exp(min + (scale - 1) * logScaleStep);
 }
 function decodeQuatOct888(u, v, r) {
@@ -3562,7 +2858,7 @@ function getSplatEncodingMaximum(splatEncoding, propertyName) {
 function normalizeColorByte2(value) {
   return Math.round(Math.min(Math.max(value, 0), 1) * 255);
 }
-function copyToArrayBuffer3(bytes) {
+function copyToArrayBuffer2(bytes) {
   const copy = new Uint8Array(bytes.byteLength);
   copy.set(bytes);
   return copy.buffer;
@@ -3591,6 +2887,7 @@ __export(rad_loader_exports, {
   parseRADChunkHeader: () => parseRADChunkHeader,
   parseRADChunkToGaussianSplats: () => parseRADChunkToGaussianSplats,
   parseRADHeader: () => parseRADHeader,
+  preloadRADCompression: () => preloadRADCompression,
   tryParseRADHeader: () => tryParseRADHeader
 });
 var _RADLoaderPreload, RADLoaderMetadataWithoutPreload, RADLoaderWithParser;
@@ -3620,7 +2917,7 @@ var init_rad_loader_types = __esm({
   "dist/rad-loader-types.js"() {
     "use strict";
     init_splats_format();
-    VERSION5 = true ? "5.0.0-alpha.10" : "latest";
+    VERSION5 = true ? "5.0.0-alpha.12" : "latest";
     RADLoader = {
       dataType: null,
       batchType: null,
@@ -3665,7 +2962,7 @@ init_parse_rad_chunk();
 init_splats_arrow_table();
 var DEFAULT_RAD_HEADER_BYTE_LENGTHS = [64 * 1024, 256 * 1024, 1024 * 1024];
 var DEFAULT_RAD_MAX_CONCURRENT_CHUNK_REQUESTS = 4;
-var VERSION6 = true ? "5.0.0-alpha.10" : "latest";
+var VERSION6 = true ? "5.0.0-alpha.12" : "latest";
 var RADSourceLoader = {
   dataType: null,
   batchType: null,
@@ -3761,11 +3058,13 @@ var RADSource = class extends DataSource {
   /** Fetches and decodes one RADC chunk into raw Gaussian splat arrays. */
   async getChunkSplats(chunkIndex, options = {}) {
     const metadata = await this.getMetadata();
+    await preloadRADCompression();
     return parseRADChunkToGaussianSplats(await this.getChunk(chunkIndex, options), this._getChunkDecodeOptions(metadata, options));
   }
   /** Fetches and decodes one RADC chunk into a Mesh Arrow table. */
   async getChunkTable(chunkIndex, options = {}) {
     const metadata = await this.getMetadata();
+    await preloadRADCompression();
     return parseRADChunk(await this.getChunk(chunkIndex, options), this._getChunkDecodeOptions(metadata, options));
   }
   /** Iterates decoded RADC chunks as Mesh Arrow tables. */