@loaders.gl/arrow 4.2.0-alpha.4 → 4.2.0-alpha.6

package/dist/index.cjs

@@ -27,9 +27,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
+// dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
   ArrowLoader: () => ArrowLoader,
   ArrowWorkerLoader: () => ArrowWorkerLoader,
   ArrowWriter: () => ArrowWriter,
@@ -57,13 +57,14 @@ __export(src_exports, {
   triangulateOnWorker: () => triangulateOnWorker,
   updateBoundsFromGeoArrowSamples: () => updateBoundsFromGeoArrowSamples
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(dist_exports);
 var import_schema3 = require("@loaders.gl/schema");
 
-// src/lib/arrow-table-batch.ts
+// dist/lib/arrow-table-batch.js
 var import_schema = require("@loaders.gl/schema");
 var arrow = __toESM(require("apache-arrow"), 1);
 var ArrowTableBatchAggregator = class extends import_schema.ColumnarTableBatchAggregator {
+  arrowSchema;
   constructor(schema, options) {
     super(schema, options);
     this.arrowSchema = null;
@@ -73,13 +74,10 @@ var ArrowTableBatchAggregator = class extends import_schema.ColumnarTableBatchAg
     if (batch) {
       this.arrowSchema = this.arrowSchema || getArrowSchema(batch.schema);
       const arrowVectors = getArrowVectors(this.arrowSchema, batch.data);
-      const recordBatch = new arrow.RecordBatch(
-        this.arrowSchema,
-        arrow.makeData({
-          type: new arrow.Struct(this.arrowSchema.fields),
-          children: arrowVectors.map(({ data }) => data[0])
-        })
-      );
+      const recordBatch = new arrow.RecordBatch(this.arrowSchema, arrow.makeData({
+        type: new arrow.Struct(this.arrowSchema.fields),
+        children: arrowVectors.map(({ data }) => data[0])
+      }));
       return {
         shape: "arrow-table",
         batchType: "data",
@@ -120,7 +118,7 @@ function getArrowVectors(arrowSchema, data) {
   return arrowVectors;
 }
 
-// src/schema/arrow-type-utils.ts
+// dist/schema/arrow-type-utils.js
 var arrow2 = __toESM(require("apache-arrow"), 1);
 function getArrowType(array) {
   switch (array.constructor) {
@@ -145,18 +143,18 @@ function getArrowType(array) {
   }
 }
 
-// src/types.ts
-var VECTOR_TYPES = /* @__PURE__ */ ((VECTOR_TYPES2) => {
+// dist/types.js
+var VECTOR_TYPES;
+(function(VECTOR_TYPES2) {
   VECTOR_TYPES2[VECTOR_TYPES2["FLOAT"] = 0] = "FLOAT";
   VECTOR_TYPES2[VECTOR_TYPES2["DATE"] = 1] = "DATE";
-  return VECTOR_TYPES2;
-})(VECTOR_TYPES || {});
+})(VECTOR_TYPES || (VECTOR_TYPES = {}));
 
-// src/parsers/parse-arrow-sync.ts
+// dist/parsers/parse-arrow-sync.js
 var import_schema2 = require("@loaders.gl/schema");
 var arrow4 = __toESM(require("apache-arrow"), 1);
 
-// src/tables/convert-arrow-to-columnar-table.ts
+// dist/tables/convert-arrow-to-columnar-table.js
 function convertArrowToColumnarTable(table) {
   const arrowTable = table.data;
   const columnarTable = {};
@@ -172,7 +170,7 @@ function convertArrowToColumnarTable(table) {
   };
 }
 
-// src/schema/convert-arrow-schema.ts
+// dist/schema/convert-arrow-schema.js
 var arrow3 = __toESM(require("apache-arrow"), 1);
 function serializeArrowSchema(arrowSchema) {
   return {
@@ -181,10 +179,7 @@ function serializeArrowSchema(arrowSchema) {
   };
 }
 function deserializeArrowSchema(schema) {
-  return new arrow3.Schema(
-    schema.fields.map((field) => deserializeArrowField(field)),
-    deserializeArrowMetadata(schema.metadata)
-  );
+  return new arrow3.Schema(schema.fields.map((field) => deserializeArrowField(field)), deserializeArrowMetadata(schema.metadata));
 }
 function serializeArrowMetadata(arrowMetadata) {
   return Object.fromEntries(arrowMetadata);
@@ -201,12 +196,7 @@ function serializeArrowField(field) {
   };
 }
 function deserializeArrowField(field) {
-  return new arrow3.Field(
-    field.name,
-    deserializeArrowType(field.type),
-    field.nullable,
-    deserializeArrowMetadata(field.metadata)
-  );
+  return new arrow3.Field(field.name, deserializeArrowType(field.type), field.nullable, deserializeArrowMetadata(field.metadata));
 }
 function serializeArrowType(arrowType) {
   switch (arrowType.constructor) {
@@ -440,7 +430,7 @@ function deserializeArrowType(dataType) {
   }
 }
 
-// src/parsers/parse-arrow-sync.ts
+// dist/parsers/parse-arrow-sync.js
 function parseArrowSync(arrayBuffer, options) {
   const apacheArrowTable = arrow4.tableFromIPC([new Uint8Array(arrayBuffer)]);
   const arrowTable = {
@@ -465,7 +455,7 @@ function parseArrowSync(arrayBuffer, options) {
   }
 }
 
-// src/parsers/parse-arrow-in-batches.ts
+// dist/parsers/parse-arrow-in-batches.js
 var arrow5 = __toESM(require("apache-arrow"), 1);
 function parseArrowInBatches(asyncIterator, options) {
   async function* makeArrowAsyncIterator() {
@@ -493,8 +483,8 @@ function parseArrowInBatches(asyncIterator, options) {
   return makeArrowAsyncIterator();
 }
 
-// src/arrow-loader.ts
-var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+// dist/arrow-loader.js
+var VERSION = true ? "4.2.0-alpha.5" : "latest";
 var ArrowWorkerLoader = {
   name: "Apache Arrow",
   id: "arrow",
@@ -523,7 +513,7 @@ var ArrowLoader = {
   parseInBatches: parseArrowInBatches
 };
 
-// src/lib/encode-arrow.ts
+// dist/lib/encode-arrow.js
 var arrow6 = __toESM(require("apache-arrow"), 1);
 function encodeArrowSync(data) {
   const vectors = {};
@@ -537,16 +527,16 @@ function encodeArrowSync(data) {
 }
 function createVector(array, type) {
   switch (type) {
-    case 1 /* DATE */:
+    case VECTOR_TYPES.DATE:
       return arrow6.vectorFromArray(array);
-    case 0 /* FLOAT */:
+    case VECTOR_TYPES.FLOAT:
     default:
       return arrow6.vectorFromArray(array);
   }
 }
 
-// src/arrow-writer.ts
-var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+// dist/arrow-writer.js
+var VERSION2 = true ? "4.2.0-alpha.5" : "latest";
 var ArrowWriter = {
   name: "Apache Arrow",
   id: "arrow",
@@ -568,7 +558,7 @@ var ArrowWriter = {
   }
 };
 
-// src/tables/convert-arrow-to-geojson-table.ts
+// dist/tables/convert-arrow-to-geojson-table.js
 var import_arrow = require("@loaders.gl/arrow");
 var import_gis = require("@loaders.gl/gis");
 function convertArrowToGeoJSONTable(table) {
@@ -597,7 +587,7 @@ function convertArrowToGeoJSONTable(table) {
   };
 }
 
-// src/parsers/parse-geoarrow-sync.ts
+// dist/parsers/parse-geoarrow-sync.js
 function parseGeoArrowSync(arrayBuffer, options) {
   const table = parseArrowSync(arrayBuffer, { shape: "arrow-table" });
   switch (options == null ? void 0 : options.shape) {
@@ -608,12 +598,12 @@ function parseGeoArrowSync(arrayBuffer, options) {
   }
 }
 
-// src/parsers/parse-geoarrow-in-batches.ts
+// dist/parsers/parse-geoarrow-in-batches.js
 function parseGeoArrowInBatches(asyncIterator) {
   return parseArrowInBatches(asyncIterator);
 }
 
-// src/geoarrow-loader.ts
+// dist/geoarrow-loader.js
 var GeoArrowWorkerLoader = {
   ...ArrowWorkerLoader,
   options: {
@@ -634,10 +624,10 @@ var GeoArrowLoader = {
   parseInBatches: parseGeoArrowInBatches
 };
 
-// src/geoarrow/convert-geoarrow-to-binary-geometry.ts
+// dist/geoarrow/convert-geoarrow-to-binary-geometry.js
 var import_polygon = require("@math.gl/polygon");
 
-// src/geoarrow/get-arrow-bounds.ts
+// dist/geoarrow/get-arrow-bounds.js
 function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds, sampleSize = 100) {
   const numberOfFeatures = flatCoords.length / nDim;
   const sampleStep = Math.max(Math.floor(numberOfFeatures / sampleSize), 1);
@@ -661,7 +651,13 @@ function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds, sampleSize =
   return newBounds;
 }
 
-// src/geoarrow/convert-geoarrow-to-binary-geometry.ts
+// dist/geoarrow/convert-geoarrow-to-binary-geometry.js
+var BinaryGeometryType;
+(function(BinaryGeometryType2) {
+  BinaryGeometryType2["points"] = "points";
+  BinaryGeometryType2["lines"] = "lines";
+  BinaryGeometryType2["polygons"] = "polygons";
+})(BinaryGeometryType || (BinaryGeometryType = {}));
 function getBinaryGeometryTemplate() {
   return {
     globalFeatureIds: { value: new Uint32Array(0), size: 1 },
@@ -744,11 +740,11 @@ function getMeanCentersFromBinaryGeometries(binaryGeometries) {
     var _a;
     let binaryGeometryType = null;
     if (binaryGeometry.points && binaryGeometry.points.positions.value.length > 0) {
-      binaryGeometryType = "points" /* points */;
+      binaryGeometryType = BinaryGeometryType.points;
     } else if (binaryGeometry.lines && binaryGeometry.lines.positions.value.length > 0) {
-      binaryGeometryType = "lines" /* lines */;
+      binaryGeometryType = BinaryGeometryType.lines;
     } else if (binaryGeometry.polygons && binaryGeometry.polygons.positions.value.length > 0) {
-      binaryGeometryType = "polygons" /* polygons */;
+      binaryGeometryType = BinaryGeometryType.polygons;
     }
     const binaryContent = binaryGeometryType ? binaryGeometry[binaryGeometryType] : null;
     if (binaryContent && binaryGeometryType !== null) {
@@ -756,13 +752,7 @@ function getMeanCentersFromBinaryGeometries(binaryGeometries) {
       const flatCoordinateArray = binaryContent.positions.value;
       const nDim = binaryContent.positions.size;
       const primitivePolygonIndices = binaryContent.type === "Polygon" ? (_a = binaryContent.primitivePolygonIndices) == null ? void 0 : _a.value : void 0;
-      const meanCenters = getMeanCentersFromGeometry(
-        featureIds,
-        flatCoordinateArray,
-        nDim,
-        binaryGeometryType,
-        primitivePolygonIndices
-      );
+      const meanCenters = getMeanCentersFromGeometry(featureIds, flatCoordinateArray, nDim, binaryGeometryType, primitivePolygonIndices);
       meanCenters.forEach((center) => {
         globalMeanCenters.push(center);
       });
@@ -781,7 +771,7 @@ function getMeanCentersFromGeometry(featureIds, flatCoordinateArray, nDim, geome
     const center = [0, 0];
     let vertexCountInFeature = 0;
     while (vertexIndex < vertexCount && featureIds[coordIdx] === featureId) {
-      if (geometryType === "polygons" /* polygons */ && (primitivePolygonIndices == null ? void 0 : primitivePolygonIndices[primitiveIdx]) === coordIdx) {
+      if (geometryType === BinaryGeometryType.polygons && (primitivePolygonIndices == null ? void 0 : primitivePolygonIndices[primitiveIdx]) === coordIdx) {
         vertexIndex += nDim;
         primitiveIdx++;
       } else {
@@ -828,11 +818,7 @@ function getTriangleIndices(polygonIndices, primitivePolygonIndices, flatCoordin
         }
         primitiveIndex++;
       }
-      const triangleIndices = (0, import_polygon.earcut)(
-        slicedFlatCoords,
-        holeIndices.length > 0 ? holeIndices : void 0,
-        nDim
-      );
+      const triangleIndices = (0, import_polygon.earcut)(slicedFlatCoords, holeIndices.length > 0 ? holeIndices : void 0, nDim);
       if (triangleIndices.length === 0) {
         throw Error("earcut failed e.g. invalid polygon");
       }
@@ -953,7 +939,7 @@ function getBinaryPointsFromChunk(chunk, geoEncoding) {
   };
 }
 
-// src/geoarrow/convert-geoarrow-to-geojson-geometry.ts
+// dist/geoarrow/convert-geoarrow-to-geojson-geometry.js
 var import_gis2 = require("@loaders.gl/gis");
 var import_wkt = require("@loaders.gl/wkt");
 function parseGeometryFromArrow2(arrowCellValue, encoding) {
@@ -995,10 +981,7 @@ function parseGeometryFromArrow2(arrowCellValue, encoding) {
 }
 function arrowWKBToFeature(arrowCellValue) {
   var _a, _b;
-  const arrayBuffer = arrowCellValue.buffer.slice(
-    arrowCellValue.byteOffset,
-    arrowCellValue.byteOffset + arrowCellValue.byteLength
-  );
+  const arrayBuffer = arrowCellValue.buffer.slice(arrowCellValue.byteOffset, arrowCellValue.byteOffset + arrowCellValue.byteLength);
   const binaryGeometry = (_b = (_a = import_wkt.WKBLoader).parseSync) == null ? void 0 : _b.call(_a, arrayBuffer);
   const geometry = (0, import_gis2.binaryToGeometry)(binaryGeometry);
   return geometry;
@@ -1104,7 +1087,7 @@ function arrowLineStringToFeature(arrowLineString) {
   };
 }
 
-// src/workers/hard-clone.ts
+// dist/workers/hard-clone.js
 var arrow7 = __toESM(require("apache-arrow"), 1);
 function hardClone(data, force = false) {
   if ("data" in data) {
@@ -1149,9 +1132,9 @@ function cloneBuffer(arr, force) {
   return arr.slice();
 }
 
-// src/triangulate-on-worker.ts
+// dist/triangulate-on-worker.js
 var import_worker_utils = require("@loaders.gl/worker-utils");
-var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var VERSION3 = true ? "4.2.0-alpha.5" : "latest";
 var TriangulationWorker = {
   id: "triangulation",
   name: "Triangulate",
@@ -1166,5 +1149,6 @@ function parseGeoArrowOnWorker(data, options = {}) {
   return (0, import_worker_utils.processOnWorker)(TriangulationWorker, { ...data, operation: "parse-geoarrow" }, options);
 }
 
-// src/index.ts
+// dist/index.js
 import_schema3.TableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["index.js", "lib/arrow-table-batch.js", "schema/arrow-type-utils.js", "types.js", "parsers/parse-arrow-sync.js", "tables/convert-arrow-to-columnar-table.js", "schema/convert-arrow-schema.js", "parsers/parse-arrow-in-batches.js", "arrow-loader.js", "lib/encode-arrow.js", "arrow-writer.js", "tables/convert-arrow-to-geojson-table.js", "parsers/parse-geoarrow-sync.js", "parsers/parse-geoarrow-in-batches.js", "geoarrow-loader.js", "geoarrow/convert-geoarrow-to-binary-geometry.js", "geoarrow/get-arrow-bounds.js", "geoarrow/convert-geoarrow-to-geojson-geometry.js", "workers/hard-clone.js", "triangulate-on-worker.js"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { TableBatchBuilder } from '@loaders.gl/schema';\nimport { ArrowTableBatchAggregator } from \"./lib/arrow-table-batch.js\";\n// Make the ArrowBatch type available\nTableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;\n// TYPES\nexport { getArrowType } from \"./schema/arrow-type-utils.js\";\nexport { VECTOR_TYPES } from \"./types.js\";\nexport { ArrowLoader, ArrowWorkerLoader } from \"./arrow-loader.js\";\nexport { ArrowWriter } from \"./arrow-writer.js\";\n// Geoarrow loader\nexport { GeoArrowLoader, GeoArrowWorkerLoader } from \"./geoarrow-loader.js\";\n// Schema utils\nexport { serializeArrowSchema, deserializeArrowSchema, serializeArrowMetadata, deserializeArrowMetadata, serializeArrowField, deserializeArrowField, serializeArrowType, deserializeArrowType } from \"./schema/convert-arrow-schema.js\";\nexport { getBinaryGeometryTemplate, getBinaryGeometriesFromArrow, getTriangleIndices, getMeanCentersFromBinaryGeometries } from \"./geoarrow/convert-geoarrow-to-binary-geometry.js\";\nexport { updateBoundsFromGeoArrowSamples } from \"./geoarrow/get-arrow-bounds.js\";\nexport { parseGeometryFromArrow } from \"./geoarrow/convert-geoarrow-to-geojson-geometry.js\";\nexport { convertArrowToGeoJSONTable } from \"./tables/convert-arrow-to-geojson-table.js\";\n// EXPERIMENTAL WORKER\nexport { hardClone } from \"./workers/hard-clone.js\";\nexport { TriangulationWorker, triangulateOnWorker, parseGeoArrowOnWorker } from \"./triangulate-on-worker.js\";\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { ColumnarTableBatchAggregator } from '@loaders.gl/schema';\nimport * as arrow from 'apache-arrow';\nexport class ArrowTableBatchAggregator extends ColumnarTableBatchAggregator {\n    arrowSchema;\n    constructor(schema, options) {\n        super(schema, options);\n        this.arrowSchema = null;\n    }\n    getBatch() {\n        const batch = super.getBatch();\n        if (batch) {\n            // Get the arrow schema\n            this.arrowSchema = this.arrowSchema || getArrowSchema(batch.schema);\n            // Get arrow format vectors\n            const arrowVectors = getArrowVectors(this.arrowSchema, batch.data);\n            // Create the record batch\n            const recordBatch = new arrow.RecordBatch(this.arrowSchema, arrow.makeData({\n                type: new arrow.Struct(this.arrowSchema.fields),\n                children: arrowVectors.map(({ data }) => data[0])\n            }));\n            return {\n                shape: 'arrow-table',\n                batchType: 'data',\n                data: new arrow.Table([recordBatch]),\n                length: batch.length\n            };\n        }\n        return null;\n    }\n}\n// Convert from a simple loaders.gl schema to an Arrow schema\nfunction getArrowSchema(schema) {\n    const arrowFields = [];\n    for (const key in schema) {\n        const field = schema[key];\n        if (field.type === Float32Array) {\n            // TODO - just store the original field as metadata?\n            const metadata = new Map(); // field;\n            // arrow: new arrow.Field(name, nullable, metadata)\n            const arrowField = new arrow.Field(field.name, new arrow.Float32(), field.nullable, metadata);\n            arrowFields.push(arrowField);\n        }\n    }\n    if (arrowFields.length === 0) {\n        throw new Error('No arrow convertible fields');\n    }\n    return new arrow.Schema(arrowFields);\n}\n// Convert from simple loaders.gl arrays to arrow vectors\nfunction getArrowVectors(arrowSchema, data) {\n    const arrowVectors = [];\n    for (const field of arrowSchema.fields) {\n        const vector = data[field.name];\n        if (vector instanceof Float32Array) {\n            const arrowVector = arrow.makeVector(vector);\n            arrowVectors.push(arrowVector);\n        }\n    }\n    if (arrowSchema.fields.length !== arrowVectors.length) {\n        throw new Error('Some columns not arrow convertible');\n    }\n    return arrowVectors;\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport * as arrow from 'apache-arrow';\n/** Return an Apache Arrow Type instance that corresponds to the type of the elements in the supplied Typed Array */\nexport function getArrowType(array) {\n    switch (array.constructor) {\n        case Int8Array:\n            return new arrow.Int8();\n        case Uint8Array:\n            return new arrow.Uint8();\n        case Int16Array:\n            return new arrow.Int16();\n        case Uint16Array:\n            return new arrow.Uint16();\n        case Int32Array:\n            return new arrow.Int32();\n        case Uint32Array:\n            return new arrow.Uint32();\n        case Float32Array:\n            return new arrow.Float32();\n        case Float64Array:\n            return new arrow.Float64();\n        default:\n            throw new Error('array type not supported');\n    }\n}\n/*\nexport function getArrowVector(array: TypedArray): AbstractVector {\n  switch (array.constructor) {\n    case Int8Array:\n      return Int8Vector.from(array);\n    case Uint8Array:\n      return Uint8Vector.from(array);\n    case Int16Array:\n      return Int16Vector.from(array);\n    case Uint16Array:\n      return Uint16Vector.from(array);\n    case Int32Array:\n      return Int32Vector.from(array);\n    case Uint32Array:\n      return Uint32Vector.from(array);\n    case Float32Array:\n      return Float32Vector.from(array);\n    case Float64Array:\n      return Float64Vector.from(array);\n    default:\n      throw new Error('array type not supported');\n  }\n}\n*/\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport var VECTOR_TYPES;\n(function (VECTOR_TYPES) {\n    VECTOR_TYPES[VECTOR_TYPES[\"FLOAT\"] = 0] = \"FLOAT\";\n    VECTOR_TYPES[VECTOR_TYPES[\"DATE\"] = 1] = \"DATE\";\n})(VECTOR_TYPES || (VECTOR_TYPES = {}));\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { convertTable } from '@loaders.gl/schema';\nimport * as arrow from 'apache-arrow';\nimport { convertArrowToColumnarTable } from \"../tables/convert-arrow-to-columnar-table.js\";\nimport { serializeArrowSchema } from \"../schema/convert-arrow-schema.js\";\n// Parses arrow to a columnar table\nexport function parseArrowSync(arrayBuffer, options) {\n    const apacheArrowTable = arrow.tableFromIPC([new Uint8Array(arrayBuffer)]);\n    const arrowTable = {\n        shape: 'arrow-table',\n        schema: serializeArrowSchema(apacheArrowTable.schema),\n        data: apacheArrowTable\n    };\n    const shape = options?.shape || 'arrow-table';\n    switch (shape) {\n        case 'arrow-table':\n            return arrowTable;\n        case 'columnar-table':\n            return convertArrowToColumnarTable(arrowTable);\n        case 'object-row-table':\n            let columnarTable = convertArrowToColumnarTable(arrowTable);\n            return convertTable(columnarTable, 'object-row-table');\n        case 'array-row-table':\n            columnarTable = convertArrowToColumnarTable(arrowTable);\n            return convertTable(columnarTable, 'array-row-table');\n        default:\n            // TODO\n            throw new Error(shape);\n    }\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/**\n * Convert an Apache Arrow table to a ColumnarTable\n * @note Currently does not convert schema\n */\nexport function convertArrowToColumnarTable(table) {\n    // TODO - avoid calling `getColumn` on columns we are not interested in?\n    // Add options object?\n    const arrowTable = table.data;\n    const columnarTable = {};\n    for (const field of arrowTable.schema.fields) {\n        // This (is intended to) coalesce all record batches into a single typed array\n        const arrowColumn = arrowTable.getChild(field.name);\n        const values = arrowColumn?.toArray();\n        columnarTable[field.name] = values;\n    }\n    return {\n        shape: 'columnar-table',\n        schema: table.schema,\n        data: columnarTable\n    };\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport * as arrow from 'apache-arrow';\n/** Convert Apache Arrow Schema (class instance) to a serialized Schema (plain data) */\nexport function serializeArrowSchema(arrowSchema) {\n    return {\n        fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),\n        metadata: serializeArrowMetadata(arrowSchema.metadata)\n    };\n}\n/** Convert a serialized Schema (plain data) to an Apache Arrow Schema (class instance) */\nexport function deserializeArrowSchema(schema) {\n    return new arrow.Schema(schema.fields.map((field) => deserializeArrowField(field)), deserializeArrowMetadata(schema.metadata));\n}\n/** Convert Apache Arrow Schema metadata (Map<string, string>) to serialized metadata (Record<string, string> */\nexport function serializeArrowMetadata(arrowMetadata) {\n    return Object.fromEntries(arrowMetadata);\n}\n/** Convert serialized metadata (Record<string, string> to Apache Arrow Schema metadata (Map<string, string>) to */\nexport function deserializeArrowMetadata(metadata) {\n    return metadata ? new Map(Object.entries(metadata)) : new Map();\n}\n/** Convert Apache Arrow Field (class instance) to serialized Field (plain data) */\nexport function serializeArrowField(field) {\n    return {\n        name: field.name,\n        type: serializeArrowType(field.type),\n        nullable: field.nullable,\n        metadata: serializeArrowMetadata(field.metadata)\n    };\n}\n/** Convert a serialized Field (plain data) to an Apache Arrow Field (class instance)*/\nexport function deserializeArrowField(field) {\n    return new arrow.Field(field.name, deserializeArrowType(field.type), field.nullable, deserializeArrowMetadata(field.metadata));\n}\n/** Converts a serializable loaders.gl data type to hydrated arrow data type */\n// eslint-disable-next-line complexity\nexport function serializeArrowType(arrowType) {\n    switch (arrowType.constructor) {\n        case arrow.Null:\n            return 'null';\n        case arrow.Binary:\n            return 'binary';\n        case arrow.Bool:\n            return 'bool';\n        case arrow.Int:\n            const intType = arrowType;\n            return `${intType.isSigned ? 'u' : ''}int${intType.bitWidth}`;\n        case arrow.Int8:\n            return 'int8';\n        case arrow.Int16:\n            return 'int16';\n        case arrow.Int32:\n            return 'int32';\n        case arrow.Int64:\n            return 'int64';\n        case arrow.Uint8:\n            return 'uint8';\n        case arrow.Uint16:\n            return 'uint16';\n        case arrow.Uint32:\n            return 'uint32';\n        case arrow.Uint64:\n            return 'uint64';\n        case arrow.Float:\n            const precision = arrowType.precision;\n            // return `float(precision + 1) * 16`;\n            switch (precision) {\n                case arrow.Precision.HALF:\n                    return 'float16';\n                case arrow.Precision.SINGLE:\n                    return 'float32';\n                case arrow.Precision.DOUBLE:\n                    return 'float64';\n                default:\n                    return 'float16';\n            }\n        case arrow.Float16:\n            return 'float16';\n        case arrow.Float32:\n            return 'float32';\n        case arrow.Float64:\n            return 'float64';\n        case arrow.Utf8:\n            return 'utf8';\n        case arrow.Decimal:\n            const decimal = arrowType;\n            return {\n                type: 'decimal',\n                bitWidth: decimal.bitWidth,\n                precision: decimal.precision,\n                scale: decimal.scale\n            };\n        case arrow.Date_:\n            const dateUnit = arrowType.unit;\n            return dateUnit === arrow.DateUnit.DAY ? 'date-day' : 'date-millisecond';\n        case arrow.DateDay:\n            return 'date-day';\n        case arrow.DateMillisecond:\n            return 'date-millisecond';\n        case arrow.Time:\n            const timeUnit = arrowType.unit;\n            switch (timeUnit) {\n                case arrow.TimeUnit.SECOND:\n                    return 'time-second';\n                case arrow.TimeUnit.MILLISECOND:\n                    return 'time-millisecond';\n                case arrow.TimeUnit.MICROSECOND:\n                    return 'time-microsecond';\n                case arrow.TimeUnit.NANOSECOND:\n                    return 'time-nanosecond';\n                default:\n                    return 'time-second';\n            }\n        case arrow.TimeMillisecond:\n            return 'time-millisecond';\n        case arrow.TimeSecond:\n            return 'time-second';\n        case arrow.TimeMicrosecond:\n            return 'time-microsecond';\n        case arrow.TimeNanosecond:\n            return 'time-nanosecond';\n        case arrow.Timestamp:\n            const timeStampUnit = arrowType.unit;\n            switch (timeStampUnit) {\n                case arrow.TimeUnit.SECOND:\n                    return 'timestamp-second';\n                case arrow.TimeUnit.MILLISECOND:\n                    return 'timestamp-millisecond';\n                case arrow.TimeUnit.MICROSECOND:\n                    return 'timestamp-microsecond';\n                case arrow.TimeUnit.NANOSECOND:\n                    return 'timestamp-nanosecond';\n                default:\n                    return 'timestamp-second';\n            }\n        case arrow.TimestampSecond:\n            return 'timestamp-second';\n        case arrow.TimestampMillisecond:\n            return 'timestamp-millisecond';\n        case arrow.TimestampMicrosecond:\n            return 'timestamp-microsecond';\n        case arrow.TimestampNanosecond:\n            return 'timestamp-nanosecond';\n        case arrow.Interval:\n            const intervalUnit = arrowType.unit;\n            switch (intervalUnit) {\n                case arrow.IntervalUnit.DAY_TIME:\n                    return 'interval-daytime';\n                case arrow.IntervalUnit.YEAR_MONTH:\n                    return 'interval-yearmonth';\n                default:\n                    return 'interval-daytime';\n            }\n        case arrow.IntervalDayTime:\n            return 'interval-daytime';\n        case arrow.IntervalYearMonth:\n            return 'interval-yearmonth';\n        case arrow.Map_:\n            const mapType = arrowType;\n            return {\n                type: 'map',\n                keysSorted: mapType.keysSorted,\n                children: mapType.children.map((arrowField) => serializeArrowField(arrowField))\n            };\n        case arrow.List:\n            const listType = arrowType;\n            const listField = listType.valueField;\n            return {\n                type: 'list',\n                children: [serializeArrowField(listField)]\n            };\n        case arrow.FixedSizeList:\n            const fixedSizeList = arrowType;\n            return {\n                type: 'fixed-size-list',\n                listSize: fixedSizeList.listSize,\n                children: [serializeArrowField(fixedSizeList.children[0])]\n            };\n        case arrow.Struct:\n            const structType = arrowType;\n            return {\n                type: 'struct',\n                children: structType.children.map((arrowField) => serializeArrowField(arrowField))\n            };\n        default:\n            throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);\n    }\n}\n/** Converts a serializable loaders.gl data type to hydrated arrow data type */\n// eslint-disable-next-line complexity\nexport function deserializeArrowType(dataType) {\n    if (typeof dataType === 'object') {\n        switch (dataType.type) {\n            case 'decimal':\n                return new arrow.Decimal(dataType.precision, dataType.scale, dataType.bitWidth);\n            case 'map':\n                let children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));\n                return new arrow.Map_(children, dataType.keysSorted);\n            case 'list':\n                const field = deserializeArrowField(dataType.children[0]);\n                return new arrow.List(field);\n            case 'fixed-size-list':\n                const child = deserializeArrowField(dataType.children[0]);\n                return new arrow.FixedSizeList(dataType.listSize, child);\n            case 'struct':\n                children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));\n                return new arrow.Struct(children);\n            default:\n                throw new Error('array type not supported');\n        }\n    }\n    switch (dataType) {\n        case 'null':\n            return new arrow.Null();\n        case 'binary':\n            return new arrow.Binary();\n        case 'bool':\n            return new arrow.Bool();\n        case 'int8':\n            return new arrow.Int8();\n        case 'int16':\n            return new arrow.Int16();\n        case 'int32':\n            return new arrow.Int32();\n        case 'int64':\n            return new arrow.Int64();\n        case 'uint8':\n            return new arrow.Uint8();\n        case 'uint16':\n            return new arrow.Uint16();\n        case 'uint32':\n            return new arrow.Uint32();\n        case 'uint64':\n            return new arrow.Uint64();\n        case 'float16':\n            return new arrow.Float16();\n        case 'float32':\n            return new arrow.Float32();\n        case 'float64':\n            return new arrow.Float64();\n        case 'utf8':\n            return new arrow.Utf8();\n        case 'date-day':\n            return new arrow.DateDay();\n        case 'date-millisecond':\n            return new arrow.DateMillisecond();\n        case 'time-second':\n            return new arrow.TimeSecond();\n        case 'time-millisecond':\n            return new arrow.TimeMillisecond();\n        case 'time-microsecond':\n            return new arrow.TimeMicrosecond();\n        case 'time-nanosecond':\n            return new arrow.TimeNanosecond();\n        case 'timestamp-second':\n            return new arrow.TimestampSecond();\n        case 'timestamp-millisecond':\n            return new arrow.TimestampMillisecond();\n        case 'timestamp-microsecond':\n            return new arrow.TimestampMicrosecond();\n        case 'timestamp-nanosecond':\n            return new arrow.TimestampNanosecond();\n        case 'interval-daytime':\n            return new arrow.IntervalDayTime();\n        case 'interval-yearmonth':\n            return new arrow.IntervalYearMonth();\n        default:\n            throw new Error('array type not supported');\n    }\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport * as arrow from 'apache-arrow';\n// import {isIterable} from '@loaders.gl/core';\n/**\n */\nexport function parseArrowInBatches(asyncIterator, options) {\n    // Creates the appropriate arrow.RecordBatchReader subclasses from the input\n    // This will also close the underlying source in case of early termination or errors\n    // As an optimization, return a non-async iterator\n    /*\n    if (isIterable(readers)) {\n      function* makeArrowIterator() {\n        for (const reader of readers) {\n          for (const batch of reader) {\n            yield processBatch(batch, reader);\n          }\n          break; // only processing one stream of batches\n        }\n      }\n      const arrowIterator = makeArrowIterator();\n    }\n    */\n    async function* makeArrowAsyncIterator() {\n        // @ts-ignore\n        const readers = arrow.RecordBatchReader.readAll(asyncIterator);\n        for await (const reader of readers) {\n            for await (const recordBatch of reader) {\n                // use options.batchDebounceMs to add a delay between batches if needed (use case: incremental loading)\n                if (options?.arrow?.batchDebounceMs !== undefined && options?.arrow?.batchDebounceMs > 0) {\n                    await new Promise((resolve) => setTimeout(resolve, options.arrow?.batchDebounceMs || 0));\n                }\n                const arrowTabledBatch = {\n                    shape: 'arrow-table',\n                    batchType: 'data',\n                    data: new arrow.Table([recordBatch]),\n                    length: recordBatch.data.length\n                };\n                // processBatch(recordBatch);\n                yield arrowTabledBatch;\n            }\n            break; // only processing one stream of batches\n        }\n    }\n    return makeArrowAsyncIterator(); // as AsyncIterator<ArrowTableBatch>;\n}\n// function processBatch(batch: RecordBatch): ArrowTableBatch {\n//   const values = {};\n//   batch.schema.fields.forEach(({name}, index) => {\n//     values[name] = batch.getChildAt(index)?.toArray();\n//   });\n//   return {\n//   };\n// }\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { parseArrowSync } from \"./parsers/parse-arrow-sync.js\";\nimport { parseArrowInBatches } from \"./parsers/parse-arrow-in-batches.js\";\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof \"4.2.0-alpha.5\" !== 'undefined' ? \"4.2.0-alpha.5\" : 'latest';\n/** ArrowJS table loader */\nexport const ArrowWorkerLoader = {\n    name: 'Apache Arrow',\n    id: 'arrow',\n    module: 'arrow',\n    version: VERSION,\n    // worker: true,\n    category: 'table',\n    extensions: ['arrow', 'feather'],\n    mimeTypes: [\n        'application/vnd.apache.arrow.file',\n        'application/vnd.apache.arrow.stream',\n        'application/octet-stream'\n    ],\n    binary: true,\n    tests: ['ARROW'],\n    options: {\n        arrow: {\n            shape: 'columnar-table'\n        }\n    }\n};\n/** ArrowJS table loader */\nexport const ArrowLoader = {\n    ...ArrowWorkerLoader,\n    parse: async (arraybuffer, options) => parseArrowSync(arraybuffer, options?.arrow),\n    parseSync: (arraybuffer, options) => parseArrowSync(arraybuffer, options?.arrow),\n    parseInBatches: parseArrowInBatches\n};\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport * as arrow from 'apache-arrow';\nimport { VECTOR_TYPES } from \"../types.js\";\n/**\n * Encodes set of arrays into the Apache Arrow columnar format\n * https://arrow.apache.org/docs/format/Columnar.html#ipc-file-format\n * @param data - columns data\n * @param options - the writer options\n * @returns - encoded ArrayBuffer\n */\nexport function encodeArrowSync(data) {\n    const vectors = {};\n    for (const arrayData of data) {\n        const arrayVector = createVector(arrayData.array, arrayData.type);\n        vectors[arrayData.name] = arrayVector;\n    }\n    const table = new arrow.Table(vectors);\n    const arrowBuffer = arrow.tableToIPC(table);\n    return arrowBuffer;\n}\n/**\n * Create Arrow arrow.Vector from given data and vector type\n * @param array {import('../types').AnyArrayType} - columns data\n * @param type {number} - the writer options\n * @return a vector of one of vector's types defined in the Apache Arrow library\n */\nfunction createVector(array, type) {\n    switch (type) {\n        case VECTOR_TYPES.DATE:\n            return arrow.vectorFromArray(array);\n        case VECTOR_TYPES.FLOAT:\n        default:\n            return arrow.vectorFromArray(array);\n    }\n}\n", "// import type {} from '@loaders.gl/loader-utils';\nimport { encodeArrowSync } from \"./lib/encode-arrow.js\";\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof \"4.2.0-alpha.5\" !== 'undefined' ? \"4.2.0-alpha.5\" : 'latest';\n/** Apache Arrow writer */\nexport const ArrowWriter = {\n    name: 'Apache Arrow',\n    id: 'arrow',\n    module: 'arrow',\n    version: VERSION,\n    extensions: ['arrow', 'feather'],\n    mimeTypes: [\n        'application/vnd.apache.arrow.file',\n        'application/vnd.apache.arrow.stream',\n        'application/octet-stream'\n    ],\n    binary: true,\n    options: {},\n    encode: async function encodeArrow(data, options) {\n        return encodeArrowSync(data);\n    },\n    encodeSync(data, options) {\n        return encodeArrowSync(data);\n    }\n};\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { serializeArrowSchema, parseGeometryFromArrow } from '@loaders.gl/arrow';\nimport { getGeometryColumnsFromSchema } from '@loaders.gl/gis';\n/**\n * Wrap an apache arrow table in a loaders.gl table wrapper.\n * From this additional conversions are available.\n * @param arrowTable\n * @returns\n */\nexport function convertApacheArrowToArrowTable(arrowTable) {\n    return {\n        shape: 'arrow-table',\n        schema: serializeArrowSchema(arrowTable.schema),\n        data: arrowTable\n    };\n}\n/**\n * Convert an Apache Arrow table to a GeoJSONTable\n * @note Currently does not convert schema\n */\nexport function convertArrowToGeoJSONTable(table) {\n    const arrowTable = table.data;\n    const schema = serializeArrowSchema(arrowTable.schema);\n    const geometryColumns = getGeometryColumnsFromSchema(schema);\n    // get encoding from geometryColumns['geometry']\n    const encoding = geometryColumns.geometry.encoding;\n    const features = [];\n    // Remove geometry columns\n    const propertyColumnNames = arrowTable.schema.fields\n        .map((field) => field.name)\n        // TODO - this deletes all geometry columns\n        .filter((name) => !(name in geometryColumns));\n    const propertiesTable = arrowTable.select(propertyColumnNames);\n    const arrowGeometryColumn = arrowTable.getChild('geometry');\n    for (let row = 0; row < arrowTable.numRows; row++) {\n        // get the geometry value from arrow geometry column\n        // Note that type can vary\n        const arrowGeometry = arrowGeometryColumn?.get(row);\n        // parse arrow geometry to geojson feature\n        const feature = parseGeometryFromArrow(arrowGeometry, encoding);\n        if (feature) {\n            const properties = propertiesTable.get(row)?.toJSON() || {};\n            features.push({ type: 'Feature', geometry: feature, properties });\n        }\n    }\n    return {\n        shape: 'geojson-table',\n        type: 'FeatureCollection',\n        schema: table.schema,\n        features\n    };\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { parseArrowSync } from \"./parse-arrow-sync.js\";\nimport { convertArrowToGeoJSONTable } from \"../tables/convert-arrow-to-geojson-table.js\";\n// Parses arrow to a columnar table\nexport function parseGeoArrowSync(arrayBuffer, options) {\n    // | BinaryGeometry\n    const table = parseArrowSync(arrayBuffer, { shape: 'arrow-table' });\n    switch (options?.shape) {\n        case 'geojson-table':\n            return convertArrowToGeoJSONTable(table);\n        default:\n            return table;\n    }\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { parseArrowInBatches } from \"./parse-arrow-in-batches.js\";\n/**\n */\nexport function parseGeoArrowInBatches(asyncIterator) {\n    // | BinaryGeometry\n    return parseArrowInBatches(asyncIterator);\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { ArrowWorkerLoader } from \"./arrow-loader.js\";\nimport { parseGeoArrowSync } from \"./parsers/parse-geoarrow-sync.js\";\nimport { parseGeoArrowInBatches } from \"./parsers/parse-geoarrow-in-batches.js\";\n/** ArrowJS table loader */\nexport const GeoArrowWorkerLoader = {\n    ...ArrowWorkerLoader,\n    options: {\n        arrow: {\n            shape: 'arrow-table'\n        }\n    }\n};\n/**\n * GeoArrowLoader loads an Apache Arrow table, parses GeoArrow type extension data\n * to convert it to a GeoJSON table or a BinaryGeometry\n */\nexport const GeoArrowLoader = {\n    ...ArrowWorkerLoader,\n    options: {\n        arrow: {\n            shape: 'arrow-table'\n        }\n    },\n    parse: async (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options?.arrow),\n    parseSync: (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options?.arrow),\n    parseInBatches: parseGeoArrowInBatches\n};\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { earcut } from '@math.gl/polygon';\nimport { updateBoundsFromGeoArrowSamples } from \"./get-arrow-bounds.js\";\n/**\n * Binary geometry type\n */\nvar BinaryGeometryType;\n(function (BinaryGeometryType) {\n    BinaryGeometryType[\"points\"] = \"points\";\n    BinaryGeometryType[\"lines\"] = \"lines\";\n    BinaryGeometryType[\"polygons\"] = \"polygons\";\n})(BinaryGeometryType || (BinaryGeometryType = {}));\n/**\n * binary geometry template, see deck.gl BinaryGeometry\n */\nexport function getBinaryGeometryTemplate() {\n    return {\n        globalFeatureIds: { value: new Uint32Array(0), size: 1 },\n        positions: { value: new Float32Array(0), size: 2 },\n        properties: [],\n        numericProps: {},\n        featureIds: { value: new Uint32Array(0), size: 1 }\n    };\n}\n/**\n * get binary geometries from geoarrow column\n *\n * @param geoColumn the geoarrow column, e.g. arrowTable.getChildAt(geoColumnIndex)\n * @param geoEncoding the geo encoding of the geoarrow column, e.g. getGeoArrowEncoding(arrowTable.schema, geoColumnName)\n * @param options options for getting binary geometries {meanCenter: boolean}\n * @returns BinaryDataFromGeoArrow\n */\nexport function getBinaryGeometriesFromArrow(geoColumn, geoEncoding, options) {\n    const featureTypes = {\n        polygon: geoEncoding === 'geoarrow.multipolygon' || geoEncoding === 'geoarrow.polygon',\n        point: geoEncoding === 'geoarrow.multipoint' || geoEncoding === 'geoarrow.point',\n        line: geoEncoding === 'geoarrow.multilinestring' || geoEncoding === 'geoarrow.linestring'\n    };\n    const chunks = options?.chunkIndex !== undefined && options?.chunkIndex >= 0\n        ? [geoColumn.data[options?.chunkIndex]]\n        : geoColumn.data;\n    let bounds = [Infinity, Infinity, -Infinity, -Infinity];\n    let globalFeatureIdOffset = options?.chunkOffset || 0;\n    const binaryGeometries = [];\n    chunks.forEach((chunk) => {\n        const { featureIds, flatCoordinateArray, nDim, geomOffset, triangles } = getBinaryGeometriesFromChunk(chunk, geoEncoding, options);\n        const globalFeatureIds = new Uint32Array(featureIds.length);\n        for (let i = 0; i < featureIds.length; i++) {\n            globalFeatureIds[i] = featureIds[i] + globalFeatureIdOffset;\n        }\n        const binaryContent = {\n            globalFeatureIds: { value: globalFeatureIds, size: 1 },\n            positions: {\n                value: flatCoordinateArray,\n                size: nDim\n            },\n            featureIds: { value: featureIds, size: 1 },\n            // eslint-disable-next-line no-loop-func\n            properties: [...Array(chunk.length).keys()].map((i) => ({\n                index: i + globalFeatureIdOffset\n            }))\n        };\n        // TODO: check if chunks are sequentially accessed\n        globalFeatureIdOffset += chunk.length;\n        // NOTE: deck.gl defines the BinaryFeatures structure must have points, lines, polygons even if they are empty\n        binaryGeometries.push({\n            shape: 'binary-feature-collection',\n            points: {\n                type: 'Point',\n                ...getBinaryGeometryTemplate(),\n                ...(featureTypes.point ? binaryContent : {})\n            },\n            lines: {\n                type: 'LineString',\n                ...getBinaryGeometryTemplate(),\n                ...(featureTypes.line ? binaryContent : {}),\n                pathIndices: { value: featureTypes.line ? geomOffset : new Uint16Array(0), size: 1 }\n            },\n            polygons: {\n                type: 'Polygon',\n                ...getBinaryGeometryTemplate(),\n                ...(featureTypes.polygon ? binaryContent : {}),\n                polygonIndices: {\n                    // use geomOffset as polygonIndices same as primitivePolygonIndices since we are using earcut to get triangule indices\n                    value: featureTypes.polygon ? geomOffset : new Uint16Array(0),\n                    size: 1\n                },\n                primitivePolygonIndices: {\n                    value: featureTypes.polygon ? geomOffset : new Uint16Array(0),\n                    size: 1\n                },\n                ...(triangles ? { triangles: { value: triangles, size: 1 } } : {})\n            }\n        });\n        bounds = updateBoundsFromGeoArrowSamples(flatCoordinateArray, nDim, bounds);\n    });\n    return {\n        binaryGeometries,\n        bounds,\n        featureTypes,\n        ...(options?.calculateMeanCenters\n            ? { meanCenters: getMeanCentersFromBinaryGeometries(binaryGeometries) }\n            : {})\n    };\n}\n/**\n * Get mean centers from binary geometries\n * @param binaryGeometries binary geometries from geoarrow column, an array of BinaryFeatureCollection\n * @returns mean centers of the binary geometries\n */\nexport function getMeanCentersFromBinaryGeometries(binaryGeometries) {\n    const globalMeanCenters = [];\n    binaryGeometries.forEach((binaryGeometry) => {\n        let binaryGeometryType = null;\n        if (binaryGeometry.points && binaryGeometry.points.positions.value.length > 0) {\n            binaryGeometryType = BinaryGeometryType.points;\n        }\n        else if (binaryGeometry.lines && binaryGeometry.lines.positions.value.length > 0) {\n            binaryGeometryType = BinaryGeometryType.lines;\n        }\n        else if (binaryGeometry.polygons && binaryGeometry.polygons.positions.value.length > 0) {\n            binaryGeometryType = BinaryGeometryType.polygons;\n        }\n        const binaryContent = binaryGeometryType ? binaryGeometry[binaryGeometryType] : null;\n        if (binaryContent && binaryGeometryType !== null) {\n            const featureIds = binaryContent.featureIds.value;\n            const flatCoordinateArray = binaryContent.positions.value;\n            const nDim = binaryContent.positions.size;\n            const primitivePolygonIndices = binaryContent.type === 'Polygon' ? binaryContent.primitivePolygonIndices?.value : undefined;\n            const meanCenters = getMeanCentersFromGeometry(featureIds, flatCoordinateArray, nDim, binaryGeometryType, primitivePolygonIndices);\n            meanCenters.forEach((center) => {\n                globalMeanCenters.push(center);\n            });\n        }\n    });\n    return globalMeanCenters;\n}\n/**\n * Get mean centers from raw coordinates and feature ids\n * @param featureIds Array of feature ids indexes by vertex\n * @param flatCoordinateArray  Array of vertex, e.g. x, y or x, y, z, positions\n * @param nDim number of dimensions per position\n * @returns - mean centers of each polygon\n */\nfunction getMeanCentersFromGeometry(featureIds, flatCoordinateArray, nDim, geometryType, primitivePolygonIndices) {\n    const meanCenters = [];\n    const vertexCount = flatCoordinateArray.length;\n    let vertexIndex = 0;\n    let coordIdx = 0;\n    let primitiveIdx = 0;\n    while (vertexIndex < vertexCount) {\n        const featureId = featureIds[vertexIndex / nDim];\n        const center = [0, 0];\n        let vertexCountInFeature = 0;\n        while (vertexIndex < vertexCount && featureIds[coordIdx] === featureId) {\n            if (geometryType === BinaryGeometryType.polygons &&\n                primitivePolygonIndices?.[primitiveIdx] === coordIdx) {\n                // skip the first point since it is the same as the last point in each ring for polygons\n                vertexIndex += nDim;\n                primitiveIdx++;\n            }\n            else {\n                center[0] += flatCoordinateArray[vertexIndex];\n                center[1] += flatCoordinateArray[vertexIndex + 1];\n                vertexIndex += nDim;\n                vertexCountInFeature++;\n            }\n            coordIdx += 1;\n        }\n        center[0] /= vertexCountInFeature;\n        center[1] /= vertexCountInFeature;\n        meanCenters.push(center);\n    }\n    return meanCenters;\n}\n/**\n * get binary geometries from geoarrow column\n * @param chunk one chunk/batch of geoarrow column\n * @param geoEncoding geo encoding of the geoarrow column\n * @param options options for getting binary geometries\n * @returns BinaryGeometryContent\n */\nfunction getBinaryGeometriesFromChunk(chunk, geoEncoding, options) {\n    switch (geoEncoding) {\n        case 'geoarrow.point':\n        case 'geoarrow.multipoint':\n            return getBinaryPointsFromChunk(chunk, geoEncoding);\n        case 'geoarrow.linestring':\n        case 'geoarrow.multilinestring':\n            return getBinaryLinesFromChunk(chunk, geoEncoding);\n        case 'geoarrow.polygon':\n        case 'geoarrow.multipolygon':\n            return getBinaryPolygonsFromChunk(chunk, geoEncoding, options);\n        default:\n            throw Error('invalid geoarrow encoding');\n    }\n}\n/**\n * get triangle indices. Allows deck.gl to skip performing costly triangulation on main thread.\n * @param polygonIndices Indices within positions of the start of each simple Polygon\n * @param primitivePolygonIndices Indices within positions of the start of each primitive Polygon/ring\n * @param flatCoordinateArray Array of x, y or x, y, z positions\n * @param nDim - number of dimensions per position\n * @returns triangle indices or null if invalid polygon and earcut fails\n */\nexport function getTriangleIndices(polygonIndices, primitivePolygonIndices, flatCoordinateArray, nDim) {\n    try {\n        let primitiveIndex = 0;\n        const triangles = [];\n        // loop polygonIndices to get triangles\n        for (let i = 0; i < polygonIndices.length - 1; i++) {\n            const startIdx = polygonIndices[i];\n            const endIdx = polygonIndices[i + 1];\n            // get subarray of flatCoordinateArray\n            const slicedFlatCoords = flatCoordinateArray.subarray(startIdx * nDim, endIdx * nDim);\n            // get holeIndices for earcut\n            const holeIndices = [];\n            while (primitivePolygonIndices[primitiveIndex] < endIdx) {\n                if (primitivePolygonIndices[primitiveIndex] > startIdx) {\n                    holeIndices.push(primitivePolygonIndices[primitiveIndex] - startIdx);\n                }\n                primitiveIndex++;\n            }\n            // TODO check if each ring is closed\n            const triangleIndices = earcut(slicedFlatCoords, holeIndices.length > 0 ? holeIndices : undefined, nDim);\n            if (triangleIndices.length === 0) {\n                throw Error('earcut failed e.g. invalid polygon');\n            }\n            for (let j = 0; j < triangleIndices.length; j++) {\n                triangles.push(triangleIndices[j] + startIdx);\n            }\n        }\n        // convert traingles to Uint32Array\n        const trianglesUint32 = new Uint32Array(triangles.length);\n        for (let i = 0; i < triangles.length; i++) {\n            trianglesUint32[i] = triangles[i];\n        }\n        return trianglesUint32;\n    }\n    catch (error) {\n        // if earcut fails, return null\n        return null;\n    }\n}\n/**\n * get binary polygons from geoarrow polygon column\n * @param chunk one chunk of geoarrow polygon column\n * @param geoEncoding the geo encoding of the geoarrow polygon column\n * @param options options for getting binary geometries\n * @returns BinaryGeometryContent\n */\nfunction getBinaryPolygonsFromChunk(chunk, geoEncoding, options) {\n    const isMultiPolygon = geoEncoding === 'geoarrow.multipolygon';\n    const polygonData = isMultiPolygon ? chunk.children[0] : chunk;\n    const polygonOffset = polygonData.valueOffsets;\n    const partData = isMultiPolygon\n        ? chunk.valueOffsets.map((i) => polygonOffset.at(i) || i)\n        : chunk.valueOffsets;\n    const ringData = polygonData.children[0];\n    const pointData = ringData.children[0];\n    const coordData = pointData.children[0];\n    const nDim = pointData.stride;\n    const geomOffset = ringData.valueOffsets;\n    const flatCoordinateArray = coordData.values;\n    const geometryIndicies = new Uint16Array(polygonOffset.length);\n    for (let i = 0; i < polygonOffset.length; i++) {\n        geometryIndicies[i] = geomOffset[polygonOffset[i]];\n    }\n    const numOfVertices = flatCoordinateArray.length / nDim;\n    const featureIds = new Uint32Array(numOfVertices);\n    for (let i = 0; i < partData.length - 1; i++) {\n        const startIdx = geomOffset[partData[i]];\n        const endIdx = geomOffset[partData[i + 1]];\n        for (let j = startIdx; j < endIdx; j++) {\n            featureIds[j] = i;\n        }\n    }\n    const triangles = options?.triangulate\n        ? getTriangleIndices(geometryIndicies, geomOffset, flatCoordinateArray, nDim)\n        : null;\n    return {\n        featureIds,\n        nDim,\n        flatCoordinateArray,\n        geomOffset,\n        geometryIndicies,\n        ...(options?.triangulate && triangles ? { triangles } : {})\n    };\n}\n/**\n * get binary lines from geoarrow line column\n * @param chunk one chunk/batch of geoarrow column\n * @param geoEncoding the geo encoding of the geoarrow column\n * @returns BinaryGeometryContent\n */\nfunction getBinaryLinesFromChunk(chunk, geoEncoding) {\n    const isMultiLineString = geoEncoding === 'geoarrow.multilinestring';\n    const lineData = isMultiLineString ? chunk.children[0] : chunk;\n    const pointData = lineData.children[0];\n    const coordData = pointData.children[0];\n    const nDim = pointData.stride;\n    const geomOffset = lineData.valueOffsets;\n    const flatCoordinateArray = coordData.values;\n    // geometryIndicies is not needed for line string\n    const geometryIndicies = new Uint16Array(0);\n    const numOfVertices = flatCoordinateArray.length / nDim;\n    const featureIds = new Uint32Array(numOfVertices);\n    if (isMultiLineString) {\n        const partData = chunk.valueOffsets;\n        for (let i = 0; i < partData.length - 1; i++) {\n            const startIdx = geomOffset[partData[i]];\n            const endIdx = geomOffset[partData[i + 1]];\n            for (let j = startIdx; j < endIdx; j++) {\n                featureIds[j] = i;\n            }\n        }\n    }\n    else {\n        for (let i = 0; i < chunk.length; i++) {\n            const startIdx = geomOffset[i];\n            const endIdx = geomOffset[i + 1];\n            for (let j = startIdx; j < endIdx; j++) {\n                featureIds[j] = i;\n            }\n        }\n    }\n    return {\n        featureIds,\n        flatCoordinateArray,\n        nDim,\n        geomOffset,\n        geometryIndicies\n    };\n}\n/**\n * get binary points from geoarrow point column\n * @param chunk one chunk/batch of geoarrow column\n * @param geoEncoding  geo encoding of the geoarrow column\n * @returns BinaryGeometryContent\n */\nfunction getBinaryPointsFromChunk(chunk, geoEncoding) {\n    const isMultiPoint = geoEncoding === 'geoarrow.multipoint';\n    const pointData = isMultiPoint ? chunk.children[0] : chunk;\n    const coordData = pointData.children[0];\n    const nDim = pointData.stride;\n    const flatCoordinateArray = coordData.values;\n    // geometryIndices is not needed for point\n    const geometryIndicies = new Uint16Array(0);\n    // geomOffset is not needed for point\n    const geomOffset = new Int32Array(0);\n    const numOfVertices = flatCoordinateArray.length / nDim;\n    const featureIds = new Uint32Array(numOfVertices);\n    if (isMultiPoint) {\n        const partData = chunk.valueOffsets;\n        for (let i = 0; i < partData.length - 1; i++) {\n            const startIdx = partData[i];\n            const endIdx = partData[i + 1];\n            for (let j = startIdx; j < endIdx; j++) {\n                featureIds[j] = i;\n            }\n        }\n    }\n    else {\n        for (let i = 0; i < chunk.length; i++) {\n            featureIds[i] = i;\n        }\n    }\n    return {\n        featureIds,\n        flatCoordinateArray,\n        nDim,\n        geomOffset,\n        geometryIndicies\n    };\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/**\n *  Update bounds from geoarrow sample data\n *\n * @param flatCoords the flattend coordinates array from one chunk of geoarrow column\n * @param nDim the number of dimensions of the coordinates\n * @param bounds the bounds to be updated\n * @param sampleSize how many samples to be used to update the bounds, default is 1000 per chunk\n * @returns the updated bounds\n */\nexport function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds, sampleSize = 100) {\n    const numberOfFeatures = flatCoords.length / nDim;\n    const sampleStep = Math.max(Math.floor(numberOfFeatures / sampleSize), 1);\n    const newBounds = [...bounds];\n    for (let i = 0; i < numberOfFeatures; i += sampleStep) {\n        const lng = flatCoords[i * nDim];\n        const lat = flatCoords[i * nDim + 1];\n        if (lng < newBounds[0]) {\n            newBounds[0] = lng;\n        }\n        if (lat < newBounds[1]) {\n            newBounds[1] = lat;\n        }\n        if (lng > newBounds[2]) {\n            newBounds[2] = lng;\n        }\n        if (lat > newBounds[3]) {\n            newBounds[3] = lat;\n        }\n    }\n    return newBounds;\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { binaryToGeometry } from '@loaders.gl/gis';\nimport { WKBLoader, WKTLoader } from '@loaders.gl/wkt';\n/**\n * parse geometry from arrow data that is returned from processArrowData()\n * NOTE: this function could be deduplicated with the binaryToFeature() in deck.gl,\n * it is currently used for deck.gl picking because currently deck.gl returns only the index of the feature\n *\n * @param data data extraced from arrow vector representing a geometry\n * @param encoding the geoarrow encoding of the geometry column\n * @returns Feature or null\n */\nexport function parseGeometryFromArrow(arrowCellValue, encoding) {\n    // sanity\n    encoding = encoding?.toLowerCase();\n    if (!encoding || !arrowCellValue) {\n        return null;\n    }\n    let geometry;\n    switch (encoding) {\n        case 'geoarrow.multipolygon':\n            geometry = arrowMultiPolygonToFeature(arrowCellValue);\n            break;\n        case 'geoarrow.polygon':\n            geometry = arrowPolygonToFeature(arrowCellValue);\n            break;\n        case 'geoarrow.multipoint':\n            geometry = arrowMultiPointToFeature(arrowCellValue);\n            break;\n        case 'geoarrow.point':\n            geometry = arrowPointToFeature(arrowCellValue);\n            break;\n        case 'geoarrow.multilinestring':\n            geometry = arrowMultiLineStringToFeature(arrowCellValue);\n            break;\n        case 'geoarrow.linestring':\n            geometry = arrowLineStringToFeature(arrowCellValue);\n            break;\n        case 'geoarrow.wkb':\n            geometry = arrowWKBToFeature(arrowCellValue);\n            break;\n        case 'geoarrow.wkt':\n            geometry = arrowWKTToFeature(arrowCellValue);\n            break;\n        default: {\n            throw Error(`GeoArrow encoding not supported ${encoding}`);\n        }\n    }\n    return geometry;\n}\nfunction arrowWKBToFeature(arrowCellValue) {\n    // The actual WKB array buffer starts from byteOffset and ends at byteOffset + byteLength\n    const arrayBuffer = arrowCellValue.buffer.slice(arrowCellValue.byteOffset, arrowCellValue.byteOffset + arrowCellValue.byteLength);\n    const binaryGeometry = WKBLoader.parseSync?.(arrayBuffer);\n    const geometry = binaryToGeometry(binaryGeometry);\n    return geometry;\n}\nfunction arrowWKTToFeature(arrowCellValue) {\n    const string = arrowCellValue;\n    return WKTLoader.parseTextSync?.(string);\n}\n/**\n * convert Arrow MultiPolygon to geojson Feature\n */\nfunction arrowMultiPolygonToFeature(arrowMultiPolygon) {\n    const multiPolygon = [];\n    for (let m = 0; m < arrowMultiPolygon.length; m++) {\n        const arrowPolygon = arrowMultiPolygon.get(m);\n        const polygon = [];\n        for (let i = 0; arrowPolygon && i < arrowPolygon?.length; i++) {\n            const arrowRing = arrowPolygon?.get(i);\n            const ring = [];\n            for (let j = 0; arrowRing && j < arrowRing.length; j++) {\n                const arrowCoord = arrowRing.get(j);\n                const coord = Array.from(arrowCoord);\n                ring.push(coord);\n            }\n            polygon.push(ring);\n        }\n        multiPolygon.push(polygon);\n    }\n    const geometry = {\n        type: 'MultiPolygon',\n        coordinates: multiPolygon\n    };\n    return geometry;\n}\n/**\n * convert Arrow Polygon to geojson Feature\n */\nfunction arrowPolygonToFeature(arrowPolygon) {\n    const polygon = [];\n    for (let i = 0; arrowPolygon && i < arrowPolygon.length; i++) {\n        const arrowRing = arrowPolygon.get(i);\n        const ring = [];\n        for (let j = 0; arrowRing && j < arrowRing.length; j++) {\n            const arrowCoord = arrowRing.get(j);\n            const coords = Array.from(arrowCoord);\n            ring.push(coords);\n        }\n        polygon.push(ring);\n    }\n    const geometry = {\n        type: 'Polygon',\n        coordinates: polygon\n    };\n    return geometry;\n}\n/**\n * convert Arrow MultiPoint to geojson MultiPoint\n */\nfunction arrowMultiPointToFeature(arrowMultiPoint) {\n    const multiPoint = [];\n    for (let i = 0; arrowMultiPoint && i < arrowMultiPoint.length; i++) {\n        const arrowPoint = arrowMultiPoint.get(i);\n        if (arrowPoint) {\n            const coord = Array.from(arrowPoint);\n            multiPoint.push(coord);\n        }\n    }\n    return {\n        type: 'MultiPoint',\n        coordinates: multiPoint\n    };\n}\n/**\n * convert Arrow Point to geojson Point\n */\nfunction arrowPointToFeature(arrowPoint) {\n    const point = Array.from(arrowPoint);\n    return {\n        type: 'Point',\n        coordinates: point\n    };\n}\n/**\n * convert Arrow MultiLineString to geojson MultiLineString\n */\nfunction arrowMultiLineStringToFeature(arrowMultiLineString) {\n    const multiLineString = [];\n    for (let i = 0; arrowMultiLineString && i < arrowMultiLineString.length; i++) {\n        const arrowLineString = arrowMultiLineString.get(i);\n        const lineString = [];\n        for (let j = 0; arrowLineString && j < arrowLineString.length; j++) {\n            const arrowCoord = arrowLineString.get(j);\n            if (arrowCoord) {\n                const coords = Array.from(arrowCoord);\n                lineString.push(coords);\n            }\n        }\n        multiLineString.push(lineString);\n    }\n    return {\n        type: 'MultiLineString',\n        coordinates: multiLineString\n    };\n}\n/**\n * convert Arrow LineString to geojson LineString\n */\nfunction arrowLineStringToFeature(arrowLineString) {\n    const lineString = [];\n    for (let i = 0; arrowLineString && i < arrowLineString.length; i++) {\n        const arrowCoord = arrowLineString.get(i);\n        if (arrowCoord) {\n            const coords = Array.from(arrowCoord);\n            lineString.push(coords);\n        }\n    }\n    return {\n        type: 'LineString',\n        coordinates: lineString\n    };\n}\n", "import * as arrow from 'apache-arrow';\nexport function hardClone(data, force = false) {\n    // Check if `data` is an arrow.Vector\n    if ('data' in data) {\n        return new arrow.Vector(data.data.map((data) => hardClone(data, force)));\n    }\n    // Clone each of the children, recursively\n    const clonedChildren = [];\n    for (const childData of data.children) {\n        clonedChildren.push(hardClone(childData, force));\n    }\n    // Clone the dictionary if there is one\n    let clonedDictionary;\n    if (data.dictionary !== undefined) {\n        clonedDictionary = hardClone(data.dictionary, force);\n    }\n    // Buffers can have up to four entries. Each of these can be `undefined` for\n    // one or more array types.\n    //\n    // - OFFSET: value offsets for variable size list types\n    // - DATA: the underlying data\n    // - VALIDITY: the null buffer. This may be empty or undefined if all elements\n    //   are non-null/valid.\n    // - TYPE: type ids for a union type.\n    const clonedBuffers = {\n        [arrow.BufferType.OFFSET]: cloneBuffer(data.buffers[arrow.BufferType.OFFSET], force),\n        [arrow.BufferType.DATA]: cloneBuffer(data.buffers[arrow.BufferType.DATA], force),\n        [arrow.BufferType.VALIDITY]: cloneBuffer(data.buffers[arrow.BufferType.VALIDITY], force),\n        [arrow.BufferType.TYPE]: cloneBuffer(data.buffers[arrow.BufferType.TYPE], force)\n    };\n    // Note: the data.offset is passed on so that a sliced Data instance will not\n    // be \"un-sliced\". However keep in mind that this means we're cloning the\n    // _original backing buffer_, not only the portion of the Data that was\n    // sliced.\n    return new arrow.Data(data.type, data.offset, data.length, \n    // @ts-expect-error _nullCount is protected. We're using it here to mimic\n    // `Data.clone`\n    data._nullCount, clonedBuffers, clonedChildren, clonedDictionary);\n}\n/**\n * Test whether an arrow.Data instance is a slice of a larger `ArrayBuffer`.\n */\nexport function isShared(data) {\n    // Loop over arrow.Vector\n    if ('data' in data) {\n        return data.data.some((data) => isShared(data));\n    }\n    // Check child data\n    for (const childData of data.children) {\n        if (isShared(childData)) {\n            return true;\n        }\n    }\n    // Check dictionary\n    if (data.dictionary !== undefined) {\n        if (isShared(data.dictionary)) {\n            return true;\n        }\n    }\n    const bufferTypes = [\n        arrow.BufferType.OFFSET,\n        arrow.BufferType.DATA,\n        arrow.BufferType.VALIDITY,\n        arrow.BufferType.TYPE\n    ];\n    for (const bufferType of bufferTypes) {\n        if (data.buffers[bufferType] !== undefined && isTypedArraySliced(data.buffers[bufferType])) {\n            return true;\n        }\n    }\n    return false;\n}\n/**\n * Returns true if the current typed array is a partial slice on a larger\n * ArrayBuffer\n */\nfunction isTypedArraySliced(arr) {\n    return !(arr.byteOffset === 0 && arr.byteLength === arr.buffer.byteLength);\n}\n/**\n * If a slice of a larger ArrayBuffer, clone to a fresh `ArrayBuffer`.\n *\n * If `force` is `true`, always clone the array, even if not shared.\n */\nfunction cloneBuffer(arr, force) {\n    // Not all buffer types are defined for every type of Arrow array. E.g.\n    // `arrow.BufferType.TYPE` is only defined for the Union type.\n    if (arr === undefined) {\n        return arr;\n    }\n    // The current array is not a part of a larger ArrayBuffer, don't clone it\n    if (!force && !isTypedArraySliced(arr)) {\n        return arr;\n    }\n    // Note: TypedArray.slice() **copies** into a new ArrayBuffer\n    // @ts-expect-error 'Uint8Array' is assignable to the constraint of type 'A',\n    // but 'A' could be instantiated with a different subtype of constraint\n    // 'TypedArray'\n    // We know from arr.slice that it will always return the same\n    return arr.slice();\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { processOnWorker } from '@loaders.gl/worker-utils';\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof \"4.2.0-alpha.5\" !== 'undefined' ? \"4.2.0-alpha.5\" : 'latest';\n/**\n * Worker for tessellating geometries. Normally called through triangulateOnWorker\n */\nexport const TriangulationWorker = {\n    id: 'triangulation',\n    name: 'Triangulate',\n    module: 'arrow',\n    version: VERSION,\n    options: {}\n};\n/**\n * Triangulate a set of polygons on worker, type safe API\n */\nexport function triangulateOnWorker(data, options = {}) {\n    return processOnWorker(TriangulationWorker, { ...data, operation: 'triangulate' }, options);\n}\n/**\n * Parse GeoArrow geometry colum on worker, type safe API\n */\nexport function parseGeoArrowOnWorker(data, options = {}) {\n    return processOnWorker(TriangulationWorker, { ...data, operation: 'parse-geoarrow' }, options);\n}\n"],
+  "mappings": "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",
+  "names": ["parseGeometryFromArrow", "import_schema", "arrow", "VECTOR_TYPES", "import_schema", "arrow", "arrow", "arrow", "_a", "arrow", "VERSION", "BinaryGeometryType", "import_gis", "parseGeometryFromArrow", "arrow", "data", "VERSION"]
+}

package/dist/index.d.ts

@@ -1,19 +1,19 @@
-import type { ArrowLoaderOptions } from './arrow-loader';
-export { getArrowType } from './schema/arrow-type-utils';
-export type { ArrowTable, ArrowTableBatch } from './lib/arrow-table';
-export { VECTOR_TYPES } from './types';
+import type { ArrowLoaderOptions } from "./arrow-loader.js";
+export { getArrowType } from "./schema/arrow-type-utils.js";
+export type { ArrowTable, ArrowTableBatch } from "./lib/arrow-table.js";
+export { VECTOR_TYPES } from "./types.js";
 export type { ArrowLoaderOptions };
-export { ArrowLoader, ArrowWorkerLoader } from './arrow-loader';
-export { ArrowWriter } from './arrow-writer';
-export { GeoArrowLoader, GeoArrowWorkerLoader } from './geoarrow-loader';
-export { serializeArrowSchema, deserializeArrowSchema, serializeArrowMetadata, deserializeArrowMetadata, serializeArrowField, deserializeArrowField, serializeArrowType, deserializeArrowType } from './schema/convert-arrow-schema';
+export { ArrowLoader, ArrowWorkerLoader } from "./arrow-loader.js";
+export { ArrowWriter } from "./arrow-writer.js";
+export { GeoArrowLoader, GeoArrowWorkerLoader } from "./geoarrow-loader.js";
+export { serializeArrowSchema, deserializeArrowSchema, serializeArrowMetadata, deserializeArrowMetadata, serializeArrowField, deserializeArrowField, serializeArrowType, deserializeArrowType } from "./schema/convert-arrow-schema.js";
 export type { GeoArrowEncoding } from '@loaders.gl/gis';
-export type { BinaryDataFromGeoArrow, BinaryGeometriesFromArrowOptions } from './geoarrow/convert-geoarrow-to-binary-geometry';
-export { getBinaryGeometryTemplate, getBinaryGeometriesFromArrow, getTriangleIndices, getMeanCentersFromBinaryGeometries } from './geoarrow/convert-geoarrow-to-binary-geometry';
-export { updateBoundsFromGeoArrowSamples } from './geoarrow/get-arrow-bounds';
-export { parseGeometryFromArrow } from './geoarrow/convert-geoarrow-to-geojson-geometry';
-export { convertArrowToGeoJSONTable } from './tables/convert-arrow-to-geojson-table';
-export { hardClone } from './workers/hard-clone';
-export type { ParseGeoArrowInput, ParseGeoArrowResult } from './triangulate-on-worker';
-export { TriangulationWorker, triangulateOnWorker, parseGeoArrowOnWorker } from './triangulate-on-worker';
+export type { BinaryDataFromGeoArrow, BinaryGeometriesFromArrowOptions } from "./geoarrow/convert-geoarrow-to-binary-geometry.js";
+export { getBinaryGeometryTemplate, getBinaryGeometriesFromArrow, getTriangleIndices, getMeanCentersFromBinaryGeometries } from "./geoarrow/convert-geoarrow-to-binary-geometry.js";
+export { updateBoundsFromGeoArrowSamples } from "./geoarrow/get-arrow-bounds.js";
+export { parseGeometryFromArrow } from "./geoarrow/convert-geoarrow-to-geojson-geometry.js";
+export { convertArrowToGeoJSONTable } from "./tables/convert-arrow-to-geojson-table.js";
+export { hardClone } from "./workers/hard-clone.js";
+export type { ParseGeoArrowInput, ParseGeoArrowResult } from "./triangulate-on-worker.js";
+export { TriangulationWorker, triangulateOnWorker, parseGeoArrowOnWorker } from "./triangulate-on-worker.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,gBAAgB,CAAC;AASvD,OAAO,EAAC,YAAY,EAAC,MAAM,2BAA2B,CAAC;AAKvD,YAAY,EAAC,UAAU,EAAE,eAAe,EAAC,MAAM,mBAAmB,CAAC;AACnE,OAAO,EAAC,YAAY,EAAC,MAAM,SAAS,CAAC;AAIrC,YAAY,EAAC,kBAAkB,EAAC,CAAC;AACjC,OAAO,EAAC,WAAW,EAAE,iBAAiB,EAAC,MAAM,gBAAgB,CAAC;AAE9D,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAG3C,OAAO,EAAC,cAAc,EAAE,oBAAoB,EAAC,MAAM,mBAAmB,CAAC;AAGvE,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,EACxB,mBAAmB,EACnB,qBAAqB,EACrB,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,+BAA+B,CAAC;AAKvC,YAAY,EAAC,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AAItD,YAAY,EACV,sBAAsB,EACtB,gCAAgC,EACjC,MAAM,gDAAgD,CAAC;AACxD,OAAO,EACL,yBAAyB,EACzB,4BAA4B,EAC5B,kBAAkB,EAClB,kCAAkC,EACnC,MAAM,gDAAgD,CAAC;AAExD,OAAO,EAAC,+BAA+B,EAAC,MAAM,6BAA6B,CAAC;AAE5E,OAAO,EAAC,sBAAsB,EAAC,MAAM,iDAAiD,CAAC;AAEvF,OAAO,EAAC,0BAA0B,EAAC,MAAM,yCAAyC,CAAC;AAGnF,OAAO,EAAC,SAAS,EAAC,MAAM,sBAAsB,CAAC;AAE/C,YAAY,EAAC,kBAAkB,EAAE,mBAAmB,EAAC,MAAM,yBAAyB,CAAC;AACrF,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,kBAAkB,EAAC,0BAAuB;AASvD,OAAO,EAAC,YAAY,EAAC,qCAAkC;AAKvD,YAAY,EAAC,UAAU,EAAE,eAAe,EAAC,6BAA0B;AACnE,OAAO,EAAC,YAAY,EAAC,mBAAgB;AAIrC,YAAY,EAAC,kBAAkB,EAAC,CAAC;AACjC,OAAO,EAAC,WAAW,EAAE,iBAAiB,EAAC,0BAAuB;AAE9D,OAAO,EAAC,WAAW,EAAC,0BAAuB;AAG3C,OAAO,EAAC,cAAc,EAAE,oBAAoB,EAAC,6BAA0B;AAGvE,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,EACxB,mBAAmB,EACnB,qBAAqB,EACrB,kBAAkB,EAClB,oBAAoB,EACrB,yCAAsC;AAKvC,YAAY,EAAC,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AAItD,YAAY,EACV,sBAAsB,EACtB,gCAAgC,EACjC,0DAAuD;AACxD,OAAO,EACL,yBAAyB,EACzB,4BAA4B,EAC5B,kBAAkB,EAClB,kCAAkC,EACnC,0DAAuD;AAExD,OAAO,EAAC,+BAA+B,EAAC,uCAAoC;AAE5E,OAAO,EAAC,sBAAsB,EAAC,2DAAwD;AAEvF,OAAO,EAAC,0BAA0B,EAAC,mDAAgD;AAGnF,OAAO,EAAC,SAAS,EAAC,gCAA6B;AAE/C,YAAY,EAAC,kBAAkB,EAAE,mBAAmB,EAAC,mCAAgC;AACrF,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,EACtB,mCAAgC"}

package/dist/index.js

@@ -1,16 +1,23 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { TableBatchBuilder } from '@loaders.gl/schema';
 import { ArrowTableBatchAggregator } from "./lib/arrow-table-batch.js";
+// Make the ArrowBatch type available
 TableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;
+// TYPES
 export { getArrowType } from "./schema/arrow-type-utils.js";
 export { VECTOR_TYPES } from "./types.js";
 export { ArrowLoader, ArrowWorkerLoader } from "./arrow-loader.js";
 export { ArrowWriter } from "./arrow-writer.js";
+// Geoarrow loader
 export { GeoArrowLoader, GeoArrowWorkerLoader } from "./geoarrow-loader.js";
+// Schema utils
 export { serializeArrowSchema, deserializeArrowSchema, serializeArrowMetadata, deserializeArrowMetadata, serializeArrowField, deserializeArrowField, serializeArrowType, deserializeArrowType } from "./schema/convert-arrow-schema.js";
 export { getBinaryGeometryTemplate, getBinaryGeometriesFromArrow, getTriangleIndices, getMeanCentersFromBinaryGeometries } from "./geoarrow/convert-geoarrow-to-binary-geometry.js";
 export { updateBoundsFromGeoArrowSamples } from "./geoarrow/get-arrow-bounds.js";
 export { parseGeometryFromArrow } from "./geoarrow/convert-geoarrow-to-geojson-geometry.js";
 export { convertArrowToGeoJSONTable } from "./tables/convert-arrow-to-geojson-table.js";
+// EXPERIMENTAL WORKER
 export { hardClone } from "./workers/hard-clone.js";
 export { TriangulationWorker, triangulateOnWorker, parseGeoArrowOnWorker } from "./triangulate-on-worker.js";
-//# sourceMappingURL=index.js.map

package/dist/lib/arrow-table-batch.d.ts

@@ -1,5 +1,5 @@
 import { ColumnarTableBatchAggregator } from '@loaders.gl/schema';
-import type { ArrowTableBatch } from './arrow-table';
+import type { ArrowTableBatch } from "./arrow-table.js";
 import * as arrow from 'apache-arrow';
 export declare class ArrowTableBatchAggregator extends ColumnarTableBatchAggregator {
     arrowSchema: arrow.Schema | null;

package/dist/lib/arrow-table-batch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arrow-table-batch.d.ts","sourceRoot":"","sources":["../../src/lib/arrow-table-batch.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,4BAA4B,EAAC,MAAM,oBAAoB,CAAC;AAChE,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,qBAAa,yBAA0B,SAAQ,4BAA4B;IACzE,WAAW,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;gBAErB,MAAM,KAAA,EAAE,OAAO,KAAA;IAK3B,QAAQ,IAAI,eAAe,GAAG,IAAI;CA4BnC"}
+{"version":3,"file":"arrow-table-batch.d.ts","sourceRoot":"","sources":["../../src/lib/arrow-table-batch.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,4BAA4B,EAAC,MAAM,oBAAoB,CAAC;AAChE,OAAO,KAAK,EAAC,eAAe,EAAC,yBAAsB;AACnD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,qBAAa,yBAA0B,SAAQ,4BAA4B;IACzE,WAAW,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;gBAErB,MAAM,KAAA,EAAE,OAAO,KAAA;IAK3B,QAAQ,IAAI,eAAe,GAAG,IAAI;CA4BnC"}