whitebox-wasm 0.2.0 → 0.3.0

package/README.md

@@ -1,8 +1,14 @@
 # whitebox-wasm
 
-**Pure-Rust GeoTIFF decoding compiled to WebAssembly.** No GDAL, no PROJ, no
-native libraries, no server. Decode GeoTIFF / BigTIFF / COG entirely in the
-browser, Node, Deno, or any Wasm host.
+**Pure-Rust geospatial toolkit compiled to WebAssembly.** No GDAL, no PROJ, no
+native libraries, no server. Work with raster, vector, and LiDAR data entirely
+in the browser, Node, Deno, or any Wasm host:
+
+- **Raster** - read/write GeoTIFF / BigTIFF / COG, stats, range-request streaming
+- **Projections** - full EPSG + user-defined CRS to WGS84 lon/lat
+- **Vector** - read GeoJSON, TopoJSON, GML, GPX, KML, FlatGeobuf, GeoPackage, KMZ -> GeoJSON, with reprojection
+- **LiDAR** - read LAS / LAZ / PLY point clouds (xyz, classification, intensity)
+- **Analysis** - convex hull, Moran's I spatial autocorrelation
 
 This wraps `wbgeotiff`, the shared GeoTIFF engine from the original
 [**whitebox_next_gen**](https://github.com/jblindsay/whitebox_next_gen) project
@@ -132,6 +138,40 @@ window). Requires a tiled COG on a server that supports HTTP range requests.
 
 JSON-returning functions report failures as `{"ok":false,"error":"..."}`; class methods throw on error.
 
+## Vector
+
+```js
+import init, { vector_to_geojson, vector_info, vector_to_geojson_reproject } from "whitebox-wasm";
+await init();
+const bytes = new Uint8Array(await (await fetch("data.fgb")).arrayBuffer());
+const geojson = JSON.parse(vector_to_geojson(bytes, "flatgeobuf"));
+const meta = JSON.parse(vector_info(bytes, "flatgeobuf")); // { features, geometry, epsg, fields, bbox }
+const wgs84 = vector_to_geojson_reproject(bytes, "flatgeobuf", 4326, 0); // dst, src(0=auto)
+```
+
+- `vector_formats()` -> supported formats (geojson, topojson, gml, gpx, kml, flatgeobuf, geopackage, kmz)
+- `vector_to_geojson(data, format)` -> GeoJSON string
+- `vector_to_geojson_reproject(data, format, dst_epsg, src_epsg)` -> reprojected GeoJSON (`src_epsg=0` uses the layer CRS, or 4326)
+- `vector_info(data, format)` -> JSON `{name, features, geometry, epsg, fields, bbox}`
+
+## LiDAR
+
+```js
+import init, { lidar_info, lidar_read_xyz } from "whitebox-wasm";
+await init();
+const las = new Uint8Array(await (await fetch("cloud.laz")).arrayBuffer());
+const meta = JSON.parse(lidar_info(las, "laz")); // { points, epsg, point_format, bounds }
+const xyz = lidar_read_xyz(las, "laz");          // Float64Array [x0,y0,z0, x1,y1,z1, ...]
+```
+
+- `lidar_formats()`, `lidar_info(data, format)` (header-only count/bounds for LAS/LAZ)
+- `lidar_read_xyz` -> `Float64Array`; `lidar_read_classification` -> `Uint8Array`; `lidar_read_intensity` -> `Uint16Array`
+
+## Analysis
+
+- `convex_hull(points_xy)` -> hull ring `Float64Array` (input `[x0,y0,x1,y1,...]`)
+- `morans_i(points_xy, values, distance_threshold)` -> JSON global spatial autocorrelation `{morans_i, expected, variance, z_score, p_value, n}`
+
 ## Limits
 
 WebAssembly is 32-bit, so linear memory is capped at ~4 GiB. `geotiff_info` is
@@ -147,5 +187,5 @@ decoded in-browser). For such data, read metadata only or process server-side.
 ## License
 
 Dual-licensed under MIT or Apache-2.0, at your option. Includes the vendored
-`wbgeotiff` and `wbprojection` crates (Copyright John Lindsay, Whitebox
+`wbgeotiff`, `wbprojection`, `wbvector`, `wblidar`, `wbtopology`, `wbspatialstats`, and `wbhdf` crates (Copyright John Lindsay, Whitebox
 Geospatial Inc.), used under the same dual license.

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "whitebox-wasm",
   "type": "module",
-  "description": "WebAssembly bindings for the pure-Rust Whitebox GeoTIFF engine",
-  "version": "0.2.0",
+  "description": "Pure-Rust geospatial toolkit (raster, vector, LiDAR, projections) compiled to WebAssembly",
+  "version": "0.3.0",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",
@@ -20,10 +20,10 @@
     "./snippets/*"
   ],
   "keywords": [
-    "geotiff",
+    "geospatial",
     "wasm",
     "gis",
-    "raster",
-    "webassembly"
+    "geotiff",
+    "lidar"
   ]
 }

package/whitebox_wasm.d.ts

@@ -248,6 +248,12 @@ export class GeoTiffReader {
  */
 export function __start(): void;
 
+/**
+ * Convex hull of a 2D point set. Input is `[x0,y0,x1,y1,...]`; output is the
+ * hull ring as `[x0,y0,...]` (closed). Needs at least 3 points.
+ */
+export function convex_hull(points_xy: Float64Array): Float64Array;
+
 /**
  * Decode only a GeoTIFF's header and return its metadata as JSON. O(header)
  * memory, so it works on multi-gigabyte rasters that whole-image reads cannot
@@ -270,6 +276,75 @@ export function geotiff_read_band_f64(data: Uint8Array, band: number): Float64Ar
  */
 export function geotiff_stats(data: Uint8Array): string;
 
+/**
+ * LiDAR formats this build can read from memory.
+ */
+export function lidar_formats(): string;
+
+/**
+ * Read a LiDAR file's metadata as JSON without loading all points where
+ * possible (LAS/LAZ report count and bounds from the header):
+ * `{"ok":true,"format","points","epsg"|null,"point_format"|null,
+ *   "bounds":[min_x,min_y,min_z,max_x,max_y,max_z]|null}`.
+ */
+export function lidar_info(data: Uint8Array, format: string): string;
+
+/**
+ * Read per-point classification codes as a `Uint8Array` (length `point_count`).
+ */
+export function lidar_read_classification(data: Uint8Array, format: string): Uint8Array;
+
+/**
+ * Read per-point intensity as a `Uint16Array` (length `point_count`).
+ */
+export function lidar_read_intensity(data: Uint8Array, format: string): Uint16Array;
+
+/**
+ * Read all point coordinates as an interleaved `Float64Array`
+ * `[x0,y0,z0, x1,y1,z1, ...]` (length `3 * point_count`).
+ *
+ * Guarded against 32-bit memory blowup; very large clouds return a clean error
+ * (read the header with `lidar_info`, or downsample on your side).
+ */
+export function lidar_read_xyz(data: Uint8Array, format: string): Float64Array;
+
+/**
+ * Global Moran's I spatial autocorrelation for point data, using a binary
+ * distance-band spatial weights matrix (neighbors within `distance_threshold`).
+ *
+ * `points_xy` is `[x0,y0,...]`, `values` is one value per point. Returns JSON:
+ * `{"ok":true,"morans_i","expected","variance","z_score","p_value","n"}`.
+ *
+ * Builds neighbors in O(n^2); intended for up to a few thousand points.
+ */
+export function morans_i(points_xy: Float64Array, values: Float64Array, distance_threshold: number): string;
+
+/**
+ * Vector formats this build can read from memory (comma-separated).
+ */
+export function vector_formats(): string;
+
+/**
+ * Read a vector dataset and return metadata as JSON:
+ * `{"ok":true,"name","features","geometry","epsg"|null,"fields":[...],
+ *   "bbox":[min_x,min_y,max_x,max_y]|null}`.
+ */
+export function vector_info(data: Uint8Array, format: string): string;
+
+/**
+ * Read a vector dataset and return it as a GeoJSON `FeatureCollection` string.
+ */
+export function vector_to_geojson(data: Uint8Array, format: string): string;
+
+/**
+ * Read a vector dataset, reproject it to `dst_epsg`, and return GeoJSON.
+ * Uses the bundled pure-Rust projection engine (full EPSG support).
+ *
+ * `src_epsg` overrides the source CRS: pass `0` to use the layer's own CRS, or
+ * fall back to EPSG:4326 if it declares none (GeoJSON is WGS84 by RFC 7946).
+ */
+export function vector_to_geojson_reproject(data: Uint8Array, format: string, dst_epsg: number, src_epsg: number): string;
+
 /**
  * Semantic version of this crate, exposed for runtime feature detection.
  */
@@ -279,6 +354,7 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
+    readonly __start: () => void;
     readonly __wbg_cogbuilder_free: (a: number, b: number) => void;
     readonly __wbg_cogstream_free: (a: number, b: number) => void;
     readonly __wbg_geotiffreader_free: (a: number, b: number) => void;
@@ -307,6 +383,7 @@ export interface InitOutput {
     readonly cogstream_num_levels: (a: number) => number;
     readonly cogstream_tile_range: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly cogstream_tiles_for_window: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly convex_hull: (a: number, b: number, c: number) => void;
     readonly geotiff_info: (a: number, b: number, c: number) => void;
     readonly geotiff_read_band_f64: (a: number, b: number, c: number, d: number) => void;
     readonly geotiff_stats: (a: number, b: number, c: number) => void;
@@ -338,8 +415,25 @@ export interface InitOutput {
     readonly geotiffreader_stats_json: (a: number, b: number) => void;
     readonly geotiffreader_value_transform: (a: number, b: number) => void;
     readonly geotiffreader_width: (a: number) => number;
+    readonly lidar_formats: (a: number) => void;
+    readonly lidar_info: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly lidar_read_classification: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly lidar_read_intensity: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly lidar_read_xyz: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly morans_i: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly vector_formats: (a: number) => void;
+    readonly vector_info: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly vector_to_geojson: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly vector_to_geojson_reproject: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly version: (a: number) => void;
-    readonly __start: () => void;
+    readonly rust_zstd_wasm_shim_calloc: (a: number, b: number) => number;
+    readonly rust_zstd_wasm_shim_free: (a: number) => void;
+    readonly rust_zstd_wasm_shim_malloc: (a: number) => number;
+    readonly rust_zstd_wasm_shim_memcmp: (a: number, b: number, c: number) => number;
+    readonly rust_zstd_wasm_shim_memcpy: (a: number, b: number, c: number) => number;
+    readonly rust_zstd_wasm_shim_memmove: (a: number, b: number, c: number) => number;
+    readonly rust_zstd_wasm_shim_memset: (a: number, b: number, c: number) => number;
+    readonly rust_zstd_wasm_shim_qsort: (a: number, b: number, c: number, d: number) => void;
     readonly __wbindgen_export: (a: number, b: number, c: number) => void;
     readonly __wbindgen_export2: (a: number, b: number) => number;
     readonly __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;

package/whitebox_wasm.js

@@ -989,6 +989,33 @@ export function __start() {
     wasm.__start();
 }
 
+/**
+ * Convex hull of a 2D point set. Input is `[x0,y0,x1,y1,...]`; output is the
+ * hull ring as `[x0,y0,...]` (closed). Needs at least 3 points.
+ * @param {Float64Array} points_xy
+ * @returns {Float64Array}
+ */
+export function convex_hull(points_xy) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArrayF64ToWasm0(points_xy, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.convex_hull(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v2 = getArrayF64FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export(r0, r1 * 8, 8);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Decode only a GeoTIFF's header and return its metadata as JSON. O(header)
  * memory, so it works on multi-gigabyte rasters that whole-image reads cannot
@@ -1071,6 +1098,332 @@ export function geotiff_stats(data) {
     }
 }
 
+/**
+ * LiDAR formats this build can read from memory.
+ * @returns {string}
+ */
+export function lidar_formats() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.lidar_formats(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred1_0 = r0;
+        deferred1_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * Read a LiDAR file's metadata as JSON without loading all points where
+ * possible (LAS/LAZ report count and bounds from the header):
+ * `{"ok":true,"format","points","epsg"|null,"point_format"|null,
+ *   "bounds":[min_x,min_y,min_z,max_x,max_y,max_z]|null}`.
+ * @param {Uint8Array} data
+ * @param {string} format
+ * @returns {string}
+ */
+export function lidar_info(data, format) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.lidar_info(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Read per-point classification codes as a `Uint8Array` (length `point_count`).
+ * @param {Uint8Array} data
+ * @param {string} format
+ * @returns {Uint8Array}
+ */
+export function lidar_read_classification(data, format) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.lidar_read_classification(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v3 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export(r0, r1 * 1, 1);
+        return v3;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Read per-point intensity as a `Uint16Array` (length `point_count`).
+ * @param {Uint8Array} data
+ * @param {string} format
+ * @returns {Uint16Array}
+ */
+export function lidar_read_intensity(data, format) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.lidar_read_intensity(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v3 = getArrayU16FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export(r0, r1 * 2, 2);
+        return v3;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Read all point coordinates as an interleaved `Float64Array`
+ * `[x0,y0,z0, x1,y1,z1, ...]` (length `3 * point_count`).
+ *
+ * Guarded against 32-bit memory blowup; very large clouds return a clean error
+ * (read the header with `lidar_info`, or downsample on your side).
+ * @param {Uint8Array} data
+ * @param {string} format
+ * @returns {Float64Array}
+ */
+export function lidar_read_xyz(data, format) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.lidar_read_xyz(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v3 = getArrayF64FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export(r0, r1 * 8, 8);
+        return v3;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Global Moran's I spatial autocorrelation for point data, using a binary
+ * distance-band spatial weights matrix (neighbors within `distance_threshold`).
+ *
+ * `points_xy` is `[x0,y0,...]`, `values` is one value per point. Returns JSON:
+ * `{"ok":true,"morans_i","expected","variance","z_score","p_value","n"}`.
+ *
+ * Builds neighbors in O(n^2); intended for up to a few thousand points.
+ * @param {Float64Array} points_xy
+ * @param {Float64Array} values
+ * @param {number} distance_threshold
+ * @returns {string}
+ */
+export function morans_i(points_xy, values, distance_threshold) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArrayF64ToWasm0(points_xy, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(values, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.morans_i(retptr, ptr0, len0, ptr1, len1, distance_threshold);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Vector formats this build can read from memory (comma-separated).
+ * @returns {string}
+ */
+export function vector_formats() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.vector_formats(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred1_0 = r0;
+        deferred1_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * Read a vector dataset and return metadata as JSON:
+ * `{"ok":true,"name","features","geometry","epsg"|null,"fields":[...],
+ *   "bbox":[min_x,min_y,max_x,max_y]|null}`.
+ * @param {Uint8Array} data
+ * @param {string} format
+ * @returns {string}
+ */
+export function vector_info(data, format) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.vector_info(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Read a vector dataset and return it as a GeoJSON `FeatureCollection` string.
+ * @param {Uint8Array} data
+ * @param {string} format
+ * @returns {string}
+ */
+export function vector_to_geojson(data, format) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.vector_to_geojson(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Read a vector dataset, reproject it to `dst_epsg`, and return GeoJSON.
+ * Uses the bundled pure-Rust projection engine (full EPSG support).
+ *
+ * `src_epsg` overrides the source CRS: pass `0` to use the layer's own CRS, or
+ * fall back to EPSG:4326 if it declares none (GeoJSON is WGS84 by RFC 7946).
+ * @param {Uint8Array} data
+ * @param {string} format
+ * @param {number} dst_epsg
+ * @param {number} src_epsg
+ * @returns {string}
+ */
+export function vector_to_geojson_reproject(data, format, dst_epsg, src_epsg) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.vector_to_geojson_reproject(retptr, ptr0, len0, ptr1, len1, dst_epsg, src_epsg);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred4_0, deferred4_1, 1);
+    }
+}
+
 /**
  * Semantic version of this crate, exposed for runtime feature detection.
  * @returns {string}