@math.gl/geospatial 5.0.0-alpha.17 → 5.0.0-alpha.19

package/dist/geoarrow/kernels.js

@@ -0,0 +1,982 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import { getGeoArrowDimensionSize, getGeoArrowGeometryType } from "./types.js";
+import { GeoArrowBuilder } from "./builder.js";
+import { getGeoArrowRowCount, getGeoArrowVertexCount, isGeoArrowValueValid, visitGeoArrowCoordinates, getListRange } from "./layout.js";
+/** Returns XY bounds, or null when the column contains no finite coordinates. */
+export function getGeoArrowBounds(column) {
+    if (column.encoding === 'geoarrow.box')
+        return getGeoArrowBoxBounds(column);
+    let minimumX = Number.POSITIVE_INFINITY;
+    let minimumY = Number.POSITIVE_INFINITY;
+    let maximumX = Number.NEGATIVE_INFINITY;
+    let maximumY = Number.NEGATIVE_INFINITY;
+    visitGeoArrowCoordinates(column, coordinate => {
+        const x = coordinate[0];
+        const y = coordinate[1];
+        if (Number.isFinite(x) && Number.isFinite(y)) {
+            minimumX = Math.min(minimumX, x);
+            minimumY = Math.min(minimumY, y);
+            maximumX = Math.max(maximumX, x);
+            maximumY = Math.max(maximumY, y);
+        }
+        return coordinate;
+    });
+    return Number.isFinite(minimumX) ? [minimumX, minimumY, maximumX, maximumY] : null;
+}
+/** Computes exact XY bounds for each logical row without materializing geometry values. */
+export function getGeoArrowRowBounds(column) {
+    const rowCount = getGeoArrowRowCount(column);
+    if (column.encoding === 'geoarrow.box') {
+        const result = [];
+        for (const chunk of column.chunks) {
+            for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+                if (chunk.kind !== 'struct' || !isGeoArrowValueValid(chunk.validity, rowIndex)) {
+                    result.push(null);
+                    continue;
+                }
+                const index = (chunk.offset || 0) + rowIndex;
+                const xmin = readPrimitiveNumber(chunk.children['xmin'], index);
+                const ymin = readPrimitiveNumber(chunk.children['ymin'], index);
+                const xmax = readPrimitiveNumber(chunk.children['xmax'], index);
+                const ymax = readPrimitiveNumber(chunk.children['ymax'], index);
+                result.push([xmin, ymin, xmax, ymax].every(Number.isFinite) ? [xmin, ymin, xmax, ymax] : null);
+            }
+        }
+        return result;
+    }
+    const minimumX = new Float64Array(rowCount).fill(Number.POSITIVE_INFINITY);
+    const minimumY = new Float64Array(rowCount).fill(Number.POSITIVE_INFINITY);
+    const maximumX = new Float64Array(rowCount).fill(Number.NEGATIVE_INFINITY);
+    const maximumY = new Float64Array(rowCount).fill(Number.NEGATIVE_INFINITY);
+    visitGeoArrowCoordinates(column, (coordinate, sourceRowIndex) => {
+        const [x, y] = coordinate;
+        if (Number.isFinite(x) && Number.isFinite(y)) {
+            minimumX[sourceRowIndex] = Math.min(minimumX[sourceRowIndex], x);
+            minimumY[sourceRowIndex] = Math.min(minimumY[sourceRowIndex], y);
+            maximumX[sourceRowIndex] = Math.max(maximumX[sourceRowIndex], x);
+            maximumY[sourceRowIndex] = Math.max(maximumY[sourceRowIndex], y);
+        }
+        return coordinate;
+    });
+    const bounds = [];
+    for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+        bounds.push(Number.isFinite(minimumX[rowIndex])
+            ? [minimumX[rowIndex], minimumY[rowIndex], maximumX[rowIndex], maximumY[rowIndex]]
+            : null);
+    }
+    return bounds;
+}
+function getGeoArrowBoxBounds(column) {
+    let minimumX = Number.POSITIVE_INFINITY;
+    let minimumY = Number.POSITIVE_INFINITY;
+    let maximumX = Number.NEGATIVE_INFINITY;
+    let maximumY = Number.NEGATIVE_INFINITY;
+    for (const chunk of column.chunks) {
+        if (chunk.kind !== 'struct')
+            continue;
+        const xmin = chunk.children['xmin'];
+        const ymin = chunk.children['ymin'];
+        const xmax = chunk.children['xmax'];
+        const ymax = chunk.children['ymax'];
+        if (!xmin || !ymin || !xmax || !ymax)
+            continue;
+        for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+            if (!isGeoArrowValueValid(chunk.validity, rowIndex))
+                continue;
+            const structIndex = (chunk.offset || 0) + rowIndex;
+            const bounds = [
+                readPrimitiveNumber(xmin, structIndex),
+                readPrimitiveNumber(ymin, structIndex),
+                readPrimitiveNumber(xmax, structIndex),
+                readPrimitiveNumber(ymax, structIndex)
+            ];
+            if (bounds.every(Number.isFinite)) {
+                minimumX = Math.min(minimumX, bounds[0]);
+                minimumY = Math.min(minimumY, bounds[1]);
+                maximumX = Math.max(maximumX, bounds[2]);
+                maximumY = Math.max(maximumY, bounds[3]);
+            }
+        }
+    }
+    return Number.isFinite(minimumX) ? [minimumX, minimumY, maximumX, maximumY] : null;
+}
+function readPrimitiveNumber(array, index) {
+    if (array.kind !== 'primitive' || !isGeoArrowValueValid(array.validity, index))
+        return Number.NaN;
+    const valueIndex = (array.offset || 0) + index * (array.stride || 1);
+    return Number(array.values[valueIndex]);
+}
+/** Maps every coordinate into newly allocated physical buffers while preserving column semantics. */
+export 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 !== undefined, options.coordinateLayout !== undefined, sourceDimension);
+        rowOffset += chunk.length;
+        return mapped;
+    });
+    return { ...column, dimension, coordinateLayout: layout, chunks };
+}
+/**
+ * Maps coordinates and copies the result into caller-provided destination buffers.
+ *
+ * The destination must have the same physical topology as the mapped result. Topology, validity,
+ * offsets, and metadata in the destination are never replaced.
+ */
+export function mapGeoArrowCoordinatesInto(target, source, mapper, options = {}) {
+    const mapped = mapGeoArrowCoordinates(source, mapper, {
+        ...options,
+        coordinateLayout: target.coordinateLayout || undefined
+    });
+    const sourceLeaves = collectCoordinateLeaves(mapped);
+    const targetLeaves = collectCoordinateLeaves(target);
+    if (sourceLeaves.length !== targetLeaves.length) {
+        throw new Error('GeoArrow destination has different coordinate topology');
+    }
+    for (let index = 0; index < sourceLeaves.length; index++) {
+        const sourceLeaf = sourceLeaves[index];
+        const targetLeaf = targetLeaves[index];
+        if (sourceLeaf.length !== targetLeaf.length) {
+            throw new Error('GeoArrow destination coordinate buffer has a different length');
+        }
+        targetLeaf.set(sourceLeaf);
+    }
+    return target;
+}
+/** Converts separated native coordinates to interleaved tuples. Identity is returned unchanged. */
+export function interleaveGeoArrowCoordinates(column) {
+    if (column.coordinateLayout === 'interleaved')
+        return column;
+    if (!column.coordinateLayout)
+        return column;
+    return mapGeoArrowCoordinates(column, coordinate => coordinate, {
+        coordinateLayout: 'interleaved'
+    });
+}
+/** Normalizes dense-union children by ascending type ID without changing dispatch buffers. */
+export function normalizeGeoArrowUnion(column) {
+    if (column.encoding !== 'geoarrow.geometry')
+        return column;
+    let changed = false;
+    const chunks = column.chunks.map(chunk => {
+        if (chunk.kind !== 'dense-union')
+            return chunk;
+        const children = [...chunk.children].sort((left, right) => left.typeId - right.typeId);
+        changed || (changed = children.some((child, index) => child !== chunk.children[index]));
+        return children.every((child, index) => child === chunk.children[index])
+            ? chunk
+            : { ...chunk, children };
+    });
+    return changed ? { ...column, chunks } : column;
+}
+/** Converts between concrete/mixed encodings, dimensions, and coordinate layouts. */
+export function convertGeoArrowColumn(column, options = {}) {
+    const encoding = options.encoding === 'native' || !options.encoding ? column.encoding : options.encoding;
+    const dimension = options.dimension || column.dimension;
+    const coordinateLayout = options.coordinateLayout === 'preserve' || !options.coordinateLayout
+        ? column.coordinateLayout
+        : options.coordinateLayout;
+    const requestedOffsetType = options.offsetType || 'preserve';
+    const currentOffsetType = getColumnOffsetType(column);
+    if (encoding === column.encoding &&
+        dimension === column.dimension &&
+        coordinateLayout === column.coordinateLayout &&
+        (requestedOffsetType === 'preserve' || requestedOffsetType === currentOffsetType) &&
+        (!options.coordinateType || options.coordinateType === 'preserve')) {
+        return column;
+    }
+    if (encoding === 'geoarrow.wkb' || encoding === 'geoarrow.wkt') {
+        throw new Error('Use encodeGeoArrowWKB or encodeGeoArrowWKT for serialized output');
+    }
+    assertGeoArrowResourceLimits(column, options.limits);
+    const needsCoordinateMap = dimension !== column.dimension ||
+        coordinateLayout !== column.coordinateLayout ||
+        (options.coordinateType && options.coordinateType !== 'preserve');
+    const mapped = needsCoordinateMap
+        ? mapGeoArrowCoordinates(column, coordinate => coordinate, {
+            dimension,
+            coordinateLayout: coordinateLayout || undefined,
+            coordinateType: options.coordinateType,
+            limits: options.limits
+        }, column.dimension)
+        : column;
+    const offsetConverted = requestedOffsetType === 'preserve'
+        ? mapped
+        : {
+            ...mapped,
+            chunks: mapped.chunks.map(chunk => convertArrayOffsets(chunk, requestedOffsetType))
+        };
+    if (encoding === column.encoding)
+        return offsetConverted;
+    if (encoding === 'geoarrow.geometry')
+        return promoteToDenseUnion(offsetConverted);
+    const promoted = promoteSingleFamily(offsetConverted, encoding, requestedOffsetType);
+    if (promoted)
+        return promoted;
+    if (column.encoding === 'geoarrow.geometry')
+        return demoteDenseUnion(offsetConverted, encoding);
+    throw new Error(`Rows cannot be represented as ${encoding}`);
+}
+/** Wraps a concrete family in one list level without copying its coordinate/topology buffers. */
+function promoteSingleFamily(column, encoding, offsetType) {
+    const sourceEncoding = column.encoding;
+    const validPair = (sourceEncoding === 'geoarrow.point' && encoding === 'geoarrow.multipoint') ||
+        (sourceEncoding === 'geoarrow.linestring' && encoding === 'geoarrow.multilinestring') ||
+        (sourceEncoding === 'geoarrow.polygon' && encoding === 'geoarrow.multipolygon');
+    if (!validPair)
+        return null;
+    const chunks = column.chunks.map(chunk => {
+        const OffsetArray = offsetType === 'int64' || (offsetType === 'preserve' && findOffsetType(chunk) === 'int64')
+            ? BigInt64Array
+            : Int32Array;
+        const offsets = new OffsetArray(chunk.length + 1);
+        for (let index = 0; index <= chunk.length; index++) {
+            if (offsets instanceof BigInt64Array)
+                offsets[index] = BigInt(index);
+            else
+                offsets[index] = index;
+        }
+        return {
+            kind: 'list',
+            length: chunk.length,
+            offsets,
+            child: chunk,
+            validity: chunk.validity
+        };
+    });
+    return { ...column, encoding, chunks };
+}
+function resizeCoordinate(coordinate, sourceDimension, targetDimension) {
+    const sourceNames = getDimensionNames(sourceDimension);
+    return getDimensionNames(targetDimension).map(name => {
+        const sourceIndex = sourceNames.indexOf(name);
+        return sourceIndex >= 0 ? (coordinate[sourceIndex] ?? 0) : 0;
+    });
+}
+/** Rewinds polygon rings without changing non-polygon rows. */
+export function rewindGeoArrow(column, options = {}) {
+    assertGeoArrowResourceLimits(column, options.limits);
+    if (column.encoding === 'geoarrow.wkb' || column.encoding === 'geoarrow.wkt') {
+        throw new Error('Rewinding requires native GeoArrow storage');
+    }
+    const outerClockwise = (options.outer || 'counter-clockwise') === 'clockwise';
+    let changed = false;
+    const chunks = column.chunks.map(chunk => {
+        const clone = mapArrayCoordinates(chunk, column.encoding, 0, column.dimension, column.coordinateLayout || 'interleaved', coordinate => coordinate, 'preserve');
+        changed || (changed = rewindArrayRings(clone, column.encoding, outerClockwise));
+        return clone;
+    });
+    return changed ? { ...column, chunks } : column;
+}
+/** Throws when a column exceeds configured work or output limits. */
+export function assertGeoArrowResourceLimits(column, options = {}) {
+    const rows = getGeoArrowRowCount(column);
+    if (rows > (options.maximumRows ?? Number.POSITIVE_INFINITY)) {
+        throw new Error(`GeoArrow row count ${rows} exceeds maximumRows`);
+    }
+    if (column.chunks.length > (options.maximumChunks ?? Number.POSITIVE_INFINITY)) {
+        throw new Error(`GeoArrow chunk count ${column.chunks.length} exceeds maximumChunks`);
+    }
+    const coordinates = getGeoArrowVertexCount(column);
+    if (coordinates > (options.maximumCoordinates ?? Number.POSITIVE_INFINITY)) {
+        throw new Error(`GeoArrow coordinate count ${coordinates} exceeds maximumCoordinates`);
+    }
+    if (options.maximumNestingDepth !== undefined) {
+        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 !== undefined) {
+        const estimatedBytes = coordinates * getGeoArrowDimensionSize(column.dimension) * 8;
+        if (estimatedBytes > options.maximumOutputBytes) {
+            throw new Error(`GeoArrow estimated output ${estimatedBytes} exceeds maximumOutputBytes`);
+        }
+    }
+}
+/** Directly clones a physical array while rewriting only coordinate leaves. */
+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 || getEncodingFromChildName(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 = getEncodingDepth(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?.[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);
+}
+/** Fills one row-index entry per coordinate in a concrete nested array. */
+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 || getEncodingFromChildName(child.name);
+        return new Array(getLeafLength(child.data, getEncodingDepth(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(child => child.typeId === union.typeIds[physical]);
+        if (childIndex < 0)
+            continue;
+        const child = union.children[childIndex];
+        assignUnionRowIndices(child.data, child.encoding || getEncodingFromChildName(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 || getEncodingFromChildName(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, getEncodingDepth(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?.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?.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 getEncodingFromChildName(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 getEncodingDepth(encoding) {
+    switch (encoding) {
+        case 'geoarrow.point':
+            return 0;
+        case 'geoarrow.linestring':
+        case 'geoarrow.multipoint':
+            return 1;
+        case 'geoarrow.polygon':
+        case 'geoarrow.multilinestring':
+            return 2;
+        case 'geoarrow.multipolygon':
+            return 3;
+        default:
+            return 0;
+    }
+}
+function promoteToDenseUnion(column) {
+    if (column.encoding === 'geoarrow.geometry')
+        return column;
+    const chunks = column.chunks.map(chunk => {
+        const typeId = getCanonicalTypeId(column.encoding, column.dimension);
+        const typeIds = new Int8Array(chunk.length);
+        typeIds.fill(typeId);
+        const valueOffsets = new Int32Array(chunk.length);
+        for (let index = 0; index < chunk.length; index++)
+            valueOffsets[index] = index;
+        return {
+            kind: 'dense-union',
+            length: chunk.length,
+            typeIds,
+            valueOffsets,
+            children: [
+                {
+                    name: getGeoArrowGeometryTypeName(column.encoding),
+                    typeId,
+                    encoding: column.encoding,
+                    dimension: column.dimension,
+                    coordinateLayout: column.coordinateLayout,
+                    data: chunk
+                }
+            ]
+        };
+    });
+    return { ...column, encoding: 'geoarrow.geometry', chunks };
+}
+function demoteDenseUnion(column, encoding) {
+    if (encoding === 'geoarrow.geometry' || encoding === 'geoarrow.geometrycollection')
+        return column;
+    if (!isConcreteEncoding(encoding))
+        throw new Error(`Rows cannot be represented as ${encoding}`);
+    const builderOptions = {
+        encoding,
+        dimension: column.dimension,
+        coordinateLayout: column.coordinateLayout || 'interleaved',
+        offsetType: getColumnOffsetType(column)
+    };
+    const chunks = column.chunks.map(chunk => {
+        if (chunk.kind !== 'dense-union')
+            throw new Error('Expected dense-union storage');
+        const replay = (builder) => {
+            for (let index = 0; index < chunk.length; index++) {
+                if (!isGeoArrowValueValid(chunk.validity, index)) {
+                    builder.append(null);
+                    continue;
+                }
+                const physical = (chunk.offset || 0) + index;
+                const child = chunk.children.find(candidate => candidate.typeId === chunk.typeIds[physical]);
+                const childEncoding = child && (child.encoding || getEncodingFromChildName(child.name));
+                const childIndex = chunk.valueOffsets[physical];
+                if (!child || !childEncoding || !isGeoArrowValueValid(child.data.validity, childIndex)) {
+                    builder.append(null);
+                    continue;
+                }
+                if (!isConcreteEncoding(childEncoding) || !canPromoteEncoding(childEncoding, encoding)) {
+                    throw new Error(`Rows cannot be represented as ${encoding}`);
+                }
+                replayPhysicalGeometryIntoBuilder(builder, child.data, childIndex, childEncoding, child.dimension || column.dimension, encoding);
+            }
+        };
+        const measure = new GeoArrowBuilder({ ...builderOptions, mode: 'measure' });
+        replay(measure);
+        const write = new GeoArrowBuilder({
+            ...builderOptions,
+            mode: 'write',
+            target: measure.allocateTarget()
+        });
+        replay(write);
+        return write.finish().chunks[0];
+    });
+    return { ...column, encoding, coordinateLayout: builderOptions.coordinateLayout, chunks };
+}
+function replayPhysicalGeometryIntoBuilder(builder, array, rowIndex, sourceEncoding, sourceDimension, targetEncoding) {
+    const targetType = getGeoArrowGeometryTypeName(targetEncoding);
+    builder.beginGeometry(targetType, sourceDimension);
+    if (sourceEncoding === 'geoarrow.point') {
+        writePhysicalCoordinateIntoBuilder(builder, array, rowIndex, sourceDimension);
+    }
+    else if (sourceEncoding === 'geoarrow.linestring' || sourceEncoding === 'geoarrow.multipoint') {
+        const [first, last] = requireListRange(array, rowIndex);
+        if (targetEncoding === 'geoarrow.multilinestring')
+            builder.beginRing(last - first);
+        const leaf = array.child;
+        for (let index = first; index < last; index++) {
+            writePhysicalCoordinateIntoBuilder(builder, leaf, index, sourceDimension);
+        }
+    }
+    else if (sourceEncoding === 'geoarrow.polygon' ||
+        sourceEncoding === 'geoarrow.multilinestring') {
+        const [first, last] = requireListRange(array, rowIndex);
+        if (targetEncoding === 'geoarrow.multipolygon')
+            builder.beginPolygon();
+        const parts = array.child;
+        for (let partIndex = first; partIndex < last; partIndex++) {
+            const [partFirst, partLast] = requireListRange(parts, partIndex);
+            builder.beginRing(partLast - partFirst);
+            const leaf = parts.child;
+            for (let index = partFirst; index < partLast; index++) {
+                writePhysicalCoordinateIntoBuilder(builder, leaf, index, sourceDimension);
+            }
+        }
+    }
+    else {
+        const [first, last] = requireListRange(array, rowIndex);
+        const polygons = array.child;
+        for (let polygonIndex = first; polygonIndex < last; polygonIndex++) {
+            builder.beginPolygon();
+            const [partFirst, partLast] = requireListRange(polygons, polygonIndex);
+            const parts = polygons.child;
+            for (let partIndex = partFirst; partIndex < partLast; partIndex++) {
+                const [ringFirst, ringLast] = requireListRange(parts, partIndex);
+                builder.beginRing(ringLast - ringFirst);
+                const leaf = parts.child;
+                for (let index = ringFirst; index < ringLast; index++) {
+                    writePhysicalCoordinateIntoBuilder(builder, leaf, index, sourceDimension);
+                }
+            }
+        }
+    }
+    builder.endGeometry();
+}
+function writePhysicalCoordinateIntoBuilder(builder, array, index, dimension) {
+    if (array.kind === 'fixed-size-list' && array.child.kind === 'primitive') {
+        const logical = (array.offset || 0) + index;
+        const stride = array.child.stride || 1;
+        const scalarOffset = (array.child.offset || 0) + logical * array.size * stride;
+        const x = Number(array.child.values[scalarOffset]);
+        const y = Number(array.child.values[scalarOffset + stride]);
+        const third = array.size > 2 ? Number(array.child.values[scalarOffset + 2 * stride]) : undefined;
+        const fourth = array.size > 3 ? Number(array.child.values[scalarOffset + 3 * stride]) : undefined;
+        builder.writeCoordinateFromDimension(x, y, dimension === 'xyz' || dimension === 'xyzm' ? third : undefined, dimension === 'xym' ? third : fourth, dimension);
+        return;
+    }
+    if (array.kind === 'struct') {
+        const logical = (array.offset || 0) + index;
+        const read = (name) => {
+            const child = array.children[name];
+            return child?.kind === 'primitive'
+                ? Number(child.values[(child.offset || 0) + logical * (child.stride || 1)])
+                : undefined;
+        };
+        builder.writeCoordinateFromDimension(read('x'), read('y'), read('z'), read('m'), dimension);
+        return;
+    }
+    throw new Error('Invalid GeoArrow coordinate storage');
+}
+function requireListRange(array, index) {
+    if (array.kind !== 'list')
+        throw new Error('Invalid GeoArrow list storage');
+    return getListRange(array, index);
+}
+function canPromoteEncoding(source, target) {
+    return (source === target ||
+        (source === 'geoarrow.point' && target === 'geoarrow.multipoint') ||
+        (source === 'geoarrow.linestring' && target === 'geoarrow.multilinestring') ||
+        (source === 'geoarrow.polygon' && target === 'geoarrow.multipolygon'));
+}
+function isConcreteEncoding(encoding) {
+    return (encoding === 'geoarrow.point' ||
+        encoding === 'geoarrow.linestring' ||
+        encoding === 'geoarrow.polygon' ||
+        encoding === 'geoarrow.multipoint' ||
+        encoding === 'geoarrow.multilinestring' ||
+        encoding === 'geoarrow.multipolygon');
+}
+function getCanonicalTypeId(encoding, dimension) {
+    const families = [
+        'point',
+        'linestring',
+        'polygon',
+        'multipoint',
+        'multilinestring',
+        'multipolygon',
+        'geometrycollection'
+    ];
+    const dimensions = ['xy', 'xyz', 'xym', 'xyzm'];
+    const family = encoding.replace('geoarrow.', '');
+    const familyIndex = families.indexOf(family);
+    const dimensionIndex = dimensions.indexOf(dimension);
+    return familyIndex < 0 || dimensionIndex < 0 ? 1 : familyIndex * 4 + dimensionIndex + 1;
+}
+function getColumnOffsetType(column) {
+    for (const chunk of column.chunks) {
+        const found = findOffsetType(chunk);
+        if (found)
+            return found;
+    }
+    return 'int32';
+}
+function findOffsetType(array) {
+    switch (array.kind) {
+        case 'list':
+        case 'serialized':
+            return array.offsets instanceof BigInt64Array ? 'int64' : 'int32';
+        case 'fixed-size-list':
+            return findOffsetType(array.child);
+        case 'struct': {
+            for (const child of Object.values(array.children)) {
+                const found = findOffsetType(child);
+                if (found)
+                    return found;
+            }
+            return null;
+        }
+        case 'dense-union':
+            for (const child of array.children) {
+                const found = findOffsetType(child.data);
+                if (found)
+                    return found;
+            }
+            return null;
+        default:
+            return null;
+    }
+}
+function convertArrayOffsets(array, offsetType) {
+    const toOffsets = (offsets, offsetBase) => {
+        if (offsetType === 'int64') {
+            const result = new BigInt64Array(offsets.length);
+            for (let index = 0; index < offsets.length; index++)
+                result[index] = BigInt(offsets[index]);
+            return { offsets: result, ...(offsetBase === undefined ? {} : { offsetBase }) };
+        }
+        const result = new Int32Array(offsets.length);
+        const base = BigInt(offsetBase ?? 0);
+        for (let index = 0; index < offsets.length; index++) {
+            const value = BigInt(offsets[index]) - base;
+            if (value < -2147483648n || value > 2147483647n) {
+                throw new Error('GeoArrow offset cannot be represented as Int32');
+            }
+            result[index] = Number(value);
+        }
+        return { offsets: result, offsetBase: 0 };
+    };
+    switch (array.kind) {
+        case 'list':
+            if (array.offsets instanceof (offsetType === 'int64' ? BigInt64Array : Int32Array)) {
+                return { ...array, child: convertArrayOffsets(array.child, offsetType) };
+            }
+            return {
+                ...array,
+                ...toOffsets(array.offsets, array.offsetBase),
+                child: convertArrayOffsets(array.child, offsetType)
+            };
+        case 'serialized':
+            if (array.offsets instanceof (offsetType === 'int64' ? BigInt64Array : Int32Array))
+                return array;
+            return { ...array, ...toOffsets(array.offsets, array.offsetBase) };
+        case 'fixed-size-list':
+            return { ...array, child: convertArrayOffsets(array.child, offsetType) };
+        case 'struct':
+            return {
+                ...array,
+                children: Object.fromEntries(Object.entries(array.children).map(([name, child]) => [
+                    name,
+                    convertArrayOffsets(child, offsetType)
+                ]))
+            };
+        case 'dense-union':
+            return {
+                ...array,
+                children: array.children.map(child => ({
+                    ...child,
+                    data: convertArrayOffsets(child.data, offsetType)
+                }))
+            };
+        default:
+            return array;
+    }
+}
+function getGeoArrowGeometryTypeName(encoding) {
+    return getGeoArrowGeometryType(encoding) || encoding.replace('geoarrow.', '');
+}
+function rewindArrayRings(array, encoding, outerClockwise) {
+    if (encoding === 'geoarrow.geometry' && array.kind === 'dense-union') {
+        let changed = false;
+        for (const child of array.children) {
+            if (rewindArrayRings(child.data, child.encoding || getEncodingFromChildName(child.name), outerClockwise))
+                changed = true;
+        }
+        return changed;
+    }
+    if (encoding === 'geoarrow.geometrycollection' && array.kind === 'list') {
+        if (array.child.kind !== 'dense-union')
+            return false;
+        let changed = false;
+        for (const child of array.child.children) {
+            if (rewindArrayRings(child.data, child.encoding || getEncodingFromChildName(child.name), outerClockwise))
+                changed = true;
+        }
+        return changed;
+    }
+    if (encoding !== 'geoarrow.polygon' && encoding !== 'geoarrow.multipolygon')
+        return false;
+    if (array.kind !== 'list' || array.child.kind !== 'list')
+        return false;
+    let changed = false;
+    for (let rowIndex = 0; rowIndex < array.length; rowIndex++) {
+        if (!isGeoArrowValueValid(array.validity, rowIndex))
+            continue;
+        const [, rowEnd] = getListRange(array, rowIndex);
+        const rowStart = getListRange(array, rowIndex)[0];
+        if (encoding === 'geoarrow.polygon') {
+            const rings = array.child;
+            if (rewindRingGroup(rings, rowStart, rowEnd, outerClockwise))
+                changed = true;
+        }
+        else {
+            const polygons = array.child;
+            for (let polygonIndex = rowStart; polygonIndex < rowEnd; polygonIndex++) {
+                const [ringStart, ringEnd] = getListRange(polygons, polygonIndex);
+                if (rewindRingGroup(polygons.child, ringStart, ringEnd, outerClockwise))
+                    changed = true;
+            }
+        }
+    }
+    return changed;
+}
+function rewindRingGroup(rings, firstRing, lastRing, outerClockwise) {
+    if (rings.kind !== 'list')
+        return false;
+    const leaf = rings.child;
+    if (leaf.kind !== 'fixed-size-list' && leaf.kind !== 'struct')
+        return false;
+    let changed = false;
+    for (let ringIndex = firstRing; ringIndex < lastRing; ringIndex++) {
+        const [first, last] = getListRange(rings, ringIndex);
+        const area = getRingArea(leaf, first, last);
+        if (!Number.isFinite(area) || area === 0)
+            continue;
+        const shouldClockwise = ringIndex === firstRing ? outerClockwise : !outerClockwise;
+        if (area < 0 !== shouldClockwise) {
+            reverseCoordinateRange(leaf, first, last);
+            changed = true;
+        }
+    }
+    return changed;
+}
+function getRingArea(leaf, first, last) {
+    let area = 0;
+    for (let index = first; index < last; index++) {
+        const current = readCoordinateAt(leaf, index);
+        const next = readCoordinateAt(leaf, index + 1 < last ? index + 1 : first);
+        if (!current || !next)
+            return Number.NaN;
+        area += current[0] * next[1] - next[0] * current[1];
+    }
+    return area / 2;
+}
+function reverseCoordinateRange(leaf, first, last) {
+    const values = [];
+    for (let index = first; index < last; index++)
+        values.push(readCoordinateAt(leaf, index));
+    values.reverse();
+    for (let index = first; index < last; index++)
+        writeCoordinateAt(leaf, index, values[index - first]);
+}
+function writeCoordinateAt(array, index, coordinate) {
+    if (array.kind === 'fixed-size-list' && array.child.kind === 'primitive') {
+        const logical = (array.offset || 0) + index;
+        for (let component = 0; component < array.size; component++) {
+            const scalar = (array.child.offset || 0) + logical * array.size + component;
+            array.child.values[scalar] = coordinate[component];
+        }
+    }
+    else if (array.kind === 'struct') {
+        const logical = (array.offset || 0) + index;
+        const names = ['x', 'y', 'z', 'm'];
+        for (let component = 0; component < names.length; component++) {
+            const child = array.children[names[component]];
+            if (child?.kind === 'primitive')
+                child.values[(child.offset || 0) + logical * (child.stride || 1)] = coordinate[component];
+        }
+    }
+}
+function collectCoordinateLeaves(column) {
+    const leaves = [];
+    for (const chunk of column.chunks)
+        collectArrayCoordinateLeaves(chunk, leaves);
+    return leaves;
+}
+function collectArrayCoordinateLeaves(array, leaves) {
+    switch (array.kind) {
+        case 'primitive':
+            if (array.values instanceof Float32Array || array.values instanceof Float64Array) {
+                leaves.push(array.values);
+            }
+            break;
+        case 'fixed-size-list':
+        case 'list':
+            collectArrayCoordinateLeaves(array.child, leaves);
+            break;
+        case 'struct':
+            for (const name of ['x', 'y', 'z', 'm']) {
+                const child = array.children[name];
+                if (child)
+                    collectArrayCoordinateLeaves(child, leaves);
+            }
+            break;
+        case 'dense-union':
+            for (const child of array.children)
+                collectArrayCoordinateLeaves(child.data, leaves);
+            break;
+        default:
+            break;
+    }
+}
+function getArrayDepth(array) {
+    switch (array.kind) {
+        case 'list':
+        case 'fixed-size-list':
+            return 1 + getArrayDepth(array.child);
+        case 'struct':
+            return 1 + Math.max(0, ...Object.values(array.children).map(getArrayDepth));
+        case 'dense-union':
+            return 1 + Math.max(0, ...array.children.map(child => getArrayDepth(child.data)));
+        default:
+            return 1;
+    }
+}
+//# sourceMappingURL=kernels.js.map