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

package/dist/index.cjs

@@ -9665,6 +9665,7 @@ var init_i3s_loader_options = __esm({
       decodeTextures: true,
       attributeValues: "legacy",
       colorFormat: "uint8norm",
+      geometryMode: "render",
       coordinateSystem: COORDINATE_SYSTEM.METER_OFFSETS
     };
   }
@@ -13685,9 +13686,6 @@ var init_tileset_traverser = __esm({
               childRefines = child.contentAvailable;
             }
             refines = refines && childRefines;
-            if (!refines) {
-              return false;
-            }
           }
         }
         if (!hasVisibleChild) {
@@ -15028,16 +15026,20 @@ var init_format_spatial_reference = __esm({
 });
 
 // ../tiles/src/spatial/spatial-resource-registry.ts
+function getSpatialProjectionEngine() {
+  return spatialProjectionEngine;
+}
 function getGeoidModel(name) {
   return geoidModels.get(name);
 }
-var import_geoid, import_projection, geoidModels;
+var import_geoid, import_projection, geoidModels, spatialProjectionEngine;
 var init_spatial_resource_registry = __esm({
   "../tiles/src/spatial/spatial-resource-registry.ts"() {
     "use strict";
     import_geoid = require("@math.gl/geoid");
     import_projection = require("@math.gl/projection");
     geoidModels = /* @__PURE__ */ new Map();
+    spatialProjectionEngine = new import_projection.FullProjectionEngine();
   }
 });
 
@@ -15142,13 +15144,12 @@ function transformHeight(height, geoidUndulation, source, target) {
   }
   throw new Error(`Unsupported height conversion from ${source} to ${target}`);
 }
-var import_core7, import_geospatial4, import_projection2, SpatialCoordinateTransformer;
+var import_core7, import_geospatial4, SpatialCoordinateTransformer;
 var init_spatial_coordinate_transformer = __esm({
   "../tiles/src/spatial/spatial-coordinate-transformer.ts"() {
     "use strict";
     import_core7 = require("@math.gl/core");
     import_geospatial4 = require("@math.gl/geospatial");
-    import_projection2 = require("@math.gl/projection");
     init_spatial_resource_registry();
     init_normalize_crs_identifier();
     init_get_spatial_coordinate_frame();
@@ -15179,6 +15180,7 @@ var init_spatial_coordinate_transformer = __esm({
        */
       constructor(spatialReference, options = {}) {
         this.spatialReference = spatialReference;
+        const projectionEngine = getSpatialProjectionEngine();
         validateTransformRequest(spatialReference);
         const outputCrs = spatialReference.targetCrs || spatialReference.sourceCrs;
         this.sourceIsGeocentric = isWgs84Geocentric(spatialReference.sourceCrs);
@@ -15186,7 +15188,7 @@ var init_spatial_coordinate_transformer = __esm({
         this.sourceIsGeographic = isWgs84Geographic(spatialReference.sourceCrs);
         this.outputIsGeographic = isWgs84Geographic(outputCrs);
         if (spatialReference.sourceCrs && spatialReference.targetCrs && !this.sourceIsGeocentric && !this.outputIsGeocentric) {
-          this.horizontalProjection = new import_projection2.Projection({
+          this.horizontalProjection = projectionEngine.createProjection({
             from: getHorizontalProjectionDefinition(spatialReference.sourceCrs),
             to: getHorizontalProjectionDefinition(spatialReference.targetCrs),
             enforceAxis: false
@@ -15194,14 +15196,14 @@ var init_spatial_coordinate_transformer = __esm({
         }
         if (requiresHeightTransformation(spatialReference) || this.sourceIsGeocentric || this.outputIsGeocentric) {
           if (!this.sourceIsGeographic && !this.sourceIsGeocentric) {
-            this.geographicProjection = new import_projection2.Projection({
+            this.geographicProjection = projectionEngine.createProjection({
               from: getHorizontalProjectionDefinition(spatialReference.sourceCrs),
               to: WGS84_GEOGRAPHIC_CRS,
               enforceAxis: false
             });
           }
           if (!this.outputIsGeographic && !this.outputIsGeocentric) {
-            this.heightOutputProjection = new import_projection2.Projection({
+            this.heightOutputProjection = projectionEngine.createProjection({
               from: WGS84_GEOGRAPHIC_CRS,
               to: getHorizontalProjectionDefinition(outputCrs),
               enforceAxis: false
@@ -15248,7 +15250,7 @@ var init_spatial_coordinate_transformer = __esm({
           return result;
         }
         if (this.horizontalProjection) {
-          const projected = this.horizontalProjection.project(result.slice(0, 3));
+          const projected = this.horizontalProjection.projectSync(result.slice(0, 3));
           result.splice(0, projected.length, ...projected);
         }
         return result;
@@ -15312,7 +15314,7 @@ var init_spatial_coordinate_transformer = __esm({
         if (this.sourceIsGeographic) {
           return coordinate.slice(0, 3);
         }
-        return this.geographicProjection.project(coordinate.slice(0, 3));
+        return this.geographicProjection.projectSync(coordinate.slice(0, 3));
       }
       /** Convert one conventional WGS84 geographic coordinate to the selected output CRS. */
       fromGeographic(coordinate) {
@@ -15322,7 +15324,7 @@ var init_spatial_coordinate_transformer = __esm({
         if (this.outputIsGeographic) {
           return coordinate.slice(0, 3);
         }
-        return this.heightOutputProjection.project(coordinate.slice(0, 3));
+        return this.heightOutputProjection.projectSync(coordinate.slice(0, 3));
       }
     };
   }
@@ -15958,6 +15960,34 @@ var init_i3s_spatial_transformer = __esm({
           placedPositions.subarray(sourcePositions.length)
         );
       }
+      /**
+       * Transforms conversion geometry without passing through renderer float32 offsets.
+       * Positions and normals share one batch of elevation samples. Source arrays remain unchanged.
+       * @param sourcePositions - Packed absolute xyz positions in source units.
+       * @param normals - Optional packed normals paired with the positions.
+       * @param normalReferenceFrame - I3S earth-centered or vertex-reference-frame declaration.
+       * @returns Absolute target positions and optional transformed normals.
+       */
+      async transformGeometryAsync(sourcePositions, normals, normalReferenceFrame = "earth-centered") {
+        if (sourcePositions.length % 3 || normals && normals.length !== sourcePositions.length) {
+          throw new Error("Conversion positions and normals must contain matching finite xyz triples");
+        }
+        for (let index = 0; index < sourcePositions.length; index++) {
+          if (!Number.isFinite(sourcePositions[index]) || normals && !Number.isFinite(normals[index])) {
+            throw new Error(
+              "Conversion positions and normals must contain matching finite xyz triples"
+            );
+          }
+        }
+        if (!["earth-centered", "vertex-reference-frame"].includes(normalReferenceFrame)) {
+          throw new Error("Unsupported I3S normal reference frame");
+        }
+        const placedPositions = await this.placeSourcePositions(sourcePositions);
+        return {
+          positions: this.positionTransformer.transformPositions(placedPositions),
+          normals: normals ? this.transformNormals(normals, placedPositions, normalReferenceFrame) : void 0
+        };
+      }
       /** Transform already placed positions into renderer-relative target coordinates. */
       transformPlacedPositions(sourcePositions, sourceOrigin) {
         const origin = this.transformPlacedPosition(sourceOrigin);
@@ -15995,7 +16025,19 @@ var init_i3s_spatial_transformer = __esm({
        * @param normalReferenceFrame - I3S normal frame declaration.
        */
       transformNormals(normals, sourcePositions, normalReferenceFrame = "earth-centered") {
+        if (normals.length !== sourcePositions.length || normals.length % 3) {
+          throw new Error("I3S normals and positions must have matching xyz component counts");
+        }
         const transformedNormals = new Float32Array(normals.length);
+        if (normalReferenceFrame === "earth-centered" && (this.spatialReference.targetCrs || this.spatialReference.sourceCrs) === "EPSG:4978") {
+          for (let index = 0; index < normals.length; index += 3) {
+            const length = Math.hypot(normals[index], normals[index + 1], normals[index + 2]);
+            for (let axis = 0; axis < 3; axis++) {
+              transformedNormals[index + axis] = length ? normals[index + axis] / length : normals[index + axis];
+            }
+          }
+          return transformedNormals;
+        }
         for (let index = 0; index < normals.length; index += 3) {
           const geographic = this.sourceToGeographicTransformer.transformPosition([
             sourcePositions[index],
@@ -16740,6 +16782,7 @@ var init_src11 = __esm({
     init_i3s_source();
     init_spatial_types();
     init_format_spatial_reference();
+    init_spatial_coordinate_transformer();
     init_i3s_spatial_transformer();
   }
 });
@@ -16828,8 +16871,13 @@ function getLoaderForTextureFormat(textureFormat) {
   }
 }
 async function parseI3STileContent(arrayBuffer, tileOptions, tilesetOptions, options, context) {
-  var _a2;
+  var _a2, _b;
+  const geometryMode = ((_a2 = options == null ? void 0 : options.i3s) == null ? void 0 : _a2.geometryMode) ?? "render";
+  if (geometryMode !== "render" && geometryMode !== "source") {
+    throw new Error("Unsupported I3S geometry mode");
+  }
   const content = {
+    geometryMode,
     attributes: {},
     indices: null,
     featureIds: [],
@@ -16843,7 +16891,7 @@ async function parseI3STileContent(arrayBuffer, tileOptions, tilesetOptions, opt
     pointSymbol: tileOptions.pointSymbol
   };
   const requiredContext = context ? getRequiredContext(context, "parse nested resources") : null;
-  const textureResources = ((_a2 = tileOptions.textureUrls) == null ? void 0 : _a2.length) ? tileOptions.textureUrls : tileOptions.textureUrl ? [
+  const textureResources = ((_b = tileOptions.textureUrls) == null ? void 0 : _b.length) ? tileOptions.textureUrls : tileOptions.textureUrl ? [
     {
       textureSetDefinitionId: getMaterialTextureSetDefinitionId(
         tileOptions.materialDefinition
@@ -16981,6 +17029,13 @@ async function parseI3SNodeGeometry(arrayBuffer, content, tileOptions, tilesetOp
       id: featureIndex
     };
     copyDracoTextureCoordinates(attributes, decompressedGeometry.attributes);
+    if (content.geometryMode === "source") {
+      for (const [name, attribute] of Object.entries(decompressedGeometry.attributes)) {
+        if (!["POSITION", "NORMAL", "COLOR_0", "feature-index", "uv-region"].includes(name) && !/^TEXCOORD_\d+$/.test(name)) {
+          attributes[name] = attribute;
+        }
+      }
+    }
     updateAttributesMetadata(attributes, decompressedGeometry);
     const featureIds = getFeatureIdsFromFeatureIndexMetadata(featureIndex);
     if (featureIds) {
@@ -17029,7 +17084,32 @@ async function parseI3SNodeGeometry(arrayBuffer, content, tileOptions, tilesetOp
     attributes = concatAttributes(normalizedVertexAttributes, normalizedFeatureAttributes);
   }
   const spatialReference = tilesetOptions.spatialReference;
-  if ((spatialReference == null ? void 0 : spatialReference.status) === "transformable" || (spatialReference == null ? void 0 : spatialReference.status) === "transformed") {
+  if (content.geometryMode === "source") {
+    if (attributes.position.size !== 3 || attributes.position.transform || attributes.position.normalized || (attributes.position.byteStride ?? 0) !== 0 || (attributes.position.byteOffset ?? 0) !== 0 || attributes.position.value.length !== vertexCount * 3 || tileOptions.mbs.length < 3 || tileOptions.mbs.slice(0, 3).some((value) => !Number.isFinite(value))) {
+      throw new Error("Source I3S geometry requires packed xyz values and a finite source origin");
+    }
+    const positions = offsetsToSourcePositions(
+      attributes.position.value,
+      attributes.position.metadata,
+      tileOptions.mbs
+    );
+    if (positions.some((value) => !Number.isFinite(value))) {
+      throw new Error("Source I3S positions must be finite");
+    }
+    attributes.position = { value: positions, size: 3 };
+    content.origin = [0, 0, 0];
+    content.cartographicOrigin = [0, 0, 0];
+    content.coordinateSystem = (spatialReference == null ? void 0 : spatialReference.sourceCrs) && getSpatialCoordinateFrame(spatialReference.sourceCrs) === "geographic" ? "lnglat" : "cartesian";
+    content.spatialReference = spatialReference ? Object.freeze({
+      ...spatialReference,
+      status: "native",
+      targetCrs: void 0,
+      targetHeightReference: "native",
+      outputCoordinates: "auto"
+    }) : void 0;
+    content.normalReferenceFrame = tilesetOptions.store.normalReferenceFrame || "earth-centered";
+    content.sourceAttributes = attributes;
+  } else if ((spatialReference == null ? void 0 : spatialReference.status) === "transformable" || (spatialReference == null ? void 0 : spatialReference.status) === "transformed") {
     const spatialTransformer = new I3SSpatialTransformer(
       spatialReference,
       tilesetOptions.spatialOptions || ((_c = options == null ? void 0 : options.i3s) == null ? void 0 : _c.spatial)
@@ -17287,9 +17367,10 @@ function parsePositions(attribute, options) {
   return enuMatrix;
 }
 function offsetsToSourcePositions(vertices, metadata = {}, sourceOrigin) {
+  var _a2, _b;
   const positions = new Float64Array(vertices.length);
-  const scaleX = metadata["i3s-scale_x"] && metadata["i3s-scale_x"].double || 1;
-  const scaleY = metadata["i3s-scale_y"] && metadata["i3s-scale_y"].double || 1;
+  const scaleX = ((_a2 = metadata["i3s-scale_x"]) == null ? void 0 : _a2.double) ?? 1;
+  const scaleY = ((_b = metadata["i3s-scale_y"]) == null ? void 0 : _b.double) ?? 1;
   for (let index = 0; index < positions.length; index += 3) {
     positions[index] = vertices[index] * scaleX + sourceOrigin[0];
     positions[index + 1] = vertices[index + 1] * scaleY + sourceOrigin[1];
@@ -21732,6 +21813,223 @@ var init_compression = __esm({
   }
 });
 
+// ../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 _a2, _b;
+  if (typeof globalThis.DecompressionStream === "undefined") {
+    return null;
+  }
+  if (((_b = (_a2 = globalThis.process) == null ? void 0 : _a2.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);
@@ -22178,223 +22476,6 @@ var init_fflate = __esm({
   }
 });
 
-// ../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 _a2, _b;
-  if (typeof globalThis.DecompressionStream === "undefined") {
-    return null;
-  }
-  if (((_b = (_a2 = globalThis.process) == null ? void 0 : _a2.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-stream.ts
 async function* transformFflateBatches(processor, inputBatches) {
   const chunks = [];