@recast-navigation/core 0.3.0 → 0.4.0

package/dist/nav-mesh-query.d.ts

@@ -10,37 +10,41 @@ export type NavMeshQueryParams = {
 };
 export declare class NavMeshQuery {
     raw: R.NavMeshQuery;
-    private tmpVec1;
-    private tmpVec2;
-    constructor({ navMesh, maxNodes }: NavMeshQueryParams);
+    defaultFilter: R.dtQueryFilter;
+    defaultQueryHalfExtents: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    constructor(value: R.NavMeshQuery | NavMeshQueryParams);
+    findNearestPoly(position: Vector3, halfExtents: Vector3, filter?: R.dtQueryFilter): {
+        status: number;
+        nearestRef: number;
+        nearestPoint: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        isOverPoly: boolean;
+    };
     /**
      * Returns the closest point on the NavMesh to the given position.
      */
-    getClosestPoint(position: Vector3): Vector3;
+    getClosestPoint(position: Vector3, filter?: R.dtQueryFilter): Vector3;
     /**
      * Returns a random point on the NavMesh within the given radius of the given position.
      */
-    getRandomPointAround(position: Vector3, radius: number): Vector3;
+    getRandomPointAround(position: Vector3, radius: number, filter?: R.dtQueryFilter): Vector3;
     /**
      * Compute the final position from a segment made of destination-position
      */
-    moveAlong(position: Vector3, destination: Vector3): Vector3;
+    moveAlong(position: Vector3, destination: Vector3, filter?: R.dtQueryFilter): Vector3;
     /**
      * Finds a path from the start position to the end position.
      *
      * @returns an array of Vector3 positions that make up the path, or an empty array if no path was found.
      */
-    computePath(start: Vector3, end: Vector3): Vector3[];
-    /**
-     * Gets the Bounding box extent specified by setDefaultQueryExtent
-     */
-    getDefaultQueryExtent(): Vector3;
-    /**
-     * Sets the Bounding box extent for doing spatial queries (getClosestPoint, getRandomPointAround, ...)
-     * The queries will try to find a solution within those bounds.
-     * The default is (1,1,1)
-     */
-    setDefaultQueryExtent(extent: Vector3): void;
+    computePath(start: Vector3, end: Vector3, filter?: R.dtQueryFilter): Vector3[];
     /**
      * Destroys the NavMeshQuery instance
      */

package/dist/nav-mesh.d.ts

@@ -1,10 +1,10 @@
 import type R from '@recast-navigation/wasm';
 import { Vector3 } from './utils';
-import { dtMeshTile, dtPoly, dtOffMeshConnection } from './wrappers';
+import { DetourMeshTile, dtPoly, DetourOffMeshConnection } from './detour';
 export declare class NavMeshGetTilesAtResult {
     raw: R.NavMeshGetTilesAtResult;
     constructor(raw: R.NavMeshGetTilesAtResult);
-    tiles(index: number): dtMeshTile;
+    tiles(index: number): DetourMeshTile;
     tileCount(): number;
     destroy(): void;
 }
@@ -32,7 +32,7 @@ export declare class NavMeshCalcTileLocResult {
 export declare class NavMeshGetTileAndPolyByRefResult {
     raw: R.NavMeshGetTileAndPolyByRefResult;
     constructor(raw: R.NavMeshGetTileAndPolyByRefResult);
-    tile(): dtMeshTile;
+    tile(): DetourMeshTile;
     poly(): dtPoly;
     status(): number;
     destroy(): void;
@@ -83,27 +83,24 @@ export declare class NavMesh {
     constructor(raw?: R.NavMesh);
     /**
      * Initializes the NavMesh for use with a single tile.
-     * @param data the nav mesh data
-     * @param dataSize the size of the nav mesh data
-     * @param flags the flags to use when building the nav mesh
+     * @param navMeshData the nav mesh data
      * @returns the status of the operation
      */
-    initSolo(data: ReadonlyArray<number>, dataSize: number, flags: number): boolean;
+    initSolo(navMeshData: R.NavMeshData): boolean;
     /**
      * Initializes the NavMesh for use with multiple tiles.
      * @param params parameters for the NavMesh
      * @returns the status of the operation
      */
-    initTiled({ orig, tileWidth, tileHeight, maxTiles, maxPolys, }: NavMeshParams): boolean;
+    initTiled(params: R.dtNavMeshParams): boolean;
     /**
      * Adds a tile to the NavMesh.
-     * @param data the nav mesh data
-     * @param dataSize the size of the nav mesh data
+     * @param navMeshData the nav mesh data
      * @param flags the flags to use when building the nav mesh
      * @param lastRef
      * @returns the status of the operation and the reference of the added tile
      */
-    addTile(data: number[], dataSize: number, flags: number, lastRef: number): NavMeshAddTileResult;
+    addTile(navMeshData: R.NavMeshData, flags: number, lastRef: number): NavMeshAddTileResult;
     /**
      * Removes a tile from the NavMesh
      * @param ref the tile ref
@@ -123,7 +120,7 @@ export declare class NavMesh {
      * @param layer The tile's layer. (x, y, layer)
      * @returns The tile, or null if the tile does not exist.
      */
-    getTileAt(x: number, y: number, layer: number): dtMeshTile | null;
+    getTileAt(x: number, y: number, layer: number): DetourMeshTile | null;
     /**
      * Gets all tiles at the specified grid location. (All layers.)
      * @param x The tile's x-location. (x, y)
@@ -144,13 +141,13 @@ export declare class NavMesh {
      * @param tile
      * @returns
      */
-    getTileRef(tile: dtMeshTile): number;
+    getTileRef(tile: DetourMeshTile): number;
     /**
      * Gets the tile for the specified tile reference.
      * @param ref The tile reference of the tile to retrieve.
      * @returns The tile for the specified reference, or null if the reference is invalid.
      */
-    getTileByRef(ref: number): dtMeshTile | null;
+    getTileByRef(ref: number): DetourMeshTile | null;
     /**
      * Returns the maximum number of tiles supported by the navigation mesh.
      */
@@ -160,7 +157,7 @@ export declare class NavMesh {
      * @param i the tile index. [Limit: 0 >= index < #getMaxTiles()]
      * @returns
      */
-    getTile(i: number): dtMeshTile;
+    getTile(i: number): DetourMeshTile;
     /**
      * Gets the tile and polygon for the specified polygon reference.
      * @param ref The reference for the a polygon.
@@ -184,7 +181,7 @@ export declare class NavMesh {
      * @param tile
      * @returns
      */
-    getPolyRefBase(tile: dtMeshTile): number;
+    getPolyRefBase(tile: DetourMeshTile): number;
     /**
      * Gets the endpoints for an off-mesh connection, ordered by "direction of travel".
      * @param prevRef The reference of the polygon before the connection.
@@ -197,7 +194,7 @@ export declare class NavMesh {
      * @param ref The polygon reference of the off-mesh connection.
      * @returns
      */
-    getOffMeshConnectionByRef(ref: number): dtOffMeshConnection;
+    getOffMeshConnectionByRef(ref: number): DetourOffMeshConnection;
     /**
      * Sets the user defined flags for the specified polygon.
      * @param ref The polygon reference.
@@ -227,14 +224,14 @@ export declare class NavMesh {
      * @param tile
      * @returns The size of the buffer required to store the state.
      */
-    getTileStateSize(tile: dtMeshTile): number;
+    getTileStateSize(tile: DetourMeshTile): number;
     /**
      * Stores the non-structural state of the tile in the specified buffer. (Flags, area ids, etc.)
      * @param tile The tile.
      * @param maxDataSize The size of the data buffer. [Limit: >= #getTileStateSize]
      * @returns
      */
-    storeTileState(tile: dtMeshTile, maxDataSize: number): NavMeshStoreTileStateResult;
+    storeTileState(tile: DetourMeshTile, maxDataSize: number): NavMeshStoreTileStateResult;
     /**
      * Restores the state of the tile.
      * @param tile The tile.
@@ -242,7 +239,7 @@ export declare class NavMesh {
      * @param maxDataSize The size of the state within the data buffer.
      * @returns
      */
-    restoreTileState(tile: dtMeshTile, data: number[], maxDataSize: number): number;
+    restoreTileState(tile: DetourMeshTile, data: number[], maxDataSize: number): number;
     /**
      * Returns a DebugNavMesh that can be used to visualize the NavMesh.
      */

package/dist/raw.d.ts

@@ -0,0 +1,23 @@
+import Module from '@recast-navigation/wasm';
+declare const instances: readonly ["Recast", "Detour", "DetourNavMeshBuilder", "DetourTileCacheBuilder", "ChunkyTriMesh", "NavMeshImporter", "NavMeshExporter", "CrowdUtils"];
+declare const classes: readonly ["rcContext", "dtNavMeshParams", "dtNavMeshCreateParams", "RecastLinearAllocator", "RecastFastLZCompressor", "rcChunkyTriMesh", "TileCacheData", "dtTileCacheParams", "dtTileCacheLayerHeader"];
+declare const arrays: readonly ["IntArray", "UnsignedCharArray", "UnsignedShortArray", "FloatArray"];
+type RawType = {
+    Module: typeof Module;
+    Arrays: {
+        [K in typeof arrays[number]]: typeof Module[K];
+    };
+    isNull: (obj: unknown) => boolean;
+} & {
+    [K in typeof instances[number]]: InstanceType<typeof Module[K]>;
+} & {
+    [K in typeof classes[number]]: typeof Module[K];
+};
+/**
+ * Lower level bindings for the Recast and Detour libraries.
+ *
+ * The `init` function must be called before using the `Raw` api.
+ */
+export declare const Raw: RawType;
+export declare const init: () => Promise<void>;
+export {};

package/dist/recast.d.ts

@@ -0,0 +1,245 @@
+import R from '@recast-navigation/wasm';
+import { Vector3 } from './utils';
+export type RecastConfigType = {
+    /**
+     * The size of the non-navigable border around the heightfield.
+     * [Limit: >=0] [Units: vx]
+     * @default 0
+     */
+    borderSize: number;
+    /**
+     * The width/height size of tile's on the xz-plane.
+     * [Limit: >= 0] [Units: vx]
+     *
+     * If tileSize is provided, a tiled navmesh will be created.
+     * If tileSize is not provided, or is set to zero, a solo navmesh will be created.
+     *
+     * To use obstacles, a tiled navmesh must be generated.
+     * @default 0
+     */
+    tileSize: number;
+    /**
+     * The xz-plane cell size to use for fields.
+     * [Limit: > 0] [Units: wu]
+     * @default 0.2
+     */
+    cs: number;
+    /**
+     * The y-axis cell size to use for fields.
+     * Limit: > 0] [Units: wu]
+     * @default 0.2
+     */
+    ch: number;
+    /**
+     * The maximum slope that is considered walkable.
+     * [Limits: 0 <= value < 90] [Units: Degrees]
+     * @default 60
+     */
+    walkableSlopeAngle: number;
+    /**
+     * Minimum floor to 'ceiling' height that will still allow the floor area to be considered walkable.
+     * [Limit: >= 3] [Units: vx]
+     * @default 2
+     */
+    walkableHeight: number;
+    /**
+     * Maximum ledge height that is considered to still be traversable.
+     * [Limit: >=0] [Units: vx]
+     * @default 2
+     */
+    walkableClimb: number;
+    /**
+     * The distance to erode/shrink the walkable area of the heightfield away from obstructions.
+     * [Limit: >=0] [Units: vx]
+     * @default 0.5
+     */
+    walkableRadius: number;
+    /**
+     * The maximum allowed length for contour edges along the border of the mesh.
+     * [Limit: >=0] [Units: vx]
+     * @default 12
+     */
+    maxEdgeLen: number;
+    /**
+     * The maximum distance a simplfied contour's border edges should deviate the original raw contour.
+     * [Limit: >=0] [Units: vx]
+     * @default 1.3
+     */
+    maxSimplificationError: number;
+    /**
+     * The minimum number of cells allowed to form isolated island areas.
+     * [Limit: >=0] [Units: vx]
+     * @default 8
+     */
+    minRegionArea: number;
+    /**
+     * Any regions with a span count smaller than this value will, if possible, be merged with larger regions.
+     * [Limit: >=0] [Units: vx]
+     * @default 20
+     */
+    mergeRegionArea: number;
+    /**
+     * The maximum number of vertices allowed for polygons generated during the be merged with larger regions.
+     * [Limit: >=0] [Units: vx]
+     * @default 6
+     */
+    maxVertsPerPoly: number;
+    /**
+     * Sets the sampling distance to use when generating the detail mesh. (For height detail only.)
+     * [Limits: 0 or >= 0.9] [Units: wu]
+     * @default 6
+     */
+    detailSampleDist: number;
+    /**
+     * The maximum distance the detail mesh surface should deviate from heightfield data. (For height detail only.)
+     * [Limit: >=0] [Units: wu]
+     * @default 1
+     */
+    detailSampleMaxError: number;
+};
+export declare const recastConfigDefaults: RecastConfigType;
+export declare class RecastConfig {
+    raw: R.rcConfig;
+    constructor(raw: R.rcConfig);
+    static create(partialConfig: Partial<RecastConfigType>): RecastConfig;
+    clone(): RecastConfig;
+}
+export declare class RecastSpan {
+    raw: R.rcSpan;
+    constructor(raw: R.rcSpan);
+    smin(): number;
+    smax(): number;
+    area(): number;
+    next(): RecastSpan | null;
+}
+export declare class RecastSpanPool {
+    raw: R.rcSpanPool;
+    constructor(raw: R.rcSpanPool);
+    next(): RecastSpanPool | null;
+    items(index: number): RecastSpan;
+}
+export declare class RecastHeightfield {
+    raw: R.rcHeightfield;
+    constructor(raw: R.rcHeightfield);
+    width(): number;
+    height(): number;
+    bmin(): Vector3;
+    bmax(): Vector3;
+    cs(): number;
+    ch(): number;
+    spans(index: number): RecastSpan;
+    pools(index: number): RecastSpanPool;
+    freelist(index: number): RecastSpan;
+}
+export declare class RecastCompactCell {
+    raw: R.rcCompactCell;
+    constructor(raw: R.rcCompactCell);
+    index(): number;
+    count(): number;
+}
+export declare class RecastCompactSpan {
+    raw: R.rcCompactSpan;
+    constructor(raw: R.rcCompactSpan);
+    y(): number;
+    reg(): number;
+    con(): number;
+    h(): number;
+}
+export declare class RecastCompactHeightfield {
+    raw: R.rcCompactHeightfield;
+    constructor(raw: R.rcCompactHeightfield);
+    width(): number;
+    height(): number;
+    spanCount(): number;
+    walkableHeight(): number;
+    walkableClimb(): number;
+    borderSize(): number;
+    maxDistance(): number;
+    maxRegions(): number;
+    bmin(): Vector3;
+    bmax(): Vector3;
+    cs(): number;
+    ch(): number;
+    cells(index: number): RecastCompactCell;
+    spans(index: number): RecastCompactSpan;
+    dist(index: number): number;
+    areas(index: number): number;
+}
+export declare class RecastContour {
+    raw: R.rcContour;
+    constructor(raw: R.rcContour);
+    verts(index: number): number;
+    nverts(): number;
+    rverts(index: number): number;
+    nrverts(): number;
+    reg(): number;
+    area(): number;
+}
+export declare class RecastContourSet {
+    raw: R.rcContourSet;
+    constructor(raw: R.rcContourSet);
+    conts(index: number): RecastContour;
+    nconts(): number;
+    bmin(): Vector3;
+    bmax(): Vector3;
+    cs(): number;
+    ch(): number;
+    width(): number;
+    height(): number;
+    borderSize(): number;
+    maxError(): number;
+}
+export declare class RecastHeightfieldLayer {
+    raw: R.rcHeightfieldLayer;
+    constructor(raw: R.rcHeightfieldLayer);
+    bmin(): Vector3;
+    bmax(): Vector3;
+    cs(): number;
+    ch(): number;
+    width(): number;
+    height(): number;
+    minx(): number;
+    maxx(): number;
+    miny(): number;
+    maxy(): number;
+    hmin(): number;
+    hmax(): number;
+    heights(index: number): number;
+    areas(index: number): number;
+    cons(index: number): number;
+}
+export declare class RecastHeightfieldLayerSet {
+    raw: R.rcHeightfieldLayerSet;
+    constructor(raw: R.rcHeightfieldLayerSet);
+    layers(index: number): RecastHeightfieldLayer;
+    nlayers(): number;
+}
+export declare class RecastPolyMesh {
+    raw: R.rcPolyMesh;
+    constructor(raw: R.rcPolyMesh);
+    verts(index: number): number;
+    polys(index: number): number;
+    regs(index: number): number;
+    flags(index: number): number;
+    areas(index: number): number;
+    nverts(): number;
+    npolys(): number;
+    maxpolys(): number;
+    nvp(): number;
+    bmin(): Vector3;
+    bmax(): Vector3;
+    cs(): number;
+    ch(): number;
+    borderSize(): number;
+    maxEdgeError(): number;
+}
+export declare class RecastPolyMeshDetail {
+    raw: R.rcPolyMeshDetail;
+    constructor(raw: R.rcPolyMeshDetail);
+    meshes(index: number): number;
+    verts(index: number): number;
+    tris(index: number): number;
+    nmeshes(): number;
+    nverts(): number;
+    ntris(): number;
+}

package/dist/serdes/export-nav-mesh.d.ts

@@ -0,0 +1,3 @@
+import { NavMesh } from '../nav-mesh';
+import { TileCache } from '../tile-cache';
+export declare const exportNavMesh: (navMesh: NavMesh, tileCache?: TileCache) => Uint8Array;

package/dist/serdes/import-nav-mesh.d.ts

@@ -0,0 +1,12 @@
+import type R from '@recast-navigation/wasm';
+import { NavMesh } from '../nav-mesh';
+import { TileCache, TileCacheMeshProcess } from '../tile-cache';
+export type NavMeshImporterResult = {
+    navMesh: NavMesh;
+} | {
+    navMesh: NavMesh;
+    tileCache: TileCache;
+    allocator: R.RecastLinearAllocator;
+    compressor: R.RecastFastLZCompressor;
+};
+export declare const importNavMesh: (data: Uint8Array, tileCacheMeshProcess: TileCacheMeshProcess) => NavMeshImporterResult;

package/dist/serdes/index.d.ts

@@ -0,0 +1,2 @@
+export * from './export-nav-mesh';
+export * from './import-nav-mesh';

package/dist/tile-cache.d.ts

@@ -1,7 +1,22 @@
 import type R from '@recast-navigation/wasm';
 import { NavMesh } from './nav-mesh';
-import { BoxObstacle, CylinderObstacle, Obstacle, ObstacleRef } from './obstacle';
 import { Vector3 } from './utils';
+export type ObstacleRef = R.dtObstacleRef;
+export type BoxObstacle = {
+    type: 'box';
+    ref: ObstacleRef;
+    position: Vector3;
+    extent: Vector3;
+    angle: number;
+};
+export type CylinderObstacle = {
+    type: 'cylinder';
+    ref: ObstacleRef;
+    position: Vector3;
+    radius: number;
+    height: number;
+};
+export type Obstacle = BoxObstacle | CylinderObstacle;
 export type TileCacheParams = {
     orig: ReadonlyArray<number>;
     cs: number;
@@ -15,6 +30,11 @@ export type TileCacheParams = {
     maxTiles: number;
     maxObstacles: number;
 };
+export declare class dtTileCacheParams {
+    raw: R.dtTileCacheParams;
+    constructor(raw: R.dtTileCacheParams);
+    static create(config: TileCacheParams): dtTileCacheParams;
+}
 export type TileCacheUpdateResult = {
     status: number;
     upToDate: boolean;
@@ -27,7 +47,7 @@ export declare class TileCache {
      * Initialises the TileCache
      * @param params
      */
-    init(params: TileCacheParams): void;
+    init(params: R.dtTileCacheParams, alloc: R.RecastLinearAllocator, compressor: R.RecastFastLZCompressor, meshProcess: TileCacheMeshProcess): boolean;
     /**
      * Updates the tile cache by rebuilding tiles touched by unfinished obstacle requests.
      * This should be called after adding or removing obstacles.
@@ -45,5 +65,12 @@ export declare class TileCache {
      * Removes an obstacle from the navigation mesh.
      */
     removeObstacle(obstacle: Obstacle | ObstacleRef): void;
+    addTile(data: R.TileCacheData, flags?: number): R.TileCacheAddTileResult;
+    buildNavMeshTile(ref: R.dtCompressedTileRef, navMesh: NavMesh): number;
+    buildNavMeshTilesAt(tx: number, ty: number, navMesh: NavMesh): number;
     destroy(): void;
 }
+export declare class TileCacheMeshProcess {
+    raw: R.TileCacheMeshProcess;
+    constructor(process: (navMeshCreateParams: R.dtNavMeshCreateParams, polyAreasArray: R.UnsignedCharArray, polyFlagsArray: R.UnsignedShortArray) => void);
+}

package/dist/utils.d.ts

@@ -1,9 +1,4 @@
 import type R from '@recast-navigation/wasm';
-export declare const emscripten: {
-    isNull: (obj: unknown) => boolean;
-    getPointer: (obj: unknown) => number;
-    destroy: (obj: unknown) => void;
-};
 export type Vector3 = {
     x: number;
     y: number;

package/package.json

@@ -6,7 +6,7 @@
     "email": "isaac@isaacmason.com",
     "url": "https://isaacmason.com/"
   },
-  "version": "0.3.0",
+  "version": "0.4.0",
   "license": "MIT",
   "homepage": "https://github.com/isaac-mason/recast-navigation-js",
   "bugs": {
@@ -25,32 +25,32 @@
     "test": "vitest run"
   },
   "devDependencies": {
-    "@babel/core": "^7.18.6",
-    "@recast-navigation/wasm": "0.3.0",
+    "@babel/core": "^7.22.5",
+    "@recast-navigation/wasm": "0.4.0",
     "@rollup/plugin-commonjs": "^24.0.1",
     "@rollup/plugin-node-resolve": "^15.0.1",
-    "@rollup/plugin-terser": "^0.4.0",
-    "@rollup/plugin-typescript": "^11.0.0",
-    "@types/three": "^0.150.0",
+    "@rollup/plugin-terser": "^0.4.3",
+    "@rollup/plugin-typescript": "^11.1.2",
+    "@types/three": "^0.155.0",
     "@typescript-eslint/eslint-plugin": "^5.7.0",
-    "@typescript-eslint/parser": "^5.7.0",
+    "@typescript-eslint/parser": "^5.60.1",
     "babel-loader": "^8.2.5",
     "eslint": "^8.5.0",
     "eslint-config-airbnb": "^18.2.1",
-    "eslint-config-airbnb-base": "^14.2.1",
+    "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-import-resolver-typescript": "^3.5.5",
     "eslint-plugin-es": "^4.1.0",
-    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-import": "^2.28.0",
     "eslint-plugin-prettier": "^4.0.0",
     "eslint-plugin-simple-import-sort": "^10.0.0",
     "eslint-plugin-typescript-enum": "^2.1.0",
     "prettier": "^2.3.2",
-    "rollup": "^3.20.0",
+    "rollup": "^3.26.3",
     "rollup-plugin-copy": "^3.4.0",
     "rollup-plugin-filesize": "^10.0.0",
-    "typescript": "^5.1.3",
-    "vitest": "^0.32.0"
+    "typescript": "^5.1.6",
+    "vitest": "^0.33.0"
   },
   "packageManager": "yarn@3.2.1"
 }

package/dist/dt-status.d.ts

@@ -1,18 +0,0 @@
-export declare class DtStatus {
-    static get FAILURE(): number;
-    static get SUCCESS(): number;
-    static get IN_PROGRESS(): number;
-    static get STATUS_DETAIL_MASK(): number;
-    static get WRONG_MAGIC(): number;
-    static get WRONG_VERSION(): number;
-    static get OUT_OF_MEMORY(): number;
-    static get INVALID_PARAM(): number;
-    static get BUFFER_TOO_SMALL(): number;
-    static get OUT_OF_NODES(): number;
-    static get PARTIAL_RESULT(): number;
-    static get ALREADY_OCCUPIED(): number;
-    static statusSucceed(status: number): boolean;
-    static statusFailed(status: number): boolean;
-    static statusInProgress(status: number): boolean;
-    static statusDetail(status: number, detail: number): boolean;
-}

package/dist/nav-mesh-builder.d.ts

@@ -1,41 +0,0 @@
-import type R from '@recast-navigation/wasm';
-export type CreateNavMeshDataParams = {
-    verts: number[];
-    vertCount: number;
-    polys: number[];
-    polyFlags: number[];
-    polyAreas: number[];
-    polyCount: number;
-    nvp: number;
-    detailMeshes: number[];
-    detailVerts: number[];
-    detailVertsCount: number;
-    detailTris: number[];
-    detailTriCount: number;
-    offMeshConVerts: number[];
-    offMeshConRad: number[];
-    offMeshConFlags: number[];
-    offMeshConAreas: number[];
-    offMeshConDir: number[];
-    offMeshConUserID: number[];
-    offMeshConCount: number;
-    userId: number;
-    tileX: number;
-    tileY: number;
-    tileLayer: number;
-    bmin: number[];
-    bmax: number[];
-    walkableHeight: number;
-    walkableRadius: number;
-    walkableClimb: number;
-    cs: number;
-    ch: number;
-    buildBvTree: boolean;
-};
-export type CreateNavMeshDataResult = R.CreateNavMeshDataResult;
-export declare class NavMeshBuilder {
-    raw: R.NavMeshBuilder;
-    constructor();
-    createNavMeshData(params: CreateNavMeshDataParams): CreateNavMeshDataResult;
-    destroy(): void;
-}

package/dist/nav-mesh-exporter.d.ts

@@ -1,13 +0,0 @@
-import type R from '@recast-navigation/wasm';
-import { NavMesh } from './nav-mesh';
-import { TileCache } from './tile-cache';
-export declare class NavMeshExporter {
-    raw: R.NavMeshExporter;
-    constructor();
-    /**
-     * Returns a NavMesh export that can be used later. The NavMesh must be built before retrieving the data
-     * @returns data the Uint8Array that can be saved and reused
-     */
-    export(navMesh: NavMesh, tileCache?: TileCache): Uint8Array;
-    destroy(): void;
-}