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

package/dist/index.cjs

@@ -791,6 +791,309 @@ var init_compression = __esm({
   }
 });
 
+// ../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";
+  }
+});
+
+// ../compression/src/lib/decompression-stream.ts
+async function decompressWithNativeDecompressionStream(input, format) {
+  const outputBatches = decompressBatchesWithNativeDecompressionStream([input], format);
+  return outputBatches ? await concatenateNativeDecompressionBatches(outputBatches) : null;
+}
+function decompressBatchesWithNativeDecompressionStream(inputBatches, format) {
+  const decompressionStream = createNativeDecompressionStream(format);
+  return decompressionStream ? transformBatchesWithNativeDecompressionStream(inputBatches, decompressionStream) : null;
+}
+function isNativeDecompressionSupported(format) {
+  return Boolean(createNativeDecompressionStream(format));
+}
+function createNativeDecompressionStream(format) {
+  var _a, _b;
+  if (typeof globalThis.DecompressionStream === "undefined") {
+    return null;
+  }
+  if (((_b = (_a = globalThis.process) == null ? void 0 : _a.release) == null ? void 0 : _b.name) === "node" && typeof globalThis.Buffer === "undefined") {
+    return null;
+  }
+  try {
+    const DecompressionStreamConstructor = globalThis.DecompressionStream;
+    return new DecompressionStreamConstructor(format);
+  } catch (error) {
+    if (error instanceof TypeError || (error == null ? void 0 : error.name) === "TypeError") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function* transformBatchesWithNativeDecompressionStream(inputBatches, decompressionStream) {
+  const writer = decompressionStream.writable.getWriter();
+  const reader = decompressionStream.readable.getReader();
+  const writePromise = writeBatchesToNativeDecompressionStream(inputBatches, writer);
+  writePromise.catch(() => {
+  });
+  let outputCompleted = false;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        outputCompleted = true;
+        break;
+      }
+      yield copyExactArrayBuffer(value);
+    }
+    await writePromise;
+  } finally {
+    if (!outputCompleted) {
+      await reader.cancel().catch(() => {
+      });
+      await writer.abort().catch(() => {
+      });
+      await writePromise.catch(() => {
+      });
+    }
+    reader.releaseLock();
+  }
+}
+async function concatenateNativeDecompressionBatches(outputBatches) {
+  const batches = [];
+  let byteLength = 0;
+  for await (const outputBatch of outputBatches) {
+    const bytes = new Uint8Array(outputBatch);
+    batches.push(bytes);
+    byteLength += bytes.byteLength;
+  }
+  const output = new Uint8Array(byteLength);
+  let byteOffset = 0;
+  for (const batch of batches) {
+    output.set(batch, byteOffset);
+    byteOffset += batch.byteLength;
+  }
+  return output.buffer;
+}
+function copyExactArrayBuffer(value) {
+  return new Uint8Array(value).buffer;
+}
+async function writeBatchesToNativeDecompressionStream(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;
+  }
+}
+var init_decompression_stream = __esm({
+  "../compression/src/lib/decompression-stream.ts"() {
+    "use strict";
+  }
+});
+
+// ../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;
+      }
+      /** 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;
+      /** 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);
@@ -1123,418 +1426,115 @@ var init_fflate = __esm({
       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";
-  }
-});
-
-// ../compression/src/lib/decompression-stream.ts
-async function decompressWithNativeDecompressionStream(input, format) {
-  const outputBatches = decompressBatchesWithNativeDecompressionStream([input], format);
-  return outputBatches ? await concatenateNativeDecompressionBatches(outputBatches) : null;
-}
-function decompressBatchesWithNativeDecompressionStream(inputBatches, format) {
-  const decompressionStream = createNativeDecompressionStream(format);
-  return decompressionStream ? transformBatchesWithNativeDecompressionStream(inputBatches, decompressionStream) : null;
-}
-function isNativeDecompressionSupported(format) {
-  return Boolean(createNativeDecompressionStream(format));
-}
-function createNativeDecompressionStream(format) {
-  var _a, _b;
-  if (typeof globalThis.DecompressionStream === "undefined") {
-    return null;
-  }
-  if (((_b = (_a = globalThis.process) == null ? void 0 : _a.release) == null ? void 0 : _b.name) === "node" && typeof globalThis.Buffer === "undefined") {
-    return null;
-  }
-  try {
-    const DecompressionStreamConstructor = globalThis.DecompressionStream;
-    return new DecompressionStreamConstructor(format);
-  } catch (error) {
-    if (error instanceof TypeError || (error == null ? void 0 : error.name) === "TypeError") {
-      return null;
-    }
-    throw error;
-  }
-}
-async function* transformBatchesWithNativeDecompressionStream(inputBatches, decompressionStream) {
-  const writer = decompressionStream.writable.getWriter();
-  const reader = decompressionStream.readable.getReader();
-  const writePromise = writeBatchesToNativeDecompressionStream(inputBatches, writer);
-  writePromise.catch(() => {
-  });
-  let outputCompleted = false;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        outputCompleted = true;
-        break;
+    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;
       }
-      yield copyExactArrayBuffer(value);
-    }
-    await writePromise;
-  } finally {
-    if (!outputCompleted) {
-      await reader.cancel().catch(() => {
-      });
-      await writer.abort().catch(() => {
-      });
-      await writePromise.catch(() => {
-      });
-    }
-    reader.releaseLock();
-  }
-}
-async function concatenateNativeDecompressionBatches(outputBatches) {
-  const batches = [];
-  let byteLength = 0;
-  for await (const outputBatch of outputBatches) {
-    const bytes = new Uint8Array(outputBatch);
-    batches.push(bytes);
-    byteLength += bytes.byteLength;
-  }
-  const output = new Uint8Array(byteLength);
-  let byteOffset = 0;
-  for (const batch of batches) {
-    output.set(batch, byteOffset);
-    byteOffset += batch.byteLength;
-  }
-  return output.buffer;
-}
-function copyExactArrayBuffer(value) {
-  return new Uint8Array(value).buffer;
-}
-async function writeBatchesToNativeDecompressionStream(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;
-  }
-}
-var init_decompression_stream = __esm({
-  "../compression/src/lib/decompression-stream.ts"() {
-    "use strict";
-  }
-});
-
-// ../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;
+      /** 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 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;
+      /** 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;
       }
-      /** 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;
+      /**
+       * 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);
       }
     };
   }
@@ -2499,7 +2499,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.11" : "latest";
     SPLATLoader = {
       dataType: null,
       batchType: null,
@@ -2824,7 +2824,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.11" : "latest";
     KSPLATLoader = {
       dataType: null,
       batchType: null,
@@ -2869,7 +2869,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.11" : "latest";
     SPZLoader = {
       dataType: null,
       batchType: null,
@@ -3620,7 +3620,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.11" : "latest";
     RADLoader = {
       dataType: null,
       batchType: null,
@@ -3665,7 +3665,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.11" : "latest";
 var RADSourceLoader = {
   dataType: null,
   batchType: null,