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

package/README.md

@@ -1,16 +1,19 @@
 # @math.gl/geoarrow
 
-Columnar geometry descriptors and synchronous CPU kernels for GeoArrow-compatible memory layouts.
+Arrow-independent columnar geometry descriptors and synchronous buffer algorithms for
+GeoArrow-compatible memory layouts.
 
 `@math.gl/geoarrow` works directly over borrowed typed arrays. It deliberately does not require an
 Arrow runtime: a loader, dataframe, database client, or application can adapt its buffers to the
-small descriptor ABI and use the same validation, conversion, column-codec, and tessellation
-kernels.
+small descriptor ABI and use the same validation, conversion, and coordinate algorithms. Optional
+format and mesh capabilities are isolated behind subpaths so consumers only bundle what they use.
 
 ## Install
 
 ```bash
 npm install @math.gl/geoarrow
+# Only needed when using the /wkb subpath directly.
+npm install @math.gl/wkb
 ```
 
 ## Why descriptors?
@@ -34,11 +37,11 @@ identity as a reliable zero-copy signal.
 
 ```typescript
 import {
-  GeoArrowBuilder,
   getGeoArrowBounds,
   getGeoArrowVertexCount,
   mapGeoArrowCoordinates
 } from '@math.gl/geoarrow';
+import {GeoArrowBuilder} from '@math.gl/geoarrow/builder';
 
 const column = GeoArrowBuilder.build(
   [
@@ -173,11 +176,13 @@ The following operations traverse descriptors directly and do not create per-row
 - `validateGeoArrowColumn`
 - `getGeoArrowVertexCount`
 - `getGeoArrowBounds`
+- `getGeoArrowRowBounds`
 - `visitGeoArrowCoordinates`
 - `getGeoArrowTransferList`
 
-Allocating transforms such as coordinate mapping, physical conversion, winding normalization, and
-codec decoding return new descriptors. Their inputs remain unchanged.
+Allocating transforms such as coordinate mapping, physical conversion, and winding normalization
+return new descriptors. Their inputs remain unchanged. Serialized codecs are isolated in the
+`/wkb` subpath.
 
 ## Conversion and winding
 
@@ -207,7 +212,7 @@ import {
   encodeGeoArrowWKB,
   decodeGeoArrowWKT,
   encodeGeoArrowWKT
-} from '@math.gl/geoarrow';
+} from '@math.gl/geoarrow/wkb';
 
 const wkb = encodeGeoArrowWKB(polygons);
 const decoded = decodeGeoArrowWKB(wkb);
@@ -221,19 +226,20 @@ families, dimension tokens, both MultiPoint spellings, and empties. Decoding nor
 serialized coordinates to the column's declared semantic dimension.
 
 Parsing or formatting one geometry is intentionally provided by the dependency-free
-`@math.gl/wkb` package:
+`@math.gl/wkb` package. The GeoArrow `/wkb` bridge consumes its visitors and two-pass builder:
 
 ```typescript
 import {parseWKB, writeWKB, parseWKT, formatWKT} from '@math.gl/wkb';
 ```
 
-`@math.gl/geoarrow` depends on `@math.gl/wkb`; the format package never depends on GeoArrow or
-Apache Arrow.
+The descriptor and buffer-algorithm implementation does not require Apache Arrow. The `/wkb`
+subpath (and the legacy root codec re-exports) uses `@math.gl/wkb`; install it when using those
+functions.
 
 ## Polygon tessellation
 
 ```typescript
-import {tessellateGeoArrowPolygons} from '@math.gl/geoarrow';
+import {tessellateGeoArrowPolygons} from '@math.gl/geoarrow/tessellation';
 
 const mesh = tessellateGeoArrowPolygons(polygons, {
   positionSize: 3,
@@ -280,6 +286,29 @@ worker.postMessage(payload.column, {transfer: payload.transferList});
 explicit `postMessage` call transfers ownership. Shared buffers are omitted because they are not
 transferable.
 
+## Loaders.gl integration
+
+The intended loaders.gl architecture keeps Apache Arrow at the boundary:
+
+```text
+Arrow Data / Vector / Table
+        │  loaders.gl adapter
+        ▼
+GeoArrowColumn descriptors  ──►  @math.gl/geoarrow buffer algorithms
+        │
+        └── loaders.gl Arrow field + extension metadata
+```
+
+The adapter should borrow Arrow buffers and preserve chunking, offsets, validity, dense-union
+dispatch, dimensions, layouts, CRS, and extension metadata. It should not call Arrow scalar
+accessors in conversion paths. Keep GeoJSON conversion, adaptive target policy, Arrow schema
+construction, and row-shaped compatibility values in loaders.gl.
+
+Use the optional `/wkb` bridge only for serialized columns and `/builder` when emitting native
+descriptors from a feature stream. For event-built MultiPolygons, call `beginPolygon()` before each
+part; omitting it retains the compatibility behavior of treating all rings as one polygon. This
+keeps the common Arrow-to-native path independent of text and binary codec code.
+
 ## Adapting another columnar runtime
 
 Keep runtime-specific objects at the boundary. Read their physical buffers and construct a
@@ -299,11 +328,12 @@ the producer runtime.
 
 - Descriptors: `GeoArrowColumn`, `GeoArrowArray`, all physical array descriptor types
 - Layout: `inspectGeoArrowColumn`, `validateGeoArrowColumn`, slicing and traversal
-- Kernels: count, bounds, map, interleave, convert, rewind, union normalization, resource limits
-- Construction: `GeoArrowBuilder`, `makeGeoArrowColumnFromGeometryRows`
-- Column codecs: WKB/WKT descriptor encode and decode (individual parsing/formatting is tested in
+- Buffer algorithms: count, bounds, row bounds, map, interleave, convert, rewind, union
+  normalization, resource limits
+- Construction: `@math.gl/geoarrow/builder`
+- Column codecs: `@math.gl/geoarrow/wkb` (individual parsing/formatting is provided by
   `@math.gl/wkb`)
-- Meshes: `tessellateGeoArrowPolygons`
+- Meshes: `@math.gl/geoarrow/tessellation`
 - Transfer: `getGeoArrowTransferList`, plus `@math.gl/geoarrow/worker`
 
 See the math.gl documentation for the full [physical-layout guide](../../docs/modules/geoarrow/physical-layouts.md),

package/dist/builder-entry.cjs

@@ -0,0 +1,561 @@
+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/builder-entry.js
+var builder_entry_exports = {};
+__export(builder_entry_exports, {
+  GeoArrowBuilder: () => GeoArrowBuilder,
+  allocateGeoArrowBuilderTarget: () => allocateGeoArrowBuilderTarget,
+  makeGeoArrowColumnFromGeometryRows: () => makeGeoArrowColumnFromGeometryRows
+});
+module.exports = __toCommonJS(builder_entry_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/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");
+  }
+}
+//# sourceMappingURL=builder-entry.cjs.map