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

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,6 +12409,29 @@ 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/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 {
+      shape: "columnar-table",
+      schema: table.schema,
+      data: columnarTable
+    };
+  }
+
   // src/schema/convert-arrow-schema.ts
   function serializeArrowSchema(arrowSchema) {
     return {
@@ -12739,12 +12691,75 @@ 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/parsers/parse-arrow-sync.ts
+  function parseArrowSync(arrayBuffer, options) {
+    const apacheArrowTable = tableFromIPC([new Uint8Array(arrayBuffer)]);
+    const arrowTable = {
+      shape: "arrow-table",
+      schema: serializeArrowSchema(apacheArrowTable.schema),
+      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);
+    }
+  }
+
+  // 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();
+  }
+
+  // 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) {
@@ -12786,101 +12801,879 @@ return true;`);
     }
   };
 
-  // src/geoarrow/get-arrow-bounds.ts
-  function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds, sampleSize = 100) {
-    const numberOfFeatures = flatCoords.length / nDim;
-    const sampleStep = Math.max(Math.floor(numberOfFeatures / sampleSize), 1);
-    const newBounds = [...bounds];
-    for (let i = 0; i < numberOfFeatures; i += sampleStep) {
-      const lng = flatCoords[i * nDim];
-      const lat = flatCoords[i * nDim + 1];
-      if (lng < newBounds[0]) {
-        newBounds[0] = lng;
+  // ../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;
       }
-      if (lat < newBounds[1]) {
-        newBounds[1] = lat;
+    }
+    return geometryColumns;
+  }
+  function getGeometryMetadataForField(field) {
+    let metadata = null;
+    let geoEncoding = field.metadata?.[GEOARROW_COLUMN_METADATA_ENCODING];
+    if (geoEncoding) {
+      geoEncoding = geoEncoding.toLowerCase();
+      if (geoEncoding === "wkb") {
+        geoEncoding = "geoarrow.wkb";
       }
-      if (lng > newBounds[2]) {
-        newBounds[2] = lng;
+      if (geoEncoding === "wkt") {
+        geoEncoding = "geoarrow.wkt";
       }
-      if (lat > newBounds[3]) {
-        newBounds[3] = lat;
+      if (!GEOARROW_ENCODINGS.includes(geoEncoding)) {
+        console.warn(`Invalid GeoArrow encoding: ${geoEncoding}`);
+      } else {
+        metadata = metadata || {};
+        metadata.encoding = geoEncoding;
       }
     }
-    return newBounds;
+    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);
+      }
+    }
+    return metadata || null;
   }
 
-  // src/geoarrow/convert-geoarrow-to-binary-geometry.ts
-  var BINARY_GEOMETRY_TEMPLATE = {
-    globalFeatureIds: {
-      value: new Uint32Array(0),
-      size: 1
-    },
-    positions: {
-      value: new Float32Array(0),
-      size: 2
-    },
-    properties: [],
-    numericProps: {},
-    featureIds: {
-      value: new Uint32Array(0),
-      size: 1
+  // ../../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.");
     }
-  };
-  function getBinaryGeometriesFromArrow(geoColumn, geoEncoding) {
-    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;
-    let bounds = [Infinity, Infinity, -Infinity, -Infinity];
-    let globalFeatureIdOffset = 0;
-    const binaryGeometries = [];
-    chunks.forEach((chunk) => {
-      const {
-        featureIds,
-        flatCoordinateArray,
-        nDim,
-        geomOffset
-      } = getBinaryGeometriesFromChunk(chunk, geoEncoding);
-      const globalFeatureIds = new Uint32Array(featureIds.length);
-      for (let i = 0; i < featureIds.length; i++) {
-        globalFeatureIds[i] = featureIds[i] + globalFeatureIdOffset;
+    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;
       }
-      const binaryContent = {
-        globalFeatureIds: {
-          value: globalFeatureIds,
-          size: 1
-        },
-        positions: {
-          value: flatCoordinateArray,
-          size: nDim
-        },
-        featureIds: {
-          value: featureIds,
-          size: 1
-        },
-        properties: [...Array(chunk.length).keys()].map((i) => ({
-          index: i + globalFeatureIdOffset
-        }))
-      };
-      globalFeatureIdOffset += chunk.length;
-      binaryGeometries.push({
-        shape: "binary-feature-collection",
-        points: {
-          type: "Point",
-          ...BINARY_GEOMETRY_TEMPLATE,
-          ...featureTypes.point ? binaryContent : {}
-        },
-        lines: {
-          type: "LineString",
-          ...BINARY_GEOMETRY_TEMPLATE,
-          ...featureTypes.line ? binaryContent : {},
-          pathIndices: {
-            value: featureTypes.line ? geomOffset : new Uint16Array(0),
-            size: 1
-          }
+    } 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;
+    }
+  };
+
+  // ../gis/src/lib/binary-features/binary-to-geojson.ts
+  function binaryToGeometry(data, startIndex, endIndex) {
+    switch (data.type) {
+      case "Point":
+        return pointToGeoJson(data, startIndex, endIndex);
+      case "LineString":
+        return lineStringToGeoJson(data, startIndex, endIndex);
+      case "Polygon":
+        return polygonToGeoJson(data, startIndex, endIndex);
+      default:
+        const unexpectedInput = data;
+        throw new Error(`Unsupported geometry type: ${unexpectedInput?.type}`);
+    }
+  }
+  function polygonToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
+    const {
+      positions
+    } = data;
+    const polygonIndices = data.polygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+    const primitivePolygonIndices = data.primitivePolygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+    const multi = polygonIndices.length > 2;
+    if (!multi) {
+      const coordinates2 = [];
+      for (let i = 0; i < primitivePolygonIndices.length - 1; i++) {
+        const startRingIndex = primitivePolygonIndices[i];
+        const endRingIndex = primitivePolygonIndices[i + 1];
+        const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
+        coordinates2.push(ringCoordinates);
+      }
+      return {
+        type: "Polygon",
+        coordinates: coordinates2
+      };
+    }
+    const coordinates = [];
+    for (let i = 0; i < polygonIndices.length - 1; i++) {
+      const startPolygonIndex = polygonIndices[i];
+      const endPolygonIndex = polygonIndices[i + 1];
+      const polygonCoordinates = polygonToGeoJson(data, startPolygonIndex, endPolygonIndex).coordinates;
+      coordinates.push(polygonCoordinates);
+    }
+    return {
+      type: "MultiPolygon",
+      coordinates
+    };
+  }
+  function lineStringToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
+    const {
+      positions
+    } = data;
+    const pathIndices = data.pathIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+    const multi = pathIndices.length > 2;
+    if (!multi) {
+      const coordinates2 = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);
+      return {
+        type: "LineString",
+        coordinates: coordinates2
+      };
+    }
+    const coordinates = [];
+    for (let i = 0; i < pathIndices.length - 1; i++) {
+      const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
+      coordinates.push(ringCoordinates);
+    }
+    return {
+      type: "MultiLineString",
+      coordinates
+    };
+  }
+  function pointToGeoJson(data, startIndex, endIndex) {
+    const {
+      positions
+    } = data;
+    const coordinates = ringToGeoJson(positions, startIndex, endIndex);
+    const multi = coordinates.length > 1;
+    if (multi) {
+      return {
+        type: "MultiPoint",
+        coordinates
+      };
+    }
+    return {
+      type: "Point",
+      coordinates: coordinates[0]
+    };
+  }
+  function ringToGeoJson(positions, startIndex, endIndex) {
+    startIndex = startIndex || 0;
+    endIndex = endIndex || positions.value.length / positions.size;
+    const ringCoordinates = [];
+    for (let j = startIndex; j < endIndex; j++) {
+      const coord = Array();
+      for (let k = j * positions.size; k < (j + 1) * positions.size; k++) {
+        coord.push(Number(positions.value[k]));
+      }
+      ringCoordinates.push(coord);
+    }
+    return ringCoordinates;
+  }
+
+  // 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 = [];
+    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?.get(row);
+      const feature = parseGeometryFromArrow(arrowGeometry, encoding);
+      if (feature) {
+        const properties = propertiesTable.get(row)?.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?.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/geoarrow/get-arrow-bounds.ts
+  function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds, sampleSize = 100) {
+    const numberOfFeatures = flatCoords.length / nDim;
+    const sampleStep = Math.max(Math.floor(numberOfFeatures / sampleSize), 1);
+    const newBounds = [...bounds];
+    for (let i = 0; i < numberOfFeatures; i += sampleStep) {
+      const lng = flatCoords[i * nDim];
+      const lat = flatCoords[i * nDim + 1];
+      if (lng < newBounds[0]) {
+        newBounds[0] = lng;
+      }
+      if (lat < newBounds[1]) {
+        newBounds[1] = lat;
+      }
+      if (lng > newBounds[2]) {
+        newBounds[2] = lng;
+      }
+      if (lat > newBounds[3]) {
+        newBounds[3] = lat;
+      }
+    }
+    return newBounds;
+  }
+
+  // src/geoarrow/convert-geoarrow-to-binary-geometry.ts
+  var BinaryGeometryType = function(BinaryGeometryType2) {
+    BinaryGeometryType2["points"] = "points";
+    BinaryGeometryType2["lines"] = "lines";
+    BinaryGeometryType2["polygons"] = "polygons";
+    return BinaryGeometryType2;
+  }(BinaryGeometryType || {});
+  var BINARY_GEOMETRY_TEMPLATE = {
+    globalFeatureIds: {
+      value: new Uint32Array(0),
+      size: 1
+    },
+    positions: {
+      value: new Float32Array(0),
+      size: 2
+    },
+    properties: [],
+    numericProps: {},
+    featureIds: {
+      value: new Uint32Array(0),
+      size: 1
+    }
+  };
+  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 = options?.chunkIndex ? [geoColumn.data[options?.chunkIndex]] : geoColumn.data;
+    let bounds = [Infinity, Infinity, -Infinity, -Infinity];
+    let globalFeatureIdOffset = 0;
+    const binaryGeometries = [];
+    chunks.forEach((chunk) => {
+      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;
+      }
+      const binaryContent = {
+        globalFeatureIds: {
+          value: globalFeatureIds,
+          size: 1
+        },
+        positions: {
+          value: flatCoordinateArray,
+          size: nDim
+        },
+        featureIds: {
+          value: featureIds,
+          size: 1
+        },
+        properties: [...Array(chunk.length).keys()].map((i) => ({
+          index: i + globalFeatureIdOffset
+        }))
+      };
+      globalFeatureIdOffset += chunk.length;
+      binaryGeometries.push({
+        shape: "binary-feature-collection",
+        points: {
+          type: "Point",
+          ...BINARY_GEOMETRY_TEMPLATE,
+          ...featureTypes.point ? binaryContent : {}
+        },
+        lines: {
+          type: "LineString",
+          ...BINARY_GEOMETRY_TEMPLATE,
+          ...featureTypes.line ? binaryContent : {},
+          pathIndices: {
+            value: featureTypes.line ? geomOffset : new Uint16Array(0),
+            size: 1
+          }
         },
         polygons: {
           type: "Polygon",
@@ -12893,7 +13686,13 @@ return true;`);
           primitivePolygonIndices: {
             value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
             size: 1
-          }
+          },
+          ...triangles ? {
+            triangles: {
+              value: triangles,
+              size: 1
+            }
+          } : {}
         }
       });
       bounds = updateBoundsFromGeoArrowSamples(flatCoordinateArray, nDim, bounds);
@@ -12901,10 +13700,66 @@ return true;`);
     return {
       binaryGeometries,
       bounds,
-      featureTypes
+      featureTypes,
+      ...options?.calculateMeanCenters ? {
+        meanCenters: getMeanCentersFromBinaryGeometries(binaryGeometries)
+      } : {}
     };
   }
-  function getBinaryGeometriesFromChunk(chunk, geoEncoding) {
+  function getMeanCentersFromBinaryGeometries(binaryGeometries) {
+    const globalMeanCenters = [];
+    binaryGeometries.forEach((binaryGeometry) => {
+      let binaryGeometryType = null;
+      if (binaryGeometry.points && binaryGeometry.points.positions.value.length > 0) {
+        binaryGeometryType = BinaryGeometryType.points;
+      } else if (binaryGeometry.lines && binaryGeometry.lines.positions.value.length > 0) {
+        binaryGeometryType = BinaryGeometryType.lines;
+      } else if (binaryGeometry.polygons && binaryGeometry.polygons.positions.value.length > 0) {
+        binaryGeometryType = 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.type === "Polygon" ? binaryContent.primitivePolygonIndices?.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 === BinaryGeometryType.polygons && 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, options) {
     switch (geoEncoding) {
       case "geoarrow.point":
       case "geoarrow.multipoint":
@@ -12914,12 +13769,44 @@ return true;`);
         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 = 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;
@@ -12943,98 +13830,788 @@ return true;`);
         featureIds[j] = i;
       }
     }
+    const triangles = options?.triangulate ? getTriangleIndices(geometryIndicies, geomOffset, flatCoordinateArray, nDim) : null;
+    return {
+      featureIds,
+      flatCoordinateArray,
+      nDim,
+      geomOffset,
+      geometryIndicies,
+      ...options?.triangulate && triangles ? {
+        triangles
+      } : {}
+    };
+  }
+  function getBinaryLinesFromChunk(chunk, geoEncoding) {
+    const isMultiLineString = geoEncoding === "geoarrow.multilinestring";
+    const lineData = isMultiLineString ? chunk.children[0] : chunk;
+    const pointData = lineData.children[0];
+    const coordData = pointData.children[0];
+    const nDim = pointData.stride;
+    const geomOffset = lineData.valueOffsets;
+    const flatCoordinateArray = coordData.values;
+    const geometryIndicies = new Uint16Array(0);
+    const numOfVertices = flatCoordinateArray.length / nDim;
+    const featureIds = new Uint32Array(numOfVertices);
+    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 {
+      featureIds,
+      flatCoordinateArray,
+      nDim,
+      geomOffset,
+      geometryIndicies
+    };
+  }
+  function getBinaryPointsFromChunk(chunk, geoEncoding) {
+    const isMultiPoint = geoEncoding === "geoarrow.multipoint";
+    const pointData = isMultiPoint ? chunk.children[0] : chunk;
+    const coordData = pointData.children[0];
+    const nDim = pointData.stride;
+    const flatCoordinateArray = coordData.values;
+    const geometryIndicies = new Uint16Array(0);
+    const geomOffset = new Int32Array(0);
+    const numOfVertices = flatCoordinateArray.length / nDim;
+    const featureIds = new Uint32Array(numOfVertices);
+    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,
+      flatCoordinateArray,
+      nDim,
+      geomOffset,
+      geometryIndicies
+    };
+  }
+
+  // ../wkt/src/lib/utils/version.ts
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+
+  // ../wkt/src/lib/parse-wkt.ts
+  var numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
+  var tuples = new RegExp("^" + numberRegexp.source + "(\\s" + numberRegexp.source + "){1,}");
+  var WKT_MAGIC_STRINGS = ["POINT(", "LINESTRING(", "POLYGON(", "MULTIPOINT(", "MULTILINESTRING(", "MULTIPOLYGON(", "GEOMETRYCOLLECTION("];
+  function isWKT(input) {
+    return WKT_MAGIC_STRINGS.some((magicString) => input.startsWith(magicString));
+  }
+  function parseWKT(input, options) {
+    return parseWKTToGeometry(input, options);
+  }
+  function parseWKTToGeometry(input, options) {
+    const parts = input.split(";");
+    let _ = parts.pop();
+    const srid = (parts.shift() || "").split("=").pop();
+    const state = {
+      parts,
+      _,
+      i: 0
+    };
+    const geometry = parseGeometry(state);
+    return options?.wkt?.crs ? addCRS(geometry, srid) : geometry;
+  }
+  function parseGeometry(state) {
+    return parsePoint(state) || parseLineString(state) || parsePolygon(state) || parseMultiPoint(state) || parseMultiLineString(state) || parseMultiPolygon(state) || parseGeometryCollection(state);
+  }
+  function addCRS(obj, srid) {
+    if (obj && srid?.match(/\d+/)) {
+      const crs = {
+        type: "name",
+        properties: {
+          name: "urn:ogc:def:crs:EPSG::" + srid
+        }
+      };
+      obj.crs = crs;
+    }
+    return obj;
+  }
+  function parsePoint(state) {
+    if (!$(/^(POINT(\sz)?)/i, state)) {
+      return null;
+    }
+    white(state);
+    if (!$(/^(\()/, state)) {
+      return null;
+    }
+    const c = coords(state);
+    if (!c) {
+      return null;
+    }
+    white(state);
+    if (!$(/^(\))/, state)) {
+      return null;
+    }
+    return {
+      type: "Point",
+      coordinates: c[0]
+    };
+  }
+  function parseMultiPoint(state) {
+    if (!$(/^(MULTIPOINT)/i, state)) {
+      return null;
+    }
+    white(state);
+    const newCoordsFormat = state._?.substring(state._?.indexOf("(") + 1, state._.length - 1).replace(/\(/g, "").replace(/\)/g, "");
+    state._ = "MULTIPOINT (" + newCoordsFormat + ")";
+    const c = multicoords(state);
+    if (!c) {
+      return null;
+    }
+    white(state);
+    return {
+      type: "MultiPoint",
+      coordinates: c
+    };
+  }
+  function parseLineString(state) {
+    if (!$(/^(LINESTRING(\sz)?)/i, state)) {
+      return null;
+    }
+    white(state);
+    if (!$(/^(\()/, state)) {
+      return null;
+    }
+    const c = coords(state);
+    if (!c) {
+      return null;
+    }
+    if (!$(/^(\))/, state)) {
+      return null;
+    }
+    return {
+      type: "LineString",
+      coordinates: c
+    };
+  }
+  function parseMultiLineString(state) {
+    if (!$(/^(MULTILINESTRING)/i, state))
+      return null;
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+      return null;
+    }
+    white(state);
+    return {
+      type: "MultiLineString",
+      coordinates: c
+    };
+  }
+  function parsePolygon(state) {
+    if (!$(/^(POLYGON(\sz)?)/i, state)) {
+      return null;
+    }
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+      return null;
+    }
+    return {
+      type: "Polygon",
+      coordinates: c
+    };
+  }
+  function parseMultiPolygon(state) {
+    if (!$(/^(MULTIPOLYGON)/i, state)) {
+      return null;
+    }
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+      return null;
+    }
+    return {
+      type: "MultiPolygon",
+      coordinates: c
+    };
+  }
+  function parseGeometryCollection(state) {
+    const geometries = [];
+    let geometry;
+    if (!$(/^(GEOMETRYCOLLECTION)/i, state)) {
+      return null;
+    }
+    white(state);
+    if (!$(/^(\()/, state)) {
+      return null;
+    }
+    while (geometry = parseGeometry(state)) {
+      geometries.push(geometry);
+      white(state);
+      $(/^(,)/, state);
+      white(state);
+    }
+    if (!$(/^(\))/, state)) {
+      return null;
+    }
+    return {
+      type: "GeometryCollection",
+      geometries
+    };
+  }
+  function multicoords(state) {
+    white(state);
+    let depth = 0;
+    const rings = [];
+    const stack = [rings];
+    let pointer = rings;
+    let elem;
+    while (elem = $(/^(\()/, state) || $(/^(\))/, state) || $(/^(,)/, state) || $(tuples, state)) {
+      if (elem === "(") {
+        stack.push(pointer);
+        pointer = [];
+        stack[stack.length - 1].push(pointer);
+        depth++;
+      } else if (elem === ")") {
+        if (pointer.length === 0)
+          return null;
+        pointer = stack.pop();
+        if (!pointer)
+          return null;
+        depth--;
+        if (depth === 0)
+          break;
+      } else if (elem === ",") {
+        pointer = [];
+        stack[stack.length - 1].push(pointer);
+      } else if (!elem.split(/\s/g).some(isNaN)) {
+        Array.prototype.push.apply(pointer, elem.split(/\s/g).map(parseFloat));
+      } else {
+        return null;
+      }
+      white(state);
+    }
+    if (depth !== 0)
+      return null;
+    return rings;
+  }
+  function coords(state) {
+    const list = [];
+    let item;
+    let pt;
+    while (pt = $(tuples, state) || $(/^(,)/, state)) {
+      if (pt === ",") {
+        list.push(item);
+        item = [];
+      } else if (!pt.split(/\s/g).some(isNaN)) {
+        if (!item)
+          item = [];
+        Array.prototype.push.apply(item, pt.split(/\s/g).map(parseFloat));
+      }
+      white(state);
+    }
+    if (item)
+      list.push(item);
+    else
+      return null;
+    return list.length ? list : null;
+  }
+  function $(regexp, state) {
+    const match = state._?.substring(state.i).match(regexp);
+    if (!match)
+      return null;
+    else {
+      state.i += match[0].length;
+      return match[0];
+    }
+  }
+  function white(state) {
+    $(/^\s*/, state);
+  }
+
+  // ../wkt/src/wkt-loader.ts
+  var WKTWorkerLoader = {
+    name: "WKT (Well-Known Text)",
+    id: "wkt",
+    module: "wkt",
+    version: VERSION3,
+    worker: true,
+    extensions: ["wkt"],
+    mimeTypes: ["text/plain"],
+    category: "geometry",
+    text: true,
+    tests: WKT_MAGIC_STRINGS,
+    testText: isWKT,
+    options: {
+      wkt: {
+        shape: "geojson-geometry",
+        crs: true
+      }
+    }
+  };
+  var WKTLoader = {
+    ...WKTWorkerLoader,
+    parse: async (arrayBuffer, options) => parseWKT(new TextDecoder().decode(arrayBuffer), options),
+    parseTextSync: parseWKT
+  };
+
+  // ../wkt/src/lib/parse-wkb-header.ts
+  var EWKB_FLAG_Z = 2147483648;
+  var EWKB_FLAG_M = 1073741824;
+  var EWKB_FLAG_SRID = 536870912;
+  var MAX_SRID = 1e4;
+  var WKBGeometryType = function(WKBGeometryType2) {
+    WKBGeometryType2[WKBGeometryType2["Point"] = 1] = "Point";
+    WKBGeometryType2[WKBGeometryType2["LineString"] = 2] = "LineString";
+    WKBGeometryType2[WKBGeometryType2["Polygon"] = 3] = "Polygon";
+    WKBGeometryType2[WKBGeometryType2["MultiPoint"] = 4] = "MultiPoint";
+    WKBGeometryType2[WKBGeometryType2["MultiLineString"] = 5] = "MultiLineString";
+    WKBGeometryType2[WKBGeometryType2["MultiPolygon"] = 6] = "MultiPolygon";
+    WKBGeometryType2[WKBGeometryType2["GeometryCollection"] = 7] = "GeometryCollection";
+    return WKBGeometryType2;
+  }({});
+  function isWKB(arrayBuffer) {
+    const dataView = new DataView(arrayBuffer);
+    let byteOffset = 0;
+    const endianness = dataView.getUint8(byteOffset);
+    byteOffset += 1;
+    if (endianness > 1) {
+      return false;
+    }
+    const littleEndian = endianness === 1;
+    const geometry = dataView.getUint32(byteOffset, littleEndian);
+    byteOffset += 4;
+    const geometryType = geometry & 7;
+    if (geometryType === 0 || geometryType > 7) {
+      return false;
+    }
+    const geometryFlags = geometry - geometryType;
+    if (geometryFlags === 0 || geometryFlags === 1e3 || geometryFlags === 2e3 || geometryFlags === 3e3) {
+      return true;
+    }
+    if ((geometryFlags & ~(EWKB_FLAG_Z | EWKB_FLAG_M | EWKB_FLAG_SRID)) !== 0) {
+      return false;
+    }
+    if (geometryFlags & EWKB_FLAG_SRID) {
+      const srid = dataView.getUint32(byteOffset, littleEndian);
+      byteOffset += 4;
+      if (srid > MAX_SRID) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function parseWKBHeader(dataView, target) {
+    const wkbHeader = Object.assign(target || {}, {
+      type: "wkb",
+      geometryType: 1,
+      dimensions: 2,
+      coordinates: "xy",
+      littleEndian: true,
+      byteOffset: 0
+    });
+    wkbHeader.littleEndian = dataView.getUint8(wkbHeader.byteOffset) === 1;
+    wkbHeader.byteOffset++;
+    const geometryCode = dataView.getUint32(wkbHeader.byteOffset, wkbHeader.littleEndian);
+    wkbHeader.byteOffset += 4;
+    wkbHeader.geometryType = geometryCode & 7;
+    const isoType = (geometryCode - wkbHeader.geometryType) / 1e3;
+    switch (isoType) {
+      case 0:
+        break;
+      case 1:
+        wkbHeader.type = "iso-wkb";
+        wkbHeader.dimensions = 3;
+        wkbHeader.coordinates = "xyz";
+        break;
+      case 2:
+        wkbHeader.type = "iso-wkb";
+        wkbHeader.dimensions = 3;
+        wkbHeader.coordinates = "xym";
+        break;
+      case 3:
+        wkbHeader.type = "iso-wkb";
+        wkbHeader.dimensions = 4;
+        wkbHeader.coordinates = "xyzm";
+        break;
+      default:
+        throw new Error(`WKB: Unsupported iso-wkb type: ${isoType}`);
+    }
+    const ewkbZ = geometryCode & EWKB_FLAG_Z;
+    const ewkbM = geometryCode & EWKB_FLAG_M;
+    const ewkbSRID = geometryCode & EWKB_FLAG_SRID;
+    if (ewkbZ && ewkbM) {
+      wkbHeader.type = "ewkb";
+      wkbHeader.dimensions = 4;
+      wkbHeader.coordinates = "xyzm";
+    } else if (ewkbZ) {
+      wkbHeader.type = "ewkb";
+      wkbHeader.dimensions = 3;
+      wkbHeader.coordinates = "xyz";
+    } else if (ewkbM) {
+      wkbHeader.type = "ewkb";
+      wkbHeader.dimensions = 3;
+      wkbHeader.coordinates = "xym";
+    }
+    if (ewkbSRID) {
+      wkbHeader.type = "ewkb";
+      wkbHeader.srid = dataView.getUint32(wkbHeader.byteOffset, wkbHeader.littleEndian);
+      wkbHeader.byteOffset += 4;
+    }
+    return wkbHeader;
+  }
+
+  // ../wkt/src/lib/parse-wkb.ts
+  function parseWKB(arrayBuffer, options) {
+    const binaryGeometry = parseWKBToBinary(arrayBuffer, options);
+    const shape = options?.wkb?.shape || "binary-geometry";
+    switch (shape) {
+      case "binary-geometry":
+        return binaryGeometry;
+      case "geojson-geometry":
+        return binaryToGeometry(binaryGeometry);
+      case "geometry":
+        console.error('WKBLoader: "geometry" shape is deprecated, use "binary-geometry" instead');
+        return binaryToGeometry(binaryGeometry);
+      default:
+        throw new Error(shape);
+    }
+  }
+  function parseWKBToBinary(arrayBuffer, options) {
+    const dataView = new DataView(arrayBuffer);
+    const wkbHeader = parseWKBHeader(dataView);
+    const {
+      geometryType,
+      dimensions,
+      littleEndian
+    } = wkbHeader;
+    const offset = wkbHeader.byteOffset;
+    switch (geometryType) {
+      case WKBGeometryType.Point:
+        const point = parsePoint2(dataView, offset, dimensions, littleEndian);
+        return point.geometry;
+      case WKBGeometryType.LineString:
+        const line = parseLineString2(dataView, offset, dimensions, littleEndian);
+        return line.geometry;
+      case WKBGeometryType.Polygon:
+        const polygon = parsePolygon2(dataView, offset, dimensions, littleEndian);
+        return polygon.geometry;
+      case WKBGeometryType.MultiPoint:
+        const multiPoint = parseMultiPoint2(dataView, offset, dimensions, littleEndian);
+        multiPoint.type = "Point";
+        return multiPoint;
+      case WKBGeometryType.MultiLineString:
+        const multiLine = parseMultiLineString2(dataView, offset, dimensions, littleEndian);
+        multiLine.type = "LineString";
+        return multiLine;
+      case WKBGeometryType.MultiPolygon:
+        const multiPolygon = parseMultiPolygon2(dataView, offset, dimensions, littleEndian);
+        multiPolygon.type = "Polygon";
+        return multiPolygon;
+      default:
+        throw new Error(`WKB: Unsupported geometry type: ${geometryType}`);
+    }
+  }
+  function parsePoint2(dataView, offset, dimension, littleEndian) {
+    const positions = new Float64Array(dimension);
+    for (let i = 0; i < dimension; i++) {
+      positions[i] = dataView.getFloat64(offset, littleEndian);
+      offset += 8;
+    }
+    return {
+      geometry: {
+        type: "Point",
+        positions: {
+          value: positions,
+          size: dimension
+        }
+      },
+      offset
+    };
+  }
+  function parseLineString2(dataView, offset, dimension, littleEndian) {
+    const nPoints = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const positions = new Float64Array(nPoints * dimension);
+    for (let i = 0; i < nPoints * dimension; i++) {
+      positions[i] = dataView.getFloat64(offset, littleEndian);
+      offset += 8;
+    }
+    const pathIndices = [0];
+    if (nPoints > 0) {
+      pathIndices.push(nPoints);
+    }
     return {
-      featureIds,
-      flatCoordinateArray,
-      nDim,
-      geomOffset,
-      geometryIndicies
+      geometry: {
+        type: "LineString",
+        positions: {
+          value: positions,
+          size: dimension
+        },
+        pathIndices: {
+          value: new Uint16Array(pathIndices),
+          size: 1
+        }
+      },
+      offset
     };
   }
-  function getBinaryLinesFromChunk(chunk, geoEncoding) {
-    const isMultiLineString = geoEncoding === "geoarrow.multilinestring";
-    const lineData = isMultiLineString ? chunk.children[0] : chunk;
-    const pointData = lineData.children[0];
-    const coordData = pointData.children[0];
-    const nDim = pointData.stride;
-    const geomOffset = lineData.valueOffsets;
-    const flatCoordinateArray = coordData.values;
-    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;
+  var cumulativeSum = (sum2) => (value) => sum2 += value;
+  function parsePolygon2(dataView, offset, dimension, littleEndian) {
+    const nRings = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const rings = [];
+    for (let i = 0; i < nRings; i++) {
+      const parsed = parseLineString2(dataView, offset, dimension, littleEndian);
+      const {
+        positions
+      } = parsed.geometry;
+      offset = parsed.offset;
+      rings.push(positions.value);
+    }
+    const concatenatedPositions = new Float64Array(concatTypedArrays(rings).buffer);
+    const polygonIndices = [0];
+    if (concatenatedPositions.length > 0) {
+      polygonIndices.push(concatenatedPositions.length / dimension);
+    }
+    const primitivePolygonIndices = rings.map((l) => l.length / dimension).map(cumulativeSum(0));
+    primitivePolygonIndices.unshift(0);
+    return {
+      geometry: {
+        type: "Polygon",
+        positions: {
+          value: concatenatedPositions,
+          size: dimension
+        },
+        polygonIndices: {
+          value: new Uint16Array(polygonIndices),
+          size: 1
+        },
+        primitivePolygonIndices: {
+          value: new Uint16Array(primitivePolygonIndices),
+          size: 1
+        }
+      },
+      offset
+    };
+  }
+  function parseMultiPoint2(dataView, offset, dimension, littleEndian) {
+    const nPoints = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const binaryPointGeometries = [];
+    for (let i = 0; i < nPoints; i++) {
+      const littleEndianPoint = dataView.getUint8(offset) === 1;
+      offset++;
+      if (dataView.getUint32(offset, littleEndianPoint) % 1e3 !== 1) {
+        throw new Error("WKB: Inner geometries of MultiPoint not of type Point");
+      }
+      offset += 4;
+      const parsed = parsePoint2(dataView, offset, dimension, littleEndianPoint);
+      offset = parsed.offset;
+      binaryPointGeometries.push(parsed.geometry);
+    }
+    return concatenateBinaryPointGeometries(binaryPointGeometries, dimension);
+  }
+  function parseMultiLineString2(dataView, offset, dimension, littleEndian) {
+    const nLines = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const binaryLineGeometries = [];
+    for (let i = 0; i < nLines; i++) {
+      const littleEndianLine = dataView.getUint8(offset) === 1;
+      offset++;
+      if (dataView.getUint32(offset, littleEndianLine) % 1e3 !== 2) {
+        throw new Error("WKB: Inner geometries of MultiLineString not of type LineString");
+      }
+      offset += 4;
+      const parsed = parseLineString2(dataView, offset, dimension, littleEndianLine);
+      offset = parsed.offset;
+      binaryLineGeometries.push(parsed.geometry);
+    }
+    return concatenateBinaryLineGeometries(binaryLineGeometries, dimension);
+  }
+  function parseMultiPolygon2(dataView, offset, dimension, littleEndian) {
+    const nPolygons = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const binaryPolygonGeometries = [];
+    for (let i = 0; i < nPolygons; i++) {
+      const littleEndianPolygon = dataView.getUint8(offset) === 1;
+      offset++;
+      if (dataView.getUint32(offset, littleEndianPolygon) % 1e3 !== 3) {
+        throw new Error("WKB: Inner geometries of MultiPolygon not of type Polygon");
+      }
+      offset += 4;
+      const parsed = parsePolygon2(dataView, offset, dimension, littleEndianPolygon);
+      offset = parsed.offset;
+      binaryPolygonGeometries.push(parsed.geometry);
+    }
+    return concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension);
+  }
+  function concatenateBinaryPointGeometries(binaryPointGeometries, dimension) {
+    const positions = binaryPointGeometries.map((geometry) => geometry.positions.value);
+    const concatenatedPositions = new Float64Array(concatTypedArrays(positions).buffer);
+    return {
+      type: "Point",
+      positions: {
+        value: concatenatedPositions,
+        size: dimension
       }
-    }
+    };
+  }
+  function concatenateBinaryLineGeometries(binaryLineGeometries, dimension) {
+    const lines = binaryLineGeometries.map((geometry) => geometry.positions.value);
+    const concatenatedPositions = new Float64Array(concatTypedArrays(lines).buffer);
+    const pathIndices = lines.map((line) => line.length / dimension).map(cumulativeSum(0));
+    pathIndices.unshift(0);
     return {
-      featureIds,
-      flatCoordinateArray,
-      nDim,
-      geomOffset,
-      geometryIndicies
+      type: "LineString",
+      positions: {
+        value: concatenatedPositions,
+        size: dimension
+      },
+      pathIndices: {
+        value: new Uint16Array(pathIndices),
+        size: 1
+      }
     };
   }
-  function getBinaryPointsFromChunk(chunk, geoEncoding) {
-    const isMultiPoint = geoEncoding === "geoarrow.multipoint";
-    const pointData = isMultiPoint ? chunk.children[0] : chunk;
-    const coordData = pointData.children[0];
-    const nDim = pointData.stride;
-    const flatCoordinateArray = coordData.values;
-    const geometryIndicies = new Uint16Array(0);
-    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;
+  function concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension) {
+    const polygons = [];
+    const primitivePolygons = [];
+    for (const binaryPolygon of binaryPolygonGeometries) {
+      const {
+        positions,
+        primitivePolygonIndices: primitivePolygonIndices2
+      } = binaryPolygon;
+      polygons.push(positions.value);
+      primitivePolygons.push(primitivePolygonIndices2.value);
+    }
+    const concatenatedPositions = new Float64Array(concatTypedArrays(polygons).buffer);
+    const polygonIndices = polygons.map((p) => p.length / dimension).map(cumulativeSum(0));
+    polygonIndices.unshift(0);
+    const primitivePolygonIndices = [0];
+    for (const primitivePolygon of primitivePolygons) {
+      primitivePolygonIndices.push(...primitivePolygon.filter((x) => x > 0).map((x) => x + primitivePolygonIndices[primitivePolygonIndices.length - 1]));
     }
     return {
-      featureIds,
-      flatCoordinateArray,
-      nDim,
-      geomOffset,
-      geometryIndicies
+      type: "Polygon",
+      positions: {
+        value: concatenatedPositions,
+        size: dimension
+      },
+      polygonIndices: {
+        value: new Uint16Array(polygonIndices),
+        size: 1
+      },
+      primitivePolygonIndices: {
+        value: new Uint16Array(primitivePolygonIndices),
+        size: 1
+      }
     };
   }
+  function concatTypedArrays(arrays) {
+    let byteLength = 0;
+    for (let i = 0; i < arrays.length; ++i) {
+      byteLength += arrays[i].byteLength;
+    }
+    const buffer = new Uint8Array(byteLength);
+    let byteOffset = 0;
+    for (let i = 0; i < arrays.length; ++i) {
+      const data = new Uint8Array(arrays[i].buffer);
+      byteLength = data.length;
+      for (let j = 0; j < byteLength; ++j) {
+        buffer[byteOffset++] = data[j];
+      }
+    }
+    return buffer;
+  }
+
+  // ../wkt/src/wkb-loader.ts
+  var WKBWorkerLoader = {
+    name: "WKB",
+    id: "wkb",
+    module: "wkt",
+    version: VERSION3,
+    worker: true,
+    category: "geometry",
+    extensions: ["wkb"],
+    mimeTypes: [],
+    tests: [isWKB],
+    options: {
+      wkb: {
+        shape: "binary-geometry"
+      }
+    }
+  };
+  var WKBLoader = {
+    ...WKBWorkerLoader,
+    parse: async (arrayBuffer) => parseWKB(arrayBuffer),
+    parseSync: parseWKB
+  };
 
-  // src/geoarrow/convert-geoarrow-to-geojson.ts
-  function parseGeometryFromArrow(rawData) {
-    const encoding = rawData.encoding?.toLowerCase();
-    const data = rawData.data;
-    if (!encoding || !data) {
+  // src/geoarrow/convert-geoarrow-to-geojson-geometry.ts
+  function parseGeometryFromArrow(arrowCellValue, encoding) {
+    encoding = 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) {
+    const arrayBuffer = arrowCellValue.buffer.slice(arrowCellValue.byteOffset, arrowCellValue.byteOffset + arrowCellValue.byteLength);
+    const binaryGeometry = WKBLoader.parseSync?.(arrayBuffer);
+    const geometry = binaryToGeometry(binaryGeometry);
+    return geometry;
+  }
+  function arrowWKTToFeature(arrowCellValue) {
+    const string = arrowCellValue;
+    return WKTLoader.parseTextSync?.(string);
   }
   function arrowMultiPolygonToFeature(arrowMultiPolygon) {
     const multiPolygon = [];
@@ -13066,8 +14643,8 @@ return true;`);
       const ring = [];
       for (let j = 0; arrowRing && j < arrowRing.length; j++) {
         const arrowCoord = arrowRing.get(j);
-        const coords = Array.from(arrowCoord);
-        ring.push(coords);
+        const coords2 = Array.from(arrowCoord);
+        ring.push(coords2);
       }
       polygon.push(ring);
     }
@@ -13086,19 +14663,17 @@ return true;`);
         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 = [];
@@ -13108,42 +14683,597 @@ return true;`);
       for (let j = 0; arrowLineString && j < arrowLineString.length; j++) {
         const arrowCoord = arrowLineString.get(j);
         if (arrowCoord) {
-          const coords = Array.from(arrowCoord);
-          lineString.push(coords);
+          const coords2 = Array.from(arrowCoord);
+          lineString.push(coords2);
         }
       }
       multiLineString.push(lineString);
     }
-    const geometry = {
+    return {
       type: "MultiLineString",
       coordinates: multiLineString
     };
-    return geometry;
   }
   function arrowLineStringToFeature(arrowLineString) {
     const lineString = [];
     for (let i = 0; arrowLineString && i < arrowLineString.length; i++) {
       const arrowCoord = arrowLineString.get(i);
       if (arrowCoord) {
-        const coords = Array.from(arrowCoord);
-        lineString.push(coords);
+        const coords2 = Array.from(arrowCoord);
+        lineString.push(coords2);
       }
     }
-    const geometry = {
+    return {
       type: "LineString",
       coordinates: lineString
     };
-    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 VERSION4 = 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 !== VERSION4 ? ` (worker-utils@${VERSION4})` : "";
+    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 VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var TriangulationWorker = {
+    id: "triangulation",
+    name: "Triangulate",
+    module: "arrow",
+    version: VERSION5,
+    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__;