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

package/dist/geoarrow/index.cjs

@@ -0,0 +1,4114 @@
+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/index.js
+var index_exports = {};
+__export(index_exports, {
+  GeoArrowBuilder: () => GeoArrowBuilder,
+  allocateGeoArrowBuilderTarget: () => allocateGeoArrowBuilderTarget,
+  assertGeoArrowResourceLimits: () => assertGeoArrowResourceLimits,
+  concatenateGeoArrowColumns: () => concatenateGeoArrowColumns,
+  convertGeoArrowColumn: () => convertGeoArrowColumn,
+  decodeGeoArrowWKB: () => decodeGeoArrowWKB,
+  decodeGeoArrowWKT: () => decodeGeoArrowWKT,
+  encodeGeoArrowWKB: () => encodeGeoArrowWKB,
+  encodeGeoArrowWKT: () => encodeGeoArrowWKT,
+  getGeoArrowBounds: () => getGeoArrowBounds,
+  getGeoArrowDimensionSize: () => getGeoArrowDimensionSize,
+  getGeoArrowEncodingForGeometry: () => getGeoArrowEncodingForGeometry,
+  getGeoArrowGeometryType: () => getGeoArrowGeometryType,
+  getGeoArrowRowBounds: () => getGeoArrowRowBounds,
+  getGeoArrowRowCount: () => getGeoArrowRowCount,
+  getGeoArrowRowView: () => getGeoArrowRowView,
+  getGeoArrowTransferList: () => getGeoArrowTransferList,
+  getGeoArrowVertexCount: () => getGeoArrowVertexCount,
+  getGeoArrowWKBVertexCount: () => getGeoArrowWKBVertexCount,
+  inferGeoArrowGeometryDimension: () => inferGeoArrowGeometryDimension,
+  inspectGeoArrowColumn: () => inspectGeoArrowColumn,
+  interleaveGeoArrowCoordinates: () => interleaveGeoArrowCoordinates,
+  isGeoArrowValueValid: () => isGeoArrowValueValid,
+  iterateGeoArrowBatches: () => iterateGeoArrowBatches,
+  makeGeoArrowColumnFromGeometryRows: () => makeGeoArrowColumnFromGeometryRows,
+  mapGeoArrowCoordinates: () => mapGeoArrowCoordinates,
+  mapGeoArrowCoordinatesInto: () => mapGeoArrowCoordinatesInto,
+  materializeGeoArrowRows: () => materializeGeoArrowRows,
+  mergeGeoArrowDimensions: () => mergeGeoArrowDimensions,
+  normalizeGeoArrowUnion: () => normalizeGeoArrowUnion,
+  rewindGeoArrow: () => rewindGeoArrow,
+  sliceGeoArrowArray: () => sliceGeoArrowArray,
+  sliceGeoArrowColumn: () => sliceGeoArrowColumn,
+  tessellateGeoArrowPolygons: () => tessellateGeoArrowPolygons,
+  validateGeoArrowColumn: () => validateGeoArrowColumn,
+  visitGeoArrowCoordinates: () => visitGeoArrowCoordinates
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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 inferGeoArrowGeometryDimension(geometry) {
+  if (geometry.type === "GeometryCollection") {
+    return geometry.geometries.reduce((dimension, child) => mergeGeoArrowDimensions(dimension, inferGeoArrowGeometryDimension(child)), "xy");
+  }
+  return inferCoordinateDimensions(geometry.coordinates);
+}
+function inferCoordinateDimensions(coordinates) {
+  if (typeof coordinates[0] === "number") {
+    return coordinates.length >= 4 ? "xyzm" : coordinates.length === 3 ? "xyz" : "xy";
+  }
+  let dimension = "xy";
+  for (const child of coordinates) {
+    if (Array.isArray(child)) {
+      dimension = mergeGeoArrowDimensions(dimension, inferCoordinateDimensions(child));
+    }
+  }
+  return dimension;
+}
+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/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 getGeoArrowRowCount(column) {
+  return column.chunks.reduce((count, chunk) => count + chunk.length, 0);
+}
+function visitGeoArrowCoordinates(column, visitor) {
+  let rowOffset = 0;
+  for (const chunk of column.chunks) {
+    visitChunkCoordinates(chunk, column.encoding, rowOffset, visitor);
+    rowOffset += chunk.length;
+  }
+}
+function sliceGeoArrowColumn(column, begin = 0, end = getGeoArrowRowCount(column)) {
+  const rowCount = getGeoArrowRowCount(column);
+  const first = normalizeSliceIndex(begin, rowCount);
+  const last = Math.max(first, normalizeSliceIndex(end, rowCount));
+  if (first === 0 && last === rowCount)
+    return column;
+  const chunks = [];
+  let chunkStart = 0;
+  for (const chunk of column.chunks) {
+    const chunkEnd = chunkStart + chunk.length;
+    const localFirst = Math.max(0, first - chunkStart);
+    const localLast = Math.min(chunk.length, last - chunkStart);
+    if (localLast > localFirst) {
+      chunks.push(sliceGeoArrowArray(chunk, localFirst, localLast));
+    }
+    chunkStart = chunkEnd;
+    if (chunkStart >= last)
+      break;
+  }
+  return { ...column, chunks };
+}
+function sliceGeoArrowArray(array, begin, end) {
+  if (begin === 0 && end === array.length)
+    return array;
+  const length = end - begin;
+  const validity = array.validity ? { ...array.validity, bitOffset: (array.validity.bitOffset || 0) + begin } : void 0;
+  switch (array.kind) {
+    case "primitive":
+      return {
+        ...array,
+        length,
+        offset: (array.offset || 0) + begin * (array.stride || 1),
+        validity
+      };
+    case "fixed-size-list":
+      return { ...array, length, offset: (array.offset || 0) + begin, validity };
+    case "list":
+    case "serialized":
+      return { ...array, length, offset: (array.offset || 0) + begin, validity };
+    case "struct":
+      return { ...array, length, offset: (array.offset || 0) + begin, validity };
+    case "dense-union":
+      return { ...array, length, offset: (array.offset || 0) + begin, validity };
+  }
+}
+function validateGeoArrowColumn(column) {
+  const issues = [];
+  for (let chunkIndex = 0; chunkIndex < column.chunks.length; chunkIndex++) {
+    validateArray(column.chunks[chunkIndex], `chunks[${chunkIndex}]`, issues);
+  }
+  validateColumnLayout(column, issues);
+  return { valid: issues.length === 0, issues };
+}
+function inspectGeoArrowColumn(column) {
+  const validation = validateGeoArrowColumn(column);
+  const storageKinds = [];
+  let nullCount = 0;
+  for (const chunk of column.chunks) {
+    collectStorageKinds(chunk, storageKinds);
+    for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+      if (!isGeoArrowRowValid(chunk, rowIndex))
+        nullCount++;
+    }
+  }
+  return {
+    encoding: column.encoding,
+    rowCount: getGeoArrowRowCount(column),
+    chunkCount: column.chunks.length,
+    nullCount,
+    coordinateCount: getGeoArrowVertexCount(column),
+    storageKinds,
+    valid: validation.valid,
+    issues: validation.issues
+  };
+}
+function isGeoArrowRowValid(array, rowIndex) {
+  if (!isGeoArrowValueValid(array.validity, rowIndex))
+    return false;
+  if (array.kind !== "dense-union")
+    return true;
+  const physicalIndex = (array.offset || 0) + rowIndex;
+  const child = array.children.find((candidate) => candidate.typeId === array.typeIds[physicalIndex]);
+  const valueOffset = array.valueOffsets[physicalIndex];
+  return Boolean(child && valueOffset >= 0 && valueOffset < child.data.length && isGeoArrowValueValid(child.data.validity, valueOffset));
+}
+function getGeoArrowVertexCount(column) {
+  if (column.encoding === "geoarrow.wkb" || column.encoding === "geoarrow.wkt" || column.encoding === "geoarrow.box") {
+    return 0;
+  }
+  let count = 0;
+  visitGeoArrowCoordinates(column, (coordinate) => {
+    count++;
+    return coordinate;
+  });
+  return count;
+}
+function getGeoArrowTransferList(column) {
+  const buffers = /* @__PURE__ */ new Set();
+  for (const chunk of column.chunks)
+    collectArrayBuffers(chunk, buffers);
+  return [...buffers];
+}
+function materializeGeoArrowRows(column) {
+  if (column.encoding === "geoarrow.wkb" || column.encoding === "geoarrow.wkt") {
+    throw new Error("Serialized GeoArrow columns must be decoded before materialization");
+  }
+  const rows = [];
+  for (const chunk of column.chunks) {
+    for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+      rows.push(materializeGeometryRow(chunk, rowIndex, column.encoding));
+    }
+  }
+  return rows;
+}
+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 visitChunkCoordinates(array, encoding, rowOffset, visitor) {
+  for (let rowIndex = 0; rowIndex < array.length; rowIndex++) {
+    if (!isGeoArrowValueValid(array.validity, rowIndex))
+      continue;
+    if (encoding === "geoarrow.geometry" && array.kind === "dense-union") {
+      visitUnionRowCoordinates(array, rowIndex, rowOffset + rowIndex, visitor);
+      continue;
+    }
+    if (encoding === "geoarrow.geometrycollection" && array.kind === "list") {
+      const [first, last] = getListRange(array, rowIndex);
+      if (array.child.kind === "dense-union") {
+        for (let index = first; index < last; index++) {
+          visitUnionRowCoordinates(array.child, index, rowOffset + rowIndex, visitor);
+        }
+      }
+      continue;
+    }
+    const depth = getEncodingDepth(encoding);
+    visitNestedCoordinates(array, rowIndex, depth, rowOffset + rowIndex, visitor);
+  }
+}
+function visitUnionRowCoordinates(union, rowIndex, sourceRowIndex, visitor) {
+  if (!isGeoArrowValueValid(union.validity, rowIndex))
+    return;
+  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)
+    return;
+  const encoding = child.encoding || getEncodingFromChildName(child.name);
+  if (encoding === "geoarrow.geometrycollection" && child.data.kind === "list") {
+    const [first, last] = getListRange(child.data, valueOffset);
+    if (child.data.child.kind === "dense-union") {
+      for (let index = first; index < last; index++) {
+        visitUnionRowCoordinates(child.data.child, index, sourceRowIndex, visitor);
+      }
+    }
+    return;
+  }
+  visitNestedCoordinates(child.data, valueOffset, getEncodingDepth(encoding), sourceRowIndex, visitor);
+}
+function visitNestedCoordinates(array, index, depth, rowIndex, visitor) {
+  if (depth === 0) {
+    const coordinate = readCoordinate(array, index);
+    if (coordinate)
+      visitor(coordinate, rowIndex);
+    return;
+  }
+  if (array.kind !== "list" || !isGeoArrowValueValid(array.validity, index))
+    return;
+  const [first, last] = getListRange(array, index);
+  for (let childIndex = first; childIndex < last; childIndex++) {
+    visitNestedCoordinates(array.child, childIndex, depth - 1, rowIndex, visitor);
+  }
+}
+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;
+  }
+}
+function validateArray(array, path, issues) {
+  if (!Number.isSafeInteger(array.length) || array.length < 0) {
+    issues.push({
+      code: "invalid-length",
+      path,
+      message: "Length must be a non-negative safe integer."
+    });
+    return;
+  }
+  validateValidity(array.validity, array.length, path, issues);
+  switch (array.kind) {
+    case "primitive": {
+      const stride = array.stride || 1;
+      const offset = array.offset || 0;
+      if (!Number.isSafeInteger(stride) || stride < 1) {
+        issues.push({ code: "invalid-stride", path, message: "Primitive stride must be positive." });
+      }
+      const requiredLength = array.length === 0 ? offset : offset + (array.length - 1) * stride + 1;
+      if (offset < 0 || requiredLength > array.values.length) {
+        issues.push({
+          code: "invalid-length",
+          path,
+          message: "Primitive values do not cover the logical range."
+        });
+      }
+      break;
+    }
+    case "fixed-size-list": {
+      const offset = array.offset ?? 0;
+      const validOffset = Number.isSafeInteger(offset) && offset >= 0;
+      if (!validOffset) {
+        issues.push({
+          code: "invalid-offset",
+          path,
+          message: "Fixed-size list offset must be a non-negative safe integer."
+        });
+      }
+      if (!Number.isSafeInteger(array.size) || array.size < 1) {
+        issues.push({
+          code: "invalid-length",
+          path,
+          message: "Fixed-size list size must be positive."
+        });
+      }
+      const childEnd = (offset + array.length) * array.size;
+      if (validOffset && childEnd > array.child.length) {
+        issues.push({ code: "invalid-child", path, message: "Fixed-size list child is too short." });
+      }
+      validateArray(array.child, `${path}.child`, issues);
+      break;
+    }
+    case "list":
+      validateList(array, path, issues);
+      validateArray(array.child, `${path}.child`, issues);
+      break;
+    case "struct":
+      if (Object.keys(array.children).length === 0) {
+        issues.push({ code: "invalid-child", path, message: "Struct must contain children." });
+      }
+      for (const [name, child] of Object.entries(array.children)) {
+        if ((array.offset || 0) + array.length > child.length) {
+          issues.push({
+            code: "invalid-child",
+            path: `${path}.${name}`,
+            message: "Struct child is too short."
+          });
+        }
+        validateArray(child, `${path}.${name}`, issues);
+      }
+      break;
+    case "dense-union": {
+      const end = (array.offset || 0) + array.length;
+      if (end > array.typeIds.length || end > array.valueOffsets.length) {
+        issues.push({
+          code: "invalid-union",
+          path,
+          message: "Dense-union dispatch buffers are too short."
+        });
+      }
+      const childIds = /* @__PURE__ */ new Set();
+      for (const child of array.children) {
+        if (childIds.has(child.typeId)) {
+          issues.push({
+            code: "invalid-union",
+            path,
+            message: `Duplicate dense-union type ID ${child.typeId}.`
+          });
+        }
+        childIds.add(child.typeId);
+        validateArray(child.data, `${path}.${child.name}`, issues);
+      }
+      for (let index = array.offset || 0; index < end; index++) {
+        if (!isGeoArrowValueValid(array.validity, index - (array.offset || 0)))
+          continue;
+        const child = array.children.find((candidate) => candidate.typeId === array.typeIds[index]);
+        const valueOffset = array.valueOffsets[index];
+        if (!child || valueOffset < 0 || valueOffset >= child.data.length) {
+          issues.push({
+            code: "invalid-union",
+            path: `${path}[${index}]`,
+            message: "Dense-union row references an invalid child value."
+          });
+        }
+      }
+      break;
+    }
+    case "serialized": {
+      if (array.views) {
+        const requiredWords = ((array.offset || 0) + array.length) * 4;
+        if (requiredWords > array.views.length) {
+          issues.push({
+            code: "invalid-length",
+            path,
+            message: "Serialized view records are too short."
+          });
+        }
+      } else {
+        validateOffsets(array.offsets, array.offset || 0, array.length, array.values.length, array.offsetBase, path, issues);
+      }
+      break;
+    }
+  }
+}
+function validateList(list, path, issues) {
+  validateOffsets(list.offsets, list.offset || 0, list.length, list.child.length, list.offsetBase, path, issues);
+}
+function validateOffsets(offsets, offset, length, childLength, offsetBase, path, issues) {
+  if (offset < 0 || offset + length >= offsets.length) {
+    issues.push({ code: "invalid-offset", path, message: "Offset buffer is too short." });
+    return;
+  }
+  const base = typeof offsetBase === "bigint" ? Number(offsetBase) : offsetBase || 0;
+  let previous;
+  try {
+    previous = getGeoArrowOffset(offsets, offset) - base;
+  } catch (error) {
+    issues.push({ code: "unsafe-offset", path, message: error.message });
+    return;
+  }
+  for (let index = 1; index <= length; index++) {
+    let current;
+    try {
+      current = getGeoArrowOffset(offsets, offset + index) - base;
+    } catch (error) {
+      issues.push({ code: "unsafe-offset", path, message: error.message });
+      return;
+    }
+    if (current < previous || current < 0 || current > childLength) {
+      issues.push({
+        code: "invalid-offset",
+        path,
+        message: "Offsets must be monotonic and within child storage."
+      });
+      return;
+    }
+    previous = current;
+  }
+}
+function validateValidity(validity, length, path, issues) {
+  if (!validity)
+    return;
+  const bitOffset = validity.bitOffset || 0;
+  if (bitOffset < 0 || bitOffset + length > validity.values.length * 8) {
+    issues.push({ code: "invalid-validity", path, message: "Validity bitmap is too short." });
+  }
+}
+function validateColumnLayout(column, issues) {
+  var _a;
+  if (column.encoding === "geoarrow.wkb" || column.encoding === "geoarrow.wkt") {
+    for (const [index, chunk] of column.chunks.entries()) {
+      const expectedEncoding = column.encoding === "geoarrow.wkb" ? "binary" : "utf8";
+      if (chunk.kind !== "serialized" || chunk.encoding !== expectedEncoding) {
+        issues.push({
+          code: "invalid-layout",
+          path: `chunks[${index}]`,
+          message: `Serialized encoding requires ${expectedEncoding} storage.`
+        });
+      }
+    }
+    return;
+  }
+  if (column.encoding === "geoarrow.box") {
+    for (const [index, chunk] of column.chunks.entries()) {
+      if (chunk.kind !== "struct") {
+        addInvalidLayout(`chunks[${index}]`, "Box encoding requires struct storage.", issues);
+        continue;
+      }
+      const requiredNames = column.dimension === "xy" ? ["xmin", "ymin", "xmax", "ymax"] : column.dimension === "xyz" ? ["xmin", "ymin", "zmin", "xmax", "ymax", "zmax"] : column.dimension === "xym" ? ["xmin", "ymin", "mmin", "xmax", "ymax", "mmax"] : ["xmin", "ymin", "zmin", "mmin", "xmax", "ymax", "zmax", "mmax"];
+      for (const name of requiredNames) {
+        if (((_a = chunk.children[name]) == null ? void 0 : _a.kind) !== "primitive") {
+          addInvalidLayout(`chunks[${index}].${name}`, `Box storage requires primitive ${name}.`, issues);
+        }
+      }
+    }
+    return;
+  }
+  if (!column.coordinateLayout) {
+    addInvalidLayout("coordinateLayout", "Native geometry requires a coordinate layout.", issues);
+    return;
+  }
+  for (const [index, chunk] of column.chunks.entries()) {
+    validateGeometryLayout(chunk, column.encoding, column, `chunks[${index}]`, issues);
+  }
+}
+function validateGeometryLayout(array, encoding, column, path, issues) {
+  if (encoding === "geoarrow.geometry") {
+    if (array.kind !== "dense-union") {
+      addInvalidLayout(path, "Mixed geometry encoding requires dense-union storage.", issues);
+      return;
+    }
+    validateUnionLayouts(array, column, path, issues);
+    return;
+  }
+  if (encoding === "geoarrow.geometrycollection") {
+    if (array.kind !== "list" || array.child.kind !== "dense-union") {
+      addInvalidLayout(path, "GeometryCollection requires list-of-dense-union storage.", issues);
+      return;
+    }
+    validateUnionLayouts(array.child, column, `${path}.child`, issues);
+    return;
+  }
+  let coordinateArray = array;
+  const depth = getEncodingDepth(encoding);
+  for (let level = 0; level < depth; level++) {
+    if (coordinateArray.kind !== "list") {
+      addInvalidLayout(path, `${encoding} requires ${depth} variable-list levels.`, issues);
+      return;
+    }
+    coordinateArray = coordinateArray.child;
+  }
+  validateCoordinateLayout(coordinateArray, column, path, issues);
+}
+function validateUnionLayouts(union, column, path, issues) {
+  for (const child of union.children) {
+    let encoding;
+    try {
+      encoding = child.encoding || getEncodingFromChildName(child.name);
+    } catch (error) {
+      addInvalidLayout(`${path}.${child.name}`, error.message, issues);
+      continue;
+    }
+    const childColumn = child.dimension || child.coordinateLayout ? {
+      ...column,
+      dimension: child.dimension || column.dimension,
+      coordinateLayout: child.coordinateLayout || column.coordinateLayout
+    } : column;
+    validateGeometryLayout(child.data, encoding, childColumn, `${path}.${child.name}`, issues);
+  }
+}
+function validateCoordinateLayout(array, column, path, issues) {
+  var _a;
+  const dimensionSize = getGeoArrowDimensionSize(column.dimension);
+  if (column.coordinateLayout === "interleaved") {
+    if (array.kind !== "fixed-size-list" || array.size !== dimensionSize || array.child.kind !== "primitive") {
+      addInvalidLayout(path, `Interleaved ${column.dimension} coordinates require fixed-size-list<${dimensionSize}> primitive storage.`, issues);
+    }
+    return;
+  }
+  if (array.kind !== "struct") {
+    addInvalidLayout(path, `Separated ${column.dimension} coordinates require struct storage.`, issues);
+    return;
+  }
+  const requiredNames = column.dimension === "xy" ? ["x", "y"] : column.dimension === "xyz" ? ["x", "y", "z"] : column.dimension === "xym" ? ["x", "y", "m"] : ["x", "y", "z", "m"];
+  for (const name of requiredNames) {
+    if (((_a = array.children[name]) == null ? void 0 : _a.kind) !== "primitive") {
+      addInvalidLayout(`${path}.${name}`, `Separated coordinates require primitive ${name}.`, issues);
+    }
+  }
+}
+function addInvalidLayout(path, message, issues) {
+  issues.push({ code: "invalid-layout", path, message });
+}
+function collectStorageKinds(array, kinds) {
+  kinds.push(array.kind);
+  switch (array.kind) {
+    case "fixed-size-list":
+    case "list":
+      collectStorageKinds(array.child, kinds);
+      break;
+    case "struct":
+      for (const child of Object.values(array.children))
+        collectStorageKinds(child, kinds);
+      break;
+    case "dense-union":
+      for (const child of array.children)
+        collectStorageKinds(child.data, kinds);
+      break;
+    default:
+      break;
+  }
+}
+function collectArrayBuffers(array, buffers) {
+  if (array.validity)
+    addBuffer(array.validity.values.buffer, buffers);
+  switch (array.kind) {
+    case "primitive":
+      addBuffer(array.values.buffer, buffers);
+      break;
+    case "fixed-size-list":
+      collectArrayBuffers(array.child, buffers);
+      break;
+    case "list":
+      addBuffer(array.offsets.buffer, buffers);
+      collectArrayBuffers(array.child, buffers);
+      break;
+    case "struct":
+      for (const child of Object.values(array.children))
+        collectArrayBuffers(child, buffers);
+      break;
+    case "dense-union":
+      addBuffer(array.typeIds.buffer, buffers);
+      addBuffer(array.valueOffsets.buffer, buffers);
+      for (const child of array.children)
+        collectArrayBuffers(child.data, buffers);
+      break;
+    case "serialized":
+      addBuffer(array.offsets.buffer, buffers);
+      addBuffer(array.values.buffer, buffers);
+      if (array.views)
+        addBuffer(array.views.buffer, buffers);
+      for (const data of array.dataBuffers || [])
+        addBuffer(data.buffer, buffers);
+      break;
+  }
+}
+function addBuffer(buffer, buffers) {
+  if (buffer instanceof ArrayBuffer)
+    buffers.add(buffer);
+}
+function normalizeSliceIndex(index, length) {
+  const normalized = index < 0 ? Math.max(0, length + index) : Math.min(length, index);
+  return Math.max(0, Math.trunc(normalized));
+}
+
+// dist/geoarrow/views.js
+function* iterateGeoArrowBatches(column) {
+  assertNativeGeometryColumn(column);
+  let rowOffset = 0;
+  for (let chunkIndex = 0; chunkIndex < column.chunks.length; chunkIndex++) {
+    const chunk = column.chunks[chunkIndex];
+    yield { column: { ...column, chunks: [chunk] }, chunkIndex, rowOffset };
+    rowOffset += chunk.length;
+  }
+}
+function getGeoArrowRowView(column, rowIndex) {
+  assertNativeGeometryColumn(column);
+  if (!Number.isSafeInteger(rowIndex) || rowIndex < 0) {
+    throw new RangeError("GeoArrow row index must be a nonnegative safe integer");
+  }
+  let chunkRowIndex = rowIndex;
+  for (let chunkIndex = 0; chunkIndex < column.chunks.length; chunkIndex++) {
+    const chunk = column.chunks[chunkIndex];
+    if (chunkRowIndex >= chunk.length) {
+      chunkRowIndex -= chunk.length;
+      continue;
+    }
+    let rowColumn = {
+      ...column,
+      chunks: [sliceGeoArrowArray(chunk, chunkRowIndex, chunkRowIndex + 1)]
+    };
+    if (column.encoding === "geoarrow.geometry" && isGeoArrowValueValid(chunk.validity, chunkRowIndex)) {
+      if (chunk.kind !== "dense-union") {
+        throw new Error("Mixed GeoArrow geometry requires dense-union storage");
+      }
+      const physicalIndex = (chunk.offset || 0) + chunkRowIndex;
+      const child = chunk.children.find((candidate) => candidate.typeId === chunk.typeIds[physicalIndex]);
+      const valueOffset = chunk.valueOffsets[physicalIndex];
+      if (!child || !Number.isInteger(valueOffset) || valueOffset < 0 || valueOffset >= child.data.length) {
+        throw new Error("Invalid GeoArrow union row dispatch");
+      }
+      const encoding = child.encoding || getEncodingFromChildName(child.name);
+      if (encoding === "geoarrow.geometry") {
+        throw new Error("GeoArrow geometry union children must be concrete geometries");
+      }
+      const data = sliceGeoArrowArray(child.data, valueOffset, valueOffset + 1);
+      rowColumn = {
+        ...column,
+        encoding,
+        dimension: child.dimension ?? column.dimension,
+        coordinateLayout: child.coordinateLayout ?? column.coordinateLayout,
+        chunks: [data]
+      };
+      assertNativeGeometryColumn(rowColumn);
+    }
+    return { column: rowColumn, rowIndex, chunkIndex, chunkRowIndex };
+  }
+  throw new RangeError("GeoArrow row index exceeds column length");
+}
+function concatenateGeoArrowColumns(columns) {
+  let firstColumn;
+  const chunks = [];
+  for (const column of columns) {
+    assertNativeGeometryColumn(column);
+    if (!firstColumn) {
+      firstColumn = column;
+    } else if (column.encoding !== firstColumn.encoding || column.dimension !== firstColumn.dimension || column.coordinateLayout !== firstColumn.coordinateLayout || (column.edges ?? "planar") !== (firstColumn.edges ?? "planar") || column.spatialReference !== firstColumn.spatialReference || column.metadata !== firstColumn.metadata) {
+      throw new Error("Cannot concatenate GeoArrow columns with different semantic envelopes");
+    }
+    for (const chunk of column.chunks)
+      chunks.push(chunk);
+  }
+  if (!firstColumn)
+    throw new Error("At least one GeoArrow column is required");
+  return { ...firstColumn, chunks };
+}
+function assertNativeGeometryColumn(column) {
+  if (column.encoding === "geoarrow.wkb" || column.encoding === "geoarrow.wkt" || column.encoding === "geoarrow.box") {
+    throw new Error("GeoArrow geometry views require native geometry; decode WKB/WKT first");
+  }
+}
+
+// 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/kernels.js
+function getGeoArrowBounds(column) {
+  if (column.encoding === "geoarrow.box")
+    return getGeoArrowBoxBounds(column);
+  let minimumX = Number.POSITIVE_INFINITY;
+  let minimumY = Number.POSITIVE_INFINITY;
+  let maximumX = Number.NEGATIVE_INFINITY;
+  let maximumY = Number.NEGATIVE_INFINITY;
+  visitGeoArrowCoordinates(column, (coordinate) => {
+    const x = coordinate[0];
+    const y = coordinate[1];
+    if (Number.isFinite(x) && Number.isFinite(y)) {
+      minimumX = Math.min(minimumX, x);
+      minimumY = Math.min(minimumY, y);
+      maximumX = Math.max(maximumX, x);
+      maximumY = Math.max(maximumY, y);
+    }
+    return coordinate;
+  });
+  return Number.isFinite(minimumX) ? [minimumX, minimumY, maximumX, maximumY] : null;
+}
+function getGeoArrowRowBounds(column) {
+  const rowCount = getGeoArrowRowCount(column);
+  if (column.encoding === "geoarrow.box") {
+    const result = [];
+    for (const chunk of column.chunks) {
+      for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+        if (chunk.kind !== "struct" || !isGeoArrowValueValid(chunk.validity, rowIndex)) {
+          result.push(null);
+          continue;
+        }
+        const index = (chunk.offset || 0) + rowIndex;
+        const xmin = readPrimitiveNumber(chunk.children["xmin"], index);
+        const ymin = readPrimitiveNumber(chunk.children["ymin"], index);
+        const xmax = readPrimitiveNumber(chunk.children["xmax"], index);
+        const ymax = readPrimitiveNumber(chunk.children["ymax"], index);
+        result.push([xmin, ymin, xmax, ymax].every(Number.isFinite) ? [xmin, ymin, xmax, ymax] : null);
+      }
+    }
+    return result;
+  }
+  const minimumX = new Float64Array(rowCount).fill(Number.POSITIVE_INFINITY);
+  const minimumY = new Float64Array(rowCount).fill(Number.POSITIVE_INFINITY);
+  const maximumX = new Float64Array(rowCount).fill(Number.NEGATIVE_INFINITY);
+  const maximumY = new Float64Array(rowCount).fill(Number.NEGATIVE_INFINITY);
+  visitGeoArrowCoordinates(column, (coordinate, sourceRowIndex) => {
+    const [x, y] = coordinate;
+    if (Number.isFinite(x) && Number.isFinite(y)) {
+      minimumX[sourceRowIndex] = Math.min(minimumX[sourceRowIndex], x);
+      minimumY[sourceRowIndex] = Math.min(minimumY[sourceRowIndex], y);
+      maximumX[sourceRowIndex] = Math.max(maximumX[sourceRowIndex], x);
+      maximumY[sourceRowIndex] = Math.max(maximumY[sourceRowIndex], y);
+    }
+    return coordinate;
+  });
+  const bounds = [];
+  for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+    bounds.push(Number.isFinite(minimumX[rowIndex]) ? [minimumX[rowIndex], minimumY[rowIndex], maximumX[rowIndex], maximumY[rowIndex]] : null);
+  }
+  return bounds;
+}
+function getGeoArrowBoxBounds(column) {
+  let minimumX = Number.POSITIVE_INFINITY;
+  let minimumY = Number.POSITIVE_INFINITY;
+  let maximumX = Number.NEGATIVE_INFINITY;
+  let maximumY = Number.NEGATIVE_INFINITY;
+  for (const chunk of column.chunks) {
+    if (chunk.kind !== "struct")
+      continue;
+    const xmin = chunk.children["xmin"];
+    const ymin = chunk.children["ymin"];
+    const xmax = chunk.children["xmax"];
+    const ymax = chunk.children["ymax"];
+    if (!xmin || !ymin || !xmax || !ymax)
+      continue;
+    for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+      if (!isGeoArrowValueValid(chunk.validity, rowIndex))
+        continue;
+      const structIndex = (chunk.offset || 0) + rowIndex;
+      const bounds = [
+        readPrimitiveNumber(xmin, structIndex),
+        readPrimitiveNumber(ymin, structIndex),
+        readPrimitiveNumber(xmax, structIndex),
+        readPrimitiveNumber(ymax, structIndex)
+      ];
+      if (bounds.every(Number.isFinite)) {
+        minimumX = Math.min(minimumX, bounds[0]);
+        minimumY = Math.min(minimumY, bounds[1]);
+        maximumX = Math.max(maximumX, bounds[2]);
+        maximumY = Math.max(maximumY, bounds[3]);
+      }
+    }
+  }
+  return Number.isFinite(minimumX) ? [minimumX, minimumY, maximumX, maximumY] : null;
+}
+function readPrimitiveNumber(array, index) {
+  if (array.kind !== "primitive" || !isGeoArrowValueValid(array.validity, index))
+    return Number.NaN;
+  const valueIndex = (array.offset || 0) + index * (array.stride || 1);
+  return Number(array.values[valueIndex]);
+}
+function mapGeoArrowCoordinates(column, mapper, options = {}, sourceDimension) {
+  assertGeoArrowResourceLimits(column, options.limits);
+  if (column.encoding === "geoarrow.wkb" || column.encoding === "geoarrow.wkt") {
+    throw new Error("Coordinate mapping requires native GeoArrow storage");
+  }
+  const dimension = options.dimension || column.dimension;
+  const layout = options.coordinateLayout || column.coordinateLayout || "interleaved";
+  let rowOffset = 0;
+  const chunks = column.chunks.map((chunk) => {
+    const mapped = mapArrayCoordinates(chunk, column.encoding, rowOffset, dimension, layout, mapper, options.coordinateType || "preserve", options.dimension !== void 0, options.coordinateLayout !== void 0, sourceDimension);
+    rowOffset += chunk.length;
+    return mapped;
+  });
+  return { ...column, dimension, coordinateLayout: layout, chunks };
+}
+function mapGeoArrowCoordinatesInto(target, source, mapper, options = {}) {
+  const mapped = mapGeoArrowCoordinates(source, mapper, {
+    ...options,
+    coordinateLayout: target.coordinateLayout || void 0
+  });
+  const sourceLeaves = collectCoordinateLeaves(mapped);
+  const targetLeaves = collectCoordinateLeaves(target);
+  if (sourceLeaves.length !== targetLeaves.length) {
+    throw new Error("GeoArrow destination has different coordinate topology");
+  }
+  for (let index = 0; index < sourceLeaves.length; index++) {
+    const sourceLeaf = sourceLeaves[index];
+    const targetLeaf = targetLeaves[index];
+    if (sourceLeaf.length !== targetLeaf.length) {
+      throw new Error("GeoArrow destination coordinate buffer has a different length");
+    }
+    targetLeaf.set(sourceLeaf);
+  }
+  return target;
+}
+function interleaveGeoArrowCoordinates(column) {
+  if (column.coordinateLayout === "interleaved")
+    return column;
+  if (!column.coordinateLayout)
+    return column;
+  return mapGeoArrowCoordinates(column, (coordinate) => coordinate, {
+    coordinateLayout: "interleaved"
+  });
+}
+function normalizeGeoArrowUnion(column) {
+  if (column.encoding !== "geoarrow.geometry")
+    return column;
+  let changed = false;
+  const chunks = column.chunks.map((chunk) => {
+    if (chunk.kind !== "dense-union")
+      return chunk;
+    const children = [...chunk.children].sort((left, right) => left.typeId - right.typeId);
+    changed || (changed = children.some((child, index) => child !== chunk.children[index]));
+    return children.every((child, index) => child === chunk.children[index]) ? chunk : { ...chunk, children };
+  });
+  return changed ? { ...column, chunks } : column;
+}
+function convertGeoArrowColumn(column, options = {}) {
+  const encoding = options.encoding === "native" || !options.encoding ? column.encoding : options.encoding;
+  const dimension = options.dimension || column.dimension;
+  const coordinateLayout = options.coordinateLayout === "preserve" || !options.coordinateLayout ? column.coordinateLayout : options.coordinateLayout;
+  const requestedOffsetType = options.offsetType || "preserve";
+  const currentOffsetType = getColumnOffsetType(column);
+  if (encoding === column.encoding && dimension === column.dimension && coordinateLayout === column.coordinateLayout && (requestedOffsetType === "preserve" || requestedOffsetType === currentOffsetType) && (!options.coordinateType || options.coordinateType === "preserve")) {
+    return column;
+  }
+  if (encoding === "geoarrow.wkb" || encoding === "geoarrow.wkt") {
+    throw new Error("Use encodeGeoArrowWKB or encodeGeoArrowWKT for serialized output");
+  }
+  assertGeoArrowResourceLimits(column, options.limits);
+  const needsCoordinateMap = dimension !== column.dimension || coordinateLayout !== column.coordinateLayout || options.coordinateType && options.coordinateType !== "preserve";
+  const mapped = needsCoordinateMap ? mapGeoArrowCoordinates(column, (coordinate) => coordinate, {
+    dimension,
+    coordinateLayout: coordinateLayout || void 0,
+    coordinateType: options.coordinateType,
+    limits: options.limits
+  }, column.dimension) : column;
+  const offsetConverted = requestedOffsetType === "preserve" ? mapped : {
+    ...mapped,
+    chunks: mapped.chunks.map((chunk) => convertArrayOffsets(chunk, requestedOffsetType))
+  };
+  if (encoding === column.encoding)
+    return offsetConverted;
+  if (encoding === "geoarrow.geometry")
+    return promoteToDenseUnion(offsetConverted);
+  const promoted = promoteSingleFamily(offsetConverted, encoding, requestedOffsetType);
+  if (promoted)
+    return promoted;
+  if (column.encoding === "geoarrow.geometry")
+    return demoteDenseUnion(offsetConverted, encoding);
+  throw new Error(`Rows cannot be represented as ${encoding}`);
+}
+function promoteSingleFamily(column, encoding, offsetType) {
+  const sourceEncoding = column.encoding;
+  const validPair = sourceEncoding === "geoarrow.point" && encoding === "geoarrow.multipoint" || sourceEncoding === "geoarrow.linestring" && encoding === "geoarrow.multilinestring" || sourceEncoding === "geoarrow.polygon" && encoding === "geoarrow.multipolygon";
+  if (!validPair)
+    return null;
+  const chunks = column.chunks.map((chunk) => {
+    const OffsetArray = offsetType === "int64" || offsetType === "preserve" && findOffsetType(chunk) === "int64" ? BigInt64Array : Int32Array;
+    const offsets = new OffsetArray(chunk.length + 1);
+    for (let index = 0; index <= chunk.length; index++) {
+      if (offsets instanceof BigInt64Array)
+        offsets[index] = BigInt(index);
+      else
+        offsets[index] = index;
+    }
+    return {
+      kind: "list",
+      length: chunk.length,
+      offsets,
+      child: chunk,
+      validity: chunk.validity
+    };
+  });
+  return { ...column, encoding, chunks };
+}
+function resizeCoordinate(coordinate, sourceDimension, targetDimension) {
+  const sourceNames = getDimensionNames2(sourceDimension);
+  return getDimensionNames2(targetDimension).map((name) => {
+    const sourceIndex = sourceNames.indexOf(name);
+    return sourceIndex >= 0 ? coordinate[sourceIndex] ?? 0 : 0;
+  });
+}
+function rewindGeoArrow(column, options = {}) {
+  assertGeoArrowResourceLimits(column, options.limits);
+  if (column.encoding === "geoarrow.wkb" || column.encoding === "geoarrow.wkt") {
+    throw new Error("Rewinding requires native GeoArrow storage");
+  }
+  const outerClockwise = (options.outer || "counter-clockwise") === "clockwise";
+  let changed = false;
+  const chunks = column.chunks.map((chunk) => {
+    const clone = mapArrayCoordinates(chunk, column.encoding, 0, column.dimension, column.coordinateLayout || "interleaved", (coordinate) => coordinate, "preserve");
+    changed || (changed = rewindArrayRings(clone, column.encoding, outerClockwise));
+    return clone;
+  });
+  return changed ? { ...column, chunks } : column;
+}
+function assertGeoArrowResourceLimits(column, options = {}) {
+  const rows = getGeoArrowRowCount(column);
+  if (rows > (options.maximumRows ?? Number.POSITIVE_INFINITY)) {
+    throw new Error(`GeoArrow row count ${rows} exceeds maximumRows`);
+  }
+  if (column.chunks.length > (options.maximumChunks ?? Number.POSITIVE_INFINITY)) {
+    throw new Error(`GeoArrow chunk count ${column.chunks.length} exceeds maximumChunks`);
+  }
+  const coordinates = getGeoArrowVertexCount(column);
+  if (coordinates > (options.maximumCoordinates ?? Number.POSITIVE_INFINITY)) {
+    throw new Error(`GeoArrow coordinate count ${coordinates} exceeds maximumCoordinates`);
+  }
+  if (options.maximumNestingDepth !== void 0) {
+    const depth = Math.max(0, ...column.chunks.map(getArrayDepth));
+    if (depth > options.maximumNestingDepth) {
+      throw new Error(`GeoArrow nesting depth ${depth} exceeds maximumNestingDepth`);
+    }
+  }
+  if (options.maximumOutputBytes !== void 0) {
+    const estimatedBytes = coordinates * getGeoArrowDimensionSize(column.dimension) * 8;
+    if (estimatedBytes > options.maximumOutputBytes) {
+      throw new Error(`GeoArrow estimated output ${estimatedBytes} exceeds maximumOutputBytes`);
+    }
+  }
+}
+function mapArrayCoordinates(array, encoding, rowOffset, targetDimension, targetLayout, mapper, coordinateType, forceDimension = false, forceLayout = false, sourceDimension, rowIndicesOverride) {
+  if (encoding === "geoarrow.geometry" && array.kind === "dense-union") {
+    const childRowIndices = collectUnionRowIndices(array, rowOffset);
+    return {
+      ...array,
+      children: array.children.map((child, childIndex) => {
+        const childEncoding = child.encoding || getEncodingFromChildName2(child.name);
+        const childDimension = forceDimension ? targetDimension : child.dimension || targetDimension;
+        const childLayout = forceLayout ? targetLayout : child.coordinateLayout || targetLayout;
+        return {
+          ...child,
+          data: mapArrayCoordinates(child.data, childEncoding, rowOffset, childDimension, childLayout, mapper, coordinateType, forceDimension, forceLayout, childDimension, childRowIndices[childIndex]),
+          dimension: childDimension,
+          coordinateLayout: childLayout,
+          encoding: childEncoding
+        };
+      })
+    };
+  }
+  if (encoding === "geoarrow.geometrycollection" && array.kind === "list") {
+    return {
+      ...array,
+      child: mapArrayCoordinates(array.child, "geoarrow.geometry", rowOffset, targetDimension, targetLayout, mapper, coordinateType, forceDimension, forceLayout, sourceDimension, rowIndicesOverride)
+    };
+  }
+  const depth = getEncodingDepth2(encoding);
+  const rowIndices = rowIndicesOverride || collectLeafRowIndices(array, depth, rowOffset);
+  return mapNestedArray(array, depth, rowOffset, targetDimension, targetLayout, mapper, coordinateType, rowIndices, sourceDimension);
+}
+function mapNestedArray(array, depth, rowOffset, targetDimension, targetLayout, mapper, coordinateType, rowIndices, sourceDimension) {
+  if (depth === 0) {
+    return mapCoordinateLeaf(array, rowOffset, targetDimension, targetLayout, mapper, coordinateType, rowIndices, sourceDimension);
+  }
+  if (array.kind !== "list")
+    return array;
+  return {
+    ...array,
+    child: mapNestedArray(array.child, depth - 1, rowOffset, targetDimension, targetLayout, mapper, coordinateType, rowIndices, sourceDimension)
+  };
+}
+function mapCoordinateLeaf(array, rowOffset, targetDimension, targetLayout, mapper, coordinateType, rowIndices, sourceDimension) {
+  const count = array.length;
+  const targetSize = getGeoArrowDimensionSize(targetDimension);
+  const sourceValues = new Array(count);
+  for (let index = 0; index < count; index++) {
+    const coordinate = readCoordinateAt(array, index);
+    const mapped = coordinate ? mapper(sourceDimension ? resizeCoordinate(coordinate, sourceDimension, targetDimension) : coordinate, (rowIndices == null ? void 0 : rowIndices[index]) ?? rowOffset) : new Array(targetSize).fill(0);
+    if (mapped.length !== targetSize) {
+      throw new Error(`Coordinate mapper returned ${mapped.length} values; expected ${targetSize}`);
+    }
+    sourceValues[index] = [...mapped];
+  }
+  const FloatArray = resolveCoordinateConstructor(array, coordinateType);
+  return makeCoordinateLeaf(sourceValues, targetDimension, targetLayout, FloatArray, array.validity);
+}
+function collectLeafRowIndices(array, depth, rowOffset) {
+  const output = new Array(getLeafLength(array, depth)).fill(rowOffset);
+  for (let rowIndex = 0; rowIndex < array.length; rowIndex++) {
+    if (isGeoArrowValueValid(array.validity, rowIndex)) {
+      assignNestedRowIndices(array, rowIndex, depth, rowOffset + rowIndex, output);
+    }
+  }
+  return output;
+}
+function assignNestedRowIndices(array, index, depth, rowIndex, output) {
+  if (depth === 0) {
+    if (index >= 0 && index < output.length)
+      output[index] = rowIndex;
+    return;
+  }
+  if (array.kind !== "list")
+    return;
+  const [first, last] = getListRange(array, index);
+  for (let childIndex = first; childIndex < last; childIndex++) {
+    assignNestedRowIndices(array.child, childIndex, depth - 1, rowIndex, output);
+  }
+}
+function collectUnionRowIndices(union, rowOffset) {
+  if (union.kind !== "dense-union")
+    return [];
+  const output = union.children.map((child) => {
+    const encoding = child.encoding || getEncodingFromChildName2(child.name);
+    return new Array(getLeafLength(child.data, getEncodingDepth2(encoding))).fill(rowOffset);
+  });
+  for (let rowIndex = 0; rowIndex < union.length; rowIndex++) {
+    if (!isGeoArrowValueValid(union.validity, rowIndex))
+      continue;
+    const physical = (union.offset || 0) + rowIndex;
+    const childIndex = union.children.findIndex((child2) => child2.typeId === union.typeIds[physical]);
+    if (childIndex < 0)
+      continue;
+    const child = union.children[childIndex];
+    assignUnionRowIndices(child.data, child.encoding || getEncodingFromChildName2(child.name), union.valueOffsets[physical], rowOffset + rowIndex, output[childIndex]);
+  }
+  return output;
+}
+function assignUnionRowIndices(array, encoding, index, rowIndex, output) {
+  if (encoding === "geoarrow.geometry" && array.kind === "dense-union") {
+    const physical = (array.offset || 0) + index;
+    const childIndex = array.children.findIndex((child) => child.typeId === array.typeIds[physical]);
+    if (childIndex >= 0) {
+      const child = array.children[childIndex];
+      assignUnionRowIndices(child.data, child.encoding || getEncodingFromChildName2(child.name), array.valueOffsets[physical], rowIndex, output);
+    }
+    return;
+  }
+  if (encoding === "geoarrow.geometrycollection" && array.kind === "list") {
+    const [first, last] = getListRange(array, index);
+    if (array.child.kind === "dense-union") {
+      for (let childIndex = first; childIndex < last; childIndex++) {
+        assignUnionRowIndices(array.child, "geoarrow.geometry", childIndex, rowIndex, output);
+      }
+    }
+    return;
+  }
+  assignNestedRowIndices(array, index, getEncodingDepth2(encoding), rowIndex, output);
+}
+function getLeafLength(array, depth) {
+  let current = array;
+  for (let level = 0; level < depth; level++) {
+    if (current.kind !== "list")
+      return 0;
+    current = current.child;
+  }
+  return current.length;
+}
+function resolveCoordinateConstructor(array, coordinateType) {
+  if (coordinateType === "float32")
+    return Float32Array;
+  if (coordinateType === "float64")
+    return Float64Array;
+  if (array.kind === "fixed-size-list" && array.child.kind === "primitive") {
+    return array.child.values instanceof Float32Array ? Float32Array : Float64Array;
+  }
+  if (array.kind === "struct") {
+    const child = array.children["x"];
+    if ((child == null ? void 0 : child.kind) === "primitive" && child.values instanceof Float32Array)
+      return Float32Array;
+  }
+  return Float64Array;
+}
+function makeCoordinateLeaf(coordinates, dimension, layout, FloatArray, validity) {
+  const size = getGeoArrowDimensionSize(dimension);
+  if (layout === "interleaved") {
+    const values = new FloatArray(coordinates.length * size);
+    for (let index = 0; index < coordinates.length; index++) {
+      values.set(coordinates[index], index * size);
+    }
+    return {
+      kind: "fixed-size-list",
+      length: coordinates.length,
+      size,
+      child: { kind: "primitive", length: values.length, values },
+      validity
+    };
+  }
+  const children = {
+    x: { kind: "primitive", length: coordinates.length, values: new FloatArray(coordinates.length) },
+    y: { kind: "primitive", length: coordinates.length, values: new FloatArray(coordinates.length) }
+  };
+  const names = getDimensionNames2(dimension);
+  for (let component = 2; component < names.length; component++) {
+    children[names[component]] = {
+      kind: "primitive",
+      length: coordinates.length,
+      values: new FloatArray(coordinates.length)
+    };
+  }
+  for (let index = 0; index < coordinates.length; index++) {
+    const coordinate = coordinates[index];
+    for (let component = 0; component < names.length; component++) {
+      const child = children[names[component]];
+      if (child.kind === "primitive")
+        child.values[index] = coordinate[component];
+    }
+  }
+  return { kind: "struct", length: coordinates.length, children, validity };
+}
+function readCoordinateAt(array, index) {
+  if (!isGeoArrowValueValid(array.validity, index))
+    return null;
+  if (array.kind === "fixed-size-list") {
+    const logicalIndex = (array.offset || 0) + index;
+    if (array.child.kind !== "primitive")
+      return null;
+    const values = [];
+    for (let component = 0; component < array.size; component++) {
+      const scalarIndex = logicalIndex * array.size + component;
+      values.push(Number(array.child.values[(array.child.offset || 0) + scalarIndex * (array.child.stride || 1)]));
+    }
+    return values;
+  }
+  if (array.kind === "struct") {
+    const logicalIndex = (array.offset || 0) + index;
+    const values = [];
+    for (const name of ["x", "y", "z", "m"]) {
+      const child = array.children[name];
+      if ((child == null ? void 0 : child.kind) === "primitive") {
+        values.push(Number(child.values[(child.offset || 0) + logicalIndex * (child.stride || 1)]));
+      }
+    }
+    return values.length >= 2 ? values : null;
+  }
+  return null;
+}
+function getDimensionNames2(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 getEncodingFromChildName2(name) {
+  const normalized = name.replace(/[^a-z]/gi, "").toLowerCase();
+  const encoding = `geoarrow.${normalized}`;
+  if (encoding === "geoarrow.point" || encoding === "geoarrow.linestring" || encoding === "geoarrow.polygon" || encoding === "geoarrow.multipoint" || encoding === "geoarrow.multilinestring" || encoding === "geoarrow.multipolygon" || encoding === "geoarrow.geometrycollection") {
+    return encoding;
+  }
+  throw new Error(`Unknown GeoArrow dense-union child ${name}`);
+}
+function getEncodingDepth2(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;
+  }
+}
+function promoteToDenseUnion(column) {
+  if (column.encoding === "geoarrow.geometry")
+    return column;
+  const chunks = column.chunks.map((chunk) => {
+    const typeId = getCanonicalTypeId(column.encoding, column.dimension);
+    const typeIds = new Int8Array(chunk.length);
+    typeIds.fill(typeId);
+    const valueOffsets = new Int32Array(chunk.length);
+    for (let index = 0; index < chunk.length; index++)
+      valueOffsets[index] = index;
+    return {
+      kind: "dense-union",
+      length: chunk.length,
+      typeIds,
+      valueOffsets,
+      children: [
+        {
+          name: getGeoArrowGeometryTypeName(column.encoding),
+          typeId,
+          encoding: column.encoding,
+          dimension: column.dimension,
+          coordinateLayout: column.coordinateLayout,
+          data: chunk
+        }
+      ]
+    };
+  });
+  return { ...column, encoding: "geoarrow.geometry", chunks };
+}
+function demoteDenseUnion(column, encoding) {
+  if (encoding === "geoarrow.geometry" || encoding === "geoarrow.geometrycollection")
+    return column;
+  if (!isConcreteEncoding(encoding))
+    throw new Error(`Rows cannot be represented as ${encoding}`);
+  const builderOptions = {
+    encoding,
+    dimension: column.dimension,
+    coordinateLayout: column.coordinateLayout || "interleaved",
+    offsetType: getColumnOffsetType(column)
+  };
+  const chunks = column.chunks.map((chunk) => {
+    if (chunk.kind !== "dense-union")
+      throw new Error("Expected dense-union storage");
+    const replay = (builder) => {
+      for (let index = 0; index < chunk.length; index++) {
+        if (!isGeoArrowValueValid(chunk.validity, index)) {
+          builder.append(null);
+          continue;
+        }
+        const physical = (chunk.offset || 0) + index;
+        const child = chunk.children.find((candidate) => candidate.typeId === chunk.typeIds[physical]);
+        const childEncoding = child && (child.encoding || getEncodingFromChildName2(child.name));
+        const childIndex = chunk.valueOffsets[physical];
+        if (!child || !childEncoding || !isGeoArrowValueValid(child.data.validity, childIndex)) {
+          builder.append(null);
+          continue;
+        }
+        if (!isConcreteEncoding(childEncoding) || !canPromoteEncoding(childEncoding, encoding)) {
+          throw new Error(`Rows cannot be represented as ${encoding}`);
+        }
+        replayPhysicalGeometryIntoBuilder(builder, child.data, childIndex, childEncoding, child.dimension || column.dimension, encoding);
+      }
+    };
+    const measure = new GeoArrowBuilder({ ...builderOptions, mode: "measure" });
+    replay(measure);
+    const write = new GeoArrowBuilder({
+      ...builderOptions,
+      mode: "write",
+      target: measure.allocateTarget()
+    });
+    replay(write);
+    return write.finish().chunks[0];
+  });
+  return { ...column, encoding, coordinateLayout: builderOptions.coordinateLayout, chunks };
+}
+function replayPhysicalGeometryIntoBuilder(builder, array, rowIndex, sourceEncoding, sourceDimension, targetEncoding) {
+  const targetType = getGeoArrowGeometryTypeName(targetEncoding);
+  builder.beginGeometry(targetType, sourceDimension);
+  if (sourceEncoding === "geoarrow.point") {
+    writePhysicalCoordinateIntoBuilder(builder, array, rowIndex, sourceDimension);
+  } else if (sourceEncoding === "geoarrow.linestring" || sourceEncoding === "geoarrow.multipoint") {
+    const [first, last] = requireListRange(array, rowIndex);
+    if (targetEncoding === "geoarrow.multilinestring")
+      builder.beginRing(last - first);
+    const leaf = array.child;
+    for (let index = first; index < last; index++) {
+      writePhysicalCoordinateIntoBuilder(builder, leaf, index, sourceDimension);
+    }
+  } else if (sourceEncoding === "geoarrow.polygon" || sourceEncoding === "geoarrow.multilinestring") {
+    const [first, last] = requireListRange(array, rowIndex);
+    if (targetEncoding === "geoarrow.multipolygon")
+      builder.beginPolygon();
+    const parts = array.child;
+    for (let partIndex = first; partIndex < last; partIndex++) {
+      const [partFirst, partLast] = requireListRange(parts, partIndex);
+      builder.beginRing(partLast - partFirst);
+      const leaf = parts.child;
+      for (let index = partFirst; index < partLast; index++) {
+        writePhysicalCoordinateIntoBuilder(builder, leaf, index, sourceDimension);
+      }
+    }
+  } else {
+    const [first, last] = requireListRange(array, rowIndex);
+    const polygons = array.child;
+    for (let polygonIndex = first; polygonIndex < last; polygonIndex++) {
+      builder.beginPolygon();
+      const [partFirst, partLast] = requireListRange(polygons, polygonIndex);
+      const parts = polygons.child;
+      for (let partIndex = partFirst; partIndex < partLast; partIndex++) {
+        const [ringFirst, ringLast] = requireListRange(parts, partIndex);
+        builder.beginRing(ringLast - ringFirst);
+        const leaf = parts.child;
+        for (let index = ringFirst; index < ringLast; index++) {
+          writePhysicalCoordinateIntoBuilder(builder, leaf, index, sourceDimension);
+        }
+      }
+    }
+  }
+  builder.endGeometry();
+}
+function writePhysicalCoordinateIntoBuilder(builder, array, index, dimension) {
+  if (array.kind === "fixed-size-list" && array.child.kind === "primitive") {
+    const logical = (array.offset || 0) + index;
+    const stride = array.child.stride || 1;
+    const scalarOffset = (array.child.offset || 0) + logical * array.size * stride;
+    const x = Number(array.child.values[scalarOffset]);
+    const y = Number(array.child.values[scalarOffset + stride]);
+    const third = array.size > 2 ? Number(array.child.values[scalarOffset + 2 * stride]) : void 0;
+    const fourth = array.size > 3 ? Number(array.child.values[scalarOffset + 3 * stride]) : void 0;
+    builder.writeCoordinateFromDimension(x, y, dimension === "xyz" || dimension === "xyzm" ? third : void 0, dimension === "xym" ? third : fourth, dimension);
+    return;
+  }
+  if (array.kind === "struct") {
+    const logical = (array.offset || 0) + index;
+    const read = (name) => {
+      const child = array.children[name];
+      return (child == null ? void 0 : child.kind) === "primitive" ? Number(child.values[(child.offset || 0) + logical * (child.stride || 1)]) : void 0;
+    };
+    builder.writeCoordinateFromDimension(read("x"), read("y"), read("z"), read("m"), dimension);
+    return;
+  }
+  throw new Error("Invalid GeoArrow coordinate storage");
+}
+function requireListRange(array, index) {
+  if (array.kind !== "list")
+    throw new Error("Invalid GeoArrow list storage");
+  return getListRange(array, index);
+}
+function canPromoteEncoding(source, target) {
+  return source === target || source === "geoarrow.point" && target === "geoarrow.multipoint" || source === "geoarrow.linestring" && target === "geoarrow.multilinestring" || source === "geoarrow.polygon" && target === "geoarrow.multipolygon";
+}
+function isConcreteEncoding(encoding) {
+  return encoding === "geoarrow.point" || encoding === "geoarrow.linestring" || encoding === "geoarrow.polygon" || encoding === "geoarrow.multipoint" || encoding === "geoarrow.multilinestring" || encoding === "geoarrow.multipolygon";
+}
+function getCanonicalTypeId(encoding, dimension) {
+  const families = [
+    "point",
+    "linestring",
+    "polygon",
+    "multipoint",
+    "multilinestring",
+    "multipolygon",
+    "geometrycollection"
+  ];
+  const dimensions = ["xy", "xyz", "xym", "xyzm"];
+  const family = encoding.replace("geoarrow.", "");
+  const familyIndex = families.indexOf(family);
+  const dimensionIndex = dimensions.indexOf(dimension);
+  return familyIndex < 0 || dimensionIndex < 0 ? 1 : familyIndex * 4 + dimensionIndex + 1;
+}
+function getColumnOffsetType(column) {
+  for (const chunk of column.chunks) {
+    const found = findOffsetType(chunk);
+    if (found)
+      return found;
+  }
+  return "int32";
+}
+function findOffsetType(array) {
+  switch (array.kind) {
+    case "list":
+    case "serialized":
+      return array.offsets instanceof BigInt64Array ? "int64" : "int32";
+    case "fixed-size-list":
+      return findOffsetType(array.child);
+    case "struct": {
+      for (const child of Object.values(array.children)) {
+        const found = findOffsetType(child);
+        if (found)
+          return found;
+      }
+      return null;
+    }
+    case "dense-union":
+      for (const child of array.children) {
+        const found = findOffsetType(child.data);
+        if (found)
+          return found;
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+function convertArrayOffsets(array, offsetType) {
+  const toOffsets = (offsets, offsetBase) => {
+    if (offsetType === "int64") {
+      const result2 = new BigInt64Array(offsets.length);
+      for (let index = 0; index < offsets.length; index++)
+        result2[index] = BigInt(offsets[index]);
+      return { offsets: result2, ...offsetBase === void 0 ? {} : { offsetBase } };
+    }
+    const result = new Int32Array(offsets.length);
+    const base = BigInt(offsetBase ?? 0);
+    for (let index = 0; index < offsets.length; index++) {
+      const value = BigInt(offsets[index]) - base;
+      if (value < -2147483648n || value > 2147483647n) {
+        throw new Error("GeoArrow offset cannot be represented as Int32");
+      }
+      result[index] = Number(value);
+    }
+    return { offsets: result, offsetBase: 0 };
+  };
+  switch (array.kind) {
+    case "list":
+      if (array.offsets instanceof (offsetType === "int64" ? BigInt64Array : Int32Array)) {
+        return { ...array, child: convertArrayOffsets(array.child, offsetType) };
+      }
+      return {
+        ...array,
+        ...toOffsets(array.offsets, array.offsetBase),
+        child: convertArrayOffsets(array.child, offsetType)
+      };
+    case "serialized":
+      if (array.offsets instanceof (offsetType === "int64" ? BigInt64Array : Int32Array))
+        return array;
+      return { ...array, ...toOffsets(array.offsets, array.offsetBase) };
+    case "fixed-size-list":
+      return { ...array, child: convertArrayOffsets(array.child, offsetType) };
+    case "struct":
+      return {
+        ...array,
+        children: Object.fromEntries(Object.entries(array.children).map(([name, child]) => [
+          name,
+          convertArrayOffsets(child, offsetType)
+        ]))
+      };
+    case "dense-union":
+      return {
+        ...array,
+        children: array.children.map((child) => ({
+          ...child,
+          data: convertArrayOffsets(child.data, offsetType)
+        }))
+      };
+    default:
+      return array;
+  }
+}
+function getGeoArrowGeometryTypeName(encoding) {
+  return getGeoArrowGeometryType(encoding) || encoding.replace("geoarrow.", "");
+}
+function rewindArrayRings(array, encoding, outerClockwise) {
+  if (encoding === "geoarrow.geometry" && array.kind === "dense-union") {
+    let changed2 = false;
+    for (const child of array.children) {
+      if (rewindArrayRings(child.data, child.encoding || getEncodingFromChildName2(child.name), outerClockwise))
+        changed2 = true;
+    }
+    return changed2;
+  }
+  if (encoding === "geoarrow.geometrycollection" && array.kind === "list") {
+    if (array.child.kind !== "dense-union")
+      return false;
+    let changed2 = false;
+    for (const child of array.child.children) {
+      if (rewindArrayRings(child.data, child.encoding || getEncodingFromChildName2(child.name), outerClockwise))
+        changed2 = true;
+    }
+    return changed2;
+  }
+  if (encoding !== "geoarrow.polygon" && encoding !== "geoarrow.multipolygon")
+    return false;
+  if (array.kind !== "list" || array.child.kind !== "list")
+    return false;
+  let changed = false;
+  for (let rowIndex = 0; rowIndex < array.length; rowIndex++) {
+    if (!isGeoArrowValueValid(array.validity, rowIndex))
+      continue;
+    const [, rowEnd] = getListRange(array, rowIndex);
+    const rowStart = getListRange(array, rowIndex)[0];
+    if (encoding === "geoarrow.polygon") {
+      const rings = array.child;
+      if (rewindRingGroup(rings, rowStart, rowEnd, outerClockwise))
+        changed = true;
+    } else {
+      const polygons = array.child;
+      for (let polygonIndex = rowStart; polygonIndex < rowEnd; polygonIndex++) {
+        const [ringStart, ringEnd] = getListRange(polygons, polygonIndex);
+        if (rewindRingGroup(polygons.child, ringStart, ringEnd, outerClockwise))
+          changed = true;
+      }
+    }
+  }
+  return changed;
+}
+function rewindRingGroup(rings, firstRing, lastRing, outerClockwise) {
+  if (rings.kind !== "list")
+    return false;
+  const leaf = rings.child;
+  if (leaf.kind !== "fixed-size-list" && leaf.kind !== "struct")
+    return false;
+  let changed = false;
+  for (let ringIndex = firstRing; ringIndex < lastRing; ringIndex++) {
+    const [first, last] = getListRange(rings, ringIndex);
+    const area = getRingArea(leaf, first, last);
+    if (!Number.isFinite(area) || area === 0)
+      continue;
+    const shouldClockwise = ringIndex === firstRing ? outerClockwise : !outerClockwise;
+    if (area < 0 !== shouldClockwise) {
+      reverseCoordinateRange(leaf, first, last);
+      changed = true;
+    }
+  }
+  return changed;
+}
+function getRingArea(leaf, first, last) {
+  let area = 0;
+  for (let index = first; index < last; index++) {
+    const current = readCoordinateAt(leaf, index);
+    const next = readCoordinateAt(leaf, index + 1 < last ? index + 1 : first);
+    if (!current || !next)
+      return Number.NaN;
+    area += current[0] * next[1] - next[0] * current[1];
+  }
+  return area / 2;
+}
+function reverseCoordinateRange(leaf, first, last) {
+  const values = [];
+  for (let index = first; index < last; index++)
+    values.push(readCoordinateAt(leaf, index));
+  values.reverse();
+  for (let index = first; index < last; index++)
+    writeCoordinateAt(leaf, index, values[index - first]);
+}
+function writeCoordinateAt(array, index, coordinate) {
+  if (array.kind === "fixed-size-list" && array.child.kind === "primitive") {
+    const logical = (array.offset || 0) + index;
+    for (let component = 0; component < array.size; component++) {
+      const scalar = (array.child.offset || 0) + logical * array.size + component;
+      array.child.values[scalar] = coordinate[component];
+    }
+  } else if (array.kind === "struct") {
+    const logical = (array.offset || 0) + index;
+    const names = ["x", "y", "z", "m"];
+    for (let component = 0; component < names.length; component++) {
+      const child = array.children[names[component]];
+      if ((child == null ? void 0 : child.kind) === "primitive")
+        child.values[(child.offset || 0) + logical * (child.stride || 1)] = coordinate[component];
+    }
+  }
+}
+function collectCoordinateLeaves(column) {
+  const leaves = [];
+  for (const chunk of column.chunks)
+    collectArrayCoordinateLeaves(chunk, leaves);
+  return leaves;
+}
+function collectArrayCoordinateLeaves(array, leaves) {
+  switch (array.kind) {
+    case "primitive":
+      if (array.values instanceof Float32Array || array.values instanceof Float64Array) {
+        leaves.push(array.values);
+      }
+      break;
+    case "fixed-size-list":
+    case "list":
+      collectArrayCoordinateLeaves(array.child, leaves);
+      break;
+    case "struct":
+      for (const name of ["x", "y", "z", "m"]) {
+        const child = array.children[name];
+        if (child)
+          collectArrayCoordinateLeaves(child, leaves);
+      }
+      break;
+    case "dense-union":
+      for (const child of array.children)
+        collectArrayCoordinateLeaves(child.data, leaves);
+      break;
+    default:
+      break;
+  }
+}
+function getArrayDepth(array) {
+  switch (array.kind) {
+    case "list":
+    case "fixed-size-list":
+      return 1 + getArrayDepth(array.child);
+    case "struct":
+      return 1 + Math.max(0, ...Object.values(array.children).map(getArrayDepth));
+    case "dense-union":
+      return 1 + Math.max(0, ...array.children.map((child) => getArrayDepth(child.data)));
+    default:
+      return 1;
+  }
+}
+
+// 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/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 = getEncodingDepth3(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 getEncodingDepth3(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
+  };
+}
+
+// dist/geoarrow/tessellate.js
+var import_polygon = require("@math.gl/geometry/polygon");
+function tessellateGeoArrowPolygons(column, options = {}) {
+  assertGeoArrowResourceLimits(column, options.limits);
+  const rows = materializeGeoArrowRows(column);
+  const sourceDimension = getGeoArrowDimensionSize(column.dimension);
+  const positionSize = options.positionSize || sourceDimension;
+  const sourceRowOffset = options.sourceRowOffset || 0;
+  const positions = [];
+  const sourceRowIndices = [];
+  const indices = [];
+  let polygonCount = 0;
+  for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+    const row = rows[rowIndex];
+    if (row) {
+      visitPolygons(row, (polygon) => {
+        const vertexOffset = positions.length / positionSize;
+        const flatCoordinates = [];
+        const holeIndices = [];
+        let localVertexCount = 0;
+        for (let ringIndex = 0; ringIndex < polygon.length; ringIndex++) {
+          const ring = removeClosingCoordinate(polygon[ringIndex]);
+          if (ring.length < 3)
+            continue;
+          if (localVertexCount > 0)
+            holeIndices.push(localVertexCount);
+          for (const coordinate of ring) {
+            for (let component = 0; component < sourceDimension; component++) {
+              flatCoordinates.push(coordinate[component] ?? 0);
+            }
+            for (let component = 0; component < positionSize; component++) {
+              positions.push(coordinate[component] ?? 0);
+            }
+            sourceRowIndices.push(sourceRowOffset + rowIndex);
+            localVertexCount++;
+          }
+        }
+        if (localVertexCount >= 3) {
+          const localIndices = (0, import_polygon.earcut)(flatCoordinates, holeIndices, sourceDimension);
+          for (const index of localIndices)
+            indices.push(vertexOffset + index);
+          polygonCount++;
+        }
+      });
+    }
+  }
+  const vertexCount = positions.length / positionSize;
+  const IndexArray = vertexCount <= 65535 ? Uint16Array : Uint32Array;
+  return {
+    positions: Float32Array.from(positions),
+    sourceRowIndices: Uint32Array.from(sourceRowIndices),
+    indices: IndexArray.from(indices),
+    sourceDimension,
+    positionSize,
+    rowCount: rows.length,
+    polygonCount,
+    vertexCount,
+    triangleCount: indices.length / 3
+  };
+}
+function visitPolygons(geometry, visitor) {
+  switch (geometry.type) {
+    case "Polygon":
+      visitor(geometry.coordinates);
+      break;
+    case "MultiPolygon":
+      for (const polygon of geometry.coordinates)
+        visitor(polygon);
+      break;
+    case "GeometryCollection":
+      for (const child of geometry.geometries)
+        visitPolygons(child, visitor);
+      break;
+    default:
+      break;
+  }
+}
+function removeClosingCoordinate(ring) {
+  if (ring.length < 2)
+    return ring;
+  const first = ring[0];
+  const last = ring[ring.length - 1];
+  if (first.length !== last.length)
+    return ring;
+  for (let index = 0; index < first.length; index++) {
+    if (first[index] !== last[index])
+      return ring;
+  }
+  return ring.slice(0, -1);
+}
+//# sourceMappingURL=index.cjs.map