screeps-clockwork 0.2.0 → 0.4.0

package/dist/index.js

@@ -46,15 +46,6 @@ function takeObject(idx) {
     return ret;
 }
 
-function addHeapObject(obj) {
-    if (heap_next === heap.length) heap.push(heap.length + 1);
-    const idx = heap_next;
-    heap_next = heap[idx];
-
-    heap[idx] = obj;
-    return idx;
-}
-
 function isLikeNone(x) {
     return x === undefined || x === null;
 }
@@ -68,6 +59,15 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
 const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
 
 if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); }
@@ -84,36 +84,6 @@ function getStringFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
-/**
- * @returns {string}
- */
-function version() {
-    let deferred1_0;
-    let deferred1_1;
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.version(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_free(deferred1_0, deferred1_1, 1);
-    }
-}
-
-/**
- * Exports the global range calculation between two positions.
- * @param {number} packed_pos_1
- * @param {number} packed_pos_2
- * @returns {number}
- */
-function get_range(packed_pos_1, packed_pos_2) {
-    const ret = wasm.get_range(packed_pos_1, packed_pos_2);
-    return ret >>> 0;
-}
 
 let cachedUint32ArrayMemory0 = null;
 
@@ -124,13 +94,9 @@ function getUint32ArrayMemory0() {
     return cachedUint32ArrayMemory0;
 }
 
-let WASM_VECTOR_LEN = 0;
-
-function passArray32ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 4, 4) >>> 0;
-    getUint32ArrayMemory0().set(arg, ptr / 4);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
 }
 
 function _assertClass(instance, klass) {
@@ -139,85 +105,129 @@ function _assertClass(instance, klass) {
     }
     return instance.ptr;
 }
+
+let WASM_VECTOR_LEN = 0;
+
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
 /**
- * WASM wrapper for the BFS flow field function.
+ * WASM wrapper for the Dijkstra flow field function.
  * @param {Uint32Array} start_packed
  * @param {ClockworkCostMatrix} cost_matrix
  * @returns {FlowField}
  */
-function js_bfs_flow_field(start_packed, cost_matrix) {
+function js_dijkstra_flow_field(start_packed, cost_matrix) {
     const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     _assertClass(cost_matrix, ClockworkCostMatrix);
-    const ret = wasm.js_bfs_flow_field(ptr0, len0, cost_matrix.__wbg_ptr);
+    const ret = wasm.js_dijkstra_flow_field(ptr0, len0, cost_matrix.__wbg_ptr);
     return FlowField.__wrap(ret);
 }
 
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(takeObject(mem.getUint32(i, true)));
+    }
+    return result;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    const mem = getDataViewMemory0();
+    for (let i = 0; i < array.length; i++) {
+        mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+/**
+ * @param {number} start
+ * @param {MonoFlowField} flow_field
+ * @returns {Path}
+ */
+function js_path_to_mono_flow_field_origin(start, flow_field) {
+    _assertClass(flow_field, MonoFlowField);
+    const ret = wasm.js_path_to_mono_flow_field_origin(start, flow_field.__wbg_ptr);
+    return Path$1.__wrap(ret);
+}
+
 /**
- * WASM wrapper for the Dijkstra mono flow field function.
+ * WASM wrapper for the Dijkstra distance map function.
  * @param {Uint32Array} start_packed
  * @param {ClockworkCostMatrix} cost_matrix
- * @returns {MonoFlowField}
+ * @returns {DistanceMap}
  */
-function js_dijkstra_mono_flow_field(start_packed, cost_matrix) {
+function js_dijkstra_distance_map(start_packed, cost_matrix) {
     const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     _assertClass(cost_matrix, ClockworkCostMatrix);
-    const ret = wasm.js_dijkstra_mono_flow_field(ptr0, len0, cost_matrix.__wbg_ptr);
-    return MonoFlowField.__wrap(ret);
+    const ret = wasm.js_dijkstra_distance_map(ptr0, len0, cost_matrix.__wbg_ptr);
+    return DistanceMap.__wrap(ret);
 }
 
 /**
- * WASM wrapper for the Dijkstra flow field function.
+ * WASM wrapper for the BFS mono flow field function.
  * @param {Uint32Array} start_packed
  * @param {ClockworkCostMatrix} cost_matrix
- * @returns {FlowField}
+ * @returns {MonoFlowField}
  */
-function js_dijkstra_flow_field(start_packed, cost_matrix) {
+function js_bfs_mono_flow_field(start_packed, cost_matrix) {
     const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     _assertClass(cost_matrix, ClockworkCostMatrix);
-    const ret = wasm.js_dijkstra_flow_field(ptr0, len0, cost_matrix.__wbg_ptr);
-    return FlowField.__wrap(ret);
+    const ret = wasm.js_bfs_mono_flow_field(ptr0, len0, cost_matrix.__wbg_ptr);
+    return MonoFlowField.__wrap(ret);
 }
 
-function getArrayU32FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
-}
 /**
- * WASM wrapper for the Dijkstra distance map function.
- * @param {Uint32Array} start_packed
- * @param {ClockworkCostMatrix} cost_matrix
- * @returns {DistanceMap}
+ * @param {number} start
+ * @param {DistanceMap} distance_map
+ * @returns {Path}
  */
-function js_dijkstra_distance_map(start_packed, cost_matrix) {
-    const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    _assertClass(cost_matrix, ClockworkCostMatrix);
-    const ret = wasm.js_dijkstra_distance_map(ptr0, len0, cost_matrix.__wbg_ptr);
-    return DistanceMap.__wrap(ret);
+function js_path_to_distance_map_origin(start, distance_map) {
+    _assertClass(distance_map, DistanceMap);
+    const ret = wasm.js_path_to_distance_map_origin(start, distance_map.__wbg_ptr);
+    return Path$1.__wrap(ret);
 }
 
-function getArrayJsValueFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    const mem = getDataViewMemory0();
-    const result = [];
-    for (let i = ptr; i < ptr + 4 * len; i += 4) {
-        result.push(takeObject(mem.getUint32(i, true)));
+/**
+ * @returns {string}
+ */
+function version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.version(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_free(deferred1_0, deferred1_1, 1);
     }
-    return result;
 }
 
-function passArrayJsValueToWasm0(array, malloc) {
-    const ptr = malloc(array.length * 4, 4) >>> 0;
-    const mem = getDataViewMemory0();
-    for (let i = 0; i < array.length; i++) {
-        mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
-    }
-    WASM_VECTOR_LEN = array.length;
-    return ptr;
+/**
+ * Exports the global range calculation between two positions.
+ * @param {number} packed_pos_1
+ * @param {number} packed_pos_2
+ * @returns {number}
+ */
+function get_range(packed_pos_1, packed_pos_2) {
+    const ret = wasm.get_range(packed_pos_1, packed_pos_2);
+    return ret >>> 0;
 }
+
 /**
  * WASM wrapper for the BFS distance map function.
  * @param {Uint32Array} start_packed
@@ -233,19 +243,53 @@ function js_bfs_distance_map(start_packed, cost_matrix) {
 }
 
 /**
- * WASM wrapper for the BFS mono flow field function.
+ * WASM wrapper for the BFS flow field function.
+ * @param {Uint32Array} start_packed
+ * @param {ClockworkCostMatrix} cost_matrix
+ * @returns {FlowField}
+ */
+function js_bfs_flow_field(start_packed, cost_matrix) {
+    const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    _assertClass(cost_matrix, ClockworkCostMatrix);
+    const ret = wasm.js_bfs_flow_field(ptr0, len0, cost_matrix.__wbg_ptr);
+    return FlowField.__wrap(ret);
+}
+
+/**
+ * WASM wrapper for the Dijkstra mono flow field function.
  * @param {Uint32Array} start_packed
  * @param {ClockworkCostMatrix} cost_matrix
  * @returns {MonoFlowField}
  */
-function js_bfs_mono_flow_field(start_packed, cost_matrix) {
+function js_dijkstra_mono_flow_field(start_packed, cost_matrix) {
     const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     _assertClass(cost_matrix, ClockworkCostMatrix);
-    const ret = wasm.js_bfs_mono_flow_field(ptr0, len0, cost_matrix.__wbg_ptr);
+    const ret = wasm.js_dijkstra_mono_flow_field(ptr0, len0, cost_matrix.__wbg_ptr);
     return MonoFlowField.__wrap(ret);
 }
 
+/**
+ * @param {number} start
+ * @param {FlowField} flow_field
+ * @returns {Path}
+ */
+function js_path_to_flow_field_origin(start, flow_field) {
+    _assertClass(flow_field, FlowField);
+    const ret = wasm.js_path_to_flow_field_origin(start, flow_field.__wbg_ptr);
+    return Path$1.__wrap(ret);
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_exn_store(addHeapObject(e));
+    }
+}
+
+function notDefined(what) { return () => { throw new Error(`${what} is not defined`); }; }
 /**
  * Translates `COLOR_*` and `COLORS_ALL` constants.
  */
@@ -300,6 +344,10 @@ Object.freeze({ GenerateOps:1,"1":"GenerateOps",OperateSpawn:2,"2":"OperateSpawn
  */
 Object.freeze({ Plain:0,"0":"Plain",Wall:1,"1":"Wall",Swamp:2,"2":"Swamp", });
 
+const __wbindgen_enum_Look = ["creep", "energy", "resource", "source", "mineral", "structure", "flag", "constructionSite", "nuke", "terrain", "tombstone", "powerCreep", "deposit", "ruin", "scoreContainer", "scoreCollector", "symbolContainer", "symbolDecoder", "reactor"];
+
+const __wbindgen_enum_StructureType = ["spawn", "extension", "road", "constructedWall", "rampart", "keeperLair", "portal", "controller", "link", "storage", "tower", "observer", "powerBank", "powerSpawn", "extractor", "lab", "terminal", "container", "nuker", "factory", "invaderCore"];
+
 const ClockworkCostMatrixFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_clockworkcostmatrix_free(ptr >>> 0, 1));
@@ -559,6 +607,118 @@ class MonoFlowField {
     }
 }
 
+const PathFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_path_free(ptr >>> 0, 1));
+/**
+ * A list of positions representing a path.
+ */
+class Path$1 {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Path$1.prototype);
+        obj.__wbg_ptr = ptr;
+        PathFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PathFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_path_free(ptr, 0);
+    }
+    /**
+     * @param {number} packed_position
+     */
+    add(packed_position) {
+        wasm.path_add(this.__wbg_ptr, packed_position);
+    }
+    /**
+     * @param {number} index
+     * @returns {number | undefined}
+     */
+    get(index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.path_get(retptr, this.__wbg_ptr, index);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            return r0 === 0 ? undefined : r1 >>> 0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    len() {
+        const ret = wasm.path_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Given a position, find the index of the next adjacent position
+     * in the path. If the position is not in the path, the target is
+     * the next adjacent position closest to the end of the path. If
+     * the position is neither on nor adjacent to the path, return None.
+     * @param {number} packed_position
+     * @returns {number | undefined}
+     */
+    find_next_index(packed_position) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.path_find_next_index(retptr, this.__wbg_ptr, packed_position);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            return r0 === 0 ? undefined : r1 >>> 0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    to_array() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.path_to_array(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_free(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    to_array_reversed() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.path_to_array_reversed(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_free(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+
+(typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_pathfatigue_free(ptr >>> 0, 1));
+
 (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_searchgoal_free(ptr >>> 0, 1));
@@ -569,9 +729,13 @@ function __wbg_get_imports() {
     imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
         takeObject(arg0);
     };
-    imports.wbg.__wbindgen_number_new = function(arg0) {
-        const ret = arg0;
-        return addHeapObject(ret);
+    imports.wbg.__wbindgen_is_null = function(arg0) {
+        const ret = getObject(arg0) === null;
+        return ret;
+    };
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = getObject(arg0) === undefined;
+        return ret;
     };
     imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
         const obj = getObject(arg1);
@@ -579,23 +743,64 @@ function __wbg_get_imports() {
         getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
     };
+    imports.wbg.__wbindgen_number_new = function(arg0) {
+        const ret = arg0;
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_try_into_number = function(arg0) {
         let result;
     try { result = +getObject(arg0); } catch (e) { result = e; }
     const ret = result;
     return addHeapObject(ret);
 };
-imports.wbg.__wbg_static_accessor_ROOM_POSITION_PROTOTYPE_359d8a1531b99b4c = function() {
-    const ret = RoomPosition.prototype;
+imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
     return addHeapObject(ret);
 };
 imports.wbg.__wbg_setpacked_e36387710a3ff5bb = function(arg0, arg1) {
     getObject(arg0).__packedPos = arg1 >>> 0;
 };
+imports.wbg.__wbg_getvalue_b80bdd3552834f00 = function(arg0, arg1) {
+    const ret = getObject(arg0)[getObject(arg1)];
+    return addHeapObject(ret);
+};
+imports.wbg.__wbg_getRoomTerrain_de7e854c5bcae92b = function() { return handleError(function (arg0) {
+    const ret = Game.map.getRoomTerrain(getObject(arg0));
+    return addHeapObject(ret);
+}, arguments) };
+imports.wbg.__wbg_lookFor_649f089b6bfdb0c7 = function() { return handleError(function (arg0, arg1) {
+    const ret = getObject(arg0).lookFor(__wbindgen_enum_Look[arg1]);
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+}, arguments) };
+imports.wbg.__wbg_rooms_8265844828084f14 = function() {
+    const ret = Game.rooms;
+    return addHeapObject(ret);
+};
+imports.wbg.__wbg_static_accessor_ROOM_POSITION_PROTOTYPE_359d8a1531b99b4c = function() {
+    const ret = RoomPosition.prototype;
+    return addHeapObject(ret);
+};
+imports.wbg.__wbg_structuretype_f649797e27122f54 = function(arg0) {
+    const ret = getObject(arg0).structureType;
+    return (__wbindgen_enum_StructureType.indexOf(ret) + 1 || 22) - 1;
+};
+imports.wbg.__wbg_get_ac6072ecac1ab4ec = function(arg0, arg1, arg2) {
+    const ret = getObject(arg0).get(arg1, arg2);
+    return ret;
+};
+imports.wbg.__wbg_get_5419cf6b954aa11d = function(arg0, arg1) {
+    const ret = getObject(arg0)[arg1 >>> 0];
+    return addHeapObject(ret);
+};
+imports.wbg.__wbg_length_f217bbbf7e8e4df4 = function(arg0) {
+    const ret = getObject(arg0).length;
+    return ret;
+};
 imports.wbg.__wbg_create_70ef5302cb22a5c4 = function(arg0) {
     const ret = Object.create(getObject(arg0));
     return addHeapObject(ret);
 };
+imports.wbg.__wbg_ceil_f6b5b24722eb28de = typeof Math.ceil == 'function' ? Math.ceil : notDefined('Math.ceil');
 imports.wbg.__wbindgen_throw = function(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 };
@@ -648,6 +853,9 @@ function initSync(module) {
  * This might be useful for creeps with only MOVE parts and/or empty
  * CARRY parts, which don't generate fatigue.
  *
+ * Note that the `roomName` on start positions is ignored - all positions
+ * are assumed to be in the same room as the cost matrix.
+ *
  * @param start - The starting positions.
  * @param costMatrix - The cost matrix to use for the flow field.
  * @returns The flow field.
@@ -689,6 +897,9 @@ function bfsFlowField(start, costMatrix) {
  * This might be useful for creeps with only MOVE parts and/or empty
  * CARRY parts, which don't generate fatigue.
  *
+ * Note that the `roomName` on start positions is ignored - all positions
+ * are assumed to be in the same room as the cost matrix.
+ *
  * @param start - The starting positions.
  * @param costMatrix - The cost matrix to use for the flow field.
  * @returns The flow field.
@@ -708,6 +919,9 @@ function bfsMonoFlowField(start, costMatrix) {
  * Note that values of 0 in the cost matrix may have unexpected behavior. You probably want
  * a cost matrix with a default value of at least 1.
  *
+ * Note that the `roomName` on start positions is ignored - all positions
+ * are assumed to be in the same room as the cost matrix.
+ *
  * @param start - The starting positions.
  * @param costMatrix - The cost matrix to use for the flow field.
  * @returns The flow field.
@@ -745,6 +959,9 @@ function dijkstraFlowField(start, costMatrix) {
  * Note that values of 0 in the cost matrix may have unexpected behavior. You probably want
  * a cost matrix with a default value of at least 1.
  *
+ * Note that the `roomName` on start positions is ignored - all positions
+ * are assumed to be in the same room as the cost matrix.
+ *
  * @param start - The starting positions.
  * @param costMatrix - The cost matrix to use for the flow field.
  * @returns The flow field.
@@ -768,6 +985,90 @@ function getRange(pos1, pos2) {
     return get_range(pos1.__packedPos, pos2.__packedPos);
 }
 
+function fromPacked(packedPos) {
+    const pos = Object.create(RoomPosition.prototype);
+    pos.__packedPos = packedPos;
+    return pos;
+}
+
+class Path {
+    constructor(path) {
+        this.path = path;
+    }
+    [Symbol.iterator]() {
+        let index = 0;
+        const length = this.length;
+        return {
+            next: () => {
+                if (index < length - 1) {
+                    return { value: this.get(index++), done: false };
+                }
+                else {
+                    return { value: this.get(index++), done: true };
+                }
+            }
+        };
+    }
+    /**
+     * Iterate over the path in reverse order
+     */
+    *reversed() {
+        let index = this.length - 1;
+        return {
+            next: () => {
+                if (index > 0) {
+                    return { value: this.get(index--), done: false };
+                }
+                else {
+                    return { value: this.get(index--), done: true };
+                }
+            }
+        };
+    }
+    get(index) {
+        const packedPos = this.path.get(index);
+        if (packedPos === undefined) {
+            throw new Error('Index out of bounds');
+        }
+        return fromPacked(packedPos);
+    }
+    get length() {
+        return this.path.len();
+    }
+    findNextIndex(index) {
+        return this.path.find_next_index(index);
+    }
+    toArray() {
+        const result = [];
+        for (const packedPos of this.path.to_array()) {
+            result.push(fromPacked(packedPos));
+        }
+        return result;
+    }
+    toArrayReversed() {
+        const result = [];
+        for (const packedPos of this.path.to_array_reversed()) {
+            result.push(fromPacked(packedPos));
+        }
+        return result;
+    }
+    free() {
+        this.path.free();
+    }
+}
+
+function pathToDistanceMapOrigin(start, distanceMap) {
+    return new Path(js_path_to_distance_map_origin(start.__packedPos, distanceMap));
+}
+
+function pathToFlowFieldOrigin(start, flowField) {
+    return new Path(js_path_to_flow_field_origin(start.__packedPos, flowField));
+}
+
+function pathToMonoFlowFieldOrigin(start, flowField) {
+    return new Path(js_path_to_mono_flow_field_origin(start.__packedPos, flowField));
+}
+
 let wasm_bytes;
 let wasm_module;
 let wasm_instance;
@@ -802,6 +1103,7 @@ exports.ClockworkCostMatrix = ClockworkCostMatrix;
 exports.DistanceMap = DistanceMap;
 exports.FlowField = FlowField;
 exports.MonoFlowField = MonoFlowField;
+exports.Path = Path;
 exports.bfsDistanceMap = bfsDistanceMap;
 exports.bfsFlowField = bfsFlowField;
 exports.bfsMonoFlowField = bfsMonoFlowField;
@@ -810,4 +1112,7 @@ exports.dijkstraFlowField = dijkstraFlowField;
 exports.dijkstraMonoFlowField = dijkstraMonoFlowField;
 exports.getRange = getRange;
 exports.initialize = initialize;
+exports.pathToDistanceMapOrigin = pathToDistanceMapOrigin;
+exports.pathToFlowFieldOrigin = pathToFlowFieldOrigin;
+exports.pathToMonoFlowFieldOrigin = pathToMonoFlowFieldOrigin;
 //# sourceMappingURL=index.js.map