@math.gl/geoarrow 5.0.0-alpha.2

package/LICENSE

@@ -0,0 +1,140 @@
+MIT License
+
+Copyright (c) 2017 Uber Technologies, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---
+
+Some primitive tessellation approaches were originally inspired by the TDL WebGL samples under
+the New BSD License:
+
+Copyright (c) 2011, Google Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted
+provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions
+   and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice, this list of
+   conditions and the following disclaimer in the documentation and/or other materials provided
+   with the distribution.
+3. Neither the name of Google Inc. nor the names of its contributors may be used to endorse or
+   promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+---
+
+math.gl builds on docs and code from "gl-matrix", which is MIT licensed as follows:
+
+Copyright (c) 2015, Brandon Jones, Colin MacKenzie IV.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+--
+
+math.gl builds on docs and code from THREE.js, which is MIT licensed as follows:
+
+The MIT License
+
+Copyright © 2010-2017 three.js authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---
+
+math.gl includes certain files from Cesium (https://github.com/AnalyticalGraphicsInc/cesium) under the Apache 2 License:
+
+Copyright 2011-2018 CesiumJS Contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and limitations under the License.
+
+Cesium-derived code can be found in the submodule: modules/3d-tiles
+
+---
+
+The @math.gl/geometry primitive tessellators are adapted from luma.gl under the MIT License:
+
+Copyright (c) 2020 vis.gl contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,311 @@
+# @math.gl/geoarrow
+
+Columnar geometry descriptors and synchronous CPU kernels for GeoArrow-compatible memory layouts.
+
+`@math.gl/geoarrow` works directly over borrowed typed arrays. It deliberately does not require an
+Arrow runtime: a loader, dataframe, database client, or application can adapt its buffers to the
+small descriptor ABI and use the same validation, conversion, column-codec, and tessellation
+kernels.
+
+## Install
+
+```bash
+npm install @math.gl/geoarrow
+```
+
+## Why descriptors?
+
+Columnar geometry should not need to become GeoJSON objects before useful work can begin. A
+`GeoArrowColumn` describes the physical buffers that already exist:
+
+- primitive numeric buffers;
+- interleaved fixed-size coordinate tuples or separated coordinate structs;
+- Int32 or Int64 variable-list offsets;
+- validity bitmaps with non-byte-aligned slice offsets;
+- dense unions for mixed geometry and list-of-union geometry collections;
+- binary WKB and UTF-8 WKT buffers;
+- one or more chunks.
+
+Descriptors borrow their buffers. Read-only kernels never mutate or detach them. Identity
+conversions return the original column object, so callers can use descriptor and `ArrayBuffer`
+identity as a reliable zero-copy signal.
+
+## Quick start
+
+```typescript
+import {
+  GeoArrowBuilder,
+  getGeoArrowBounds,
+  getGeoArrowVertexCount,
+  mapGeoArrowCoordinates
+} from '@math.gl/geoarrow';
+
+const column = GeoArrowBuilder.build(
+  [
+    {type: 'LineString', coordinates: [[-122.4, 37.8], [-73.9, 40.7]]},
+    null
+  ],
+  {
+    encoding: 'geoarrow.linestring',
+    dimension: 'xy',
+    coordinateLayout: 'interleaved',
+    offsetType: 'int32'
+  }
+);
+
+getGeoArrowVertexCount(column); // 2
+getGeoArrowBounds(column); // [-122.4, 37.8, -73.9, 40.7]
+
+const shifted = mapGeoArrowCoordinates(column, ([x, y]) => [x + 360, y]);
+```
+
+## Physical nesting
+
+`coord` below is either an interleaved `fixed-size-list` or a separated `struct`.
+
+| Encoding | Physical descriptor tree |
+| --- | --- |
+| Point | `coord` |
+| LineString | `list<coord>` |
+| MultiPoint | `list<coord>` |
+| Polygon | `list<list<coord>>` |
+| MultiLineString | `list<list<coord>>` |
+| MultiPolygon | `list<list<list<coord>>>` |
+| Geometry | `dense-union<geometry children>` |
+| GeometryCollection | `list<dense-union<geometry children>>` |
+| Box | `struct<minimum and maximum ordinates>` |
+| WKB | `serialized<binary>` |
+| WKT | `serialized<utf8>` |
+
+This example describes two XY points without copying the source coordinates:
+
+```typescript
+import type {GeoArrowColumn} from '@math.gl/geoarrow';
+
+const values = new Float64Array([10, 20, 30, 40]);
+const points: GeoArrowColumn = {
+  encoding: 'geoarrow.point',
+  dimension: 'xy',
+  coordinateLayout: 'interleaved',
+  chunks: [{
+    kind: 'fixed-size-list',
+    length: 2,
+    size: 2,
+    child: {kind: 'primitive', length: 4, values}
+  }]
+};
+```
+
+For separated coordinates, use canonical ordinate names. `x` and `y` are always present; `z` and
+`m` follow the semantic dimension and are never treated as interchangeable.
+
+```typescript
+const separatedPoints: GeoArrowColumn = {
+  encoding: 'geoarrow.point',
+  dimension: 'xym',
+  coordinateLayout: 'separated',
+  chunks: [{
+    kind: 'struct',
+    length: 2,
+    children: {
+      x: {kind: 'primitive', length: 2, values: new Float64Array([10, 30])},
+      y: {kind: 'primitive', length: 2, values: new Float64Array([20, 40])},
+      m: {kind: 'primitive', length: 2, values: new Float64Array([100, 200])}
+    }
+  }]
+};
+```
+
+## Slices, validity, and chunks
+
+Every physical descriptor has a logical `length` and may have a validity bitmap. A set bit means
+valid. `bitOffset` makes sliced null bitmaps explicit, including slices that do not begin at a byte
+boundary.
+
+Variable-width descriptors have an `offset` into their offsets buffer and an optional `offsetBase`.
+The child range for row `i` is:
+
+```text
+[offsets[offset + i] - offsetBase, offsets[offset + i + 1] - offsetBase)
+```
+
+Both `Int32Array` and `BigInt64Array` offsets are supported. Int64 values are checked before
+conversion to JavaScript numbers; values outside the safe integer range are rejected.
+
+`sliceGeoArrowColumn` creates zero-copy descriptor views and preserves chunk boundaries.
+`validateGeoArrowColumn` checks physical bounds, validity coverage, monotonic offsets, coordinate
+layout, list depth, and dense-union dispatch before an expensive operation is attempted.
+
+## Two-pass building
+
+`GeoArrowBuilder` has a measure pass and a write pass. This avoids growing arrays and lets an owner
+allocate buffers in a pool, shared arena, or renderer-specific allocator.
+
+```typescript
+const rows = [
+  {type: 'Polygon' as const, coordinates: [[[0, 0], [4, 0], [0, 4], [0, 0]]]},
+  null
+];
+const options = {
+  encoding: 'geoarrow.polygon' as const,
+  dimension: 'xy' as const,
+  coordinateLayout: 'separated' as const,
+  offsetType: 'int64' as const
+};
+
+const measure = new GeoArrowBuilder({...options, mode: 'measure'});
+rows.forEach(row => measure.append(row));
+
+const target = measure.allocateTarget();
+const write = new GeoArrowBuilder({...options, mode: 'write', target});
+rows.forEach(row => write.append(row));
+
+const polygons = write.finish(); // borrows target; no Arrow objects are constructed
+```
+
+`GeoArrowBuilder.build(rows, options)` is the convenient form when custom allocation is not needed.
+
+## Inspection and read-only kernels
+
+The following operations traverse descriptors directly and do not create per-row geometry objects:
+
+- `inspectGeoArrowColumn`
+- `validateGeoArrowColumn`
+- `getGeoArrowVertexCount`
+- `getGeoArrowBounds`
+- `visitGeoArrowCoordinates`
+- `getGeoArrowTransferList`
+
+Allocating transforms such as coordinate mapping, physical conversion, winding normalization, and
+codec decoding return new descriptors. Their inputs remain unchanged.
+
+## Conversion and winding
+
+```typescript
+import {
+  convertGeoArrowColumn,
+  interleaveGeoArrowCoordinates,
+  rewindGeoArrow
+} from '@math.gl/geoarrow';
+
+const interleaved = interleaveGeoArrowCoordinates(separatedPoints);
+const xyz = convertGeoArrowColumn(interleaved, {dimension: 'xyz'});
+const normalized = rewindGeoArrow(polygons, {outer: 'counter-clockwise'});
+```
+
+Semantic dimensions are mapped by ordinate name. Converting XYM to XYZ produces a zero Z; it does
+not reinterpret M as elevation. Requesting `geoarrow.geometry` always produces a dense union, even
+when every current row has the same geometry family.
+
+## WKB and WKT
+
+The codecs consume and produce the same plain descriptors:
+
+```typescript
+import {
+  decodeGeoArrowWKB,
+  encodeGeoArrowWKB,
+  decodeGeoArrowWKT,
+  encodeGeoArrowWKT
+} from '@math.gl/geoarrow';
+
+const wkb = encodeGeoArrowWKB(polygons);
+const decoded = decodeGeoArrowWKB(wkb);
+const wkt = encodeGeoArrowWKT(decoded);
+const nativeAgain = decodeGeoArrowWKT(wkt);
+```
+
+WKB decoding accepts little- or big-endian geometry, ISO Z/M/ZM type offsets, EWKB Z/M/SRID flags,
+multi-geometries, and nested geometry collections. WKT supports all corresponding geometry
+families, dimension tokens, both MultiPoint spellings, and empties. Decoding normalizes mixed-size
+serialized coordinates to the column's declared semantic dimension.
+
+Parsing or formatting one geometry is intentionally provided by the dependency-free
+`@math.gl/wkb` package:
+
+```typescript
+import {parseWKB, writeWKB, parseWKT, formatWKT} from '@math.gl/wkb';
+```
+
+`@math.gl/geoarrow` depends on `@math.gl/wkb`; the format package never depends on GeoArrow or
+Apache Arrow.
+
+## Polygon tessellation
+
+```typescript
+import {tessellateGeoArrowPolygons} from '@math.gl/geoarrow';
+
+const mesh = tessellateGeoArrowPolygons(polygons, {
+  positionSize: 3,
+  sourceRowOffset: 1000
+});
+
+// mesh.positions        Float32Array
+// mesh.sourceRowIndices Uint32Array
+// mesh.indices          Uint16Array or Uint32Array
+```
+
+Polygon, MultiPolygon, and polygon members of dense unions or geometry collections are supported.
+Holes are retained, duplicate closing coordinates are omitted from mesh vertices, and every output
+vertex retains its top-level source row. Tessellation uses `@math.gl/polygon` and is synchronous.
+
+## Resource limits
+
+Potentially allocating operations accept limits, and limits can also be checked directly:
+
+```typescript
+import {assertGeoArrowResourceLimits} from '@math.gl/geoarrow';
+
+assertGeoArrowResourceLimits(column, {
+  maximumRows: 1_000_000,
+  maximumCoordinates: 50_000_000,
+  maximumChunks: 10_000,
+  maximumNestingDepth: 8,
+  maximumOutputBytes: 1_000_000_000
+});
+```
+
+## Workers and transfer ownership
+
+Root APIs are synchronous. Worker-specific payload preparation is isolated in the optional subpath:
+
+```typescript
+import {prepareGeoArrowTransfer} from '@math.gl/geoarrow/worker';
+
+const payload = prepareGeoArrowTransfer(column);
+worker.postMessage(payload.column, {transfer: payload.transferList});
+```
+
+`prepareGeoArrowTransfer` only lists unique transferable buffers; it does not detach them. The
+explicit `postMessage` call transfers ownership. Shared buffers are omitted because they are not
+transferable.
+
+## Adapting another columnar runtime
+
+Keep runtime-specific objects at the boundary. Read their physical buffers and construct a
+`GeoArrowColumn`; do not call scalar `get(row)` methods. The adapter should preserve:
+
+1. chunk boundaries and logical lengths;
+2. typed-array byte offsets and strides;
+3. list offsets, including 64-bit offsets;
+4. validity bitmap plus bit offset;
+5. dense-union type IDs, value offsets, and child names;
+6. extension encoding, semantic dimension, coordinate layout, CRS, and edge metadata.
+
+Run `validateGeoArrowColumn` once at the trust boundary. Downstream math then remains independent of
+the producer runtime.
+
+## API groups
+
+- Descriptors: `GeoArrowColumn`, `GeoArrowArray`, all physical array descriptor types
+- Layout: `inspectGeoArrowColumn`, `validateGeoArrowColumn`, slicing and traversal
+- Kernels: count, bounds, map, interleave, convert, rewind, union normalization, resource limits
+- Construction: `GeoArrowBuilder`, `makeGeoArrowColumnFromGeometryRows`
+- Column codecs: WKB/WKT descriptor encode and decode (individual parsing/formatting is tested in
+  `@math.gl/wkb`)
+- Meshes: `tessellateGeoArrowPolygons`
+- Transfer: `getGeoArrowTransferList`, plus `@math.gl/geoarrow/worker`
+
+See the math.gl documentation for the full [physical-layout guide](../../docs/modules/geoarrow/physical-layouts.md),
+[API reference](../../docs/modules/geoarrow/api-reference/geoarrow.md), and
+[migration guide](../../docs/modules/geoarrow/migration-guide.md).

package/dist/builder.d.ts

@@ -0,0 +1,90 @@
+import type { GeoArrowColumn, GeoArrowCoordinateLayout, GeoArrowDimension, GeoArrowEncoding, GeoArrowGeometryValue, GeoArrowOffsets } from "./types.js";
+/** Concrete native encodings accepted by {@link GeoArrowBuilder}. */
+export type GeoArrowBuilderEncoding = Exclude<GeoArrowEncoding, 'geoarrow.geometry' | 'geoarrow.geometrycollection' | 'geoarrow.box' | 'geoarrow.wkb' | 'geoarrow.wkt'>;
+/** Buffer counts produced by a measure pass. */
+export type GeoArrowBuilderMeasurement = Readonly<{
+    length: number;
+    nullCount: number;
+    coordinateCount: number;
+    geometryOffsetCount: number;
+    partOffsetCount: number;
+    ringOffsetCount: number;
+}>;
+/** Caller-owned buffers filled by a builder write pass. */
+export type GeoArrowBuilderTarget = {
+    validity: Uint8Array;
+    coordinates: Float32Array | Float64Array | {
+        x: Float32Array | Float64Array;
+        y: Float32Array | Float64Array;
+        z?: Float32Array | Float64Array;
+        m?: Float32Array | Float64Array;
+    };
+    geometryOffsets?: GeoArrowOffsets;
+    partOffsets?: GeoArrowOffsets;
+    ringOffsets?: GeoArrowOffsets;
+};
+/** Common builder options. */
+export type GeoArrowBuilderOptions = Readonly<{
+    encoding: GeoArrowBuilderEncoding;
+    dimension?: GeoArrowDimension;
+    coordinateLayout?: GeoArrowCoordinateLayout;
+    offsetType?: 'int32' | 'int64';
+    coordinateType?: 'float32' | 'float64';
+}>;
+/** Options for materializing a column from geometry values. */
+export type GeoArrowColumnFromRowsOptions = Omit<GeoArrowBuilderOptions, 'encoding'> & Readonly<{
+    /** Forces homogeneous values into a dense-union column. */
+    encoding?: 'geoarrow.geometry';
+}>;
+/** Measure-pass options. */
+export type GeoArrowBuilderMeasureOptions = GeoArrowBuilderOptions & Readonly<{
+    mode: 'measure';
+}>;
+/** Write-pass options. */
+export type GeoArrowBuilderWriteOptions = GeoArrowBuilderOptions & Readonly<{
+    mode: 'write';
+    target: GeoArrowBuilderTarget;
+}>;
+/** Options accepted by the incremental builder. */
+export type GeoArrowBuilderModeOptions = GeoArrowBuilderMeasureOptions | GeoArrowBuilderWriteOptions;
+/**
+ * Two-pass writer for homogeneous native GeoArrow geometry columns.
+ *
+ * Feed the same rows to a measure builder, allocate its target, and then feed them to a write
+ * builder. The write result borrows the supplied target buffers.
+ */
+export declare class GeoArrowBuilder {
+    readonly encoding: GeoArrowBuilderEncoding;
+    readonly dimension: GeoArrowDimension;
+    readonly coordinateLayout: GeoArrowCoordinateLayout;
+    readonly offsetType: 'int32' | 'int64';
+    readonly coordinateType: 'float32' | 'float64';
+    private readonly mode;
+    private readonly target?;
+    private length;
+    private nullCount;
+    private coordinateCount;
+    private partCount;
+    private ringCount;
+    constructor(options: GeoArrowBuilderModeOptions);
+    /** Appends one geometry row or null. */
+    append(geometry: GeoArrowGeometryValue | null | undefined): this;
+    /** Returns current exact allocation counts. */
+    getMeasurement(): GeoArrowBuilderMeasurement;
+    /** Allocates a write target from the current measure pass. */
+    allocateTarget(): GeoArrowBuilderTarget;
+    /** Finishes a write pass and returns a one-chunk borrowed column. */
+    finish(): GeoArrowColumn;
+    /** Builds a homogeneous column using an internal measure/write pair. */
+    static build(rows: readonly (GeoArrowGeometryValue | null | undefined)[], options: GeoArrowBuilderOptions): GeoArrowColumn;
+    private appendNull;
+    private writeCoordinateList;
+    private writeCoordinate;
+    private writeOffset;
+    private initializeTargetOffsets;
+}
+/** Allocates exact buffers for one measured builder pass. */
+export declare function allocateGeoArrowBuilderTarget(measurement: GeoArrowBuilderMeasurement, options: GeoArrowBuilderOptions): GeoArrowBuilderTarget;
+/** Builds a concrete or dense-union column from materialized rows. */
+export declare function makeGeoArrowColumnFromGeometryRows(rows: readonly (GeoArrowGeometryValue | null)[], options?: GeoArrowColumnFromRowsOptions): GeoArrowColumn;
+//# sourceMappingURL=builder.d.ts.map

package/dist/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"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"}