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

package/dist/index.cjs

@@ -15841,6 +15841,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
     }
@@ -15869,6 +15871,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);
@@ -20739,16 +20742,20 @@ var init_format_spatial_reference = __esm({
 });
 
 // ../../modules/tiles/src/spatial/spatial-resource-registry.ts
+function getSpatialProjectionEngine() {
+  return spatialProjectionEngine;
+}
 function getGeoidModel(name18) {
   return geoidModels.get(name18);
 }
-var import_geoid, import_projection, geoidModels;
+var import_geoid, import_projection, geoidModels, spatialProjectionEngine;
 var init_spatial_resource_registry = __esm({
   "../../modules/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();
   }
 });
 
@@ -20853,13 +20860,12 @@ function transformHeight(height, geoidUndulation, source, target) {
   }
   throw new Error(`Unsupported height conversion from ${source} to ${target}`);
 }
-var import_core4, import_geospatial2, import_projection2, SpatialCoordinateTransformer;
+var import_core4, import_geospatial2, SpatialCoordinateTransformer;
 var init_spatial_coordinate_transformer = __esm({
   "../../modules/tiles/src/spatial/spatial-coordinate-transformer.ts"() {
     "use strict";
     import_core4 = require("@math.gl/core");
     import_geospatial2 = require("@math.gl/geospatial");
-    import_projection2 = require("@math.gl/projection");
     init_spatial_resource_registry();
     init_normalize_crs_identifier();
     init_get_spatial_coordinate_frame();
@@ -20890,6 +20896,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);
@@ -20897,7 +20904,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
@@ -20905,14 +20912,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
@@ -20959,7 +20966,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;
@@ -21023,7 +21030,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) {
@@ -21033,7 +21040,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));
       }
     };
   }
@@ -21139,14 +21146,12 @@ function createAxisAlignedBox(samples) {
     (maximum[2] - minimum[2]) / 2 + padding[2]
   ];
 }
-var import_core5, import_geospatial3, Tiles3DSpatialTransformer;
+var import_core5, Tiles3DSpatialTransformer;
 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();
     import_core5 = require("@math.gl/core");
-    import_geospatial3 = require("@math.gl/geospatial");
     Tiles3DSpatialTransformer = class {
       /** Normalized reference describing the completed operation. */
       spatialReference;
@@ -21190,16 +21195,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 = import_geospatial3.Ellipsoid.WGS84.cartographicToCartesian([
-            longitudeDegrees,
-            latitudeDegrees,
-            height
-          ]);
-          return Array.from(cartesian);
-        }
         return this.geographicCoordinateTransformer.transformPosition(sample);
       }
     };
@@ -21209,19 +21204,19 @@ var init_tiles_3d_spatial_transformer = __esm({
 // ../../modules/tiles/src/tileset-3d/helpers/s2-bounding-volume.ts
 function convertS2BoundingVolumeToOBB(s2VolumeInfo) {
   const [[west, south], [east, north]] = (0, import_s2.getS2Bounds)(s2VolumeInfo.token);
-  const orientedBoundingBox = (0, import_geospatial4.makeOBBFromRegion)(
+  const orientedBoundingBox = (0, import_geospatial3.makeOBBFromRegion)(
     [west, south, east, north, s2VolumeInfo.minimumHeight, s2VolumeInfo.maximumHeight],
-    import_geospatial4.Ellipsoid.WGS84,
+    import_geospatial3.Ellipsoid.WGS84,
     { units: "degrees" }
   );
   return [...orientedBoundingBox.center, ...orientedBoundingBox.halfAxes];
 }
-var import_s2, import_geospatial4;
+var import_s2, import_geospatial3;
 var init_s2_bounding_volume = __esm({
   "../../modules/tiles/src/tileset-3d/helpers/s2-bounding-volume.ts"() {
     "use strict";
     import_s2 = require("@math.gl/dggs/s2");
-    import_geospatial4 = require("@math.gl/geospatial");
+    import_geospatial3 = require("@math.gl/geospatial");
   }
 });
 
@@ -21310,7 +21305,7 @@ function getGeographicBoundingSphere(geographicSamples) {
     throw new Error("I3S spatial transformation requires at least one bound sample");
   }
   const cartesianSamples = geographicSamples.map(
-    (position) => import_geospatial5.Ellipsoid.WGS84.cartographicToCartesian(new import_core6.Vector3(position))
+    (position) => import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian(new import_core6.Vector3(position))
   );
   const cartesianCenter = new import_core6.Vector3();
   for (const sample of cartesianSamples) {
@@ -21321,7 +21316,7 @@ function getGeographicBoundingSphere(geographicSamples) {
   for (const sample of cartesianSamples) {
     radius = Math.max(radius, new import_core6.Vector3(sample).subtract(cartesianCenter).magnitude());
   }
-  const geographicCenter = import_geospatial5.Ellipsoid.WGS84.cartesianToCartographic(cartesianCenter);
+  const geographicCenter = import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(cartesianCenter);
   return [geographicCenter[0], geographicCenter[1], geographicCenter[2], radius];
 }
 function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransformer, sourceVerticalUnitScale) {
@@ -21338,7 +21333,7 @@ function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransforme
     ];
     if (sourceFrame === "geographic") {
       const geographicCenter = sourceToGeographicTransformer.transformPosition(center2);
-      const cartesianCenter = import_geospatial5.Ellipsoid.WGS84.cartographicToCartesian(
+      const cartesianCenter = import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian(
         new import_core6.Vector3(geographicCenter)
       );
       const cartesianAxes = bounds.normalReferenceFrame === "vertex-reference-frame" ? axes.map((axis) => localEnuVectorToEcef(axis, geographicCenter)) : axes;
@@ -21347,7 +21342,7 @@ function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransforme
         for (let axisIndex = 0; axisIndex < 3; axisIndex++) {
           corner.add(new import_core6.Vector3(cartesianAxes[axisIndex]).scale(signs[axisIndex]));
         }
-        return Array.from(import_geospatial5.Ellipsoid.WGS84.cartesianToCartographic(corner));
+        return Array.from(import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(corner));
       });
     }
     return getBoxSigns().map((signs) => {
@@ -21367,10 +21362,10 @@ function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransforme
   const radius = mbs[3];
   if (sourceFrame === "geographic") {
     const geographicCenter = sourceToGeographicTransformer.transformPosition(center);
-    const cartesianCenter = import_geospatial5.Ellipsoid.WGS84.cartographicToCartesian(new import_core6.Vector3(geographicCenter));
+    const cartesianCenter = import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian(new import_core6.Vector3(geographicCenter));
     return getAxisDirections().map(
       (direction) => Array.from(
-        import_geospatial5.Ellipsoid.WGS84.cartesianToCartographic(
+        import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(
           new import_core6.Vector3(cartesianCenter).add(new import_core6.Vector3(direction).scale(radius))
         )
       )
@@ -21470,12 +21465,12 @@ function getGeographicRegion(positions) {
 function normalizeLongitude(longitude) {
   return ((longitude + 180) % 360 + 360) % 360 - 180;
 }
-var import_core6, import_geospatial5, I3SSpatialTransformer;
+var import_core6, import_geospatial4, I3SSpatialTransformer;
 var init_i3s_spatial_transformer = __esm({
   "../../modules/tiles/src/spatial/i3s-spatial-transformer.ts"() {
     "use strict";
     import_core6 = require("@math.gl/core");
-    import_geospatial5 = require("@math.gl/geospatial");
+    import_geospatial4 = require("@math.gl/geospatial");
     init_spatial_coordinate_transformer();
     init_spatial_types();
     init_i3s_elevation();
@@ -21684,6 +21679,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);
@@ -21721,7 +21744,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],
@@ -21771,14 +21806,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(import_geospatial5.Ellipsoid.WGS84.cartographicToCartesian(new import_core6.Vector3(position)))
+          (position) => Array.from(import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian(new import_core6.Vector3(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(import_geospatial5.Ellipsoid.WGS84.cartographicToCartesian(new import_core6.Vector3(position)))
+          (position) => Array.from(import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian(new import_core6.Vector3(position)))
         );
         return { box: getAxisAlignedBox(cartesianSamples) };
       }
@@ -21808,7 +21843,7 @@ var init_i3s_spatial_transformer = __esm({
       async transformBoundsAsync(bounds) {
         const geographicSamples = await this.getGeographicBoundSamplesAsync(bounds);
         const cartesianSamples = geographicSamples.map(
-          (position) => Array.from(import_geospatial5.Ellipsoid.WGS84.cartographicToCartesian(new import_core6.Vector3(position)))
+          (position) => Array.from(import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian(new import_core6.Vector3(position)))
         );
         const targetSamples = geographicSamples.map(
           (position) => this.geographicToTargetTransformer.transformPosition(position)
@@ -21967,13 +22002,13 @@ var init_i3s_spatial_transformer = __esm({
         if (this.targetCoordinateFrame === "geographic") {
           return ecefVectorToLocalEnu(ecefNormal, geographic).normalize();
         }
-        const cartesian = import_geospatial5.Ellipsoid.WGS84.cartographicToCartesian(new import_core6.Vector3(geographic));
+        const cartesian = import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian(new import_core6.Vector3(geographic));
         const jacobianColumns = [];
         for (const direction of getPositiveAxisDirections()) {
-          const positiveGeographic = import_geospatial5.Ellipsoid.WGS84.cartesianToCartographic(
+          const positiveGeographic = import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(
             new import_core6.Vector3(cartesian).add(direction)
           );
-          const negativeGeographic = import_geospatial5.Ellipsoid.WGS84.cartesianToCartographic(
+          const negativeGeographic = import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(
             new import_core6.Vector3(cartesian).subtract(direction)
           );
           const positiveTarget = this.geographicToTargetTransformer.transformPosition(positiveGeographic);
@@ -23480,7 +23515,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
         tile.hasCustomOrientation = true;
         hasCustomOrientation = true;
       } else if (tile.eastNorthUp) {
-        import_geospatial6.Ellipsoid.WGS84.eastNorthUpToFixedFrame(instancePosition, instanceTransform);
+        import_geospatial5.Ellipsoid.WGS84.eastNorthUpToFixedFrame(instancePosition, instanceTransform);
         instanceTransform.getRotationMatrix3(instanceRotation);
       } else {
         instanceRotation.identity();
@@ -23525,12 +23560,12 @@ function decodeOct32POrientation(encodedUp, encodedRight, normalUp, normalRight)
   (0, import_geometry_utils9.octDecodeInRange)(encodedUp[0], encodedUp[1], 65535, normalUp);
   (0, import_geometry_utils9.octDecodeInRange)(encodedRight[0], encodedRight[1], 65535, normalRight);
 }
-var import_core10, import_geospatial6, import_geometry_utils9;
+var import_core10, import_geospatial5, import_geometry_utils9;
 var init_parse_3d_tile_instanced_model = __esm({
   "../../modules/3d-tiles/src/lib/parsers/parse-3d-tile-instanced-model.ts"() {
     "use strict";
     import_core10 = require("@math.gl/core");
-    import_geospatial6 = require("@math.gl/geospatial");
+    import_geospatial5 = require("@math.gl/geospatial");
     import_geometry_utils9 = require("@math.gl/geometry-utils");
     init_tile_3d_feature_table();
     init_tile_3d_batch_table();
@@ -25043,7 +25078,7 @@ function getGeoreferenceMatrix(longitudeDegrees, latitudeDegrees, height) {
   const sinLongitude = Math.sin(longitude);
   const cosLatitude = Math.cos(latitude);
   const sinLatitude = Math.sin(latitude);
-  const position = import_geospatial7.Ellipsoid.WGS84.cartographicToCartesian([longitude, latitude, height]);
+  const position = import_geospatial6.Ellipsoid.WGS84.cartographicToCartesian([longitude, latitude, height]);
   return new import_core12.Matrix4([
     sinLongitude,
     -cosLongitude,
@@ -25075,13 +25110,13 @@ function isNonnegativeNumber(value) {
 function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
-var import_core12, import_geospatial7, TILESET_EXTENSION, SUBTREE_EXTENSION, IMPLICIT_TILING_EXTENSION, VECTOR_EXTENSION;
+var import_core12, import_geospatial6, TILESET_EXTENSION, SUBTREE_EXTENSION, IMPLICIT_TILING_EXTENSION, VECTOR_EXTENSION;
 var init_parse_3d_tiles_2_gltf = __esm({
   "../../modules/3d-tiles/src/lib/parsers/parse-3d-tiles-2-gltf.ts"() {
     "use strict";
     init_src9();
     import_core12 = require("@math.gl/core");
-    import_geospatial7 = require("@math.gl/geospatial");
+    import_geospatial6 = require("@math.gl/geospatial");
     init_src2();
     init_s2_corners_to_obb();
     TILESET_EXTENSION = "3DTILES_tileset";
@@ -27738,116 +27773,358 @@ 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;
+  }
+});
+
+// ../../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) => {
@@ -28048,379 +28325,137 @@ var init_fflate = __esm({
             }
             if (noBuf) cbuf(bt + 131072);
             const end = bt + add;
-            for (; bt < end; bt += 4) {
-              buf[bt] = buf[bt - dt];
-              buf[bt + 1] = buf[bt + 1 - dt];
-              buf[bt + 2] = buf[bt + 2 - dt];
-              buf[bt + 3] = buf[bt + 3 - dt];
-            }
-            bt = end;
-          }
-        }
-        st.l = lm, st.p = lpos, st.b = bt, st.f = final;
-        if (lm) final = 1, st.m = lbt, st.d = dm, st.n = dbt;
-      } while (!final);
-      return bt == buf.length ? buf : slc(buf, 0, bt);
-    };
-    gzs = (d) => {
-      if (d[0] != 31 || d[1] != 139 || d[2] != 8) err(6, "invalid gzip data");
-      const flg = d[3];
-      let st = 10;
-      if (flg & 4) st += d[10] | (d[11] << 8) + 2;
-      for (let zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++]) ;
-      return st + (flg & 2);
-    };
-    gzl = (d) => {
-      const l = d.length;
-      return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
-    };
-    zlv = (d) => {
-      if ((d[0] & 15) != 8 || d[0] >>> 4 > 7 || (d[0] << 8 | d[1]) % 31) err(6, "invalid zlib data");
-      if (d[1] & 32) err(6, "invalid zlib data: preset dictionaries not supported");
-    };
-    Inflate = class {
-      /**
-       * Creates an inflation stream
-       * @param cb The callback to call whenever data is inflated
-       */
-      constructor(cb) {
-        this.ondata = cb;
-      }
-      /** Persistent bit-reader and Huffman decoding state. */
-      s = {};
-      /** Compression options or retained output window for this stream. */
-      o;
-      /** Compressed bytes pending decoding. */
-      p = new u8(0);
-      /** Whether the stream has received its final chunk. */
-      d;
-      /**
-       * The handler to call whenever data is available
-       */
-      ondata;
-      /** Appends pending input after checking stream lifecycle. */
-      e(c) {
-        if (!this.ondata) err(5);
-        if (this.d) err(4);
-        const l = this.p.length;
-        const n = new u8(l + c.length);
-        n.set(this.p), n.set(c, l), this.p = n;
-      }
-      /** Decodes pending input and retains the sliding window. */
-      c(final) {
-        this.d = this.s.i = final || false;
-        const bts = this.s.b;
-        const dt = inflt(this.p, this.o, this.s);
-        this.ondata(slc(dt, bts, this.s.b), this.d);
-        this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;
-        this.p = slc(this.p, this.s.p / 8 | 0), this.s.p &= 7;
-      }
-      /**
-       * Pushes a chunk to be inflated
-       * @param chunk The chunk to push
-       * @param final Whether this is the final chunk
-       */
-      push(chunk, final) {
-        this.e(chunk), this.c(final);
-      }
-    };
-    Gunzip = class extends Inflate {
-      /** Whether the stream header still needs to be emitted or consumed. */
-      v = 1;
-      /**
-       * Creates a GUNZIP stream
-       * @param cb The callback to call whenever data is inflated
-       */
-      constructor(cb) {
-        super(cb);
-      }
-      /**
-       * Pushes a chunk to be GUNZIPped
-       * @param chunk The chunk to push
-       * @param final Whether this is the last chunk
-       */
-      push(chunk, final) {
-        Inflate.prototype.e.call(this, chunk);
-        if (this.v) {
-          const s = this.p.length > 3 ? gzs(this.p) : 4;
-          if (s >= this.p.length && !final) return;
-          this.p = this.p.subarray(s), this.v = 0;
-        }
-        if (final) {
-          if (this.p.length < 8) err(6, "invalid gzip data");
-          this.p = this.p.subarray(0, -8);
-        }
-        Inflate.prototype.c.call(this, final);
-      }
-    };
-    Unzlib = class extends Inflate {
-      /** Whether the stream header still needs to be emitted or consumed. */
-      v = 1;
-      /**
-       * Creates a Zlib decompression stream
-       * @param cb The callback to call whenever data is inflated
-       */
-      constructor(cb) {
-        super(cb);
-      }
-      /**
-       * Pushes a chunk to be unzlibbed
-       * @param chunk The chunk to push
-       * @param final Whether this is the last chunk
-       */
-      push(chunk, final) {
-        Inflate.prototype.e.call(this, chunk);
-        if (this.v) {
-          if (this.p.length < 2 && !final) return;
-          this.p = this.p.subarray(2), this.v = 0;
-        }
-        if (final) {
-          if (this.p.length < 4) err(6, "invalid zlib data");
-          this.p = this.p.subarray(0, -4);
-        }
-        Inflate.prototype.c.call(this, final);
-      }
-    };
-  }
-});
-
-// ../../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;
+            for (; bt < end; bt += 4) {
+              buf[bt] = buf[bt - dt];
+              buf[bt + 1] = buf[bt + 1 - dt];
+              buf[bt + 2] = buf[bt + 2 - dt];
+              buf[bt + 3] = buf[bt + 3 - dt];
+            }
+            bt = end;
+          }
+        }
+        st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+        if (lm) final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+      } while (!final);
+      return bt == buf.length ? buf : slc(buf, 0, bt);
+    };
+    gzs = (d) => {
+      if (d[0] != 31 || d[1] != 139 || d[2] != 8) err(6, "invalid gzip data");
+      const flg = d[3];
+      let st = 10;
+      if (flg & 4) st += d[10] | (d[11] << 8) + 2;
+      for (let zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++]) ;
+      return st + (flg & 2);
+    };
+    gzl = (d) => {
+      const l = d.length;
+      return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
+    };
+    zlv = (d) => {
+      if ((d[0] & 15) != 8 || d[0] >>> 4 > 7 || (d[0] << 8 | d[1]) % 31) err(6, "invalid zlib data");
+      if (d[1] & 32) err(6, "invalid zlib data: preset dictionaries not supported");
+    };
+    Inflate = class {
+      /**
+       * Creates an inflation stream
+       * @param cb The callback to call whenever data is inflated
+       */
+      constructor(cb) {
+        this.ondata = cb;
       }
-      /** 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);
       }
     };
   }
@@ -29275,6 +29310,7 @@ var init_i3s_loader_options = __esm({
       decodeTextures: true,
       attributeValues: "legacy",
       colorFormat: "uint8norm",
+      geometryMode: "render",
       coordinateSystem: COORDINATE_SYSTEM.METER_OFFSETS
     };
   }
@@ -29364,7 +29400,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: [],
@@ -29514,6 +29555,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) {
@@ -29562,7 +29610,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
@@ -29813,15 +29886,15 @@ function parsePositions2(attribute, options) {
   const enuMatrix = new import_core23.Matrix4();
   const cartographicOrigin = new import_core23.Vector3(mbs[0], mbs[1], mbs[2]);
   const cartesianOrigin = new import_core23.Vector3();
-  import_geospatial12.Ellipsoid.WGS84.cartographicToCartesian(cartographicOrigin, cartesianOrigin);
-  import_geospatial12.Ellipsoid.WGS84.eastNorthUpToFixedFrame(cartesianOrigin, enuMatrix);
+  import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(cartographicOrigin, cartesianOrigin);
+  import_geospatial11.Ellipsoid.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];
@@ -29832,7 +29905,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) {
-    import_geospatial12.Ellipsoid.WGS84.cartographicToCartesian(positions.subarray(i, i + 3), scratchVector3);
+    import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(positions.subarray(i, i + 3), scratchVector3);
     positions[i] = scratchVector3.x;
     positions[i + 1] = scratchVector3.y;
     positions[i + 2] = scratchVector3.z;
@@ -30012,13 +30085,13 @@ function flattenFeatureIdsByFeatureIndices(attributes, featureIds) {
 function getFeatureIdsFromFeatureIndexMetadata(featureIndex) {
   return featureIndex?.metadata?.["i3s-feature-ids"]?.intArray;
 }
-var import_core23, import_geospatial12, scratchVector3, I3S_ATTRIBUTE_TYPE;
+var import_core23, import_geospatial11, scratchVector3, I3S_ATTRIBUTE_TYPE;
 var init_parse_i3s_tile_content = __esm({
   "../../modules/i3s/src/lib/parsers/parse-i3s-tile-content.ts"() {
     "use strict";
     init_src3();
     import_core23 = require("@math.gl/core");
-    import_geospatial12 = require("@math.gl/geospatial");
+    import_geospatial11 = require("@math.gl/geospatial");
     init_src2();
     init_src6();
     init_src8();
@@ -30645,14 +30718,14 @@ function normalizeTileNonUrlData(tile) {
   if (tile.mbs) {
     mbs = tile.mbs;
     boundingVolume.sphere = [
-      ...import_geospatial13.Ellipsoid.WGS84.cartographicToCartesian(tile.mbs.slice(0, 3)),
+      ...import_geospatial12.Ellipsoid.WGS84.cartographicToCartesian(tile.mbs.slice(0, 3)),
       // cartesian center of sphere
       tile.mbs[3]
       // radius of sphere
     ];
   } else if (tile.obb) {
     boundingVolume.box = [
-      ...import_geospatial13.Ellipsoid.WGS84.cartographicToCartesian(tile.obb.center),
+      ...import_geospatial12.Ellipsoid.WGS84.cartographicToCartesian(tile.obb.center),
       // cartesian center of box
       ...tile.obb.halfSize,
       // halfSize
@@ -30713,12 +30786,12 @@ async function normalizeTilesetData(tileset, options, context) {
     lodMetricValue: root.lodMetricValue
   };
 }
-var import_culling4, import_geospatial13;
+var import_culling4, import_geospatial12;
 var init_parse_i3s = __esm({
   "../../modules/i3s/src/lib/parsers/parse-i3s.ts"() {
     "use strict";
     import_culling4 = require("@math.gl/culling");
-    import_geospatial13 = require("@math.gl/geospatial");
+    import_geospatial12 = require("@math.gl/geospatial");
     init_src5();
     init_i3s_nodepages_tiles();
     init_url_utils2();
@@ -31037,10 +31110,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:
@@ -31052,14 +31126,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);
@@ -32378,7 +32482,7 @@ async function getDirectorySize(dirPath) {
 
 // src/v4/i3s-converter/helpers/geometry-converter.ts
 var import_core16 = require("@math.gl/core");
-var import_geospatial10 = require("@math.gl/geospatial");
+var import_geospatial9 = require("@math.gl/geospatial");
 var import_node_module = require("node:module");
 init_src8();
 init_src5();
@@ -32600,13 +32704,13 @@ function encodeStringAttribute(values) {
 
 // src/v4/i3s-converter/helpers/coordinate-converter.ts
 var import_core14 = require("@math.gl/core");
-var import_geospatial8 = require("@math.gl/geospatial");
+var import_geospatial7 = require("@math.gl/geospatial");
 var import_culling2 = require("@math.gl/culling");
 function createBoundingVolumes(sourceBoundingVolume, geoidHeightModel) {
   let radius;
   let halfSize;
   let quaternion;
-  const cartographicCenter = import_geospatial8.Ellipsoid.WGS84.cartesianToCartographic(
+  const cartographicCenter = import_geospatial7.Ellipsoid.WGS84.cartesianToCartographic(
     sourceBoundingVolume.center,
     new import_core14.Vector3()
   );
@@ -32635,8 +32739,8 @@ function createBoundingVolumesFromGeometry(cartesianPositions, geoidHeightModel)
   const positionVectors = convertPositionsToVectors(cartesianPositions);
   const geometryObb = (0, import_culling2.makeOrientedBoundingBoxFromPoints)(positionVectors);
   const geometryMbs = (0, import_culling2.makeBoundingSphereFromPoints)(positionVectors);
-  const mbsCenter = import_geospatial8.Ellipsoid.WGS84.cartesianToCartographic(geometryMbs.center, new import_core14.Vector3());
-  const obbCenter = import_geospatial8.Ellipsoid.WGS84.cartesianToCartographic(geometryObb.center, new import_core14.Vector3());
+  const mbsCenter = import_geospatial7.Ellipsoid.WGS84.cartesianToCartographic(geometryMbs.center, new import_core14.Vector3());
+  const obbCenter = import_geospatial7.Ellipsoid.WGS84.cartesianToCartographic(geometryObb.center, new import_core14.Vector3());
   if (geoidHeightModel) {
     mbsCenter[2] = mbsCenter[2] - geoidHeightModel.getHeight(mbsCenter[1], mbsCenter[0]);
     obbCenter[2] = obbCenter[2] - geoidHeightModel.getHeight(obbCenter[1], obbCenter[0]);
@@ -32667,11 +32771,11 @@ function convertBoundingVolumeToI3SFullExtent(boundingVolume) {
   }
   const center = sphere.center;
   const radius = sphere.radius;
-  const vertexMax = import_geospatial8.Ellipsoid.WGS84.cartesianToCartographic(
+  const vertexMax = import_geospatial7.Ellipsoid.WGS84.cartesianToCartographic(
     new import_core14.Vector3(center[0] + radius, center[1] + radius, center[2] + radius),
     new import_core14.Vector3()
   );
-  const vertexMin = import_geospatial8.Ellipsoid.WGS84.cartesianToCartographic(
+  const vertexMin = import_geospatial7.Ellipsoid.WGS84.cartesianToCartographic(
     new import_core14.Vector3(center[0] - radius, center[1] - radius, center[2] - radius),
     new import_core14.Vector3()
   );
@@ -32694,7 +32798,7 @@ function createObbFromMbs(mbs) {
 // src/v4/i3s-converter/helpers/gltf-attributes.ts
 var import_core15 = require("@math.gl/core");
 init_src6();
-var import_geospatial9 = require("@math.gl/geospatial");
+var import_geospatial8 = require("@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) => {
@@ -32757,7 +32861,7 @@ function calculateTransformProps(tileContent, tileTransform, boundingVolume) {
       break;
   }
   const cartesianOrigin = new import_core15.Vector3(center);
-  const cartographicOrigin = import_geospatial9.Ellipsoid.WGS84.cartesianToCartographic(
+  const cartographicOrigin = import_geospatial8.Ellipsoid.WGS84.cartesianToCartographic(
     cartesianOrigin,
     new import_core15.Vector3()
   );
@@ -33144,7 +33248,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);
-      import_geospatial10.Ellipsoid.WGS84.cartesianToCartographic(Array.from(vertex), scratchVector2);
+      import_geospatial9.Ellipsoid.WGS84.cartesianToCartographic(Array.from(vertex), scratchVector2);
       if (geoidHeightModel) {
         scratchVector2[2] = scratchVector2[2] - geoidHeightModel.getHeight(scratchVector2[1], scratchVector2[0]);
       }
@@ -33478,7 +33582,7 @@ function transformVertexPositions(vertexVector, calleeArgs) {
   if (useCartesianPositions) {
     return vertexVector;
   }
-  import_geospatial10.Ellipsoid.WGS84.cartesianToCartographic(
+  import_geospatial9.Ellipsoid.WGS84.cartesianToCartographic(
     [vertexVector[0], vertexVector[1], vertexVector[2]],
     vertexVector
   );
@@ -34621,7 +34725,7 @@ function transfromTextureDefinitions(textureDefinitionInfos, thisObject, origina
 // src/v4/i3s-converter/helpers/node-debug.ts
 var import_culling3 = require("@math.gl/culling");
 var import_core18 = require("@math.gl/core");
-var import_geospatial11 = require("@math.gl/geospatial");
+var import_geospatial10 = require("@math.gl/geospatial");
 var CUBE_POSITIONS = new Float32Array([
   -1,
   -1,
@@ -34734,7 +34838,7 @@ function createBoundingBoxFromTileObb(obb) {
 function getTileObbVertices(node) {
   const halfSize = node.obb.halfSize;
   const positions = CUBE_POSITIONS;
-  const obbCenterCartesian = import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(node.obb.center);
+  const obbCenterCartesian = import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(node.obb.center);
   let vertices = [];
   for (let i = 0; i < positions.length; i += 3) {
     positions[i] *= halfSize[0];
@@ -34750,7 +34854,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 = import_geospatial11.Ellipsoid.WGS84.cartesianToCartographic(point);
+    const cartographicPoint = import_geospatial10.Ellipsoid.WGS84.cartesianToCartographic(point);
     const distance = boundingVolume.distanceTo(cartographicPoint);
     if (distance > 0) {
       isVerticesInsideObb = false;
@@ -37520,7 +37624,7 @@ function collectWktNodes(node) {
 
 // src/v4/3d-tiles-converter/helpers/i3s-obb-to-3d-tiles-obb.ts
 var import_core25 = require("@math.gl/core");
-var import_geospatial14 = require("@math.gl/geospatial");
+var import_geospatial13 = require("@math.gl/geospatial");
 var import_culling5 = require("@math.gl/culling");
 function i3sObbTo3dTilesObb(i3SObb, geoidHeightModel) {
   const tiles3DCenter = [
@@ -37528,7 +37632,7 @@ function i3sObbTo3dTilesObb(i3SObb, geoidHeightModel) {
     i3SObb.center[1],
     i3SObb.center[2] + geoidHeightModel.getHeight(i3SObb.center[1], i3SObb.center[0])
   ];
-  const cartesianCenter = import_geospatial14.Ellipsoid.WGS84.cartographicToCartesian(tiles3DCenter, new import_core25.Vector3());
+  const cartesianCenter = import_geospatial13.Ellipsoid.WGS84.cartographicToCartesian(tiles3DCenter, new import_core25.Vector3());
   const tiles3DObb = new import_culling5.OrientedBoundingBox().fromCenterHalfSizeQuaternion(
     cartesianCenter,
     i3SObb.halfSize,
@@ -37586,7 +37690,7 @@ init_src5();
 init_src9();
 var import_core27 = require("@math.gl/core");
 var import_types5 = require("@math.gl/types");
-var import_geospatial15 = require("@math.gl/geospatial");
+var import_geospatial14 = require("@math.gl/geospatial");
 
 // src/v4/3d-tiles-converter/helpers/texture-atlas.ts
 function convertTextureAtlas(texCoords, uvRegions) {
@@ -37681,7 +37785,7 @@ var Tiles3DContentConverter = class {
       );
     }
     const cartesianOrigin = new import_core27.Vector3(box);
-    const cartographicOrigin = import_geospatial15.Ellipsoid.WGS84.cartesianToCartographic(
+    const cartographicOrigin = import_geospatial14.Ellipsoid.WGS84.cartesianToCartographic(
       cartesianOrigin,
       new import_core27.Vector3()
     );
@@ -37846,7 +37950,7 @@ var Tiles3DContentConverter = class {
       const vertex = positionsValue.subarray(index, index + 3);
       const cartesianOriginVector = new import_core27.Vector3(cartesianOrigin);
       let vertexVector = new import_core27.Vector3(Array.from(vertex)).transform(modelMatrix).add(cartographicOrigin);
-      import_geospatial15.Ellipsoid.WGS84.cartographicToCartesian(vertexVector, scratchVector4);
+      import_geospatial14.Ellipsoid.WGS84.cartographicToCartesian(vertexVector, scratchVector4);
       vertexVector = scratchVector4.subtract(cartesianOriginVector);
       newPositionsValue.set(vertexVector, index);
     }