@recast-navigation/core 0.0.0-canary-20261030-064e4acc

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright © 2025 Isaac Mason
+
+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,3 @@
+# @recast-navigation/core
+
+This package contains the the core functionality for `recast-navigation`. Please refer to the [main package's README](https://github.com/isaac-mason/recast-navigation-js/tree/main/packages/recast-navigation/README.md) for usage information.

package/dist/arrays.d.ts

@@ -0,0 +1,86 @@
+import { type RawModule } from './raw';
+declare abstract class BaseArray<RawType extends RawModule.IntArray | RawModule.UnsignedIntArray | RawModule.UnsignedCharArray | RawModule.UnsignedShortArray | RawModule.FloatArray, TypedArrayType extends Int32Array | Uint32Array | Uint8Array | Uint16Array | Float32Array> {
+    raw: RawType;
+    get size(): number;
+    protected abstract ArrayConstructor: new (buffer: ArrayBufferLike, byteOffset: number, length: number) => TypedArrayType;
+    constructor(raw: RawType);
+    get(i: number): number;
+    set(i: number, value: number): void;
+    resize(size: number): void;
+    copy(data: TypedArrayType | number[]): void;
+    destroy(): void;
+    getHeapView(): TypedArrayType;
+    toTypedArray(): TypedArrayType;
+    protected abstract getHeap(): TypedArrayType;
+}
+export declare class IntArray extends BaseArray<RawModule.IntArray, Int32Array> {
+    protected ArrayConstructor: Int32ArrayConstructor;
+    /**
+     * Creates a new IntArray.
+     */
+    constructor();
+    /**
+     * Creates a wrapper around an existing raw IntArray object.
+     */
+    constructor(raw: RawModule.IntArray);
+    protected getHeap(): Int32Array;
+    static fromRaw(raw: RawModule.IntArray): IntArray;
+}
+export declare class UnsignedIntArray extends BaseArray<RawModule.UnsignedIntArray, Uint32Array> {
+    protected ArrayConstructor: Uint32ArrayConstructor;
+    /**
+     * Creates a new UnsignedIntArray.
+     */
+    constructor();
+    /**
+     * Creates a wrapper around an existing raw UnsignedIntArray object.
+     */
+    constructor(raw: RawModule.UnsignedIntArray);
+    protected getHeap(): Uint32Array;
+    static fromRaw(raw: RawModule.UnsignedIntArray): UnsignedIntArray;
+}
+export declare class UnsignedCharArray extends BaseArray<RawModule.UnsignedCharArray, Uint8Array> {
+    protected ArrayConstructor: Uint8ArrayConstructor;
+    /**
+     * Creates a new UnsignedCharArray.
+     */
+    constructor();
+    /**
+     * Creates a wrapper around an existing raw UnsignedCharArray object.
+     */
+    constructor(raw: RawModule.UnsignedCharArray);
+    protected getHeap(): Uint8Array;
+    static fromRaw(raw: RawModule.UnsignedCharArray): UnsignedCharArray;
+}
+export declare class UnsignedShortArray extends BaseArray<RawModule.UnsignedShortArray, Uint16Array> {
+    protected ArrayConstructor: Uint16ArrayConstructor;
+    /**
+     * Creates a new UnsignedShortArray.
+     */
+    constructor();
+    /**
+     * Creates a wrapper around an existing raw UnsignedShortArray object.
+     */
+    constructor(raw: RawModule.UnsignedShortArray);
+    protected getHeap(): Uint16Array;
+    static fromRaw(raw: RawModule.UnsignedShortArray): UnsignedShortArray;
+}
+export declare class FloatArray extends BaseArray<RawModule.FloatArray, Float32Array> {
+    protected ArrayConstructor: Float32ArrayConstructor;
+    /**
+     * Creates a new FloatArray.
+     */
+    constructor();
+    /**
+     * Creates a wrapper around an existing raw FloatArray object.
+     */
+    constructor(raw: RawModule.FloatArray);
+    protected getHeap(): Float32Array;
+    static fromRaw(raw: RawModule.FloatArray): FloatArray;
+}
+export declare const VerticesArray: typeof FloatArray;
+export declare const TrianglesArray: typeof IntArray;
+export declare const TriangleAreasArray: typeof UnsignedCharArray;
+export declare const ChunkIdsArray: typeof IntArray;
+export declare const TileCacheData: typeof UnsignedCharArray;
+export {};

package/dist/crowd.d.ts

@@ -0,0 +1,297 @@
+import type { NavMesh } from './nav-mesh';
+import { NavMeshQuery, QueryFilter } from './nav-mesh-query';
+import { type RawModule } from './raw';
+import { type Vector3 } from './utils';
+export type CrowdAgentParams = {
+    /**
+     * The radius of the agent.
+     * @default 0.5
+     */
+    radius: number;
+    /**
+     * The height of the agent.
+     * @default 1
+     */
+    height: number;
+    /**
+     * The maximum allowed acceleration for the agent.
+     * @default 20
+     */
+    maxAcceleration: number;
+    /**
+     * The maximum allowed speed for the agent.
+     * @default 6
+     */
+    maxSpeed: number;
+    /**
+     * Defines how close a collision element must be before it is considered for steering behaviors.
+     * [Limits: > 0]
+     * @default 2.5
+     */
+    collisionQueryRange: number;
+    /**
+     * The path visibility optimization range.
+     * [Limit: > 0]
+     * @default 0
+     */
+    pathOptimizationRange: number;
+    /**
+     * How aggresive the agent manager should be at avoiding collisions with this agent.
+     * [Limit: >= 0]
+     * @default 0
+     */
+    separationWeight: number;
+    /**
+     * Flags that impact steering behavior.
+     * @default 7
+     */
+    updateFlags: number;
+    /**
+     * The index of the avoidance configuration to use for the agent.
+     * [Limits: 0 <= value <= #DT_CROWD_MAX_OBSTAVOIDANCE_PARAMS]
+     * @default 0
+     */
+    obstacleAvoidanceType: number;
+    /**
+     * The index of the query filter used by this agent.
+     * @default 0
+     */
+    queryFilterType: number;
+    /**
+     * User defined data attached to the agent.
+     * @default 0
+     */
+    userData: unknown;
+};
+export declare const crowdAgentParamsDefaults: CrowdAgentParams;
+export declare class CrowdAgent implements CrowdAgentParams {
+    crowd: Crowd;
+    agentIndex: number;
+    raw: RawModule.dtCrowdAgent;
+    get radius(): number;
+    set radius(value: number);
+    get height(): number;
+    set height(value: number);
+    get maxAcceleration(): number;
+    set maxAcceleration(value: number);
+    get maxSpeed(): number;
+    set maxSpeed(value: number);
+    get collisionQueryRange(): number;
+    set collisionQueryRange(value: number);
+    get pathOptimizationRange(): number;
+    set pathOptimizationRange(value: number);
+    get separationWeight(): number;
+    set separationWeight(value: number);
+    get updateFlags(): number;
+    set updateFlags(value: number);
+    get obstacleAvoidanceType(): number;
+    set obstacleAvoidanceType(value: number);
+    get queryFilterType(): number;
+    set queryFilterType(value: number);
+    get userData(): unknown;
+    set userData(value: unknown);
+    /**
+     * The interpolated position of the agent.
+     *
+     * Use this if stepping the crowd with interpolation.
+     * This will not be updated if stepping the crowd without interpolation.
+     */
+    interpolatedPosition: Vector3;
+    constructor(crowd: Crowd, agentIndex: number);
+    /**
+     * Updates the agent's target.
+     * @param position The new target position.
+     * @returns True if the request was successful.
+     */
+    requestMoveTarget(position: Vector3): boolean;
+    /**
+     * Submits a new move request for the specified agent.
+     * @param velocity The desired velocity of the agent.
+     * @returns True if the request was successful.
+     */
+    requestMoveVelocity(velocity: Vector3): boolean;
+    /**
+     * Resets the current move request for the specified agent.
+     */
+    resetMoveTarget(): void;
+    /**
+     * Teleports the agent to the specified position.
+     * @param position
+     */
+    teleport(position: Vector3): void;
+    /**
+     * The position of the agent.
+     * @returns
+     */
+    position(): Vector3;
+    /**
+     * The actual velocity of the agent. The change from velocityDesiredObstacleAdjusted -> velocity is constrained by max acceleration.
+     */
+    velocity(): Vector3;
+    /**
+     * The desired velocity of the agent. Based on the current path, calculated from scratch each frame.
+     */
+    desiredVelocity(): Vector3;
+    /**
+     * The desired velocity adjusted by obstacle avoidance, calculated from scratch each frame.
+     */
+    desiredVelocityObstacleAdjusted(): Vector3;
+    /**
+     * Returns the state of the agent.
+     *
+     * 0 = DT_CROWDAGENT_STATE_INVALID
+     * 1 = DT_CROWDAGENT_STATE_WALKING
+     * 2 = DT_CROWDAGENT_STATE_OFFMESH
+     */
+    state(): number;
+    /**
+     * Returns the next target position on the path to the target
+     * @returns
+     */
+    target(): Vector3;
+    /**
+     * Returns the next target position on the path to the target
+     * @returns
+     */
+    nextTargetInPath(): Vector3;
+    /**
+     * Returns the local path corridor corners for the agent
+     * @returns
+     */
+    corners(): Vector3[];
+    /**
+     * Returns the agents parameters.
+     * @returns
+     */
+    parameters(): CrowdAgentParams;
+    /**
+     * Updates the agent's parameters.
+     * Any parameters not specified in the crowdAgentParams object will be unchanged.
+     * @param crowdAgentParams agent parameters to update.
+     */
+    updateParameters(crowdAgentParams: Partial<CrowdAgentParams>): void;
+    /**
+     * Sets the agent's parameters.
+     * Any parameters not specified in the crowdAgentParams object will be set to their default values.
+     * @param crowdAgentParams agent parameters
+     */
+    setParameters(crowdAgentParams: Partial<CrowdAgentParams>): void;
+    /**
+     * Returns whether the agent is over an off-mesh connection.
+     * @returns
+     */
+    overOffMeshConnection(): boolean;
+}
+export type CrowdParams = {
+    /**
+     * The maximum number of agents that can be managed by the crowd.
+     * [Limit: >= 1]
+     */
+    maxAgents: number;
+    /**
+     * The maximum radius of any agent that will be added to the crowd.
+     * [Limit: > 0]
+     */
+    maxAgentRadius: number;
+};
+export declare class Crowd {
+    raw: RawModule.dtCrowd;
+    /**
+     * The agents in the crowd.
+     */
+    agents: {
+        [idx: string]: CrowdAgent;
+    };
+    /**
+     * The NavMesh the crowd is interacting with.
+     */
+    navMesh: NavMesh;
+    /**
+     * The NavMeshQuery used to find nearest polys for commands
+     */
+    navMeshQuery: NavMeshQuery;
+    /**
+     * Accumulator for fixed updates with interpolation
+     */
+    private accumulator;
+    /**
+     *
+     * @param navMesh the navmesh the crowd will use for planning
+     * @param param1 the crowd parameters
+     *
+     * @example
+     * ```ts
+     * const crowd = new Crowd(navMesh, {
+     *   maxAgents: 100,
+     *   maxAgentRadius: 1,
+     * });
+     * ```
+     */
+    constructor(navMesh: NavMesh, { maxAgents, maxAgentRadius }: CrowdParams);
+    /**
+     * Steps the crowd forward in time with a fixed time step.
+     *
+     * There are two modes. The simple mode is fixed timestepping without interpolation. In this case you only use the first argument. The second case uses interpolation. In that you also provide the time since the function was last used, as well as the maximum fixed timesteps to take.
+     *
+     * @param dt The fixed time step size to use.
+     * @param timeSinceLastCalled The time elapsed since the function was last called.
+     * @param maxSubSteps Maximum number of fixed steps to take per function call.
+     *
+     * @example fixed time stepping
+     * ```ts
+     * const deltaTime = 1 / 60;
+     * crowd.update(deltaTime);
+     * ```
+     *
+     * @example variable time stepping
+     * ```ts
+     * crowd.update(timeSinceLastUpdate);
+     * ```
+     *
+     * @example fixed time stepping with interpolation
+     * ```ts
+     * const deltaTime = 1 / 60;
+     * const maxSubSteps = 10;
+     * crowd.update(deltaTime, timeSinceLastUpdate, maxSubSteps);
+     *
+     * console.log(agent.interpolatedPosition);
+     * ```
+     */
+    update(dt: number, timeSinceLastCalled?: number, maxSubSteps?: number): void;
+    /**
+     * Adds a new agent to the crowd.
+     */
+    addAgent(position: Vector3, crowdAgentParams: Partial<CrowdAgentParams>): CrowdAgent;
+    /**
+     * Gets the agent for the specified index, or null if no agent has the given index.
+     * @param agentIndex
+     * @returns
+     */
+    getAgent(agentIndex: number): CrowdAgent | null;
+    /**
+     * Removes the agent from the crowd.
+     */
+    removeAgent(agent: number | CrowdAgent): void;
+    /**
+     * Returns the maximum number of agents that can be managed by the crowd.
+     */
+    getAgentCount(): number;
+    /**
+     * Returns the number of active agents in the crowd.
+     */
+    getActiveAgentCount(): number;
+    /**
+     * Returns all the agents managed by the crowd.
+     */
+    getAgents(): CrowdAgent[];
+    /**
+     * Gets the query filter for the specified index.
+     * @param filterIndex the index of the query filter to retrieve, (min 0, max 15)
+     * @returns the query filter
+     */
+    getFilter(filterIndex: number): QueryFilter;
+    /**
+     * Destroys the crowd.
+     */
+    destroy(): void;
+}

package/dist/debug-drawer-utils.d.ts

@@ -0,0 +1,55 @@
+import type { NavMesh } from './nav-mesh';
+import type { NavMeshQuery } from './nav-mesh-query';
+import type { RecastCompactHeightfield, RecastContourSet, RecastHeightfield, RecastHeightfieldLayer, RecastHeightfieldLayerSet, RecastPolyMesh, RecastPolyMeshDetail } from './recast';
+export type DebugDrawerPrimitiveType = 'lines' | 'tris' | 'quads' | 'points';
+export type DebugDrawerPrimitive = {
+    type: DebugDrawerPrimitiveType;
+    vertices: [
+        x: number,
+        y: number,
+        z: number,
+        r: number,
+        g: number,
+        b: number,
+        a: number
+    ][];
+};
+/**
+ * Represents a helper class to visualize navigation cur and related data in PlayCanvas.
+ */
+export declare class DebugDrawerUtils {
+    private debugDrawImpl;
+    private currentPrimitiveType;
+    private currentVertices;
+    private primitives;
+    constructor();
+    private flush;
+    drawHeightfieldSolid(hf: RecastHeightfield): DebugDrawerPrimitive[];
+    drawHeightfieldWalkable(hf: RecastHeightfield): DebugDrawerPrimitive[];
+    drawCompactHeightfieldSolid(chf: RecastCompactHeightfield): DebugDrawerPrimitive[];
+    drawCompactHeightfieldRegions(chf: RecastCompactHeightfield): DebugDrawerPrimitive[];
+    drawCompactHeightfieldDistance(chf: RecastCompactHeightfield): DebugDrawerPrimitive[];
+    drawHeightfieldLayer(layer: RecastHeightfieldLayer, idx: number): DebugDrawerPrimitive[];
+    drawHeightfieldLayers(lset: RecastHeightfieldLayerSet): DebugDrawerPrimitive[];
+    drawRegionConnections(cset: RecastContourSet, alpha?: number): DebugDrawerPrimitive[];
+    drawRawContours(cset: RecastContourSet, alpha?: number): DebugDrawerPrimitive[];
+    drawContours(cset: RecastContourSet, alpha?: number): DebugDrawerPrimitive[];
+    drawPolyMesh(mesh: RecastPolyMesh): DebugDrawerPrimitive[];
+    drawPolyMeshDetail(dmesh: RecastPolyMeshDetail): DebugDrawerPrimitive[];
+    drawNavMesh(mesh: NavMesh, flags?: number): DebugDrawerPrimitive[];
+    drawNavMeshWithClosedList(mesh: NavMesh, query: NavMeshQuery, flags?: number): DebugDrawerPrimitive[];
+    drawNavMeshNodes(query: NavMeshQuery): DebugDrawerPrimitive[];
+    drawNavMeshBVTree(mesh: NavMesh): DebugDrawerPrimitive[];
+    drawNavMeshPortals(mesh: NavMesh): DebugDrawerPrimitive[];
+    drawNavMeshPolysWithFlags(mesh: NavMesh, flags: number, col: number): DebugDrawerPrimitive[];
+    drawNavMeshPoly(mesh: NavMesh, ref: number, col: number): DebugDrawerPrimitive[];
+    /**
+     * Disposes of the debug drawer and releases resources.
+     */
+    dispose(): void;
+    private vertex;
+}
+/**
+ * Converts a color in 0xRRGGBBAA format to a duRGBA format.
+ */
+export declare const rgbToDuRgba: (hexColor: number) => number;

package/dist/detour.d.ts

@@ -0,0 +1,183 @@
+import { UnsignedCharArray } from './arrays';
+import { type RawModule } from './raw';
+import type { RecastPolyMesh, RecastPolyMeshDetail } from './recast';
+import { type Vector3, type Vector3Tuple } from './utils';
+export declare const statusSucceed: (status: number) => boolean;
+export declare const statusFailed: (status: number) => boolean;
+export declare const statusInProgress: (status: number) => boolean;
+export declare const statusDetail: (status: number, detail: number) => boolean;
+export declare const statusToReadableString: (status: number) => string;
+export declare class DetourPolyDetail {
+    raw: RawModule.dtPolyDetail;
+    constructor(raw: RawModule.dtPolyDetail);
+    vertBase(): number;
+    triBase(): number;
+    vertCount(): number;
+    triCount(): number;
+}
+export declare class DetourLink {
+    raw: RawModule.dtLink;
+    constructor(raw: RawModule.dtLink);
+    ref(): number;
+    next(): number;
+    edge(): number;
+    side(): number;
+    bmin(): number;
+    bmax(): number;
+}
+export declare class DetourBVNode {
+    raw: RawModule.dtBVNode;
+    constructor(raw: RawModule.dtBVNode);
+    bmin(): Vector3;
+    bmax(): Vector3;
+    i(): number;
+}
+export declare class DetourOffMeshConnection {
+    raw: RawModule.dtOffMeshConnection;
+    constructor(raw: RawModule.dtOffMeshConnection);
+    pos(index: number): number;
+    rad(): number;
+    poly(): number;
+    flags(): number;
+    side(): number;
+    userId(): number;
+}
+export declare class DetourMeshHeader {
+    raw: RawModule.dtMeshHeader;
+    constructor(raw: RawModule.dtMeshHeader);
+    magic(): number;
+    version(): number;
+    x(): number;
+    y(): number;
+    layer(): number;
+    userId(): number;
+    polyCount(): number;
+    vertCount(): number;
+    maxLinkCount(): number;
+    detailMeshCount(): number;
+    detailVertCount(): number;
+    detailTriCount(): number;
+    bvNodeCount(): number;
+    offMeshConCount(): number;
+    offMeshBase(): number;
+    walkableHeight(): number;
+    walkableRadius(): number;
+    walkableClimb(): number;
+    bmin(index: number): number;
+    bmax(index: number): number;
+    bvQuantFactor(): number;
+}
+export declare class DetourPoly {
+    raw: RawModule.dtPoly;
+    constructor(raw: RawModule.dtPoly);
+    firstLink(): number;
+    verts(index: number): number;
+    neis(index: number): number;
+    flags(): number;
+    vertCount(): number;
+    areaAndType(): number;
+    getType(): number;
+}
+export declare class DetourMeshTile {
+    raw: RawModule.dtMeshTile;
+    constructor(raw: RawModule.dtMeshTile);
+    salt(): number;
+    linksFreeList(): number;
+    header(): DetourMeshHeader | null;
+    polys(index: number): DetourPoly;
+    verts(index: number): number;
+    links(index: number): DetourLink;
+    detailMeshes(index: number): DetourPolyDetail;
+    detailVerts(index: number): number;
+    detailTris(index: number): number;
+    bvTree(index: number): DetourBVNode;
+    offMeshCons(index: number): DetourOffMeshConnection;
+    data(index: number): number;
+    dataSize(): number;
+    flags(): number;
+    next(): DetourMeshTile;
+}
+export declare const createNavMeshData: (navMeshCreateParams: NavMeshCreateParams) => {
+    success: boolean;
+    navMeshData: UnsignedCharArray;
+};
+export type OffMeshConnectionParams = {
+    startPosition: Vector3;
+    endPosition: Vector3;
+    radius: number;
+    bidirectional: boolean;
+    /**
+     * @default 0
+     */
+    area?: number;
+    /**
+     * @default 1
+     */
+    flags?: number;
+    userId?: number;
+};
+export declare class NavMeshCreateParams {
+    raw: RawModule.dtNavMeshCreateParams;
+    /**
+     * Creates a new NavMeshCreateParams object.
+     */
+    constructor();
+    /**
+     * Creates a wrapper around an existing raw NavMeshCreateParams object.
+     */
+    constructor(raw: RawModule.dtNavMeshCreateParams);
+    setPolyMeshCreateParams(polyMesh: RecastPolyMesh): void;
+    setPolyMeshDetailCreateParams(polyMeshDetail: RecastPolyMeshDetail): void;
+    setOffMeshConnections(offMeshConnections: OffMeshConnectionParams[]): void;
+    verts(index: number): number;
+    setVerts(index: number, value: number): void;
+    vertCount(): number;
+    polys(index: number): number;
+    setPolys(index: number, value: number): void;
+    polyAreas(index: number): number;
+    setPolyAreas(index: number, value: number): void;
+    polyFlags(index: number): number;
+    setPolyFlags(index: number, value: number): void;
+    polyCount(): number;
+    nvp(): number;
+    setNvp(value: number): void;
+    detailMeshes(index: number): number;
+    setDetailMeshes(index: number, value: number): void;
+    detailVerts(index: number): number;
+    setDetailVerts(index: number, value: number): void;
+    detailVertsCount(): number;
+    detailTris(index: number): number;
+    setDetailTris(index: number, value: number): void;
+    detailTriCount(): number;
+    offMeshConVerts(index: number): number;
+    offMeshConRad(index: number): number;
+    offMeshConDir(index: number): number;
+    offMeshConAreas(index: number): number;
+    offMeshConFlags(index: number): number;
+    offMeshConUserID(index: number): number;
+    offMeshConCount(): number;
+    userId(): number;
+    tileX(): number;
+    setTileX(value: number): void;
+    tileY(): number;
+    setTileY(value: number): void;
+    tileLayer(): number;
+    setTileLayer(value: number): void;
+    boundsMin(): Vector3Tuple;
+    setBoundsMin(value: Vector3Tuple): void;
+    boundsMax(): Vector3Tuple;
+    setBoundsMax(value: Vector3Tuple): void;
+    walkableHeight(): number;
+    setWalkableHeight(value: number): void;
+    walkableRadius(): number;
+    setWalkableRadius(value: number): void;
+    walkableClimb(): number;
+    setWalkableClimb(value: number): void;
+    cellSize(): number;
+    setCellSize(value: number): void;
+    cellHeight(): number;
+    setCellHeight(value: number): void;
+    buildBvTree(): boolean;
+    setBuildBvTree(value: boolean): void;
+    destroy(): void;
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export * from './arrays';
+export * from './crowd';
+export * from './debug-drawer-utils';
+export * from './detour';
+export * from './nav-mesh';
+export * from './nav-mesh-query';
+export * from './random';
+export * from './raw';
+export * from './recast';
+export * from './serdes';
+export * from './tile-cache';
+export * from './utils';