cavi 0.1.0

package/cavi.js

@@ -0,0 +1,1510 @@
+/* @ts-self-types="./cavi.d.ts" */
+
+export class Node {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Node.prototype);
+        obj.__wbg_ptr = ptr;
+        NodeFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        NodeFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_node_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get fixed() {
+        const ret = wasm.__wbg_get_node_fixed(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {Position}
+     */
+    get position() {
+        const ret = wasm.__wbg_get_node_position(this.__wbg_ptr);
+        return Position.__wrap(ret);
+    }
+    /**
+     * @returns {Point}
+     */
+    get velocity() {
+        const ret = wasm.__wbg_get_node_velocity(this.__wbg_ptr);
+        return Point.__wrap(ret);
+    }
+    /**
+     * Applies a force to the node (changes velocity)
+     * @param {number} fx
+     * @param {number} fy
+     */
+    apply_force(fx, fy) {
+        wasm.node_apply_force(this.__wbg_ptr, fx, fy);
+    }
+    /**
+     * Applies a force from a Point
+     * @param {Point} force
+     */
+    apply_force_point(force) {
+        _assertClass(force, Point);
+        var ptr0 = force.__destroy_into_raw();
+        wasm.node_apply_force_point(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * Returns the squared distance to another node (faster)
+     * @param {Node} other
+     * @returns {number}
+     */
+    distance_squared_to(other) {
+        _assertClass(other, Node);
+        const ret = wasm.node_distance_squared_to(this.__wbg_ptr, other.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the distance to another node
+     * @param {Node} other
+     * @returns {number}
+     */
+    distance_to(other) {
+        _assertClass(other, Node);
+        const ret = wasm.node_distance_to(this.__wbg_ptr, other.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the fixed value (0.0 = movable, 1.0 = fixed)
+     * @returns {boolean}
+     */
+    get_fixed() {
+        const ret = wasm.node_get_fixed(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Returns the current position as a Point
+     * @returns {Point}
+     */
+    get_position() {
+        const ret = wasm.node_get_position(this.__wbg_ptr);
+        return Point.__wrap(ret);
+    }
+    /**
+     * Returns the speed (magnitude of velocity)
+     * @returns {number}
+     */
+    get_speed() {
+        const ret = wasm.node_get_speed(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the velocity as a Point
+     * @returns {Point}
+     */
+    get_velocity() {
+        const ret = wasm.node_get_velocity(this.__wbg_ptr);
+        return Point.__wrap(ret);
+    }
+    /**
+     * Returns the velocity x component
+     * @returns {number}
+     */
+    get_velocity_x() {
+        const ret = wasm.node_get_velocity_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the velocity y component
+     * @returns {number}
+     */
+    get_velocity_y() {
+        const ret = wasm.node_get_velocity_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the current x position
+     * @returns {number}
+     */
+    get_x() {
+        const ret = wasm.node_get_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the current y position
+     * @returns {number}
+     */
+    get_y() {
+        const ret = wasm.node_get_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns true if the node is fixed
+     * @returns {boolean}
+     */
+    is_fixed() {
+        const ret = wasm.node_get_fixed(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Returns true if the node is movable
+     * @returns {boolean}
+     */
+    is_movable() {
+        const ret = wasm.node_is_movable(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Makes the node fixed (immovable)
+     */
+    make_fixed() {
+        wasm.node_make_fixed(this.__wbg_ptr);
+    }
+    /**
+     * Makes the node movable
+     */
+    make_movable() {
+        wasm.node_make_movable(this.__wbg_ptr);
+    }
+    /**
+     * @param {Position} pos
+     * @param {Point} vel
+     * @param {boolean} fix
+     */
+    constructor(pos, vel, fix) {
+        _assertClass(pos, Position);
+        var ptr0 = pos.__destroy_into_raw();
+        _assertClass(vel, Point);
+        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);
+        return this;
+    }
+    /**
+     * Creates a fixed Node at the given position
+     * @param {number} x
+     * @param {number} y
+     * @returns {Node}
+     */
+    static new_fixed(x, y) {
+        const ret = wasm.node_new_fixed(x, y);
+        return Node.__wrap(ret);
+    }
+    /**
+     * Creates a Node with no initial velocity
+     * @param {number} x
+     * @param {number} y
+     * @param {boolean} fix
+     * @returns {Node}
+     */
+    static new_no_vel(x, y, fix) {
+        const ret = wasm.node_new_no_vel(x, y, fix);
+        return Node.__wrap(ret);
+    }
+    /**
+     * Converts to a string representation
+     * @returns {string}
+     */
+    print() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.node_print(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Resets the velocity to zero
+     */
+    reset_velocity() {
+        wasm.node_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);
+    }
+    /**
+     * Sets the current position
+     * @param {number} x
+     * @param {number} y
+     */
+    set_position(x, y) {
+        wasm.node_set_position(this.__wbg_ptr, x, y);
+    }
+    /**
+     * Sets the velocity
+     * @param {number} vx
+     * @param {number} vy
+     */
+    set_velocity(vx, vy) {
+        wasm.node_set_velocity(this.__wbg_ptr, vx, vy);
+    }
+    /**
+     * Moves the node by a delta amount
+     * @param {number} dx
+     * @param {number} dy
+     */
+    translate(dx, dy) {
+        wasm.node_translate(this.__wbg_ptr, dx, dy);
+    }
+    /**
+     * Updates the position based on velocity and acceleration
+     * @param {number} dt
+     * @param {number} friction
+     * @param {Point} acceleration
+     */
+    update_position(dt, friction, acceleration) {
+        _assertClass(acceleration, Point);
+        var ptr0 = acceleration.__destroy_into_raw();
+        wasm.node_update_position(this.__wbg_ptr, dt, friction, ptr0);
+    }
+    /**
+     * Updates position with custom acceleration
+     * @param {Point} acceleration
+     * @param {number} dt
+     * @param {number} friction
+     */
+    update_with_acceleration(acceleration, dt, friction) {
+        _assertClass(acceleration, Point);
+        var ptr0 = acceleration.__destroy_into_raw();
+        wasm.node_update_with_acceleration(this.__wbg_ptr, ptr0, dt, friction);
+    }
+    /**
+     * Creates a Node at origin with no velocity
+     * @returns {Node}
+     */
+    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);
+    }
+}
+if (Symbol.dispose) Node.prototype[Symbol.dispose] = Node.prototype.free;
+
+export class Point {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Point.prototype);
+        obj.__wbg_ptr = ptr;
+        PointFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PointFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_point_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get x() {
+        const ret = wasm.__wbg_get_point_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get y() {
+        const ret = wasm.__wbg_get_point_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the angle of this vector in radians
+     * @returns {number}
+     */
+    angle() {
+        const ret = wasm.point_angle(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the angle to another point in radians
+     * @param {Point} other
+     * @returns {number}
+     */
+    angle_to(other) {
+        _assertClass(other, Point);
+        const ret = wasm.point_angle_to(this.__wbg_ptr, other.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns true if this point is approximately equal to another
+     * @param {Point} 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);
+        return ret !== 0;
+    }
+    /**
+     * Clamps the length of the vector to a maximum value
+     * @param {number} max_length
+     * @returns {Point}
+     */
+    clamped(max_length) {
+        const ret = wasm.point_clamped(this.__wbg_ptr, max_length);
+        return Point.__wrap(ret);
+    }
+    /**
+     * Returns the cross product (z component) with another point
+     * @param {Point} other
+     * @returns {number}
+     */
+    cross(other) {
+        _assertClass(other, Point);
+        const ret = wasm.point_cross(this.__wbg_ptr, other.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the squared distance to another point (avoids sqrt)
+     * @param {Point} other
+     * @returns {number}
+     */
+    distance_squared_to(other) {
+        _assertClass(other, Point);
+        const ret = wasm.point_distance_squared_to(this.__wbg_ptr, other.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the distance to another point
+     * @param {Point} other
+     * @returns {number}
+     */
+    distance_to(other) {
+        _assertClass(other, Point);
+        const ret = wasm.point_distance_to(this.__wbg_ptr, other.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the dot product with another point
+     * @param {Point} other
+     * @returns {number}
+     */
+    dot(other) {
+        _assertClass(other, Point);
+        const ret = wasm.point_dot(this.__wbg_ptr, other.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the length (magnitude) of the vector
+     * @returns {number}
+     */
+    length() {
+        const ret = wasm.point_length(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the squared length (avoids sqrt for performance)
+     * @returns {number}
+     */
+    length_squared() {
+        const ret = wasm.point_length_squared(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Linear interpolation between this point and another
+     * @param {Point} other
+     * @param {number} t
+     * @returns {Point}
+     */
+    lerp(other, t) {
+        _assertClass(other, Point);
+        const ret = wasm.point_lerp(this.__wbg_ptr, other.__wbg_ptr, t);
+        return Point.__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);
+        return this;
+    }
+    /**
+     * Normalizes this point in place
+     */
+    normalize() {
+        wasm.point_normalize(this.__wbg_ptr);
+    }
+    /**
+     * Returns a normalized version of this point (unit vector)
+     * @returns {Point}
+     */
+    normalized() {
+        const ret = wasm.point_normalized(this.__wbg_ptr);
+        return Point.__wrap(ret);
+    }
+    /**
+     * Returns a point with both components set to 1
+     * @returns {Point}
+     */
+    static one() {
+        const ret = wasm.point_one();
+        return Point.__wrap(ret);
+    }
+    /**
+     * Returns a perpendicular vector (rotated 90 degrees CCW)
+     * @returns {Point}
+     */
+    perpendicular() {
+        const ret = wasm.point_perpendicular(this.__wbg_ptr);
+        return Point.__wrap(ret);
+    }
+    /**
+     * Reflects this vector across a normal vector
+     * @param {Point} normal
+     * @returns {Point}
+     */
+    reflect(normal) {
+        _assertClass(normal, Point);
+        const ret = wasm.point_reflect(this.__wbg_ptr, normal.__wbg_ptr);
+        return Point.__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);
+    }
+    /**
+     * Returns a point rotated by the given angle (in radians)
+     * @param {number} angle
+     * @returns {Point}
+     */
+    rotated(angle) {
+        const ret = wasm.point_rotated(this.__wbg_ptr, angle);
+        return Point.__wrap(ret);
+    }
+    /**
+     * Returns a unit point in the X direction (1, 0)
+     * @returns {Point}
+     */
+    static unit_x() {
+        const ret = wasm.point_unit_x();
+        return Point.__wrap(ret);
+    }
+    /**
+     * Returns a unit point in the Y direction (0, 1)
+     * @returns {Point}
+     */
+    static unit_y() {
+        const ret = wasm.point_unit_y();
+        return Point.__wrap(ret);
+    }
+    /**
+     * Returns a zero point (0, 0)
+     * @returns {Point}
+     */
+    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);
+    }
+}
+if (Symbol.dispose) Point.prototype[Symbol.dispose] = Point.prototype.free;
+
+export class Position {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Position.prototype);
+        obj.__wbg_ptr = ptr;
+        PositionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PositionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_position_free(ptr, 0);
+    }
+    /**
+     * @returns {Point}
+     */
+    get curr() {
+        const ret = wasm.__wbg_get_position_curr(this.__wbg_ptr);
+        return Point.__wrap(ret);
+    }
+    /**
+     * @returns {Point}
+     */
+    get old() {
+        const ret = wasm.__wbg_get_position_old(this.__wbg_ptr);
+        return Point.__wrap(ret);
+    }
+    /**
+     * Applies a constraint by moving the current position
+     * @param {Point} target
+     */
+    constrain(target) {
+        _assertClass(target, Point);
+        var ptr0 = target.__destroy_into_raw();
+        wasm.position_constrain(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * Returns the distance between current and old positions
+     * @returns {number}
+     */
+    displacement() {
+        const ret = wasm.position_displacement(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Creates a Position from two Points
+     * @param {Point} curr
+     * @param {Point} old
+     * @returns {Position}
+     */
+    static from_points(curr, old) {
+        _assertClass(curr, Point);
+        var ptr0 = curr.__destroy_into_raw();
+        _assertClass(old, Point);
+        var ptr1 = old.__destroy_into_raw();
+        const ret = wasm.position_from_points(ptr0, ptr1);
+        return Position.__wrap(ret);
+    }
+    /**
+     * Returns the current position as a Point
+     * @returns {Point}
+     */
+    get_curr() {
+        const ret = wasm.position_get_curr(this.__wbg_ptr);
+        return Point.__wrap(ret);
+    }
+    /**
+     * Returns the current x coordinate
+     * @returns {number}
+     */
+    get_curr_x() {
+        const ret = wasm.position_get_curr_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the current y coordinate
+     * @returns {number}
+     */
+    get_curr_y() {
+        const ret = wasm.position_get_curr_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the old position as a Point
+     * @returns {Point}
+     */
+    get_old() {
+        const ret = wasm.position_get_old(this.__wbg_ptr);
+        return Point.__wrap(ret);
+    }
+    /**
+     * Returns the old x coordinate
+     * @returns {number}
+     */
+    get_old_x() {
+        const ret = wasm.position_get_old_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the old y coordinate
+     * @returns {number}
+     */
+    get_old_y() {
+        const ret = wasm.position_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 {number} dt
+     * @param {number} damping
+     */
+    integrate(acceleration, dt, damping) {
+        _assertClass(acceleration, Point);
+        var ptr0 = acceleration.__destroy_into_raw();
+        wasm.position_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);
+        return this;
+    }
+    /**
+     * Creates a Position with different current and old positions
+     * @param {number} curr_x
+     * @param {number} curr_y
+     * @param {number} old_x
+     * @param {number} old_y
+     * @returns {Position}
+     */
+    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);
+    }
+    /**
+     * Resets old position to match current (stops motion)
+     */
+    reset_velocity() {
+        wasm.position_reset_velocity(this.__wbg_ptr);
+    }
+    /**
+     * Sets the current position
+     * @param {number} x
+     * @param {number} y
+     */
+    set_curr(x, y) {
+        wasm.position_set_curr(this.__wbg_ptr, x, y);
+    }
+    /**
+     * Sets the current position from a Point
+     * @param {Point} point
+     */
+    set_curr_point(point) {
+        _assertClass(point, Point);
+        var ptr0 = point.__destroy_into_raw();
+        wasm.position_set_curr_point(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * Sets the old position
+     * @param {number} x
+     * @param {number} y
+     */
+    set_old(x, y) {
+        wasm.position_set_old(this.__wbg_ptr, x, y);
+    }
+    /**
+     * Sets the old position from a Point
+     * @param {Point} point
+     */
+    set_old_point(point) {
+        _assertClass(point, Point);
+        var ptr0 = point.__destroy_into_raw();
+        wasm.position_set_old_point(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * Returns the speed (magnitude of velocity)
+     * @returns {number}
+     */
+    speed() {
+        const ret = wasm.position_speed(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Updates the position: stores current as old, then sets new current
+     * @param {number} x
+     * @param {number} y
+     */
+    update(x, y) {
+        wasm.position_update(this.__wbg_ptr, x, y);
+    }
+    /**
+     * Updates the position from a Point
+     * @param {Point} point
+     */
+    update_point(point) {
+        _assertClass(point, Point);
+        var ptr0 = point.__destroy_into_raw();
+        wasm.position_update_point(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * Returns the velocity (difference between current and old positions)
+     * @returns {Point}
+     */
+    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);
+    }
+}
+if (Symbol.dispose) Position.prototype[Symbol.dispose] = Position.prototype.free;
+
+export class Wire {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Wire.prototype);
+        obj.__wbg_ptr = ptr;
+        WireFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WireFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wire_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get iterations() {
+        const ret = wasm.__wbg_get_wire_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);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get radius() {
+        const ret = wasm.__wbg_get_wire_radius(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get render_type() {
+        const ret = wasm.__wbg_get_wire_render_type(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set iterations(arg0) {
+        wasm.__wbg_set_wire_iterations(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set link_target_distance(arg0) {
+        wasm.__wbg_set_wire_link_target_distance(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set radius(arg0) {
+        wasm.__wbg_set_wire_radius(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set render_type(arg0) {
+        wasm.__wbg_set_wire_render_type(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Checks collision with a point and adjusts nodes
+     * @param {Point} 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);
+    }
+    /**
+     * Checks collision with mouse/pointer position
+     * @param {Point} mouse
+     * @param {number} mouse_radius
+     */
+    check_mouse_collision(mouse, mouse_radius) {
+        _assertClass(mouse, Point);
+        var ptr0 = mouse.__destroy_into_raw();
+        wasm.wire_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);
+    }
+    /**
+     * Gets the end point of the wire
+     * @returns {Point}
+     */
+    get_end() {
+        const ret = wasm.wire_get_end(this.__wbg_ptr);
+        return Point.__wrap(ret);
+    }
+    /**
+     * Gets a specific node by index
+     * @param {number} index
+     * @returns {Node | undefined}
+     */
+    get_node(index) {
+        const ret = wasm.wire_get_node(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : Node.__wrap(ret);
+    }
+    /**
+     * Gets the x coordinate of a node at the given index
+     * @param {number} index
+     * @returns {number}
+     */
+    get_node_x(index) {
+        const ret = wasm.wire_get_node_x(this.__wbg_ptr, index);
+        return ret;
+    }
+    /**
+     * Gets the y coordinate of a node at the given index
+     * @param {number} index
+     * @returns {number}
+     */
+    get_node_y(index) {
+        const ret = wasm.wire_get_node_y(this.__wbg_ptr, index);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get_radius() {
+        const ret = wasm.wire_get_radius(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Gets the render type (0 = segments, 1 = bezier)
+     * @returns {number}
+     */
+    get_render_type() {
+        const ret = wasm.wire_get_render_type(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Gets the start point of the wire
+     * @returns {Point}
+     */
+    get_start() {
+        const ret = wasm.wire_get_start(this.__wbg_ptr);
+        return Point.__wrap(ret);
+    }
+    /**
+     * Resets the iteration counter
+     */
+    invalidate() {
+        wasm.wire_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);
+        return ret;
+    }
+    constructor() {
+        const ret = wasm.wire_new();
+        this.__wbg_ptr = ret >>> 0;
+        WireFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Creates a wire between two points with specified radius
+     * @param {number} xs
+     * @param {number} ys
+     * @param {number} xe
+     * @param {number} ye
+     * @param {number} radius
+     * @returns {Wire}
+     */
+    static new_wire(xs, ys, xe, ye, radius) {
+        const ret = wasm.wire_new_wire(xs, ys, xe, ye, radius);
+        return Wire.__wrap(ret);
+    }
+    /**
+     * Creates a wire with specific node count and link target distance
+     * @param {number} xs
+     * @param {number} ys
+     * @param {number} xe
+     * @param {number} ye
+     * @param {number} node_count
+     * @param {number} link_target
+     * @param {number} radius
+     * @param {number} render_type
+     * @returns {Wire}
+     */
+    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);
+    }
+    /**
+     * Returns the number of nodes in the wire
+     * @returns {number}
+     */
+    node_count() {
+        const ret = wasm.wire_node_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {Point} start
+     * @param {Point} end
+     * @param {number} node_radius
+     * @returns {number}
+     */
+    static optimal_length(start, end, node_radius) {
+        _assertClass(start, Point);
+        var ptr0 = start.__destroy_into_raw();
+        _assertClass(end, Point);
+        var ptr1 = end.__destroy_into_raw();
+        const ret = wasm.wire_optimal_length(ptr0, ptr1, node_radius);
+        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);
+    }
+    /**
+     * Sets the number of nodes in the wire
+     * Redistributes nodes evenly between start and end points
+     * @param {number} new_count
+     */
+    set_node_count(new_count) {
+        wasm.wire_set_node_count(this.__wbg_ptr, new_count);
+    }
+    /**
+     * Sets the fixed state of a specific node
+     * @param {number} node_idx
+     * @param {boolean} fixed
+     */
+    set_node_fixed(node_idx, fixed) {
+        wasm.wire_set_node_fixed(this.__wbg_ptr, node_idx, fixed);
+    }
+    /**
+     * Sets the radius of the wire
+     * @param {number} radius
+     */
+    set_radius(radius) {
+        wasm.wire_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);
+    }
+    /**
+     * Sets the start point position (if it's fixed)
+     * @param {number} x
+     * @param {number} y
+     */
+    set_start(x, y) {
+        wasm.wire_set_start(this.__wbg_ptr, x, y);
+    }
+    /**
+     * Updates the wire physics simulation
+     * @param {number} dt
+     * @param {number} friction
+     * @param {Point} acceleration
+     */
+    update(dt, friction, acceleration) {
+        _assertClass(acceleration, Point);
+        var ptr0 = acceleration.__destroy_into_raw();
+        wasm.wire_update(this.__wbg_ptr, dt, friction, ptr0);
+    }
+}
+if (Symbol.dispose) Wire.prototype[Symbol.dispose] = Wire.prototype.free;
+
+export class World {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WorldFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_world_free(ptr, 0);
+    }
+    /**
+     * Adds a wire between two points with specified radius
+     * @param {number} xs
+     * @param {number} ys
+     * @param {number} xe
+     * @param {number} ye
+     * @param {number} radius
+     */
+    add_wire(xs, ys, xe, ye, radius) {
+        wasm.world_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);
+    }
+    /**
+     * Adds a wire with specific node count and link target distance
+     * @param {number} xs
+     * @param {number} ys
+     * @param {number} xe
+     * @param {number} ye
+     * @param {number} node_count
+     * @param {number} link_target
+     * @param {number} radius
+     * @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);
+    }
+    /**
+     * Gets the acceleration vector
+     * @returns {Point}
+     */
+    get_acceleration() {
+        const ret = wasm.world_get_acceleration(this.__wbg_ptr);
+        return Point.__wrap(ret);
+    }
+    /**
+     * Gets the friction coefficient
+     * @returns {number}
+     */
+    get_friction() {
+        const ret = wasm.world_get_friction(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Gets the mouse interaction radius
+     * @returns {number}
+     */
+    get_mouse_radius() {
+        const ret = wasm.world_get_mouse_radius(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Gets the pointer collision radius
+     * @returns {number}
+     */
+    get_pointer_radius() {
+        const ret = wasm.world_get_pointer_radius(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Gets the collision response coefficient
+     * @returns {number}
+     */
+    get_response_coef() {
+        const ret = wasm.world_get_response_coef(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Gets a specific wire by index
+     * @param {number} index
+     * @returns {Wire | undefined}
+     */
+    get_wire(index) {
+        const ret = wasm.world_get_wire(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : Wire.__wrap(ret);
+    }
+    /**
+     * Gets a node from a specific wire
+     * @param {number} wire_idx
+     * @param {number} node_idx
+     * @returns {Node | 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);
+    }
+    /**
+     * Gets the number of nodes in a specific wire
+     * @param {number} wire_idx
+     * @returns {number}
+     */
+    get_wire_node_count(wire_idx) {
+        const ret = wasm.world_get_wire_node_count(this.__wbg_ptr, wire_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Gets x coordinate of a node in a wire
+     * @param {number} wire_idx
+     * @param {number} node_idx
+     * @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);
+        return ret;
+    }
+    /**
+     * Gets y coordinate of a node in a wire
+     * @param {number} wire_idx
+     * @param {number} node_idx
+     * @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);
+        return ret;
+    }
+    /**
+     * @param {number} wire_idx
+     * @returns {number}
+     */
+    get_wire_radius(wire_idx) {
+        const ret = wasm.world_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);
+        return this;
+    }
+    /**
+     * Sets the acceleration vector
+     * @param {number} x
+     * @param {number} y
+     */
+    set_acceleration(x, y) {
+        wasm.world_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);
+    }
+    /**
+     * Sets the mouse position
+     * @param {number} x
+     * @param {number} y
+     */
+    set_mouse(x, y) {
+        wasm.world_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);
+    }
+    /**
+     * Sets the pointer collision radius
+     * @param {number} radius
+     */
+    set_pointer_radius(radius) {
+        wasm.world_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);
+    }
+    /**
+     * Sets the position of the last node (end) of a wire
+     * @param {number} wire_idx
+     * @param {number} x
+     * @param {number} y
+     */
+    set_wire_end(wire_idx, x, y) {
+        wasm.world_set_wire_end(this.__wbg_ptr, wire_idx, x, y);
+    }
+    /**
+     * Sets the number of nodes in a specific wire
+     * @param {number} wire_idx
+     * @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);
+    }
+    /**
+     * Sets the fixed state of a specific node in a wire
+     * @param {number} wire_idx
+     * @param {number} node_idx
+     * @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);
+    }
+    /**
+     * Sets the position of the first node (start) of a wire
+     * @param {number} wire_idx
+     * @param {number} x
+     * @param {number} y
+     */
+    set_wire_start(wire_idx, x, y) {
+        wasm.world_set_wire_start(this.__wbg_ptr, wire_idx, x, y);
+    }
+    /**
+     * Updates all wires in the world
+     */
+    update() {
+        wasm.world_update(this.__wbg_ptr);
+    }
+    /**
+     * Returns the number of wires
+     * @returns {number}
+     */
+    wire_count() {
+        const ret = wasm.world_wire_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Returns the length of the wire data buffer
+     * @returns {number}
+     */
+    wire_data_len() {
+        const ret = wasm.world_wire_data_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Returns the pointer to the wire data buffer
+     * Buffer format per wire: [node_count, radius, render_type, path_length, ...path_data]
+     * @returns {number}
+     */
+    wire_data_ptr() {
+        const ret = wasm.world_wire_data_ptr(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Calculates the default node count for a wire based on distance and link target
+     * @param {number} start_x
+     * @param {number} start_y
+     * @param {number} end_x
+     * @param {number} end_y
+     * @param {number} radius
+     * @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);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) World.prototype[Symbol.dispose] = World.prototype.free;
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./cavi_bg.js": import0,
+    };
+}
+
+const NodeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_node_free(ptr >>> 0, 1));
+const PointFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_point_free(ptr >>> 0, 1));
+const PositionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_position_free(ptr >>> 0, 1));
+const WireFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wire_free(ptr >>> 0, 1));
+const WorldFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_world_free(ptr >>> 0, 1));
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+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));
+}
+
+let wasmModule, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && 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);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({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, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('cavi_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };