@math.gl/geospatial 5.0.0-alpha.9 → 5.0.0-beta.1

package/dist/turf.cjs

@@ -0,0 +1,1660 @@
+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/turf.js
+var turf_exports = {};
+__export(turf_exports, {
+  along: () => along,
+  area: () => area,
+  bbox: () => bbox,
+  bboxPolygon: () => bboxPolygon,
+  bearing: () => bearing,
+  booleanClockwise: () => booleanClockwise,
+  booleanConcave: () => booleanConcave,
+  booleanPointInPolygon: () => booleanPointInPolygon,
+  booleanPointOnLine: () => booleanPointOnLine,
+  center: () => center,
+  centroid: () => centroid,
+  circle: () => circle,
+  clone: () => clone,
+  destination: () => destination,
+  distance: () => distance,
+  explode: () => explode,
+  kinks: () => kinks,
+  length: () => length,
+  lineArc: () => lineArc,
+  lineIntersect: () => lineIntersect,
+  lineSegment: () => lineSegment,
+  lineToPolygon: () => lineToPolygon,
+  midpoint: () => midpoint,
+  polygonToLine: () => polygonToLine,
+  rewind: () => rewind,
+  rhumbBearing: () => rhumbBearing,
+  rhumbDestination: () => rhumbDestination,
+  rhumbDistance: () => rhumbDistance,
+  toMercator: () => toMercator,
+  toWgs84: () => toWgs84,
+  transformRotate: () => transformRotate,
+  transformScale: () => transformScale,
+  transformTranslate: () => transformTranslate,
+  truncate: () => truncate
+});
+module.exports = __toCommonJS(turf_exports);
+
+// dist/geoarrow/types.js
+function getGeoArrowDimensionSize(dimension) {
+  switch (dimension) {
+    case "xy":
+      return 2;
+    case "xyz":
+    case "xym":
+      return 3;
+    case "xyzm":
+      return 4;
+  }
+}
+
+// dist/geoarrow/layout.js
+function isGeoArrowValueValid(validity, index) {
+  if (!validity)
+    return true;
+  const bitIndex = (validity.bitOffset || 0) + index;
+  return Boolean(validity.values[bitIndex >> 3] & 1 << (bitIndex & 7));
+}
+function getGeoArrowRowCount(column) {
+  return column.chunks.reduce((count, chunk) => count + chunk.length, 0);
+}
+function visitGeoArrowCoordinates(column, visitor) {
+  let rowOffset = 0;
+  for (const chunk of column.chunks) {
+    visitChunkCoordinates(chunk, column.encoding, rowOffset, visitor);
+    rowOffset += chunk.length;
+  }
+}
+function 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 getGeoArrowOffset(offsets, index) {
+  const value = offsets[index];
+  const numericValue = typeof value === "bigint" ? Number(value) : value;
+  if (!Number.isSafeInteger(numericValue)) {
+    throw new Error(`GeoArrow offset ${String(value)} exceeds JavaScript's safe integer range`);
+  }
+  return numericValue;
+}
+function getListRange(list, rowIndex) {
+  const offsetIndex = (list.offset || 0) + rowIndex;
+  const baseValue = list.offsetBase ?? 0;
+  const base = typeof baseValue === "bigint" ? Number(baseValue) : baseValue;
+  return [
+    getGeoArrowOffset(list.offsets, offsetIndex) - base,
+    getGeoArrowOffset(list.offsets, offsetIndex + 1) - base
+  ];
+}
+function visitChunkCoordinates(array, encoding, rowOffset, visitor) {
+  for (let rowIndex = 0; rowIndex < array.length; rowIndex++) {
+    if (!isGeoArrowValueValid(array.validity, rowIndex))
+      continue;
+    if (encoding === "geoarrow.geometry" && array.kind === "dense-union") {
+      visitUnionRowCoordinates(array, rowIndex, rowOffset + rowIndex, visitor);
+      continue;
+    }
+    if (encoding === "geoarrow.geometrycollection" && array.kind === "list") {
+      const [first, last] = getListRange(array, rowIndex);
+      if (array.child.kind === "dense-union") {
+        for (let index = first; index < last; index++) {
+          visitUnionRowCoordinates(array.child, index, rowOffset + rowIndex, visitor);
+        }
+      }
+      continue;
+    }
+    const depth = getEncodingDepth(encoding);
+    visitNestedCoordinates(array, rowIndex, depth, rowOffset + rowIndex, visitor);
+  }
+}
+function visitUnionRowCoordinates(union, rowIndex, sourceRowIndex, visitor) {
+  if (!isGeoArrowValueValid(union.validity, rowIndex))
+    return;
+  const physicalIndex = (union.offset || 0) + rowIndex;
+  const typeId = union.typeIds[physicalIndex];
+  const valueOffset = union.valueOffsets[physicalIndex];
+  const child = union.children.find((candidate) => candidate.typeId === typeId);
+  if (!child)
+    return;
+  const encoding = child.encoding || getEncodingFromChildName(child.name);
+  if (encoding === "geoarrow.geometrycollection" && child.data.kind === "list") {
+    const [first, last] = getListRange(child.data, valueOffset);
+    if (child.data.child.kind === "dense-union") {
+      for (let index = first; index < last; index++) {
+        visitUnionRowCoordinates(child.data.child, index, sourceRowIndex, visitor);
+      }
+    }
+    return;
+  }
+  visitNestedCoordinates(child.data, valueOffset, getEncodingDepth(encoding), sourceRowIndex, visitor);
+}
+function visitNestedCoordinates(array, index, depth, rowIndex, visitor) {
+  if (depth === 0) {
+    const coordinate = readCoordinate(array, index);
+    if (coordinate)
+      visitor(coordinate, rowIndex);
+    return;
+  }
+  if (array.kind !== "list" || !isGeoArrowValueValid(array.validity, index))
+    return;
+  const [first, last] = getListRange(array, index);
+  for (let childIndex = first; childIndex < last; childIndex++) {
+    visitNestedCoordinates(array.child, childIndex, depth - 1, rowIndex, visitor);
+  }
+}
+function readCoordinate(array, index) {
+  if (!isGeoArrowValueValid(array.validity, index))
+    return null;
+  if (array.kind === "fixed-size-list") {
+    const listIndex = (array.offset || 0) + index;
+    const coordinate = [];
+    for (let component = 0; component < array.size; component++) {
+      coordinate.push(readPrimitive(array.child, listIndex * array.size + component));
+    }
+    return coordinate;
+  }
+  if (array.kind === "struct") {
+    const structIndex = (array.offset || 0) + index;
+    const coordinate = [];
+    for (const name of ["x", "y", "z", "m"]) {
+      const child = array.children[name];
+      if (child)
+        coordinate.push(readPrimitive(child, structIndex));
+    }
+    return coordinate.length >= 2 ? coordinate : null;
+  }
+  return null;
+}
+function readPrimitive(array, index) {
+  if (array.kind !== "primitive")
+    throw new Error("GeoArrow coordinate child must be primitive");
+  if (!isGeoArrowValueValid(array.validity, index))
+    return Number.NaN;
+  const valueIndex = (array.offset || 0) + index * (array.stride || 1);
+  return Number(array.values[valueIndex]);
+}
+function getEncodingFromChildName(name) {
+  const normalized = name.replace(/[^a-z]/gi, "").toLowerCase();
+  switch (normalized) {
+    case "point":
+      return "geoarrow.point";
+    case "linestring":
+      return "geoarrow.linestring";
+    case "polygon":
+      return "geoarrow.polygon";
+    case "multipoint":
+      return "geoarrow.multipoint";
+    case "multilinestring":
+      return "geoarrow.multilinestring";
+    case "multipolygon":
+      return "geoarrow.multipolygon";
+    case "geometrycollection":
+      return "geoarrow.geometrycollection";
+    default:
+      throw new Error(`Unknown GeoArrow dense-union child ${name}`);
+  }
+}
+function getEncodingDepth(encoding) {
+  switch (encoding) {
+    case "geoarrow.point":
+      return 0;
+    case "geoarrow.linestring":
+    case "geoarrow.multipoint":
+      return 1;
+    case "geoarrow.polygon":
+    case "geoarrow.multilinestring":
+      return 2;
+    case "geoarrow.multipolygon":
+      return 3;
+    default:
+      return 0;
+  }
+}
+
+// dist/geoarrow/kernels.js
+function getGeoArrowRowBounds(column) {
+  const rowCount = getGeoArrowRowCount(column);
+  if (column.encoding === "geoarrow.box") {
+    const result2 = [];
+    for (const chunk of column.chunks) {
+      for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+        if (chunk.kind !== "struct" || !isGeoArrowValueValid(chunk.validity, rowIndex)) {
+          result2.push(null);
+          continue;
+        }
+        const index = (chunk.offset || 0) + rowIndex;
+        const xmin = readPrimitiveNumber(chunk.children["xmin"], index);
+        const ymin = readPrimitiveNumber(chunk.children["ymin"], index);
+        const xmax = readPrimitiveNumber(chunk.children["xmax"], index);
+        const ymax = readPrimitiveNumber(chunk.children["ymax"], index);
+        result2.push([xmin, ymin, xmax, ymax].every(Number.isFinite) ? [xmin, ymin, xmax, ymax] : null);
+      }
+    }
+    return result2;
+  }
+  const minimumX = new Float64Array(rowCount).fill(Number.POSITIVE_INFINITY);
+  const minimumY = new Float64Array(rowCount).fill(Number.POSITIVE_INFINITY);
+  const maximumX = new Float64Array(rowCount).fill(Number.NEGATIVE_INFINITY);
+  const maximumY = new Float64Array(rowCount).fill(Number.NEGATIVE_INFINITY);
+  visitGeoArrowCoordinates(column, (coordinate, sourceRowIndex) => {
+    const [x, y] = coordinate;
+    if (Number.isFinite(x) && Number.isFinite(y)) {
+      minimumX[sourceRowIndex] = Math.min(minimumX[sourceRowIndex], x);
+      minimumY[sourceRowIndex] = Math.min(minimumY[sourceRowIndex], y);
+      maximumX[sourceRowIndex] = Math.max(maximumX[sourceRowIndex], x);
+      maximumY[sourceRowIndex] = Math.max(maximumY[sourceRowIndex], y);
+    }
+    return coordinate;
+  });
+  const bounds = [];
+  for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+    bounds.push(Number.isFinite(minimumX[rowIndex]) ? [minimumX[rowIndex], minimumY[rowIndex], maximumX[rowIndex], maximumY[rowIndex]] : null);
+  }
+  return bounds;
+}
+function readPrimitiveNumber(array, index) {
+  if (array.kind !== "primitive" || !isGeoArrowValueValid(array.validity, index))
+    return Number.NaN;
+  const valueIndex = (array.offset || 0) + index * (array.stride || 1);
+  return Number(array.values[valueIndex]);
+}
+function mapGeoArrowCoordinates(column, mapper, options = {}, sourceDimension) {
+  assertGeoArrowResourceLimits(column, options.limits);
+  if (column.encoding === "geoarrow.wkb" || column.encoding === "geoarrow.wkt") {
+    throw new Error("Coordinate mapping requires native GeoArrow storage");
+  }
+  const dimension = options.dimension || column.dimension;
+  const layout = options.coordinateLayout || column.coordinateLayout || "interleaved";
+  let rowOffset = 0;
+  const chunks = column.chunks.map((chunk) => {
+    const mapped = mapArrayCoordinates(chunk, column.encoding, rowOffset, dimension, layout, mapper, options.coordinateType || "preserve", options.dimension !== void 0, options.coordinateLayout !== void 0, sourceDimension);
+    rowOffset += chunk.length;
+    return mapped;
+  });
+  return { ...column, dimension, coordinateLayout: layout, chunks };
+}
+function resizeCoordinate(coordinate, sourceDimension, targetDimension) {
+  const sourceNames = getDimensionNames(sourceDimension);
+  return getDimensionNames(targetDimension).map((name) => {
+    const sourceIndex = sourceNames.indexOf(name);
+    return sourceIndex >= 0 ? coordinate[sourceIndex] ?? 0 : 0;
+  });
+}
+function rewindGeoArrow(column, options = {}) {
+  assertGeoArrowResourceLimits(column, options.limits);
+  if (column.encoding === "geoarrow.wkb" || column.encoding === "geoarrow.wkt") {
+    throw new Error("Rewinding requires native GeoArrow storage");
+  }
+  const outerClockwise = (options.outer || "counter-clockwise") === "clockwise";
+  let changed = false;
+  const chunks = column.chunks.map((chunk) => {
+    const clone2 = mapArrayCoordinates(chunk, column.encoding, 0, column.dimension, column.coordinateLayout || "interleaved", (coordinate) => coordinate, "preserve");
+    changed || (changed = rewindArrayRings(clone2, column.encoding, outerClockwise));
+    return clone2;
+  });
+  return changed ? { ...column, chunks } : column;
+}
+function assertGeoArrowResourceLimits(column, options = {}) {
+  const rows2 = getGeoArrowRowCount(column);
+  if (rows2 > (options.maximumRows ?? Number.POSITIVE_INFINITY)) {
+    throw new Error(`GeoArrow row count ${rows2} exceeds maximumRows`);
+  }
+  if (column.chunks.length > (options.maximumChunks ?? Number.POSITIVE_INFINITY)) {
+    throw new Error(`GeoArrow chunk count ${column.chunks.length} exceeds maximumChunks`);
+  }
+  const coordinates = getGeoArrowVertexCount(column);
+  if (coordinates > (options.maximumCoordinates ?? Number.POSITIVE_INFINITY)) {
+    throw new Error(`GeoArrow coordinate count ${coordinates} exceeds maximumCoordinates`);
+  }
+  if (options.maximumNestingDepth !== void 0) {
+    const depth = Math.max(0, ...column.chunks.map(getArrayDepth));
+    if (depth > options.maximumNestingDepth) {
+      throw new Error(`GeoArrow nesting depth ${depth} exceeds maximumNestingDepth`);
+    }
+  }
+  if (options.maximumOutputBytes !== void 0) {
+    const estimatedBytes = coordinates * getGeoArrowDimensionSize(column.dimension) * 8;
+    if (estimatedBytes > options.maximumOutputBytes) {
+      throw new Error(`GeoArrow estimated output ${estimatedBytes} exceeds maximumOutputBytes`);
+    }
+  }
+}
+function mapArrayCoordinates(array, encoding, rowOffset, targetDimension, targetLayout, mapper, coordinateType, forceDimension = false, forceLayout = false, sourceDimension, rowIndicesOverride) {
+  if (encoding === "geoarrow.geometry" && array.kind === "dense-union") {
+    const childRowIndices = collectUnionRowIndices(array, rowOffset);
+    return {
+      ...array,
+      children: array.children.map((child, childIndex) => {
+        const childEncoding = child.encoding || getEncodingFromChildName2(child.name);
+        const childDimension = forceDimension ? targetDimension : child.dimension || targetDimension;
+        const childLayout = forceLayout ? targetLayout : child.coordinateLayout || targetLayout;
+        return {
+          ...child,
+          data: mapArrayCoordinates(child.data, childEncoding, rowOffset, childDimension, childLayout, mapper, coordinateType, forceDimension, forceLayout, childDimension, childRowIndices[childIndex]),
+          dimension: childDimension,
+          coordinateLayout: childLayout,
+          encoding: childEncoding
+        };
+      })
+    };
+  }
+  if (encoding === "geoarrow.geometrycollection" && array.kind === "list") {
+    return {
+      ...array,
+      child: mapArrayCoordinates(array.child, "geoarrow.geometry", rowOffset, targetDimension, targetLayout, mapper, coordinateType, forceDimension, forceLayout, sourceDimension, rowIndicesOverride)
+    };
+  }
+  const depth = getEncodingDepth2(encoding);
+  const rowIndices = rowIndicesOverride || collectLeafRowIndices(array, depth, rowOffset);
+  return mapNestedArray(array, depth, rowOffset, targetDimension, targetLayout, mapper, coordinateType, rowIndices, sourceDimension);
+}
+function mapNestedArray(array, depth, rowOffset, targetDimension, targetLayout, mapper, coordinateType, rowIndices, sourceDimension) {
+  if (depth === 0) {
+    return mapCoordinateLeaf(array, rowOffset, targetDimension, targetLayout, mapper, coordinateType, rowIndices, sourceDimension);
+  }
+  if (array.kind !== "list")
+    return array;
+  return {
+    ...array,
+    child: mapNestedArray(array.child, depth - 1, rowOffset, targetDimension, targetLayout, mapper, coordinateType, rowIndices, sourceDimension)
+  };
+}
+function mapCoordinateLeaf(array, rowOffset, targetDimension, targetLayout, mapper, coordinateType, rowIndices, sourceDimension) {
+  const count = array.length;
+  const targetSize = getGeoArrowDimensionSize(targetDimension);
+  const sourceValues = new Array(count);
+  for (let index = 0; index < count; index++) {
+    const coordinate = readCoordinateAt(array, index);
+    const mapped = coordinate ? mapper(sourceDimension ? resizeCoordinate(coordinate, sourceDimension, targetDimension) : coordinate, (rowIndices == null ? void 0 : rowIndices[index]) ?? rowOffset) : new Array(targetSize).fill(0);
+    if (mapped.length !== targetSize) {
+      throw new Error(`Coordinate mapper returned ${mapped.length} values; expected ${targetSize}`);
+    }
+    sourceValues[index] = [...mapped];
+  }
+  const FloatArray = resolveCoordinateConstructor(array, coordinateType);
+  return makeCoordinateLeaf(sourceValues, targetDimension, targetLayout, FloatArray, array.validity);
+}
+function collectLeafRowIndices(array, depth, rowOffset) {
+  const output = new Array(getLeafLength(array, depth)).fill(rowOffset);
+  for (let rowIndex = 0; rowIndex < array.length; rowIndex++) {
+    if (isGeoArrowValueValid(array.validity, rowIndex)) {
+      assignNestedRowIndices(array, rowIndex, depth, rowOffset + rowIndex, output);
+    }
+  }
+  return output;
+}
+function assignNestedRowIndices(array, index, depth, rowIndex, output) {
+  if (depth === 0) {
+    if (index >= 0 && index < output.length)
+      output[index] = rowIndex;
+    return;
+  }
+  if (array.kind !== "list")
+    return;
+  const [first, last] = getListRange(array, index);
+  for (let childIndex = first; childIndex < last; childIndex++) {
+    assignNestedRowIndices(array.child, childIndex, depth - 1, rowIndex, output);
+  }
+}
+function collectUnionRowIndices(union, rowOffset) {
+  if (union.kind !== "dense-union")
+    return [];
+  const output = union.children.map((child) => {
+    const encoding = child.encoding || getEncodingFromChildName2(child.name);
+    return new Array(getLeafLength(child.data, getEncodingDepth2(encoding))).fill(rowOffset);
+  });
+  for (let rowIndex = 0; rowIndex < union.length; rowIndex++) {
+    if (!isGeoArrowValueValid(union.validity, rowIndex))
+      continue;
+    const physical = (union.offset || 0) + rowIndex;
+    const childIndex = union.children.findIndex((child2) => child2.typeId === union.typeIds[physical]);
+    if (childIndex < 0)
+      continue;
+    const child = union.children[childIndex];
+    assignUnionRowIndices(child.data, child.encoding || getEncodingFromChildName2(child.name), union.valueOffsets[physical], rowOffset + rowIndex, output[childIndex]);
+  }
+  return output;
+}
+function assignUnionRowIndices(array, encoding, index, rowIndex, output) {
+  if (encoding === "geoarrow.geometry" && array.kind === "dense-union") {
+    const physical = (array.offset || 0) + index;
+    const childIndex = array.children.findIndex((child) => child.typeId === array.typeIds[physical]);
+    if (childIndex >= 0) {
+      const child = array.children[childIndex];
+      assignUnionRowIndices(child.data, child.encoding || getEncodingFromChildName2(child.name), array.valueOffsets[physical], rowIndex, output);
+    }
+    return;
+  }
+  if (encoding === "geoarrow.geometrycollection" && array.kind === "list") {
+    const [first, last] = getListRange(array, index);
+    if (array.child.kind === "dense-union") {
+      for (let childIndex = first; childIndex < last; childIndex++) {
+        assignUnionRowIndices(array.child, "geoarrow.geometry", childIndex, rowIndex, output);
+      }
+    }
+    return;
+  }
+  assignNestedRowIndices(array, index, getEncodingDepth2(encoding), rowIndex, output);
+}
+function getLeafLength(array, depth) {
+  let current = array;
+  for (let level = 0; level < depth; level++) {
+    if (current.kind !== "list")
+      return 0;
+    current = current.child;
+  }
+  return current.length;
+}
+function resolveCoordinateConstructor(array, coordinateType) {
+  if (coordinateType === "float32")
+    return Float32Array;
+  if (coordinateType === "float64")
+    return Float64Array;
+  if (array.kind === "fixed-size-list" && array.child.kind === "primitive") {
+    return array.child.values instanceof Float32Array ? Float32Array : Float64Array;
+  }
+  if (array.kind === "struct") {
+    const child = array.children["x"];
+    if ((child == null ? void 0 : child.kind) === "primitive" && child.values instanceof Float32Array)
+      return Float32Array;
+  }
+  return Float64Array;
+}
+function makeCoordinateLeaf(coordinates, dimension, layout, FloatArray, validity) {
+  const size = getGeoArrowDimensionSize(dimension);
+  if (layout === "interleaved") {
+    const values = new FloatArray(coordinates.length * size);
+    for (let index = 0; index < coordinates.length; index++) {
+      values.set(coordinates[index], index * size);
+    }
+    return {
+      kind: "fixed-size-list",
+      length: coordinates.length,
+      size,
+      child: { kind: "primitive", length: values.length, values },
+      validity
+    };
+  }
+  const children = {
+    x: { kind: "primitive", length: coordinates.length, values: new FloatArray(coordinates.length) },
+    y: { kind: "primitive", length: coordinates.length, values: new FloatArray(coordinates.length) }
+  };
+  const names = getDimensionNames(dimension);
+  for (let component = 2; component < names.length; component++) {
+    children[names[component]] = {
+      kind: "primitive",
+      length: coordinates.length,
+      values: new FloatArray(coordinates.length)
+    };
+  }
+  for (let index = 0; index < coordinates.length; index++) {
+    const coordinate = coordinates[index];
+    for (let component = 0; component < names.length; component++) {
+      const child = children[names[component]];
+      if (child.kind === "primitive")
+        child.values[index] = coordinate[component];
+    }
+  }
+  return { kind: "struct", length: coordinates.length, children, validity };
+}
+function readCoordinateAt(array, index) {
+  if (!isGeoArrowValueValid(array.validity, index))
+    return null;
+  if (array.kind === "fixed-size-list") {
+    const logicalIndex = (array.offset || 0) + index;
+    if (array.child.kind !== "primitive")
+      return null;
+    const values = [];
+    for (let component = 0; component < array.size; component++) {
+      const scalarIndex = logicalIndex * array.size + component;
+      values.push(Number(array.child.values[(array.child.offset || 0) + scalarIndex * (array.child.stride || 1)]));
+    }
+    return values;
+  }
+  if (array.kind === "struct") {
+    const logicalIndex = (array.offset || 0) + index;
+    const values = [];
+    for (const name of ["x", "y", "z", "m"]) {
+      const child = array.children[name];
+      if ((child == null ? void 0 : child.kind) === "primitive") {
+        values.push(Number(child.values[(child.offset || 0) + logicalIndex * (child.stride || 1)]));
+      }
+    }
+    return values.length >= 2 ? values : null;
+  }
+  return null;
+}
+function 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 getEncodingFromChildName2(name) {
+  const normalized = name.replace(/[^a-z]/gi, "").toLowerCase();
+  const encoding = `geoarrow.${normalized}`;
+  if (encoding === "geoarrow.point" || encoding === "geoarrow.linestring" || encoding === "geoarrow.polygon" || encoding === "geoarrow.multipoint" || encoding === "geoarrow.multilinestring" || encoding === "geoarrow.multipolygon" || encoding === "geoarrow.geometrycollection") {
+    return encoding;
+  }
+  throw new Error(`Unknown GeoArrow dense-union child ${name}`);
+}
+function getEncodingDepth2(encoding) {
+  switch (encoding) {
+    case "geoarrow.point":
+      return 0;
+    case "geoarrow.linestring":
+    case "geoarrow.multipoint":
+      return 1;
+    case "geoarrow.polygon":
+    case "geoarrow.multilinestring":
+      return 2;
+    case "geoarrow.multipolygon":
+      return 3;
+    default:
+      return 0;
+  }
+}
+function rewindArrayRings(array, encoding, outerClockwise) {
+  if (encoding === "geoarrow.geometry" && array.kind === "dense-union") {
+    let changed2 = false;
+    for (const child of array.children) {
+      if (rewindArrayRings(child.data, child.encoding || getEncodingFromChildName2(child.name), outerClockwise))
+        changed2 = true;
+    }
+    return changed2;
+  }
+  if (encoding === "geoarrow.geometrycollection" && array.kind === "list") {
+    if (array.child.kind !== "dense-union")
+      return false;
+    let changed2 = false;
+    for (const child of array.child.children) {
+      if (rewindArrayRings(child.data, child.encoding || getEncodingFromChildName2(child.name), outerClockwise))
+        changed2 = true;
+    }
+    return changed2;
+  }
+  if (encoding !== "geoarrow.polygon" && encoding !== "geoarrow.multipolygon")
+    return false;
+  if (array.kind !== "list" || array.child.kind !== "list")
+    return false;
+  let changed = false;
+  for (let rowIndex = 0; rowIndex < array.length; rowIndex++) {
+    if (!isGeoArrowValueValid(array.validity, rowIndex))
+      continue;
+    const [, rowEnd] = getListRange(array, rowIndex);
+    const rowStart = getListRange(array, rowIndex)[0];
+    if (encoding === "geoarrow.polygon") {
+      const rings = array.child;
+      if (rewindRingGroup(rings, rowStart, rowEnd, outerClockwise))
+        changed = true;
+    } else {
+      const polygons2 = array.child;
+      for (let polygonIndex = rowStart; polygonIndex < rowEnd; polygonIndex++) {
+        const [ringStart, ringEnd] = getListRange(polygons2, polygonIndex);
+        if (rewindRingGroup(polygons2.child, ringStart, ringEnd, outerClockwise))
+          changed = true;
+      }
+    }
+  }
+  return changed;
+}
+function rewindRingGroup(rings, firstRing, lastRing, outerClockwise) {
+  if (rings.kind !== "list")
+    return false;
+  const leaf = rings.child;
+  if (leaf.kind !== "fixed-size-list" && leaf.kind !== "struct")
+    return false;
+  let changed = false;
+  for (let ringIndex = firstRing; ringIndex < lastRing; ringIndex++) {
+    const [first, last] = getListRange(rings, ringIndex);
+    const area2 = getRingArea(leaf, first, last);
+    if (!Number.isFinite(area2) || area2 === 0)
+      continue;
+    const shouldClockwise = ringIndex === firstRing ? outerClockwise : !outerClockwise;
+    if (area2 < 0 !== shouldClockwise) {
+      reverseCoordinateRange(leaf, first, last);
+      changed = true;
+    }
+  }
+  return changed;
+}
+function getRingArea(leaf, first, last) {
+  let area2 = 0;
+  for (let index = first; index < last; index++) {
+    const current = readCoordinateAt(leaf, index);
+    const next = readCoordinateAt(leaf, index + 1 < last ? index + 1 : first);
+    if (!current || !next)
+      return Number.NaN;
+    area2 += current[0] * next[1] - next[0] * current[1];
+  }
+  return area2 / 2;
+}
+function reverseCoordinateRange(leaf, first, last) {
+  const values = [];
+  for (let index = first; index < last; index++)
+    values.push(readCoordinateAt(leaf, index));
+  values.reverse();
+  for (let index = first; index < last; index++)
+    writeCoordinateAt(leaf, index, values[index - first]);
+}
+function writeCoordinateAt(array, index, coordinate) {
+  if (array.kind === "fixed-size-list" && array.child.kind === "primitive") {
+    const logical = (array.offset || 0) + index;
+    for (let component = 0; component < array.size; component++) {
+      const scalar2 = (array.child.offset || 0) + logical * array.size + component;
+      array.child.values[scalar2] = coordinate[component];
+    }
+  } else if (array.kind === "struct") {
+    const logical = (array.offset || 0) + index;
+    const names = ["x", "y", "z", "m"];
+    for (let component = 0; component < names.length; component++) {
+      const child = array.children[names[component]];
+      if ((child == null ? void 0 : child.kind) === "primitive")
+        child.values[(child.offset || 0) + logical * (child.stride || 1)] = coordinate[component];
+    }
+  }
+}
+function 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/turf.js
+var RADIUS = 63710088e-1;
+var RAD = Math.PI / 180;
+var depths = {
+  "geoarrow.point": 0,
+  "geoarrow.multipoint": 1,
+  "geoarrow.linestring": 1,
+  "geoarrow.multilinestring": 2,
+  "geoarrow.polygon": 2,
+  "geoarrow.multipolygon": 3
+};
+function rows(column, allowed) {
+  if (!allowed.includes(column.encoding))
+    throw new Error(`Unsupported GeoArrow encoding ${column.encoding}; expected ${allowed.join(", ")}`);
+  const result2 = [];
+  for (const array of column.chunks)
+    for (let index = 0; index < array.length; index++)
+      result2.push({ array, index, valid: isGeoArrowValueValid(array.validity, index) });
+  return result2;
+}
+function range(array, index) {
+  if (array.kind !== "list")
+    throw new Error("Invalid GeoArrow list storage");
+  const i = (array.offset || 0) + index;
+  const base = Number(array.offsetBase ?? 0);
+  const a = Number(array.offsets[i]) - base, b = Number(array.offsets[i + 1]) - base;
+  if (!Number.isSafeInteger(a) || !Number.isSafeInteger(b))
+    throw new Error("Invalid GeoArrow list offsets");
+  return [a, b];
+}
+function scalar(array, index) {
+  if (array.kind !== "primitive")
+    throw new Error("Invalid GeoArrow coordinate");
+  if (!isGeoArrowValueValid(array.validity, index))
+    return NaN;
+  return Number(array.values[(array.offset || 0) + index * (array.stride || 1)]);
+}
+function point(array, index) {
+  if (!isGeoArrowValueValid(array.validity, index))
+    return null;
+  if (array.kind === "fixed-size-list") {
+    const i = ((array.offset || 0) + index) * array.size;
+    const x = scalar(array.child, i), y = scalar(array.child, i + 1);
+    return !Number.isFinite(x) || !Number.isFinite(y) ? null : [x, y];
+  }
+  if (array.kind === "struct") {
+    const i = (array.offset || 0) + index;
+    const x = scalar(array.children["x"], i), y = scalar(array.children["y"], i);
+    return !Number.isFinite(x) || !Number.isFinite(y) ? null : [x, y];
+  }
+  throw new Error("Invalid GeoArrow coordinate storage");
+}
+function walk(array, index, depth, visit) {
+  if (!isGeoArrowValueValid(array.validity, index))
+    return;
+  if (!depth) {
+    const p = point(array, index);
+    if (p)
+      visit(p);
+    return;
+  }
+  const [a, b] = range(array, index);
+  if (array.kind !== "list")
+    throw new Error("Invalid GeoArrow list storage");
+  for (let i = a; i < b; i++)
+    walk(array.child, i, depth - 1, visit);
+}
+function lines(array, index, depth, visit) {
+  if (!isGeoArrowValueValid(array.validity, index))
+    return;
+  const [a, b] = range(array, index);
+  if (array.kind !== "list")
+    throw new Error("Invalid GeoArrow list storage");
+  if (depth === 1)
+    visit(array.child, a, b);
+  else
+    for (let i = a; i < b; i++)
+      lines(array.child, i, depth - 1, visit);
+}
+function valid(bitmap, i) {
+  bitmap[i >> 3] |= 1 << (i & 7);
+}
+function result(n, boolean = false) {
+  return {
+    values: boolean ? new Uint8Array(n) : new Float64Array(n),
+    validity: new Uint8Array(Math.ceil(n / 8))
+  };
+}
+function paired(a, b) {
+  if (a.length === b.length)
+    return a.length;
+  if (a.length === 1)
+    return b.length;
+  if (b.length === 1)
+    return a.length;
+  throw new Error("GeoArrow batch lengths must match or one input must contain one row");
+}
+function units(radians, unit = "kilometers") {
+  switch (unit) {
+    case "kilometers":
+      return radians * RADIUS / 1e3;
+    case "meters":
+      return radians * RADIUS;
+    case "miles":
+      return radians * RADIUS / 1609.344;
+    case "nauticalmiles":
+      return radians * RADIUS / 1852;
+    case "radians":
+      return radians;
+    case "degrees":
+      return radians / RAD;
+    default:
+      throw new Error(`Unsupported units: ${unit}`);
+  }
+}
+function angular(a, b) {
+  const dlat = (b[1] - a[1]) * RAD, dlon = (b[0] - a[0]) * RAD;
+  const h = Math.sin(dlat / 2) ** 2 + Math.cos(a[1] * RAD) * Math.cos(b[1] * RAD) * Math.sin(dlon / 2) ** 2;
+  return 2 * Math.atan2(Math.sqrt(h), Math.sqrt(Math.max(0, 1 - h)));
+}
+var native = Object.keys(depths);
+var points = ["geoarrow.point"];
+var polygons = ["geoarrow.polygon", "geoarrow.multipolygon"];
+function bbox(column) {
+  rows(column, native);
+  const bounds = getGeoArrowRowBounds(column), out = {
+    values: new Float64Array(bounds.length * 4),
+    validity: new Uint8Array(Math.ceil(bounds.length / 8))
+  };
+  bounds.forEach((b, i) => {
+    if (b) {
+      out.values.set(b, i * 4);
+      valid(out.validity, i);
+    }
+  });
+  return out;
+}
+function pointPair(a, b, fn) {
+  const left = rows(a, points), right = rows(b, points), n = paired(left, right), out = result(n);
+  for (let i = 0; i < n; i++) {
+    const x = left[left.length === 1 ? 0 : i], y = right[right.length === 1 ? 0 : i];
+    if (!x.valid || !y.valid)
+      continue;
+    const p = point(x.array, x.index), q = point(y.array, y.index);
+    if (p && q) {
+      out.values[i] = fn(p, q);
+      valid(out.validity, i);
+    }
+  }
+  return out;
+}
+function distance(a, b, options = {}) {
+  return pointPair(a, b, (p, q) => units(angular(p, q), options.units));
+}
+function bearing(a, b) {
+  return pointPair(a, b, (p, q) => {
+    const d = (q[0] - p[0]) * RAD, y = Math.sin(d) * Math.cos(q[1] * RAD), x = Math.cos(p[1] * RAD) * Math.sin(q[1] * RAD) - Math.sin(p[1] * RAD) * Math.cos(q[1] * RAD) * Math.cos(d);
+    return Math.atan2(y, x) / RAD;
+  });
+}
+function length(column, options = {}) {
+  const input = rows(column, ["geoarrow.linestring", "geoarrow.multilinestring"]), out = result(input.length);
+  input.forEach((row, i) => {
+    if (!row.valid)
+      return;
+    let sum = 0;
+    lines(row.array, row.index, depths[column.encoding], (array, a, b) => {
+      let prev = null;
+      for (let j = a; j < b; j++) {
+        const p = point(array, j);
+        if (p && prev)
+          sum += angular(prev, p);
+        prev = p;
+      }
+    });
+    out.values[i] = units(sum, options.units);
+    valid(out.validity, i);
+  });
+  return out;
+}
+function ringArea(array, a, b) {
+  const n = b - a - 1;
+  if (n <= 2)
+    return 0;
+  let sum = 0;
+  for (let i = 0; i < n; i++) {
+    const p = point(array, a + i), q = point(array, a + (i + 1) % n), r = point(array, a + (i + 2) % n);
+    if (p && q && r)
+      sum += (r[0] - p[0]) * RAD * Math.sin(q[1] * RAD);
+  }
+  return sum * RADIUS * RADIUS / 2;
+}
+function polygonArea(array, index) {
+  const [a, b] = range(array, index);
+  if (array.kind !== "list")
+    throw new Error("Invalid polygon");
+  if (a === b || !isGeoArrowValueValid(array.child.validity, a))
+    return 0;
+  let sum = 0;
+  for (let i = a; i < b; i++) {
+    if (!isGeoArrowValueValid(array.child.validity, i))
+      continue;
+    const [x, y] = range(array.child, i);
+    if (array.child.kind !== "list")
+      throw new Error("Invalid polygon ring");
+    const v = Math.abs(ringArea(array.child.child, x, y));
+    sum += i === a ? v : -v;
+  }
+  return sum;
+}
+function area(column) {
+  const input = rows(column, polygons), out = result(input.length);
+  input.forEach((row, i) => {
+    if (!row.valid)
+      return;
+    let sum = 0;
+    if (column.encoding === "geoarrow.polygon")
+      sum = polygonArea(row.array, row.index);
+    else {
+      const [a, b] = range(row.array, row.index);
+      if (row.array.kind !== "list")
+        throw new Error("Invalid multipolygon");
+      for (let j = a; j < b; j++)
+        if (isGeoArrowValueValid(row.array.child.validity, j))
+          sum += polygonArea(row.array.child, j);
+    }
+    out.values[i] = sum;
+    valid(out.validity, i);
+  });
+  return out;
+}
+function centroid(column) {
+  const input = rows(column, native), values = new Float64Array(input.length * 2), validity = new Uint8Array(Math.ceil(input.length / 8));
+  input.forEach((row, i) => {
+    if (!row.valid)
+      return;
+    let x = 0, y = 0, n = 0;
+    const add = (p) => {
+      x += p[0];
+      y += p[1];
+      n++;
+    };
+    if (polygons.includes(column.encoding))
+      lines(row.array, row.index, depths[column.encoding], (array, a, b) => {
+        for (let j = a; j < Math.max(a, b - 1); j++) {
+          const p = point(array, j);
+          if (p)
+            add(p);
+        }
+      });
+    else
+      walk(row.array, row.index, depths[column.encoding], add);
+    if (n) {
+      values[i * 2] = x / n;
+      values[i * 2 + 1] = y / n;
+      valid(validity, i);
+    }
+  });
+  return {
+    encoding: "geoarrow.point",
+    dimension: "xy",
+    coordinateLayout: "interleaved",
+    spatialReference: column.spatialReference,
+    edges: column.edges,
+    metadata: column.metadata,
+    chunks: [
+      {
+        kind: "fixed-size-list",
+        size: 2,
+        length: input.length,
+        validity: { values: validity },
+        child: { kind: "primitive", length: values.length, values }
+      }
+    ]
+  };
+}
+function ringContains(array, a, b, p) {
+  let inside = false;
+  for (let i = a, j = b - 1; i < b; j = i++) {
+    const u = point(array, i), v = point(array, j);
+    if (!u || !v)
+      continue;
+    const cross = (p[0] - u[0]) * (v[1] - u[1]) - (p[1] - u[1]) * (v[0] - u[0]);
+    if (cross === 0 && p[0] >= Math.min(u[0], v[0]) && p[0] <= Math.max(u[0], v[0]) && p[1] >= Math.min(u[1], v[1]) && p[1] <= Math.max(u[1], v[1]))
+      return 0;
+    if (u[1] > p[1] !== v[1] > p[1] && p[0] < (v[0] - u[0]) * (p[1] - u[1]) / (v[1] - u[1]) + u[0])
+      inside = !inside;
+  }
+  return inside ? 1 : -1;
+}
+function polygonContains(array, index, p) {
+  const [a, b] = range(array, index);
+  if (array.kind !== "list")
+    throw new Error("Invalid polygon");
+  if (a === b || !isGeoArrowValueValid(array.child.validity, a))
+    return -1;
+  for (let i = a; i < b; i++) {
+    if (!isGeoArrowValueValid(array.child.validity, i))
+      continue;
+    const [x, y] = range(array.child, i);
+    if (array.child.kind !== "list")
+      throw new Error("Invalid polygon ring");
+    const c = ringContains(array.child.child, x, y, p);
+    if (c === 0)
+      return 0;
+    if (i === a && c < 0 || i > a && c > 0)
+      return -1;
+  }
+  return a === b ? -1 : 1;
+}
+function booleanPointInPolygon(pointColumn, polygonColumn, options = {}) {
+  const a = rows(pointColumn, points), b = rows(polygonColumn, polygons), n = paired(a, b), out = result(n, true);
+  for (let i = 0; i < n; i++) {
+    const x = a[a.length === 1 ? 0 : i], y = b[b.length === 1 ? 0 : i];
+    if (!x.valid || !y.valid)
+      continue;
+    const p = point(x.array, x.index);
+    if (!p)
+      continue;
+    let hit = false;
+    if (polygonColumn.encoding === "geoarrow.polygon") {
+      const c = polygonContains(y.array, y.index, p);
+      hit = c > 0 || c === 0 && !options.ignoreBoundary;
+    } else {
+      const [start, end] = range(y.array, y.index);
+      if (y.array.kind !== "list")
+        throw new Error("Invalid multipolygon");
+      for (let j = start; j < end; j++) {
+        if (!isGeoArrowValueValid(y.array.child.validity, j))
+          continue;
+        const c = polygonContains(y.array.child, j, p);
+        if (c > 0 || c === 0 && !options.ignoreBoundary) {
+          hit = true;
+          break;
+        }
+      }
+    }
+    out.values[i] = Number(hit);
+    valid(out.validity, i);
+  }
+  return out;
+}
+function clone(column) {
+  rows(column, native);
+  return mapGeoArrowCoordinates(column, (coordinate) => coordinate);
+}
+function truncate(column, options = {}) {
+  rows(column, native);
+  const precision = options.precision ?? 6;
+  if (!Number.isInteger(precision) || precision < 0 || precision > 15) {
+    throw new RangeError("precision must be an integer between 0 and 15");
+  }
+  const factor = 10 ** precision;
+  return mapGeoArrowCoordinates(column, (coordinate) => coordinate.map((value) => Math.round(value * factor) / factor));
+}
+function toMercator(column) {
+  rows(column, native);
+  const radius = 6378137;
+  const maximum = 20037508342789244e-9;
+  return {
+    ...mapGeoArrowCoordinates(column, (coordinate) => {
+      const longitude = Math.abs(coordinate[0]) <= 180 ? coordinate[0] : coordinate[0] - Math.sign(coordinate[0]) * 360;
+      const x = radius * longitude * RAD;
+      const y = radius * Math.log(Math.tan(Math.PI / 4 + coordinate[1] * RAD / 2));
+      return [
+        Math.max(-maximum, Math.min(maximum, x)),
+        Math.max(-maximum, Math.min(maximum, y)),
+        ...coordinate.slice(2)
+      ];
+    }),
+    spatialReference: null
+  };
+}
+function toWgs84(column) {
+  rows(column, native);
+  return {
+    ...mapGeoArrowCoordinates(column, (coordinate) => [
+      coordinate[0] / 6378137 / RAD,
+      (2 * Math.atan(Math.exp(coordinate[1] / 6378137)) - Math.PI / 2) / RAD,
+      ...coordinate.slice(2)
+    ]),
+    spatialReference: null
+  };
+}
+function pointOutput(source, count, calculate) {
+  const values = new Float64Array(count * 2);
+  const validity = new Uint8Array(Math.ceil(count / 8));
+  for (let i = 0; i < count; i++) {
+    const p = calculate(i);
+    if (p) {
+      values.set(p, i * 2);
+      valid(validity, i);
+    }
+  }
+  return {
+    encoding: "geoarrow.point",
+    dimension: "xy",
+    coordinateLayout: "interleaved",
+    spatialReference: source.spatialReference,
+    metadata: source.metadata,
+    edges: source.edges,
+    chunks: [
+      {
+        kind: "fixed-size-list",
+        size: 2,
+        length: count,
+        validity: { values: validity },
+        child: { kind: "primitive", length: values.length, values }
+      }
+    ]
+  };
+}
+function center(column) {
+  rows(column, native);
+  const bounds = getGeoArrowRowBounds(column);
+  return pointOutput(column, bounds.length, (i) => bounds[i] ? [(bounds[i][0] + bounds[i][2]) / 2, (bounds[i][1] + bounds[i][3]) / 2] : null);
+}
+function destinationPoint(p, radians, bearingDegrees) {
+  const latitude = p[1] * RAD, bearing2 = bearingDegrees * RAD;
+  const y = Math.asin(Math.sin(latitude) * Math.cos(radians) + Math.cos(latitude) * Math.sin(radians) * Math.cos(bearing2));
+  const x = p[0] * RAD + Math.atan2(Math.sin(bearing2) * Math.sin(radians) * Math.cos(latitude), Math.cos(radians) - Math.sin(latitude) * Math.sin(y));
+  return [x / RAD, y / RAD];
+}
+function destination(column, distanceValue, bearingDegrees, options = {}) {
+  if (!Number.isFinite(distanceValue) || !Number.isFinite(bearingDegrees))
+    throw new RangeError("Distance and bearing must be finite");
+  const input = rows(column, points), radians = distanceValue / units(1, options.units);
+  return pointOutput(column, input.length, (i) => {
+    const row = input[i];
+    const p = row.valid ? point(row.array, row.index) : null;
+    return p ? destinationPoint(p, radians, bearingDegrees) : null;
+  });
+}
+function midpoint(a, b) {
+  const left = rows(a, points), right = rows(b, points), count = paired(left, right);
+  return pointOutput(a, count, (i) => {
+    const x = left[left.length === 1 ? 0 : i], y = right[right.length === 1 ? 0 : i];
+    if (!x.valid || !y.valid)
+      return null;
+    const p = point(x.array, x.index), q = point(y.array, y.index);
+    if (!p || !q)
+      return null;
+    const delta = (q[0] - p[0]) * RAD;
+    const angle = Math.atan2(Math.sin(delta) * Math.cos(q[1] * RAD), Math.cos(p[1] * RAD) * Math.sin(q[1] * RAD) - Math.sin(p[1] * RAD) * Math.cos(q[1] * RAD) * Math.cos(delta));
+    return destinationPoint(p, angular(p, q) / 2, angle / RAD);
+  });
+}
+function rhumbAngle(a, b) {
+  let longitude = (b[0] - a[0]) * RAD;
+  if (Math.abs(longitude) > Math.PI)
+    longitude += longitude > 0 ? -2 * Math.PI : 2 * Math.PI;
+  const latitude = Math.log(Math.tan(b[1] * RAD / 2 + Math.PI / 4) / Math.tan(a[1] * RAD / 2 + Math.PI / 4));
+  return Math.atan2(longitude, latitude);
+}
+function rhumbDistance(a, b, options = {}) {
+  return pointPair(a, b, (p, q) => {
+    const delta = (q[1] - p[1]) * RAD;
+    let longitude = Math.abs(q[0] - p[0]) * RAD;
+    if (longitude > Math.PI)
+      longitude = 2 * Math.PI - longitude;
+    const psi = Math.log(Math.tan(q[1] * RAD / 2 + Math.PI / 4) / Math.tan(p[1] * RAD / 2 + Math.PI / 4));
+    const scale = Math.abs(psi) > 1e-11 ? delta / psi : Math.cos(p[1] * RAD);
+    return units(Math.hypot(delta, scale * longitude), options.units);
+  });
+}
+function rhumbBearing(a, b, options = {}) {
+  return pointPair(a, b, (p, q) => rhumbAngle(options.final ? q : p, options.final ? p : q) / RAD);
+}
+function rhumbDestinationPoint(p, radians, bearingDegrees) {
+  const phi = p[1] * RAD, theta = bearingDegrees * RAD;
+  const delta = radians * Math.cos(theta);
+  let latitude = phi + delta;
+  if (Math.abs(latitude) > Math.PI / 2)
+    latitude = latitude > 0 ? Math.PI - latitude : -Math.PI - latitude;
+  const psi = Math.log(Math.tan(latitude / 2 + Math.PI / 4) / Math.tan(phi / 2 + Math.PI / 4));
+  const scale = Math.abs(psi) > 1e-11 ? delta / psi : Math.cos(phi);
+  let longitude = ((p[0] * RAD + radians * Math.sin(theta) / scale + 3 * Math.PI) % (2 * Math.PI) - Math.PI) / RAD;
+  if (longitude - p[0] > 180)
+    longitude -= 360;
+  if (p[0] - longitude > 180)
+    longitude += 360;
+  return [longitude, latitude / RAD];
+}
+function rhumbDestination(column, distanceValue, bearingDegrees, options = {}) {
+  if (!Number.isFinite(distanceValue) || !Number.isFinite(bearingDegrees))
+    throw new RangeError("Distance and bearing must be finite");
+  const input = rows(column, points), radians = distanceValue / units(1, options.units);
+  return pointOutput(column, input.length, (i) => {
+    const row = input[i], p = row.valid ? point(row.array, row.index) : null;
+    return p ? rhumbDestinationPoint(p, radians, bearingDegrees) : null;
+  });
+}
+function transformTranslate(column, distanceValue, direction, options = {}) {
+  rows(column, native);
+  if (!Number.isFinite(distanceValue) || !Number.isFinite(direction))
+    throw new RangeError("Distance and direction must be finite");
+  const radians = distanceValue / units(1, options.units);
+  return mapGeoArrowCoordinates(column, (p) => [
+    ...rhumbDestinationPoint([p[0], p[1]], radians, direction),
+    ...p.slice(2)
+  ]);
+}
+function transformRotate(column, angle, options) {
+  rows(column, native);
+  if (!Number.isFinite(angle) || !options.pivot.every(Number.isFinite))
+    throw new RangeError("Angle and pivot must be finite");
+  const pivot = [options.pivot[0], options.pivot[1]];
+  return mapGeoArrowCoordinates(column, (p) => {
+    const phi = (p[1] - pivot[1]) * RAD;
+    const psi = Math.log(Math.tan(p[1] * RAD / 2 + Math.PI / 4) / Math.tan(pivot[1] * RAD / 2 + Math.PI / 4));
+    const q = Math.abs(psi) > 1e-11 ? phi / psi : Math.cos(pivot[1] * RAD);
+    let longitude = Math.abs(p[0] - pivot[0]) * RAD;
+    if (longitude > Math.PI)
+      longitude = 2 * Math.PI - longitude;
+    const distance2 = Math.hypot(phi, q * longitude);
+    return [
+      ...rhumbDestinationPoint(pivot, distance2, rhumbAngle(pivot, [p[0], p[1]]) / RAD + angle),
+      ...p.slice(2)
+    ];
+  });
+}
+function generatedPaths(source, count, size, polygon, generate) {
+  const values = new Float64Array(count * size * 2), validity = new Uint8Array(Math.ceil(count / 8));
+  const offsets = new Int32Array(count + 1);
+  for (let row = 0; row < count; row++) {
+    offsets[row + 1] = (row + 1) * size;
+    let present = true;
+    for (let vertex = 0; vertex < size; vertex++) {
+      const p = generate(row, vertex);
+      if (p)
+        values.set(p, (row * size + vertex) * 2);
+      else
+        present = false;
+    }
+    if (present)
+      valid(validity, row);
+  }
+  const coordinates = {
+    kind: "fixed-size-list",
+    size: 2,
+    length: count * size,
+    child: { kind: "primitive", length: values.length, values }
+  };
+  const paths = { kind: "list", length: count, offsets, child: coordinates };
+  const geometry = polygon ? {
+    kind: "list",
+    length: count,
+    offsets: Int32Array.from({ length: count + 1 }, (_, i) => i),
+    child: paths,
+    validity: { values: validity }
+  } : { ...paths, validity: { values: validity } };
+  return {
+    encoding: polygon ? "geoarrow.polygon" : "geoarrow.linestring",
+    dimension: "xy",
+    coordinateLayout: "interleaved",
+    spatialReference: source.spatialReference,
+    metadata: source.metadata,
+    edges: source.edges,
+    chunks: [geometry]
+  };
+}
+function checkedSteps(steps = 64) {
+  if (!Number.isInteger(steps) || steps < 4 || steps > 65536)
+    throw new RangeError("steps must be an integer from 4 through 65536");
+  return steps;
+}
+function circle(column, radius, options = {}) {
+  const input = rows(column, points), steps = checkedSteps(options.steps);
+  if (!Number.isFinite(radius) || radius < 0)
+    throw new RangeError("radius must be finite and nonnegative");
+  const radians = radius / units(1, options.units);
+  return generatedPaths(column, input.length, steps + 1, true, (i, j) => {
+    const row = input[i], p = row.valid ? point(row.array, row.index) : null;
+    return p ? destinationPoint(p, radians, -360 * (j % steps) / steps) : null;
+  });
+}
+function bboxPolygon(column) {
+  rows(column, native);
+  const bounds = getGeoArrowRowBounds(column);
+  return generatedPaths(column, bounds.length, 5, true, (i, j) => {
+    const b = bounds[i];
+    if (!b)
+      return null;
+    return [b[j === 1 || j === 2 ? 2 : 0], b[j === 2 || j === 3 ? 3 : 1]];
+  });
+}
+function lineArc(column, radius, bearing1, bearing2, options = {}) {
+  const input = rows(column, points), steps = checkedSteps(options.steps);
+  if (![radius, bearing1, bearing2].every(Number.isFinite) || radius < 0)
+    throw new RangeError("Radius and bearings must be finite; radius must be nonnegative");
+  const start = (bearing1 % 360 + 360) % 360, end = (bearing2 % 360 + 360) % 360;
+  const sweep = (end - start + 360) % 360 || 360;
+  const segments2 = Math.ceil(sweep * steps / 360), radians = radius / units(1, options.units);
+  return generatedPaths(column, input.length, segments2 + 1, false, (i, j) => {
+    const row = input[i], p = row.valid ? point(row.array, row.index) : null;
+    return p ? destinationPoint(p, radians, start + Math.min(j * 360 / steps, sweep)) : null;
+  });
+}
+function along(column, distanceValue, options = {}) {
+  const input = rows(column, ["geoarrow.linestring"]);
+  if (!Number.isFinite(distanceValue) || distanceValue < 0)
+    throw new RangeError("distance must be finite and nonnegative");
+  const target = distanceValue / units(1, options.units);
+  return pointOutput(column, input.length, (i) => {
+    const row = input[i];
+    if (!row.valid || row.array.kind !== "list")
+      return null;
+    const [a, b] = range(row.array, row.index);
+    let previous = null, travelled = 0;
+    for (let j = a; j < b; j++) {
+      const p = point(row.array.child, j);
+      if (!p) {
+        previous = null;
+        continue;
+      }
+      if (previous) {
+        const segment = angular(previous, p);
+        if (travelled + segment >= target) {
+          const delta = (p[0] - previous[0]) * RAD;
+          const heading = Math.atan2(Math.sin(delta) * Math.cos(p[1] * RAD), Math.cos(previous[1] * RAD) * Math.sin(p[1] * RAD) - Math.sin(previous[1] * RAD) * Math.cos(p[1] * RAD) * Math.cos(delta));
+          return destinationPoint(previous, target - travelled, heading / RAD);
+        }
+        travelled += segment;
+      } else if (target === 0)
+        return p;
+      previous = p;
+    }
+    return previous;
+  });
+}
+function booleanPointOnLine(pointColumn, lineColumn, options = {}) {
+  const epsilon = options.epsilon ?? 0;
+  if (!Number.isFinite(epsilon) || epsilon < 0)
+    throw new RangeError("epsilon must be finite and nonnegative");
+  const a = rows(pointColumn, points), b = rows(lineColumn, ["geoarrow.linestring"]), n = paired(a, b), out = result(n, true);
+  for (let i = 0; i < n; i++) {
+    const left = a[a.length === 1 ? 0 : i], right = b[b.length === 1 ? 0 : i];
+    if (!left.valid || !right.valid)
+      continue;
+    const p = point(left.array, left.index);
+    if (!p || right.array.kind !== "list")
+      continue;
+    const [start, end] = range(right.array, right.index);
+    for (let j = start + 1; j < end; j++) {
+      const u = point(right.array.child, j - 1), v = point(right.array.child, j);
+      if (!u || !v)
+        continue;
+      const cross = (p[0] - u[0]) * (v[1] - u[1]) - (p[1] - u[1]) * (v[0] - u[0]);
+      const axis = Math.abs(v[0] - u[0]) >= Math.abs(v[1] - u[1]) ? 0 : 1;
+      if (u[0] === v[0] && u[1] === v[1]) {
+        if (p[0] !== u[0] || p[1] !== u[1])
+          continue;
+      } else if (Math.abs(cross) > epsilon || p[axis] < Math.min(u[axis], v[axis]) || p[axis] > Math.max(u[axis], v[axis]))
+        continue;
+      if (options.ignoreEndVertices && (j === start + 1 && p[0] === u[0] && p[1] === u[1] || j === end - 1 && p[0] === v[0] && p[1] === v[1]))
+        continue;
+      out.values[i] = 1;
+      break;
+    }
+    valid(out.validity, i);
+  }
+  return out;
+}
+function booleanClockwise(column) {
+  const input = rows(column, ["geoarrow.linestring"]), out = result(input.length, true);
+  input.forEach((row, i) => {
+    if (!row.valid || row.array.kind !== "list")
+      return;
+    const [a, b] = range(row.array, row.index);
+    let sum = 0;
+    for (let j = a + 1; j < b; j++) {
+      const p = point(row.array.child, j - 1), q = point(row.array.child, j);
+      if (p && q)
+        sum += (q[0] - p[0]) * (q[1] + p[1]);
+    }
+    out.values[i] = Number(sum > 0);
+    valid(out.validity, i);
+  });
+  return out;
+}
+function rewind(column, options = {}) {
+  rows(column, polygons);
+  return rewindGeoArrow(column, { outer: options.reverse ? "clockwise" : "counter-clockwise" });
+}
+function transformScale(column, factor, options) {
+  rows(column, native);
+  if (!Number.isFinite(factor) || factor <= 0 || !options.origin.every(Number.isFinite))
+    throw new RangeError("factor must be positive and origin must be finite");
+  const origin = [options.origin[0], options.origin[1]];
+  return mapGeoArrowCoordinates(column, (p) => {
+    const delta = (p[1] - origin[1]) * RAD;
+    const psi = Math.log(Math.tan(p[1] * RAD / 2 + Math.PI / 4) / Math.tan(origin[1] * RAD / 2 + Math.PI / 4));
+    const q = Math.abs(psi) > 1e-11 ? delta / psi : Math.cos(origin[1] * RAD);
+    let longitude = Math.abs(p[0] - origin[0]) * RAD;
+    if (longitude > Math.PI)
+      longitude = 2 * Math.PI - longitude;
+    return [
+      ...rhumbDestinationPoint(origin, Math.hypot(delta, q * longitude) * factor, rhumbAngle(origin, [p[0], p[1]]) / RAD),
+      ...p.slice(2)
+    ];
+  });
+}
+function polygonToLine(column) {
+  rows(column, ["geoarrow.polygon"]);
+  return { ...column, encoding: "geoarrow.multilinestring" };
+}
+function lineToPolygon(column) {
+  const input = rows(column, ["geoarrow.linestring"]);
+  for (const row of input) {
+    if (!row.valid || row.array.kind !== "list")
+      continue;
+    const [a, b] = range(row.array, row.index);
+    if (a === b)
+      continue;
+    const first = point(row.array.child, a), last = point(row.array.child, b - 1);
+    if (b - a < 4 || !first || !last || first[0] !== last[0] || first[1] !== last[1])
+      throw new RangeError("lineToPolygon requires closed rings with at least four coordinates");
+  }
+  return {
+    ...column,
+    encoding: "geoarrow.polygon",
+    chunks: column.chunks.map((chunk) => ({
+      kind: "list",
+      length: chunk.length,
+      validity: chunk.validity,
+      offsets: Int32Array.from({ length: chunk.length + 1 }, (_, i) => i),
+      child: chunk
+    }))
+  };
+}
+function explode(column) {
+  const input = rows(column, native);
+  let count = 0;
+  for (const row of input)
+    if (row.valid)
+      walk(row.array, row.index, depths[column.encoding], () => count++);
+  const values = new Float64Array(count * 2);
+  let index = 0;
+  for (const row of input)
+    if (row.valid)
+      walk(row.array, row.index, depths[column.encoding], (p) => {
+        values.set(p, index * 2);
+        index++;
+      });
+  return {
+    encoding: "geoarrow.point",
+    dimension: "xy",
+    coordinateLayout: "interleaved",
+    spatialReference: column.spatialReference,
+    metadata: column.metadata,
+    edges: column.edges,
+    chunks: [
+      {
+        kind: "fixed-size-list",
+        size: 2,
+        length: count,
+        child: { kind: "primitive", length: values.length, values }
+      }
+    ]
+  };
+}
+function lineSegment(column) {
+  const input = rows(column, ["geoarrow.linestring", "geoarrow.multilinestring", ...polygons]);
+  const visit = (emit) => {
+    for (const row of input)
+      if (row.valid)
+        lines(row.array, row.index, depths[column.encoding], (array, a, b) => {
+          for (let j = a + 1; j < b; j++) {
+            const p = point(array, j - 1), q = point(array, j);
+            if (p && q)
+              emit(p, q);
+          }
+        });
+  };
+  let count = 0;
+  visit(() => count++);
+  const values = new Float64Array(count * 4), offsets = Int32Array.from({ length: count + 1 }, (_, i) => i * 2);
+  let index = 0;
+  visit((p, q) => {
+    values.set(p, index * 4);
+    values.set(q, index * 4 + 2);
+    index++;
+  });
+  return {
+    encoding: "geoarrow.linestring",
+    dimension: "xy",
+    coordinateLayout: "interleaved",
+    spatialReference: column.spatialReference,
+    metadata: column.metadata,
+    edges: column.edges,
+    chunks: [
+      {
+        kind: "list",
+        length: count,
+        offsets,
+        child: {
+          kind: "fixed-size-list",
+          size: 2,
+          length: count * 2,
+          child: { kind: "primitive", length: values.length, values }
+        }
+      }
+    ]
+  };
+}
+function booleanConcave(column) {
+  const input = rows(column, ["geoarrow.polygon"]), out = result(input.length, true);
+  input.forEach((row, i) => {
+    if (!row.valid || row.array.kind !== "list")
+      return;
+    valid(out.validity, i);
+    const [firstRing, lastRing] = range(row.array, row.index);
+    const rings = row.array.child;
+    if (firstRing === lastRing || rings.kind !== "list" || !isGeoArrowValueValid(rings.validity, firstRing))
+      return;
+    const [a, b] = range(rings, firstRing), n = b - a - 1;
+    if (n < 3)
+      return;
+    let positive = false, negative = false;
+    for (let j = 0; j < n; j++) {
+      const p = point(rings.child, a + j), q = point(rings.child, a + (j + 1) % n), r = point(rings.child, a + (j + 2) % n);
+      if (!p || !q || !r)
+        continue;
+      const cross = (q[0] - p[0]) * (r[1] - q[1]) - (q[1] - p[1]) * (r[0] - q[0]);
+      positive || (positive = cross > 0);
+      negative || (negative = cross < 0);
+    }
+    out.values[i] = Number(positive && negative);
+  });
+  return out;
+}
+var lineFamilies = ["geoarrow.linestring", "geoarrow.multilinestring", ...polygons];
+function segments(row, encoding) {
+  const output = [];
+  let path = 0;
+  if (row.valid)
+    lines(row.array, row.index, depths[encoding], (array, first, last) => {
+      for (let index = first; index + 1 < last; index++)
+        output.push({ array, index, path, first, last });
+      path++;
+    });
+  return output;
+}
+function segmentCrossing(a, b) {
+  const p = point(a.array, a.index), q = point(a.array, a.index + 1);
+  const r = point(b.array, b.index), s = point(b.array, b.index + 1);
+  if (!p || !q || !r || !s)
+    return null;
+  const dx = q[0] - p[0], dy = q[1] - p[1], ex = s[0] - r[0], ey = s[1] - r[1];
+  const denominator = dx * ey - dy * ex;
+  const onSegment = (a2, b2, v) => (v[0] - a2[0]) * (b2[1] - a2[1]) - (v[1] - a2[1]) * (b2[0] - a2[0]) === 0 && v[0] >= Math.min(a2[0], b2[0]) && v[0] <= Math.max(a2[0], b2[0]) && v[1] >= Math.min(a2[1], b2[1]) && v[1] <= Math.max(a2[1], b2[1]);
+  const endpoints = [p, q, r, s].filter((v) => onSegment(p, q, v) && onSegment(r, s, v));
+  if (denominator === 0) {
+    const unique = endpoints.filter((v, i) => !endpoints.slice(0, i).some((w) => w[0] === v[0] && w[1] === v[1]));
+    return unique.length === 1 ? unique[0] : null;
+  }
+  if (endpoints.length)
+    return endpoints[0];
+  const rx = r[0] - p[0], ry = r[1] - p[1];
+  const t = (rx * ey - ry * ex) / denominator, u = (rx * dy - ry * dx) / denominator;
+  return t >= 0 && t <= 1 && u >= 0 && u <= 1 ? [p[0] + t * dx, p[1] + t * dy] : null;
+}
+function intersectionOutput(source, count, visit) {
+  const offsets = new Int32Array(count + 1), validity = new Uint8Array(Math.ceil(count / 8));
+  for (let i = 0; i < count; i++) {
+    let size = 0;
+    if (visit(i, () => size++))
+      valid(validity, i);
+    const next = offsets[i] + size;
+    if (next > 2147483647)
+      throw new RangeError("Intersection output exceeds Int32 offsets");
+    offsets[i + 1] = next;
+  }
+  const values = new Float64Array(offsets[count] * 2);
+  for (let i = 0; i < count; i++) {
+    let index = offsets[i];
+    visit(i, (p) => {
+      values.set(p, index * 2);
+      index++;
+    });
+  }
+  return {
+    encoding: "geoarrow.multipoint",
+    dimension: "xy",
+    coordinateLayout: "interleaved",
+    spatialReference: source.spatialReference,
+    metadata: source.metadata,
+    edges: source.edges,
+    chunks: [
+      {
+        kind: "list",
+        length: count,
+        offsets,
+        validity: { values: validity },
+        child: {
+          kind: "fixed-size-list",
+          size: 2,
+          length: offsets[count],
+          child: { kind: "primitive", length: values.length, values }
+        }
+      }
+    ]
+  };
+}
+function lineIntersect(a, b, options = {}) {
+  const left = rows(a, lineFamilies), right = rows(b, lineFamilies), count = paired(left, right);
+  return intersectionOutput(a, count, (i, emit) => {
+    const x = left[left.length === 1 ? 0 : i], y = right[right.length === 1 ? 0 : i];
+    if (!x.valid || !y.valid)
+      return false;
+    const seen = /* @__PURE__ */ new Set();
+    const xs = segments(x, a.encoding), ys = segments(y, b.encoding);
+    for (const p of xs)
+      for (const q of ys) {
+        const crossing = segmentCrossing(p, q);
+        if (!crossing)
+          continue;
+        const key = `${crossing[0]},${crossing[1]}`;
+        if (options.removeDuplicates !== false && seen.has(key))
+          continue;
+        seen.add(key);
+        emit(crossing);
+      }
+    return true;
+  });
+}
+function kinks(column) {
+  const input = rows(column, lineFamilies);
+  return intersectionOutput(column, input.length, (i, emit) => {
+    const row = input[i];
+    if (!row.valid)
+      return false;
+    const edges = segments(row, column.encoding), seen = /* @__PURE__ */ new Set();
+    for (let j = 0; j < edges.length; j++)
+      for (let k = j + 1; k < edges.length; k++) {
+        const a = edges[j], b = edges[k];
+        if (a.path === b.path && b.index === a.index + 1)
+          continue;
+        if (a.path === b.path && a.index === a.first && b.index === a.last - 2) {
+          const first = point(a.array, a.first), last = point(a.array, a.last - 1);
+          if (first && last && first[0] === last[0] && first[1] === last[1])
+            continue;
+        }
+        const crossing = segmentCrossing(a, b);
+        if (!crossing)
+          continue;
+        const key = `${crossing[0]},${crossing[1]}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          emit(crossing);
+        }
+      }
+    return true;
+  });
+}
+//# sourceMappingURL=turf.cjs.map