cavi 0.1.0 → 0.1.2

package/cavi.js

@@ -1,43 +1,64 @@
 /* @ts-self-types="./cavi.d.ts" */
 
-export class Node {
+export class WasmNode {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Node.prototype);
+        const obj = Object.create(WasmNode.prototype);
         obj.__wbg_ptr = ptr;
-        NodeFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmNodeFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        NodeFinalization.unregister(this);
+        WasmNodeFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_node_free(ptr, 0);
+        wasm.__wbg_wasmnode_free(ptr, 0);
     }
     /**
      * @returns {boolean}
      */
     get fixed() {
-        const ret = wasm.__wbg_get_node_fixed(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_wasmnode_fixed(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
-     * @returns {Position}
+     * @returns {WasmPosition}
      */
     get position() {
-        const ret = wasm.__wbg_get_node_position(this.__wbg_ptr);
-        return Position.__wrap(ret);
+        const ret = wasm.__wbg_get_wasmnode_position(this.__wbg_ptr);
+        return WasmPosition.__wrap(ret);
     }
     /**
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     get velocity() {
-        const ret = wasm.__wbg_get_node_velocity(this.__wbg_ptr);
-        return Point.__wrap(ret);
+        const ret = wasm.__wbg_get_wasmnode_velocity(this.__wbg_ptr);
+        return WasmPoint.__wrap(ret);
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set fixed(arg0) {
+        wasm.__wbg_set_wasmnode_fixed(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {WasmPosition} arg0
+     */
+    set position(arg0) {
+        _assertClass(arg0, WasmPosition);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_wasmnode_position(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @param {WasmPoint} arg0
+     */
+    set velocity(arg0) {
+        _assertClass(arg0, WasmPoint);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_wasmnode_velocity(this.__wbg_ptr, ptr0);
     }
     /**
      * Applies a force to the node (changes velocity)
@@ -45,35 +66,35 @@ export class Node {
      * @param {number} fy
      */
     apply_force(fx, fy) {
-        wasm.node_apply_force(this.__wbg_ptr, fx, fy);
+        wasm.wasmnode_apply_force(this.__wbg_ptr, fx, fy);
     }
     /**
      * Applies a force from a Point
-     * @param {Point} force
+     * @param {WasmPoint} force
      */
     apply_force_point(force) {
-        _assertClass(force, Point);
+        _assertClass(force, WasmPoint);
         var ptr0 = force.__destroy_into_raw();
-        wasm.node_apply_force_point(this.__wbg_ptr, ptr0);
+        wasm.wasmnode_apply_force_point(this.__wbg_ptr, ptr0);
     }
     /**
      * Returns the squared distance to another node (faster)
-     * @param {Node} other
+     * @param {WasmNode} other
      * @returns {number}
      */
     distance_squared_to(other) {
-        _assertClass(other, Node);
-        const ret = wasm.node_distance_squared_to(this.__wbg_ptr, other.__wbg_ptr);
+        _assertClass(other, WasmNode);
+        const ret = wasm.wasmnode_distance_squared_to(this.__wbg_ptr, other.__wbg_ptr);
         return ret;
     }
     /**
      * Returns the distance to another node
-     * @param {Node} other
+     * @param {WasmNode} other
      * @returns {number}
      */
     distance_to(other) {
-        _assertClass(other, Node);
-        const ret = wasm.node_distance_to(this.__wbg_ptr, other.__wbg_ptr);
+        _assertClass(other, WasmNode);
+        const ret = wasm.wasmnode_distance_to(this.__wbg_ptr, other.__wbg_ptr);
         return ret;
     }
     /**
@@ -81,39 +102,39 @@ export class Node {
      * @returns {boolean}
      */
     get_fixed() {
-        const ret = wasm.node_get_fixed(this.__wbg_ptr);
+        const ret = wasm.wasmnode_get_fixed(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
      * Returns the current position as a Point
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     get_position() {
-        const ret = wasm.node_get_position(this.__wbg_ptr);
-        return Point.__wrap(ret);
+        const ret = wasm.wasmnode_get_position(this.__wbg_ptr);
+        return WasmPoint.__wrap(ret);
     }
     /**
      * Returns the speed (magnitude of velocity)
      * @returns {number}
      */
     get_speed() {
-        const ret = wasm.node_get_speed(this.__wbg_ptr);
+        const ret = wasm.wasmnode_get_speed(this.__wbg_ptr);
         return ret;
     }
     /**
      * Returns the velocity as a Point
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     get_velocity() {
-        const ret = wasm.node_get_velocity(this.__wbg_ptr);
-        return Point.__wrap(ret);
+        const ret = wasm.wasmnode_get_velocity(this.__wbg_ptr);
+        return WasmPoint.__wrap(ret);
     }
     /**
      * Returns the velocity x component
      * @returns {number}
      */
     get_velocity_x() {
-        const ret = wasm.node_get_velocity_x(this.__wbg_ptr);
+        const ret = wasm.wasmnode_get_velocity_x(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -121,7 +142,7 @@ export class Node {
      * @returns {number}
      */
     get_velocity_y() {
-        const ret = wasm.node_get_velocity_y(this.__wbg_ptr);
+        const ret = wasm.wasmnode_get_velocity_y(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -129,7 +150,7 @@ export class Node {
      * @returns {number}
      */
     get_x() {
-        const ret = wasm.node_get_x(this.__wbg_ptr);
+        const ret = wasm.wasmnode_get_x(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -137,7 +158,7 @@ export class Node {
      * @returns {number}
      */
     get_y() {
-        const ret = wasm.node_get_y(this.__wbg_ptr);
+        const ret = wasm.wasmnode_get_y(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -145,7 +166,7 @@ export class Node {
      * @returns {boolean}
      */
     is_fixed() {
-        const ret = wasm.node_get_fixed(this.__wbg_ptr);
+        const ret = wasm.wasmnode_is_fixed(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
@@ -153,56 +174,56 @@ export class Node {
      * @returns {boolean}
      */
     is_movable() {
-        const ret = wasm.node_is_movable(this.__wbg_ptr);
+        const ret = wasm.wasmnode_is_movable(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
      * Makes the node fixed (immovable)
      */
     make_fixed() {
-        wasm.node_make_fixed(this.__wbg_ptr);
+        wasm.wasmnode_make_fixed(this.__wbg_ptr);
     }
     /**
      * Makes the node movable
      */
     make_movable() {
-        wasm.node_make_movable(this.__wbg_ptr);
+        wasm.wasmnode_make_movable(this.__wbg_ptr);
     }
     /**
-     * @param {Position} pos
-     * @param {Point} vel
+     * @param {WasmPosition} pos
+     * @param {WasmPoint} vel
      * @param {boolean} fix
      */
     constructor(pos, vel, fix) {
-        _assertClass(pos, Position);
+        _assertClass(pos, WasmPosition);
         var ptr0 = pos.__destroy_into_raw();
-        _assertClass(vel, Point);
+        _assertClass(vel, WasmPoint);
         var ptr1 = vel.__destroy_into_raw();
-        const ret = wasm.node_new(ptr0, ptr1, fix);
-        this.__wbg_ptr = ret >>> 0;
-        NodeFinalization.register(this, this.__wbg_ptr, this);
+        const ret = wasm.wasmnode_new(ptr0, ptr1, fix);
+        this.__wbg_ptr = ret;
+        WasmNodeFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
      * Creates a fixed Node at the given position
      * @param {number} x
      * @param {number} y
-     * @returns {Node}
+     * @returns {WasmNode}
      */
     static new_fixed(x, y) {
-        const ret = wasm.node_new_fixed(x, y);
-        return Node.__wrap(ret);
+        const ret = wasm.wasmnode_new_fixed(x, y);
+        return WasmNode.__wrap(ret);
     }
     /**
      * Creates a Node with no initial velocity
      * @param {number} x
      * @param {number} y
      * @param {boolean} fix
-     * @returns {Node}
+     * @returns {WasmNode}
      */
     static new_no_vel(x, y, fix) {
-        const ret = wasm.node_new_no_vel(x, y, fix);
-        return Node.__wrap(ret);
+        const ret = wasm.wasmnode_new_no_vel(x, y, fix);
+        return WasmNode.__wrap(ret);
     }
     /**
      * Converts to a string representation
@@ -212,7 +233,7 @@ export class Node {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.node_print(this.__wbg_ptr);
+            const ret = wasm.wasmnode_print(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -224,14 +245,14 @@ export class Node {
      * Resets the velocity to zero
      */
     reset_velocity() {
-        wasm.node_reset_velocity(this.__wbg_ptr);
+        wasm.wasmnode_reset_velocity(this.__wbg_ptr);
     }
     /**
      * Sets whether the node is fixed
      * @param {boolean} fixed
      */
     set_fixed(fixed) {
-        wasm.node_set_fixed(this.__wbg_ptr, fixed);
+        wasm.wasmnode_set_fixed(this.__wbg_ptr, fixed);
     }
     /**
      * Sets the current position
@@ -239,7 +260,7 @@ export class Node {
      * @param {number} y
      */
     set_position(x, y) {
-        wasm.node_set_position(this.__wbg_ptr, x, y);
+        wasm.wasmnode_set_position(this.__wbg_ptr, x, y);
     }
     /**
      * Sets the velocity
@@ -247,7 +268,7 @@ export class Node {
      * @param {number} vy
      */
     set_velocity(vx, vy) {
-        wasm.node_set_velocity(this.__wbg_ptr, vx, vy);
+        wasm.wasmnode_set_velocity(this.__wbg_ptr, vx, vy);
     }
     /**
      * Moves the node by a delta amount
@@ -255,171 +276,160 @@ export class Node {
      * @param {number} dy
      */
     translate(dx, dy) {
-        wasm.node_translate(this.__wbg_ptr, dx, dy);
+        wasm.wasmnode_translate(this.__wbg_ptr, dx, dy);
     }
     /**
      * Updates the position based on velocity and acceleration
      * @param {number} dt
      * @param {number} friction
-     * @param {Point} acceleration
+     * @param {WasmPoint} acceleration
      */
     update_position(dt, friction, acceleration) {
-        _assertClass(acceleration, Point);
+        _assertClass(acceleration, WasmPoint);
         var ptr0 = acceleration.__destroy_into_raw();
-        wasm.node_update_position(this.__wbg_ptr, dt, friction, ptr0);
+        wasm.wasmnode_update_position(this.__wbg_ptr, dt, friction, ptr0);
     }
     /**
      * Updates position with custom acceleration
-     * @param {Point} acceleration
+     * @param {WasmPoint} acceleration
      * @param {number} dt
      * @param {number} friction
      */
     update_with_acceleration(acceleration, dt, friction) {
-        _assertClass(acceleration, Point);
+        _assertClass(acceleration, WasmPoint);
         var ptr0 = acceleration.__destroy_into_raw();
-        wasm.node_update_with_acceleration(this.__wbg_ptr, ptr0, dt, friction);
+        wasm.wasmnode_update_with_acceleration(this.__wbg_ptr, ptr0, dt, friction);
     }
     /**
      * Creates a Node at origin with no velocity
-     * @returns {Node}
+     * @returns {WasmNode}
      */
     static zero() {
-        const ret = wasm.node_zero();
-        return Node.__wrap(ret);
-    }
-    /**
-     * @param {boolean} arg0
-     */
-    set fixed(arg0) {
-        wasm.__wbg_set_node_fixed(this.__wbg_ptr, arg0);
-    }
-    /**
-     * @param {Position} arg0
-     */
-    set position(arg0) {
-        _assertClass(arg0, Position);
-        var ptr0 = arg0.__destroy_into_raw();
-        wasm.__wbg_set_node_position(this.__wbg_ptr, ptr0);
-    }
-    /**
-     * @param {Point} arg0
-     */
-    set velocity(arg0) {
-        _assertClass(arg0, Point);
-        var ptr0 = arg0.__destroy_into_raw();
-        wasm.__wbg_set_node_velocity(this.__wbg_ptr, ptr0);
+        const ret = wasm.wasmnode_zero();
+        return WasmNode.__wrap(ret);
     }
 }
-if (Symbol.dispose) Node.prototype[Symbol.dispose] = Node.prototype.free;
+if (Symbol.dispose) WasmNode.prototype[Symbol.dispose] = WasmNode.prototype.free;
 
-export class Point {
+export class WasmPoint {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Point.prototype);
+        const obj = Object.create(WasmPoint.prototype);
         obj.__wbg_ptr = ptr;
-        PointFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmPointFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        PointFinalization.unregister(this);
+        WasmPointFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_point_free(ptr, 0);
+        wasm.__wbg_wasmpoint_free(ptr, 0);
     }
     /**
      * @returns {number}
      */
     get x() {
-        const ret = wasm.__wbg_get_point_x(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_wasmpoint_x(this.__wbg_ptr);
         return ret;
     }
     /**
      * @returns {number}
      */
     get y() {
-        const ret = wasm.__wbg_get_point_y(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_wasmpoint_y(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * @param {number} arg0
+     */
+    set x(arg0) {
+        wasm.__wbg_set_wasmpoint_x(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set y(arg0) {
+        wasm.__wbg_set_wasmpoint_y(this.__wbg_ptr, arg0);
+    }
     /**
      * Returns the angle of this vector in radians
      * @returns {number}
      */
     angle() {
-        const ret = wasm.point_angle(this.__wbg_ptr);
+        const ret = wasm.wasmpoint_angle(this.__wbg_ptr);
         return ret;
     }
     /**
      * Returns the angle to another point in radians
-     * @param {Point} other
+     * @param {WasmPoint} other
      * @returns {number}
      */
     angle_to(other) {
-        _assertClass(other, Point);
-        const ret = wasm.point_angle_to(this.__wbg_ptr, other.__wbg_ptr);
+        _assertClass(other, WasmPoint);
+        const ret = wasm.wasmpoint_angle_to(this.__wbg_ptr, other.__wbg_ptr);
         return ret;
     }
     /**
      * Returns true if this point is approximately equal to another
-     * @param {Point} other
+     * @param {WasmPoint} other
      * @param {number} epsilon
      * @returns {boolean}
      */
     approx_equal(other, epsilon) {
-        _assertClass(other, Point);
-        const ret = wasm.point_approx_equal(this.__wbg_ptr, other.__wbg_ptr, epsilon);
+        _assertClass(other, WasmPoint);
+        const ret = wasm.wasmpoint_approx_equal(this.__wbg_ptr, other.__wbg_ptr, epsilon);
         return ret !== 0;
     }
     /**
      * Clamps the length of the vector to a maximum value
      * @param {number} max_length
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     clamped(max_length) {
-        const ret = wasm.point_clamped(this.__wbg_ptr, max_length);
-        return Point.__wrap(ret);
+        const ret = wasm.wasmpoint_clamped(this.__wbg_ptr, max_length);
+        return WasmPoint.__wrap(ret);
     }
     /**
      * Returns the cross product (z component) with another point
-     * @param {Point} other
+     * @param {WasmPoint} other
      * @returns {number}
      */
     cross(other) {
-        _assertClass(other, Point);
-        const ret = wasm.point_cross(this.__wbg_ptr, other.__wbg_ptr);
+        _assertClass(other, WasmPoint);
+        const ret = wasm.wasmpoint_cross(this.__wbg_ptr, other.__wbg_ptr);
         return ret;
     }
     /**
      * Returns the squared distance to another point (avoids sqrt)
-     * @param {Point} other
+     * @param {WasmPoint} other
      * @returns {number}
      */
     distance_squared_to(other) {
-        _assertClass(other, Point);
-        const ret = wasm.point_distance_squared_to(this.__wbg_ptr, other.__wbg_ptr);
+        _assertClass(other, WasmPoint);
+        const ret = wasm.wasmpoint_distance_squared_to(this.__wbg_ptr, other.__wbg_ptr);
         return ret;
     }
     /**
      * Returns the distance to another point
-     * @param {Point} other
+     * @param {WasmPoint} other
      * @returns {number}
      */
     distance_to(other) {
-        _assertClass(other, Point);
-        const ret = wasm.point_distance_to(this.__wbg_ptr, other.__wbg_ptr);
+        _assertClass(other, WasmPoint);
+        const ret = wasm.wasmpoint_distance_to(this.__wbg_ptr, other.__wbg_ptr);
         return ret;
     }
     /**
      * Returns the dot product with another point
-     * @param {Point} other
+     * @param {WasmPoint} other
      * @returns {number}
      */
     dot(other) {
-        _assertClass(other, Point);
-        const ret = wasm.point_dot(this.__wbg_ptr, other.__wbg_ptr);
+        _assertClass(other, WasmPoint);
+        const ret = wasm.wasmpoint_dot(this.__wbg_ptr, other.__wbg_ptr);
         return ret;
     }
     /**
@@ -427,7 +437,7 @@ export class Point {
      * @returns {number}
      */
     length() {
-        const ret = wasm.point_length(this.__wbg_ptr);
+        const ret = wasm.wasmpoint_length(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -435,202 +445,205 @@ export class Point {
      * @returns {number}
      */
     length_squared() {
-        const ret = wasm.point_length_squared(this.__wbg_ptr);
+        const ret = wasm.wasmpoint_length_squared(this.__wbg_ptr);
         return ret;
     }
     /**
      * Linear interpolation between this point and another
-     * @param {Point} other
+     * @param {WasmPoint} other
      * @param {number} t
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     lerp(other, t) {
-        _assertClass(other, Point);
-        const ret = wasm.point_lerp(this.__wbg_ptr, other.__wbg_ptr, t);
-        return Point.__wrap(ret);
+        _assertClass(other, WasmPoint);
+        const ret = wasm.wasmpoint_lerp(this.__wbg_ptr, other.__wbg_ptr, t);
+        return WasmPoint.__wrap(ret);
     }
     /**
      * @param {number} x
      * @param {number} y
      */
     constructor(x, y) {
-        const ret = wasm.point_new(x, y);
-        this.__wbg_ptr = ret >>> 0;
-        PointFinalization.register(this, this.__wbg_ptr, this);
+        const ret = wasm.wasmpoint_new(x, y);
+        this.__wbg_ptr = ret;
+        WasmPointFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
      * Normalizes this point in place
      */
     normalize() {
-        wasm.point_normalize(this.__wbg_ptr);
+        wasm.wasmpoint_normalize(this.__wbg_ptr);
     }
     /**
      * Returns a normalized version of this point (unit vector)
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     normalized() {
-        const ret = wasm.point_normalized(this.__wbg_ptr);
-        return Point.__wrap(ret);
+        const ret = wasm.wasmpoint_normalized(this.__wbg_ptr);
+        return WasmPoint.__wrap(ret);
     }
     /**
      * Returns a point with both components set to 1
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     static one() {
-        const ret = wasm.point_one();
-        return Point.__wrap(ret);
+        const ret = wasm.wasmpoint_one();
+        return WasmPoint.__wrap(ret);
     }
     /**
      * Returns a perpendicular vector (rotated 90 degrees CCW)
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     perpendicular() {
-        const ret = wasm.point_perpendicular(this.__wbg_ptr);
-        return Point.__wrap(ret);
+        const ret = wasm.wasmpoint_perpendicular(this.__wbg_ptr);
+        return WasmPoint.__wrap(ret);
     }
     /**
      * Reflects this vector across a normal vector
-     * @param {Point} normal
-     * @returns {Point}
+     * @param {WasmPoint} normal
+     * @returns {WasmPoint}
      */
     reflect(normal) {
-        _assertClass(normal, Point);
-        const ret = wasm.point_reflect(this.__wbg_ptr, normal.__wbg_ptr);
-        return Point.__wrap(ret);
+        _assertClass(normal, WasmPoint);
+        const ret = wasm.wasmpoint_reflect(this.__wbg_ptr, normal.__wbg_ptr);
+        return WasmPoint.__wrap(ret);
     }
     /**
      * Rotates this point in place by the given angle (in radians)
      * @param {number} angle
      */
     rotate(angle) {
-        wasm.point_rotate(this.__wbg_ptr, angle);
+        wasm.wasmpoint_rotate(this.__wbg_ptr, angle);
     }
     /**
      * Returns a point rotated by the given angle (in radians)
      * @param {number} angle
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     rotated(angle) {
-        const ret = wasm.point_rotated(this.__wbg_ptr, angle);
-        return Point.__wrap(ret);
+        const ret = wasm.wasmpoint_rotated(this.__wbg_ptr, angle);
+        return WasmPoint.__wrap(ret);
     }
     /**
      * Returns a unit point in the X direction (1, 0)
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     static unit_x() {
-        const ret = wasm.point_unit_x();
-        return Point.__wrap(ret);
+        const ret = wasm.wasmpoint_unit_x();
+        return WasmPoint.__wrap(ret);
     }
     /**
      * Returns a unit point in the Y direction (0, 1)
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     static unit_y() {
-        const ret = wasm.point_unit_y();
-        return Point.__wrap(ret);
+        const ret = wasm.wasmpoint_unit_y();
+        return WasmPoint.__wrap(ret);
     }
     /**
      * Returns a zero point (0, 0)
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     static zero() {
-        const ret = wasm.point_zero();
-        return Point.__wrap(ret);
-    }
-    /**
-     * @param {number} arg0
-     */
-    set x(arg0) {
-        wasm.__wbg_set_point_x(this.__wbg_ptr, arg0);
-    }
-    /**
-     * @param {number} arg0
-     */
-    set y(arg0) {
-        wasm.__wbg_set_point_y(this.__wbg_ptr, arg0);
+        const ret = wasm.wasmpoint_zero();
+        return WasmPoint.__wrap(ret);
     }
 }
-if (Symbol.dispose) Point.prototype[Symbol.dispose] = Point.prototype.free;
+if (Symbol.dispose) WasmPoint.prototype[Symbol.dispose] = WasmPoint.prototype.free;
 
-export class Position {
+export class WasmPosition {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Position.prototype);
+        const obj = Object.create(WasmPosition.prototype);
         obj.__wbg_ptr = ptr;
-        PositionFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmPositionFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        PositionFinalization.unregister(this);
+        WasmPositionFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_position_free(ptr, 0);
+        wasm.__wbg_wasmposition_free(ptr, 0);
     }
     /**
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     get curr() {
-        const ret = wasm.__wbg_get_position_curr(this.__wbg_ptr);
-        return Point.__wrap(ret);
+        const ret = wasm.__wbg_get_wasmposition_curr(this.__wbg_ptr);
+        return WasmPoint.__wrap(ret);
     }
     /**
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     get old() {
-        const ret = wasm.__wbg_get_position_old(this.__wbg_ptr);
-        return Point.__wrap(ret);
+        const ret = wasm.__wbg_get_wasmposition_old(this.__wbg_ptr);
+        return WasmPoint.__wrap(ret);
+    }
+    /**
+     * @param {WasmPoint} arg0
+     */
+    set curr(arg0) {
+        _assertClass(arg0, WasmPoint);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_wasmposition_curr(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @param {WasmPoint} arg0
+     */
+    set old(arg0) {
+        _assertClass(arg0, WasmPoint);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_wasmposition_old(this.__wbg_ptr, ptr0);
     }
     /**
      * Applies a constraint by moving the current position
-     * @param {Point} target
+     * @param {WasmPoint} target
      */
     constrain(target) {
-        _assertClass(target, Point);
+        _assertClass(target, WasmPoint);
         var ptr0 = target.__destroy_into_raw();
-        wasm.position_constrain(this.__wbg_ptr, ptr0);
+        wasm.wasmposition_constrain(this.__wbg_ptr, ptr0);
     }
     /**
      * Returns the distance between current and old positions
      * @returns {number}
      */
     displacement() {
-        const ret = wasm.position_displacement(this.__wbg_ptr);
+        const ret = wasm.wasmposition_displacement(this.__wbg_ptr);
         return ret;
     }
     /**
      * Creates a Position from two Points
-     * @param {Point} curr
-     * @param {Point} old
-     * @returns {Position}
+     * @param {WasmPoint} curr
+     * @param {WasmPoint} old
+     * @returns {WasmPosition}
      */
     static from_points(curr, old) {
-        _assertClass(curr, Point);
+        _assertClass(curr, WasmPoint);
         var ptr0 = curr.__destroy_into_raw();
-        _assertClass(old, Point);
+        _assertClass(old, WasmPoint);
         var ptr1 = old.__destroy_into_raw();
-        const ret = wasm.position_from_points(ptr0, ptr1);
-        return Position.__wrap(ret);
+        const ret = wasm.wasmposition_from_points(ptr0, ptr1);
+        return WasmPosition.__wrap(ret);
     }
     /**
      * Returns the current position as a Point
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     get_curr() {
-        const ret = wasm.position_get_curr(this.__wbg_ptr);
-        return Point.__wrap(ret);
+        const ret = wasm.wasmposition_get_curr(this.__wbg_ptr);
+        return WasmPoint.__wrap(ret);
     }
     /**
      * Returns the current x coordinate
      * @returns {number}
      */
     get_curr_x() {
-        const ret = wasm.position_get_curr_x(this.__wbg_ptr);
+        const ret = wasm.wasmposition_get_curr_x(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -638,23 +651,23 @@ export class Position {
      * @returns {number}
      */
     get_curr_y() {
-        const ret = wasm.position_get_curr_y(this.__wbg_ptr);
+        const ret = wasm.wasmposition_get_curr_y(this.__wbg_ptr);
         return ret;
     }
     /**
      * Returns the old position as a Point
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     get_old() {
-        const ret = wasm.position_get_old(this.__wbg_ptr);
-        return Point.__wrap(ret);
+        const ret = wasm.wasmposition_get_old(this.__wbg_ptr);
+        return WasmPoint.__wrap(ret);
     }
     /**
      * Returns the old x coordinate
      * @returns {number}
      */
     get_old_x() {
-        const ret = wasm.position_get_old_x(this.__wbg_ptr);
+        const ret = wasm.wasmposition_get_old_x(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -662,29 +675,29 @@ export class Position {
      * @returns {number}
      */
     get_old_y() {
-        const ret = wasm.position_get_old_y(this.__wbg_ptr);
+        const ret = wasm.wasmposition_get_old_y(this.__wbg_ptr);
         return ret;
     }
     /**
      * Integrates the position using Verlet integration
      * new_pos = curr + (curr - old) * damping + acceleration * dt^2
-     * @param {Point} acceleration
+     * @param {WasmPoint} acceleration
      * @param {number} dt
      * @param {number} damping
      */
     integrate(acceleration, dt, damping) {
-        _assertClass(acceleration, Point);
+        _assertClass(acceleration, WasmPoint);
         var ptr0 = acceleration.__destroy_into_raw();
-        wasm.position_integrate(this.__wbg_ptr, ptr0, dt, damping);
+        wasm.wasmposition_integrate(this.__wbg_ptr, ptr0, dt, damping);
     }
     /**
      * @param {number} x
      * @param {number} y
      */
     constructor(x, y) {
-        const ret = wasm.position_new(x, y);
-        this.__wbg_ptr = ret >>> 0;
-        PositionFinalization.register(this, this.__wbg_ptr, this);
+        const ret = wasm.wasmposition_new(x, y);
+        this.__wbg_ptr = ret;
+        WasmPositionFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
@@ -693,17 +706,17 @@ export class Position {
      * @param {number} curr_y
      * @param {number} old_x
      * @param {number} old_y
-     * @returns {Position}
+     * @returns {WasmPosition}
      */
     static new_with_old(curr_x, curr_y, old_x, old_y) {
-        const ret = wasm.position_new_with_old(curr_x, curr_y, old_x, old_y);
-        return Position.__wrap(ret);
+        const ret = wasm.wasmposition_new_with_old(curr_x, curr_y, old_x, old_y);
+        return WasmPosition.__wrap(ret);
     }
     /**
      * Resets old position to match current (stops motion)
      */
     reset_velocity() {
-        wasm.position_reset_velocity(this.__wbg_ptr);
+        wasm.wasmposition_reset_velocity(this.__wbg_ptr);
     }
     /**
      * Sets the current position
@@ -711,16 +724,16 @@ export class Position {
      * @param {number} y
      */
     set_curr(x, y) {
-        wasm.position_set_curr(this.__wbg_ptr, x, y);
+        wasm.wasmposition_set_curr(this.__wbg_ptr, x, y);
     }
     /**
      * Sets the current position from a Point
-     * @param {Point} point
+     * @param {WasmPoint} point
      */
     set_curr_point(point) {
-        _assertClass(point, Point);
+        _assertClass(point, WasmPoint);
         var ptr0 = point.__destroy_into_raw();
-        wasm.position_set_curr_point(this.__wbg_ptr, ptr0);
+        wasm.wasmposition_set_curr_point(this.__wbg_ptr, ptr0);
     }
     /**
      * Sets the old position
@@ -728,23 +741,23 @@ export class Position {
      * @param {number} y
      */
     set_old(x, y) {
-        wasm.position_set_old(this.__wbg_ptr, x, y);
+        wasm.wasmposition_set_old(this.__wbg_ptr, x, y);
     }
     /**
      * Sets the old position from a Point
-     * @param {Point} point
+     * @param {WasmPoint} point
      */
     set_old_point(point) {
-        _assertClass(point, Point);
+        _assertClass(point, WasmPoint);
         var ptr0 = point.__destroy_into_raw();
-        wasm.position_set_old_point(this.__wbg_ptr, ptr0);
+        wasm.wasmposition_set_old_point(this.__wbg_ptr, ptr0);
     }
     /**
      * Returns the speed (magnitude of velocity)
      * @returns {number}
      */
     speed() {
-        const ret = wasm.position_speed(this.__wbg_ptr);
+        const ret = wasm.wasmposition_speed(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -753,156 +766,158 @@ export class Position {
      * @param {number} y
      */
     update(x, y) {
-        wasm.position_update(this.__wbg_ptr, x, y);
+        wasm.wasmposition_update(this.__wbg_ptr, x, y);
     }
     /**
      * Updates the position from a Point
-     * @param {Point} point
+     * @param {WasmPoint} point
      */
     update_point(point) {
-        _assertClass(point, Point);
+        _assertClass(point, WasmPoint);
         var ptr0 = point.__destroy_into_raw();
-        wasm.position_update_point(this.__wbg_ptr, ptr0);
+        wasm.wasmposition_update_point(this.__wbg_ptr, ptr0);
     }
     /**
      * Returns the velocity (difference between current and old positions)
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     velocity() {
-        const ret = wasm.position_velocity(this.__wbg_ptr);
-        return Point.__wrap(ret);
-    }
-    /**
-     * @param {Point} arg0
-     */
-    set curr(arg0) {
-        _assertClass(arg0, Point);
-        var ptr0 = arg0.__destroy_into_raw();
-        wasm.__wbg_set_position_curr(this.__wbg_ptr, ptr0);
-    }
-    /**
-     * @param {Point} arg0
-     */
-    set old(arg0) {
-        _assertClass(arg0, Point);
-        var ptr0 = arg0.__destroy_into_raw();
-        wasm.__wbg_set_position_old(this.__wbg_ptr, ptr0);
+        const ret = wasm.wasmposition_velocity(this.__wbg_ptr);
+        return WasmPoint.__wrap(ret);
     }
 }
-if (Symbol.dispose) Position.prototype[Symbol.dispose] = Position.prototype.free;
+if (Symbol.dispose) WasmPosition.prototype[Symbol.dispose] = WasmPosition.prototype.free;
 
-export class Wire {
+export class WasmWire {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Wire.prototype);
+        const obj = Object.create(WasmWire.prototype);
         obj.__wbg_ptr = ptr;
-        WireFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmWireFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WireFinalization.unregister(this);
+        WasmWireFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wire_free(ptr, 0);
+        wasm.__wbg_wasmwire_free(ptr, 0);
     }
     /**
      * @returns {number}
      */
     get iterations() {
-        const ret = wasm.__wbg_get_wire_iterations(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_wasmwire_iterations(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
      * @returns {number}
      */
     get link_target_distance() {
-        const ret = wasm.__wbg_get_wire_link_target_distance(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_wasmwire_link_target_distance(this.__wbg_ptr);
         return ret;
     }
     /**
      * @returns {number}
      */
     get radius() {
-        const ret = wasm.__wbg_get_wire_radius(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_wasmwire_radius(this.__wbg_ptr);
         return ret;
     }
     /**
      * @returns {number}
      */
     get render_type() {
-        const ret = wasm.__wbg_get_wire_render_type(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_wasmwire_render_type(this.__wbg_ptr);
         return ret;
     }
     /**
      * @param {number} arg0
      */
     set iterations(arg0) {
-        wasm.__wbg_set_wire_iterations(this.__wbg_ptr, arg0);
+        wasm.__wbg_set_wasmwire_iterations(this.__wbg_ptr, arg0);
     }
     /**
      * @param {number} arg0
      */
     set link_target_distance(arg0) {
-        wasm.__wbg_set_wire_link_target_distance(this.__wbg_ptr, arg0);
+        wasm.__wbg_set_wasmwire_link_target_distance(this.__wbg_ptr, arg0);
     }
     /**
      * @param {number} arg0
      */
     set radius(arg0) {
-        wasm.__wbg_set_wire_radius(this.__wbg_ptr, arg0);
+        wasm.__wbg_set_wasmwire_radius(this.__wbg_ptr, arg0);
     }
     /**
      * @param {number} arg0
      */
     set render_type(arg0) {
-        wasm.__wbg_set_wire_render_type(this.__wbg_ptr, arg0);
+        wasm.__wbg_set_wasmwire_render_type(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Adds a new node at the specified position
+     * @param {number} x
+     * @param {number} y
+     * @param {boolean} fixed
+     */
+    add_node(x, y, fixed) {
+        wasm.wasmwire_add_node(this.__wbg_ptr, x, y, fixed);
+    }
+    /**
+     * Adds a new node at a specific index
+     * @param {number} index
+     * @param {number} x
+     * @param {number} y
+     * @param {boolean} fixed
+     */
+    add_node_at(index, x, y, fixed) {
+        wasm.wasmwire_add_node_at(this.__wbg_ptr, index, x, y, fixed);
     }
     /**
      * Checks collision with a point and adjusts nodes
-     * @param {Point} point
+     * @param {WasmPoint} point
      * @param {number} pointer_radius
      */
     check_collision(point, pointer_radius) {
-        _assertClass(point, Point);
-        wasm.wire_check_collision(this.__wbg_ptr, point.__wbg_ptr, pointer_radius);
+        _assertClass(point, WasmPoint);
+        wasm.wasmwire_check_collision(this.__wbg_ptr, point.__wbg_ptr, pointer_radius);
     }
     /**
      * Checks collision with mouse/pointer position
-     * @param {Point} mouse
+     * @param {WasmPoint} mouse
      * @param {number} mouse_radius
      */
     check_mouse_collision(mouse, mouse_radius) {
-        _assertClass(mouse, Point);
+        _assertClass(mouse, WasmPoint);
         var ptr0 = mouse.__destroy_into_raw();
-        wasm.wire_check_mouse_collision(this.__wbg_ptr, ptr0, mouse_radius);
+        wasm.wasmwire_check_mouse_collision(this.__wbg_ptr, ptr0, mouse_radius);
     }
     /**
      * Checks for collisions between wire elements
      * @param {number} response_coef
      */
     check_wire_elements_collisions(response_coef) {
-        wasm.wire_check_wire_elements_collisions(this.__wbg_ptr, response_coef);
+        wasm.wasmwire_check_wire_elements_collisions(this.__wbg_ptr, response_coef);
     }
     /**
      * Gets the end point of the wire
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     get_end() {
-        const ret = wasm.wire_get_end(this.__wbg_ptr);
-        return Point.__wrap(ret);
+        const ret = wasm.wasmwire_get_end(this.__wbg_ptr);
+        return WasmPoint.__wrap(ret);
     }
     /**
      * Gets a specific node by index
      * @param {number} index
-     * @returns {Node | undefined}
+     * @returns {WasmNode | undefined}
      */
     get_node(index) {
-        const ret = wasm.wire_get_node(this.__wbg_ptr, index);
-        return ret === 0 ? undefined : Node.__wrap(ret);
+        const ret = wasm.wasmwire_get_node(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : WasmNode.__wrap(ret);
     }
     /**
      * Gets the x coordinate of a node at the given index
@@ -910,7 +925,7 @@ export class Wire {
      * @returns {number}
      */
     get_node_x(index) {
-        const ret = wasm.wire_get_node_x(this.__wbg_ptr, index);
+        const ret = wasm.wasmwire_get_node_x(this.__wbg_ptr, index);
         return ret;
     }
     /**
@@ -919,14 +934,14 @@ export class Wire {
      * @returns {number}
      */
     get_node_y(index) {
-        const ret = wasm.wire_get_node_y(this.__wbg_ptr, index);
+        const ret = wasm.wasmwire_get_node_y(this.__wbg_ptr, index);
         return ret;
     }
     /**
      * @returns {number}
      */
     get_radius() {
-        const ret = wasm.wire_get_radius(this.__wbg_ptr);
+        const ret = wasm.wasmwire_get_radius(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -934,35 +949,35 @@ export class Wire {
      * @returns {number}
      */
     get_render_type() {
-        const ret = wasm.wire_get_render_type(this.__wbg_ptr);
+        const ret = wasm.wasmwire_get_render_type(this.__wbg_ptr);
         return ret;
     }
     /**
      * Gets the start point of the wire
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     get_start() {
-        const ret = wasm.wire_get_start(this.__wbg_ptr);
-        return Point.__wrap(ret);
+        const ret = wasm.wasmwire_get_start(this.__wbg_ptr);
+        return WasmPoint.__wrap(ret);
     }
     /**
      * Resets the iteration counter
      */
     invalidate() {
-        wasm.wire_invalidate(this.__wbg_ptr);
+        wasm.wasmwire_invalidate(this.__wbg_ptr);
     }
     /**
      * Returns the length of the wire (sum of all segment distances)
      * @returns {number}
      */
     length() {
-        const ret = wasm.wire_length(this.__wbg_ptr);
+        const ret = wasm.wasmwire_length(this.__wbg_ptr);
         return ret;
     }
     constructor() {
-        const ret = wasm.wire_new();
-        this.__wbg_ptr = ret >>> 0;
-        WireFinalization.register(this, this.__wbg_ptr, this);
+        const ret = wasm.wasmwire_new();
+        this.__wbg_ptr = ret;
+        WasmWireFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
@@ -972,11 +987,11 @@ export class Wire {
      * @param {number} xe
      * @param {number} ye
      * @param {number} radius
-     * @returns {Wire}
+     * @returns {WasmWire}
      */
     static new_wire(xs, ys, xe, ye, radius) {
-        const ret = wasm.wire_new_wire(xs, ys, xe, ye, radius);
-        return Wire.__wrap(ret);
+        const ret = wasm.wasmwire_new_wire(xs, ys, xe, ye, radius);
+        return WasmWire.__wrap(ret);
     }
     /**
      * Creates a wire with specific node count and link target distance
@@ -988,41 +1003,50 @@ export class Wire {
      * @param {number} link_target
      * @param {number} radius
      * @param {number} render_type
-     * @returns {Wire}
+     * @returns {WasmWire}
      */
     static new_with_count(xs, ys, xe, ye, node_count, link_target, radius, render_type) {
-        const ret = wasm.wire_new_with_count(xs, ys, xe, ye, node_count, link_target, radius, render_type);
-        return Wire.__wrap(ret);
+        const ret = wasm.wasmwire_new_with_count(xs, ys, xe, ye, node_count, link_target, radius, render_type);
+        return WasmWire.__wrap(ret);
     }
     /**
      * Returns the number of nodes in the wire
      * @returns {number}
      */
     node_count() {
-        const ret = wasm.wire_node_count(this.__wbg_ptr);
+        const ret = wasm.wasmwire_node_count(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-     * @param {Point} start
-     * @param {Point} end
+     * @param {WasmPoint} start
+     * @param {WasmPoint} end
      * @param {number} node_radius
      * @returns {number}
      */
     static optimal_length(start, end, node_radius) {
-        _assertClass(start, Point);
+        _assertClass(start, WasmPoint);
         var ptr0 = start.__destroy_into_raw();
-        _assertClass(end, Point);
+        _assertClass(end, WasmPoint);
         var ptr1 = end.__destroy_into_raw();
-        const ret = wasm.wire_optimal_length(ptr0, ptr1, node_radius);
+        const ret = wasm.wasmwire_optimal_length(ptr0, ptr1, node_radius);
         return ret >>> 0;
     }
+    /**
+     * Removes a node at the specified index
+     * @param {number} index
+     * @returns {boolean}
+     */
+    remove_node(index) {
+        const ret = wasm.wasmwire_remove_node(this.__wbg_ptr, index);
+        return ret !== 0;
+    }
     /**
      * Sets the end point position (if it's fixed)
      * @param {number} x
      * @param {number} y
      */
     set_end(x, y) {
-        wasm.wire_set_end(this.__wbg_ptr, x, y);
+        wasm.wasmwire_set_end(this.__wbg_ptr, x, y);
     }
     /**
      * Sets the number of nodes in the wire
@@ -1030,7 +1054,7 @@ export class Wire {
      * @param {number} new_count
      */
     set_node_count(new_count) {
-        wasm.wire_set_node_count(this.__wbg_ptr, new_count);
+        wasm.wasmwire_set_node_count(this.__wbg_ptr, new_count);
     }
     /**
      * Sets the fixed state of a specific node
@@ -1038,21 +1062,30 @@ export class Wire {
      * @param {boolean} fixed
      */
     set_node_fixed(node_idx, fixed) {
-        wasm.wire_set_node_fixed(this.__wbg_ptr, node_idx, fixed);
+        wasm.wasmwire_set_node_fixed(this.__wbg_ptr, node_idx, fixed);
+    }
+    /**
+     * Sets the position of a specific node
+     * @param {number} node_idx
+     * @param {number} x
+     * @param {number} y
+     */
+    set_node_position(node_idx, x, y) {
+        wasm.wasmwire_set_node_position(this.__wbg_ptr, node_idx, x, y);
     }
     /**
      * Sets the radius of the wire
      * @param {number} radius
      */
     set_radius(radius) {
-        wasm.wire_set_radius(this.__wbg_ptr, radius);
+        wasm.wasmwire_set_radius(this.__wbg_ptr, radius);
     }
     /**
      * Sets the render type (0 = segments, 1 = bezier)
      * @param {number} render_type
      */
     set_render_type(render_type) {
-        wasm.wire_set_render_type(this.__wbg_ptr, render_type);
+        wasm.wasmwire_set_render_type(this.__wbg_ptr, render_type);
     }
     /**
      * Sets the start point position (if it's fixed)
@@ -1060,32 +1093,32 @@ export class Wire {
      * @param {number} y
      */
     set_start(x, y) {
-        wasm.wire_set_start(this.__wbg_ptr, x, y);
+        wasm.wasmwire_set_start(this.__wbg_ptr, x, y);
     }
     /**
      * Updates the wire physics simulation
      * @param {number} dt
      * @param {number} friction
-     * @param {Point} acceleration
+     * @param {WasmPoint} acceleration
      */
     update(dt, friction, acceleration) {
-        _assertClass(acceleration, Point);
+        _assertClass(acceleration, WasmPoint);
         var ptr0 = acceleration.__destroy_into_raw();
-        wasm.wire_update(this.__wbg_ptr, dt, friction, ptr0);
+        wasm.wasmwire_update(this.__wbg_ptr, dt, friction, ptr0);
     }
 }
-if (Symbol.dispose) Wire.prototype[Symbol.dispose] = Wire.prototype.free;
+if (Symbol.dispose) WasmWire.prototype[Symbol.dispose] = WasmWire.prototype.free;
 
-export class World {
+export class WasmWorld {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WorldFinalization.unregister(this);
+        WasmWorldFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_world_free(ptr, 0);
+        wasm.__wbg_wasmworld_free(ptr, 0);
     }
     /**
      * Adds a wire between two points with specified radius
@@ -1096,13 +1129,34 @@ export class World {
      * @param {number} radius
      */
     add_wire(xs, ys, xe, ye, radius) {
-        wasm.world_add_wire(this.__wbg_ptr, xs, ys, xe, ye, radius);
+        wasm.wasmworld_add_wire(this.__wbg_ptr, xs, ys, xe, ye, radius);
     }
     /**
      * Adds a default wire to the world
      */
     add_wire_debug() {
-        wasm.world_add_wire_debug(this.__wbg_ptr);
+        wasm.wasmworld_add_wire_debug(this.__wbg_ptr);
+    }
+    /**
+     * Adds a node to a specific wire
+     * @param {number} wire_idx
+     * @param {number} x
+     * @param {number} y
+     * @param {boolean} fixed
+     */
+    add_wire_node(wire_idx, x, y, fixed) {
+        wasm.wasmworld_add_wire_node(this.__wbg_ptr, wire_idx, x, y, fixed);
+    }
+    /**
+     * Adds a node to a specific wire at a specific index
+     * @param {number} wire_idx
+     * @param {number} node_idx
+     * @param {number} x
+     * @param {number} y
+     * @param {boolean} fixed
+     */
+    add_wire_node_at(wire_idx, node_idx, x, y, fixed) {
+        wasm.wasmworld_add_wire_node_at(this.__wbg_ptr, wire_idx, node_idx, x, y, fixed);
     }
     /**
      * Adds a wire with specific node count and link target distance
@@ -1116,22 +1170,47 @@ export class World {
      * @param {number} render_type
      */
     add_wire_with_count(xs, ys, xe, ye, node_count, link_target, radius, render_type) {
-        wasm.world_add_wire_with_count(this.__wbg_ptr, xs, ys, xe, ye, node_count, link_target, radius, render_type);
+        wasm.wasmworld_add_wire_with_count(this.__wbg_ptr, xs, ys, xe, ye, node_count, link_target, radius, render_type);
+    }
+    /**
+     * Deletes a wire by index
+     * @param {number} index
+     * @returns {boolean}
+     */
+    delete_wire(index) {
+        const ret = wasm.wasmworld_delete_wire(this.__wbg_ptr, index);
+        return ret !== 0;
     }
     /**
      * Gets the acceleration vector
-     * @returns {Point}
+     * @returns {WasmPoint}
      */
     get_acceleration() {
-        const ret = wasm.world_get_acceleration(this.__wbg_ptr);
-        return Point.__wrap(ret);
+        const ret = wasm.wasmworld_get_acceleration(this.__wbg_ptr);
+        return WasmPoint.__wrap(ret);
+    }
+    /**
+     * Gets the x component of acceleration
+     * @returns {number}
+     */
+    get_acceleration_x() {
+        const ret = wasm.wasmworld_get_acceleration_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Gets the y component of acceleration
+     * @returns {number}
+     */
+    get_acceleration_y() {
+        const ret = wasm.wasmworld_get_acceleration_y(this.__wbg_ptr);
+        return ret;
     }
     /**
      * Gets the friction coefficient
      * @returns {number}
      */
     get_friction() {
-        const ret = wasm.world_get_friction(this.__wbg_ptr);
+        const ret = wasm.wasmworld_get_friction(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -1139,7 +1218,7 @@ export class World {
      * @returns {number}
      */
     get_mouse_radius() {
-        const ret = wasm.world_get_mouse_radius(this.__wbg_ptr);
+        const ret = wasm.wasmworld_get_mouse_radius(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -1147,7 +1226,7 @@ export class World {
      * @returns {number}
      */
     get_pointer_radius() {
-        const ret = wasm.world_get_pointer_radius(this.__wbg_ptr);
+        const ret = wasm.wasmworld_get_pointer_radius(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -1155,27 +1234,27 @@ export class World {
      * @returns {number}
      */
     get_response_coef() {
-        const ret = wasm.world_get_response_coef(this.__wbg_ptr);
+        const ret = wasm.wasmworld_get_response_coef(this.__wbg_ptr);
         return ret;
     }
     /**
      * Gets a specific wire by index
      * @param {number} index
-     * @returns {Wire | undefined}
+     * @returns {WasmWire | undefined}
      */
     get_wire(index) {
-        const ret = wasm.world_get_wire(this.__wbg_ptr, index);
-        return ret === 0 ? undefined : Wire.__wrap(ret);
+        const ret = wasm.wasmworld_get_wire(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : WasmWire.__wrap(ret);
     }
     /**
      * Gets a node from a specific wire
      * @param {number} wire_idx
      * @param {number} node_idx
-     * @returns {Node | undefined}
+     * @returns {WasmNode | undefined}
      */
     get_wire_node(wire_idx, node_idx) {
-        const ret = wasm.world_get_wire_node(this.__wbg_ptr, wire_idx, node_idx);
-        return ret === 0 ? undefined : Node.__wrap(ret);
+        const ret = wasm.wasmworld_get_wire_node(this.__wbg_ptr, wire_idx, node_idx);
+        return ret === 0 ? undefined : WasmNode.__wrap(ret);
     }
     /**
      * Gets the number of nodes in a specific wire
@@ -1183,7 +1262,7 @@ export class World {
      * @returns {number}
      */
     get_wire_node_count(wire_idx) {
-        const ret = wasm.world_get_wire_node_count(this.__wbg_ptr, wire_idx);
+        const ret = wasm.wasmworld_get_wire_node_count(this.__wbg_ptr, wire_idx);
         return ret >>> 0;
     }
     /**
@@ -1193,7 +1272,7 @@ export class World {
      * @returns {number}
      */
     get_wire_node_x(wire_idx, node_idx) {
-        const ret = wasm.world_get_wire_node_x(this.__wbg_ptr, wire_idx, node_idx);
+        const ret = wasm.wasmworld_get_wire_node_x(this.__wbg_ptr, wire_idx, node_idx);
         return ret;
     }
     /**
@@ -1203,7 +1282,7 @@ export class World {
      * @returns {number}
      */
     get_wire_node_y(wire_idx, node_idx) {
-        const ret = wasm.world_get_wire_node_y(this.__wbg_ptr, wire_idx, node_idx);
+        const ret = wasm.wasmworld_get_wire_node_y(this.__wbg_ptr, wire_idx, node_idx);
         return ret;
     }
     /**
@@ -1211,29 +1290,39 @@ export class World {
      * @returns {number}
      */
     get_wire_radius(wire_idx) {
-        const ret = wasm.world_get_wire_radius(this.__wbg_ptr, wire_idx);
+        const ret = wasm.wasmworld_get_wire_radius(this.__wbg_ptr, wire_idx);
         return ret;
     }
     constructor() {
-        const ret = wasm.world_new();
-        this.__wbg_ptr = ret >>> 0;
-        WorldFinalization.register(this, this.__wbg_ptr, this);
+        const ret = wasm.wasmworld_new();
+        this.__wbg_ptr = ret;
+        WasmWorldFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * Removes a node from a specific wire
+     * @param {number} wire_idx
+     * @param {number} node_idx
+     * @returns {boolean}
+     */
+    remove_wire_node(wire_idx, node_idx) {
+        const ret = wasm.wasmworld_remove_wire_node(this.__wbg_ptr, wire_idx, node_idx);
+        return ret !== 0;
+    }
     /**
      * Sets the acceleration vector
      * @param {number} x
      * @param {number} y
      */
     set_acceleration(x, y) {
-        wasm.world_set_acceleration(this.__wbg_ptr, x, y);
+        wasm.wasmworld_set_acceleration(this.__wbg_ptr, x, y);
     }
     /**
      * Sets the friction coefficient
      * @param {number} friction
      */
     set_friction(friction) {
-        wasm.world_set_friction(this.__wbg_ptr, friction);
+        wasm.wasmworld_set_friction(this.__wbg_ptr, friction);
     }
     /**
      * Sets the mouse position
@@ -1241,28 +1330,28 @@ export class World {
      * @param {number} y
      */
     set_mouse(x, y) {
-        wasm.world_set_mouse(this.__wbg_ptr, x, y);
+        wasm.wasmworld_set_mouse(this.__wbg_ptr, x, y);
     }
     /**
      * Sets the mouse interaction radius
      * @param {number} radius
      */
     set_mouse_radius(radius) {
-        wasm.world_set_mouse_radius(this.__wbg_ptr, radius);
+        wasm.wasmworld_set_mouse_radius(this.__wbg_ptr, radius);
     }
     /**
      * Sets the pointer collision radius
      * @param {number} radius
      */
     set_pointer_radius(radius) {
-        wasm.world_set_pointer_radius(this.__wbg_ptr, radius);
+        wasm.wasmworld_set_pointer_radius(this.__wbg_ptr, radius);
     }
     /**
      * Sets the collision response coefficient
      * @param {number} coef
      */
     set_response_coef(coef) {
-        wasm.world_set_response_coef(this.__wbg_ptr, coef);
+        wasm.wasmworld_set_response_coef(this.__wbg_ptr, coef);
     }
     /**
      * Sets the position of the last node (end) of a wire
@@ -1271,7 +1360,7 @@ export class World {
      * @param {number} y
      */
     set_wire_end(wire_idx, x, y) {
-        wasm.world_set_wire_end(this.__wbg_ptr, wire_idx, x, y);
+        wasm.wasmworld_set_wire_end(this.__wbg_ptr, wire_idx, x, y);
     }
     /**
      * Sets the number of nodes in a specific wire
@@ -1279,7 +1368,7 @@ export class World {
      * @param {number} node_count
      */
     set_wire_node_count(wire_idx, node_count) {
-        wasm.world_set_wire_node_count(this.__wbg_ptr, wire_idx, node_count);
+        wasm.wasmworld_set_wire_node_count(this.__wbg_ptr, wire_idx, node_count);
     }
     /**
      * Sets the fixed state of a specific node in a wire
@@ -1288,7 +1377,25 @@ export class World {
      * @param {boolean} fixed
      */
     set_wire_node_fixed(wire_idx, node_idx, fixed) {
-        wasm.world_set_wire_node_fixed(this.__wbg_ptr, wire_idx, node_idx, fixed);
+        wasm.wasmworld_set_wire_node_fixed(this.__wbg_ptr, wire_idx, node_idx, fixed);
+    }
+    /**
+     * Sets the position of a specific node in a wire
+     * @param {number} wire_idx
+     * @param {number} node_idx
+     * @param {number} x
+     * @param {number} y
+     */
+    set_wire_node_position(wire_idx, node_idx, x, y) {
+        wasm.wasmworld_set_wire_node_position(this.__wbg_ptr, wire_idx, node_idx, x, y);
+    }
+    /**
+     * Sets the radius of a specific wire
+     * @param {number} wire_idx
+     * @param {number} radius
+     */
+    set_wire_radius(wire_idx, radius) {
+        wasm.wasmworld_set_wire_radius(this.__wbg_ptr, wire_idx, radius);
     }
     /**
      * Sets the position of the first node (start) of a wire
@@ -1297,20 +1404,20 @@ export class World {
      * @param {number} y
      */
     set_wire_start(wire_idx, x, y) {
-        wasm.world_set_wire_start(this.__wbg_ptr, wire_idx, x, y);
+        wasm.wasmworld_set_wire_start(this.__wbg_ptr, wire_idx, x, y);
     }
     /**
      * Updates all wires in the world
      */
     update() {
-        wasm.world_update(this.__wbg_ptr);
+        wasm.wasmworld_update(this.__wbg_ptr);
     }
     /**
      * Returns the number of wires
      * @returns {number}
      */
     wire_count() {
-        const ret = wasm.world_wire_count(this.__wbg_ptr);
+        const ret = wasm.wasmworld_wire_count(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -1318,7 +1425,7 @@ export class World {
      * @returns {number}
      */
     wire_data_len() {
-        const ret = wasm.world_wire_data_len(this.__wbg_ptr);
+        const ret = wasm.wasmworld_wire_data_len(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -1327,7 +1434,7 @@ export class World {
      * @returns {number}
      */
     wire_data_ptr() {
-        const ret = wasm.world_wire_data_ptr(this.__wbg_ptr);
+        const ret = wasm.wasmworld_wire_data_ptr(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -1340,16 +1447,15 @@ export class World {
      * @returns {number}
      */
     static wire_optimal_length(start_x, start_y, end_x, end_y, radius) {
-        const ret = wasm.world_wire_optimal_length(start_x, start_y, end_x, end_y, radius);
+        const ret = wasm.wasmworld_wire_optimal_length(start_x, start_y, end_x, end_y, radius);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) World.prototype[Symbol.dispose] = World.prototype.free;
-
+if (Symbol.dispose) WasmWorld.prototype[Symbol.dispose] = WasmWorld.prototype.free;
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
+        __wbg___wbindgen_throw_bb96b2010945f0bc: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
         __wbindgen_init_externref_table: function() {
@@ -1368,21 +1474,21 @@ function __wbg_get_imports() {
     };
 }
 
-const NodeFinalization = (typeof FinalizationRegistry === 'undefined')
+const WasmNodeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_node_free(ptr >>> 0, 1));
-const PointFinalization = (typeof FinalizationRegistry === 'undefined')
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmnode_free(ptr, 1));
+const WasmPointFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_point_free(ptr >>> 0, 1));
-const PositionFinalization = (typeof FinalizationRegistry === 'undefined')
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpoint_free(ptr, 1));
+const WasmPositionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_position_free(ptr >>> 0, 1));
-const WireFinalization = (typeof FinalizationRegistry === 'undefined')
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmposition_free(ptr, 1));
+const WasmWireFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wire_free(ptr >>> 0, 1));
-const WorldFinalization = (typeof FinalizationRegistry === 'undefined')
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmwire_free(ptr, 1));
+const WasmWorldFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_world_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmworld_free(ptr, 1));
 
 function _assertClass(instance, klass) {
     if (!(instance instanceof klass)) {
@@ -1391,8 +1497,7 @@ function _assertClass(instance, klass) {
 }
 
 function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return decodeText(ptr, len);
+    return decodeText(ptr >>> 0, len);
 }
 
 let cachedUint8ArrayMemory0 = null;
@@ -1417,8 +1522,9 @@ function decodeText(ptr, len) {
     return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 
-let wasmModule, wasm;
+let wasmModule, wasmInstance, wasm;
 function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
     wasm = instance.exports;
     wasmModule = module;
     cachedUint8ArrayMemory0 = null;
@@ -1428,11 +1534,15 @@ function __wbg_finalize_init(instance, module) {
 
 async function __wbg_load(module, imports) {
     if (typeof Response === 'function' && module instanceof Response) {
+        if (!module.ok) {
+            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
+        }
+
         if (typeof WebAssembly.instantiateStreaming === 'function') {
             try {
                 return await WebAssembly.instantiateStreaming(module, imports);
             } catch (e) {
-                const validResponse = module.ok && expectedResponseType(module.type);
+                const validResponse = expectedResponseType(module.type);
 
                 if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
                     console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);