@math.gl/geoarrow 5.0.0-alpha.2

package/dist/index.cjs

@@ -0,0 +1,1651 @@
+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/index.js
+var index_exports = {};
+__export(index_exports, {
+  GeoArrowBuilder: () => GeoArrowBuilder,
+  allocateGeoArrowBuilderTarget: () => allocateGeoArrowBuilderTarget,
+  assertGeoArrowResourceLimits: () => assertGeoArrowResourceLimits,
+  convertGeoArrowColumn: () => convertGeoArrowColumn,
+  decodeGeoArrowWKB: () => decodeGeoArrowWKB,
+  decodeGeoArrowWKT: () => decodeGeoArrowWKT,
+  encodeGeoArrowWKB: () => encodeGeoArrowWKB,
+  encodeGeoArrowWKT: () => encodeGeoArrowWKT,
+  getGeoArrowBounds: () => getGeoArrowBounds,
+  getGeoArrowDimensionSize: () => getGeoArrowDimensionSize,
+  getGeoArrowEncodingForGeometry: () => getGeoArrowEncodingForGeometry,
+  getGeoArrowGeometryType: () => getGeoArrowGeometryType,
+  getGeoArrowRowCount: () => getGeoArrowRowCount,
+  getGeoArrowTransferList: () => getGeoArrowTransferList,
+  getGeoArrowVertexCount: () => getGeoArrowVertexCount,
+  inspectGeoArrowColumn: () => inspectGeoArrowColumn,
+  interleaveGeoArrowCoordinates: () => interleaveGeoArrowCoordinates,
+  isGeoArrowValueValid: () => isGeoArrowValueValid,
+  makeGeoArrowColumnFromGeometryRows: () => makeGeoArrowColumnFromGeometryRows,
+  mapGeoArrowCoordinates: () => mapGeoArrowCoordinates,
+  mapGeoArrowCoordinatesInto: () => mapGeoArrowCoordinatesInto,
+  normalizeGeoArrowUnion: () => normalizeGeoArrowUnion,
+  rewindGeoArrow: () => rewindGeoArrow,
+  sliceGeoArrowArray: () => sliceGeoArrowArray,
+  sliceGeoArrowColumn: () => sliceGeoArrowColumn,
+  tessellateGeoArrowPolygons: () => tessellateGeoArrowPolygons,
+  validateGeoArrowColumn: () => validateGeoArrowColumn,
+  visitGeoArrowCoordinates: () => visitGeoArrowCoordinates
+});
+module.exports = __toCommonJS(index_exports);
+
+// dist/types.js
+function getGeoArrowDimensionSize(dimension) {
+  switch (dimension) {
+    case "xy":
+      return 2;
+    case "xyz":
+    case "xym":
+      return 3;
+    case "xyzm":
+      return 4;
+  }
+}
+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/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 (!isGeoArrowValueValid(chunk.validity, 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 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);
+  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 = 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) {
+  if (depth === 0)
+    return readCoordinate(array, index);
+  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);
+    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");
+  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, 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": {
+      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 = getEncodingFromChildName(child.name);
+    } catch (error) {
+      addInvalidLayout(`${path}.${child.name}`, error.message, issues);
+      continue;
+    }
+    validateGeometryLayout(child.data, encoding, column, `${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);
+      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/builder.js
+var GeoArrowBuilder = class _GeoArrowBuilder {
+  constructor(options) {
+    this.length = 0;
+    this.nullCount = 0;
+    this.coordinateCount = 0;
+    this.partCount = 0;
+    this.ringCount = 0;
+    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.writeCoordinate(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.writeCoordinate(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.writeCoordinate(coordinate);
+  }
+  writeCoordinate(coordinate) {
+    const size = getGeoArrowDimensionSize(this.dimension);
+    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++;
+  }
+  writeOffset(target, index, value) {
+    if (!target)
+      return;
+    if (target instanceof BigInt64Array)
+      target[index] = BigInt(value);
+    else
+      target[index] = value;
+  }
+  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);
+  const validity = new Uint8Array(Math.ceil(rows.length / 8));
+  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);
+    valueOffsets[rowIndex] = values.length;
+    if (geometry) {
+      values.push(geometry);
+      childRows.set(type, values);
+      setValidityBit(validity, rowIndex);
+    }
+  }
+  const children = [...childRows.entries()].sort(([left], [right]) => getGeometryTypeId(left) - getGeometryTypeId(right)).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), data };
+  });
+  return {
+    kind: "dense-union",
+    length: rows.length,
+    typeIds,
+    valueOffsets,
+    children,
+    validity: { values: validity }
+  };
+}
+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 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) {
+  return [
+    "Point",
+    "LineString",
+    "Polygon",
+    "MultiPoint",
+    "MultiLineString",
+    "MultiPolygon",
+    "GeometryCollection"
+  ].indexOf(type) + 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 visitGeometry = (geometry) => {
+    if (geometry.type === "GeometryCollection") {
+      for (const child of geometry.geometries)
+        visitGeometry(child);
+    } else {
+      visit(geometry.coordinates);
+    }
+  };
+  for (const row of rows) {
+    if (row)
+      visitGeometry(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/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 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 = {}) {
+  assertGeoArrowResourceLimits(column, options.limits);
+  const rows = materializeGeoArrowRows(column);
+  let rowIndex = 0;
+  const mappedRows = rows.map((row) => {
+    const mapped = row ? mapGeometryCoordinates(row, (coordinate) => mapper(coordinate, rowIndex)) : null;
+    rowIndex++;
+    return mapped;
+  });
+  const result = makeGeoArrowColumnFromGeometryRows(mappedRows, {
+    dimension: options.dimension || column.dimension,
+    coordinateLayout: options.coordinateLayout || column.coordinateLayout || "interleaved"
+  });
+  return copyColumnMetadata(column, result);
+}
+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 || column.encoding;
+  const dimension = options.dimension || column.dimension;
+  const coordinateLayout = options.coordinateLayout || column.coordinateLayout;
+  if (encoding === column.encoding && dimension === column.dimension && coordinateLayout === column.coordinateLayout) {
+    return column;
+  }
+  if (encoding === "geoarrow.wkb" || encoding === "geoarrow.wkt") {
+    throw new Error("Use encodeGeoArrowWKB or encodeGeoArrowWKT for serialized output");
+  }
+  assertGeoArrowResourceLimits(column, options.limits);
+  const rows = materializeGeoArrowRows(column).map((row) => row ? convertGeometryFamily(row, encoding, column.dimension, dimension) : null);
+  const result = makeGeoArrowColumnFromGeometryRows(rows, {
+    encoding: encoding === "geoarrow.geometry" ? encoding : void 0,
+    dimension,
+    coordinateLayout: coordinateLayout || "interleaved"
+  });
+  if (result.encoding !== encoding && encoding !== "geoarrow.geometry") {
+    throw new Error(`Rows cannot be represented as ${encoding}`);
+  }
+  return copyColumnMetadata(column, result);
+}
+function rewindGeoArrow(column, options = {}) {
+  assertGeoArrowResourceLimits(column, options.limits);
+  const outerClockwise = (options.outer || "counter-clockwise") === "clockwise";
+  let changed = false;
+  const rows = materializeGeoArrowRows(column).map((row) => {
+    if (!row)
+      return null;
+    const rewound = rewindGeometry(row, outerClockwise);
+    changed || (changed = rewound !== row);
+    return rewound;
+  });
+  if (!changed)
+    return column;
+  const result = makeGeoArrowColumnFromGeometryRows(rows, {
+    dimension: column.dimension,
+    coordinateLayout: column.coordinateLayout || "interleaved"
+  });
+  return copyColumnMetadata(column, result);
+}
+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 mapGeometryCoordinates(geometry, mapper) {
+  if (geometry.type === "GeometryCollection") {
+    return {
+      ...geometry,
+      geometries: geometry.geometries.map((child) => mapGeometryCoordinates(child, mapper))
+    };
+  }
+  return {
+    ...geometry,
+    coordinates: mapCoordinateNesting(geometry.coordinates, mapper)
+  };
+}
+function mapCoordinateNesting(value, mapper) {
+  if (value.length === 0)
+    return [];
+  if (typeof value[0] === "number")
+    return [...mapper(value)];
+  return value.map((child) => mapCoordinateNesting(child, mapper));
+}
+function rewindGeometry(geometry, outerClockwise) {
+  if (geometry.type === "GeometryCollection") {
+    const geometries = geometry.geometries.map((child) => rewindGeometry(child, outerClockwise));
+    return geometries.some((child, index) => child !== geometry.geometries[index]) ? { ...geometry, geometries } : geometry;
+  }
+  if (geometry.type === "Polygon") {
+    const coordinates = rewindPolygon(geometry.coordinates, outerClockwise);
+    return coordinates === geometry.coordinates ? geometry : { ...geometry, coordinates };
+  }
+  if (geometry.type === "MultiPolygon") {
+    const coordinates = geometry.coordinates.map((polygon) => rewindPolygon(polygon, outerClockwise));
+    return coordinates.every((polygon, index) => polygon === geometry.coordinates[index]) ? geometry : { ...geometry, coordinates };
+  }
+  return geometry;
+}
+function rewindPolygon(rings, outerClockwise) {
+  let changed = false;
+  const result = rings.map((ring, ringIndex) => {
+    const shouldBeClockwise = ringIndex === 0 ? outerClockwise : !outerClockwise;
+    const isClockwise = getRingSignedArea(ring) < 0;
+    if (isClockwise === shouldBeClockwise)
+      return ring;
+    changed = true;
+    return [...ring].reverse();
+  });
+  return changed ? result : rings;
+}
+function getRingSignedArea(ring) {
+  let area = 0;
+  for (let index = 0; index < ring.length; index++) {
+    const current = ring[index];
+    const next = ring[(index + 1) % ring.length];
+    area += current[0] * next[1] - next[0] * current[1];
+  }
+  return area / 2;
+}
+function convertGeometryFamily(geometry, encoding, sourceDimension, targetDimension) {
+  if (geometry.type === "GeometryCollection") {
+    const geometries = geometry.geometries.map((child) => convertGeometryFamily(child, "geoarrow.geometry", sourceDimension, targetDimension));
+    if (encoding === "geoarrow.geometry" || encoding === "geoarrow.geometrycollection") {
+      return { ...geometry, geometries };
+    }
+    throw new Error(`${geometry.type} cannot be represented as ${encoding}`);
+  }
+  const coordinates = mapCoordinateNesting(geometry.coordinates, (coordinate) => resizeCoordinate(coordinate, sourceDimension, targetDimension));
+  if (encoding === "geoarrow.geometry") {
+    return { ...geometry, coordinates };
+  }
+  const target = encoding.replace("geoarrow.", "");
+  if (geometry.type.toLowerCase() !== target) {
+    throw new Error(`${geometry.type} cannot be represented as ${encoding}`);
+  }
+  return { ...geometry, coordinates };
+}
+function resizeCoordinate(coordinate, sourceDimension, targetDimension) {
+  const sourceNames = getDimensionNames(sourceDimension);
+  const targetNames = getDimensionNames(targetDimension);
+  return targetNames.map((name) => {
+    const sourceIndex = sourceNames.indexOf(name);
+    return sourceIndex >= 0 ? coordinate[sourceIndex] ?? 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 copyColumnMetadata(source, target) {
+  return {
+    ...target,
+    spatialReference: source.spatialReference,
+    edges: source.edges,
+    metadata: source.metadata
+  };
+}
+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/codecs.js
+var import_wkb = require("@math.gl/wkb");
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+function decodeGeoArrowWKB(column) {
+  if (column.encoding !== "geoarrow.wkb")
+    throw new Error("Expected a geoarrow.wkb column");
+  const rows = normalizeRowsToDimension(decodeSerializedRows(column, (bytes) => (0, import_wkb.parseWKB)(bytes).geometry), column.dimension);
+  return copyMetadata(column, makeGeoArrowColumnFromGeometryRows(rows, { dimension: column.dimension }));
+}
+function encodeGeoArrowWKB(column) {
+  if (column.encoding === "geoarrow.wkb")
+    return column;
+  const rows = materializeGeoArrowRows(column);
+  const values = rows.map((row) => row ? (0, import_wkb.writeWKB)(row, column.dimension) : null);
+  return copyMetadata(column, makeSerializedColumn(values, "geoarrow.wkb", column.dimension));
+}
+function decodeGeoArrowWKT(column) {
+  if (column.encoding !== "geoarrow.wkt")
+    throw new Error("Expected a geoarrow.wkt column");
+  const rows = normalizeRowsToDimension(decodeSerializedRows(column, (bytes) => (0, import_wkb.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 rows = materializeGeoArrowRows(column);
+  const values = rows.map((row) => row ? textEncoder.encode((0, import_wkb.formatWKT)(row, column.dimension)) : null);
+  return copyMetadata(column, makeSerializedColumn(values, "geoarrow.wkt", column.dimension));
+}
+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) {
+  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/tessellate.js
+var import_polygon = require("@math.gl/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