@math.gl/geoarrow 5.0.0-alpha.2 → 5.0.0-alpha.3

package/dist/wkb-entry.cjs

@@ -0,0 +1,1005 @@
+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/wkb-entry.js
+var wkb_entry_exports = {};
+__export(wkb_entry_exports, {
+  decodeGeoArrowWKB: () => decodeGeoArrowWKB,
+  decodeGeoArrowWKT: () => decodeGeoArrowWKT,
+  encodeGeoArrowWKB: () => encodeGeoArrowWKB,
+  encodeGeoArrowWKT: () => encodeGeoArrowWKT
+});
+module.exports = __toCommonJS(wkb_entry_exports);
+
+// dist/codecs.js
+var import_wkb = require("@math.gl/wkb");
+var import_wkb2 = require("@math.gl/wkb");
+
+// 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/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 !== 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++;
+  }
+  /** Begins an event-driven geometry. Events are accepted by both measure and write builders. */
+  beginGeometry(type, dimension = this.dimension, _count) {
+    this.eventStack.push({ type, dimension, rings: [], polygons: [], 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')");
+    }
+    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");
+    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");
+    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.type === "Point") {
+      state.rings = [[coordinate]];
+      return this;
+    }
+    if (!state.currentRing)
+      this.beginRing();
+    state.currentRing.push(coordinate);
+    return this;
+  }
+  /** Ends the current event geometry and appends it to the builder/parent. */
+  endGeometry() {
+    var _a;
+    const state = this.eventStack.pop();
+    if (!state)
+      throw new Error("endGeometry without beginGeometry");
+    const coordinates = state.rings;
+    let geometry;
+    switch (state.type) {
+      case "Point":
+        geometry = { type: "Point", coordinates: ((_a = coordinates[0]) == null ? void 0 : _a[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: state.polygons.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;
+  }
+  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, dimension);
+    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, 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,
+    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, 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 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/layout.js
+function isGeoArrowValueValid(validity, index) {
+  if (!validity)
+    return true;
+  const bitIndex = (validity.bitOffset || 0) + index;
+  return Boolean(validity.values[bitIndex >> 3] & 1 << (bitIndex & 7));
+}
+function materializeGeometryRow(array, rowIndex, encoding) {
+  if (!isGeoArrowValueValid(array.validity, rowIndex))
+    return null;
+  if (encoding === "geoarrow.geometry") {
+    if (array.kind !== "dense-union")
+      return null;
+    return materializeUnionRow(array, rowIndex);
+  }
+  if (encoding === "geoarrow.geometrycollection") {
+    if (array.kind !== "list")
+      return null;
+    const [first, last] = getListRange(array, rowIndex);
+    const geometries = [];
+    for (let index = first; index < last; index++) {
+      if (array.child.kind !== "dense-union")
+        continue;
+      const geometry = materializeUnionRow(array.child, index);
+      if (geometry)
+        geometries.push(geometry);
+    }
+    return { type: "GeometryCollection", geometries };
+  }
+  const geometryType = getGeoArrowGeometryType(encoding);
+  if (!geometryType || geometryType === "GeometryCollection")
+    return null;
+  const depth = getEncodingDepth(encoding);
+  const coordinates = readNestedCoordinates(array, rowIndex, depth);
+  if (!coordinates)
+    return null;
+  return { type: geometryType, coordinates };
+}
+function getGeoArrowOffset(offsets, index) {
+  const value = offsets[index];
+  const numericValue = typeof value === "bigint" ? Number(value) : value;
+  if (!Number.isSafeInteger(numericValue)) {
+    throw new Error(`GeoArrow offset ${String(value)} exceeds JavaScript's safe integer range`);
+  }
+  return numericValue;
+}
+function getListRange(list, rowIndex) {
+  const offsetIndex = (list.offset || 0) + rowIndex;
+  const baseValue = list.offsetBase ?? 0;
+  const base = typeof baseValue === "bigint" ? Number(baseValue) : baseValue;
+  return [
+    getGeoArrowOffset(list.offsets, offsetIndex) - base,
+    getGeoArrowOffset(list.offsets, offsetIndex + 1) - base
+  ];
+}
+function readNestedCoordinates(array, index, depth) {
+  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, child.encoding || getEncodingFromChildName(child.name));
+}
+function getEncodingFromChildName(name) {
+  const normalized = name.replace(/[^a-z]/gi, "").toLowerCase();
+  switch (normalized) {
+    case "point":
+      return "geoarrow.point";
+    case "linestring":
+      return "geoarrow.linestring";
+    case "polygon":
+      return "geoarrow.polygon";
+    case "multipoint":
+      return "geoarrow.multipoint";
+    case "multilinestring":
+      return "geoarrow.multilinestring";
+    case "multipolygon":
+      return "geoarrow.multipolygon";
+    case "geometrycollection":
+      return "geoarrow.geometrycollection";
+    default:
+      throw new Error(`Unknown GeoArrow dense-union child ${name}`);
+  }
+}
+function getEncodingDepth(encoding) {
+  switch (encoding) {
+    case "geoarrow.point":
+      return 0;
+    case "geoarrow.linestring":
+    case "geoarrow.multipoint":
+      return 1;
+    case "geoarrow.polygon":
+    case "geoarrow.multilinestring":
+      return 2;
+    case "geoarrow.multipolygon":
+      return 3;
+    default:
+      return 0;
+  }
+}
+
+// dist/codecs.js
+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 writers = [];
+  const dimensions = [];
+  for (const chunk of column.chunks) {
+    for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+      if (!isGeoArrowValueValid(chunk.validity, rowIndex)) {
+        writers.push(null);
+        dimensions.push(column.dimension);
+        continue;
+      }
+      dimensions.push(getPhysicalGeometryDimension(chunk, rowIndex, column.encoding, column.dimension));
+      writers.push((builder) => writePhysicalGeometry(builder, chunk, rowIndex, column.encoding, column.dimension));
+    }
+  }
+  const built = import_wkb2.WKBBuilder.buildGeometryArray(writers, {
+    dimension: column.dimension,
+    dimensionResolver: (index) => dimensions[index] || column.dimension
+  });
+  return copyMetadata(column, {
+    encoding: "geoarrow.wkb",
+    dimension: column.dimension,
+    coordinateLayout: null,
+    chunks: [
+      {
+        kind: "serialized",
+        encoding: "binary",
+        length: writers.length,
+        offsets: built.valueOffsets,
+        values: built.values,
+        ...built.nullBitmap ? { validity: { values: built.nullBitmap } } : {}
+      }
+    ]
+  });
+}
+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 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((0, import_wkb.formatWKT)(row, column.dimension)) : null);
+    }
+  }
+  return copyMetadata(column, makeSerializedColumn(values, "geoarrow.wkt", column.dimension));
+}
+function writePhysicalGeometry(builder, array, rowIndex, encoding, dimension) {
+  const depth = getEncodingDepth2(encoding);
+  if (encoding === "geoarrow.geometry" && array.kind === "dense-union") {
+    const physical = (array.offset || 0) + rowIndex;
+    const typeId = array.typeIds[physical];
+    const child = array.children.find((candidate) => candidate.typeId === typeId);
+    if (!child)
+      throw new Error("Dense-union row references an unknown child");
+    const childDimension = child.dimension || dimension;
+    builder.withDimension(childDimension, () => writePhysicalGeometry(builder, child.data, array.valueOffsets[physical], child.encoding || encodingFromName(child.name), childDimension));
+    return;
+  }
+  if (encoding === "geoarrow.geometrycollection" && array.kind === "list") {
+    const [first, last] = getListRange2(array, rowIndex);
+    builder.beginGeometry("GeometryCollection", last - first);
+    if (array.child.kind !== "dense-union")
+      throw new Error("GeometryCollection requires dense union child");
+    const union = array.child;
+    for (let index = first; index < last; index++) {
+      const physical = (union.offset || 0) + index;
+      const child = union.children.find((candidate) => candidate.typeId === union.typeIds[physical]);
+      if (child) {
+        const childDimension = child.dimension || dimension;
+        builder.withDimension(childDimension, () => writePhysicalGeometry(builder, child.data, union.valueOffsets[physical], child.encoding || encodingFromName(child.name), childDimension));
+      }
+    }
+    return;
+  }
+  if (array.kind !== "list" && depth > 0)
+    throw new Error(`Invalid ${encoding} storage`);
+  const writeCoordinate2 = (leaf, index) => {
+    const coordinate = readPhysicalCoordinate(leaf, index);
+    if (!coordinate)
+      throw new Error("Invalid GeoArrow coordinate storage");
+    if (dimension === "xym")
+      builder.writeCoordinate(coordinate[0], coordinate[1], void 0, coordinate[2]);
+    else if (dimension === "xyzm")
+      builder.writeCoordinate(coordinate[0], coordinate[1], coordinate[2], coordinate[3]);
+    else
+      builder.writeCoordinate(coordinate[0], coordinate[1], coordinate[2]);
+  };
+  const writeSequence = (leaf, first, last) => {
+    for (let index = first; index < last; index++)
+      writeCoordinate2(leaf, index);
+  };
+  if (encoding === "geoarrow.point") {
+    builder.beginPoint();
+    writeCoordinate2(array, rowIndex);
+  } else if (encoding === "geoarrow.linestring" || encoding === "geoarrow.multipoint") {
+    const [first, last] = getListRange2(array, rowIndex);
+    if (encoding === "geoarrow.linestring") {
+      builder.beginLineString(last - first);
+      writeSequence(array.child, first, last);
+    } else {
+      builder.beginMultiPoint(last - first);
+      const leaf = array.child;
+      for (let index = first; index < last; index++) {
+        builder.beginPoint();
+        writeCoordinate2(leaf, index);
+      }
+    }
+  } else if (encoding === "geoarrow.polygon" || encoding === "geoarrow.multilinestring") {
+    const [first, last] = getListRange2(array, rowIndex);
+    const parts = array.child;
+    if (encoding === "geoarrow.polygon")
+      builder.beginPolygon(last - first);
+    else
+      builder.beginMultiLineString(last - first);
+    for (let partIndex = first; partIndex < last; partIndex++) {
+      const [ringFirst, ringLast] = getListRange2(parts, partIndex);
+      const leaf = parts.child;
+      if (encoding === "geoarrow.polygon")
+        builder.beginLinearRing(ringLast - ringFirst);
+      else
+        builder.beginLineString(ringLast - ringFirst);
+      writeSequence(leaf, ringFirst, ringLast);
+    }
+  } else if (encoding === "geoarrow.multipolygon") {
+    const [first, last] = getListRange2(array, rowIndex);
+    const polygons = array.child;
+    builder.beginMultiPolygon(last - first);
+    for (let polygonIndex = first; polygonIndex < last; polygonIndex++) {
+      const [partFirst, partLast] = getListRange2(polygons, polygonIndex);
+      const parts = polygons.child;
+      builder.beginPolygon(partLast - partFirst);
+      for (let partIndex = partFirst; partIndex < partLast; partIndex++) {
+        const [ringFirst, ringLast] = getListRange2(parts, partIndex);
+        builder.beginLinearRing(ringLast - ringFirst);
+        writeSequence(parts.child, ringFirst, ringLast);
+      }
+    }
+  }
+}
+function getPhysicalGeometryDimension(array, rowIndex, encoding, dimension) {
+  if (encoding !== "geoarrow.geometry" || array.kind !== "dense-union")
+    return dimension;
+  const physical = (array.offset || 0) + rowIndex;
+  const child = array.children.find((candidate) => candidate.typeId === array.typeIds[physical]);
+  return (child == null ? void 0 : child.dimension) || dimension;
+}
+function readPhysicalCoordinate(array, index) {
+  if (array.kind === "fixed-size-list" && array.child.kind === "primitive") {
+    const logical = (array.offset || 0) + index;
+    const values = [];
+    for (let component = 0; component < array.size; component++)
+      values.push(Number(array.child.values[(array.child.offset || 0) + (logical * array.size + component) * (array.child.stride || 1)]));
+    return values;
+  }
+  if (array.kind === "struct") {
+    const logical = (array.offset || 0) + index;
+    return ["x", "y", "z", "m"].flatMap((name) => {
+      const child = array.children[name];
+      return (child == null ? void 0 : child.kind) === "primitive" ? [Number(child.values[(child.offset || 0) + logical * (child.stride || 1)])] : [];
+    });
+  }
+  return null;
+}
+function getListRange2(list, index) {
+  const offset = (list.offset || 0) + index;
+  const base = typeof (list.offsetBase ?? 0) === "bigint" ? Number(list.offsetBase) : Number(list.offsetBase ?? 0);
+  return [
+    getGeoArrowOffset(list.offsets, offset) - base,
+    getGeoArrowOffset(list.offsets, offset + 1) - base
+  ];
+}
+function getEncodingDepth2(encoding) {
+  return encoding === "geoarrow.point" ? 0 : encoding === "geoarrow.linestring" || encoding === "geoarrow.multipoint" ? 1 : encoding === "geoarrow.polygon" || encoding === "geoarrow.multilinestring" ? 2 : 3;
+}
+function encodingFromName(name) {
+  return `geoarrow.${name.toLowerCase()}`;
+}
+function normalizeRowsToDimension(rows, dimension) {
+  const size = getGeoArrowDimensionSize(dimension);
+  const normalizeGeometry = (geometry) => {
+    if (geometry.type === "GeometryCollection") {
+      return { ...geometry, geometries: geometry.geometries.map(normalizeGeometry) };
+    }
+    return {
+      ...geometry,
+      coordinates: normalizeCoordinateNesting(geometry.coordinates, size)
+    };
+  };
+  return rows.map((row) => row ? normalizeGeometry(row) : null);
+}
+function normalizeCoordinateNesting(value, size) {
+  if (value.length === 0)
+    return [];
+  if (typeof value[0] === "number") {
+    const coordinate = value.slice(0, size);
+    while (coordinate.length < size)
+      coordinate.push(0);
+    return coordinate;
+  }
+  return value.map((child) => normalizeCoordinateNesting(child, size));
+}
+function decodeSerializedRows(column, decoder) {
+  const rows = [];
+  for (const chunk of column.chunks) {
+    if (chunk.kind !== "serialized")
+      throw new Error("Serialized column contains native storage");
+    for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+      if (!isGeoArrowValueValid(chunk.validity, rowIndex)) {
+        rows.push(null);
+        continue;
+      }
+      rows.push(decoder(getSerializedBytes(chunk, rowIndex)));
+    }
+  }
+  return rows;
+}
+function getSerializedBytes(array, rowIndex) {
+  var _a;
+  if (array.views) {
+    const viewIndex = ((array.offset || 0) + rowIndex) * 4;
+    const length = array.views[viewIndex];
+    if (length <= 12) {
+      const byteOffset2 = array.views.byteOffset + viewIndex * 4 + 4;
+      return new Uint8Array(array.views.buffer, byteOffset2, length);
+    }
+    const bufferIndex = array.views[viewIndex + 2];
+    const byteOffset = array.views[viewIndex + 3];
+    const data = (_a = array.dataBuffers) == null ? void 0 : _a[bufferIndex];
+    if (!data)
+      throw new Error(`Serialized view references missing data buffer ${bufferIndex}`);
+    return data.subarray(byteOffset, byteOffset + length);
+  }
+  const offsetIndex = (array.offset || 0) + rowIndex;
+  const baseValue = array.offsetBase ?? 0;
+  const base = typeof baseValue === "bigint" ? Number(baseValue) : baseValue;
+  const first = getGeoArrowOffset(array.offsets, offsetIndex) - base;
+  const last = getGeoArrowOffset(array.offsets, offsetIndex + 1) - base;
+  return array.values.subarray(first, last);
+}
+function makeSerializedColumn(rows, encoding, dimension) {
+  let byteLength = 0;
+  for (const row of rows)
+    byteLength += (row == null ? void 0 : row.byteLength) || 0;
+  const values = new Uint8Array(byteLength);
+  const offsets = new Int32Array(rows.length + 1);
+  const validity = new Uint8Array(Math.ceil(rows.length / 8));
+  let byteOffset = 0;
+  for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+    const row = rows[rowIndex];
+    if (row) {
+      values.set(row, byteOffset);
+      byteOffset += row.byteLength;
+      validity[rowIndex >> 3] |= 1 << (rowIndex & 7);
+    }
+    offsets[rowIndex + 1] = byteOffset;
+  }
+  const chunk = {
+    kind: "serialized",
+    encoding: encoding === "geoarrow.wkb" ? "binary" : "utf8",
+    length: rows.length,
+    offsets,
+    values,
+    validity: { values: validity }
+  };
+  return { encoding, dimension, coordinateLayout: null, chunks: [chunk] };
+}
+function copyMetadata(source, target) {
+  return {
+    ...target,
+    spatialReference: source.spatialReference,
+    edges: source.edges,
+    metadata: source.metadata
+  };
+}
+//# sourceMappingURL=wkb-entry.cjs.map