@loaders.gl/tile-converter 5.0.0-alpha.10 → 5.0.0-alpha.11

package/dist/index.js

@@ -15822,6 +15822,8 @@ async function decompressPrimitive(iterator, primitive, options, context) {
       ...options.draco,
       // Internal glTF decoding consumes the legacy mesh contract.
       shape: "mesh",
+      // Normalize compressed strips to the triangle indices returned below.
+      topology: "triangle-list",
       decoderProfile: options.draco?.decoderProfile || "gltf",
       extraAttributes: dracoExtension.attributes
     }
@@ -15850,6 +15852,7 @@ async function decompressPrimitive(iterator, primitive, options, context) {
   primitive.attributes = decodedAttributes;
   if (decodedData.indices) {
     primitive.indices = getGLTFAccessor(decodedData.indices);
+    primitive.mode = 4;
   }
   iterator.removeExtension(primitive, KHR_DRACO_MESH_COMPRESSION);
   checkPrimitive(primitive);
@@ -20725,22 +20728,25 @@ var init_format_spatial_reference = __esm({
 
 // ../../modules/tiles/src/spatial/spatial-resource-registry.ts
 import { parsePGM } from "@math.gl/geoid";
-import { Projection } from "@math.gl/projection";
+import { FullProjectionEngine, parseNTv2Grid } from "@math.gl/projection";
+function getSpatialProjectionEngine() {
+  return spatialProjectionEngine;
+}
 function getGeoidModel(name18) {
   return geoidModels.get(name18);
 }
-var geoidModels;
+var geoidModels, spatialProjectionEngine;
 var init_spatial_resource_registry = __esm({
   "../../modules/tiles/src/spatial/spatial-resource-registry.ts"() {
     "use strict";
     geoidModels = /* @__PURE__ */ new Map();
+    spatialProjectionEngine = new FullProjectionEngine();
   }
 });
 
 // ../../modules/tiles/src/spatial/spatial-coordinate-transformer.ts
 import { Vector3 as Vector34 } from "@math.gl/core";
 import { Ellipsoid as Ellipsoid2 } from "@math.gl/geospatial";
-import { Projection as Projection2 } from "@math.gl/projection";
 function getFiniteDifferenceJacobian(transformer, position, epsilon) {
   const columns = [];
   for (let axis = 0; axis < 3; axis++) {
@@ -20875,6 +20881,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);
@@ -20882,7 +20889,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 Projection2({
+          this.horizontalProjection = projectionEngine.createProjection({
             from: getHorizontalProjectionDefinition(spatialReference.sourceCrs),
             to: getHorizontalProjectionDefinition(spatialReference.targetCrs),
             enforceAxis: false
@@ -20890,14 +20897,14 @@ var init_spatial_coordinate_transformer = __esm({
         }
         if (requiresHeightTransformation(spatialReference) || this.sourceIsGeocentric || this.outputIsGeocentric) {
           if (!this.sourceIsGeographic && !this.sourceIsGeocentric) {
-            this.geographicProjection = new Projection2({
+            this.geographicProjection = projectionEngine.createProjection({
               from: getHorizontalProjectionDefinition(spatialReference.sourceCrs),
               to: WGS84_GEOGRAPHIC_CRS,
               enforceAxis: false
             });
           }
           if (!this.outputIsGeographic && !this.outputIsGeocentric) {
-            this.heightOutputProjection = new Projection2({
+            this.heightOutputProjection = projectionEngine.createProjection({
               from: WGS84_GEOGRAPHIC_CRS,
               to: getHorizontalProjectionDefinition(outputCrs),
               enforceAxis: false
@@ -20944,7 +20951,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;
@@ -21008,7 +21015,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) {
@@ -21018,7 +21025,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));
       }
     };
   }
@@ -21026,7 +21033,6 @@ var init_spatial_coordinate_transformer = __esm({
 
 // ../../modules/tiles/src/spatial/tiles-3d-spatial-transformer.ts
 import { Matrix4 as Matrix43 } from "@math.gl/core";
-import { Ellipsoid as Ellipsoid3 } from "@math.gl/geospatial";
 function getRegionSamples(region) {
   if (region.length < 6 || region.some((value) => !Number.isFinite(value))) {
     return [];
@@ -21131,7 +21137,6 @@ var init_tiles_3d_spatial_transformer = __esm({
   "../../modules/tiles/src/spatial/tiles-3d-spatial-transformer.ts"() {
     "use strict";
     init_spatial_coordinate_transformer();
-    init_get_spatial_coordinate_frame();
     Tiles3DSpatialTransformer = class {
       /** Normalized reference describing the completed operation. */
       spatialReference;
@@ -21175,16 +21180,6 @@ var init_tiles_3d_spatial_transformer = __esm({
       }
       /** Transforms one WGS84 region sample into the selected output frame. */
       transformRegionSample(sample) {
-        const [longitudeDegrees, latitudeDegrees, height] = sample;
-        const targetCrs = this.spatialReference.targetCrs || this.spatialReference.sourceCrs;
-        if (targetCrs && getSpatialCoordinateFrame(targetCrs) === "geocentric") {
-          const cartesian = Ellipsoid3.WGS84.cartographicToCartesian([
-            longitudeDegrees,
-            latitudeDegrees,
-            height
-          ]);
-          return Array.from(cartesian);
-        }
         return this.geographicCoordinateTransformer.transformPosition(sample);
       }
     };
@@ -21193,12 +21188,12 @@ var init_tiles_3d_spatial_transformer = __esm({
 
 // ../../modules/tiles/src/tileset-3d/helpers/s2-bounding-volume.ts
 import { getS2Bounds } from "@math.gl/dggs/s2";
-import { Ellipsoid as Ellipsoid4, makeOBBFromRegion as makeOBBFromRegion2 } from "@math.gl/geospatial";
+import { Ellipsoid as Ellipsoid3, makeOBBFromRegion as makeOBBFromRegion2 } from "@math.gl/geospatial";
 function convertS2BoundingVolumeToOBB(s2VolumeInfo) {
   const [[west, south], [east, north]] = getS2Bounds(s2VolumeInfo.token);
   const orientedBoundingBox = makeOBBFromRegion2(
     [west, south, east, north, s2VolumeInfo.minimumHeight, s2VolumeInfo.maximumHeight],
-    Ellipsoid4.WGS84,
+    Ellipsoid3.WGS84,
     { units: "degrees" }
   );
   return [...orientedBoundingBox.center, ...orientedBoundingBox.halfAxes];
@@ -21264,7 +21259,7 @@ var init_implicit_tiling = __esm({
 
 // ../../modules/tiles/src/spatial/i3s-spatial-transformer.ts
 import { Matrix3 as Matrix33, Matrix4 as Matrix44, Quaternion as Quaternion3, Vector3 as Vector35 } from "@math.gl/core";
-import { Ellipsoid as Ellipsoid5 } from "@math.gl/geospatial";
+import { Ellipsoid as Ellipsoid4 } from "@math.gl/geospatial";
 function getElevationProvider(mode, options) {
   return mode === "relativeToScene" ? options.sceneElevationProvider : requiresElevationSurface(mode) ? options.terrainElevationProvider : void 0;
 }
@@ -21295,7 +21290,7 @@ function getGeographicBoundingSphere(geographicSamples) {
     throw new Error("I3S spatial transformation requires at least one bound sample");
   }
   const cartesianSamples = geographicSamples.map(
-    (position) => Ellipsoid5.WGS84.cartographicToCartesian(new Vector35(position))
+    (position) => Ellipsoid4.WGS84.cartographicToCartesian(new Vector35(position))
   );
   const cartesianCenter = new Vector35();
   for (const sample of cartesianSamples) {
@@ -21306,7 +21301,7 @@ function getGeographicBoundingSphere(geographicSamples) {
   for (const sample of cartesianSamples) {
     radius = Math.max(radius, new Vector35(sample).subtract(cartesianCenter).magnitude());
   }
-  const geographicCenter = Ellipsoid5.WGS84.cartesianToCartographic(cartesianCenter);
+  const geographicCenter = Ellipsoid4.WGS84.cartesianToCartographic(cartesianCenter);
   return [geographicCenter[0], geographicCenter[1], geographicCenter[2], radius];
 }
 function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransformer, sourceVerticalUnitScale) {
@@ -21323,7 +21318,7 @@ function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransforme
     ];
     if (sourceFrame === "geographic") {
       const geographicCenter = sourceToGeographicTransformer.transformPosition(center2);
-      const cartesianCenter = Ellipsoid5.WGS84.cartographicToCartesian(
+      const cartesianCenter = Ellipsoid4.WGS84.cartographicToCartesian(
         new Vector35(geographicCenter)
       );
       const cartesianAxes = bounds.normalReferenceFrame === "vertex-reference-frame" ? axes.map((axis) => localEnuVectorToEcef(axis, geographicCenter)) : axes;
@@ -21332,7 +21327,7 @@ function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransforme
         for (let axisIndex = 0; axisIndex < 3; axisIndex++) {
           corner.add(new Vector35(cartesianAxes[axisIndex]).scale(signs[axisIndex]));
         }
-        return Array.from(Ellipsoid5.WGS84.cartesianToCartographic(corner));
+        return Array.from(Ellipsoid4.WGS84.cartesianToCartographic(corner));
       });
     }
     return getBoxSigns().map((signs) => {
@@ -21352,10 +21347,10 @@ function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransforme
   const radius = mbs[3];
   if (sourceFrame === "geographic") {
     const geographicCenter = sourceToGeographicTransformer.transformPosition(center);
-    const cartesianCenter = Ellipsoid5.WGS84.cartographicToCartesian(new Vector35(geographicCenter));
+    const cartesianCenter = Ellipsoid4.WGS84.cartographicToCartesian(new Vector35(geographicCenter));
     return getAxisDirections().map(
       (direction) => Array.from(
-        Ellipsoid5.WGS84.cartesianToCartographic(
+        Ellipsoid4.WGS84.cartesianToCartographic(
           new Vector35(cartesianCenter).add(new Vector35(direction).scale(radius))
         )
       )
@@ -21667,6 +21662,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);
@@ -21704,7 +21727,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],
@@ -21754,14 +21789,14 @@ var init_i3s_spatial_transformer = __esm({
       /** Rebuild an I3S bound as a WGS84 ECEF box for generic `Tileset3D` traversal. */
       transformBoundingVolumeToGeocentric(bounds) {
         const cartesianSamples = this.getGeographicBoundSamples(bounds).map(
-          (position) => Array.from(Ellipsoid5.WGS84.cartographicToCartesian(new Vector35(position)))
+          (position) => Array.from(Ellipsoid4.WGS84.cartographicToCartesian(new Vector35(position)))
         );
         return { box: getAxisAlignedBox(cartesianSamples) };
       }
       /** Rebuild an I3S bound as WGS84 ECEF after asynchronous elevation placement. */
       async transformBoundingVolumeToGeocentricAsync(bounds) {
         const cartesianSamples = (await this.getGeographicBoundSamplesAsync(bounds)).map(
-          (position) => Array.from(Ellipsoid5.WGS84.cartographicToCartesian(new Vector35(position)))
+          (position) => Array.from(Ellipsoid4.WGS84.cartographicToCartesian(new Vector35(position)))
         );
         return { box: getAxisAlignedBox(cartesianSamples) };
       }
@@ -21791,7 +21826,7 @@ var init_i3s_spatial_transformer = __esm({
       async transformBoundsAsync(bounds) {
         const geographicSamples = await this.getGeographicBoundSamplesAsync(bounds);
         const cartesianSamples = geographicSamples.map(
-          (position) => Array.from(Ellipsoid5.WGS84.cartographicToCartesian(new Vector35(position)))
+          (position) => Array.from(Ellipsoid4.WGS84.cartographicToCartesian(new Vector35(position)))
         );
         const targetSamples = geographicSamples.map(
           (position) => this.geographicToTargetTransformer.transformPosition(position)
@@ -21950,13 +21985,13 @@ var init_i3s_spatial_transformer = __esm({
         if (this.targetCoordinateFrame === "geographic") {
           return ecefVectorToLocalEnu(ecefNormal, geographic).normalize();
         }
-        const cartesian = Ellipsoid5.WGS84.cartographicToCartesian(new Vector35(geographic));
+        const cartesian = Ellipsoid4.WGS84.cartographicToCartesian(new Vector35(geographic));
         const jacobianColumns = [];
         for (const direction of getPositiveAxisDirections()) {
-          const positiveGeographic = Ellipsoid5.WGS84.cartesianToCartographic(
+          const positiveGeographic = Ellipsoid4.WGS84.cartesianToCartographic(
             new Vector35(cartesian).add(direction)
           );
-          const negativeGeographic = Ellipsoid5.WGS84.cartesianToCartographic(
+          const negativeGeographic = Ellipsoid4.WGS84.cartesianToCartographic(
             new Vector35(cartesian).subtract(direction)
           );
           const positiveTarget = this.geographicToTargetTransformer.transformPosition(positiveGeographic);
@@ -23328,7 +23363,7 @@ var init_parse_3d_tile_batched_model = __esm({
 
 // ../../modules/3d-tiles/src/lib/parsers/parse-3d-tile-instanced-model.ts
 import { Vector3 as Vector39, Matrix3 as Matrix34, Matrix4 as Matrix45, Quaternion as Quaternion4 } from "@math.gl/core";
-import { Ellipsoid as Ellipsoid6 } from "@math.gl/geospatial";
+import { Ellipsoid as Ellipsoid5 } from "@math.gl/geospatial";
 import { GL as GL8, octDecodeInRange } from "@math.gl/geometry-utils";
 async function parseInstancedModel3DTile(tile, arrayBuffer, byteOffset, options, context) {
   byteOffset = parseInstancedModel(tile, arrayBuffer, byteOffset, options, context);
@@ -23462,7 +23497,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
         tile.hasCustomOrientation = true;
         hasCustomOrientation = true;
       } else if (tile.eastNorthUp) {
-        Ellipsoid6.WGS84.eastNorthUpToFixedFrame(instancePosition, instanceTransform);
+        Ellipsoid5.WGS84.eastNorthUpToFixedFrame(instancePosition, instanceTransform);
         instanceTransform.getRotationMatrix3(instanceRotation);
       } else {
         instanceRotation.identity();
@@ -24243,7 +24278,7 @@ var init_parse_3d_tile_subtree = __esm({
 
 // ../../modules/3d-tiles/src/lib/parsers/parse-3d-tiles-2-gltf.ts
 import { Matrix4 as Matrix47 } from "@math.gl/core";
-import { Ellipsoid as Ellipsoid7 } from "@math.gl/geospatial";
+import { Ellipsoid as Ellipsoid6 } from "@math.gl/geospatial";
 function is3DTiles2Tileset(gltf) {
   return isRecord4(gltf.json.extensions?.[TILESET_EXTENSION]);
 }
@@ -25022,7 +25057,7 @@ function getGeoreferenceMatrix(longitudeDegrees, latitudeDegrees, height) {
   const sinLongitude = Math.sin(longitude);
   const cosLatitude = Math.cos(latitude);
   const sinLatitude = Math.sin(latitude);
-  const position = Ellipsoid7.WGS84.cartographicToCartesian([longitude, latitude, height]);
+  const position = Ellipsoid6.WGS84.cartographicToCartesian([longitude, latitude, height]);
   return new Matrix47([
     sinLongitude,
     -cosLongitude,
@@ -27715,119 +27750,361 @@ var init_compression = __esm({
   }
 });
 
-// ../../modules/compression/src/lib/fflate/index.ts
-function inflateSync(data, out) {
-  return inflt(data, out);
+// ../../modules/compression/src/lib/decompression-stream.ts
+async function decompressWithNativeDecompressionStream(input, format) {
+  const outputBatches = decompressBatchesWithNativeDecompressionStream([input], format);
+  return outputBatches ? await concatenateNativeDecompressionBatches(outputBatches) : null;
 }
-function gunzipSync(data, out) {
-  return inflt(data.subarray(gzs(data), -8), out || new u8(gzl(data)));
+function decompressBatchesWithNativeDecompressionStream(inputBatches, format) {
+  const decompressionStream = createNativeDecompressionStream(format);
+  return decompressionStream ? transformBatchesWithNativeDecompressionStream(inputBatches, decompressionStream) : null;
 }
-function unzlibSync(data, out) {
-  return inflt((zlv(data), data.subarray(2, -4)), out);
+function isNativeDecompressionSupported(format) {
+  return Boolean(createNativeDecompressionStream(format));
 }
-var u8, u16, u32, fleb, fdeb, clim, freb, fl, revfl, fd, revfd, rev, hMap, flt, fdt, flrm, fdrm, max, bits, bits16, shft, slc, ec, err, inflt, gzs, gzl, zlv, Inflate, Gunzip, Unzlib;
-var init_fflate = __esm({
-  "../../modules/compression/src/lib/fflate/index.ts"() {
+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 (error) {
+    if (error instanceof TypeError || 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({
+  "../../modules/compression/src/lib/decompression-stream.ts"() {
     "use strict";
-    u8 = Uint8Array;
-    u16 = Uint16Array;
-    u32 = Uint32Array;
-    fleb = new u8([
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      1,
-      1,
-      1,
-      1,
-      2,
-      2,
-      2,
-      2,
-      3,
-      3,
-      3,
-      3,
-      4,
-      4,
-      4,
-      4,
-      5,
-      5,
-      5,
-      5,
-      0,
-      /* unused */
-      0,
-      0,
-      /* impossible */
-      0
-    ]);
-    fdeb = new u8([
-      0,
-      0,
-      0,
-      0,
-      1,
-      1,
-      2,
-      2,
-      3,
-      3,
-      4,
-      4,
-      5,
-      5,
-      6,
-      6,
-      7,
-      7,
-      8,
-      8,
-      9,
-      9,
-      10,
-      10,
-      11,
-      11,
-      12,
-      12,
-      13,
-      13,
-      /* unused */
-      0,
-      0
-    ]);
-    clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
-    freb = (eb, start) => {
-      const b = new u16(31);
-      for (let i = 0; i < 31; ++i) {
-        b[i] = start += 1 << eb[i - 1];
+  }
+});
+
+// ../../modules/compression/src/lib/native-decompressor.ts
+var native_decompressor_exports = {};
+__export(native_decompressor_exports, {
+  NativeDecompressor: () => NativeDecompressor
+});
+var NativeDecompressor;
+var init_native_decompressor = __esm({
+  "../../modules/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;
       }
-      const r = new u32(b[30]);
-      for (let i = 1; i < 30; ++i) {
-        for (let j = b[i]; j < b[i + 1]; ++j) {
-          r[j] = j - b[i] << 5 | i;
-        }
+      /** 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;
       }
-      return [b, r];
     };
-    [fl, revfl] = freb(fleb, 2);
-    fl[28] = 258, revfl[258] = 28;
-    [fd, revfd] = freb(fdeb, 0);
-    rev = new u16(32768);
-    for (let i = 0; i < 32768; ++i) {
-      let x = (i & 43690) >>> 1 | (i & 21845) << 1;
-      x = (x & 52428) >>> 2 | (x & 13107) << 2;
-      x = (x & 61680) >>> 4 | (x & 3855) << 4;
-      rev[i] = ((x & 65280) >>> 8 | (x & 255) << 8) >>> 1;
-    }
-    hMap = (cd, mb, r) => {
+  }
+});
+
+// ../../modules/compression/src/lib/lazy-compression.ts
+function mergeModules(options, modules) {
+  return { ...options, modules: { ...options.modules, ...modules } };
+}
+var LazyDecompressor;
+var init_lazy_compression = __esm({
+  "../../modules/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);
+      }
+    };
+  }
+});
+
+// ../../modules/compression/src/no-decompressor.ts
+var no_decompressor_exports = {};
+__export(no_decompressor_exports, {
+  NoDecompressor: () => NoDecompressor
+});
+var NoDecompressor;
+var init_no_decompressor = __esm({
+  "../../modules/compression/src/no-decompressor.ts"() {
+    "use strict";
+    init_compression();
+    NoDecompressor = class extends Decompressor {
+      name = "uncompressed";
+      extensions = [];
+      contentEncodings = [];
+      isSupported = true;
+      constructor(options = {}) {
+        super(options);
+      }
+      /** Returns the input without modification. */
+      decompressSync(input) {
+        return input;
+      }
+    };
+  }
+});
+
+// ../../modules/compression/src/lib/fflate/index.ts
+function inflateSync(data, out) {
+  return inflt(data, out);
+}
+function gunzipSync(data, out) {
+  return inflt(data.subarray(gzs(data), -8), out || new u8(gzl(data)));
+}
+function unzlibSync(data, out) {
+  return inflt((zlv(data), data.subarray(2, -4)), out);
+}
+var u8, u16, u32, fleb, fdeb, clim, freb, fl, revfl, fd, revfd, rev, hMap, flt, fdt, flrm, fdrm, max, bits, bits16, shft, slc, ec, err, inflt, gzs, gzl, zlv, Inflate, Gunzip, Unzlib;
+var init_fflate = __esm({
+  "../../modules/compression/src/lib/fflate/index.ts"() {
+    "use strict";
+    u8 = Uint8Array;
+    u16 = Uint16Array;
+    u32 = Uint32Array;
+    fleb = new u8([
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      1,
+      1,
+      1,
+      2,
+      2,
+      2,
+      2,
+      3,
+      3,
+      3,
+      3,
+      4,
+      4,
+      4,
+      4,
+      5,
+      5,
+      5,
+      5,
+      0,
+      /* unused */
+      0,
+      0,
+      /* impossible */
+      0
+    ]);
+    fdeb = new u8([
+      0,
+      0,
+      0,
+      0,
+      1,
+      1,
+      2,
+      2,
+      3,
+      3,
+      4,
+      4,
+      5,
+      5,
+      6,
+      6,
+      7,
+      7,
+      8,
+      8,
+      9,
+      9,
+      10,
+      10,
+      11,
+      11,
+      12,
+      12,
+      13,
+      13,
+      /* unused */
+      0,
+      0
+    ]);
+    clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+    freb = (eb, start) => {
+      const b = new u16(31);
+      for (let i = 0; i < 31; ++i) {
+        b[i] = start += 1 << eb[i - 1];
+      }
+      const r = new u32(b[30]);
+      for (let i = 1; i < 30; ++i) {
+        for (let j = b[i]; j < b[i + 1]; ++j) {
+          r[j] = j - b[i] << 5 | i;
+        }
+      }
+      return [b, r];
+    };
+    [fl, revfl] = freb(fleb, 2);
+    fl[28] = 258, revfl[258] = 28;
+    [fd, revfd] = freb(fdeb, 0);
+    rev = new u16(32768);
+    for (let i = 0; i < 32768; ++i) {
+      let x = (i & 43690) >>> 1 | (i & 21845) << 1;
+      x = (x & 52428) >>> 2 | (x & 13107) << 2;
+      x = (x & 61680) >>> 4 | (x & 3855) << 4;
+      rev[i] = ((x & 65280) >>> 8 | (x & 255) << 8) >>> 1;
+    }
+    hMap = (cd, mb, r) => {
       const s = cd.length;
       let i = 0;
       const l = new u16(mb);
@@ -28030,374 +28307,132 @@ var init_fflate = __esm({
               buf[bt + 1] = buf[bt + 1 - dt];
               buf[bt + 2] = buf[bt + 2 - dt];
               buf[bt + 3] = buf[bt + 3 - dt];
-            }
-            bt = end;
-          }
-        }
-        st.l = lm, st.p = lpos, st.b = bt, st.f = final;
-        if (lm) final = 1, st.m = lbt, st.d = dm, st.n = dbt;
-      } while (!final);
-      return bt == buf.length ? buf : slc(buf, 0, bt);
-    };
-    gzs = (d) => {
-      if (d[0] != 31 || d[1] != 139 || d[2] != 8) err(6, "invalid gzip data");
-      const flg = d[3];
-      let st = 10;
-      if (flg & 4) st += d[10] | (d[11] << 8) + 2;
-      for (let zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++]) ;
-      return st + (flg & 2);
-    };
-    gzl = (d) => {
-      const l = d.length;
-      return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
-    };
-    zlv = (d) => {
-      if ((d[0] & 15) != 8 || d[0] >>> 4 > 7 || (d[0] << 8 | d[1]) % 31) err(6, "invalid zlib data");
-      if (d[1] & 32) err(6, "invalid zlib data: preset dictionaries not supported");
-    };
-    Inflate = class {
-      /**
-       * Creates an inflation stream
-       * @param cb The callback to call whenever data is inflated
-       */
-      constructor(cb) {
-        this.ondata = cb;
-      }
-      /** Persistent bit-reader and Huffman decoding state. */
-      s = {};
-      /** Compression options or retained output window for this stream. */
-      o;
-      /** Compressed bytes pending decoding. */
-      p = new u8(0);
-      /** Whether the stream has received its final chunk. */
-      d;
-      /**
-       * The handler to call whenever data is available
-       */
-      ondata;
-      /** Appends pending input after checking stream lifecycle. */
-      e(c) {
-        if (!this.ondata) err(5);
-        if (this.d) err(4);
-        const l = this.p.length;
-        const n = new u8(l + c.length);
-        n.set(this.p), n.set(c, l), this.p = n;
-      }
-      /** Decodes pending input and retains the sliding window. */
-      c(final) {
-        this.d = this.s.i = final || false;
-        const bts = this.s.b;
-        const dt = inflt(this.p, this.o, this.s);
-        this.ondata(slc(dt, bts, this.s.b), this.d);
-        this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;
-        this.p = slc(this.p, this.s.p / 8 | 0), this.s.p &= 7;
-      }
-      /**
-       * Pushes a chunk to be inflated
-       * @param chunk The chunk to push
-       * @param final Whether this is the final chunk
-       */
-      push(chunk, final) {
-        this.e(chunk), this.c(final);
-      }
-    };
-    Gunzip = class extends Inflate {
-      /** Whether the stream header still needs to be emitted or consumed. */
-      v = 1;
-      /**
-       * Creates a GUNZIP stream
-       * @param cb The callback to call whenever data is inflated
-       */
-      constructor(cb) {
-        super(cb);
-      }
-      /**
-       * Pushes a chunk to be GUNZIPped
-       * @param chunk The chunk to push
-       * @param final Whether this is the last chunk
-       */
-      push(chunk, final) {
-        Inflate.prototype.e.call(this, chunk);
-        if (this.v) {
-          const s = this.p.length > 3 ? gzs(this.p) : 4;
-          if (s >= this.p.length && !final) return;
-          this.p = this.p.subarray(s), this.v = 0;
-        }
-        if (final) {
-          if (this.p.length < 8) err(6, "invalid gzip data");
-          this.p = this.p.subarray(0, -8);
-        }
-        Inflate.prototype.c.call(this, final);
-      }
-    };
-    Unzlib = class extends Inflate {
-      /** Whether the stream header still needs to be emitted or consumed. */
-      v = 1;
-      /**
-       * Creates a Zlib decompression stream
-       * @param cb The callback to call whenever data is inflated
-       */
-      constructor(cb) {
-        super(cb);
-      }
-      /**
-       * Pushes a chunk to be unzlibbed
-       * @param chunk The chunk to push
-       * @param final Whether this is the last chunk
-       */
-      push(chunk, final) {
-        Inflate.prototype.e.call(this, chunk);
-        if (this.v) {
-          if (this.p.length < 2 && !final) return;
-          this.p = this.p.subarray(2), this.v = 0;
-        }
-        if (final) {
-          if (this.p.length < 4) err(6, "invalid zlib data");
-          this.p = this.p.subarray(0, -4);
-        }
-        Inflate.prototype.c.call(this, final);
-      }
-    };
-  }
-});
-
-// ../../modules/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) {
-  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 (error) {
-    if (error instanceof TypeError || 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({
-  "../../modules/compression/src/lib/decompression-stream.ts"() {
-    "use strict";
-  }
-});
-
-// ../../modules/compression/src/lib/native-decompressor.ts
-var native_decompressor_exports = {};
-__export(native_decompressor_exports, {
-  NativeDecompressor: () => NativeDecompressor
-});
-var NativeDecompressor;
-var init_native_decompressor = __esm({
-  "../../modules/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;
+            }
+            bt = end;
+          }
+        }
+        st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+        if (lm) final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+      } while (!final);
+      return bt == buf.length ? buf : slc(buf, 0, bt);
+    };
+    gzs = (d) => {
+      if (d[0] != 31 || d[1] != 139 || d[2] != 8) err(6, "invalid gzip data");
+      const flg = d[3];
+      let st = 10;
+      if (flg & 4) st += d[10] | (d[11] << 8) + 2;
+      for (let zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++]) ;
+      return st + (flg & 2);
+    };
+    gzl = (d) => {
+      const l = d.length;
+      return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
+    };
+    zlv = (d) => {
+      if ((d[0] & 15) != 8 || d[0] >>> 4 > 7 || (d[0] << 8 | d[1]) % 31) err(6, "invalid zlib data");
+      if (d[1] & 32) err(6, "invalid zlib data: preset dictionaries not supported");
+    };
+    Inflate = class {
+      /**
+       * Creates an inflation stream
+       * @param cb The callback to call whenever data is inflated
+       */
+      constructor(cb) {
+        this.ondata = cb;
       }
-      /** Decompresses one buffer with the runtime-provided stream. */
-      async decompress(input) {
-        const output = await decompressWithNativeDecompressionStream(input, this.format);
-        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
-        return output;
+      /** Persistent bit-reader and Huffman decoding state. */
+      s = {};
+      /** Compression options or retained output window for this stream. */
+      o;
+      /** Compressed bytes pending decoding. */
+      p = new u8(0);
+      /** Whether the stream has received its final chunk. */
+      d;
+      /**
+       * The handler to call whenever data is available
+       */
+      ondata;
+      /** Appends pending input after checking stream lifecycle. */
+      e(c) {
+        if (!this.ondata) err(5);
+        if (this.d) err(4);
+        const l = this.p.length;
+        const n = new u8(l + c.length);
+        n.set(this.p), n.set(c, l), this.p = n;
       }
-      /** Decompresses batches incrementally with the runtime-provided stream. */
-      async *decompressBatches(inputBatches) {
-        const output = decompressBatchesWithNativeDecompressionStream(inputBatches, this.format);
-        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
-        yield* output;
+      /** Decodes pending input and retains the sliding window. */
+      c(final) {
+        this.d = this.s.i = final || false;
+        const bts = this.s.b;
+        const dt = inflt(this.p, this.o, this.s);
+        this.ondata(slc(dt, bts, this.s.b), this.d);
+        this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;
+        this.p = slc(this.p, this.s.p / 8 | 0), this.s.p &= 7;
       }
-    };
-  }
-});
-
-// ../../modules/compression/src/lib/lazy-compression.ts
-function mergeModules(options, modules) {
-  return { ...options, modules: { ...options.modules, ...modules } };
-}
-var LazyDecompressor;
-var init_lazy_compression = __esm({
-  "../../modules/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;
+      /**
+       * 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);
       }
-      /** 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;
-        }
+    };
+    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);
       }
-      /** 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);
+      /**
+       * 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;
         }
-        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()`);
+        if (final) {
+          if (this.p.length < 8) err(6, "invalid gzip data");
+          this.p = this.p.subarray(0, -8);
         }
-        return this.implementation.decompressSync(input, size);
-      }
-      /** Decompresses batches after lazily selecting the default implementation. */
-      async *decompressBatches(inputBatches) {
-        yield* (await this.preload()).decompressBatches(inputBatches);
+        Inflate.prototype.c.call(this, final);
       }
     };
-  }
-});
-
-// ../../modules/compression/src/no-decompressor.ts
-var no_decompressor_exports = {};
-__export(no_decompressor_exports, {
-  NoDecompressor: () => NoDecompressor
-});
-var NoDecompressor;
-var init_no_decompressor = __esm({
-  "../../modules/compression/src/no-decompressor.ts"() {
-    "use strict";
-    init_compression();
-    NoDecompressor = class extends Decompressor {
-      name = "uncompressed";
-      extensions = [];
-      contentEncodings = [];
-      isSupported = true;
-      constructor(options = {}) {
-        super(options);
+    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);
       }
-      /** Returns the input without modification. */
-      decompressSync(input) {
-        return input;
+      /**
+       * 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);
       }
     };
   }
@@ -29252,6 +29287,7 @@ var init_i3s_loader_options = __esm({
       decodeTextures: true,
       attributeValues: "legacy",
       colorFormat: "uint8norm",
+      geometryMode: "render",
       coordinateSystem: COORDINATE_SYSTEM.METER_OFFSETS
     };
   }
@@ -29320,7 +29356,7 @@ var init_url_utils2 = __esm({
 
 // ../../modules/i3s/src/lib/parsers/parse-i3s-tile-content.ts
 import { Vector3 as Vector314, Matrix4 as Matrix411 } from "@math.gl/core";
-import { Ellipsoid as Ellipsoid12 } from "@math.gl/geospatial";
+import { Ellipsoid as Ellipsoid11 } from "@math.gl/geospatial";
 function getRequiredContext(context, operation) {
   if (!context) {
     throw new Error(
@@ -29343,7 +29379,12 @@ function getLoaderForTextureFormat(textureFormat) {
   }
 }
 async function parseI3STileContent(arrayBuffer, tileOptions, tilesetOptions, options, context) {
+  const geometryMode = options?.i3s?.geometryMode ?? "render";
+  if (geometryMode !== "render" && geometryMode !== "source") {
+    throw new Error("Unsupported I3S geometry mode");
+  }
   const content = {
+    geometryMode,
     attributes: {},
     indices: null,
     featureIds: [],
@@ -29493,6 +29534,13 @@ async function parseI3SNodeGeometry(arrayBuffer, content, tileOptions, tilesetOp
       id: featureIndex
     };
     copyDracoTextureCoordinates(attributes, decompressedGeometry.attributes);
+    if (content.geometryMode === "source") {
+      for (const [name18, attribute] of Object.entries(decompressedGeometry.attributes)) {
+        if (!["POSITION", "NORMAL", "COLOR_0", "feature-index", "uv-region"].includes(name18) && !/^TEXCOORD_\d+$/.test(name18)) {
+          attributes[name18] = attribute;
+        }
+      }
+    }
     updateAttributesMetadata(attributes, decompressedGeometry);
     const featureIds = getFeatureIdsFromFeatureIndexMetadata(featureIndex);
     if (featureIds) {
@@ -29541,7 +29589,32 @@ async function parseI3SNodeGeometry(arrayBuffer, content, tileOptions, tilesetOp
     attributes = concatAttributes(normalizedVertexAttributes, normalizedFeatureAttributes);
   }
   const spatialReference = tilesetOptions.spatialReference;
-  if (spatialReference?.status === "transformable" || 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?.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?.status === "transformable" || spatialReference?.status === "transformed") {
     const spatialTransformer = new I3SSpatialTransformer(
       spatialReference,
       tilesetOptions.spatialOptions || options?.i3s?.spatial
@@ -29792,15 +29865,15 @@ function parsePositions2(attribute, options) {
   const enuMatrix = new Matrix411();
   const cartographicOrigin = new Vector314(mbs[0], mbs[1], mbs[2]);
   const cartesianOrigin = new Vector314();
-  Ellipsoid12.WGS84.cartographicToCartesian(cartographicOrigin, cartesianOrigin);
-  Ellipsoid12.WGS84.eastNorthUpToFixedFrame(cartesianOrigin, enuMatrix);
+  Ellipsoid11.WGS84.cartographicToCartesian(cartographicOrigin, cartesianOrigin);
+  Ellipsoid11.WGS84.eastNorthUpToFixedFrame(cartesianOrigin, enuMatrix);
   attribute.value = offsetsToCartesians(value, metadata, cartographicOrigin);
   return enuMatrix;
 }
 function offsetsToSourcePositions(vertices, metadata = {}, sourceOrigin) {
   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 = metadata["i3s-scale_x"]?.double ?? 1;
+  const scaleY = metadata["i3s-scale_y"]?.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];
@@ -29811,7 +29884,7 @@ function offsetsToSourcePositions(vertices, metadata = {}, sourceOrigin) {
 function offsetsToCartesians(vertices, metadata = {}, cartographicOrigin) {
   const positions = offsetsToSourcePositions(vertices, metadata, cartographicOrigin);
   for (let i = 0; i < positions.length; i += 3) {
-    Ellipsoid12.WGS84.cartographicToCartesian(positions.subarray(i, i + 3), scratchVector3);
+    Ellipsoid11.WGS84.cartographicToCartesian(positions.subarray(i, i + 3), scratchVector3);
     positions[i] = scratchVector3.x;
     positions[i + 1] = scratchVector3.y;
     positions[i + 2] = scratchVector3.z;
@@ -30499,7 +30572,7 @@ var init_i3s_nodepages_tiles = __esm({
 
 // ../../modules/i3s/src/lib/parsers/parse-i3s.ts
 import { OrientedBoundingBox as OrientedBoundingBox4 } from "@math.gl/culling";
-import { Ellipsoid as Ellipsoid13 } from "@math.gl/geospatial";
+import { Ellipsoid as Ellipsoid12 } from "@math.gl/geospatial";
 async function normalizeTileData2(tile, context) {
   const url = context.url || "";
   let contentUrl;
@@ -30624,14 +30697,14 @@ function normalizeTileNonUrlData(tile) {
   if (tile.mbs) {
     mbs = tile.mbs;
     boundingVolume.sphere = [
-      ...Ellipsoid13.WGS84.cartographicToCartesian(tile.mbs.slice(0, 3)),
+      ...Ellipsoid12.WGS84.cartographicToCartesian(tile.mbs.slice(0, 3)),
       // cartesian center of sphere
       tile.mbs[3]
       // radius of sphere
     ];
   } else if (tile.obb) {
     boundingVolume.box = [
-      ...Ellipsoid13.WGS84.cartographicToCartesian(tile.obb.center),
+      ...Ellipsoid12.WGS84.cartographicToCartesian(tile.obb.center),
       // cartesian center of box
       ...tile.obb.halfSize,
       // halfSize
@@ -31013,10 +31086,11 @@ function parseI3STileAttribute(arrayBuffer, options) {
     [attributeName]: attributeType ? parseAttribute(attributeType, arrayBuffer, options.i3s?.attributeValues === "exact") : null
   };
 }
-function parseAttribute(attributeType, arrayBuffer, exactStrings = false) {
+function parseAttribute(attributeType, arrayBuffer, exactValues = false) {
+  if (exactValues) validateExactNumericLayout(attributeType, arrayBuffer);
   switch (attributeType) {
     case STRING_ATTRIBUTE_TYPE:
-      return parseStringsAttribute(arrayBuffer, exactStrings);
+      return parseStringsAttribute(arrayBuffer, exactValues);
     case OBJECT_ID_ATTRIBUTE_TYPE:
       return parseShortNumberAttribute(arrayBuffer);
     case FLOAT_64_TYPE:
@@ -31028,14 +31102,44 @@ function parseAttribute(attributeType, arrayBuffer, exactStrings = false) {
     case INT_16_ATTRIBUTE_TYPE:
     case "Int32":
     case "Int64":
-      return parseNumericAttribute(attributeType, arrayBuffer);
+      return parseNumericAttribute(attributeType, arrayBuffer, exactValues);
     default:
       return parseShortNumberAttribute(arrayBuffer);
   }
 }
-function parseNumericAttribute(attributeType, arrayBuffer) {
+function validateExactNumericLayout(attributeType, arrayBuffer) {
+  if (attributeType === "String") return;
+  const widths = {
+    Oid32: 4,
+    UInt8: 1,
+    UInt16: 2,
+    UInt32: 4,
+    UInt64: 8,
+    Int16: 2,
+    Int32: 4,
+    Int64: 8,
+    Float32: 4,
+    Float64: 8
+  };
+  const width = Object.hasOwn(widths, attributeType) ? widths[attributeType] : void 0;
+  const valueOffset = Math.max(4, width || 0);
+  if (!width || arrayBuffer.byteLength < valueOffset || new DataView(arrayBuffer).getUint32(0, true) * width !== arrayBuffer.byteLength - valueOffset) {
+    throw new Error(
+      "Exact I3S attributes require a supported scalar type and matching count/length"
+    );
+  }
+}
+function parseNumericAttribute(attributeType, arrayBuffer, exactValues) {
   const valueOffset = attributeType === "Float64" || attributeType === "Int64" || attributeType === "UInt64" ? 8 : 4;
   if (attributeType === "UInt64" || attributeType === "Int64") {
+    if (exactValues) {
+      const values = attributeType === "UInt64" ? new BigUint64Array((arrayBuffer.byteLength - valueOffset) / 8) : new BigInt64Array((arrayBuffer.byteLength - valueOffset) / 8);
+      const view = new DataView(arrayBuffer);
+      for (let index = 0; index < values.length; index++) {
+        values[index] = attributeType === "UInt64" ? view.getBigUint64(valueOffset + index * 8, true) : view.getBigInt64(valueOffset + index * 8, true);
+      }
+      return values;
+    }
     return parseInt64Attribute(attributeType, arrayBuffer, valueOffset);
   }
   const TypedArrayType = getNumericAttributeConstructor(attributeType);
@@ -32349,7 +32453,7 @@ init_src8();
 init_src5();
 init_src2();
 import { Vector3 as Vector312, Matrix4 as Matrix49, Vector4 as Vector42 } from "@math.gl/core";
-import { Ellipsoid as Ellipsoid10 } from "@math.gl/geospatial";
+import { Ellipsoid as Ellipsoid9 } from "@math.gl/geospatial";
 import { createRequire } from "node:module";
 import md5 from "md5";
 import { v4 as uuidv4 } from "uuid";
@@ -32568,7 +32672,7 @@ function encodeStringAttribute(values) {
 
 // src/v4/i3s-converter/helpers/coordinate-converter.ts
 import { Matrix3 as Matrix35, Quaternion as Quaternion5, Vector3 as Vector310 } from "@math.gl/core";
-import { Ellipsoid as Ellipsoid8 } from "@math.gl/geospatial";
+import { Ellipsoid as Ellipsoid7 } from "@math.gl/geospatial";
 import {
   OrientedBoundingBox as OrientedBoundingBox2,
   makeOrientedBoundingBoxFromPoints,
@@ -32579,7 +32683,7 @@ function createBoundingVolumes(sourceBoundingVolume, geoidHeightModel) {
   let radius;
   let halfSize;
   let quaternion;
-  const cartographicCenter = Ellipsoid8.WGS84.cartesianToCartographic(
+  const cartographicCenter = Ellipsoid7.WGS84.cartesianToCartographic(
     sourceBoundingVolume.center,
     new Vector310()
   );
@@ -32608,8 +32712,8 @@ function createBoundingVolumesFromGeometry(cartesianPositions, geoidHeightModel)
   const positionVectors = convertPositionsToVectors(cartesianPositions);
   const geometryObb = makeOrientedBoundingBoxFromPoints(positionVectors);
   const geometryMbs = makeBoundingSphereFromPoints(positionVectors);
-  const mbsCenter = Ellipsoid8.WGS84.cartesianToCartographic(geometryMbs.center, new Vector310());
-  const obbCenter = Ellipsoid8.WGS84.cartesianToCartographic(geometryObb.center, new Vector310());
+  const mbsCenter = Ellipsoid7.WGS84.cartesianToCartographic(geometryMbs.center, new Vector310());
+  const obbCenter = Ellipsoid7.WGS84.cartesianToCartographic(geometryObb.center, new Vector310());
   if (geoidHeightModel) {
     mbsCenter[2] = mbsCenter[2] - geoidHeightModel.getHeight(mbsCenter[1], mbsCenter[0]);
     obbCenter[2] = obbCenter[2] - geoidHeightModel.getHeight(obbCenter[1], obbCenter[0]);
@@ -32640,11 +32744,11 @@ function convertBoundingVolumeToI3SFullExtent(boundingVolume) {
   }
   const center = sphere.center;
   const radius = sphere.radius;
-  const vertexMax = Ellipsoid8.WGS84.cartesianToCartographic(
+  const vertexMax = Ellipsoid7.WGS84.cartesianToCartographic(
     new Vector310(center[0] + radius, center[1] + radius, center[2] + radius),
     new Vector310()
   );
-  const vertexMin = Ellipsoid8.WGS84.cartesianToCartographic(
+  const vertexMin = Ellipsoid7.WGS84.cartesianToCartographic(
     new Vector310(center[0] - radius, center[1] - radius, center[2] - radius),
     new Vector310()
   );
@@ -32667,7 +32771,7 @@ function createObbFromMbs(mbs) {
 // src/v4/i3s-converter/helpers/gltf-attributes.ts
 init_src6();
 import { Matrix4 as Matrix48, Vector3 as Vector311 } from "@math.gl/core";
-import { Ellipsoid as Ellipsoid9 } from "@math.gl/geospatial";
+import { Ellipsoid as Ellipsoid8 } from "@math.gl/geospatial";
 function prepareDataForAttributesConversion(tileContent, tileTransform, boundingVolume) {
   const nodes = tileContent.gltf?.scene?.nodes || tileContent.gltf?.scenes?.[0]?.nodes || tileContent.gltf?.nodes || [];
   const images = tileContent.gltf?.images?.map((imageObject) => {
@@ -32730,7 +32834,7 @@ function calculateTransformProps(tileContent, tileTransform, boundingVolume) {
       break;
   }
   const cartesianOrigin = new Vector311(center);
-  const cartographicOrigin = Ellipsoid9.WGS84.cartesianToCartographic(
+  const cartographicOrigin = Ellipsoid8.WGS84.cartesianToCartographic(
     cartesianOrigin,
     new Vector311()
   );
@@ -33116,7 +33220,7 @@ function _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeigh
     const cartographicOrigin = boundingVolumes.obb.center;
     for (let index = 0; index < attributes.positions.length; index += VALUES_PER_VERTEX2) {
       const vertex = attributes.positions.subarray(index, index + VALUES_PER_VERTEX2);
-      Ellipsoid10.WGS84.cartesianToCartographic(Array.from(vertex), scratchVector2);
+      Ellipsoid9.WGS84.cartesianToCartographic(Array.from(vertex), scratchVector2);
       if (geoidHeightModel) {
         scratchVector2[2] = scratchVector2[2] - geoidHeightModel.getHeight(scratchVector2[1], scratchVector2[0]);
       }
@@ -33450,7 +33554,7 @@ function transformVertexPositions(vertexVector, calleeArgs) {
   if (useCartesianPositions) {
     return vertexVector;
   }
-  Ellipsoid10.WGS84.cartesianToCartographic(
+  Ellipsoid9.WGS84.cartesianToCartographic(
     [vertexVector[0], vertexVector[1], vertexVector[2]],
     vertexVector
   );
@@ -34593,7 +34697,7 @@ function transfromTextureDefinitions(textureDefinitionInfos, thisObject, origina
 // src/v4/i3s-converter/helpers/node-debug.ts
 import { OrientedBoundingBox as OrientedBoundingBox3, BoundingSphere as BoundingSphere3 } from "@math.gl/culling";
 import { Vector3 as Vector313 } from "@math.gl/core";
-import { Ellipsoid as Ellipsoid11 } from "@math.gl/geospatial";
+import { Ellipsoid as Ellipsoid10 } from "@math.gl/geospatial";
 var CUBE_POSITIONS = new Float32Array([
   -1,
   -1,
@@ -34706,7 +34810,7 @@ function createBoundingBoxFromTileObb(obb) {
 function getTileObbVertices(node) {
   const halfSize = node.obb.halfSize;
   const positions = CUBE_POSITIONS;
-  const obbCenterCartesian = Ellipsoid11.WGS84.cartographicToCartesian(node.obb.center);
+  const obbCenterCartesian = Ellipsoid10.WGS84.cartographicToCartesian(node.obb.center);
   let vertices = [];
   for (let i = 0; i < positions.length; i += 3) {
     positions[i] *= halfSize[0];
@@ -34722,7 +34826,7 @@ function isAllVerticesInsideBoundingVolume(boundingVolume, positions) {
   let isVerticesInsideObb = true;
   for (let index = 0; index < positions.length / 3; index += 3) {
     const point = [positions[index], positions[index + 1], positions[index + 2]];
-    const cartographicPoint = Ellipsoid11.WGS84.cartesianToCartographic(point);
+    const cartographicPoint = Ellipsoid10.WGS84.cartesianToCartographic(point);
     const distance = boundingVolume.distanceTo(cartographicPoint);
     if (distance > 0) {
       isVerticesInsideObb = false;
@@ -37492,7 +37596,7 @@ function collectWktNodes(node) {
 
 // src/v4/3d-tiles-converter/helpers/i3s-obb-to-3d-tiles-obb.ts
 import { Vector3 as Vector315 } from "@math.gl/core";
-import { Ellipsoid as Ellipsoid14 } from "@math.gl/geospatial";
+import { Ellipsoid as Ellipsoid13 } from "@math.gl/geospatial";
 import { OrientedBoundingBox as OrientedBoundingBox5 } from "@math.gl/culling";
 function i3sObbTo3dTilesObb(i3SObb, geoidHeightModel) {
   const tiles3DCenter = [
@@ -37500,7 +37604,7 @@ function i3sObbTo3dTilesObb(i3SObb, geoidHeightModel) {
     i3SObb.center[1],
     i3SObb.center[2] + geoidHeightModel.getHeight(i3SObb.center[1], i3SObb.center[0])
   ];
-  const cartesianCenter = Ellipsoid14.WGS84.cartographicToCartesian(tiles3DCenter, new Vector315());
+  const cartesianCenter = Ellipsoid13.WGS84.cartographicToCartesian(tiles3DCenter, new Vector315());
   const tiles3DObb = new OrientedBoundingBox5().fromCenterHalfSizeQuaternion(
     cartesianCenter,
     i3SObb.halfSize,
@@ -37558,7 +37662,7 @@ init_src5();
 init_src9();
 import { Matrix4 as Matrix412, Vector3 as Vector316 } from "@math.gl/core";
 import { isTypedArray } from "@math.gl/types";
-import { Ellipsoid as Ellipsoid15 } from "@math.gl/geospatial";
+import { Ellipsoid as Ellipsoid14 } from "@math.gl/geospatial";
 
 // src/v4/3d-tiles-converter/helpers/texture-atlas.ts
 function convertTextureAtlas(texCoords, uvRegions) {
@@ -37653,7 +37757,7 @@ var Tiles3DContentConverter = class {
       );
     }
     const cartesianOrigin = new Vector316(box);
-    const cartographicOrigin = Ellipsoid15.WGS84.cartesianToCartographic(
+    const cartographicOrigin = Ellipsoid14.WGS84.cartesianToCartographic(
       cartesianOrigin,
       new Vector316()
     );
@@ -37818,7 +37922,7 @@ var Tiles3DContentConverter = class {
       const vertex = positionsValue.subarray(index, index + 3);
       const cartesianOriginVector = new Vector316(cartesianOrigin);
       let vertexVector = new Vector316(Array.from(vertex)).transform(modelMatrix).add(cartographicOrigin);
-      Ellipsoid15.WGS84.cartographicToCartesian(vertexVector, scratchVector4);
+      Ellipsoid14.WGS84.cartographicToCartesian(vertexVector, scratchVector4);
       vertexVector = scratchVector4.subtract(cartesianOriginVector);
       newPositionsValue.set(vertexVector, index);
     }