@newkrok/nape-js 3.4.1 → 3.4.2

package/dist/index.cjs

@@ -1318,6 +1318,53 @@ _ZPP_Flags.ArbiterType_SENSOR = null;
 _ZPP_Flags.ArbiterType_FLUID = null;
 // --- Internal flag ---
 _ZPP_Flags.internal = false;
+// --- ID constants (numeric bitmasks / enum ordinals) ---
+_ZPP_Flags.id_ImmState_ACCEPT = 1;
+_ZPP_Flags.id_ImmState_IGNORE = 2;
+_ZPP_Flags.id_ImmState_ALWAYS = 4;
+_ZPP_Flags.id_GravMassMode_DEFAULT = 0;
+_ZPP_Flags.id_GravMassMode_FIXED = 1;
+_ZPP_Flags.id_GravMassMode_SCALED = 2;
+_ZPP_Flags.id_InertiaMode_DEFAULT = 0;
+_ZPP_Flags.id_InertiaMode_FIXED = 1;
+_ZPP_Flags.id_MassMode_DEFAULT = 0;
+_ZPP_Flags.id_MassMode_FIXED = 1;
+_ZPP_Flags.id_BodyType_STATIC = 1;
+_ZPP_Flags.id_BodyType_DYNAMIC = 2;
+_ZPP_Flags.id_BodyType_KINEMATIC = 3;
+_ZPP_Flags.id_ListenerType_BODY = 0;
+_ZPP_Flags.id_ListenerType_CONSTRAINT = 1;
+_ZPP_Flags.id_ListenerType_INTERACTION = 2;
+_ZPP_Flags.id_ListenerType_PRE = 3;
+_ZPP_Flags.id_PreFlag_ACCEPT = 1;
+_ZPP_Flags.id_PreFlag_IGNORE = 2;
+_ZPP_Flags.id_PreFlag_ACCEPT_ONCE = 3;
+_ZPP_Flags.id_PreFlag_IGNORE_ONCE = 4;
+_ZPP_Flags.id_CbEvent_BEGIN = 0;
+_ZPP_Flags.id_CbEvent_END = 1;
+_ZPP_Flags.id_CbEvent_WAKE = 2;
+_ZPP_Flags.id_CbEvent_SLEEP = 3;
+_ZPP_Flags.id_CbEvent_BREAK = 4;
+_ZPP_Flags.id_CbEvent_PRE = 5;
+_ZPP_Flags.id_CbEvent_ONGOING = 6;
+_ZPP_Flags.id_InteractionType_COLLISION = 1;
+_ZPP_Flags.id_InteractionType_SENSOR = 2;
+_ZPP_Flags.id_InteractionType_FLUID = 4;
+_ZPP_Flags.id_InteractionType_ANY = 7;
+_ZPP_Flags.id_Winding_UNDEFINED = 0;
+_ZPP_Flags.id_Winding_CLOCKWISE = 1;
+_ZPP_Flags.id_Winding_ANTICLOCKWISE = 2;
+_ZPP_Flags.id_ValidationResult_VALID = 0;
+_ZPP_Flags.id_ValidationResult_DEGENERATE = 1;
+_ZPP_Flags.id_ValidationResult_CONCAVE = 2;
+_ZPP_Flags.id_ValidationResult_SELF_INTERSECTING = 3;
+_ZPP_Flags.id_ShapeType_CIRCLE = 0;
+_ZPP_Flags.id_ShapeType_POLYGON = 1;
+_ZPP_Flags.id_Broadphase_DYNAMIC_AABB_TREE = 0;
+_ZPP_Flags.id_Broadphase_SWEEP_AND_PRUNE = 1;
+_ZPP_Flags.id_ArbiterType_COLLISION = 1;
+_ZPP_Flags.id_ArbiterType_SENSOR = 2;
+_ZPP_Flags.id_ArbiterType_FLUID = 4;
 var ZPP_Flags = _ZPP_Flags;
 
 // src/native/callbacks/ZPP_CbType.ts
@@ -1348,6 +1395,15 @@ var _ZPP_CbType = class _ZPP_CbType {
     this.interactors = new zpp8.util.ZNPList_ZPP_Interactor();
     this.cbsets = new zpp8.util.ZNPList_ZPP_CbSet();
   }
+  /**
+   * Initialize ANY_* singleton CbTypes. Called once from compiled factory.
+   */
+  static _initEnums(nape67) {
+    _ZPP_CbType.ANY_SHAPE = new nape67.callbacks.CbType();
+    _ZPP_CbType.ANY_BODY = new nape67.callbacks.CbType();
+    _ZPP_CbType.ANY_COMPOUND = new nape67.callbacks.CbType();
+    _ZPP_CbType.ANY_CONSTRAINT = new nape67.callbacks.CbType();
+  }
   /** Sort comparator by id. */
   static setlt(a, b) {
     return a.id < b.id;
@@ -1526,6 +1582,11 @@ var _ZPP_CbType = class _ZPP_CbType {
 _ZPP_CbType.__name__ = ["zpp_nape", "callbacks", "ZPP_CbType"];
 // --- Static: namespace references ---
 _ZPP_CbType._zpp = null;
+// --- Static: ANY_* singleton CbType instances (set by _initEnums) ---
+_ZPP_CbType.ANY_SHAPE = null;
+_ZPP_CbType.ANY_BODY = null;
+_ZPP_CbType.ANY_COMPOUND = null;
+_ZPP_CbType.ANY_CONSTRAINT = null;
 var ZPP_CbType = _ZPP_CbType;
 
 // src/native/util/ZPP_ID.ts
@@ -2350,6 +2411,37 @@ var _ZPP_Listener = class _ZPP_Listener {
   }
   removedFromSpace() {
   }
+  /**
+   * Initialize singleton enum arrays. Called once from compiled factory after
+   * nape.callbacks.ListenerType and nape.callbacks.CbEvent stubs exist.
+   */
+  static _initEnums(nape67, ZPP_Flags2) {
+    const mkLT = () => {
+      ZPP_Flags2.internal = true;
+      const o = new nape67.callbacks.ListenerType();
+      ZPP_Flags2.internal = false;
+      return o;
+    };
+    if (ZPP_Flags2.ListenerType_BODY == null) ZPP_Flags2.ListenerType_BODY = mkLT();
+    if (ZPP_Flags2.ListenerType_CONSTRAINT == null) ZPP_Flags2.ListenerType_CONSTRAINT = mkLT();
+    if (ZPP_Flags2.ListenerType_INTERACTION == null) ZPP_Flags2.ListenerType_INTERACTION = mkLT();
+    if (ZPP_Flags2.ListenerType_PRE == null) ZPP_Flags2.ListenerType_PRE = mkLT();
+    _ZPP_Listener.types = [ZPP_Flags2.ListenerType_BODY, ZPP_Flags2.ListenerType_CONSTRAINT, ZPP_Flags2.ListenerType_INTERACTION, ZPP_Flags2.ListenerType_PRE];
+    const mkCE = () => {
+      ZPP_Flags2.internal = true;
+      const o = new nape67.callbacks.CbEvent();
+      ZPP_Flags2.internal = false;
+      return o;
+    };
+    if (ZPP_Flags2.CbEvent_BEGIN == null) ZPP_Flags2.CbEvent_BEGIN = mkCE();
+    if (ZPP_Flags2.CbEvent_END == null) ZPP_Flags2.CbEvent_END = mkCE();
+    if (ZPP_Flags2.CbEvent_WAKE == null) ZPP_Flags2.CbEvent_WAKE = mkCE();
+    if (ZPP_Flags2.CbEvent_SLEEP == null) ZPP_Flags2.CbEvent_SLEEP = mkCE();
+    if (ZPP_Flags2.CbEvent_BREAK == null) ZPP_Flags2.CbEvent_BREAK = mkCE();
+    if (ZPP_Flags2.CbEvent_PRE == null) ZPP_Flags2.CbEvent_PRE = mkCE();
+    if (ZPP_Flags2.CbEvent_ONGOING == null) ZPP_Flags2.CbEvent_ONGOING = mkCE();
+    _ZPP_Listener.events = [ZPP_Flags2.CbEvent_BEGIN, ZPP_Flags2.CbEvent_END, ZPP_Flags2.CbEvent_WAKE, ZPP_Flags2.CbEvent_SLEEP, ZPP_Flags2.CbEvent_BREAK, ZPP_Flags2.CbEvent_PRE, ZPP_Flags2.CbEvent_ONGOING];
+  }
 };
 // --- Static: Haxe metadata ---
 _ZPP_Listener.__name__ = ["zpp_nape", "callbacks", "ZPP_Listener"];
@@ -3073,6 +3165,17 @@ var _ZPP_InteractionListener = class _ZPP_InteractionListener extends ZPP_Listen
     }
     return ret;
   }
+  /**
+   * Initialize static working lists. Called once from compiled factory.
+   */
+  static _initStatics(zpp_nape) {
+    _ZPP_InteractionListener.UCbSet = new zpp_nape.util.ZNPList_ZPP_CbSet();
+    _ZPP_InteractionListener.VCbSet = new zpp_nape.util.ZNPList_ZPP_CbSet();
+    _ZPP_InteractionListener.WCbSet = new zpp_nape.util.ZNPList_ZPP_CbSet();
+    _ZPP_InteractionListener.UCbType = new zpp_nape.util.ZNPList_ZPP_CbType();
+    _ZPP_InteractionListener.VCbType = new zpp_nape.util.ZNPList_ZPP_CbType();
+    _ZPP_InteractionListener.WCbType = new zpp_nape.util.ZNPList_ZPP_CbType();
+  }
 };
 _ZPP_InteractionListener.__name__ = ["zpp_nape", "callbacks", "ZPP_InteractionListener"];
 // --- Static: working lists for set operations (initialized at engine init time) ---
@@ -5855,6 +5958,21 @@ var _ZPP_Body = class _ZPP_Body {
       }
     }
   }
+  /**
+   * Initialize BodyType singleton enums. Called once from compiled factory.
+   */
+  static _initEnums(nape67, ZPP_Flags2) {
+    const mk = () => {
+      ZPP_Flags2.internal = true;
+      const o = new nape67.phys.BodyType();
+      ZPP_Flags2.internal = false;
+      return o;
+    };
+    if (ZPP_Flags2.BodyType_STATIC == null) ZPP_Flags2.BodyType_STATIC = mk();
+    if (ZPP_Flags2.BodyType_DYNAMIC == null) ZPP_Flags2.BodyType_DYNAMIC = mk();
+    if (ZPP_Flags2.BodyType_KINEMATIC == null) ZPP_Flags2.BodyType_KINEMATIC = mk();
+    _ZPP_Body.types = [null, ZPP_Flags2.BodyType_STATIC, ZPP_Flags2.BodyType_DYNAMIC, ZPP_Flags2.BodyType_KINEMATIC];
+  }
 };
 // --- Static: Haxe metadata ---
 _ZPP_Body.__name__ = ["zpp_nape", "phys", "ZPP_Body"];
@@ -6824,6 +6942,21 @@ var _ZPP_Arbiter = class _ZPP_Arbiter {
     this.hnext = null;
     this.outer = null;
   }
+  /**
+   * Initialize ArbiterType singleton enums. Called once from compiled factory.
+   */
+  static _initEnums(nape67, ZPP_Flags2) {
+    const mk = () => {
+      ZPP_Flags2.internal = true;
+      const o = new nape67.dynamics.ArbiterType();
+      ZPP_Flags2.internal = false;
+      return o;
+    };
+    if (ZPP_Flags2.ArbiterType_COLLISION == null) ZPP_Flags2.ArbiterType_COLLISION = mk();
+    if (ZPP_Flags2.ArbiterType_SENSOR == null) ZPP_Flags2.ArbiterType_SENSOR = mk();
+    if (ZPP_Flags2.ArbiterType_FLUID == null) ZPP_Flags2.ArbiterType_FLUID = mk();
+    _ZPP_Arbiter.types = [null, ZPP_Flags2.ArbiterType_COLLISION, ZPP_Flags2.ArbiterType_SENSOR, null, ZPP_Flags2.ArbiterType_FLUID];
+  }
   // ========== Wrapper ==========
   wrapper() {
     if (this.outer == null) {
@@ -6982,7 +7115,7 @@ _ZPP_Arbiter.internal = false;
 _ZPP_Arbiter.COL = 1;
 _ZPP_Arbiter.FLUID = 4;
 _ZPP_Arbiter.SENSOR = 2;
-// --- Static: arbiter type enum lookup (set at init time by compiled code) ---
+// --- Static: arbiter type enum lookup (populated by _initEnums) ---
 _ZPP_Arbiter.types = [];
 var ZPP_Arbiter = _ZPP_Arbiter;
 
@@ -13991,6 +14124,20 @@ var _ZPP_Shape = class _ZPP_Shape {
       this._initShape(type);
     }
   }
+  /**
+   * Initialize ShapeType singleton enums. Called once from compiled factory.
+   */
+  static _initEnums(nape67, ZPP_Flags2) {
+    const mk = () => {
+      ZPP_Flags2.internal = true;
+      const o = new nape67.shape.ShapeType();
+      ZPP_Flags2.internal = false;
+      return o;
+    };
+    if (ZPP_Flags2.ShapeType_CIRCLE == null) ZPP_Flags2.ShapeType_CIRCLE = mk();
+    if (ZPP_Flags2.ShapeType_POLYGON == null) ZPP_Flags2.ShapeType_POLYGON = mk();
+    _ZPP_Shape.types = [ZPP_Flags2.ShapeType_CIRCLE, ZPP_Flags2.ShapeType_POLYGON];
+  }
   /**
    * Initialize shape state. Separated from constructor so that compiled
    * subclass constructors can call `ZPP_Shape.call(this, type)` which
@@ -14356,12 +14503,7 @@ var _ZPP_Shape = class _ZPP_Shape {
     ret.fluidEnabled = this.fluidEnabled;
     ret.sensorEnabled = this.sensorEnabled;
     if (this.userData != null) {
-      const Reflect2 = nape67.__Reflect || _ZPP_Shape._zpp.__Reflect;
-      if (Reflect2 && Reflect2.copy) {
-        ret.userData = Reflect2.copy(this.userData);
-      } else {
-        ret.userData = Object.assign({}, this.userData);
-      }
+      ret.userData = Object.assign({}, this.userData);
     }
     this.copyto(ret.outer);
     return ret.outer;
@@ -14373,7 +14515,7 @@ _ZPP_Shape.__super__ = null;
 // --- Static: namespace references ---
 _ZPP_Shape._nape = null;
 _ZPP_Shape._zpp = null;
-// --- Static: shape type enum lookup ---
+// --- Static: shape type enum lookup (populated by _initEnums) ---
 _ZPP_Shape.types = [];
 // --- Static: init guard ---
 _ZPP_Shape._initialized = false;
@@ -20904,6 +21046,199 @@ var _ZPP_SimpleSweep = class _ZPP_SimpleSweep {
 _ZPP_SimpleSweep.__name__ = ["zpp_nape", "geom", "ZPP_SimpleSweep"];
 var ZPP_SimpleSweep = _ZPP_SimpleSweep;
 
+// src/native/util/Hashable2_Boolfalse.ts
+var _Hashable2_Boolfalse = class _Hashable2_Boolfalse {
+  constructor() {
+    this.value = false;
+    this.next = null;
+    this.hnext = null;
+    this.id = 0;
+    this.di = 0;
+    this.__class__ = _Hashable2_Boolfalse;
+  }
+  static _alloc() {
+    if (_Hashable2_Boolfalse.zpp_pool == null) {
+      return new _Hashable2_Boolfalse();
+    }
+    const ret = _Hashable2_Boolfalse.zpp_pool;
+    _Hashable2_Boolfalse.zpp_pool = ret.next;
+    ret.next = null;
+    return ret;
+  }
+  static get(id, di, val) {
+    const ret = _Hashable2_Boolfalse._alloc();
+    ret.id = id;
+    ret.di = di;
+    ret.value = val;
+    return ret;
+  }
+  static getpersist(id, di) {
+    const ret = _Hashable2_Boolfalse._alloc();
+    ret.id = id;
+    ret.di = di;
+    return ret;
+  }
+  static ordered_get(id, di, val) {
+    if (id <= di) {
+      const ret = _Hashable2_Boolfalse._alloc();
+      ret.id = id;
+      ret.di = di;
+      ret.value = val;
+      return ret;
+    } else {
+      const ret = _Hashable2_Boolfalse._alloc();
+      ret.id = di;
+      ret.di = id;
+      ret.value = val;
+      return ret;
+    }
+  }
+  static ordered_get_persist(id, di) {
+    if (id <= di) {
+      const ret = _Hashable2_Boolfalse._alloc();
+      ret.id = id;
+      ret.di = di;
+      return ret;
+    } else {
+      const ret = _Hashable2_Boolfalse._alloc();
+      ret.id = di;
+      ret.di = id;
+      return ret;
+    }
+  }
+  free() {
+  }
+  alloc() {
+  }
+};
+_Hashable2_Boolfalse.__name__ = ["zpp_nape", "util", "Hashable2_Boolfalse"];
+_Hashable2_Boolfalse.zpp_pool = null;
+var Hashable2_Boolfalse = _Hashable2_Boolfalse;
+
+// src/native/util/FastHash2_Hashable2_Boolfalse.ts
+var TABLE_SIZE = 1048576;
+var TABLE_MASK = 1048575;
+var HASH_MULT = 106039;
+var _FastHash2_Hashable2_Boolfalse = class _FastHash2_Hashable2_Boolfalse {
+  constructor() {
+    this.cnt = 0;
+    this.__class__ = _FastHash2_Hashable2_Boolfalse;
+    this.cnt = 0;
+    this.table = new Array(TABLE_SIZE).fill(null);
+  }
+  empty() {
+    return this.cnt == 0;
+  }
+  clear() {
+    for (let i = 0; i < this.table.length; i++) {
+      let n = this.table[i];
+      if (n == null) continue;
+      while (n != null) {
+        const t = n.hnext;
+        n.hnext = null;
+        n = t;
+      }
+      this.table[i] = null;
+    }
+  }
+  get(id, di) {
+    let n = this.table[id * HASH_MULT + di & TABLE_MASK];
+    if (n == null) {
+      return null;
+    } else if (n.id == id && n.di == di) {
+      return n;
+    } else {
+      while (true) {
+        n = n.hnext;
+        if (!(n != null && (n.id != id || n.di != di))) break;
+      }
+      return n;
+    }
+  }
+  ordered_get(id, di) {
+    if (id > di) {
+      const t = id;
+      id = di;
+      di = t;
+    }
+    let n = this.table[id * HASH_MULT + di & TABLE_MASK];
+    if (n == null) {
+      return null;
+    } else if (n.id == id && n.di == di) {
+      return n;
+    } else {
+      while (true) {
+        n = n.hnext;
+        if (!(n != null && (n.id != id || n.di != di))) break;
+      }
+      return n;
+    }
+  }
+  has(id, di) {
+    let n = this.table[id * HASH_MULT + di & TABLE_MASK];
+    if (n == null) {
+      return false;
+    } else if (n.id == id && n.di == di) {
+      return true;
+    } else {
+      while (true) {
+        n = n.hnext;
+        if (!(n != null && (n.id != id || n.di != di))) break;
+      }
+      return n != null;
+    }
+  }
+  maybeAdd(arb) {
+    const h = arb.id * HASH_MULT + arb.di & TABLE_MASK;
+    const n = this.table[h];
+    const cont = true;
+    if (n == null) {
+      this.table[h] = arb;
+      arb.hnext = null;
+    } else if (cont) {
+      arb.hnext = n.hnext;
+      n.hnext = arb;
+    }
+    if (cont) {
+      this.cnt++;
+    }
+  }
+  add(arb) {
+    const h = arb.id * HASH_MULT + arb.di & TABLE_MASK;
+    const n = this.table[h];
+    if (n == null) {
+      this.table[h] = arb;
+      arb.hnext = null;
+    } else {
+      arb.hnext = n.hnext;
+      n.hnext = arb;
+    }
+    this.cnt++;
+  }
+  remove(arb) {
+    const h = arb.id * HASH_MULT + arb.di & TABLE_MASK;
+    let n = this.table[h];
+    if (n == arb) {
+      this.table[h] = n.hnext;
+    } else if (n != null) {
+      let pre;
+      while (true) {
+        pre = n;
+        n = n.hnext;
+        if (!(n != null && n != arb)) break;
+      }
+      pre.hnext = n.hnext;
+    }
+    arb.hnext = null;
+    this.cnt--;
+  }
+  hash(id, di) {
+    return id * HASH_MULT + di & TABLE_MASK;
+  }
+};
+_FastHash2_Hashable2_Boolfalse.__name__ = ["zpp_nape", "util", "FastHash2_Hashable2_Boolfalse"];
+var FastHash2_Hashable2_Boolfalse = _FastHash2_Hashable2_Boolfalse;
+
 // src/native/geom/ZPP_Simple.ts
 var _ZPP_Simple = class _ZPP_Simple {
   constructor() {
@@ -20913,7 +21248,7 @@ var _ZPP_Simple = class _ZPP_Simple {
     const zpp8 = getNape().__zpp;
     if (_ZPP_Simple.sweep == null) {
       _ZPP_Simple.sweep = new ZPP_SimpleSweep();
-      _ZPP_Simple.inthash = new zpp8.util.FastHash2_Hashable2_Boolfalse();
+      _ZPP_Simple.inthash = new FastHash2_Hashable2_Boolfalse();
     }
     if (_ZPP_Simple.vertices == null) {
       if (zpp8.util.ZPP_Set_ZPP_SimpleVert.zpp_pool == null) {
@@ -21121,11 +21456,11 @@ var _ZPP_Simple = class _ZPP_Simple {
                   const id = s.next.id;
                   const di = s.id;
                   let ret5;
-                  if (zpp8.util.Hashable2_Boolfalse.zpp_pool == null) {
-                    ret5 = new zpp8.util.Hashable2_Boolfalse();
+                  if (Hashable2_Boolfalse.zpp_pool == null) {
+                    ret5 = new Hashable2_Boolfalse();
                   } else {
-                    ret5 = zpp8.util.Hashable2_Boolfalse.zpp_pool;
-                    zpp8.util.Hashable2_Boolfalse.zpp_pool = ret5.next;
+                    ret5 = Hashable2_Boolfalse.zpp_pool;
+                    Hashable2_Boolfalse.zpp_pool = ret5.next;
                     ret5.next = null;
                   }
                   ret5.id = id;
@@ -21138,11 +21473,11 @@ var _ZPP_Simple = class _ZPP_Simple {
                   const id1 = s.id;
                   const di1 = s.next.id;
                   let ret7;
-                  if (zpp8.util.Hashable2_Boolfalse.zpp_pool == null) {
-                    ret7 = new zpp8.util.Hashable2_Boolfalse();
+                  if (Hashable2_Boolfalse.zpp_pool == null) {
+                    ret7 = new Hashable2_Boolfalse();
                   } else {
-                    ret7 = zpp8.util.Hashable2_Boolfalse.zpp_pool;
-                    zpp8.util.Hashable2_Boolfalse.zpp_pool = ret7.next;
+                    ret7 = Hashable2_Boolfalse.zpp_pool;
+                    Hashable2_Boolfalse.zpp_pool = ret7.next;
                     ret7.next = null;
                   }
                   ret7.id = id1;
@@ -21229,11 +21564,11 @@ var _ZPP_Simple = class _ZPP_Simple {
                   const id2 = s.id;
                   const di2 = s.prev.id;
                   let ret9;
-                  if (zpp8.util.Hashable2_Boolfalse.zpp_pool == null) {
-                    ret9 = new zpp8.util.Hashable2_Boolfalse();
+                  if (Hashable2_Boolfalse.zpp_pool == null) {
+                    ret9 = new Hashable2_Boolfalse();
                   } else {
-                    ret9 = zpp8.util.Hashable2_Boolfalse.zpp_pool;
-                    zpp8.util.Hashable2_Boolfalse.zpp_pool = ret9.next;
+                    ret9 = Hashable2_Boolfalse.zpp_pool;
+                    Hashable2_Boolfalse.zpp_pool = ret9.next;
                     ret9.next = null;
                   }
                   ret9.id = id2;
@@ -21246,11 +21581,11 @@ var _ZPP_Simple = class _ZPP_Simple {
                   const id3 = s.prev.id;
                   const di3 = s.id;
                   let ret11;
-                  if (zpp8.util.Hashable2_Boolfalse.zpp_pool == null) {
-                    ret11 = new zpp8.util.Hashable2_Boolfalse();
+                  if (Hashable2_Boolfalse.zpp_pool == null) {
+                    ret11 = new Hashable2_Boolfalse();
                   } else {
-                    ret11 = zpp8.util.Hashable2_Boolfalse.zpp_pool;
-                    zpp8.util.Hashable2_Boolfalse.zpp_pool = ret11.next;
+                    ret11 = Hashable2_Boolfalse.zpp_pool;
+                    Hashable2_Boolfalse.zpp_pool = ret11.next;
                     ret11.next = null;
                   }
                   ret11.id = id3;
@@ -21350,11 +21685,11 @@ var _ZPP_Simple = class _ZPP_Simple {
                     const id4 = nxt.id;
                     const di4 = pre1.id;
                     let ret13;
-                    if (zpp8.util.Hashable2_Boolfalse.zpp_pool == null) {
-                      ret13 = new zpp8.util.Hashable2_Boolfalse();
+                    if (Hashable2_Boolfalse.zpp_pool == null) {
+                      ret13 = new Hashable2_Boolfalse();
                     } else {
-                      ret13 = zpp8.util.Hashable2_Boolfalse.zpp_pool;
-                      zpp8.util.Hashable2_Boolfalse.zpp_pool = ret13.next;
+                      ret13 = Hashable2_Boolfalse.zpp_pool;
+                      Hashable2_Boolfalse.zpp_pool = ret13.next;
                       ret13.next = null;
                     }
                     ret13.id = id4;
@@ -21367,11 +21702,11 @@ var _ZPP_Simple = class _ZPP_Simple {
                     const id5 = pre1.id;
                     const di5 = nxt.id;
                     let ret15;
-                    if (zpp8.util.Hashable2_Boolfalse.zpp_pool == null) {
-                      ret15 = new zpp8.util.Hashable2_Boolfalse();
+                    if (Hashable2_Boolfalse.zpp_pool == null) {
+                      ret15 = new Hashable2_Boolfalse();
                     } else {
-                      ret15 = zpp8.util.Hashable2_Boolfalse.zpp_pool;
-                      zpp8.util.Hashable2_Boolfalse.zpp_pool = ret15.next;
+                      ret15 = Hashable2_Boolfalse.zpp_pool;
+                      Hashable2_Boolfalse.zpp_pool = ret15.next;
                       ret15.next = null;
                     }
                     ret15.id = id5;
@@ -21549,11 +21884,11 @@ var _ZPP_Simple = class _ZPP_Simple {
                   const id6 = b.next.id;
                   const di6 = b.id;
                   let ret17;
-                  if (zpp8.util.Hashable2_Boolfalse.zpp_pool == null) {
-                    ret17 = new zpp8.util.Hashable2_Boolfalse();
+                  if (Hashable2_Boolfalse.zpp_pool == null) {
+                    ret17 = new Hashable2_Boolfalse();
                   } else {
-                    ret17 = zpp8.util.Hashable2_Boolfalse.zpp_pool;
-                    zpp8.util.Hashable2_Boolfalse.zpp_pool = ret17.next;
+                    ret17 = Hashable2_Boolfalse.zpp_pool;
+                    Hashable2_Boolfalse.zpp_pool = ret17.next;
                     ret17.next = null;
                   }
                   ret17.id = id6;
@@ -21566,11 +21901,11 @@ var _ZPP_Simple = class _ZPP_Simple {
                   const id7 = b.id;
                   const di7 = b.next.id;
                   let ret19;
-                  if (zpp8.util.Hashable2_Boolfalse.zpp_pool == null) {
-                    ret19 = new zpp8.util.Hashable2_Boolfalse();
+                  if (Hashable2_Boolfalse.zpp_pool == null) {
+                    ret19 = new Hashable2_Boolfalse();
                   } else {
-                    ret19 = zpp8.util.Hashable2_Boolfalse.zpp_pool;
-                    zpp8.util.Hashable2_Boolfalse.zpp_pool = ret19.next;
+                    ret19 = Hashable2_Boolfalse.zpp_pool;
+                    Hashable2_Boolfalse.zpp_pool = ret19.next;
                     ret19.next = null;
                   }
                   ret19.id = id7;
@@ -21657,11 +21992,11 @@ var _ZPP_Simple = class _ZPP_Simple {
                   const id8 = a.id;
                   const di8 = a.prev.id;
                   let ret21;
-                  if (zpp8.util.Hashable2_Boolfalse.zpp_pool == null) {
-                    ret21 = new zpp8.util.Hashable2_Boolfalse();
+                  if (Hashable2_Boolfalse.zpp_pool == null) {
+                    ret21 = new Hashable2_Boolfalse();
                   } else {
-                    ret21 = zpp8.util.Hashable2_Boolfalse.zpp_pool;
-                    zpp8.util.Hashable2_Boolfalse.zpp_pool = ret21.next;
+                    ret21 = Hashable2_Boolfalse.zpp_pool;
+                    Hashable2_Boolfalse.zpp_pool = ret21.next;
                     ret21.next = null;
                   }
                   ret21.id = id8;
@@ -21674,11 +22009,11 @@ var _ZPP_Simple = class _ZPP_Simple {
                   const id9 = a.prev.id;
                   const di9 = a.id;
                   let ret23;
-                  if (zpp8.util.Hashable2_Boolfalse.zpp_pool == null) {
-                    ret23 = new zpp8.util.Hashable2_Boolfalse();
+                  if (Hashable2_Boolfalse.zpp_pool == null) {
+                    ret23 = new Hashable2_Boolfalse();
                   } else {
-                    ret23 = zpp8.util.Hashable2_Boolfalse.zpp_pool;
-                    zpp8.util.Hashable2_Boolfalse.zpp_pool = ret23.next;
+                    ret23 = Hashable2_Boolfalse.zpp_pool;
+                    Hashable2_Boolfalse.zpp_pool = ret23.next;
                     ret23.next = null;
                   }
                   ret23.id = id9;
@@ -21742,8 +22077,8 @@ var _ZPP_Simple = class _ZPP_Simple {
         const t1 = n.hnext;
         n.hnext = null;
         const o28 = n;
-        o28.next = zpp8.util.Hashable2_Boolfalse.zpp_pool;
-        zpp8.util.Hashable2_Boolfalse.zpp_pool = o28;
+        o28.next = Hashable2_Boolfalse.zpp_pool;
+        Hashable2_Boolfalse.zpp_pool = o28;
         n = t1;
       }
       _ZPP_Simple.inthash.table[i] = null;
@@ -21916,7 +22251,7 @@ var _ZPP_Simple = class _ZPP_Simple {
     const zpp8 = getNape().__zpp;
     if (_ZPP_Simple.sweep == null) {
       _ZPP_Simple.sweep = new ZPP_SimpleSweep();
-      _ZPP_Simple.inthash = new zpp8.util.FastHash2_Hashable2_Boolfalse();
+      _ZPP_Simple.inthash = new FastHash2_Hashable2_Boolfalse();
     }
     let vertices = _ZPP_Simple.list_vertices;
     if (vertices == null) {
@@ -22863,6 +23198,13 @@ var _ZPP_Collide = class _ZPP_Collide {
   constructor() {
     this.__class__ = _ZPP_Collide;
   }
+  /**
+   * Initialize static working lists. Called once from compiled factory.
+   */
+  static _initStatics(zpp_nape) {
+    _ZPP_Collide.flowpoly = new zpp_nape.util.ZNPList_ZPP_Vec2();
+    _ZPP_Collide.flowsegs = new zpp_nape.util.ZNPList_ZPP_Vec2();
+  }
   static circleContains(c, p) {
     const dx = p.x - c.worldCOMx;
     const dy = p.y - c.worldCOMy;
@@ -29892,12 +30234,12 @@ var _ZPP_CallbackSet = class _ZPP_CallbackSet {
     if (!ret) {
       const _this = this.arbiters;
       let ret1;
-      const ZNPNode = _ZPP_CallbackSet._zpp.util.ZNPNode_ZPP_Arbiter;
-      if (ZNPNode.zpp_pool == null) {
-        ret1 = new ZNPNode();
+      const ZNPNode2 = _ZPP_CallbackSet._zpp.util.ZNPNode_ZPP_Arbiter;
+      if (ZNPNode2.zpp_pool == null) {
+        ret1 = new ZNPNode2();
       } else {
-        ret1 = ZNPNode.zpp_pool;
-        ZNPNode.zpp_pool = ret1.next;
+        ret1 = ZNPNode2.zpp_pool;
+        ZNPNode2.zpp_pool = ret1.next;
         ret1.next = null;
       }
       ret1.elt = x;
@@ -29937,9 +30279,9 @@ var _ZPP_CallbackSet = class _ZPP_CallbackSet {
         }
         const o = old;
         o.elt = null;
-        const ZNPNode = _ZPP_CallbackSet._zpp.util.ZNPNode_ZPP_Arbiter;
-        o.next = ZNPNode.zpp_pool;
-        ZNPNode.zpp_pool = o;
+        const ZNPNode2 = _ZPP_CallbackSet._zpp.util.ZNPNode_ZPP_Arbiter;
+        o.next = ZNPNode2.zpp_pool;
+        ZNPNode2.zpp_pool = o;
         _this.modified = true;
         _this.length--;
         _this.pushmod = true;
@@ -29976,9 +30318,9 @@ var _ZPP_CallbackSet = class _ZPP_CallbackSet {
         }
         const o = old;
         o.elt = null;
-        const ZNPNode = _ZPP_CallbackSet._zpp.util.ZNPNode_ZPP_Arbiter;
-        o.next = ZNPNode.zpp_pool;
-        ZNPNode.zpp_pool = o;
+        const ZNPNode2 = _ZPP_CallbackSet._zpp.util.ZNPNode_ZPP_Arbiter;
+        o.next = ZNPNode2.zpp_pool;
+        ZNPNode2.zpp_pool = o;
         _this.modified = true;
         _this.length--;
         _this.pushmod = true;
@@ -30472,6 +30814,12 @@ var _ZPP_AABBTree = class _ZPP_AABBTree {
     // --- Instance: Haxe class reference ---
     this.__class__ = _ZPP_AABBTree;
   }
+  /**
+   * Initialize static instances. Called once from compiled factory.
+   */
+  static _initStatics() {
+    _ZPP_AABBTree.tmpaabb = new ZPP_AABB();
+  }
   // ========== clear ==========
   clear() {
     if (this.root == null) {
@@ -50335,6 +50683,38 @@ _ZPP_Space._zpp = null;
 _ZPP_Space._nape = null;
 var ZPP_Space = _ZPP_Space;
 
+// src/native/util/ZNPArray2.ts
+var ZNPArray2 = class {
+  constructor(width, _height) {
+    this.list = [];
+    this.width = 0;
+    this.width = width;
+    this.list = [];
+  }
+  resize(width, height, def) {
+    this.width = width;
+    const len = width * height;
+    for (let i = 0; i < len; i++) {
+      this.list[i] = def;
+    }
+  }
+  get(x, y) {
+    return this.list[y * this.width + x];
+  }
+  set(x, y, obj) {
+    return this.list[y * this.width + x] = obj;
+  }
+};
+var ZNPArray2_Float = class extends ZNPArray2 {
+};
+ZNPArray2_Float.__name__ = ["zpp_nape", "util", "ZNPArray2_Float"];
+var ZNPArray2_ZPP_GeomVert = class extends ZNPArray2 {
+};
+ZNPArray2_ZPP_GeomVert.__name__ = ["zpp_nape", "util", "ZNPArray2_ZPP_GeomVert"];
+var ZNPArray2_ZPP_MarchPair = class extends ZNPArray2 {
+};
+ZNPArray2_ZPP_MarchPair.__name__ = ["zpp_nape", "util", "ZNPArray2_ZPP_MarchPair"];
+
 // src/native/geom/ZPP_MarchingSquares.ts
 var _ZPP_MarchingSquares = class _ZPP_MarchingSquares {
   constructor() {
@@ -50343,6 +50723,8 @@ var _ZPP_MarchingSquares = class _ZPP_MarchingSquares {
   static _init(zpp8, nape67) {
     _ZPP_MarchingSquares._zpp = zpp8;
     _ZPP_MarchingSquares._nape = nape67;
+    _ZPP_MarchingSquares.me = new _ZPP_MarchingSquares();
+    _ZPP_MarchingSquares.look_march = [-1, 224, 56, 216, 14, -1, 54, 214, 131, 99, -1, 91, 141, 109, 181, 85];
   }
   // ---------------------------------------------------------------------------
   // Helper: allocate a ZPP_GeomVert from pool
@@ -50543,13 +50925,13 @@ var _ZPP_MarchingSquares = class _ZPP_MarchingSquares {
     }
     if (combine) {
       if (_ZPP_MarchingSquares.map == null) {
-        _ZPP_MarchingSquares.map = new _ZPP_MarchingSquares._zpp.util.ZNPArray2_ZPP_MarchPair(xn, yn);
+        _ZPP_MarchingSquares.map = new ZNPArray2_ZPP_MarchPair(xn, yn);
       } else {
         _ZPP_MarchingSquares.map.resize(xn, yn, null);
       }
     }
     if (_ZPP_MarchingSquares.isos == null) {
-      _ZPP_MarchingSquares.isos = new _ZPP_MarchingSquares._zpp.util.ZNPArray2_Float(xn + 1, yn + 1);
+      _ZPP_MarchingSquares.isos = new ZNPArray2_Float(xn + 1, yn + 1);
     } else {
       _ZPP_MarchingSquares.isos.resize(xn + 1, yn + 1, 0);
     }
@@ -50591,7 +50973,7 @@ var _ZPP_MarchingSquares = class _ZPP_MarchingSquares {
       }
     }
     if (_ZPP_MarchingSquares.ints == null) {
-      _ZPP_MarchingSquares.ints = new _ZPP_MarchingSquares._zpp.util.ZNPArray2_ZPP_GeomVert(xn + 1, (yn << 1) + 1);
+      _ZPP_MarchingSquares.ints = new ZNPArray2_ZPP_GeomVert(xn + 1, (yn << 1) + 1);
     } else {
       _ZPP_MarchingSquares.ints.resize(xn + 1, (yn << 1) + 1, null);
     }
@@ -51696,176 +52078,923 @@ _ZPP_MarchingSquares._zpp = null;
 _ZPP_MarchingSquares._nape = null;
 var ZPP_MarchingSquares = _ZPP_MarchingSquares;
 
-// src/core/nape-compiled.js
-var _nape;
-var define = function(factory) {
-  _nape = factory();
+// src/native/util/ZNPNode.ts
+var ZNPNode = class {
+  constructor() {
+    this.elt = null;
+    this.next = null;
+  }
+  alloc() {
+  }
+  free() {
+    this.elt = null;
+  }
+  elem() {
+    return this.elt;
+  }
 };
-define(function() {
-  "use strict";
-  var nape67, zpp_nape, js, Std, Reflect2, StringTools, sandbox;
-  var $_, $hxClasses = $hxClasses || {}, $estr = function() {
-    return js.Boot.__string_rec(this, "");
-  };
-  function $bind(o, m) {
-    var f = function() {
-      return f.method.apply(f.scope, arguments);
-    };
-    f.scope = o;
-    f.method = m;
-    return f;
+ZNPNode.zpp_pool = null;
+
+// src/native/util/ZNPList.ts
+var ZNPList = class {
+  constructor() {
+    this.head = null;
+    this.length = 0;
+    this.modified = false;
+    this.pushmod = false;
   }
-  Reflect2 = $hxClasses["Reflect"] = function() {
-  };
-  Reflect2.__name__ = ["Reflect"];
-  Reflect2.field = function(o, field) {
-    try {
-      return o[field];
-    } catch (e) {
-      var e1 = e instanceof js._Boot.HaxeError ? e.val : e;
-      return null;
+  _allocNode() {
+    const N = this.constructor._NodeClass;
+    let ret;
+    if (N.zpp_pool == null) {
+      ret = new N();
+    } else {
+      ret = N.zpp_pool;
+      N.zpp_pool = ret.next;
+      ret.next = null;
     }
-  };
-  Reflect2.fields = function(o) {
-    var a = [];
-    if (o != null) {
-      var hasOwnProperty = Object.prototype.hasOwnProperty;
-      for (var f in o) {
-        if (f != "__id__" && f != "hx__closures__" && hasOwnProperty.call(o, f)) {
-          a.push(f);
+    return ret;
+  }
+  _freeNode(node) {
+    const N = this.constructor._NodeClass;
+    node.elt = null;
+    node.next = N.zpp_pool;
+    N.zpp_pool = node;
+  }
+  begin() {
+    return this.head;
+  }
+  setbegin(i) {
+    this.head = i;
+    this.modified = true;
+    this.pushmod = true;
+  }
+  add(o) {
+    const node = this._allocNode();
+    node.elt = o;
+    node.next = this.head;
+    this.head = node;
+    this.modified = true;
+    this.length++;
+    return o;
+  }
+  addAll(x) {
+    let cx_ite = x.head;
+    while (cx_ite != null) {
+      this.add(cx_ite.elt);
+      cx_ite = cx_ite.next;
+    }
+  }
+  insert(cur, o) {
+    const node = this._allocNode();
+    node.elt = o;
+    if (cur == null) {
+      node.next = this.head;
+      this.head = node;
+    } else {
+      node.next = cur.next;
+      cur.next = node;
+    }
+    this.pushmod = this.modified = true;
+    this.length++;
+    return node;
+  }
+  pop() {
+    const ret = this.head;
+    this.head = ret.next;
+    this._freeNode(ret);
+    if (this.head == null) {
+      this.pushmod = true;
+    }
+    this.modified = true;
+    this.length--;
+  }
+  pop_unsafe() {
+    const ret = this.head.elt;
+    this.pop();
+    return ret;
+  }
+  erase(pre) {
+    let old;
+    let ret;
+    if (pre == null) {
+      old = this.head;
+      ret = old.next;
+      this.head = ret;
+      if (this.head == null) {
+        this.pushmod = true;
+      }
+    } else {
+      old = pre.next;
+      ret = old.next;
+      pre.next = ret;
+      if (ret == null) {
+        this.pushmod = true;
+      }
+    }
+    this._freeNode(old);
+    this.modified = true;
+    this.length--;
+    this.pushmod = true;
+    return ret;
+  }
+  remove(obj) {
+    let pre = null;
+    let cur = this.head;
+    while (cur != null) {
+      if (cur.elt == obj) {
+        this.erase(pre);
+        break;
+      }
+      pre = cur;
+      cur = cur.next;
+    }
+  }
+  try_remove(obj) {
+    let pre = null;
+    let cur = this.head;
+    let ret = false;
+    while (cur != null) {
+      if (cur.elt == obj) {
+        this.erase(pre);
+        ret = true;
+        break;
+      }
+      pre = cur;
+      cur = cur.next;
+    }
+    return ret;
+  }
+  splice(pre, n) {
+    while (n-- > 0 && pre.next != null) this.erase(pre);
+    return pre.next;
+  }
+  clear() {
+    while (this.head != null) {
+      const ret = this.head;
+      this.head = ret.next;
+      this._freeNode(ret);
+      if (this.head == null) {
+        this.pushmod = true;
+      }
+      this.modified = true;
+      this.length--;
+    }
+    this.pushmod = true;
+  }
+  reverse() {
+    let cur = this.head;
+    let pre = null;
+    while (cur != null) {
+      const nx = cur.next;
+      cur.next = pre;
+      this.head = cur;
+      pre = cur;
+      cur = nx;
+    }
+    this.modified = true;
+    this.pushmod = true;
+  }
+  empty() {
+    return this.head == null;
+  }
+  size() {
+    return this.length;
+  }
+  has(obj) {
+    let cx_ite = this.head;
+    while (cx_ite != null) {
+      if (cx_ite.elt == obj) return true;
+      cx_ite = cx_ite.next;
+    }
+    return false;
+  }
+  front() {
+    return this.head.elt;
+  }
+  back() {
+    let ret = this.head;
+    let cur = ret;
+    while (cur != null) {
+      ret = cur;
+      cur = cur.next;
+    }
+    return ret.elt;
+  }
+  iterator_at(ind) {
+    let ret = this.head;
+    while (ind-- > 0 && ret != null) ret = ret.next;
+    return ret;
+  }
+  at(ind) {
+    const it = this.iterator_at(ind);
+    return it != null ? it.elt : null;
+  }
+};
+ZNPList.prototype.inlined_add = ZNPList.prototype.add;
+ZNPList.prototype.inlined_insert = ZNPList.prototype.insert;
+ZNPList.prototype.inlined_pop = ZNPList.prototype.pop;
+ZNPList.prototype.inlined_pop_unsafe = ZNPList.prototype.pop_unsafe;
+ZNPList.prototype.inlined_erase = ZNPList.prototype.erase;
+ZNPList.prototype.inlined_remove = ZNPList.prototype.remove;
+ZNPList.prototype.inlined_try_remove = ZNPList.prototype.try_remove;
+ZNPList.prototype.inlined_clear = ZNPList.prototype.clear;
+ZNPList.prototype.inlined_has = ZNPList.prototype.has;
+
+// src/native/util/ZPP_Set.ts
+var ZPP_Set = class {
+  constructor() {
+    this.colour = 0;
+    this.parent = null;
+    this.next = null;
+    this.prev = null;
+    this.data = null;
+    this.swapped = null;
+    this.lt = null;
+  }
+  _allocNode() {
+    const Cls = this.constructor;
+    let x;
+    if (Cls.zpp_pool == null) {
+      x = new Cls();
+    } else {
+      x = Cls.zpp_pool;
+      Cls.zpp_pool = x.next;
+      x.next = null;
+    }
+    return x;
+  }
+  _freeNode(node) {
+    const Cls = this.constructor;
+    node.data = null;
+    node.lt = null;
+    node.swapped = null;
+    node.next = Cls.zpp_pool;
+    Cls.zpp_pool = node;
+  }
+  free() {
+    this.data = null;
+    this.lt = null;
+    this.swapped = null;
+  }
+  alloc() {
+  }
+  verify() {
+    if (!this.empty()) {
+      let set_ite = this.parent;
+      while (set_ite.prev != null) set_ite = set_ite.prev;
+      while (set_ite != null) {
+        const i = set_ite.data;
+        let prei = true;
+        if (!this.empty()) {
+          let set_ite1 = this.parent;
+          while (set_ite1.prev != null) set_ite1 = set_ite1.prev;
+          while (set_ite1 != null) {
+            const j = set_ite1.data;
+            if (!prei) {
+              if (!this.lt(i, j) && this.lt(j, i)) return false;
+            } else if (i == j) {
+              prei = false;
+            } else if (!this.lt(j, i) && this.lt(i, j)) return false;
+            if (set_ite1.next != null) {
+              set_ite1 = set_ite1.next;
+              while (set_ite1.prev != null) set_ite1 = set_ite1.prev;
+            } else {
+              while (set_ite1.parent != null && set_ite1 == set_ite1.parent.next)
+                set_ite1 = set_ite1.parent;
+              set_ite1 = set_ite1.parent;
+            }
+          }
+        }
+        if (set_ite.next != null) {
+          set_ite = set_ite.next;
+          while (set_ite.prev != null) set_ite = set_ite.prev;
+        } else {
+          while (set_ite.parent != null && set_ite == set_ite.parent.next)
+            set_ite = set_ite.parent;
+          set_ite = set_ite.parent;
         }
       }
     }
-    return a;
-  };
-  Reflect2.copy = function(o) {
-    if (o == null) {
-      return null;
+    return true;
+  }
+  empty() {
+    return this.parent == null;
+  }
+  singular() {
+    if (this.parent != null && this.parent.prev == null) return this.parent.next == null;
+    return false;
+  }
+  size() {
+    let ret = 0;
+    if (!this.empty()) {
+      let set_ite = this.parent;
+      while (set_ite.prev != null) set_ite = set_ite.prev;
+      while (set_ite != null) {
+        ++ret;
+        if (set_ite.next != null) {
+          set_ite = set_ite.next;
+          while (set_ite.prev != null) set_ite = set_ite.prev;
+        } else {
+          while (set_ite.parent != null && set_ite == set_ite.parent.next)
+            set_ite = set_ite.parent;
+          set_ite = set_ite.parent;
+        }
+      }
     }
-    var o2 = {};
-    var _g = 0;
-    var _g1 = Reflect2.fields(o);
-    while (_g < _g1.length) {
-      var f = _g1[_g];
-      ++_g;
-      o2[f] = Reflect2.field(o, f);
+    return ret;
+  }
+  has(obj) {
+    return this.find(obj) != null;
+  }
+  find(obj) {
+    let cur = this.parent;
+    while (cur != null && cur.data != obj) {
+      if (this.lt(obj, cur.data)) cur = cur.prev;
+      else cur = cur.next;
     }
-    return o2;
-  };
-  Reflect2.prototype.__class__ = Reflect2;
-  Std = $hxClasses["Std"] = function() {
-  };
-  Std.__name__ = ["Std"];
-  Std.string = function(s) {
-    return js.Boot.__string_rec(s, "");
-  };
-  Std.prototype.__class__ = Std;
-  StringTools = $hxClasses["StringTools"] = function() {
-  };
-  StringTools.__name__ = ["StringTools"];
-  StringTools.hex = function(n, digits) {
-    var s = "";
-    var hexChars = "0123456789ABCDEF";
+    return cur;
+  }
+  has_weak(obj) {
+    return this.find_weak(obj) != null;
+  }
+  find_weak(obj) {
+    let cur = this.parent;
+    while (cur != null) {
+      if (this.lt(obj, cur.data)) cur = cur.prev;
+      else if (this.lt(cur.data, obj)) cur = cur.next;
+      else break;
+    }
+    return cur;
+  }
+  lower_bound(obj) {
+    let ret = null;
+    if (!this.empty()) {
+      let set_ite = this.parent;
+      while (set_ite.prev != null) set_ite = set_ite.prev;
+      while (set_ite != null) {
+        if (!this.lt(set_ite.data, obj)) {
+          ret = set_ite.data;
+          break;
+        }
+        if (set_ite.next != null) {
+          set_ite = set_ite.next;
+          while (set_ite.prev != null) set_ite = set_ite.prev;
+        } else {
+          while (set_ite.parent != null && set_ite == set_ite.parent.next)
+            set_ite = set_ite.parent;
+          set_ite = set_ite.parent;
+        }
+      }
+    }
+    return ret;
+  }
+  first() {
+    let cur = this.parent;
+    while (cur.prev != null) cur = cur.prev;
+    return cur.data;
+  }
+  pop_front() {
+    let cur = this.parent;
+    while (cur.prev != null) cur = cur.prev;
+    const ret = cur.data;
+    this.remove_node(cur);
+    return ret;
+  }
+  remove(obj) {
+    this.remove_node(this.find(obj));
+  }
+  successor_node(cur) {
+    if (cur.next != null) {
+      cur = cur.next;
+      while (cur.prev != null) cur = cur.prev;
+    } else {
+      let pre = cur;
+      cur = cur.parent;
+      while (cur != null && cur.prev != pre) {
+        pre = cur;
+        cur = cur.parent;
+      }
+    }
+    return cur;
+  }
+  predecessor_node(cur) {
+    if (cur.prev != null) {
+      cur = cur.prev;
+      while (cur.next != null) cur = cur.next;
+    } else {
+      let pre = cur;
+      cur = cur.parent;
+      while (cur != null && cur.next != pre) {
+        pre = cur;
+        cur = cur.parent;
+      }
+    }
+    return cur;
+  }
+  successor(obj) {
+    const node = this.successor_node(this.find(obj));
+    return node == null ? null : node.data;
+  }
+  predecessor(obj) {
+    const node = this.predecessor_node(this.find(obj));
+    return node == null ? null : node.data;
+  }
+  remove_node(cur) {
+    if (cur.next != null && cur.prev != null) {
+      let sm = cur.next;
+      while (sm.prev != null) sm = sm.prev;
+      const t = cur.data;
+      cur.data = sm.data;
+      sm.data = t;
+      if (this.swapped != null) this.swapped(cur.data, sm.data);
+      cur = sm;
+    }
+    const child = cur.prev == null ? cur.next : cur.prev;
+    if (cur.colour == 1) {
+      if (cur.prev != null || cur.next != null) {
+        child.colour = 1;
+      } else if (cur.parent != null) {
+        let parent = cur.parent;
+        while (true) {
+          parent.colour++;
+          parent.prev.colour--;
+          parent.next.colour--;
+          const child1 = parent.prev;
+          if (child1.colour == -1) {
+            this.__fix_neg_red(child1);
+            break;
+          } else if (child1.colour == 0) {
+            if (child1.prev != null && child1.prev.colour == 0) {
+              this.__fix_dbl_red(child1.prev);
+              break;
+            }
+            if (child1.next != null && child1.next.colour == 0) {
+              this.__fix_dbl_red(child1.next);
+              break;
+            }
+          }
+          const child2 = parent.next;
+          if (child2.colour == -1) {
+            this.__fix_neg_red(child2);
+            break;
+          } else if (child2.colour == 0) {
+            if (child2.prev != null && child2.prev.colour == 0) {
+              this.__fix_dbl_red(child2.prev);
+              break;
+            }
+            if (child2.next != null && child2.next.colour == 0) {
+              this.__fix_dbl_red(child2.next);
+              break;
+            }
+          }
+          if (parent.colour == 2) {
+            if (parent.parent == null) {
+              parent.colour = 1;
+            } else {
+              parent = parent.parent;
+              continue;
+            }
+          }
+          break;
+        }
+      }
+    }
+    const par = cur.parent;
+    if (par == null) this.parent = child;
+    else if (par.prev == cur) par.prev = child;
+    else par.next = child;
+    if (child != null) child.parent = par;
+    cur.parent = cur.prev = cur.next = null;
+    this._freeNode(cur);
+  }
+  clear() {
+    if (this.parent != null) {
+      let cur = this.parent;
+      while (cur != null) {
+        if (cur.prev != null) cur = cur.prev;
+        else if (cur.next != null) cur = cur.next;
+        else {
+          const ret = cur.parent;
+          if (ret != null) {
+            if (cur == ret.prev) ret.prev = null;
+            else ret.next = null;
+            cur.parent = null;
+          }
+          this._freeNode(cur);
+          cur = ret;
+        }
+      }
+      this.parent = null;
+    }
+  }
+  clear_with(lambda) {
+    if (this.parent == null) return;
+    let cur = this.parent;
+    while (cur != null) {
+      if (cur.prev != null) cur = cur.prev;
+      else if (cur.next != null) cur = cur.next;
+      else {
+        lambda(cur.data);
+        const ret = cur.parent;
+        if (ret != null) {
+          if (cur == ret.prev) ret.prev = null;
+          else ret.next = null;
+          cur.parent = null;
+        }
+        this._freeNode(cur);
+        cur = ret;
+      }
+    }
+    this.parent = null;
+  }
+  clear_node(node, lambda) {
+    lambda(node.data);
+    const ret = node.parent;
+    if (ret != null) {
+      if (node == ret.prev) ret.prev = null;
+      else ret.next = null;
+      node.parent = null;
+    }
+    this._freeNode(node);
+    return ret;
+  }
+  __fix_neg_red(negred) {
+    const parent = negred.parent;
+    let child;
+    if (parent.prev == negred) {
+      const nl = negred.prev;
+      const nr = negred.next;
+      const trl = nr.prev;
+      const trr = nr.next;
+      nl.colour = 0;
+      negred.colour = parent.colour = 1;
+      negred.next = trl;
+      if (trl != null) trl.parent = negred;
+      const t = parent.data;
+      parent.data = nr.data;
+      nr.data = t;
+      if (this.swapped != null) this.swapped(parent.data, nr.data);
+      nr.prev = trr;
+      if (trr != null) trr.parent = nr;
+      nr.next = parent.next;
+      if (parent.next != null) parent.next.parent = nr;
+      parent.next = nr;
+      if (nr != null) nr.parent = parent;
+      child = nl;
+    } else {
+      const nl1 = negred.next;
+      const nr1 = negred.prev;
+      const trl1 = nr1.next;
+      const trr1 = nr1.prev;
+      nl1.colour = 0;
+      negred.colour = parent.colour = 1;
+      negred.prev = trl1;
+      if (trl1 != null) trl1.parent = negred;
+      const t1 = parent.data;
+      parent.data = nr1.data;
+      nr1.data = t1;
+      if (this.swapped != null) this.swapped(parent.data, nr1.data);
+      nr1.next = trr1;
+      if (trr1 != null) trr1.parent = nr1;
+      nr1.prev = parent.prev;
+      if (parent.prev != null) parent.prev.parent = nr1;
+      parent.prev = nr1;
+      if (nr1 != null) nr1.parent = parent;
+      child = nl1;
+    }
+    if (child.prev != null && child.prev.colour == 0) this.__fix_dbl_red(child.prev);
+    else if (child.next != null && child.next.colour == 0) this.__fix_dbl_red(child.next);
+  }
+  __fix_dbl_red(x) {
     while (true) {
-      s = hexChars.charAt(n & 15) + s;
-      n >>>= 4;
-      if (!(n > 0)) {
+      const par = x.parent;
+      const g = par.parent;
+      if (g == null) {
+        par.colour = 1;
         break;
       }
+      let n1, n2, n3;
+      let t1, t2;
+      let t3, t4;
+      if (par == g.prev) {
+        n3 = g;
+        t4 = g.next;
+        if (x == par.prev) {
+          n1 = x;
+          n2 = par;
+          t1 = x.prev;
+          t2 = x.next;
+          t3 = par.next;
+        } else {
+          n1 = par;
+          n2 = x;
+          t1 = par.prev;
+          t2 = x.prev;
+          t3 = x.next;
+        }
+      } else {
+        n1 = g;
+        t1 = g.prev;
+        if (x == par.prev) {
+          n2 = x;
+          n3 = par;
+          t2 = x.prev;
+          t3 = x.next;
+          t4 = par.next;
+        } else {
+          n2 = par;
+          n3 = x;
+          t2 = par.prev;
+          t3 = x.prev;
+          t4 = x.next;
+        }
+      }
+      const par1 = g.parent;
+      if (par1 == null) this.parent = n2;
+      else if (par1.prev == g) par1.prev = n2;
+      else par1.next = n2;
+      if (n2 != null) n2.parent = par1;
+      n1.prev = t1;
+      if (t1 != null) t1.parent = n1;
+      n1.next = t2;
+      if (t2 != null) t2.parent = n1;
+      n2.prev = n1;
+      if (n1 != null) n1.parent = n2;
+      n2.next = n3;
+      if (n3 != null) n3.parent = n2;
+      n3.prev = t3;
+      if (t3 != null) t3.parent = n3;
+      n3.next = t4;
+      if (t4 != null) t4.parent = n3;
+      n2.colour = g.colour - 1;
+      n1.colour = 1;
+      n3.colour = 1;
+      if (n2 == this.parent) {
+        this.parent.colour = 1;
+      } else if (n2.colour == 0 && n2.parent.colour == 0) {
+        x = n2;
+        continue;
+      }
+      break;
     }
-    if (digits != null) {
-      while (s.length < digits) s = "0" + s;
+  }
+  try_insert_bool(obj) {
+    let x = null;
+    if (this.parent == null) {
+      x = this._allocNode();
+      x.data = obj;
+      this.parent = x;
+    } else {
+      let cur = this.parent;
+      while (true) {
+        if (this.lt(obj, cur.data)) {
+          if (cur.prev == null) {
+            x = this._allocNode();
+            x.data = obj;
+            cur.prev = x;
+            x.parent = cur;
+            break;
+          } else cur = cur.prev;
+        } else if (this.lt(cur.data, obj)) {
+          if (cur.next == null) {
+            x = this._allocNode();
+            x.data = obj;
+            cur.next = x;
+            x.parent = cur;
+            break;
+          } else cur = cur.next;
+        } else break;
+      }
     }
-    return s;
-  };
-  StringTools.prototype.__class__ = StringTools;
-  if (typeof js == "undefined") js = {};
-  if (!js._Boot) js._Boot = {};
-  js._Boot.HaxeError = $hxClasses["js._Boot.HaxeError"] = function(val) {
-    Error.call(this);
+    if (x == null) return false;
+    if (x.parent == null) x.colour = 1;
+    else {
+      x.colour = 0;
+      if (x.parent.colour == 0) this.__fix_dbl_red(x);
+    }
+    return true;
+  }
+  try_insert(obj) {
+    let x = null;
+    let cur = null;
+    if (this.parent == null) {
+      x = this._allocNode();
+      x.data = obj;
+      this.parent = x;
+    } else {
+      cur = this.parent;
+      while (true) {
+        if (this.lt(obj, cur.data)) {
+          if (cur.prev == null) {
+            x = this._allocNode();
+            x.data = obj;
+            cur.prev = x;
+            x.parent = cur;
+            break;
+          } else cur = cur.prev;
+        } else if (this.lt(cur.data, obj)) {
+          if (cur.next == null) {
+            x = this._allocNode();
+            x.data = obj;
+            cur.next = x;
+            x.parent = cur;
+            break;
+          } else cur = cur.next;
+        } else break;
+      }
+    }
+    if (x == null) return cur;
+    if (x.parent == null) x.colour = 1;
+    else {
+      x.colour = 0;
+      if (x.parent.colour == 0) this.__fix_dbl_red(x);
+    }
+    return x;
+  }
+  insert(obj) {
+    const x = this._allocNode();
+    x.data = obj;
+    if (this.parent == null) {
+      this.parent = x;
+    } else {
+      let cur = this.parent;
+      while (true) {
+        if (this.lt(x.data, cur.data)) {
+          if (cur.prev == null) {
+            cur.prev = x;
+            x.parent = cur;
+            break;
+          } else cur = cur.prev;
+        } else if (cur.next == null) {
+          cur.next = x;
+          x.parent = cur;
+          break;
+        } else cur = cur.next;
+      }
+    }
+    if (x.parent == null) x.colour = 1;
+    else {
+      x.colour = 0;
+      if (x.parent.colour == 0) this.__fix_dbl_red(x);
+    }
+    return x;
+  }
+};
+ZPP_Set.zpp_pool = null;
+
+// src/core/HaxeShims.ts
+var $hxClasses = {};
+var Reflect2 = function() {
+};
+Reflect2.__name__ = ["Reflect"];
+Reflect2.field = function(o, field) {
+  try {
+    return o[field];
+  } catch (_e) {
+    return null;
+  }
+};
+Reflect2.fields = function(o) {
+  const a = [];
+  if (o != null) {
+    const hasOwnProperty = Object.prototype.hasOwnProperty;
+    for (const f in o) {
+      if (f != "__id__" && f != "hx__closures__" && hasOwnProperty.call(o, f)) {
+        a.push(f);
+      }
+    }
+  }
+  return a;
+};
+Reflect2.copy = function(o) {
+  if (o == null) return null;
+  const o2 = {};
+  const fields = Reflect2.fields(o);
+  for (let i = 0; i < fields.length; i++) {
+    o2[fields[i]] = Reflect2.field(o, fields[i]);
+  }
+  return o2;
+};
+Reflect2.prototype.__class__ = Reflect2;
+var Std = function() {
+};
+Std.__name__ = ["Std"];
+Std.string = function(s) {
+  return jsBoot.__string_rec(s, "");
+};
+Std.prototype.__class__ = Std;
+var StringTools = function() {
+};
+StringTools.__name__ = ["StringTools"];
+StringTools.hex = function(n, digits) {
+  let s = "";
+  const hexChars = "0123456789ABCDEF";
+  do {
+    s = hexChars.charAt(n & 15) + s;
+    n >>>= 4;
+  } while (n > 0);
+  if (digits != null) {
+    while (s.length < digits) s = "0" + s;
+  }
+  return s;
+};
+StringTools.prototype.__class__ = StringTools;
+var HaxeError = class _HaxeError extends Error {
+  constructor(val) {
+    super();
     this.val = val;
     if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, js._Boot.HaxeError);
+      Error.captureStackTrace(this, _HaxeError);
     }
-  };
-  js._Boot.HaxeError.__name__ = ["js", "_Boot", "HaxeError"];
-  js._Boot.HaxeError.__super__ = Error;
-  for (var k in Error.prototype)
-    js._Boot.HaxeError.prototype[k] = Error.prototype[k];
-  js._Boot.HaxeError.prototype.val = null;
-  js._Boot.HaxeError.prototype.__class__ = js._Boot.HaxeError;
-  js.Boot = $hxClasses["js.Boot"] = function() {
-  };
-  js.Boot.__name__ = ["js", "Boot"];
-  js.Boot.__string_rec = function(o, s) {
-    if (o == null) {
-      return "null";
-    }
-    if (s.length >= 5) {
-      return "<...>";
-    }
-    var t = typeof o;
-    if (t == "function" && (o.__name__ || o.__ename__)) {
-      t = "object";
-    }
-    switch (t) {
-      case "function":
-        return "<function>";
-      case "object":
-        if (o instanceof Array) {
-          var str = "[";
-          s += "	";
-          var _g3 = 0;
-          var _g11 = o.length;
-          while (_g3 < _g11) {
-            var i = _g3++;
-            str += (i > 0 ? "," : "") + js.Boot.__string_rec(o[i], s);
-          }
-          str += "]";
-          return str;
-        }
-        var tostr;
+  }
+};
+HaxeError.__name__ = ["js", "_Boot", "HaxeError"];
+HaxeError.__super__ = Error;
+HaxeError.prototype.__class__ = HaxeError;
+var jsBoot = function() {
+};
+jsBoot.__name__ = ["js", "Boot"];
+jsBoot.__string_rec = function(o, s) {
+  if (o == null) return "null";
+  if (s.length >= 5) return "<...>";
+  const t = typeof o;
+  const effectiveType = t == "function" && (o.__name__ || o.__ename__) ? "object" : t;
+  switch (effectiveType) {
+    case "function":
+      return "<function>";
+    case "object":
+      if (o instanceof Array) {
+        let str = "[";
+        s += "	";
+        for (let i = 0; i < o.length; i++) {
+          str += (i > 0 ? "," : "") + jsBoot.__string_rec(o[i], s);
+        }
+        str += "]";
+        return str;
+      }
+      {
+        let tostr;
         try {
           tostr = o.toString;
-        } catch (e1) {
-          var e2 = e1 instanceof js._Boot.HaxeError ? e1.val : e1;
+        } catch (_e) {
           return "???";
         }
         if (tostr != null && tostr != Object.toString && typeof tostr == "function") {
-          var s2 = o.toString();
-          if (s2 != "[object Object]") {
-            return s2;
-          }
+          const s2 = o.toString();
+          if (s2 != "[object Object]") return s2;
         }
-        var str1 = "{\n";
+        let str1 = "{\n";
         s += "	";
-        var hasp = o.hasOwnProperty != null;
-        var k2 = null;
-        for (k2 in o) {
-          if (hasp && !o.hasOwnProperty(k2)) {
-            continue;
-          }
-          if (k2 == "prototype" || k2 == "__class__" || k2 == "__super__" || k2 == "__interfaces__" || k2 == "__properties__") {
+        const hasp = o.hasOwnProperty != null;
+        for (const k in o) {
+          if (hasp && !o.hasOwnProperty(k)) continue;
+          if (k == "prototype" || k == "__class__" || k == "__super__" || k == "__interfaces__" || k == "__properties__")
             continue;
-          }
-          if (str1.length != 2) {
-            str1 += ", \n";
-          }
-          str1 += s + k2 + " : " + js.Boot.__string_rec(o[k2], s);
+          if (str1.length != 2) str1 += ", \n";
+          str1 += s + k + " : " + jsBoot.__string_rec(o[k], s);
         }
         s = s.substring(1);
         str1 += "\n" + s + "}";
         return str1;
-      case "string":
-        return o;
-      default:
-        return String(o);
-    }
-  };
-  js.Boot.__toStr = null;
-  js.Boot.prototype.__class__ = js.Boot;
+      }
+    case "string":
+      return o;
+    default:
+      return String(o);
+  }
+};
+jsBoot.__toStr = null;
+jsBoot.prototype.__class__ = jsBoot;
+var js = {
+  _Boot: { HaxeError },
+  Boot: jsBoot
+};
+function $estr() {
+  return jsBoot.__string_rec(this, "");
+}
+$hxClasses["Reflect"] = Reflect2;
+$hxClasses["Std"] = Std;
+$hxClasses["StringTools"] = StringTools;
+$hxClasses["js._Boot.HaxeError"] = HaxeError;
+$hxClasses["js.Boot"] = jsBoot;
+
+// src/core/nape-compiled.js
+var _nape;
+var define = function(factory) {
+  _nape = factory();
+};
+define(function() {
+  "use strict";
+  var nape67, zpp_nape, sandbox;
+  var $hxClasses2 = $hxClasses;
+  var $estr2 = $estr;
+  var js2 = js;
+  var Reflect3 = Reflect2;
+  var Std2 = Std;
+  var StringTools2 = StringTools;
   if (typeof nape67 == "undefined") nape67 = {};
-  nape67.Config = $hxClasses["nape.Config"] = function() {
+  nape67.Config = $hxClasses2["nape.Config"] = function() {
   };
   nape67.Config.__name__ = ["nape", "Config"];
   nape67.Config.prototype.__class__ = nape67.Config;
@@ -51873,7 +53002,7 @@ define(function() {
   nape67.callbacks.Callback = function() {
     this.zpp_inner = null;
     if (!zpp_nape.callbacks.ZPP_Callback.internal) {
-      throw new js._Boot.HaxeError("Error: Callback cannot be instantiated derp!");
+      throw new js2._Boot.HaxeError("Error: Callback cannot be instantiated derp!");
     }
   };
   nape67.callbacks.Callback.__name__ = ["nape", "callbacks", "Callback"];
@@ -51888,7 +53017,7 @@ define(function() {
   nape67.callbacks.Listener = function() {
     this.zpp_inner = null;
     if (!zpp_nape.callbacks.ZPP_Listener.internal) {
-      throw new js._Boot.HaxeError("Error: Cannot instantiate Listener derp!");
+      throw new js2._Boot.HaxeError("Error: Cannot instantiate Listener derp!");
     }
   };
   nape67.callbacks.Listener.__name__ = ["nape", "callbacks", "Listener"];
@@ -51896,7 +53025,7 @@ define(function() {
   nape67.callbacks.Listener.prototype.__class__ = nape67.callbacks.Listener;
   nape67.callbacks.CbEvent = function() {
     if (!zpp_nape.util.ZPP_Flags.internal) {
-      throw new js._Boot.HaxeError("Error: Cannot instantiate CbEvent derp!");
+      throw new js2._Boot.HaxeError("Error: Cannot instantiate CbEvent derp!");
     }
   };
   nape67.callbacks.CbEvent.__name__ = ["nape", "callbacks", "CbEvent"];
@@ -51924,7 +53053,7 @@ define(function() {
   nape67.callbacks.InteractionCallback.prototype.__class__ = nape67.callbacks.InteractionCallback;
   nape67.callbacks.ListenerType = function() {
     if (!zpp_nape.util.ZPP_Flags.internal) {
-      throw new js._Boot.HaxeError(
+      throw new js2._Boot.HaxeError(
         "Error: Cannot instantiate ListenerType derp!"
       );
     }
@@ -51960,48 +53089,48 @@ define(function() {
   nape67.callbacks.PreCallback.prototype = Object.create(nape67.callbacks.Callback.prototype);
   nape67.callbacks.PreCallback.prototype.__class__ = nape67.callbacks.PreCallback;
   if (!nape67.constraint) nape67.constraint = {};
-  nape67.constraint.Constraint = $hxClasses["nape.constraint.Constraint"] = function() {
+  nape67.constraint.Constraint = $hxClasses2["nape.constraint.Constraint"] = function() {
   };
   nape67.constraint.Constraint.__name__ = ["nape", "constraint", "Constraint"];
   nape67.constraint.Constraint.prototype.__class__ = nape67.constraint.Constraint;
-  nape67.constraint.AngleJoint = $hxClasses["nape.constraint.AngleJoint"] = function() {
+  nape67.constraint.AngleJoint = $hxClasses2["nape.constraint.AngleJoint"] = function() {
   };
   nape67.constraint.AngleJoint.__name__ = ["nape", "constraint", "AngleJoint"];
   nape67.constraint.AngleJoint.prototype.__class__ = nape67.constraint.AngleJoint;
-  nape67.constraint.DistanceJoint = $hxClasses["nape.constraint.DistanceJoint"] = function() {
+  nape67.constraint.DistanceJoint = $hxClasses2["nape.constraint.DistanceJoint"] = function() {
   };
   nape67.constraint.DistanceJoint.__name__ = ["nape", "constraint", "DistanceJoint"];
   nape67.constraint.DistanceJoint.prototype.__class__ = nape67.constraint.DistanceJoint;
-  nape67.constraint.LineJoint = $hxClasses["nape.constraint.LineJoint"] = function() {
+  nape67.constraint.LineJoint = $hxClasses2["nape.constraint.LineJoint"] = function() {
   };
   nape67.constraint.LineJoint.__name__ = ["nape", "constraint", "LineJoint"];
   nape67.constraint.LineJoint.prototype.__class__ = nape67.constraint.LineJoint;
-  nape67.constraint.MotorJoint = $hxClasses["nape.constraint.MotorJoint"] = function() {
+  nape67.constraint.MotorJoint = $hxClasses2["nape.constraint.MotorJoint"] = function() {
   };
   nape67.constraint.MotorJoint.__name__ = ["nape", "constraint", "MotorJoint"];
   nape67.constraint.MotorJoint.prototype.__class__ = nape67.constraint.MotorJoint;
-  nape67.constraint.PivotJoint = $hxClasses["nape.constraint.PivotJoint"] = function() {
+  nape67.constraint.PivotJoint = $hxClasses2["nape.constraint.PivotJoint"] = function() {
   };
   nape67.constraint.PivotJoint.__name__ = ["nape", "constraint", "PivotJoint"];
   nape67.constraint.PivotJoint.prototype.__class__ = nape67.constraint.PivotJoint;
-  nape67.constraint.PulleyJoint = $hxClasses["nape.constraint.PulleyJoint"] = function() {
+  nape67.constraint.PulleyJoint = $hxClasses2["nape.constraint.PulleyJoint"] = function() {
   };
   nape67.constraint.PulleyJoint.__name__ = ["nape", "constraint", "PulleyJoint"];
   nape67.constraint.PulleyJoint.__super__ = nape67.constraint.Constraint;
   nape67.constraint.PulleyJoint.prototype.__class__ = nape67.constraint.PulleyJoint;
-  nape67.constraint.UserConstraint = $hxClasses["nape.constraint.UserConstraint"] = function() {
+  nape67.constraint.UserConstraint = $hxClasses2["nape.constraint.UserConstraint"] = function() {
   };
   nape67.constraint.UserConstraint.__name__ = ["nape", "constraint", "UserConstraint"];
   nape67.constraint.UserConstraint.prototype.__class__ = nape67.constraint.UserConstraint;
-  nape67.constraint.WeldJoint = $hxClasses["nape.constraint.WeldJoint"] = function() {
+  nape67.constraint.WeldJoint = $hxClasses2["nape.constraint.WeldJoint"] = function() {
   };
   nape67.constraint.WeldJoint.__name__ = ["nape", "constraint", "WeldJoint"];
   nape67.constraint.WeldJoint.prototype.__class__ = nape67.constraint.WeldJoint;
   if (!nape67.dynamics) nape67.dynamics = {};
-  nape67.dynamics.Arbiter = $hxClasses["nape.dynamics.Arbiter"] = function() {
+  nape67.dynamics.Arbiter = $hxClasses2["nape.dynamics.Arbiter"] = function() {
     this.zpp_inner = null;
     if (!zpp_nape.dynamics.ZPP_Arbiter.internal) {
-      throw new js._Boot.HaxeError("Error: Cannot instantiate Arbiter derp!");
+      throw new js2._Boot.HaxeError("Error: Cannot instantiate Arbiter derp!");
     }
   };
   nape67.dynamics.Arbiter.__name__ = ["nape", "dynamics", "Arbiter"];
@@ -52013,16 +53142,16 @@ define(function() {
   nape67.dynamics.ArbiterList.prototype.zpp_inner = null;
   nape67.dynamics.ArbiterType = function() {
     if (!zpp_nape.util.ZPP_Flags.internal) {
-      throw new js._Boot.HaxeError(
+      throw new js2._Boot.HaxeError(
         "Error: Cannot instantiate ArbiterType derp!"
       );
     }
   };
   nape67.dynamics.ArbiterType.__name__ = ["nape", "dynamics", "ArbiterType"];
   nape67.dynamics.ArbiterType.prototype.__class__ = nape67.dynamics.ArbiterType;
-  nape67.dynamics.CollisionArbiter = $hxClasses["nape.dynamics.CollisionArbiter"] = function() {
+  nape67.dynamics.CollisionArbiter = $hxClasses2["nape.dynamics.CollisionArbiter"] = function() {
     if (!zpp_nape.dynamics.ZPP_Arbiter.internal) {
-      throw new js._Boot.HaxeError(
+      throw new js2._Boot.HaxeError(
         "Error: Cannot instantiate CollisionArbiter derp!"
       );
     }
@@ -52036,12 +53165,12 @@ define(function() {
   nape67.dynamics.CollisionArbiter.__super__ = nape67.dynamics.Arbiter;
   for (var k in nape67.dynamics.Arbiter.prototype)
     nape67.dynamics.CollisionArbiter.prototype[k] = nape67.dynamics.Arbiter.prototype[k];
-  nape67.dynamics.ContactIterator = $hxClasses["nape.dynamics.ContactIterator"] = function() {
+  nape67.dynamics.ContactIterator = $hxClasses2["nape.dynamics.ContactIterator"] = function() {
   };
   nape67.dynamics.ContactIterator.__name__ = ["nape", "dynamics", "ContactIterator"];
   nape67.dynamics.ContactIterator.zpp_pool = null;
   nape67.dynamics.ContactIterator.prototype.__class__ = nape67.dynamics.ContactIterator;
-  nape67.dynamics.ContactList = $hxClasses["nape.dynamics.ContactList"] = function() {
+  nape67.dynamics.ContactList = $hxClasses2["nape.dynamics.ContactList"] = function() {
     this.zpp_inner = null;
     this.zpp_inner = new zpp_nape.util.ZPP_ContactList();
     this.zpp_inner.outer = this;
@@ -52049,9 +53178,9 @@ define(function() {
   nape67.dynamics.ContactList.__name__ = ["nape", "dynamics", "ContactList"];
   nape67.dynamics.ContactList.prototype.zpp_inner = null;
   nape67.dynamics.ContactList.prototype.__class__ = nape67.dynamics.ContactList;
-  nape67.dynamics.FluidArbiter = $hxClasses["nape.dynamics.FluidArbiter"] = function() {
+  nape67.dynamics.FluidArbiter = $hxClasses2["nape.dynamics.FluidArbiter"] = function() {
     if (!zpp_nape.dynamics.ZPP_Arbiter.internal) {
-      throw new js._Boot.HaxeError(
+      throw new js2._Boot.HaxeError(
         "Error: Cannot instantiate FluidArbiter derp!"
       );
     }
@@ -52062,26 +53191,26 @@ define(function() {
   for (var k in nape67.dynamics.Arbiter.prototype)
     nape67.dynamics.FluidArbiter.prototype[k] = nape67.dynamics.Arbiter.prototype[k];
   if (!nape67.geom) nape67.geom = {};
-  nape67.geom.Geom = $hxClasses["nape.geom.Geom"] = function() {
+  nape67.geom.Geom = $hxClasses2["nape.geom.Geom"] = function() {
   };
   nape67.geom.Geom.__name__ = ["nape", "geom", "Geom"];
   nape67.geom.Geom.prototype.__class__ = nape67.geom.Geom;
-  nape67.geom.GeomVertexIterator = $hxClasses["nape.geom.GeomVertexIterator"] = function() {
+  nape67.geom.GeomVertexIterator = $hxClasses2["nape.geom.GeomVertexIterator"] = function() {
   };
   nape67.geom.GeomVertexIterator.__name__ = ["nape", "geom", "GeomVertexIterator"];
   nape67.geom.GeomVertexIterator.prototype.zpp_inner = null;
   nape67.geom.GeomVertexIterator.prototype.__class__ = nape67.geom.GeomVertexIterator;
   nape67.geom.GeomVertexIterator;
-  nape67.geom.Ray = $hxClasses["nape.geom.Ray"] = function() {
+  nape67.geom.Ray = $hxClasses2["nape.geom.Ray"] = function() {
   };
   nape67.geom.Ray.__name__ = ["nape", "geom", "Ray"];
   nape67.geom.Ray.prototype.__class__ = nape67.geom.Ray;
-  nape67.geom.Vec2Iterator = $hxClasses["nape.geom.Vec2Iterator"] = function() {
+  nape67.geom.Vec2Iterator = $hxClasses2["nape.geom.Vec2Iterator"] = function() {
   };
   nape67.geom.Vec2Iterator.__name__ = ["nape", "geom", "Vec2Iterator"];
   nape67.geom.Vec2Iterator.zpp_pool = null;
   nape67.geom.Vec2Iterator.prototype.__class__ = nape67.geom.Vec2Iterator;
-  nape67.geom.Vec2List = $hxClasses["nape.geom.Vec2List"] = function() {
+  nape67.geom.Vec2List = $hxClasses2["nape.geom.Vec2List"] = function() {
     this.zpp_inner = null;
     this.zpp_inner = new zpp_nape.util.ZPP_Vec2List();
     this.zpp_inner.outer = this;
@@ -52090,10 +53219,10 @@ define(function() {
   nape67.geom.Vec2List.prototype.zpp_inner = null;
   nape67.geom.Vec2List.prototype.__class__ = nape67.geom.Vec2List;
   if (!nape67.phys) nape67.phys = {};
-  nape67.phys.Interactor = $hxClasses["nape.phys.Interactor"] = function() {
+  nape67.phys.Interactor = $hxClasses2["nape.phys.Interactor"] = function() {
     this.zpp_inner_i = null;
     if (!nape67.phys.Interactor.zpp_internalAlloc) {
-      throw new js._Boot.HaxeError(
+      throw new js2._Boot.HaxeError(
         "Error: Cannot instantiate an Interactor, only Shape/Body/Compound"
       );
     }
@@ -52203,7 +53332,7 @@ define(function() {
     return "";
   };
   nape67.phys.Interactor.prototype.__class__ = nape67.phys.Interactor;
-  nape67.phys.Body = $hxClasses["nape.phys.Body"] = function() {
+  nape67.phys.Body = $hxClasses2["nape.phys.Body"] = function() {
   };
   nape67.phys.Body.__name__ = ["nape", "phys", "Body"];
   nape67.phys.Body.__super__ = nape67.phys.Interactor;
@@ -52214,12 +53343,12 @@ define(function() {
   nape67.phys.Body.prototype.__class__ = nape67.phys.Body;
   nape67.phys.BodyType = function() {
     if (!zpp_nape.util.ZPP_Flags.internal) {
-      throw new js._Boot.HaxeError("Error: Cannot instantiate BodyType derp!");
+      throw new js2._Boot.HaxeError("Error: Cannot instantiate BodyType derp!");
     }
   };
   nape67.phys.BodyType.__name__ = ["nape", "phys", "BodyType"];
   nape67.phys.BodyType.prototype.__class__ = nape67.phys.BodyType;
-  nape67.phys.Compound = $hxClasses["nape.phys.Compound"] = function() {
+  nape67.phys.Compound = $hxClasses2["nape.phys.Compound"] = function() {
   };
   nape67.phys.Compound.__name__ = ["nape", "phys", "Compound"];
   nape67.phys.Compound.__super__ = nape67.phys.Interactor;
@@ -52227,13 +53356,13 @@ define(function() {
     nape67.phys.Compound.prototype[k] = nape67.phys.Interactor.prototype[k];
   nape67.phys.Compound.prototype.__class__ = nape67.phys.Compound;
   if (!nape67.shape) nape67.shape = {};
-  nape67.shape.Shape = $hxClasses["nape.shape.Shape"] = function() {
+  nape67.shape.Shape = $hxClasses2["nape.shape.Shape"] = function() {
     this.zpp_inner = null;
     nape67.phys.Interactor.zpp_internalAlloc = true;
     nape67.phys.Interactor.call(this);
     nape67.phys.Interactor.zpp_internalAlloc = false;
     if (!nape67.shape.Shape.zpp_internalAlloc) {
-      throw new js._Boot.HaxeError("Error: Shape cannot be instantiated derp!");
+      throw new js2._Boot.HaxeError("Error: Shape cannot be instantiated derp!");
     }
   };
   nape67.shape.Shape.__name__ = ["nape", "shape", "Shape"];
@@ -52242,7 +53371,7 @@ define(function() {
     nape67.shape.Shape.prototype[k] = nape67.phys.Interactor.prototype[k];
   nape67.shape.Shape.prototype.zpp_inner = null;
   nape67.shape.Shape.prototype.__class__ = nape67.shape.Shape;
-  nape67.shape.Circle = $hxClasses["nape.shape.Circle"] = function() {
+  nape67.shape.Circle = $hxClasses2["nape.shape.Circle"] = function() {
   };
   nape67.shape.Circle.__name__ = ["nape", "shape", "Circle"];
   nape67.shape.Circle.__super__ = nape67.shape.Shape;
@@ -52250,30 +53379,30 @@ define(function() {
     nape67.shape.Circle.prototype[k] = nape67.shape.Shape.prototype[k];
   nape67.shape.Circle.prototype.zpp_inner_zn = null;
   nape67.shape.Circle.prototype.__class__ = nape67.shape.Circle;
-  nape67.shape.Edge = $hxClasses["nape.shape.Edge"] = function() {
+  nape67.shape.Edge = $hxClasses2["nape.shape.Edge"] = function() {
     this.zpp_inner = null;
     if (!zpp_nape.shape.ZPP_Edge.internal) {
-      throw new js._Boot.HaxeError("Error: Cannot instantiate an Edge derp!");
+      throw new js2._Boot.HaxeError("Error: Cannot instantiate an Edge derp!");
     }
   };
   nape67.shape.Edge.__name__ = ["nape", "shape", "Edge"];
   nape67.shape.Edge.prototype.zpp_inner = null;
   nape67.shape.Edge.prototype.__class__ = nape67.shape.Edge;
-  nape67.shape.Polygon = $hxClasses["nape.shape.Polygon"] = function() {
+  nape67.shape.Polygon = $hxClasses2["nape.shape.Polygon"] = function() {
   };
   nape67.shape.Polygon.__name__ = ["nape", "shape", "Polygon"];
   nape67.shape.Polygon.__super__ = nape67.shape.Shape;
   nape67.shape.Polygon.prototype.__class__ = nape67.shape.Polygon;
   nape67.shape.ShapeType = function() {
     if (!zpp_nape.util.ZPP_Flags.internal) {
-      throw new js._Boot.HaxeError("Error: Cannot instantiate ShapeType derp!");
+      throw new js2._Boot.HaxeError("Error: Cannot instantiate ShapeType derp!");
     }
   };
   nape67.shape.ShapeType.__name__ = ["nape", "shape", "ShapeType"];
   nape67.shape.ShapeType.prototype.__class__ = nape67.shape.ShapeType;
   nape67.shape.ValidationResult = function() {
     if (!zpp_nape.util.ZPP_Flags.internal) {
-      throw new js._Boot.HaxeError("Error: Cannot instantiate ValidationResult derp!");
+      throw new js2._Boot.HaxeError("Error: Cannot instantiate ValidationResult derp!");
     }
   };
   nape67.shape.ValidationResult.__name__ = ["nape", "shape", "ValidationResult"];
@@ -52281,846 +53410,69 @@ define(function() {
   if (!nape67.space) nape67.space = {};
   nape67.space.Broadphase = function() {
     if (!zpp_nape.util.ZPP_Flags.internal) {
-      throw new js._Boot.HaxeError("Error: Cannot instantiate Broadphase derp!");
+      throw new js2._Boot.HaxeError("Error: Cannot instantiate Broadphase derp!");
     }
   };
   nape67.space.Broadphase.__name__ = ["nape", "space", "Broadphase"];
   nape67.space.Broadphase.prototype.__class__ = nape67.space.Broadphase;
-  nape67.space.Space = $hxClasses["nape.space.Space"] = function() {
+  nape67.space.Space = $hxClasses2["nape.space.Space"] = function() {
   };
   nape67.space.Space.__name__ = ["nape", "space", "Space"];
   nape67.space.Space.prototype.__class__ = nape67.space.Space;
   if (!nape67.util) nape67.util = {};
-  nape67.util.Debug = $hxClasses["nape.util.Debug"] = function() {
+  nape67.util.Debug = $hxClasses2["nape.util.Debug"] = function() {
   };
   nape67.util.Debug.__name__ = ["nape", "util", "Debug"];
   nape67.util.Debug.prototype.__class__ = nape67.util.Debug;
   if (typeof sandbox == "undefined") sandbox = {};
-  sandbox.Main = $hxClasses["sandbox.Main"] = function() {
+  sandbox.Main = $hxClasses2["sandbox.Main"] = function() {
   };
   sandbox.Main.__name__ = ["sandbox", "Main"];
   sandbox.Main.main = function() {
   };
   sandbox.Main.prototype.__class__ = sandbox.Main;
   if (typeof zpp_nape == "undefined") zpp_nape = {};
-  zpp_nape.ZPP_Const = $hxClasses["zpp_nape.ZPP_Const"] = ZPP_Const;
+  zpp_nape.ZPP_Const = $hxClasses2["zpp_nape.ZPP_Const"] = ZPP_Const;
   zpp_nape.ZPP_Const.prototype.__class__ = zpp_nape.ZPP_Const;
-  zpp_nape.ZPP_ID = $hxClasses["zpp_nape.ZPP_ID"] = ZPP_ID;
+  zpp_nape.ZPP_ID = $hxClasses2["zpp_nape.ZPP_ID"] = ZPP_ID;
   zpp_nape.ZPP_ID.prototype.__class__ = zpp_nape.ZPP_ID;
   if (!zpp_nape.callbacks) zpp_nape.callbacks = {};
   ZPP_Callback._nape = nape67;
   ZPP_Callback._zpp = zpp_nape;
-  zpp_nape.callbacks.ZPP_Callback = $hxClasses["zpp_nape.callbacks.ZPP_Callback"] = ZPP_Callback;
+  zpp_nape.callbacks.ZPP_Callback = $hxClasses2["zpp_nape.callbacks.ZPP_Callback"] = ZPP_Callback;
   zpp_nape.callbacks.ZPP_Callback.prototype.__class__ = zpp_nape.callbacks.ZPP_Callback;
   ZPP_CbSet._zpp = zpp_nape;
-  zpp_nape.callbacks.ZPP_CbSet = $hxClasses["zpp_nape.callbacks.ZPP_CbSet"] = ZPP_CbSet;
+  zpp_nape.callbacks.ZPP_CbSet = $hxClasses2["zpp_nape.callbacks.ZPP_CbSet"] = ZPP_CbSet;
   zpp_nape.callbacks.ZPP_CbSet.prototype.__class__ = zpp_nape.callbacks.ZPP_CbSet;
   ZPP_CbSetPair._zpp = zpp_nape;
-  zpp_nape.callbacks.ZPP_CbSetPair = $hxClasses["zpp_nape.callbacks.ZPP_CbSetPair"] = ZPP_CbSetPair;
+  zpp_nape.callbacks.ZPP_CbSetPair = $hxClasses2["zpp_nape.callbacks.ZPP_CbSetPair"] = ZPP_CbSetPair;
   zpp_nape.callbacks.ZPP_CbSetPair.prototype.__class__ = zpp_nape.callbacks.ZPP_CbSetPair;
   if (!zpp_nape.util) zpp_nape.util = {};
   function createZNPNode(typeName) {
-    var cls = $hxClasses["zpp_nape.util.ZNPNode_" + typeName] = function() {
-      this.elt = null;
-      this.next = null;
+    var cls = class extends ZNPNode {
     };
     cls.__name__ = ["zpp_nape", "util", "ZNPNode_" + typeName];
     cls.zpp_pool = null;
-    cls.prototype.next = null;
-    cls.prototype.alloc = function() {
-    };
-    cls.prototype.free = function() {
-      this.elt = null;
-    };
-    cls.prototype.elt = null;
-    cls.prototype.elem = function() {
-      return this.elt;
-    };
     cls.prototype.__class__ = cls;
+    $hxClasses2["zpp_nape.util.ZNPNode_" + typeName] = cls;
     return cls;
   }
   function createZNPList(typeName, N) {
-    var cls = $hxClasses["zpp_nape.util.ZNPList_" + typeName] = function() {
-      this.length = 0;
-      this.pushmod = false;
-      this.modified = false;
-      this.head = null;
+    var cls = class extends ZNPList {
     };
     cls.__name__ = ["zpp_nape", "util", "ZNPList_" + typeName];
-    cls.prototype.head = null;
-    cls.prototype.begin = function() {
-      return this.head;
-    };
-    cls.prototype.modified = null;
-    cls.prototype.pushmod = null;
-    cls.prototype.length = null;
-    cls.prototype.setbegin = function(i) {
-      this.head = i;
-      this.modified = true;
-      this.pushmod = true;
-    };
-    cls.prototype.add = function(o) {
-      var ret;
-      if (N.zpp_pool == null) {
-        ret = new N();
-      } else {
-        ret = N.zpp_pool;
-        N.zpp_pool = ret.next;
-        ret.next = null;
-      }
-      ret.elt = o;
-      var temp = ret;
-      temp.next = this.head;
-      this.head = temp;
-      this.modified = true;
-      this.length++;
-      return o;
-    };
-    cls.prototype.inlined_add = cls.prototype.add;
-    cls.prototype.addAll = function(x) {
-      var cx_ite = x.head;
-      while (cx_ite != null) {
-        this.add(cx_ite.elt);
-        cx_ite = cx_ite.next;
-      }
-    };
-    cls.prototype.insert = function(cur, o) {
-      var ret;
-      if (N.zpp_pool == null) {
-        ret = new N();
-      } else {
-        ret = N.zpp_pool;
-        N.zpp_pool = ret.next;
-        ret.next = null;
-      }
-      ret.elt = o;
-      var temp = ret;
-      if (cur == null) {
-        temp.next = this.head;
-        this.head = temp;
-      } else {
-        temp.next = cur.next;
-        cur.next = temp;
-      }
-      this.pushmod = this.modified = true;
-      this.length++;
-      return temp;
-    };
-    cls.prototype.inlined_insert = cls.prototype.insert;
-    cls.prototype.pop = function() {
-      var ret = this.head;
-      this.head = ret.next;
-      var o = ret;
-      o.elt = null;
-      o.next = N.zpp_pool;
-      N.zpp_pool = o;
-      if (this.head == null) {
-        this.pushmod = true;
-      }
-      this.modified = true;
-      this.length--;
-    };
-    cls.prototype.inlined_pop = cls.prototype.pop;
-    cls.prototype.pop_unsafe = function() {
-      var ret = this.head.elt;
-      this.pop();
-      return ret;
-    };
-    cls.prototype.inlined_pop_unsafe = cls.prototype.pop_unsafe;
-    cls.prototype.erase = function(pre) {
-      var old, ret;
-      if (pre == null) {
-        old = this.head;
-        ret = old.next;
-        this.head = ret;
-        if (this.head == null) {
-          this.pushmod = true;
-        }
-      } else {
-        old = pre.next;
-        ret = old.next;
-        pre.next = ret;
-        if (ret == null) {
-          this.pushmod = true;
-        }
-      }
-      var o = old;
-      o.elt = null;
-      o.next = N.zpp_pool;
-      N.zpp_pool = o;
-      this.modified = true;
-      this.length--;
-      this.pushmod = true;
-      return ret;
-    };
-    cls.prototype.inlined_erase = cls.prototype.erase;
-    cls.prototype.remove = function(obj) {
-      var pre = null, cur = this.head;
-      while (cur != null) {
-        if (cur.elt == obj) {
-          this.erase(pre);
-          break;
-        }
-        pre = cur;
-        cur = cur.next;
-      }
-    };
-    cls.prototype.inlined_remove = cls.prototype.remove;
-    cls.prototype.try_remove = function(obj) {
-      var pre = null, cur = this.head, ret = false;
-      while (cur != null) {
-        if (cur.elt == obj) {
-          this.erase(pre);
-          ret = true;
-          break;
-        }
-        pre = cur;
-        cur = cur.next;
-      }
-      return ret;
-    };
-    cls.prototype.inlined_try_remove = cls.prototype.try_remove;
-    cls.prototype.splice = function(pre, n) {
-      while (n-- > 0 && pre.next != null) this.erase(pre);
-      return pre.next;
-    };
-    cls.prototype.clear = function() {
-      while (this.head != null) {
-        var ret = this.head;
-        this.head = ret.next;
-        var o = ret;
-        o.elt = null;
-        o.next = N.zpp_pool;
-        N.zpp_pool = o;
-        if (this.head == null) {
-          this.pushmod = true;
-        }
-        this.modified = true;
-        this.length--;
-      }
-      this.pushmod = true;
-    };
-    cls.prototype.inlined_clear = cls.prototype.clear;
-    cls.prototype.reverse = function() {
-      var cur = this.head, pre = null;
-      while (cur != null) {
-        var nx = cur.next;
-        cur.next = pre;
-        this.head = cur;
-        pre = cur;
-        cur = nx;
-      }
-      this.modified = true;
-      this.pushmod = true;
-    };
-    cls.prototype.empty = function() {
-      return this.head == null;
-    };
-    cls.prototype.size = function() {
-      return this.length;
-    };
-    cls.prototype.has = function(obj) {
-      var cx_ite = this.head;
-      while (cx_ite != null) {
-        if (cx_ite.elt == obj) return true;
-        cx_ite = cx_ite.next;
-      }
-      return false;
-    };
-    cls.prototype.inlined_has = cls.prototype.has;
-    cls.prototype.front = function() {
-      return this.head.elt;
-    };
-    cls.prototype.back = function() {
-      var ret = this.head, cur = ret;
-      while (cur != null) {
-        ret = cur;
-        cur = cur.next;
-      }
-      return ret.elt;
-    };
-    cls.prototype.iterator_at = function(ind) {
-      var ret = this.head;
-      while (ind-- > 0 && ret != null) ret = ret.next;
-      return ret;
-    };
-    cls.prototype.at = function(ind) {
-      var it = this.iterator_at(ind);
-      return it != null ? it.elt : null;
-    };
+    cls._NodeClass = N;
     cls.prototype.__class__ = cls;
+    $hxClasses2["zpp_nape.util.ZNPList_" + typeName] = cls;
     return cls;
   }
   function createZPPSet(typeName) {
-    var cls = $hxClasses["zpp_nape.util.ZPP_Set_" + typeName] = function() {
-      this.colour = 0;
-      this.parent = null;
-      this.next = null;
-      this.prev = null;
-      this.data = null;
-      this.swapped = null;
-      this.lt = null;
+    var cls = class extends ZPP_Set {
     };
     cls.__name__ = ["zpp_nape", "util", "ZPP_Set_" + typeName];
     cls.zpp_pool = null;
-    cls.prototype.free = function() {
-      this.data = null;
-      this.lt = null;
-      this.swapped = null;
-    };
-    cls.prototype.alloc = function() {
-    };
-    cls.prototype.lt = null;
-    cls.prototype.swapped = null;
-    cls.prototype.data = null;
-    cls.prototype.prev = null;
-    cls.prototype.next = null;
-    cls.prototype.parent = null;
-    cls.prototype.colour = null;
-    cls.prototype.verify = function() {
-      if (!this.empty()) {
-        var set_ite = this.parent;
-        while (set_ite.prev != null) set_ite = set_ite.prev;
-        while (set_ite != null) {
-          var i = set_ite.data;
-          var prei = true;
-          if (!this.empty()) {
-            var set_ite1 = this.parent;
-            while (set_ite1.prev != null) set_ite1 = set_ite1.prev;
-            while (set_ite1 != null) {
-              var j = set_ite1.data;
-              if (!prei) {
-                if (!this.lt(i, j) && this.lt(j, i)) return false;
-              } else if (i == j) {
-                prei = false;
-              } else if (!this.lt(j, i) && this.lt(i, j)) return false;
-              if (set_ite1.next != null) {
-                set_ite1 = set_ite1.next;
-                while (set_ite1.prev != null) set_ite1 = set_ite1.prev;
-              } else {
-                while (set_ite1.parent != null && set_ite1 == set_ite1.parent.next) set_ite1 = set_ite1.parent;
-                set_ite1 = set_ite1.parent;
-              }
-            }
-          }
-          if (set_ite.next != null) {
-            set_ite = set_ite.next;
-            while (set_ite.prev != null) set_ite = set_ite.prev;
-          } else {
-            while (set_ite.parent != null && set_ite == set_ite.parent.next) set_ite = set_ite.parent;
-            set_ite = set_ite.parent;
-          }
-        }
-      }
-      return true;
-    };
-    cls.prototype.empty = function() {
-      return this.parent == null;
-    };
-    cls.prototype.singular = function() {
-      if (this.parent != null && this.parent.prev == null) return this.parent.next == null;
-      return false;
-    };
-    cls.prototype.size = function() {
-      var ret = 0;
-      if (!this.empty()) {
-        var set_ite = this.parent;
-        while (set_ite.prev != null) set_ite = set_ite.prev;
-        while (set_ite != null) {
-          ++ret;
-          if (set_ite.next != null) {
-            set_ite = set_ite.next;
-            while (set_ite.prev != null) set_ite = set_ite.prev;
-          } else {
-            while (set_ite.parent != null && set_ite == set_ite.parent.next) set_ite = set_ite.parent;
-            set_ite = set_ite.parent;
-          }
-        }
-      }
-      return ret;
-    };
-    cls.prototype.has = function(obj) {
-      return this.find(obj) != null;
-    };
-    cls.prototype.find = function(obj) {
-      var cur = this.parent;
-      while (cur != null && cur.data != obj) {
-        if (this.lt(obj, cur.data)) cur = cur.prev;
-        else cur = cur.next;
-      }
-      return cur;
-    };
-    cls.prototype.has_weak = function(obj) {
-      return this.find_weak(obj) != null;
-    };
-    cls.prototype.find_weak = function(obj) {
-      var cur = this.parent;
-      while (cur != null) {
-        if (this.lt(obj, cur.data)) cur = cur.prev;
-        else if (this.lt(cur.data, obj)) cur = cur.next;
-        else break;
-      }
-      return cur;
-    };
-    cls.prototype.lower_bound = function(obj) {
-      var ret = null;
-      if (!this.empty()) {
-        var set_ite = this.parent;
-        while (set_ite.prev != null) set_ite = set_ite.prev;
-        while (set_ite != null) {
-          if (!this.lt(set_ite.data, obj)) {
-            ret = set_ite.data;
-            break;
-          }
-          if (set_ite.next != null) {
-            set_ite = set_ite.next;
-            while (set_ite.prev != null) set_ite = set_ite.prev;
-          } else {
-            while (set_ite.parent != null && set_ite == set_ite.parent.next) set_ite = set_ite.parent;
-            set_ite = set_ite.parent;
-          }
-        }
-      }
-      return ret;
-    };
-    cls.prototype.first = function() {
-      var cur = this.parent;
-      while (cur.prev != null) cur = cur.prev;
-      return cur.data;
-    };
-    cls.prototype.pop_front = function() {
-      var cur = this.parent;
-      while (cur.prev != null) cur = cur.prev;
-      var ret = cur.data;
-      this.remove_node(cur);
-      return ret;
-    };
-    cls.prototype.remove = function(obj) {
-      this.remove_node(this.find(obj));
-    };
-    cls.prototype.successor_node = function(cur) {
-      if (cur.next != null) {
-        cur = cur.next;
-        while (cur.prev != null) cur = cur.prev;
-      } else {
-        var pre = cur;
-        cur = cur.parent;
-        while (cur != null && cur.prev != pre) {
-          pre = cur;
-          cur = cur.parent;
-        }
-      }
-      return cur;
-    };
-    cls.prototype.predecessor_node = function(cur) {
-      if (cur.prev != null) {
-        cur = cur.prev;
-        while (cur.next != null) cur = cur.next;
-      } else {
-        var pre = cur;
-        cur = cur.parent;
-        while (cur != null && cur.next != pre) {
-          pre = cur;
-          cur = cur.parent;
-        }
-      }
-      return cur;
-    };
-    cls.prototype.successor = function(obj) {
-      var node = this.successor_node(this.find(obj));
-      return node == null ? null : node.data;
-    };
-    cls.prototype.predecessor = function(obj) {
-      var node = this.predecessor_node(this.find(obj));
-      return node == null ? null : node.data;
-    };
-    cls.prototype.remove_node = function(cur) {
-      if (cur.next != null && cur.prev != null) {
-        var sm = cur.next;
-        while (sm.prev != null) sm = sm.prev;
-        var t = cur.data;
-        cur.data = sm.data;
-        sm.data = t;
-        if (this.swapped != null) this.swapped(cur.data, sm.data);
-        cur = sm;
-      }
-      var child = cur.prev == null ? cur.next : cur.prev;
-      if (cur.colour == 1) {
-        if (cur.prev != null || cur.next != null) {
-          child.colour = 1;
-        } else if (cur.parent != null) {
-          var parent = cur.parent;
-          while (true) {
-            parent.colour++;
-            parent.prev.colour--;
-            parent.next.colour--;
-            var child1 = parent.prev;
-            if (child1.colour == -1) {
-              this.__fix_neg_red(child1);
-              break;
-            } else if (child1.colour == 0) {
-              if (child1.prev != null && child1.prev.colour == 0) {
-                this.__fix_dbl_red(child1.prev);
-                break;
-              }
-              if (child1.next != null && child1.next.colour == 0) {
-                this.__fix_dbl_red(child1.next);
-                break;
-              }
-            }
-            var child2 = parent.next;
-            if (child2.colour == -1) {
-              this.__fix_neg_red(child2);
-              break;
-            } else if (child2.colour == 0) {
-              if (child2.prev != null && child2.prev.colour == 0) {
-                this.__fix_dbl_red(child2.prev);
-                break;
-              }
-              if (child2.next != null && child2.next.colour == 0) {
-                this.__fix_dbl_red(child2.next);
-                break;
-              }
-            }
-            if (parent.colour == 2) {
-              if (parent.parent == null) {
-                parent.colour = 1;
-              } else {
-                parent = parent.parent;
-                continue;
-              }
-            }
-            break;
-          }
-        }
-      }
-      var par = cur.parent;
-      if (par == null) this.parent = child;
-      else if (par.prev == cur) par.prev = child;
-      else par.next = child;
-      if (child != null) child.parent = par;
-      cur.parent = cur.prev = cur.next = null;
-      var o = cur;
-      o.data = null;
-      o.lt = null;
-      o.swapped = null;
-      o.next = cls.zpp_pool;
-      cls.zpp_pool = o;
-    };
-    cls.prototype.clear = function() {
-      if (this.parent != null) {
-        var cur = this.parent;
-        while (cur != null) {
-          if (cur.prev != null) cur = cur.prev;
-          else if (cur.next != null) cur = cur.next;
-          else {
-            var ret = cur.parent;
-            if (ret != null) {
-              if (cur == ret.prev) ret.prev = null;
-              else ret.next = null;
-              cur.parent = null;
-            }
-            var o = cur;
-            o.data = null;
-            o.lt = null;
-            o.swapped = null;
-            o.next = cls.zpp_pool;
-            cls.zpp_pool = o;
-            cur = ret;
-          }
-        }
-        this.parent = null;
-      }
-    };
-    cls.prototype.clear_with = function(lambda) {
-      if (this.parent == null) return;
-      var cur = this.parent;
-      while (cur != null) {
-        if (cur.prev != null) cur = cur.prev;
-        else if (cur.next != null) cur = cur.next;
-        else {
-          lambda(cur.data);
-          var ret = cur.parent;
-          if (ret != null) {
-            if (cur == ret.prev) ret.prev = null;
-            else ret.next = null;
-            cur.parent = null;
-          }
-          var o = cur;
-          o.data = null;
-          o.lt = null;
-          o.swapped = null;
-          o.next = cls.zpp_pool;
-          cls.zpp_pool = o;
-          cur = ret;
-        }
-      }
-      this.parent = null;
-    };
-    cls.prototype.clear_node = function(node, lambda) {
-      lambda(node.data);
-      var ret = node.parent;
-      if (ret != null) {
-        if (node == ret.prev) ret.prev = null;
-        else ret.next = null;
-        node.parent = null;
-      }
-      var o = node;
-      o.data = null;
-      o.lt = null;
-      o.swapped = null;
-      o.next = cls.zpp_pool;
-      cls.zpp_pool = o;
-      return ret;
-    };
-    cls.prototype.__fix_neg_red = function(negred) {
-      var parent = negred.parent;
-      var child;
-      if (parent.prev == negred) {
-        var nl = negred.prev, nr = negred.next, trl = nr.prev, trr = nr.next;
-        nl.colour = 0;
-        negred.colour = parent.colour = 1;
-        negred.next = trl;
-        if (trl != null) trl.parent = negred;
-        var t = parent.data;
-        parent.data = nr.data;
-        nr.data = t;
-        if (this.swapped != null) this.swapped(parent.data, nr.data);
-        nr.prev = trr;
-        if (trr != null) trr.parent = nr;
-        nr.next = parent.next;
-        if (parent.next != null) parent.next.parent = nr;
-        parent.next = nr;
-        if (nr != null) nr.parent = parent;
-        child = nl;
-      } else {
-        var nl1 = negred.next, nr1 = negred.prev, trl1 = nr1.next, trr1 = nr1.prev;
-        nl1.colour = 0;
-        negred.colour = parent.colour = 1;
-        negred.prev = trl1;
-        if (trl1 != null) trl1.parent = negred;
-        var t1 = parent.data;
-        parent.data = nr1.data;
-        nr1.data = t1;
-        if (this.swapped != null) this.swapped(parent.data, nr1.data);
-        nr1.next = trr1;
-        if (trr1 != null) trr1.parent = nr1;
-        nr1.prev = parent.prev;
-        if (parent.prev != null) parent.prev.parent = nr1;
-        parent.prev = nr1;
-        if (nr1 != null) nr1.parent = parent;
-        child = nl1;
-      }
-      if (child.prev != null && child.prev.colour == 0) this.__fix_dbl_red(child.prev);
-      else if (child.next != null && child.next.colour == 0) this.__fix_dbl_red(child.next);
-    };
-    cls.prototype.__fix_dbl_red = function(x) {
-      while (true) {
-        var par = x.parent, g = par.parent;
-        if (g == null) {
-          par.colour = 1;
-          break;
-        }
-        var n1, n2, n3, t1, t2, t3, t4;
-        if (par == g.prev) {
-          n3 = g;
-          t4 = g.next;
-          if (x == par.prev) {
-            n1 = x;
-            n2 = par;
-            t1 = x.prev;
-            t2 = x.next;
-            t3 = par.next;
-          } else {
-            n1 = par;
-            n2 = x;
-            t1 = par.prev;
-            t2 = x.prev;
-            t3 = x.next;
-          }
-        } else {
-          n1 = g;
-          t1 = g.prev;
-          if (x == par.prev) {
-            n2 = x;
-            n3 = par;
-            t2 = x.prev;
-            t3 = x.next;
-            t4 = par.next;
-          } else {
-            n2 = par;
-            n3 = x;
-            t2 = par.prev;
-            t3 = x.prev;
-            t4 = x.next;
-          }
-        }
-        var par1 = g.parent;
-        if (par1 == null) this.parent = n2;
-        else if (par1.prev == g) par1.prev = n2;
-        else par1.next = n2;
-        if (n2 != null) n2.parent = par1;
-        n1.prev = t1;
-        if (t1 != null) t1.parent = n1;
-        n1.next = t2;
-        if (t2 != null) t2.parent = n1;
-        n2.prev = n1;
-        if (n1 != null) n1.parent = n2;
-        n2.next = n3;
-        if (n3 != null) n3.parent = n2;
-        n3.prev = t3;
-        if (t3 != null) t3.parent = n3;
-        n3.next = t4;
-        if (t4 != null) t4.parent = n3;
-        n2.colour = g.colour - 1;
-        n1.colour = 1;
-        n3.colour = 1;
-        if (n2 == this.parent) {
-          this.parent.colour = 1;
-        } else if (n2.colour == 0 && n2.parent.colour == 0) {
-          x = n2;
-          continue;
-        }
-        break;
-      }
-    };
-    cls.prototype.try_insert_bool = function(obj) {
-      var x = null, cur = null;
-      if (this.parent == null) {
-        if (cls.zpp_pool == null) x = new cls();
-        else {
-          x = cls.zpp_pool;
-          cls.zpp_pool = x.next;
-          x.next = null;
-        }
-        x.data = obj;
-        this.parent = x;
-      } else {
-        cur = this.parent;
-        while (true) {
-          if (this.lt(obj, cur.data)) {
-            if (cur.prev == null) {
-              if (cls.zpp_pool == null) x = new cls();
-              else {
-                x = cls.zpp_pool;
-                cls.zpp_pool = x.next;
-                x.next = null;
-              }
-              x.data = obj;
-              cur.prev = x;
-              x.parent = cur;
-              break;
-            } else cur = cur.prev;
-          } else if (this.lt(cur.data, obj)) {
-            if (cur.next == null) {
-              if (cls.zpp_pool == null) x = new cls();
-              else {
-                x = cls.zpp_pool;
-                cls.zpp_pool = x.next;
-                x.next = null;
-              }
-              x.data = obj;
-              cur.next = x;
-              x.parent = cur;
-              break;
-            } else cur = cur.next;
-          } else break;
-        }
-      }
-      if (x == null) return false;
-      if (x.parent == null) x.colour = 1;
-      else {
-        x.colour = 0;
-        if (x.parent.colour == 0) this.__fix_dbl_red(x);
-      }
-      return true;
-    };
-    cls.prototype.try_insert = function(obj) {
-      var x = null, cur = null;
-      if (this.parent == null) {
-        if (cls.zpp_pool == null) x = new cls();
-        else {
-          x = cls.zpp_pool;
-          cls.zpp_pool = x.next;
-          x.next = null;
-        }
-        x.data = obj;
-        this.parent = x;
-      } else {
-        cur = this.parent;
-        while (true) {
-          if (this.lt(obj, cur.data)) {
-            if (cur.prev == null) {
-              if (cls.zpp_pool == null) x = new cls();
-              else {
-                x = cls.zpp_pool;
-                cls.zpp_pool = x.next;
-                x.next = null;
-              }
-              x.data = obj;
-              cur.prev = x;
-              x.parent = cur;
-              break;
-            } else cur = cur.prev;
-          } else if (this.lt(cur.data, obj)) {
-            if (cur.next == null) {
-              if (cls.zpp_pool == null) x = new cls();
-              else {
-                x = cls.zpp_pool;
-                cls.zpp_pool = x.next;
-                x.next = null;
-              }
-              x.data = obj;
-              cur.next = x;
-              x.parent = cur;
-              break;
-            } else cur = cur.next;
-          } else break;
-        }
-      }
-      if (x == null) return cur;
-      if (x.parent == null) x.colour = 1;
-      else {
-        x.colour = 0;
-        if (x.parent.colour == 0) this.__fix_dbl_red(x);
-      }
-      return x;
-    };
-    cls.prototype.insert = function(obj) {
-      var x;
-      if (cls.zpp_pool == null) x = new cls();
-      else {
-        x = cls.zpp_pool;
-        cls.zpp_pool = x.next;
-        x.next = null;
-      }
-      x.data = obj;
-      if (this.parent == null) {
-        this.parent = x;
-      } else {
-        var cur = this.parent;
-        while (true) {
-          if (this.lt(x.data, cur.data)) {
-            if (cur.prev == null) {
-              cur.prev = x;
-              x.parent = cur;
-              break;
-            } else cur = cur.prev;
-          } else if (cur.next == null) {
-            cur.next = x;
-            x.parent = cur;
-            break;
-          } else cur = cur.next;
-        }
-      }
-      if (x.parent == null) x.colour = 1;
-      else {
-        x.colour = 0;
-        if (x.parent.colour == 0) this.__fix_dbl_red(x);
-      }
-      return x;
-    };
     cls.prototype.__class__ = cls;
+    $hxClasses2["zpp_nape.util.ZPP_Set_" + typeName] = cls;
     return cls;
   }
   zpp_nape.util.ZNPNode_ZPP_CbType = createZNPNode("ZPP_CbType");
@@ -53202,582 +53554,250 @@ define(function() {
   zpp_nape.util.ZPP_Set_ZPP_SimpleEvent = createZPPSet("ZPP_SimpleEvent");
   zpp_nape.util.ZPP_Set_ZPP_CbSet = createZPPSet("ZPP_CbSet");
   ZPP_CbType._zpp = zpp_nape;
-  zpp_nape.callbacks.ZPP_CbType = $hxClasses["zpp_nape.callbacks.ZPP_CbType"] = ZPP_CbType;
+  zpp_nape.callbacks.ZPP_CbType = $hxClasses2["zpp_nape.callbacks.ZPP_CbType"] = ZPP_CbType;
   zpp_nape.callbacks.ZPP_CbType.prototype.__class__ = zpp_nape.callbacks.ZPP_CbType;
-  zpp_nape.util.ZPP_Flags = $hxClasses["zpp_nape.util.ZPP_Flags"] = ZPP_Flags;
+  zpp_nape.util.ZPP_Flags = $hxClasses2["zpp_nape.util.ZPP_Flags"] = ZPP_Flags;
   zpp_nape.util.ZPP_Flags.prototype.__class__ = zpp_nape.util.ZPP_Flags;
   ZPP_Listener._nape = nape67;
   ZPP_Listener._zpp = zpp_nape;
-  zpp_nape.callbacks.ZPP_Listener = $hxClasses["zpp_nape.callbacks.ZPP_Listener"] = ZPP_Listener;
+  zpp_nape.callbacks.ZPP_Listener = $hxClasses2["zpp_nape.callbacks.ZPP_Listener"] = ZPP_Listener;
   zpp_nape.callbacks.ZPP_Listener.prototype.__class__ = zpp_nape.callbacks.ZPP_Listener;
-  zpp_nape.callbacks.ZPP_BodyListener = $hxClasses["zpp_nape.callbacks.ZPP_BodyListener"] = ZPP_BodyListener;
+  zpp_nape.callbacks.ZPP_BodyListener = $hxClasses2["zpp_nape.callbacks.ZPP_BodyListener"] = ZPP_BodyListener;
   zpp_nape.callbacks.ZPP_BodyListener.prototype.__class__ = zpp_nape.callbacks.ZPP_BodyListener;
-  zpp_nape.callbacks.ZPP_ConstraintListener = $hxClasses["zpp_nape.callbacks.ZPP_ConstraintListener"] = ZPP_ConstraintListener;
+  zpp_nape.callbacks.ZPP_ConstraintListener = $hxClasses2["zpp_nape.callbacks.ZPP_ConstraintListener"] = ZPP_ConstraintListener;
   zpp_nape.callbacks.ZPP_ConstraintListener.prototype.__class__ = zpp_nape.callbacks.ZPP_ConstraintListener;
-  zpp_nape.callbacks.ZPP_InteractionListener = $hxClasses["zpp_nape.callbacks.ZPP_InteractionListener"] = ZPP_InteractionListener;
+  zpp_nape.callbacks.ZPP_InteractionListener = $hxClasses2["zpp_nape.callbacks.ZPP_InteractionListener"] = ZPP_InteractionListener;
   zpp_nape.callbacks.ZPP_InteractionListener.prototype.__class__ = zpp_nape.callbacks.ZPP_InteractionListener;
   ZPP_OptionType._nape = nape67;
   ZPP_OptionType._zpp = zpp_nape;
-  zpp_nape.callbacks.ZPP_OptionType = $hxClasses["zpp_nape.callbacks.ZPP_OptionType"] = ZPP_OptionType;
+  zpp_nape.callbacks.ZPP_OptionType = $hxClasses2["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 = nape67;
   ZPP_Constraint._zpp = zpp_nape;
-  zpp_nape.constraint.ZPP_Constraint = $hxClasses["zpp_nape.constraint.ZPP_Constraint"] = ZPP_Constraint;
+  zpp_nape.constraint.ZPP_Constraint = $hxClasses2["zpp_nape.constraint.ZPP_Constraint"] = ZPP_Constraint;
   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"] = ZPP_AngleJoint;
+  zpp_nape.constraint.ZPP_AngleJoint = $hxClasses2["zpp_nape.constraint.ZPP_AngleJoint"] = ZPP_AngleJoint;
   zpp_nape.constraint.ZPP_AngleJoint.__name__ = ZPP_AngleJoint.__name__;
   zpp_nape.constraint.ZPP_AngleJoint.prototype.__class__ = zpp_nape.constraint.ZPP_AngleJoint;
-  zpp_nape.constraint.ZPP_CopyHelper = $hxClasses["zpp_nape.constraint.ZPP_CopyHelper"] = ZPP_CopyHelper;
+  zpp_nape.constraint.ZPP_CopyHelper = $hxClasses2["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"] = ZPP_DistanceJoint;
+  zpp_nape.constraint.ZPP_DistanceJoint = $hxClasses2["zpp_nape.constraint.ZPP_DistanceJoint"] = ZPP_DistanceJoint;
   zpp_nape.constraint.ZPP_DistanceJoint.__name__ = ZPP_DistanceJoint.__name__;
   zpp_nape.constraint.ZPP_DistanceJoint.prototype.__class__ = zpp_nape.constraint.ZPP_DistanceJoint;
-  zpp_nape.constraint.ZPP_LineJoint = $hxClasses["zpp_nape.constraint.ZPP_LineJoint"] = ZPP_LineJoint;
+  zpp_nape.constraint.ZPP_LineJoint = $hxClasses2["zpp_nape.constraint.ZPP_LineJoint"] = ZPP_LineJoint;
   zpp_nape.constraint.ZPP_LineJoint.__name__ = ZPP_LineJoint.__name__;
   zpp_nape.constraint.ZPP_LineJoint.prototype.__class__ = zpp_nape.constraint.ZPP_LineJoint;
-  zpp_nape.constraint.ZPP_MotorJoint = $hxClasses["zpp_nape.constraint.ZPP_MotorJoint"] = ZPP_MotorJoint;
+  zpp_nape.constraint.ZPP_MotorJoint = $hxClasses2["zpp_nape.constraint.ZPP_MotorJoint"] = ZPP_MotorJoint;
   zpp_nape.constraint.ZPP_MotorJoint.__name__ = ZPP_MotorJoint.__name__;
   zpp_nape.constraint.ZPP_MotorJoint.prototype.__class__ = zpp_nape.constraint.ZPP_MotorJoint;
-  zpp_nape.constraint.ZPP_PivotJoint = $hxClasses["zpp_nape.constraint.ZPP_PivotJoint"] = ZPP_PivotJoint;
+  zpp_nape.constraint.ZPP_PivotJoint = $hxClasses2["zpp_nape.constraint.ZPP_PivotJoint"] = ZPP_PivotJoint;
   zpp_nape.constraint.ZPP_PivotJoint.__name__ = ZPP_PivotJoint.__name__;
   zpp_nape.constraint.ZPP_PivotJoint.prototype.__class__ = zpp_nape.constraint.ZPP_PivotJoint;
-  zpp_nape.constraint.ZPP_PulleyJoint = $hxClasses["zpp_nape.constraint.ZPP_PulleyJoint"] = ZPP_PulleyJoint;
+  zpp_nape.constraint.ZPP_PulleyJoint = $hxClasses2["zpp_nape.constraint.ZPP_PulleyJoint"] = ZPP_PulleyJoint;
   zpp_nape.constraint.ZPP_PulleyJoint.__name__ = ZPP_PulleyJoint.__name__;
   zpp_nape.constraint.ZPP_PulleyJoint.prototype.__class__ = zpp_nape.constraint.ZPP_PulleyJoint;
-  zpp_nape.constraint.ZPP_UserConstraint = $hxClasses["zpp_nape.constraint.ZPP_UserConstraint"] = ZPP_UserConstraint;
+  zpp_nape.constraint.ZPP_UserConstraint = $hxClasses2["zpp_nape.constraint.ZPP_UserConstraint"] = ZPP_UserConstraint;
   zpp_nape.constraint.ZPP_UserConstraint.__name__ = ZPP_UserConstraint.__name__;
   zpp_nape.constraint.ZPP_UserConstraint.prototype.__class__ = zpp_nape.constraint.ZPP_UserConstraint;
-  zpp_nape.constraint.ZPP_UserBody = $hxClasses["zpp_nape.constraint.ZPP_UserBody"] = ZPP_UserBody;
+  zpp_nape.constraint.ZPP_UserBody = $hxClasses2["zpp_nape.constraint.ZPP_UserBody"] = ZPP_UserBody;
   zpp_nape.constraint.ZPP_UserBody.prototype.__class__ = zpp_nape.constraint.ZPP_UserBody;
-  zpp_nape.constraint.ZPP_WeldJoint = $hxClasses["zpp_nape.constraint.ZPP_WeldJoint"] = ZPP_WeldJoint;
+  zpp_nape.constraint.ZPP_WeldJoint = $hxClasses2["zpp_nape.constraint.ZPP_WeldJoint"] = ZPP_WeldJoint;
   zpp_nape.constraint.ZPP_WeldJoint.__name__ = ZPP_WeldJoint.__name__;
   zpp_nape.constraint.ZPP_WeldJoint.prototype.__class__ = zpp_nape.constraint.ZPP_WeldJoint;
   if (!zpp_nape.dynamics) zpp_nape.dynamics = {};
   ZPP_Arbiter._nape = nape67;
   ZPP_Arbiter._zpp = zpp_nape;
-  zpp_nape.dynamics.ZPP_Arbiter = $hxClasses["zpp_nape.dynamics.ZPP_Arbiter"] = ZPP_Arbiter;
+  zpp_nape.dynamics.ZPP_Arbiter = $hxClasses2["zpp_nape.dynamics.ZPP_Arbiter"] = ZPP_Arbiter;
   zpp_nape.dynamics.ZPP_Arbiter.prototype.__class__ = zpp_nape.dynamics.ZPP_Arbiter;
-  zpp_nape.dynamics.ZPP_SensorArbiter = $hxClasses["zpp_nape.dynamics.ZPP_SensorArbiter"] = ZPP_SensorArbiter;
+  zpp_nape.dynamics.ZPP_SensorArbiter = $hxClasses2["zpp_nape.dynamics.ZPP_SensorArbiter"] = ZPP_SensorArbiter;
   zpp_nape.dynamics.ZPP_SensorArbiter.prototype.__class__ = zpp_nape.dynamics.ZPP_SensorArbiter;
   ZPP_FluidArbiter._nape = nape67;
   ZPP_FluidArbiter._zpp = zpp_nape;
-  zpp_nape.dynamics.ZPP_FluidArbiter = $hxClasses["zpp_nape.dynamics.ZPP_FluidArbiter"] = ZPP_FluidArbiter;
+  zpp_nape.dynamics.ZPP_FluidArbiter = $hxClasses2["zpp_nape.dynamics.ZPP_FluidArbiter"] = ZPP_FluidArbiter;
   zpp_nape.dynamics.ZPP_FluidArbiter.prototype.__class__ = zpp_nape.dynamics.ZPP_FluidArbiter;
   ZPP_ColArbiter._nape = nape67;
   ZPP_ColArbiter._zpp = zpp_nape;
-  zpp_nape.dynamics.ZPP_ColArbiter = $hxClasses["zpp_nape.dynamics.ZPP_ColArbiter"] = ZPP_ColArbiter;
+  zpp_nape.dynamics.ZPP_ColArbiter = $hxClasses2["zpp_nape.dynamics.ZPP_ColArbiter"] = ZPP_ColArbiter;
   zpp_nape.dynamics.ZPP_ColArbiter.prototype.__class__ = zpp_nape.dynamics.ZPP_ColArbiter;
-  zpp_nape.dynamics.ZPP_IContact = $hxClasses["zpp_nape.dynamics.ZPP_IContact"] = ZPP_IContact;
+  zpp_nape.dynamics.ZPP_IContact = $hxClasses2["zpp_nape.dynamics.ZPP_IContact"] = ZPP_IContact;
   zpp_nape.dynamics.ZPP_IContact.prototype.__class__ = zpp_nape.dynamics.ZPP_IContact;
   ZPP_Contact._nape = nape67;
   ZPP_Contact._zpp = zpp_nape;
-  zpp_nape.dynamics.ZPP_Contact = $hxClasses["zpp_nape.dynamics.ZPP_Contact"] = ZPP_Contact;
+  zpp_nape.dynamics.ZPP_Contact = $hxClasses2["zpp_nape.dynamics.ZPP_Contact"] = ZPP_Contact;
   zpp_nape.dynamics.ZPP_Contact.prototype.__class__ = zpp_nape.dynamics.ZPP_Contact;
   ZPP_InteractionFilter._nape = nape67;
   ZPP_InteractionFilter._zpp = zpp_nape;
-  zpp_nape.dynamics.ZPP_InteractionFilter = $hxClasses["zpp_nape.dynamics.ZPP_InteractionFilter"] = ZPP_InteractionFilter;
+  zpp_nape.dynamics.ZPP_InteractionFilter = $hxClasses2["zpp_nape.dynamics.ZPP_InteractionFilter"] = ZPP_InteractionFilter;
   zpp_nape.dynamics.ZPP_InteractionFilter.prototype.__class__ = zpp_nape.dynamics.ZPP_InteractionFilter;
   ZPP_InteractionGroup._zpp = zpp_nape;
-  zpp_nape.dynamics.ZPP_InteractionGroup = $hxClasses["zpp_nape.dynamics.ZPP_InteractionGroup"] = ZPP_InteractionGroup;
+  zpp_nape.dynamics.ZPP_InteractionGroup = $hxClasses2["zpp_nape.dynamics.ZPP_InteractionGroup"] = ZPP_InteractionGroup;
   zpp_nape.dynamics.ZPP_InteractionGroup.prototype.__class__ = zpp_nape.dynamics.ZPP_InteractionGroup;
   ZPP_SpaceArbiterList._nape = nape67;
   ZPP_SpaceArbiterList._zpp = zpp_nape;
   ZPP_SpaceArbiterList._init();
-  zpp_nape.dynamics.ZPP_SpaceArbiterList = $hxClasses["zpp_nape.dynamics.ZPP_SpaceArbiterList"] = ZPP_SpaceArbiterList;
+  zpp_nape.dynamics.ZPP_SpaceArbiterList = $hxClasses2["zpp_nape.dynamics.ZPP_SpaceArbiterList"] = ZPP_SpaceArbiterList;
   zpp_nape.dynamics.ZPP_SpaceArbiterList.prototype.__class__ = zpp_nape.dynamics.ZPP_SpaceArbiterList;
   if (!zpp_nape.geom) zpp_nape.geom = {};
   ZPP_AABB._nape = nape67;
   ZPP_AABB._zpp = zpp_nape;
-  zpp_nape.geom.ZPP_AABB = $hxClasses["zpp_nape.geom.ZPP_AABB"] = ZPP_AABB;
+  zpp_nape.geom.ZPP_AABB = $hxClasses2["zpp_nape.geom.ZPP_AABB"] = ZPP_AABB;
   zpp_nape.geom.ZPP_AABB.prototype.__class__ = zpp_nape.geom.ZPP_AABB;
-  zpp_nape.geom.ZPP_Collide = $hxClasses["zpp_nape.geom.ZPP_Collide"] = ZPP_Collide;
+  zpp_nape.geom.ZPP_Collide = $hxClasses2["zpp_nape.geom.ZPP_Collide"] = ZPP_Collide;
   zpp_nape.geom.ZPP_Collide.prototype.__class__ = zpp_nape.geom.ZPP_Collide;
-  zpp_nape.geom.ZPP_Convex = $hxClasses["zpp_nape.geom.ZPP_Convex"] = ZPP_Convex;
+  zpp_nape.geom.ZPP_Convex = $hxClasses2["zpp_nape.geom.ZPP_Convex"] = ZPP_Convex;
   zpp_nape.geom.ZPP_Convex.prototype.__class__ = zpp_nape.geom.ZPP_Convex;
-  zpp_nape.geom.ZPP_ConvexRayResult = $hxClasses["zpp_nape.geom.ZPP_ConvexRayResult"] = ZPP_ConvexRayResult;
+  zpp_nape.geom.ZPP_ConvexRayResult = $hxClasses2["zpp_nape.geom.ZPP_ConvexRayResult"] = ZPP_ConvexRayResult;
   zpp_nape.geom.ZPP_ConvexRayResult.prototype.__class__ = zpp_nape.geom.ZPP_ConvexRayResult;
-  zpp_nape.geom.ZPP_CutVert = $hxClasses["zpp_nape.geom.ZPP_CutVert"] = ZPP_CutVert;
+  zpp_nape.geom.ZPP_CutVert = $hxClasses2["zpp_nape.geom.ZPP_CutVert"] = ZPP_CutVert;
   zpp_nape.geom.ZPP_CutVert.prototype.__class__ = zpp_nape.geom.ZPP_CutVert;
-  zpp_nape.geom.ZPP_CutInt = $hxClasses["zpp_nape.geom.ZPP_CutInt"] = ZPP_CutInt;
+  zpp_nape.geom.ZPP_CutInt = $hxClasses2["zpp_nape.geom.ZPP_CutInt"] = ZPP_CutInt;
   zpp_nape.geom.ZPP_CutInt.prototype.__class__ = zpp_nape.geom.ZPP_CutInt;
-  zpp_nape.geom.ZPP_Cutter = $hxClasses["zpp_nape.geom.ZPP_Cutter"] = ZPP_Cutter;
+  zpp_nape.geom.ZPP_Cutter = $hxClasses2["zpp_nape.geom.ZPP_Cutter"] = ZPP_Cutter;
   zpp_nape.geom.ZPP_Cutter.prototype.__class__ = zpp_nape.geom.ZPP_Cutter;
-  zpp_nape.geom.ZPP_Geom = $hxClasses["zpp_nape.geom.ZPP_Geom"] = ZPP_Geom;
+  zpp_nape.geom.ZPP_Geom = $hxClasses2["zpp_nape.geom.ZPP_Geom"] = ZPP_Geom;
   zpp_nape.geom.ZPP_Geom.prototype.__class__ = zpp_nape.geom.ZPP_Geom;
-  zpp_nape.geom.ZPP_GeomVert = $hxClasses["zpp_nape.geom.ZPP_GeomVert"] = ZPP_GeomVert;
+  zpp_nape.geom.ZPP_GeomVert = $hxClasses2["zpp_nape.geom.ZPP_GeomVert"] = ZPP_GeomVert;
   zpp_nape.geom.ZPP_GeomVert.prototype.__class__ = zpp_nape.geom.ZPP_GeomVert;
   ZPP_GeomVert._createVec2Fn = function() {
     return new nape67.geom.Vec2();
   };
-  zpp_nape.geom.ZPP_GeomPoly = $hxClasses["zpp_nape.geom.ZPP_GeomPoly"] = ZPP_GeomPoly;
+  zpp_nape.geom.ZPP_GeomPoly = $hxClasses2["zpp_nape.geom.ZPP_GeomPoly"] = ZPP_GeomPoly;
   zpp_nape.geom.ZPP_GeomPoly.prototype.__class__ = zpp_nape.geom.ZPP_GeomPoly;
-  zpp_nape.geom.ZPP_MarchSpan = $hxClasses["zpp_nape.geom.ZPP_MarchSpan"] = ZPP_MarchSpan;
+  zpp_nape.geom.ZPP_MarchSpan = $hxClasses2["zpp_nape.geom.ZPP_MarchSpan"] = ZPP_MarchSpan;
   zpp_nape.geom.ZPP_MarchSpan.prototype.__class__ = zpp_nape.geom.ZPP_MarchSpan;
-  zpp_nape.geom.ZPP_MarchPair = $hxClasses["zpp_nape.geom.ZPP_MarchPair"] = ZPP_MarchPair;
+  zpp_nape.geom.ZPP_MarchPair = $hxClasses2["zpp_nape.geom.ZPP_MarchPair"] = ZPP_MarchPair;
   zpp_nape.geom.ZPP_MarchPair.prototype.__class__ = zpp_nape.geom.ZPP_MarchPair;
   ZPP_MarchingSquares._init(zpp_nape, nape67);
-  zpp_nape.geom.ZPP_MarchingSquares = $hxClasses["zpp_nape.geom.ZPP_MarchingSquares"] = ZPP_MarchingSquares;
+  zpp_nape.geom.ZPP_MarchingSquares = $hxClasses2["zpp_nape.geom.ZPP_MarchingSquares"] = ZPP_MarchingSquares;
   zpp_nape.geom.ZPP_MarchingSquares.prototype.__class__ = zpp_nape.geom.ZPP_MarchingSquares;
   ZPP_Mat23._nape = nape67;
-  zpp_nape.geom.ZPP_Mat23 = $hxClasses["zpp_nape.geom.ZPP_Mat23"] = ZPP_Mat23;
+  zpp_nape.geom.ZPP_Mat23 = $hxClasses2["zpp_nape.geom.ZPP_Mat23"] = ZPP_Mat23;
   zpp_nape.geom.ZPP_Mat23.prototype.__class__ = zpp_nape.geom.ZPP_Mat23;
-  zpp_nape.geom.ZPP_MatMN = $hxClasses["zpp_nape.geom.ZPP_MatMN"] = ZPP_MatMN;
+  zpp_nape.geom.ZPP_MatMN = $hxClasses2["zpp_nape.geom.ZPP_MatMN"] = ZPP_MatMN;
   zpp_nape.geom.ZPP_MatMN.prototype.__class__ = zpp_nape.geom.ZPP_MatMN;
-  zpp_nape.geom.ZPP_Monotone = $hxClasses["zpp_nape.geom.ZPP_Monotone"] = ZPP_Monotone;
-  zpp_nape.geom.ZPP_PartitionVertex = $hxClasses["zpp_nape.geom.ZPP_PartitionVertex"] = ZPP_PartitionVertex;
+  zpp_nape.geom.ZPP_Monotone = $hxClasses2["zpp_nape.geom.ZPP_Monotone"] = ZPP_Monotone;
+  zpp_nape.geom.ZPP_PartitionVertex = $hxClasses2["zpp_nape.geom.ZPP_PartitionVertex"] = ZPP_PartitionVertex;
   zpp_nape.geom.ZPP_PartitionVertex.prototype.__class__ = zpp_nape.geom.ZPP_PartitionVertex;
-  zpp_nape.geom.ZPP_PartitionedPoly = $hxClasses["zpp_nape.geom.ZPP_PartitionedPoly"] = ZPP_PartitionedPoly;
+  zpp_nape.geom.ZPP_PartitionedPoly = $hxClasses2["zpp_nape.geom.ZPP_PartitionedPoly"] = ZPP_PartitionedPoly;
   zpp_nape.geom.ZPP_PartitionedPoly.prototype.__class__ = zpp_nape.geom.ZPP_PartitionedPoly;
-  zpp_nape.geom.ZPP_Ray = $hxClasses["zpp_nape.geom.ZPP_Ray"] = ZPP_Ray;
+  zpp_nape.geom.ZPP_Ray = $hxClasses2["zpp_nape.geom.ZPP_Ray"] = ZPP_Ray;
   zpp_nape.geom.ZPP_Ray.prototype.__class__ = zpp_nape.geom.ZPP_Ray;
-  zpp_nape.geom.ZPP_SimpleVert = $hxClasses["zpp_nape.geom.ZPP_SimpleVert"] = ZPP_SimpleVert;
+  zpp_nape.geom.ZPP_SimpleVert = $hxClasses2["zpp_nape.geom.ZPP_SimpleVert"] = ZPP_SimpleVert;
   zpp_nape.geom.ZPP_SimpleVert.prototype.__class__ = zpp_nape.geom.ZPP_SimpleVert;
-  zpp_nape.geom.ZPP_SimpleSeg = $hxClasses["zpp_nape.geom.ZPP_SimpleSeg"] = ZPP_SimpleSeg;
+  zpp_nape.geom.ZPP_SimpleSeg = $hxClasses2["zpp_nape.geom.ZPP_SimpleSeg"] = ZPP_SimpleSeg;
   zpp_nape.geom.ZPP_SimpleSeg.prototype.__class__ = zpp_nape.geom.ZPP_SimpleSeg;
-  zpp_nape.geom.ZPP_SimpleEvent = $hxClasses["zpp_nape.geom.ZPP_SimpleEvent"] = ZPP_SimpleEvent;
+  zpp_nape.geom.ZPP_SimpleEvent = $hxClasses2["zpp_nape.geom.ZPP_SimpleEvent"] = ZPP_SimpleEvent;
   zpp_nape.geom.ZPP_SimpleEvent.prototype.__class__ = zpp_nape.geom.ZPP_SimpleEvent;
-  zpp_nape.geom.ZPP_SimpleSweep = $hxClasses["zpp_nape.geom.ZPP_SimpleSweep"] = ZPP_SimpleSweep;
+  zpp_nape.geom.ZPP_SimpleSweep = $hxClasses2["zpp_nape.geom.ZPP_SimpleSweep"] = ZPP_SimpleSweep;
   zpp_nape.geom.ZPP_SimpleSweep.prototype.__class__ = zpp_nape.geom.ZPP_SimpleSweep;
-  zpp_nape.geom.ZPP_Simple = $hxClasses["zpp_nape.geom.ZPP_Simple"] = ZPP_Simple;
+  zpp_nape.geom.ZPP_Simple = $hxClasses2["zpp_nape.geom.ZPP_Simple"] = ZPP_Simple;
   zpp_nape.geom.ZPP_Simple.prototype.__class__ = zpp_nape.geom.ZPP_Simple;
-  zpp_nape.geom.ZPP_SimplifyV = $hxClasses["zpp_nape.geom.ZPP_SimplifyV"] = ZPP_SimplifyV;
+  zpp_nape.geom.ZPP_SimplifyV = $hxClasses2["zpp_nape.geom.ZPP_SimplifyV"] = ZPP_SimplifyV;
   zpp_nape.geom.ZPP_SimplifyV.prototype.__class__ = zpp_nape.geom.ZPP_SimplifyV;
-  zpp_nape.geom.ZPP_SimplifyP = $hxClasses["zpp_nape.geom.ZPP_SimplifyP"] = ZPP_SimplifyP;
+  zpp_nape.geom.ZPP_SimplifyP = $hxClasses2["zpp_nape.geom.ZPP_SimplifyP"] = ZPP_SimplifyP;
   zpp_nape.geom.ZPP_SimplifyP.prototype.__class__ = zpp_nape.geom.ZPP_SimplifyP;
-  zpp_nape.geom.ZPP_Simplify = $hxClasses["zpp_nape.geom.ZPP_Simplify"] = ZPP_Simplify;
+  zpp_nape.geom.ZPP_Simplify = $hxClasses2["zpp_nape.geom.ZPP_Simplify"] = ZPP_Simplify;
   zpp_nape.geom.ZPP_Simplify.prototype.__class__ = zpp_nape.geom.ZPP_Simplify;
-  zpp_nape.geom.ZPP_ToiEvent = $hxClasses["zpp_nape.geom.ZPP_ToiEvent"] = ZPP_ToiEvent;
+  zpp_nape.geom.ZPP_ToiEvent = $hxClasses2["zpp_nape.geom.ZPP_ToiEvent"] = ZPP_ToiEvent;
   zpp_nape.geom.ZPP_ToiEvent.prototype.__class__ = zpp_nape.geom.ZPP_ToiEvent;
-  zpp_nape.geom.ZPP_SweepDistance = $hxClasses["zpp_nape.geom.ZPP_SweepDistance"] = ZPP_SweepDistance;
+  zpp_nape.geom.ZPP_SweepDistance = $hxClasses2["zpp_nape.geom.ZPP_SweepDistance"] = ZPP_SweepDistance;
   zpp_nape.geom.ZPP_SweepDistance.prototype.__class__ = zpp_nape.geom.ZPP_SweepDistance;
-  zpp_nape.geom.ZPP_PartitionPair = $hxClasses["zpp_nape.geom.ZPP_PartitionPair"] = ZPP_PartitionPair;
+  zpp_nape.geom.ZPP_PartitionPair = $hxClasses2["zpp_nape.geom.ZPP_PartitionPair"] = ZPP_PartitionPair;
   zpp_nape.geom.ZPP_PartitionPair.prototype.__class__ = zpp_nape.geom.ZPP_PartitionPair;
-  zpp_nape.geom.ZPP_Triangular = $hxClasses["zpp_nape.geom.ZPP_Triangular"] = ZPP_Triangular;
+  zpp_nape.geom.ZPP_Triangular = $hxClasses2["zpp_nape.geom.ZPP_Triangular"] = ZPP_Triangular;
   zpp_nape.geom.ZPP_Triangular.prototype.__class__ = zpp_nape.geom.ZPP_Triangular;
-  zpp_nape.geom.ZPP_Vec2 = $hxClasses["zpp_nape.geom.ZPP_Vec2"] = ZPP_Vec2;
+  zpp_nape.geom.ZPP_Vec2 = $hxClasses2["zpp_nape.geom.ZPP_Vec2"] = ZPP_Vec2;
   zpp_nape.geom.ZPP_Vec2.prototype.__class__ = zpp_nape.geom.ZPP_Vec2;
   ZPP_Vec3._zpp = zpp_nape;
-  zpp_nape.geom.ZPP_Vec3 = $hxClasses["zpp_nape.geom.ZPP_Vec3"] = ZPP_Vec3;
+  zpp_nape.geom.ZPP_Vec3 = $hxClasses2["zpp_nape.geom.ZPP_Vec3"] = ZPP_Vec3;
   zpp_nape.geom.ZPP_Vec3.prototype.__class__ = zpp_nape.geom.ZPP_Vec3;
-  zpp_nape.geom.ZPP_VecMath = $hxClasses["zpp_nape.geom.ZPP_VecMath"] = ZPP_VecMath;
+  zpp_nape.geom.ZPP_VecMath = $hxClasses2["zpp_nape.geom.ZPP_VecMath"] = ZPP_VecMath;
   zpp_nape.geom.ZPP_VecMath.prototype.__class__ = zpp_nape.geom.ZPP_VecMath;
   if (!zpp_nape.phys) zpp_nape.phys = {};
-  zpp_nape.phys.ZPP_Interactor = $hxClasses["zpp_nape.phys.ZPP_Interactor"] = ZPP_Interactor;
+  zpp_nape.phys.ZPP_Interactor = $hxClasses2["zpp_nape.phys.ZPP_Interactor"] = ZPP_Interactor;
   ZPP_Interactor._init(zpp_nape, nape67);
   zpp_nape.phys.ZPP_Interactor.prototype.__class__ = zpp_nape.phys.ZPP_Interactor;
   ZPP_Body._init(zpp_nape, nape67);
-  zpp_nape.phys.ZPP_Body = $hxClasses["zpp_nape.phys.ZPP_Body"] = ZPP_Body;
+  zpp_nape.phys.ZPP_Body = $hxClasses2["zpp_nape.phys.ZPP_Body"] = ZPP_Body;
   zpp_nape.phys.ZPP_Body.prototype.__class__ = zpp_nape.phys.ZPP_Body;
   ZPP_Compound._nape = nape67;
   ZPP_Compound._zpp = zpp_nape;
   ZPP_Compound._init();
-  zpp_nape.phys.ZPP_Compound = $hxClasses["zpp_nape.phys.ZPP_Compound"] = ZPP_Compound;
+  zpp_nape.phys.ZPP_Compound = $hxClasses2["zpp_nape.phys.ZPP_Compound"] = ZPP_Compound;
   zpp_nape.phys.ZPP_Compound.prototype.__class__ = zpp_nape.phys.ZPP_Compound;
   ZPP_FluidProperties._nape = nape67;
   ZPP_FluidProperties._zpp = zpp_nape;
-  zpp_nape.phys.ZPP_FluidProperties = $hxClasses["zpp_nape.phys.ZPP_FluidProperties"] = ZPP_FluidProperties;
+  zpp_nape.phys.ZPP_FluidProperties = $hxClasses2["zpp_nape.phys.ZPP_FluidProperties"] = ZPP_FluidProperties;
   zpp_nape.phys.ZPP_FluidProperties.prototype.__class__ = zpp_nape.phys.ZPP_FluidProperties;
   ZPP_Material._nape = nape67;
   ZPP_Material._zpp = zpp_nape;
-  zpp_nape.phys.ZPP_Material = $hxClasses["zpp_nape.phys.ZPP_Material"] = ZPP_Material;
+  zpp_nape.phys.ZPP_Material = $hxClasses2["zpp_nape.phys.ZPP_Material"] = ZPP_Material;
   zpp_nape.phys.ZPP_Material.prototype.__class__ = zpp_nape.phys.ZPP_Material;
   if (!zpp_nape.shape) zpp_nape.shape = {};
   ZPP_Shape._nape = nape67;
   ZPP_Shape._zpp = zpp_nape;
   ZPP_Shape._init();
-  zpp_nape.shape.ZPP_Shape = $hxClasses["zpp_nape.shape.ZPP_Shape"] = ZPP_Shape;
+  zpp_nape.shape.ZPP_Shape = $hxClasses2["zpp_nape.shape.ZPP_Shape"] = ZPP_Shape;
   zpp_nape.shape.ZPP_Shape.prototype.__class__ = zpp_nape.shape.ZPP_Shape;
   ZPP_Circle._nape = nape67;
   ZPP_Circle._zpp = zpp_nape;
   ZPP_Circle._init();
-  zpp_nape.shape.ZPP_Circle = $hxClasses["zpp_nape.shape.ZPP_Circle"] = ZPP_Circle;
+  zpp_nape.shape.ZPP_Circle = $hxClasses2["zpp_nape.shape.ZPP_Circle"] = ZPP_Circle;
   zpp_nape.shape.ZPP_Circle.prototype.__class__ = zpp_nape.shape.ZPP_Circle;
   ZPP_Edge._nape = nape67;
   ZPP_Edge._zpp = zpp_nape;
-  zpp_nape.shape.ZPP_Edge = $hxClasses["zpp_nape.shape.ZPP_Edge"] = ZPP_Edge;
+  zpp_nape.shape.ZPP_Edge = $hxClasses2["zpp_nape.shape.ZPP_Edge"] = ZPP_Edge;
   zpp_nape.shape.ZPP_Edge.prototype.__class__ = zpp_nape.shape.ZPP_Edge;
   ZPP_Polygon._nape = nape67;
   ZPP_Polygon._zpp = zpp_nape;
   ZPP_Polygon._init();
-  zpp_nape.shape.ZPP_Polygon = $hxClasses["zpp_nape.shape.ZPP_Polygon"] = ZPP_Polygon;
+  zpp_nape.shape.ZPP_Polygon = $hxClasses2["zpp_nape.shape.ZPP_Polygon"] = ZPP_Polygon;
   zpp_nape.shape.ZPP_Polygon.prototype.__class__ = zpp_nape.shape.ZPP_Polygon;
   if (!zpp_nape.space) zpp_nape.space = {};
   ZPP_Broadphase._zpp = zpp_nape;
   ZPP_Broadphase._nape = nape67;
-  zpp_nape.space.ZPP_Broadphase = $hxClasses["zpp_nape.space.ZPP_Broadphase"] = ZPP_Broadphase;
+  zpp_nape.space.ZPP_Broadphase = $hxClasses2["zpp_nape.space.ZPP_Broadphase"] = ZPP_Broadphase;
   zpp_nape.space.ZPP_Broadphase.prototype.__class__ = zpp_nape.space.ZPP_Broadphase;
-  zpp_nape.space.ZPP_AABBNode = $hxClasses["zpp_nape.space.ZPP_AABBNode"] = ZPP_AABBNode;
+  zpp_nape.space.ZPP_AABBNode = $hxClasses2["zpp_nape.space.ZPP_AABBNode"] = ZPP_AABBNode;
   zpp_nape.space.ZPP_AABBNode.prototype.__class__ = zpp_nape.space.ZPP_AABBNode;
-  zpp_nape.space.ZPP_AABBPair = $hxClasses["zpp_nape.space.ZPP_AABBPair"] = ZPP_AABBPair;
+  zpp_nape.space.ZPP_AABBPair = $hxClasses2["zpp_nape.space.ZPP_AABBPair"] = ZPP_AABBPair;
   zpp_nape.space.ZPP_AABBPair.prototype.__class__ = zpp_nape.space.ZPP_AABBPair;
-  zpp_nape.space.ZPP_AABBTree = $hxClasses["zpp_nape.space.ZPP_AABBTree"] = ZPP_AABBTree;
+  zpp_nape.space.ZPP_AABBTree = $hxClasses2["zpp_nape.space.ZPP_AABBTree"] = ZPP_AABBTree;
   zpp_nape.space.ZPP_AABBTree.prototype.__class__ = zpp_nape.space.ZPP_AABBTree;
   ZPP_DynAABBPhase._zpp = zpp_nape;
   ZPP_DynAABBPhase._nape = nape67;
   ZPP_DynAABBPhase._init();
-  zpp_nape.space.ZPP_DynAABBPhase = $hxClasses["zpp_nape.space.ZPP_DynAABBPhase"] = ZPP_DynAABBPhase;
+  zpp_nape.space.ZPP_DynAABBPhase = $hxClasses2["zpp_nape.space.ZPP_DynAABBPhase"] = ZPP_DynAABBPhase;
   zpp_nape.space.ZPP_DynAABBPhase.prototype.__class__ = zpp_nape.space.ZPP_DynAABBPhase;
   ZPP_Island._zpp = zpp_nape;
-  zpp_nape.space.ZPP_Island = $hxClasses["zpp_nape.space.ZPP_Island"] = ZPP_Island;
+  zpp_nape.space.ZPP_Island = $hxClasses2["zpp_nape.space.ZPP_Island"] = ZPP_Island;
   zpp_nape.space.ZPP_Island.prototype.__class__ = zpp_nape.space.ZPP_Island;
-  zpp_nape.space.ZPP_Component = $hxClasses["zpp_nape.space.ZPP_Component"] = ZPP_Component;
+  zpp_nape.space.ZPP_Component = $hxClasses2["zpp_nape.space.ZPP_Component"] = ZPP_Component;
   zpp_nape.space.ZPP_Component.prototype.__class__ = zpp_nape.space.ZPP_Component;
   ZPP_CallbackSet._zpp = zpp_nape;
-  zpp_nape.space.ZPP_CallbackSet = $hxClasses["zpp_nape.space.ZPP_CallbackSet"] = ZPP_CallbackSet;
+  zpp_nape.space.ZPP_CallbackSet = $hxClasses2["zpp_nape.space.ZPP_CallbackSet"] = ZPP_CallbackSet;
   zpp_nape.space.ZPP_CallbackSet.prototype.__class__ = zpp_nape.space.ZPP_CallbackSet;
   ZPP_CbSetManager._zpp = zpp_nape;
-  zpp_nape.space.ZPP_CbSetManager = $hxClasses["zpp_nape.space.ZPP_CbSetManager"] = ZPP_CbSetManager;
+  zpp_nape.space.ZPP_CbSetManager = $hxClasses2["zpp_nape.space.ZPP_CbSetManager"] = ZPP_CbSetManager;
   zpp_nape.space.ZPP_CbSetManager.prototype.__class__ = zpp_nape.space.ZPP_CbSetManager;
   ZPP_Space._zpp = zpp_nape;
   ZPP_Space._nape = nape67;
-  zpp_nape.space.ZPP_Space = $hxClasses["zpp_nape.space.ZPP_Space"] = ZPP_Space;
+  zpp_nape.space.ZPP_Space = $hxClasses2["zpp_nape.space.ZPP_Space"] = ZPP_Space;
   zpp_nape.space.ZPP_Space.prototype.__class__ = zpp_nape.space.ZPP_Space;
-  zpp_nape.space.ZPP_SweepData = $hxClasses["zpp_nape.space.ZPP_SweepData"] = ZPP_SweepData;
+  zpp_nape.space.ZPP_SweepData = $hxClasses2["zpp_nape.space.ZPP_SweepData"] = ZPP_SweepData;
   zpp_nape.space.ZPP_SweepData.prototype.__class__ = zpp_nape.space.ZPP_SweepData;
   ZPP_SweepPhase._zpp = zpp_nape;
   ZPP_SweepPhase._nape = nape67;
   ZPP_SweepPhase._init();
-  zpp_nape.space.ZPP_SweepPhase = $hxClasses["zpp_nape.space.ZPP_SweepPhase"] = ZPP_SweepPhase;
+  zpp_nape.space.ZPP_SweepPhase = $hxClasses2["zpp_nape.space.ZPP_SweepPhase"] = ZPP_SweepPhase;
   zpp_nape.space.ZPP_SweepPhase.prototype.__class__ = zpp_nape.space.ZPP_SweepPhase;
-  zpp_nape.util.ZNPArray2_Float = $hxClasses["zpp_nape.util.ZNPArray2_Float"] = function(width, height) {
-    this.width = 0;
-    this.list = null;
-    this.width = width;
-    this.list = [];
-  };
-  zpp_nape.util.ZNPArray2_Float.__name__ = [
-    "zpp_nape",
-    "util",
-    "ZNPArray2_Float"
-  ];
-  zpp_nape.util.ZNPArray2_Float.prototype.list = null;
-  zpp_nape.util.ZNPArray2_Float.prototype.width = null;
-  zpp_nape.util.ZNPArray2_Float.prototype.resize = function(width, height, def) {
-    this.width = width;
-    var _g = 0;
-    var _g1 = width * height;
-    while (_g < _g1) {
-      var i = _g++;
-      this.list[i] = def;
-    }
-  };
-  zpp_nape.util.ZNPArray2_Float.prototype.get = function(x, y) {
-    return this.list[y * this.width + x];
-  };
-  zpp_nape.util.ZNPArray2_Float.prototype.set = function(x, y, obj) {
-    return this.list[y * this.width + x] = obj;
-  };
-  zpp_nape.util.ZNPArray2_Float.prototype.__class__ = zpp_nape.util.ZNPArray2_Float;
-  zpp_nape.util.ZNPArray2_ZPP_GeomVert = $hxClasses["zpp_nape.util.ZNPArray2_ZPP_GeomVert"] = function(width, height) {
-    this.width = 0;
-    this.list = null;
-    this.width = width;
-    this.list = [];
-  };
-  zpp_nape.util.ZNPArray2_ZPP_GeomVert.__name__ = [
-    "zpp_nape",
-    "util",
-    "ZNPArray2_ZPP_GeomVert"
-  ];
-  zpp_nape.util.ZNPArray2_ZPP_GeomVert.prototype.list = null;
-  zpp_nape.util.ZNPArray2_ZPP_GeomVert.prototype.width = null;
-  zpp_nape.util.ZNPArray2_ZPP_GeomVert.prototype.resize = function(width, height, def) {
-    this.width = width;
-    var _g = 0;
-    var _g1 = width * height;
-    while (_g < _g1) {
-      var i = _g++;
-      this.list[i] = def;
-    }
-  };
-  zpp_nape.util.ZNPArray2_ZPP_GeomVert.prototype.get = function(x, y) {
-    return this.list[y * this.width + x];
-  };
-  zpp_nape.util.ZNPArray2_ZPP_GeomVert.prototype.set = function(x, y, obj) {
-    return this.list[y * this.width + x] = obj;
-  };
-  zpp_nape.util.ZNPArray2_ZPP_GeomVert.prototype.__class__ = zpp_nape.util.ZNPArray2_ZPP_GeomVert;
-  zpp_nape.util.ZNPArray2_ZPP_MarchPair = $hxClasses["zpp_nape.util.ZNPArray2_ZPP_MarchPair"] = function(width, height) {
-    this.width = 0;
-    this.list = null;
-    this.width = width;
-    this.list = [];
-  };
-  zpp_nape.util.ZNPArray2_ZPP_MarchPair.__name__ = [
-    "zpp_nape",
-    "util",
-    "ZNPArray2_ZPP_MarchPair"
-  ];
-  zpp_nape.util.ZNPArray2_ZPP_MarchPair.prototype.list = null;
-  zpp_nape.util.ZNPArray2_ZPP_MarchPair.prototype.width = null;
-  zpp_nape.util.ZNPArray2_ZPP_MarchPair.prototype.resize = function(width, height, def) {
-    this.width = width;
-    var _g = 0;
-    var _g1 = width * height;
-    while (_g < _g1) {
-      var i = _g++;
-      this.list[i] = def;
-    }
-  };
-  zpp_nape.util.ZNPArray2_ZPP_MarchPair.prototype.get = function(x, y) {
-    return this.list[y * this.width + x];
-  };
-  zpp_nape.util.ZNPArray2_ZPP_MarchPair.prototype.set = function(x, y, obj) {
-    return this.list[y * this.width + x] = obj;
-  };
-  zpp_nape.util.ZNPArray2_ZPP_MarchPair.prototype.__class__ = zpp_nape.util.ZNPArray2_ZPP_MarchPair;
-  zpp_nape.util.Hashable2_Boolfalse = $hxClasses["zpp_nape.util.Hashable2_Boolfalse"] = function() {
-    this.di = 0;
-    this.id = 0;
-    this.hnext = null;
-    this.next = null;
-    this.value = false;
-  };
-  zpp_nape.util.Hashable2_Boolfalse.__name__ = [
-    "zpp_nape",
-    "util",
-    "Hashable2_Boolfalse"
-  ];
-  zpp_nape.util.Hashable2_Boolfalse.get = function(id, di, val) {
-    var ret;
-    if (zpp_nape.util.Hashable2_Boolfalse.zpp_pool == null) {
-      ret = new zpp_nape.util.Hashable2_Boolfalse();
-    } else {
-      ret = zpp_nape.util.Hashable2_Boolfalse.zpp_pool;
-      zpp_nape.util.Hashable2_Boolfalse.zpp_pool = ret.next;
-      ret.next = null;
-    }
-    ret.id = id;
-    ret.di = di;
-    var ret1 = ret;
-    ret1.value = val;
-    return ret1;
-  };
-  zpp_nape.util.Hashable2_Boolfalse.getpersist = function(id, di) {
-    var ret;
-    if (zpp_nape.util.Hashable2_Boolfalse.zpp_pool == null) {
-      ret = new zpp_nape.util.Hashable2_Boolfalse();
-    } else {
-      ret = zpp_nape.util.Hashable2_Boolfalse.zpp_pool;
-      zpp_nape.util.Hashable2_Boolfalse.zpp_pool = ret.next;
-      ret.next = null;
-    }
-    ret.id = id;
-    ret.di = di;
-    return ret;
-  };
-  zpp_nape.util.Hashable2_Boolfalse.ordered_get = function(id, di, val) {
-    if (id <= di) {
-      var ret;
-      if (zpp_nape.util.Hashable2_Boolfalse.zpp_pool == null) {
-        ret = new zpp_nape.util.Hashable2_Boolfalse();
-      } else {
-        ret = zpp_nape.util.Hashable2_Boolfalse.zpp_pool;
-        zpp_nape.util.Hashable2_Boolfalse.zpp_pool = ret.next;
-        ret.next = null;
-      }
-      ret.id = id;
-      ret.di = di;
-      var ret1 = ret;
-      ret1.value = val;
-      return ret1;
-    } else {
-      var ret2;
-      if (zpp_nape.util.Hashable2_Boolfalse.zpp_pool == null) {
-        ret2 = new zpp_nape.util.Hashable2_Boolfalse();
-      } else {
-        ret2 = zpp_nape.util.Hashable2_Boolfalse.zpp_pool;
-        zpp_nape.util.Hashable2_Boolfalse.zpp_pool = ret2.next;
-        ret2.next = null;
-      }
-      ret2.id = di;
-      ret2.di = id;
-      var ret3 = ret2;
-      ret3.value = val;
-      return ret3;
-    }
-  };
-  zpp_nape.util.Hashable2_Boolfalse.ordered_get_persist = function(id, di) {
-    if (id <= di) {
-      var ret;
-      if (zpp_nape.util.Hashable2_Boolfalse.zpp_pool == null) {
-        ret = new zpp_nape.util.Hashable2_Boolfalse();
-      } else {
-        ret = zpp_nape.util.Hashable2_Boolfalse.zpp_pool;
-        zpp_nape.util.Hashable2_Boolfalse.zpp_pool = ret.next;
-        ret.next = null;
-      }
-      ret.id = id;
-      ret.di = di;
-      return ret;
-    } else {
-      var ret1;
-      if (zpp_nape.util.Hashable2_Boolfalse.zpp_pool == null) {
-        ret1 = new zpp_nape.util.Hashable2_Boolfalse();
-      } else {
-        ret1 = zpp_nape.util.Hashable2_Boolfalse.zpp_pool;
-        zpp_nape.util.Hashable2_Boolfalse.zpp_pool = ret1.next;
-        ret1.next = null;
-      }
-      ret1.id = di;
-      ret1.di = id;
-      return ret1;
-    }
-  };
-  zpp_nape.util.Hashable2_Boolfalse.prototype.value = null;
-  zpp_nape.util.Hashable2_Boolfalse.prototype.next = null;
-  zpp_nape.util.Hashable2_Boolfalse.prototype.hnext = null;
-  zpp_nape.util.Hashable2_Boolfalse.prototype.id = null;
-  zpp_nape.util.Hashable2_Boolfalse.prototype.di = null;
-  zpp_nape.util.Hashable2_Boolfalse.prototype.free = function() {
-  };
-  zpp_nape.util.Hashable2_Boolfalse.prototype.alloc = function() {
-  };
-  zpp_nape.util.Hashable2_Boolfalse.prototype.__class__ = zpp_nape.util.Hashable2_Boolfalse;
-  zpp_nape.util.FastHash2_Hashable2_Boolfalse = $hxClasses["zpp_nape.util.FastHash2_Hashable2_Boolfalse"] = function() {
-    this.cnt = 0;
-    this.table = null;
-    this.cnt = 0;
-    this.table = [];
-    var _g = 0;
-    var _g1 = 1048576;
-    while (_g < _g1) {
-      var i = _g++;
-      this.table.push(null);
-    }
-  };
-  zpp_nape.util.FastHash2_Hashable2_Boolfalse.__name__ = [
-    "zpp_nape",
-    "util",
-    "FastHash2_Hashable2_Boolfalse"
-  ];
-  zpp_nape.util.FastHash2_Hashable2_Boolfalse.prototype.table = null;
-  zpp_nape.util.FastHash2_Hashable2_Boolfalse.prototype.cnt = null;
-  zpp_nape.util.FastHash2_Hashable2_Boolfalse.prototype.empty = function() {
-    return this.cnt == 0;
-  };
-  zpp_nape.util.FastHash2_Hashable2_Boolfalse.prototype.clear = function() {
-    var _g = 0;
-    var _g1 = this.table.length;
-    while (_g < _g1) {
-      var i = _g++;
-      var n = this.table[i];
-      if (n == null) {
-        continue;
-      }
-      while (n != null) {
-        var t = n.hnext;
-        n.hnext = null;
-        n = t;
-      }
-      this.table[i] = null;
-    }
-  };
-  zpp_nape.util.FastHash2_Hashable2_Boolfalse.prototype.get = function(id, di) {
-    var n = this.table[id * 106039 + di & 1048575];
-    if (n == null) {
-      return null;
-    } else if (n.id == id && n.di == di) {
-      return n;
-    } else {
-      while (true) {
-        n = n.hnext;
-        if (!(n != null && (n.id != id || n.di != di))) {
-          break;
-        }
-      }
-      return n;
-    }
-  };
-  zpp_nape.util.FastHash2_Hashable2_Boolfalse.prototype.ordered_get = function(id, di) {
-    if (id > di) {
-      var t = id;
-      id = di;
-      di = t;
-    }
-    var n = this.table[id * 106039 + di & 1048575];
-    if (n == null) {
-      return null;
-    } else if (n.id == id && n.di == di) {
-      return n;
-    } else {
-      while (true) {
-        n = n.hnext;
-        if (!(n != null && (n.id != id || n.di != di))) {
-          break;
-        }
-      }
-      return n;
-    }
-  };
-  zpp_nape.util.FastHash2_Hashable2_Boolfalse.prototype.has = function(id, di) {
-    var n = this.table[id * 106039 + di & 1048575];
-    if (n == null) {
-      return false;
-    } else if (n.id == id && n.di == di) {
-      return true;
-    } else {
-      while (true) {
-        n = n.hnext;
-        if (!(n != null && (n.id != id || n.di != di))) {
-          break;
-        }
-      }
-      return n != null;
-    }
-  };
-  zpp_nape.util.FastHash2_Hashable2_Boolfalse.prototype.maybeAdd = function(arb) {
-    var h = arb.id * 106039 + arb.di & 1048575;
-    var n = this.table[h];
-    var cont = true;
-    if (n == null) {
-      this.table[h] = arb;
-      arb.hnext = null;
-    } else if (cont) {
-      arb.hnext = n.hnext;
-      n.hnext = arb;
-    }
-    if (cont) {
-      this.cnt++;
-    }
-  };
-  zpp_nape.util.FastHash2_Hashable2_Boolfalse.prototype.add = function(arb) {
-    var h = arb.id * 106039 + arb.di & 1048575;
-    var n = this.table[h];
-    if (n == null) {
-      this.table[h] = arb;
-      arb.hnext = null;
-    } else {
-      arb.hnext = n.hnext;
-      n.hnext = arb;
-    }
-    this.cnt++;
-  };
-  zpp_nape.util.FastHash2_Hashable2_Boolfalse.prototype.remove = function(arb) {
-    var h = arb.id * 106039 + arb.di & 1048575;
-    var n = this.table[h];
-    if (n == arb) {
-      this.table[h] = n.hnext;
-    } else if (n != null) {
-      var pre;
-      while (true) {
-        pre = n;
-        n = n.hnext;
-        if (!(n != null && n != arb)) {
-          break;
-        }
-      }
-      pre.hnext = n.hnext;
-    }
-    arb.hnext = null;
-    this.cnt--;
-  };
-  zpp_nape.util.FastHash2_Hashable2_Boolfalse.prototype.hash = function(id, di) {
-    return id * 106039 + di & 1048575;
-  };
-  zpp_nape.util.FastHash2_Hashable2_Boolfalse.prototype.__class__ = zpp_nape.util.FastHash2_Hashable2_Boolfalse;
+  zpp_nape.util.ZNPArray2_Float = ZNPArray2_Float;
+  zpp_nape.util.ZNPArray2_ZPP_GeomVert = ZNPArray2_ZPP_GeomVert;
+  zpp_nape.util.ZNPArray2_ZPP_MarchPair = ZNPArray2_ZPP_MarchPair;
+  zpp_nape.util.Hashable2_Boolfalse = Hashable2_Boolfalse;
+  zpp_nape.util.FastHash2_Hashable2_Boolfalse = FastHash2_Hashable2_Boolfalse;
   zpp_nape.util.ZNPNode_ZPP_CbType;
   zpp_nape.util.ZNPNode_ZPP_CallbackSet;
   zpp_nape.util.ZNPNode_ZPP_Shape;
@@ -53813,7 +53833,7 @@ define(function() {
   zpp_nape.util.ZNPNode_ConvexResult;
   zpp_nape.util.ZNPNode_ZPP_GeomPoly;
   zpp_nape.util.ZNPNode_RayResult;
-  zpp_nape.util.ZPP_MixVec2List = $hxClasses["zpp_nape.util.ZPP_MixVec2List"] = function() {
+  zpp_nape.util.ZPP_MixVec2List = $hxClasses2["zpp_nape.util.ZPP_MixVec2List"] = function() {
     this.at_index = 0;
     this.at_ite = null;
     this.zip_length = false;
@@ -53872,7 +53892,7 @@ define(function() {
   zpp_nape.util.ZPP_MixVec2List.prototype.at = function(index) {
     this.zpp_vm();
     if (index < 0 || index >= this.zpp_gl()) {
-      throw new js._Boot.HaxeError("Error: Index out of bounds");
+      throw new js2._Boot.HaxeError("Error: Index out of bounds");
     }
     if (this.zpp_inner.reverse_flag) {
       index = this.zpp_gl() - 1 - index;
@@ -53912,12 +53932,12 @@ define(function() {
   };
   zpp_nape.util.ZPP_MixVec2List.prototype.push = function(obj) {
     if (this.zpp_inner.immutable) {
-      throw new js._Boot.HaxeError("Error: Vec2List is immutable");
+      throw new js2._Boot.HaxeError("Error: Vec2List is immutable");
     }
     this.zpp_inner.modify_test();
     this.zpp_vm();
     if (obj.zpp_inner._inuse) {
-      throw new js._Boot.HaxeError("Error: Vec2 is already in use");
+      throw new js2._Boot.HaxeError("Error: Vec2 is already in use");
     }
     var cont = this.zpp_inner.adder != null ? this.zpp_inner.adder(obj) : true;
     if (cont) {
@@ -53936,12 +53956,12 @@ define(function() {
   };
   zpp_nape.util.ZPP_MixVec2List.prototype.unshift = function(obj) {
     if (this.zpp_inner.immutable) {
-      throw new js._Boot.HaxeError("Error: Vec2List is immutable");
+      throw new js2._Boot.HaxeError("Error: Vec2List is immutable");
     }
     this.zpp_inner.modify_test();
     this.zpp_vm();
     if (obj.zpp_inner._inuse) {
-      throw new js._Boot.HaxeError("Error: Vec2 is already in use");
+      throw new js2._Boot.HaxeError("Error: Vec2 is already in use");
     }
     var cont = this.zpp_inner.adder != null ? this.zpp_inner.adder(obj) : true;
     if (cont) {
@@ -53960,11 +53980,11 @@ define(function() {
   };
   zpp_nape.util.ZPP_MixVec2List.prototype.pop = function() {
     if (this.zpp_inner.immutable) {
-      throw new js._Boot.HaxeError("Error: Vec2List is immutable");
+      throw new js2._Boot.HaxeError("Error: Vec2List is immutable");
     }
     this.zpp_inner.modify_test();
     if (this.empty()) {
-      throw new js._Boot.HaxeError("Error: Cannot remove from empty list");
+      throw new js2._Boot.HaxeError("Error: Cannot remove from empty list");
     }
     this.zpp_vm();
     var ret = null;
@@ -54039,11 +54059,11 @@ define(function() {
   };
   zpp_nape.util.ZPP_MixVec2List.prototype.shift = function() {
     if (this.zpp_inner.immutable) {
-      throw new js._Boot.HaxeError("Error: Vec2List is immutable");
+      throw new js2._Boot.HaxeError("Error: Vec2List is immutable");
     }
     this.zpp_inner.modify_test();
     if (this.empty()) {
-      throw new js._Boot.HaxeError("Error: Cannot remove from empty list");
+      throw new js2._Boot.HaxeError("Error: Cannot remove from empty list");
     }
     this.zpp_vm();
     var ret = null;
@@ -54118,7 +54138,7 @@ define(function() {
   };
   zpp_nape.util.ZPP_MixVec2List.prototype.remove = function(obj) {
     if (this.zpp_inner.immutable) {
-      throw new js._Boot.HaxeError("Error: Vec2List is immutable");
+      throw new js2._Boot.HaxeError("Error: Vec2List is immutable");
     }
     this.zpp_inner.modify_test();
     this.zpp_vm();
@@ -54146,7 +54166,7 @@ define(function() {
   };
   zpp_nape.util.ZPP_MixVec2List.prototype.clear = function() {
     if (this.zpp_inner.immutable) {
-      throw new js._Boot.HaxeError("Error: Vec2List is immutable");
+      throw new js2._Boot.HaxeError("Error: Vec2List is immutable");
     }
     if (this.zpp_inner.reverse_flag) {
       while (!this.empty()) this.pop();
@@ -54155,354 +54175,28 @@ define(function() {
     }
   };
   zpp_nape.util.ZPP_MixVec2List.prototype.__class__ = zpp_nape.util.ZPP_MixVec2List;
-  zpp_nape.util.ZPP_Math = $hxClasses["zpp_nape.util.ZPP_Math"] = ZPP_Math;
+  zpp_nape.util.ZPP_Math = $hxClasses2["zpp_nape.util.ZPP_Math"] = ZPP_Math;
   zpp_nape.util.ZPP_Math.prototype.__class__ = zpp_nape.util.ZPP_Math;
-  zpp_nape.util.ZPP_PubPool = $hxClasses["zpp_nape.util.ZPP_PubPool"] = ZPP_PubPool;
+  zpp_nape.util.ZPP_PubPool = $hxClasses2["zpp_nape.util.ZPP_PubPool"] = ZPP_PubPool;
   zpp_nape.util.ZPP_PubPool.prototype.__class__ = zpp_nape.util.ZPP_PubPool;
   {
     String.__name__ = true;
     Array.__name__ = true;
   }
-  Object.defineProperty(js._Boot.HaxeError.prototype, "message", {
+  Object.defineProperty(js2._Boot.HaxeError.prototype, "message", {
     get: function() {
       return String(this.val);
     }
   });
-  js.Boot.__toStr = {}.toString;
-  nape67.constraint.Constraint.zpp_internalAlloc = false;
-  nape67.dynamics.ContactIterator.zpp_pool = null;
-  nape67.geom.Vec2Iterator.zpp_pool = null;
-  nape67.phys.Interactor.zpp_internalAlloc = false;
-  nape67.shape.Shape.zpp_internalAlloc = false;
-  zpp_nape.callbacks.ZPP_CbType.ANY_SHAPE = new nape67.callbacks.CbType();
-  zpp_nape.callbacks.ZPP_CbType.ANY_BODY = new nape67.callbacks.CbType();
-  zpp_nape.callbacks.ZPP_CbType.ANY_COMPOUND = new nape67.callbacks.CbType();
-  zpp_nape.callbacks.ZPP_CbType.ANY_CONSTRAINT = new nape67.callbacks.CbType();
-  zpp_nape.util.ZPP_Flags.internal = false;
-  zpp_nape.util.ZPP_Flags.id_ImmState_ACCEPT = 1;
-  zpp_nape.util.ZPP_Flags.id_ImmState_IGNORE = 2;
-  zpp_nape.util.ZPP_Flags.id_ImmState_ALWAYS = 4;
-  zpp_nape.util.ZPP_Flags.id_GravMassMode_DEFAULT = 0;
-  zpp_nape.util.ZPP_Flags.id_GravMassMode_FIXED = 1;
-  zpp_nape.util.ZPP_Flags.id_GravMassMode_SCALED = 2;
-  zpp_nape.util.ZPP_Flags.id_InertiaMode_DEFAULT = 0;
-  zpp_nape.util.ZPP_Flags.id_InertiaMode_FIXED = 1;
-  zpp_nape.util.ZPP_Flags.id_MassMode_DEFAULT = 0;
-  zpp_nape.util.ZPP_Flags.id_MassMode_FIXED = 1;
-  zpp_nape.util.ZPP_Flags.id_BodyType_STATIC = 1;
-  zpp_nape.util.ZPP_Flags.id_BodyType_DYNAMIC = 2;
-  zpp_nape.util.ZPP_Flags.id_BodyType_KINEMATIC = 3;
-  zpp_nape.util.ZPP_Flags.id_ListenerType_BODY = 0;
-  zpp_nape.util.ZPP_Flags.id_PreFlag_ACCEPT = 1;
-  zpp_nape.util.ZPP_Flags.id_ListenerType_CONSTRAINT = 1;
-  zpp_nape.util.ZPP_Flags.id_PreFlag_IGNORE = 2;
-  zpp_nape.util.ZPP_Flags.id_ListenerType_INTERACTION = 2;
-  zpp_nape.util.ZPP_Flags.id_PreFlag_ACCEPT_ONCE = 3;
-  zpp_nape.util.ZPP_Flags.id_ListenerType_PRE = 3;
-  zpp_nape.util.ZPP_Flags.id_PreFlag_IGNORE_ONCE = 4;
-  zpp_nape.util.ZPP_Flags.id_CbEvent_BEGIN = 0;
-  zpp_nape.util.ZPP_Flags.id_InteractionType_COLLISION = 1;
-  zpp_nape.util.ZPP_Flags.id_CbEvent_ONGOING = 6;
-  zpp_nape.util.ZPP_Flags.id_InteractionType_SENSOR = 2;
-  zpp_nape.util.ZPP_Flags.id_CbEvent_END = 1;
-  zpp_nape.util.ZPP_Flags.id_InteractionType_FLUID = 4;
-  zpp_nape.util.ZPP_Flags.id_CbEvent_WAKE = 2;
-  zpp_nape.util.ZPP_Flags.id_InteractionType_ANY = 7;
-  zpp_nape.util.ZPP_Flags.id_CbEvent_SLEEP = 3;
-  zpp_nape.util.ZPP_Flags.id_CbEvent_BREAK = 4;
-  zpp_nape.util.ZPP_Flags.id_CbEvent_PRE = 5;
-  zpp_nape.util.ZPP_Flags.id_Winding_UNDEFINED = 0;
-  zpp_nape.util.ZPP_Flags.id_Winding_CLOCKWISE = 1;
-  zpp_nape.util.ZPP_Flags.id_Winding_ANTICLOCKWISE = 2;
-  zpp_nape.util.ZPP_Flags.id_ValidationResult_VALID = 0;
-  zpp_nape.util.ZPP_Flags.id_ValidationResult_DEGENERATE = 1;
-  zpp_nape.util.ZPP_Flags.id_ValidationResult_CONCAVE = 2;
-  zpp_nape.util.ZPP_Flags.id_ValidationResult_SELF_INTERSECTING = 3;
-  zpp_nape.util.ZPP_Flags.id_ShapeType_CIRCLE = 0;
-  zpp_nape.util.ZPP_Flags.id_ShapeType_POLYGON = 1;
-  zpp_nape.util.ZPP_Flags.id_Broadphase_DYNAMIC_AABB_TREE = 0;
-  zpp_nape.util.ZPP_Flags.id_Broadphase_SWEEP_AND_PRUNE = 1;
-  zpp_nape.util.ZPP_Flags.id_ArbiterType_COLLISION = 1;
-  zpp_nape.util.ZPP_Flags.id_ArbiterType_SENSOR = 2;
-  zpp_nape.util.ZPP_Flags.id_ArbiterType_FLUID = 4;
-  zpp_nape.callbacks.ZPP_Listener.internal = false;
-  zpp_nape.callbacks.ZPP_Listener.types = (function($this) {
-    var $r;
-    if (zpp_nape.util.ZPP_Flags.ListenerType_BODY == null) {
-      zpp_nape.util.ZPP_Flags.internal = true;
-      zpp_nape.util.ZPP_Flags.ListenerType_BODY = new nape67.callbacks.ListenerType();
-      zpp_nape.util.ZPP_Flags.internal = false;
-    }
-    var tmp = zpp_nape.util.ZPP_Flags.ListenerType_BODY;
-    if (zpp_nape.util.ZPP_Flags.ListenerType_CONSTRAINT == null) {
-      zpp_nape.util.ZPP_Flags.internal = true;
-      zpp_nape.util.ZPP_Flags.ListenerType_CONSTRAINT = new nape67.callbacks.ListenerType();
-      zpp_nape.util.ZPP_Flags.internal = false;
-    }
-    var tmp1 = zpp_nape.util.ZPP_Flags.ListenerType_CONSTRAINT;
-    if (zpp_nape.util.ZPP_Flags.ListenerType_INTERACTION == null) {
-      zpp_nape.util.ZPP_Flags.internal = true;
-      zpp_nape.util.ZPP_Flags.ListenerType_INTERACTION = new nape67.callbacks.ListenerType();
-      zpp_nape.util.ZPP_Flags.internal = false;
-    }
-    var tmp2 = zpp_nape.util.ZPP_Flags.ListenerType_INTERACTION;
-    if (zpp_nape.util.ZPP_Flags.ListenerType_PRE == null) {
-      zpp_nape.util.ZPP_Flags.internal = true;
-      zpp_nape.util.ZPP_Flags.ListenerType_PRE = new nape67.callbacks.ListenerType();
-      zpp_nape.util.ZPP_Flags.internal = false;
-    }
-    $r = [tmp, tmp1, tmp2, zpp_nape.util.ZPP_Flags.ListenerType_PRE];
-    return $r;
-  })(this);
-  zpp_nape.callbacks.ZPP_Listener.events = (function($this) {
-    var $r;
-    if (zpp_nape.util.ZPP_Flags.CbEvent_BEGIN == null) {
-      zpp_nape.util.ZPP_Flags.internal = true;
-      zpp_nape.util.ZPP_Flags.CbEvent_BEGIN = new nape67.callbacks.CbEvent();
-      zpp_nape.util.ZPP_Flags.internal = false;
-    }
-    var tmp = zpp_nape.util.ZPP_Flags.CbEvent_BEGIN;
-    if (zpp_nape.util.ZPP_Flags.CbEvent_END == null) {
-      zpp_nape.util.ZPP_Flags.internal = true;
-      zpp_nape.util.ZPP_Flags.CbEvent_END = new nape67.callbacks.CbEvent();
-      zpp_nape.util.ZPP_Flags.internal = false;
-    }
-    var tmp1 = zpp_nape.util.ZPP_Flags.CbEvent_END;
-    if (zpp_nape.util.ZPP_Flags.CbEvent_WAKE == null) {
-      zpp_nape.util.ZPP_Flags.internal = true;
-      zpp_nape.util.ZPP_Flags.CbEvent_WAKE = new nape67.callbacks.CbEvent();
-      zpp_nape.util.ZPP_Flags.internal = false;
-    }
-    var tmp2 = zpp_nape.util.ZPP_Flags.CbEvent_WAKE;
-    if (zpp_nape.util.ZPP_Flags.CbEvent_SLEEP == null) {
-      zpp_nape.util.ZPP_Flags.internal = true;
-      zpp_nape.util.ZPP_Flags.CbEvent_SLEEP = new nape67.callbacks.CbEvent();
-      zpp_nape.util.ZPP_Flags.internal = false;
-    }
-    var tmp3 = zpp_nape.util.ZPP_Flags.CbEvent_SLEEP;
-    if (zpp_nape.util.ZPP_Flags.CbEvent_BREAK == null) {
-      zpp_nape.util.ZPP_Flags.internal = true;
-      zpp_nape.util.ZPP_Flags.CbEvent_BREAK = new nape67.callbacks.CbEvent();
-      zpp_nape.util.ZPP_Flags.internal = false;
-    }
-    var tmp4 = zpp_nape.util.ZPP_Flags.CbEvent_BREAK;
-    if (zpp_nape.util.ZPP_Flags.CbEvent_PRE == null) {
-      zpp_nape.util.ZPP_Flags.internal = true;
-      zpp_nape.util.ZPP_Flags.CbEvent_PRE = new nape67.callbacks.CbEvent();
-      zpp_nape.util.ZPP_Flags.internal = false;
-    }
-    var tmp5 = zpp_nape.util.ZPP_Flags.CbEvent_PRE;
-    if (zpp_nape.util.ZPP_Flags.CbEvent_ONGOING == null) {
-      zpp_nape.util.ZPP_Flags.internal = true;
-      zpp_nape.util.ZPP_Flags.CbEvent_ONGOING = new nape67.callbacks.CbEvent();
-      zpp_nape.util.ZPP_Flags.internal = false;
-    }
-    $r = [
-      tmp,
-      tmp1,
-      tmp2,
-      tmp3,
-      tmp4,
-      tmp5,
-      zpp_nape.util.ZPP_Flags.CbEvent_ONGOING
-    ];
-    return $r;
-  })(this);
-  zpp_nape.callbacks.ZPP_InteractionListener.UCbSet = new zpp_nape.util.ZNPList_ZPP_CbSet();
-  zpp_nape.callbacks.ZPP_InteractionListener.VCbSet = new zpp_nape.util.ZNPList_ZPP_CbSet();
-  zpp_nape.callbacks.ZPP_InteractionListener.WCbSet = new zpp_nape.util.ZNPList_ZPP_CbSet();
-  zpp_nape.callbacks.ZPP_InteractionListener.UCbType = new zpp_nape.util.ZNPList_ZPP_CbType();
-  zpp_nape.callbacks.ZPP_InteractionListener.VCbType = new zpp_nape.util.ZNPList_ZPP_CbType();
-  zpp_nape.callbacks.ZPP_InteractionListener.WCbType = new zpp_nape.util.ZNPList_ZPP_CbType();
-  zpp_nape.dynamics.ZPP_Arbiter.internal = false;
-  zpp_nape.dynamics.ZPP_Arbiter.COL = 1;
-  zpp_nape.dynamics.ZPP_Arbiter.FLUID = 4;
-  zpp_nape.dynamics.ZPP_Arbiter.SENSOR = 2;
-  zpp_nape.dynamics.ZPP_Arbiter.types = (function($this) {
-    var $r;
-    if (zpp_nape.util.ZPP_Flags.ArbiterType_COLLISION == null) {
-      zpp_nape.util.ZPP_Flags.internal = true;
-      zpp_nape.util.ZPP_Flags.ArbiterType_COLLISION = new nape67.dynamics.ArbiterType();
-      zpp_nape.util.ZPP_Flags.internal = false;
-    }
-    var tmp = zpp_nape.util.ZPP_Flags.ArbiterType_COLLISION;
-    if (zpp_nape.util.ZPP_Flags.ArbiterType_SENSOR == null) {
-      zpp_nape.util.ZPP_Flags.internal = true;
-      zpp_nape.util.ZPP_Flags.ArbiterType_SENSOR = new nape67.dynamics.ArbiterType();
-      zpp_nape.util.ZPP_Flags.internal = false;
-    }
-    var tmp1 = zpp_nape.util.ZPP_Flags.ArbiterType_SENSOR;
-    if (zpp_nape.util.ZPP_Flags.ArbiterType_FLUID == null) {
-      zpp_nape.util.ZPP_Flags.internal = true;
-      zpp_nape.util.ZPP_Flags.ArbiterType_FLUID = new nape67.dynamics.ArbiterType();
-      zpp_nape.util.ZPP_Flags.internal = false;
-    }
-    $r = [null, tmp, tmp1, null, zpp_nape.util.ZPP_Flags.ArbiterType_FLUID];
-    return $r;
-  })(this);
-  zpp_nape.dynamics.ZPP_SensorArbiter.zpp_pool = null;
-  zpp_nape.dynamics.ZPP_FluidArbiter.zpp_pool = null;
-  zpp_nape.dynamics.ZPP_ColArbiter.FACE1 = 0;
-  zpp_nape.dynamics.ZPP_ColArbiter.FACE2 = 1;
-  zpp_nape.dynamics.ZPP_ColArbiter.CIRCLE = 2;
-  zpp_nape.dynamics.ZPP_ColArbiter.zpp_pool = null;
-  zpp_nape.dynamics.ZPP_Contact.internal = false;
-  zpp_nape.dynamics.ZPP_Contact.zpp_pool = null;
-  zpp_nape.dynamics.ZPP_InteractionFilter.zpp_pool = null;
-  zpp_nape.dynamics.ZPP_InteractionGroup.SHAPE = 1;
-  zpp_nape.dynamics.ZPP_InteractionGroup.BODY = 2;
-  zpp_nape.geom.ZPP_AABB.zpp_pool = null;
-  zpp_nape.geom.ZPP_Collide.flowpoly = new zpp_nape.util.ZNPList_ZPP_Vec2();
-  zpp_nape.geom.ZPP_Collide.flowsegs = new zpp_nape.util.ZNPList_ZPP_Vec2();
-  zpp_nape.geom.ZPP_Cutter.ints = null;
-  zpp_nape.geom.ZPP_Cutter.paths = null;
-  zpp_nape.geom.ZPP_GeomVert.zpp_pool = null;
-  zpp_nape.geom.ZPP_MarchingSquares.me = new zpp_nape.geom.ZPP_MarchingSquares();
-  zpp_nape.geom.ZPP_MarchingSquares.look_march = [
-    -1,
-    224,
-    56,
-    216,
-    14,
-    -1,
-    54,
-    214,
-    131,
-    99,
-    -1,
-    91,
-    141,
-    109,
-    181,
-    85
-  ];
-  zpp_nape.geom.ZPP_Monotone.queue = null;
-  zpp_nape.geom.ZPP_Monotone.edges = null;
-  zpp_nape.geom.ZPP_PartitionVertex.nextId = 0;
-  zpp_nape.geom.ZPP_PartitionVertex.zpp_pool = null;
-  zpp_nape.geom.ZPP_PartitionedPoly.zpp_pool = null;
-  zpp_nape.geom.ZPP_Ray.internal = false;
-  zpp_nape.geom.ZPP_SimpleVert.zpp_pool = null;
-  zpp_nape.geom.ZPP_SimpleSeg.zpp_pool = null;
-  zpp_nape.geom.ZPP_SimpleEvent.zpp_pool = null;
-  zpp_nape.geom.ZPP_Simple.sweep = null;
-  zpp_nape.geom.ZPP_Simple.inthash = null;
-  zpp_nape.geom.ZPP_Simple.vertices = null;
-  zpp_nape.geom.ZPP_Simple.queue = null;
-  zpp_nape.geom.ZPP_Simple.ints = null;
-  zpp_nape.geom.ZPP_Simple.list_vertices = null;
-  zpp_nape.geom.ZPP_Simple.list_queue = null;
-  zpp_nape.geom.ZPP_SimplifyV.zpp_pool = null;
-  zpp_nape.geom.ZPP_SimplifyP.zpp_pool = null;
-  zpp_nape.geom.ZPP_Simplify.stack = null;
-  zpp_nape.geom.ZPP_ToiEvent.zpp_pool = null;
-  zpp_nape.geom.ZPP_PartitionPair.zpp_pool = null;
-  zpp_nape.geom.ZPP_Triangular.queue = null;
-  zpp_nape.geom.ZPP_Triangular.stack = null;
-  zpp_nape.geom.ZPP_Triangular.edgeSet = null;
-  zpp_nape.geom.ZPP_Vec2.zpp_pool = null;
-  zpp_nape.phys.ZPP_Body.types = (function($this) {
-    var $r;
-    if (zpp_nape.util.ZPP_Flags.BodyType_STATIC == null) {
-      zpp_nape.util.ZPP_Flags.internal = true;
-      zpp_nape.util.ZPP_Flags.BodyType_STATIC = new nape67.phys.BodyType();
-      zpp_nape.util.ZPP_Flags.internal = false;
-    }
-    var tmp = zpp_nape.util.ZPP_Flags.BodyType_STATIC;
-    if (zpp_nape.util.ZPP_Flags.BodyType_DYNAMIC == null) {
-      zpp_nape.util.ZPP_Flags.internal = true;
-      zpp_nape.util.ZPP_Flags.BodyType_DYNAMIC = new nape67.phys.BodyType();
-      zpp_nape.util.ZPP_Flags.internal = false;
-    }
-    var tmp1 = zpp_nape.util.ZPP_Flags.BodyType_DYNAMIC;
-    if (zpp_nape.util.ZPP_Flags.BodyType_KINEMATIC == null) {
-      zpp_nape.util.ZPP_Flags.internal = true;
-      zpp_nape.util.ZPP_Flags.BodyType_KINEMATIC = new nape67.phys.BodyType();
-      zpp_nape.util.ZPP_Flags.internal = false;
-    }
-    $r = [null, tmp, tmp1, zpp_nape.util.ZPP_Flags.BodyType_KINEMATIC];
-    return $r;
-  })(this);
-  zpp_nape.phys.ZPP_Body.bodystack = null;
-  zpp_nape.phys.ZPP_Body.bodyset = null;
-  zpp_nape.phys.ZPP_Body.cur_graph_depth = 0;
-  zpp_nape.phys.ZPP_FluidProperties.zpp_pool = null;
-  zpp_nape.phys.ZPP_Material.zpp_pool = null;
-  zpp_nape.phys.ZPP_Material.WAKE = 1;
-  zpp_nape.phys.ZPP_Material.PROPS = 2;
-  zpp_nape.phys.ZPP_Material.ANGDRAG = 4;
-  zpp_nape.phys.ZPP_Material.ARBITERS = 8;
-  zpp_nape.shape.ZPP_Shape.types = (function($this) {
-    var $r;
-    if (zpp_nape.util.ZPP_Flags.ShapeType_CIRCLE == null) {
-      zpp_nape.util.ZPP_Flags.internal = true;
-      zpp_nape.util.ZPP_Flags.ShapeType_CIRCLE = new nape67.shape.ShapeType();
-      zpp_nape.util.ZPP_Flags.internal = false;
-    }
-    var tmp = zpp_nape.util.ZPP_Flags.ShapeType_CIRCLE;
-    if (zpp_nape.util.ZPP_Flags.ShapeType_POLYGON == null) {
-      zpp_nape.util.ZPP_Flags.internal = true;
-      zpp_nape.util.ZPP_Flags.ShapeType_POLYGON = new nape67.shape.ShapeType();
-      zpp_nape.util.ZPP_Flags.internal = false;
-    }
-    $r = [tmp, zpp_nape.util.ZPP_Flags.ShapeType_POLYGON];
-    return $r;
-  })(this);
-  zpp_nape.shape.ZPP_Edge.zpp_pool = null;
-  zpp_nape.shape.ZPP_Edge.internal = false;
-  zpp_nape.space.ZPP_AABBNode.zpp_pool = null;
-  zpp_nape.space.ZPP_AABBPair.zpp_pool = null;
-  zpp_nape.space.ZPP_AABBTree.tmpaabb = new zpp_nape.geom.ZPP_AABB();
-  zpp_nape.space.ZPP_DynAABBPhase.FATTEN = 3;
-  zpp_nape.space.ZPP_DynAABBPhase.VEL_STEPS = 2;
-  zpp_nape.space.ZPP_Island.zpp_pool = null;
-  zpp_nape.space.ZPP_Component.zpp_pool = null;
-  zpp_nape.space.ZPP_CallbackSet.zpp_pool = null;
-  zpp_nape.space.ZPP_SweepData.zpp_pool = null;
-  zpp_nape.util.Hashable2_Boolfalse.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_CbType.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_CallbackSet.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_Shape.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_Body.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_Constraint.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_Compound.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_Arbiter.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_InteractionListener.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_CbSet.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_Interactor.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_BodyListener.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_CbSetPair.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_ConstraintListener.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_CutInt.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_CutVert.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_PartitionVertex.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_SimplifyP.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_PartitionedPoly.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_GeomVert.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_SimpleVert.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_SimpleEvent.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_Vec2.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_AABBPair.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_Edge.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_AABBNode.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_Component.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_FluidArbiter.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_SensorArbiter.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_Listener.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_ColArbiter.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_InteractionGroup.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_ToiEvent.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ConvexResult.zpp_pool = null;
-  zpp_nape.util.ZNPNode_ZPP_GeomPoly.zpp_pool = null;
-  zpp_nape.util.ZNPNode_RayResult.zpp_pool = null;
-  zpp_nape.util.ZPP_Set_ZPP_Body.zpp_pool = null;
-  zpp_nape.util.ZPP_Set_ZPP_CbSetPair.zpp_pool = null;
-  zpp_nape.util.ZPP_Set_ZPP_PartitionVertex.zpp_pool = null;
-  zpp_nape.util.ZPP_Set_ZPP_PartitionPair.zpp_pool = null;
-  zpp_nape.util.ZPP_Set_ZPP_SimpleVert.zpp_pool = null;
-  zpp_nape.util.ZPP_Set_ZPP_SimpleSeg.zpp_pool = null;
-  zpp_nape.util.ZPP_Set_ZPP_SimpleEvent.zpp_pool = null;
-  zpp_nape.util.ZPP_Set_ZPP_CbSet.zpp_pool = null;
+  js2.Boot.__toStr = {}.toString;
+  zpp_nape.callbacks.ZPP_CbType._initEnums(nape67);
+  zpp_nape.callbacks.ZPP_Listener._initEnums(nape67, zpp_nape.util.ZPP_Flags);
+  zpp_nape.callbacks.ZPP_InteractionListener._initStatics(zpp_nape);
+  zpp_nape.dynamics.ZPP_Arbiter._initEnums(nape67, zpp_nape.util.ZPP_Flags);
+  zpp_nape.geom.ZPP_Collide._initStatics(zpp_nape);
+  zpp_nape.phys.ZPP_Body._initEnums(nape67, zpp_nape.util.ZPP_Flags);
+  zpp_nape.shape.ZPP_Shape._initEnums(nape67, zpp_nape.util.ZPP_Flags);
+  zpp_nape.space.ZPP_AABBTree._initStatics();
   sandbox.Main.main();
   nape67.__zpp = zpp_nape;
   return nape67;
@@ -69544,7 +69238,7 @@ var zpp7 = nape66.__zpp;
 zpp7.constraint.ZPP_PulleyJoint = ZPP_PulleyJoint;
 
 // src/index.ts
-var VERSION = "3.4.0";
+var VERSION = "3.4.1";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AABB,