@newkrok/nape-js 3.3.21 → 3.3.23

package/dist/index.cjs

@@ -8224,6 +8224,440 @@ _ZPP_ColArbiter.CIRCLE = 2;
 _ZPP_ColArbiter.zpp_pool = null;
 var ZPP_ColArbiter = _ZPP_ColArbiter;
 
+// src/native/constraint/ZPP_Constraint.ts
+var _ZPP_Constraint = class _ZPP_Constraint {
+  constructor() {
+    // --- Instance fields ---
+    this.outer = null;
+    this.id = 0;
+    this.userData = null;
+    this.compound = null;
+    this.space = null;
+    this.active = false;
+    this.stiff = false;
+    this.frequency = 0;
+    this.damping = 0;
+    this.maxForce = 0;
+    this.maxError = 0;
+    this.breakUnderForce = false;
+    this.breakUnderError = false;
+    this.removeOnBreak = false;
+    this.component = null;
+    this.ignore = false;
+    this.__velocity = false;
+    this.cbTypes = null;
+    this.cbSet = null;
+    this.wrap_cbTypes = null;
+    this.pre_dt = -1;
+    this.__class__ = _ZPP_Constraint;
+    this._initBase();
+  }
+  /**
+   * Initialise base constraint fields.
+   * Extracted into a separate method because compiled joint subclasses
+   * call `ZPP_Constraint.call(this)` — ES classes can't be invoked that
+   * way, so the compiled wrapper delegates to this method instead.
+   */
+  _initBase() {
+    const zpp = _ZPP_Constraint._zpp;
+    this.id = ZPP_ID.Constraint();
+    this.stiff = true;
+    this.active = true;
+    this.ignore = false;
+    this.frequency = 10;
+    this.damping = 1;
+    this.maxForce = Infinity;
+    this.maxError = Infinity;
+    this.breakUnderForce = false;
+    this.removeOnBreak = true;
+    this.pre_dt = -1;
+    this.cbTypes = new zpp.util.ZNPList_ZPP_CbType();
+  }
+  // --- Stub methods (overridden by subclasses) ---
+  clear() {
+  }
+  activeBodies() {
+  }
+  inactiveBodies() {
+  }
+  clearcache() {
+  }
+  validate() {
+  }
+  wake_connected() {
+  }
+  forest() {
+  }
+  broken() {
+  }
+  warmStart() {
+  }
+  draw(_g) {
+  }
+  pair_exists(_id, _di) {
+    return false;
+  }
+  preStep(_dt) {
+    return false;
+  }
+  applyImpulseVel() {
+    return false;
+  }
+  applyImpulsePos() {
+    return false;
+  }
+  copy(_dict, _todo) {
+    return null;
+  }
+  // --- Mid-step guard ---
+  immutable_midstep(name) {
+    if (this.space != null && this.space.midstep) {
+      throw new Error(
+        "Error: Constraint::" + name + " cannot be set during space step()"
+      );
+    }
+  }
+  // --- Callback types management ---
+  setupcbTypes() {
+    const zpp = _ZPP_Constraint._zpp;
+    this.wrap_cbTypes = zpp.util.ZPP_CbTypeList.get(this.cbTypes);
+    this.wrap_cbTypes.zpp_inner.adder = this.wrap_cbTypes_adder.bind(this);
+    this.wrap_cbTypes.zpp_inner.subber = this.wrap_cbTypes_subber.bind(this);
+    this.wrap_cbTypes.zpp_inner.dontremove = true;
+    this.wrap_cbTypes.zpp_inner._modifiable = this.immutable_cbTypes.bind(this);
+  }
+  immutable_cbTypes() {
+    this.immutable_midstep("Constraint::cbTypes");
+  }
+  wrap_cbTypes_subber(pcb) {
+    const cb = pcb.zpp_inner;
+    if (this.cbTypes.has(cb)) {
+      if (this.space != null) {
+        this.dealloc_cbSet();
+        cb.constraints.remove(this);
+      }
+      this.cbTypes.remove(cb);
+      if (this.space != null) {
+        this.alloc_cbSet();
+        this.wake();
+      }
+    }
+  }
+  wrap_cbTypes_adder(cb) {
+    this.insert_cbtype(cb.zpp_inner);
+    return false;
+  }
+  insert_cbtype(cb) {
+    const zpp = _ZPP_Constraint._zpp;
+    if (!this.cbTypes.has(cb)) {
+      if (this.space != null) {
+        this.dealloc_cbSet();
+        cb.constraints.add(this);
+      }
+      let pre = null;
+      let cx_ite = this.cbTypes.head;
+      while (cx_ite != null) {
+        const j = cx_ite.elt;
+        if (cb.id < j.id) {
+          break;
+        }
+        pre = cx_ite;
+        cx_ite = cx_ite.next;
+      }
+      const _this = this.cbTypes;
+      let ret;
+      if (zpp.util.ZNPNode_ZPP_CbType.zpp_pool == null) {
+        ret = new zpp.util.ZNPNode_ZPP_CbType();
+      } else {
+        ret = zpp.util.ZNPNode_ZPP_CbType.zpp_pool;
+        zpp.util.ZNPNode_ZPP_CbType.zpp_pool = ret.next;
+        ret.next = null;
+      }
+      ret.elt = cb;
+      const temp = ret;
+      if (pre == null) {
+        temp.next = _this.head;
+        _this.head = temp;
+      } else {
+        temp.next = pre.next;
+        pre.next = temp;
+      }
+      _this.pushmod = _this.modified = true;
+      _this.length++;
+      if (this.space != null) {
+        this.alloc_cbSet();
+        this.wake();
+      }
+    }
+  }
+  // --- CbSet management ---
+  alloc_cbSet() {
+    if ((this.cbSet = this.space.cbsets.get(this.cbTypes)) != null) {
+      this.cbSet.count++;
+      this.cbSet.constraints.add(this);
+    }
+  }
+  dealloc_cbSet() {
+    const zpp = _ZPP_Constraint._zpp;
+    if (this.cbSet != null) {
+      this.cbSet.constraints.remove(this);
+      if (--this.cbSet.count == 0) {
+        this.space.cbsets.remove(this.cbSet);
+        const o = this.cbSet;
+        o.listeners.clear();
+        o.zip_listeners = true;
+        o.bodylisteners.clear();
+        o.zip_bodylisteners = true;
+        o.conlisteners.clear();
+        o.zip_conlisteners = true;
+        while (o.cbTypes.head != null) {
+          const cb = o.cbTypes.pop_unsafe();
+          cb.cbsets.remove(o);
+        }
+        o.next = zpp.callbacks.ZPP_CbSet.zpp_pool;
+        zpp.callbacks.ZPP_CbSet.zpp_pool = o;
+      }
+      this.cbSet = null;
+    }
+  }
+  // --- Activation / space integration ---
+  activate() {
+    if (this.space != null) {
+      this.activeInSpace();
+    }
+  }
+  deactivate() {
+    if (this.space != null) {
+      this.inactiveOrOutSpace();
+    }
+  }
+  addedToSpace() {
+    if (this.active) {
+      this.activeInSpace();
+    }
+    this.activeBodies();
+    let cx_ite = this.cbTypes.head;
+    while (cx_ite != null) {
+      const cb = cx_ite.elt;
+      cb.constraints.add(this);
+      cx_ite = cx_ite.next;
+    }
+  }
+  removedFromSpace() {
+    if (this.active) {
+      this.inactiveOrOutSpace();
+    }
+    this.inactiveBodies();
+    let cx_ite = this.cbTypes.head;
+    while (cx_ite != null) {
+      const cb = cx_ite.elt;
+      cb.constraints.remove(this);
+      cx_ite = cx_ite.next;
+    }
+  }
+  activeInSpace() {
+    const zpp = _ZPP_Constraint._zpp;
+    this.alloc_cbSet();
+    if (zpp.space.ZPP_Component.zpp_pool == null) {
+      this.component = new zpp.space.ZPP_Component();
+    } else {
+      this.component = zpp.space.ZPP_Component.zpp_pool;
+      zpp.space.ZPP_Component.zpp_pool = this.component.next;
+      this.component.next = null;
+    }
+    this.component.isBody = false;
+    this.component.constraint = this;
+  }
+  inactiveOrOutSpace() {
+    const zpp = _ZPP_Constraint._zpp;
+    this.dealloc_cbSet();
+    const o = this.component;
+    o.body = null;
+    o.constraint = null;
+    o.next = zpp.space.ZPP_Component.zpp_pool;
+    zpp.space.ZPP_Component.zpp_pool = o;
+    this.component = null;
+  }
+  // --- Wake ---
+  wake() {
+    if (this.space != null) {
+      this.space.wake_constraint(this);
+    }
+  }
+  // --- Copy support ---
+  copyto(ret) {
+    const nape46 = _ZPP_Constraint._nape;
+    const me = this.outer;
+    if (me.zpp_inner.wrap_cbTypes == null) {
+      me.zpp_inner.setupcbTypes();
+    }
+    const cbList = me.zpp_inner.wrap_cbTypes;
+    cbList.zpp_inner.valmod();
+    const _g = nape46.callbacks.CbTypeIterator.get(cbList);
+    while (true) {
+      _g.zpp_inner.zpp_inner.valmod();
+      const _this1 = _g.zpp_inner;
+      _this1.zpp_inner.valmod();
+      if (_this1.zpp_inner.zip_length) {
+        _this1.zpp_inner.zip_length = false;
+        _this1.zpp_inner.user_length = _this1.zpp_inner.inner.length;
+      }
+      const length = _this1.zpp_inner.user_length;
+      _g.zpp_critical = true;
+      let tmp;
+      if (_g.zpp_i < length) {
+        tmp = true;
+      } else {
+        _g.zpp_next = nape46.callbacks.CbTypeIterator.zpp_pool;
+        nape46.callbacks.CbTypeIterator.zpp_pool = _g;
+        _g.zpp_inner = null;
+        tmp = false;
+      }
+      if (!tmp) {
+        break;
+      }
+      _g.zpp_critical = false;
+      const cb = _g.zpp_inner.at(_g.zpp_i++);
+      if (ret.zpp_inner.wrap_cbTypes == null) {
+        ret.zpp_inner.setupcbTypes();
+      }
+      const _this2 = ret.zpp_inner.wrap_cbTypes;
+      if (_this2.zpp_inner.reverse_flag) {
+        _this2.push(cb);
+      } else {
+        _this2.unshift(cb);
+      }
+    }
+    ret.zpp_inner.removeOnBreak = me.zpp_inner.removeOnBreak;
+    const breakUnderError = me.zpp_inner.breakUnderError;
+    if (ret.zpp_inner.breakUnderError != breakUnderError) {
+      ret.zpp_inner.breakUnderError = breakUnderError;
+      ret.zpp_inner.wake();
+    }
+    const breakUnderForce = me.zpp_inner.breakUnderForce;
+    if (ret.zpp_inner.breakUnderForce != breakUnderForce) {
+      ret.zpp_inner.breakUnderForce = breakUnderForce;
+      ret.zpp_inner.wake();
+    }
+    const maxError = me.zpp_inner.maxError;
+    if (maxError !== maxError) {
+      throw new Error("Error: Constraint::maxError cannot be NaN");
+    }
+    if (maxError < 0) {
+      throw new Error("Error: Constraint::maxError must be >=0");
+    }
+    if (ret.zpp_inner.maxError != maxError) {
+      ret.zpp_inner.maxError = maxError;
+      ret.zpp_inner.wake();
+    }
+    const maxForce = me.zpp_inner.maxForce;
+    if (maxForce !== maxForce) {
+      throw new Error("Error: Constraint::maxForce cannot be NaN");
+    }
+    if (maxForce < 0) {
+      throw new Error("Error: Constraint::maxForce must be >=0");
+    }
+    if (ret.zpp_inner.maxForce != maxForce) {
+      ret.zpp_inner.maxForce = maxForce;
+      ret.zpp_inner.wake();
+    }
+    const damping = me.zpp_inner.damping;
+    if (damping !== damping) {
+      throw new Error("Error: Constraint::Damping cannot be Nan");
+    }
+    if (damping < 0) {
+      throw new Error("Error: Constraint::Damping must be >=0");
+    }
+    if (ret.zpp_inner.damping != damping) {
+      ret.zpp_inner.damping = damping;
+      if (!ret.zpp_inner.stiff) {
+        ret.zpp_inner.wake();
+      }
+    }
+    const frequency = me.zpp_inner.frequency;
+    if (frequency !== frequency) {
+      throw new Error("Error: Constraint::Frequency cannot be NaN");
+    }
+    if (frequency <= 0) {
+      throw new Error("Error: Constraint::Frequency must be >0");
+    }
+    if (ret.zpp_inner.frequency != frequency) {
+      ret.zpp_inner.frequency = frequency;
+      if (!ret.zpp_inner.stiff) {
+        ret.zpp_inner.wake();
+      }
+    }
+    const stiff = me.zpp_inner.stiff;
+    if (ret.zpp_inner.stiff != stiff) {
+      ret.zpp_inner.stiff = stiff;
+      ret.zpp_inner.wake();
+    }
+    const ignore = me.zpp_inner.ignore;
+    if (ret.zpp_inner.ignore != ignore) {
+      ret.zpp_inner.ignore = ignore;
+      ret.zpp_inner.wake();
+    }
+    const active = me.zpp_inner.active;
+    if (ret.zpp_inner.active != active) {
+      if (ret.zpp_inner.component != null) {
+        ret.zpp_inner.component.woken = false;
+      }
+      ret.zpp_inner.clearcache();
+      if (active) {
+        ret.zpp_inner.active = active;
+        ret.zpp_inner.activate();
+        if (ret.zpp_inner.space != null) {
+          if (ret.zpp_inner.component != null) {
+            ret.zpp_inner.component.sleeping = true;
+          }
+          ret.zpp_inner.space.wake_constraint(ret.zpp_inner, true);
+        }
+      } else {
+        if (ret.zpp_inner.space != null) {
+          ret.zpp_inner.wake();
+          ret.zpp_inner.space.live_constraints.remove(ret.zpp_inner);
+        }
+        ret.zpp_inner.active = active;
+        ret.zpp_inner.deactivate();
+      }
+    }
+  }
+};
+// --- Static: Haxe metadata ---
+_ZPP_Constraint.__name__ = ["zpp_nape", "constraint", "ZPP_Constraint"];
+/**
+ * Namespace references, set by the compiled module after import.
+ * _nape = the `nape` public namespace (for CbTypeIterator in copyto)
+ * _zpp = the `zpp_nape` internal namespace (for ZNPList_*, ZPP_CbSet, etc.)
+ */
+_ZPP_Constraint._nape = null;
+_ZPP_Constraint._zpp = null;
+var ZPP_Constraint = _ZPP_Constraint;
+
+// src/native/constraint/ZPP_CopyHelper.ts
+var _ZPP_CopyHelper = class _ZPP_CopyHelper {
+  constructor() {
+    this.id = 0;
+    this.bc = null;
+    this.cb = null;
+    this.__class__ = _ZPP_CopyHelper;
+  }
+  static dict(id, bc) {
+    const ret = new _ZPP_CopyHelper();
+    ret.id = id;
+    ret.bc = bc;
+    return ret;
+  }
+  static todo(id, cb) {
+    const ret = new _ZPP_CopyHelper();
+    ret.id = id;
+    ret.cb = cb;
+    return ret;
+  }
+};
+_ZPP_CopyHelper.__name__ = ["zpp_nape", "constraint", "ZPP_CopyHelper"];
+var ZPP_CopyHelper = _ZPP_CopyHelper;
+
 // src/core/nape-compiled.js
 var _nape;
 var define = function(factory) {
@@ -29001,409 +29435,17 @@ define(function() {
   zpp_nape.callbacks.ZPP_OptionType = $hxClasses["zpp_nape.callbacks.ZPP_OptionType"] = ZPP_OptionType;
   zpp_nape.callbacks.ZPP_OptionType.prototype.__class__ = zpp_nape.callbacks.ZPP_OptionType;
   if (!zpp_nape.constraint) zpp_nape.constraint = {};
+  ZPP_Constraint._nape = nape46;
+  ZPP_Constraint._zpp = zpp_nape;
   zpp_nape.constraint.ZPP_Constraint = $hxClasses["zpp_nape.constraint.ZPP_Constraint"] = function() {
-    this.pre_dt = 0;
-    this.wrap_cbTypes = null;
-    this.cbSet = null;
-    this.cbTypes = null;
-    this.__velocity = false;
-    this.ignore = false;
-    this.component = null;
-    this.removeOnBreak = false;
-    this.breakUnderError = false;
-    this.breakUnderForce = false;
-    this.maxError = 0;
-    this.maxForce = 0;
-    this.damping = 0;
-    this.frequency = 0;
-    this.stiff = false;
-    this.active = false;
-    this.space = null;
-    this.compound = null;
-    this.userData = null;
-    this.id = 0;
-    this.outer = null;
-    this.__velocity = false;
-    this.id = zpp_nape.ZPP_ID.Constraint();
-    this.stiff = true;
-    this.active = true;
-    this.ignore = false;
-    this.frequency = 10;
-    this.damping = 1;
-    this.maxForce = Infinity;
-    this.maxError = Infinity;
-    this.breakUnderForce = false;
-    this.removeOnBreak = true;
-    this.pre_dt = -1;
-    this.cbTypes = new zpp_nape.util.ZNPList_ZPP_CbType();
-  };
-  zpp_nape.constraint.ZPP_Constraint.__name__ = [
-    "zpp_nape",
-    "constraint",
-    "ZPP_Constraint"
-  ];
-  zpp_nape.constraint.ZPP_Constraint.prototype.outer = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.clear = function() {
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.id = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.userData = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.compound = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.space = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.active = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.stiff = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.frequency = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.damping = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.maxForce = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.maxError = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.breakUnderForce = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.breakUnderError = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.removeOnBreak = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.component = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.ignore = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.__velocity = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.immutable_midstep = function(name) {
-    if (this.space != null && this.space.midstep) {
-      throw new js._Boot.HaxeError(
-        "Error: Constraint::" + name + " cannot be set during space step()"
-      );
-    }
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.cbTypes = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.cbSet = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.wrap_cbTypes = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.setupcbTypes = function() {
-    this.wrap_cbTypes = zpp_nape.util.ZPP_CbTypeList.get(this.cbTypes);
-    this.wrap_cbTypes.zpp_inner.adder = $bind(this, this.wrap_cbTypes_adder);
-    this.wrap_cbTypes.zpp_inner.subber = $bind(this, this.wrap_cbTypes_subber);
-    this.wrap_cbTypes.zpp_inner.dontremove = true;
-    this.wrap_cbTypes.zpp_inner._modifiable = $bind(
-      this,
-      this.immutable_cbTypes
-    );
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.immutable_cbTypes = function() {
-    this.immutable_midstep("Constraint::cbTypes");
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.wrap_cbTypes_subber = function(pcb) {
-    var cb = pcb.zpp_inner;
-    if (this.cbTypes.has(cb)) {
-      if (this.space != null) {
-        this.dealloc_cbSet();
-        cb.constraints.remove(this);
-      }
-      this.cbTypes.remove(cb);
-      if (this.space != null) {
-        this.alloc_cbSet();
-        this.wake();
-      }
-    }
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.wrap_cbTypes_adder = function(cb) {
-    this.insert_cbtype(cb.zpp_inner);
-    return false;
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.insert_cbtype = function(cb) {
-    if (!this.cbTypes.has(cb)) {
-      if (this.space != null) {
-        this.dealloc_cbSet();
-        cb.constraints.add(this);
-      }
-      var pre = null;
-      var cx_ite = this.cbTypes.head;
-      while (cx_ite != null) {
-        var j = cx_ite.elt;
-        if (cb.id < j.id) {
-          break;
-        }
-        pre = cx_ite;
-        cx_ite = cx_ite.next;
-      }
-      var _this = this.cbTypes;
-      var ret;
-      if (zpp_nape.util.ZNPNode_ZPP_CbType.zpp_pool == null) {
-        ret = new zpp_nape.util.ZNPNode_ZPP_CbType();
-      } else {
-        ret = zpp_nape.util.ZNPNode_ZPP_CbType.zpp_pool;
-        zpp_nape.util.ZNPNode_ZPP_CbType.zpp_pool = ret.next;
-        ret.next = null;
-      }
-      ret.elt = cb;
-      var temp = ret;
-      if (pre == null) {
-        temp.next = _this.head;
-        _this.head = temp;
-      } else {
-        temp.next = pre.next;
-        pre.next = temp;
-      }
-      _this.pushmod = _this.modified = true;
-      _this.length++;
-      if (this.space != null) {
-        this.alloc_cbSet();
-        this.wake();
-      }
-    }
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.alloc_cbSet = function() {
-    if ((this.cbSet = this.space.cbsets.get(this.cbTypes)) != null) {
-      this.cbSet.count++;
-      this.cbSet.constraints.add(this);
-    }
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.dealloc_cbSet = function() {
-    if (this.cbSet != null) {
-      this.cbSet.constraints.remove(this);
-      if (--this.cbSet.count == 0) {
-        this.space.cbsets.remove(this.cbSet);
-        var o = this.cbSet;
-        o.listeners.clear();
-        o.zip_listeners = true;
-        o.bodylisteners.clear();
-        o.zip_bodylisteners = true;
-        o.conlisteners.clear();
-        o.zip_conlisteners = true;
-        while (o.cbTypes.head != null) {
-          var cb = o.cbTypes.pop_unsafe();
-          cb.cbsets.remove(o);
-        }
-        o.next = zpp_nape.callbacks.ZPP_CbSet.zpp_pool;
-        zpp_nape.callbacks.ZPP_CbSet.zpp_pool = o;
-      }
-      this.cbSet = null;
-    }
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.activate = function() {
-    if (this.space != null) {
-      this.activeInSpace();
-    }
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.deactivate = function() {
-    if (this.space != null) {
-      this.inactiveOrOutSpace();
-    }
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.addedToSpace = function() {
-    if (this.active) {
-      this.activeInSpace();
-    }
-    this.activeBodies();
-    var cx_ite = this.cbTypes.head;
-    while (cx_ite != null) {
-      var cb = cx_ite.elt;
-      cb.constraints.add(this);
-      cx_ite = cx_ite.next;
-    }
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.removedFromSpace = function() {
-    if (this.active) {
-      this.inactiveOrOutSpace();
-    }
-    this.inactiveBodies();
-    var cx_ite = this.cbTypes.head;
-    while (cx_ite != null) {
-      var cb = cx_ite.elt;
-      cb.constraints.remove(this);
-      cx_ite = cx_ite.next;
-    }
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.activeInSpace = function() {
-    this.alloc_cbSet();
-    if (zpp_nape.space.ZPP_Component.zpp_pool == null) {
-      this.component = new zpp_nape.space.ZPP_Component();
-    } else {
-      this.component = zpp_nape.space.ZPP_Component.zpp_pool;
-      zpp_nape.space.ZPP_Component.zpp_pool = this.component.next;
-      this.component.next = null;
-    }
-    this.component.isBody = false;
-    this.component.constraint = this;
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.inactiveOrOutSpace = function() {
-    this.dealloc_cbSet();
-    var o = this.component;
-    o.body = null;
-    o.constraint = null;
-    o.next = zpp_nape.space.ZPP_Component.zpp_pool;
-    zpp_nape.space.ZPP_Component.zpp_pool = o;
-    this.component = null;
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.activeBodies = function() {
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.inactiveBodies = function() {
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.clearcache = function() {
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.validate = function() {
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.wake_connected = function() {
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.forest = function() {
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.pair_exists = function(id, di) {
-    return false;
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.broken = function() {
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.warmStart = function() {
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.pre_dt = null;
-  zpp_nape.constraint.ZPP_Constraint.prototype.preStep = function(dt) {
-    return false;
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.applyImpulseVel = function() {
-    return false;
+    ZPP_Constraint.prototype._initBase.call(this);
   };
-  zpp_nape.constraint.ZPP_Constraint.prototype.applyImpulsePos = function() {
-    return false;
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.wake = function() {
-    if (this.space != null) {
-      this.space.wake_constraint(this);
-    }
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.draw = function(g) {
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.copy = function(dict, todo) {
-    return null;
-  };
-  zpp_nape.constraint.ZPP_Constraint.prototype.copyto = function(ret) {
-    var me = this.outer;
-    if (me.zpp_inner.wrap_cbTypes == null) {
-      me.zpp_inner.setupcbTypes();
-    }
-    var _this = me.zpp_inner.wrap_cbTypes;
-    _this.zpp_inner.valmod();
-    var _g = nape46.callbacks.CbTypeIterator.get(_this);
-    while (true) {
-      _g.zpp_inner.zpp_inner.valmod();
-      var _this1 = _g.zpp_inner;
-      _this1.zpp_inner.valmod();
-      if (_this1.zpp_inner.zip_length) {
-        _this1.zpp_inner.zip_length = false;
-        _this1.zpp_inner.user_length = _this1.zpp_inner.inner.length;
-      }
-      var length = _this1.zpp_inner.user_length;
-      _g.zpp_critical = true;
-      var tmp;
-      if (_g.zpp_i < length) {
-        tmp = true;
-      } else {
-        _g.zpp_next = nape46.callbacks.CbTypeIterator.zpp_pool;
-        nape46.callbacks.CbTypeIterator.zpp_pool = _g;
-        _g.zpp_inner = null;
-        tmp = false;
-      }
-      if (!tmp) {
-        break;
-      }
-      _g.zpp_critical = false;
-      var cb = _g.zpp_inner.at(_g.zpp_i++);
-      if (ret.zpp_inner.wrap_cbTypes == null) {
-        ret.zpp_inner.setupcbTypes();
-      }
-      var _this2 = ret.zpp_inner.wrap_cbTypes;
-      if (_this2.zpp_inner.reverse_flag) {
-        _this2.push(cb);
-      } else {
-        _this2.unshift(cb);
-      }
-    }
-    ret.zpp_inner.removeOnBreak = me.zpp_inner.removeOnBreak;
-    var breakUnderError = me.zpp_inner.breakUnderError;
-    if (ret.zpp_inner.breakUnderError != breakUnderError) {
-      ret.zpp_inner.breakUnderError = breakUnderError;
-      ret.zpp_inner.wake();
-    }
-    var breakUnderForce = me.zpp_inner.breakUnderForce;
-    if (ret.zpp_inner.breakUnderForce != breakUnderForce) {
-      ret.zpp_inner.breakUnderForce = breakUnderForce;
-      ret.zpp_inner.wake();
-    }
-    var maxError = me.zpp_inner.maxError;
-    if (maxError != maxError) {
-      throw new js._Boot.HaxeError("Error: Constraint::maxError cannot be NaN");
-    }
-    if (maxError < 0) {
-      throw new js._Boot.HaxeError("Error: Constraint::maxError must be >=0");
-    }
-    if (ret.zpp_inner.maxError != maxError) {
-      ret.zpp_inner.maxError = maxError;
-      ret.zpp_inner.wake();
-    }
-    var maxForce = me.zpp_inner.maxForce;
-    if (maxForce != maxForce) {
-      throw new js._Boot.HaxeError("Error: Constraint::maxForce cannot be NaN");
-    }
-    if (maxForce < 0) {
-      throw new js._Boot.HaxeError("Error: Constraint::maxForce must be >=0");
-    }
-    if (ret.zpp_inner.maxForce != maxForce) {
-      ret.zpp_inner.maxForce = maxForce;
-      ret.zpp_inner.wake();
+  Object.getOwnPropertyNames(ZPP_Constraint.prototype).forEach(function(k2) {
+    if (k2 !== "constructor") {
+      zpp_nape.constraint.ZPP_Constraint.prototype[k2] = ZPP_Constraint.prototype[k2];
     }
-    var damping = me.zpp_inner.damping;
-    if (damping != damping) {
-      throw new js._Boot.HaxeError("Error: Constraint::Damping cannot be Nan");
-    }
-    if (damping < 0) {
-      throw new js._Boot.HaxeError("Error: Constraint::Damping must be >=0");
-    }
-    if (ret.zpp_inner.damping != damping) {
-      ret.zpp_inner.damping = damping;
-      if (!ret.zpp_inner.stiff) {
-        ret.zpp_inner.wake();
-      }
-    }
-    var frequency = me.zpp_inner.frequency;
-    if (frequency != frequency) {
-      throw new js._Boot.HaxeError(
-        "Error: Constraint::Frequency cannot be NaN"
-      );
-    }
-    if (frequency <= 0) {
-      throw new js._Boot.HaxeError("Error: Constraint::Frequency must be >0");
-    }
-    if (ret.zpp_inner.frequency != frequency) {
-      ret.zpp_inner.frequency = frequency;
-      if (!ret.zpp_inner.stiff) {
-        ret.zpp_inner.wake();
-      }
-    }
-    var stiff = me.zpp_inner.stiff;
-    if (ret.zpp_inner.stiff != stiff) {
-      ret.zpp_inner.stiff = stiff;
-      ret.zpp_inner.wake();
-    }
-    var ignore = me.zpp_inner.ignore;
-    if (ret.zpp_inner.ignore != ignore) {
-      ret.zpp_inner.ignore = ignore;
-      ret.zpp_inner.wake();
-    }
-    var active = me.zpp_inner.active;
-    if (ret.zpp_inner.active != active) {
-      if (ret.zpp_inner.component != null) {
-        ret.zpp_inner.component.woken = false;
-      }
-      ret.zpp_inner.clearcache();
-      if (active) {
-        ret.zpp_inner.active = active;
-        ret.zpp_inner.activate();
-        if (ret.zpp_inner.space != null) {
-          if (ret.zpp_inner.component != null) {
-            ret.zpp_inner.component.sleeping = true;
-          }
-          ret.zpp_inner.space.wake_constraint(ret.zpp_inner, true);
-        }
-      } else {
-        if (ret.zpp_inner.space != null) {
-          ret.zpp_inner.wake();
-          ret.zpp_inner.space.live_constraints.remove(ret.zpp_inner);
-        }
-        ret.zpp_inner.active = active;
-        ret.zpp_inner.deactivate();
-      }
-    }
-  };
+  });
+  zpp_nape.constraint.ZPP_Constraint.__name__ = ZPP_Constraint.__name__;
   zpp_nape.constraint.ZPP_Constraint.prototype.__class__ = zpp_nape.constraint.ZPP_Constraint;
   zpp_nape.constraint.ZPP_AngleJoint = $hxClasses["zpp_nape.constraint.ZPP_AngleJoint"] = function() {
     this.stepped = false;
@@ -29865,31 +29907,7 @@ define(function() {
   zpp_nape.constraint.ZPP_AngleJoint.prototype.draw = function(g) {
   };
   zpp_nape.constraint.ZPP_AngleJoint.prototype.__class__ = zpp_nape.constraint.ZPP_AngleJoint;
-  zpp_nape.constraint.ZPP_CopyHelper = $hxClasses["zpp_nape.constraint.ZPP_CopyHelper"] = function() {
-    this.cb = null;
-    this.bc = null;
-    this.id = 0;
-  };
-  zpp_nape.constraint.ZPP_CopyHelper.__name__ = [
-    "zpp_nape",
-    "constraint",
-    "ZPP_CopyHelper"
-  ];
-  zpp_nape.constraint.ZPP_CopyHelper.dict = function(id, bc) {
-    var ret = new zpp_nape.constraint.ZPP_CopyHelper();
-    ret.id = id;
-    ret.bc = bc;
-    return ret;
-  };
-  zpp_nape.constraint.ZPP_CopyHelper.todo = function(id, cb) {
-    var ret = new zpp_nape.constraint.ZPP_CopyHelper();
-    ret.id = id;
-    ret.cb = cb;
-    return ret;
-  };
-  zpp_nape.constraint.ZPP_CopyHelper.prototype.id = null;
-  zpp_nape.constraint.ZPP_CopyHelper.prototype.bc = null;
-  zpp_nape.constraint.ZPP_CopyHelper.prototype.cb = null;
+  zpp_nape.constraint.ZPP_CopyHelper = $hxClasses["zpp_nape.constraint.ZPP_CopyHelper"] = ZPP_CopyHelper;
   zpp_nape.constraint.ZPP_CopyHelper.prototype.__class__ = zpp_nape.constraint.ZPP_CopyHelper;
   zpp_nape.constraint.ZPP_DistanceJoint = $hxClasses["zpp_nape.constraint.ZPP_DistanceJoint"] = function() {
     this.stepped = false;
@@ -90331,7 +90349,7 @@ var PulleyJoint = class _PulleyJoint extends Constraint {
 };
 
 // src/index.ts
-var VERSION = "3.3.20";
+var VERSION = "3.3.22";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AABB,