@recast-navigation/core 0.26.0 → 0.28.0

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

@@ -1,26 +1,45 @@
 import { FloatArray, UnsignedCharArray, UnsignedIntArray } from './arrays';
 import { NavMesh } from './nav-mesh';
-import type R from './raw-module';
+import { type RawModule } from './raw';
 import { Vector3 } from './utils';
 export declare class QueryFilter {
-    raw: R.dtQueryFilter;
+    raw: RawModule.dtQueryFilter;
     get includeFlags(): number;
     set includeFlags(flags: number);
     get excludeFlags(): number;
     set excludeFlags(flags: number);
-    constructor(raw?: R.dtQueryFilter);
+    /**
+     * Constructs a new query filter object.
+     */
+    constructor();
+    /**
+     * Constructs a query filter wrapper for a raw dtQueryFilter object.
+     * @param raw
+     */
+    constructor(raw: RawModule.dtQueryFilter);
     getAreaCost(i: number): number;
     setAreaCost(i: number, cost: number): void;
 }
 export type NavMeshQueryParams = {
-    navMesh: NavMesh;
     /**
      * @default 2048
      */
     maxNodes?: number;
+    /**
+     * Default query filter.
+     *
+     * If omitted, the default filter will include all flags and exclude none.
+     *
+     * ```ts
+     * this.defaultFilter = new QueryFilter();
+     * this.defaultFilter.includeFlags = 0xffff;
+     * this.defaultFilter.excludeFlags = 0;
+     * ```
+     */
+    defaultQueryFilter?: QueryFilter;
 };
 export declare class NavMeshQuery {
-    raw: R.NavMeshQuery;
+    raw: RawModule.NavMeshQuery;
     /**
      * Default query filter.
      */
@@ -33,7 +52,27 @@ export declare class NavMeshQuery {
         y: number;
         z: number;
     };
-    constructor(value: R.NavMeshQuery | NavMeshQueryParams);
+    /**
+     * Constructs a new navigation mesh query object.
+     * @param navMesh the navigation mesh to use for the query
+     * @param params optional additional parameters
+     *
+     * @example
+     * ```ts
+     * const query = new NavMeshQuery(navMesh);
+     * ```
+     *
+     * @example
+     * ```ts
+     * const query = new NavMeshQuery(navMesh, { maxNodes: 2048 });
+     * ```
+     */
+    constructor(navMesh: NavMesh, params?: NavMeshQueryParams);
+    /**
+     * Constructs a navigation mesh query object from a raw object.
+     * @param raw
+     */
+    constructor(raw: RawModule.NavMeshQuery);
     /**
      * Finds the polygon nearest to the given position.
      */
@@ -82,7 +121,7 @@ export declare class NavMeshQuery {
         status: number;
         resultRefs: number[];
         resultParents: number[];
-        resultCost: number;
+        resultCost: number[];
         resultCount: number;
     };
     /**
@@ -122,7 +161,7 @@ export declare class NavMeshQuery {
             y: number;
             z: number;
         };
-        posOverPoly: boolean;
+        isPointOverPoly: boolean;
     };
     /**
      * Finds the closest point on the NavMesh to the given position.
@@ -299,6 +338,12 @@ export declare class NavMeshQuery {
      * @param endPosition position within the end polygon.
      * @param options additional options
      * @returns
+     *
+     * The `polys` array returned must be freed after use.
+     *
+     * ```ts
+     * findPathResult.polys.destroy();
+     * ```
      */
     findPath(startRef: number, endRef: number, startPosition: Vector3, endPosition: Vector3, options?: {
         /**
@@ -339,6 +384,14 @@ export declare class NavMeshQuery {
      * @param path an array of polygon references that represent the path corridor
      * @param options additional options
      * @returns the straight path result
+     *
+     * The straightPath, straightPathFlags, and straightPathRefs arrays returned must be freed after use.
+     *
+     * ```ts
+     * findStraightPathResult.straightPath.destroy();
+     * findStraightPathResult.straightPathFlags.destroy();
+     * findStraightPathResult.straightPathRefs.destroy();
+     * ```
      */
     findStraightPath(start: Vector3, end: Vector3, path: UnsignedIntArray, options?: {
         /**

package/dist/nav-mesh.d.ts

@@ -1,35 +1,28 @@
 import { UnsignedCharArray } from './arrays';
 import { DetourMeshTile, DetourOffMeshConnection, DetourPoly } from './detour';
-import type R from './raw-module';
+import { type RawModule } from './raw';
 import { Vector3 } from './utils';
 export declare class NavMeshGetTilesAtResult {
-    raw: R.NavMeshGetTilesAtResult;
-    constructor(raw: R.NavMeshGetTilesAtResult);
+    raw: RawModule.NavMeshGetTilesAtResult;
+    constructor(raw: RawModule.NavMeshGetTilesAtResult);
     tiles(index: number): DetourMeshTile;
     tileCount(): number;
 }
 export declare class NavMeshRemoveTileResult {
-    raw: R.NavMeshRemoveTileResult;
-    constructor(raw: R.NavMeshRemoveTileResult);
+    raw: RawModule.NavMeshRemoveTileResult;
+    constructor(raw: RawModule.NavMeshRemoveTileResult);
     data(): number[];
     dataSize(): number;
 }
 export declare class NavMeshCalcTileLocResult {
-    raw: R.NavMeshCalcTileLocResult;
-    constructor(raw: R.NavMeshCalcTileLocResult);
+    raw: RawModule.NavMeshCalcTileLocResult;
+    constructor(raw: RawModule.NavMeshCalcTileLocResult);
     tileX(): number;
     tileY(): number;
 }
-export declare class NavMeshGetTileAndPolyByRefResult {
-    raw: R.NavMeshGetTileAndPolyByRefResult;
-    constructor(raw: R.NavMeshGetTileAndPolyByRefResult);
-    tile(): DetourMeshTile;
-    poly(): DetourPoly;
-    status(): number;
-}
 export declare class NavMeshStoreTileStateResult {
-    raw: R.NavMeshStoreTileStateResult;
-    constructor(raw: R.NavMeshStoreTileStateResult);
+    raw: RawModule.NavMeshStoreTileStateResult;
+    constructor(raw: RawModule.NavMeshStoreTileStateResult);
     data(): number[];
     dataSize(): number;
 }
@@ -55,14 +48,22 @@ export type NavMeshParamsType = {
     maxPolys: number;
 };
 export declare class NavMeshParams {
-    raw: R.dtNavMeshParams;
-    constructor(raw: R.dtNavMeshParams);
+    raw: RawModule.dtNavMeshParams;
+    constructor(raw: RawModule.dtNavMeshParams);
     static create(params: NavMeshParamsType): NavMeshParams;
     clone(): NavMeshParams;
 }
 export declare class NavMesh {
-    raw: R.NavMesh;
-    constructor(raw?: R.NavMesh);
+    raw: RawModule.NavMesh;
+    /**
+     * Constructs a new NavMesh
+     */
+    constructor();
+    /**
+     * Creates a wrapper around a raw NavMesh object
+     * @param raw raw object
+     */
+    constructor(raw: RawModule.NavMesh);
     /**
      * Initializes the NavMesh for use with a single tile.
      * @param navMeshData the nav mesh data
@@ -162,13 +163,21 @@ export declare class NavMesh {
      * @param ref The reference for the a polygon.
      * @returns
      */
-    getTileAndPolyByRef(ref: number): NavMeshGetTileAndPolyByRefResult;
+    getTileAndPolyByRef(ref: number): {
+        success: boolean;
+        status: number;
+        tile: DetourMeshTile;
+        poly: DetourPoly;
+    };
     /**
      * Gets the tile and polygon for the specified polygon reference.
      * @param ref A known valid reference for a polygon.
      * @returns
      */
-    getTileAndPolyByRefUnsafe(ref: number): NavMeshGetTileAndPolyByRefResult;
+    getTileAndPolyByRefUnsafe(ref: number): {
+        tile: DetourMeshTile;
+        poly: DetourPoly;
+    };
     /**
      * Checks the validity of a polygon reference.
      * @param ref

package/dist/raw.d.ts

@@ -1,4 +1,5 @@
-import RawModule from './raw-module';
+import type { default as Module, default as RawModule } from '@recast-navigation/wasm';
+export type { RawModule };
 /**
  * Lower level bindings for the Recast and Detour libraries.
  *
@@ -7,37 +8,37 @@ import RawModule from './raw-module';
 export declare const Raw: {
     Module: typeof RawModule;
     isNull: (obj: unknown) => boolean;
-    CrowdUtils: RawModule.CrowdUtils;
-    Detour: RawModule.Detour;
-    Recast: RawModule.Recast;
-    DetourNavMeshBuilder: RawModule.DetourNavMeshBuilder;
-    DetourTileCacheBuilder: RawModule.DetourTileCacheBuilder;
-    ChunkyTriMeshUtils: RawModule.ChunkyTriMeshUtils;
-    NavMeshImporter: RawModule.NavMeshImporter;
-    NavMeshExporter: RawModule.NavMeshExporter;
-    RecastDebugDraw: RawModule.RecastDebugDraw;
-    DetourDebugDraw: RawModule.DetourDebugDraw;
-    rcConfig: typeof RawModule.rcConfig;
-    dtNavMeshCreateParams: typeof RawModule.dtNavMeshCreateParams;
-    dtNavMeshParams: typeof RawModule.dtNavMeshParams;
-    Vec3: typeof RawModule.Vec3;
-    Vec2: typeof RawModule.Vec2;
-    dtTileCacheParams: typeof RawModule.dtTileCacheParams;
-    RecastFastLZCompressor: typeof RawModule.RecastFastLZCompressor;
-    RecastLinearAllocator: typeof RawModule.RecastLinearAllocator;
-    rcContext: typeof RawModule.rcContext;
-    dtTileCacheLayerHeader: typeof RawModule.dtTileCacheLayerHeader;
-    rcChunkyTriMesh: typeof RawModule.rcChunkyTriMesh;
-    BoolRef: typeof RawModule.BoolRef;
-    IntRef: typeof RawModule.IntRef;
-    UnsignedIntRef: typeof RawModule.UnsignedIntRef;
-    UnsignedCharRef: typeof RawModule.UnsignedCharRef;
-    UnsignedShortRef: typeof RawModule.UnsignedShortRef;
-    FloatRef: typeof RawModule.FloatRef;
-    IntArray: typeof RawModule.IntArray;
-    UnsignedIntArray: typeof RawModule.UnsignedIntArray;
-    UnsignedCharArray: typeof RawModule.UnsignedCharArray;
-    UnsignedShortArray: typeof RawModule.UnsignedShortArray;
-    FloatArray: typeof RawModule.FloatArray;
+    destroy: (obj: unknown) => void;
+    CrowdUtils: Module.CrowdUtils;
+    Detour: Module.Detour;
+    Recast: Module.Recast;
+    DetourNavMeshBuilder: Module.DetourNavMeshBuilder;
+    DetourTileCacheBuilder: Module.DetourTileCacheBuilder;
+    ChunkyTriMeshUtils: Module.ChunkyTriMeshUtils;
+    NavMeshImporter: Module.NavMeshImporter;
+    NavMeshExporter: Module.NavMeshExporter;
+    RecastDebugDraw: Module.RecastDebugDraw;
+    DetourDebugDraw: Module.DetourDebugDraw;
+    rcConfig: typeof Module.rcConfig;
+    dtNavMeshCreateParams: typeof Module.dtNavMeshCreateParams;
+    dtNavMeshParams: typeof Module.dtNavMeshParams;
+    Vec3: typeof Module.Vec3;
+    dtTileCacheParams: typeof Module.dtTileCacheParams;
+    RecastFastLZCompressor: typeof Module.RecastFastLZCompressor;
+    RecastLinearAllocator: typeof Module.RecastLinearAllocator;
+    rcContext: typeof Module.rcContext;
+    dtTileCacheLayerHeader: typeof Module.dtTileCacheLayerHeader;
+    rcChunkyTriMesh: typeof Module.rcChunkyTriMesh;
+    BoolRef: typeof Module.BoolRef;
+    IntRef: typeof Module.IntRef;
+    UnsignedIntRef: typeof Module.UnsignedIntRef;
+    UnsignedCharRef: typeof Module.UnsignedCharRef;
+    UnsignedShortRef: typeof Module.UnsignedShortRef;
+    FloatRef: typeof Module.FloatRef;
+    IntArray: typeof Module.IntArray;
+    UnsignedIntArray: typeof Module.UnsignedIntArray;
+    UnsignedCharArray: typeof Module.UnsignedCharArray;
+    UnsignedShortArray: typeof Module.UnsignedShortArray;
+    FloatArray: typeof Module.FloatArray;
 };
-export declare const init: () => Promise<void>;
+export declare const init: (impl?: typeof Module) => Promise<void>;

package/dist/recast.d.ts

@@ -1,6 +1,6 @@
 import { Vector3Tuple } from 'three';
 import { FloatArray, IntArray, UnsignedCharArray } from './arrays';
-import type R from './raw-module';
+import { type RawModule } from './raw';
 import { Vector2Tuple, Vector3 } from './utils';
 export type RecastConfig = {
     /**
@@ -95,10 +95,10 @@ export type RecastConfig = {
     detailSampleMaxError: number;
 };
 export declare const recastConfigDefaults: RecastConfig;
-export declare const createRcConfig: (partialConfig: Partial<RecastConfig>) => R.rcConfig;
-export declare const cloneRcConfig: (rcConfig: R.rcConfig) => R.rcConfig;
+export declare const createRcConfig: (partialConfig: Partial<RecastConfig>) => RawModule.rcConfig;
+export declare const cloneRcConfig: (rcConfig: RawModule.rcConfig) => RawModule.rcConfig;
 export declare class RecastBuildContext {
-    raw: R.RecastBuildContext;
+    raw: RawModule.RecastBuildContext;
     logs: Array<{
         category: number;
         msg: string;
@@ -118,31 +118,38 @@ export declare class RecastBuildContext {
     resetTimers(): void;
 }
 export declare class RecastChunkyTriMesh {
-    raw: R.rcChunkyTriMesh;
-    constructor(raw?: R.rcChunkyTriMesh);
+    raw: RawModule.rcChunkyTriMesh;
+    /**
+     * Creates a new RecastChunkyTriMesh.
+     */
+    constructor();
+    /**
+     * Creates a wrapper around an existing raw RecastChunkyTriMesh object.
+     */
+    constructor(raw: RawModule.rcChunkyTriMesh);
     init(verts: FloatArray, tris: IntArray, ntris: number, trisPerChunk: number): boolean;
     getChunksOverlappingRect(boundsMin: Vector2Tuple, boundsMax: Vector2Tuple, chunks: IntArray, maxChunks: number): number;
     getNodeTris(nodeId: number): IntArray;
-    nodes(index: number): R.rcChunkyTriMeshNode;
+    nodes(index: number): RawModule.rcChunkyTriMeshNode;
     maxTrisPerChunk(): number;
 }
 export declare class RecastSpan {
-    raw: R.rcSpan;
-    constructor(raw: R.rcSpan);
+    raw: RawModule.rcSpan;
+    constructor(raw: RawModule.rcSpan);
     smin(): number;
     smax(): number;
     area(): number;
     next(): RecastSpan | null;
 }
 export declare class RecastSpanPool {
-    raw: R.rcSpanPool;
-    constructor(raw: R.rcSpanPool);
+    raw: RawModule.rcSpanPool;
+    constructor(raw: RawModule.rcSpanPool);
     next(): RecastSpanPool | null;
     items(index: number): RecastSpan;
 }
 export declare class RecastHeightfield {
-    raw: R.rcHeightfield;
-    constructor(raw: R.rcHeightfield);
+    raw: RawModule.rcHeightfield;
+    constructor(raw: RawModule.rcHeightfield);
     width(): number;
     height(): number;
     bmin(): Vector3;
@@ -154,22 +161,22 @@ export declare class RecastHeightfield {
     freelist(index: number): RecastSpan;
 }
 export declare class RecastCompactCell {
-    raw: R.rcCompactCell;
-    constructor(raw: R.rcCompactCell);
+    raw: RawModule.rcCompactCell;
+    constructor(raw: RawModule.rcCompactCell);
     index(): number;
     count(): number;
 }
 export declare class RecastCompactSpan {
-    raw: R.rcCompactSpan;
-    constructor(raw: R.rcCompactSpan);
+    raw: RawModule.rcCompactSpan;
+    constructor(raw: RawModule.rcCompactSpan);
     y(): number;
     reg(): number;
     con(): number;
     h(): number;
 }
 export declare class RecastCompactHeightfield {
-    raw: R.rcCompactHeightfield;
-    constructor(raw: R.rcCompactHeightfield);
+    raw: RawModule.rcCompactHeightfield;
+    constructor(raw: RawModule.rcCompactHeightfield);
     width(): number;
     height(): number;
     spanCount(): number;
@@ -188,8 +195,8 @@ export declare class RecastCompactHeightfield {
     areas(index: number): number;
 }
 export declare class RecastContour {
-    raw: R.rcContour;
-    constructor(raw: R.rcContour);
+    raw: RawModule.rcContour;
+    constructor(raw: RawModule.rcContour);
     verts(index: number): number;
     nverts(): number;
     rverts(index: number): number;
@@ -198,8 +205,8 @@ export declare class RecastContour {
     area(): number;
 }
 export declare class RecastContourSet {
-    raw: R.rcContourSet;
-    constructor(raw: R.rcContourSet);
+    raw: RawModule.rcContourSet;
+    constructor(raw: RawModule.rcContourSet);
     conts(index: number): RecastContour;
     nconts(): number;
     bmin(): Vector3;
@@ -212,8 +219,8 @@ export declare class RecastContourSet {
     maxError(): number;
 }
 export declare class RecastHeightfieldLayer {
-    raw: R.rcHeightfieldLayer;
-    constructor(raw: R.rcHeightfieldLayer);
+    raw: RawModule.rcHeightfieldLayer;
+    constructor(raw: RawModule.rcHeightfieldLayer);
     bmin(): Vector3;
     bmax(): Vector3;
     cs(): number;
@@ -231,14 +238,14 @@ export declare class RecastHeightfieldLayer {
     cons(index: number): number;
 }
 export declare class RecastHeightfieldLayerSet {
-    raw: R.rcHeightfieldLayerSet;
-    constructor(raw: R.rcHeightfieldLayerSet);
+    raw: RawModule.rcHeightfieldLayerSet;
+    constructor(raw: RawModule.rcHeightfieldLayerSet);
     layers(index: number): RecastHeightfieldLayer;
     nlayers(): number;
 }
 export declare class RecastPolyMesh {
-    raw: R.rcPolyMesh;
-    constructor(raw: R.rcPolyMesh);
+    raw: RawModule.rcPolyMesh;
+    constructor(raw: RawModule.rcPolyMesh);
     verts(index: number): number;
     polys(index: number): number;
     regs(index: number): number;
@@ -258,8 +265,8 @@ export declare class RecastPolyMesh {
     maxEdgeError(): number;
 }
 export declare class RecastPolyMeshDetail {
-    raw: R.rcPolyMeshDetail;
-    constructor(raw: R.rcPolyMeshDetail);
+    raw: RawModule.rcPolyMeshDetail;
+    constructor(raw: RawModule.rcPolyMeshDetail);
     meshes(index: number): number;
     verts(index: number): number;
     tris(index: number): number;
@@ -267,8 +274,8 @@ export declare class RecastPolyMeshDetail {
     nverts(): number;
     ntris(): number;
 }
-export declare const calcBounds: (verts: FloatArray, nv: number) => R.RecastCalcBoundsResult;
-export declare const calcGridSize: (bmin: Vector3Tuple, bmax: Vector3Tuple, cs: number) => R.RecastCalcGridSizeResult;
+export declare const calcBounds: (verts: FloatArray, nv: number) => RawModule.RecastCalcBoundsResult;
+export declare const calcGridSize: (bmin: Vector3Tuple, bmax: Vector3Tuple, cs: number) => RawModule.RecastCalcGridSizeResult;
 export declare const createHeightfield: (buildContext: RecastBuildContext, heightfield: RecastHeightfield, width: number, height: number, bmin: Vector3Tuple, bmax: Vector3Tuple, cs: number, ch: number) => boolean;
 export declare const markWalkableTriangles: (buildContext: RecastBuildContext, walkableSlopeAngle: number, verts: FloatArray, nv: number, tris: IntArray, nt: number, areas: UnsignedCharArray) => void;
 export declare const clearUnwalkableTriangles: (buildContext: RecastBuildContext, walkableSlopeAngle: number, verts: FloatArray, nv: number, tris: IntArray, nt: number, areas: UnsignedCharArray) => void;

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

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

package/dist/tile-cache.d.ts

@@ -1,9 +1,9 @@
 import { UnsignedCharArray, UnsignedShortArray } from './arrays';
 import { NavMeshCreateParams } from './detour';
 import { NavMesh } from './nav-mesh';
-import type R from './raw-module';
+import { type RawModule } from './raw';
 import { Vector3 } from './utils';
-export type ObstacleRef = R.dtObstacleRef;
+export type ObstacleRef = RawModule.dtObstacleRef;
 export type BoxObstacle = {
     type: 'box';
     ref: ObstacleRef;
@@ -46,8 +46,8 @@ export type TileCacheParamsType = {
     maxObstacles: number;
 };
 export declare class DetourTileCacheParams {
-    raw: R.dtTileCacheParams;
-    constructor(raw: R.dtTileCacheParams);
+    raw: RawModule.dtTileCacheParams;
+    constructor(raw: RawModule.dtTileCacheParams);
     static create(config: TileCacheParamsType): DetourTileCacheParams;
 }
 export type TileCacheUpdateResult = {
@@ -56,14 +56,22 @@ export type TileCacheUpdateResult = {
     upToDate: boolean;
 };
 export declare class TileCache {
-    raw: R.TileCache;
+    raw: RawModule.TileCache;
     obstacles: Map<ObstacleRef, Obstacle>;
-    constructor(raw?: R.TileCache);
+    /**
+     * Constructs a new TileCache
+     */
+    constructor();
+    /**
+     * Creates a wrapper around a raw TileCache object
+     * @param raw raw object
+     */
+    constructor(raw: RawModule.TileCache);
     /**
      * Initialises the TileCache
      * @param params
      */
-    init(params: DetourTileCacheParams, alloc: R.RecastLinearAllocator, compressor: R.RecastFastLZCompressor, meshProcess: TileCacheMeshProcess): boolean;
+    init(params: DetourTileCacheParams, alloc: RawModule.RecastLinearAllocator, compressor: RawModule.RecastFastLZCompressor, meshProcess: TileCacheMeshProcess): boolean;
     /**
      * Updates the tile cache by rebuilding tiles touched by unfinished obstacle requests.
      *
@@ -97,13 +105,13 @@ export declare class TileCache {
      * Removes an obstacle from the navigation mesh.
      */
     removeObstacle(obstacle: Obstacle | ObstacleRef): RemoveObstacleResult;
-    addTile(data: UnsignedCharArray, flags?: number): R.TileCacheAddTileResult;
-    buildNavMeshTile(ref: R.dtCompressedTileRef, navMesh: NavMesh): number;
+    addTile(data: UnsignedCharArray, flags?: number): RawModule.TileCacheAddTileResult;
+    buildNavMeshTile(ref: RawModule.dtCompressedTileRef, navMesh: NavMesh): number;
     buildNavMeshTilesAt(tx: number, ty: number, navMesh: NavMesh): number;
     destroy(): void;
 }
 export declare class TileCacheMeshProcess {
-    raw: R.TileCacheMeshProcess;
+    raw: RawModule.TileCacheMeshProcess;
     constructor(process: (navMeshCreateParams: NavMeshCreateParams, polyAreasArray: UnsignedCharArray, polyFlagsArray: UnsignedShortArray) => void);
 }
-export declare const buildTileCacheLayer: (comp: R.RecastFastLZCompressor, header: R.dtTileCacheLayerHeader, heights: UnsignedCharArray, areas: UnsignedCharArray, cons: UnsignedCharArray, tileCacheData: UnsignedCharArray) => number;
+export declare const buildTileCacheLayer: (comp: RawModule.RecastFastLZCompressor, header: RawModule.dtTileCacheLayerHeader, heights: UnsignedCharArray, areas: UnsignedCharArray, cons: UnsignedCharArray, tileCacheData: UnsignedCharArray) => number;

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import type R from './raw-module';
+import { type RawModule } from './raw';
 export type Vector3 = {
     x: number;
     y: number;
@@ -11,8 +11,8 @@ export type Vector2 = {
 };
 export type Vector2Tuple = [x: number, y: number];
 export declare const vec3: {
-    toRaw: ({ x, y, z }: Vector3, existing?: R.Vec3) => R.Vec3;
-    fromRaw: (vec3: R.Vec3, freeRaw?: boolean) => {
+    toRaw: ({ x, y, z }: Vector3, existing?: RawModule.Vec3) => RawModule.Vec3;
+    fromRaw: (vec3: RawModule.Vec3) => {
         x: number;
         y: number;
         z: number;

package/package.json

@@ -6,13 +6,14 @@
     "email": "isaac@isaacmason.com",
     "url": "https://isaacmason.com/"
   },
-  "version": "0.26.0",
+  "version": "0.28.0",
   "license": "MIT",
   "homepage": "https://github.com/isaac-mason/recast-navigation-js",
   "bugs": {
     "url": "https://github.com/isaac-mason/recast-navigation-js/issues"
   },
-  "main": "./dist/index.cjs",
+  "type": "module",
+  "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "files": [
@@ -26,11 +27,14 @@
     "lint": "eslint --ext .ts src"
   },
   "dependencies": {
-    "@recast-navigation/wasm": "0.26.0"
+    "@recast-navigation/wasm": "0.28.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.24.4",
+    "@babel/core": "^7.24.5",
+    "@babel/preset-env": "^7.24.5",
+    "@babel/preset-typescript": "^7.24.1",
     "@isaac-mason/eslint-config-typescript": "^0.0.5",
+    "@rollup/plugin-babel": "^6.0.4",
     "@rollup/plugin-commonjs": "^25.0.7",
     "@rollup/plugin-node-resolve": "^15.0.1",
     "@rollup/plugin-terser": "^0.4.3",