@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/README.md +1 -1
- package/dist/index.cjs +72 -231
- package/dist/index.cjs.map +3 -3
- package/package.json +6 -6
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,
|
|
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
|
|
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
|
-
|
|
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,
|
|
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
|
|
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
|
|
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
|
|
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
|
-
|
|
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/
|
|
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
|
-
|
|
9991
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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,
|
|
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 =
|
|
11648
|
+
const point = import_geospatial2.Ellipsoid.WGS84.scaleToGeodeticSurface(center, scratchPoint);
|
|
11801
11649
|
let zAxis;
|
|
11802
11650
|
if (point) {
|
|
11803
|
-
zAxis =
|
|
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
|
-
|
|
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,
|
|
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
|
-
|
|
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
|
-
|
|
11739
|
+
import_geospatial3.Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, cameraPositionCartesian);
|
|
11892
11740
|
toEye.copy(cameraPositionCartesian).subtract(mbsCenterCartesian).normalize();
|
|
11893
|
-
(0,
|
|
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 =
|
|
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,
|
|
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
|
-
|
|
11921
|
-
|
|
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
|
-
|
|
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,
|
|
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
|
-
|
|
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,
|
|
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
|
-
|
|
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(
|
|
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(
|
|
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) =>
|
|
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 =
|
|
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 =
|
|
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(
|
|
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 =
|
|
14064
|
+
const cartesianCenter = import_geospatial7.Ellipsoid.WGS84.cartographicToCartesian(new import_core10.Vector3(geographicCenter));
|
|
14217
14065
|
return getAxisDirections().map(
|
|
14218
14066
|
(direction) => Array.from(
|
|
14219
|
-
|
|
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,
|
|
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
|
-
|
|
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(
|
|
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(
|
|
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(
|
|
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 =
|
|
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 =
|
|
14709
|
+
const positiveGeographic = import_geospatial7.Ellipsoid.WGS84.cartesianToCartographic(
|
|
14862
14710
|
new import_core10.Vector3(cartesian).add(direction)
|
|
14863
14711
|
);
|
|
14864
|
-
const negativeGeographic =
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
15936
|
-
(0,
|
|
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
|
-
|
|
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,
|
|
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
|
-
|
|
16147
|
-
|
|
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
|
-
...
|
|
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
|
-
...
|
|
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,
|
|
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
|
-
|
|
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
|
-
|
|
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,
|
|
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
|
-
|
|
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 (
|
|
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
|
|
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
|
-
|
|
20791
|
+
import_arrow2 = require("@math.gl/arrow");
|
|
20951
20792
|
}
|
|
20952
20793
|
});
|
|
20953
20794
|
|