screeps-clockwork 0.7.2 → 0.9.0

package/dist/index.js

@@ -25,393 +25,71 @@ function requireEncoderDecoderTogether_min () {
 requireEncoderDecoderTogether_min();
 
 function clockworkcostmatrix_get_pointer(value) {
-        if (!value || 
-            typeof value !== 'object' || 
-            !('__wbg_ptr' in value) ||
-            value.constructor.name !== 'ClockworkCostMatrix') {
-            return 0;
-        }
-        return value.__wbg_ptr;
-    }
-
-let wasm;
-
-const heap = new Array(128).fill(undefined);
-
-heap.push(undefined, null, true, false);
-
-function getObject(idx) { return heap[idx]; }
-
-let heap_next = heap.length;
-
-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 handleError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        wasm.__wbindgen_exn_store(addHeapObject(e));
-    }
-}
-
-function dropObject(idx) {
-    if (idx < 132) return;
-    heap[idx] = heap_next;
-    heap_next = idx;
-}
-
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
-    return ret;
-}
-
-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(); }
-let cachedUint8ArrayMemory0 = null;
-
-function getUint8ArrayMemory0() {
-    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8ArrayMemory0;
-}
-
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
-
-let WASM_VECTOR_LEN = 0;
-
-const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
-
-const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
-    ? function (arg, view) {
-    return cachedTextEncoder.encodeInto(arg, view);
-}
-    : function (arg, view) {
-    const buf = cachedTextEncoder.encode(arg);
-    view.set(buf);
-    return {
-        read: arg.length,
-        written: buf.length
-    };
-});
-
-function passStringToWasm0(arg, malloc, realloc) {
-
-    if (realloc === undefined) {
-        const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length, 1) >>> 0;
-        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
-        WASM_VECTOR_LEN = buf.length;
-        return ptr;
-    }
-
-    let len = arg.length;
-    let ptr = malloc(len, 1) >>> 0;
-
-    const mem = getUint8ArrayMemory0();
-
-    let offset = 0;
-
-    for (; offset < len; offset++) {
-        const code = arg.charCodeAt(offset);
-        if (code > 0x7F) break;
-        mem[ptr + offset] = code;
-    }
-
-    if (offset !== len) {
-        if (offset !== 0) {
-            arg = arg.slice(offset);
-        }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
-        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-        const ret = encodeString(arg, view);
-
-        offset += ret.written;
-        ptr = realloc(ptr, len, offset, 1) >>> 0;
-    }
-
-    WASM_VECTOR_LEN = offset;
-    return ptr;
-}
-
-let cachedDataViewMemory0 = null;
-
-function getDataViewMemory0() {
-    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
-        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
-    }
-    return cachedDataViewMemory0;
-}
-/**
- * @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;
-
-function getUint32ArrayMemory0() {
-    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
-        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
-    }
-    return cachedUint32ArrayMemory0;
-}
-
-function passArray32ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 4, 4) >>> 0;
-    getUint32ArrayMemory0().set(arg, ptr / 4);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-
-let stack_pointer = 128;
-
-function addBorrowedObject(obj) {
-    if (stack_pointer == 1) throw new Error('out of js stack');
-    heap[--stack_pointer] = obj;
-    return stack_pointer;
-}
-/**
- * WASM wrapper for the BFS multiroom distance map function.
- *
- * # Arguments
- * * `start_packed` - Array of packed position integers representing start positions
- * * `get_cost_matrix` - JavaScript function that returns cost matrices for rooms
- * * `max_ops` - Maximum number of tiles to explore
- * * `max_rooms` - Maximum number of rooms to explore
- * * `max_room_distance` - Maximum Manhattan distance in rooms to explore
- * * `max_path_cost` - Maximum distance in tiles to explore
- * * `any_of_destinations` - Array of packed positions to trigger early exit when any are reached
- * * `all_of_destinations` - Array of packed positions to trigger early exit when all are reached
- *
- * # Returns
- * A `MultiroomDistanceMap` containing the distances from the start positions
- * @param {Uint32Array} start_packed
- * @param {Function} get_cost_matrix
- * @param {number} max_ops
- * @param {number} max_rooms
- * @param {number} max_path_cost
- * @param {Uint32Array | null} [any_of_destinations]
- * @param {Uint32Array | null} [all_of_destinations]
- * @returns {SearchResult}
- */
-function js_bfs_multiroom_distance_map(start_packed, get_cost_matrix, max_ops, max_rooms, max_path_cost, any_of_destinations, all_of_destinations) {
-    try {
-        const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        var ptr1 = isLikeNone(any_of_destinations) ? 0 : passArray32ToWasm0(any_of_destinations, wasm.__wbindgen_malloc);
-        var len1 = WASM_VECTOR_LEN;
-        var ptr2 = isLikeNone(all_of_destinations) ? 0 : passArray32ToWasm0(all_of_destinations, wasm.__wbindgen_malloc);
-        var len2 = WASM_VECTOR_LEN;
-        const ret = wasm.js_bfs_multiroom_distance_map(ptr0, len0, addBorrowedObject(get_cost_matrix), max_ops, max_rooms, max_path_cost, ptr1, len1, ptr2, len2);
-        return SearchResult.__wrap(ret);
-    } finally {
-        heap[stack_pointer++] = undefined;
+    if (!value ||
+        typeof value !== 'object' ||
+        !('__wbg_ptr' in value) ||
+        value.constructor.name !== 'ClockworkCostMatrix') {
+        return 0;
     }
+    return value.__wbg_ptr;
 }
 
+/* @ts-self-types="./screeps_clockwork.d.ts" */
 /**
- * @param {Uint32Array} start_packed
- * @param {Function} get_cost_matrix
- * @param {number} max_ops
- * @param {number} max_rooms
- * @param {number} max_path_cost
- * @param {Uint32Array | null} [any_of_destinations]
- * @param {Uint32Array | null} [all_of_destinations]
- * @returns {SearchResult}
+ * A wrapper around the `LocalCostMatrix` type from the Screeps API.
+ * Instances can be passed between WASM and JS as a pointer, using the
+ * methods to get and set values, rather than copying the entire matrix.
  */
-function js_dijkstra_multiroom_distance_map(start_packed, get_cost_matrix, max_ops, max_rooms, max_path_cost, any_of_destinations, all_of_destinations) {
-    try {
-        const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        var ptr1 = isLikeNone(any_of_destinations) ? 0 : passArray32ToWasm0(any_of_destinations, wasm.__wbindgen_malloc);
-        var len1 = WASM_VECTOR_LEN;
-        var ptr2 = isLikeNone(all_of_destinations) ? 0 : passArray32ToWasm0(all_of_destinations, wasm.__wbindgen_malloc);
-        var len2 = WASM_VECTOR_LEN;
-        const ret = wasm.js_dijkstra_multiroom_distance_map(ptr0, len0, addBorrowedObject(get_cost_matrix), max_ops, max_rooms, max_path_cost, ptr1, len1, ptr2, len2);
-        return SearchResult.__wrap(ret);
-    } finally {
-        heap[stack_pointer++] = undefined;
+class ClockworkCostMatrix {
+    static __wrap(ptr) {
+        const obj = Object.create(ClockworkCostMatrix.prototype);
+        obj.__wbg_ptr = ptr;
+        ClockworkCostMatrixFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
     }
-}
-
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ClockworkCostMatrixFinalization.unregister(this);
+        return ptr;
     }
-}
-/**
- * @param {number} start
- * @param {MultiroomMonoFlowField} flow_field
- * @returns {Path}
- */
-function js_path_to_multiroom_mono_flow_field_origin(start, flow_field) {
-    _assertClass(flow_field, MultiroomMonoFlowField);
-    const ret = wasm.js_path_to_multiroom_mono_flow_field_origin(start, flow_field.__wbg_ptr);
-    return Path.__wrap(ret);
-}
-
-/**
- * Creates a monodirectional flow field for the given distance map.
- * @param {MultiroomDistanceMap} distance_map
- * @returns {MultiroomMonoFlowField}
- */
-function multiroomMonoFlowField(distance_map) {
-    _assertClass(distance_map, MultiroomDistanceMap);
-    var ptr0 = distance_map.__destroy_into_raw();
-    const ret = wasm.multiroomMonoFlowField(ptr0);
-    return MultiroomMonoFlowField.__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)));
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_clockworkcostmatrix_free(ptr, 0);
     }
-    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);
+    /**
+     * Gets the cost of a given position in the cost matrix.
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
+     */
+    get(x, y) {
+        const ret = wasm.clockworkcostmatrix_get(this.__wbg_ptr, x, y);
+        return ret;
     }
-    WASM_VECTOR_LEN = array.length;
-    return ptr;
-}
-
-function getArrayU32FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
-}
-/**
- * @param {number} room_name
- * @param {number | null} [plain_cost]
- * @param {number | null} [swamp_cost]
- * @param {number | null} [wall_cost]
- * @returns {ClockworkCostMatrix}
- */
-function get_terrain_cost_matrix(room_name, plain_cost, swamp_cost, wall_cost) {
-    const ret = wasm.get_terrain_cost_matrix(room_name, isLikeNone(plain_cost) ? 0xFFFFFF : plain_cost, isLikeNone(swamp_cost) ? 0xFFFFFF : swamp_cost, isLikeNone(wall_cost) ? 0xFFFFFF : wall_cost);
-    return ClockworkCostMatrix.__wrap(ret);
-}
-
-/**
- * Creates a flow field for the given distance map.
- * @param {MultiroomDistanceMap} distance_map
- * @returns {MultiroomFlowField}
- */
-function multiroomFlowField(distance_map) {
-    _assertClass(distance_map, MultiroomDistanceMap);
-    var ptr0 = distance_map.__destroy_into_raw();
-    const ret = wasm.multiroomFlowField(ptr0);
-    return MultiroomFlowField.__wrap(ret);
-}
-
-let cachedUint16ArrayMemory0 = null;
-
-function getUint16ArrayMemory0() {
-    if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
-        cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
+    /**
+     * Creates a new cost matrix within the WASM module. Optionally, a default value
+     * can be provided to initialize all cells in the matrix to that value.
+     * @param {number | null} [_default]
+     */
+    constructor(_default) {
+        const ret = wasm.clockworkcostmatrix_new(isLikeNone(_default) ? 0xFFFFFF : _default);
+        this.__wbg_ptr = ret;
+        ClockworkCostMatrixFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
-    return cachedUint16ArrayMemory0;
-}
-
-function getArrayU16FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
-}
-/**
- * @param {number} start
- * @param {MultiroomFlowField} flow_field
- * @returns {Path}
- */
-function js_path_to_multiroom_flow_field_origin(start, flow_field) {
-    _assertClass(flow_field, MultiroomFlowField);
-    const ret = wasm.js_path_to_multiroom_flow_field_origin(start, flow_field.__wbg_ptr);
-    return Path.__wrap(ret);
-}
-
-/**
- * @param {number} start
- * @param {MultiroomDistanceMap} distance_map
- * @returns {Path}
- */
-function js_path_to_multiroom_distance_map_origin(start, distance_map) {
-    _assertClass(distance_map, MultiroomDistanceMap);
-    const ret = wasm.js_path_to_multiroom_distance_map_origin(start, distance_map.__wbg_ptr);
-    return Path.__wrap(ret);
-}
-
-/**
- * @param {Uint32Array} start_packed
- * @param {Function} get_cost_matrix
- * @param {number} max_rooms
- * @param {number} max_ops
- * @param {number} max_path_cost
- * @param {Uint32Array | null} [any_of_destinations]
- * @param {Uint32Array | null} [all_of_destinations]
- * @returns {SearchResult}
- */
-function js_astar_multiroom_distance_map(start_packed, get_cost_matrix, max_rooms, max_ops, max_path_cost, any_of_destinations, all_of_destinations) {
-    try {
-        const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        var ptr1 = isLikeNone(any_of_destinations) ? 0 : passArray32ToWasm0(any_of_destinations, wasm.__wbindgen_malloc);
-        var len1 = WASM_VECTOR_LEN;
-        var ptr2 = isLikeNone(all_of_destinations) ? 0 : passArray32ToWasm0(all_of_destinations, wasm.__wbindgen_malloc);
-        var len2 = WASM_VECTOR_LEN;
-        const ret = wasm.js_astar_multiroom_distance_map(ptr0, len0, addBorrowedObject(get_cost_matrix), max_rooms, max_ops, max_path_cost, ptr1, len1, ptr2, len2);
-        return SearchResult.__wrap(ret);
-    } finally {
-        heap[stack_pointer++] = undefined;
+    /**
+     * Sets the cost of a given position in the cost matrix.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} value
+     */
+    set(x, y, value) {
+        wasm.clockworkcostmatrix_set(this.__wbg_ptr, x, y, value);
     }
 }
-
+if (Symbol.dispose)
+    ClockworkCostMatrix.prototype[Symbol.dispose] = ClockworkCostMatrix.prototype.free;
 /**
  * Translates `COLOR_*` and `COLORS_ALL` constants.
  * @enum {1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10}
@@ -452,6 +130,73 @@ Object.freeze({
     Left: 7, "7": "Left",
     TopLeft: 8, "8": "TopLeft",
 });
+/**
+ * @enum {0 | 1}
+ */
+const DirectionOrder = Object.freeze({
+    CardinalFirst: 0, "0": "CardinalFirst",
+    DiagonalFirst: 1, "1": "DiagonalFirst",
+});
+/**
+ * Maps a distance value onto individual room tile positions.
+ */
+class DistanceMap {
+    static __wrap(ptr) {
+        const obj = Object.create(DistanceMap.prototype);
+        obj.__wbg_ptr = ptr;
+        DistanceMapFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DistanceMapFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_distancemap_free(ptr, 0);
+    }
+    /**
+     * Gets the distance value at a given position.
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
+     */
+    get(x, y) {
+        const ret = wasm.distancemap_get(this.__wbg_ptr, x, y);
+        return ret >>> 0;
+    }
+    /**
+     * Sets the distance value at a given position.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} value
+     */
+    set(x, y, value) {
+        wasm.distancemap_set(this.__wbg_ptr, x, y, value);
+    }
+    /**
+     * Converts the distance map into a flat array of distances.
+     * @returns {Uint32Array}
+     */
+    toArray() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.distancemap_toArray(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);
+        }
+    }
+}
+if (Symbol.dispose)
+    DistanceMap.prototype[Symbol.dispose] = DistanceMap.prototype.free;
 /**
  * Type used for when the game returns a direction to an exit.
  *
@@ -521,984 +266,1191 @@ Object.freeze({
     Reactors: 10051, "10051": "Reactors",
 });
 /**
- * Translates the `EFFECT_*` constants, which are natural effect types
- * @enum {1001 | 1002}
- */
-Object.freeze({
-    Invulnerability: 1001, "1001": "Invulnerability",
-    CollapseTimer: 1002, "1002": "CollapseTimer",
-});
-/**
- * Translates the `PWR_*` constants, which are types of powers used by power
- * creeps
- * @enum {1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19}
- */
-Object.freeze({
-    GenerateOps: 1, "1": "GenerateOps",
-    OperateSpawn: 2, "2": "OperateSpawn",
-    OperateTower: 3, "3": "OperateTower",
-    OperateStorage: 4, "4": "OperateStorage",
-    OperateLab: 5, "5": "OperateLab",
-    OperateExtension: 6, "6": "OperateExtension",
-    OperateObserver: 7, "7": "OperateObserver",
-    OperateTerminal: 8, "8": "OperateTerminal",
-    DisruptSpawn: 9, "9": "DisruptSpawn",
-    DisruptTower: 10, "10": "DisruptTower",
-    Shield: 12, "12": "Shield",
-    RegenSource: 13, "13": "RegenSource",
-    RegenMineral: 14, "14": "RegenMineral",
-    DisruptTerminal: 15, "15": "DisruptTerminal",
-    OperatePower: 16, "16": "OperatePower",
-    Fortify: 17, "17": "Fortify",
-    OperateController: 18, "18": "OperateController",
-    OperateFactory: 19, "19": "OperateFactory",
-});
-/**
- * Translates `TERRAIN_*` constants.
- * @enum {0 | 1 | 2}
- */
-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));
-/**
- * A wrapper around the `LocalCostMatrix` type from the Screeps API.
- * Instances can be passed between WASM and JS as a pointer, using the
- * methods to get and set values, rather than copying the entire matrix.
+ * A flow field is a 50x50 grid (representing a room), representing viable directions
+ * to travel to reach a particular target (or targets). A given tile may have multiple
+ * equally valid directions, so we represent this as a bitfield (where each bit in an
+ * 8-bit unsigned integer represents a direction that is either viable or not).
  */
-class ClockworkCostMatrix {
-
+class FlowField {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(ClockworkCostMatrix.prototype);
+        const obj = Object.create(FlowField.prototype);
         obj.__wbg_ptr = ptr;
-        ClockworkCostMatrixFinalization.register(obj, obj.__wbg_ptr, obj);
+        FlowFieldFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        ClockworkCostMatrixFinalization.unregister(this);
+        FlowFieldFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_clockworkcostmatrix_free(ptr, 0);
+        wasm.__wbg_flowfield_free(ptr, 0);
     }
     /**
-     * Creates a new cost matrix within the WASM module. Optionally, a default value
-     * can be provided to initialize all cells in the matrix to that value.
-     * @param {number | null} [_default]
+     * Add a direction to the list of valid directions for a given coordinate.
+     * @param {number} x
+     * @param {number} y
+     * @param {Direction} direction
      */
-    constructor(_default) {
-        const ret = wasm.clockworkcostmatrix_new(isLikeNone(_default) ? 0xFFFFFF : _default);
-        this.__wbg_ptr = ret >>> 0;
-        ClockworkCostMatrixFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    addDirection(x, y, direction) {
+        wasm.flowfield_addDirection(this.__wbg_ptr, x, y, direction);
     }
     /**
-     * Gets the cost of a given position in the cost matrix.
+     * Get the internal value for a given coordinate.
      * @param {number} x
      * @param {number} y
      * @returns {number}
      */
     get(x, y) {
-        const ret = wasm.clockworkcostmatrix_get(this.__wbg_ptr, x, y);
+        const ret = wasm.flowfield_get(this.__wbg_ptr, x, y);
         return ret;
     }
     /**
-     * Sets the cost of a given position in the cost matrix.
+     * Get the list of valid directions for a given coordinate.
+     * @param {number} x
+     * @param {number} y
+     * @returns {any[]}
+     */
+    getDirections(x, y) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.flowfield_getDirections(retptr, this.__wbg_ptr, x, y);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_free(r0, r1 * 4, 4);
+            return v1;
+        }
+        finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Set the internal value for a given coordinate.
      * @param {number} x
      * @param {number} y
      * @param {number} value
      */
     set(x, y, value) {
-        wasm.clockworkcostmatrix_set(this.__wbg_ptr, x, y, value);
+        wasm.flowfield_set(this.__wbg_ptr, x, y, value);
+    }
+    /**
+     * Set the list of valid directions for a given coordinate.
+     * @param {number} x
+     * @param {number} y
+     * @param {any[]} directions
+     */
+    setDirections(x, y, directions) {
+        const ptr0 = passArrayJsValueToWasm0(directions, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.flowfield_setDirections(this.__wbg_ptr, x, y, ptr0, len0);
     }
 }
-
-const DistanceMapFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_distancemap_free(ptr >>> 0, 1));
+if (Symbol.dispose)
+    FlowField.prototype[Symbol.dispose] = FlowField.prototype.free;
 /**
- * Maps a distance value onto individual room tile positions.
+ * A flow field is a 50x50 grid (representing a room), representing viable directions
+ * to travel to reach a particular target (or targets). A mono flow field only stores
+ * a single direction for each tile, so we represent this as 4 bits of an unsigned
+ * integer (0 for no direction, 1 for TOP, etc.).
  */
-class DistanceMap {
-
+class MonoFlowField {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(DistanceMap.prototype);
+        const obj = Object.create(MonoFlowField.prototype);
         obj.__wbg_ptr = ptr;
-        DistanceMapFinalization.register(obj, obj.__wbg_ptr, obj);
+        MonoFlowFieldFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        DistanceMapFinalization.unregister(this);
+        MonoFlowFieldFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_distancemap_free(ptr, 0);
+        wasm.__wbg_monoflowfield_free(ptr, 0);
     }
     /**
-     * Gets the distance value at a given position.
+     * Get the direction for a given coordinate.
      * @param {number} x
      * @param {number} y
-     * @returns {number}
+     * @returns {Direction | undefined}
      */
     get(x, y) {
-        const ret = wasm.distancemap_get(this.__wbg_ptr, x, y);
-        return ret >>> 0;
+        const ret = wasm.monoflowfield_get(this.__wbg_ptr, x, y);
+        return ret === 0 ? undefined : ret;
     }
     /**
-     * Sets the distance value at a given position.
+     * Set the direction for a given coordinate.
      * @param {number} x
      * @param {number} y
-     * @param {number} value
+     * @param {Direction | null} [value]
      */
     set(x, y, value) {
-        wasm.distancemap_set(this.__wbg_ptr, x, y, value);
+        wasm.monoflowfield_set(this.__wbg_ptr, x, y, isLikeNone(value) ? 0 : value);
+    }
+}
+if (Symbol.dispose)
+    MonoFlowField.prototype[Symbol.dispose] = MonoFlowField.prototype.free;
+/**
+ * Maps distance values across multiple rooms, storing a DistanceMap for each room
+ */
+class MultiroomDistanceMap {
+    static __wrap(ptr) {
+        const obj = Object.create(MultiroomDistanceMap.prototype);
+        obj.__wbg_ptr = ptr;
+        MultiroomDistanceMapFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MultiroomDistanceMapFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_multiroomdistancemap_free(ptr, 0);
     }
     /**
-     * Converts the distance map into a flat array of distances.
-     * @returns {Uint32Array}
+     * Gets the distance value at a given position
+     * @param {number} packed_pos
+     * @returns {number}
      */
-    toArray() {
+    get(packed_pos) {
+        const ret = wasm.multiroomdistancemap_get(this.__wbg_ptr, packed_pos);
+        return ret >>> 0;
+    }
+    /**
+     * Gets the DistanceMap for a given room
+     * @param {number} room_name
+     * @returns {DistanceMap | undefined}
+     */
+    get_room(room_name) {
+        const ret = wasm.multiroomdistancemap_get_room(this.__wbg_ptr, room_name);
+        return ret === 0 ? undefined : DistanceMap.__wrap(ret);
+    }
+    /**
+     * Gets the list of rooms in the map
+     * @returns {Uint16Array}
+     */
+    get_rooms() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.distancemap_toArray(retptr, this.__wbg_ptr);
+            wasm.multiroomdistancemap_get_rooms(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);
+            var v1 = getArrayU16FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_free(r0, r1 * 2, 2);
             return v1;
-        } finally {
+        }
+        finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Creates a new empty multiroom distance map (JavaScript constructor)
+     */
+    constructor() {
+        const ret = wasm.multiroomdistancemap_js_new();
+        this.__wbg_ptr = ret;
+        MultiroomDistanceMapFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Sets the distance value at a given position
+     * @param {number} packed_pos
+     * @param {number} value
+     */
+    set(packed_pos, value) {
+        wasm.multiroomdistancemap_set(this.__wbg_ptr, packed_pos, value);
+    }
 }
-
-const FlowFieldFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_flowfield_free(ptr >>> 0, 1));
+if (Symbol.dispose)
+    MultiroomDistanceMap.prototype[Symbol.dispose] = MultiroomDistanceMap.prototype.free;
 /**
- * A flow field is a 50x50 grid (representing a room), representing viable directions
- * to travel to reach a particular target (or targets). A given tile may have multiple
- * equally valid directions, so we represent this as a bitfield (where each bit in an
- * 8-bit unsigned integer represents a direction that is either viable or not).
+ * Maps flow field values across multiple rooms, storing a FlowField for each room
  */
-class FlowField {
-
+class MultiroomFlowField {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(FlowField.prototype);
+        const obj = Object.create(MultiroomFlowField.prototype);
         obj.__wbg_ptr = ptr;
-        FlowFieldFinalization.register(obj, obj.__wbg_ptr, obj);
+        MultiroomFlowFieldFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        FlowFieldFinalization.unregister(this);
+        MultiroomFlowFieldFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_flowfield_free(ptr, 0);
+        wasm.__wbg_multiroomflowfield_free(ptr, 0);
+    }
+    /**
+     * Adds a direction to the list of valid directions at a given position (JavaScript)
+     * @param {number} packed_pos
+     * @param {Direction} direction
+     */
+    addDirection(packed_pos, direction) {
+        wasm.multiroomflowfield_addDirection(this.__wbg_ptr, packed_pos, direction);
     }
     /**
-     * Add a direction to the list of valid directions for a given coordinate.
-     * @param {number} x
-     * @param {number} y
-     * @param {Direction} direction
+     * Gets the flow field value at a given position
+     * @param {number} packed_pos
+     * @returns {number}
      */
-    addDirection(x, y, direction) {
-        wasm.flowfield_addDirection(this.__wbg_ptr, x, y, direction);
+    get(packed_pos) {
+        const ret = wasm.multiroomflowfield_get(this.__wbg_ptr, packed_pos);
+        return ret;
     }
     /**
-     * Get the list of valid directions for a given coordinate.
-     * @param {number} x
-     * @param {number} y
+     * Gets the list of valid directions at a given position (JavaScript)
+     * @param {number} packed_pos
      * @returns {any[]}
      */
-    getDirections(x, y) {
+    getDirections(packed_pos) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.flowfield_getDirections(retptr, this.__wbg_ptr, x, y);
+            wasm.multiroomflowfield_getDirections(retptr, this.__wbg_ptr, packed_pos);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
             wasm.__wbindgen_free(r0, r1 * 4, 4);
             return v1;
-        } finally {
+        }
+        finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Set the list of valid directions for a given coordinate.
-     * @param {number} x
-     * @param {number} y
-     * @param {any[]} directions
+     * Gets the FlowField for a given room
+     * @param {number} room_name
+     * @returns {FlowField | undefined}
      */
-    setDirections(x, y, directions) {
-        const ptr0 = passArrayJsValueToWasm0(directions, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.flowfield_setDirections(this.__wbg_ptr, x, y, ptr0, len0);
+    getRoom(room_name) {
+        const ret = wasm.multiroomflowfield_getRoom(this.__wbg_ptr, room_name);
+        return ret === 0 ? undefined : FlowField.__wrap(ret);
     }
     /**
-     * Get the internal value for a given coordinate.
-     * @param {number} x
-     * @param {number} y
-     * @returns {number}
+     * Gets the list of rooms in the flow field
+     * @returns {Uint16Array}
      */
-    get(x, y) {
-        const ret = wasm.flowfield_get(this.__wbg_ptr, x, y);
-        return ret;
+    getRooms() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.multiroomflowfield_getRooms(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU16FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_free(r0, r1 * 2, 2);
+            return v1;
+        }
+        finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-     * Set the internal value for a given coordinate.
-     * @param {number} x
-     * @param {number} y
+     * Creates a new empty multiroom flow field (JavaScript constructor)
+     */
+    constructor() {
+        const ret = wasm.multiroomflowfield_js_new();
+        this.__wbg_ptr = ret;
+        MultiroomFlowFieldFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Sets the flow field value at a given position
+     * @param {number} packed_pos
      * @param {number} value
      */
-    set(x, y, value) {
-        wasm.flowfield_set(this.__wbg_ptr, x, y, value);
+    set(packed_pos, value) {
+        wasm.multiroomflowfield_set(this.__wbg_ptr, packed_pos, value);
+    }
+    /**
+     * Sets the list of valid directions at a given position (JavaScript)
+     * @param {number} packed_pos
+     * @param {any[]} directions
+     */
+    setDirections(packed_pos, directions) {
+        const ptr0 = passArrayJsValueToWasm0(directions, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.multiroomflowfield_setDirections(this.__wbg_ptr, packed_pos, ptr0, len0);
     }
 }
-
-const MonoFlowFieldFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_monoflowfield_free(ptr >>> 0, 1));
+if (Symbol.dispose)
+    MultiroomFlowField.prototype[Symbol.dispose] = MultiroomFlowField.prototype.free;
 /**
- * A flow field is a 50x50 grid (representing a room), representing viable directions
- * to travel to reach a particular target (or targets). A mono flow field only stores
- * a single direction for each tile, so we represent this as 4 bits of an unsigned
- * integer (0 for no direction, 1 for TOP, etc.).
+ * Maps monodirectional flow field values across multiple rooms, storing a MonoFlowField for each room
  */
-class MonoFlowField {
-
+class MultiroomMonoFlowField {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(MonoFlowField.prototype);
+        const obj = Object.create(MultiroomMonoFlowField.prototype);
         obj.__wbg_ptr = ptr;
-        MonoFlowFieldFinalization.register(obj, obj.__wbg_ptr, obj);
+        MultiroomMonoFlowFieldFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        MonoFlowFieldFinalization.unregister(this);
+        MultiroomMonoFlowFieldFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_monoflowfield_free(ptr, 0);
+        wasm.__wbg_multiroommonoflowfield_free(ptr, 0);
     }
     /**
-     * Get the direction for a given coordinate.
-     * @param {number} x
-     * @param {number} y
+     * Gets the direction at a given position
+     * @param {number} packed_pos
      * @returns {Direction | undefined}
      */
-    get(x, y) {
-        const ret = wasm.monoflowfield_get(this.__wbg_ptr, x, y);
+    get(packed_pos) {
+        const ret = wasm.multiroommonoflowfield_get(this.__wbg_ptr, packed_pos);
         return ret === 0 ? undefined : ret;
     }
     /**
-     * Set the direction for a given coordinate.
-     * @param {number} x
-     * @param {number} y
-     * @param {Direction | null} [value]
+     * Gets the MonoFlowField for a given room
+     * @param {number} room_name
+     * @returns {MonoFlowField | undefined}
      */
-    set(x, y, value) {
-        wasm.monoflowfield_set(this.__wbg_ptr, x, y, isLikeNone(value) ? 0 : value);
+    getRoom(room_name) {
+        const ret = wasm.multiroommonoflowfield_getRoom(this.__wbg_ptr, room_name);
+        return ret === 0 ? undefined : MonoFlowField.__wrap(ret);
+    }
+    /**
+     * Gets the list of rooms in the flow field
+     * @returns {Uint16Array}
+     */
+    getRooms() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.multiroommonoflowfield_getRooms(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU16FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_free(r0, r1 * 2, 2);
+            return v1;
+        }
+        finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Creates a new empty multiroom monodirectional flow field (JavaScript constructor)
+     */
+    constructor() {
+        const ret = wasm.multiroommonoflowfield_js_new();
+        this.__wbg_ptr = ret;
+        MultiroomMonoFlowFieldFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Sets the direction at a given position
+     * @param {number} packed_pos
+     * @param {Direction | null} [direction]
+     */
+    set(packed_pos, direction) {
+        wasm.multiroommonoflowfield_set(this.__wbg_ptr, packed_pos, isLikeNone(direction) ? 0 : direction);
     }
 }
-
-const MultiroomDistanceMapFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_multiroomdistancemap_free(ptr >>> 0, 1));
+if (Symbol.dispose)
+    MultiroomMonoFlowField.prototype[Symbol.dispose] = MultiroomMonoFlowField.prototype.free;
 /**
- * Maps distance values across multiple rooms, storing a DistanceMap for each room
+ * Translates the `EFFECT_*` constants, which are natural effect types
+ * @enum {1001 | 1002}
  */
-class MultiroomDistanceMap {
-
+Object.freeze({
+    Invulnerability: 1001, "1001": "Invulnerability",
+    CollapseTimer: 1002, "1002": "CollapseTimer",
+});
+/**
+ * A list of positions representing a path.
+ */
+class Path {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(MultiroomDistanceMap.prototype);
+        const obj = Object.create(Path.prototype);
         obj.__wbg_ptr = ptr;
-        MultiroomDistanceMapFinalization.register(obj, obj.__wbg_ptr, obj);
+        PathFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        MultiroomDistanceMapFinalization.unregister(this);
+        PathFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_multiroomdistancemap_free(ptr, 0);
+        wasm.__wbg_path_free(ptr, 0);
     }
     /**
-     * Gets the DistanceMap for a given room
-     * @param {number} room_name
-     * @returns {DistanceMap | undefined}
+     * @param {number} packed_position
      */
-    get_room(room_name) {
-        const ret = wasm.multiroomdistancemap_get_room(this.__wbg_ptr, room_name);
-        return ret === 0 ? undefined : DistanceMap.__wrap(ret);
+    add(packed_position) {
+        wasm.path_add(this.__wbg_ptr, packed_position);
     }
     /**
-     * Gets the list of rooms in the map
-     * @returns {Uint16Array}
+     * 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}
      */
-    get_rooms() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.multiroomdistancemap_get_rooms(retptr, this.__wbg_ptr);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var v1 = getArrayU16FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_free(r0, r1 * 2, 2);
-            return v1;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    find_next_index(packed_position) {
+        const ret = wasm.path_find_next_index(this.__wbg_ptr, packed_position);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
+     * @param {number} index
+     * @returns {number | undefined}
+     */
+    get(index) {
+        const ret = wasm.path_get(this.__wbg_ptr, index);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
-     * Gets the distance value at a given position
-     * @param {number} packed_pos
      * @returns {number}
      */
-    get(packed_pos) {
-        const ret = wasm.multiroomdistancemap_get(this.__wbg_ptr, packed_pos);
+    len() {
+        const ret = wasm.path_len(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-     * Creates a new empty multiroom distance map (JavaScript constructor)
+     * @returns {Uint32Array}
      */
-    constructor() {
-        const ret = wasm.multiroomdistancemap_js_new();
-        this.__wbg_ptr = ret >>> 0;
-        MultiroomDistanceMapFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    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);
+        }
     }
     /**
-     * Sets the distance value at a given position
-     * @param {number} packed_pos
-     * @param {number} value
+     * @returns {Uint32Array}
      */
-    set(packed_pos, value) {
-        wasm.multiroomdistancemap_set(this.__wbg_ptr, packed_pos, value);
+    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);
+        }
     }
 }
-
-const MultiroomFlowFieldFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_multiroomflowfield_free(ptr >>> 0, 1));
+if (Symbol.dispose)
+    Path.prototype[Symbol.dispose] = Path.prototype.free;
 /**
- * Maps flow field values across multiple rooms, storing a FlowField for each room
+ * Translates the `PWR_*` constants, which are types of powers used by power
+ * creeps
+ * @enum {1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19}
  */
-class MultiroomFlowField {
-
+Object.freeze({
+    GenerateOps: 1, "1": "GenerateOps",
+    OperateSpawn: 2, "2": "OperateSpawn",
+    OperateTower: 3, "3": "OperateTower",
+    OperateStorage: 4, "4": "OperateStorage",
+    OperateLab: 5, "5": "OperateLab",
+    OperateExtension: 6, "6": "OperateExtension",
+    OperateObserver: 7, "7": "OperateObserver",
+    OperateTerminal: 8, "8": "OperateTerminal",
+    DisruptSpawn: 9, "9": "DisruptSpawn",
+    DisruptTower: 10, "10": "DisruptTower",
+    Shield: 12, "12": "Shield",
+    RegenSource: 13, "13": "RegenSource",
+    RegenMineral: 14, "14": "RegenMineral",
+    DisruptTerminal: 15, "15": "DisruptTerminal",
+    OperatePower: 16, "16": "OperatePower",
+    Fortify: 17, "17": "Fortify",
+    OperateController: 18, "18": "OperateController",
+    OperateFactory: 19, "19": "OperateFactory",
+});
+/**
+ * A distance map search returns both the distance map (filled out
+ * with all tiles explored) and the targets found. These aren't necessarily
+ * the same positions specified as targets - if the target range is 5, then
+ * this is the first position in range 5 of the target. If multiple targets
+ * are specified, and you care about matching the found target with one of
+ * the original targets, you can iterate through your list and figure out the
+ * ones that are in range of the found target(s).
+ */
+class SearchResult {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(MultiroomFlowField.prototype);
+        const obj = Object.create(SearchResult.prototype);
         obj.__wbg_ptr = ptr;
-        MultiroomFlowFieldFinalization.register(obj, obj.__wbg_ptr, obj);
+        SearchResultFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        MultiroomFlowFieldFinalization.unregister(this);
+        SearchResultFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_multiroomflowfield_free(ptr, 0);
+        wasm.__wbg_searchresult_free(ptr, 0);
     }
     /**
-     * Gets the FlowField for a given room
-     * @param {number} room_name
-     * @returns {FlowField | undefined}
+     * @returns {MultiroomDistanceMap}
      */
-    getRoom(room_name) {
-        const ret = wasm.multiroomflowfield_getRoom(this.__wbg_ptr, room_name);
-        return ret === 0 ? undefined : FlowField.__wrap(ret);
+    get distance_map() {
+        const ret = wasm.searchresult_distance_map(this.__wbg_ptr);
+        return MultiroomDistanceMap.__wrap(ret);
     }
     /**
-     * Gets the list of rooms in the flow field
-     * @returns {Uint16Array}
+     * @returns {Uint32Array}
      */
-    getRooms() {
+    get found_targets() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.multiroomflowfield_getRooms(retptr, this.__wbg_ptr);
+            wasm.searchresult_found_targets(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var v1 = getArrayU16FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_free(r0, r1 * 2, 2);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_free(r0, r1 * 4, 4);
             return v1;
-        } finally {
+        }
+        finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Adds a direction to the list of valid directions at a given position (JavaScript)
-     * @param {number} packed_pos
-     * @param {Direction} direction
+     * @returns {number}
      */
-    addDirection(packed_pos, direction) {
-        wasm.multiroomflowfield_addDirection(this.__wbg_ptr, packed_pos, direction);
+    get ops() {
+        const ret = wasm.searchresult_ops(this.__wbg_ptr);
+        return ret >>> 0;
     }
-    /**
-     * Gets the list of valid directions at a given position (JavaScript)
-     * @param {number} packed_pos
-     * @returns {any[]}
-     */
-    getDirections(packed_pos) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.multiroomflowfield_getDirections(retptr, this.__wbg_ptr, packed_pos);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
-            wasm.__wbindgen_free(r0, r1 * 4, 4);
-            return v1;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+}
+if (Symbol.dispose)
+    SearchResult.prototype[Symbol.dispose] = SearchResult.prototype.free;
+/**
+ * Translates `TERRAIN_*` constants.
+ * @enum {0 | 1 | 2}
+ */
+Object.freeze({
+    Plain: 0, "0": "Plain",
+    Wall: 1, "1": "Wall",
+    Swamp: 2, "2": "Swamp",
+});
+/**
+ * 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;
+}
+/**
+ * @param {number} room_name
+ * @param {number | null} [plain_cost]
+ * @param {number | null} [swamp_cost]
+ * @param {number | null} [wall_cost]
+ * @returns {ClockworkCostMatrix}
+ */
+function get_terrain_cost_matrix(room_name, plain_cost, swamp_cost, wall_cost) {
+    const ret = wasm.get_terrain_cost_matrix(room_name, isLikeNone(plain_cost) ? 0xFFFFFF : plain_cost, isLikeNone(swamp_cost) ? 0xFFFFFF : swamp_cost, isLikeNone(wall_cost) ? 0xFFFFFF : wall_cost);
+    return ClockworkCostMatrix.__wrap(ret);
+}
+/**
+ * @param {Uint32Array} start_packed
+ * @param {Function} get_cost_matrix
+ * @param {number} max_rooms
+ * @param {number} max_ops
+ * @param {number} max_path_cost
+ * @param {Uint32Array | null} [any_of_destinations]
+ * @param {Uint32Array | null} [all_of_destinations]
+ * @returns {SearchResult}
+ */
+function js_astar_multiroom_distance_map(start_packed, get_cost_matrix, max_rooms, max_ops, max_path_cost, any_of_destinations, all_of_destinations) {
+    try {
+        const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(any_of_destinations) ? 0 : passArray32ToWasm0(any_of_destinations, wasm.__wbindgen_malloc);
+        var len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(all_of_destinations) ? 0 : passArray32ToWasm0(all_of_destinations, wasm.__wbindgen_malloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.js_astar_multiroom_distance_map(ptr0, len0, addBorrowedObject(get_cost_matrix), max_rooms, max_ops, max_path_cost, ptr1, len1, ptr2, len2);
+        return SearchResult.__wrap(ret);
     }
-    /**
-     * Sets the list of valid directions at a given position (JavaScript)
-     * @param {number} packed_pos
-     * @param {any[]} directions
-     */
-    setDirections(packed_pos, directions) {
-        const ptr0 = passArrayJsValueToWasm0(directions, wasm.__wbindgen_malloc);
+    finally {
+        heap[stack_pointer++] = undefined;
+    }
+}
+/**
+ * WASM wrapper for the BFS multiroom distance map function.
+ *
+ * # Arguments
+ * * `start_packed` - Array of packed position integers representing start positions
+ * * `get_cost_matrix` - JavaScript function that returns cost matrices for rooms
+ * * `max_ops` - Maximum number of tiles to explore
+ * * `max_rooms` - Maximum number of rooms to explore
+ * * `max_room_distance` - Maximum Manhattan distance in rooms to explore
+ * * `max_path_cost` - Maximum distance in tiles to explore
+ * * `any_of_destinations` - Array of packed positions to trigger early exit when any are reached
+ * * `all_of_destinations` - Array of packed positions to trigger early exit when all are reached
+ *
+ * # Returns
+ * A `MultiroomDistanceMap` containing the distances from the start positions
+ * @param {Uint32Array} start_packed
+ * @param {Function} get_cost_matrix
+ * @param {number} max_ops
+ * @param {number} max_rooms
+ * @param {number} max_path_cost
+ * @param {Uint32Array | null} [any_of_destinations]
+ * @param {Uint32Array | null} [all_of_destinations]
+ * @returns {SearchResult}
+ */
+function js_bfs_multiroom_distance_map(start_packed, get_cost_matrix, max_ops, max_rooms, max_path_cost, any_of_destinations, all_of_destinations) {
+    try {
+        const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.multiroomflowfield_setDirections(this.__wbg_ptr, packed_pos, ptr0, len0);
+        var ptr1 = isLikeNone(any_of_destinations) ? 0 : passArray32ToWasm0(any_of_destinations, wasm.__wbindgen_malloc);
+        var len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(all_of_destinations) ? 0 : passArray32ToWasm0(all_of_destinations, wasm.__wbindgen_malloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.js_bfs_multiroom_distance_map(ptr0, len0, addBorrowedObject(get_cost_matrix), max_ops, max_rooms, max_path_cost, ptr1, len1, ptr2, len2);
+        return SearchResult.__wrap(ret);
     }
-    /**
-     * Gets the flow field value at a given position
-     * @param {number} packed_pos
-     * @returns {number}
-     */
-    get(packed_pos) {
-        const ret = wasm.multiroomflowfield_get(this.__wbg_ptr, packed_pos);
-        return ret;
+    finally {
+        heap[stack_pointer++] = undefined;
     }
-    /**
-     * Creates a new empty multiroom flow field (JavaScript constructor)
-     */
-    constructor() {
-        const ret = wasm.multiroomdistancemap_js_new();
-        this.__wbg_ptr = ret >>> 0;
-        MultiroomFlowFieldFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+}
+/**
+ * @param {Uint32Array} start_packed
+ * @param {Function} get_cost_matrix
+ * @param {number} max_ops
+ * @param {number} max_rooms
+ * @param {number} max_path_cost
+ * @param {Uint32Array | null} [any_of_destinations]
+ * @param {Uint32Array | null} [all_of_destinations]
+ * @returns {SearchResult}
+ */
+function js_dijkstra_multiroom_distance_map(start_packed, get_cost_matrix, max_ops, max_rooms, max_path_cost, any_of_destinations, all_of_destinations) {
+    try {
+        const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(any_of_destinations) ? 0 : passArray32ToWasm0(any_of_destinations, wasm.__wbindgen_malloc);
+        var len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(all_of_destinations) ? 0 : passArray32ToWasm0(all_of_destinations, wasm.__wbindgen_malloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.js_dijkstra_multiroom_distance_map(ptr0, len0, addBorrowedObject(get_cost_matrix), max_ops, max_rooms, max_path_cost, ptr1, len1, ptr2, len2);
+        return SearchResult.__wrap(ret);
     }
-    /**
-     * Sets the flow field value at a given position
-     * @param {number} packed_pos
-     * @param {number} value
-     */
-    set(packed_pos, value) {
-        wasm.multiroomflowfield_set(this.__wbg_ptr, packed_pos, value);
+    finally {
+        heap[stack_pointer++] = undefined;
+    }
+}
+/**
+ * @param {number} start
+ * @param {MultiroomDistanceMap} distance_map
+ * @param {DirectionOrder} direction_order
+ * @returns {Path}
+ */
+function js_path_to_multiroom_distance_map_origin(start, distance_map, direction_order) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        _assertClass(distance_map, MultiroomDistanceMap);
+        wasm.js_path_to_multiroom_distance_map_origin(retptr, start, distance_map.__wbg_ptr, direction_order);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return Path.__wrap(r0);
+    }
+    finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
-
-const MultiroomMonoFlowFieldFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_multiroommonoflowfield_free(ptr >>> 0, 1));
 /**
- * Maps monodirectional flow field values across multiple rooms, storing a MonoFlowField for each room
+ * @param {number} start
+ * @param {MultiroomFlowField} flow_field
+ * @returns {Path}
  */
-class MultiroomMonoFlowField {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(MultiroomMonoFlowField.prototype);
-        obj.__wbg_ptr = ptr;
-        MultiroomMonoFlowFieldFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        MultiroomMonoFlowFieldFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_multiroommonoflowfield_free(ptr, 0);
-    }
-    /**
-     * Gets the MonoFlowField for a given room
-     * @param {number} room_name
-     * @returns {MonoFlowField | undefined}
-     */
-    getRoom(room_name) {
-        const ret = wasm.multiroommonoflowfield_getRoom(this.__wbg_ptr, room_name);
-        return ret === 0 ? undefined : MonoFlowField.__wrap(ret);
-    }
-    /**
-     * Gets the list of rooms in the flow field
-     * @returns {Uint16Array}
-     */
-    getRooms() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.multiroommonoflowfield_getRooms(retptr, this.__wbg_ptr);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var v1 = getArrayU16FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_free(r0, r1 * 2, 2);
-            return v1;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
+function js_path_to_multiroom_flow_field_origin(start, flow_field) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        _assertClass(flow_field, MultiroomFlowField);
+        wasm.js_path_to_multiroom_flow_field_origin(retptr, start, flow_field.__wbg_ptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
         }
+        return Path.__wrap(r0);
     }
-    /**
-     * Gets the direction at a given position
-     * @param {number} packed_pos
-     * @returns {Direction | undefined}
-     */
-    get(packed_pos) {
-        const ret = wasm.multiroommonoflowfield_get(this.__wbg_ptr, packed_pos);
-        return ret === 0 ? undefined : ret;
+    finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
     }
-    /**
-     * Creates a new empty multiroom monodirectional flow field (JavaScript constructor)
-     */
-    constructor() {
-        const ret = wasm.multiroommonoflowfield_js_new();
-        this.__wbg_ptr = ret >>> 0;
-        MultiroomMonoFlowFieldFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+}
+/**
+ * @param {number} start
+ * @param {MultiroomMonoFlowField} flow_field
+ * @returns {Path}
+ */
+function js_path_to_multiroom_mono_flow_field_origin(start, flow_field) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        _assertClass(flow_field, MultiroomMonoFlowField);
+        wasm.js_path_to_multiroom_mono_flow_field_origin(retptr, start, flow_field.__wbg_ptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return Path.__wrap(r0);
     }
-    /**
-     * Sets the direction at a given position
-     * @param {number} packed_pos
-     * @param {Direction | null} [direction]
-     */
-    set(packed_pos, direction) {
-        wasm.multiroommonoflowfield_set(this.__wbg_ptr, packed_pos, isLikeNone(direction) ? 0 : direction);
+    finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
-
-const PathFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_path_free(ptr >>> 0, 1));
 /**
- * A list of positions representing a path.
+ * Creates a flow field for the given distance map.
+ * @param {MultiroomDistanceMap} distance_map
+ * @param {DirectionOrder} direction_order
+ * @returns {MultiroomFlowField}
  */
-class Path {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Path.prototype);
-        obj.__wbg_ptr = ptr;
-        PathFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
+function multiroomFlowField(distance_map, direction_order) {
+    _assertClass(distance_map, MultiroomDistanceMap);
+    const ret = wasm.multiroomFlowField(distance_map.__wbg_ptr, direction_order);
+    return MultiroomFlowField.__wrap(ret);
+}
+/**
+ * Creates a monodirectional flow field for the given distance map.
+ * @param {MultiroomDistanceMap} distance_map
+ * @param {DirectionOrder} direction_order
+ * @returns {MultiroomMonoFlowField}
+ */
+function multiroomMonoFlowField(distance_map, direction_order) {
+    _assertClass(distance_map, MultiroomDistanceMap);
+    const ret = wasm.multiroomMonoFlowField(distance_map.__wbg_ptr, direction_order);
+    return MultiroomMonoFlowField.__wrap(ret);
+}
+/**
+ * @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);
     }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        PathFinalization.unregister(this);
-        return ptr;
+    finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_path_free(ptr, 0);
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_is_null_2042690d351e14f0: function (arg0) {
+            const ret = getObject(arg0) === null;
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_35bb9f4c7fd651d5: function (arg0) {
+            const ret = getObject(arg0) === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_number_get_f73a1244370fcc2c: function (arg0, arg1) {
+            const obj = getObject(arg1);
+            const ret = typeof (obj) === 'number' ? obj : undefined;
+            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
+        __wbg___wbindgen_rethrow_2b7cc655458909c2: function (arg0) {
+            throw takeObject(arg0);
+        },
+        __wbg___wbindgen_throw_9c31b086c2b26051: function (arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_call_dfde26266607c996: function () {
+            return handleError(function (arg0, arg1, arg2) {
+                const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+                return addHeapObject(ret);
+            }, arguments);
+        },
+        __wbg_ceil_2f02237b685bdce4: function (arg0) {
+            const ret = Math.ceil(arg0);
+            return ret;
+        },
+        __wbg_clockworkcostmatrix_get_pointer_79c3c65971038fea: function (arg0) {
+            const ret = clockworkcostmatrix_get_pointer(takeObject(arg0));
+            return ret;
+        },
+        __wbg_create_55d0f7a358253d86: function (arg0) {
+            const ret = Object.create(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_error_a6fa202b58aa1cd3: function (arg0, arg1) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg0;
+                deferred0_1 = arg1;
+                console.error(getStringFromWasm0(arg0, arg1));
+            }
+            finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        },
+        __wbg_getRawBuffer_2165a0506d77f9ca: function (arg0, arg1) {
+            const ret = getObject(arg0).getRawBuffer(getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_getRoomTerrain_ff542df2ea2015b1: function () {
+            return handleError(function (arg0) {
+                const ret = Game.map.getRoomTerrain(getObject(arg0));
+                return addHeapObject(ret);
+            }, arguments);
+        },
+        __wbg_get_8f8e5734959cd5fc: function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).get(arg1, arg2);
+            return ret;
+        },
+        __wbg_get_unchecked_1dfe6d05ad91d9b7: function (arg0, arg1) {
+            const ret = getObject(arg0)[arg1 >>> 0];
+            return addHeapObject(ret);
+        },
+        __wbg_get_value_3083233b2ad9f36e: function (arg0, arg1) {
+            const ret = getObject(arg0)[getObject(arg1)];
+            return addHeapObject(ret);
+        },
+        __wbg_length_2591a0f4f659a55c: function (arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_log_c30a21014b80980e: function (arg0, arg1) {
+            console.log(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_lookFor_0ddc4d9f22e9bfe5: function () {
+            return handleError(function (arg0, arg1) {
+                const ret = getObject(arg0).lookFor(__wbindgen_enum_Look[arg1]);
+                return isLikeNone(ret) ? 0 : addHeapObject(ret);
+            }, arguments);
+        },
+        __wbg_new_1f236d63ba0c4784: function (arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_new_227d7c05414eb861: function () {
+            const ret = new Error();
+            return addHeapObject(ret);
+        },
+        __wbg_new_internal_dc21004de3373c5f: function () {
+            return handleError(function (arg0) {
+                const ret = new Room.Terrain(getObject(arg0));
+                return addHeapObject(ret);
+            }, arguments);
+        },
+        __wbg_rooms_c5dbffde521939da: function () {
+            const ret = Game.rooms;
+            return addHeapObject(ret);
+        },
+        __wbg_set_packed_cc769b1ab2aa7e8e: function (arg0, arg1) {
+            getObject(arg0).__packedPos = arg1 >>> 0;
+        },
+        __wbg_stack_3b0d974bbf31e44f: function (arg0, arg1) {
+            const ret = getObject(arg1).stack;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_static_accessor_ROOM_POSITION_PROTOTYPE_9def1bb4de86c8f7: function () {
+            const ret = RoomPosition.prototype;
+            return addHeapObject(ret);
+        },
+        __wbg_structure_type_dbc211ed19dd8423: function (arg0) {
+            const ret = getObject(arg0).structureType;
+            return (__wbindgen_enum_StructureType.indexOf(ret) + 1 || 22) - 1;
+        },
+        __wbindgen_cast_0000000000000001: function (arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000002: function (arg0, arg1) {
+            // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+            const ret = getArrayU8FromWasm0(arg0, arg1);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000003: function (arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_drop_ref: function (arg0) {
+            takeObject(arg0);
+        },
+    };
+    return {
+        __proto__: null,
+        "./screeps_clockwork_bg.js": import0,
+    };
+}
+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, 1));
+const DistanceMapFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => { }, unregister: () => { } }
+    : new FinalizationRegistry(ptr => wasm.__wbg_distancemap_free(ptr, 1));
+const FlowFieldFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => { }, unregister: () => { } }
+    : new FinalizationRegistry(ptr => wasm.__wbg_flowfield_free(ptr, 1));
+const MonoFlowFieldFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => { }, unregister: () => { } }
+    : new FinalizationRegistry(ptr => wasm.__wbg_monoflowfield_free(ptr, 1));
+const MultiroomDistanceMapFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => { }, unregister: () => { } }
+    : new FinalizationRegistry(ptr => wasm.__wbg_multiroomdistancemap_free(ptr, 1));
+const MultiroomFlowFieldFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => { }, unregister: () => { } }
+    : new FinalizationRegistry(ptr => wasm.__wbg_multiroomflowfield_free(ptr, 1));
+const MultiroomMonoFlowFieldFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => { }, unregister: () => { } }
+    : new FinalizationRegistry(ptr => wasm.__wbg_multiroommonoflowfield_free(ptr, 1));
+const PathFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => { }, unregister: () => { } }
+    : new FinalizationRegistry(ptr => wasm.__wbg_path_free(ptr, 1));
+(typeof FinalizationRegistry === 'undefined')
+    ? { register: () => { }, unregister: () => { } }
+    : new FinalizationRegistry(ptr => wasm.__wbg_pathfatigue_free(ptr, 1));
+(typeof FinalizationRegistry === 'undefined')
+    ? { register: () => { }, unregister: () => { } }
+    : new FinalizationRegistry(ptr => wasm.__wbg_searchgoal_free(ptr, 1));
+const SearchResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => { }, unregister: () => { } }
+    : new FinalizationRegistry(ptr => wasm.__wbg_searchresult_free(ptr, 1));
+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 _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
     }
-    /**
-     * @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);
-        }
+}
+function addBorrowedObject(obj) {
+    if (stack_pointer == 1)
+        throw new Error('out of js stack');
+    heap[--stack_pointer] = obj;
+    return stack_pointer;
+}
+function dropObject(idx) {
+    if (idx < 1028)
+        return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+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)));
     }
-    /**
-     * 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) {
-        const ret = wasm.path_find_next_index(this.__wbg_ptr, packed_position);
-        return ret === 0x100000001 ? undefined : ret;
+    return result;
+}
+function getArrayU16FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
+}
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
     }
-    /**
-     * @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);
-        }
+    return cachedDataViewMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+let cachedUint16ArrayMemory0 = null;
+function getUint16ArrayMemory0() {
+    if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
+        cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
+    }
+    return cachedUint16ArrayMemory0;
+}
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
     }
-    /**
-     * @param {number} packed_position
-     */
-    add(packed_position) {
-        wasm.path_add(this.__wbg_ptr, packed_position);
+    return cachedUint32ArrayMemory0;
+}
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
     }
-    /**
-     * @param {number} index
-     * @returns {number | undefined}
-     */
-    get(index) {
-        const ret = wasm.path_get(this.__wbg_ptr, index);
-        return ret === 0x100000001 ? undefined : ret;
+    return cachedUint8ArrayMemory0;
+}
+function getObject(idx) { return heap[idx]; }
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
     }
-    /**
-     * @returns {number}
-     */
-    len() {
-        const ret = wasm.path_len(this.__wbg_ptr);
-        return ret >>> 0;
+    catch (e) {
+        wasm.__wbindgen_exn_store(addHeapObject(e));
     }
 }
-
-(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));
-
-const SearchResultFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_searchresult_free(ptr >>> 0, 1));
-/**
- * A distance map search returns both the distance map (filled out
- * with all tiles explored) and the targets found. These aren't necessarily
- * the same positions specified as targets - if the target range is 5, then
- * this is the first position in range 5 of the target. If multiple targets
- * are specified, and you care about matching the found target with one of
- * the original targets, you can iterate through your list and figure out the
- * ones that are in range of the found target(s).
- */
-class SearchResult {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(SearchResult.prototype);
-        obj.__wbg_ptr = ptr;
-        SearchResultFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
+let heap = new Array(1024).fill(undefined);
+heap.push(undefined, null, true, false);
+let heap_next = heap.length;
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+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 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);
     }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        SearchResultFinalization.unregister(this);
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
         return ptr;
     }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_searchresult_free(ptr, 0);
-    }
-    /**
-     * @returns {MultiroomDistanceMap}
-     */
-    get distance_map() {
-        const ret = wasm.searchresult_distance_map(this.__wbg_ptr);
-        return MultiroomDistanceMap.__wrap(ret);
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+    const mem = getUint8ArrayMemory0();
+    let offset = 0;
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F)
+            break;
+        mem[ptr + offset] = code;
     }
-    /**
-     * @returns {Uint32Array}
-     */
-    get found_targets() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.searchresult_found_targets(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);
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
         }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
     }
-    /**
-     * @returns {number}
-     */
-    get ops() {
-        const ret = wasm.searchresult_ops(this.__wbg_ptr);
-        return ret >>> 0;
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+let stack_pointer = 1024;
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
     }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
-
-function __wbg_get_imports() {
-    const imports = {};
-    imports.wbg = {};
-    imports.wbg.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
-        const ret = getObject(arg0).buffer;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_call_7cccdd69e0791ae2 = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_ceil_2a411b0e70cc0baf = function(arg0) {
-        const ret = Math.ceil(arg0);
-        return ret;
-    };
-    imports.wbg.__wbg_clockworkcostmatrixgetpointer_ee2b0a46684eb38c = function(arg0) {
-        const ret = clockworkcostmatrix_get_pointer(takeObject(arg0));
-        return ret;
-    };
-    imports.wbg.__wbg_create_cfe43ccc88c64e0a = function(arg0) {
-        const ret = Object.create(getObject(arg0));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
-        let deferred0_0;
-        let deferred0_1;
-        try {
-            deferred0_0 = arg0;
-            deferred0_1 = arg1;
-            console.error(getStringFromWasm0(arg0, arg1));
-        } finally {
-            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
-        }
-    };
-    imports.wbg.__wbg_getRawBuffer_063ad218fd3b8817 = function(arg0, arg1) {
-        const ret = getObject(arg0).getRawBuffer(getObject(arg1));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_getRoomTerrain_82fcc54e35a8985e = function() { return handleError(function (arg0) {
-        const ret = Game.map.getRoomTerrain(getObject(arg0));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_get_1f5a4efd15e39f01 = function(arg0, arg1, arg2) {
-        const ret = getObject(arg0).get(arg1, arg2);
-        return ret;
-    };
-    imports.wbg.__wbg_get_b9b93047fe3cf45b = function(arg0, arg1) {
-        const ret = getObject(arg0)[arg1 >>> 0];
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_getvalue_a18eaf2c77e125e4 = function(arg0, arg1) {
-        const ret = getObject(arg0)[getObject(arg1)];
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_length_e2d2a49132c1b256 = function(arg0) {
-        const ret = getObject(arg0).length;
-        return ret;
-    };
-    imports.wbg.__wbg_log_4a86514c61094407 = function(arg0, arg1) {
-        console.log(getStringFromWasm0(arg0, arg1));
-    };
-    imports.wbg.__wbg_lookFor_04c5885fea38e9b2 = 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_new_8a6f238a6ece86ea = function() {
-        const ret = new Error();
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_newinternal_306f5ebf22959477 = function() { return handleError(function (arg0) {
-        const ret = new Room.Terrain(getObject(arg0));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_newwithbyteoffsetandlength_d97e637ebe145a9a = function(arg0, arg1, arg2) {
-        const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_rooms_c7983d4650f28959 = function() {
-        const ret = Game.rooms;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_setpacked_50526296a5796941 = function(arg0, arg1) {
-        getObject(arg0).__packedPos = arg1 >>> 0;
-    };
-    imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
-        const ret = getObject(arg1).stack;
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-    };
-    imports.wbg.__wbg_static_accessor_ROOM_POSITION_PROTOTYPE_359d8a1531b99b4c = function() {
-        const ret = RoomPosition.prototype;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_structuretype_d5991613c372a27e = function(arg0) {
-        const ret = getObject(arg0).structureType;
-        return (__wbindgen_enum_StructureType.indexOf(ret) + 1 || 22) - 1;
-    };
-    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_memory = function() {
-        const ret = wasm.memory;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
-        const obj = getObject(arg1);
-        const ret = typeof(obj) === 'number' ? obj : undefined;
-        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_object_drop_ref = function(arg0) {
-        takeObject(arg0);
-    };
-    imports.wbg.__wbindgen_rethrow = function(arg0) {
-        throw takeObject(arg0);
-    };
-    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
-        const ret = getStringFromWasm0(arg0, arg1);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
-        throw new Error(getStringFromWasm0(arg0, arg1));
-    };
-    imports.wbg.__wbindgen_try_into_number = function(arg0) {
-        let result;
-        try { result = +getObject(arg0); } catch (e) { result = e; }
-        const ret = result;
-        return addHeapObject(ret);
+const cachedTextEncoder = new TextEncoder();
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
     };
-
-    return imports;
 }
-
+let WASM_VECTOR_LEN = 0;
+let wasm;
 function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     cachedDataViewMemory0 = null;
     cachedUint16ArrayMemory0 = null;
     cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;
-
-
-
     return wasm;
 }
-
 function initSync(module) {
-    if (wasm !== undefined) return wasm;
-
-
-    if (typeof module !== 'undefined') {
+    if (wasm !== undefined)
+        return wasm;
+    if (module !== undefined) {
         if (Object.getPrototypeOf(module) === Object.prototype) {
-            ({module} = module);
-        } else {
+            ({ module } = module);
+        }
+        else {
             console.warn('using deprecated parameters for `initSync()`; pass a single object instead');
         }
     }
-
     const imports = __wbg_get_imports();
-
     if (!(module instanceof WebAssembly.Module)) {
         module = new WebAssembly.Module(module);
     }
-
     const instance = new WebAssembly.Instance(module, imports);
-
     return __wbg_finalize_init(instance);
 }
 
-const cache = new Set();
-let cacheTick = 0;
-/**
- * Mark an item as ephemeral. This means that the item will be freed after the
- * current tick.
- *
- * If you don't use this to clean up your data, you'll need to call `free()`
- * yourself.
- *
- * @param item - The item to be cleaned up.
- * @returns The item.
- */
-function ephemeral(item) {
-    if (cacheTick !== Game.time) {
-        for (const item of cache) {
-            try {
-                item.free();
-            }
-            catch (_a) {
-                // may have already been cleaned up
-            }
-        }
-        cache.clear();
-        cacheTick = Game.time;
-    }
-    cache.add(item);
-    return item;
-}
-/**
- * Persist an ephemeral item. This means that the item will not be freed after
- * the current tick.
- *
- * @param item - The item to be persisted.
- * @returns The item.
- */
-function persist(item) {
-    cache.delete(item);
-    return item;
-}
-
 const MAX_USIZE = 0xffffffff;
 
 function fromPacked(packedPos) {
@@ -1540,6 +1492,33 @@ function packRoomName(room) {
     return (x << 8) | y;
 }
 
+/**
+ * A distance map for a single room.
+ */
+class ClockworkDistanceMap {
+    constructor(_map) {
+        this._map = _map;
+    }
+    /**
+     * Gets the distance value at a given position.
+     */
+    get(x, y) {
+        return this._map.get(x, y);
+    }
+    /**
+     * Sets the distance value at a given position.
+     */
+    set(x, y, value) {
+        this._map.set(x, y, value);
+    }
+    /**
+     * Converts the distance map into a flat array of distances.
+     */
+    toArray() {
+        return this._map.toArray();
+    }
+}
+
 /**
  * A flow field for a single room that stores multiple directions per tile.
  */
@@ -1577,17 +1556,11 @@ class ClockworkFlowField {
     addDirection(x, y, direction) {
         this._flowField.addDirection(x, y, direction);
     }
-    /**
-     * Free the memory allocated for this flow field.
-     */
-    free() {
-        this._flowField.free();
-    }
 }
 
 /**
  * A path from a start position to an end position. Typically returned by a
- * function like `pathToFlowFieldOrigin` rather than created directly.
+ * function like `ClockworkMultiroomFlowField.pathToOrigin` rather than created directly.
  */
 class ClockworkPath {
     constructor(path) {
@@ -1599,7 +1572,7 @@ class ClockworkPath {
      * @example
      * ```typescript
      * for (const pos of path) {
-     *   console.log(pos);
+     *   console.logUnsafe(pos);
      * }
      * ```
      */
@@ -1623,7 +1596,7 @@ class ClockworkPath {
      * @example
      * ```typescript
      * for (const pos of path.reversed()) {
-     *   console.log(pos);
+     *   console.logUnsafe(pos);
      * }
      * ```
      */
@@ -1682,12 +1655,6 @@ class ClockworkPath {
         }
         return result;
     }
-    /**
-     * Free the memory allocated for this path.
-     */
-    free() {
-        this.path.free();
-    }
 }
 
 /**
@@ -1750,12 +1717,6 @@ class ClockworkMultiroomFlowField {
     pathToOrigin(start) {
         return new ClockworkPath(js_path_to_multiroom_flow_field_origin(start.__packedPos, this._flowField));
     }
-    /**
-     * Free the memory allocated for this flow field.
-     */
-    free() {
-        this._flowField.free();
-    }
 }
 
 /**
@@ -1777,12 +1738,6 @@ class ClockworkMonoFlowField {
     set(x, y, value) {
         this._flowField.set(x, y, value);
     }
-    /**
-     * Free the memory allocated for this flow field.
-     */
-    free() {
-        this._flowField.free();
-    }
 }
 
 /**
@@ -1828,14 +1783,9 @@ class ClockworkMultiroomMonoFlowField {
     pathToOrigin(start) {
         return new ClockworkPath(js_path_to_multiroom_mono_flow_field_origin(start.__packedPos, this._flowField));
     }
-    /**
-     * Free the memory allocated for this flow field.
-     */
-    free() {
-        this._flowField.free();
-    }
 }
 
+const DEFAULT_DIRECTION_ORDER = DirectionOrder.CardinalFirst;
 /**
  * A distance map that covers multiple rooms. Typically returned by a function
  * like `bfsMultiroomDistanceMap` rather than created directly.
@@ -1860,7 +1810,8 @@ class ClockworkMultiroomDistanceMap {
      * Get the DistanceMap for a given room.
      */
     getRoom(room) {
-        return this._map.get_room(packRoomName(room));
+        const map = this._map.get_room(packRoomName(room));
+        return map ? new ClockworkDistanceMap(map) : undefined;
     }
     /**
      * List all the rooms covered by this distance map.
@@ -1868,29 +1819,29 @@ class ClockworkMultiroomDistanceMap {
     getRooms() {
         return [...this._map.get_rooms()].map(room => fromPackedRoomName(room));
     }
-    /**
-     * Free the memory allocated for this distance map.
-     */
-    free() {
-        this._map.free();
-    }
     /**
      * Path to the origin from a given position.
+     * Pass `DirectionOrder.DiagonalFirst` to prefer diagonal steps when multiple neighbors are equally close.
      */
-    pathToOrigin(start) {
-        return new ClockworkPath(js_path_to_multiroom_distance_map_origin(start.__packedPos, this._map));
+    pathToOrigin(start, options = {}) {
+        var _a;
+        return new ClockworkPath(js_path_to_multiroom_distance_map_origin(start.__packedPos, this._map, (_a = options.directionOrder) !== null && _a !== void 0 ? _a : DEFAULT_DIRECTION_ORDER));
     }
     /**
      * Flow field for this distance map.
+     * Pass `DirectionOrder.DiagonalFirst` to prefer diagonal directions when multiple neighbors are equally close.
      */
-    toFlowField() {
-        return new ClockworkMultiroomFlowField(multiroomFlowField(this._map));
+    toFlowField(options = {}) {
+        var _a;
+        return new ClockworkMultiroomFlowField(multiroomFlowField(this._map, (_a = options.directionOrder) !== null && _a !== void 0 ? _a : DEFAULT_DIRECTION_ORDER));
     }
     /**
      * Mono-directional flow field for this distance map.
+     * Pass `DirectionOrder.DiagonalFirst` to prefer diagonal directions when multiple neighbors are equally close.
      */
-    toMonoFlowField() {
-        return new ClockworkMultiroomMonoFlowField(multiroomMonoFlowField(this._map));
+    toMonoFlowField(options = {}) {
+        var _a;
+        return new ClockworkMultiroomMonoFlowField(multiroomMonoFlowField(this._map, (_a = options.directionOrder) !== null && _a !== void 0 ? _a : DEFAULT_DIRECTION_ORDER));
     }
 }
 
@@ -1901,7 +1852,6 @@ function fromPackedSearchResult(result) {
     }, []);
     const distanceMap = new ClockworkMultiroomDistanceMap(result.distance_map);
     const ops = result.ops;
-    result.free();
     return {
         distanceMap,
         foundTargets,
@@ -2030,6 +1980,7 @@ function getTerrainCostMatrix(roomName, { plainCost, swampCost, wallCost } = {})
     return get_terrain_cost_matrix(packRoomName(roomName), plainCost, swampCost, wallCost);
 }
 
+/// <reference types="../types.d.ts" />
 let wasm_bytes;
 let wasm_module;
 let wasm_instance;
@@ -2049,16 +2000,16 @@ function initialize(verbose = false) {
     if (!wasm_bytes)
         wasm_bytes = require('screeps_clockwork.wasm');
     if (verbose && !initialized)
-        console.log('[clockwork] wasm_bytes loaded');
+        console.logUnsafe('[clockwork] wasm_bytes loaded');
     if (!wasm_module)
         wasm_module = new WebAssembly.Module(wasm_bytes);
     if (verbose && !initialized)
-        console.log('[clockwork] wasm_module loaded');
+        console.logUnsafe('[clockwork] wasm_module loaded');
     if (!wasm_instance)
         wasm_instance = initSync({ module: wasm_module });
     if (verbose && !initialized) {
-        console.log('[clockwork] wasm_instance loaded');
-        console.log(`[clockwork] version ${version()} initialized with ${(Game.cpu.getUsed() - start).toFixed(2)} CPU`);
+        console.logUnsafe('[clockwork] wasm_instance loaded');
+        console.logUnsafe(`[clockwork] version ${version()} initialized with ${(Game.cpu.getUsed() - start).toFixed(2)} CPU`);
     }
     initialized = true;
 }
@@ -2081,7 +2032,7 @@ function console_error() {
         }
     })
         .join(' ');
-    console.log('ERROR:', processedArgs);
+    console.logUnsafe('ERROR:', processedArgs);
 }
 
 exports.ClockworkCostMatrix = ClockworkCostMatrix;
@@ -2090,15 +2041,11 @@ exports.ClockworkMonoFlowField = ClockworkMonoFlowField;
 exports.ClockworkMultiroomFlowField = ClockworkMultiroomFlowField;
 exports.ClockworkMultiroomMonoFlowField = ClockworkMultiroomMonoFlowField;
 exports.ClockworkPath = ClockworkPath;
-exports.DistanceMap = DistanceMap;
-exports.FlowField = FlowField;
-exports.MonoFlowField = MonoFlowField;
+exports.DirectionOrder = DirectionOrder;
 exports.astarMultiroomDistanceMap = astarMultiroomDistanceMap;
 exports.bfsMultiroomDistanceMap = bfsMultiroomDistanceMap;
 exports.dijkstraMultiroomDistanceMap = dijkstraMultiroomDistanceMap;
-exports.ephemeral = ephemeral;
 exports.getRange = getRange;
 exports.getTerrainCostMatrix = getTerrainCostMatrix;
 exports.initialize = initialize;
-exports.persist = persist;
 //# sourceMappingURL=index.js.map