@loaders.gl/arrow 4.3.0-alpha.8 → 4.3.0-beta.2

package/dist/dist.dev.js

@@ -60,12 +60,14 @@ var __exports__ = (() => {
     GeoArrowWorkerLoader: () => GeoArrowWorkerLoader,
     TriangulationWorker: () => TriangulationWorker,
     VECTOR_TYPES: () => VECTOR_TYPES,
-    convertArrowToGeoJSONTable: () => convertArrowToGeoJSONTable,
+    convertArrowToSchema: () => convertArrowToSchema,
+    convertArrowToTable: () => convertArrowToTable,
+    convertSchemaToArrow: () => convertSchemaToArrow,
+    convertTableToArrow: () => convertTableToArrow,
     deserializeArrowField: () => deserializeArrowField,
     deserializeArrowMetadata: () => deserializeArrowMetadata,
     deserializeArrowSchema: () => deserializeArrowSchema,
     deserializeArrowType: () => deserializeArrowType,
-    getArrowType: () => getArrowType,
     getBinaryGeometriesFromArrow: () => getBinaryGeometriesFromArrow,
     getBinaryGeometryTemplate: () => getBinaryGeometryTemplate,
     getMeanCentersFromBinaryGeometries: () => getMeanCentersFromBinaryGeometries,
@@ -82,6 +84,13 @@ var __exports__ = (() => {
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
+  // src/lib/types.ts
+  var VECTOR_TYPES = /* @__PURE__ */ ((VECTOR_TYPES2) => {
+    VECTOR_TYPES2[VECTOR_TYPES2["FLOAT"] = 0] = "FLOAT";
+    VECTOR_TYPES2[VECTOR_TYPES2["DATE"] = 1] = "DATE";
+    return VECTOR_TYPES2;
+  })(VECTOR_TYPES || {});
+
   // ../schema/src/lib/table/simple-table/data-type.ts
   function getDataTypeFromValue(value, defaultNumberType = "float32") {
     if (value instanceof Date) {
@@ -575,6 +584,29 @@ var __exports__ = (() => {
         throw new Error("table");
     }
   }
+  function getTableNumCols(table) {
+    if (table.schema) {
+      return table.schema.fields.length;
+    }
+    if (getTableLength(table) === 0) {
+      throw new Error("empty table");
+    }
+    switch (table.shape) {
+      case "array-row-table":
+        return table.data[0].length;
+      case "object-row-table":
+        return Object.keys(table.data[0]).length;
+      case "geojson-table":
+        return Object.keys(table.features[0]).length;
+      case "columnar-table":
+        return Object.keys(table.data).length;
+      case "arrow-table":
+        const arrowTable = table.data;
+        return arrowTable.numCols;
+      default:
+        throw new Error("table");
+    }
+  }
   function getTableCell(table, rowIndex, columnName) {
     switch (table.shape) {
       case "array-row-table":
@@ -597,6 +629,27 @@ var __exports__ = (() => {
         throw new Error("todo");
     }
   }
+  function getTableCellAt(table, rowIndex, columnIndex) {
+    switch (table.shape) {
+      case "array-row-table":
+        return table.data[rowIndex][columnIndex];
+      case "object-row-table":
+        const columnName1 = getTableColumnName(table, columnIndex);
+        return table.data[rowIndex][columnName1];
+      case "geojson-table":
+        const columnName2 = getTableColumnName(table, columnIndex);
+        return table.features[rowIndex][columnName2];
+      case "columnar-table":
+        const columnName3 = getTableColumnName(table, columnIndex);
+        const column = table.data[columnName3];
+        return column[rowIndex];
+      case "arrow-table":
+        const arrowTable = table.data;
+        return arrowTable.getChildAt(columnIndex)?.get(rowIndex);
+      default:
+        throw new Error("todo");
+    }
+  }
   function getTableColumnIndex(table, columnName) {
     const columnIndex = table.schema?.fields.findIndex((field) => field.name === columnName);
     if (columnIndex === void 0) {
@@ -604,6 +657,13 @@ var __exports__ = (() => {
     }
     return columnIndex;
   }
+  function getTableColumnName(table, columnIndex) {
+    const columnName = table.schema?.fields[columnIndex]?.name;
+    if (!columnName) {
+      throw new Error(`${columnIndex}`);
+    }
+    return columnName;
+  }
   function getTableRowAsObject(table, rowIndex, target, copy2) {
     switch (table.shape) {
       case "object-row-table":
@@ -923,16 +983,24 @@ var __exports__ = (() => {
     if (!Symbol.asyncIterator)
       throw new TypeError("Symbol.asyncIterator is not defined.");
     var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
       return this;
     }, i;
-    function verb(n) {
-      if (g[n])
+    function awaitReturn(f) {
+      return function(v) {
+        return Promise.resolve(v).then(f, reject);
+      };
+    }
+    function verb(n, f) {
+      if (g[n]) {
         i[n] = function(v) {
           return new Promise(function(a, b) {
             q.push([n, v, a, b]) > 1 || resume(n, v);
           });
         };
+        if (f)
+          i[n] = f(i[n]);
+      }
     }
     function resume(n, v) {
       try {
@@ -12711,7 +12779,7 @@ return true;`);
   RecordBatchFileWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
   RecordBatchStreamWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
 
-  // src/lib/arrow-table-batch.ts
+  // src/schema/arrow-table-batch.ts
   var ArrowTableBatchAggregator = class extends ColumnarTableBatchAggregator {
     arrowSchema;
     constructor(schema, options) {
@@ -12770,594 +12838,182 @@ return true;`);
     return arrowVectors;
   }
 
-  // src/schema/arrow-type-utils.ts
-  function getArrowType(array) {
-    switch (array.constructor) {
-      case Int8Array:
-        return new Int8();
-      case Uint8Array:
-        return new Uint8();
-      case Int16Array:
-        return new Int16();
-      case Uint16Array:
-        return new Uint16();
-      case Int32Array:
-        return new Int32();
-      case Uint32Array:
-        return new Uint32();
-      case Float32Array:
-        return new Float32();
-      case Float64Array:
-        return new Float64();
-      default:
-        throw new Error("array type not supported");
+  // src/exports/arrow-loader.ts
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var ArrowWorkerLoader = {
+    dataType: null,
+    batchType: null,
+    name: "Apache Arrow",
+    id: "arrow",
+    module: "arrow",
+    version: VERSION,
+    // worker: true,
+    category: "table",
+    extensions: ["arrow", "feather"],
+    mimeTypes: [
+      "application/vnd.apache.arrow.file",
+      "application/vnd.apache.arrow.stream",
+      "application/octet-stream"
+    ],
+    binary: true,
+    tests: ["ARROW"],
+    options: {
+      arrow: {
+        shape: "columnar-table"
+      }
     }
-  }
-
-  // src/types.ts
-  var VECTOR_TYPES = /* @__PURE__ */ ((VECTOR_TYPES2) => {
-    VECTOR_TYPES2[VECTOR_TYPES2["FLOAT"] = 0] = "FLOAT";
-    VECTOR_TYPES2[VECTOR_TYPES2["DATE"] = 1] = "DATE";
-    return VECTOR_TYPES2;
-  })(VECTOR_TYPES || {});
+  };
 
-  // src/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;
+  // ../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 {
-      shape: "columnar-table",
-      schema: table.schema,
-      data: columnarTable
-    };
+    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;
   }
 
-  // src/schema/convert-arrow-schema.ts
-  function serializeArrowSchema(arrowSchema) {
-    return {
-      fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
-      metadata: serializeArrowMetadata(arrowSchema.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 deserializeArrowSchema(schema) {
-    return new Schema2(
-      schema.fields.map((field) => deserializeArrowField(field)),
-      deserializeArrowMetadata(schema.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;
+        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 serializeArrowMetadata(arrowMetadata) {
-    return Object.fromEntries(arrowMetadata);
+  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 deserializeArrowMetadata(metadata) {
-    return metadata ? new Map(Object.entries(metadata)) : /* @__PURE__ */ new Map();
-  }
-  function serializeArrowField(field) {
-    return {
-      name: field.name,
-      type: serializeArrowType(field.type),
-      nullable: field.nullable,
-      metadata: serializeArrowMetadata(field.metadata)
-    };
-  }
-  function deserializeArrowField(field) {
-    return new Field2(
-      field.name,
-      deserializeArrowType(field.type),
-      field.nullable,
-      deserializeArrowMetadata(field.metadata)
-    );
-  }
-  function serializeArrowType(arrowType) {
-    switch (arrowType.constructor) {
-      case Null2:
-        return "null";
-      case Binary2:
-        return "binary";
-      case Bool2:
-        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 Utf82:
-        return "utf8";
-      case Decimal2:
-        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 List2:
-        const listType = arrowType;
-        const listField = listType.valueField;
-        return {
-          type: "list",
-          children: [serializeArrowField(listField)]
-        };
-      case FixedSizeList2:
-        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 Decimal2(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 List2(field);
-        case "fixed-size-list":
-          const child = deserializeArrowField(dataType.children[0]);
-          return new FixedSizeList2(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 Null2();
-      case "binary":
-        return new Binary2();
-      case "bool":
-        return new Bool2();
-      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 Utf82();
-      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, options) {
-    async function* makeArrowAsyncIterator() {
-      const readers = RecordBatchReader.readAll(asyncIterator);
-      for await (const reader of readers) {
-        for await (const recordBatch of reader) {
-          if (options?.arrow?.batchDebounceMs !== void 0 && options?.arrow?.batchDebounceMs > 0) {
-            await new Promise((resolve) => setTimeout(resolve, options.arrow?.batchDebounceMs || 0));
-          }
-          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 = {
-    dataType: null,
-    batchType: null,
-    name: "Apache Arrow",
-    id: "arrow",
-    module: "arrow",
-    version: VERSION,
-    // worker: true,
-    category: "table",
-    extensions: ["arrow", "feather"],
-    mimeTypes: [
-      "application/vnd.apache.arrow.file",
-      "application/vnd.apache.arrow.stream",
-      "application/octet-stream"
-    ],
-    binary: true,
-    tests: ["ARROW"],
-    options: {
-      arrow: {
-        shape: "columnar-table"
-      }
-    }
-  };
-  var ArrowLoader = {
-    ...ArrowWorkerLoader,
-    parse: async (arraybuffer, options) => parseArrowSync(arraybuffer, options?.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 1 /* DATE */:
-        return vectorFromArray(array);
-      case 0 /* 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/@math.gl/polygon/dist/polygon-utils.js
-  var DimIndex = {
-    x: 0,
-    y: 1,
-    z: 2
-  };
-  function getPolygonSignedArea(points, options = {}) {
-    const { start = 0, end = points.length, plane = "xy" } = options;
-    const dim = options.size || 2;
-    let area2 = 0;
-    const i0 = DimIndex[plane[0]];
-    const i1 = DimIndex[plane[1]];
-    for (let i = start, j = end - dim; i < end; i += dim) {
-      area2 += (points[i + i0] - points[j + i0]) * (points[i + i1] + points[j + i1]);
-      j = i;
-    }
-    return area2 / 2;
-  }
-
-  // ../../node_modules/@math.gl/polygon/dist/earcut.js
-  function earcut(positions, holeIndices, dim = 2, areas, plane = "xy") {
-    const hasHoles = holeIndices && holeIndices.length;
-    const outerLen = hasHoles ? holeIndices[0] * dim : positions.length;
-    let outerNode = linkedList(positions, 0, outerLen, dim, true, areas && areas[0], plane);
-    const triangles = [];
-    if (!outerNode || outerNode.next === outerNode.prev)
-      return triangles;
-    let invSize;
-    let maxX;
-    let maxY;
-    let minX;
-    let minY;
-    let x;
-    let y;
-    if (hasHoles)
-      outerNode = eliminateHoles(positions, holeIndices, outerNode, dim, areas, plane);
-    if (positions.length > 80 * dim) {
-      minX = maxX = positions[0];
-      minY = maxY = positions[1];
-      for (let i = dim; i < outerLen; i += dim) {
-        x = positions[i];
-        y = positions[i + 1];
-        if (x < minX)
-          minX = x;
-        if (y < minY)
-          minY = y;
-        if (x > maxX)
-          maxX = x;
-        if (y > maxY)
-          maxY = y;
-      }
-      invSize = Math.max(maxX - minX, maxY - minY);
-      invSize = invSize !== 0 ? 32767 / invSize : 0;
-    }
-    earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
-    return triangles;
-  }
-  function linkedList(data, start, end, dim, clockwise, area2, plane) {
-    let i;
-    let last;
-    if (area2 === void 0) {
-      area2 = getPolygonSignedArea(data, { start, end, size: dim, plane });
-    }
-    let i0 = DimIndex[plane[0]];
-    let i1 = DimIndex[plane[1]];
-    if (clockwise === area2 < 0) {
-      for (i = start; i < end; i += dim)
-        last = insertNode(i, data[i + i0], data[i + i1], last);
-    } else {
-      for (i = end - dim; i >= start; i -= dim)
-        last = insertNode(i, data[i + i0], data[i + i1], last);
-    }
-    if (last && equals(last, last.next)) {
-      removeNode(last);
-      last = last.next;
-    }
-    return last;
-  }
-  function filterPoints(start, end) {
-    if (!start)
-      return start;
-    if (!end)
-      end = start;
-    let p = start;
-    let again;
-    do {
-      again = false;
-      if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
-        removeNode(p);
-        p = end = p.prev;
-        if (p === p.next)
-          break;
-        again = true;
-      } else {
-        p = p.next;
-      }
-    } while (again || p !== end);
-    return end;
+  function filterPoints(start, end) {
+    if (!start)
+      return start;
+    if (!end)
+      end = start;
+    let p = start;
+    let again;
+    do {
+      again = false;
+      if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+        removeNode(p);
+        p = end = p.prev;
+        if (p === p.next)
+          break;
+        again = true;
+      } else {
+        p = p.next;
+      }
+    } while (again || p !== end);
+    return end;
   }
   function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
     if (!ear)
@@ -13622,605 +13278,505 @@ return true;`);
           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) && // dones't intersect other edges
-    (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
-    (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors
-    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) {
-      this.prev = null;
-      this.next = null;
-      this.z = 0;
-      this.prevZ = null;
-      this.nextZ = null;
-      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);
+        p = q;
       }
-      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 };
+      tail.nextZ = null;
+      inSize *= 2;
+    } while (numMerges > 1);
+    return list;
   }
-  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 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 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 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 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 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);
   }
-
-  // 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
-    };
+  function isValidDiagonal(a, b) {
+    return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && // dones't intersect other edges
+    (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
+    (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors
+    equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0);
   }
-
-  // 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 area(p, q, r) {
+    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
   }
-
-  // src/parsers/parse-geoarrow-in-batches.ts
-  function parseGeoArrowInBatches(asyncIterator) {
-    return parseArrowInBatches(asyncIterator);
+  function equals(p1, p2) {
+    return p1.x === p2.x && p1.y === p2.y;
   }
-
-  // src/geoarrow-loader.ts
-  var GeoArrowWorkerLoader = {
-    ...ArrowWorkerLoader,
-    options: {
-      arrow: {
-        shape: "arrow-table"
-      }
-    }
-  };
-  var GeoArrowLoader = {
-    ...GeoArrowWorkerLoader,
-    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;
+  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;
   }
-
-  // src/geoarrow/convert-geoarrow-to-binary-geometry.ts
-  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 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 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 !== void 0 && options?.chunkIndex >= 0 ? [geoColumn.data[options?.chunkIndex]] : geoColumn.data;
-    let bounds = [Infinity, Infinity, -Infinity, -Infinity];
-    let globalFeatureIdOffset = options?.chunkOffset || 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 },
-        // eslint-disable-next-line no-loop-func
-        properties: [...Array(chunk.length).keys()].map((i) => ({
-          index: i + globalFeatureIdOffset
-        }))
-      };
-      globalFeatureIdOffset += chunk.length;
-      binaryGeometries.push({
-        shape: "binary-feature-collection",
-        points: {
-          type: "Point",
-          ...getBinaryGeometryTemplate(),
-          ...featureTypes.point ? binaryContent : {}
-        },
-        lines: {
-          type: "LineString",
-          ...getBinaryGeometryTemplate(),
-          ...featureTypes.line ? binaryContent : {},
-          pathIndices: { value: featureTypes.line ? geomOffset : new Uint16Array(0), size: 1 }
-        },
-        polygons: {
-          type: "Polygon",
-          ...getBinaryGeometryTemplate(),
-          ...featureTypes.polygon ? binaryContent : {},
-          polygonIndices: {
-            // use geomOffset as polygonIndices same as primitivePolygonIndices since we are using earcut to get triangule indices
-            value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
-            size: 1
-          },
-          primitivePolygonIndices: {
-            value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
-            size: 1
-          },
-          ...triangles ? { triangles: { value: triangles, size: 1 } } : {}
-        }
-      });
-      bounds = updateBoundsFromGeoArrowSamples(flatCoordinateArray, nDim, bounds);
-    });
-    return {
-      binaryGeometries,
-      bounds,
-      featureTypes,
-      ...options?.calculateMeanCenters ? { meanCenters: getMeanCentersFromBinaryGeometries(binaryGeometries) } : {}
-    };
+  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 getMeanCentersFromBinaryGeometries(binaryGeometries) {
-    const globalMeanCenters = [];
-    binaryGeometries.forEach((binaryGeometry) => {
-      let binaryGeometryType = null;
-      if (binaryGeometry.points && binaryGeometry.points.positions.value.length > 0) {
-        binaryGeometryType = "points" /* points */;
-      } else if (binaryGeometry.lines && binaryGeometry.lines.positions.value.length > 0) {
-        binaryGeometryType = "lines" /* lines */;
-      } else if (binaryGeometry.polygons && binaryGeometry.polygons.positions.value.length > 0) {
-        binaryGeometryType = "polygons" /* polygons */;
-      }
-      const binaryContent = binaryGeometryType ? binaryGeometry[binaryGeometryType] : null;
-      if (binaryContent && binaryGeometryType !== null) {
-        const featureIds = binaryContent.featureIds.value;
-        const flatCoordinateArray = binaryContent.positions.value;
-        const nDim = binaryContent.positions.size;
-        const primitivePolygonIndices = binaryContent.type === "Polygon" ? binaryContent.primitivePolygonIndices?.value : void 0;
-        const meanCenters = getMeanCentersFromGeometry(
-          featureIds,
-          flatCoordinateArray,
-          nDim,
-          binaryGeometryType,
-          primitivePolygonIndices
-        );
-        meanCenters.forEach((center) => {
-          globalMeanCenters.push(center);
-        });
-      }
-    });
-    return globalMeanCenters;
+  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 getMeanCentersFromGeometry(featureIds, flatCoordinateArray, nDim, geometryType, primitivePolygonIndices) {
-    const meanCenters = [];
-    const vertexCount = flatCoordinateArray.length;
-    let vertexIndex = 0;
-    let coordIdx = 0;
-    let primitiveIdx = 0;
-    while (vertexIndex < vertexCount) {
-      const featureId = featureIds[vertexIndex / nDim];
-      const center = [0, 0];
-      let vertexCountInFeature = 0;
-      while (vertexIndex < vertexCount && featureIds[coordIdx] === featureId) {
-        if (geometryType === "polygons" /* polygons */ && primitivePolygonIndices?.[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);
+  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 meanCenters;
+    return p;
   }
-  function getBinaryGeometriesFromChunk(chunk, geoEncoding, options) {
-    switch (geoEncoding) {
-      case "geoarrow.point":
-      case "geoarrow.multipoint":
-        return getBinaryPointsFromChunk(chunk, geoEncoding);
-      case "geoarrow.linestring":
-      case "geoarrow.multilinestring":
-        return getBinaryLinesFromChunk(chunk, geoEncoding);
-      case "geoarrow.polygon":
-      case "geoarrow.multipolygon":
-        return getBinaryPolygonsFromChunk(chunk, geoEncoding, options);
+  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) {
+      this.prev = null;
+      this.next = null;
+      this.z = 0;
+      this.prevZ = null;
+      this.nextZ = null;
+      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:
-        throw Error("invalid geoarrow encoding");
+        const unexpectedInput = data;
+        throw new Error(`Unsupported geometry type: ${unexpectedInput?.type}`);
     }
   }
-  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("earcut failed e.g. 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];
+  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 trianglesUint32;
-    } catch (error) {
-      return null;
+      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 getBinaryPolygonsFromChunk(chunk, geoEncoding, options) {
-    const isMultiPolygon = geoEncoding === "geoarrow.multipolygon";
-    const polygonData = isMultiPolygon ? chunk.children[0] : chunk;
-    const polygonOffset = polygonData.valueOffsets;
-    const partData = isMultiPolygon ? chunk.valueOffsets.map((i) => polygonOffset.at(i) || i) : chunk.valueOffsets;
-    const ringData = polygonData.children[0];
-    const pointData = ringData.children[0];
-    const coordData = pointData.children[0];
-    const nDim = pointData.stride;
-    const geomOffset = ringData.valueOffsets;
-    const flatCoordinateArray = coordData.values;
-    const geometryIndicies = new Uint16Array(polygonOffset.length);
-    for (let i = 0; i < polygonOffset.length; i++) {
-      geometryIndicies[i] = geomOffset[polygonOffset[i]];
+  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 numOfVertices = flatCoordinateArray.length / nDim;
-    const featureIds = new Uint32Array(numOfVertices);
-    for (let i = 0; i < partData.length - 1; i++) {
-      const startIdx = geomOffset[partData[i]];
-      const endIdx = geomOffset[partData[i + 1]];
-      for (let j = startIdx; j < endIdx; j++) {
-        featureIds[j] = i;
+    const 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);
     }
-    const triangles = options?.triangulate ? getTriangleIndices(geometryIndicies, geomOffset, flatCoordinateArray, nDim) : null;
+    return ringCoordinates;
+  }
+
+  // src/lib/tables/convert-arrow-schema.ts
+  function convertArrowToSchema(arrowSchema) {
+    return serializeArrowSchema(arrowSchema);
+  }
+  function convertSchemaToArrow(schema) {
+    return deserializeArrowSchema(schema);
+  }
+  function serializeArrowSchema(arrowSchema) {
     return {
-      featureIds,
-      nDim,
-      flatCoordinateArray,
-      geomOffset,
-      geometryIndicies,
-      ...options?.triangulate && triangles ? { triangles } : {}
+      fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
+      metadata: serializeArrowMetadata(arrowSchema.metadata)
     };
   }
-  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;
-        }
-      }
-    }
+  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 {
-      featureIds,
-      flatCoordinateArray,
-      nDim,
-      geomOffset,
-      geometryIndicies
+      name: field.name,
+      type: serializeArrowType(field.type),
+      nullable: field.nullable,
+      metadata: serializeArrowMetadata(field.metadata)
     };
   }
-  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;
+  function deserializeArrowField(field) {
+    return new Field2(
+      field.name,
+      deserializeArrowType(field.type),
+      field.nullable,
+      deserializeArrowMetadata(field.metadata)
+    );
+  }
+  function serializeArrowType(arrowType) {
+    switch (arrowType.constructor) {
+      case Null2:
+        return "null";
+      case Binary2:
+        return "binary";
+      case Bool2:
+        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";
         }
-      }
-    } else {
-      for (let i = 0; i < chunk.length; i++) {
-        featureIds[i] = i;
+      case Float16:
+        return "float16";
+      case Float32:
+        return "float32";
+      case Float64:
+        return "float64";
+      case Utf82:
+        return "utf8";
+      case Decimal2:
+        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 List2:
+        const listType = arrowType;
+        const listField = listType.valueField;
+        return {
+          type: "list",
+          children: [serializeArrowField(listField)]
+        };
+      case FixedSizeList2:
+        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 Decimal2(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 List2(field);
+        case "fixed-size-list":
+          const child = deserializeArrowField(dataType.children[0]);
+          return new FixedSizeList2(dataType.listSize, child);
+        case "struct":
+          children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
+          return new Struct(children);
+        default:
+          throw new Error("array type not supported");
       }
     }
-    return {
-      featureIds,
-      flatCoordinateArray,
-      nDim,
-      geomOffset,
-      geometryIndicies
-    };
+    switch (dataType) {
+      case "null":
+        return new Null2();
+      case "binary":
+        return new Binary2();
+      case "bool":
+        return new Bool2();
+      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 Utf82();
+      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");
+    }
   }
 
   // ../wkt/src/lib/utils/version.ts
-  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
   // ../wkt/src/lib/parse-wkt.ts
   var numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
@@ -14238,747 +13794,1286 @@ return true;`);
   function isWKT(input) {
     return WKT_MAGIC_STRINGS.some((magicString) => input.startsWith(magicString));
   }
-  function parseWKT(input, options) {
-    return parseWKTToGeometry(input, options);
+  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 {
+      // @ts-ignore
+      type: "MultiLineString",
+      // @ts-expect-error
+      coordinates: c
+    };
+  }
+  function parsePolygon(state) {
+    if (!$(/^(POLYGON(\sz)?)/i, state)) {
+      return null;
+    }
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+      return null;
+    }
+    return {
+      // @ts-ignore
+      type: "Polygon",
+      // @ts-expect-error
+      coordinates: c
+    };
+  }
+  function parseMultiPolygon(state) {
+    if (!$(/^(MULTIPOLYGON)/i, state)) {
+      return null;
+    }
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+      return null;
+    }
+    return {
+      type: "MultiPolygon",
+      // @ts-expect-error
+      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 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 $(regexp, state) {
+    const match = state._?.substring(state.i).match(regexp);
+    if (!match)
+      return null;
+    else {
+      state.i += match[0].length;
+      return match[0];
+    }
   }
-  function parseGeometry(state) {
-    return parsePoint(state) || parseLineString(state) || parsePolygon(state) || parseMultiPoint(state) || parseMultiLineString(state) || parseMultiPolygon(state) || parseGeometryCollection(state);
+  function white(state) {
+    $(/^\s*/, 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;
+
+  // ../wkt/src/wkt-loader.ts
+  var WKTWorkerLoader = {
+    dataType: null,
+    batchType: null,
+    name: "WKT (Well-Known Text)",
+    id: "wkt",
+    module: "wkt",
+    version: VERSION2,
+    worker: true,
+    extensions: ["wkt"],
+    mimeTypes: ["text/plain"],
+    category: "geometry",
+    text: true,
+    tests: WKT_MAGIC_STRINGS,
+    testText: isWKT,
+    options: {
+      wkt: {
+        shape: "geojson-geometry",
+        crs: true
+      }
     }
-    return obj;
+  };
+  var WKTLoader = {
+    ...WKTWorkerLoader,
+    parse: async (arrayBuffer, options) => parseWKT(new TextDecoder().decode(arrayBuffer), options),
+    parseTextSync: (string, options) => parseWKT(string, options)
+  };
+
+  // ../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;
+  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 parsePoint(state) {
-    if (!$(/^(POINT(\sz)?)/i, state)) {
-      return null;
+  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}`);
     }
-    white(state);
-    if (!$(/^(\()/, state)) {
-      return null;
+    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";
     }
-    const c = coords(state);
-    if (!c) {
-      return null;
+    if (ewkbSRID) {
+      wkbHeader.type = "ewkb";
+      wkbHeader.srid = dataView.getUint32(wkbHeader.byteOffset, wkbHeader.littleEndian);
+      wkbHeader.byteOffset += 4;
     }
-    white(state);
-    if (!$(/^(\))/, state)) {
-      return null;
+    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);
     }
-    return {
-      type: "Point",
-      coordinates: c[0]
-    };
   }
-  function parseMultiPoint(state) {
-    if (!$(/^(MULTIPOINT)/i, state)) {
-      return null;
+  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 1 /* Point */:
+        const point = parsePoint2(dataView, offset, dimensions, littleEndian);
+        return point.geometry;
+      case 2 /* LineString */:
+        const line = parseLineString2(dataView, offset, dimensions, littleEndian);
+        return line.geometry;
+      case 3 /* Polygon */:
+        const polygon = parsePolygon2(dataView, offset, dimensions, littleEndian);
+        return polygon.geometry;
+      case 4 /* MultiPoint */:
+        const multiPoint = parseMultiPoint2(dataView, offset, dimensions, littleEndian);
+        multiPoint.type = "Point";
+        return multiPoint;
+      case 5 /* MultiLineString */:
+        const multiLine = parseMultiLineString2(dataView, offset, dimensions, littleEndian);
+        multiLine.type = "LineString";
+        return multiLine;
+      case 6 /* MultiPolygon */:
+        const multiPolygon = parseMultiPolygon2(dataView, offset, dimensions, littleEndian);
+        multiPolygon.type = "Polygon";
+        return multiPolygon;
+      default:
+        throw new Error(`WKB: Unsupported geometry type: ${geometryType}`);
     }
-    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;
+  }
+  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;
     }
-    white(state);
     return {
-      type: "MultiPoint",
-      coordinates: c
+      geometry: { type: "Point", positions: { value: positions, size: dimension } },
+      offset
     };
   }
-  function parseLineString(state) {
-    if (!$(/^(LINESTRING(\sz)?)/i, state)) {
-      return null;
-    }
-    white(state);
-    if (!$(/^(\()/, state)) {
-      return null;
-    }
-    const c = coords(state);
-    if (!c) {
-      return null;
+  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;
     }
-    if (!$(/^(\))/, state)) {
-      return null;
+    const pathIndices = [0];
+    if (nPoints > 0) {
+      pathIndices.push(nPoints);
     }
     return {
-      type: "LineString",
-      coordinates: c
+      geometry: {
+        type: "LineString",
+        positions: { value: positions, size: dimension },
+        pathIndices: { value: new Uint32Array(pathIndices), size: 1 }
+      },
+      offset
     };
   }
-  function parseMultiLineString(state) {
-    if (!$(/^(MULTILINESTRING)/i, state))
-      return null;
-    white(state);
-    const c = multicoords(state);
-    if (!c) {
-      return null;
+  var cumulativeSum = (sum) => (value) => sum += 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);
     }
-    white(state);
+    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 {
-      // @ts-ignore
-      type: "MultiLineString",
-      // @ts-expect-error
-      coordinates: c
+      geometry: {
+        type: "Polygon",
+        positions: { value: concatenatedPositions, size: dimension },
+        polygonIndices: {
+          value: new Uint32Array(polygonIndices),
+          size: 1
+        },
+        primitivePolygonIndices: { value: new Uint32Array(primitivePolygonIndices), size: 1 }
+      },
+      offset
     };
   }
-  function parsePolygon(state) {
-    if (!$(/^(POLYGON(\sz)?)/i, state)) {
-      return null;
+  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);
     }
-    white(state);
-    const c = multicoords(state);
-    if (!c) {
-      return null;
+    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 {
-      // @ts-ignore
-      type: "Polygon",
-      // @ts-expect-error
-      coordinates: c
+      type: "Point",
+      positions: { value: concatenatedPositions, size: dimension }
     };
   }
-  function parseMultiPolygon(state) {
-    if (!$(/^(MULTIPOLYGON)/i, state)) {
-      return null;
-    }
-    white(state);
-    const c = multicoords(state);
-    if (!c) {
-      return null;
-    }
+  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: "MultiPolygon",
-      // @ts-expect-error
-      coordinates: c
+      type: "LineString",
+      positions: { value: concatenatedPositions, size: dimension },
+      pathIndices: { value: new Uint32Array(pathIndices), size: 1 }
     };
   }
-  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);
+  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);
     }
-    if (!$(/^(\))/, state)) {
-      return null;
+    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: "GeometryCollection",
-      geometries
+      type: "Polygon",
+      positions: { value: concatenatedPositions, size: dimension },
+      polygonIndices: { value: new Uint32Array(polygonIndices), size: 1 },
+      primitivePolygonIndices: { value: new Uint32Array(primitivePolygonIndices), size: 1 }
     };
   }
-  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);
+  function concatTypedArrays(arrays) {
+    let byteLength = 0;
+    for (let i = 0; i < arrays.length; ++i) {
+      byteLength += arrays[i].byteLength;
     }
-    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));
+    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];
       }
-      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);
+    return buffer;
   }
 
-  // ../wkt/src/wkt-loader.ts
-  var WKTWorkerLoader = {
+  // ../wkt/src/wkb-loader.ts
+  var WKBWorkerLoader = {
     dataType: null,
     batchType: null,
-    name: "WKT (Well-Known Text)",
-    id: "wkt",
+    name: "WKB",
+    id: "wkb",
     module: "wkt",
-    version: VERSION3,
+    version: VERSION2,
     worker: true,
-    extensions: ["wkt"],
-    mimeTypes: ["text/plain"],
     category: "geometry",
-    text: true,
-    tests: WKT_MAGIC_STRINGS,
-    testText: isWKT,
+    extensions: ["wkb"],
+    mimeTypes: [],
+    // TODO can we define static, serializable tests, eg. some binary strings?
+    tests: [isWKB],
     options: {
-      wkt: {
-        shape: "geojson-geometry",
-        crs: true
+      wkb: {
+        shape: "binary-geometry"
+        // 'geojson-geometry'
       }
     }
   };
-  var WKTLoader = {
-    ...WKTWorkerLoader,
-    parse: async (arrayBuffer, options) => parseWKT(new TextDecoder().decode(arrayBuffer), options),
-    parseTextSync: (string, options) => parseWKT(string, options)
+  var WKBLoader = {
+    ...WKBWorkerLoader,
+    parse: async (arrayBuffer) => parseWKB(arrayBuffer),
+    parseSync: parseWKB
   };
 
-  // ../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;
-  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;
+  // src/lib/geoarrow/convert-geoarrow-to-geojson-geometry.ts
+  function parseGeometryFromArrow(arrowCellValue, encoding) {
+    encoding = encoding?.toLowerCase();
+    if (!encoding || !arrowCellValue) {
+      return null;
     }
-    const geometryFlags = geometry - geometryType;
-    if (geometryFlags === 0 || geometryFlags === 1e3 || geometryFlags === 2e3 || geometryFlags === 3e3) {
-      return true;
+    let geometry;
+    switch (encoding) {
+      case "geoarrow.multipolygon":
+        geometry = arrowMultiPolygonToFeature(arrowCellValue);
+        break;
+      case "geoarrow.polygon":
+        geometry = arrowPolygonToFeature(arrowCellValue);
+        break;
+      case "geoarrow.multipoint":
+        geometry = arrowMultiPointToFeature(arrowCellValue);
+        break;
+      case "geoarrow.point":
+        geometry = arrowPointToFeature(arrowCellValue);
+        break;
+      case "geoarrow.multilinestring":
+        geometry = arrowMultiLineStringToFeature(arrowCellValue);
+        break;
+      case "geoarrow.linestring":
+        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}`);
+      }
     }
-    if ((geometryFlags & ~(EWKB_FLAG_Z | EWKB_FLAG_M | EWKB_FLAG_SRID)) !== 0) {
-      return false;
+    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 = [];
+    for (let m = 0; m < arrowMultiPolygon.length; m++) {
+      const arrowPolygon = arrowMultiPolygon.get(m);
+      const polygon = [];
+      for (let i = 0; arrowPolygon && i < arrowPolygon?.length; i++) {
+        const arrowRing = arrowPolygon?.get(i);
+        const ring = [];
+        for (let j = 0; arrowRing && j < arrowRing.length; j++) {
+          const arrowCoord = arrowRing.get(j);
+          const coord = Array.from(arrowCoord);
+          ring.push(coord);
+        }
+        polygon.push(ring);
+      }
+      multiPolygon.push(polygon);
     }
-    if (geometryFlags & EWKB_FLAG_SRID) {
-      const srid = dataView.getUint32(byteOffset, littleEndian);
-      byteOffset += 4;
-      if (srid > MAX_SRID) {
-        return false;
+    const geometry = {
+      type: "MultiPolygon",
+      coordinates: multiPolygon
+    };
+    return geometry;
+  }
+  function arrowPolygonToFeature(arrowPolygon) {
+    const polygon = [];
+    for (let i = 0; arrowPolygon && i < arrowPolygon.length; i++) {
+      const arrowRing = arrowPolygon.get(i);
+      const ring = [];
+      for (let j = 0; arrowRing && j < arrowRing.length; j++) {
+        const arrowCoord = arrowRing.get(j);
+        const coords2 = Array.from(arrowCoord);
+        ring.push(coords2);
       }
+      polygon.push(ring);
     }
-    return true;
+    const geometry = {
+      type: "Polygon",
+      coordinates: polygon
+    };
+    return geometry;
   }
-  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}`);
+  function arrowMultiPointToFeature(arrowMultiPoint) {
+    const multiPoint = [];
+    for (let i = 0; arrowMultiPoint && i < arrowMultiPoint.length; i++) {
+      const arrowPoint = arrowMultiPoint.get(i);
+      if (arrowPoint) {
+        const coord = Array.from(arrowPoint);
+        multiPoint.push(coord);
+      }
     }
-    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";
+    return {
+      type: "MultiPoint",
+      coordinates: multiPoint
+    };
+  }
+  function arrowPointToFeature(arrowPoint) {
+    const point = Array.from(arrowPoint);
+    return {
+      type: "Point",
+      coordinates: point
+    };
+  }
+  function arrowMultiLineStringToFeature(arrowMultiLineString) {
+    const multiLineString = [];
+    for (let i = 0; arrowMultiLineString && i < arrowMultiLineString.length; i++) {
+      const arrowLineString = arrowMultiLineString.get(i);
+      const lineString = [];
+      for (let j = 0; arrowLineString && j < arrowLineString.length; j++) {
+        const arrowCoord = arrowLineString.get(j);
+        if (arrowCoord) {
+          const coords2 = Array.from(arrowCoord);
+          lineString.push(coords2);
+        }
+      }
+      multiLineString.push(lineString);
     }
-    if (ewkbSRID) {
-      wkbHeader.type = "ewkb";
-      wkbHeader.srid = dataView.getUint32(wkbHeader.byteOffset, wkbHeader.littleEndian);
-      wkbHeader.byteOffset += 4;
+    return {
+      type: "MultiLineString",
+      coordinates: multiLineString
+    };
+  }
+  function arrowLineStringToFeature(arrowLineString) {
+    const lineString = [];
+    for (let i = 0; arrowLineString && i < arrowLineString.length; i++) {
+      const arrowCoord = arrowLineString.get(i);
+      if (arrowCoord) {
+        const coords2 = Array.from(arrowCoord);
+        lineString.push(coords2);
+      }
     }
-    return wkbHeader;
+    return {
+      type: "LineString",
+      coordinates: lineString
+    };
   }
 
-  // ../wkt/src/lib/parse-wkb.ts
-  function parseWKB(arrayBuffer, options) {
-    const binaryGeometry = parseWKBToBinary(arrayBuffer, options);
-    const shape = options?.wkb?.shape || "binary-geometry";
+  // src/lib/tables/convert-arrow-to-table.ts
+  function convertArrowToTable(arrowTable, shape) {
     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);
+      case "arrow-table":
+        return convertArrowToArrowTable(arrowTable);
+      case "array-row-table":
+        return convertArrowToArrayRowTable(arrowTable);
+      case "object-row-table":
+        return convertArrowToObjectRowTable(arrowTable);
+      case "columnar-table":
+        return convertArrowToColumnarTable(arrowTable);
+      case "geojson-table":
+        return convertArrowToGeoJSONTable(arrowTable);
       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 1 /* Point */:
-        const point = parsePoint2(dataView, offset, dimensions, littleEndian);
-        return point.geometry;
-      case 2 /* LineString */:
-        const line = parseLineString2(dataView, offset, dimensions, littleEndian);
-        return line.geometry;
-      case 3 /* Polygon */:
-        const polygon = parsePolygon2(dataView, offset, dimensions, littleEndian);
-        return polygon.geometry;
-      case 4 /* MultiPoint */:
-        const multiPoint = parseMultiPoint2(dataView, offset, dimensions, littleEndian);
-        multiPoint.type = "Point";
-        return multiPoint;
-      case 5 /* MultiLineString */:
-        const multiLine = parseMultiLineString2(dataView, offset, dimensions, littleEndian);
-        multiLine.type = "LineString";
-        return multiLine;
-      case 6 /* MultiPolygon */:
-        const multiPolygon = parseMultiPolygon2(dataView, offset, dimensions, littleEndian);
-        multiPolygon.type = "Polygon";
-        return multiPolygon;
-      default:
-        throw new Error(`WKB: Unsupported geometry type: ${geometryType}`);
-    }
+  function convertArrowToArrowTable(arrowTable) {
+    return {
+      shape: "arrow-table",
+      schema: convertArrowToSchema(arrowTable.schema),
+      data: arrowTable
+    };
   }
-  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;
+  function convertArrowToArrayRowTable(arrowTable) {
+    const columnarTable = convertArrowToColumnarTable(arrowTable);
+    return convertTable(columnarTable, "array-row-table");
+  }
+  function convertArrowToObjectRowTable(arrowTable) {
+    const columnarTable = convertArrowToColumnarTable(arrowTable);
+    return convertTable(columnarTable, "object-row-table");
+  }
+  function convertArrowToColumnarTable(arrowTable) {
+    const columns = {};
+    for (const field of arrowTable.schema.fields) {
+      const arrowColumn = arrowTable.getChild(field.name);
+      const values = arrowColumn?.toArray();
+      columns[field.name] = values;
     }
+    const schema = convertArrowToSchema(arrowTable.schema);
     return {
-      geometry: { type: "Point", positions: { value: positions, size: dimension } },
-      offset
+      shape: "columnar-table",
+      schema,
+      data: columns
     };
   }
-  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);
+  function convertArrowToGeoJSONTable(arrowTable) {
+    const schema = convertArrowToSchema(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 {
-      geometry: {
-        type: "LineString",
-        positions: { value: positions, size: dimension },
-        pathIndices: { value: new Uint32Array(pathIndices), size: 1 }
-      },
-      offset
+      shape: "geojson-table",
+      type: "FeatureCollection",
+      schema,
+      features
     };
   }
-  var cumulativeSum = (sum) => (value) => sum += 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);
+
+  // src/lib/parsers/parse-arrow.ts
+  function parseArrowSync(arrayBuffer, options) {
+    const shape = options?.shape || "arrow-table";
+    const arrowTable = tableFromIPC([new Uint8Array(arrayBuffer)]);
+    return convertArrowToTable(arrowTable, shape);
+  }
+  function parseArrowInBatches(asyncIterator, options) {
+    async function* makeArrowAsyncIterator() {
+      const readers = RecordBatchReader.readAll(asyncIterator);
+      for await (const reader of readers) {
+        for await (const recordBatch of reader) {
+          if (options?.arrow?.batchDebounceMs !== void 0 && options?.arrow?.batchDebounceMs > 0) {
+            await new Promise((resolve) => setTimeout(resolve, options.arrow?.batchDebounceMs || 0));
+          }
+          const arrowTabledBatch = {
+            shape: "arrow-table",
+            batchType: "data",
+            data: new Table([recordBatch]),
+            length: recordBatch.data.length
+          };
+          yield arrowTabledBatch;
+        }
+        break;
+      }
     }
-    const concatenatedPositions = new Float64Array(concatTypedArrays(rings).buffer);
-    const polygonIndices = [0];
-    if (concatenatedPositions.length > 0) {
-      polygonIndices.push(concatenatedPositions.length / dimension);
+    return makeArrowAsyncIterator();
+  }
+
+  // src/arrow-loader.ts
+  var ArrowLoader = {
+    ...ArrowWorkerLoader,
+    parse: async (arraybuffer, options) => parseArrowSync(arraybuffer, options?.arrow),
+    parseSync: (arraybuffer, options) => parseArrowSync(arraybuffer, options?.arrow),
+    parseInBatches: parseArrowInBatches
+  };
+
+  // src/lib/encoders/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 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 Uint32Array(polygonIndices),
-          size: 1
-        },
-        primitivePolygonIndices: { value: new Uint32Array(primitivePolygonIndices), size: 1 }
-      },
-      offset
-    };
+    const table = new Table(vectors);
+    const arrowBuffer = tableToIPC(table);
+    return arrowBuffer;
   }
-  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");
+  function createVector(array, type) {
+    switch (type) {
+      case 1 /* DATE */:
+        return vectorFromArray(array);
+      case 0 /* FLOAT */:
+      default:
+        return vectorFromArray(array);
+    }
+  }
+
+  // src/arrow-writer.ts
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var ArrowWriter = {
+    name: "Apache Arrow",
+    id: "arrow",
+    module: "arrow",
+    version: VERSION3,
+    extensions: ["arrow", "feather"],
+    mimeTypes: [
+      "application/vnd.apache.arrow.file",
+      "application/vnd.apache.arrow.stream",
+      "application/octet-stream"
+    ],
+    binary: true,
+    options: {},
+    encode: async function encodeArrow(data, options) {
+      return encodeArrowSync(data);
+    },
+    encodeSync(data, options) {
+      return encodeArrowSync(data);
+    }
+  };
+
+  // src/exports/geoarrow-loader.ts
+  var GeoArrowWorkerLoader = {
+    ...ArrowWorkerLoader,
+    options: {
+      arrow: {
+        shape: "arrow-table"
       }
-      offset += 4;
-      const parsed = parsePoint2(dataView, offset, dimension, littleEndianPoint);
-      offset = parsed.offset;
-      binaryPointGeometries.push(parsed.geometry);
     }
-    return concatenateBinaryPointGeometries(binaryPointGeometries, dimension);
+  };
+
+  // src/lib/parsers/parse-geoarrow.ts
+  function parseGeoArrowSync(arrayBuffer, options) {
+    const table = parseArrowSync(arrayBuffer, { shape: "arrow-table" });
+    switch (options?.shape) {
+      case "geojson-table":
+        return convertArrowToTable(table.data, "geojson-table");
+      default:
+        return table;
+    }
+  }
+  function parseGeoArrowInBatches(asyncIterator) {
+    return parseArrowInBatches(asyncIterator);
+  }
+
+  // src/geoarrow-loader.ts
+  var GeoArrowLoader = {
+    ...GeoArrowWorkerLoader,
+    parse: async (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options?.arrow),
+    parseSync: (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options?.arrow),
+    parseInBatches: parseGeoArrowInBatches
+  };
+
+  // src/lib/tables/convert-table-to-arrow.ts
+  function convertTableToArrow(table, options) {
+    switch (table.shape) {
+      case "arrow-table":
+        return table.data;
+      case "columnar-table":
+      default:
+        const arrowBatchIterator = makeTableToArrowBatchesIterator(table, options);
+        return new Table(arrowBatchIterator);
+    }
   }
-  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");
+  function* makeTableToArrowBatchesIterator(table, options) {
+    const arrowSchema = deserializeArrowSchema(table.schema);
+    const length = getTableLength(table);
+    const numColumns = getTableNumCols(table);
+    const batchSize = options?.batchSize || length;
+    const builders = arrowSchema?.fields.map((arrowField) => makeBuilder(arrowField));
+    const structField = new Struct(arrowSchema.fields);
+    let batchLength = 0;
+    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+      for (let columnIndex = 0; columnIndex < numColumns; ++columnIndex) {
+        const value = getTableCellAt(table, rowIndex, columnIndex);
+        const builder = builders[columnIndex];
+        builder.append(value);
+        batchLength++;
+        if (batchLength >= batchSize) {
+          const datas = builders.map((builder2) => builder2.flush());
+          const structData = new Data(structField, 0, batchLength, 0, void 0, datas);
+          yield new RecordBatch2(arrowSchema, structData);
+          batchLength = 0;
+        }
       }
-      offset += 4;
-      const parsed = parseLineString2(dataView, offset, dimension, littleEndianLine);
-      offset = parsed.offset;
-      binaryLineGeometries.push(parsed.geometry);
     }
-    return concatenateBinaryLineGeometries(binaryLineGeometries, dimension);
+    if (batchLength > 0) {
+      const datas = builders.map((builder) => builder.flush());
+      const structData = new Data(structField, 0, batchLength, 0, void 0, datas);
+      yield new RecordBatch2(arrowSchema, structData);
+      batchLength = 0;
+    }
+    builders.map((builder) => builder.finish());
   }
-  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");
+
+  // src/lib/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;
       }
-      offset += 4;
-      const parsed = parsePolygon2(dataView, offset, dimension, littleEndianPolygon);
-      offset = parsed.offset;
-      binaryPolygonGeometries.push(parsed.geometry);
     }
-    return concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension);
+    return newBounds;
   }
-  function concatenateBinaryPointGeometries(binaryPointGeometries, dimension) {
-    const positions = binaryPointGeometries.map((geometry) => geometry.positions.value);
-    const concatenatedPositions = new Float64Array(concatTypedArrays(positions).buffer);
+
+  // src/lib/geoarrow/convert-geoarrow-to-binary-geometry.ts
+  function getBinaryGeometryTemplate() {
     return {
-      type: "Point",
-      positions: { value: concatenatedPositions, size: dimension }
+      globalFeatureIds: { value: new Uint32Array(0), size: 1 },
+      positions: { value: new Float32Array(0), size: 2 },
+      properties: [],
+      numericProps: {},
+      featureIds: { value: new Uint32Array(0), size: 1 }
     };
   }
-  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 Uint32Array(pathIndices), 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"
     };
-  }
-  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])
-      );
-    }
+    const chunks = options?.chunkIndex !== void 0 && options?.chunkIndex >= 0 ? [geoColumn.data[options?.chunkIndex]] : geoColumn.data;
+    let bounds = [Infinity, Infinity, -Infinity, -Infinity];
+    let globalFeatureIdOffset = options?.chunkOffset || 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 },
+        // eslint-disable-next-line no-loop-func
+        properties: [...Array(chunk.length).keys()].map((i) => ({
+          index: i + globalFeatureIdOffset
+        }))
+      };
+      globalFeatureIdOffset += chunk.length;
+      binaryGeometries.push({
+        shape: "binary-feature-collection",
+        points: {
+          type: "Point",
+          ...getBinaryGeometryTemplate(),
+          ...featureTypes.point ? binaryContent : {}
+        },
+        lines: {
+          type: "LineString",
+          ...getBinaryGeometryTemplate(),
+          ...featureTypes.line ? binaryContent : {},
+          pathIndices: { value: featureTypes.line ? geomOffset : new Uint16Array(0), size: 1 }
+        },
+        polygons: {
+          type: "Polygon",
+          ...getBinaryGeometryTemplate(),
+          ...featureTypes.polygon ? binaryContent : {},
+          polygonIndices: {
+            // use geomOffset as polygonIndices same as primitivePolygonIndices since we are using earcut to get triangule indices
+            value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
+            size: 1
+          },
+          primitivePolygonIndices: {
+            value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
+            size: 1
+          },
+          ...triangles ? { triangles: { value: triangles, size: 1 } } : {}
+        }
+      });
+      bounds = updateBoundsFromGeoArrowSamples(flatCoordinateArray, nDim, bounds);
+    });
     return {
-      type: "Polygon",
-      positions: { value: concatenatedPositions, size: dimension },
-      polygonIndices: { value: new Uint32Array(polygonIndices), size: 1 },
-      primitivePolygonIndices: { value: new Uint32Array(primitivePolygonIndices), size: 1 }
+      binaryGeometries,
+      bounds,
+      featureTypes,
+      ...options?.calculateMeanCenters ? { meanCenters: getMeanCentersFromBinaryGeometries(binaryGeometries) } : {}
     };
   }
-  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];
+  function getMeanCentersFromBinaryGeometries(binaryGeometries) {
+    const globalMeanCenters = [];
+    binaryGeometries.forEach((binaryGeometry) => {
+      let binaryGeometryType = null;
+      if (binaryGeometry.points && binaryGeometry.points.positions.value.length > 0) {
+        binaryGeometryType = "points" /* points */;
+      } else if (binaryGeometry.lines && binaryGeometry.lines.positions.value.length > 0) {
+        binaryGeometryType = "lines" /* lines */;
+      } else if (binaryGeometry.polygons && binaryGeometry.polygons.positions.value.length > 0) {
+        binaryGeometryType = "polygons" /* polygons */;
       }
-    }
-    return buffer;
-  }
-
-  // ../wkt/src/wkb-loader.ts
-  var WKBWorkerLoader = {
-    dataType: null,
-    batchType: null,
-    name: "WKB",
-    id: "wkb",
-    module: "wkt",
-    version: VERSION3,
-    worker: true,
-    category: "geometry",
-    extensions: ["wkb"],
-    mimeTypes: [],
-    // TODO can we define static, serializable tests, eg. some binary strings?
-    tests: [isWKB],
-    options: {
-      wkb: {
-        shape: "binary-geometry"
-        // 'geojson-geometry'
+      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 === "polygons" /* 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);
     }
-  };
-  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(arrowCellValue);
-        break;
-      case "geoarrow.polygon":
-        geometry = arrowPolygonToFeature(arrowCellValue);
-        break;
-      case "geoarrow.multipoint":
-        geometry = arrowMultiPointToFeature(arrowCellValue);
-        break;
+    return meanCenters;
+  }
+  function getBinaryGeometriesFromChunk(chunk, geoEncoding, options) {
+    switch (geoEncoding) {
       case "geoarrow.point":
-        geometry = arrowPointToFeature(arrowCellValue);
-        break;
-      case "geoarrow.multilinestring":
-        geometry = arrowMultiLineStringToFeature(arrowCellValue);
-        break;
+      case "geoarrow.multipoint":
+        return getBinaryPointsFromChunk(chunk, geoEncoding);
       case "geoarrow.linestring":
-        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}`);
-      }
+      case "geoarrow.multilinestring":
+        return getBinaryLinesFromChunk(chunk, geoEncoding);
+      case "geoarrow.polygon":
+      case "geoarrow.multipolygon":
+        return getBinaryPolygonsFromChunk(chunk, geoEncoding, options);
+      default:
+        throw Error("invalid geoarrow encoding");
     }
-    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 = [];
-    for (let m = 0; m < arrowMultiPolygon.length; m++) {
-      const arrowPolygon = arrowMultiPolygon.get(m);
-      const polygon = [];
-      for (let i = 0; arrowPolygon && i < arrowPolygon?.length; i++) {
-        const arrowRing = arrowPolygon?.get(i);
-        const ring = [];
-        for (let j = 0; arrowRing && j < arrowRing.length; j++) {
-          const arrowCoord = arrowRing.get(j);
-          const coord = Array.from(arrowCoord);
-          ring.push(coord);
+  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("earcut failed e.g. invalid polygon");
+        }
+        for (let j = 0; j < triangleIndices.length; j++) {
+          triangles.push(triangleIndices[j] + startIdx);
         }
-        polygon.push(ring);
       }
-      multiPolygon.push(polygon);
-    }
-    const geometry = {
-      type: "MultiPolygon",
-      coordinates: multiPolygon
-    };
-    return geometry;
-  }
-  function arrowPolygonToFeature(arrowPolygon) {
-    const polygon = [];
-    for (let i = 0; arrowPolygon && i < arrowPolygon.length; i++) {
-      const arrowRing = arrowPolygon.get(i);
-      const ring = [];
-      for (let j = 0; arrowRing && j < arrowRing.length; j++) {
-        const arrowCoord = arrowRing.get(j);
-        const coords2 = Array.from(arrowCoord);
-        ring.push(coords2);
+      const trianglesUint32 = new Uint32Array(triangles.length);
+      for (let i = 0; i < triangles.length; i++) {
+        trianglesUint32[i] = triangles[i];
       }
-      polygon.push(ring);
+      return trianglesUint32;
+    } catch (error) {
+      return null;
     }
-    const geometry = {
-      type: "Polygon",
-      coordinates: polygon
-    };
-    return geometry;
   }
-  function arrowMultiPointToFeature(arrowMultiPoint) {
-    const multiPoint = [];
-    for (let i = 0; arrowMultiPoint && i < arrowMultiPoint.length; i++) {
-      const arrowPoint = arrowMultiPoint.get(i);
-      if (arrowPoint) {
-        const coord = Array.from(arrowPoint);
-        multiPoint.push(coord);
+  function getBinaryPolygonsFromChunk(chunk, geoEncoding, options) {
+    const isMultiPolygon = geoEncoding === "geoarrow.multipolygon";
+    const polygonData = isMultiPolygon ? chunk.children[0] : chunk;
+    const polygonOffset = polygonData.valueOffsets;
+    const partData = isMultiPolygon ? chunk.valueOffsets.map((i) => polygonOffset.at(i) || i) : chunk.valueOffsets;
+    const ringData = polygonData.children[0];
+    const pointData = ringData.children[0];
+    const coordData = pointData.children[0];
+    const nDim = pointData.stride;
+    const geomOffset = ringData.valueOffsets;
+    const flatCoordinateArray = coordData.values;
+    const geometryIndicies = new Uint16Array(polygonOffset.length);
+    for (let i = 0; i < polygonOffset.length; i++) {
+      geometryIndicies[i] = geomOffset[polygonOffset[i]];
+    }
+    const numOfVertices = flatCoordinateArray.length / nDim;
+    const featureIds = new Uint32Array(numOfVertices);
+    for (let i = 0; i < partData.length - 1; i++) {
+      const startIdx = geomOffset[partData[i]];
+      const endIdx = geomOffset[partData[i + 1]];
+      for (let j = startIdx; j < endIdx; j++) {
+        featureIds[j] = i;
       }
     }
+    const triangles = options?.triangulate ? getTriangleIndices(geometryIndicies, geomOffset, flatCoordinateArray, nDim) : null;
     return {
-      type: "MultiPoint",
-      coordinates: multiPoint
-    };
-  }
-  function arrowPointToFeature(arrowPoint) {
-    const point = Array.from(arrowPoint);
-    return {
-      type: "Point",
-      coordinates: point
+      featureIds,
+      nDim,
+      flatCoordinateArray,
+      geomOffset,
+      geometryIndicies,
+      ...options?.triangulate && triangles ? { triangles } : {}
     };
   }
-  function arrowMultiLineStringToFeature(arrowMultiLineString) {
-    const multiLineString = [];
-    for (let i = 0; arrowMultiLineString && i < arrowMultiLineString.length; i++) {
-      const arrowLineString = arrowMultiLineString.get(i);
-      const lineString = [];
-      for (let j = 0; arrowLineString && j < arrowLineString.length; j++) {
-        const arrowCoord = arrowLineString.get(j);
-        if (arrowCoord) {
-          const coords2 = Array.from(arrowCoord);
-          lineString.push(coords2);
+  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;
         }
       }
-      multiLineString.push(lineString);
     }
     return {
-      type: "MultiLineString",
-      coordinates: multiLineString
+      featureIds,
+      flatCoordinateArray,
+      nDim,
+      geomOffset,
+      geometryIndicies
     };
   }
-  function arrowLineStringToFeature(arrowLineString) {
-    const lineString = [];
-    for (let i = 0; arrowLineString && i < arrowLineString.length; i++) {
-      const arrowCoord = arrowLineString.get(i);
-      if (arrowCoord) {
-        const coords2 = Array.from(arrowCoord);
-        lineString.push(coords2);
+  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 {
-      type: "LineString",
-      coordinates: lineString
+      featureIds,
+      flatCoordinateArray,
+      nDim,
+      geomOffset,
+      geometryIndicies
     };
   }