@math.gl/geospatial 5.0.0-alpha.2 → 5.0.0-alpha.20

package/dist/geoarrow/wkb-entry.cjs

@@ -0,0 +1,2472 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/geoarrow/wkb-entry.js
+var wkb_entry_exports = {};
+__export(wkb_entry_exports, {
+  decodeGeoArrowWKB: () => decodeGeoArrowWKB,
+  decodeGeoArrowWKT: () => decodeGeoArrowWKT,
+  encodeGeoArrowWKB: () => encodeGeoArrowWKB,
+  encodeGeoArrowWKT: () => encodeGeoArrowWKT,
+  getGeoArrowWKBVertexCount: () => getGeoArrowWKBVertexCount
+});
+module.exports = __toCommonJS(wkb_entry_exports);
+
+// dist/wkb/types.js
+function getWellKnownDimensionSize(dimension) {
+  switch (dimension) {
+    case "xy":
+      return 2;
+    case "xyz":
+    case "xym":
+      return 3;
+    case "xyzm":
+      return 4;
+  }
+}
+function inferWellKnownGeometryDimension(geometry) {
+  const size = getGeometryDimensionSize(geometry);
+  return size >= 4 ? "xyzm" : size === 3 ? "xyz" : "xy";
+}
+function getGeometryDimensionSize(geometry) {
+  if (geometry.type === "GeometryCollection") {
+    return Math.max(2, ...geometry.geometries.map(getGeometryDimensionSize));
+  }
+  return getCoordinateDimension(geometry.coordinates);
+}
+function getCoordinateDimension(value) {
+  if (value.length === 0)
+    return 2;
+  if (typeof value[0] === "number")
+    return value.length;
+  return Math.max(2, ...value.map((child) => getCoordinateDimension(child)));
+}
+
+// dist/wkb/wkb-reader.js
+var GEOMETRY_TYPES = [
+  "Point",
+  "LineString",
+  "Polygon",
+  "MultiPoint",
+  "MultiLineString",
+  "MultiPolygon",
+  "GeometryCollection"
+];
+function inspectWKBHeader(input, byteOffset = 0) {
+  return inspectWKBHeaderView(getDataView(input), byteOffset);
+}
+function visitWKB(input, visitor, options = {}) {
+  const view = getDataView(input);
+  const state = {
+    maximumDepth: validateLimit(options.maximumDepth, 64, "maximumDepth"),
+    maximumElements: validateLimit(options.maximumElements, 1e8, "maximumElements"),
+    elementCount: 0,
+    visitor
+  };
+  const byteLength = visitGeometry(view, 0, state, 0).byteOffset;
+  if (byteLength !== view.byteLength)
+    throw new Error("WKB contains trailing bytes");
+  return byteLength;
+}
+function visitGeometry(view, byteOffset, state, depth, expectedType) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  if (depth > state.maximumDepth)
+    throw new Error("WKB geometry nesting exceeds maximumDepth");
+  const header = inspectWKBHeaderView(view, byteOffset);
+  if (expectedType && header.geometryType !== expectedType) {
+    throw new Error(`WKB ${expectedType} collection contains a ${header.geometryType} child`);
+  }
+  byteOffset = header.bodyByteOffset;
+  switch (header.geometryType) {
+    case "Point":
+      (_b = (_a = state.visitor).geometry) == null ? void 0 : _b.call(_a, header, void 0, depth);
+      byteOffset = visitCoordinate(view, byteOffset, header, state.visitor, depth);
+      break;
+    case "LineString": {
+      const pointCount = readCount(view, byteOffset, header.littleEndian, state);
+      byteOffset += 4;
+      (_d = (_c = state.visitor).geometry) == null ? void 0 : _d.call(_c, header, pointCount, depth);
+      byteOffset = visitCoordinateSequence(view, byteOffset, pointCount, header, state, depth);
+      break;
+    }
+    case "Polygon": {
+      const ringCount = readCount(view, byteOffset, header.littleEndian, state);
+      byteOffset += 4;
+      (_f = (_e = state.visitor).geometry) == null ? void 0 : _f.call(_e, header, ringCount, depth);
+      for (let ringIndex = 0; ringIndex < ringCount; ringIndex++) {
+        const pointCount = readCount(view, byteOffset, header.littleEndian, state);
+        byteOffset += 4;
+        (_h = (_g = state.visitor).ring) == null ? void 0 : _h.call(_g, pointCount, ringIndex, depth);
+        byteOffset = visitCoordinateSequence(view, byteOffset, pointCount, header, state, depth);
+      }
+      break;
+    }
+    case "MultiPoint":
+    case "MultiLineString":
+    case "MultiPolygon":
+    case "GeometryCollection": {
+      const childCount = readCount(view, byteOffset, header.littleEndian, state);
+      byteOffset += 4;
+      (_j = (_i = state.visitor).geometry) == null ? void 0 : _j.call(_i, header, childCount, depth);
+      const childType = header.geometryType === "MultiPoint" ? "Point" : header.geometryType === "MultiLineString" ? "LineString" : header.geometryType === "MultiPolygon" ? "Polygon" : void 0;
+      for (let childIndex = 0; childIndex < childCount; childIndex++) {
+        byteOffset = visitGeometry(view, byteOffset, state, depth + 1, childType).byteOffset;
+      }
+      break;
+    }
+  }
+  return { byteOffset, header };
+}
+function visitCoordinateSequence(view, byteOffset, pointCount, header, state, depth) {
+  for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
+    byteOffset = visitCoordinate(view, byteOffset, header, state.visitor, depth);
+  }
+  return byteOffset;
+}
+function visitCoordinate(view, byteOffset, header, visitor, depth) {
+  var _a;
+  const coordinateByteLength = getWellKnownDimensionSize(header.dimension) * 8;
+  assertRemaining(view, byteOffset, coordinateByteLength);
+  if (!visitor.coordinate)
+    return byteOffset + coordinateByteLength;
+  const x = view.getFloat64(byteOffset, header.littleEndian);
+  const y = view.getFloat64(byteOffset + 8, header.littleEndian);
+  const third = header.dimension === "xy" ? void 0 : view.getFloat64(byteOffset + 16, header.littleEndian);
+  const fourth = header.dimension === "xyzm" ? view.getFloat64(byteOffset + 24, header.littleEndian) : void 0;
+  const z = header.dimension === "xyz" || header.dimension === "xyzm" ? third : void 0;
+  const m = header.dimension === "xym" ? third : fourth;
+  (_a = visitor.coordinate) == null ? void 0 : _a.call(visitor, x, y, z, m, header.dimension, byteOffset, depth);
+  return byteOffset + coordinateByteLength;
+}
+function inspectWKBHeaderView(view, byteOffset) {
+  const startByteOffset = byteOffset;
+  assertRemaining(view, byteOffset, 5);
+  const byteOrder = view.getUint8(byteOffset++);
+  if (byteOrder !== 0 && byteOrder !== 1)
+    throw new Error("Invalid WKB byte order");
+  const littleEndian = byteOrder === 1;
+  const typeCode = view.getUint32(byteOffset, littleEndian);
+  byteOffset += 4;
+  const hasZ = Boolean(typeCode & 2147483648);
+  const hasM = Boolean(typeCode & 1073741824);
+  const hasSrid = Boolean(typeCode & 536870912);
+  let geometryCode = typeCode & 536870911;
+  let dimension;
+  if (geometryCode >= 3e3 && geometryCode < 4e3) {
+    dimension = "xyzm";
+    geometryCode -= 3e3;
+  } else if (geometryCode >= 2e3 && geometryCode < 3e3) {
+    dimension = "xym";
+    geometryCode -= 2e3;
+  } else if (geometryCode >= 1e3 && geometryCode < 2e3) {
+    dimension = "xyz";
+    geometryCode -= 1e3;
+  } else {
+    dimension = hasZ && hasM ? "xyzm" : hasZ ? "xyz" : hasM ? "xym" : "xy";
+  }
+  const geometryType = GEOMETRY_TYPES[geometryCode - 1];
+  if (!geometryType)
+    throw new Error(`Unsupported WKB geometry type ${geometryCode}`);
+  let srid;
+  if (hasSrid) {
+    assertRemaining(view, byteOffset, 4);
+    srid = view.getUint32(byteOffset, littleEndian);
+    byteOffset += 4;
+  }
+  const dialect = hasZ || hasM || hasSrid ? "ewkb" : dimension === "xy" ? "wkb" : "iso-wkb";
+  return {
+    geometryType,
+    dimension,
+    dialect,
+    littleEndian,
+    byteOffset: startByteOffset,
+    bodyByteOffset: byteOffset,
+    byteLength: byteOffset - startByteOffset,
+    ...srid === void 0 ? {} : { srid }
+  };
+}
+function readCount(view, byteOffset, littleEndian, state) {
+  assertRemaining(view, byteOffset, 4);
+  const count = view.getUint32(byteOffset, littleEndian);
+  state.elementCount += count;
+  if (state.elementCount > state.maximumElements) {
+    throw new Error("WKB element count exceeds maximumElements");
+  }
+  return count;
+}
+function getDataView(input) {
+  return ArrayBuffer.isView(input) ? new DataView(input.buffer, input.byteOffset, input.byteLength) : new DataView(input);
+}
+function assertRemaining(view, byteOffset, byteLength) {
+  if (byteOffset < 0 || byteOffset + byteLength > view.byteLength) {
+    throw new Error("Unexpected end of WKB");
+  }
+}
+function validateLimit(value, fallback, name) {
+  const limit = value ?? fallback;
+  if (!Number.isSafeInteger(limit) || limit < 0) {
+    throw new Error(`${name} must be a non-negative safe integer`);
+  }
+  return limit;
+}
+
+// dist/wkb/wkb-builder.js
+var GEOMETRY_TYPE_CODES = {
+  Point: 1,
+  LineString: 2,
+  Polygon: 3,
+  MultiPoint: 4,
+  MultiLineString: 5,
+  MultiPolygon: 6,
+  GeometryCollection: 7
+};
+var WKBBuilder = class _WKBBuilder {
+  constructor(options) {
+    this.mode = options.mode;
+    this.dimension = options.dimension ?? "xy";
+    this.littleEndian = options.byteOrder !== "big-endian";
+    this.srid = options.srid;
+    this.transform = options.transform;
+    validateSrid(this.srid);
+    if (options.mode === "write") {
+      const dataView = getTargetDataView(options.target);
+      const byteOffset = options.byteOffset ?? 0;
+      if (!Number.isSafeInteger(byteOffset) || byteOffset < 0 || byteOffset > dataView.byteLength) {
+        throw new Error("WKBBuilder byteOffset is outside the target");
+      }
+      this.dataView = dataView;
+      this.startByteOffset = byteOffset;
+      this.endByteOffset = dataView.byteLength;
+      this.byteOffset = byteOffset;
+    } else {
+      this.dataView = null;
+      this.startByteOffset = 0;
+      this.endByteOffset = Number.POSITIVE_INFINITY;
+      this.byteOffset = 0;
+    }
+  }
+  /** Begins a geometry and writes its count field when required. */
+  beginGeometry(type, count) {
+    switch (type) {
+      case "Point":
+        this.beginPoint();
+        break;
+      case "LineString":
+        this.beginLineString(count ?? 0);
+        break;
+      case "Polygon":
+        this.beginPolygon(count ?? 0);
+        break;
+      case "MultiPoint":
+        this.beginMultiPoint(count ?? 0);
+        break;
+      case "MultiLineString":
+        this.beginMultiLineString(count ?? 0);
+        break;
+      case "MultiPolygon":
+        this.beginMultiPolygon(count ?? 0);
+        break;
+      case "GeometryCollection":
+        this.writeHeader("GeometryCollection");
+        this.writeUint32(count ?? 0);
+        break;
+    }
+  }
+  /** Begins one point geometry. */
+  beginPoint() {
+    this.writeHeader("Point");
+  }
+  /** Begins one linestring geometry. */
+  beginLineString(pointCount) {
+    this.writeHeader("LineString");
+    this.writeUint32(pointCount);
+  }
+  /** Begins one polygon geometry. */
+  beginPolygon(ringCount) {
+    this.writeHeader("Polygon");
+    this.writeUint32(ringCount);
+  }
+  /** Begins one linear ring inside a polygon. */
+  beginLinearRing(pointCount) {
+    this.writeUint32(pointCount);
+  }
+  /** Begins one multipoint geometry. */
+  beginMultiPoint(pointCount) {
+    this.writeHeader("MultiPoint");
+    this.writeUint32(pointCount);
+  }
+  /** Begins one multilinestring geometry. */
+  beginMultiLineString(lineCount) {
+    this.writeHeader("MultiLineString");
+    this.writeUint32(lineCount);
+  }
+  /** Begins one multipolygon geometry. */
+  beginMultiPolygon(polygonCount) {
+    this.writeHeader("MultiPolygon");
+    this.writeUint32(polygonCount);
+  }
+  /** Writes one coordinate using the builder's semantic dimension. */
+  writeCoordinate(x, y, z, m) {
+    let coordinate = makeCoordinate(this.dimension, x, y, z, m);
+    if (this.transform)
+      coordinate = this.transform(coordinate, this.dimension);
+    const coordinateSize = getDimensionSize(this.dimension);
+    for (let index = 0; index < coordinateSize; index++) {
+      this.writeFloat64(coordinate[index] ?? Number.NaN);
+    }
+  }
+  /** Temporarily changes the semantic dimension for a nested geometry. */
+  withDimension(dimension, callback) {
+    const previous = this.dimension;
+    this.dimension = dimension;
+    try {
+      return callback();
+    } finally {
+      this.dimension = previous;
+    }
+  }
+  /** Returns the number of bytes measured or written. */
+  finishGeometry() {
+    return this.byteOffset - this.startByteOffset;
+  }
+  /** Measures geometry callbacks and returns contiguous Binary offsets. */
+  static measureGeometryArray(geometryWriters, options = {}) {
+    var _a;
+    const valueOffsets = new Int32Array(geometryWriters.length + 1);
+    for (let geometryIndex = 0; geometryIndex < geometryWriters.length; geometryIndex++) {
+      const geometryWriter = geometryWriters[geometryIndex];
+      const byteLength = geometryWriter ? measureGeometry(geometryWriter, {
+        ...options,
+        dimension: ((_a = options.dimensionResolver) == null ? void 0 : _a.call(options, geometryIndex)) ?? options.dimension
+      }) : 0;
+      const nextOffset = valueOffsets[geometryIndex] + byteLength;
+      if (nextOffset > 2147483647)
+        throw new Error("WKB geometry array exceeds Int32 offsets");
+      valueOffsets[geometryIndex + 1] = nextOffset;
+    }
+    return valueOffsets;
+  }
+  /** Writes geometry callbacks into an existing contiguous values buffer. */
+  static writeGeometryArray(geometryWriters, valueOffsets, values, options = {}) {
+    var _a;
+    if (valueOffsets.length !== geometryWriters.length + 1) {
+      throw new Error("WKB valueOffsets length must equal geometry count plus one");
+    }
+    for (let i = 0; i < valueOffsets.length; i++) {
+      if (!Number.isInteger(valueOffsets[i]) || valueOffsets[i] < 0 || i > 0 && valueOffsets[i] < valueOffsets[i - 1]) {
+        throw new Error("WKB valueOffsets must be nonnegative and nondecreasing");
+      }
+    }
+    if (valueOffsets[valueOffsets.length - 1] > values.byteLength) {
+      throw new Error("WKB values buffer is smaller than its final offset");
+    }
+    for (let geometryIndex = 0; geometryIndex < geometryWriters.length; geometryIndex++) {
+      const geometryWriter = geometryWriters[geometryIndex];
+      if (!geometryWriter)
+        continue;
+      const builder = new _WKBBuilder({
+        ...options,
+        mode: "write",
+        target: values,
+        byteOffset: valueOffsets[geometryIndex],
+        dimension: ((_a = options.dimensionResolver) == null ? void 0 : _a.call(options, geometryIndex)) ?? options.dimension
+      });
+      geometryWriter(builder);
+      const byteLength = builder.finishGeometry();
+      if (valueOffsets[geometryIndex] + byteLength !== valueOffsets[geometryIndex + 1]) {
+        throw new Error("WKB measure and write passes produced different byte lengths");
+      }
+    }
+    return values;
+  }
+  /** Builds plain offsets, values, and validity buffers in two passes. */
+  static buildGeometryArray(geometryWriters, options = {}) {
+    const valueOffsets = _WKBBuilder.measureGeometryArray(geometryWriters, options);
+    const values = new Uint8Array(valueOffsets[valueOffsets.length - 1]);
+    _WKBBuilder.writeGeometryArray(geometryWriters, valueOffsets, values, options);
+    const { nullBitmap, nullCount } = makeNullBitmap(geometryWriters);
+    return {
+      valueOffsets,
+      values,
+      ...nullCount > 0 ? { nullBitmap } : {},
+      nullCount
+    };
+  }
+  writeHeader(geometryType) {
+    this.writeUint8(this.littleEndian ? 1 : 0);
+    this.writeUint32(getWKBTypeCode(geometryType, this.dimension, this.srid !== void 0));
+    if (this.srid !== void 0)
+      this.writeUint32(this.srid);
+  }
+  writeUint8(value) {
+    var _a;
+    this.ensureSize(1);
+    (_a = this.dataView) == null ? void 0 : _a.setUint8(this.byteOffset, value);
+    this.byteOffset++;
+  }
+  writeUint32(value) {
+    var _a;
+    if (!Number.isSafeInteger(value) || value < 0 || value > 4294967295) {
+      throw new Error("WKB count must be an unsigned 32-bit integer");
+    }
+    this.ensureSize(4);
+    (_a = this.dataView) == null ? void 0 : _a.setUint32(this.byteOffset, value, this.littleEndian);
+    this.byteOffset += 4;
+  }
+  writeFloat64(value) {
+    var _a;
+    this.ensureSize(8);
+    (_a = this.dataView) == null ? void 0 : _a.setFloat64(this.byteOffset, value, this.littleEndian);
+    this.byteOffset += 8;
+  }
+  ensureSize(byteLength) {
+    if (this.byteOffset + byteLength > this.endByteOffset) {
+      throw new Error("WKBBuilder target buffer overflow");
+    }
+  }
+};
+function measureGeometry(geometryWriter, options) {
+  const builder = new WKBBuilder({ ...options, mode: "measure" });
+  geometryWriter(builder);
+  return builder.finishGeometry();
+}
+function getTargetDataView(target) {
+  return ArrayBuffer.isView(target) ? new DataView(target.buffer, target.byteOffset, target.byteLength) : new DataView(target);
+}
+function getWKBTypeCode(geometryType, dimension, hasSrid) {
+  const geometryCode = GEOMETRY_TYPE_CODES[geometryType];
+  if (hasSrid) {
+    const dimensionFlags = dimension === "xyz" ? 2147483648 : dimension === "xym" ? 1073741824 : dimension === "xyzm" ? 3221225472 : 0;
+    return (geometryCode | dimensionFlags | 536870912) >>> 0;
+  }
+  const dimensionOffset = dimension === "xyz" ? 1e3 : dimension === "xym" ? 2e3 : dimension === "xyzm" ? 3e3 : 0;
+  return geometryCode + dimensionOffset;
+}
+function makeCoordinate(dimension, x, y, z, m) {
+  switch (dimension) {
+    case "xy":
+      return [x, y];
+    case "xyz":
+      return [x, y, z ?? Number.NaN];
+    case "xym":
+      return [x, y, m ?? Number.NaN];
+    case "xyzm":
+      return [x, y, z ?? Number.NaN, m ?? Number.NaN];
+  }
+}
+function getDimensionSize(dimension) {
+  return dimension === "xy" ? 2 : dimension === "xyzm" ? 4 : 3;
+}
+function validateSrid(srid) {
+  if (srid !== void 0 && (!Number.isSafeInteger(srid) || srid < 0 || srid > 4294967295)) {
+    throw new Error("WKBBuilder srid must be an unsigned 32-bit integer");
+  }
+}
+function makeNullBitmap(geometryWriters) {
+  const nullBitmap = new Uint8Array(Math.ceil(geometryWriters.length / 8));
+  let nullCount = 0;
+  for (let geometryIndex = 0; geometryIndex < geometryWriters.length; geometryIndex++) {
+    if (geometryWriters[geometryIndex]) {
+      nullBitmap[geometryIndex >> 3] |= 1 << (geometryIndex & 7);
+    } else {
+      nullCount++;
+    }
+  }
+  return { nullBitmap, nullCount };
+}
+
+// dist/wkb/wkt.js
+function parseWKT(text, options) {
+  const parser = new WKTParser(text);
+  const result = parser.parseGeometry("xy", options ?? {}, false);
+  parser.assertComplete();
+  return result.geometry;
+}
+function formatWKT(geometry, dimension) {
+  if (isWKTParseResult(geometry)) {
+    return dimension === void 0 ? formatWKTResult(geometry) : formatWKTGeometry(geometry.geometry, dimension);
+  }
+  return formatWKTGeometry(geometry, dimension ?? inferWellKnownGeometryDimension(geometry));
+}
+function formatWKTResult(result) {
+  return formatWKTGeometry(result.geometry, result.dimension, result.children);
+}
+function formatWKTGeometry(geometry, dimension, children) {
+  const dimensionToken = dimension === "xy" ? "" : " " + dimension.slice(2).toUpperCase();
+  if (geometry.type === "GeometryCollection") {
+    if (geometry.geometries.length === 0)
+      return "GEOMETRYCOLLECTION" + dimensionToken + " EMPTY";
+    const formattedChildren = children ? children.map(formatWKTResult) : geometry.geometries.map((child) => formatWKTGeometry(child, dimension));
+    return "GEOMETRYCOLLECTION" + dimensionToken + " (" + formattedChildren.join(", ") + ")";
+  }
+  const type = geometry.type.toUpperCase();
+  const isEmpty = geometry.type === "MultiPoint" ? geometry.coordinates.length === 0 : isEmptyCoordinates(geometry.coordinates);
+  if (isEmpty)
+    return type + dimensionToken + " EMPTY";
+  return type + dimensionToken + " " + formatCoordinateNesting(geometry.coordinates, getGeometryDepth(geometry.type), geometry.type === "MultiPoint");
+}
+function isWKTParseResult(value) {
+  return "geometry" in value && "dimension" in value;
+}
+var WKTParser = class {
+  constructor(text) {
+    this.index = 0;
+    this.tokens = tokenizeWKT(text);
+  }
+  parseGeometry(inheritedDimension, options, validateInheritedDimensions) {
+    const type = this.takeWord().toUpperCase();
+    let dimension = inheritedDimension;
+    let hasExplicitDimension = false;
+    if (["Z", "M", "ZM"].includes(this.peek().toUpperCase())) {
+      const token = this.take().toUpperCase();
+      dimension = token === "Z" ? "xyz" : token === "M" ? "xym" : "xyzm";
+      hasExplicitDimension = true;
+    }
+    const dimensionSize = getWellKnownDimensionSize(dimension);
+    if (this.peek().toUpperCase() === "EMPTY") {
+      this.take();
+      return { geometry: makeEmptyGeometry(type, dimensionSize), dimension };
+    }
+    if (type === "GEOMETRYCOLLECTION") {
+      this.expect("(");
+      const children = [];
+      if (this.peek() !== ")") {
+        do
+          children.push(this.parseGeometry(dimension, options, validateInheritedDimensions));
+        while (this.takeIf(","));
+      }
+      this.expect(")");
+      return {
+        geometry: { type: "GeometryCollection", geometries: children.map((child) => child.geometry) },
+        dimension,
+        children
+      };
+    }
+    const inferDimension = Boolean(options.inferDimensions && !hasExplicitDimension && inheritedDimension === "xy");
+    const coordinates = this.parseCoordinateNesting(getWKTDepth(type), inferDimension ? null : dimensionSize, type === "MULTIPOINT");
+    const coordinateValues = coordinates;
+    if (inferDimension) {
+      const inferredSize = inferCoordinateSize(coordinateValues);
+      if (inferredSize !== null)
+        dimension = getDimensionForSize(inferredSize);
+    } else if (hasExplicitDimension || validateInheritedDimensions) {
+      assertCoordinateSize(coordinateValues, dimensionSize);
+    }
+    return { geometry: makeGeometry(type, coordinates), dimension };
+  }
+  assertComplete() {
+    if (this.index !== this.tokens.length)
+      throw new Error(`Unexpected WKT token ${this.peek()}`);
+  }
+  parseCoordinateNesting(depth, dimensionSize, allowEmptyPoints = false) {
+    this.expect("(");
+    if (depth === 0) {
+      const coordinate = this.readCoordinate(dimensionSize);
+      this.expect(")");
+      return coordinate;
+    }
+    const values = [];
+    if (this.peek() !== ")") {
+      do {
+        if (allowEmptyPoints && depth === 1 && this.peek().toUpperCase() === "EMPTY") {
+          this.take();
+          values.push([]);
+        } else if (depth === 1 && this.peek() !== "(") {
+          values.push(this.readCoordinate(dimensionSize));
+        } else {
+          values.push(this.parseCoordinateNesting(depth - 1, dimensionSize));
+        }
+      } while (this.takeIf(","));
+    }
+    this.expect(")");
+    return values;
+  }
+  readCoordinate(dimensionSize) {
+    const values = [];
+    while ((dimensionSize === null || values.length < dimensionSize) && isNumberToken(this.peek())) {
+      values.push(Number(this.take()));
+    }
+    if (values.length < 2)
+      throw new Error("WKT coordinate requires at least two numbers");
+    if (values.length > 4)
+      throw new Error("WKT coordinates cannot contain more than four numbers");
+    return values;
+  }
+  peek() {
+    return this.tokens[this.index] || "";
+  }
+  take() {
+    if (this.index >= this.tokens.length)
+      throw new Error("Unexpected end of WKT");
+    return this.tokens[this.index++];
+  }
+  takeWord() {
+    const token = this.take();
+    if (!/^[A-Za-z_]+$/.test(token))
+      throw new Error(`Expected WKT geometry type, found ${token}`);
+    return token;
+  }
+  takeIf(token) {
+    if (this.peek() !== token)
+      return false;
+    this.index++;
+    return true;
+  }
+  expect(token) {
+    const actual = this.take();
+    if (actual !== token)
+      throw new Error(`Expected WKT token ${token}, found ${actual}`);
+  }
+};
+function inferCoordinateSize(value) {
+  let coordinateSize = null;
+  const visit = (coordinates) => {
+    if (coordinates.length === 0)
+      return;
+    if (typeof coordinates[0] === "number") {
+      if (coordinates.length < 2 || coordinates.length > 4) {
+        throw new Error("WKT coordinates must contain between two and four numbers");
+      }
+      if (coordinateSize !== null && coordinateSize !== coordinates.length) {
+        throw new Error("WKT geometry contains inconsistent coordinate dimensions");
+      }
+      coordinateSize = coordinates.length;
+      return;
+    }
+    for (const child of coordinates)
+      visit(child);
+  };
+  visit(value);
+  return coordinateSize;
+}
+function assertCoordinateSize(value, expectedSize) {
+  const actualSize = inferCoordinateSize(value);
+  if (actualSize !== null && actualSize !== expectedSize) {
+    throw new Error("WKT coordinate dimension does not match declared dimension " + expectedSize);
+  }
+}
+function getDimensionForSize(size) {
+  switch (size) {
+    case 2:
+      return "xy";
+    case 3:
+      return "xyz";
+    case 4:
+      return "xyzm";
+    default:
+      throw new Error("Unsupported WKT coordinate dimension " + size);
+  }
+}
+function tokenizeWKT(text) {
+  const tokens = [];
+  const tokenPattern = /[A-Za-z_]+|[(),]|[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?/gy;
+  let index = 0;
+  while (index < text.length) {
+    while (index < text.length && /\s/.test(text[index]))
+      index++;
+    if (index === text.length)
+      break;
+    tokenPattern.lastIndex = index;
+    const match = tokenPattern.exec(text);
+    if (!match) {
+      throw new Error(`Unexpected WKT character ${JSON.stringify(text[index])} at ${index}`);
+    }
+    tokens.push(match[0]);
+    index = tokenPattern.lastIndex;
+  }
+  return tokens;
+}
+function formatCoordinateNesting(value, depth, allowEmptyPoints = false) {
+  if (depth === 0)
+    return `(${value.map(formatNumber).join(" ")})`;
+  return `(${value.map((child) => {
+    if (depth === 1) {
+      const coordinate = child;
+      if (allowEmptyPoints && isEmptyCoordinates(coordinate))
+        return "EMPTY";
+      return coordinate.map(formatNumber).join(" ");
+    }
+    return formatCoordinateNesting(child, depth - 1);
+  }).join(", ")})`;
+}
+function formatNumber(value) {
+  if (!Number.isFinite(value))
+    return "NaN";
+  return String(value);
+}
+function getGeometryDepth(type) {
+  switch (type) {
+    case "Point":
+      return 0;
+    case "LineString":
+    case "MultiPoint":
+      return 1;
+    case "Polygon":
+    case "MultiLineString":
+      return 2;
+    case "MultiPolygon":
+      return 3;
+  }
+}
+function getWKTDepth(type) {
+  switch (type) {
+    case "POINT":
+      return 0;
+    case "LINESTRING":
+      return 1;
+    case "POLYGON":
+      return 2;
+    case "MULTIPOINT":
+      return 1;
+    case "MULTILINESTRING":
+      return 2;
+    case "MULTIPOLYGON":
+      return 3;
+    default:
+      throw new Error(`Unsupported WKT geometry type ${type}`);
+  }
+}
+function makeGeometry(type, coordinates) {
+  const canonical = type[0] + type.slice(1).toLowerCase();
+  const names = {
+    Point: "Point",
+    Linestring: "LineString",
+    Polygon: "Polygon",
+    Multipoint: "MultiPoint",
+    Multilinestring: "MultiLineString",
+    Multipolygon: "MultiPolygon"
+  };
+  const geometryType = names[canonical];
+  if (!geometryType)
+    throw new Error(`Unsupported WKT geometry type ${type}`);
+  return { type: geometryType, coordinates };
+}
+function makeEmptyGeometry(type, dimensionSize) {
+  if (type === "GEOMETRYCOLLECTION")
+    return { type: "GeometryCollection", geometries: [] };
+  if (type === "POINT") {
+    return {
+      type: "Point",
+      coordinates: new Array(getValidDimensionSize(dimensionSize)).fill(Number.NaN)
+    };
+  }
+  return makeGeometry(type, []);
+}
+function getValidDimensionSize(size) {
+  if (size === 2 || size === 3 || size === 4)
+    return size;
+  return getWellKnownDimensionSize("xy");
+}
+function isEmptyCoordinates(value) {
+  if (value.length === 0)
+    return true;
+  if (typeof value[0] === "number") {
+    return value.every((component) => !Number.isFinite(component));
+  }
+  return value.every((child) => isEmptyCoordinates(child));
+}
+function isNumberToken(token) {
+  return token !== "" && Number.isFinite(Number(token));
+}
+
+// dist/geoarrow/types.js
+function getGeoArrowDimensionSize(dimension) {
+  switch (dimension) {
+    case "xy":
+      return 2;
+    case "xyz":
+    case "xym":
+      return 3;
+    case "xyzm":
+      return 4;
+  }
+}
+function mergeGeoArrowDimensions(left, right) {
+  const hasZ = left === "xyz" || left === "xyzm" || right === "xyz" || right === "xyzm";
+  const hasM = left === "xym" || left === "xyzm" || right === "xym" || right === "xyzm";
+  return hasZ && hasM ? "xyzm" : hasZ ? "xyz" : hasM ? "xym" : "xy";
+}
+function getGeoArrowGeometryType(encoding) {
+  switch (encoding) {
+    case "geoarrow.point":
+      return "Point";
+    case "geoarrow.linestring":
+      return "LineString";
+    case "geoarrow.polygon":
+      return "Polygon";
+    case "geoarrow.multipoint":
+      return "MultiPoint";
+    case "geoarrow.multilinestring":
+      return "MultiLineString";
+    case "geoarrow.multipolygon":
+      return "MultiPolygon";
+    case "geoarrow.geometrycollection":
+      return "GeometryCollection";
+    default:
+      return null;
+  }
+}
+function getGeoArrowEncodingForGeometry(type) {
+  return `geoarrow.${type.toLowerCase()}`;
+}
+
+// dist/geoarrow/builder.js
+var GeoArrowBuilder = class _GeoArrowBuilder {
+  constructor(options) {
+    this.length = 0;
+    this.nullCount = 0;
+    this.coordinateCount = 0;
+    this.partCount = 0;
+    this.ringCount = 0;
+    this.eventStack = [];
+    this.mode = options.mode;
+    this.encoding = options.encoding;
+    this.dimension = options.dimension || "xy";
+    this.coordinateLayout = options.coordinateLayout || "interleaved";
+    this.offsetType = options.offsetType || "int32";
+    this.coordinateType = options.coordinateType || "float64";
+    this.target = options.mode === "write" ? options.target : void 0;
+    if (this.target)
+      this.initializeTargetOffsets(this.target);
+  }
+  /** Appends one geometry row or null. */
+  append(geometry) {
+    var _a, _b, _c, _d, _e, _f;
+    const rowIndex = this.length++;
+    if (!geometry) {
+      this.nullCount++;
+      this.appendNull(rowIndex);
+      return this;
+    }
+    const expectedType = getGeoArrowGeometryType(this.encoding);
+    if (geometry.type !== expectedType) {
+      throw new Error(`GeoArrowBuilder for ${this.encoding} cannot append ${geometry.type}`);
+    }
+    if (geometry.type === "GeometryCollection") {
+      throw new Error("GeoArrowBuilder only accepts concrete geometry families");
+    }
+    if (this.target)
+      setValidityBit(this.target.validity, rowIndex);
+    const depth = getBuilderDepth(this.encoding);
+    const coordinates = geometry.coordinates;
+    if (depth === 0) {
+      this.writeCoordinateValues(coordinates);
+    } else if (depth === 1) {
+      this.writeCoordinateList(coordinates);
+      this.writeOffset((_a = this.target) == null ? void 0 : _a.geometryOffsets, rowIndex + 1, this.coordinateCount);
+    } else if (depth === 2) {
+      for (const part of coordinates) {
+        this.writeCoordinateList(part);
+        this.partCount++;
+        this.writeOffset((_b = this.target) == null ? void 0 : _b.partOffsets, this.partCount, this.coordinateCount);
+      }
+      this.writeOffset((_c = this.target) == null ? void 0 : _c.geometryOffsets, rowIndex + 1, this.partCount);
+    } else {
+      for (const polygon of coordinates) {
+        for (const ring of polygon) {
+          this.writeCoordinateList(ring);
+          this.ringCount++;
+          this.writeOffset((_d = this.target) == null ? void 0 : _d.ringOffsets, this.ringCount, this.coordinateCount);
+        }
+        this.partCount++;
+        this.writeOffset((_e = this.target) == null ? void 0 : _e.partOffsets, this.partCount, this.ringCount);
+      }
+      this.writeOffset((_f = this.target) == null ? void 0 : _f.geometryOffsets, rowIndex + 1, this.partCount);
+    }
+    return this;
+  }
+  /** Returns current exact allocation counts. */
+  getMeasurement() {
+    const depth = getBuilderDepth(this.encoding);
+    return {
+      length: this.length,
+      nullCount: this.nullCount,
+      coordinateCount: this.coordinateCount,
+      geometryOffsetCount: depth >= 1 ? this.length + 1 : 0,
+      partOffsetCount: depth >= 2 ? this.partCount + 1 : 0,
+      ringOffsetCount: depth >= 3 ? this.ringCount + 1 : 0
+    };
+  }
+  /** Allocates a write target from the current measure pass. */
+  allocateTarget() {
+    if (this.mode !== "measure")
+      throw new Error("Only a measure builder can allocate a target");
+    return allocateGeoArrowBuilderTarget(this.getMeasurement(), {
+      encoding: this.encoding,
+      dimension: this.dimension,
+      coordinateLayout: this.coordinateLayout,
+      offsetType: this.offsetType,
+      coordinateType: this.coordinateType
+    });
+  }
+  /** Finishes a write pass and returns a one-chunk borrowed column. */
+  finish() {
+    if (!this.target)
+      throw new Error("A measure builder has no finished column");
+    const measurement = this.getMeasurement();
+    assertTargetCapacity(this.target, measurement, getGeoArrowDimensionSize(this.dimension));
+    const coordinates = makeCoordinateArray(this.target.coordinates, measurement.coordinateCount, this.dimension, this.coordinateLayout);
+    const depth = getBuilderDepth(this.encoding);
+    let chunk = coordinates;
+    if (depth >= 3) {
+      chunk = {
+        kind: "list",
+        length: this.ringCount,
+        offsets: this.target.ringOffsets,
+        child: chunk
+      };
+    }
+    if (depth >= 2) {
+      chunk = {
+        kind: "list",
+        length: this.partCount,
+        offsets: this.target.partOffsets,
+        child: chunk
+      };
+    }
+    if (depth >= 1) {
+      chunk = {
+        kind: "list",
+        length: this.length,
+        offsets: this.target.geometryOffsets,
+        child: chunk,
+        validity: { values: this.target.validity }
+      };
+    } else {
+      chunk = { ...chunk, validity: { values: this.target.validity } };
+    }
+    return {
+      encoding: this.encoding,
+      dimension: this.dimension,
+      coordinateLayout: this.coordinateLayout,
+      chunks: [chunk]
+    };
+  }
+  /** Builds a homogeneous column using an internal measure/write pair. */
+  static build(rows, options) {
+    const measure = new _GeoArrowBuilder({ ...options, mode: "measure" });
+    for (const row of rows)
+      measure.append(row);
+    const write = new _GeoArrowBuilder({
+      ...options,
+      mode: "write",
+      target: measure.allocateTarget()
+    });
+    for (const row of rows)
+      write.append(row);
+    return write.finish();
+  }
+  appendNull(rowIndex) {
+    var _a;
+    const depth = getBuilderDepth(this.encoding);
+    if (depth === 0) {
+      this.writeCoordinateValues(new Array(getGeoArrowDimensionSize(this.dimension)).fill(0));
+    } else {
+      this.writeOffset((_a = this.target) == null ? void 0 : _a.geometryOffsets, rowIndex + 1, depth === 1 ? this.coordinateCount : this.partCount);
+    }
+  }
+  writeCoordinateList(coordinates) {
+    for (const coordinate of coordinates)
+      this.writeCoordinateValues(coordinate);
+  }
+  writeCoordinateValues(coordinate) {
+    const size = getGeoArrowDimensionSize(this.dimension);
+    if (coordinate.length === 0 && (this.encoding === "geoarrow.point" || this.encoding === "geoarrow.multipoint")) {
+      coordinate = new Array(size).fill(Number.NaN);
+    }
+    if (coordinate.length !== size) {
+      throw new Error(`Expected ${size} coordinate values for ${this.dimension}`);
+    }
+    if (this.target)
+      writeCoordinate(this.target.coordinates, this.coordinateCount, coordinate, this.dimension);
+    this.coordinateCount++;
+  }
+  writeCoordinateComponents(x, y, z, m, sourceDimension) {
+    const targetZ = sourceDimension === "xyz" || sourceDimension === "xyzm" ? z ?? 0 : 0;
+    const targetM = sourceDimension === "xym" || sourceDimension === "xyzm" ? m ?? 0 : 0;
+    if (this.target) {
+      writeCoordinateComponents(this.target.coordinates, this.coordinateCount, x, y, targetZ, targetM, this.dimension);
+    }
+    this.coordinateCount++;
+  }
+  /** Begins an event-driven geometry. Events are accepted by both measure and write builders. */
+  beginGeometry(type, dimension = this.dimension, _count) {
+    const direct = getGeoArrowGeometryType(this.encoding) === type;
+    const rowIndex = direct ? this.length++ : -1;
+    this.eventStack.push({
+      type,
+      dimension,
+      direct,
+      rowIndex,
+      ringStarted: false,
+      polygonStarted: false,
+      ...direct ? {} : { rings: [], polygons: [] },
+      ...direct ? {} : { children: [] }
+    });
+    return this;
+  }
+  /** Begins a polygon part inside an event-built MultiPolygon. */
+  beginPolygon() {
+    const state = this.eventStack[this.eventStack.length - 1];
+    if (!state || state.type !== "MultiPolygon") {
+      throw new Error("beginPolygon must follow beginGeometry('MultiPolygon')");
+    }
+    if (state.direct) {
+      this.finishEventRing(state);
+      this.finishEventPolygon(state);
+      state.polygonStarted = true;
+      return this;
+    }
+    state.currentPolygon = [];
+    state.polygons.push(state.currentPolygon);
+    state.currentRing = void 0;
+    return this;
+  }
+  /** Begins a ring/part in the current event geometry. */
+  beginRing(_count) {
+    const state = this.eventStack[this.eventStack.length - 1];
+    if (!state)
+      throw new Error("beginRing must follow beginGeometry");
+    if (state.direct) {
+      this.finishEventRing(state);
+      state.ringStarted = true;
+      return this;
+    }
+    state.currentRing = [];
+    if (state.type === "MultiPolygon") {
+      if (!state.currentPolygon)
+        this.beginPolygon();
+      state.currentPolygon.push(state.currentRing);
+    } else {
+      state.rings.push(state.currentRing);
+    }
+    return this;
+  }
+  /** Writes one coordinate into the current event ring or point. */
+  writeCoordinate(x, y, z, m) {
+    const state = this.eventStack[this.eventStack.length - 1];
+    if (!state)
+      throw new Error("writeCoordinate must follow beginGeometry");
+    if (typeof x === "number" && state.direct) {
+      this.writeCoordinateComponents(x, y, z, m, state.dimension);
+      return this;
+    }
+    const coordinate = Array.isArray(x) ? [...x] : [x, y, ...z === void 0 ? [] : [z], ...m === void 0 ? [] : [m]];
+    const size = getGeoArrowDimensionSize(state.dimension);
+    if (coordinate.length !== size)
+      throw new Error(`Expected ${size} coordinate values for ${state.dimension}`);
+    if (state.direct) {
+      this.writeCoordinateValues(resizeEventCoordinate(coordinate, state.dimension, this.dimension));
+      return this;
+    }
+    if (state.type === "Point") {
+      state.rings = [[coordinate]];
+      return this;
+    }
+    if (!state.currentRing)
+      this.beginRing();
+    state.currentRing.push(coordinate);
+    return this;
+  }
+  /** Writes scalar ordinates tagged with their source dimension without allocating a tuple. */
+  writeCoordinateFromDimension(x, y, z, m, sourceDimension) {
+    const state = this.eventStack[this.eventStack.length - 1];
+    if (!state)
+      throw new Error("writeCoordinateFromDimension must follow beginGeometry");
+    if (state.direct) {
+      this.writeCoordinateComponents(x, y, z, m, sourceDimension);
+      return this;
+    }
+    const coordinate = getDimensionNames(state.dimension).map((name) => {
+      if (name === "x")
+        return x;
+      if (name === "y")
+        return y;
+      if (name === "z")
+        return sourceDimension === "xyz" || sourceDimension === "xyzm" ? z ?? 0 : 0;
+      return sourceDimension === "xym" || sourceDimension === "xyzm" ? m ?? 0 : 0;
+    });
+    return this.writeCoordinate(coordinate);
+  }
+  /** Ends the current event geometry and appends it to the builder/parent. */
+  endGeometry() {
+    var _a, _b, _c;
+    const state = this.eventStack.pop();
+    if (!state)
+      throw new Error("endGeometry without beginGeometry");
+    if (state.direct) {
+      this.finishEventRing(state);
+      this.finishEventPolygon(state);
+      const depth = getBuilderDepth(this.encoding);
+      if (depth >= 1) {
+        this.writeOffset((_a = this.target) == null ? void 0 : _a.geometryOffsets, state.rowIndex + 1, depth === 1 ? this.coordinateCount : this.partCount);
+      }
+      if (this.target)
+        setValidityBit(this.target.validity, state.rowIndex);
+      return this;
+    }
+    const coordinates = state.rings || [];
+    let geometry;
+    switch (state.type) {
+      case "Point":
+        geometry = { type: "Point", coordinates: ((_b = coordinates[0]) == null ? void 0 : _b[0]) || [] };
+        break;
+      case "LineString":
+        geometry = { type: "LineString", coordinates: coordinates[0] || [] };
+        break;
+      case "MultiPoint":
+        geometry = { type: "MultiPoint", coordinates: coordinates.flat() };
+        break;
+      case "Polygon":
+        geometry = { type: "Polygon", coordinates };
+        break;
+      case "MultiLineString":
+        geometry = { type: "MultiLineString", coordinates };
+        break;
+      case "MultiPolygon":
+        geometry = {
+          type: "MultiPolygon",
+          coordinates: ((_c = state.polygons) == null ? void 0 : _c.length) ? state.polygons : [coordinates]
+        };
+        break;
+      case "GeometryCollection":
+        geometry = { type: "GeometryCollection", geometries: state.children || [] };
+        break;
+    }
+    const parent = this.eventStack[this.eventStack.length - 1];
+    if ((parent == null ? void 0 : parent.type) === "GeometryCollection")
+      parent.children.push(geometry);
+    else
+      this.append(geometry);
+    return this;
+  }
+  writeOffset(target, index, value) {
+    if (!target)
+      return;
+    if (target instanceof BigInt64Array)
+      target[index] = BigInt(value);
+    else
+      target[index] = value;
+  }
+  finishEventRing(state) {
+    var _a, _b;
+    if (!state.direct || !state.ringStarted)
+      return;
+    if (this.encoding === "geoarrow.multipolygon") {
+      this.ringCount++;
+      this.writeOffset((_a = this.target) == null ? void 0 : _a.ringOffsets, this.ringCount, this.coordinateCount);
+    } else if (getBuilderDepth(this.encoding) >= 2) {
+      this.partCount++;
+      this.writeOffset((_b = this.target) == null ? void 0 : _b.partOffsets, this.partCount, this.coordinateCount);
+    }
+    state.ringStarted = false;
+  }
+  finishEventPolygon(state) {
+    var _a;
+    if (!state.direct || !state.polygonStarted)
+      return;
+    if (this.encoding === "geoarrow.multipolygon") {
+      this.partCount++;
+      this.writeOffset((_a = this.target) == null ? void 0 : _a.partOffsets, this.partCount, this.ringCount);
+    }
+    state.polygonStarted = false;
+  }
+  initializeTargetOffsets(target) {
+    this.writeOffset(target.geometryOffsets, 0, 0);
+    this.writeOffset(target.partOffsets, 0, 0);
+    this.writeOffset(target.ringOffsets, 0, 0);
+  }
+};
+function allocateGeoArrowBuilderTarget(measurement, options) {
+  const dimension = options.dimension || "xy";
+  const size = getGeoArrowDimensionSize(dimension);
+  const FloatArray = options.coordinateType === "float32" ? Float32Array : Float64Array;
+  const coordinateLayout = options.coordinateLayout || "interleaved";
+  const coordinates = coordinateLayout === "interleaved" ? new FloatArray(measurement.coordinateCount * size) : makeSeparatedCoordinateTarget(FloatArray, measurement.coordinateCount, dimension);
+  const OffsetArray = options.offsetType === "int64" ? BigInt64Array : Int32Array;
+  return {
+    validity: new Uint8Array(Math.ceil(measurement.length / 8)),
+    coordinates,
+    geometryOffsets: measurement.geometryOffsetCount ? new OffsetArray(measurement.geometryOffsetCount) : void 0,
+    partOffsets: measurement.partOffsetCount ? new OffsetArray(measurement.partOffsetCount) : void 0,
+    ringOffsets: measurement.ringOffsetCount ? new OffsetArray(measurement.ringOffsetCount) : void 0
+  };
+}
+function makeGeoArrowColumnFromGeometryRows(rows, options = {}) {
+  const geometryTypes = [...new Set(rows.filter(Boolean).map((row) => row.type))];
+  const dimension = options.dimension || inferRowsDimension(rows);
+  if (options.encoding === "geoarrow.geometry") {
+    return {
+      encoding: "geoarrow.geometry",
+      dimension,
+      coordinateLayout: options.coordinateLayout || "interleaved",
+      chunks: [makeDenseUnionArray(rows, options, dimension)]
+    };
+  }
+  if (geometryTypes.length === 0) {
+    return GeoArrowBuilder.build(rows, { ...options, dimension, encoding: "geoarrow.point" });
+  }
+  if (geometryTypes.length === 1 && geometryTypes[0] !== "GeometryCollection") {
+    return GeoArrowBuilder.build(rows, {
+      ...options,
+      dimension,
+      encoding: getGeoArrowEncodingForGeometry(geometryTypes[0])
+    });
+  }
+  if (geometryTypes.length === 1 && geometryTypes[0] === "GeometryCollection") {
+    return {
+      encoding: "geoarrow.geometrycollection",
+      dimension,
+      coordinateLayout: options.coordinateLayout || "interleaved",
+      chunks: [makeGeometryCollectionArray(rows, options, dimension)]
+    };
+  }
+  return {
+    encoding: "geoarrow.geometry",
+    dimension,
+    coordinateLayout: options.coordinateLayout || "interleaved",
+    chunks: [makeDenseUnionArray(rows, options, dimension)]
+  };
+}
+function makeDenseUnionArray(rows, options, dimension) {
+  const nonNullTypes = [...new Set(rows.filter(Boolean).map((row) => row.type))];
+  const fallbackType = nonNullTypes[0] || "Point";
+  const childRows = /* @__PURE__ */ new Map();
+  for (const type of nonNullTypes.length ? nonNullTypes : [fallbackType])
+    childRows.set(type, []);
+  const typeIds = new Int8Array(rows.length);
+  const valueOffsets = new Int32Array(rows.length);
+  for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+    const geometry = rows[rowIndex];
+    const type = (geometry == null ? void 0 : geometry.type) || fallbackType;
+    const values = childRows.get(type) || [];
+    typeIds[rowIndex] = getGeometryTypeId(type, dimension);
+    valueOffsets[rowIndex] = values.length;
+    values.push(geometry);
+    childRows.set(type, values);
+  }
+  const children = [...childRows.entries()].sort(([left], [right]) => getGeometryTypeId(left, dimension) - getGeometryTypeId(right, dimension)).map(([type, values]) => {
+    const data = type === "GeometryCollection" ? makeGeometryCollectionArray(values, options, dimension) : GeoArrowBuilder.build(values, {
+      ...options,
+      dimension,
+      encoding: getGeoArrowEncodingForGeometry(type)
+    }).chunks[0];
+    return {
+      name: type,
+      typeId: getGeometryTypeId(type, dimension),
+      encoding: getGeoArrowEncodingForGeometry(type),
+      dimension,
+      coordinateLayout: options.coordinateLayout || "interleaved",
+      data
+    };
+  });
+  return {
+    kind: "dense-union",
+    length: rows.length,
+    typeIds,
+    valueOffsets,
+    children
+  };
+}
+function makeGeometryCollectionArray(rows, options, dimension) {
+  const offsets = new Int32Array(rows.length + 1);
+  const validity = new Uint8Array(Math.ceil(rows.length / 8));
+  const flattened = [];
+  for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+    const row = rows[rowIndex];
+    if ((row == null ? void 0 : row.type) === "GeometryCollection") {
+      flattened.push(...row.geometries);
+      setValidityBit(validity, rowIndex);
+    }
+    offsets[rowIndex + 1] = flattened.length;
+  }
+  return {
+    kind: "list",
+    length: rows.length,
+    offsets,
+    child: makeDenseUnionArray(flattened, options, dimension),
+    validity: { values: validity }
+  };
+}
+function makeCoordinateArray(coordinates, coordinateCount, dimension, layout) {
+  const size = getGeoArrowDimensionSize(dimension);
+  if (layout === "interleaved") {
+    const values = coordinates;
+    return {
+      kind: "fixed-size-list",
+      length: coordinateCount,
+      size,
+      child: { kind: "primitive", length: coordinateCount * size, values }
+    };
+  }
+  const separated = coordinates;
+  const children = {
+    x: { kind: "primitive", length: coordinateCount, values: separated.x },
+    y: { kind: "primitive", length: coordinateCount, values: separated.y }
+  };
+  if (separated.z) {
+    children["z"] = { kind: "primitive", length: coordinateCount, values: separated.z };
+  }
+  if (separated.m) {
+    children["m"] = { kind: "primitive", length: coordinateCount, values: separated.m };
+  }
+  return { kind: "struct", length: coordinateCount, children };
+}
+function makeSeparatedCoordinateTarget(FloatArray, count, dimension) {
+  return {
+    x: new FloatArray(count),
+    y: new FloatArray(count),
+    z: dimension === "xyz" || dimension === "xyzm" ? new FloatArray(count) : void 0,
+    m: dimension === "xym" || dimension === "xyzm" ? new FloatArray(count) : void 0
+  };
+}
+function writeCoordinate(target, coordinateIndex, coordinate, dimension) {
+  if (target instanceof Float32Array || target instanceof Float64Array) {
+    target.set(coordinate, coordinateIndex * coordinate.length);
+    return;
+  }
+  target.x[coordinateIndex] = coordinate[0];
+  target.y[coordinateIndex] = coordinate[1];
+  if (dimension === "xyz")
+    target.z[coordinateIndex] = coordinate[2];
+  else if (dimension === "xym")
+    target.m[coordinateIndex] = coordinate[2];
+  else if (dimension === "xyzm") {
+    target.z[coordinateIndex] = coordinate[2];
+    target.m[coordinateIndex] = coordinate[3];
+  }
+}
+function writeCoordinateComponents(target, coordinateIndex, x, y, z, m, dimension) {
+  if (target instanceof Float32Array || target instanceof Float64Array) {
+    const size = getGeoArrowDimensionSize(dimension);
+    const offset = coordinateIndex * size;
+    target[offset] = x;
+    target[offset + 1] = y;
+    if (dimension === "xyz")
+      target[offset + 2] = z;
+    else if (dimension === "xym")
+      target[offset + 2] = m;
+    else if (dimension === "xyzm") {
+      target[offset + 2] = z;
+      target[offset + 3] = m;
+    }
+    return;
+  }
+  target.x[coordinateIndex] = x;
+  target.y[coordinateIndex] = y;
+  if (dimension === "xyz")
+    target.z[coordinateIndex] = z;
+  else if (dimension === "xym")
+    target.m[coordinateIndex] = m;
+  else if (dimension === "xyzm") {
+    target.z[coordinateIndex] = z;
+    target.m[coordinateIndex] = m;
+  }
+}
+function resizeEventCoordinate(coordinate, sourceDimension, targetDimension) {
+  if (sourceDimension === targetDimension)
+    return [...coordinate];
+  const sourceNames = getDimensionNames(sourceDimension);
+  return getDimensionNames(targetDimension).map((name) => {
+    const index = sourceNames.indexOf(name);
+    return index >= 0 ? coordinate[index] ?? 0 : 0;
+  });
+}
+function getDimensionNames(dimension) {
+  switch (dimension) {
+    case "xy":
+      return ["x", "y"];
+    case "xyz":
+      return ["x", "y", "z"];
+    case "xym":
+      return ["x", "y", "m"];
+    case "xyzm":
+      return ["x", "y", "z", "m"];
+  }
+}
+function setValidityBit(validity, index) {
+  validity[index >> 3] |= 1 << (index & 7);
+}
+function getBuilderDepth(encoding) {
+  switch (encoding) {
+    case "geoarrow.point":
+      return 0;
+    case "geoarrow.linestring":
+    case "geoarrow.multipoint":
+      return 1;
+    case "geoarrow.polygon":
+    case "geoarrow.multilinestring":
+      return 2;
+    case "geoarrow.multipolygon":
+      return 3;
+  }
+}
+function getGeometryTypeId(type, dimension = "xy") {
+  const family = [
+    "Point",
+    "LineString",
+    "Polygon",
+    "MultiPoint",
+    "MultiLineString",
+    "MultiPolygon",
+    "GeometryCollection"
+  ].indexOf(type);
+  const dimensionIndex = ["xy", "xyz", "xym", "xyzm"].indexOf(dimension);
+  return family < 0 || dimensionIndex < 0 ? 1 : family * 4 + dimensionIndex + 1;
+}
+function inferRowsDimension(rows) {
+  let size = 2;
+  const visit = (value) => {
+    if (!Array.isArray(value) || value.length === 0)
+      return;
+    if (typeof value[0] === "number")
+      size = Math.max(size, value.length);
+    else
+      for (const child of value)
+        visit(child);
+  };
+  const visitGeometry2 = (geometry) => {
+    if (geometry.type === "GeometryCollection") {
+      for (const child of geometry.geometries)
+        visitGeometry2(child);
+    } else {
+      visit(geometry.coordinates);
+    }
+  };
+  for (const row of rows) {
+    if (row)
+      visitGeometry2(row);
+  }
+  return size >= 4 ? "xyzm" : size === 3 ? "xyz" : "xy";
+}
+function assertTargetCapacity(target, measurement, size) {
+  const coordinateLength = target.coordinates instanceof Float32Array || target.coordinates instanceof Float64Array ? target.coordinates.length / size : target.coordinates.x.length;
+  if (coordinateLength < measurement.coordinateCount || target.validity.length * 8 < measurement.length) {
+    throw new Error("GeoArrowBuilder target is smaller than its measured output");
+  }
+}
+
+// dist/geoarrow/layout.js
+function isGeoArrowValueValid(validity, index) {
+  if (!validity)
+    return true;
+  const bitIndex = (validity.bitOffset || 0) + index;
+  return Boolean(validity.values[bitIndex >> 3] & 1 << (bitIndex & 7));
+}
+function materializeGeometryRow(array, rowIndex, encoding) {
+  if (!isGeoArrowValueValid(array.validity, rowIndex))
+    return null;
+  if (encoding === "geoarrow.geometry") {
+    if (array.kind !== "dense-union")
+      return null;
+    return materializeUnionRow(array, rowIndex);
+  }
+  if (encoding === "geoarrow.geometrycollection") {
+    if (array.kind !== "list")
+      return null;
+    const [first, last] = getListRange(array, rowIndex);
+    const geometries = [];
+    for (let index = first; index < last; index++) {
+      if (array.child.kind !== "dense-union")
+        continue;
+      const geometry = materializeUnionRow(array.child, index);
+      if (geometry)
+        geometries.push(geometry);
+    }
+    return { type: "GeometryCollection", geometries };
+  }
+  const geometryType = getGeoArrowGeometryType(encoding);
+  if (!geometryType || geometryType === "GeometryCollection")
+    return null;
+  const depth = getEncodingDepth(encoding);
+  const coordinates = readNestedCoordinates(array, rowIndex, depth, geometryType === "Point" || geometryType === "MultiPoint");
+  if (!coordinates)
+    return null;
+  return { type: geometryType, coordinates };
+}
+function getGeoArrowOffset(offsets, index) {
+  const value = offsets[index];
+  const numericValue = typeof value === "bigint" ? Number(value) : value;
+  if (!Number.isSafeInteger(numericValue)) {
+    throw new Error(`GeoArrow offset ${String(value)} exceeds JavaScript's safe integer range`);
+  }
+  return numericValue;
+}
+function getListRange(list, rowIndex) {
+  const offsetIndex = (list.offset || 0) + rowIndex;
+  const baseValue = list.offsetBase ?? 0;
+  const base = typeof baseValue === "bigint" ? Number(baseValue) : baseValue;
+  return [
+    getGeoArrowOffset(list.offsets, offsetIndex) - base,
+    getGeoArrowOffset(list.offsets, offsetIndex + 1) - base
+  ];
+}
+function readNestedCoordinates(array, index, depth, normalizeEmptyPoints) {
+  if (depth === 0) {
+    const coordinate = readCoordinate(array, index);
+    return normalizeEmptyPoints && (coordinate == null ? void 0 : coordinate.every((value) => !Number.isFinite(value))) ? [] : coordinate;
+  }
+  if (array.kind !== "list" || !isGeoArrowValueValid(array.validity, index))
+    return null;
+  const [first, last] = getListRange(array, index);
+  const values = [];
+  for (let childIndex = first; childIndex < last; childIndex++) {
+    const value = readNestedCoordinates(array.child, childIndex, depth - 1, normalizeEmptyPoints);
+    if (value !== null)
+      values.push(value);
+  }
+  return values;
+}
+function readCoordinate(array, index) {
+  if (!isGeoArrowValueValid(array.validity, index))
+    return null;
+  if (array.kind === "fixed-size-list") {
+    const listIndex = (array.offset || 0) + index;
+    const coordinate = [];
+    for (let component = 0; component < array.size; component++) {
+      coordinate.push(readPrimitive(array.child, listIndex * array.size + component));
+    }
+    return coordinate;
+  }
+  if (array.kind === "struct") {
+    const structIndex = (array.offset || 0) + index;
+    const coordinate = [];
+    for (const name of ["x", "y", "z", "m"]) {
+      const child = array.children[name];
+      if (child)
+        coordinate.push(readPrimitive(child, structIndex));
+    }
+    return coordinate.length >= 2 ? coordinate : null;
+  }
+  return null;
+}
+function readPrimitive(array, index) {
+  if (array.kind !== "primitive")
+    throw new Error("GeoArrow coordinate child must be primitive");
+  if (!isGeoArrowValueValid(array.validity, index))
+    return Number.NaN;
+  const valueIndex = (array.offset || 0) + index * (array.stride || 1);
+  return Number(array.values[valueIndex]);
+}
+function materializeUnionRow(union, rowIndex) {
+  if (!isGeoArrowValueValid(union.validity, rowIndex))
+    return null;
+  const physicalIndex = (union.offset || 0) + rowIndex;
+  const typeId = union.typeIds[physicalIndex];
+  const valueOffset = union.valueOffsets[physicalIndex];
+  const child = union.children.find((candidate) => candidate.typeId === typeId);
+  if (!child || valueOffset < 0 || valueOffset >= child.data.length)
+    return null;
+  return materializeGeometryRow(child.data, valueOffset, child.encoding || getEncodingFromChildName(child.name));
+}
+function getEncodingFromChildName(name) {
+  const normalized = name.replace(/[^a-z]/gi, "").toLowerCase();
+  switch (normalized) {
+    case "point":
+      return "geoarrow.point";
+    case "linestring":
+      return "geoarrow.linestring";
+    case "polygon":
+      return "geoarrow.polygon";
+    case "multipoint":
+      return "geoarrow.multipoint";
+    case "multilinestring":
+      return "geoarrow.multilinestring";
+    case "multipolygon":
+      return "geoarrow.multipolygon";
+    case "geometrycollection":
+      return "geoarrow.geometrycollection";
+    default:
+      throw new Error(`Unknown GeoArrow dense-union child ${name}`);
+  }
+}
+function getEncodingDepth(encoding) {
+  switch (encoding) {
+    case "geoarrow.point":
+      return 0;
+    case "geoarrow.linestring":
+    case "geoarrow.multipoint":
+      return 1;
+    case "geoarrow.polygon":
+    case "geoarrow.multilinestring":
+      return 2;
+    case "geoarrow.multipolygon":
+      return 3;
+    default:
+      return 0;
+  }
+}
+
+// dist/geoarrow/codecs.js
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+var NULL_FAMILY = 255;
+function decodeGeoArrowWKB(column, options = {}) {
+  if (column.encoding !== "geoarrow.wkb")
+    throw new Error("Expected a geoarrow.wkb column");
+  const classifications = [];
+  const schemaKeys = /* @__PURE__ */ new Set();
+  const collectionSchemas = [];
+  const rootFamilies = /* @__PURE__ */ new Set();
+  let hasNulls = false;
+  let inferredDimension = "xy";
+  for (const chunk of column.chunks) {
+    if (chunk.kind !== "serialized")
+      throw new Error("Serialized column contains native storage");
+    const families = new Uint8Array(chunk.length).fill(NULL_FAMILY);
+    const dimensions = new Uint8Array(chunk.length);
+    for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+      if (!isGeoArrowValueValid(chunk.validity, rowIndex)) {
+        hasNulls = true;
+        continue;
+      }
+      const bytes = getSerializedBytes(chunk, rowIndex);
+      const rootHeader = inspectWKBHeader(bytes);
+      const rootFamily = getGeometryFamilyIndex(rootHeader.geometryType);
+      let rowDimension = rootHeader.dimension;
+      if (rootHeader.geometryType === "GeometryCollection") {
+        const collectionStack = [];
+        let concreteRootDepth = -1;
+        visitWKB(bytes, {
+          geometry: (header, _count, depth) => {
+            var _a;
+            rowDimension = mergeGeoArrowDimensions(rowDimension, header.dimension);
+            if (concreteRootDepth >= 0 && depth > concreteRootDepth)
+              return;
+            concreteRootDepth = -1;
+            while (collectionStack.length && depth <= collectionStack[collectionStack.length - 1].depth) {
+              collectionStack.pop();
+            }
+            const parent = collectionStack[collectionStack.length - 1];
+            if (parent) {
+              collectionSchemas[_a = parent.level] || (collectionSchemas[_a] = /* @__PURE__ */ new Set());
+              collectionSchemas[parent.level].add(getGeometryTypeId2(header.geometryType, header.dimension));
+            }
+            if (header.geometryType === "GeometryCollection") {
+              collectionStack.push({ depth, level: parent ? parent.level + 1 : 0 });
+            } else if (parent) {
+              concreteRootDepth = depth;
+            }
+          }
+        }, options.traversal);
+      }
+      families[rowIndex] = rootFamily;
+      dimensions[rowIndex] = getDimensionIndex(rowDimension);
+      rootFamilies.add(rootFamily);
+      schemaKeys.add(getGeometryTypeIdFromIndices(rootFamily, dimensions[rowIndex]));
+      inferredDimension = mergeGeoArrowDimensions(inferredDimension, rowDimension);
+    }
+    classifications.push({ families, dimensions });
+  }
+  const dimension = resolveDecodeDimension(options.dimension, column.dimension, inferredDimension);
+  const forceDimension = Boolean(options.dimension && options.dimension !== "infer");
+  if (forceDimension) {
+    schemaKeys.clear();
+    for (const classification of classifications) {
+      for (let rowIndex = 0; rowIndex < classification.families.length; rowIndex++) {
+        const family = classification.families[rowIndex];
+        if (family === NULL_FAMILY)
+          continue;
+        classification.dimensions[rowIndex] = getDimensionIndex(dimension);
+        schemaKeys.add(getGeometryTypeIdFromIndices(family, getDimensionIndex(dimension)));
+      }
+    }
+  }
+  const encoding = resolveDecodeEncoding(options.encoding, rootFamilies);
+  validateDecodeEncoding(encoding, rootFamilies);
+  const builderOptions = {
+    dimension,
+    coordinateLayout: options.coordinateLayout || "interleaved",
+    coordinateType: options.coordinateType || "float64",
+    offsetType: options.offsetType || "int32"
+  };
+  if (encoding !== "geoarrow.geometry" && encoding !== "geoarrow.geometrycollection") {
+    const chunks2 = column.chunks.map((chunk, chunkIndex) => decodeConcreteWKBChunk(chunk, classifications[chunkIndex], encoding, builderOptions, options.traversal));
+    return copyMetadata(column, {
+      encoding,
+      dimension,
+      coordinateLayout: builderOptions.coordinateLayout,
+      chunks: chunks2
+    });
+  }
+  if (encoding === "geoarrow.geometrycollection") {
+    const stableCollectionSchemas = normalizeCollectionSchemas(collectionSchemas, dimension, forceDimension);
+    const chunks2 = column.chunks.map((chunk, chunkIndex) => decodeGeometryCollectionWKBChunk(chunk, classifications[chunkIndex], void 0, stableCollectionSchemas, builderOptions, options.traversal, forceDimension ? dimension : void 0));
+    return copyMetadata(column, {
+      encoding,
+      dimension,
+      coordinateLayout: builderOptions.coordinateLayout,
+      chunks: chunks2
+    });
+  }
+  if (schemaKeys.size === 0)
+    schemaKeys.add(getGeometryTypeId2("Point", dimension));
+  if (hasNulls)
+    schemaKeys.add(getGeometryTypeId2("Point", dimension));
+  const stableSchema = [...schemaKeys].sort((left, right) => left - right);
+  const chunks = column.chunks.map((chunk, chunkIndex) => decodeUnionWKBChunk(chunk, classifications[chunkIndex], stableSchema, normalizeCollectionSchemas(collectionSchemas, dimension, forceDimension), builderOptions, options.traversal, forceDimension ? dimension : void 0));
+  return copyMetadata(column, {
+    encoding: "geoarrow.geometry",
+    dimension,
+    coordinateLayout: builderOptions.coordinateLayout,
+    chunks
+  });
+}
+function getGeoArrowWKBVertexCount(column, traversal) {
+  if (column.encoding !== "geoarrow.wkb")
+    throw new Error("Expected a geoarrow.wkb column");
+  let vertexCount = 0;
+  for (const chunk of column.chunks) {
+    if (chunk.kind !== "serialized")
+      throw new Error("Serialized column contains native storage");
+    for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+      if (!isGeoArrowValueValid(chunk.validity, rowIndex))
+        continue;
+      visitWKB(getSerializedBytes(chunk, rowIndex), {
+        geometry: (header, count) => {
+          if (header.geometryType === "Point")
+            vertexCount++;
+          else if (header.geometryType === "LineString")
+            vertexCount += count || 0;
+        },
+        ring: (pointCount) => {
+          vertexCount += pointCount;
+        }
+      }, traversal);
+    }
+  }
+  return vertexCount;
+}
+function decodeConcreteWKBChunk(chunk, classification, encoding, options, traversal) {
+  const measure = new GeoArrowBuilder({ ...options, encoding, mode: "measure" });
+  replaySerializedChunk(chunk, classification, encoding, measure, traversal);
+  const write = new GeoArrowBuilder({
+    ...options,
+    encoding,
+    mode: "write",
+    target: measure.allocateTarget()
+  });
+  replaySerializedChunk(chunk, classification, encoding, write, traversal);
+  return write.finish().chunks[0];
+}
+function replaySerializedChunk(chunk, classification, encoding, builder, traversal) {
+  const targetType = geometryTypeFromEncoding(encoding);
+  for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+    if (classification.families[rowIndex] === NULL_FAMILY)
+      builder.append(null);
+    else
+      visitWKBIntoBuilder(getSerializedBytes(chunk, rowIndex), builder, targetType, traversal);
+  }
+}
+function decodeUnionWKBChunk(chunk, classification, stableSchema, collectionSchemas, options, traversal, childDimensionOverride) {
+  const measureBuilders = /* @__PURE__ */ new Map();
+  for (const key of stableSchema) {
+    const type = getGeometryTypeFromId(key);
+    if (type !== "GeometryCollection") {
+      const encoding = encodingFromGeometryType(type);
+      measureBuilders.set(key, new GeoArrowBuilder({
+        ...options,
+        encoding,
+        dimension: getDimensionFromId(key),
+        mode: "measure"
+      }));
+    }
+  }
+  const typeIds = new Int8Array(chunk.length);
+  const valueOffsets = new Int32Array(chunk.length);
+  const childCounts = /* @__PURE__ */ new Map();
+  const nullKey = stableSchema[0];
+  for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+    const family = classification.families[rowIndex];
+    const key = family === NULL_FAMILY ? nullKey : getGeometryTypeIdFromIndices(family, classification.dimensions[rowIndex]);
+    typeIds[rowIndex] = key;
+    valueOffsets[rowIndex] = childCounts.get(key) || 0;
+    childCounts.set(key, valueOffsets[rowIndex] + 1);
+    const builder = measureBuilders.get(key);
+    if (builder) {
+      if (family === NULL_FAMILY)
+        builder.append(null);
+      else
+        visitWKBIntoBuilder(getSerializedBytes(chunk, rowIndex), builder, getConcreteGeometryTypeFromId(key), traversal);
+    }
+  }
+  const writeBuilders = /* @__PURE__ */ new Map();
+  for (const key of stableSchema) {
+    if (getGeometryTypeFromId(key) === "GeometryCollection")
+      continue;
+    const measure = measureBuilders.get(key);
+    writeBuilders.set(key, new GeoArrowBuilder({
+      ...options,
+      encoding: encodingFromGeometryType(getConcreteGeometryTypeFromId(key)),
+      dimension: getDimensionFromId(key),
+      mode: "write",
+      target: measure.allocateTarget()
+    }));
+  }
+  for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+    const family = classification.families[rowIndex];
+    const key = family === NULL_FAMILY ? nullKey : getGeometryTypeIdFromIndices(family, classification.dimensions[rowIndex]);
+    const builder = writeBuilders.get(key);
+    if (builder) {
+      if (family === NULL_FAMILY)
+        builder.append(null);
+      else
+        visitWKBIntoBuilder(getSerializedBytes(chunk, rowIndex), builder, getConcreteGeometryTypeFromId(key), traversal);
+    }
+  }
+  const children = stableSchema.map((key) => {
+    const type = getGeometryTypeFromId(key);
+    if (type === "GeometryCollection") {
+      return {
+        name: type,
+        typeId: key,
+        encoding: "geoarrow.geometrycollection",
+        dimension: getDimensionFromId(key),
+        coordinateLayout: options.coordinateLayout,
+        data: decodeGeometryCollectionWKBChunk(chunk, classification, key, collectionSchemas, { ...options, dimension: getDimensionFromId(key) }, traversal, childDimensionOverride)
+      };
+    }
+    const built = writeBuilders.get(key).finish();
+    return {
+      name: getGeometryTypeFromId(key),
+      typeId: key,
+      encoding: built.encoding,
+      dimension: built.dimension,
+      coordinateLayout: built.coordinateLayout,
+      data: built.chunks[0]
+    };
+  });
+  return { kind: "dense-union", length: chunk.length, typeIds, valueOffsets, children };
+}
+function decodeGeometryCollectionWKBChunk(chunk, classification, selectorKey, schemas, options, traversal, childDimensionOverride) {
+  const measureLevels = schemas.map((schema) => makeCollectionMeasureLevel(schema, options));
+  if (measureLevels.length === 0)
+    measureLevels.push(makeCollectionMeasureLevel([], options));
+  forEachSelectedCollectionRow(chunk, classification, selectorKey, (bytes, valid) => {
+    if (!valid) {
+      measureLevels[0].rowCount++;
+      return;
+    }
+    replayWKBCollection(bytes, measureLevels, void 0, options.dimension, traversal, childDimensionOverride);
+  });
+  const writeLevels = measureLevels.map((level) => makeCollectionWriteLevel(level, options));
+  forEachSelectedCollectionRow(chunk, classification, selectorKey, (bytes, valid) => {
+    if (!valid) {
+      writeCollectionRow(writeLevels[0], 0);
+      return;
+    }
+    replayWKBCollection(bytes, measureLevels, writeLevels, options.dimension, traversal, childDimensionOverride);
+  });
+  const root = makeCollectionLevelArray(0, measureLevels, writeLevels, options);
+  if (selectorKey !== void 0)
+    return root;
+  const validity = new Uint8Array(Math.ceil(root.length / 8));
+  for (let rowIndex = 0; rowIndex < classification.families.length; rowIndex++) {
+    if (classification.families[rowIndex] === getGeometryFamilyIndex("GeometryCollection")) {
+      validity[rowIndex >> 3] |= 1 << (rowIndex & 7);
+    }
+  }
+  return { ...root, validity: { values: validity } };
+}
+function forEachSelectedCollectionRow(chunk, classification, selectorKey, visitor) {
+  const collectionFamily = getGeometryFamilyIndex("GeometryCollection");
+  for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+    const family = classification.families[rowIndex];
+    if (selectorKey === void 0) {
+      if (family === NULL_FAMILY)
+        visitor(void 0, false);
+      else if (family === collectionFamily)
+        visitor(getSerializedBytes(chunk, rowIndex), true);
+      else
+        throw new Error("Rows cannot be represented as geoarrow.geometrycollection");
+    } else if (family === collectionFamily && getGeometryTypeIdFromIndices(family, classification.dimensions[rowIndex]) === selectorKey) {
+      visitor(getSerializedBytes(chunk, rowIndex), true);
+    }
+  }
+}
+function makeCollectionMeasureLevel(schema, options) {
+  const builders = /* @__PURE__ */ new Map();
+  for (const key of schema) {
+    const type = getGeometryTypeFromId(key);
+    if (type !== "GeometryCollection") {
+      builders.set(key, new GeoArrowBuilder({
+        ...options,
+        encoding: encodingFromGeometryType(type),
+        dimension: getDimensionFromId(key),
+        mode: "measure"
+      }));
+    }
+  }
+  return { schema, rowCount: 0, childCount: 0, builders };
+}
+function makeCollectionWriteLevel(measure, options) {
+  const OffsetArray = options.offsetType === "int64" ? BigInt64Array : Int32Array;
+  const builders = /* @__PURE__ */ new Map();
+  for (const [key, builder] of measure.builders) {
+    builders.set(key, new GeoArrowBuilder({
+      ...options,
+      encoding: encodingFromGeometryType(getConcreteGeometryTypeFromId(key)),
+      dimension: getDimensionFromId(key),
+      mode: "write",
+      target: builder.allocateTarget()
+    }));
+  }
+  return {
+    schema: measure.schema,
+    rowCursor: 0,
+    childCursor: 0,
+    offsets: new OffsetArray(measure.rowCount + 1),
+    typeIds: new Int8Array(measure.childCount),
+    valueOffsets: new Int32Array(measure.childCount),
+    childCounts: /* @__PURE__ */ new Map(),
+    builders
+  };
+}
+function replayWKBCollection(bytes, measureLevels, writeLevels, collectionDimension, traversal, childDimensionOverride) {
+  const collectionStack = [];
+  let active;
+  const finishActive = () => {
+    active == null ? void 0 : active.builder.endGeometry();
+    active = void 0;
+  };
+  visitWKB(bytes, {
+    geometry: (header, count, depth) => {
+      if (active && depth > active.rootDepth) {
+        if (active.rootType === "MultiLineString" && header.geometryType === "LineString") {
+          active.builder.beginRing(count);
+        } else if (active.rootType === "MultiPolygon" && header.geometryType === "Polygon") {
+          active.builder.beginPolygon();
+        }
+        return;
+      }
+      finishActive();
+      while (collectionStack.length && depth <= collectionStack[collectionStack.length - 1].depth) {
+        collectionStack.pop();
+      }
+      const parent = collectionStack[collectionStack.length - 1];
+      if (header.geometryType === "GeometryCollection") {
+        if (parent) {
+          addCollectionChild(measureLevels[parent.level], writeLevels == null ? void 0 : writeLevels[parent.level], getGeometryTypeId2("GeometryCollection", collectionDimension));
+        }
+        const level = parent ? parent.level + 1 : 0;
+        if (!measureLevels[level]) {
+          measureLevels[level] = makeCollectionMeasureLevel([], {
+            dimension: collectionDimension,
+            coordinateLayout: "interleaved",
+            coordinateType: "float64",
+            offsetType: "int32"
+          });
+        }
+        if (writeLevels)
+          writeCollectionRow(writeLevels[level], count || 0);
+        else
+          measureLevels[level].rowCount++;
+        collectionStack.push({ depth, level });
+        return;
+      }
+      if (!parent)
+        throw new Error("Expected a GeometryCollection root");
+      const key = getGeometryTypeId2(header.geometryType, childDimensionOverride || header.dimension);
+      addCollectionChild(measureLevels[parent.level], writeLevels == null ? void 0 : writeLevels[parent.level], key);
+      const builder = writeLevels ? writeLevels[parent.level].builders.get(key) : measureLevels[parent.level].builders.get(key);
+      if (!builder)
+        throw new Error(`Missing GeometryCollection child schema for type ID ${key}`);
+      builder.beginGeometry(header.geometryType, header.dimension, count);
+      active = { builder, rootDepth: depth, rootType: header.geometryType };
+    },
+    ring: (pointCount) => active == null ? void 0 : active.builder.beginRing(pointCount),
+    coordinate: (x, y, z, m, dimension) => active == null ? void 0 : active.builder.writeCoordinateFromDimension(x, y, z, m, dimension)
+  }, traversal);
+  finishActive();
+}
+function addCollectionChild(measure, write, key) {
+  if (!write) {
+    measure.childCount++;
+    return;
+  }
+  const index = write.childCursor++;
+  write.typeIds[index] = key;
+  write.valueOffsets[index] = write.childCounts.get(key) || 0;
+  write.childCounts.set(key, write.valueOffsets[index] + 1);
+}
+function writeCollectionRow(level, childCount) {
+  level.rowCursor++;
+  setGeoArrowOffset(level.offsets, level.rowCursor, level.childCursor + childCount);
+}
+function makeCollectionLevelArray(levelIndex, measureLevels, writeLevels, options) {
+  const measure = measureLevels[levelIndex];
+  const write = writeLevels[levelIndex];
+  const children = measure.schema.map((key) => {
+    const type = getGeometryTypeFromId(key);
+    if (type === "GeometryCollection") {
+      return {
+        name: type,
+        typeId: key,
+        encoding: "geoarrow.geometrycollection",
+        dimension: getDimensionFromId(key),
+        coordinateLayout: options.coordinateLayout,
+        data: makeCollectionLevelArray(levelIndex + 1, measureLevels, writeLevels, options)
+      };
+    }
+    const built = write.builders.get(key).finish();
+    return {
+      name: type,
+      typeId: key,
+      encoding: built.encoding,
+      dimension: built.dimension,
+      coordinateLayout: built.coordinateLayout,
+      data: built.chunks[0]
+    };
+  });
+  return {
+    kind: "list",
+    length: measure.rowCount,
+    offsets: write.offsets,
+    child: {
+      kind: "dense-union",
+      length: measure.childCount,
+      typeIds: write.typeIds,
+      valueOffsets: write.valueOffsets,
+      children
+    }
+  };
+}
+function setGeoArrowOffset(offsets, index, value) {
+  if (offsets instanceof BigInt64Array)
+    offsets[index] = BigInt(value);
+  else
+    offsets[index] = value;
+}
+function normalizeCollectionSchemas(schemas, dimension, forceDimension) {
+  return schemas.map((schema) => [...schema].map((key) => forceDimension || getGeometryTypeFromId(key) === "GeometryCollection" ? getGeometryTypeId2(getGeometryTypeFromId(key), dimension) : key).filter((key, index, values) => values.indexOf(key) === index).sort((left, right) => left - right));
+}
+function visitWKBIntoBuilder(bytes, builder, targetType, traversal) {
+  let rootType;
+  visitWKB(bytes, {
+    geometry: (header, _count, depth) => {
+      if (depth === 0) {
+        rootType = header.geometryType;
+        builder.beginGeometry(targetType, header.dimension, _count);
+        if (rootType === "LineString" && targetType === "MultiLineString")
+          builder.beginRing(_count);
+        if (rootType === "Polygon" && targetType === "MultiPolygon")
+          builder.beginPolygon();
+      } else if (rootType === "MultiLineString" && header.geometryType === "LineString") {
+        builder.beginRing(_count);
+      } else if (rootType === "MultiPolygon" && header.geometryType === "Polygon") {
+        builder.beginPolygon();
+      }
+    },
+    ring: (pointCount) => {
+      if (rootType === "Polygon" || rootType === "MultiPolygon")
+        builder.beginRing(pointCount);
+    },
+    coordinate: (x, y, z, m, dimension) => {
+      builder.writeCoordinateFromDimension(x, y, z, m, dimension);
+    }
+  }, traversal);
+  builder.endGeometry();
+}
+function encodingFromGeometryType(type) {
+  if (type === "GeometryCollection")
+    throw new Error("GeometryCollection requires collection storage");
+  return `geoarrow.${type.toLowerCase()}`;
+}
+function getGeometryTypeId2(type, dimension) {
+  return getGeometryTypeIdFromIndices(getGeometryFamilyIndex(type), getDimensionIndex(dimension));
+}
+var GEOMETRY_TYPES2 = [
+  "Point",
+  "LineString",
+  "Polygon",
+  "MultiPoint",
+  "MultiLineString",
+  "MultiPolygon",
+  "GeometryCollection"
+];
+var DIMENSIONS = ["xy", "xyz", "xym", "xyzm"];
+function getGeometryFamilyIndex(type) {
+  return GEOMETRY_TYPES2.indexOf(type);
+}
+function getDimensionIndex(dimension) {
+  return DIMENSIONS.indexOf(dimension);
+}
+function getGeometryTypeIdFromIndices(family, dimension) {
+  return family * 4 + dimension + 1;
+}
+function getGeometryTypeFromId(typeId) {
+  return GEOMETRY_TYPES2[Math.floor((typeId - 1) / 4)];
+}
+function getConcreteGeometryTypeFromId(typeId) {
+  const type = getGeometryTypeFromId(typeId);
+  if (type === "GeometryCollection")
+    throw new Error("GeometryCollection requires collection storage");
+  return type;
+}
+function getDimensionFromId(typeId) {
+  return DIMENSIONS[(typeId - 1) % 4];
+}
+function resolveDecodeDimension(requested, declared, inferred) {
+  if (!requested || requested === "infer")
+    return inferred;
+  return requested === "preserve" ? declared : requested;
+}
+function resolveDecodeEncoding(requested, families) {
+  if (requested && requested !== "native")
+    return requested;
+  if (families.size !== 1)
+    return "geoarrow.geometry";
+  const type = GEOMETRY_TYPES2[[...families][0]];
+  return type === "GeometryCollection" ? "geoarrow.geometrycollection" : encodingFromGeometryType(type);
+}
+function validateDecodeEncoding(encoding, families) {
+  if (encoding === "geoarrow.geometry")
+    return;
+  if (encoding === "geoarrow.geometrycollection") {
+    const collectionFamily = getGeometryFamilyIndex("GeometryCollection");
+    if ([...families].some((family) => family !== collectionFamily)) {
+      throw new Error("Rows cannot be represented as geoarrow.geometrycollection");
+    }
+    return;
+  }
+  const targetType = geometryTypeFromEncoding(encoding);
+  for (const family of families) {
+    const sourceType = GEOMETRY_TYPES2[family];
+    const promotable = sourceType === targetType || sourceType === "Point" && targetType === "MultiPoint" || sourceType === "LineString" && targetType === "MultiLineString" || sourceType === "Polygon" && targetType === "MultiPolygon";
+    if (!promotable)
+      throw new Error(`Rows cannot be represented as ${encoding}`);
+  }
+}
+function geometryTypeFromEncoding(encoding) {
+  const type = GEOMETRY_TYPES2.find((candidate) => `geoarrow.${candidate.toLowerCase()}` === encoding);
+  if (!type || type === "GeometryCollection")
+    throw new Error(`Unsupported target encoding ${encoding}`);
+  return type;
+}
+function encodeGeoArrowWKB(column) {
+  if (column.encoding === "geoarrow.wkb")
+    return column;
+  return copyMetadata(column, {
+    encoding: "geoarrow.wkb",
+    dimension: column.dimension,
+    coordinateLayout: null,
+    chunks: column.chunks.map((chunk) => encodeWKBChunk(column, chunk))
+  });
+}
+function encodeWKBChunk(column, chunk) {
+  const offsets = new Int32Array(chunk.length + 1);
+  const validity = new Uint8Array(Math.ceil(chunk.length / 8));
+  let nullCount = 0;
+  for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+    let byteLength = 0;
+    if (isPhysicalGeometryRowValid(chunk, rowIndex, column.encoding)) {
+      const dimension = getPhysicalGeometryDimension(chunk, rowIndex, column.encoding, column.dimension);
+      const builder = new WKBBuilder({ mode: "measure", dimension });
+      writePhysicalGeometry(builder, chunk, rowIndex, column.encoding, dimension);
+      byteLength = builder.finishGeometry();
+      validity[rowIndex >> 3] |= 1 << (rowIndex & 7);
+    } else {
+      nullCount++;
+    }
+    const nextOffset = offsets[rowIndex] + byteLength;
+    if (nextOffset > 2147483647)
+      throw new Error("WKB geometry chunk exceeds Int32 offsets");
+    offsets[rowIndex + 1] = nextOffset;
+  }
+  const values = new Uint8Array(offsets[offsets.length - 1]);
+  for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+    if (!isPhysicalGeometryRowValid(chunk, rowIndex, column.encoding))
+      continue;
+    const dimension = getPhysicalGeometryDimension(chunk, rowIndex, column.encoding, column.dimension);
+    const builder = new WKBBuilder({
+      mode: "write",
+      target: values,
+      byteOffset: offsets[rowIndex],
+      dimension
+    });
+    writePhysicalGeometry(builder, chunk, rowIndex, column.encoding, dimension);
+    if (offsets[rowIndex] + builder.finishGeometry() !== offsets[rowIndex + 1]) {
+      throw new Error("WKB measure and write passes produced different byte lengths");
+    }
+  }
+  return {
+    kind: "serialized",
+    encoding: "binary",
+    length: chunk.length,
+    offsets,
+    values,
+    ...nullCount ? { validity: { values: validity } } : {}
+  };
+}
+function isPhysicalGeometryRowValid(array, rowIndex, encoding) {
+  if (!isGeoArrowValueValid(array.validity, rowIndex))
+    return false;
+  if (encoding !== "geoarrow.geometry" || array.kind !== "dense-union")
+    return true;
+  const physical = (array.offset || 0) + rowIndex;
+  const child = array.children.find((candidate) => candidate.typeId === array.typeIds[physical]);
+  const childIndex = array.valueOffsets[physical];
+  return Boolean(child && childIndex >= 0 && childIndex < child.data.length && isGeoArrowValueValid(child.data.validity, childIndex));
+}
+function decodeGeoArrowWKT(column) {
+  if (column.encoding !== "geoarrow.wkt")
+    throw new Error("Expected a geoarrow.wkt column");
+  const rows = normalizeRowsToDimension(decodeSerializedRows(column, (bytes) => parseWKT(textDecoder.decode(bytes))), column.dimension);
+  return copyMetadata(column, makeGeoArrowColumnFromGeometryRows(rows, { dimension: column.dimension }));
+}
+function encodeGeoArrowWKT(column) {
+  if (column.encoding === "geoarrow.wkt")
+    return column;
+  const values = [];
+  for (const chunk of column.chunks) {
+    for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+      const row = isGeoArrowValueValid(chunk.validity, rowIndex) ? materializeGeometryRow(chunk, rowIndex, column.encoding) : null;
+      values.push(row ? textEncoder.encode(formatWKT(row, column.dimension)) : null);
+    }
+  }
+  return copyMetadata(column, makeSerializedColumn(values, "geoarrow.wkt", column.dimension));
+}
+function writePhysicalGeometry(builder, array, rowIndex, encoding, dimension) {
+  const depth = getEncodingDepth2(encoding);
+  if (encoding === "geoarrow.geometry" && array.kind === "dense-union") {
+    const physical = (array.offset || 0) + rowIndex;
+    const typeId = array.typeIds[physical];
+    const child = array.children.find((candidate) => candidate.typeId === typeId);
+    if (!child)
+      throw new Error("Dense-union row references an unknown child");
+    const childDimension = child.dimension || dimension;
+    builder.withDimension(childDimension, () => writePhysicalGeometry(builder, child.data, array.valueOffsets[physical], child.encoding || encodingFromName(child.name), childDimension));
+    return;
+  }
+  if (encoding === "geoarrow.geometrycollection" && array.kind === "list") {
+    const [first, last] = getListRange2(array, rowIndex);
+    builder.beginGeometry("GeometryCollection", last - first);
+    if (array.child.kind !== "dense-union")
+      throw new Error("GeometryCollection requires dense union child");
+    const union = array.child;
+    for (let index = first; index < last; index++) {
+      const physical = (union.offset || 0) + index;
+      const child = union.children.find((candidate) => candidate.typeId === union.typeIds[physical]);
+      if (child) {
+        const childDimension = child.dimension || dimension;
+        builder.withDimension(childDimension, () => writePhysicalGeometry(builder, child.data, union.valueOffsets[physical], child.encoding || encodingFromName(child.name), childDimension));
+      }
+    }
+    return;
+  }
+  if (array.kind !== "list" && depth > 0)
+    throw new Error(`Invalid ${encoding} storage`);
+  const writeCoordinate2 = (leaf, index) => {
+    const coordinate = readPhysicalCoordinate(leaf, index);
+    if (!coordinate)
+      throw new Error("Invalid GeoArrow coordinate storage");
+    if (dimension === "xym")
+      builder.writeCoordinate(coordinate[0], coordinate[1], void 0, coordinate[2]);
+    else if (dimension === "xyzm")
+      builder.writeCoordinate(coordinate[0], coordinate[1], coordinate[2], coordinate[3]);
+    else
+      builder.writeCoordinate(coordinate[0], coordinate[1], coordinate[2]);
+  };
+  const writeSequence = (leaf, first, last) => {
+    for (let index = first; index < last; index++)
+      writeCoordinate2(leaf, index);
+  };
+  if (encoding === "geoarrow.point") {
+    builder.beginPoint();
+    writeCoordinate2(array, rowIndex);
+  } else if (encoding === "geoarrow.linestring" || encoding === "geoarrow.multipoint") {
+    const [first, last] = getListRange2(array, rowIndex);
+    if (encoding === "geoarrow.linestring") {
+      builder.beginLineString(last - first);
+      writeSequence(array.child, first, last);
+    } else {
+      builder.beginMultiPoint(last - first);
+      const leaf = array.child;
+      for (let index = first; index < last; index++) {
+        builder.beginPoint();
+        writeCoordinate2(leaf, index);
+      }
+    }
+  } else if (encoding === "geoarrow.polygon" || encoding === "geoarrow.multilinestring") {
+    const [first, last] = getListRange2(array, rowIndex);
+    const parts = array.child;
+    if (encoding === "geoarrow.polygon")
+      builder.beginPolygon(last - first);
+    else
+      builder.beginMultiLineString(last - first);
+    for (let partIndex = first; partIndex < last; partIndex++) {
+      const [ringFirst, ringLast] = getListRange2(parts, partIndex);
+      const leaf = parts.child;
+      if (encoding === "geoarrow.polygon")
+        builder.beginLinearRing(ringLast - ringFirst);
+      else
+        builder.beginLineString(ringLast - ringFirst);
+      writeSequence(leaf, ringFirst, ringLast);
+    }
+  } else if (encoding === "geoarrow.multipolygon") {
+    const [first, last] = getListRange2(array, rowIndex);
+    const polygons = array.child;
+    builder.beginMultiPolygon(last - first);
+    for (let polygonIndex = first; polygonIndex < last; polygonIndex++) {
+      const [partFirst, partLast] = getListRange2(polygons, polygonIndex);
+      const parts = polygons.child;
+      builder.beginPolygon(partLast - partFirst);
+      for (let partIndex = partFirst; partIndex < partLast; partIndex++) {
+        const [ringFirst, ringLast] = getListRange2(parts, partIndex);
+        builder.beginLinearRing(ringLast - ringFirst);
+        writeSequence(parts.child, ringFirst, ringLast);
+      }
+    }
+  }
+}
+function getPhysicalGeometryDimension(array, rowIndex, encoding, dimension) {
+  if (encoding !== "geoarrow.geometry" || array.kind !== "dense-union")
+    return dimension;
+  const physical = (array.offset || 0) + rowIndex;
+  const child = array.children.find((candidate) => candidate.typeId === array.typeIds[physical]);
+  return (child == null ? void 0 : child.dimension) || dimension;
+}
+function readPhysicalCoordinate(array, index) {
+  if (array.kind === "fixed-size-list" && array.child.kind === "primitive") {
+    const logical = (array.offset || 0) + index;
+    const values = [];
+    for (let component = 0; component < array.size; component++)
+      values.push(Number(array.child.values[(array.child.offset || 0) + (logical * array.size + component) * (array.child.stride || 1)]));
+    return values;
+  }
+  if (array.kind === "struct") {
+    const logical = (array.offset || 0) + index;
+    return ["x", "y", "z", "m"].flatMap((name) => {
+      const child = array.children[name];
+      return (child == null ? void 0 : child.kind) === "primitive" ? [Number(child.values[(child.offset || 0) + logical * (child.stride || 1)])] : [];
+    });
+  }
+  return null;
+}
+function getListRange2(list, index) {
+  const offset = (list.offset || 0) + index;
+  const base = typeof (list.offsetBase ?? 0) === "bigint" ? Number(list.offsetBase) : Number(list.offsetBase ?? 0);
+  return [
+    getGeoArrowOffset(list.offsets, offset) - base,
+    getGeoArrowOffset(list.offsets, offset + 1) - base
+  ];
+}
+function getEncodingDepth2(encoding) {
+  return encoding === "geoarrow.point" ? 0 : encoding === "geoarrow.linestring" || encoding === "geoarrow.multipoint" ? 1 : encoding === "geoarrow.polygon" || encoding === "geoarrow.multilinestring" ? 2 : 3;
+}
+function encodingFromName(name) {
+  return `geoarrow.${name.toLowerCase()}`;
+}
+function normalizeRowsToDimension(rows, dimension) {
+  const size = getGeoArrowDimensionSize(dimension);
+  const normalizeGeometry = (geometry) => {
+    if (geometry.type === "GeometryCollection") {
+      return { ...geometry, geometries: geometry.geometries.map(normalizeGeometry) };
+    }
+    return {
+      ...geometry,
+      coordinates: normalizeCoordinateNesting(geometry.coordinates, size)
+    };
+  };
+  return rows.map((row) => row ? normalizeGeometry(row) : null);
+}
+function normalizeCoordinateNesting(value, size) {
+  if (value.length === 0)
+    return [];
+  if (typeof value[0] === "number") {
+    const coordinate = value.slice(0, size);
+    while (coordinate.length < size)
+      coordinate.push(0);
+    return coordinate;
+  }
+  return value.map((child) => normalizeCoordinateNesting(child, size));
+}
+function decodeSerializedRows(column, decoder) {
+  const rows = [];
+  for (const chunk of column.chunks) {
+    if (chunk.kind !== "serialized")
+      throw new Error("Serialized column contains native storage");
+    for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+      if (!isGeoArrowValueValid(chunk.validity, rowIndex)) {
+        rows.push(null);
+        continue;
+      }
+      rows.push(decoder(getSerializedBytes(chunk, rowIndex)));
+    }
+  }
+  return rows;
+}
+function getSerializedBytes(array, rowIndex) {
+  var _a;
+  if (array.views) {
+    const viewIndex = ((array.offset || 0) + rowIndex) * 4;
+    const length = array.views[viewIndex];
+    if (length <= 12) {
+      const byteOffset2 = array.views.byteOffset + viewIndex * 4 + 4;
+      return new Uint8Array(array.views.buffer, byteOffset2, length);
+    }
+    const bufferIndex = array.views[viewIndex + 2];
+    const byteOffset = array.views[viewIndex + 3];
+    const data = (_a = array.dataBuffers) == null ? void 0 : _a[bufferIndex];
+    if (!data)
+      throw new Error(`Serialized view references missing data buffer ${bufferIndex}`);
+    return data.subarray(byteOffset, byteOffset + length);
+  }
+  const offsetIndex = (array.offset || 0) + rowIndex;
+  const baseValue = array.offsetBase ?? 0;
+  const base = typeof baseValue === "bigint" ? Number(baseValue) : baseValue;
+  const first = getGeoArrowOffset(array.offsets, offsetIndex) - base;
+  const last = getGeoArrowOffset(array.offsets, offsetIndex + 1) - base;
+  return array.values.subarray(first, last);
+}
+function makeSerializedColumn(rows, encoding, dimension) {
+  let byteLength = 0;
+  for (const row of rows)
+    byteLength += (row == null ? void 0 : row.byteLength) || 0;
+  const values = new Uint8Array(byteLength);
+  const offsets = new Int32Array(rows.length + 1);
+  const validity = new Uint8Array(Math.ceil(rows.length / 8));
+  let byteOffset = 0;
+  for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+    const row = rows[rowIndex];
+    if (row) {
+      values.set(row, byteOffset);
+      byteOffset += row.byteLength;
+      validity[rowIndex >> 3] |= 1 << (rowIndex & 7);
+    }
+    offsets[rowIndex + 1] = byteOffset;
+  }
+  const chunk = {
+    kind: "serialized",
+    encoding: encoding === "geoarrow.wkb" ? "binary" : "utf8",
+    length: rows.length,
+    offsets,
+    values,
+    validity: { values: validity }
+  };
+  return { encoding, dimension, coordinateLayout: null, chunks: [chunk] };
+}
+function copyMetadata(source, target) {
+  return {
+    ...target,
+    spatialReference: source.spatialReference,
+    edges: source.edges,
+    metadata: source.metadata
+  };
+}
+//# sourceMappingURL=wkb-entry.cjs.map