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

package/dist/dist.dev.js

@@ -1408,6 +1408,308 @@ var __exports__ = (() => {
     }
   });
 
+  // ../compression/src/lib/compression-stream.ts
+  async function compressWithNativeCompressionStream(input2, format) {
+    const outputBatches = compressBatchesWithNativeCompressionStream([input2], 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 (error62) {
+      if (error62 instanceof TypeError || error62?.name === "TypeError") {
+        return null;
+      }
+      throw error62;
+    }
+  }
+  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 (error62) {
+      await writer.abort(error62).catch(() => {
+      });
+      throw error62;
+    }
+  }
+  async function concatenateBatches(batches) {
+    const output2 = [];
+    let byteLength = 0;
+    for await (const batch of batches) {
+      const bytes = new Uint8Array(batch);
+      output2.push(bytes);
+      byteLength += bytes.byteLength;
+    }
+    const result = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const batch of output2) {
+      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(input2, format) {
+    const outputBatches = decompressBatchesWithNativeDecompressionStream([input2], 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) {
+    if (typeof globalThis.DecompressionStream === "undefined") {
+      return null;
+    }
+    if (globalThis.process?.release?.name === "node" && typeof globalThis.Buffer === "undefined") {
+      return null;
+    }
+    try {
+      const DecompressionStreamConstructor = globalThis.DecompressionStream;
+      return new DecompressionStreamConstructor(format);
+    } catch (error62) {
+      if (error62 instanceof TypeError || error62?.name === "TypeError") {
+        return null;
+      }
+      throw error62;
+    }
+  }
+  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 output2 = new Uint8Array(byteLength);
+    let byteOffset = 0;
+    for (const batch of batches) {
+      output2.set(batch, byteOffset);
+      byteOffset += batch.byteLength;
+    }
+    return output2.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 (error62) {
+      await writer.abort(error62).catch(() => {
+      });
+      throw error62;
+    }
+  }
+  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(input2) {
+          const output2 = await decompressWithNativeDecompressionStream(input2, this.format);
+          if (!output2) throw new Error(`${this.name}: built-in decompression is no longer available`);
+          return output2;
+        }
+        /** Decompresses batches incrementally with the runtime-provided stream. */
+        async *decompressBatches(inputBatches) {
+          const output2 = decompressBatchesWithNativeDecompressionStream(inputBatches, this.format);
+          if (!output2) throw new Error(`${this.name}: built-in decompression is no longer available`);
+          yield* output2;
+        }
+      };
+    }
+  });
+
+  // ../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 (error62) {
+            this.implementationPromise = null;
+            throw error62;
+          }
+        }
+        /** 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(input2, size) {
+          return (await this.preload()).decompress(input2, size);
+        }
+        /** Decompresses synchronously after an implementation has been preloaded. */
+        decompressSync(input2, size) {
+          if (!this.implementation) {
+            throw new Error(`${this.name}: call preload() before decompressSync()`);
+          }
+          return this.implementation.decompressSync(input2, 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);
@@ -1740,417 +2042,115 @@ var __exports__ = (() => {
         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(input2, format) {
-    const outputBatches = compressBatchesWithNativeCompressionStream([input2], 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 (error62) {
-      if (error62 instanceof TypeError || error62?.name === "TypeError") {
-        return null;
-      }
-      throw error62;
-    }
-  }
-  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 (error62) {
-      await writer.abort(error62).catch(() => {
-      });
-      throw error62;
-    }
-  }
-  async function concatenateBatches(batches) {
-    const output2 = [];
-    let byteLength = 0;
-    for await (const batch of batches) {
-      const bytes = new Uint8Array(batch);
-      output2.push(bytes);
-      byteLength += bytes.byteLength;
-    }
-    const result = new Uint8Array(byteLength);
-    let offset = 0;
-    for (const batch of output2) {
-      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(input2, format) {
-    const outputBatches = decompressBatchesWithNativeDecompressionStream([input2], 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) {
-    if (typeof globalThis.DecompressionStream === "undefined") {
-      return null;
-    }
-    if (globalThis.process?.release?.name === "node" && typeof globalThis.Buffer === "undefined") {
-      return null;
-    }
-    try {
-      const DecompressionStreamConstructor = globalThis.DecompressionStream;
-      return new DecompressionStreamConstructor(format);
-    } catch (error62) {
-      if (error62 instanceof TypeError || error62?.name === "TypeError") {
-        return null;
-      }
-      throw error62;
-    }
-  }
-  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 output2 = new Uint8Array(byteLength);
-    let byteOffset = 0;
-    for (const batch of batches) {
-      output2.set(batch, byteOffset);
-      byteOffset += batch.byteLength;
-    }
-    return output2.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 (error62) {
-      await writer.abort(error62).catch(() => {
-      });
-      throw error62;
-    }
-  }
-  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(input2) {
-          const output2 = await decompressWithNativeDecompressionStream(input2, this.format);
-          if (!output2) throw new Error(`${this.name}: built-in decompression is no longer available`);
-          return output2;
+        /** 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 output2 = decompressBatchesWithNativeDecompressionStream(inputBatches, this.format);
-          if (!output2) throw new Error(`${this.name}: built-in decompression is no longer available`);
-          yield* output2;
+        /**
+         * 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 (error62) {
-            this.implementationPromise = null;
-            throw error62;
+        /**
+         * 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(input2, size) {
-          return (await this.preload()).decompress(input2, 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(input2, 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(input2, 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);
         }
       };
     }