@loaders.gl/arrow 4.0.2 → 4.0.4

package/dist/dist.dev.js

@@ -27,22 +27,29 @@ var __exports__ = (() => {
   // 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,
+    getMeanCentersFromBinaryGeometries: () => getMeanCentersFromBinaryGeometries,
+    getTriangleIndices: () => getTriangleIndices,
     parseGeometryFromArrow: () => parseGeometryFromArrow,
     serializeArrowField: () => serializeArrowField,
     serializeArrowMetadata: () => serializeArrowMetadata,
     serializeArrowSchema: () => serializeArrowSchema,
     serializeArrowType: () => serializeArrowType,
+    triangulateOnWorker: () => triangulateOnWorker,
     updateBoundsFromGeoArrowSamples: () => updateBoundsFromGeoArrowSamples
   });
 
@@ -456,10 +463,10 @@ var __exports__ = (() => {
     }
     return columnIndex;
   }
-  function getTableRowAsObject(table, rowIndex, target, copy) {
+  function getTableRowAsObject(table, rowIndex, target, copy2) {
     switch (table.shape) {
       case "object-row-table":
-        return copy ? Object.fromEntries(Object.entries(table.data[rowIndex])) : table.data[rowIndex];
+        return copy2 ? Object.fromEntries(Object.entries(table.data[rowIndex])) : table.data[rowIndex];
       case "array-row-table":
         if (table.schema) {
           const objectRow2 = target || {};
@@ -505,10 +512,10 @@ var __exports__ = (() => {
         throw new Error("shape");
     }
   }
-  function getTableRowAsArray(table, rowIndex, target, copy) {
+  function getTableRowAsArray(table, rowIndex, target, copy2) {
     switch (table.shape) {
       case "array-row-table":
-        return copy ? Array.from(table.data[rowIndex]) : table.data[rowIndex];
+        return copy2 ? Array.from(table.data[rowIndex]) : table.data[rowIndex];
       case "object-row-table":
         if (table.schema) {
           const arrayRow2 = target || [];
@@ -792,25 +799,6 @@ var __exports__ = (() => {
     };
   }
 
-  // src/arrow-loader.ts
-  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-  var ArrowLoader = {
-    name: "Apache Arrow",
-    id: "arrow",
-    module: "arrow",
-    version: VERSION,
-    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"
-      }
-    }
-  };
-
   // ../../node_modules/tslib/tslib.es6.mjs
   function __rest(s, e) {
     var t = {};
@@ -2796,21 +2784,21 @@ var __exports__ = (() => {
   function uint16ToFloat64(h) {
     const expo = (h & 31744) >> 10;
     const sigf = (h & 1023) / 1024;
-    const sign = Math.pow(-1, (h & 32768) >> 15);
+    const sign2 = Math.pow(-1, (h & 32768) >> 15);
     switch (expo) {
       case 31:
-        return sign * (sigf ? Number.NaN : 1 / 0);
+        return sign2 * (sigf ? Number.NaN : 1 / 0);
       case 0:
-        return sign * (sigf ? 6103515625e-14 * sigf : 0);
+        return sign2 * (sigf ? 6103515625e-14 * sigf : 0);
     }
-    return sign * Math.pow(2, expo - 15) * (1 + sigf);
+    return sign2 * Math.pow(2, expo - 15) * (1 + sigf);
   }
   function float64ToUint16(d) {
     if (d !== d) {
       return 32256;
     }
     f64[0] = d;
-    const sign = (u32[1] & 2147483648) >> 16 & 65535;
+    const sign2 = (u32[1] & 2147483648) >> 16 & 65535;
     let expo = u32[1] & 2146435072, sigf = 0;
     if (expo >= 1089470464) {
       if (u32[0] > 0) {
@@ -2827,7 +2815,7 @@ var __exports__ = (() => {
       expo = expo - 1056964608 >> 10;
       sigf = (u32[1] & 1048575) + 512 >> 10;
     }
-    return sign | expo | sigf & 65535;
+    return sign2 | expo | sigf & 65535;
   }
 
   // ../../node_modules/apache-arrow/visitor/set.mjs
@@ -11592,8 +11580,8 @@ return true;`);
       return new JSONVectorLoader(body, header.nodes, header.buffers, this.dictionaries).visitMany(types);
     }
   };
-  function shouldAutoDestroy(self, options) {
-    return options && typeof options["autoDestroy"] === "boolean" ? options["autoDestroy"] : self["autoDestroy"];
+  function shouldAutoDestroy(self2, options) {
+    return options && typeof options["autoDestroy"] === "boolean" ? options["autoDestroy"] : self2["autoDestroy"];
   }
   function* readAllSync(source) {
     const reader = RecordBatchReader.from(source);
@@ -12340,65 +12328,6 @@ return true;`);
   RecordBatchFileWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
   RecordBatchStreamWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
 
-  // 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?.toArray();
-      columnarTable[field.name] = values;
-    }
-    return {
-      shape: "columnar-table",
-      data: columnarTable
-    };
-  }
-
-  // src/lib/parse-arrow-sync.ts
-  function parseArrowSync(arrayBuffer, options) {
-    const apacheArrowTable = tableFromIPC([new Uint8Array(arrayBuffer)]);
-    const arrowTable = convertApacheArrowToArrowTable(apacheArrowTable);
-    const shape = options?.arrow?.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 convertTable(columnarTable, "object-row-table");
-      default:
-        throw new Error(shape);
-    }
-  }
-
-  // src/lib/parse-arrow-in-batches.ts
-  function parseArrowInBatches(asyncIterator) {
-    async function* makeArrowAsyncIterator() {
-      const readers = RecordBatchReader.readAll(asyncIterator);
-      for await (const reader of readers) {
-        for await (const recordBatch of reader) {
-          const arrowTabledBatch = {
-            shape: "arrow-table",
-            batchType: "data",
-            data: new Table([recordBatch]),
-            length: recordBatch.data.length
-          };
-          yield arrowTabledBatch;
-        }
-        break;
-      }
-    }
-    return makeArrowAsyncIterator();
-  }
-
   // src/lib/arrow-table-batch.ts
   var ArrowTableBatchAggregator = class extends ColumnarTableBatchAggregator {
     constructor(schema, options) {
@@ -12480,88 +12409,887 @@ return true;`);
     }
   }
 
-  // src/schema/convert-arrow-schema.ts
-  function serializeArrowSchema(arrowSchema) {
+  // src/types.ts
+  var VECTOR_TYPES = function(VECTOR_TYPES2) {
+    VECTOR_TYPES2[VECTOR_TYPES2["FLOAT"] = 0] = "FLOAT";
+    VECTOR_TYPES2[VECTOR_TYPES2["DATE"] = 1] = "DATE";
+    return VECTOR_TYPES2;
+  }({});
+
+  // 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?.toArray();
+      columnarTable[field.name] = values;
+    }
     return {
-      fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
-      metadata: serializeArrowMetadata(arrowSchema.metadata)
+      shape: "columnar-table",
+      data: columnarTable
     };
   }
-  function deserializeArrowSchema(schema) {
-    return new Schema2(schema.fields.map((field) => deserializeArrowField(field)), deserializeArrowMetadata(schema.metadata));
+
+  // src/parsers/parse-arrow-sync.ts
+  function parseArrowSync(arrayBuffer, options) {
+    const apacheArrowTable = tableFromIPC([new Uint8Array(arrayBuffer)]);
+    const arrowTable = {
+      shape: "arrow-table",
+      data: apacheArrowTable
+    };
+    const shape = 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 convertTable(columnarTable, "object-row-table");
+      case "array-row-table":
+        columnarTable = convertArrowToColumnarTable(arrowTable);
+        return convertTable(columnarTable, "array-row-table");
+      default:
+        throw new Error(shape);
+    }
   }
-  function serializeArrowMetadata(arrowMetadata) {
-    return Object.fromEntries(arrowMetadata);
+
+  // src/parsers/parse-arrow-in-batches.ts
+  function parseArrowInBatches(asyncIterator) {
+    async function* makeArrowAsyncIterator() {
+      const readers = RecordBatchReader.readAll(asyncIterator);
+      for await (const reader of readers) {
+        for await (const recordBatch of reader) {
+          const arrowTabledBatch = {
+            shape: "arrow-table",
+            batchType: "data",
+            data: new Table([recordBatch]),
+            length: recordBatch.data.length
+          };
+          yield arrowTabledBatch;
+        }
+        break;
+      }
+    }
+    return makeArrowAsyncIterator();
   }
-  function deserializeArrowMetadata(metadata) {
-    return metadata ? new Map(Object.entries(metadata)) : /* @__PURE__ */ new Map();
+
+  // src/arrow-loader.ts
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var ArrowWorkerLoader = {
+    name: "Apache Arrow",
+    id: "arrow",
+    module: "arrow",
+    version: VERSION,
+    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?.arrow),
+    parseSync: (arraybuffer, options) => parseArrowSync(arraybuffer, options?.arrow),
+    parseInBatches: parseArrowInBatches
+  };
+
+  // src/lib/encode-arrow.ts
+  function encodeArrowSync(data) {
+    const vectors = {};
+    for (const arrayData of data) {
+      const arrayVector = createVector(arrayData.array, arrayData.type);
+      vectors[arrayData.name] = arrayVector;
+    }
+    const table = new Table(vectors);
+    const arrowBuffer = tableToIPC(table);
+    return arrowBuffer;
   }
-  function serializeArrowField(field) {
-    return {
-      name: field.name,
-      type: serializeArrowType(field.type),
-      nullable: field.nullable,
-      metadata: serializeArrowMetadata(field.metadata)
-    };
+  function createVector(array, type) {
+    switch (type) {
+      case VECTOR_TYPES.DATE:
+        return vectorFromArray(array);
+      case VECTOR_TYPES.FLOAT:
+      default:
+        return vectorFromArray(array);
+    }
   }
-  function deserializeArrowField(field) {
-    return new Field2(field.name, deserializeArrowType(field.type), field.nullable, deserializeArrowMetadata(field.metadata));
+
+  // src/arrow-writer.ts
+  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var ArrowWriter = {
+    name: "Apache Arrow",
+    id: "arrow",
+    module: "arrow",
+    version: VERSION2,
+    extensions: ["arrow", "feather"],
+    mimeTypes: ["application/vnd.apache.arrow.file", "application/vnd.apache.arrow.stream", "application/octet-stream"],
+    binary: true,
+    options: {},
+    encode: async function encodeArrow(data, options) {
+      return encodeArrowSync(data);
+    },
+    encodeSync(data, options) {
+      return encodeArrowSync(data);
+    }
+  };
+
+  // ../gis/src/lib/geo/geoarrow-metadata.ts
+  var GEOARROW_ENCODINGS = ["geoarrow.multipolygon", "geoarrow.polygon", "geoarrow.multilinestring", "geoarrow.linestring", "geoarrow.multipoint", "geoarrow.point", "geoarrow.wkb", "geoarrow.wkt"];
+  var GEOARROW_COLUMN_METADATA_ENCODING = "ARROW:extension:name";
+  var GEOARROW_COLUMN_METADATA_METADATA = "ARROW:extension:metadata";
+  function getGeometryColumnsFromSchema(schema) {
+    const geometryColumns = {};
+    for (const field of schema.fields) {
+      const metadata = getGeometryMetadataForField(field);
+      if (metadata) {
+        geometryColumns[field.name] = metadata;
+      }
+    }
+    return geometryColumns;
   }
-  function serializeArrowType(arrowType) {
-    switch (arrowType.constructor) {
-      case Null:
-        return "null";
-      case Binary:
-        return "binary";
-      case Bool:
-        return "bool";
-      case Int_:
-        const intType = arrowType;
-        return `${intType.isSigned ? "u" : ""}int${intType.bitWidth}`;
-      case Int8:
-        return "int8";
-      case Int16:
-        return "int16";
-      case Int32:
-        return "int32";
-      case Int64:
-        return "int64";
-      case Uint8:
-        return "uint8";
-      case Uint16:
-        return "uint16";
-      case Uint32:
-        return "uint32";
-      case Uint64:
-        return "uint64";
-      case Float:
-        const precision = arrowType.precision;
-        switch (precision) {
-          case Precision.HALF:
-            return "float16";
-          case Precision.SINGLE:
-            return "float32";
-          case Precision.DOUBLE:
-            return "float64";
-          default:
-            return "float16";
-        }
-      case Float16:
-        return "float16";
-      case Float32:
-        return "float32";
-      case Float64:
-        return "float64";
-      case Utf8:
-        return "utf8";
-      case Date:
-        const dateUnit = arrowType.unit;
-        return dateUnit === DateUnit.DAY ? "date-day" : "date-millisecond";
-      case DateDay:
-        return "date-day";
-      case DateMillisecond:
-        return "date-millisecond";
-      case Time_:
+  function getGeometryMetadataForField(field) {
+    let metadata = null;
+    const columnMetadata = field.metadata?.[GEOARROW_COLUMN_METADATA_METADATA];
+    if (columnMetadata) {
+      try {
+        metadata = JSON.parse(columnMetadata);
+      } catch (error) {
+        console.warn("Failed to parse GeoArrow metadata", error);
+      }
+    }
+    let geoEncoding = field.metadata?.[GEOARROW_COLUMN_METADATA_ENCODING];
+    if (geoEncoding) {
+      geoEncoding = geoEncoding.toLowerCase();
+      if (!GEOARROW_ENCODINGS.includes(geoEncoding)) {
+        console.warn(`Invalid GeoArrow encoding: ${geoEncoding}`);
+      } else {
+        metadata = metadata || {};
+        metadata.encoding = geoEncoding;
+      }
+    }
+    return metadata || null;
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+      return typeof obj2;
+    } : function(obj2) {
+      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    }, _typeof(obj);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+  function _toPrimitive(input, hint) {
+    if (_typeof(input) !== "object" || input === null)
+      return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== void 0) {
+      var res = prim.call(input, hint || "default");
+      if (_typeof(res) !== "object")
+        return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return _typeof(key) === "symbol" ? key : String(key);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
+  function _defineProperty(obj, key, value) {
+    key = _toPropertyKey(key);
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+
+  // ../../node_modules/@math.gl/polygon/dist/polygon-utils.js
+  var DimIndex = {
+    x: 0,
+    y: 1,
+    z: 2
+  };
+  function getPolygonSignedArea(points, options = {}) {
+    const {
+      start = 0,
+      end = points.length,
+      plane = "xy"
+    } = options;
+    const dim = options.size || 2;
+    let area2 = 0;
+    const i0 = DimIndex[plane[0]];
+    const i1 = DimIndex[plane[1]];
+    for (let i = start, j = end - dim; i < end; i += dim) {
+      area2 += (points[i + i0] - points[j + i0]) * (points[i + i1] + points[j + i1]);
+      j = i;
+    }
+    return area2 / 2;
+  }
+
+  // ../../node_modules/@math.gl/polygon/dist/earcut.js
+  function earcut(positions, holeIndices, dim = 2, areas, plane = "xy") {
+    const hasHoles = holeIndices && holeIndices.length;
+    const outerLen = hasHoles ? holeIndices[0] * dim : positions.length;
+    let outerNode = linkedList(positions, 0, outerLen, dim, true, areas && areas[0], plane);
+    const triangles = [];
+    if (!outerNode || outerNode.next === outerNode.prev)
+      return triangles;
+    let invSize;
+    let maxX;
+    let maxY;
+    let minX;
+    let minY;
+    let x;
+    let y;
+    if (hasHoles)
+      outerNode = eliminateHoles(positions, holeIndices, outerNode, dim, areas, plane);
+    if (positions.length > 80 * dim) {
+      minX = maxX = positions[0];
+      minY = maxY = positions[1];
+      for (let i = dim; i < outerLen; i += dim) {
+        x = positions[i];
+        y = positions[i + 1];
+        if (x < minX)
+          minX = x;
+        if (y < minY)
+          minY = y;
+        if (x > maxX)
+          maxX = x;
+        if (y > maxY)
+          maxY = y;
+      }
+      invSize = Math.max(maxX - minX, maxY - minY);
+      invSize = invSize !== 0 ? 32767 / invSize : 0;
+    }
+    earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
+    return triangles;
+  }
+  function linkedList(data, start, end, dim, clockwise, area2, plane) {
+    let i;
+    let last;
+    if (area2 === void 0) {
+      area2 = getPolygonSignedArea(data, {
+        start,
+        end,
+        size: dim,
+        plane
+      });
+    }
+    let i0 = DimIndex[plane[0]];
+    let i1 = DimIndex[plane[1]];
+    if (clockwise === area2 < 0) {
+      for (i = start; i < end; i += dim)
+        last = insertNode(i, data[i + i0], data[i + i1], last);
+    } else {
+      for (i = end - dim; i >= start; i -= dim)
+        last = insertNode(i, data[i + i0], data[i + i1], last);
+    }
+    if (last && equals(last, last.next)) {
+      removeNode(last);
+      last = last.next;
+    }
+    return last;
+  }
+  function filterPoints(start, end) {
+    if (!start)
+      return start;
+    if (!end)
+      end = start;
+    let p = start;
+    let again;
+    do {
+      again = false;
+      if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+        removeNode(p);
+        p = end = p.prev;
+        if (p === p.next)
+          break;
+        again = true;
+      } else {
+        p = p.next;
+      }
+    } while (again || p !== end);
+    return end;
+  }
+  function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+    if (!ear)
+      return;
+    if (!pass && invSize)
+      indexCurve(ear, minX, minY, invSize);
+    let stop = ear;
+    let prev;
+    let next;
+    while (ear.prev !== ear.next) {
+      prev = ear.prev;
+      next = ear.next;
+      if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+        triangles.push(prev.i / dim | 0);
+        triangles.push(ear.i / dim | 0);
+        triangles.push(next.i / dim | 0);
+        removeNode(ear);
+        ear = next.next;
+        stop = next.next;
+        continue;
+      }
+      ear = next;
+      if (ear === stop) {
+        if (!pass) {
+          earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+        } else if (pass === 1) {
+          ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
+          earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+        } else if (pass === 2) {
+          splitEarcut(ear, triangles, dim, minX, minY, invSize);
+        }
+        break;
+      }
+    }
+  }
+  function isEar(ear) {
+    const a = ear.prev;
+    const b = ear;
+    const c = ear.next;
+    if (area(a, b, c) >= 0)
+      return false;
+    const ax = a.x;
+    const bx = b.x;
+    const cx = c.x;
+    const ay = a.y;
+    const by = b.y;
+    const cy = c.y;
+    const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx;
+    const y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy;
+    const x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx;
+    const y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+    let p = c.next;
+    while (p !== a) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+        return false;
+      p = p.next;
+    }
+    return true;
+  }
+  function isEarHashed(ear, minX, minY, invSize) {
+    const a = ear.prev;
+    const b = ear;
+    const c = ear.next;
+    if (area(a, b, c) >= 0)
+      return false;
+    const ax = a.x;
+    const bx = b.x;
+    const cx = c.x;
+    const ay = a.y;
+    const by = b.y;
+    const cy = c.y;
+    const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx;
+    const y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy;
+    const x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx;
+    const y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+    const minZ = zOrder(x0, y0, minX, minY, invSize);
+    const maxZ = zOrder(x1, y1, minX, minY, invSize);
+    let p = ear.prevZ;
+    let n = ear.nextZ;
+    while (p && p.z >= minZ && n && n.z <= maxZ) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+        return false;
+      p = p.prevZ;
+      if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+        return false;
+      n = n.nextZ;
+    }
+    while (p && p.z >= minZ) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+        return false;
+      p = p.prevZ;
+    }
+    while (n && n.z <= maxZ) {
+      if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+        return false;
+      n = n.nextZ;
+    }
+    return true;
+  }
+  function cureLocalIntersections(start, triangles, dim) {
+    let p = start;
+    do {
+      const a = p.prev;
+      const b = p.next.next;
+      if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+        triangles.push(a.i / dim | 0);
+        triangles.push(p.i / dim | 0);
+        triangles.push(b.i / dim | 0);
+        removeNode(p);
+        removeNode(p.next);
+        p = start = b;
+      }
+      p = p.next;
+    } while (p !== start);
+    return filterPoints(p);
+  }
+  function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+    let a = start;
+    do {
+      let b = a.next.next;
+      while (b !== a.prev) {
+        if (a.i !== b.i && isValidDiagonal(a, b)) {
+          let c = splitPolygon(a, b);
+          a = filterPoints(a, a.next);
+          c = filterPoints(c, c.next);
+          earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
+          earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
+          return;
+        }
+        b = b.next;
+      }
+      a = a.next;
+    } while (a !== start);
+  }
+  function eliminateHoles(data, holeIndices, outerNode, dim, areas, plane) {
+    const queue = [];
+    let i;
+    let len;
+    let start;
+    let end;
+    let list;
+    for (i = 0, len = holeIndices.length; i < len; i++) {
+      start = holeIndices[i] * dim;
+      end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+      list = linkedList(data, start, end, dim, false, areas && areas[i + 1], plane);
+      if (list === list.next)
+        list.steiner = true;
+      queue.push(getLeftmost(list));
+    }
+    queue.sort(compareX);
+    for (i = 0; i < queue.length; i++) {
+      outerNode = eliminateHole(queue[i], outerNode);
+    }
+    return outerNode;
+  }
+  function compareX(a, b) {
+    return a.x - b.x;
+  }
+  function eliminateHole(hole, outerNode) {
+    const bridge = findHoleBridge(hole, outerNode);
+    if (!bridge) {
+      return outerNode;
+    }
+    const bridgeReverse = splitPolygon(bridge, hole);
+    filterPoints(bridgeReverse, bridgeReverse.next);
+    return filterPoints(bridge, bridge.next);
+  }
+  function findHoleBridge(hole, outerNode) {
+    let p = outerNode;
+    const hx = hole.x;
+    const hy = hole.y;
+    let qx = -Infinity;
+    let m;
+    do {
+      if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+        const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+        if (x <= hx && x > qx) {
+          qx = x;
+          m = p.x < p.next.x ? p : p.next;
+          if (x === hx)
+            return m;
+        }
+      }
+      p = p.next;
+    } while (p !== outerNode);
+    if (!m)
+      return null;
+    const stop = m;
+    const mx = m.x;
+    const my = m.y;
+    let tanMin = Infinity;
+    let tan;
+    p = m;
+    do {
+      if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+        tan = Math.abs(hy - p.y) / (hx - p.x);
+        if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
+          m = p;
+          tanMin = tan;
+        }
+      }
+      p = p.next;
+    } while (p !== stop);
+    return m;
+  }
+  function sectorContainsSector(m, p) {
+    return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+  }
+  function indexCurve(start, minX, minY, invSize) {
+    let p = start;
+    do {
+      if (p.z === 0)
+        p.z = zOrder(p.x, p.y, minX, minY, invSize);
+      p.prevZ = p.prev;
+      p.nextZ = p.next;
+      p = p.next;
+    } while (p !== start);
+    p.prevZ.nextZ = null;
+    p.prevZ = null;
+    sortLinked(p);
+  }
+  function sortLinked(list) {
+    let e;
+    let i;
+    let inSize = 1;
+    let numMerges;
+    let p;
+    let pSize;
+    let q;
+    let qSize;
+    let tail;
+    do {
+      p = list;
+      list = null;
+      tail = null;
+      numMerges = 0;
+      while (p) {
+        numMerges++;
+        q = p;
+        pSize = 0;
+        for (i = 0; i < inSize; i++) {
+          pSize++;
+          q = q.nextZ;
+          if (!q)
+            break;
+        }
+        qSize = inSize;
+        while (pSize > 0 || qSize > 0 && q) {
+          if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
+            e = p;
+            p = p.nextZ;
+            pSize--;
+          } else {
+            e = q;
+            q = q.nextZ;
+            qSize--;
+          }
+          if (tail)
+            tail.nextZ = e;
+          else
+            list = e;
+          e.prevZ = tail;
+          tail = e;
+        }
+        p = q;
+      }
+      tail.nextZ = null;
+      inSize *= 2;
+    } while (numMerges > 1);
+    return list;
+  }
+  function zOrder(x, y, minX, minY, invSize) {
+    x = (x - minX) * invSize | 0;
+    y = (y - minY) * invSize | 0;
+    x = (x | x << 8) & 16711935;
+    x = (x | x << 4) & 252645135;
+    x = (x | x << 2) & 858993459;
+    x = (x | x << 1) & 1431655765;
+    y = (y | y << 8) & 16711935;
+    y = (y | y << 4) & 252645135;
+    y = (y | y << 2) & 858993459;
+    y = (y | y << 1) & 1431655765;
+    return x | y << 1;
+  }
+  function getLeftmost(start) {
+    let p = start;
+    let leftmost = start;
+    do {
+      if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y)
+        leftmost = p;
+      p = p.next;
+    } while (p !== start);
+    return leftmost;
+  }
+  function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+    return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py);
+  }
+  function isValidDiagonal(a, b) {
+    return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && (area(a.prev, a, b.prev) || area(a, b.prev, b)) || equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0);
+  }
+  function area(p, q, r) {
+    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+  }
+  function equals(p1, p2) {
+    return p1.x === p2.x && p1.y === p2.y;
+  }
+  function intersects(p1, q1, p2, q2) {
+    const o1 = sign(area(p1, q1, p2));
+    const o2 = sign(area(p1, q1, q2));
+    const o3 = sign(area(p2, q2, p1));
+    const o4 = sign(area(p2, q2, q1));
+    if (o1 !== o2 && o3 !== o4)
+      return true;
+    if (o1 === 0 && onSegment(p1, p2, q1))
+      return true;
+    if (o2 === 0 && onSegment(p1, q2, q1))
+      return true;
+    if (o3 === 0 && onSegment(p2, p1, q2))
+      return true;
+    if (o4 === 0 && onSegment(p2, q1, q2))
+      return true;
+    return false;
+  }
+  function onSegment(p, q, r) {
+    return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+  }
+  function sign(num) {
+    return num > 0 ? 1 : num < 0 ? -1 : 0;
+  }
+  function intersectsPolygon(a, b) {
+    let p = a;
+    do {
+      if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b))
+        return true;
+      p = p.next;
+    } while (p !== a);
+    return false;
+  }
+  function locallyInside(a, b) {
+    return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
+  }
+  function middleInside(a, b) {
+    let p = a;
+    let inside = false;
+    const px = (a.x + b.x) / 2;
+    const py = (a.y + b.y) / 2;
+    do {
+      if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x)
+        inside = !inside;
+      p = p.next;
+    } while (p !== a);
+    return inside;
+  }
+  function splitPolygon(a, b) {
+    const a2 = new Vertex(a.i, a.x, a.y);
+    const b2 = new Vertex(b.i, b.x, b.y);
+    const an = a.next;
+    const bp = b.prev;
+    a.next = b;
+    b.prev = a;
+    a2.next = an;
+    an.prev = a2;
+    b2.next = a2;
+    a2.prev = b2;
+    bp.next = b2;
+    b2.prev = bp;
+    return b2;
+  }
+  function insertNode(i, x, y, last) {
+    const p = new Vertex(i, x, y);
+    if (!last) {
+      p.prev = p;
+      p.next = p;
+    } else {
+      p.next = last.next;
+      p.prev = last;
+      last.next.prev = p;
+      last.next = p;
+    }
+    return p;
+  }
+  function removeNode(p) {
+    p.next.prev = p.prev;
+    p.prev.next = p.next;
+    if (p.prevZ)
+      p.prevZ.nextZ = p.nextZ;
+    if (p.nextZ)
+      p.nextZ.prevZ = p.prevZ;
+  }
+  var Vertex = class {
+    constructor(i, x, y) {
+      _defineProperty(this, "i", void 0);
+      _defineProperty(this, "x", void 0);
+      _defineProperty(this, "y", void 0);
+      _defineProperty(this, "prev", null);
+      _defineProperty(this, "next", null);
+      _defineProperty(this, "z", 0);
+      _defineProperty(this, "prevZ", null);
+      _defineProperty(this, "nextZ", null);
+      _defineProperty(this, "steiner", false);
+      this.i = i;
+      this.x = x;
+      this.y = y;
+    }
+  };
+
+  // src/tables/convert-arrow-to-geojson-table.ts
+  function convertArrowToGeoJSONTable(table) {
+    const arrowTable = table.data;
+    const schema = serializeArrowSchema(arrowTable.schema);
+    const geometryColumns = getGeometryColumnsFromSchema(schema);
+    const encoding = geometryColumns.geometry.encoding;
+    const features = [];
+    for (let row = 0; row < arrowTable.numRows; row++) {
+      const arrowGeometry = arrowTable.getChild("geometry")?.get(row);
+      const arrowGeometryObject = {
+        encoding,
+        data: arrowGeometry
+      };
+      const feature = parseGeometryFromArrow(arrowGeometryObject);
+      if (feature) {
+        features.push(feature);
+      }
+    }
+    return {
+      shape: "geojson-table",
+      type: "FeatureCollection",
+      features
+    };
+  }
+
+  // src/parsers/parse-geoarrow-sync.ts
+  function parseGeoArrowSync(arrayBuffer, options) {
+    const table = parseArrowSync(arrayBuffer, {
+      shape: "arrow-table"
+    });
+    switch (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?.arrow),
+    parseSync: (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options?.arrow),
+    parseInBatches: parseGeoArrowInBatches
+  };
+
+  // src/schema/convert-arrow-schema.ts
+  function serializeArrowSchema(arrowSchema) {
+    return {
+      fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
+      metadata: serializeArrowMetadata(arrowSchema.metadata)
+    };
+  }
+  function deserializeArrowSchema(schema) {
+    return new Schema2(schema.fields.map((field) => deserializeArrowField(field)), deserializeArrowMetadata(schema.metadata));
+  }
+  function serializeArrowMetadata(arrowMetadata) {
+    return Object.fromEntries(arrowMetadata);
+  }
+  function deserializeArrowMetadata(metadata) {
+    return metadata ? new Map(Object.entries(metadata)) : /* @__PURE__ */ new Map();
+  }
+  function serializeArrowField(field) {
+    return {
+      name: field.name,
+      type: serializeArrowType(field.type),
+      nullable: field.nullable,
+      metadata: serializeArrowMetadata(field.metadata)
+    };
+  }
+  function deserializeArrowField(field) {
+    return new Field2(field.name, deserializeArrowType(field.type), field.nullable, deserializeArrowMetadata(field.metadata));
+  }
+  function serializeArrowType(arrowType) {
+    switch (arrowType.constructor) {
+      case Null:
+        return "null";
+      case Binary:
+        return "binary";
+      case Bool:
+        return "bool";
+      case Int_:
+        const intType = arrowType;
+        return `${intType.isSigned ? "u" : ""}int${intType.bitWidth}`;
+      case Int8:
+        return "int8";
+      case Int16:
+        return "int16";
+      case Int32:
+        return "int32";
+      case Int64:
+        return "int64";
+      case Uint8:
+        return "uint8";
+      case Uint16:
+        return "uint16";
+      case Uint32:
+        return "uint32";
+      case Uint64:
+        return "uint64";
+      case Float:
+        const precision = arrowType.precision;
+        switch (precision) {
+          case Precision.HALF:
+            return "float16";
+          case Precision.SINGLE:
+            return "float32";
+          case Precision.DOUBLE:
+            return "float64";
+          default:
+            return "float16";
+        }
+      case Float16:
+        return "float16";
+      case Float32:
+        return "float32";
+      case Float64:
+        return "float64";
+      case Utf8:
+        return "utf8";
+      case Decimal:
+        const decimal = arrowType;
+        return {
+          type: "decimal",
+          bitWidth: decimal.bitWidth,
+          precision: decimal.precision,
+          scale: decimal.scale
+        };
+      case Date_:
+        const dateUnit = arrowType.unit;
+        return dateUnit === DateUnit.DAY ? "date-day" : "date-millisecond";
+      case DateDay:
+        return "date-day";
+      case DateMillisecond:
+        return "date-millisecond";
+      case Time_:
         const timeUnit = arrowType.unit;
         switch (timeUnit) {
           case TimeUnit.SECOND:
@@ -12619,6 +13347,13 @@ return true;`);
         return "interval-daytime";
       case IntervalYearMonth:
         return "interval-yearmonth";
+      case Map_:
+        const mapType = arrowType;
+        return {
+          type: "map",
+          keysSorted: mapType.keysSorted,
+          children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
+        };
       case List:
         const listType = arrowType;
         const listField = listType.valueField;
@@ -12627,18 +13362,30 @@ return true;`);
           children: [serializeArrowField(listField)]
         };
       case FixedSizeList:
+        const fixedSizeList = arrowType;
         return {
           type: "fixed-size-list",
-          listSize: arrowType.listSize,
-          children: [serializeArrowField(arrowType.children[0])]
+          listSize: fixedSizeList.listSize,
+          children: [serializeArrowField(fixedSizeList.children[0])]
+        };
+      case Struct:
+        const structType = arrowType;
+        return {
+          type: "struct",
+          children: structType.children.map((arrowField) => serializeArrowField(arrowField))
         };
       default:
-        throw new Error("array type not supported");
+        throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
     }
   }
   function deserializeArrowType(dataType) {
     if (typeof dataType === "object") {
       switch (dataType.type) {
+        case "decimal":
+          return new Decimal(dataType.precision, dataType.scale, dataType.bitWidth);
+        case "map":
+          let children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
+          return new Map_(children, dataType.keysSorted);
         case "list":
           const field = deserializeArrowField(dataType.children[0]);
           return new List(field);
@@ -12646,7 +13393,7 @@ return true;`);
           const child = deserializeArrowField(dataType.children[0]);
           return new FixedSizeList(dataType.listSize, child);
         case "struct":
-          const children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
+          children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
           return new Struct(children);
         default:
           throw new Error("array type not supported");
@@ -12712,53 +13459,6 @@ return true;`);
     }
   }
 
-  // src/types.ts
-  var VECTOR_TYPES = function(VECTOR_TYPES2) {
-    VECTOR_TYPES2[VECTOR_TYPES2["FLOAT"] = 0] = "FLOAT";
-    VECTOR_TYPES2[VECTOR_TYPES2["DATE"] = 1] = "DATE";
-    return VECTOR_TYPES2;
-  }({});
-
-  // src/lib/encode-arrow.ts
-  function encodeArrowSync(data) {
-    const vectors = {};
-    for (const arrayData of data) {
-      const arrayVector = createVector(arrayData.array, arrayData.type);
-      vectors[arrayData.name] = arrayVector;
-    }
-    const table = new Table(vectors);
-    const arrowBuffer = tableToIPC(table);
-    return arrowBuffer;
-  }
-  function createVector(array, type) {
-    switch (type) {
-      case VECTOR_TYPES.DATE:
-        return vectorFromArray(array);
-      case VECTOR_TYPES.FLOAT:
-      default:
-        return vectorFromArray(array);
-    }
-  }
-
-  // src/arrow-writer.ts
-  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-  var ArrowWriter = {
-    name: "Apache Arrow",
-    id: "arrow",
-    module: "arrow",
-    version: VERSION2,
-    extensions: ["arrow", "feather"],
-    mimeTypes: ["application/vnd.apache.arrow.file", "application/vnd.apache.arrow.stream", "application/octet-stream"],
-    binary: true,
-    options: {},
-    encode: async function encodeArrow(data, options) {
-      return encodeArrowSync(data);
-    },
-    encodeSync(data, options) {
-      return encodeArrowSync(data);
-    }
-  };
-
   // src/geoarrow/get-arrow-bounds.ts
   function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds, sampleSize = 100) {
     const numberOfFeatures = flatCoords.length / nDim;
@@ -12800,13 +13500,13 @@ return true;`);
       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?.chunkIndex ? [geoColumn.data[options?.chunkIndex]] : geoColumn.data;
     let bounds = [Infinity, Infinity, -Infinity, -Infinity];
     let globalFeatureIdOffset = 0;
     const binaryGeometries = [];
@@ -12815,11 +13515,11 @@ return true;`);
         featureIds,
         flatCoordinateArray,
         nDim,
-        geomOffset
+        geomOffset,
+        triangles
       } = getBinaryGeometriesFromChunk(chunk, geoEncoding);
-      const numOfVertices = flatCoordinateArray.length / nDim;
-      const globalFeatureIds = new Uint32Array(numOfVertices);
-      for (let i = 0; i < numOfVertices; i++) {
+      const globalFeatureIds = new Uint32Array(featureIds.length);
+      for (let i = 0; i < featureIds.length; i++) {
         globalFeatureIds[i] = featureIds[i] + globalFeatureIdOffset;
       }
       const binaryContent = {
@@ -12867,7 +13567,13 @@ return true;`);
           primitivePolygonIndices: {
             value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
             size: 1
-          }
+          },
+          ...triangles ? {
+            triangles: {
+              value: triangles,
+              size: 1
+            }
+          } : {}
         }
       });
       bounds = updateBoundsFromGeoArrowSamples(flatCoordinateArray, nDim, bounds);
@@ -12875,9 +13581,61 @@ return true;`);
     return {
       binaryGeometries,
       bounds,
-      featureTypes
+      featureTypes,
+      ...options?.meanCenter ? {
+        meanCenters: getMeanCentersFromBinaryGeometries(binaryGeometries)
+      } : {}
     };
   }
+  function getMeanCentersFromBinaryGeometries(binaryGeometries) {
+    const globalMeanCenters = [];
+    binaryGeometries.forEach((binaryGeometry) => {
+      let binaryGeometryType = null;
+      if (binaryGeometry.points && binaryGeometry.points.positions.value.length > 0) {
+        binaryGeometryType = "points";
+      } else if (binaryGeometry.lines && binaryGeometry.lines.positions.value.length > 0) {
+        binaryGeometryType = "lines";
+      } else if (binaryGeometry.polygons && binaryGeometry.polygons.positions.value.length > 0) {
+        binaryGeometryType = "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.primitivePolygonIndices?.value;
+        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;
+    while (vertexIndex < vertexCount) {
+      const featureId = featureIds[vertexIndex / nDim];
+      const center = [0, 0];
+      let vertexCountInFeature = 0;
+      while (vertexIndex < vertexCount && featureIds[vertexIndex / nDim] === featureId) {
+        if (geometryType === "polygons" && primitivePolygonIndices && primitivePolygonIndices.indexOf(vertexIndex / nDim) >= 0) {
+          vertexIndex += nDim;
+        } else {
+          center[0] += flatCoordinateArray[vertexIndex];
+          center[1] += flatCoordinateArray[vertexIndex + 1];
+          vertexIndex += nDim;
+          vertexCountInFeature++;
+        }
+      }
+      center[0] /= vertexCountInFeature;
+      center[1] /= vertexCountInFeature;
+      meanCenters.push(center);
+    }
+    return meanCenters;
+  }
   function getBinaryGeometriesFromChunk(chunk, geoEncoding) {
     switch (geoEncoding) {
       case "geoarrow.point":
@@ -12893,35 +13651,63 @@ return true;`);
         throw Error("invalid geoarrow encoding");
     }
   }
+  function getTriangleIndices(polygonIndices, primitivePolygonIndices, flatCoordinateArray, nDim) {
+    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 = earcut(slicedFlatCoords, holeIndices.length > 0 ? holeIndices : void 0, nDim);
+      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;
+  }
   function getBinaryPolygonsFromChunk(chunk, geoEncoding) {
     const isMultiPolygon = geoEncoding === "geoarrow.multipolygon";
     const polygonData = isMultiPolygon ? chunk.children[0] : chunk;
+    const polygonOffset = polygonData.valueOffsets;
+    const partData = isMultiPolygon ? chunk.valueOffsets.map((i) => polygonOffset.at(i) || i) : chunk.valueOffsets;
     const ringData = polygonData.children[0];
     const pointData = ringData.children[0];
     const coordData = pointData.children[0];
     const nDim = pointData.stride;
     const geomOffset = ringData.valueOffsets;
     const flatCoordinateArray = coordData.values;
-    const geometryIndicies = new Uint16Array(chunk.length + 1);
-    for (let i = 0; i < chunk.length; i++) {
-      geometryIndicies[i] = geomOffset[chunk.valueOffsets[i]];
+    const geometryIndicies = new Uint16Array(polygonOffset.length);
+    for (let i = 0; i < polygonOffset.length; i++) {
+      geometryIndicies[i] = geomOffset[polygonOffset[i]];
     }
-    geometryIndicies[chunk.length] = flatCoordinateArray.length / nDim;
     const numOfVertices = flatCoordinateArray.length / nDim;
     const featureIds = new Uint32Array(numOfVertices);
-    for (let i = 0; i < chunk.length - 1; i++) {
-      const startIdx = geomOffset[chunk.valueOffsets[i]];
-      const endIdx = geomOffset[chunk.valueOffsets[i + 1]];
+    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;
       }
     }
+    const triangles = getTriangleIndices(geometryIndicies, geomOffset, flatCoordinateArray, nDim);
     return {
       featureIds,
       flatCoordinateArray,
       nDim,
       geomOffset,
-      geometryIndicies
+      geometryIndicies,
+      triangles
     };
   }
   function getBinaryLinesFromChunk(chunk, geoEncoding) {
@@ -12935,11 +13721,22 @@ return true;`);
     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 {
@@ -12960,8 +13757,19 @@ return true;`);
     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,
@@ -12999,6 +13807,10 @@ return true;`);
       case "geoarrow.linestring":
         geometry = arrowLineStringToFeature(data);
         break;
+      case "geoarrow.wkb":
+        throw Error(`GeoArrow encoding not supported ${encoding}`);
+      case "geoarrow.wkt":
+        throw Error(`GeoArrow encoding not supported ${encoding}`);
       default: {
         throw Error(`GeoArrow encoding not supported ${encoding}`);
       }
@@ -13109,14 +13921,571 @@ return true;`);
     return geometry;
   }
 
+  // ../worker-utils/src/lib/env-utils/version.ts
+  var NPM_TAG = "latest";
+  function getVersion() {
+    if (!globalThis._loadersgl_?.version) {
+      globalThis._loadersgl_ = globalThis._loadersgl_ || {};
+      if (typeof __VERSION__ === "undefined") {
+        console.warn("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
+        globalThis._loadersgl_.version = NPM_TAG;
+      } else {
+        globalThis._loadersgl_.version = __VERSION__;
+      }
+    }
+    return globalThis._loadersgl_.version;
+  }
+  var VERSION3 = getVersion();
+
+  // ../worker-utils/src/lib/env-utils/assert.ts
+  function assert(condition, message) {
+    if (!condition) {
+      throw new Error(message || "loaders.gl assertion failed.");
+    }
+  }
+
+  // ../worker-utils/src/lib/env-utils/globals.ts
+  var globals = {
+    self: typeof self !== "undefined" && self,
+    window: typeof window !== "undefined" && window,
+    global: typeof global !== "undefined" && global,
+    document: typeof document !== "undefined" && document
+  };
+  var self_ = globals.self || globals.window || globals.global || {};
+  var window_ = globals.window || globals.self || globals.global || {};
+  var global_ = globals.global || globals.self || globals.window || {};
+  var document_ = globals.document || {};
+  var isBrowser = typeof process !== "object" || String(process) !== "[object process]" || process.browser;
+  var isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
+  var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+  var nodeVersion = matches && parseFloat(matches[1]) || 0;
+
+  // ../worker-utils/src/lib/worker-farm/worker-job.ts
+  var WorkerJob = class {
+    isRunning = true;
+    _resolve = () => {
+    };
+    _reject = () => {
+    };
+    constructor(jobName, workerThread) {
+      this.name = jobName;
+      this.workerThread = workerThread;
+      this.result = new Promise((resolve, reject) => {
+        this._resolve = resolve;
+        this._reject = reject;
+      });
+    }
+    postMessage(type, payload) {
+      this.workerThread.postMessage({
+        source: "loaders.gl",
+        type,
+        payload
+      });
+    }
+    done(value) {
+      assert(this.isRunning);
+      this.isRunning = false;
+      this._resolve(value);
+    }
+    error(error) {
+      assert(this.isRunning);
+      this.isRunning = false;
+      this._reject(error);
+    }
+  };
+
+  // ../worker-utils/src/lib/node/worker_threads-browser.ts
+  var NodeWorker = class {
+    terminate() {
+    }
+  };
+
+  // ../worker-utils/src/lib/worker-utils/get-loadable-worker-url.ts
+  var workerURLCache = /* @__PURE__ */ new Map();
+  function getLoadableWorkerURL(props) {
+    assert(props.source && !props.url || !props.source && props.url);
+    let workerURL = workerURLCache.get(props.source || props.url);
+    if (!workerURL) {
+      if (props.url) {
+        workerURL = getLoadableWorkerURLFromURL(props.url);
+        workerURLCache.set(props.url, workerURL);
+      }
+      if (props.source) {
+        workerURL = getLoadableWorkerURLFromSource(props.source);
+        workerURLCache.set(props.source, workerURL);
+      }
+    }
+    assert(workerURL);
+    return workerURL;
+  }
+  function getLoadableWorkerURLFromURL(url) {
+    if (!url.startsWith("http")) {
+      return url;
+    }
+    const workerSource = buildScriptSource(url);
+    return getLoadableWorkerURLFromSource(workerSource);
+  }
+  function getLoadableWorkerURLFromSource(workerSource) {
+    const blob = new Blob([workerSource], {
+      type: "application/javascript"
+    });
+    return URL.createObjectURL(blob);
+  }
+  function buildScriptSource(workerUrl) {
+    return `try {
+  importScripts('${workerUrl}');
+} catch (error) {
+  console.error(error);
+  throw error;
+}`;
+  }
+
+  // ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
+  function getTransferList(object, recursive = true, transfers) {
+    const transfersSet = transfers || /* @__PURE__ */ new Set();
+    if (!object) {
+    } else if (isTransferable(object)) {
+      transfersSet.add(object);
+    } else if (isTransferable(object.buffer)) {
+      transfersSet.add(object.buffer);
+    } else if (ArrayBuffer.isView(object)) {
+    } else if (recursive && typeof object === "object") {
+      for (const key in object) {
+        getTransferList(object[key], recursive, transfersSet);
+      }
+    }
+    return transfers === void 0 ? Array.from(transfersSet) : [];
+  }
+  function isTransferable(object) {
+    if (!object) {
+      return false;
+    }
+    if (object instanceof ArrayBuffer) {
+      return true;
+    }
+    if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
+      return true;
+    }
+    if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
+      return true;
+    }
+    if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
+      return true;
+    }
+    return false;
+  }
+  function getTransferListForWriter(object) {
+    if (object === null) {
+      return {};
+    }
+    const clone = Object.assign({}, object);
+    Object.keys(clone).forEach((key) => {
+      if (typeof object[key] === "object" && !ArrayBuffer.isView(object[key]) && !(object[key] instanceof Array)) {
+        clone[key] = getTransferListForWriter(object[key]);
+      } else if (typeof clone[key] === "function" || clone[key] instanceof RegExp) {
+        clone[key] = {};
+      } else {
+        clone[key] = object[key];
+      }
+    });
+    return clone;
+  }
+
+  // ../worker-utils/src/lib/worker-farm/worker-thread.ts
+  var NOOP = () => {
+  };
+  var WorkerThread = class {
+    terminated = false;
+    _loadableURL = "";
+    static isSupported() {
+      return typeof Worker !== "undefined" && isBrowser || typeof NodeWorker !== "undefined" && !isBrowser;
+    }
+    constructor(props) {
+      const {
+        name,
+        source,
+        url
+      } = props;
+      assert(source || url);
+      this.name = name;
+      this.source = source;
+      this.url = url;
+      this.onMessage = NOOP;
+      this.onError = (error) => console.log(error);
+      this.worker = isBrowser ? this._createBrowserWorker() : this._createNodeWorker();
+    }
+    destroy() {
+      this.onMessage = NOOP;
+      this.onError = NOOP;
+      this.worker.terminate();
+      this.terminated = true;
+    }
+    get isRunning() {
+      return Boolean(this.onMessage);
+    }
+    postMessage(data, transferList) {
+      transferList = transferList || getTransferList(data);
+      this.worker.postMessage(data, transferList);
+    }
+    _getErrorFromErrorEvent(event) {
+      let message = "Failed to load ";
+      message += `worker ${this.name} from ${this.url}. `;
+      if (event.message) {
+        message += `${event.message} in `;
+      }
+      if (event.lineno) {
+        message += `:${event.lineno}:${event.colno}`;
+      }
+      return new Error(message);
+    }
+    _createBrowserWorker() {
+      this._loadableURL = getLoadableWorkerURL({
+        source: this.source,
+        url: this.url
+      });
+      const worker = new Worker(this._loadableURL, {
+        name: this.name
+      });
+      worker.onmessage = (event) => {
+        if (!event.data) {
+          this.onError(new Error("No data received"));
+        } else {
+          this.onMessage(event.data);
+        }
+      };
+      worker.onerror = (error) => {
+        this.onError(this._getErrorFromErrorEvent(error));
+        this.terminated = true;
+      };
+      worker.onmessageerror = (event) => console.error(event);
+      return worker;
+    }
+    _createNodeWorker() {
+      let worker;
+      if (this.url) {
+        const absolute = this.url.includes(":/") || this.url.startsWith("/");
+        const url = absolute ? this.url : `./${this.url}`;
+        worker = new NodeWorker(url, {
+          eval: false
+        });
+      } else if (this.source) {
+        worker = new NodeWorker(this.source, {
+          eval: true
+        });
+      } else {
+        throw new Error("no worker");
+      }
+      worker.on("message", (data) => {
+        this.onMessage(data);
+      });
+      worker.on("error", (error) => {
+        this.onError(error);
+      });
+      worker.on("exit", (code) => {
+      });
+      return worker;
+    }
+  };
+
+  // ../worker-utils/src/lib/worker-farm/worker-pool.ts
+  var WorkerPool = class {
+    name = "unnamed";
+    maxConcurrency = 1;
+    maxMobileConcurrency = 1;
+    onDebug = () => {
+    };
+    reuseWorkers = true;
+    props = {};
+    jobQueue = [];
+    idleQueue = [];
+    count = 0;
+    isDestroyed = false;
+    static isSupported() {
+      return WorkerThread.isSupported();
+    }
+    constructor(props) {
+      this.source = props.source;
+      this.url = props.url;
+      this.setProps(props);
+    }
+    destroy() {
+      this.idleQueue.forEach((worker) => worker.destroy());
+      this.isDestroyed = true;
+    }
+    setProps(props) {
+      this.props = {
+        ...this.props,
+        ...props
+      };
+      if (props.name !== void 0) {
+        this.name = props.name;
+      }
+      if (props.maxConcurrency !== void 0) {
+        this.maxConcurrency = props.maxConcurrency;
+      }
+      if (props.maxMobileConcurrency !== void 0) {
+        this.maxMobileConcurrency = props.maxMobileConcurrency;
+      }
+      if (props.reuseWorkers !== void 0) {
+        this.reuseWorkers = props.reuseWorkers;
+      }
+      if (props.onDebug !== void 0) {
+        this.onDebug = props.onDebug;
+      }
+    }
+    async startJob(name, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
+      const startPromise = new Promise((onStart) => {
+        this.jobQueue.push({
+          name,
+          onMessage: onMessage2,
+          onError,
+          onStart
+        });
+        return this;
+      });
+      this._startQueuedJob();
+      return await startPromise;
+    }
+    async _startQueuedJob() {
+      if (!this.jobQueue.length) {
+        return;
+      }
+      const workerThread = this._getAvailableWorker();
+      if (!workerThread) {
+        return;
+      }
+      const queuedJob = this.jobQueue.shift();
+      if (queuedJob) {
+        this.onDebug({
+          message: "Starting job",
+          name: queuedJob.name,
+          workerThread,
+          backlog: this.jobQueue.length
+        });
+        const job = new WorkerJob(queuedJob.name, workerThread);
+        workerThread.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload);
+        workerThread.onError = (error) => queuedJob.onError(job, error);
+        queuedJob.onStart(job);
+        try {
+          await job.result;
+        } catch (error) {
+          console.error(`Worker exception: ${error}`);
+        } finally {
+          this.returnWorkerToQueue(workerThread);
+        }
+      }
+    }
+    returnWorkerToQueue(worker) {
+      const shouldDestroyWorker = !isBrowser || this.isDestroyed || !this.reuseWorkers || this.count > this._getMaxConcurrency();
+      if (shouldDestroyWorker) {
+        worker.destroy();
+        this.count--;
+      } else {
+        this.idleQueue.push(worker);
+      }
+      if (!this.isDestroyed) {
+        this._startQueuedJob();
+      }
+    }
+    _getAvailableWorker() {
+      if (this.idleQueue.length > 0) {
+        return this.idleQueue.shift() || null;
+      }
+      if (this.count < this._getMaxConcurrency()) {
+        this.count++;
+        const name = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`;
+        return new WorkerThread({
+          name,
+          source: this.source,
+          url: this.url
+        });
+      }
+      return null;
+    }
+    _getMaxConcurrency() {
+      return isMobile ? this.maxMobileConcurrency : this.maxConcurrency;
+    }
+  };
+
+  // ../worker-utils/src/lib/worker-farm/worker-farm.ts
+  var DEFAULT_PROPS = {
+    maxConcurrency: 3,
+    maxMobileConcurrency: 1,
+    reuseWorkers: true,
+    onDebug: () => {
+    }
+  };
+  var WorkerFarm = class {
+    workerPools = /* @__PURE__ */ new Map();
+    static isSupported() {
+      return WorkerThread.isSupported();
+    }
+    static getWorkerFarm(props = {}) {
+      WorkerFarm._workerFarm = WorkerFarm._workerFarm || new WorkerFarm({});
+      WorkerFarm._workerFarm.setProps(props);
+      return WorkerFarm._workerFarm;
+    }
+    constructor(props) {
+      this.props = {
+        ...DEFAULT_PROPS
+      };
+      this.setProps(props);
+      this.workerPools = /* @__PURE__ */ new Map();
+    }
+    destroy() {
+      for (const workerPool of this.workerPools.values()) {
+        workerPool.destroy();
+      }
+      this.workerPools = /* @__PURE__ */ new Map();
+    }
+    setProps(props) {
+      this.props = {
+        ...this.props,
+        ...props
+      };
+      for (const workerPool of this.workerPools.values()) {
+        workerPool.setProps(this._getWorkerPoolProps());
+      }
+    }
+    getWorkerPool(options) {
+      const {
+        name,
+        source,
+        url
+      } = options;
+      let workerPool = this.workerPools.get(name);
+      if (!workerPool) {
+        workerPool = new WorkerPool({
+          name,
+          source,
+          url
+        });
+        workerPool.setProps(this._getWorkerPoolProps());
+        this.workerPools.set(name, workerPool);
+      }
+      return workerPool;
+    }
+    _getWorkerPoolProps() {
+      return {
+        maxConcurrency: this.props.maxConcurrency,
+        maxMobileConcurrency: this.props.maxMobileConcurrency,
+        reuseWorkers: this.props.reuseWorkers,
+        onDebug: this.props.onDebug
+      };
+    }
+  };
+
+  // ../worker-utils/src/lib/worker-api/get-worker-url.ts
+  function getWorkerName(worker) {
+    const warning = worker.version !== VERSION3 ? ` (worker-utils@${VERSION3})` : "";
+    return `${worker.name}@${worker.version}${warning}`;
+  }
+  function getWorkerURL(worker, options = {}) {
+    const workerOptions = options[worker.id] || {};
+    const workerFile = isBrowser ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`;
+    let url = workerOptions.workerUrl;
+    if (!url && worker.id === "compression") {
+      url = options.workerUrl;
+    }
+    if (options._workerType === "test") {
+      if (isBrowser) {
+        url = `modules/${worker.module}/dist/${workerFile}`;
+      } else {
+        url = `modules/${worker.module}/src/workers/${worker.id}-worker-node.ts`;
+      }
+    }
+    if (!url) {
+      let version = worker.version;
+      if (version === "latest") {
+        version = NPM_TAG;
+      }
+      const versionTag = version ? `@${version}` : "";
+      url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
+    }
+    assert(url);
+    return url;
+  }
+
+  // ../worker-utils/src/lib/worker-api/process-on-worker.ts
+  async function processOnWorker(worker, data, options = {}, context = {}) {
+    const name = getWorkerName(worker);
+    const workerFarm = WorkerFarm.getWorkerFarm(options);
+    const {
+      source
+    } = options;
+    const workerPoolProps = {
+      name,
+      source
+    };
+    if (!source) {
+      workerPoolProps.url = getWorkerURL(worker, options);
+    }
+    const workerPool = workerFarm.getWorkerPool(workerPoolProps);
+    const jobName = options.jobName || worker.name;
+    const job = await workerPool.startJob(jobName, onMessage.bind(null, context));
+    const transferableOptions = getTransferListForWriter(options);
+    job.postMessage("process", {
+      input: data,
+      options: transferableOptions
+    });
+    const result = await job.result;
+    return result.result;
+  }
+  async function onMessage(context, job, type, payload) {
+    switch (type) {
+      case "done":
+        job.done(payload);
+        break;
+      case "error":
+        job.error(new Error(payload.error));
+        break;
+      case "process":
+        const {
+          id,
+          input,
+          options
+        } = payload;
+        try {
+          if (!context.process) {
+            job.postMessage("error", {
+              id,
+              error: "Worker not set up to process on main thread"
+            });
+            return;
+          }
+          const result = await context.process(input, options);
+          job.postMessage("done", {
+            id,
+            result
+          });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "unknown error";
+          job.postMessage("error", {
+            id,
+            error: message
+          });
+        }
+        break;
+      default:
+        console.warn(`process-on-worker: unknown message ${type}`);
+    }
+  }
+
+  // src/triangulate-on-worker.ts
+  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var TriangulationWorker = {
+    id: "triangulation",
+    name: "Triangulate",
+    module: "arrow",
+    version: VERSION4,
+    options: {}
+  };
+  function triangulateOnWorker(data, options = {}) {
+    return processOnWorker(TriangulationWorker, data, options);
+  }
+
   // src/index.ts
   TableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;
-  var ArrowLoader2 = {
-    ...ArrowLoader,
-    parse: async (arraybuffer, options) => parseArrowSync(arraybuffer, options),
-    parseSync: parseArrowSync,
-    parseInBatches: parseArrowInBatches
-  };
   return __toCommonJS(src_exports);
 })();
       return __exports__;