@loaders.gl/arcgis 5.0.0-beta.2 → 5.0.0-beta.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.cjs CHANGED
@@ -3818,7 +3818,7 @@ function convertGeometryToWKT(geometry, options) {
3818
3818
  if (geometry.geometries.length === 0) return "GEOMETRYCOLLECTION EMPTY";
3819
3819
  return `GEOMETRYCOLLECTION (${geometry.geometries.map((child) => convertGeometryToWKT(child)).join(", ")})`;
3820
3820
  }
3821
- return (0, import_geospatial2.formatWKT)(normalizeGeometryDimension(geometry, dimension), dimension);
3821
+ return (0, import_wkb.formatWKT)(normalizeGeometryDimension(geometry, dimension), dimension);
3822
3822
  }
3823
3823
  function normalizeGeometryDimension(geometry, dimension) {
3824
3824
  if (geometry.type === "GeometryCollection") {
@@ -3877,11 +3877,11 @@ function getFirstCoordinate(geometry) {
3877
3877
  function getDimensionSize(dimension) {
3878
3878
  return dimension === "xy" ? 2 : dimension === "xyzm" ? 4 : 3;
3879
3879
  }
3880
- var import_geospatial2;
3880
+ var import_wkb;
3881
3881
  var init_geometry_to_wkt = __esm({
3882
3882
  "../core/src/arrow-geometry/geometry-to-wkt.ts"() {
3883
3883
  "use strict";
3884
- import_geospatial2 = require("@math.gl/geospatial");
3884
+ import_wkb = require("@math.gl/arrow/wkb");
3885
3885
  }
3886
3886
  });
3887
3887
 
@@ -3895,7 +3895,7 @@ function convertGeometryToWKB(input, options = {}) {
3895
3895
  }
3896
3896
  function encodeGeometry(geometry, dimension) {
3897
3897
  if (geometry.type !== "GeometryCollection") {
3898
- return (0, import_geospatial3.writeWKB)(geometry, dimension);
3898
+ return (0, import_wkb2.writeWKB)(geometry, dimension);
3899
3899
  }
3900
3900
  const children = geometry.geometries.map(
3901
3901
  (child) => encodeGeometry(
@@ -3903,13 +3903,13 @@ function encodeGeometry(geometry, dimension) {
3903
3903
  child.__geoarrowDimension ?? dimension
3904
3904
  )
3905
3905
  );
3906
- const headerBuilder = new import_geospatial3.WKBBuilder({ mode: "measure", dimension });
3906
+ const headerBuilder = new import_wkb2.WKBBuilder({ mode: "measure", dimension });
3907
3907
  headerBuilder.beginGeometry("GeometryCollection", children.length);
3908
3908
  const headerLength = headerBuilder.finishGeometry();
3909
3909
  const bytes = new Uint8Array(
3910
3910
  headerLength + children.reduce((total, child) => total + child.length, 0)
3911
3911
  );
3912
- const writer = new import_geospatial3.WKBBuilder({ mode: "write", target: bytes, dimension });
3912
+ const writer = new import_wkb2.WKBBuilder({ mode: "write", target: bytes, dimension });
3913
3913
  writer.beginGeometry("GeometryCollection", children.length);
3914
3914
  let byteOffset = writer.finishGeometry();
3915
3915
  for (const child of children) {
@@ -3918,11 +3918,11 @@ function encodeGeometry(geometry, dimension) {
3918
3918
  }
3919
3919
  return bytes;
3920
3920
  }
3921
- var import_geospatial3;
3921
+ var import_wkb2;
3922
3922
  var init_geometry_codecs = __esm({
3923
3923
  "../core/src/arrow-geometry/geometry-codecs.ts"() {
3924
3924
  "use strict";
3925
- import_geospatial3 = require("@math.gl/geospatial");
3925
+ import_wkb2 = require("@math.gl/arrow/wkb");
3926
3926
  init_geometry_to_wkt();
3927
3927
  }
3928
3928
  });
@@ -9854,109 +9854,7 @@ var init_usd = __esm({
9854
9854
  }
9855
9855
  });
9856
9856
 
9857
- // ../core/src/schema-utils/lib/arrow/split-arrow-buffers.ts
9858
- function splitArrowBuffers(input, options = {}) {
9859
- const context = { ...options, copies: /* @__PURE__ */ new WeakMap() };
9860
- if (isArrowTable(input)) {
9861
- return splitArrowTableBuffersInternal(input, context);
9862
- }
9863
- if (isArrowRecordBatch(input)) {
9864
- return splitArrowRecordBatchBuffers(input, context);
9865
- }
9866
- if (isArrowVector(input)) {
9867
- return splitArrowVectorBuffers(input, context);
9868
- }
9869
- return splitArrowDataBuffers(input, context);
9870
- }
9871
- function isArrowTable(input) {
9872
- return "batches" in input;
9873
- }
9874
- function isArrowRecordBatch(input) {
9875
- return "schema" in input && "data" in input && !Array.isArray(input.data);
9876
- }
9877
- function isArrowVector(input) {
9878
- return "data" in input && Array.isArray(input.data);
9879
- }
9880
- function splitArrowTableBuffersInternal(table, options) {
9881
- const recordBatches = table.batches.map(
9882
- (recordBatch) => splitArrowRecordBatchBuffers(recordBatch, options)
9883
- );
9884
- return new arrow8.Table(table.schema, recordBatches);
9885
- }
9886
- function splitArrowRecordBatchBuffers(recordBatch, options) {
9887
- return new arrow8.RecordBatch(
9888
- recordBatch.schema,
9889
- splitArrowDataBuffers(recordBatch.data, options)
9890
- );
9891
- }
9892
- function splitArrowDataBuffers(data, options) {
9893
- const children = data.children.map((childData) => splitArrowDataBuffers(childData, options));
9894
- const dictionary = data.dictionary ? splitArrowVectorBuffers(data.dictionary, options) : void 0;
9895
- const buffers = {
9896
- [arrow8.BufferType.OFFSET]: splitArrowBuffer(data.buffers[arrow8.BufferType.OFFSET], options),
9897
- [arrow8.BufferType.DATA]: splitArrowBuffer(data.buffers[arrow8.BufferType.DATA], options),
9898
- [arrow8.BufferType.VALIDITY]: splitArrowBuffer(data.buffers[arrow8.BufferType.VALIDITY], options),
9899
- [arrow8.BufferType.TYPE]: splitArrowBuffer(data.buffers[arrow8.BufferType.TYPE], options)
9900
- };
9901
- return new arrow8.Data(
9902
- data.type,
9903
- data.offset,
9904
- data.length,
9905
- // @ts-expect-error _nullCount is protected. Reuse it to preserve lazy null-count state.
9906
- data._nullCount,
9907
- buffers,
9908
- children,
9909
- dictionary
9910
- );
9911
- }
9912
- function splitArrowVectorBuffers(vector, options) {
9913
- return new arrow8.Vector(vector.data.map((data) => splitArrowDataBuffers(data, options)));
9914
- }
9915
- function splitArrowBuffer(array, options) {
9916
- if (!isArrowTypedArray(array)) {
9917
- return array;
9918
- }
9919
- if (options.copy === "none") {
9920
- return array;
9921
- }
9922
- if (options.copy !== "all" && array.byteOffset === 0 && array.byteLength === array.buffer.byteLength) {
9923
- return array;
9924
- }
9925
- let copy = options.copies.get(array);
9926
- if (!copy) {
9927
- copy = array.slice();
9928
- options.copies.set(array, copy);
9929
- }
9930
- return copy;
9931
- }
9932
- function isArrowTypedArray(value) {
9933
- return ArrayBuffer.isView(value) && !(value instanceof DataView);
9934
- }
9935
- var arrow8;
9936
- var init_split_arrow_buffers = __esm({
9937
- "../core/src/schema-utils/lib/arrow/split-arrow-buffers.ts"() {
9938
- "use strict";
9939
- arrow8 = __toESM(require("apache-arrow"), 1);
9940
- }
9941
- });
9942
-
9943
- // ../core/src/schema-utils/lib/arrow/arrow-table-transport.ts
9944
- function dehydrateArrowTable(table, options) {
9945
- const splitTable = splitArrowBuffers(table, options);
9946
- return {
9947
- shape: "arrow-table",
9948
- transport: "arrow-js",
9949
- schema: serializeArrowSchema(splitTable.schema),
9950
- batches: splitTable.batches.map((recordBatch) => dehydrateArrowRecordBatch(recordBatch))
9951
- };
9952
- }
9953
- function hydrateArrowTable(table) {
9954
- const schema = deserializeArrowSchema(table.schema);
9955
- const recordBatches = table.batches.map(
9956
- (recordBatch) => new arrow9.RecordBatch(schema, hydrateArrowData(recordBatch.data))
9957
- );
9958
- return new arrow9.Table(schema, recordBatches);
9959
- }
9857
+ // ../core/src/arrow-worker-transport.ts
9960
9858
  function serializeArrowWorkerResult(result, options) {
9961
9859
  var _a2;
9962
9860
  if (!isArrowTableWrapper(result)) {
@@ -9966,14 +9864,14 @@ function serializeArrowWorkerResult(result, options) {
9966
9864
  const bufferCopyMode = ((_a2 = workerOptions == null ? void 0 : workerOptions.core) == null ? void 0 : _a2.workerTransferBufferCopy) ?? (workerOptions == null ? void 0 : workerOptions.workerTransferBufferCopy);
9967
9865
  return {
9968
9866
  ...result,
9969
- data: dehydrateArrowTable(result.data, bufferCopyMode ? { copy: bufferCopyMode } : void 0)
9867
+ data: (0, import_arrow.dehydrateArrowTable)(result.data, bufferCopyMode ? { copy: bufferCopyMode } : void 0)
9970
9868
  };
9971
9869
  }
9972
9870
  function deserializeArrowWorkerResult(result) {
9973
9871
  if (!isDehydratedArrowTableWrapper(result)) {
9974
9872
  return result;
9975
9873
  }
9976
- return { ...result, data: hydrateArrowTable(result.data) };
9874
+ return { ...result, data: (0, import_arrow.hydrateArrowTable)(result.data) };
9977
9875
  }
9978
9876
  function isArrowTableWrapper(value) {
9979
9877
  const table = value;
@@ -9987,61 +9885,11 @@ function isDehydratedArrowTableWrapper(value) {
9987
9885
  table && table.shape === "arrow-table" && table.data && table.data.transport === "arrow-js" && Array.isArray(table.data.batches)
9988
9886
  );
9989
9887
  }
9990
- function dehydrateArrowRecordBatch(recordBatch) {
9991
- return { data: dehydrateArrowData(recordBatch.data) };
9992
- }
9993
- function dehydrateArrowData(data) {
9994
- return {
9995
- type: serializeArrowType(data.type),
9996
- offset: data.offset,
9997
- length: data.length,
9998
- // @ts-expect-error _nullCount is protected. Preserve the Arrow lazy null-count state.
9999
- nullCount: data._nullCount,
10000
- buffers: {
10001
- [arrow9.BufferType.OFFSET]: data.buffers[arrow9.BufferType.OFFSET],
10002
- [arrow9.BufferType.DATA]: data.buffers[arrow9.BufferType.DATA],
10003
- [arrow9.BufferType.VALIDITY]: data.buffers[arrow9.BufferType.VALIDITY],
10004
- [arrow9.BufferType.TYPE]: data.buffers[arrow9.BufferType.TYPE]
10005
- },
10006
- children: data.children.map((childData) => dehydrateArrowData(childData)),
10007
- dictionary: data.dictionary ? dehydrateArrowVector(data.dictionary) : void 0
10008
- };
10009
- }
10010
- function dehydrateArrowVector(vector) {
10011
- return { data: vector.data.map((data) => dehydrateArrowData(data)) };
10012
- }
10013
- function hydrateArrowData(data) {
10014
- const children = data.children.map((childData) => hydrateArrowData(childData));
10015
- const dictionary = data.dictionary ? hydrateArrowVector(data.dictionary) : void 0;
10016
- return new arrow9.Data(
10017
- deserializeArrowType(data.type),
10018
- data.offset,
10019
- data.length,
10020
- data.nullCount,
10021
- data.buffers,
10022
- children,
10023
- dictionary
10024
- );
10025
- }
10026
- function hydrateArrowVector(vector) {
10027
- return new arrow9.Vector(vector.data.map((data) => hydrateArrowData(data)));
10028
- }
10029
- var arrow9;
10030
- var init_arrow_table_transport = __esm({
10031
- "../core/src/schema-utils/lib/arrow/arrow-table-transport.ts"() {
9888
+ var import_arrow;
9889
+ var init_arrow_worker_transport = __esm({
9890
+ "../core/src/arrow-worker-transport.ts"() {
10032
9891
  "use strict";
10033
- arrow9 = __toESM(require("apache-arrow"), 1);
10034
- init_convert_arrow_schema();
10035
- init_split_arrow_buffers();
10036
- }
10037
- });
10038
-
10039
- // ../core/src/schema-utils/arrow-transport.ts
10040
- var init_arrow_transport = __esm({
10041
- "../core/src/schema-utils/arrow-transport.ts"() {
10042
- "use strict";
10043
- init_arrow_table_transport();
10044
- init_split_arrow_buffers();
9892
+ import_arrow = require("@math.gl/arrow");
10045
9893
  }
10046
9894
  });
10047
9895
 
@@ -11141,7 +10989,7 @@ var DracoLoader;
11141
10989
  var init_draco_loader_types = __esm({
11142
10990
  "../scene/src/draco/draco-loader-types.ts"() {
11143
10991
  "use strict";
11144
- init_arrow_transport();
10992
+ init_arrow_worker_transport();
11145
10993
  init_version3();
11146
10994
  init_draco_format();
11147
10995
  init_draco_loader_options();
@@ -11688,7 +11536,7 @@ function createBoundingVolume(boundingVolumeHeader, transform, result, initialTr
11688
11536
  return createBox(boundingVolumeHeader.box, boxTransform, result);
11689
11537
  }
11690
11538
  if (boundingVolumeHeader.region) {
11691
- const boundingVolume = (0, import_geospatial4.makeOBBFromRegion)(boundingVolumeHeader.region);
11539
+ const boundingVolume = (0, import_geospatial2.makeOBBFromRegion)(boundingVolumeHeader.region);
11692
11540
  const regionTransform = transform.equals(initialTransform) ? identityTransform : transform.clone().multiplyRight(initialTransform.clone().invert());
11693
11541
  return createBox(
11694
11542
  [...boundingVolume.center, ...boundingVolume.halfAxes],
@@ -11797,10 +11645,10 @@ function orientedBoundingBoxToCartographicBounds(boundingVolume) {
11797
11645
  function boundingSphereToCartographicBounds(boundingVolume) {
11798
11646
  const result = emptyCartographicBounds();
11799
11647
  const { center, radius } = boundingVolume;
11800
- const point = import_geospatial4.Ellipsoid.WGS84.scaleToGeodeticSurface(center, scratchPoint);
11648
+ const point = import_geospatial2.Ellipsoid.WGS84.scaleToGeodeticSurface(center, scratchPoint);
11801
11649
  let zAxis;
11802
11650
  if (point) {
11803
- zAxis = import_geospatial4.Ellipsoid.WGS84.geodeticSurfaceNormal(point);
11651
+ zAxis = import_geospatial2.Ellipsoid.WGS84.geodeticSurfaceNormal(point);
11804
11652
  } else {
11805
11653
  zAxis = new import_core5.Vector3(0, 0, 1);
11806
11654
  }
@@ -11829,7 +11677,7 @@ function emptyCartographicBounds() {
11829
11677
  ];
11830
11678
  }
11831
11679
  function addToCartographicBounds(target, cartesian) {
11832
- import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(cartesian, scratchPoint);
11680
+ import_geospatial2.Ellipsoid.WGS84.cartesianToCartographic(cartesian, scratchPoint);
11833
11681
  target[0][0] = Math.min(target[0][0], scratchPoint[0]);
11834
11682
  target[0][1] = Math.min(target[0][1], scratchPoint[1]);
11835
11683
  target[0][2] = Math.min(target[0][2], scratchPoint[2]);
@@ -11837,13 +11685,13 @@ function addToCartographicBounds(target, cartesian) {
11837
11685
  target[1][1] = Math.max(target[1][1], scratchPoint[1]);
11838
11686
  target[1][2] = Math.max(target[1][2], scratchPoint[2]);
11839
11687
  }
11840
- var import_core5, import_culling2, import_geospatial4, scratchPoint, scratchScale, identityTransform;
11688
+ var import_core5, import_culling2, import_geospatial2, scratchPoint, scratchScale, identityTransform;
11841
11689
  var init_bounding_volume = __esm({
11842
11690
  "../tiles-3d/src/tileset-3d/helpers/bounding-volume.ts"() {
11843
11691
  "use strict";
11844
11692
  import_core5 = require("@math.gl/core");
11845
11693
  import_culling2 = require("@math.gl/geometry/culling");
11846
- import_geospatial4 = require("@math.gl/geospatial");
11694
+ import_geospatial2 = require("@math.gl/geospatial");
11847
11695
  init_loader_utils();
11848
11696
  scratchPoint = new import_core5.Vector3();
11849
11697
  scratchScale = new import_core5.Vector3();
@@ -11888,9 +11736,9 @@ function getProjectedRadius(tile, frameState) {
11888
11736
  const mbsR = mbs[3];
11889
11737
  const mbsCenterCartesian = [...tile.boundingVolume.center];
11890
11738
  const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);
11891
- import_geospatial5.Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, cameraPositionCartesian);
11739
+ import_geospatial3.Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, cameraPositionCartesian);
11892
11740
  toEye.copy(cameraPositionCartesian).subtract(mbsCenterCartesian).normalize();
11893
- (0, import_geospatial6.eastNorthUpToFixedFrame)(import_geospatial5.Ellipsoid.WGS84, mbsCenterCartesian, enuToCartesianMatrix);
11741
+ (0, import_geospatial4.eastNorthUpToFixedFrame)(import_geospatial3.Ellipsoid.WGS84, mbsCenterCartesian, enuToCartesianMatrix);
11894
11742
  cartesianToEnuMatrix.copy(enuToCartesianMatrix).invert();
11895
11743
  cameraPositionEnu.copy(cameraPositionCartesian).transform(cartesianToEnuMatrix);
11896
11744
  const projection = Math.sqrt(
@@ -11902,7 +11750,7 @@ function getProjectedRadius(tile, frameState) {
11902
11750
  const extraVectorCartesian = extraVertexCartesian.subtract(mbsCenterCartesian).normalize();
11903
11751
  const radiusVector = toEye.cross(extraVectorCartesian).normalize().scale(mbsR);
11904
11752
  const sphereMbsBorderVertexCartesian = radiusVector.add(mbsCenterCartesian);
11905
- const sphereMbsBorderVertexCartographic = import_geospatial5.Ellipsoid.WGS84.cartesianToCartographic(
11753
+ const sphereMbsBorderVertexCartographic = import_geospatial3.Ellipsoid.WGS84.cartesianToCartographic(
11906
11754
  sphereMbsBorderVertexCartesian
11907
11755
  );
11908
11756
  const projectedOrigin = viewport.project([mbsLon, mbsLat, mbsZ]);
@@ -11912,13 +11760,13 @@ function getProjectedRadius(tile, frameState) {
11912
11760
  const projectedRadius = projectedOriginVector.copy(projectedOrigin).subtract(projectedMbsBorderVertex).magnitude();
11913
11761
  return projectedRadius;
11914
11762
  }
11915
- var import_core6, import_geospatial5, import_geospatial6, cameraPositionCartesian, toEye, cameraPositionEnu, extraVertexEnu, projectedOriginVector, enuToCartesianMatrix, cartesianToEnuMatrix;
11763
+ var import_core6, import_geospatial3, import_geospatial4, cameraPositionCartesian, toEye, cameraPositionEnu, extraVertexEnu, projectedOriginVector, enuToCartesianMatrix, cartesianToEnuMatrix;
11916
11764
  var init_i3s_lod = __esm({
11917
11765
  "../tiles-3d/src/tileset-3d/helpers/i3s-lod.ts"() {
11918
11766
  "use strict";
11919
11767
  import_core6 = require("@math.gl/core");
11920
- import_geospatial5 = require("@math.gl/geospatial");
11921
- import_geospatial6 = require("@math.gl/geospatial");
11768
+ import_geospatial3 = require("@math.gl/geospatial");
11769
+ import_geospatial4 = require("@math.gl/geospatial");
11922
11770
  cameraPositionCartesian = new import_core6.Vector3();
11923
11771
  toEye = new import_core6.Vector3();
11924
11772
  cameraPositionEnu = new import_core6.Vector3();
@@ -13378,7 +13226,7 @@ var init_tile_3d = __esm({
13378
13226
 
13379
13227
  // ../tiles-3d/src/tileset-3d/helpers/zoom.ts
13380
13228
  function getZoomFromFullExtent(fullExtent, cartorgraphicCenter, cartesianCenter) {
13381
- import_geospatial7.Ellipsoid.WGS84.cartographicToCartesian(
13229
+ import_geospatial5.Ellipsoid.WGS84.cartographicToCartesian(
13382
13230
  [fullExtent.xmax, fullExtent.ymax, fullExtent.zmax],
13383
13231
  scratchVector2
13384
13232
  );
@@ -13395,13 +13243,13 @@ function getZoomFromExtent(extent, cartorgraphicCenter, cartesianCenter) {
13395
13243
  cartesianCenter
13396
13244
  );
13397
13245
  }
13398
- var import_core8, import_culling4, import_geospatial7, WGS84_RADIUS_Z, scratchVector2;
13246
+ var import_core8, import_culling4, import_geospatial5, WGS84_RADIUS_Z, scratchVector2;
13399
13247
  var init_zoom = __esm({
13400
13248
  "../tiles-3d/src/tileset-3d/helpers/zoom.ts"() {
13401
13249
  "use strict";
13402
13250
  import_core8 = require("@math.gl/core");
13403
13251
  import_culling4 = require("@math.gl/geometry/culling");
13404
- import_geospatial7 = require("@math.gl/geospatial");
13252
+ import_geospatial5 = require("@math.gl/geospatial");
13405
13253
  WGS84_RADIUS_Z = 6356752314245179e-9;
13406
13254
  scratchVector2 = new import_core8.Vector3();
13407
13255
  }
@@ -13697,12 +13545,12 @@ function transformHeight(height, geoidUndulation, source, target) {
13697
13545
  }
13698
13546
  throw new Error(`Unsupported height conversion from ${source} to ${target}`);
13699
13547
  }
13700
- var import_core9, import_geospatial8, import_bulk, SpatialCoordinateTransformer;
13548
+ var import_core9, import_geospatial6, import_bulk, SpatialCoordinateTransformer;
13701
13549
  var init_spatial_coordinate_transformer = __esm({
13702
13550
  "../tiles-3d/src/spatial/spatial-coordinate-transformer.ts"() {
13703
13551
  "use strict";
13704
13552
  import_core9 = require("@math.gl/core");
13705
- import_geospatial8 = require("@math.gl/geospatial");
13553
+ import_geospatial6 = require("@math.gl/geospatial");
13706
13554
  import_bulk = require("@math.gl/geospatial/projection/bulk");
13707
13555
  init_spatial_resource_registry();
13708
13556
  init_normalize_crs_identifier();
@@ -13880,7 +13728,7 @@ var init_spatial_coordinate_transformer = __esm({
13880
13728
  /** Convert one source coordinate to conventional WGS84 longitude, latitude, and height. */
13881
13729
  toGeographic(coordinate) {
13882
13730
  if (this.sourceIsGeocentric) {
13883
- return Array.from(import_geospatial8.Ellipsoid.WGS84.cartesianToCartographic(new import_core9.Vector3(coordinate)));
13731
+ return Array.from(import_geospatial6.Ellipsoid.WGS84.cartesianToCartographic(new import_core9.Vector3(coordinate)));
13884
13732
  }
13885
13733
  if (this.sourceIsGeographic) {
13886
13734
  return coordinate.slice(0, 3);
@@ -13890,7 +13738,7 @@ var init_spatial_coordinate_transformer = __esm({
13890
13738
  /** Convert one conventional WGS84 geographic coordinate to the selected output CRS. */
13891
13739
  fromGeographic(coordinate) {
13892
13740
  if (this.outputIsGeocentric) {
13893
- return Array.from(import_geospatial8.Ellipsoid.WGS84.cartographicToCartesian(new import_core9.Vector3(coordinate)));
13741
+ return Array.from(import_geospatial6.Ellipsoid.WGS84.cartographicToCartesian(new import_core9.Vector3(coordinate)));
13894
13742
  }
13895
13743
  if (this.outputIsGeographic) {
13896
13744
  return coordinate.slice(0, 3);
@@ -14156,7 +14004,7 @@ function getGeographicBoundingSphere(geographicSamples) {
14156
14004
  throw new Error("I3S spatial transformation requires at least one bound sample");
14157
14005
  }
14158
14006
  const cartesianSamples = geographicSamples.map(
14159
- (position) => import_geospatial9.Ellipsoid.WGS84.cartographicToCartesian(new import_core10.Vector3(position))
14007
+ (position) => import_geospatial7.Ellipsoid.WGS84.cartographicToCartesian(new import_core10.Vector3(position))
14160
14008
  );
14161
14009
  const cartesianCenter = new import_core10.Vector3();
14162
14010
  for (const sample of cartesianSamples) {
@@ -14167,7 +14015,7 @@ function getGeographicBoundingSphere(geographicSamples) {
14167
14015
  for (const sample of cartesianSamples) {
14168
14016
  radius = Math.max(radius, new import_core10.Vector3(sample).subtract(cartesianCenter).magnitude());
14169
14017
  }
14170
- const geographicCenter = import_geospatial9.Ellipsoid.WGS84.cartesianToCartographic(cartesianCenter);
14018
+ const geographicCenter = import_geospatial7.Ellipsoid.WGS84.cartesianToCartographic(cartesianCenter);
14171
14019
  return [geographicCenter[0], geographicCenter[1], geographicCenter[2], radius];
14172
14020
  }
14173
14021
  function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransformer, sourceVerticalUnitScale) {
@@ -14184,7 +14032,7 @@ function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransforme
14184
14032
  ];
14185
14033
  if (sourceFrame === "geographic") {
14186
14034
  const geographicCenter = sourceToGeographicTransformer.transformPosition(center2);
14187
- const cartesianCenter = import_geospatial9.Ellipsoid.WGS84.cartographicToCartesian(
14035
+ const cartesianCenter = import_geospatial7.Ellipsoid.WGS84.cartographicToCartesian(
14188
14036
  new import_core10.Vector3(geographicCenter)
14189
14037
  );
14190
14038
  const cartesianAxes = bounds.normalReferenceFrame === "vertex-reference-frame" ? axes.map((axis) => localEnuVectorToEcef(axis, geographicCenter)) : axes;
@@ -14193,7 +14041,7 @@ function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransforme
14193
14041
  for (let axisIndex = 0; axisIndex < 3; axisIndex++) {
14194
14042
  corner.add(new import_core10.Vector3(cartesianAxes[axisIndex]).scale(signs[axisIndex]));
14195
14043
  }
14196
- return Array.from(import_geospatial9.Ellipsoid.WGS84.cartesianToCartographic(corner));
14044
+ return Array.from(import_geospatial7.Ellipsoid.WGS84.cartesianToCartographic(corner));
14197
14045
  });
14198
14046
  }
14199
14047
  return getBoxSigns().map((signs) => {
@@ -14213,10 +14061,10 @@ function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransforme
14213
14061
  const radius = mbs[3];
14214
14062
  if (sourceFrame === "geographic") {
14215
14063
  const geographicCenter = sourceToGeographicTransformer.transformPosition(center);
14216
- const cartesianCenter = import_geospatial9.Ellipsoid.WGS84.cartographicToCartesian(new import_core10.Vector3(geographicCenter));
14064
+ const cartesianCenter = import_geospatial7.Ellipsoid.WGS84.cartographicToCartesian(new import_core10.Vector3(geographicCenter));
14217
14065
  return getAxisDirections().map(
14218
14066
  (direction) => Array.from(
14219
- import_geospatial9.Ellipsoid.WGS84.cartesianToCartographic(
14067
+ import_geospatial7.Ellipsoid.WGS84.cartesianToCartographic(
14220
14068
  new import_core10.Vector3(cartesianCenter).add(new import_core10.Vector3(direction).scale(radius))
14221
14069
  )
14222
14070
  )
@@ -14316,12 +14164,12 @@ function getGeographicRegion(positions) {
14316
14164
  function normalizeLongitude(longitude) {
14317
14165
  return ((longitude + 180) % 360 + 360) % 360 - 180;
14318
14166
  }
14319
- var import_core10, import_geospatial9, I3SSpatialTransformer;
14167
+ var import_core10, import_geospatial7, I3SSpatialTransformer;
14320
14168
  var init_i3s_spatial_transformer = __esm({
14321
14169
  "../tiles-3d/src/spatial/i3s-spatial-transformer.ts"() {
14322
14170
  "use strict";
14323
14171
  import_core10 = require("@math.gl/core");
14324
- import_geospatial9 = require("@math.gl/geospatial");
14172
+ import_geospatial7 = require("@math.gl/geospatial");
14325
14173
  init_spatial_coordinate_transformer();
14326
14174
  init_spatial_types();
14327
14175
  init_i3s_elevation();
@@ -14658,14 +14506,14 @@ var init_i3s_spatial_transformer = __esm({
14658
14506
  /** Rebuild an I3S bound as a WGS84 ECEF box for generic `Tileset3D` traversal. */
14659
14507
  transformBoundingVolumeToGeocentric(bounds) {
14660
14508
  const cartesianSamples = this.getGeographicBoundSamples(bounds).map(
14661
- (position) => Array.from(import_geospatial9.Ellipsoid.WGS84.cartographicToCartesian(new import_core10.Vector3(position)))
14509
+ (position) => Array.from(import_geospatial7.Ellipsoid.WGS84.cartographicToCartesian(new import_core10.Vector3(position)))
14662
14510
  );
14663
14511
  return { box: getAxisAlignedBox(cartesianSamples) };
14664
14512
  }
14665
14513
  /** Rebuild an I3S bound as WGS84 ECEF after asynchronous elevation placement. */
14666
14514
  async transformBoundingVolumeToGeocentricAsync(bounds) {
14667
14515
  const cartesianSamples = (await this.getGeographicBoundSamplesAsync(bounds)).map(
14668
- (position) => Array.from(import_geospatial9.Ellipsoid.WGS84.cartographicToCartesian(new import_core10.Vector3(position)))
14516
+ (position) => Array.from(import_geospatial7.Ellipsoid.WGS84.cartographicToCartesian(new import_core10.Vector3(position)))
14669
14517
  );
14670
14518
  return { box: getAxisAlignedBox(cartesianSamples) };
14671
14519
  }
@@ -14696,7 +14544,7 @@ var init_i3s_spatial_transformer = __esm({
14696
14544
  async transformBoundsAsync(bounds) {
14697
14545
  const geographicSamples = await this.getGeographicBoundSamplesAsync(bounds);
14698
14546
  const cartesianSamples = geographicSamples.map(
14699
- (position) => Array.from(import_geospatial9.Ellipsoid.WGS84.cartographicToCartesian(new import_core10.Vector3(position)))
14547
+ (position) => Array.from(import_geospatial7.Ellipsoid.WGS84.cartographicToCartesian(new import_core10.Vector3(position)))
14700
14548
  );
14701
14549
  const targetSamples = geographicSamples.map(
14702
14550
  (position) => this.geographicToTargetTransformer.transformPosition(position)
@@ -14855,13 +14703,13 @@ var init_i3s_spatial_transformer = __esm({
14855
14703
  if (this.targetCoordinateFrame === "geographic") {
14856
14704
  return ecefVectorToLocalEnu(ecefNormal, geographic).normalize();
14857
14705
  }
14858
- const cartesian = import_geospatial9.Ellipsoid.WGS84.cartographicToCartesian(new import_core10.Vector3(geographic));
14706
+ const cartesian = import_geospatial7.Ellipsoid.WGS84.cartographicToCartesian(new import_core10.Vector3(geographic));
14859
14707
  const jacobianColumns = [];
14860
14708
  for (const direction of getPositiveAxisDirections()) {
14861
- const positiveGeographic = import_geospatial9.Ellipsoid.WGS84.cartesianToCartographic(
14709
+ const positiveGeographic = import_geospatial7.Ellipsoid.WGS84.cartesianToCartographic(
14862
14710
  new import_core10.Vector3(cartesian).add(direction)
14863
14711
  );
14864
- const negativeGeographic = import_geospatial9.Ellipsoid.WGS84.cartesianToCartographic(
14712
+ const negativeGeographic = import_geospatial7.Ellipsoid.WGS84.cartesianToCartographic(
14865
14713
  new import_core10.Vector3(cartesian).subtract(direction)
14866
14714
  );
14867
14715
  const positiveTarget = this.geographicToTargetTransformer.transformPosition(positiveGeographic);
@@ -14912,12 +14760,12 @@ function normalizeI3SRequest(input) {
14912
14760
  coreApi: input.coreApi
14913
14761
  };
14914
14762
  }
14915
- var import_geospatial10, import_core11, EMPTY_CONTENT_FORMATS, I3SSource;
14763
+ var import_geospatial8, import_core11, EMPTY_CONTENT_FORMATS, I3SSource;
14916
14764
  var init_i3s_source = __esm({
14917
14765
  "../tiles-3d/src/tileset-3d/format-i3s/i3s-source.ts"() {
14918
14766
  "use strict";
14919
14767
  init_loader_utils();
14920
- import_geospatial10 = require("@math.gl/geospatial");
14768
+ import_geospatial8 = require("@math.gl/geospatial");
14921
14769
  import_core11 = require("@math.gl/core");
14922
14770
  init_tile_3d();
14923
14771
  init_i3s_tileset_traverser();
@@ -15228,7 +15076,7 @@ var init_i3s_source = __esm({
15228
15076
  zmin + (zmax - zmin) / 2
15229
15077
  );
15230
15078
  const cartesianCenter = new import_core11.Vector3();
15231
- import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(cartographicCenter, cartesianCenter);
15079
+ import_geospatial8.Ellipsoid.WGS84.cartographicToCartesian(cartographicCenter, cartesianCenter);
15232
15080
  return {
15233
15081
  cartographicCenter,
15234
15082
  cartesianCenter,
@@ -15240,7 +15088,7 @@ var init_i3s_source = __esm({
15240
15088
  const [xmin, ymin, xmax, ymax] = extent;
15241
15089
  const cartographicCenter = new import_core11.Vector3(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, 0);
15242
15090
  const cartesianCenter = new import_core11.Vector3();
15243
- import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(cartographicCenter, cartesianCenter);
15091
+ import_geospatial8.Ellipsoid.WGS84.cartographicToCartesian(cartographicCenter, cartesianCenter);
15244
15092
  return {
15245
15093
  cartographicCenter,
15246
15094
  cartesianCenter,
@@ -15932,8 +15780,8 @@ function parsePositions(attribute, options) {
15932
15780
  const enuMatrix = new import_core12.Matrix4();
15933
15781
  const cartographicOrigin = new import_core12.Vector3(mbs[0], mbs[1], mbs[2]);
15934
15782
  const cartesianOrigin = new import_core12.Vector3();
15935
- import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(cartographicOrigin, cartesianOrigin);
15936
- (0, import_geospatial12.eastNorthUpToFixedFrame)(import_geospatial11.Ellipsoid.WGS84, cartesianOrigin, enuMatrix);
15783
+ import_geospatial9.Ellipsoid.WGS84.cartographicToCartesian(cartographicOrigin, cartesianOrigin);
15784
+ (0, import_geospatial10.eastNorthUpToFixedFrame)(import_geospatial9.Ellipsoid.WGS84, cartesianOrigin, enuMatrix);
15937
15785
  attribute.value = offsetsToCartesians(value, metadata, cartographicOrigin);
15938
15786
  return enuMatrix;
15939
15787
  }
@@ -15952,7 +15800,7 @@ function offsetsToSourcePositions(vertices, metadata = {}, sourceOrigin) {
15952
15800
  function offsetsToCartesians(vertices, metadata = {}, cartographicOrigin) {
15953
15801
  const positions = offsetsToSourcePositions(vertices, metadata, cartographicOrigin);
15954
15802
  for (let i = 0; i < positions.length; i += 3) {
15955
- import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(positions.subarray(i, i + 3), scratchVector3);
15803
+ import_geospatial9.Ellipsoid.WGS84.cartographicToCartesian(positions.subarray(i, i + 3), scratchVector3);
15956
15804
  positions[i] = scratchVector3.x;
15957
15805
  positions[i + 1] = scratchVector3.y;
15958
15806
  positions[i + 2] = scratchVector3.z;
@@ -16137,14 +15985,14 @@ function getFeatureIdsFromFeatureIndexMetadata(featureIndex) {
16137
15985
  var _a2, _b;
16138
15986
  return (_b = (_a2 = featureIndex == null ? void 0 : featureIndex.metadata) == null ? void 0 : _a2["i3s-feature-ids"]) == null ? void 0 : _b.intArray;
16139
15987
  }
16140
- var import_core12, import_geospatial11, import_geospatial12, scratchVector3, I3S_ATTRIBUTE_TYPE;
15988
+ var import_core12, import_geospatial9, import_geospatial10, scratchVector3, I3S_ATTRIBUTE_TYPE;
16141
15989
  var init_parse_i3s_tile_content = __esm({
16142
15990
  "../tiles-3d/src/i3s/lib/parsers/parse-i3s-tile-content.ts"() {
16143
15991
  "use strict";
16144
15992
  init_schema();
16145
15993
  import_core12 = require("@math.gl/core");
16146
- import_geospatial11 = require("@math.gl/geospatial");
16147
- import_geospatial12 = require("@math.gl/geospatial");
15994
+ import_geospatial9 = require("@math.gl/geospatial");
15995
+ import_geospatial10 = require("@math.gl/geospatial");
16148
15996
  init_loader_utils();
16149
15997
  init_src();
16150
15998
  init_src3();
@@ -16782,14 +16630,14 @@ function normalizeTileNonUrlData(tile) {
16782
16630
  if (tile.mbs) {
16783
16631
  mbs = tile.mbs;
16784
16632
  boundingVolume.sphere = [
16785
- ...import_geospatial13.Ellipsoid.WGS84.cartographicToCartesian(tile.mbs.slice(0, 3)),
16633
+ ...import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(tile.mbs.slice(0, 3)),
16786
16634
  // cartesian center of sphere
16787
16635
  tile.mbs[3]
16788
16636
  // radius of sphere
16789
16637
  ];
16790
16638
  } else if (tile.obb) {
16791
16639
  boundingVolume.box = [
16792
- ...import_geospatial13.Ellipsoid.WGS84.cartographicToCartesian(tile.obb.center),
16640
+ ...import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(tile.obb.center),
16793
16641
  // cartesian center of box
16794
16642
  ...tile.obb.halfSize,
16795
16643
  // halfSize
@@ -16859,12 +16707,12 @@ async function normalizeTilesetData(tileset, options, context) {
16859
16707
  lodMetricValue: root.lodMetricValue
16860
16708
  };
16861
16709
  }
16862
- var import_culling5, import_geospatial13;
16710
+ var import_culling5, import_geospatial11;
16863
16711
  var init_parse_i3s = __esm({
16864
16712
  "../tiles-3d/src/i3s/lib/parsers/parse-i3s.ts"() {
16865
16713
  "use strict";
16866
16714
  import_culling5 = require("@math.gl/geometry/culling");
16867
- import_geospatial13 = require("@math.gl/geospatial");
16715
+ import_geospatial11 = require("@math.gl/geospatial");
16868
16716
  init_i3s_nodepages_tiles();
16869
16717
  init_url_utils();
16870
16718
  init_i3s_loader_with_parser();
@@ -20023,7 +19871,7 @@ function normalizePointPositions(positions, center, requestedCoordinateSystem) {
20023
19871
  const cartesianPositions = new Float32Array(positions.length);
20024
19872
  const cartesian = new import_core13.Vector3();
20025
19873
  for (let index = 0; index < positions.length; index += 3) {
20026
- import_geospatial14.Ellipsoid.WGS84.cartographicToCartesian(
19874
+ import_geospatial12.Ellipsoid.WGS84.cartographicToCartesian(
20027
19875
  new import_core13.Vector3([positions[index], positions[index + 1], positions[index + 2]]),
20028
19876
  cartesian
20029
19877
  );
@@ -20102,7 +19950,7 @@ function getTransformedPointCloudBounds(boundingVolume, coordinateFrame) {
20102
19950
  coordinateFrame
20103
19951
  };
20104
19952
  }
20105
- var import_core13, import_geospatial14, I3SPointCloudSource, EARTH_EQUATORIAL_RADIUS;
19953
+ var import_core13, import_geospatial12, I3SPointCloudSource, EARTH_EQUATORIAL_RADIUS;
20106
19954
  var init_i3s_point_cloud_source = __esm({
20107
19955
  "../tiles-3d/src/i3s/i3s-point-cloud-source.ts"() {
20108
19956
  "use strict";
@@ -20110,7 +19958,7 @@ var init_i3s_point_cloud_source = __esm({
20110
19958
  init_schema_utils();
20111
19959
  init_schema();
20112
19960
  import_core13 = require("@math.gl/core");
20113
- import_geospatial14 = require("@math.gl/geospatial");
19961
+ import_geospatial12 = require("@math.gl/geospatial");
20114
19962
  init_src4();
20115
19963
  init_loader_utils();
20116
19964
  init_parse_slpk();
@@ -20900,21 +20748,13 @@ var init_mvt_format = __esm({
20900
20748
  }
20901
20749
  });
20902
20750
 
20903
- // ../tables/src/arrow/transport.ts
20904
- var init_transport = __esm({
20905
- "../tables/src/arrow/transport.ts"() {
20906
- "use strict";
20907
- init_arrow_transport();
20908
- }
20909
- });
20910
-
20911
20751
  // ../tiles/src/mvt/lib/mvt-worker-transport.ts
20912
20752
  function serializeMVTWorkerResult(result, options) {
20913
- if (isArrowTable2(result)) {
20753
+ if (isArrowTable(result)) {
20914
20754
  const bufferCopyMode = getWorkerTransferBufferCopyMode(options);
20915
20755
  return {
20916
20756
  ...result,
20917
- data: dehydrateArrowTable(result.data, bufferCopyMode ? { copy: bufferCopyMode } : void 0)
20757
+ data: (0, import_arrow2.dehydrateArrowTable)(result.data, bufferCopyMode ? { copy: bufferCopyMode } : void 0)
20918
20758
  };
20919
20759
  }
20920
20760
  return result;
@@ -20923,12 +20763,12 @@ function deserializeMVTWorkerResult(result) {
20923
20763
  if (isSerializedArrowTable(result)) {
20924
20764
  return {
20925
20765
  ...result,
20926
- data: hydrateArrowTable(result.data)
20766
+ data: (0, import_arrow2.hydrateArrowTable)(result.data)
20927
20767
  };
20928
20768
  }
20929
20769
  return result;
20930
20770
  }
20931
- function isArrowTable2(value) {
20771
+ function isArrowTable(value) {
20932
20772
  const table = value;
20933
20773
  return Boolean(
20934
20774
  table && typeof table === "object" && table.shape === "arrow-table" && table.data && "batches" in table.data
@@ -20944,10 +20784,11 @@ function getWorkerTransferBufferCopyMode(options) {
20944
20784
  var _a2;
20945
20785
  return ((_a2 = options == null ? void 0 : options.core) == null ? void 0 : _a2.workerTransferBufferCopy) ?? (options == null ? void 0 : options.workerTransferBufferCopy);
20946
20786
  }
20787
+ var import_arrow2;
20947
20788
  var init_mvt_worker_transport = __esm({
20948
20789
  "../tiles/src/mvt/lib/mvt-worker-transport.ts"() {
20949
20790
  "use strict";
20950
- init_transport();
20791
+ import_arrow2 = require("@math.gl/arrow");
20951
20792
  }
20952
20793
  });
20953
20794