@loaders.gl/arrow 4.0.3 → 4.1.0-alpha.1

package/dist/index.cjs

@@ -30,120 +30,38 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  ArrowLoader: () => ArrowLoader2,
-  ArrowWorkerLoader: () => ArrowLoader,
+  ArrowLoader: () => ArrowLoader,
+  ArrowWorkerLoader: () => ArrowWorkerLoader,
   ArrowWriter: () => ArrowWriter,
   BINARY_GEOMETRY_TEMPLATE: () => BINARY_GEOMETRY_TEMPLATE,
+  GeoArrowLoader: () => GeoArrowLoader,
+  GeoArrowWorkerLoader: () => GeoArrowWorkerLoader,
+  TriangulationWorker: () => TriangulationWorker,
   VECTOR_TYPES: () => VECTOR_TYPES,
+  convertArrowToGeoJSONTable: () => convertArrowToGeoJSONTable,
   deserializeArrowField: () => deserializeArrowField,
   deserializeArrowMetadata: () => deserializeArrowMetadata,
   deserializeArrowSchema: () => deserializeArrowSchema,
   deserializeArrowType: () => deserializeArrowType,
   getArrowType: () => getArrowType,
   getBinaryGeometriesFromArrow: () => getBinaryGeometriesFromArrow,
-  parseGeometryFromArrow: () => parseGeometryFromArrow,
+  getMeanCentersFromBinaryGeometries: () => getMeanCentersFromBinaryGeometries,
+  getTriangleIndices: () => getTriangleIndices,
+  parseGeometryFromArrow: () => parseGeometryFromArrow2,
   serializeArrowField: () => serializeArrowField,
   serializeArrowMetadata: () => serializeArrowMetadata,
   serializeArrowSchema: () => serializeArrowSchema,
   serializeArrowType: () => serializeArrowType,
+  triangulateOnWorker: () => triangulateOnWorker,
   updateBoundsFromGeoArrowSamples: () => updateBoundsFromGeoArrowSamples
 });
 module.exports = __toCommonJS(src_exports);
 var import_schema3 = require("@loaders.gl/schema");
 
-// src/arrow-loader.ts
-var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-var ArrowLoader = {
-  name: "Apache Arrow",
-  id: "arrow",
-  module: "arrow",
-  version: VERSION,
-  // worker: true,
-  category: "table",
-  extensions: ["arrow", "feather"],
-  mimeTypes: [
-    "application/vnd.apache.arrow.file",
-    "application/vnd.apache.arrow.stream",
-    "application/octet-stream"
-  ],
-  binary: true,
-  tests: ["ARROW"],
-  options: {
-    arrow: {
-      shape: "columnar-table"
-    }
-  }
-};
-
-// src/lib/parse-arrow-sync.ts
+// src/lib/arrow-table-batch.ts
 var import_schema = require("@loaders.gl/schema");
 var arrow = __toESM(require("apache-arrow"), 1);
-
-// src/tables/convert-arrow-to-table.ts
-function convertApacheArrowToArrowTable(arrowTable) {
-  return {
-    shape: "arrow-table",
-    data: arrowTable
-  };
-}
-function convertArrowToColumnarTable(table) {
-  const arrowTable = table.data;
-  const columnarTable = {};
-  for (const field of arrowTable.schema.fields) {
-    const arrowColumn = arrowTable.getChild(field.name);
-    const values = arrowColumn == null ? void 0 : arrowColumn.toArray();
-    columnarTable[field.name] = values;
-  }
-  return {
-    shape: "columnar-table",
-    data: columnarTable
-  };
-}
-
-// src/lib/parse-arrow-sync.ts
-function parseArrowSync(arrayBuffer, options) {
-  var _a;
-  const apacheArrowTable = arrow.tableFromIPC([new Uint8Array(arrayBuffer)]);
-  const arrowTable = convertApacheArrowToArrowTable(apacheArrowTable);
-  const shape = ((_a = options == null ? void 0 : options.arrow) == null ? void 0 : _a.shape) || "arrow-table";
-  switch (shape) {
-    case "arrow-table":
-      return arrowTable;
-    case "columnar-table":
-      return convertArrowToColumnarTable(arrowTable);
-    case "object-row-table":
-      const columnarTable = convertArrowToColumnarTable(arrowTable);
-      return (0, import_schema.convertTable)(columnarTable, "object-row-table");
-    default:
-      throw new Error(shape);
-  }
-}
-
-// src/lib/parse-arrow-in-batches.ts
-var arrow2 = __toESM(require("apache-arrow"), 1);
-function parseArrowInBatches(asyncIterator) {
-  async function* makeArrowAsyncIterator() {
-    const readers = arrow2.RecordBatchReader.readAll(asyncIterator);
-    for await (const reader of readers) {
-      for await (const recordBatch of reader) {
-        const arrowTabledBatch = {
-          shape: "arrow-table",
-          batchType: "data",
-          data: new arrow2.Table([recordBatch]),
-          length: recordBatch.data.length
-        };
-        yield arrowTabledBatch;
-      }
-      break;
-    }
-  }
-  return makeArrowAsyncIterator();
-}
-
-// src/lib/arrow-table-batch.ts
-var import_schema2 = require("@loaders.gl/schema");
-var arrow3 = __toESM(require("apache-arrow"), 1);
-var ArrowTableBatchAggregator = class extends import_schema2.ColumnarTableBatchAggregator {
+var ArrowTableBatchAggregator = class extends import_schema.ColumnarTableBatchAggregator {
   constructor(schema, options) {
     super(schema, options);
     this.arrowSchema = null;
@@ -153,17 +71,17 @@ var ArrowTableBatchAggregator = class extends import_schema2.ColumnarTableBatchA
     if (batch) {
       this.arrowSchema = this.arrowSchema || getArrowSchema(batch.schema);
       const arrowVectors = getArrowVectors(this.arrowSchema, batch.data);
-      const recordBatch = new arrow3.RecordBatch(
+      const recordBatch = new arrow.RecordBatch(
         this.arrowSchema,
-        arrow3.makeData({
-          type: new arrow3.Struct(this.arrowSchema.fields),
+        arrow.makeData({
+          type: new arrow.Struct(this.arrowSchema.fields),
           children: arrowVectors.map(({ data }) => data[0])
         })
       );
       return {
         shape: "arrow-table",
         batchType: "data",
-        data: new arrow3.Table([recordBatch]),
+        data: new arrow.Table([recordBatch]),
         length: batch.length
       };
     }
@@ -176,21 +94,21 @@ function getArrowSchema(schema) {
     const field = schema[key];
     if (field.type === Float32Array) {
       const metadata = /* @__PURE__ */ new Map();
-      const arrowField = new arrow3.Field(field.name, new arrow3.Float32(), field.nullable, metadata);
+      const arrowField = new arrow.Field(field.name, new arrow.Float32(), field.nullable, metadata);
       arrowFields.push(arrowField);
     }
   }
   if (arrowFields.length === 0) {
     throw new Error("No arrow convertible fields");
   }
-  return new arrow3.Schema(arrowFields);
+  return new arrow.Schema(arrowFields);
 }
 function getArrowVectors(arrowSchema, data) {
   const arrowVectors = [];
   for (const field of arrowSchema.fields) {
     const vector = data[field.name];
     if (vector instanceof Float32Array) {
-      const arrowVector = arrow3.makeVector(vector);
+      const arrowVector = arrow.makeVector(vector);
       arrowVectors.push(arrowVector);
     }
   }
@@ -201,32 +119,59 @@ function getArrowVectors(arrowSchema, data) {
 }
 
 // src/schema/arrow-type-utils.ts
-var arrow4 = __toESM(require("apache-arrow"), 1);
+var arrow2 = __toESM(require("apache-arrow"), 1);
 function getArrowType(array) {
   switch (array.constructor) {
     case Int8Array:
-      return new arrow4.Int8();
+      return new arrow2.Int8();
     case Uint8Array:
-      return new arrow4.Uint8();
+      return new arrow2.Uint8();
     case Int16Array:
-      return new arrow4.Int16();
+      return new arrow2.Int16();
     case Uint16Array:
-      return new arrow4.Uint16();
+      return new arrow2.Uint16();
     case Int32Array:
-      return new arrow4.Int32();
+      return new arrow2.Int32();
     case Uint32Array:
-      return new arrow4.Uint32();
+      return new arrow2.Uint32();
     case Float32Array:
-      return new arrow4.Float32();
+      return new arrow2.Float32();
     case Float64Array:
-      return new arrow4.Float64();
+      return new arrow2.Float64();
     default:
       throw new Error("array type not supported");
   }
 }
 
+// src/types.ts
+var VECTOR_TYPES = /* @__PURE__ */ ((VECTOR_TYPES2) => {
+  VECTOR_TYPES2[VECTOR_TYPES2["FLOAT"] = 0] = "FLOAT";
+  VECTOR_TYPES2[VECTOR_TYPES2["DATE"] = 1] = "DATE";
+  return VECTOR_TYPES2;
+})(VECTOR_TYPES || {});
+
+// src/parsers/parse-arrow-sync.ts
+var import_schema2 = require("@loaders.gl/schema");
+var arrow4 = __toESM(require("apache-arrow"), 1);
+
+// src/tables/convert-arrow-to-columnar-table.ts
+function convertArrowToColumnarTable(table) {
+  const arrowTable = table.data;
+  const columnarTable = {};
+  for (const field of arrowTable.schema.fields) {
+    const arrowColumn = arrowTable.getChild(field.name);
+    const values = arrowColumn == null ? void 0 : arrowColumn.toArray();
+    columnarTable[field.name] = values;
+  }
+  return {
+    shape: "columnar-table",
+    schema: table.schema,
+    data: columnarTable
+  };
+}
+
 // src/schema/convert-arrow-schema.ts
-var arrow5 = __toESM(require("apache-arrow"), 1);
+var arrow3 = __toESM(require("apache-arrow"), 1);
 function serializeArrowSchema(arrowSchema) {
   return {
     fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
@@ -234,7 +179,7 @@ function serializeArrowSchema(arrowSchema) {
   };
 }
 function deserializeArrowSchema(schema) {
-  return new arrow5.Schema(
+  return new arrow3.Schema(
     schema.fields.map((field) => deserializeArrowField(field)),
     deserializeArrowMetadata(schema.metadata)
   );
@@ -254,7 +199,7 @@ function serializeArrowField(field) {
   };
 }
 function deserializeArrowField(field) {
-  return new arrow5.Field(
+  return new arrow3.Field(
     field.name,
     deserializeArrowType(field.type),
     field.nullable,
@@ -263,52 +208,52 @@ function deserializeArrowField(field) {
 }
 function serializeArrowType(arrowType) {
   switch (arrowType.constructor) {
-    case arrow5.Null:
+    case arrow3.Null:
       return "null";
-    case arrow5.Binary:
+    case arrow3.Binary:
       return "binary";
-    case arrow5.Bool:
+    case arrow3.Bool:
       return "bool";
-    case arrow5.Int:
+    case arrow3.Int:
       const intType = arrowType;
       return `${intType.isSigned ? "u" : ""}int${intType.bitWidth}`;
-    case arrow5.Int8:
+    case arrow3.Int8:
       return "int8";
-    case arrow5.Int16:
+    case arrow3.Int16:
       return "int16";
-    case arrow5.Int32:
+    case arrow3.Int32:
       return "int32";
-    case arrow5.Int64:
+    case arrow3.Int64:
       return "int64";
-    case arrow5.Uint8:
+    case arrow3.Uint8:
       return "uint8";
-    case arrow5.Uint16:
+    case arrow3.Uint16:
       return "uint16";
-    case arrow5.Uint32:
+    case arrow3.Uint32:
       return "uint32";
-    case arrow5.Uint64:
+    case arrow3.Uint64:
       return "uint64";
-    case arrow5.Float:
+    case arrow3.Float:
       const precision = arrowType.precision;
       switch (precision) {
-        case arrow5.Precision.HALF:
+        case arrow3.Precision.HALF:
           return "float16";
-        case arrow5.Precision.SINGLE:
+        case arrow3.Precision.SINGLE:
           return "float32";
-        case arrow5.Precision.DOUBLE:
+        case arrow3.Precision.DOUBLE:
           return "float64";
         default:
           return "float16";
       }
-    case arrow5.Float16:
+    case arrow3.Float16:
       return "float16";
-    case arrow5.Float32:
+    case arrow3.Float32:
       return "float32";
-    case arrow5.Float64:
+    case arrow3.Float64:
       return "float64";
-    case arrow5.Utf8:
+    case arrow3.Utf8:
       return "utf8";
-    case arrow5.Decimal:
+    case arrow3.Decimal:
       const decimal = arrowType;
       return {
         type: "decimal",
@@ -316,93 +261,93 @@ function serializeArrowType(arrowType) {
         precision: decimal.precision,
         scale: decimal.scale
       };
-    case arrow5.Date_:
+    case arrow3.Date_:
       const dateUnit = arrowType.unit;
-      return dateUnit === arrow5.DateUnit.DAY ? "date-day" : "date-millisecond";
-    case arrow5.DateDay:
+      return dateUnit === arrow3.DateUnit.DAY ? "date-day" : "date-millisecond";
+    case arrow3.DateDay:
       return "date-day";
-    case arrow5.DateMillisecond:
+    case arrow3.DateMillisecond:
       return "date-millisecond";
-    case arrow5.Time:
+    case arrow3.Time:
       const timeUnit = arrowType.unit;
       switch (timeUnit) {
-        case arrow5.TimeUnit.SECOND:
+        case arrow3.TimeUnit.SECOND:
           return "time-second";
-        case arrow5.TimeUnit.MILLISECOND:
+        case arrow3.TimeUnit.MILLISECOND:
           return "time-millisecond";
-        case arrow5.TimeUnit.MICROSECOND:
+        case arrow3.TimeUnit.MICROSECOND:
           return "time-microsecond";
-        case arrow5.TimeUnit.NANOSECOND:
+        case arrow3.TimeUnit.NANOSECOND:
           return "time-nanosecond";
         default:
           return "time-second";
       }
-    case arrow5.TimeMillisecond:
+    case arrow3.TimeMillisecond:
       return "time-millisecond";
-    case arrow5.TimeSecond:
+    case arrow3.TimeSecond:
       return "time-second";
-    case arrow5.TimeMicrosecond:
+    case arrow3.TimeMicrosecond:
       return "time-microsecond";
-    case arrow5.TimeNanosecond:
+    case arrow3.TimeNanosecond:
       return "time-nanosecond";
-    case arrow5.Timestamp:
+    case arrow3.Timestamp:
       const timeStampUnit = arrowType.unit;
       switch (timeStampUnit) {
-        case arrow5.TimeUnit.SECOND:
+        case arrow3.TimeUnit.SECOND:
           return "timestamp-second";
-        case arrow5.TimeUnit.MILLISECOND:
+        case arrow3.TimeUnit.MILLISECOND:
           return "timestamp-millisecond";
-        case arrow5.TimeUnit.MICROSECOND:
+        case arrow3.TimeUnit.MICROSECOND:
           return "timestamp-microsecond";
-        case arrow5.TimeUnit.NANOSECOND:
+        case arrow3.TimeUnit.NANOSECOND:
           return "timestamp-nanosecond";
         default:
           return "timestamp-second";
       }
-    case arrow5.TimestampSecond:
+    case arrow3.TimestampSecond:
       return "timestamp-second";
-    case arrow5.TimestampMillisecond:
+    case arrow3.TimestampMillisecond:
       return "timestamp-millisecond";
-    case arrow5.TimestampMicrosecond:
+    case arrow3.TimestampMicrosecond:
       return "timestamp-microsecond";
-    case arrow5.TimestampNanosecond:
+    case arrow3.TimestampNanosecond:
       return "timestamp-nanosecond";
-    case arrow5.Interval:
+    case arrow3.Interval:
       const intervalUnit = arrowType.unit;
       switch (intervalUnit) {
-        case arrow5.IntervalUnit.DAY_TIME:
+        case arrow3.IntervalUnit.DAY_TIME:
           return "interval-daytime";
-        case arrow5.IntervalUnit.YEAR_MONTH:
+        case arrow3.IntervalUnit.YEAR_MONTH:
           return "interval-yearmonth";
         default:
           return "interval-daytime";
       }
-    case arrow5.IntervalDayTime:
+    case arrow3.IntervalDayTime:
       return "interval-daytime";
-    case arrow5.IntervalYearMonth:
+    case arrow3.IntervalYearMonth:
       return "interval-yearmonth";
-    case arrow5.Map_:
+    case arrow3.Map_:
       const mapType = arrowType;
       return {
         type: "map",
         keysSorted: mapType.keysSorted,
         children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
       };
-    case arrow5.List:
+    case arrow3.List:
       const listType = arrowType;
       const listField = listType.valueField;
       return {
         type: "list",
         children: [serializeArrowField(listField)]
       };
-    case arrow5.FixedSizeList:
+    case arrow3.FixedSizeList:
       const fixedSizeList = arrowType;
       return {
         type: "fixed-size-list",
         listSize: fixedSizeList.listSize,
         children: [serializeArrowField(fixedSizeList.children[0])]
       };
-    case arrow5.Struct:
+    case arrow3.Struct:
       const structType = arrowType;
       return {
         type: "struct",
@@ -416,89 +361,158 @@ function deserializeArrowType(dataType) {
   if (typeof dataType === "object") {
     switch (dataType.type) {
       case "decimal":
-        return new arrow5.Decimal(dataType.precision, dataType.scale, dataType.bitWidth);
+        return new arrow3.Decimal(dataType.precision, dataType.scale, dataType.bitWidth);
       case "map":
         let children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
-        return new arrow5.Map_(children, dataType.keysSorted);
+        return new arrow3.Map_(children, dataType.keysSorted);
       case "list":
         const field = deserializeArrowField(dataType.children[0]);
-        return new arrow5.List(field);
+        return new arrow3.List(field);
       case "fixed-size-list":
         const child = deserializeArrowField(dataType.children[0]);
-        return new arrow5.FixedSizeList(dataType.listSize, child);
+        return new arrow3.FixedSizeList(dataType.listSize, child);
       case "struct":
         children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
-        return new arrow5.Struct(children);
+        return new arrow3.Struct(children);
       default:
         throw new Error("array type not supported");
     }
   }
   switch (dataType) {
     case "null":
-      return new arrow5.Null();
+      return new arrow3.Null();
     case "binary":
-      return new arrow5.Binary();
+      return new arrow3.Binary();
     case "bool":
-      return new arrow5.Bool();
+      return new arrow3.Bool();
     case "int8":
-      return new arrow5.Int8();
+      return new arrow3.Int8();
     case "int16":
-      return new arrow5.Int16();
+      return new arrow3.Int16();
     case "int32":
-      return new arrow5.Int32();
+      return new arrow3.Int32();
     case "int64":
-      return new arrow5.Int64();
+      return new arrow3.Int64();
     case "uint8":
-      return new arrow5.Uint8();
+      return new arrow3.Uint8();
     case "uint16":
-      return new arrow5.Uint16();
+      return new arrow3.Uint16();
     case "uint32":
-      return new arrow5.Uint32();
+      return new arrow3.Uint32();
     case "uint64":
-      return new arrow5.Uint64();
+      return new arrow3.Uint64();
     case "float16":
-      return new arrow5.Float16();
+      return new arrow3.Float16();
     case "float32":
-      return new arrow5.Float32();
+      return new arrow3.Float32();
     case "float64":
-      return new arrow5.Float64();
+      return new arrow3.Float64();
     case "utf8":
-      return new arrow5.Utf8();
+      return new arrow3.Utf8();
     case "date-day":
-      return new arrow5.DateDay();
+      return new arrow3.DateDay();
     case "date-millisecond":
-      return new arrow5.DateMillisecond();
+      return new arrow3.DateMillisecond();
     case "time-second":
-      return new arrow5.TimeSecond();
+      return new arrow3.TimeSecond();
     case "time-millisecond":
-      return new arrow5.TimeMillisecond();
+      return new arrow3.TimeMillisecond();
     case "time-microsecond":
-      return new arrow5.TimeMicrosecond();
+      return new arrow3.TimeMicrosecond();
     case "time-nanosecond":
-      return new arrow5.TimeNanosecond();
+      return new arrow3.TimeNanosecond();
     case "timestamp-second":
-      return new arrow5.TimestampSecond();
+      return new arrow3.TimestampSecond();
     case "timestamp-millisecond":
-      return new arrow5.TimestampMillisecond();
+      return new arrow3.TimestampMillisecond();
     case "timestamp-microsecond":
-      return new arrow5.TimestampMicrosecond();
+      return new arrow3.TimestampMicrosecond();
     case "timestamp-nanosecond":
-      return new arrow5.TimestampNanosecond();
+      return new arrow3.TimestampNanosecond();
     case "interval-daytime":
-      return new arrow5.IntervalDayTime();
+      return new arrow3.IntervalDayTime();
     case "interval-yearmonth":
-      return new arrow5.IntervalYearMonth();
+      return new arrow3.IntervalYearMonth();
     default:
       throw new Error("array type not supported");
   }
 }
 
-// src/types.ts
-var VECTOR_TYPES = /* @__PURE__ */ ((VECTOR_TYPES2) => {
-  VECTOR_TYPES2[VECTOR_TYPES2["FLOAT"] = 0] = "FLOAT";
-  VECTOR_TYPES2[VECTOR_TYPES2["DATE"] = 1] = "DATE";
-  return VECTOR_TYPES2;
-})(VECTOR_TYPES || {});
+// src/parsers/parse-arrow-sync.ts
+function parseArrowSync(arrayBuffer, options) {
+  const apacheArrowTable = arrow4.tableFromIPC([new Uint8Array(arrayBuffer)]);
+  const arrowTable = {
+    shape: "arrow-table",
+    schema: serializeArrowSchema(apacheArrowTable.schema),
+    data: apacheArrowTable
+  };
+  const shape = (options == null ? void 0 : options.shape) || "arrow-table";
+  switch (shape) {
+    case "arrow-table":
+      return arrowTable;
+    case "columnar-table":
+      return convertArrowToColumnarTable(arrowTable);
+    case "object-row-table":
+      let columnarTable = convertArrowToColumnarTable(arrowTable);
+      return (0, import_schema2.convertTable)(columnarTable, "object-row-table");
+    case "array-row-table":
+      columnarTable = convertArrowToColumnarTable(arrowTable);
+      return (0, import_schema2.convertTable)(columnarTable, "array-row-table");
+    default:
+      throw new Error(shape);
+  }
+}
+
+// src/parsers/parse-arrow-in-batches.ts
+var arrow5 = __toESM(require("apache-arrow"), 1);
+function parseArrowInBatches(asyncIterator) {
+  async function* makeArrowAsyncIterator() {
+    const readers = arrow5.RecordBatchReader.readAll(asyncIterator);
+    for await (const reader of readers) {
+      for await (const recordBatch of reader) {
+        const arrowTabledBatch = {
+          shape: "arrow-table",
+          batchType: "data",
+          data: new arrow5.Table([recordBatch]),
+          length: recordBatch.data.length
+        };
+        yield arrowTabledBatch;
+      }
+      break;
+    }
+  }
+  return makeArrowAsyncIterator();
+}
+
+// src/arrow-loader.ts
+var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var ArrowWorkerLoader = {
+  name: "Apache Arrow",
+  id: "arrow",
+  module: "arrow",
+  version: VERSION,
+  // worker: true,
+  category: "table",
+  extensions: ["arrow", "feather"],
+  mimeTypes: [
+    "application/vnd.apache.arrow.file",
+    "application/vnd.apache.arrow.stream",
+    "application/octet-stream"
+  ],
+  binary: true,
+  tests: ["ARROW"],
+  options: {
+    arrow: {
+      shape: "columnar-table"
+    }
+  }
+};
+var ArrowLoader = {
+  ...ArrowWorkerLoader,
+  parse: async (arraybuffer, options) => parseArrowSync(arraybuffer, options == null ? void 0 : options.arrow),
+  parseSync: (arraybuffer, options) => parseArrowSync(arraybuffer, options == null ? void 0 : options.arrow),
+  parseInBatches: parseArrowInBatches
+};
 
 // src/lib/encode-arrow.ts
 var arrow6 = __toESM(require("apache-arrow"), 1);
@@ -545,6 +559,75 @@ var ArrowWriter = {
   }
 };
 
+// src/tables/convert-arrow-to-geojson-table.ts
+var import_arrow = require("@loaders.gl/arrow");
+var import_gis = require("@loaders.gl/gis");
+function convertArrowToGeoJSONTable(table) {
+  var _a;
+  const arrowTable = table.data;
+  const schema = (0, import_arrow.serializeArrowSchema)(arrowTable.schema);
+  const geometryColumns = (0, import_gis.getGeometryColumnsFromSchema)(schema);
+  const encoding = geometryColumns.geometry.encoding;
+  const features = [];
+  const propertyColumnNames = arrowTable.schema.fields.map((field) => field.name).filter((name) => !(name in geometryColumns));
+  const propertiesTable = arrowTable.select(propertyColumnNames);
+  const arrowGeometryColumn = arrowTable.getChild("geometry");
+  for (let row = 0; row < arrowTable.numRows; row++) {
+    const arrowGeometry = arrowGeometryColumn == null ? void 0 : arrowGeometryColumn.get(row);
+    const feature = (0, import_arrow.parseGeometryFromArrow)(arrowGeometry, encoding);
+    if (feature) {
+      const properties = ((_a = propertiesTable.get(row)) == null ? void 0 : _a.toJSON()) || {};
+      features.push({ type: "Feature", geometry: feature, properties });
+    }
+  }
+  return {
+    shape: "geojson-table",
+    type: "FeatureCollection",
+    schema: table.schema,
+    features
+  };
+}
+
+// src/parsers/parse-geoarrow-sync.ts
+function parseGeoArrowSync(arrayBuffer, options) {
+  const table = parseArrowSync(arrayBuffer, { shape: "arrow-table" });
+  switch (options == null ? void 0 : options.shape) {
+    case "geojson-table":
+      return convertArrowToGeoJSONTable(table);
+    default:
+      return table;
+  }
+}
+
+// src/parsers/parse-geoarrow-in-batches.ts
+function parseGeoArrowInBatches(asyncIterator) {
+  return parseArrowInBatches(asyncIterator);
+}
+
+// src/geoarrow-loader.ts
+var GeoArrowWorkerLoader = {
+  ...ArrowWorkerLoader,
+  options: {
+    arrow: {
+      shape: "arrow-table"
+    }
+  }
+};
+var GeoArrowLoader = {
+  ...ArrowWorkerLoader,
+  options: {
+    arrow: {
+      shape: "arrow-table"
+    }
+  },
+  parse: async (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options == null ? void 0 : options.arrow),
+  parseSync: (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options == null ? void 0 : options.arrow),
+  parseInBatches: parseGeoArrowInBatches
+};
+
+// src/geoarrow/convert-geoarrow-to-binary-geometry.ts
+var import_polygon = require("@math.gl/polygon");
+
 // src/geoarrow/get-arrow-bounds.ts
 function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds, sampleSize = 100) {
   const numberOfFeatures = flatCoords.length / nDim;
@@ -577,21 +660,18 @@ var BINARY_GEOMETRY_TEMPLATE = {
   numericProps: {},
   featureIds: { value: new Uint32Array(0), size: 1 }
 };
-function getBinaryGeometriesFromArrow(geoColumn, geoEncoding) {
+function getBinaryGeometriesFromArrow(geoColumn, geoEncoding, options) {
   const featureTypes = {
     polygon: geoEncoding === "geoarrow.multipolygon" || geoEncoding === "geoarrow.polygon",
     point: geoEncoding === "geoarrow.multipoint" || geoEncoding === "geoarrow.point",
     line: geoEncoding === "geoarrow.multilinestring" || geoEncoding === "geoarrow.linestring"
   };
-  const chunks = geoColumn.data;
+  const chunks = (options == null ? void 0 : options.chunkIndex) ? [geoColumn.data[options == null ? void 0 : options.chunkIndex]] : geoColumn.data;
   let bounds = [Infinity, Infinity, -Infinity, -Infinity];
   let globalFeatureIdOffset = 0;
   const binaryGeometries = [];
   chunks.forEach((chunk) => {
-    const { featureIds, flatCoordinateArray, nDim, geomOffset } = getBinaryGeometriesFromChunk(
-      chunk,
-      geoEncoding
-    );
+    const { featureIds, flatCoordinateArray, nDim, geomOffset, triangles } = getBinaryGeometriesFromChunk(chunk, geoEncoding, options);
     const globalFeatureIds = new Uint32Array(featureIds.length);
     for (let i = 0; i < featureIds.length; i++) {
       globalFeatureIds[i] = featureIds[i] + globalFeatureIdOffset;
@@ -626,22 +706,87 @@ function getBinaryGeometriesFromArrow(geoColumn, geoEncoding) {
         ...BINARY_GEOMETRY_TEMPLATE,
         ...featureTypes.polygon ? binaryContent : {},
         polygonIndices: {
-          // TODO why deck.gl's tessellatePolygon performance is not good when using geometryIndicies
-          // even when there is no hole in any polygon
+          // use geomOffset as polygonIndices same as primitivePolygonIndices since we are using earcut to get triangule indices
           value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
           size: 1
         },
         primitivePolygonIndices: {
           value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
           size: 1
-        }
+        },
+        ...triangles ? { triangles: { value: triangles, size: 1 } } : {}
       }
     });
     bounds = updateBoundsFromGeoArrowSamples(flatCoordinateArray, nDim, bounds);
   });
-  return { binaryGeometries, bounds, featureTypes };
+  return {
+    binaryGeometries,
+    bounds,
+    featureTypes,
+    ...(options == null ? void 0 : options.calculateMeanCenters) ? { meanCenters: getMeanCentersFromBinaryGeometries(binaryGeometries) } : {}
+  };
+}
+function getMeanCentersFromBinaryGeometries(binaryGeometries) {
+  const globalMeanCenters = [];
+  binaryGeometries.forEach((binaryGeometry) => {
+    var _a;
+    let binaryGeometryType = null;
+    if (binaryGeometry.points && binaryGeometry.points.positions.value.length > 0) {
+      binaryGeometryType = "points" /* points */;
+    } else if (binaryGeometry.lines && binaryGeometry.lines.positions.value.length > 0) {
+      binaryGeometryType = "lines" /* lines */;
+    } else if (binaryGeometry.polygons && binaryGeometry.polygons.positions.value.length > 0) {
+      binaryGeometryType = "polygons" /* polygons */;
+    }
+    const binaryContent = binaryGeometryType ? binaryGeometry[binaryGeometryType] : null;
+    if (binaryContent && binaryGeometryType !== null) {
+      const featureIds = binaryContent.featureIds.value;
+      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
+      );
+      meanCenters.forEach((center) => {
+        globalMeanCenters.push(center);
+      });
+    }
+  });
+  return globalMeanCenters;
+}
+function getMeanCentersFromGeometry(featureIds, flatCoordinateArray, nDim, geometryType, primitivePolygonIndices) {
+  const meanCenters = [];
+  const vertexCount = flatCoordinateArray.length;
+  let vertexIndex = 0;
+  let coordIdx = 0;
+  let primitiveIdx = 0;
+  while (vertexIndex < vertexCount) {
+    const featureId = featureIds[vertexIndex / nDim];
+    const center = [0, 0];
+    let vertexCountInFeature = 0;
+    while (vertexIndex < vertexCount && featureIds[coordIdx] === featureId) {
+      if (geometryType === "polygons" /* polygons */ && (primitivePolygonIndices == null ? void 0 : primitivePolygonIndices[primitiveIdx]) === coordIdx) {
+        vertexIndex += nDim;
+        primitiveIdx++;
+      } else {
+        center[0] += flatCoordinateArray[vertexIndex];
+        center[1] += flatCoordinateArray[vertexIndex + 1];
+        vertexIndex += nDim;
+        vertexCountInFeature++;
+      }
+      coordIdx += 1;
+    }
+    center[0] /= vertexCountInFeature;
+    center[1] /= vertexCountInFeature;
+    meanCenters.push(center);
+  }
+  return meanCenters;
 }
-function getBinaryGeometriesFromChunk(chunk, geoEncoding) {
+function getBinaryGeometriesFromChunk(chunk, geoEncoding, options) {
   switch (geoEncoding) {
     case "geoarrow.point":
     case "geoarrow.multipoint":
@@ -651,12 +796,48 @@ function getBinaryGeometriesFromChunk(chunk, geoEncoding) {
       return getBinaryLinesFromChunk(chunk, geoEncoding);
     case "geoarrow.polygon":
     case "geoarrow.multipolygon":
-      return getBinaryPolygonsFromChunk(chunk, geoEncoding);
+      return getBinaryPolygonsFromChunk(chunk, geoEncoding, options);
     default:
       throw Error("invalid geoarrow encoding");
   }
 }
-function getBinaryPolygonsFromChunk(chunk, geoEncoding) {
+function getTriangleIndices(polygonIndices, primitivePolygonIndices, flatCoordinateArray, nDim) {
+  try {
+    let primitiveIndex = 0;
+    const triangles = [];
+    for (let i = 0; i < polygonIndices.length - 1; i++) {
+      const startIdx = polygonIndices[i];
+      const endIdx = polygonIndices[i + 1];
+      const slicedFlatCoords = flatCoordinateArray.subarray(startIdx * nDim, endIdx * nDim);
+      const holeIndices = [];
+      while (primitivePolygonIndices[primitiveIndex] < endIdx) {
+        if (primitivePolygonIndices[primitiveIndex] > startIdx) {
+          holeIndices.push(primitivePolygonIndices[primitiveIndex] - startIdx);
+        }
+        primitiveIndex++;
+      }
+      const triangleIndices = (0, import_polygon.earcut)(
+        slicedFlatCoords,
+        holeIndices.length > 0 ? holeIndices : void 0,
+        nDim
+      );
+      if (triangleIndices.length === 0) {
+        throw Error("can not tesselate invalid polygon");
+      }
+      for (let j = 0; j < triangleIndices.length; j++) {
+        triangles.push(triangleIndices[j] + startIdx);
+      }
+    }
+    const trianglesUint32 = new Uint32Array(triangles.length);
+    for (let i = 0; i < triangles.length; i++) {
+      trianglesUint32[i] = triangles[i];
+    }
+    return trianglesUint32;
+  } catch (error) {
+    return null;
+  }
+}
+function getBinaryPolygonsFromChunk(chunk, geoEncoding, options) {
   const isMultiPolygon = geoEncoding === "geoarrow.multipolygon";
   const polygonData = isMultiPolygon ? chunk.children[0] : chunk;
   const polygonOffset = polygonData.valueOffsets;
@@ -680,12 +861,14 @@ function getBinaryPolygonsFromChunk(chunk, geoEncoding) {
       featureIds[j] = i;
     }
   }
+  const triangles = (options == null ? void 0 : options.triangulate) ? getTriangleIndices(geometryIndicies, geomOffset, flatCoordinateArray, nDim) : null;
   return {
     featureIds,
     flatCoordinateArray,
     nDim,
     geomOffset,
-    geometryIndicies
+    geometryIndicies,
+    ...(options == null ? void 0 : options.triangulate) && triangles ? { triangles } : {}
   };
 }
 function getBinaryLinesFromChunk(chunk, geoEncoding) {
@@ -699,11 +882,22 @@ function getBinaryLinesFromChunk(chunk, geoEncoding) {
   const geometryIndicies = new Uint16Array(0);
   const numOfVertices = flatCoordinateArray.length / nDim;
   const featureIds = new Uint32Array(numOfVertices);
-  for (let i = 0; i < chunk.length; i++) {
-    const startIdx = geomOffset[i];
-    const endIdx = geomOffset[i + 1];
-    for (let j = startIdx; j < endIdx; j++) {
-      featureIds[j] = i;
+  if (isMultiLineString) {
+    const partData = chunk.valueOffsets;
+    for (let i = 0; i < partData.length - 1; i++) {
+      const startIdx = geomOffset[partData[i]];
+      const endIdx = geomOffset[partData[i + 1]];
+      for (let j = startIdx; j < endIdx; j++) {
+        featureIds[j] = i;
+      }
+    }
+  } else {
+    for (let i = 0; i < chunk.length; i++) {
+      const startIdx = geomOffset[i];
+      const endIdx = geomOffset[i + 1];
+      for (let j = startIdx; j < endIdx; j++) {
+        featureIds[j] = i;
+      }
     }
   }
   return {
@@ -724,8 +918,19 @@ function getBinaryPointsFromChunk(chunk, geoEncoding) {
   const geomOffset = new Int32Array(0);
   const numOfVertices = flatCoordinateArray.length / nDim;
   const featureIds = new Uint32Array(numOfVertices);
-  for (let i = 0; i < chunk.length; i++) {
-    featureIds[i] = i;
+  if (isMultiPoint) {
+    const partData = chunk.valueOffsets;
+    for (let i = 0; i < partData.length - 1; i++) {
+      const startIdx = partData[i];
+      const endIdx = partData[i + 1];
+      for (let j = startIdx; j < endIdx; j++) {
+        featureIds[j] = i;
+      }
+    }
+  } else {
+    for (let i = 0; i < chunk.length; i++) {
+      featureIds[i] = i;
+    }
   }
   return {
     featureIds,
@@ -736,43 +941,60 @@ function getBinaryPointsFromChunk(chunk, geoEncoding) {
   };
 }
 
-// src/geoarrow/convert-geoarrow-to-geojson.ts
-function parseGeometryFromArrow(rawData) {
-  var _a;
-  const encoding = (_a = rawData.encoding) == null ? void 0 : _a.toLowerCase();
-  const data = rawData.data;
-  if (!encoding || !data) {
+// src/geoarrow/convert-geoarrow-to-geojson-geometry.ts
+var import_gis2 = require("@loaders.gl/gis");
+var import_wkt = require("@loaders.gl/wkt");
+function parseGeometryFromArrow2(arrowCellValue, encoding) {
+  encoding = encoding == null ? void 0 : encoding.toLowerCase();
+  if (!encoding || !arrowCellValue) {
     return null;
   }
   let geometry;
   switch (encoding) {
     case "geoarrow.multipolygon":
-      geometry = arrowMultiPolygonToFeature(data);
+      geometry = arrowMultiPolygonToFeature(arrowCellValue);
       break;
     case "geoarrow.polygon":
-      geometry = arrowPolygonToFeature(data);
+      geometry = arrowPolygonToFeature(arrowCellValue);
       break;
     case "geoarrow.multipoint":
-      geometry = arrowMultiPointToFeature(data);
+      geometry = arrowMultiPointToFeature(arrowCellValue);
       break;
     case "geoarrow.point":
-      geometry = arrowPointToFeature(data);
+      geometry = arrowPointToFeature(arrowCellValue);
       break;
     case "geoarrow.multilinestring":
-      geometry = arrowMultiLineStringToFeature(data);
+      geometry = arrowMultiLineStringToFeature(arrowCellValue);
       break;
     case "geoarrow.linestring":
-      geometry = arrowLineStringToFeature(data);
+      geometry = arrowLineStringToFeature(arrowCellValue);
+      break;
+    case "geoarrow.wkb":
+      geometry = arrowWKBToFeature(arrowCellValue);
+      break;
+    case "geoarrow.wkt":
+      geometry = arrowWKTToFeature(arrowCellValue);
       break;
     default: {
       throw Error(`GeoArrow encoding not supported ${encoding}`);
     }
   }
-  return {
-    type: "Feature",
-    geometry,
-    properties: {}
-  };
+  return geometry;
+}
+function arrowWKBToFeature(arrowCellValue) {
+  var _a, _b;
+  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;
+}
+function arrowWKTToFeature(arrowCellValue) {
+  var _a, _b;
+  const string = arrowCellValue;
+  return (_b = (_a = import_wkt.WKTLoader).parseTextSync) == null ? void 0 : _b.call(_a, string);
 }
 function arrowMultiPolygonToFeature(arrowMultiPolygon) {
   const multiPolygon = [];
@@ -824,19 +1046,17 @@ function arrowMultiPointToFeature(arrowMultiPoint) {
       multiPoint.push(coord);
     }
   }
-  const geometry = {
+  return {
     type: "MultiPoint",
     coordinates: multiPoint
   };
-  return geometry;
 }
 function arrowPointToFeature(arrowPoint) {
   const point = Array.from(arrowPoint);
-  const geometry = {
+  return {
     type: "Point",
     coordinates: point
   };
-  return geometry;
 }
 function arrowMultiLineStringToFeature(arrowMultiLineString) {
   const multiLineString = [];
@@ -852,11 +1072,10 @@ function arrowMultiLineStringToFeature(arrowMultiLineString) {
     }
     multiLineString.push(lineString);
   }
-  const geometry = {
+  return {
     type: "MultiLineString",
     coordinates: multiLineString
   };
-  return geometry;
 }
 function arrowLineStringToFeature(arrowLineString) {
   const lineString = [];
@@ -867,18 +1086,25 @@ function arrowLineStringToFeature(arrowLineString) {
       lineString.push(coords);
     }
   }
-  const geometry = {
+  return {
     type: "LineString",
     coordinates: lineString
   };
-  return geometry;
+}
+
+// src/triangulate-on-worker.ts
+var import_worker_utils = require("@loaders.gl/worker-utils");
+var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var TriangulationWorker = {
+  id: "triangulation",
+  name: "Triangulate",
+  module: "arrow",
+  version: VERSION3,
+  options: {}
+};
+function triangulateOnWorker(data, options = {}) {
+  return (0, import_worker_utils.processOnWorker)(TriangulationWorker, data, options);
 }
 
 // src/index.ts
 import_schema3.TableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;
-var ArrowLoader2 = {
-  ...ArrowLoader,
-  parse: async (arraybuffer, options) => parseArrowSync(arraybuffer, options),
-  parseSync: parseArrowSync,
-  parseInBatches: parseArrowInBatches
-};