@loaders.gl/arrow 4.0.4 → 4.1.0-alpha.2

package/dist/dist.dev.js

@@ -30,7 +30,6 @@ var __exports__ = (() => {
     ArrowLoader: () => ArrowLoader,
     ArrowWorkerLoader: () => ArrowWorkerLoader,
     ArrowWriter: () => ArrowWriter,
-    BINARY_GEOMETRY_TEMPLATE: () => BINARY_GEOMETRY_TEMPLATE,
     GeoArrowLoader: () => GeoArrowLoader,
     GeoArrowWorkerLoader: () => GeoArrowWorkerLoader,
     TriangulationWorker: () => TriangulationWorker,
@@ -42,8 +41,11 @@ var __exports__ = (() => {
     deserializeArrowType: () => deserializeArrowType,
     getArrowType: () => getArrowType,
     getBinaryGeometriesFromArrow: () => getBinaryGeometriesFromArrow,
+    getBinaryGeometryTemplate: () => getBinaryGeometryTemplate,
     getMeanCentersFromBinaryGeometries: () => getMeanCentersFromBinaryGeometries,
     getTriangleIndices: () => getTriangleIndices,
+    hardClone: () => hardClone,
+    parseGeoArrowOnWorker: () => parseGeoArrowOnWorker,
     parseGeometryFromArrow: () => parseGeometryFromArrow,
     serializeArrowField: () => serializeArrowField,
     serializeArrowMetadata: () => serializeArrowMetadata,
@@ -12427,252 +12429,519 @@ return true;`);
     }
     return {
       shape: "columnar-table",
+      schema: table.schema,
       data: columnarTable
     };
   }
 
-  // src/parsers/parse-arrow-sync.ts
-  function parseArrowSync(arrayBuffer, options) {
-    const apacheArrowTable = tableFromIPC([new Uint8Array(arrayBuffer)]);
-    const arrowTable = {
-      shape: "arrow-table",
-      data: apacheArrowTable
+  // src/schema/convert-arrow-schema.ts
+  function serializeArrowSchema(arrowSchema) {
+    return {
+      fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
+      metadata: serializeArrowMetadata(arrowSchema.metadata)
     };
-    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) {
-    const vectors = {};
-    for (const arrayData of data) {
-      const arrayVector = createVector(arrayData.array, arrayData.type);
-      vectors[arrayData.name] = arrayVector;
-    }
-    const table = new Table(vectors);
-    const arrowBuffer = tableToIPC(table);
-    return arrowBuffer;
-  }
-  function createVector(array, type) {
-    switch (type) {
-      case VECTOR_TYPES.DATE:
-        return vectorFromArray(array);
-      case VECTOR_TYPES.FLOAT:
-      default:
-        return vectorFromArray(array);
-    }
-  }
-
-  // src/arrow-writer.ts
-  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-  var ArrowWriter = {
-    name: "Apache Arrow",
-    id: "arrow",
-    module: "arrow",
-    version: VERSION2,
-    extensions: ["arrow", "feather"],
-    mimeTypes: ["application/vnd.apache.arrow.file", "application/vnd.apache.arrow.stream", "application/octet-stream"],
-    binary: true,
-    options: {},
-    encode: async function encodeArrow(data, options) {
-      return encodeArrowSync(data);
-    },
-    encodeSync(data, options) {
-      return encodeArrowSync(data);
-    }
-  };
-
-  // ../gis/src/lib/geo/geoarrow-metadata.ts
-  var GEOARROW_ENCODINGS = ["geoarrow.multipolygon", "geoarrow.polygon", "geoarrow.multilinestring", "geoarrow.linestring", "geoarrow.multipoint", "geoarrow.point", "geoarrow.wkb", "geoarrow.wkt"];
-  var GEOARROW_COLUMN_METADATA_ENCODING = "ARROW:extension:name";
-  var GEOARROW_COLUMN_METADATA_METADATA = "ARROW:extension:metadata";
-  function getGeometryColumnsFromSchema(schema) {
-    const geometryColumns = {};
-    for (const field of schema.fields) {
-      const metadata = getGeometryMetadataForField(field);
-      if (metadata) {
-        geometryColumns[field.name] = metadata;
-      }
-    }
-    return geometryColumns;
-  }
-  function getGeometryMetadataForField(field) {
-    let metadata = null;
-    const columnMetadata = field.metadata?.[GEOARROW_COLUMN_METADATA_METADATA];
-    if (columnMetadata) {
-      try {
-        metadata = JSON.parse(columnMetadata);
-      } catch (error) {
-        console.warn("Failed to parse GeoArrow metadata", error);
-      }
-    }
-    let geoEncoding = field.metadata?.[GEOARROW_COLUMN_METADATA_ENCODING];
-    if (geoEncoding) {
-      geoEncoding = geoEncoding.toLowerCase();
-      if (!GEOARROW_ENCODINGS.includes(geoEncoding)) {
-        console.warn(`Invalid GeoArrow encoding: ${geoEncoding}`);
-      } else {
-        metadata = metadata || {};
-        metadata.encoding = geoEncoding;
-      }
-    }
-    return metadata || null;
   }
-
-  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
-  function _typeof(obj) {
-    "@babel/helpers - typeof";
-    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
-      return typeof obj2;
-    } : function(obj2) {
-      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
-    }, _typeof(obj);
+  function deserializeArrowSchema(schema) {
+    return new Schema2(schema.fields.map((field) => deserializeArrowField(field)), deserializeArrowMetadata(schema.metadata));
   }
-
-  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
-  function _toPrimitive(input, hint) {
-    if (_typeof(input) !== "object" || input === null)
-      return input;
-    var prim = input[Symbol.toPrimitive];
-    if (prim !== void 0) {
-      var res = prim.call(input, hint || "default");
-      if (_typeof(res) !== "object")
-        return res;
-      throw new TypeError("@@toPrimitive must return a primitive value.");
-    }
-    return (hint === "string" ? String : Number)(input);
+  function serializeArrowMetadata(arrowMetadata) {
+    return Object.fromEntries(arrowMetadata);
   }
-
-  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
-  function _toPropertyKey(arg) {
-    var key = _toPrimitive(arg, "string");
-    return _typeof(key) === "symbol" ? key : String(key);
+  function deserializeArrowMetadata(metadata) {
+    return metadata ? new Map(Object.entries(metadata)) : /* @__PURE__ */ new Map();
   }
-
-  // ../../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;
+  function serializeArrowField(field) {
+    return {
+      name: field.name,
+      type: serializeArrowType(field.type),
+      nullable: field.nullable,
+      metadata: serializeArrowMetadata(field.metadata)
+    };
   }
-
-  // ../../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;
+  function deserializeArrowField(field) {
+    return new Field2(field.name, deserializeArrowType(field.type), field.nullable, deserializeArrowMetadata(field.metadata));
   }
-
-  // ../../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;
+  function serializeArrowType(arrowType) {
+    switch (arrowType.constructor) {
+      case Null:
+        return "null";
+      case Binary:
+        return "binary";
+      case Bool:
+        return "bool";
+      case Int_:
+        const intType = arrowType;
+        return `${intType.isSigned ? "u" : ""}int${intType.bitWidth}`;
+      case Int8:
+        return "int8";
+      case Int16:
+        return "int16";
+      case Int32:
+        return "int32";
+      case Int64:
+        return "int64";
+      case Uint8:
+        return "uint8";
+      case Uint16:
+        return "uint16";
+      case Uint32:
+        return "uint32";
+      case Uint64:
+        return "uint64";
+      case Float:
+        const precision = arrowType.precision;
+        switch (precision) {
+          case Precision.HALF:
+            return "float16";
+          case Precision.SINGLE:
+            return "float32";
+          case Precision.DOUBLE:
+            return "float64";
+          default:
+            return "float16";
+        }
+      case Float16:
+        return "float16";
+      case Float32:
+        return "float32";
+      case Float64:
+        return "float64";
+      case Utf8:
+        return "utf8";
+      case Decimal:
+        const decimal = arrowType;
+        return {
+          type: "decimal",
+          bitWidth: decimal.bitWidth,
+          precision: decimal.precision,
+          scale: decimal.scale
+        };
+      case Date_:
+        const dateUnit = arrowType.unit;
+        return dateUnit === DateUnit.DAY ? "date-day" : "date-millisecond";
+      case DateDay:
+        return "date-day";
+      case DateMillisecond:
+        return "date-millisecond";
+      case Time_:
+        const timeUnit = arrowType.unit;
+        switch (timeUnit) {
+          case TimeUnit.SECOND:
+            return "time-second";
+          case TimeUnit.MILLISECOND:
+            return "time-millisecond";
+          case TimeUnit.MICROSECOND:
+            return "time-microsecond";
+          case TimeUnit.NANOSECOND:
+            return "time-nanosecond";
+          default:
+            return "time-second";
+        }
+      case TimeMillisecond:
+        return "time-millisecond";
+      case TimeSecond:
+        return "time-second";
+      case TimeMicrosecond:
+        return "time-microsecond";
+      case TimeNanosecond:
+        return "time-nanosecond";
+      case Timestamp_:
+        const timeStampUnit = arrowType.unit;
+        switch (timeStampUnit) {
+          case TimeUnit.SECOND:
+            return "timestamp-second";
+          case TimeUnit.MILLISECOND:
+            return "timestamp-millisecond";
+          case TimeUnit.MICROSECOND:
+            return "timestamp-microsecond";
+          case TimeUnit.NANOSECOND:
+            return "timestamp-nanosecond";
+          default:
+            return "timestamp-second";
+        }
+      case TimestampSecond:
+        return "timestamp-second";
+      case TimestampMillisecond:
+        return "timestamp-millisecond";
+      case TimestampMicrosecond:
+        return "timestamp-microsecond";
+      case TimestampNanosecond:
+        return "timestamp-nanosecond";
+      case Interval_:
+        const intervalUnit = arrowType.unit;
+        switch (intervalUnit) {
+          case IntervalUnit.DAY_TIME:
+            return "interval-daytime";
+          case IntervalUnit.YEAR_MONTH:
+            return "interval-yearmonth";
+          default:
+            return "interval-daytime";
+        }
+      case IntervalDayTime:
+        return "interval-daytime";
+      case IntervalYearMonth:
+        return "interval-yearmonth";
+      case Map_:
+        const mapType = arrowType;
+        return {
+          type: "map",
+          keysSorted: mapType.keysSorted,
+          children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
+        };
+      case List:
+        const listType = arrowType;
+        const listField = listType.valueField;
+        return {
+          type: "list",
+          children: [serializeArrowField(listField)]
+        };
+      case FixedSizeList:
+        const fixedSizeList = arrowType;
+        return {
+          type: "fixed-size-list",
+          listSize: fixedSizeList.listSize,
+          children: [serializeArrowField(fixedSizeList.children[0])]
+        };
+      case Struct:
+        const structType = arrowType;
+        return {
+          type: "struct",
+          children: structType.children.map((arrowField) => serializeArrowField(arrowField))
+        };
+      default:
+        throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
+    }
+  }
+  function deserializeArrowType(dataType) {
+    if (typeof dataType === "object") {
+      switch (dataType.type) {
+        case "decimal":
+          return new Decimal(dataType.precision, dataType.scale, dataType.bitWidth);
+        case "map":
+          let children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
+          return new Map_(children, dataType.keysSorted);
+        case "list":
+          const field = deserializeArrowField(dataType.children[0]);
+          return new List(field);
+        case "fixed-size-list":
+          const child = deserializeArrowField(dataType.children[0]);
+          return new FixedSizeList(dataType.listSize, child);
+        case "struct":
+          children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
+          return new Struct(children);
+        default:
+          throw new Error("array type not supported");
+      }
+    }
+    switch (dataType) {
+      case "null":
+        return new Null();
+      case "binary":
+        return new Binary();
+      case "bool":
+        return new Bool();
+      case "int8":
+        return new Int8();
+      case "int16":
+        return new Int16();
+      case "int32":
+        return new Int32();
+      case "int64":
+        return new Int64();
+      case "uint8":
+        return new Uint8();
+      case "uint16":
+        return new Uint16();
+      case "uint32":
+        return new Uint32();
+      case "uint64":
+        return new Uint64();
+      case "float16":
+        return new Float16();
+      case "float32":
+        return new Float32();
+      case "float64":
+        return new Float64();
+      case "utf8":
+        return new Utf8();
+      case "date-day":
+        return new DateDay();
+      case "date-millisecond":
+        return new DateMillisecond();
+      case "time-second":
+        return new TimeSecond();
+      case "time-millisecond":
+        return new TimeMillisecond();
+      case "time-microsecond":
+        return new TimeMicrosecond();
+      case "time-nanosecond":
+        return new TimeNanosecond();
+      case "timestamp-second":
+        return new TimestampSecond();
+      case "timestamp-millisecond":
+        return new TimestampMillisecond();
+      case "timestamp-microsecond":
+        return new TimestampMicrosecond();
+      case "timestamp-nanosecond":
+        return new TimestampNanosecond();
+      case "interval-daytime":
+        return new IntervalDayTime();
+      case "interval-yearmonth":
+        return new IntervalYearMonth();
+      default:
+        throw new Error("array type not supported");
+    }
+  }
+
+  // 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) {
+    const vectors = {};
+    for (const arrayData of data) {
+      const arrayVector = createVector(arrayData.array, arrayData.type);
+      vectors[arrayData.name] = arrayVector;
+    }
+    const table = new Table(vectors);
+    const arrowBuffer = tableToIPC(table);
+    return arrowBuffer;
+  }
+  function createVector(array, type) {
+    switch (type) {
+      case VECTOR_TYPES.DATE:
+        return vectorFromArray(array);
+      case VECTOR_TYPES.FLOAT:
+      default:
+        return vectorFromArray(array);
+    }
+  }
+
+  // src/arrow-writer.ts
+  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var ArrowWriter = {
+    name: "Apache Arrow",
+    id: "arrow",
+    module: "arrow",
+    version: VERSION2,
+    extensions: ["arrow", "feather"],
+    mimeTypes: ["application/vnd.apache.arrow.file", "application/vnd.apache.arrow.stream", "application/octet-stream"],
+    binary: true,
+    options: {},
+    encode: async function encodeArrow(data, options) {
+      return encodeArrowSync(data);
+    },
+    encodeSync(data, options) {
+      return encodeArrowSync(data);
+    }
+  };
+
+  // ../gis/src/lib/geo/geoarrow-metadata.ts
+  var GEOARROW_ENCODINGS = ["geoarrow.multipolygon", "geoarrow.polygon", "geoarrow.multilinestring", "geoarrow.linestring", "geoarrow.multipoint", "geoarrow.point", "geoarrow.wkb", "geoarrow.wkt"];
+  var GEOARROW_COLUMN_METADATA_ENCODING = "ARROW:extension:name";
+  var GEOARROW_COLUMN_METADATA_METADATA = "ARROW:extension:metadata";
+  function getGeometryColumnsFromSchema(schema) {
+    const geometryColumns = {};
+    for (const field of schema.fields) {
+      const metadata = getGeometryMetadataForField(field);
+      if (metadata) {
+        geometryColumns[field.name] = metadata;
+      }
+    }
+    return geometryColumns;
+  }
+  function 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 (geoEncoding === "wkt") {
+        geoEncoding = "geoarrow.wkt";
+      }
+      if (!GEOARROW_ENCODINGS.includes(geoEncoding)) {
+        console.warn(`Invalid GeoArrow encoding: ${geoEncoding}`);
+      } else {
+        metadata = metadata || {};
+        metadata.encoding = geoEncoding;
+      }
+    }
+    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;
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+      return typeof obj2;
+    } : function(obj2) {
+      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    }, _typeof(obj);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+  function _toPrimitive(input, hint) {
+    if (_typeof(input) !== "object" || input === null)
+      return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== void 0) {
+      var res = prim.call(input, hint || "default");
+      if (_typeof(res) !== "object")
+        return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return _typeof(key) === "symbol" ? key : String(key);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
+  function _defineProperty(obj, key, value) {
+    key = _toPropertyKey(key);
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+
+  // ../../node_modules/@math.gl/polygon/dist/polygon-utils.js
+  var DimIndex = {
+    x: 0,
+    y: 1,
+    z: 2
+  };
+  function getPolygonSignedArea(points, options = {}) {
+    const {
+      start = 0,
+      end = points.length,
+      plane = "xy"
+    } = options;
+    const dim = options.size || 2;
+    let area2 = 0;
+    const i0 = DimIndex[plane[0]];
+    const i1 = DimIndex[plane[1]];
+    for (let i = start, j = end - dim; i < end; i += dim) {
+      area2 += (points[i + i0] - points[j + i0]) * (points[i + i1] + points[j + i1]);
+      j = i;
+    }
+    return area2 / 2;
+  }
+
+  // ../../node_modules/@math.gl/polygon/dist/earcut.js
+  function earcut(positions, holeIndices, dim = 2, areas, plane = "xy") {
+    const hasHoles = holeIndices && holeIndices.length;
+    const outerLen = hasHoles ? holeIndices[0] * dim : positions.length;
+    let outerNode = linkedList(positions, 0, outerLen, dim, true, areas && areas[0], plane);
+    const triangles = [];
+    if (!outerNode || outerNode.next === outerNode.prev)
+      return triangles;
+    let invSize;
+    let maxX;
+    let maxY;
+    let minX;
+    let minY;
+    let x;
+    let y;
+    if (hasHoles)
+      outerNode = eliminateHoles(positions, holeIndices, outerNode, dim, areas, plane);
+    if (positions.length > 80 * dim) {
+      minX = maxX = positions[0];
+      minY = maxY = positions[1];
+      for (let i = dim; i < outerLen; i += dim) {
+        x = positions[i];
+        y = positions[i + 1];
+        if (x < minX)
+          minX = x;
+        if (y < minY)
+          minY = y;
         if (x > maxX)
           maxX = x;
         if (y > maxY)
@@ -13136,329 +13405,175 @@ return true;`);
     }
   };
 
-  // src/tables/convert-arrow-to-geojson-table.ts
-  function convertArrowToGeoJSONTable(table) {
-    const arrowTable = table.data;
-    const schema = serializeArrowSchema(arrowTable.schema);
-    const geometryColumns = getGeometryColumnsFromSchema(schema);
-    const encoding = geometryColumns.geometry.encoding;
-    const features = [];
-    for (let row = 0; row < arrowTable.numRows; row++) {
-      const arrowGeometry = arrowTable.getChild("geometry")?.get(row);
-      const arrowGeometryObject = {
-        encoding,
-        data: arrowGeometry
-      };
-      const feature = parseGeometryFromArrow(arrowGeometryObject);
-      if (feature) {
-        features.push(feature);
+  // ../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 {
-      shape: "geojson-table",
-      type: "FeatureCollection",
-      features
+      type: "MultiPolygon",
+      coordinates
     };
   }
-
-  // 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;
+  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
+      };
     }
-  }
-
-  // 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"
-      }
+    const coordinates = [];
+    for (let i = 0; i < pathIndices.length - 1; i++) {
+      const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
+      coordinates.push(ringCoordinates);
     }
-  };
-  var GeoArrowLoader = {
-    ...ArrowWorkerLoader,
-    options: {
-      arrow: {
-        shape: "arrow-table"
-      }
-    },
-    parse: async (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options?.arrow),
-    parseSync: (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options?.arrow),
-    parseInBatches: parseGeoArrowInBatches
-  };
-
-  // src/schema/convert-arrow-schema.ts
-  function serializeArrowSchema(arrowSchema) {
     return {
-      fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
-      metadata: serializeArrowMetadata(arrowSchema.metadata)
+      type: "MultiLineString",
+      coordinates
     };
   }
-  function deserializeArrowSchema(schema) {
-    return new Schema2(schema.fields.map((field) => deserializeArrowField(field)), deserializeArrowMetadata(schema.metadata));
-  }
-  function serializeArrowMetadata(arrowMetadata) {
-    return Object.fromEntries(arrowMetadata);
-  }
-  function deserializeArrowMetadata(metadata) {
-    return metadata ? new Map(Object.entries(metadata)) : /* @__PURE__ */ new Map();
-  }
-  function serializeArrowField(field) {
-    return {
-      name: field.name,
-      type: serializeArrowType(field.type),
-      nullable: field.nullable,
-      metadata: serializeArrowMetadata(field.metadata)
+  function 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 deserializeArrowField(field) {
-    return new Field2(field.name, deserializeArrowType(field.type), field.nullable, deserializeArrowMetadata(field.metadata));
-  }
-  function serializeArrowType(arrowType) {
-    switch (arrowType.constructor) {
-      case Null:
-        return "null";
-      case Binary:
-        return "binary";
-      case Bool:
-        return "bool";
-      case Int_:
-        const intType = arrowType;
-        return `${intType.isSigned ? "u" : ""}int${intType.bitWidth}`;
-      case Int8:
-        return "int8";
-      case Int16:
-        return "int16";
-      case Int32:
-        return "int32";
-      case Int64:
-        return "int64";
-      case Uint8:
-        return "uint8";
-      case Uint16:
-        return "uint16";
-      case Uint32:
-        return "uint32";
-      case Uint64:
-        return "uint64";
-      case Float:
-        const precision = arrowType.precision;
-        switch (precision) {
-          case Precision.HALF:
-            return "float16";
-          case Precision.SINGLE:
-            return "float32";
-          case Precision.DOUBLE:
-            return "float64";
-          default:
-            return "float16";
-        }
-      case Float16:
-        return "float16";
-      case Float32:
-        return "float32";
-      case Float64:
-        return "float64";
-      case Utf8:
-        return "utf8";
-      case Decimal:
-        const decimal = arrowType;
-        return {
-          type: "decimal",
-          bitWidth: decimal.bitWidth,
-          precision: decimal.precision,
-          scale: decimal.scale
-        };
-      case Date_:
-        const dateUnit = arrowType.unit;
-        return dateUnit === DateUnit.DAY ? "date-day" : "date-millisecond";
-      case DateDay:
-        return "date-day";
-      case DateMillisecond:
-        return "date-millisecond";
-      case Time_:
-        const timeUnit = arrowType.unit;
-        switch (timeUnit) {
-          case TimeUnit.SECOND:
-            return "time-second";
-          case TimeUnit.MILLISECOND:
-            return "time-millisecond";
-          case TimeUnit.MICROSECOND:
-            return "time-microsecond";
-          case TimeUnit.NANOSECOND:
-            return "time-nanosecond";
-          default:
-            return "time-second";
-        }
-      case TimeMillisecond:
-        return "time-millisecond";
-      case TimeSecond:
-        return "time-second";
-      case TimeMicrosecond:
-        return "time-microsecond";
-      case TimeNanosecond:
-        return "time-nanosecond";
-      case Timestamp_:
-        const timeStampUnit = arrowType.unit;
-        switch (timeStampUnit) {
-          case TimeUnit.SECOND:
-            return "timestamp-second";
-          case TimeUnit.MILLISECOND:
-            return "timestamp-millisecond";
-          case TimeUnit.MICROSECOND:
-            return "timestamp-microsecond";
-          case TimeUnit.NANOSECOND:
-            return "timestamp-nanosecond";
-          default:
-            return "timestamp-second";
-        }
-      case TimestampSecond:
-        return "timestamp-second";
-      case TimestampMillisecond:
-        return "timestamp-millisecond";
-      case TimestampMicrosecond:
-        return "timestamp-microsecond";
-      case TimestampNanosecond:
-        return "timestamp-nanosecond";
-      case Interval_:
-        const intervalUnit = arrowType.unit;
-        switch (intervalUnit) {
-          case IntervalUnit.DAY_TIME:
-            return "interval-daytime";
-          case IntervalUnit.YEAR_MONTH:
-            return "interval-yearmonth";
-          default:
-            return "interval-daytime";
-        }
-      case IntervalDayTime:
-        return "interval-daytime";
-      case IntervalYearMonth:
-        return "interval-yearmonth";
-      case Map_:
-        const mapType = arrowType;
-        return {
-          type: "map",
-          keysSorted: mapType.keysSorted,
-          children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
-        };
-      case List:
-        const listType = arrowType;
-        const listField = listType.valueField;
-        return {
-          type: "list",
-          children: [serializeArrowField(listField)]
-        };
-      case FixedSizeList:
-        const fixedSizeList = arrowType;
-        return {
-          type: "fixed-size-list",
-          listSize: fixedSizeList.listSize,
-          children: [serializeArrowField(fixedSizeList.children[0])]
-        };
-      case Struct:
-        const structType = arrowType;
-        return {
-          type: "struct",
-          children: structType.children.map((arrowField) => serializeArrowField(arrowField))
-        };
-      default:
-        throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
+  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;
   }
-  function deserializeArrowType(dataType) {
-    if (typeof dataType === "object") {
-      switch (dataType.type) {
-        case "decimal":
-          return new Decimal(dataType.precision, dataType.scale, dataType.bitWidth);
-        case "map":
-          let children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
-          return new Map_(children, dataType.keysSorted);
-        case "list":
-          const field = deserializeArrowField(dataType.children[0]);
-          return new List(field);
-        case "fixed-size-list":
-          const child = deserializeArrowField(dataType.children[0]);
-          return new FixedSizeList(dataType.listSize, child);
-        case "struct":
-          children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
-          return new Struct(children);
-        default:
-          throw new Error("array type not supported");
+
+  // 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
+        });
       }
     }
-    switch (dataType) {
-      case "null":
-        return new Null();
-      case "binary":
-        return new Binary();
-      case "bool":
-        return new Bool();
-      case "int8":
-        return new Int8();
-      case "int16":
-        return new Int16();
-      case "int32":
-        return new Int32();
-      case "int64":
-        return new Int64();
-      case "uint8":
-        return new Uint8();
-      case "uint16":
-        return new Uint16();
-      case "uint32":
-        return new Uint32();
-      case "uint64":
-        return new Uint64();
-      case "float16":
-        return new Float16();
-      case "float32":
-        return new Float32();
-      case "float64":
-        return new Float64();
-      case "utf8":
-        return new Utf8();
-      case "date-day":
-        return new DateDay();
-      case "date-millisecond":
-        return new DateMillisecond();
-      case "time-second":
-        return new TimeSecond();
-      case "time-millisecond":
-        return new TimeMillisecond();
-      case "time-microsecond":
-        return new TimeMicrosecond();
-      case "time-nanosecond":
-        return new TimeNanosecond();
-      case "timestamp-second":
-        return new TimestampSecond();
-      case "timestamp-millisecond":
-        return new TimestampMillisecond();
-      case "timestamp-microsecond":
-        return new TimestampMicrosecond();
-      case "timestamp-nanosecond":
-        return new TimestampNanosecond();
-      case "interval-daytime":
-        return new IntervalDayTime();
-      case "interval-yearmonth":
-        return new IntervalYearMonth();
+    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:
-        throw new Error("array type not supported");
+        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;
@@ -13484,31 +13599,39 @@ return true;`);
   }
 
   // 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
-    }
-  };
+  var BinaryGeometryType = function(BinaryGeometryType2) {
+    BinaryGeometryType2["points"] = "points";
+    BinaryGeometryType2["lines"] = "lines";
+    BinaryGeometryType2["polygons"] = "polygons";
+    return BinaryGeometryType2;
+  }(BinaryGeometryType || {});
+  function getBinaryGeometryTemplate() {
+    return {
+      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;
+    const chunks = options?.chunkIndex !== void 0 && options?.chunkIndex >= 0 ? [geoColumn.data[options?.chunkIndex]] : geoColumn.data;
     let bounds = [Infinity, Infinity, -Infinity, -Infinity];
-    let globalFeatureIdOffset = 0;
+    let globalFeatureIdOffset = options?.chunkOffset || 0;
     const binaryGeometries = [];
     chunks.forEach((chunk) => {
       const {
@@ -13517,7 +13640,7 @@ return true;`);
         nDim,
         geomOffset,
         triangles
-      } = getBinaryGeometriesFromChunk(chunk, geoEncoding);
+      } = getBinaryGeometriesFromChunk(chunk, geoEncoding, options);
       const globalFeatureIds = new Uint32Array(featureIds.length);
       for (let i = 0; i < featureIds.length; i++) {
         globalFeatureIds[i] = featureIds[i] + globalFeatureIdOffset;
@@ -13544,12 +13667,12 @@ return true;`);
         shape: "binary-feature-collection",
         points: {
           type: "Point",
-          ...BINARY_GEOMETRY_TEMPLATE,
+          ...getBinaryGeometryTemplate(),
           ...featureTypes.point ? binaryContent : {}
         },
         lines: {
           type: "LineString",
-          ...BINARY_GEOMETRY_TEMPLATE,
+          ...getBinaryGeometryTemplate(),
           ...featureTypes.line ? binaryContent : {},
           pathIndices: {
             value: featureTypes.line ? geomOffset : new Uint16Array(0),
@@ -13558,7 +13681,7 @@ return true;`);
         },
         polygons: {
           type: "Polygon",
-          ...BINARY_GEOMETRY_TEMPLATE,
+          ...getBinaryGeometryTemplate(),
           ...featureTypes.polygon ? binaryContent : {},
           polygonIndices: {
             value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
@@ -13582,7 +13705,7 @@ return true;`);
       binaryGeometries,
       bounds,
       featureTypes,
-      ...options?.meanCenter ? {
+      ...options?.calculateMeanCenters ? {
         meanCenters: getMeanCentersFromBinaryGeometries(binaryGeometries)
       } : {}
     };
@@ -13592,18 +13715,18 @@ return true;`);
     binaryGeometries.forEach((binaryGeometry) => {
       let binaryGeometryType = null;
       if (binaryGeometry.points && binaryGeometry.points.positions.value.length > 0) {
-        binaryGeometryType = "points";
+        binaryGeometryType = BinaryGeometryType.points;
       } else if (binaryGeometry.lines && binaryGeometry.lines.positions.value.length > 0) {
-        binaryGeometryType = "lines";
+        binaryGeometryType = BinaryGeometryType.lines;
       } else if (binaryGeometry.polygons && binaryGeometry.polygons.positions.value.length > 0) {
-        binaryGeometryType = "polygons";
+        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.primitivePolygonIndices?.value;
+        const primitivePolygonIndices = binaryContent.type === "Polygon" ? binaryContent.primitivePolygonIndices?.value : void 0;
         const meanCenters = getMeanCentersFromGeometry(featureIds, flatCoordinateArray, nDim, binaryGeometryType, primitivePolygonIndices);
         meanCenters.forEach((center) => {
           globalMeanCenters.push(center);
@@ -13616,19 +13739,23 @@ return true;`);
     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[vertexIndex / nDim] === featureId) {
-        if (geometryType === "polygons" && primitivePolygonIndices && primitivePolygonIndices.indexOf(vertexIndex / nDim) >= 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;
@@ -13636,7 +13763,7 @@ return true;`);
     }
     return meanCenters;
   }
-  function getBinaryGeometriesFromChunk(chunk, geoEncoding) {
+  function getBinaryGeometriesFromChunk(chunk, geoEncoding, options) {
     switch (geoEncoding) {
       case "geoarrow.point":
       case "geoarrow.multipoint":
@@ -13646,37 +13773,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 getTriangleIndices(polygonIndices, primitivePolygonIndices, flatCoordinateArray, nDim) {
-    let primitiveIndex = 0;
-    const triangles = [];
-    for (let i = 0; i < polygonIndices.length - 1; i++) {
-      const startIdx = polygonIndices[i];
-      const endIdx = polygonIndices[i + 1];
-      const slicedFlatCoords = flatCoordinateArray.subarray(startIdx * nDim, endIdx * nDim);
-      const holeIndices = [];
-      while (primitivePolygonIndices[primitiveIndex] < endIdx) {
-        if (primitivePolygonIndices[primitiveIndex] > startIdx) {
-          holeIndices.push(primitivePolygonIndices[primitiveIndex] - startIdx);
+    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("earcut failed e.g. invalid polygon");
+        }
+        for (let j = 0; j < triangleIndices.length; j++) {
+          triangles.push(triangleIndices[j] + startIdx);
         }
-        primitiveIndex++;
       }
-      const triangleIndices = earcut(slicedFlatCoords, holeIndices.length > 0 ? holeIndices : void 0, nDim);
-      for (let j = 0; j < triangleIndices.length; j++) {
-        triangles.push(triangleIndices[j] + startIdx);
+      const trianglesUint32 = new Uint32Array(triangles.length);
+      for (let i = 0; i < triangles.length; i++) {
+        trianglesUint32[i] = triangles[i];
       }
+      return trianglesUint32;
+    } catch (error) {
+      return null;
     }
-    const trianglesUint32 = new Uint32Array(triangles.length);
-    for (let i = 0; i < triangles.length; i++) {
-      trianglesUint32[i] = triangles[i];
-    }
-    return trianglesUint32;
   }
-  function getBinaryPolygonsFromChunk(chunk, geoEncoding) {
+  function getBinaryPolygonsFromChunk(chunk, geoEncoding, options) {
     const isMultiPolygon = geoEncoding === "geoarrow.multipolygon";
     const polygonData = isMultiPolygon ? chunk.children[0] : chunk;
     const polygonOffset = polygonData.valueOffsets;
@@ -13700,14 +13834,16 @@ return true;`);
         featureIds[j] = i;
       }
     }
-    const triangles = getTriangleIndices(geometryIndicies, geomOffset, flatCoordinateArray, nDim);
+    const triangles = options?.triangulate ? getTriangleIndices(geometryIndicies, geomOffset, flatCoordinateArray, nDim) : null;
     return {
       featureIds,
-      flatCoordinateArray,
       nDim,
+      flatCoordinateArray,
       geomOffset,
       geometryIndicies,
-      triangles
+      ...options?.triangulate && triangles ? {
+        triangles
+      } : {}
     };
   }
   function getBinaryLinesFromChunk(chunk, geoEncoding) {
@@ -13780,46 +13916,706 @@ return true;`);
     };
   }
 
-  // src/geoarrow/convert-geoarrow-to-geojson.ts
-  function parseGeometryFromArrow(rawData) {
-    const encoding = rawData.encoding?.toLowerCase();
-    const data = rawData.data;
-    if (!encoding || !data) {
+  // ../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 {
+      geometry: {
+        type: "LineString",
+        positions: {
+          value: positions,
+          size: dimension
+        },
+        pathIndices: {
+          value: new Uint16Array(pathIndices),
+          size: 1
+        }
+      },
+      offset
+    };
+  }
+  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 {
+      type: "LineString",
+      positions: {
+        value: concatenatedPositions,
+        size: dimension
+      },
+      pathIndices: {
+        value: new Uint16Array(pathIndices),
+        size: 1
+      }
+    };
+  }
+  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 {
+      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-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":
-        throw Error(`GeoArrow encoding not supported ${encoding}`);
+        geometry = arrowWKBToFeature(arrowCellValue);
+        break;
       case "geoarrow.wkt":
-        throw Error(`GeoArrow encoding not supported ${encoding}`);
+        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 = [];
@@ -13851,8 +14647,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);
     }
@@ -13871,19 +14667,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 = [];
@@ -13893,32 +14687,64 @@ 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;
+  }
+
+  // src/workers/hard-clone.ts
+  function hardClone(data, force = false) {
+    if ("data" in data) {
+      return new Vector(data.data.map((data2) => hardClone(data2, force)));
+    }
+    const clonedChildren = [];
+    for (const childData of data.children) {
+      clonedChildren.push(hardClone(childData, force));
+    }
+    let clonedDictionary;
+    if (data.dictionary !== void 0) {
+      clonedDictionary = hardClone(data.dictionary, force);
+    }
+    const clonedBuffers = {
+      [BufferType.OFFSET]: cloneBuffer(data.buffers[BufferType.OFFSET], force),
+      [BufferType.DATA]: cloneBuffer(data.buffers[BufferType.DATA], force),
+      [BufferType.VALIDITY]: cloneBuffer(data.buffers[BufferType.VALIDITY], force),
+      [BufferType.TYPE]: cloneBuffer(data.buffers[BufferType.TYPE], force)
+    };
+    return new Data(data.type, data.offset, data.length, data._nullCount, clonedBuffers, clonedChildren, clonedDictionary);
+  }
+  function isTypedArraySliced(arr) {
+    return !(arr.byteOffset === 0 && arr.byteLength === arr.buffer.byteLength);
+  }
+  function cloneBuffer(arr, force) {
+    if (arr === void 0) {
+      return arr;
+    }
+    if (!force && !isTypedArraySliced(arr)) {
+      return arr;
+    }
+    return arr.slice();
   }
 
   // ../worker-utils/src/lib/env-utils/version.ts
@@ -13935,7 +14761,7 @@ return true;`);
     }
     return globalThis._loadersgl_.version;
   }
-  var VERSION3 = getVersion();
+  var VERSION4 = getVersion();
 
   // ../worker-utils/src/lib/env-utils/assert.ts
   function assert(condition, message) {
@@ -14377,7 +15203,7 @@ return true;`);
 
   // ../worker-utils/src/lib/worker-api/get-worker-url.ts
   function getWorkerName(worker) {
-    const warning = worker.version !== VERSION3 ? ` (worker-utils@${VERSION3})` : "";
+    const warning = worker.version !== VERSION4 ? ` (worker-utils@${VERSION4})` : "";
     return `${worker.name}@${worker.version}${warning}`;
   }
   function getWorkerURL(worker, options = {}) {
@@ -14472,16 +15298,25 @@ return true;`);
   }
 
   // src/triangulate-on-worker.ts
-  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var TriangulationWorker = {
     id: "triangulation",
     name: "Triangulate",
     module: "arrow",
-    version: VERSION4,
+    version: VERSION5,
     options: {}
   };
   function triangulateOnWorker(data, options = {}) {
-    return processOnWorker(TriangulationWorker, data, options);
+    return processOnWorker(TriangulationWorker, {
+      ...data,
+      operation: "triangulate"
+    }, options);
+  }
+  function parseGeoArrowOnWorker(data, options = {}) {
+    return processOnWorker(TriangulationWorker, {
+      ...data,
+      operation: "parse-geoarrow"
+    }, options);
   }
 
   // src/index.ts