cavi 0.1.1 → 0.1.2

package/cavi_bg.js

@@ -1,1517 +0,0 @@
-export class WasmNode {
-    static __wrap(ptr) {
-        const obj = Object.create(WasmNode.prototype);
-        obj.__wbg_ptr = ptr;
-        WasmNodeFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmNodeFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmnode_free(ptr, 0);
-    }
-    /**
-     * @returns {boolean}
-     */
-    get fixed() {
-        const ret = wasm.__wbg_get_wasmnode_fixed(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * @returns {WasmPosition}
-     */
-    get position() {
-        const ret = wasm.__wbg_get_wasmnode_position(this.__wbg_ptr);
-        return WasmPosition.__wrap(ret);
-    }
-    /**
-     * @returns {WasmPoint}
-     */
-    get velocity() {
-        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)
-     * @param {number} fx
-     * @param {number} fy
-     */
-    apply_force(fx, fy) {
-        wasm.wasmnode_apply_force(this.__wbg_ptr, fx, fy);
-    }
-    /**
-     * Applies a force from a Point
-     * @param {WasmPoint} force
-     */
-    apply_force_point(force) {
-        _assertClass(force, WasmPoint);
-        var ptr0 = force.__destroy_into_raw();
-        wasm.wasmnode_apply_force_point(this.__wbg_ptr, ptr0);
-    }
-    /**
-     * Returns the squared distance to another node (faster)
-     * @param {WasmNode} other
-     * @returns {number}
-     */
-    distance_squared_to(other) {
-        _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 {WasmNode} other
-     * @returns {number}
-     */
-    distance_to(other) {
-        _assertClass(other, WasmNode);
-        const ret = wasm.wasmnode_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.wasmnode_get_fixed(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Returns the current position as a Point
-     * @returns {WasmPoint}
-     */
-    get_position() {
-        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.wasmnode_get_speed(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Returns the velocity as a Point
-     * @returns {WasmPoint}
-     */
-    get_velocity() {
-        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.wasmnode_get_velocity_x(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Returns the velocity y component
-     * @returns {number}
-     */
-    get_velocity_y() {
-        const ret = wasm.wasmnode_get_velocity_y(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Returns the current x position
-     * @returns {number}
-     */
-    get_x() {
-        const ret = wasm.wasmnode_get_x(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Returns the current y position
-     * @returns {number}
-     */
-    get_y() {
-        const ret = wasm.wasmnode_get_y(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Returns true if the node is fixed
-     * @returns {boolean}
-     */
-    is_fixed() {
-        const ret = wasm.wasmnode_is_fixed(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Returns true if the node is movable
-     * @returns {boolean}
-     */
-    is_movable() {
-        const ret = wasm.wasmnode_is_movable(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Makes the node fixed (immovable)
-     */
-    make_fixed() {
-        wasm.wasmnode_make_fixed(this.__wbg_ptr);
-    }
-    /**
-     * Makes the node movable
-     */
-    make_movable() {
-        wasm.wasmnode_make_movable(this.__wbg_ptr);
-    }
-    /**
-     * @param {WasmPosition} pos
-     * @param {WasmPoint} vel
-     * @param {boolean} fix
-     */
-    constructor(pos, vel, fix) {
-        _assertClass(pos, WasmPosition);
-        var ptr0 = pos.__destroy_into_raw();
-        _assertClass(vel, WasmPoint);
-        var ptr1 = vel.__destroy_into_raw();
-        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 {WasmNode}
-     */
-    static new_fixed(x, y) {
-        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 {WasmNode}
-     */
-    static new_no_vel(x, y, fix) {
-        const ret = wasm.wasmnode_new_no_vel(x, y, fix);
-        return WasmNode.__wrap(ret);
-    }
-    /**
-     * Converts to a string representation
-     * @returns {string}
-     */
-    print() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.wasmnode_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.wasmnode_reset_velocity(this.__wbg_ptr);
-    }
-    /**
-     * Sets whether the node is fixed
-     * @param {boolean} fixed
-     */
-    set_fixed(fixed) {
-        wasm.wasmnode_set_fixed(this.__wbg_ptr, fixed);
-    }
-    /**
-     * Sets the current position
-     * @param {number} x
-     * @param {number} y
-     */
-    set_position(x, y) {
-        wasm.wasmnode_set_position(this.__wbg_ptr, x, y);
-    }
-    /**
-     * Sets the velocity
-     * @param {number} vx
-     * @param {number} vy
-     */
-    set_velocity(vx, vy) {
-        wasm.wasmnode_set_velocity(this.__wbg_ptr, vx, vy);
-    }
-    /**
-     * Moves the node by a delta amount
-     * @param {number} dx
-     * @param {number} dy
-     */
-    translate(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 {WasmPoint} acceleration
-     */
-    update_position(dt, friction, acceleration) {
-        _assertClass(acceleration, WasmPoint);
-        var ptr0 = acceleration.__destroy_into_raw();
-        wasm.wasmnode_update_position(this.__wbg_ptr, dt, friction, ptr0);
-    }
-    /**
-     * Updates position with custom acceleration
-     * @param {WasmPoint} acceleration
-     * @param {number} dt
-     * @param {number} friction
-     */
-    update_with_acceleration(acceleration, dt, friction) {
-        _assertClass(acceleration, WasmPoint);
-        var ptr0 = acceleration.__destroy_into_raw();
-        wasm.wasmnode_update_with_acceleration(this.__wbg_ptr, ptr0, dt, friction);
-    }
-    /**
-     * Creates a Node at origin with no velocity
-     * @returns {WasmNode}
-     */
-    static zero() {
-        const ret = wasm.wasmnode_zero();
-        return WasmNode.__wrap(ret);
-    }
-}
-if (Symbol.dispose) WasmNode.prototype[Symbol.dispose] = WasmNode.prototype.free;
-
-export class WasmPoint {
-    static __wrap(ptr) {
-        const obj = Object.create(WasmPoint.prototype);
-        obj.__wbg_ptr = ptr;
-        WasmPointFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmPointFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmpoint_free(ptr, 0);
-    }
-    /**
-     * @returns {number}
-     */
-    get x() {
-        const ret = wasm.__wbg_get_wasmpoint_x(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @returns {number}
-     */
-    get y() {
-        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.wasmpoint_angle(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Returns the angle to another point in radians
-     * @param {WasmPoint} other
-     * @returns {number}
-     */
-    angle_to(other) {
-        _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 {WasmPoint} other
-     * @param {number} epsilon
-     * @returns {boolean}
-     */
-    approx_equal(other, 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 {WasmPoint}
-     */
-    clamped(max_length) {
-        const ret = wasm.wasmpoint_clamped(this.__wbg_ptr, max_length);
-        return WasmPoint.__wrap(ret);
-    }
-    /**
-     * Returns the cross product (z component) with another point
-     * @param {WasmPoint} other
-     * @returns {number}
-     */
-    cross(other) {
-        _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 {WasmPoint} other
-     * @returns {number}
-     */
-    distance_squared_to(other) {
-        _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 {WasmPoint} other
-     * @returns {number}
-     */
-    distance_to(other) {
-        _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 {WasmPoint} other
-     * @returns {number}
-     */
-    dot(other) {
-        _assertClass(other, WasmPoint);
-        const ret = wasm.wasmpoint_dot(this.__wbg_ptr, other.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Returns the length (magnitude) of the vector
-     * @returns {number}
-     */
-    length() {
-        const ret = wasm.wasmpoint_length(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Returns the squared length (avoids sqrt for performance)
-     * @returns {number}
-     */
-    length_squared() {
-        const ret = wasm.wasmpoint_length_squared(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Linear interpolation between this point and another
-     * @param {WasmPoint} other
-     * @param {number} t
-     * @returns {WasmPoint}
-     */
-    lerp(other, t) {
-        _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.wasmpoint_new(x, y);
-        this.__wbg_ptr = ret;
-        WasmPointFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Normalizes this point in place
-     */
-    normalize() {
-        wasm.wasmpoint_normalize(this.__wbg_ptr);
-    }
-    /**
-     * Returns a normalized version of this point (unit vector)
-     * @returns {WasmPoint}
-     */
-    normalized() {
-        const ret = wasm.wasmpoint_normalized(this.__wbg_ptr);
-        return WasmPoint.__wrap(ret);
-    }
-    /**
-     * Returns a point with both components set to 1
-     * @returns {WasmPoint}
-     */
-    static one() {
-        const ret = wasm.wasmpoint_one();
-        return WasmPoint.__wrap(ret);
-    }
-    /**
-     * Returns a perpendicular vector (rotated 90 degrees CCW)
-     * @returns {WasmPoint}
-     */
-    perpendicular() {
-        const ret = wasm.wasmpoint_perpendicular(this.__wbg_ptr);
-        return WasmPoint.__wrap(ret);
-    }
-    /**
-     * Reflects this vector across a normal vector
-     * @param {WasmPoint} normal
-     * @returns {WasmPoint}
-     */
-    reflect(normal) {
-        _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.wasmpoint_rotate(this.__wbg_ptr, angle);
-    }
-    /**
-     * Returns a point rotated by the given angle (in radians)
-     * @param {number} angle
-     * @returns {WasmPoint}
-     */
-    rotated(angle) {
-        const ret = wasm.wasmpoint_rotated(this.__wbg_ptr, angle);
-        return WasmPoint.__wrap(ret);
-    }
-    /**
-     * Returns a unit point in the X direction (1, 0)
-     * @returns {WasmPoint}
-     */
-    static unit_x() {
-        const ret = wasm.wasmpoint_unit_x();
-        return WasmPoint.__wrap(ret);
-    }
-    /**
-     * Returns a unit point in the Y direction (0, 1)
-     * @returns {WasmPoint}
-     */
-    static unit_y() {
-        const ret = wasm.wasmpoint_unit_y();
-        return WasmPoint.__wrap(ret);
-    }
-    /**
-     * Returns a zero point (0, 0)
-     * @returns {WasmPoint}
-     */
-    static zero() {
-        const ret = wasm.wasmpoint_zero();
-        return WasmPoint.__wrap(ret);
-    }
-}
-if (Symbol.dispose) WasmPoint.prototype[Symbol.dispose] = WasmPoint.prototype.free;
-
-export class WasmPosition {
-    static __wrap(ptr) {
-        const obj = Object.create(WasmPosition.prototype);
-        obj.__wbg_ptr = ptr;
-        WasmPositionFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmPositionFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmposition_free(ptr, 0);
-    }
-    /**
-     * @returns {WasmPoint}
-     */
-    get curr() {
-        const ret = wasm.__wbg_get_wasmposition_curr(this.__wbg_ptr);
-        return WasmPoint.__wrap(ret);
-    }
-    /**
-     * @returns {WasmPoint}
-     */
-    get old() {
-        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 {WasmPoint} target
-     */
-    constrain(target) {
-        _assertClass(target, WasmPoint);
-        var ptr0 = target.__destroy_into_raw();
-        wasm.wasmposition_constrain(this.__wbg_ptr, ptr0);
-    }
-    /**
-     * Returns the distance between current and old positions
-     * @returns {number}
-     */
-    displacement() {
-        const ret = wasm.wasmposition_displacement(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Creates a Position from two Points
-     * @param {WasmPoint} curr
-     * @param {WasmPoint} old
-     * @returns {WasmPosition}
-     */
-    static from_points(curr, old) {
-        _assertClass(curr, WasmPoint);
-        var ptr0 = curr.__destroy_into_raw();
-        _assertClass(old, WasmPoint);
-        var ptr1 = old.__destroy_into_raw();
-        const ret = wasm.wasmposition_from_points(ptr0, ptr1);
-        return WasmPosition.__wrap(ret);
-    }
-    /**
-     * Returns the current position as a Point
-     * @returns {WasmPoint}
-     */
-    get_curr() {
-        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.wasmposition_get_curr_x(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Returns the current y coordinate
-     * @returns {number}
-     */
-    get_curr_y() {
-        const ret = wasm.wasmposition_get_curr_y(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Returns the old position as a Point
-     * @returns {WasmPoint}
-     */
-    get_old() {
-        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.wasmposition_get_old_x(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Returns the old y coordinate
-     * @returns {number}
-     */
-    get_old_y() {
-        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 {WasmPoint} acceleration
-     * @param {number} dt
-     * @param {number} damping
-     */
-    integrate(acceleration, dt, damping) {
-        _assertClass(acceleration, WasmPoint);
-        var ptr0 = acceleration.__destroy_into_raw();
-        wasm.wasmposition_integrate(this.__wbg_ptr, ptr0, dt, damping);
-    }
-    /**
-     * @param {number} x
-     * @param {number} y
-     */
-    constructor(x, y) {
-        const ret = wasm.wasmposition_new(x, y);
-        this.__wbg_ptr = ret;
-        WasmPositionFinalization.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 {WasmPosition}
-     */
-    static new_with_old(curr_x, curr_y, old_x, old_y) {
-        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.wasmposition_reset_velocity(this.__wbg_ptr);
-    }
-    /**
-     * Sets the current position
-     * @param {number} x
-     * @param {number} y
-     */
-    set_curr(x, y) {
-        wasm.wasmposition_set_curr(this.__wbg_ptr, x, y);
-    }
-    /**
-     * Sets the current position from a Point
-     * @param {WasmPoint} point
-     */
-    set_curr_point(point) {
-        _assertClass(point, WasmPoint);
-        var ptr0 = point.__destroy_into_raw();
-        wasm.wasmposition_set_curr_point(this.__wbg_ptr, ptr0);
-    }
-    /**
-     * Sets the old position
-     * @param {number} x
-     * @param {number} y
-     */
-    set_old(x, y) {
-        wasm.wasmposition_set_old(this.__wbg_ptr, x, y);
-    }
-    /**
-     * Sets the old position from a Point
-     * @param {WasmPoint} point
-     */
-    set_old_point(point) {
-        _assertClass(point, WasmPoint);
-        var ptr0 = point.__destroy_into_raw();
-        wasm.wasmposition_set_old_point(this.__wbg_ptr, ptr0);
-    }
-    /**
-     * Returns the speed (magnitude of velocity)
-     * @returns {number}
-     */
-    speed() {
-        const ret = wasm.wasmposition_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.wasmposition_update(this.__wbg_ptr, x, y);
-    }
-    /**
-     * Updates the position from a Point
-     * @param {WasmPoint} point
-     */
-    update_point(point) {
-        _assertClass(point, WasmPoint);
-        var ptr0 = point.__destroy_into_raw();
-        wasm.wasmposition_update_point(this.__wbg_ptr, ptr0);
-    }
-    /**
-     * Returns the velocity (difference between current and old positions)
-     * @returns {WasmPoint}
-     */
-    velocity() {
-        const ret = wasm.wasmposition_velocity(this.__wbg_ptr);
-        return WasmPoint.__wrap(ret);
-    }
-}
-if (Symbol.dispose) WasmPosition.prototype[Symbol.dispose] = WasmPosition.prototype.free;
-
-export class WasmWire {
-    static __wrap(ptr) {
-        const obj = Object.create(WasmWire.prototype);
-        obj.__wbg_ptr = ptr;
-        WasmWireFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmWireFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmwire_free(ptr, 0);
-    }
-    /**
-     * @returns {number}
-     */
-    get iterations() {
-        const ret = wasm.__wbg_get_wasmwire_iterations(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get link_target_distance() {
-        const ret = wasm.__wbg_get_wasmwire_link_target_distance(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @returns {number}
-     */
-    get radius() {
-        const ret = wasm.__wbg_get_wasmwire_radius(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @returns {number}
-     */
-    get render_type() {
-        const ret = wasm.__wbg_get_wasmwire_render_type(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @param {number} arg0
-     */
-    set iterations(arg0) {
-        wasm.__wbg_set_wasmwire_iterations(this.__wbg_ptr, arg0);
-    }
-    /**
-     * @param {number} arg0
-     */
-    set link_target_distance(arg0) {
-        wasm.__wbg_set_wasmwire_link_target_distance(this.__wbg_ptr, arg0);
-    }
-    /**
-     * @param {number} arg0
-     */
-    set radius(arg0) {
-        wasm.__wbg_set_wasmwire_radius(this.__wbg_ptr, arg0);
-    }
-    /**
-     * @param {number} arg0
-     */
-    set render_type(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 {WasmPoint} point
-     * @param {number} pointer_radius
-     */
-    check_collision(point, pointer_radius) {
-        _assertClass(point, WasmPoint);
-        wasm.wasmwire_check_collision(this.__wbg_ptr, point.__wbg_ptr, pointer_radius);
-    }
-    /**
-     * Checks collision with mouse/pointer position
-     * @param {WasmPoint} mouse
-     * @param {number} mouse_radius
-     */
-    check_mouse_collision(mouse, mouse_radius) {
-        _assertClass(mouse, WasmPoint);
-        var ptr0 = mouse.__destroy_into_raw();
-        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.wasmwire_check_wire_elements_collisions(this.__wbg_ptr, response_coef);
-    }
-    /**
-     * Gets the end point of the wire
-     * @returns {WasmPoint}
-     */
-    get_end() {
-        const ret = wasm.wasmwire_get_end(this.__wbg_ptr);
-        return WasmPoint.__wrap(ret);
-    }
-    /**
-     * Gets a specific node by index
-     * @param {number} index
-     * @returns {WasmNode | undefined}
-     */
-    get_node(index) {
-        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
-     * @param {number} index
-     * @returns {number}
-     */
-    get_node_x(index) {
-        const ret = wasm.wasmwire_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.wasmwire_get_node_y(this.__wbg_ptr, index);
-        return ret;
-    }
-    /**
-     * @returns {number}
-     */
-    get_radius() {
-        const ret = wasm.wasmwire_get_radius(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Gets the render type (0 = segments, 1 = bezier)
-     * @returns {number}
-     */
-    get_render_type() {
-        const ret = wasm.wasmwire_get_render_type(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Gets the start point of the wire
-     * @returns {WasmPoint}
-     */
-    get_start() {
-        const ret = wasm.wasmwire_get_start(this.__wbg_ptr);
-        return WasmPoint.__wrap(ret);
-    }
-    /**
-     * Resets the iteration counter
-     */
-    invalidate() {
-        wasm.wasmwire_invalidate(this.__wbg_ptr);
-    }
-    /**
-     * Returns the length of the wire (sum of all segment distances)
-     * @returns {number}
-     */
-    length() {
-        const ret = wasm.wasmwire_length(this.__wbg_ptr);
-        return ret;
-    }
-    constructor() {
-        const ret = wasm.wasmwire_new();
-        this.__wbg_ptr = ret;
-        WasmWireFinalization.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 {WasmWire}
-     */
-    static new_wire(xs, ys, xe, ye, radius) {
-        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
-     * @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 {WasmWire}
-     */
-    static new_with_count(xs, ys, xe, ye, node_count, link_target, radius, render_type) {
-        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.wasmwire_node_count(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @param {WasmPoint} start
-     * @param {WasmPoint} end
-     * @param {number} node_radius
-     * @returns {number}
-     */
-    static optimal_length(start, end, node_radius) {
-        _assertClass(start, WasmPoint);
-        var ptr0 = start.__destroy_into_raw();
-        _assertClass(end, WasmPoint);
-        var ptr1 = end.__destroy_into_raw();
-        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.wasmwire_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.wasmwire_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.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.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.wasmwire_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.wasmwire_set_start(this.__wbg_ptr, x, y);
-    }
-    /**
-     * Updates the wire physics simulation
-     * @param {number} dt
-     * @param {number} friction
-     * @param {WasmPoint} acceleration
-     */
-    update(dt, friction, acceleration) {
-        _assertClass(acceleration, WasmPoint);
-        var ptr0 = acceleration.__destroy_into_raw();
-        wasm.wasmwire_update(this.__wbg_ptr, dt, friction, ptr0);
-    }
-}
-if (Symbol.dispose) WasmWire.prototype[Symbol.dispose] = WasmWire.prototype.free;
-
-export class WasmWorld {
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmWorldFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmworld_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.wasmworld_add_wire(this.__wbg_ptr, xs, ys, xe, ye, radius);
-    }
-    /**
-     * Adds a default wire to the world
-     */
-    add_wire_debug() {
-        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
-     * @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.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 {WasmPoint}
-     */
-    get_acceleration() {
-        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.wasmworld_get_friction(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Gets the mouse interaction radius
-     * @returns {number}
-     */
-    get_mouse_radius() {
-        const ret = wasm.wasmworld_get_mouse_radius(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Gets the pointer collision radius
-     * @returns {number}
-     */
-    get_pointer_radius() {
-        const ret = wasm.wasmworld_get_pointer_radius(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Gets the collision response coefficient
-     * @returns {number}
-     */
-    get_response_coef() {
-        const ret = wasm.wasmworld_get_response_coef(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Gets a specific wire by index
-     * @param {number} index
-     * @returns {WasmWire | undefined}
-     */
-    get_wire(index) {
-        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 {WasmNode | undefined}
-     */
-    get_wire_node(wire_idx, node_idx) {
-        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
-     * @param {number} wire_idx
-     * @returns {number}
-     */
-    get_wire_node_count(wire_idx) {
-        const ret = wasm.wasmworld_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.wasmworld_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.wasmworld_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.wasmworld_get_wire_radius(this.__wbg_ptr, wire_idx);
-        return ret;
-    }
-    constructor() {
-        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.wasmworld_set_acceleration(this.__wbg_ptr, x, y);
-    }
-    /**
-     * Sets the friction coefficient
-     * @param {number} friction
-     */
-    set_friction(friction) {
-        wasm.wasmworld_set_friction(this.__wbg_ptr, friction);
-    }
-    /**
-     * Sets the mouse position
-     * @param {number} x
-     * @param {number} y
-     */
-    set_mouse(x, y) {
-        wasm.wasmworld_set_mouse(this.__wbg_ptr, x, y);
-    }
-    /**
-     * Sets the mouse interaction radius
-     * @param {number} radius
-     */
-    set_mouse_radius(radius) {
-        wasm.wasmworld_set_mouse_radius(this.__wbg_ptr, radius);
-    }
-    /**
-     * Sets the pointer collision radius
-     * @param {number} radius
-     */
-    set_pointer_radius(radius) {
-        wasm.wasmworld_set_pointer_radius(this.__wbg_ptr, radius);
-    }
-    /**
-     * Sets the collision response coefficient
-     * @param {number} coef
-     */
-    set_response_coef(coef) {
-        wasm.wasmworld_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.wasmworld_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.wasmworld_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.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
-     * @param {number} wire_idx
-     * @param {number} x
-     * @param {number} y
-     */
-    set_wire_start(wire_idx, x, y) {
-        wasm.wasmworld_set_wire_start(this.__wbg_ptr, wire_idx, x, y);
-    }
-    /**
-     * Updates all wires in the world
-     */
-    update() {
-        wasm.wasmworld_update(this.__wbg_ptr);
-    }
-    /**
-     * Returns the number of wires
-     * @returns {number}
-     */
-    wire_count() {
-        const ret = wasm.wasmworld_wire_count(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Returns the length of the wire data buffer
-     * @returns {number}
-     */
-    wire_data_len() {
-        const ret = wasm.wasmworld_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.wasmworld_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.wasmworld_wire_optimal_length(start_x, start_y, end_x, end_y, radius);
-        return ret >>> 0;
-    }
-}
-if (Symbol.dispose) WasmWorld.prototype[Symbol.dispose] = WasmWorld.prototype.free;
-export function __wbg___wbindgen_throw_bb96b2010945f0bc(arg0, arg1) {
-    throw new Error(getStringFromWasm0(arg0, arg1));
-}
-export function __wbindgen_init_externref_table() {
-    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);
-}
-const WasmNodeFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmnode_free(ptr, 1));
-const WasmPointFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpoint_free(ptr, 1));
-const WasmPositionFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmposition_free(ptr, 1));
-const WasmWireFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmwire_free(ptr, 1));
-const WasmWorldFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmworld_free(ptr, 1));
-
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
-    }
-}
-
-function getStringFromWasm0(ptr, len) {
-    return decodeText(ptr >>> 0, 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 wasm;
-export function __wbg_set_wasm(val) {
-    wasm = val;
-}