@loaders.gl/gis 4.3.1 → 4.4.0-alpha.1

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,280 +17,1129 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
-  GEOPARQUET_METADATA_JSON_SCHEMA: () => GEOPARQUET_METADATA_JSON_SCHEMA,
-  binaryToGeojson: () => binaryToGeojson,
-  binaryToGeometry: () => binaryToGeometry,
+  WKT_MAGIC_STRINGS: () => WKT_MAGIC_STRINGS,
+  _extractNumericPropTypes: () => extractNumericPropTypes,
+  binaryToGeojson: () => convertBinaryFeatureCollectionToGeojson,
+  convertBinaryFeatureCollectionToGeojson: () => convertBinaryFeatureCollectionToGeojson,
+  convertBinaryGeometryToGeometry: () => convertBinaryGeometryToGeometry,
+  convertFlatGeojsonToBinaryFeatureCollection: () => convertFlatGeojsonToBinaryFeatureCollection,
+  convertGeoArrowGeometryToGeoJSON: () => convertGeoArrowGeometryToGeoJSON,
+  convertGeoArrowToBinaryFeatureCollection: () => convertGeoArrowToBinaryFeatureCollection,
+  convertGeoArrowToTable: () => convertGeoArrowToTable,
+  convertGeojsonToBinaryFeatureCollection: () => convertGeojsonToBinaryFeatureCollection,
+  convertGeojsonToFlatGeojson: () => convertGeojsonToFlatGeojson,
+  convertGeometryToTWKB: () => convertGeometryToTWKB,
+  convertGeometryToWKB: () => convertGeometryToWKB,
+  convertGeometryToWKT: () => convertGeometryToWKT,
+  convertTWKBToGeometry: () => convertTWKBToGeometry,
   convertWKBTableToGeoJSON: () => convertWKBTableToGeoJSON,
-  flatGeojsonToBinary: () => flatGeojsonToBinary,
-  geojsonToBinary: () => geojsonToBinary,
-  geojsonToFlatGeojson: () => geojsonToFlatGeojson,
-  getGeoMetadata: () => getGeoMetadata,
-  getGeometryColumnsFromSchema: () => getGeometryColumnsFromSchema,
-  setGeoMetadata: () => setGeoMetadata,
+  convertWKBToBinaryGeometry: () => convertWKBToBinaryGeometry,
+  convertWKBToGeometry: () => convertWKBToGeometry,
+  convertWKTToGeometry: () => convertWKTToGeometry,
+  decodeHex: () => decodeHex,
+  encodeHex: () => encodeHex,
+  encodeWKTCRS: () => encodeWKTCRS,
+  flatGeojsonToBinary: () => convertFlatGeojsonToBinaryFeatureCollection,
+  geojsonToBinary: () => convertGeojsonToBinaryFeatureCollection,
+  geojsonToFlatGeojson: () => convertGeojsonToFlatGeojson,
+  getBinaryGeometriesFromArrow: () => convertGeoArrowToBinaryFeatureCollection,
+  getBinaryGeometryInfo: () => getBinaryGeometryInfo,
+  getBinaryGeometryTemplate: () => getBinaryGeometryTemplate,
+  getGeometryInfo: () => getGeometryInfo,
+  getMeanCentersFromBinaryGeometries: () => getMeanCentersFromBinaryGeometries,
+  getTriangleIndices: () => getTriangleIndices,
+  isTWKB: () => isTWKB,
+  isWKB: () => isWKB,
+  isWKT: () => isWKT,
+  parseWKTCRS: () => parseWKTCRS,
   transformBinaryCoords: () => transformBinaryCoords,
-  transformGeoJsonCoords: () => transformGeoJsonCoords,
-  unpackGeoMetadata: () => unpackGeoMetadata,
-  unpackJSONStringMetadata: () => unpackJSONStringMetadata
+  transformGeoJsonCoords: () => transformGeoJsonCoords
 });
 module.exports = __toCommonJS(dist_exports);
 
-// dist/lib/geo/geoparquet-metadata-schema.js
-var GEOPARQUET_METADATA_JSON_SCHEMA = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  title: "GeoParquet",
-  description: "Parquet metadata included in the geo field.",
-  type: "object",
-  required: ["version", "primary_column", "columns"],
-  properties: {
-    version: { type: "string", const: "1.0.0-beta.1" },
-    primary_column: { type: "string", minLength: 1 },
-    columns: {
-      type: "object",
-      minProperties: 1,
-      patternProperties: {
-        ".+": {
-          type: "object",
-          required: ["encoding", "geometry_types"],
-          properties: {
-            encoding: { type: "string", const: "WKB" },
-            geometry_types: {
-              type: "array",
-              uniqueItems: true,
-              items: {
-                type: "string",
-                pattern: "^(GeometryCollection|(Multi)?(Point|LineString|Polygon))( Z)?$"
-              }
-            },
-            crs: {
-              oneOf: [
-                {
-                  $ref: "https://proj.org/schemas/v0.5/projjson.schema.json"
-                },
-                { type: "null" }
-              ]
-            },
-            edges: { type: "string", enum: ["planar", "spherical"] },
-            orientation: { type: "string", const: "counterclockwise" },
-            bbox: {
-              type: "array",
-              items: { type: "number" },
-              oneOf: [
-                {
-                  description: "2D bbox consisting of (xmin, ymin, xmax, ymax)",
-                  minItems: 4,
-                  maxItems: 4
-                },
-                {
-                  description: "3D bbox consisting of (xmin, ymin, zmin, xmax, ymax, zmax)",
-                  minItems: 6,
-                  maxItems: 6
-                }
-              ]
-            },
-            epoch: { type: "number" }
+// dist/lib/geometry-api/geometry-info.js
+function getGeometryInfo(features) {
+  let pointPositionsCount = 0;
+  let pointFeaturesCount = 0;
+  let linePositionsCount = 0;
+  let linePathsCount = 0;
+  let lineFeaturesCount = 0;
+  let polygonPositionsCount = 0;
+  let polygonObjectsCount = 0;
+  let polygonRingsCount = 0;
+  let polygonFeaturesCount = 0;
+  const coordLengths = /* @__PURE__ */ new Set();
+  for (const feature of features) {
+    const geometry = feature.geometry;
+    switch (geometry.type) {
+      case "Point":
+        pointFeaturesCount++;
+        pointPositionsCount++;
+        coordLengths.add(geometry.coordinates.length);
+        break;
+      case "MultiPoint":
+        pointFeaturesCount++;
+        pointPositionsCount += geometry.coordinates.length;
+        for (const point of geometry.coordinates) {
+          coordLengths.add(point.length);
+        }
+        break;
+      case "LineString":
+        lineFeaturesCount++;
+        linePositionsCount += geometry.coordinates.length;
+        linePathsCount++;
+        for (const coord of geometry.coordinates) {
+          coordLengths.add(coord.length);
+        }
+        break;
+      case "MultiLineString":
+        lineFeaturesCount++;
+        for (const line of geometry.coordinates) {
+          linePositionsCount += line.length;
+          linePathsCount++;
+          for (const coord of line) {
+            coordLengths.add(coord.length);
           }
         }
-      },
-      additionalProperties: false
+        break;
+      case "Polygon":
+        polygonFeaturesCount++;
+        polygonObjectsCount++;
+        polygonRingsCount += geometry.coordinates.length;
+        const flattened = geometry.coordinates.flat();
+        polygonPositionsCount += flattened.length;
+        for (const coord of flattened) {
+          coordLengths.add(coord.length);
+        }
+        break;
+      case "MultiPolygon":
+        polygonFeaturesCount++;
+        for (const polygon of geometry.coordinates) {
+          polygonObjectsCount++;
+          polygonRingsCount += polygon.length;
+          const flattened2 = polygon.flat();
+          polygonPositionsCount += flattened2.length;
+          for (const coord of flattened2) {
+            coordLengths.add(coord.length);
+          }
+        }
+        break;
+      default:
+        throw new Error(`Unsupported geometry type: ${geometry.type}`);
     }
   }
-};
+  return {
+    coordLength: coordLengths.size > 0 ? Math.max(...coordLengths) : 2,
+    pointPositionsCount,
+    pointFeaturesCount,
+    linePositionsCount,
+    linePathsCount,
+    lineFeaturesCount,
+    polygonPositionsCount,
+    polygonObjectsCount,
+    polygonRingsCount,
+    polygonFeaturesCount
+  };
+}
 
-// dist/lib/geo/geoparquet-metadata.js
-function getGeoMetadata(schema) {
-  const geoMetadata = parseJSONStringMetadata(schema, "geo");
-  if (!geoMetadata) {
-    return null;
+// dist/lib/binary-geometry-api/binary-geometry-info.js
+function getBinaryGeometryInfo(geometry) {
+  return {
+    isMultiGeometry: isMultiGeometryType(geometry),
+    multiGeometryType: getMultiGeometryType(geometry),
+    dimension: geometry.positions.size,
+    pointCount: geometry.positions.value.length / geometry.positions.size,
+    coordinateCount: geometry.positions.value.length
+  };
+}
+function isMultiGeometryType(geometry) {
+  switch (geometry.type) {
+    case "Point":
+      const { positions } = geometry;
+      return positions.value.length / positions.size > 1;
+    case "LineString":
+      const { pathIndices } = geometry;
+      return pathIndices.value.length > 1;
+    case "Polygon":
+      const { polygonIndices } = geometry;
+      return polygonIndices.value.length > 1;
+    default:
+      return false;
+  }
+}
+function getMultiGeometryType(geometry) {
+  const isMulti = isMultiGeometryType(geometry);
+  switch (geometry.type) {
+    case "Point":
+      return isMulti ? "MultiPoint" : "Point";
+    case "LineString":
+      return isMulti ? "MultiLineString" : "LineString";
+    case "Polygon":
+      return isMulti ? "MultiPolygon" : "Polygon";
+    default:
+      throw new Error(`Illegal geometry type: ${type}`);
+  }
+}
+
+// dist/lib/binary-geometry-api/transform-coordinates.js
+function transformBinaryCoords(binaryFeatures, transformCoordinate) {
+  if (binaryFeatures.points) {
+    transformBinaryGeometryPositions(binaryFeatures.points, transformCoordinate);
   }
-  for (const column of Object.values(geoMetadata.columns || {})) {
-    if (column.encoding) {
-      column.encoding = column.encoding.toLowerCase();
+  if (binaryFeatures.lines) {
+    transformBinaryGeometryPositions(binaryFeatures.lines, transformCoordinate);
+  }
+  if (binaryFeatures.polygons) {
+    transformBinaryGeometryPositions(binaryFeatures.polygons, transformCoordinate);
+  }
+  return binaryFeatures;
+}
+function transformBinaryGeometryPositions(binaryGeometry, fn) {
+  const { positions } = binaryGeometry;
+  for (let i = 0; i < positions.value.length; i += positions.size) {
+    const coord = Array.from(positions.value.subarray(i, i + positions.size));
+    const transformedCoord = fn(coord);
+    positions.value.set(transformedCoord, i);
+  }
+}
+function transformGeoJsonCoords(features, fn) {
+  for (const feature of features) {
+    feature.geometry.coordinates = coordMap(feature.geometry.coordinates, fn);
+  }
+  return features;
+}
+function coordMap(array, fn) {
+  if (isCoord(array)) {
+    return fn(array);
+  }
+  return array.map((item) => {
+    return coordMap(item, fn);
+  });
+}
+function isCoord(array) {
+  return Array.isArray(array) && Number.isFinite(array[0]) && Number.isFinite(array[1]);
+}
+
+// dist/lib/table-converters/convert-geoarrow-table.js
+var arrow = __toESM(require("apache-arrow"), 1);
+var import_schema_utils = require("@loaders.gl/schema-utils");
+var import_geoarrow = require("@loaders.gl/geoarrow");
+
+// dist/lib/geometry-converters/convert-binary-geometry-to-geojson.js
+function convertBinaryGeometryToGeometry(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 == null ? void 0 : unexpectedInput.type}`);
+  }
+}
+function polygonToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
+  const { positions } = data;
+  const polygonIndices = data.polygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+  const primitivePolygonIndices = data.primitivePolygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+  const multi = polygonIndices.length > 2;
+  if (!multi) {
+    const coordinates2 = [];
+    for (let i = 0; i < primitivePolygonIndices.length - 1; i++) {
+      const startRingIndex = primitivePolygonIndices[i];
+      const endRingIndex = primitivePolygonIndices[i + 1];
+      const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
+      coordinates2.push(ringCoordinates);
     }
+    return { type: "Polygon", coordinates: coordinates2 };
+  }
+  const coordinates = [];
+  for (let i = 0; i < polygonIndices.length - 1; i++) {
+    const startPolygonIndex = polygonIndices[i];
+    const endPolygonIndex = polygonIndices[i + 1];
+    const polygonCoordinates = polygonToGeoJson(data, startPolygonIndex, endPolygonIndex).coordinates;
+    coordinates.push(polygonCoordinates);
   }
-  return geoMetadata;
+  return { type: "MultiPolygon", coordinates };
 }
-function setGeoMetadata(schema, geoMetadata) {
-  const stringifiedGeoMetadata = JSON.stringify(geoMetadata);
-  schema.metadata.geo = stringifiedGeoMetadata;
+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 unpackGeoMetadata(schema) {
-  const geoMetadata = getGeoMetadata(schema);
-  if (!geoMetadata) {
-    return;
+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 };
   }
-  const { version, primary_column, columns } = geoMetadata;
-  if (version) {
-    schema.metadata["geo.version"] = version;
+  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);
   }
-  if (primary_column) {
-    schema.metadata["geo.primary_column"] = primary_column;
+  return ringCoordinates;
+}
+
+// dist/lib/utils/concat-typed-arrays.js
+function concatTypedArrays(arrays) {
+  let byteLength = 0;
+  for (let i = 0; i < arrays.length; ++i) {
+    byteLength += arrays[i].byteLength;
   }
-  schema.metadata["geo.columns"] = Object.keys(columns || {}).join("");
-  for (const [columnName, columnMetadata] of Object.entries(columns || {})) {
-    const field = schema.fields.find((field2) => field2.name === columnName);
-    if (field) {
-      if (field.name === primary_column) {
-        setFieldMetadata(field, "geo.primary_field", "true");
-      }
-      unpackGeoFieldMetadata(field, columnMetadata);
+  const buffer = new Uint8Array(byteLength);
+  let byteOffset = 0;
+  for (let i = 0; i < arrays.length; ++i) {
+    const data = new Uint8Array(arrays[i].buffer);
+    byteLength = data.length;
+    for (let j = 0; j < byteLength; ++j) {
+      buffer[byteOffset++] = data[j];
     }
   }
+  return buffer;
 }
-function unpackGeoFieldMetadata(field, columnMetadata) {
-  for (const [key, value] of Object.entries(columnMetadata || {})) {
-    switch (key) {
-      case "geometry_types":
-        setFieldMetadata(field, `geo.${key}`, value.join(","));
-        break;
-      case "bbox":
-        setFieldMetadata(field, `geo.crs.${key}`, JSON.stringify(value));
-        break;
-      case "crs":
-        for (const [crsKey, crsValue] of Object.entries(value || {})) {
-          switch (crsKey) {
-            case "id":
-              const crsId = typeof crsValue === "object" ? (
-                // @ts-ignore
-                `${crsValue == null ? void 0 : crsValue.authority}:${crsValue == null ? void 0 : crsValue.code}`
-              ) : JSON.stringify(crsValue);
-              setFieldMetadata(field, `geo.crs.${crsKey}`, crsId);
-              break;
-            default:
-              setFieldMetadata(field, `geo.crs.${crsKey}`, typeof crsValue === "string" ? crsValue : JSON.stringify(crsValue));
-              break;
-          }
-        }
-        break;
-      case "edges":
-      default:
-        setFieldMetadata(field, `geo.${key}`, typeof value === "string" ? value : JSON.stringify(value));
+
+// dist/lib/binary-geometry-api/concat-binary-geometry.js
+function concatenateBinaryPointGeometries(binaryPointGeometries, dimension) {
+  const positions = binaryPointGeometries.map((geometry) => geometry.positions.value);
+  const concatenatedPositions = new Float64Array(concatTypedArrays(positions).buffer);
+  return {
+    type: "Point",
+    positions: { value: concatenatedPositions, size: dimension }
+  };
+}
+function concatenateBinaryLineGeometries(binaryLineGeometries, dimension) {
+  const lines = binaryLineGeometries.map((geometry) => geometry.positions.value);
+  const concatenatedPositions = new Float64Array(concatTypedArrays(lines).buffer);
+  const pathIndices = lines.map((line) => line.length / dimension).map(cumulativeSum(0));
+  pathIndices.unshift(0);
+  return {
+    type: "LineString",
+    positions: { value: concatenatedPositions, size: dimension },
+    pathIndices: { value: new Uint32Array(pathIndices), size: 1 }
+  };
+}
+function concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension) {
+  const polygons = [];
+  const primitivePolygons = [];
+  for (const binaryPolygon of binaryPolygonGeometries) {
+    const { positions, primitivePolygonIndices: primitivePolygonIndices2 } = binaryPolygon;
+    polygons.push(positions.value);
+    primitivePolygons.push(primitivePolygonIndices2.value);
+  }
+  const concatenatedPositions = new Float64Array(concatTypedArrays(polygons).buffer);
+  const polygonIndices = polygons.map((p) => p.length / dimension).map(cumulativeSum(0));
+  polygonIndices.unshift(0);
+  const primitivePolygonIndices = [0];
+  for (const primitivePolygon of primitivePolygons) {
+    primitivePolygonIndices.push(...primitivePolygon.filter((x) => x > 0).map((x) => x + primitivePolygonIndices[primitivePolygonIndices.length - 1]));
+  }
+  return {
+    type: "Polygon",
+    positions: { value: concatenatedPositions, size: dimension },
+    polygonIndices: { value: new Uint32Array(polygonIndices), size: 1 },
+    primitivePolygonIndices: { value: new Uint32Array(primitivePolygonIndices), size: 1 }
+  };
+}
+var cumulativeSum = (sum) => (value) => sum += value;
+
+// dist/lib/geometry-converters/wkb/helpers/wkb-types.js
+var WKBGeometryType;
+(function(WKBGeometryType2) {
+  WKBGeometryType2[WKBGeometryType2["Point"] = 1] = "Point";
+  WKBGeometryType2[WKBGeometryType2["LineString"] = 2] = "LineString";
+  WKBGeometryType2[WKBGeometryType2["Polygon"] = 3] = "Polygon";
+  WKBGeometryType2[WKBGeometryType2["MultiPoint"] = 4] = "MultiPoint";
+  WKBGeometryType2[WKBGeometryType2["MultiLineString"] = 5] = "MultiLineString";
+  WKBGeometryType2[WKBGeometryType2["MultiPolygon"] = 6] = "MultiPolygon";
+  WKBGeometryType2[WKBGeometryType2["GeometryCollection"] = 7] = "GeometryCollection";
+})(WKBGeometryType || (WKBGeometryType = {}));
+var EWKB_FLAG_Z = 2147483648;
+var EWKB_FLAG_M = 1073741824;
+var EWKB_FLAG_SRID = 536870912;
+var MAX_SRID = 1e4;
+var WKT_MAGIC_STRINGS = [
+  "POINT(",
+  "LINESTRING(",
+  "POLYGON(",
+  "MULTIPOINT(",
+  "MULTILINESTRING(",
+  "MULTIPOLYGON(",
+  "GEOMETRYCOLLECTION("
+];
+var textEncoder = new TextEncoder();
+var WKT_MAGIC_BYTES = WKT_MAGIC_STRINGS.map((string) => textEncoder.encode(string));
+
+// dist/lib/geometry-converters/wkb/helpers/parse-wkb-header.js
+function isWKT(input) {
+  return getWKTGeometryType(input) !== null;
+}
+function getWKTGeometryType(input) {
+  if (typeof input === "string") {
+    const index2 = WKT_MAGIC_STRINGS.findIndex((magicString) => input.startsWith(magicString));
+    return index2 >= 0 ? index2 + 1 : null;
+  }
+  const inputArray = new Uint8Array(input);
+  const index = WKT_MAGIC_BYTES.findIndex((magicBytes) => magicBytes.every((value, index2) => value === inputArray[index2]));
+  return index >= 0 ? index + 1 : null;
+}
+function isTWKB(arrayBuffer) {
+  const dataView = new DataView(arrayBuffer);
+  const byteOffset = 0;
+  const type2 = dataView.getUint8(byteOffset);
+  const geometryType = type2 & 15;
+  if (geometryType < 1 || geometryType > 7) {
+    return false;
+  }
+  return true;
+}
+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 setFieldMetadata(field, key, value) {
-  field.metadata = field.metadata || {};
-  field.metadata[key] = value;
+function parseWKBHeader(dataView, target) {
+  const wkbHeader = Object.assign(target || {}, {
+    type: "wkb",
+    variant: "wkb",
+    geometryType: 1,
+    dimensions: 2,
+    coordinates: "xy",
+    littleEndian: true,
+    byteOffset: 0
+  });
+  if (isWKT(dataView.buffer)) {
+    throw new Error("WKB: Cannot parse WKT data");
+  }
+  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.variant = "iso-wkb";
+      wkbHeader.dimensions = 3;
+      wkbHeader.coordinates = "xyz";
+      break;
+    case 2:
+      wkbHeader.variant = "iso-wkb";
+      wkbHeader.dimensions = 3;
+      wkbHeader.coordinates = "xym";
+      break;
+    case 3:
+      wkbHeader.variant = "iso-wkb";
+      wkbHeader.dimensions = 4;
+      wkbHeader.coordinates = "xyzm";
+      break;
+    default:
+      throw new Error(`WKB: Unsupported iso-wkb type: ${isoType}`);
+  }
+  const ewkbZ = geometryCode & EWKB_FLAG_Z;
+  const ewkbM = geometryCode & EWKB_FLAG_M;
+  const ewkbSRID = geometryCode & EWKB_FLAG_SRID;
+  if (ewkbZ && ewkbM) {
+    wkbHeader.variant = "ewkb";
+    wkbHeader.dimensions = 4;
+    wkbHeader.coordinates = "xyzm";
+  } else if (ewkbZ) {
+    wkbHeader.variant = "ewkb";
+    wkbHeader.dimensions = 3;
+    wkbHeader.coordinates = "xyz";
+  } else if (ewkbM) {
+    wkbHeader.variant = "ewkb";
+    wkbHeader.dimensions = 3;
+    wkbHeader.coordinates = "xym";
+  }
+  if (ewkbSRID) {
+    wkbHeader.variant = "ewkb";
+    wkbHeader.srid = dataView.getUint32(wkbHeader.byteOffset, wkbHeader.littleEndian);
+    wkbHeader.byteOffset += 4;
+  }
+  return wkbHeader;
+}
+
+// dist/lib/geometry-converters/wkb/convert-wkb-to-binary-geometry.js
+function convertWKBToBinaryGeometry(arrayBuffer) {
+  const dataView = new DataView(arrayBuffer);
+  const wkbHeader = parseWKBHeader(dataView);
+  const { geometryType, dimensions, littleEndian } = wkbHeader;
+  const offset = wkbHeader.byteOffset;
+  switch (geometryType) {
+    case WKBGeometryType.Point:
+      const point = parsePoint(dataView, offset, dimensions, littleEndian);
+      return point.geometry;
+    case WKBGeometryType.LineString:
+      const line = parseLineString(dataView, offset, dimensions, littleEndian);
+      return line.geometry;
+    case WKBGeometryType.Polygon:
+      const polygon = parsePolygon(dataView, offset, dimensions, littleEndian);
+      return polygon.geometry;
+    case WKBGeometryType.MultiPoint:
+      const multiPoint = parseMultiPoint(dataView, offset, dimensions, littleEndian);
+      multiPoint.type = "Point";
+      return multiPoint;
+    case WKBGeometryType.MultiLineString:
+      const multiLine = parseMultiLineString(dataView, offset, dimensions, littleEndian);
+      multiLine.type = "LineString";
+      return multiLine;
+    case WKBGeometryType.MultiPolygon:
+      const multiPolygon = parseMultiPolygon(dataView, offset, dimensions, littleEndian);
+      multiPolygon.type = "Polygon";
+      return multiPolygon;
+    default:
+      throw new Error(`WKB: Unsupported geometry type: ${geometryType}`);
+  }
+}
+function parsePoint(dataView, offset, dimension, littleEndian) {
+  const positions = new Float64Array(dimension);
+  for (let i = 0; i < dimension; i++) {
+    positions[i] = dataView.getFloat64(offset, littleEndian);
+    offset += 8;
+  }
+  return {
+    geometry: { type: "Point", positions: { value: positions, size: dimension } },
+    offset
+  };
+}
+function parseLineString(dataView, offset, dimension, littleEndian) {
+  const nPoints = dataView.getUint32(offset, littleEndian);
+  offset += 4;
+  const positions = new Float64Array(nPoints * dimension);
+  for (let i = 0; i < nPoints * dimension; i++) {
+    positions[i] = dataView.getFloat64(offset, littleEndian);
+    offset += 8;
+  }
+  const pathIndices = [0];
+  if (nPoints > 0) {
+    pathIndices.push(nPoints);
+  }
+  return {
+    geometry: {
+      type: "LineString",
+      positions: { value: positions, size: dimension },
+      pathIndices: { value: new Uint32Array(pathIndices), size: 1 }
+    },
+    offset
+  };
+}
+var cumulativeSum2 = (sum) => (value) => sum += value;
+function parsePolygon(dataView, offset, dimension, littleEndian) {
+  const nRings = dataView.getUint32(offset, littleEndian);
+  offset += 4;
+  const rings = [];
+  for (let i = 0; i < nRings; i++) {
+    const parsed = parseLineString(dataView, offset, dimension, littleEndian);
+    const { positions } = parsed.geometry;
+    offset = parsed.offset;
+    rings.push(positions.value);
+  }
+  const concatenatedPositions = new Float64Array(concatTypedArrays(rings).buffer);
+  const polygonIndices = [0];
+  if (concatenatedPositions.length > 0) {
+    polygonIndices.push(concatenatedPositions.length / dimension);
+  }
+  const primitivePolygonIndices = rings.map((l) => l.length / dimension).map(cumulativeSum2(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
+  };
+}
+function parseMultiPoint(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 = parsePoint(dataView, offset, dimension, littleEndianPoint);
+    offset = parsed.offset;
+    binaryPointGeometries.push(parsed.geometry);
+  }
+  return concatenateBinaryPointGeometries(binaryPointGeometries, dimension);
+}
+function parseMultiLineString(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 = parseLineString(dataView, offset, dimension, littleEndianLine);
+    offset = parsed.offset;
+    binaryLineGeometries.push(parsed.geometry);
+  }
+  return concatenateBinaryLineGeometries(binaryLineGeometries, dimension);
+}
+function parseMultiPolygon(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 = parsePolygon(dataView, offset, dimension, littleEndianPolygon);
+    offset = parsed.offset;
+    binaryPolygonGeometries.push(parsed.geometry);
+  }
+  return concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension);
+}
+
+// dist/lib/geometry-converters/wkb/convert-wkb-to-geometry.js
+function convertWKBToGeometry(arrayBuffer) {
+  const binaryGeometry = convertWKBToBinaryGeometry(arrayBuffer);
+  return convertBinaryGeometryToGeometry(binaryGeometry);
+}
+
+// dist/lib/geometry-converters/wkb/convert-wkt-to-geometry.js
+var numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
+var tuples = new RegExp("^" + numberRegexp.source + "(\\s" + numberRegexp.source + "){1,}");
+function convertWKTToGeometry(input, options) {
+  var _a;
+  const parts = input.split(";");
+  let _ = parts.pop();
+  const srid = (parts.shift() || "").split("=").pop();
+  const state = { parts, _, i: 0 };
+  const geometry = parseGeometry(state);
+  return ((_a = options == null ? void 0 : options.wkt) == null ? void 0 : _a.crs) ? addCRS(geometry, srid) : geometry;
+}
+function parseGeometry(state) {
+  return parsePoint2(state) || parseLineString2(state) || parsePolygon2(state) || parseMultiPoint2(state) || parseMultiLineString2(state) || parseMultiPolygon2(state) || parseGeometryCollection(state);
+}
+function addCRS(obj, srid) {
+  if (obj && (srid == null ? void 0 : srid.match(/\d+/))) {
+    const crs = {
+      type: "name",
+      properties: {
+        name: "urn:ogc:def:crs:EPSG::" + srid
+      }
+    };
+    obj.crs = crs;
+  }
+  return obj;
 }
-function parseJSONStringMetadata(schema, metadataKey) {
-  const stringifiedMetadata = schema.metadata[metadataKey];
-  if (!stringifiedMetadata) {
+function parsePoint2(state) {
+  if (!$(/^(POINT(\sz)?)/i, state)) {
     return null;
   }
-  try {
-    const metadata = JSON.parse(stringifiedMetadata);
-    if (!metadata || typeof metadata !== "object") {
+  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 parseMultiPoint2(state) {
+  var _a, _b;
+  if (!$(/^(MULTIPOINT)/i, state)) {
+    return null;
+  }
+  white(state);
+  const newCoordsFormat = (_b = state._) == null ? void 0 : _b.substring(((_a = state._) == null ? void 0 : _a.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 parseLineString2(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 parseMultiLineString2(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 parsePolygon2(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 parseMultiPolygon2(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;
     }
-    return metadata;
-  } catch {
+    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 unpackJSONStringMetadata(schema, metadataKey) {
-  const json = parseJSONStringMetadata(schema, metadataKey);
-  for (const [key, value] of Object.entries(json || {})) {
-    schema.metadata[`${metadataKey}.${key}`] = typeof value === "string" ? value : JSON.stringify(value);
+function $(regexp, state) {
+  var _a;
+  const match = (_a = state._) == null ? void 0 : _a.substring(state.i).match(regexp);
+  if (!match)
+    return null;
+  else {
+    state.i += match[0].length;
+    return match[0];
   }
 }
+function white(state) {
+  $(/^\s*/, state);
+}
 
-// dist/lib/geo/geoarrow-metadata.js
-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;
+// dist/lib/geometry-converters/convert-geoarrow-to-geojson.js
+function convertGeoArrowGeometryToGeoJSON(arrowCellValue, encoding) {
+  encoding = encoding == null ? void 0 : encoding.toLowerCase();
+  if (!encoding || !arrowCellValue) {
+    return null;
+  }
+  switch (encoding) {
+    case "geoarrow.multipolygon":
+      return arrowMultiPolygonToGeometry(arrowCellValue);
+    case "geoarrow.polygon":
+      return arrowPolygonToGeometry(arrowCellValue);
+    case "geoarrow.multipoint":
+      return arrowMultiPointToGeometry(arrowCellValue);
+    case "geoarrow.point":
+      return arrowPointToGeometry(arrowCellValue);
+    case "geoarrow.multilinestring":
+      return arrowMultiLineStringToGeometry(arrowCellValue);
+    case "geoarrow.linestring":
+      return arrowLineStringToGeometry(arrowCellValue);
+    case "geoarrow.wkb":
+      return arrowWKBToGeometry(arrowCellValue);
+    case "geoarrow.wkt":
+      return arrowWKTToGeometry(arrowCellValue);
+    default: {
+      throw Error(`GeoArrow encoding not supported ${encoding}`);
     }
   }
-  return geometryColumns;
 }
-function getGeometryMetadataForField(field) {
-  var _a, _b;
-  let metadata = null;
-  let geoEncoding = (_a = field.metadata) == null ? void 0 : _a[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;
+function arrowWKBToGeometry(arrowCellValue) {
+  const arrayBuffer = arrowCellValue.buffer.slice(arrowCellValue.byteOffset, arrowCellValue.byteOffset + arrowCellValue.byteLength);
+  return convertWKBToGeometry(arrayBuffer);
+}
+function arrowWKTToGeometry(arrowCellValue) {
+  const string = arrowCellValue;
+  return convertWKTToGeometry(string);
+}
+function arrowMultiPolygonToGeometry(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 == null ? void 0 : arrowPolygon.length); i++) {
+      const arrowRing = arrowPolygon == null ? void 0 : 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);
+  }
+  const geometry = {
+    type: "MultiPolygon",
+    coordinates: multiPolygon
+  };
+  return geometry;
+}
+function arrowPolygonToGeometry(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);
+  }
+  const geometry = {
+    type: "Polygon",
+    coordinates: polygon
+  };
+  return geometry;
+}
+function arrowMultiPointToGeometry(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);
+    }
+  }
+  return {
+    type: "MultiPoint",
+    coordinates: multiPoint
+  };
+}
+function arrowPointToGeometry(arrowPoint) {
+  const point = Array.from(arrowPoint);
+  return {
+    type: "Point",
+    coordinates: point
+  };
+}
+function arrowMultiLineStringToGeometry(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);
+  }
+  return {
+    type: "MultiLineString",
+    coordinates: multiLineString
+  };
+}
+function arrowLineStringToGeometry(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 {
+    type: "LineString",
+    coordinates: lineString
+  };
+}
+
+// dist/lib/table-converters/convert-geoarrow-table.js
+function convertGeoArrowToTable(arrowTable, shape) {
+  switch (shape) {
+    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 convertArrowToArrowTable(arrowTable) {
+  return {
+    shape: "arrow-table",
+    schema: (0, import_schema_utils.convertArrowToSchema)(arrowTable.schema),
+    data: arrowTable
+  };
+}
+function convertArrowToArrayRowTable(arrowTable) {
+  const columnarTable = convertArrowToColumnarTable(arrowTable);
+  return (0, import_schema_utils.convertTable)(columnarTable, "array-row-table");
+}
+function convertArrowToObjectRowTable(arrowTable) {
+  const columnarTable = convertArrowToColumnarTable(arrowTable);
+  return (0, import_schema_utils.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 == null ? void 0 : arrowColumn.toArray();
+    columns[field.name] = values;
   }
-  const columnMetadata = (_b = field.metadata) == null ? void 0 : _b[GEOARROW_COLUMN_METADATA_METADATA];
-  if (columnMetadata) {
-    try {
-      metadata = JSON.parse(columnMetadata);
-    } catch (error) {
-      console.warn("Failed to parse GeoArrow metadata", error);
+  const schema = (0, import_schema_utils.convertArrowToSchema)(arrowTable.schema);
+  return {
+    shape: "columnar-table",
+    schema,
+    data: columns
+  };
+}
+function convertArrowToGeoJSONTable(arrowTable) {
+  var _a;
+  const schema = (0, import_schema_utils.convertArrowToSchema)(arrowTable.schema);
+  const geometryColumns = (0, import_geoarrow.getGeometryColumnsFromSchema)(schema);
+  const encoding = geometryColumns.geometry.encoding;
+  const features = [];
+  const propertyColumnNames = arrowTable.schema.fields.map((field) => field.name).filter((name) => !(name in geometryColumns));
+  const propertiesTable = arrowTable.select(propertyColumnNames);
+  const arrowGeometryColumn = arrowTable.getChild("geometry");
+  for (let row = 0; row < arrowTable.numRows; row++) {
+    const arrowGeometry = arrowGeometryColumn == null ? void 0 : arrowGeometryColumn.get(row);
+    const feature = convertGeoArrowGeometryToGeoJSON(arrowGeometry, encoding);
+    if (feature) {
+      const properties = ((_a = propertiesTable.get(row)) == null ? void 0 : _a.toJSON()) || {};
+      features.push({ type: "Feature", geometry: feature, properties });
     }
   }
-  return metadata || null;
+  return {
+    shape: "geojson-table",
+    type: "FeatureCollection",
+    schema,
+    features
+  };
 }
 
-// dist/lib/tables/convert-table-to-geojson.js
-var import_schema = require("@loaders.gl/schema");
-function convertWKBTableToGeoJSON(table, schema, loaders) {
-  const geoMetadata = getGeoMetadata(schema);
+// dist/lib/table-converters/convert-wkb-table-to-geojson.js
+var import_schema_utils2 = require("@loaders.gl/schema-utils");
+var import_geoarrow2 = require("@loaders.gl/geoarrow");
+function convertWKBTableToGeoJSON(table, schema) {
+  const geoMetadata = (0, import_geoarrow2.getGeoMetadata)(schema.metadata);
   const primaryColumn = geoMetadata == null ? void 0 : geoMetadata.primary_column;
   if (!primaryColumn) {
     throw new Error("no geometry column");
   }
   const columnMetadata = geoMetadata.columns[primaryColumn];
   const features = [];
-  const length = (0, import_schema.getTableLength)(table);
+  const length = (0, import_schema_utils2.getTableLength)(table);
   for (let rowIndex = 0; rowIndex < length; rowIndex++) {
-    const row = (0, import_schema.getTableRowAsObject)(table, rowIndex);
-    const geometry = parseGeometry(row[primaryColumn], columnMetadata, loaders);
+    const row = (0, import_schema_utils2.getTableRowAsObject)(table, rowIndex);
+    const geometry = parseGeometry2(row[primaryColumn], columnMetadata);
     delete row[primaryColumn];
     const feature = { type: "Feature", geometry, properties: row };
     features.push(feature);
   }
   return { shape: "geojson-table", schema, type: "FeatureCollection", features };
 }
-function parseGeometry(geometry, columnMetadata, loaders) {
-  var _a, _b;
+function parseGeometry2(geometry, columnMetadata) {
   switch (columnMetadata.encoding) {
     case "wkt":
-      const wktLoader = loaders.find((loader) => loader.id === "wkt");
-      return ((_a = wktLoader == null ? void 0 : wktLoader.parseTextSync) == null ? void 0 : _a.call(wktLoader, geometry)) || null;
+      return convertWKTToGeometry(geometry) || null;
     case "wkb":
     default:
-      const wkbLoader = loaders.find((loader) => loader.id === "wkb");
       const arrayBuffer = ArrayBuffer.isView(geometry) ? geometry.buffer.slice(geometry.byteOffset, geometry.byteOffset + geometry.byteLength) : geometry;
-      const geojson = (_b = wkbLoader == null ? void 0 : wkbLoader.parseSync) == null ? void 0 : _b.call(wkbLoader, arrayBuffer, {
-        wkb: { shape: "geojson-geometry" }
-      });
-      return geojson;
+      return convertWKBToGeometry(arrayBuffer);
   }
 }
 
-// dist/lib/binary-features/flat-geojson-to-binary.js
+// dist/lib/feature-collection-converters/convert-flat-geojson-to-binary-features.js
 var import_polygon = require("@math.gl/polygon");
-function flatGeojsonToBinary(features, geometryInfo, options) {
+function convertFlatGeojsonToBinaryFeatureCollection(features, geometryInfo, options) {
   const propArrayTypes = extractNumericPropTypes(features);
   const numericPropKeys = Object.keys(propArrayTypes).filter((k) => propArrayTypes[k] !== Array);
   return fillArrays(features, {
@@ -514,111 +1365,26 @@ function fillNumericProperties(object, properties, index, length) {
       object.numericProps[numericPropName].fill(value, index, index + length);
     }
   }
-}
-function keepStringProperties(properties, numericKeys) {
-  const props = {};
-  for (const key in properties) {
-    if (!numericKeys.includes(key)) {
-      props[key] = properties[key];
-    }
-  }
-  return props;
-}
-function deduceArrayType(x, constructor) {
-  if (constructor === Array || !Number.isFinite(x)) {
-    return Array;
-  }
-  return constructor === Float64Array || Math.fround(x) !== x ? Float64Array : Float32Array;
-}
-
-// dist/lib/binary-features/extract-geometry-info.js
-function extractGeometryInfo(features) {
-  let pointPositionsCount = 0;
-  let pointFeaturesCount = 0;
-  let linePositionsCount = 0;
-  let linePathsCount = 0;
-  let lineFeaturesCount = 0;
-  let polygonPositionsCount = 0;
-  let polygonObjectsCount = 0;
-  let polygonRingsCount = 0;
-  let polygonFeaturesCount = 0;
-  const coordLengths = /* @__PURE__ */ new Set();
-  for (const feature of features) {
-    const geometry = feature.geometry;
-    switch (geometry.type) {
-      case "Point":
-        pointFeaturesCount++;
-        pointPositionsCount++;
-        coordLengths.add(geometry.coordinates.length);
-        break;
-      case "MultiPoint":
-        pointFeaturesCount++;
-        pointPositionsCount += geometry.coordinates.length;
-        for (const point of geometry.coordinates) {
-          coordLengths.add(point.length);
-        }
-        break;
-      case "LineString":
-        lineFeaturesCount++;
-        linePositionsCount += geometry.coordinates.length;
-        linePathsCount++;
-        for (const coord of geometry.coordinates) {
-          coordLengths.add(coord.length);
-        }
-        break;
-      case "MultiLineString":
-        lineFeaturesCount++;
-        for (const line of geometry.coordinates) {
-          linePositionsCount += line.length;
-          linePathsCount++;
-          for (const coord of line) {
-            coordLengths.add(coord.length);
-          }
-        }
-        break;
-      case "Polygon":
-        polygonFeaturesCount++;
-        polygonObjectsCount++;
-        polygonRingsCount += geometry.coordinates.length;
-        const flattened = geometry.coordinates.flat();
-        polygonPositionsCount += flattened.length;
-        for (const coord of flattened) {
-          coordLengths.add(coord.length);
-        }
-        break;
-      case "MultiPolygon":
-        polygonFeaturesCount++;
-        for (const polygon of geometry.coordinates) {
-          polygonObjectsCount++;
-          polygonRingsCount += polygon.length;
-          const flattened2 = polygon.flat();
-          polygonPositionsCount += flattened2.length;
-          for (const coord of flattened2) {
-            coordLengths.add(coord.length);
-          }
-        }
-        break;
-      default:
-        throw new Error(`Unsupported geometry type: ${geometry.type}`);
+}
+function keepStringProperties(properties, numericKeys) {
+  const props = {};
+  for (const key in properties) {
+    if (!numericKeys.includes(key)) {
+      props[key] = properties[key];
     }
   }
-  return {
-    coordLength: coordLengths.size > 0 ? Math.max(...coordLengths) : 2,
-    pointPositionsCount,
-    pointFeaturesCount,
-    linePositionsCount,
-    linePathsCount,
-    lineFeaturesCount,
-    polygonPositionsCount,
-    polygonObjectsCount,
-    polygonRingsCount,
-    polygonFeaturesCount
-  };
+  return props;
+}
+function deduceArrayType(x, constructor) {
+  if (constructor === Array || !Number.isFinite(x)) {
+    return Array;
+  }
+  return constructor === Float64Array || Math.fround(x) !== x ? Float64Array : Float32Array;
 }
 
-// dist/lib/binary-features/geojson-to-flat-geojson.js
+// dist/lib/feature-collection-converters/convert-geojson-to-flat-geojson.js
 var import_polygon2 = require("@math.gl/polygon");
-function geojsonToFlatGeojson(features, options = { coordLength: 2, fixRingWinding: true }) {
+function convertGeojsonToFlatGeojson(features, options = { coordLength: 2, fixRingWinding: true }) {
   return features.map((feature) => flattenFeature(feature, options));
 }
 function flattenPoint(coordinates, data, indices, options) {
@@ -666,251 +1432,1427 @@ function flattenFeature(feature, options) {
   const data = [];
   const indices = [];
   let areas;
-  let type;
+  let type2;
   switch (geometry.type) {
     case "Point":
-      type = "Point";
+      type2 = "Point";
       flattenPoint(geometry.coordinates, data, indices, options);
       break;
     case "MultiPoint":
-      type = "Point";
+      type2 = "Point";
       geometry.coordinates.map((c) => flattenPoint(c, data, indices, options));
       break;
     case "LineString":
-      type = "LineString";
+      type2 = "LineString";
       flattenLineString(geometry.coordinates, data, indices, options);
       break;
     case "MultiLineString":
-      type = "LineString";
+      type2 = "LineString";
       geometry.coordinates.map((c) => flattenLineString(c, data, indices, options));
       break;
     case "Polygon":
-      type = "Polygon";
+      type2 = "Polygon";
       areas = [];
       flattenPolygon(geometry.coordinates, data, indices, areas, options);
       break;
     case "MultiPolygon":
-      type = "Polygon";
+      type2 = "Polygon";
       areas = [];
       geometry.coordinates.map((c) => flattenPolygon(c, data, indices, areas, options));
       break;
     default:
-      throw new Error(`Unknown type: ${type}`);
+      throw new Error(`Unknown type: ${type2}`);
   }
-  return { ...feature, geometry: { type, indices, data, areas } };
+  return { ...feature, geometry: { type: type2, indices, data, areas } };
 }
 
-// dist/lib/binary-features/geojson-to-binary.js
-function geojsonToBinary(features, options = { fixRingWinding: true, triangulate: true }) {
-  const geometryInfo = extractGeometryInfo(features);
+// dist/lib/feature-collection-converters/convert-geojson-to-binary-features.js
+function convertGeojsonToBinaryFeatureCollection(features, options = { fixRingWinding: true, triangulate: true }) {
+  const geometryInfo = getGeometryInfo(features);
   const coordLength = geometryInfo.coordLength;
   const { fixRingWinding } = options;
-  const flatFeatures = geojsonToFlatGeojson(features, { coordLength, fixRingWinding });
-  return flatGeojsonToBinary(flatFeatures, geometryInfo, {
+  const flatFeatures = convertGeojsonToFlatGeojson(features, { coordLength, fixRingWinding });
+  return convertFlatGeojsonToBinaryFeatureCollection(flatFeatures, geometryInfo, {
     numericPropKeys: options.numericPropKeys,
     PositionDataType: options.PositionDataType || Float32Array,
     triangulate: options.triangulate
   });
 }
-
-// dist/lib/binary-features/binary-to-geojson.js
-function binaryToGeojson(data, options) {
-  const globalFeatureId = options == null ? void 0 : options.globalFeatureId;
-  if (globalFeatureId !== void 0) {
-    return getSingleFeature(data, globalFeatureId);
+
+// dist/lib/feature-collection-converters/convert-binary-features-to-geojson.js
+function convertBinaryFeatureCollectionToGeojson(data, options) {
+  const globalFeatureId = options == null ? void 0 : options.globalFeatureId;
+  if (globalFeatureId !== void 0) {
+    return getSingleFeature(data, globalFeatureId);
+  }
+  return parseFeatures(data, options == null ? void 0 : options.type);
+}
+function getSingleFeature(data, globalFeatureId) {
+  const dataArray = normalizeInput(data);
+  for (const data2 of dataArray) {
+    let lastIndex = 0;
+    let lastValue = data2.featureIds.value[0];
+    for (let i = 0; i < data2.featureIds.value.length; i++) {
+      const currValue = data2.featureIds.value[i];
+      if (currValue === lastValue) {
+        continue;
+      }
+      if (globalFeatureId === data2.globalFeatureIds.value[lastIndex]) {
+        return parseFeature(data2, lastIndex, i);
+      }
+      lastIndex = i;
+      lastValue = currValue;
+    }
+    if (globalFeatureId === data2.globalFeatureIds.value[lastIndex]) {
+      return parseFeature(data2, lastIndex, data2.featureIds.value.length);
+    }
+  }
+  throw new Error(`featureId:${globalFeatureId} not found`);
+}
+function parseFeatures(data, type2) {
+  const dataArray = normalizeInput(data, type2);
+  return parseFeatureCollection(dataArray);
+}
+function normalizeInput(data, type2) {
+  const features = [];
+  if (data.points) {
+    data.points.type = "Point";
+    features.push(data.points);
+  }
+  if (data.lines) {
+    data.lines.type = "LineString";
+    features.push(data.lines);
+  }
+  if (data.polygons) {
+    data.polygons.type = "Polygon";
+    features.push(data.polygons);
+  }
+  return features;
+}
+function parseFeatureCollection(dataArray) {
+  const features = [];
+  for (const data of dataArray) {
+    if (data.featureIds.value.length === 0) {
+      continue;
+    }
+    let lastIndex = 0;
+    let lastValue = data.featureIds.value[0];
+    for (let i = 0; i < data.featureIds.value.length; i++) {
+      const currValue = data.featureIds.value[i];
+      if (currValue === lastValue) {
+        continue;
+      }
+      features.push(parseFeature(data, lastIndex, i));
+      lastIndex = i;
+      lastValue = currValue;
+    }
+    features.push(parseFeature(data, lastIndex, data.featureIds.value.length));
+  }
+  return features;
+}
+function parseFeature(data, startIndex, endIndex) {
+  const geometry = convertBinaryGeometryToGeometry(data, startIndex, endIndex);
+  const properties = parseProperties(data, startIndex, endIndex);
+  const fields = parseFields(data, startIndex, endIndex);
+  return { type: "Feature", geometry, properties, ...fields };
+}
+function parseFields(data, startIndex = 0, endIndex) {
+  return data.fields && data.fields[data.featureIds.value[startIndex]];
+}
+function parseProperties(data, startIndex = 0, endIndex) {
+  const properties = Object.assign({}, data.properties[data.featureIds.value[startIndex]]);
+  for (const key in data.numericProps) {
+    properties[key] = data.numericProps[key].value[startIndex];
+  }
+  return properties;
+}
+
+// dist/lib/utils/binary-reader.js
+var BinaryReader = class {
+  arrayBuffer;
+  dataView;
+  byteOffset;
+  littleEndian;
+  constructor(arrayBuffer, isBigEndian = false) {
+    this.arrayBuffer = arrayBuffer;
+    this.dataView = new DataView(arrayBuffer);
+    this.byteOffset = 0;
+    this.littleEndian = !isBigEndian;
+  }
+  readUInt8() {
+    const value = this.dataView.getUint8(this.byteOffset);
+    this.byteOffset += 1;
+    return value;
+  }
+  readUInt16() {
+    const value = this.dataView.getUint16(this.byteOffset, this.littleEndian);
+    this.byteOffset += 2;
+    return value;
+  }
+  readUInt32() {
+    const value = this.dataView.getUint32(this.byteOffset, this.littleEndian);
+    this.byteOffset += 4;
+    return value;
+  }
+  readInt8() {
+    const value = this.dataView.getInt8(this.byteOffset);
+    this.byteOffset += 1;
+    return value;
+  }
+  readInt16() {
+    const value = this.dataView.getInt16(this.byteOffset, this.littleEndian);
+    this.byteOffset += 2;
+    return value;
+  }
+  readInt32() {
+    const value = this.dataView.getInt32(this.byteOffset, this.littleEndian);
+    this.byteOffset += 4;
+    return value;
+  }
+  readFloat() {
+    const value = this.dataView.getFloat32(this.byteOffset, this.littleEndian);
+    this.byteOffset += 4;
+    return value;
+  }
+  readDouble() {
+    const value = this.dataView.getFloat64(this.byteOffset, this.littleEndian);
+    this.byteOffset += 8;
+    return value;
+  }
+  readVarInt() {
+    let result = 0;
+    let bytesRead = 0;
+    let nextByte;
+    do {
+      nextByte = this.dataView.getUint8(this.byteOffset + bytesRead);
+      result += (nextByte & 127) << 7 * bytesRead;
+      bytesRead++;
+    } while (nextByte >= 128);
+    this.byteOffset += bytesRead;
+    return result;
+  }
+};
+
+// dist/lib/geometry-converters/wkb/convert-twkb-to-geometry.js
+function convertTWKBToGeometry(arrayBuffer) {
+  const binaryReader = new BinaryReader(arrayBuffer);
+  const context = parseTWKBHeader(binaryReader);
+  if (context.hasSizeAttribute) {
+    binaryReader.readVarInt();
+  }
+  if (context.hasBoundingBox) {
+    let dimensions = 2;
+    if (context.hasZ) {
+      dimensions++;
+    }
+    if (context.hasM) {
+      dimensions++;
+    }
+    for (let i = 0; i < dimensions; i++) {
+      binaryReader.readVarInt();
+      binaryReader.readVarInt();
+    }
+  }
+  return parseGeometry3(binaryReader, context, context.geometryType);
+}
+function parseTWKBHeader(binaryReader) {
+  const type2 = binaryReader.readUInt8();
+  const metadataHeader = binaryReader.readUInt8();
+  const geometryType = type2 & 15;
+  const precision = zigZagDecode(type2 >> 4);
+  const hasExtendedPrecision = Boolean(metadataHeader >> 3 & 1);
+  let hasZ = false;
+  let hasM = false;
+  let zPrecision = 0;
+  let zPrecisionFactor = 1;
+  let mPrecision = 0;
+  let mPrecisionFactor = 1;
+  if (hasExtendedPrecision) {
+    const extendedPrecision = binaryReader.readUInt8();
+    hasZ = (extendedPrecision & 1) === 1;
+    hasM = (extendedPrecision & 2) === 2;
+    zPrecision = zigZagDecode((extendedPrecision & 28) >> 2);
+    zPrecisionFactor = Math.pow(10, zPrecision);
+    mPrecision = zigZagDecode((extendedPrecision & 224) >> 5);
+    mPrecisionFactor = Math.pow(10, mPrecision);
+  }
+  return {
+    geometryType,
+    precision,
+    precisionFactor: Math.pow(10, precision),
+    hasBoundingBox: Boolean(metadataHeader >> 0 & 1),
+    hasSizeAttribute: Boolean(metadataHeader >> 1 & 1),
+    hasIdList: Boolean(metadataHeader >> 2 & 1),
+    hasExtendedPrecision,
+    isEmpty: Boolean(metadataHeader >> 4 & 1),
+    hasZ,
+    hasM,
+    zPrecision,
+    zPrecisionFactor,
+    mPrecision,
+    mPrecisionFactor
+  };
+}
+function parseGeometry3(binaryReader, context, geometryType) {
+  switch (geometryType) {
+    case WKBGeometryType.Point:
+      return parsePoint3(binaryReader, context);
+    case WKBGeometryType.LineString:
+      return parseLineString3(binaryReader, context);
+    case WKBGeometryType.Polygon:
+      return parsePolygon3(binaryReader, context);
+    case WKBGeometryType.MultiPoint:
+      return parseMultiPoint3(binaryReader, context);
+    case WKBGeometryType.MultiLineString:
+      return parseMultiLineString3(binaryReader, context);
+    case WKBGeometryType.MultiPolygon:
+      return parseMultiPolygon3(binaryReader, context);
+    case WKBGeometryType.GeometryCollection:
+      return parseGeometryCollection2(binaryReader, context);
+    default:
+      throw new Error(`GeometryType ${geometryType} not supported`);
+  }
+}
+function parsePoint3(reader, context) {
+  if (context.isEmpty) {
+    return { type: "Point", coordinates: [] };
+  }
+  return { type: "Point", coordinates: readFirstPoint(reader, context) };
+}
+function parseLineString3(reader, context) {
+  if (context.isEmpty) {
+    return { type: "LineString", coordinates: [] };
+  }
+  const pointCount = reader.readVarInt();
+  const previousPoint = makePreviousPoint(context);
+  const points = [];
+  for (let i = 0; i < pointCount; i++) {
+    points.push(parseNextPoint(reader, context, previousPoint));
+  }
+  return { type: "LineString", coordinates: points };
+}
+function parsePolygon3(reader, context) {
+  if (context.isEmpty) {
+    return { type: "Polygon", coordinates: [] };
+  }
+  const ringCount = reader.readVarInt();
+  const previousPoint = makePreviousPoint(context);
+  const exteriorRingLength = reader.readVarInt();
+  const exteriorRing = [];
+  for (let i = 0; i < exteriorRingLength; i++) {
+    exteriorRing.push(parseNextPoint(reader, context, previousPoint));
+  }
+  const polygon = [exteriorRing];
+  for (let i = 1; i < ringCount; i++) {
+    const interiorRingCount = reader.readVarInt();
+    const interiorRing = [];
+    for (let j = 0; j < interiorRingCount; j++) {
+      interiorRing.push(parseNextPoint(reader, context, previousPoint));
+    }
+    polygon.push(interiorRing);
+  }
+  return { type: "Polygon", coordinates: polygon };
+}
+function parseMultiPoint3(reader, context) {
+  if (context.isEmpty) {
+    return { type: "MultiPoint", coordinates: [] };
+  }
+  const previousPoint = makePreviousPoint(context);
+  const pointCount = reader.readVarInt();
+  const coordinates = [];
+  for (let i = 0; i < pointCount; i++) {
+    coordinates.push(parseNextPoint(reader, context, previousPoint));
+  }
+  return { type: "MultiPoint", coordinates };
+}
+function parseMultiLineString3(reader, context) {
+  if (context.isEmpty) {
+    return { type: "MultiLineString", coordinates: [] };
+  }
+  const previousPoint = makePreviousPoint(context);
+  const lineStringCount = reader.readVarInt();
+  const coordinates = [];
+  for (let i = 0; i < lineStringCount; i++) {
+    const pointCount = reader.readVarInt();
+    const lineString = [];
+    for (let j = 0; j < pointCount; j++) {
+      lineString.push(parseNextPoint(reader, context, previousPoint));
+    }
+    coordinates.push(lineString);
+  }
+  return { type: "MultiLineString", coordinates };
+}
+function parseMultiPolygon3(reader, context) {
+  if (context.isEmpty) {
+    return { type: "MultiPolygon", coordinates: [] };
+  }
+  const previousPoint = makePreviousPoint(context);
+  const polygonCount = reader.readVarInt();
+  const polygons = [];
+  for (let i = 0; i < polygonCount; i++) {
+    const ringCount = reader.readVarInt();
+    const exteriorPointCount = reader.readVarInt();
+    const exteriorRing = [];
+    for (let j = 0; j < exteriorPointCount; j++) {
+      exteriorRing.push(parseNextPoint(reader, context, previousPoint));
+    }
+    const polygon = exteriorRing ? [exteriorRing] : [];
+    for (let j = 1; j < ringCount; j++) {
+      const interiorRing = [];
+      const interiorRingLength = reader.readVarInt();
+      for (let k = 0; k < interiorRingLength; k++) {
+        interiorRing.push(parseNextPoint(reader, context, previousPoint));
+      }
+      polygon.push(interiorRing);
+    }
+    polygons.push(polygon);
+  }
+  return { type: "MultiPolygon", coordinates: polygons };
+}
+function parseGeometryCollection2(reader, context) {
+  return { type: "GeometryCollection", geometries: [] };
+}
+function zigZagDecode(value) {
+  return value >> 1 ^ -(value & 1);
+}
+function makePointCoordinates(x, y, z, m) {
+  return z !== void 0 ? m !== void 0 ? [x, y, z, m] : [x, y, z] : [x, y];
+}
+function makePreviousPoint(context) {
+  return makePointCoordinates(0, 0, context.hasZ ? 0 : void 0, context.hasM ? 0 : void 0);
+}
+function readFirstPoint(reader, context) {
+  const x = zigZagDecode(reader.readVarInt()) / context.precisionFactor;
+  const y = zigZagDecode(reader.readVarInt()) / context.precisionFactor;
+  const z = context.hasZ ? zigZagDecode(reader.readVarInt()) / context.zPrecisionFactor : void 0;
+  const m = context.hasM ? zigZagDecode(reader.readVarInt()) / context.mPrecisionFactor : void 0;
+  return makePointCoordinates(x, y, z, m);
+}
+function parseNextPoint(reader, context, previousPoint) {
+  previousPoint[0] += zigZagDecode(reader.readVarInt()) / context.precisionFactor;
+  previousPoint[1] += zigZagDecode(reader.readVarInt()) / context.precisionFactor;
+  if (context.hasZ) {
+    previousPoint[2] += zigZagDecode(reader.readVarInt()) / context.zPrecisionFactor;
+  }
+  if (context.hasM) {
+    previousPoint[3] += zigZagDecode(reader.readVarInt()) / context.mPrecisionFactor;
+  }
+  return previousPoint.slice();
+}
+
+// dist/lib/geometry-converters/wkb/convert-geometry-to-wkt.js
+function convertGeometryToWKT(geometry) {
+  switch (geometry.type) {
+    case "Point":
+      return `POINT ${wrapParens(pairWKT(geometry.coordinates))}`;
+    case "LineString":
+      return `LINESTRING ${wrapParens(ringWKT(geometry.coordinates))}`;
+    case "Polygon":
+      return `POLYGON ${wrapParens(ringsWKT(geometry.coordinates))}`;
+    case "MultiPoint":
+      return `MULTIPOINT ${wrapParens(ringWKT(geometry.coordinates))}`;
+    case "MultiPolygon":
+      return `MULTIPOLYGON ${wrapParens(multiRingsWKT(geometry.coordinates))}`;
+    case "MultiLineString":
+      return `MULTILINESTRING ${wrapParens(ringsWKT(geometry.coordinates))}`;
+    case "GeometryCollection":
+      return `GEOMETRYCOLLECTION ${wrapParens(geometry.geometries.map(convertGeometryToWKT).join(", "))}`;
+    default:
+      throw new Error("convertGeometryToWKT requires a valid GeoJSON Geometry (not Feature) as input");
+  }
+}
+function pairWKT(c) {
+  return c.join(" ");
+}
+function ringWKT(r) {
+  return r.map(pairWKT).join(", ");
+}
+function ringsWKT(r) {
+  return r.map(ringWKT).map(wrapParens).join(", ");
+}
+function multiRingsWKT(r) {
+  return r.map(ringsWKT).map(wrapParens).join(", ");
+}
+function wrapParens(s) {
+  return `(${s})`;
+}
+
+// dist/lib/utils/binary-writer.js
+var LE = true;
+var BE = false;
+var BinaryWriter = class {
+  arrayBuffer;
+  dataView;
+  byteOffset = 0;
+  allowResize = false;
+  constructor(size, allowResize) {
+    this.arrayBuffer = new ArrayBuffer(size);
+    this.dataView = new DataView(this.arrayBuffer);
+    this.byteOffset = 0;
+    this.allowResize = allowResize || false;
+  }
+  writeUInt8(value) {
+    this._ensureSize(1);
+    this.dataView.setUint8(this.byteOffset, value);
+    this.byteOffset += 1;
+  }
+  writeUInt16LE(value) {
+    this._ensureSize(2);
+    this.dataView.setUint16(this.byteOffset, value, LE);
+    this.byteOffset += 2;
+  }
+  writeUInt16BE(value) {
+    this._ensureSize(2);
+    this.dataView.setUint16(this.byteOffset, value, BE);
+    this.byteOffset += 2;
+  }
+  writeUInt32LE(value) {
+    this._ensureSize(4);
+    this.dataView.setUint32(this.byteOffset, value, LE);
+    this.byteOffset += 4;
+  }
+  writeUInt32BE(value) {
+    this._ensureSize(4);
+    this.dataView.setUint32(this.byteOffset, value, BE);
+    this.byteOffset += 4;
+  }
+  writeInt8(value) {
+    this._ensureSize(1);
+    this.dataView.setInt8(this.byteOffset, value);
+    this.byteOffset += 1;
+  }
+  writeInt16LE(value) {
+    this._ensureSize(2);
+    this.dataView.setInt16(this.byteOffset, value, LE);
+    this.byteOffset += 2;
+  }
+  writeInt16BE(value) {
+    this._ensureSize(2);
+    this.dataView.setInt16(this.byteOffset, value, BE);
+    this.byteOffset += 2;
+  }
+  writeInt32LE(value) {
+    this._ensureSize(4);
+    this.dataView.setInt32(this.byteOffset, value, LE);
+    this.byteOffset += 4;
+  }
+  writeInt32BE(value) {
+    this._ensureSize(4);
+    this.dataView.setInt32(this.byteOffset, value, BE);
+    this.byteOffset += 4;
+  }
+  writeFloatLE(value) {
+    this._ensureSize(4);
+    this.dataView.setFloat32(this.byteOffset, value, LE);
+    this.byteOffset += 4;
+  }
+  writeFloatBE(value) {
+    this._ensureSize(4);
+    this.dataView.setFloat32(this.byteOffset, value, BE);
+    this.byteOffset += 4;
+  }
+  writeDoubleLE(value) {
+    this._ensureSize(8);
+    this.dataView.setFloat64(this.byteOffset, value, LE);
+    this.byteOffset += 8;
+  }
+  writeDoubleBE(value) {
+    this._ensureSize(8);
+    this.dataView.setFloat64(this.byteOffset, value, BE);
+    this.byteOffset += 8;
+  }
+  /** A varint uses a variable number of bytes */
+  writeVarInt(value) {
+    let length = 1;
+    while ((value & 4294967168) !== 0) {
+      this.writeUInt8(value & 127 | 128);
+      value >>>= 7;
+      length++;
+    }
+    this.writeUInt8(value & 127);
+    return length;
+  }
+  writeTypedArray(typedArray) {
+    this._ensureSize(typedArray.byteLength);
+    const tempArray = new Uint8Array(this.arrayBuffer);
+    tempArray.set(typedArray, this.byteOffset);
+    this.byteOffset += typedArray.byteLength;
+  }
+  /** Append another ArrayBuffer to this ArrayBuffer */
+  writeBuffer(arrayBuffer) {
+    this._ensureSize(arrayBuffer.byteLength);
+    const tempArray = new Uint8Array(this.arrayBuffer);
+    tempArray.set(new Uint8Array(arrayBuffer), this.byteOffset);
+    this.byteOffset += arrayBuffer.byteLength;
+  }
+  /** Resizes this.arrayBuffer if not enough space */
+  _ensureSize(size) {
+    if (this.arrayBuffer.byteLength < this.byteOffset + size) {
+      if (this.allowResize) {
+        const newArrayBuffer = new ArrayBuffer(this.byteOffset + size);
+        const tempArray = new Uint8Array(newArrayBuffer);
+        tempArray.set(new Uint8Array(this.arrayBuffer));
+        this.arrayBuffer = newArrayBuffer;
+      } else {
+        throw new Error("BinaryWriter overflow");
+      }
+    }
+  }
+};
+
+// dist/lib/geometry-converters/wkb/convert-geometry-to-wkb.js
+function convertGeometryToWKB(geometry, options = {}) {
+  if (geometry.type === "Feature") {
+    geometry = geometry.geometry;
+  }
+  switch (geometry.type) {
+    case "Point":
+      return encodePoint(geometry.coordinates, options);
+    case "LineString":
+      return encodeLineString(geometry.coordinates, options);
+    case "Polygon":
+      return encodePolygon(geometry.coordinates, options);
+    case "MultiPoint":
+      return encodeMultiPoint(geometry, options);
+    case "MultiPolygon":
+      return encodeMultiPolygon(geometry, options);
+    case "MultiLineString":
+      return encodeMultiLineString(geometry, options);
+    case "GeometryCollection":
+      return encodeGeometryCollection(geometry, options);
+    default:
+      const exhaustiveCheck = geometry;
+      throw new Error(`Unhandled case: ${exhaustiveCheck}`);
+  }
+}
+function getGeometrySize(geometry, options) {
+  switch (geometry.type) {
+    case "Point":
+      return getPointSize(options);
+    case "LineString":
+      return getLineStringSize(geometry.coordinates, options);
+    case "Polygon":
+      return getPolygonSize(geometry.coordinates, options);
+    case "MultiPoint":
+      return getMultiPointSize(geometry, options);
+    case "MultiPolygon":
+      return getMultiPolygonSize(geometry, options);
+    case "MultiLineString":
+      return getMultiLineStringSize(geometry, options);
+    case "GeometryCollection":
+      return getGeometryCollectionSize(geometry, options);
+    default:
+      const exhaustiveCheck = geometry;
+      throw new Error(`Unhandled case: ${exhaustiveCheck}`);
+  }
+}
+function encodePoint(coordinates, options) {
+  const writer = new BinaryWriter(getPointSize(options));
+  writer.writeInt8(1);
+  writeWkbType(writer, WKBGeometryType.Point, options);
+  if (typeof coordinates[0] === "undefined" && typeof coordinates[1] === "undefined") {
+    writer.writeDoubleLE(NaN);
+    writer.writeDoubleLE(NaN);
+    if (options.hasZ) {
+      writer.writeDoubleLE(NaN);
+    }
+    if (options.hasM) {
+      writer.writeDoubleLE(NaN);
+    }
+  } else {
+    writeCoordinate(writer, coordinates, options);
+  }
+  return writer.arrayBuffer;
+}
+function writeCoordinate(writer, coordinate, options) {
+  writer.writeDoubleLE(coordinate[0]);
+  writer.writeDoubleLE(coordinate[1]);
+  if (options.hasZ) {
+    writer.writeDoubleLE(coordinate[2]);
+  }
+  if (options.hasM) {
+    writer.writeDoubleLE(coordinate[3]);
+  }
+}
+function getPointSize(options) {
+  const coordinateSize = getCoordinateSize(options);
+  return 1 + 4 + coordinateSize;
+}
+function encodeLineString(coordinates, options) {
+  const size = getLineStringSize(coordinates, options);
+  const writer = new BinaryWriter(size);
+  writer.writeInt8(1);
+  writeWkbType(writer, WKBGeometryType.LineString, options);
+  writer.writeUInt32LE(coordinates.length);
+  for (const coordinate of coordinates) {
+    writeCoordinate(writer, coordinate, options);
+  }
+  return writer.arrayBuffer;
+}
+function getLineStringSize(coordinates, options) {
+  const coordinateSize = getCoordinateSize(options);
+  return 1 + 4 + 4 + coordinates.length * coordinateSize;
+}
+function encodePolygon(coordinates, options) {
+  const writer = new BinaryWriter(getPolygonSize(coordinates, options));
+  writer.writeInt8(1);
+  writeWkbType(writer, WKBGeometryType.Polygon, options);
+  const [exteriorRing = [], ...interiorRings] = coordinates;
+  if (exteriorRing.length > 0) {
+    writer.writeUInt32LE(1 + interiorRings.length);
+    writer.writeUInt32LE(exteriorRing.length);
+  } else {
+    writer.writeUInt32LE(0);
+  }
+  for (const coordinate of exteriorRing) {
+    writeCoordinate(writer, coordinate, options);
+  }
+  for (const interiorRing of interiorRings) {
+    writer.writeUInt32LE(interiorRing.length);
+    for (const coordinate of interiorRing) {
+      writeCoordinate(writer, coordinate, options);
+    }
+  }
+  return writer.arrayBuffer;
+}
+function getPolygonSize(coordinates, options) {
+  const coordinateSize = getCoordinateSize(options);
+  const [exteriorRing = [], ...interiorRings] = coordinates;
+  let size = 1 + 4 + 4;
+  if (exteriorRing.length > 0) {
+    size += 4 + exteriorRing.length * coordinateSize;
+  }
+  for (const interiorRing of interiorRings) {
+    size += 4 + interiorRing.length * coordinateSize;
+  }
+  return size;
+}
+function encodeMultiPoint(multiPoint, options) {
+  const writer = new BinaryWriter(getMultiPointSize(multiPoint, options));
+  const points = multiPoint.coordinates;
+  writer.writeInt8(1);
+  writeWkbType(writer, WKBGeometryType.MultiPoint, options);
+  writer.writeUInt32LE(points.length);
+  for (const point of points) {
+    const arrayBuffer = encodePoint(point, options);
+    writer.writeBuffer(arrayBuffer);
+  }
+  return writer.arrayBuffer;
+}
+function getMultiPointSize(multiPoint, options) {
+  let coordinateSize = getCoordinateSize(options);
+  const points = multiPoint.coordinates;
+  coordinateSize += 5;
+  return 1 + 4 + 4 + points.length * coordinateSize;
+}
+function encodeMultiLineString(multiLineString, options) {
+  const writer = new BinaryWriter(getMultiLineStringSize(multiLineString, options));
+  const lineStrings = multiLineString.coordinates;
+  writer.writeInt8(1);
+  writeWkbType(writer, WKBGeometryType.MultiLineString, options);
+  writer.writeUInt32LE(lineStrings.length);
+  for (const lineString of lineStrings) {
+    const encodedLineString = encodeLineString(lineString, options);
+    writer.writeBuffer(encodedLineString);
+  }
+  return writer.arrayBuffer;
+}
+function getMultiLineStringSize(multiLineString, options) {
+  let size = 1 + 4 + 4;
+  const lineStrings = multiLineString.coordinates;
+  for (const lineString of lineStrings) {
+    size += getLineStringSize(lineString, options);
+  }
+  return size;
+}
+function encodeMultiPolygon(multiPolygon, options) {
+  const writer = new BinaryWriter(getMultiPolygonSize(multiPolygon, options));
+  const polygons = multiPolygon.coordinates;
+  writer.writeInt8(1);
+  writeWkbType(writer, WKBGeometryType.MultiPolygon, options);
+  writer.writeUInt32LE(polygons.length);
+  for (const polygon of polygons) {
+    const encodedPolygon = encodePolygon(polygon, options);
+    writer.writeBuffer(encodedPolygon);
   }
-  return parseFeatures(data, options == null ? void 0 : options.type);
+  return writer.arrayBuffer;
 }
-function getSingleFeature(data, globalFeatureId) {
-  const dataArray = normalizeInput(data);
-  for (const data2 of dataArray) {
-    let lastIndex = 0;
-    let lastValue = data2.featureIds.value[0];
-    for (let i = 0; i < data2.featureIds.value.length; i++) {
-      const currValue = data2.featureIds.value[i];
-      if (currValue === lastValue) {
-        continue;
-      }
-      if (globalFeatureId === data2.globalFeatureIds.value[lastIndex]) {
-        return parseFeature(data2, lastIndex, i);
-      }
-      lastIndex = i;
-      lastValue = currValue;
+function getMultiPolygonSize(multiPolygon, options) {
+  let size = 1 + 4 + 4;
+  const polygons = multiPolygon.coordinates;
+  for (const polygon of polygons) {
+    size += getPolygonSize(polygon, options);
+  }
+  return size;
+}
+function encodeGeometryCollection(collection, options) {
+  const writer = new BinaryWriter(getGeometryCollectionSize(collection, options));
+  writer.writeInt8(1);
+  writeWkbType(writer, WKBGeometryType.GeometryCollection, options);
+  writer.writeUInt32LE(collection.geometries.length);
+  for (const geometry of collection.geometries) {
+    const arrayBuffer = convertGeometryToWKB(geometry, options);
+    writer.writeBuffer(arrayBuffer);
+  }
+  return writer.arrayBuffer;
+}
+function getGeometryCollectionSize(collection, options) {
+  let size = 1 + 4 + 4;
+  for (const geometry of collection.geometries) {
+    size += getGeometrySize(geometry, options);
+  }
+  return size;
+}
+function writeWkbType(writer, geometryType, options) {
+  const { hasZ, hasM, srid } = options;
+  let dimensionType = 0;
+  if (!srid) {
+    if (hasZ && hasM) {
+      dimensionType += 3e3;
+    } else if (hasZ) {
+      dimensionType += 1e3;
+    } else if (hasM) {
+      dimensionType += 2e3;
     }
-    if (globalFeatureId === data2.globalFeatureIds.value[lastIndex]) {
-      return parseFeature(data2, lastIndex, data2.featureIds.value.length);
+  } else {
+    if (hasZ) {
+      dimensionType |= 2147483648;
+    }
+    if (hasM) {
+      dimensionType |= 1073741824;
     }
   }
-  throw new Error(`featureId:${globalFeatureId} not found`);
+  writer.writeUInt32LE(dimensionType + geometryType >>> 0);
 }
-function parseFeatures(data, type) {
-  const dataArray = normalizeInput(data, type);
-  return parseFeatureCollection(dataArray);
+function getCoordinateSize(options) {
+  let coordinateSize = 16;
+  if (options.hasZ) {
+    coordinateSize += 8;
+  }
+  if (options.hasM) {
+    coordinateSize += 8;
+  }
+  return coordinateSize;
 }
-function binaryToGeometry(data, startIndex, endIndex) {
-  switch (data.type) {
+
+// dist/lib/geometry-converters/wkb/convert-geometry-to-twkb.js
+function convertGeometryToTWKB(geometry, options) {
+  const writer = new BinaryWriter(0, true);
+  const context = {
+    ...getTwkbPrecision(5, 0, 0),
+    hasZ: options == null ? void 0 : options.hasZ,
+    hasM: options == null ? void 0 : options.hasM
+  };
+  encodeGeometry(writer, geometry, context);
+  return writer.arrayBuffer;
+}
+function encodeGeometry(writer, geometry, context) {
+  switch (geometry.type) {
     case "Point":
-      return pointToGeoJson(data, startIndex, endIndex);
+      return encodePoint2(writer, context, geometry);
     case "LineString":
-      return lineStringToGeoJson(data, startIndex, endIndex);
+      return encodeLineString2(writer, context, geometry);
     case "Polygon":
-      return polygonToGeoJson(data, startIndex, endIndex);
+      return encodePolygon2(writer, context, geometry);
+    case "MultiPoint":
+      return encodeMultiPoint2(writer, context, geometry);
+    case "MultiLineString":
+      return encodeMultiLineString2(writer, context, geometry);
+    case "MultiPolygon":
+      return encodeMultiPolygon2(writer, context, geometry);
+    case "GeometryCollection":
+      return encodeGeometryCollection2(writer, context, geometry);
     default:
-      const unexpectedInput = data;
-      throw new Error(`Unsupported geometry type: ${unexpectedInput == null ? void 0 : unexpectedInput.type}`);
+      throw new Error("unsupported geometry type");
   }
 }
-function normalizeInput(data, type) {
-  const features = [];
-  if (data.points) {
-    data.points.type = "Point";
-    features.push(data.points);
+function encodePoint2(writer, context, point) {
+  const isEmpty = point.coordinates.length === 0 || point[0] === "undefined" || point[1] === "undefined";
+  writeTwkbHeader(writer, context, WKBGeometryType.Point, isEmpty);
+  if (!isEmpty) {
+    const previousPoint = [0, 0, 0, 0];
+    writeTwkbPoint(writer, context, point.coordinates, previousPoint);
   }
-  if (data.lines) {
-    data.lines.type = "LineString";
-    features.push(data.lines);
+}
+function encodeLineString2(writer, context, lineString) {
+  const points = lineString.coordinates;
+  const isEmpty = points.length === 0;
+  writeTwkbHeader(writer, context, WKBGeometryType.LineString, isEmpty);
+  if (!isEmpty) {
+    writer.writeVarInt(points.length);
+    const previousPoint = [0, 0, 0, 0];
+    for (const point of points) {
+      writeTwkbPoint(writer, context, point, previousPoint);
+    }
   }
-  if (data.polygons) {
-    data.polygons.type = "Polygon";
-    features.push(data.polygons);
+  return writer.arrayBuffer;
+}
+function encodePolygon2(writer, context, polygon) {
+  const polygonRings = polygon.coordinates;
+  const isEmpty = polygonRings.length === 0;
+  writeTwkbHeader(writer, context, WKBGeometryType.Polygon, isEmpty);
+  if (!isEmpty) {
+    writer.writeVarInt(polygonRings.length);
+    const previousPoint = [0, 0, 0, 0];
+    for (const ring of polygonRings) {
+      writer.writeVarInt(ring.length);
+      for (const point of ring) {
+        writeTwkbPoint(writer, context, previousPoint, point);
+      }
+    }
   }
-  return features;
+  return writer.arrayBuffer;
 }
-function parseFeatureCollection(dataArray) {
-  const features = [];
-  for (const data of dataArray) {
-    if (data.featureIds.value.length === 0) {
-      continue;
+function encodeMultiPoint2(writer, context, multiPoint) {
+  const points = multiPoint.coordinates;
+  const isEmpty = points.length === 0;
+  writeTwkbHeader(writer, context, WKBGeometryType.MultiPoint, isEmpty);
+  if (!isEmpty) {
+    writer.writeVarInt(points.length);
+    const previousPoint = [0, 0, 0, 0];
+    for (let i = 0; i < points.length; i++) {
+      writeTwkbPoint(writer, context, previousPoint, points[i]);
     }
-    let lastIndex = 0;
-    let lastValue = data.featureIds.value[0];
-    for (let i = 0; i < data.featureIds.value.length; i++) {
-      const currValue = data.featureIds.value[i];
-      if (currValue === lastValue) {
-        continue;
+  }
+}
+function encodeMultiLineString2(writer, context, multiLineStrings) {
+  const lineStrings = multiLineStrings.coordinates;
+  const isEmpty = lineStrings.length === 0;
+  writeTwkbHeader(writer, context, WKBGeometryType.MultiLineString, isEmpty);
+  if (!isEmpty) {
+    writer.writeVarInt(lineStrings.length);
+    const previousPoint = [0, 0, 0, 0];
+    for (const lineString of lineStrings) {
+      writer.writeVarInt(lineString.length);
+      for (const point of lineString) {
+        writeTwkbPoint(writer, context, previousPoint, point);
       }
-      features.push(parseFeature(data, lastIndex, i));
-      lastIndex = i;
-      lastValue = currValue;
     }
-    features.push(parseFeature(data, lastIndex, data.featureIds.value.length));
   }
-  return features;
+  return writer.arrayBuffer;
 }
-function parseFeature(data, startIndex, endIndex) {
-  const geometry = binaryToGeometry(data, startIndex, endIndex);
-  const properties = parseProperties(data, startIndex, endIndex);
-  const fields = parseFields(data, startIndex, endIndex);
-  return { type: "Feature", geometry, properties, ...fields };
+function encodeMultiPolygon2(writer, context, multiPolygon) {
+  const { coordinates } = multiPolygon;
+  const isEmpty = coordinates.length === 0;
+  writeTwkbHeader(writer, context, WKBGeometryType.MultiPolygon, isEmpty);
+  if (!isEmpty) {
+    const polygons = coordinates;
+    writer.writeVarInt(polygons.length);
+    const previousPoint = [0, 0, 0, 0];
+    for (const polygonRings of polygons) {
+      writer.writeVarInt(polygonRings.length);
+      for (const ring of polygonRings) {
+        writer.writeVarInt(ring.length);
+        for (const point of ring) {
+          writeTwkbPoint(writer, context, previousPoint, point);
+        }
+      }
+    }
+  }
 }
-function parseFields(data, startIndex = 0, endIndex) {
-  return data.fields && data.fields[data.featureIds.value[startIndex]];
+function encodeGeometryCollection2(writer, context, geometryCollection) {
+  const { geometries } = geometryCollection;
+  const isEmpty = geometries.length === 0;
+  writeTwkbHeader(writer, context, WKBGeometryType.GeometryCollection, isEmpty);
+  if (geometries.length > 0) {
+    writer.writeVarInt(geometries.length);
+    for (const geometry of geometries) {
+      encodeGeometry(writer, geometry, context);
+    }
+  }
 }
-function parseProperties(data, startIndex = 0, endIndex) {
-  const properties = Object.assign({}, data.properties[data.featureIds.value[startIndex]]);
-  for (const key in data.numericProps) {
-    properties[key] = data.numericProps[key].value[startIndex];
+function writeTwkbHeader(writer, context, geometryType, isEmpty) {
+  const type2 = (zigZagEncode(context.xy) << 4) + geometryType;
+  let metadataHeader = context.hasZ || context.hasM ? 1 << 3 : 0;
+  metadataHeader += isEmpty ? 1 << 4 : 0;
+  writer.writeUInt8(type2);
+  writer.writeUInt8(metadataHeader);
+  if (context.hasZ || context.hasM) {
+    let extendedPrecision = 0;
+    if (context.hasZ) {
+      extendedPrecision |= 1;
+    }
+    if (context.hasM) {
+      extendedPrecision |= 2;
+    }
+    writer.writeUInt8(extendedPrecision);
   }
-  return properties;
 }
-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);
+function writeTwkbPoint(writer, context, point, previousPoint) {
+  const x = point[0] * context.xyFactor;
+  const y = point[1] * context.xyFactor;
+  const z = point[2] * context.zFactor;
+  const m = point[3] * context.mFactor;
+  writer.writeVarInt(zigZagEncode(x - previousPoint[0]));
+  writer.writeVarInt(zigZagEncode(y - previousPoint[1]));
+  if (context.hasZ) {
+    writer.writeVarInt(zigZagEncode(z - previousPoint[2]));
+  }
+  if (context.hasM) {
+    writer.writeVarInt(zigZagEncode(m - previousPoint[3]));
+  }
+  previousPoint[0] = x;
+  previousPoint[1] = y;
+  previousPoint[2] = z;
+  previousPoint[3] = m;
+}
+function zigZagEncode(value) {
+  return value << 1 ^ value >> 31;
+}
+function getTwkbPrecision(xyPrecision, zPrecision, mPrecision) {
+  return {
+    xy: xyPrecision,
+    z: zPrecision,
+    m: mPrecision,
+    xyFactor: Math.pow(10, xyPrecision),
+    zFactor: Math.pow(10, zPrecision),
+    mFactor: Math.pow(10, mPrecision)
+  };
+}
+
+// dist/lib/wkt-crs/parse-wkt-crs.js
+function parseWKTCRS(wkt, options) {
+  if (options == null ? void 0 : options.debug) {
+    console.log("[wktcrs] parse starting with\n", wkt);
+  }
+  wkt = wkt.replace(/[A-Z][A-Z\d_]+\[/gi, (match) => `["${match.substr(0, match.length - 1)}",`);
+  wkt = wkt.replace(/, ?([A-Z][A-Z\d_]+[,\]])/gi, (match, p1) => {
+    const varname = p1.substr(0, p1.length - 1);
+    return `,"${(options == null ? void 0 : options.raw) ? "raw:" : ""}${varname}"${p1[p1.length - 1]}`;
+  });
+  if (options == null ? void 0 : options.raw) {
+    wkt = wkt.replace(/, {0,2}(-?[\.\d]+)(?=,|\])/g, function(match, p1) {
+      return `,"${(options == null ? void 0 : options.raw) ? "raw:" : ""}${p1}"`;
+    });
+  }
+  if (options == null ? void 0 : options.debug) {
+    console.log(`[wktcrs] json'd wkt: '${wkt}'`);
+  }
+  let data;
+  try {
+    data = JSON.parse(wkt);
+  } catch (error) {
+    console.error(`[wktcrs] failed to parse '${wkt}'`);
+    throw error;
+  }
+  if (options == null ? void 0 : options.debug) {
+    console.log(`[wktcrs] json parsed: '${wkt}'`);
+  }
+  function process(data2, parent) {
+    const kw = data2[0];
+    data2.forEach(function(it) {
+      if (Array.isArray(it)) {
+        process(it, data2);
+      }
+    });
+    const kwarr = `MULTIPLE_${kw}`;
+    if (kwarr in parent) {
+      parent[kwarr].push(data2);
+    } else if (kw in parent) {
+      parent[kwarr] = [parent[kw], data2];
+      delete parent[kw];
+    } else {
+      parent[kw] = data2;
     }
-    return { type: "Polygon", coordinates: coordinates2 };
+    return parent;
   }
-  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);
+  const result = process(data, [data]);
+  if (options == null ? void 0 : options.debug) {
+    console.log("[wktcrs] parse returning", result);
   }
-  return { type: "MultiPolygon", coordinates };
+  if (options == null ? void 0 : options.sort) {
+    sort(result, options);
+  }
+  return result;
 }
-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 };
+function sort(data, options) {
+  const keys = Object.keys(data).filter((k) => !/\d+/.test(k));
+  const keywords = (options == null ? void 0 : options.keywords) || [];
+  if (!(options == null ? void 0 : options.keywords)) {
+    const counts = {};
+    if (Array.isArray(data)) {
+      data.forEach((it) => {
+        if (Array.isArray(it) && it.length >= 2 && typeof it[1] === "string") {
+          const k = it[0];
+          if (!counts[k])
+            counts[k] = 0;
+          counts[k]++;
+        }
+      });
+      for (const k in counts) {
+        if (counts[k] > 0)
+          keywords.push(k);
+      }
+    }
   }
-  const coordinates = [];
-  for (let i = 0; i < pathIndices.length - 1; i++) {
-    const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
-    coordinates.push(ringCoordinates);
+  keys.forEach((key) => {
+    data[key] = sort(data[key]);
+  });
+  keywords.forEach((key) => {
+    const indices = [];
+    const params = [];
+    data.forEach((item, i) => {
+      if (Array.isArray(item) && item[0] === key) {
+        indices.push(i);
+        params.push(item);
+      }
+    });
+    params.sort((a, b) => {
+      a = a[1].toString();
+      b = b[1].toString();
+      return a < b ? -1 : a > b ? 1 : 0;
+    });
+    params.forEach((param, i) => {
+      data[indices[i]] = param;
+    });
+  });
+  return data;
+}
+
+// dist/lib/wkt-crs/encode-wkt-crs.js
+function encodeWKTCRS(wkt, options) {
+  if (Array.isArray(wkt) && wkt.length === 1 && Array.isArray(wkt[0])) {
+    wkt = wkt[0];
   }
-  return { type: "MultiLineString", coordinates };
+  const [kw, ...attrs] = wkt;
+  const str = `${kw}[${attrs.map((attr) => {
+    if (Array.isArray(attr)) {
+      return encodeWKTCRS(attr, options);
+    } else if (typeof attr === "number") {
+      return attr.toString();
+    } else if (typeof attr === "string") {
+      if (attr.startsWith("raw:")) {
+        return attr.replace("raw:", "");
+      }
+      return `"${attr}"`;
+    }
+    throw new Error(`[wktcrs] unexpected attribute "${attr}"`);
+  }).join(",")}]`;
+  return str;
 }
-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 };
+
+// dist/lib/feature-collection-converters/convert-geoarrow-to-binary-features.js
+var import_polygon3 = require("@math.gl/polygon");
+var import_geoarrow3 = require("@loaders.gl/geoarrow");
+var BinaryGeometryType;
+(function(BinaryGeometryType2) {
+  BinaryGeometryType2["points"] = "points";
+  BinaryGeometryType2["lines"] = "lines";
+  BinaryGeometryType2["polygons"] = "polygons";
+})(BinaryGeometryType || (BinaryGeometryType = {}));
+function convertGeoArrowToBinaryFeatureCollection(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 == null ? void 0 : options.chunkIndex) !== void 0 && (options == null ? void 0 : options.chunkIndex) >= 0 ? [geoColumn.data[options == null ? void 0 : options.chunkIndex]] : geoColumn.data;
+  let bounds = [Infinity, Infinity, -Infinity, -Infinity];
+  let globalFeatureIdOffset = (options == null ? void 0 : 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 = (0, import_geoarrow3.updateBoundsFromGeoArrowSamples)(flatCoordinateArray, nDim, bounds);
+  });
+  return {
+    binaryGeometries,
+    bounds,
+    featureTypes,
+    ...(options == null ? void 0 : options.calculateMeanCenters) ? { meanCenters: getMeanCentersFromBinaryGeometries(binaryGeometries) } : {}
+  };
+}
+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 getMeanCentersFromBinaryGeometries(binaryGeometries) {
+  const globalMeanCenters = [];
+  binaryGeometries.forEach((binaryGeometry) => {
+    var _a;
+    let binaryGeometryType = null;
+    if (binaryGeometry.points && binaryGeometry.points.positions.value.length > 0) {
+      binaryGeometryType = BinaryGeometryType.points;
+    } else if (binaryGeometry.lines && binaryGeometry.lines.positions.value.length > 0) {
+      binaryGeometryType = BinaryGeometryType.lines;
+    } else if (binaryGeometry.polygons && binaryGeometry.polygons.positions.value.length > 0) {
+      binaryGeometryType = BinaryGeometryType.polygons;
+    }
+    const binaryContent = binaryGeometryType ? binaryGeometry[binaryGeometryType] : null;
+    if (binaryContent && binaryGeometryType !== null) {
+      const featureIds = binaryContent.featureIds.value;
+      const flatCoordinateArray = binaryContent.positions.value;
+      const nDim = binaryContent.positions.size;
+      const primitivePolygonIndices = binaryContent.type === "Polygon" ? (_a = binaryContent.primitivePolygonIndices) == null ? void 0 : _a.value : void 0;
+      const meanCenters = getMeanCentersFromGeometry(featureIds, flatCoordinateArray, nDim, binaryGeometryType, primitivePolygonIndices);
+      meanCenters.forEach((center) => {
+        globalMeanCenters.push(center);
+      });
+    }
+  });
+  return globalMeanCenters;
+}
+function getMeanCentersFromGeometry(featureIds, flatCoordinateArray, nDim, geometryType, primitivePolygonIndices) {
+  const meanCenters = [];
+  const vertexCount = flatCoordinateArray.length;
+  let vertexIndex = 0;
+  let coordIdx = 0;
+  let primitiveIdx = 0;
+  while (vertexIndex < vertexCount) {
+    const featureId = featureIds[vertexIndex / nDim];
+    const center = [0, 0];
+    let vertexCountInFeature = 0;
+    while (vertexIndex < vertexCount && featureIds[coordIdx] === featureId) {
+      if (geometryType === BinaryGeometryType.polygons && (primitivePolygonIndices == null ? void 0 : primitivePolygonIndices[primitiveIdx]) === coordIdx) {
+        vertexIndex += nDim;
+        primitiveIdx++;
+      } else {
+        center[0] += flatCoordinateArray[vertexIndex];
+        center[1] += flatCoordinateArray[vertexIndex + 1];
+        vertexIndex += nDim;
+        vertexCountInFeature++;
+      }
+      coordIdx += 1;
+    }
+    center[0] /= vertexCountInFeature;
+    center[1] /= vertexCountInFeature;
+    meanCenters.push(center);
   }
-  return { type: "Point", coordinates: coordinates[0] };
+  return meanCenters;
 }
-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]));
+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);
+    default:
+      throw Error("invalid geoarrow encoding");
+  }
+}
+function getTriangleIndices(polygonIndices, primitivePolygonIndices, flatCoordinateArray, nDim) {
+  try {
+    let primitiveIndex = 0;
+    const triangles = [];
+    for (let i = 0; i < polygonIndices.length - 1; i++) {
+      const startIdx = polygonIndices[i];
+      const endIdx = polygonIndices[i + 1];
+      const slicedFlatCoords = flatCoordinateArray.subarray(startIdx * nDim, endIdx * nDim);
+      const holeIndices = [];
+      while (primitivePolygonIndices[primitiveIndex] < endIdx) {
+        if (primitivePolygonIndices[primitiveIndex] > startIdx) {
+          holeIndices.push(primitivePolygonIndices[primitiveIndex] - startIdx);
+        }
+        primitiveIndex++;
+      }
+      const triangleIndices = (0, import_polygon3.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);
+      }
     }
-    ringCoordinates.push(coord);
+    const trianglesUint32 = new Uint32Array(triangles.length);
+    for (let i = 0; i < triangles.length; i++) {
+      trianglesUint32[i] = triangles[i];
+    }
+    return trianglesUint32;
+  } catch (error) {
+    return null;
   }
-  return ringCoordinates;
 }
-
-// dist/lib/binary-features/transform.js
-function transformBinaryCoords(binaryFeatures, transformCoordinate) {
-  if (binaryFeatures.points) {
-    transformBinaryGeometryPositions(binaryFeatures.points, transformCoordinate);
+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 geometryIndexes = new Uint16Array(polygonOffset.length);
+  for (let i = 0; i < polygonOffset.length; i++) {
+    geometryIndexes[i] = geomOffset[polygonOffset[i]];
   }
-  if (binaryFeatures.lines) {
-    transformBinaryGeometryPositions(binaryFeatures.lines, transformCoordinate);
+  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;
+    }
   }
-  if (binaryFeatures.polygons) {
-    transformBinaryGeometryPositions(binaryFeatures.polygons, transformCoordinate);
+  const triangles = (options == null ? void 0 : options.triangulate) ? getTriangleIndices(geometryIndexes, geomOffset, flatCoordinateArray, nDim) : null;
+  return {
+    featureIds,
+    nDim,
+    flatCoordinateArray,
+    geomOffset,
+    geometryIndexes,
+    ...(options == null ? void 0 : options.triangulate) && triangles ? { triangles } : {}
+  };
+}
+function getBinaryLinesFromChunk(chunk, geoEncoding) {
+  const isMultiLineString = geoEncoding === "geoarrow.multilinestring";
+  const lineData = isMultiLineString ? chunk.children[0] : chunk;
+  const pointData = lineData.children[0];
+  const coordData = pointData.children[0];
+  const nDim = pointData.stride;
+  const geomOffset = lineData.valueOffsets;
+  const flatCoordinateArray = coordData.values;
+  const geometryIndexes = new Uint16Array(0);
+  const numOfVertices = flatCoordinateArray.length / nDim;
+  const featureIds = new Uint32Array(numOfVertices);
+  if (isMultiLineString) {
+    const partData = chunk.valueOffsets;
+    for (let i = 0; i < partData.length - 1; i++) {
+      const startIdx = geomOffset[partData[i]];
+      const endIdx = geomOffset[partData[i + 1]];
+      for (let j = startIdx; j < endIdx; j++) {
+        featureIds[j] = i;
+      }
+    }
+  } else {
+    for (let i = 0; i < chunk.length; i++) {
+      const startIdx = geomOffset[i];
+      const endIdx = geomOffset[i + 1];
+      for (let j = startIdx; j < endIdx; j++) {
+        featureIds[j] = i;
+      }
+    }
   }
-  return binaryFeatures;
+  return {
+    featureIds,
+    flatCoordinateArray,
+    nDim,
+    geomOffset,
+    geometryIndexes
+  };
 }
-function transformBinaryGeometryPositions(binaryGeometry, fn) {
-  const { positions } = binaryGeometry;
-  for (let i = 0; i < positions.value.length; i += positions.size) {
-    const coord = Array.from(positions.value.subarray(i, i + positions.size));
-    const transformedCoord = fn(coord);
-    positions.value.set(transformedCoord, i);
+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 geometryIndexes = new Uint16Array(0);
+  const geomOffset = new Int32Array(0);
+  const numOfVertices = flatCoordinateArray.length / nDim;
+  const featureIds = new Uint32Array(numOfVertices);
+  if (isMultiPoint) {
+    const partData = chunk.valueOffsets;
+    for (let i = 0; i < partData.length - 1; i++) {
+      const startIdx = partData[i];
+      const endIdx = partData[i + 1];
+      for (let j = startIdx; j < endIdx; j++) {
+        featureIds[j] = i;
+      }
+    }
+  } else {
+    for (let i = 0; i < chunk.length; i++) {
+      featureIds[i] = i;
+    }
   }
+  return {
+    featureIds,
+    flatCoordinateArray,
+    nDim,
+    geomOffset,
+    geometryIndexes
+  };
 }
-function transformGeoJsonCoords(features, fn) {
-  for (const feature of features) {
-    feature.geometry.coordinates = coordMap(feature.geometry.coordinates, fn);
+
+// dist/lib/utils/hex-transcoder.js
+var alphabet = "0123456789abcdef";
+var encodeLookup = [];
+var decodeLookup = [];
+for (let i = 0; i < 256; i++) {
+  encodeLookup[i] = alphabet[i >> 4 & 15] + alphabet[i & 15];
+  if (i < 16) {
+    if (i < 10) {
+      decodeLookup[48 + i] = i;
+    } else {
+      decodeLookup[97 - 10 + i] = i;
+    }
   }
-  return features;
 }
-function coordMap(array, fn) {
-  if (isCoord(array)) {
-    return fn(array);
+function encodeHex(array) {
+  const length = array.length;
+  let string = "";
+  let i = 0;
+  while (i < length) {
+    string += encodeLookup[array[i++]];
   }
-  return array.map((item) => {
-    return coordMap(item, fn);
-  });
+  return string;
 }
-function isCoord(array) {
-  return Array.isArray(array) && Number.isFinite(array[0]) && Number.isFinite(array[1]);
+function decodeHex(string) {
+  const sizeof = string.length >> 1;
+  const length = sizeof << 1;
+  const array = new Uint8Array(sizeof);
+  let n = 0;
+  let i = 0;
+  while (i < length) {
+    array[n++] = decodeLookup[string.charCodeAt(i++)] << 4 | decodeLookup[string.charCodeAt(i++)];
+  }
+  return array;
 }
 //# sourceMappingURL=index.cjs.map