@osmix/core 0.0.2 → 0.0.6

package/dist/{src → core/src}/typed-arrays.js

@@ -1,34 +1,70 @@
+/**
+ * Resizable typed array utilities.
+ *
+ * Wraps typed arrays with automatic buffer expansion (ArrayList semantics).
+ * Uses SharedArrayBuffer (if available) for zero-copy worker transfer.
+ *
+ * @module
+ */
 /**
  * Use SharedArrayBuffer if the runtime supports it, otherwise fall back to ArrayBuffer.
+ * SharedArrayBuffer enables zero-copy transfer between workers.
  */
 export const BufferConstructor = typeof SharedArrayBuffer !== "undefined"
     ? SharedArrayBuffer
     : ArrayBuffer;
 /**
- * OSM IDs can be stored as 64-bit floating point numbers.
+ * Float64Array for storing OSM IDs.
+ *
+ * OSM IDs are 64-bit integers. JavaScript's number type (IEEE 754 double)
+ * can exactly represent integers up to 2^53, which covers all current OSM IDs.
+ * Float64Array allows typed array operations while maintaining precision.
  */
 export const IdArrayType = Float64Array;
 /**
- * When we are storing coordinates, we need to be able to store 64-bit floating point numbers.
- * However, for benchmarking it is handy to test 32-bit floating point numbers.
- */
-export const CoordinateArrayType = Float64Array;
-/**
- * When we are storing indexes into other arrays, we never need an index to exceed 2^32.
+ * Uint32Array for storing array indices.
+ *
+ * Internal indices into typed arrays never exceed 2^32 elements,
+ * so Uint32Array provides the best balance of range and memory efficiency.
  */
 export const IndexArrayType = Uint32Array;
 /**
- * Default buffer size.
+ * Initial buffer size for ResizeableTypedArray.
+ * 1 MiB provides reasonable initial capacity while avoiding excessive memory allocation.
  */
 export const DEFAULT_BUFFER_SIZE = 2 ** 20; // 1 MiB
+/**
+ * Auto-expanding typed array wrapper.
+ *
+ * - `push()` appends elements, doubling buffer size as needed.
+ * - `compact()` shrinks buffer to fit data.
+ * - Supports growable SharedArrayBuffer and resizable ArrayBuffer.
+ */
 export class ResizeableTypedArray {
+    /** The typed array constructor for this instance */
     ArrayType;
+    /** The current typed array view into the buffer */
     array;
+    /** Number of items actually stored (may be less than array.length) */
     items = 0;
+    /** The underlying ArrayBuffer or SharedArrayBuffer */
     buffer;
+    /** Current buffer size in bytes */
     bufferSize;
+    /** Maximum byte length for growable buffers */
     maxByteLength;
+    /** Buffer constructor (SharedArrayBuffer or ArrayBuffer) */
     BC;
+    /**
+     * Reconstruct a ResizeableTypedArray from an existing buffer.
+     *
+     * Used after transferring buffers between workers. The resulting array
+     * is considered "compacted" with items = array.length.
+     *
+     * @param ArrayType - The typed array constructor.
+     * @param buffer - The existing buffer to wrap.
+     * @returns A new ResizeableTypedArray wrapping the buffer.
+     */
     static from(ArrayType, buffer) {
         const rta = new ResizeableTypedArray(ArrayType, buffer instanceof SharedArrayBuffer ? SharedArrayBuffer : ArrayBuffer);
         rta.buffer = buffer;
@@ -36,6 +72,12 @@ export class ResizeableTypedArray {
         rta.items = rta.array.length;
         return rta;
     }
+    /**
+     * Create a new ResizeableTypedArray with an empty buffer.
+     *
+     * @param ArrayType - The typed array constructor (e.g., Float64Array).
+     * @param BC - Buffer constructor to use (defaults to SharedArrayBuffer if available).
+     */
     constructor(ArrayType, BC = BufferConstructor) {
         this.ArrayType = ArrayType;
         this.bufferSize = DEFAULT_BUFFER_SIZE;
@@ -46,12 +88,20 @@ export class ResizeableTypedArray {
         });
         this.array = new this.ArrayType(this.buffer);
     }
+    /**
+     * Iterate over the array values.
+     */
     [Symbol.iterator]() {
         return this.array[Symbol.iterator]();
     }
+    /**
+     * Double the buffer capacity.
+     * Uses in-place grow/resize if supported, otherwise allocates new buffer and copies.
+     */
     expandArray() {
         this.bufferSize *= 2;
         if (this.bufferSize > this.buffer.maxByteLength) {
+            // Need a completely new buffer with larger maxByteLength
             this.maxByteLength *= 2;
             const newBuffer = new this.BC(this.bufferSize, {
                 maxByteLength: this.maxByteLength,
@@ -62,6 +112,7 @@ export class ResizeableTypedArray {
             this.array = newArray;
         }
         else {
+            // Can grow/resize the existing buffer in place
             if (this.buffer instanceof SharedArrayBuffer && this.buffer.growable) {
                 this.buffer.grow(this.bufferSize);
             }
@@ -74,7 +125,7 @@ export class ResizeableTypedArray {
         }
     }
     /**
-     * Handles negative numbers
+     * Get the value at an index. Handles negative indices.
      */
     at(index) {
         if (index < -this.length || index >= this.length)
@@ -86,12 +137,18 @@ export class ResizeableTypedArray {
             throw Error(`No value at index: ${index}`);
         return result;
     }
+    /**
+     * Get a slice of the array.
+     */
     slice(start, end) {
         return this.array.slice(start, end);
     }
     get length() {
         return this.items;
     }
+    /**
+     * Push a value to the end of the array.
+     */
     push(value) {
         if (this.length >= this.array.length) {
             this.expandArray();
@@ -99,17 +156,39 @@ export class ResizeableTypedArray {
         this.array[this.items++] = value;
         return this.length - 1;
     }
+    /**
+     * Set a value at a specific index. Expands array if needed.
+     */
+    set(index, value) {
+        if (index < 0)
+            throw Error("Index out of bounds");
+        if (index >= this.length) {
+            while (index >= this.array.length)
+                this.expandArray();
+            this.items = index + 1;
+        }
+        this.array[index] = value;
+    }
+    /**
+     * Push multiple values to the end of the array.
+     */
     pushMany(values) {
         while (this.length + values.length > this.array.length)
             this.expandArray();
         this.array.set(values, this.length);
         this.items += values.length;
     }
+    /**
+     * Shrink the buffer to exactly fit stored items.
+     * Buffer becomes fixed-length after compacting.
+     */
     compact() {
         if (this.buffer instanceof SharedArrayBuffer) {
+            // SharedArrayBuffer uses slice() to create a new fixed-size buffer
             this.buffer = this.buffer.slice(0, this.length * this.ArrayType.BYTES_PER_ELEMENT);
         }
         else {
+            // ArrayBuffer uses transferToFixedLength() to detach and resize
             this.buffer = this.buffer.transferToFixedLength(this.length * this.ArrayType.BYTES_PER_ELEMENT);
         }
         this.array = new this.ArrayType(this.buffer);

package/dist/core/src/typed-arrays.js.map

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

package/dist/core/src/utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Utility functions for @osmix/core.
+ * @module
+ */
+import type { GeoBbox2D, LonLat } from "@osmix/shared/types";
+/**
+ * Compute the bounding box of a set of coordinates.
+ * Returns `[minLon, minLat, maxLon, maxLat]`.
+ */
+export declare function bboxFromLonLats(lonLats: LonLat[]): GeoBbox2D;
+//# sourceMappingURL=utils.d.ts.map

package/dist/core/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAE5D;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,SAAS,CAY5D"}

package/dist/{src → core/src}/utils.js

@@ -1,13 +1,11 @@
-export function throttle(func, timeFrame) {
-    let lastTime = 0;
-    return (...args) => {
-        const now = Date.now();
-        if (now - lastTime >= timeFrame) {
-            func(...args);
-            lastTime = now;
-        }
-    };
-}
+/**
+ * Utility functions for @osmix/core.
+ * @module
+ */
+/**
+ * Compute the bounding box of a set of coordinates.
+ * Returns `[minLon, minLat, maxLon, maxLat]`.
+ */
 export function bboxFromLonLats(lonLats) {
     let minLon = Number.POSITIVE_INFINITY;
     let minLat = Number.POSITIVE_INFINITY;

package/dist/core/src/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;;GAGG;AACH,MAAM,UAAU,eAAe,CAAC,OAAiB;IAChD,IAAI,MAAM,GAAG,MAAM,CAAC,iBAAiB,CAAA;IACrC,IAAI,MAAM,GAAG,MAAM,CAAC,iBAAiB,CAAA;IACrC,IAAI,MAAM,GAAG,MAAM,CAAC,iBAAiB,CAAA;IACrC,IAAI,MAAM,GAAG,MAAM,CAAC,iBAAiB,CAAA;IACrC,KAAK,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,OAAO,EAAE,CAAC;QAClC,IAAI,GAAG,GAAG,MAAM;YAAE,MAAM,GAAG,GAAG,CAAA;QAC9B,IAAI,GAAG,GAAG,MAAM;YAAE,MAAM,GAAG,GAAG,CAAA;QAC9B,IAAI,GAAG,GAAG,MAAM;YAAE,MAAM,GAAG,GAAG,CAAA;QAC9B,IAAI,GAAG,GAAG,MAAM;YAAE,MAAM,GAAG,GAAG,CAAA;IAC/B,CAAC;IACD,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AACxC,CAAC"}

package/dist/core/src/ways.d.ts

@@ -0,0 +1,101 @@
+import type { OsmPbfWay } from "@osmix/pbf";
+import type { GeoBbox2D, LonLat, OsmTags, OsmWay } from "@osmix/shared/types";
+import Flatbush from "flatbush";
+import { Entities, type EntitiesTransferables } from "./entities";
+import { type IdOrIndex } from "./ids";
+import type { Nodes } from "./nodes";
+import type StringTable from "./stringtable";
+import { type BufferType } from "./typed-arrays";
+export interface WaysTransferables<T extends BufferType = BufferType> extends EntitiesTransferables<T> {
+    refStart: T;
+    refCount: T;
+    refs: T;
+    bbox: T;
+    /** Optional - can be rebuilt via buildSpatialIndex() */
+    spatialIndex?: T;
+}
+export declare class Ways extends Entities<OsmWay> {
+    private spatialIndex;
+    private spatialIndexBuilt;
+    private refStart;
+    private refCount;
+    private refs;
+    private bbox;
+    private nodes;
+    /**
+     * Create a new Ways index.
+     */
+    constructor(stringTable: StringTable, nodes: Nodes, transferables?: WaysTransferables);
+    /**
+     * Add a single way to the index.
+     */
+    addWay(way: OsmWay): number;
+    /**
+     * Bulk add ways directly from a PBF PrimitiveBlock.
+     */
+    addWays(ways: OsmPbfWay[], blockStringIndexMap: Uint32Array, filter?: (way: OsmWay) => OsmWay | null): number;
+    /**
+     * Compact the internal arrays to free up memory.
+     */
+    buildEntityIndex(): void;
+    /**
+     * Build the spatial index for ways.
+     * If bbox data already exists (e.g., loaded from storage), reuses it.
+     */
+    buildSpatialIndex(): Flatbush;
+    /**
+     * Check if the spatial index has been built.
+     */
+    hasSpatialIndex(): boolean;
+    /**
+     * Get the full way entity.
+     */
+    getFullEntity(index: number, id: number, tags?: OsmTags): OsmWay;
+    /**
+     * Get the node IDs referenced by a way.
+     */
+    getRefIds(index: number): number[];
+    /**
+     * Get the bounding box of a way.
+     */
+    getEntityBbox(idOrIndex: IdOrIndex): GeoBbox2D;
+    /**
+     * Get the coordinates of a way as a flat array.
+     */
+    getLine(index: number): Float64Array<ArrayBuffer>;
+    /**
+     * Get the coordinates of a way as an array of [lon, lat] pairs.
+     */
+    getCoordinates(index: number): LonLat[];
+    /**
+     * Find way indexes that intersect a bounding box.
+     */
+    intersects(bbox: GeoBbox2D, filterFn?: (index: number) => boolean): number[];
+    /**
+     * Find way indexes near a point using great-circle distance.
+     * @param lon - Longitude in degrees.
+     * @param lat - Latitude in degrees.
+     * @param maxResults - Maximum number of results to return.
+     * @param maxDistanceKm - Maximum distance in kilometers.
+     * @returns Array of way indexes sorted by distance.
+     */
+    neighbors(lon: number, lat: number, maxResults?: number, maxDistanceKm?: number): number[];
+    /**
+     * Get ways within a bounding box.
+     */
+    withinBbox(bbox: GeoBbox2D, include?: (index: number) => boolean): {
+        ids: Float64Array;
+        positions: Float64Array;
+        startIndices: Uint32Array;
+    };
+    /**
+     * Get transferable objects for passing to another thread.
+     * Only includes spatialIndex if it has been built.
+     */
+    transferables(): WaysTransferables;
+    /**
+     * Get the approximate memory requirements for a given number of ways in bytes.
+     */
+    static getBytesRequired(count: number): number;
+}
+//# sourceMappingURL=ways.d.ts.map

package/dist/core/src/ways.d.ts.map

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

package/dist/core/src/ways.js

@@ -0,0 +1,336 @@
+import Flatbush from "flatbush";
+import { around as geoAround } from "geoflatbush";
+import { Entities } from "./entities";
+import { Ids } from "./ids";
+import { Tags } from "./tags";
+import { BufferConstructor, IdArrayType, ResizeableTypedArray as RTA, } from "./typed-arrays";
+export class Ways extends Entities {
+    spatialIndex = new Flatbush(1);
+    // Track if spatial index was properly built (vs default empty)
+    spatialIndexBuilt = false;
+    refStart;
+    refCount; // Maximum 2,000 nodes per way
+    // Node IDs
+    refs;
+    // Bounding box of the way in geographic coordinates
+    bbox;
+    // Node reference index
+    nodes;
+    /**
+     * Create a new Ways index.
+     */
+    constructor(stringTable, nodes, transferables) {
+        if (transferables) {
+            super("way", new Ids(transferables), new Tags(stringTable, transferables));
+            this.refStart = RTA.from(Uint32Array, transferables.refStart);
+            this.refCount = RTA.from(Uint16Array, transferables.refCount);
+            this.refs = RTA.from(IdArrayType, transferables.refs);
+            this.bbox = RTA.from(Float64Array, transferables.bbox);
+            // Only load spatial index if provided (not stored in IndexedDB)
+            if (transferables.spatialIndex?.byteLength) {
+                this.spatialIndex = Flatbush.from(transferables.spatialIndex);
+                this.spatialIndexBuilt = true;
+            }
+            this.indexBuilt = true;
+        }
+        else {
+            super("way", new Ids(), new Tags(stringTable));
+            this.refStart = new RTA(Uint32Array);
+            this.refCount = new RTA(Uint16Array);
+            this.refs = new RTA(IdArrayType);
+            this.bbox = new RTA(Float64Array);
+        }
+        this.nodes = nodes;
+    }
+    /**
+     * Add a single way to the index.
+     */
+    addWay(way) {
+        const wayIndex = this.addEntity(way.id, way.tags ?? {});
+        this.refStart.push(this.refs.length);
+        this.refCount.push(way.refs.length);
+        for (const ref of way.refs)
+            this.refs.push(ref);
+        return wayIndex;
+    }
+    /**
+     * Bulk add ways directly from a PBF PrimitiveBlock.
+     */
+    addWays(ways, blockStringIndexMap, filter) {
+        let added = 0;
+        for (const way of ways) {
+            let prevRefId = 0;
+            const refs = way.refs.map((refId) => {
+                prevRefId += refId;
+                return prevRefId;
+            });
+            const filteredWay = filter
+                ? filter({
+                    id: way.id,
+                    refs,
+                    tags: this.tags.getTagsFromIndices(way.keys, way.vals),
+                })
+                : null;
+            if (filter && filteredWay === null)
+                continue;
+            const tagKeys = way.keys.map((key) => {
+                const index = blockStringIndexMap[key];
+                if (index === undefined)
+                    throw Error("Tag key not found");
+                return index;
+            });
+            const tagValues = way.vals.map((val) => {
+                const index = blockStringIndexMap[val];
+                if (index === undefined)
+                    throw Error("Tag value not found");
+                return index;
+            });
+            this.addEntity(way.id, tagKeys, tagValues);
+            this.refStart.push(this.refs.length);
+            this.refCount.push(filteredWay?.refs.length ?? refs.length);
+            this.refs.pushMany(filteredWay?.refs ?? refs);
+            added++;
+        }
+        return added;
+    }
+    /**
+     * Compact the internal arrays to free up memory.
+     */
+    buildEntityIndex() {
+        this.refStart.compact();
+        this.refCount.compact();
+        this.refs.compact();
+    }
+    /**
+     * Build the spatial index for ways.
+     * If bbox data already exists (e.g., loaded from storage), reuses it.
+     */
+    buildSpatialIndex() {
+        if (!this.nodes.isReady())
+            throw Error("Node index is not ready.");
+        if (this.size === 0)
+            return this.spatialIndex;
+        console.time("WayIndex.buildSpatialIndex");
+        this.spatialIndex = new Flatbush(this.size, 128, Float64Array, BufferConstructor);
+        // If bbox already has data (loaded from storage), use it directly
+        const hasBboxData = this.bbox.length >= this.size * 4;
+        for (let i = 0; i < this.size; i++) {
+            let minX;
+            let minY;
+            let maxX;
+            let maxY;
+            if (hasBboxData) {
+                // Use stored bbox values
+                minX = this.bbox.at(i * 4);
+                minY = this.bbox.at(i * 4 + 1);
+                maxX = this.bbox.at(i * 4 + 2);
+                maxY = this.bbox.at(i * 4 + 3);
+            }
+            else {
+                // Calculate bbox from node coordinates
+                minX = Number.POSITIVE_INFINITY;
+                minY = Number.POSITIVE_INFINITY;
+                maxX = Number.NEGATIVE_INFINITY;
+                maxY = Number.NEGATIVE_INFINITY;
+                const start = this.refStart.at(i);
+                const count = this.refCount.at(i);
+                for (let j = start; j < start + count; j++) {
+                    const refId = this.refs.at(j);
+                    const [lon, lat] = this.nodes.getNodeLonLat({ id: refId });
+                    if (lon < minX)
+                        minX = lon;
+                    if (lon > maxX)
+                        maxX = lon;
+                    if (lat < minY)
+                        minY = lat;
+                    if (lat > maxY)
+                        maxY = lat;
+                }
+                this.bbox.push(minX);
+                this.bbox.push(minY);
+                this.bbox.push(maxX);
+                this.bbox.push(maxY);
+            }
+            this.spatialIndex.add(minX, minY, maxX, maxY);
+        }
+        // Compact bbox if we just calculated it
+        if (!hasBboxData) {
+            this.bbox.compact();
+        }
+        this.spatialIndex.finish();
+        this.spatialIndexBuilt = true;
+        console.timeEnd("WayIndex.buildSpatialIndex");
+        return this.spatialIndex;
+    }
+    /**
+     * Check if the spatial index has been built.
+     */
+    hasSpatialIndex() {
+        return this.spatialIndexBuilt;
+    }
+    /**
+     * Get the full way entity.
+     */
+    getFullEntity(index, id, tags) {
+        return {
+            id,
+            refs: [...this.getRefIds(index)],
+            tags,
+        };
+    }
+    /**
+     * Get the node IDs referenced by a way.
+     */
+    getRefIds(index) {
+        const start = this.refStart.at(index);
+        const count = this.refCount.at(index);
+        return Array.from(this.refs.slice(start, start + count));
+    }
+    /**
+     * Get the bounding box of a way.
+     */
+    getEntityBbox(idOrIndex) {
+        const index = "index" in idOrIndex ? idOrIndex.index : this.ids.idOrIndex(idOrIndex)[0];
+        return [
+            this.bbox.at(index * 4),
+            this.bbox.at(index * 4 + 1),
+            this.bbox.at(index * 4 + 2),
+            this.bbox.at(index * 4 + 3),
+        ];
+    }
+    /**
+     * Get the coordinates of a way as a flat array.
+     */
+    getLine(index) {
+        const count = this.refCount.at(index);
+        const start = this.refStart.at(index);
+        const line = new Float64Array(count * 2);
+        for (let i = 0; i < count; i++) {
+            const ref = this.refs.at(start + i);
+            const [lon, lat] = this.nodes.getNodeLonLat({ id: ref });
+            line[i * 2] = lon;
+            line[i * 2 + 1] = lat;
+        }
+        return line;
+    }
+    /**
+     * Get the coordinates of a way as an array of [lon, lat] pairs.
+     */
+    getCoordinates(index) {
+        const count = this.refCount.at(index);
+        const start = this.refStart.at(index);
+        const coords = [];
+        for (let refIndex = start; refIndex < start + count; refIndex++) {
+            const ref = this.refs.at(refIndex);
+            const coord = this.nodes.getNodeLonLat({ id: ref });
+            if (coord === undefined ||
+                coord[0] === undefined ||
+                coord[1] === undefined) {
+                console.error("node index has ref", this.nodes.ids.has(ref));
+                throw Error(`Invalid coordinate for way id ${this.ids.at(index)}, index ${index}, node ref ${ref}, ref index ${refIndex}`);
+            }
+            coords.push(coord);
+        }
+        return coords;
+    }
+    /**
+     * Find way indexes that intersect a bounding box.
+     */
+    intersects(bbox, filterFn) {
+        if (this.size === 0)
+            return [];
+        return this.spatialIndex.search(bbox[0], bbox[1], bbox[2], bbox[3], filterFn);
+    }
+    /**
+     * Find way indexes near a point using great-circle distance.
+     * @param lon - Longitude in degrees.
+     * @param lat - Latitude in degrees.
+     * @param maxResults - Maximum number of results to return.
+     * @param maxDistanceKm - Maximum distance in kilometers.
+     * @returns Array of way indexes sorted by distance.
+     */
+    neighbors(lon, lat, maxResults, maxDistanceKm) {
+        if (this.size === 0)
+            return [];
+        // Use geoflatbush for proper geographic distance calculations
+        return geoAround(this.spatialIndex, lon, lat, maxResults, maxDistanceKm);
+    }
+    /**
+     * Get ways within a bounding box.
+     */
+    withinBbox(bbox, include) {
+        console.time("Ways.withinBbox");
+        const wayCandidates = this.intersects(bbox, include);
+        const ids = new Float64Array(wayCandidates.length);
+        const wayPositions = [];
+        const wayStartIndices = new Uint32Array(wayCandidates.length + 1);
+        wayStartIndices[0] = 0;
+        console.time("Ways.withinBbox.loop");
+        let size = 0;
+        wayCandidates.forEach((wayIndex, i) => {
+            ids[i] = this.ids.at(wayIndex);
+            const way = this.getLine(wayIndex);
+            size += way.length;
+            wayPositions.push(way);
+            const prevIndex = wayStartIndices[i];
+            if (prevIndex === undefined)
+                throw Error("Previous index is undefined");
+            wayStartIndices[i + 1] = prevIndex + way.length / 2;
+        });
+        console.timeEnd("Ways.withinBbox.loop");
+        const wayPositionsArray = new Float64Array(size);
+        let pIndex = 0;
+        for (const way of wayPositions) {
+            wayPositionsArray.set(way, pIndex);
+            pIndex += way.length;
+        }
+        console.timeEnd("Ways.withinBbox");
+        return {
+            ids,
+            positions: wayPositionsArray,
+            startIndices: wayStartIndices,
+        };
+    }
+    /**
+     * Get transferable objects for passing to another thread.
+     * Only includes spatialIndex if it has been built.
+     */
+    transferables() {
+        const base = {
+            ...super.transferables(),
+            refStart: this.refStart.array.buffer,
+            refCount: this.refCount.array.buffer,
+            refs: this.refs.array.buffer,
+            bbox: this.bbox.array.buffer,
+        };
+        // Only include spatial index if it was built
+        if (this.spatialIndexBuilt) {
+            return { ...base, spatialIndex: this.spatialIndex.data };
+        }
+        return base;
+    }
+    /**
+     * Get the approximate memory requirements for a given number of ways in bytes.
+     */
+    static getBytesRequired(count) {
+        if (count === 0)
+            return 0;
+        // Approximate nodes per way
+        let numNodes = count;
+        let n = count;
+        while (n !== 1) {
+            n = Math.ceil(n / 128);
+            numNodes += n;
+        }
+        const indexBytes = (numNodes < 16384 ? 2 : 4) * numNodes;
+        const boxesBytes = numNodes * 4 * Float64Array.BYTES_PER_ELEMENT;
+        const spatialIndexBytes = 8 + indexBytes + boxesBytes;
+        return (Ids.getBytesRequired(count) +
+            Tags.getBytesRequired(count) +
+            count * Uint32Array.BYTES_PER_ELEMENT + // refStart
+            count * Uint16Array.BYTES_PER_ELEMENT + // refCount
+            count * 4 * Float64Array.BYTES_PER_ELEMENT + // bbox
+            spatialIndexBytes);
+    }
+}
+//# sourceMappingURL=ways.js.map