@perplexdotgg/bounce 1.5.2 → 1.6.0

package/build/bounce.js

@@ -1,6 +1,6 @@
-import { createClass, ChildType, NumberType, LazyReferenceListType, BooleanType, LazyReferenceType, ReferenceListType, ReferenceType } from "monomorph";
+import { props, createClass, ChildType, NumberType, LazyReferenceListType, BooleanType, LazyReferenceType, ReferenceListType, ReferenceType } from "monomorph";
 const mat3Keys = ["e0", "e1", "e2", "e3", "e4", "e5", "e6", "e7", "e8"];
-const mat3Props = {
+const mat3Props = props({
   e0: 0,
   e1: 0,
   e2: 0,
@@ -10,8 +10,8 @@ const mat3Props = {
   e6: 0,
   e7: 0,
   e8: 0
-};
-class Mat3 extends createClass(mat3Props) {
+});
+class Mat3 extends createClass()(mat3Props) {
   adjointMatrix(a3) {
     let a00 = a3.e0, a01 = a3.e1, a02 = a3.e2;
     let a10 = a3.e3, a11 = a3.e4, a12 = a3.e5;
@@ -420,12 +420,12 @@ function squaredDistance(a3, b3) {
   let z = b3.z - a3.z;
   return x2 * x2 + y4 * y4 + z * z;
 }
-const vec3Props = {
+const vec3Props = props({
   x: 0,
   y: 0,
   z: 0
-};
-class Vec3 extends createClass(vec3Props) {
+});
+class Vec3 extends createClass()(vec3Props) {
   constructor(data, index, pool) {
     if (Array.isArray(data)) {
       data = {
@@ -923,24 +923,24 @@ const rb = /* @__PURE__ */ Vec3.create();
 const temp = /* @__PURE__ */ Vec3.create();
 const rotatedVector = /* @__PURE__ */ Vec3.create();
 const rotationMatrix$3 = /* @__PURE__ */ Mat3.create();
-const lineProps = {
+const lineProps = props({
   a: Vec3,
   b: Vec3
-};
-class Line extends createClass(lineProps) {
+});
+class Line extends createClass()(lineProps) {
   setFromPointAndDirection(point2, direction2, length) {
     this.a.copy(point2);
     this.b.addScaledToVector(point2, direction2, length);
   }
 }
 const quatKeys = ["x", "y", "z", "w"];
-const quatProps = {
+const quatProps = props({
   x: 0,
   y: 0,
   z: 0,
   w: 1
-};
-class Quat extends createClass(quatProps) {
+});
+class Quat extends createClass()(quatProps) {
   constructor(data, index, pool) {
     if (Array.isArray(data)) {
       if (data.length && data.length < 4) {
@@ -1160,7 +1160,7 @@ const rotationMatrix$2 = /* @__PURE__ */ Mat3.create();
 const scaling = /* @__PURE__ */ Vec3.create();
 const conjugatedRotation = /* @__PURE__ */ Quat.create();
 const rotatedTranslation = /* @__PURE__ */ Vec3.create();
-const mat4Props = {
+const mat4Props = props({
   e0: 0,
   e1: 0,
   e2: 0,
@@ -1177,8 +1177,8 @@ const mat4Props = {
   e13: 0,
   e14: 0,
   e15: 0
-};
-class Mat4 extends createClass(mat4Props) {
+});
+class Mat4 extends createClass()(mat4Props) {
   multiply3x3(out, a3) {
     const x2 = a3.x;
     const y4 = a3.y;
@@ -1730,11 +1730,11 @@ class Mat4 extends createClass(mat4Props) {
 }
 const rotation$3 = /* @__PURE__ */ Quat.create();
 const cross_bn_cn = /* @__PURE__ */ Vec3.create();
-const planeProps = {
+const planeProps = props({
   normal: Vec3,
   constant: 0
-};
-class Plane extends createClass(planeProps) {
+});
+class Plane extends createClass()(planeProps) {
   toObject() {
     return {
       normal: this.normal.toObject(),
@@ -1802,11 +1802,11 @@ class Plane extends createClass(planeProps) {
     return fraction;
   }
 }
-const segmentProps = {
+const segmentProps = props({
   pointA: Vec3,
   pointB: Vec3
-};
-class Segment extends createClass(segmentProps) {
+});
+class Segment extends createClass()(segmentProps) {
   computeCenter(out) {
     out.addVectors(this.pointA, this.pointB);
     out.scaleVector(out, 0.5);
@@ -1826,12 +1826,12 @@ const newMax = /* @__PURE__ */ Vec3.create();
 const col = /* @__PURE__ */ Vec3.create();
 const a$2 = /* @__PURE__ */ Vec3.create();
 const b$1 = /* @__PURE__ */ Vec3.create();
-const aabbProps = {
+const aabbProps = props({
   min: Vec3,
   max: Vec3,
   centroid: ChildType(Vec3, void 0, true)
-};
-class Aabb extends createClass(aabbProps) {
+});
+class Aabb extends createClass()(aabbProps) {
   computeSupport(out, direction2) {
     out.x = direction2.x < 0 ? this.min.x : this.max.x;
     out.y = direction2.y < 0 ? this.min.y : this.max.y;
@@ -2105,7 +2105,7 @@ const aabbCenter = /* @__PURE__ */ Vec3.create();
 const aabbHalfExtents = /* @__PURE__ */ Vec3.create();
 const segmentCenter = /* @__PURE__ */ Vec3.create();
 const segmentHalfExtents = /* @__PURE__ */ Vec3.create();
-const triangleProps$1 = {
+const triangleProps$1 = props({
   computedBounds: ChildType(Aabb, void 0, true),
   normal: ChildType(Vec3, void 0, true),
   a: Vec3,
@@ -2116,10 +2116,10 @@ const triangleProps$1 = {
   // aabb: { struct: Aabb, readOnly: true },
   // activeEdges: { struct: Uint32, optional: true },
   // translation: { struct: Vec3, optional: true },
-};
+});
 const ab$5 = /* @__PURE__ */ Vec3.create();
 const ac$3 = /* @__PURE__ */ Vec3.create();
-let Triangle$1 = class Triangle extends createClass(triangleProps$1) {
+let Triangle$1 = class Triangle extends createClass()(triangleProps$1) {
   // type: ShapeType.triangle = ShapeType.triangle;
   computeNormal(out) {
     ab$5.subtractVectors(this.b, this.a);
@@ -2192,13 +2192,13 @@ let Triangle$1 = class Triangle extends createClass(triangleProps$1) {
     out.transform(centerOfMassTransform2);
   }
 };
-const faceProps = {
+const faceProps = props({
   numVertices: 0,
   buffer: LazyReferenceListType(() => Vec3)
-};
+});
 const triangle$1 = /* @__PURE__ */ Triangle$1.create();
 const tempVertex = /* @__PURE__ */ Vec3.create();
-class Face extends createClass(faceProps) {
+class Face extends createClass()(faceProps) {
   clear() {
     this.numVertices = 0;
   }
@@ -2294,7 +2294,7 @@ var ConstraintType = /* @__PURE__ */ ((ConstraintType2) => {
   ConstraintType2[ConstraintType2["hingeConstraint"] = 3] = "hingeConstraint";
   return ConstraintType2;
 })(ConstraintType || {});
-const baseConstraintProps = {
+const baseConstraintProps = props({
   // unless we use require here, this file will be imported after it is needed
   bodyA: LazyReferenceType((() => Body)),
   bodyB: LazyReferenceType((() => Body)),
@@ -2304,10 +2304,10 @@ const baseConstraintProps = {
     /* local */
   ),
   isEnabled: BooleanType(true)
-};
+});
 const localToWorldTransformA$1 = /* @__PURE__ */ Mat4.create();
 const point$1 = /* @__PURE__ */ Vec3.create();
-const contactManifoldProps = {
+const contactManifoldProps = props({
   // meta data
   bodyA: LazyReferenceType((() => Body)),
   bodyB: LazyReferenceType((() => Body)),
@@ -2323,8 +2323,8 @@ const contactManifoldProps = {
   contactPointsA: ReferenceListType(Vec3),
   contactPointsB: ReferenceListType(Vec3),
   lambdas: ReferenceListType(Vec3)
-};
-class ContactManifold extends createClass(contactManifoldProps) {
+});
+class ContactManifold extends createClass()(contactManifoldProps) {
   get maxContacts() {
     return this.contactPointsA.maxLength;
   }
@@ -2444,21 +2444,21 @@ class ContactManifoldPool {
     return manifold;
   }
 }
-const contactPairProps = {
+const contactPairProps = props({
   bodyA: LazyReferenceType((() => Body)),
   bodyB: LazyReferenceType((() => Body)),
   firstContactManifold: ReferenceType(ContactManifold),
   translationAB: Vec3,
   rotationAB: Quat
-};
-class ContactPair extends createClass(contactPairProps) {
+});
+class ContactPair extends createClass()(contactPairProps) {
   get key() {
     return createContactPairKey(this.bodyA, this.bodyB);
   }
 }
 function createContactPairKey(bodyA, bodyB) {
-  const keyA = `${bodyA.type}:${bodyA.index}`;
-  const keyB = `${bodyB.type}:${bodyB.index}`;
+  const keyA = `${bodyA.type}:${bodyA.poolIndex}`;
+  const keyB = `${bodyB.type}:${bodyB.poolIndex}`;
   return keyA < keyB ? `${keyA}|${keyB}` : `${keyB}|${keyA}`;
 }
 const linearVelocityA = /* @__PURE__ */ Vec3.create();
@@ -2468,7 +2468,7 @@ const angularVelocityA = /* @__PURE__ */ Vec3.create();
 const angularVelocityB = /* @__PURE__ */ Vec3.create();
 const inverseInertiaA$2 = /* @__PURE__ */ Mat3.create();
 const inverseInertiaB$2 = /* @__PURE__ */ Mat3.create();
-const directionalConstraintProps = {
+const directionalConstraintProps = props({
   mR1PlusUxAxis: Vec3,
   mR2xAxis: Vec3,
   mInvI1_R1PlusUxAxis: Vec3,
@@ -2477,10 +2477,8 @@ const directionalConstraintProps = {
   bias: 0,
   softness: 0,
   totalLambda: 0
-};
-class DirectionalConstraint extends createClass(
-  directionalConstraintProps
-) {
+});
+class DirectionalConstraint extends createClass()(directionalConstraintProps) {
   isSpringActive() {
     return this.softness !== 0;
   }
@@ -2610,16 +2608,14 @@ class DirectionalConstraint extends createClass(
     }
   }
 }
-const contactConstraintProps = {
+const contactConstraintProps = props({
   normalConstraint: DirectionalConstraint,
   tangentConstraint: DirectionalConstraint,
   bitangentConstraint: DirectionalConstraint,
   localPositionA: Vec3,
   localPositionB: Vec3
-};
-class ContactConstraint extends createClass(
-  contactConstraintProps
-) {
+});
+class ContactConstraint extends createClass()(contactConstraintProps) {
   getLambda(out, index) {
     out.x = this.normalConstraint.totalLambda;
     out.y = this.tangentConstraint.totalLambda;
@@ -2641,7 +2637,7 @@ class ContactConstraint extends createClass(
     this.normalConstraint.warmStart(bodyA, bodyB, inverseMassA, inverseMassB, normal4);
   }
 }
-const manifoldConstraintProps = {
+const manifoldConstraintProps = props({
   bodyA: LazyReferenceType((() => Body)),
   bodyB: LazyReferenceType((() => Body)),
   subShapeIdA: 0,
@@ -2655,10 +2651,8 @@ const manifoldConstraintProps = {
   inverseMassB: 0,
   contactConstraints: ReferenceListType(ContactConstraint),
   numContacts: 0
-};
-class ManifoldConstraint extends createClass(
-  manifoldConstraintProps
-) {
+});
+class ManifoldConstraint extends createClass()(manifoldConstraintProps) {
   updateTangentDirections() {
     this.worldSpaceTangent.computeNormalizedPerpendicular(this.worldSpaceNormal);
     this.worldSpaceBitangent.crossVectors(this.worldSpaceNormal, this.worldSpaceTangent);
@@ -2758,14 +2752,14 @@ function computeClosestPowersOfTwo(n2) {
   const next = 1 << Math.ceil(Math.log2(n2));
   return { previous, next };
 }
-const isometryProps = {
+const isometryProps = props({
   matrix: Mat4
-};
+});
 const tempTranslation = /* @__PURE__ */ Vec3.create();
 const tempRotation = /* @__PURE__ */ Quat.create();
 const rotation$2 = /* @__PURE__ */ Mat3.create();
 const inverseMatrix = /* @__PURE__ */ Mat4.create();
-class Isometry extends createClass(isometryProps) {
+class Isometry extends createClass()(isometryProps) {
   fromRotationAndTranslation(rotation2, translation) {
     if (rotation2) {
       tempRotation.copy(rotation2);
@@ -2839,12 +2833,12 @@ class ArrayPool {
       return null;
     }
     const instance = this.array[this._count];
-    instance.index = this._count;
+    instance.poolIndex = this._count;
     this._count++;
     return instance;
   }
   remove(instance) {
-    const index = instance.index;
+    const index = instance.poolIndex;
     const lastIndex = this._count - 1;
     if (index === lastIndex) {
       this._count--;
@@ -2852,8 +2846,8 @@ class ArrayPool {
     }
     this.array[index] = this.array[lastIndex];
     this.array[lastIndex] = instance;
-    this.array[index].index = index;
-    this.array[lastIndex].index = lastIndex;
+    this.array[index].poolIndex = index;
+    this.array[lastIndex].poolIndex = lastIndex;
     this._count--;
   }
   clear() {
@@ -3313,11 +3307,11 @@ class TransformedConvexObject {
     out.transformFromMat4(this.transform.matrix);
   }
 }
-const transformedConvexShapeProps = {
+const transformedConvexShapeProps = props({
   transform: Isometry
-};
+});
 const direction = /* @__PURE__ */ Vec3.create();
-class TransformedConvexShape extends createClass(
+class TransformedConvexShape extends createClass()(
   transformedConvexShapeProps
 ) {
   constructor() {
@@ -3331,12 +3325,10 @@ class TransformedConvexShape extends createClass(
     out.transformByMat4(this.transform.matrix);
   }
 }
-const convexRadiusObjectProps = {
+const convexRadiusObjectProps = props({
   radius: 0
-};
-class ConvexRadiusObject extends createClass(
-  convexRadiusObjectProps
-) {
+});
+class ConvexRadiusObject extends createClass()(convexRadiusObjectProps) {
   constructor() {
     super();
     this.convexShape = null;
@@ -3383,10 +3375,10 @@ var ShapeType = /* @__PURE__ */ ((ShapeType2) => {
   ShapeType2[ShapeType2["triangleMesh"] = 7] = "triangleMesh";
   return ShapeType2;
 })(ShapeType || {});
-const sphereNoConvexProps = {
+const sphereNoConvexProps = props({
   radius: 0
-};
-class SphereNoConvex extends createClass(sphereNoConvexProps) {
+});
+class SphereNoConvex extends createClass()(sphereNoConvexProps) {
   getConvexRadius() {
     return this.radius;
   }
@@ -3394,10 +3386,10 @@ class SphereNoConvex extends createClass(sphereNoConvexProps) {
     out.zero();
   }
 }
-const sphereWithConvexProps = {
+const sphereWithConvexProps = props({
   radius: 0
-};
-class SphereWithConvex extends createClass(sphereWithConvexProps) {
+});
+class SphereWithConvex extends createClass()(sphereWithConvexProps) {
   getConvexRadius() {
     return 0;
   }
@@ -3410,7 +3402,7 @@ class SphereWithConvex extends createClass(sphereWithConvexProps) {
     }
   }
 }
-const sphereProps = {
+const sphereProps = props({
   computedCenterOfMass: ChildType(Vec3, void 0, true),
   computedVolume: NumberType(0, true),
   computedAabb: ChildType(Aabb, void 0, true),
@@ -3418,11 +3410,11 @@ const sphereProps = {
   copyForDiff: LazyReferenceType((() => Sphere)),
   sphereNoConvex: ChildType(SphereNoConvex, void 0, true),
   sphereWithConvex: ChildType(SphereWithConvex, void 0, true)
-};
+});
 const afterConstructorCode$a = `
   this.world = null;
 `;
-class Sphere extends createClass(sphereProps, { afterConstructorCode: afterConstructorCode$a }) {
+class Sphere extends createClass({ afterConstructorCode: afterConstructorCode$a })(sphereProps) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.sphere;
@@ -3518,12 +3510,12 @@ const isometry$8 = /* @__PURE__ */ Isometry.create();
 const absLocalSurfacePosition = /* @__PURE__ */ Vec3.create();
 const tempVector$4 = /* @__PURE__ */ Vec3.create();
 const defaultConvexRadius = 0.05;
-const boxSupportProps = {
+const boxSupportProps = props({
   convexRadius: 0,
   // TODO: cannot used undefined default for this, possibly due to it being used as a deeply nested prop
   computedAabb: ChildType(Aabb, {}, true)
-};
-class BoxSupport extends createClass(boxSupportProps) {
+});
+class BoxSupport extends createClass()(boxSupportProps) {
   computeSupport(out, direction2) {
     this.computedAabb.computeSupport(out, direction2);
   }
@@ -3531,7 +3523,7 @@ class BoxSupport extends createClass(boxSupportProps) {
     return this.convexRadius;
   }
 }
-const boxProps = {
+const boxProps = props({
   computedCenterOfMass: ChildType(Vec3, void 0, true),
   computedVolume: NumberType(0, true),
   computedAabb: ChildType(Aabb, void 0, true),
@@ -3541,11 +3533,11 @@ const boxProps = {
   depth: 0,
   boxSupport: ChildType(BoxSupport, void 0, true),
   copyForDiff: LazyReferenceType((() => Box))
-};
+});
 const afterConstructorCode$9 = `
   this.world = null;
 `;
-class Box extends createClass(boxProps, { afterConstructorCode: afterConstructorCode$9 }) {
+class Box extends createClass({ afterConstructorCode: afterConstructorCode$9 })(boxProps) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.box;
@@ -3662,23 +3654,23 @@ function updateShape$6(shape) {
   updateVolume$4(shape);
   updateLocalBounds$6(shape);
 }
-const bodyPairNodeProps = {
+const bodyPairNodeProps = props({
   bodyA: LazyReferenceType((() => Body)),
   bodyB: LazyReferenceType((() => Body)),
   edgeA: LazyReferenceType((() => BodyPairEdge)),
   edgeB: LazyReferenceType((() => BodyPairEdge))
-};
-class BodyPairNode extends createClass(bodyPairNodeProps) {
+});
+class BodyPairNode extends createClass()(bodyPairNodeProps) {
   containsStaticBody() {
     return this.bodyA.type === BodyType.static || this.bodyB.type === BodyType.static;
   }
 }
-const bodyPairEdgeProps = {
+const bodyPairEdgeProps = props({
   node: LazyReferenceType((() => BodyPairNode)),
   next: LazyReferenceType((() => BodyPairEdge)),
   prev: LazyReferenceType((() => BodyPairEdge))
-};
-class BodyPairEdge extends createClass(bodyPairEdgeProps) {
+});
+class BodyPairEdge extends createClass()(bodyPairEdgeProps) {
 }
 class BodyPairsModule {
   constructor(bodyPool, nodesPool, edgesPool) {
@@ -3743,7 +3735,7 @@ class BodyPairsModule {
    * @returns
    */
   createPair(bodyA, bodyB) {
-    if (bodyA.type === bodyB.type && bodyA.index > bodyB.index) {
+    if (bodyA.type === bodyB.type && bodyA.poolIndex > bodyB.poolIndex) {
       const temp2 = bodyA;
       bodyA = bodyB;
       bodyB = temp2;
@@ -3917,12 +3909,12 @@ class BodyPairsModule {
     }
   }
 }
-const rayProps = {
+const rayProps = props({
   origin: Vec3,
   direction: Vec3,
   length: 0
-};
-class Ray extends createClass(rayProps) {
+});
+class Ray extends createClass()(rayProps) {
   intersectsAabb(aabb) {
     return aabb.intersectsRay(this);
   }
@@ -4036,15 +4028,15 @@ const ray$4 = /* @__PURE__ */ Ray.create();
 const halfExtents$2 = /* @__PURE__ */ Vec3.create();
 const nodeBounds$1 = /* @__PURE__ */ Aabb.create();
 const bodyBounds$1 = /* @__PURE__ */ Aabb.create();
-const bvhNodeProps$1 = {
+const bvhNodeProps$1 = props({
   parent: LazyReferenceType((() => BvhNode)),
   left: LazyReferenceType((() => BvhNode)),
   right: LazyReferenceType((() => BvhNode)),
   computedBounds: ChildType(Aabb, void 0, true),
   height: 0,
   objects: LazyReferenceListType((() => Body))
-};
-class BvhNode extends createClass(bvhNodeProps$1) {
+});
+class BvhNode extends createClass()(bvhNodeProps$1) {
   // objects: Body[] = [];
   isLeaf() {
     return this.left === null && this.right === null;
@@ -4568,20 +4560,20 @@ class BvhTree {
     }
   }
 }
-const basicTransformProps = {
+const basicTransformProps = props({
   position: Vec3,
   rotation: Quat,
   scale: 1
-};
-class BasicTransform extends createClass(basicTransformProps) {
+});
+class BasicTransform extends createClass()(basicTransformProps) {
   equals(other, tolerance = 1e-6) {
     return this.position.equals(other.position, tolerance) && this.rotation.equals(other.rotation, tolerance) && Math.abs(this.scale - other.scale) < tolerance;
   }
 }
-const numberValueProps = {
+const numberValueProps = props({
   value: 0
-};
-class NumberValue extends createClass(numberValueProps) {
+});
+class NumberValue extends createClass()(numberValueProps) {
   toObject() {
     return {
       value: this.value
@@ -4643,12 +4635,12 @@ class ConvexHullWithConvex {
     throw new Error("Method not implemented.");
   }
 }
-const convexHullPointProps = {
+const convexHullPointProps = props({
   position: Vec3,
   numFaces: 0,
   faces: Vec3
-};
-class ConvexHullPoint extends createClass(convexHullPointProps) {
+});
+class ConvexHullPoint extends createClass()(convexHullPointProps) {
   toObject() {
     return {
       position: this.position.toObject(),
@@ -4657,11 +4649,11 @@ class ConvexHullPoint extends createClass(convexHullPointProps) {
     };
   }
 }
-const convexHullFaceProps = {
+const convexHullFaceProps = props({
   firstVertex: 0,
   numVertices: 0
-};
-class ConvexHullFace extends createClass(convexHullFaceProps) {
+});
+class ConvexHullFace extends createClass()(convexHullFaceProps) {
   toObject() {
     return {
       firstVertex: this.firstVertex,
@@ -4669,7 +4661,7 @@ class ConvexHullFace extends createClass(convexHullFaceProps) {
     };
   }
 }
-const convexHullProps = {
+const convexHullProps = props({
   computedCenterOfMass: ChildType(Vec3, void 0, true),
   computedVolume: NumberType(0, true),
   computedAabb: ChildType(Aabb, void 0, true),
@@ -4688,14 +4680,14 @@ const convexHullProps = {
   // { array: Float64Array(f), itemMaxCount: f / 3, itemSize: 3 } [Vec3], transformed points used by ConvexHullNoConvex
   translation: ChildType(Vec3, { x: 0, y: 0, z: 0 }),
   copyForDiff: LazyReferenceType((() => ConvexHull))
-};
+});
 const afterConstructorCode$8 = `
-this.world = null;
-this.shapeNoConvex = null;
-this.shapeWithConvex = null;
-this.type = ${ShapeType.convexHull};
+  this.world = null;
+  this.shapeNoConvex = null;
+  this.shapeWithConvex = null;
+  this.type = ${ShapeType.convexHull};
 `;
-class ConvexHull extends createClass(convexHullProps, { afterConstructorCode: afterConstructorCode$8 }) {
+class ConvexHull extends createClass({ afterConstructorCode: afterConstructorCode$8 })(convexHullProps) {
   computeSupportShape(inMode, inScale) {
     if (this.convexRadius === 0) {
       this.shapeWithConvex.shape = this;
@@ -4880,14 +4872,12 @@ const vertex = /* @__PURE__ */ Vec3.create();
 const multiplier = /* @__PURE__ */ Vec3.create();
 const transform$1 = /* @__PURE__ */ Mat4.create();
 const isometry$6 = /* @__PURE__ */ Isometry.create();
-const cylinderSupportShapeProps = {
+const cylinderSupportShapeProps = props({
   halfHeight: 0,
   radius: 0,
   convexRadius: 0
-};
-class CylinderSupportShape extends createClass(
-  cylinderSupportShapeProps
-) {
+});
+class CylinderSupportShape extends createClass()(cylinderSupportShapeProps) {
   getConvexRadius() {
     return this.convexRadius;
   }
@@ -4910,7 +4900,7 @@ class CylinderSupportShape extends createClass(
     throw new Error("Method not implemented.");
   }
 }
-const cylinderProps = {
+const cylinderProps = props({
   computedCenterOfMass: ChildType(Vec3, void 0, true),
   computedVolume: NumberType(0, true),
   computedAabb: ChildType(Aabb, void 0, true),
@@ -4920,11 +4910,11 @@ const cylinderProps = {
   translation: ChildType(Vec3, void 0, true),
   supportShape: ChildType(CylinderSupportShape, void 0, true),
   copyForDiff: LazyReferenceType((() => Cylinder))
-};
+});
 const afterConstructorCode$7 = `
   this.world = null;
 `;
-class Cylinder extends createClass(cylinderProps, { afterConstructorCode: afterConstructorCode$7 }) {
+class Cylinder extends createClass({ afterConstructorCode: afterConstructorCode$7 })(cylinderProps) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.cylinder;
@@ -5080,11 +5070,11 @@ const support = /* @__PURE__ */ Vec3.create();
 const supportTop = /* @__PURE__ */ Vec3.create();
 const negatedScaledHalfHeightOfCylinder = /* @__PURE__ */ Vec3.create();
 const supportBottom = /* @__PURE__ */ Vec3.create();
-const capsuleNoConvexProps = {
+const capsuleNoConvexProps = props({
   halfHeightOfCylinder: Vec3,
   convexRadius: 0
-};
-class CapsuleNoConvex extends createClass(capsuleNoConvexProps) {
+});
+class CapsuleNoConvex extends createClass()(capsuleNoConvexProps) {
   computeSupport(out, direction2) {
     if (direction2.y > 0) {
       out.copy(this.halfHeightOfCylinder);
@@ -5099,13 +5089,11 @@ class CapsuleNoConvex extends createClass(capsuleNoConvexProps) {
     throw new Error("Method not implemented.");
   }
 }
-const capsuleWithConvexProps = {
+const capsuleWithConvexProps = props({
   halfHeightOfCylinder: Vec3,
   radius: 0
-};
-class CapsuleWithConvex extends createClass(
-  capsuleWithConvexProps
-) {
+});
+class CapsuleWithConvex extends createClass()(capsuleWithConvexProps) {
   computeSupport(out, direction2) {
     const len = direction2.length();
     if (len > 0) {
@@ -5126,7 +5114,7 @@ class CapsuleWithConvex extends createClass(
     throw new Error("Method not implemented.");
   }
 }
-const capsuleProps = {
+const capsuleProps = props({
   computedCenterOfMass: ChildType(Vec3, void 0, true),
   computedVolume: NumberType(0, true),
   computedAabb: ChildType(Aabb, void 0, true),
@@ -5135,11 +5123,11 @@ const capsuleProps = {
   copyForDiff: LazyReferenceType((() => Capsule)),
   capsuleNoConvex: ChildType(CapsuleNoConvex, void 0, true),
   capsuleWithConvex: ChildType(CapsuleWithConvex, void 0, true)
-};
+});
 const afterConstructorCode$6 = `
   this.world = null;
 `;
-class Capsule extends createClass(capsuleProps, { afterConstructorCode: afterConstructorCode$6 }) {
+class Capsule extends createClass({ afterConstructorCode: afterConstructorCode$6 })(capsuleProps) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.capsule;
@@ -5284,7 +5272,7 @@ function updateShape$3(shape) {
   updateVolume$2(shape);
   updateLocalBounds$3(shape);
 }
-const transformedShapeProps = {
+const transformedShapeProps = props({
   shapeType: NumberType(ShapeType.box),
   // we need to do "as 'shape' ..." otherwise they are just 'string' and not the actual specific keys
   ["shape" + ShapeType.box]: ReferenceType(Box, void 0, true),
@@ -5296,14 +5284,11 @@ const transformedShapeProps = {
   ["shape" + ShapeType.sphere]: ReferenceType(Sphere, void 0, true),
   // triangleMesh not supported
   transform: BasicTransform
-};
+});
 const afterConstructorCode$5 = `
   this.world = null;
 `;
-class TransformedShape extends createClass(
-  transformedShapeProps,
-  { afterConstructorCode: afterConstructorCode$5 }
-) {
+class TransformedShape extends createClass({ afterConstructorCode: afterConstructorCode$5 })(transformedShapeProps) {
   get shape() {
     return this["shape" + this.shapeType];
   }
@@ -5325,18 +5310,18 @@ const transformedCenterOfMass = /* @__PURE__ */ Vec3.create();
 const transformSubshapeToCompound = /* @__PURE__ */ Isometry.create();
 const subShapeDirection = /* @__PURE__ */ Vec3.create();
 const subShapeToWorld = /* @__PURE__ */ Isometry.create();
-const compoundShapeProps = {
+const compoundShapeProps = props({
   computedCenterOfMass: ChildType(Vec3, {}, true),
   computedVolume: NumberType(0, true),
   computedAabb: ChildType(Aabb, {}, true),
   copyForDiff: LazyReferenceType((() => CompoundShape)),
   shapes: ReferenceListType(TransformedShape)
-};
+});
 const afterConstructorCode$4 = `
   this.world = null;
 `;
 const tempTransform = /* @__PURE__ */ BasicTransform.create();
-class CompoundShape extends createClass(compoundShapeProps, { afterConstructorCode: afterConstructorCode$4 }) {
+class CompoundShape extends createClass({ afterConstructorCode: afterConstructorCode$4 })(compoundShapeProps) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.compoundShape;
@@ -5540,7 +5525,7 @@ const d = /* @__PURE__ */ Vec3.create();
 const scale$1 = /* @__PURE__ */ Vec3.create();
 const blockAabb = /* @__PURE__ */ Aabb.create();
 const normal$1 = /* @__PURE__ */ Vec3.create();
-const heightMapProps = {
+const heightMapProps = props({
   computedCenterOfMass: ChildType(Vec3, void 0, true),
   computedVolume: NumberType(0, true),
   computedAabb: ChildType(Aabb, {}, true),
@@ -5553,18 +5538,18 @@ const heightMapProps = {
   // maxHeights: PoolReferenceType(Vec1),
   // levels: PoolReferenceType(Vec1),
   // activeEdges: PoolReferenceType(Vec1),
-};
+});
 const afterConstructorCode$3 = `
-this.world = null;
-this.heights = [];
-this.minHeights = [];
-this.maxHeights = [];
-this.levels = [];
-this.activeEdges = [];
-this.stack = [];
-this.children = [0, 0, 0, 0];
+  this.world = null;
+  this.heights = [];
+  this.minHeights = [];
+  this.maxHeights = [];
+  this.levels = [];
+  this.activeEdges = [];
+  this.stack = [];
+  this.children = [0, 0, 0, 0];
 `;
-class HeightMap extends createClass(heightMapProps, { afterConstructorCode: afterConstructorCode$3 }) {
+class HeightMap extends createClass({ afterConstructorCode: afterConstructorCode$3 })(heightMapProps) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.heightMap;
@@ -5691,8 +5676,8 @@ class HeightMap extends createClass(heightMapProps, { afterConstructorCode: afte
     }
   }
   /**
-  * this function visits every block and triangle of the heightMap. take care when using it on high resolution heightMaps. it is intended to generate a debug visualization of the heightMap.
-  */
+   * this function visits every block and triangle of the heightMap. take care when using it on high resolution heightMaps. it is intended to generate a debug visualization of the heightMap.
+   */
   createTriangulatedVerticesAndNormalsArray() {
     const vertices = [];
     const normals = [];
@@ -5795,15 +5780,15 @@ function updateShape$1(shape) {
   updateVolume(shape);
   updateLocalBounds$1(shape);
 }
-const bvhNodeProps = {
+const bvhNodeProps = props({
   parent: LazyReferenceType((() => TriangleMeshBvhNode)),
   left: LazyReferenceType((() => TriangleMeshBvhNode)),
   right: LazyReferenceType((() => TriangleMeshBvhNode)),
   computedBounds: ChildType(Aabb, void 0, true),
   depth: NumberType(0, true),
   objects: LazyReferenceListType((() => Triangle$1))
-};
-class TriangleMeshBvhNode extends createClass(bvhNodeProps) {
+});
+class TriangleMeshBvhNode extends createClass()(bvhNodeProps) {
   /**
    * if bvh node is an internal node, this will be an empty list
    * if bvh node is a leaf node, this will contain refs to the objects in the leaf
@@ -5858,12 +5843,10 @@ function splitObjects(objects) {
   const rightObjects = objects.slice(mid);
   return [leftObjects, rightObjects];
 }
-const triangleMeshBvhTreeProps = {
+const triangleMeshBvhTreeProps = props({
   nodes: ReferenceListType(TriangleMeshBvhNode)
-};
-class TriangleMeshBvhTree extends createClass(
-  triangleMeshBvhTreeProps
-) {
+});
+class TriangleMeshBvhTree extends createClass()(triangleMeshBvhTreeProps) {
   constructor() {
     super(...arguments);
     this.intersectStack = [];
@@ -6058,7 +6041,7 @@ const halfExtents$1 = /* @__PURE__ */ Vec3.create();
 const nodeBounds = /* @__PURE__ */ Aabb.create();
 const bodyBounds = /* @__PURE__ */ Aabb.create();
 const isometry$2 = /* @__PURE__ */ Isometry.create();
-const triangleMeshProps = {
+const triangleMeshProps = props({
   computedCenterOfMass: ChildType(Vec3, void 0, true),
   computedVolume: NumberType(0, true),
   computedAabb: ChildType(Aabb, void 0, true),
@@ -6069,11 +6052,11 @@ const triangleMeshProps = {
   triangles: ReferenceListType(Triangle$1),
   copyForDiff: LazyReferenceType((() => TriangleMesh)),
   bvh: LazyReferenceType((() => TriangleMeshBvhTree))
-};
+});
 const afterConstructorCode$2 = `
   this.world = null;
 `;
-class TriangleMesh extends createClass(triangleMeshProps, { afterConstructorCode: afterConstructorCode$2 }) {
+class TriangleMesh extends createClass({ afterConstructorCode: afterConstructorCode$2 })(triangleMeshProps) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.triangleMesh;
@@ -6161,7 +6144,7 @@ function updateShape(shape) {
   updateCopyForDiff(shape);
   updateLocalBounds(shape);
 }
-const constraintOptionsProps = {
+const constraintOptionsProps = props({
   /**
    * Value used to scale the amount of position error to correct per solve iteration. Expected to be in the interval [0, 1]
    */
@@ -6174,12 +6157,10 @@ const constraintOptionsProps = {
    * Value used to scale the strength of the constraint. recommend to tune in the interval of [0, 1], with 0 being no correction, 1 being full correction
    */
   strength: 1
-};
-class ConstraintOptions extends createClass(
-  constraintOptionsProps
-) {
+});
+class ConstraintOptions extends createClass()(constraintOptionsProps) {
 }
-const pointConstraintComponentProps = {
+const pointConstraintComponentProps = props({
   bodyA: LazyReferenceType((() => Body)),
   bodyB: LazyReferenceType((() => Body)),
   options: ChildType(ConstraintOptions, {
@@ -6193,8 +6174,8 @@ const pointConstraintComponentProps = {
   effectiveInverseInertiaA: ChildType(Mat3, void 0, true),
   effectiveInverseInertiaB: ChildType(Mat3, void 0, true),
   totalLambda: ChildType(Vec3, void 0, true)
-};
-class PointConstraintComponent extends createClass(pointConstraintComponentProps) {
+});
+class PointConstraintComponent extends createClass()(pointConstraintComponentProps) {
   deactivate() {
     this.effectiveMass.zero();
     this.totalLambda.zero();
@@ -6303,15 +6284,15 @@ const lambda$2 = /* @__PURE__ */ Vec3.create();
 const transformWorldToLocalA$2 = /* @__PURE__ */ Isometry.create();
 const transformWorldToLocalB$2 = /* @__PURE__ */ Isometry.create();
 const transformLocalToWorld$3 = /* @__PURE__ */ Mat4.create();
-const pointConstraintProps = {
+const pointConstraintProps = props({
   ...baseConstraintProps,
   positionA: Vec3,
   positionB: Vec3,
   localPositionA: ChildType(Vec3, void 0, true),
   localPositionB: ChildType(Vec3, void 0, true),
   translationComponent: PointConstraintComponent
-};
-class PointConstraint extends createClass(pointConstraintProps) {
+});
+class PointConstraint extends createClass()(pointConstraintProps) {
   constructor() {
     super(...arguments);
     this.type = ConstraintType.pointConstraint;
@@ -6380,7 +6361,7 @@ PointConstraint.create = function() {
   constraint.world.sleepModule.wakeBodyUp(constraint.bodyB);
   return constraint;
 };
-const rotationEulerComponentProps = {
+const rotationEulerComponentProps = props({
   bodyA: LazyReferenceType((() => Body)),
   bodyB: LazyReferenceType((() => Body)),
   options: ChildType(ConstraintOptions, {
@@ -6392,10 +6373,8 @@ const rotationEulerComponentProps = {
   mInvI2: ChildType(Mat3, void 0, true),
   effectiveMassRotationComponent: ChildType(Mat3, void 0, true),
   totalLambdaRotationComponent: ChildType(Vec3, void 0, true)
-};
-class RotationEulerComponent extends createClass(
-  rotationEulerComponentProps
-) {
+});
+class RotationEulerComponent extends createClass()(rotationEulerComponentProps) {
   deactivate() {
     this.effectiveMassRotationComponent.zero();
     this.totalLambdaRotationComponent.zero();
@@ -6487,7 +6466,7 @@ const anchor = /* @__PURE__ */ Vec3.create();
 const transformWorldToLocalA$1 = /* @__PURE__ */ Mat4.create();
 const transformWorldToLocalB$1 = /* @__PURE__ */ Mat4.create();
 const inverseRotationB = /* @__PURE__ */ Quat.create();
-const fixedConstraintProps = {
+const fixedConstraintProps = props({
   ...baseConstraintProps,
   positionA: ChildType(Vec3),
   positionB: ChildType(Vec3),
@@ -6506,8 +6485,8 @@ const fixedConstraintProps = {
   inverseInitialRotationAToB: ChildType(Quat, void 0, true),
   translationComponent: PointConstraintComponent,
   rotationComponent: RotationEulerComponent
-};
-class FixedConstraint extends createClass(fixedConstraintProps) {
+});
+class FixedConstraint extends createClass()(fixedConstraintProps) {
   constructor() {
     super(...arguments);
     this.type = ConstraintType.fixedConstraint;
@@ -6640,7 +6619,7 @@ var SpringMode = /* @__PURE__ */ ((SpringMode2) => {
   SpringMode2[SpringMode2["UseStiffness"] = 1] = "UseStiffness";
   return SpringMode2;
 })(SpringMode || {});
-const springProps = {
+const springProps = props({
   mode: NumberType(
     0
     /* UseFrequency */
@@ -6648,8 +6627,8 @@ const springProps = {
   damping: 0,
   frequency: 0,
   stiffness: 0
-};
-class Spring extends createClass(springProps) {
+});
+class Spring extends createClass()(springProps) {
   hasStiffness() {
     return this.frequency > 0;
   }
@@ -6657,11 +6636,11 @@ class Spring extends createClass(springProps) {
     return this.frequency >= 0 && this.damping >= 0 && this.stiffness >= 0;
   }
 }
-const springComponentProps = {
+const springComponentProps = props({
   bias: 0,
   softness: 0
-};
-class SpringComponent extends createClass(springComponentProps) {
+});
+class SpringComponent extends createClass()(springComponentProps) {
   getBias(lambda2) {
     return this.softness * lambda2 + this.bias;
   }
@@ -6703,7 +6682,7 @@ const inverseInertiaA$1 = /* @__PURE__ */ Mat3.create();
 const inverseInertiaB$1 = /* @__PURE__ */ Mat3.create();
 const linearImpulse = /* @__PURE__ */ Vec3.create();
 const angularImpulse = /* @__PURE__ */ Vec3.create();
-const axisComponentProps = {
+const axisComponentProps = props({
   bodyA: LazyReferenceType((() => Body)),
   bodyB: LazyReferenceType((() => Body)),
   options: ChildType(ConstraintOptions, {
@@ -6718,8 +6697,8 @@ const axisComponentProps = {
   effectiveMass: 0,
   totalLambda: 0,
   springComponent: SpringComponent
-};
-class AxisComponent extends createClass(axisComponentProps) {
+});
+class AxisComponent extends createClass()(axisComponentProps) {
   deactivate() {
     this.effectiveMass = 0;
     this.totalLambda = 0;
@@ -6874,7 +6853,7 @@ const localToWorldTransformB = /* @__PURE__ */ Mat4.create();
 const armA = /* @__PURE__ */ Vec3.create();
 const armB = /* @__PURE__ */ Vec3.create();
 const vectorAB$5 = /* @__PURE__ */ Vec3.create();
-const distanceConstraintProps = {
+const distanceConstraintProps = props({
   ...baseConstraintProps,
   positionA: ChildType(Vec3, { x: 0, y: 0, z: 0 }),
   positionB: ChildType(Vec3, { x: 0, y: 0, z: 0 }),
@@ -6889,8 +6868,8 @@ const distanceConstraintProps = {
   worldNormal: ChildType(Vec3, void 0, true),
   minLambda: NumberType(0, true),
   maxLambda: NumberType(0, true)
-};
-class DistanceConstraint extends createClass(distanceConstraintProps) {
+});
+class DistanceConstraint extends createClass()(distanceConstraintProps) {
   constructor() {
     super(...arguments);
     this.type = ConstraintType.distanceConstraint;
@@ -7037,7 +7016,7 @@ var MotorMode = /* @__PURE__ */ ((MotorMode2) => {
   MotorMode2[MotorMode2["Velocity"] = 2] = "Velocity";
   return MotorMode2;
 })(MotorMode || {});
-const motorProps = {
+const motorProps = props({
   spring: ChildType(Spring, { mode: SpringMode.UseFrequency, damping: 1, frequency: 2, stiffness: 2 }),
   minForce: NumberType(-Infinity),
   maxForce: NumberType(Infinity),
@@ -7047,8 +7026,8 @@ const motorProps = {
     0
     /* Off */
   )
-};
-class Motor extends createClass(motorProps) {
+});
+class Motor extends createClass()(motorProps) {
   isValid() {
     return this.spring.isValid() && this.minForce <= this.maxForce && this.minTorque <= this.maxTorque;
   }
@@ -7060,7 +7039,7 @@ const perpendicular$1 = /* @__PURE__ */ Vec3.create();
 const summedInverseInertia = /* @__PURE__ */ Mat3.create();
 const massBA = /* @__PURE__ */ Vec3.create();
 const massCA = /* @__PURE__ */ Vec3.create();
-const hingeComponentProps = {
+const hingeComponentProps = props({
   bodyA: LazyReferenceType((() => Body)),
   bodyB: LazyReferenceType((() => Body)),
   options: ChildType(ConstraintOptions, {
@@ -7081,7 +7060,7 @@ const hingeComponentProps = {
   inverseInertiaB: ChildType(Mat3, void 0, true),
   totalLambdaA: NumberType(0, true),
   totalLambdaB: NumberType(0, true)
-};
+});
 function getOrthogonalVector(out, a3) {
   if (Math.abs(a3.x) > Math.abs(a3.y)) {
     out.fromArray([a3.z, 0, -a3.x]);
@@ -7089,7 +7068,7 @@ function getOrthogonalVector(out, a3) {
     out.fromArray([0, a3.z, -a3.y]);
   }
 }
-class HingeComponent extends createClass(hingeComponentProps) {
+class HingeComponent extends createClass()(hingeComponentProps) {
   deactivate() {
     this.effectiveMass00 = 0;
     this.effectiveMass01 = 0;
@@ -7207,7 +7186,7 @@ class HingeComponent extends createClass(hingeComponentProps) {
 const spinBA = /* @__PURE__ */ Vec3.create();
 const deltaSpin$1 = /* @__PURE__ */ Vec3.create();
 const inverseEffectiveMass = /* @__PURE__ */ Vec3.create();
-const angleComponentProps = {
+const angleComponentProps = props({
   bodyA: LazyReferenceType((() => Body)),
   bodyB: LazyReferenceType((() => Body)),
   options: ChildType(ConstraintOptions, {
@@ -7220,8 +7199,8 @@ const angleComponentProps = {
   effectiveInverseInertiaA: ChildType(Vec3, void 0, true),
   effectiveInverseInertiaB: ChildType(Vec3, void 0, true),
   totalLambda: NumberType(0, true)
-};
-class AngleComponent extends createClass(angleComponentProps) {
+});
+class AngleComponent extends createClass()(angleComponentProps) {
   deactivate() {
     this.effectiveMass = 0;
     this.totalLambda = 0;
@@ -7374,7 +7353,7 @@ const rotateLocalToWorldB = /* @__PURE__ */ Mat3.create();
 const worldHingeA = /* @__PURE__ */ Vec3.create();
 const worldHingeB = /* @__PURE__ */ Vec3.create();
 const transformLocalToWorld = /* @__PURE__ */ Mat4.create();
-const hingeConstraintProps = {
+const hingeConstraintProps = props({
   ...baseConstraintProps,
   // init data
   pointA: ChildType(Vec3, { x: 0, y: 0, z: 0 }),
@@ -7406,8 +7385,8 @@ const hingeConstraintProps = {
   rotationConstraintPart: HingeComponent,
   rotationLimitsConstraintPart: AngleComponent,
   motorConstraintPart: AngleComponent
-};
-class HingeConstraint extends createClass(hingeConstraintProps) {
+});
+class HingeConstraint extends createClass()(hingeConstraintProps) {
   constructor() {
     super(...arguments);
     this.type = ConstraintType.hingeConstraint;
@@ -7710,7 +7689,7 @@ HingeConstraint.create = function() {
   constraint.world.sleepModule.wakeBodyUp(constraint.bodyB);
   return constraint;
 };
-const constraintPairNodeProps = {
+const constraintPairNodeProps = props({
   bodyA: LazyReferenceType((() => Body)),
   bodyB: LazyReferenceType((() => Body)),
   edgeA: LazyReferenceType((() => ConstraintPairEdge)),
@@ -7720,14 +7699,13 @@ const constraintPairNodeProps = {
   constraintFixed: LazyReferenceType((() => FixedConstraint)),
   constraintDistance: LazyReferenceType((() => DistanceConstraint)),
   constraintHinge: LazyReferenceType((() => HingeConstraint))
-};
+});
 const afterConstructorCode$1 = `
   this.world = null;
   this.constraints = [null, null, null, null];
 `;
-class ConstraintPairNode extends createClass(
-  constraintPairNodeProps,
-  { afterConstructorCode: afterConstructorCode$1 }
+class ConstraintPairNode extends createClass({ afterConstructorCode: afterConstructorCode$1 })(
+  constraintPairNodeProps
 ) {
   containsStaticBody() {
     return this.bodyA.type === BodyType.static || this.bodyB.type === BodyType.static;
@@ -7745,14 +7723,12 @@ class ConstraintPairNode extends createClass(
     this.constraintType = value.type;
   }
 }
-const constraintPairEdgeProps = {
+const constraintPairEdgeProps = props({
   node: LazyReferenceType((() => ConstraintPairNode)),
   next: LazyReferenceType((() => ConstraintPairEdge)),
   prev: LazyReferenceType((() => ConstraintPairEdge))
-};
-class ConstraintPairEdge extends createClass(
-  constraintPairEdgeProps
-) {
+});
+class ConstraintPairEdge extends createClass()(constraintPairEdgeProps) {
 }
 class ConstraintPairsModule {
   constructor(constraintPairNodePool, constraintPairEdgePool) {
@@ -7993,7 +7969,7 @@ var ColliderType = /* @__PURE__ */ ((ColliderType2) => {
   ColliderType2[ColliderType2["attractor"] = 3] = "attractor";
   return ColliderType2;
 })(ColliderType || {});
-const bodyProps = {
+const bodyProps = props({
   type: NumberType(
     0
     /* dynamic */
@@ -8043,15 +8019,13 @@ const bodyProps = {
   isSleepingEnabled: BooleanType(true),
   linearDamping: -1,
   angularDamping: -1,
-  firstPotentialConstraintPairEdge: LazyReferenceType(
-    (() => ConstraintPairEdge)
-  ),
+  firstPotentialConstraintPairEdge: LazyReferenceType((() => ConstraintPairEdge)),
   visitGeneration: NumberType(0, true)
-};
+});
 const afterConstructorCode = `
   this.world = null;
 `;
-class Body extends createClass(bodyProps, { afterConstructorCode }) {
+class Body extends createClass({ afterConstructorCode })(bodyProps) {
   get shape() {
     return this["shape" + this.shapeType];
   }
@@ -8406,7 +8380,7 @@ function updateBody(body2, updateBroadphase = true) {
     body2.markBodyAsDirty();
   }
 }
-const castResultProps = {
+const castResultProps = props({
   status: NumberType(
     2
     /* Indeterminate */
@@ -8430,8 +8404,8 @@ const castResultProps = {
   faceB: Face,
   fraction: 0,
   isBackFaceHit: BooleanType(false)
-};
-class CastResult extends createClass(castResultProps) {
+});
+class CastResult extends createClass()(castResultProps) {
   /**
    * swaps the A and B data
    */
@@ -8507,21 +8481,21 @@ function computeBarycentricCoordinates2d(outBarycentric, a3, b3, squaredToleranc
   }
   outBarycentric.isValid = true;
 }
-const closestPointResultProps = {
+const closestPointResultProps = props({
   point: Vec3,
   pointSet: 0
-};
-class ClosestPointResult extends createClass(
-  closestPointResultProps
-) {
+});
+class ClosestPointResult extends createClass()(closestPointResultProps) {
 }
-const barycentricCoordinatesResultProps = {
+const barycentricCoordinatesResultProps = props({
   u: 0,
   v: 0,
   w: 0,
   isValid: BooleanType(false)
-};
-class BarycentricCoordinatesResult extends createClass(barycentricCoordinatesResultProps) {
+});
+class BarycentricCoordinatesResult extends createClass()(
+  barycentricCoordinatesResultProps
+) {
 }
 const ab$3 = /* @__PURE__ */ Vec3.create();
 const ac$2 = /* @__PURE__ */ Vec3.create();
@@ -8732,13 +8706,13 @@ function computeClosestPointOnTriangle(outClosestPoint, inA, inB, inC, mustInclu
   tempVector$2.addVectors(tempVector$2, c);
   outClosestPoint.point.scaleVector(n$1, tempVector$2.dot(n$1) / (3 * normalLengthSquared));
 }
-const vec4Props = {
+const vec4Props = props({
   x: 0,
   y: 0,
   z: 0,
   w: 0
-};
-class Vec4 extends createClass(vec4Props) {
+});
+class Vec4 extends createClass()(vec4Props) {
 }
 const ab$1 = /* @__PURE__ */ Vec3.create();
 const ac = /* @__PURE__ */ Vec3.create();
@@ -8840,32 +8814,30 @@ function computeClosestPointOnTetrahedron(result2, inA, inB, inC, inD, mustInclu
     }
   }
 }
-const closestPointToSimplexProps = {
+const closestPointToSimplexProps = props({
   point: Vec3,
   squaredDistance: 0,
   pointSet: 0,
   closestPointFound: BooleanType(false)
-};
-class ClosestPointToSimplex extends createClass(
-  closestPointToSimplexProps
-) {
+});
+class ClosestPointToSimplex extends createClass()(closestPointToSimplexProps) {
 }
-const gjkClosestPointsProps = {
+const gjkClosestPointsProps = props({
   squaredDistance: 0,
   penetrationAxis: Vec3,
   pointA: Vec3,
   pointB: Vec3
-};
-class GjkClosestPoints extends createClass(gjkClosestPointsProps) {
+});
+class GjkClosestPoints extends createClass()(gjkClosestPointsProps) {
 }
-const gjkCastShapeResultProps = {
+const gjkCastShapeResultProps = props({
   isHitFound: false,
   lambda: 1,
   separatingAxis: Vec3,
   pointA: Vec3,
   pointB: Vec3
-};
-class GjkCastShapeResult extends createClass(gjkCastShapeResultProps) {
+});
+class GjkCastShapeResult extends createClass()(gjkCastShapeResultProps) {
 }
 const transformedConvexObject = /* @__PURE__ */ new TransformedConvexObject();
 const y0 = /* @__PURE__ */ Vec3.create();
@@ -9354,7 +9326,7 @@ var CollisionStatus = /* @__PURE__ */ ((CollisionStatus2) => {
   CollisionStatus2[CollisionStatus2["Indeterminate"] = 2] = "Indeterminate";
   return CollisionStatus2;
 })(CollisionStatus || {});
-const collisionResultProps = {
+const collisionResultProps = props({
   status: NumberType(
     2
     /* Indeterminate */
@@ -9376,8 +9348,8 @@ const collisionResultProps = {
   isBackFace: BooleanType(false),
   faceA: Face,
   faceB: Face
-};
-class CollisionResult extends createClass(collisionResultProps) {
+});
+class CollisionResult extends createClass()(collisionResultProps) {
   /**
    * swaps the A and B data
    */
@@ -9436,15 +9408,15 @@ var BackFaceMode = /* @__PURE__ */ ((BackFaceMode2) => {
   BackFaceMode2[BackFaceMode2["CollideWithBackFaces"] = 1] = "CollideWithBackFaces";
   return BackFaceMode2;
 })(BackFaceMode || {});
-const edgeProps = {
+const edgeProps = props({
   neighbourTriangle: LazyReferenceType((() => Triangle2)),
   neighbourEdge: 0,
   startIndex: 0
-};
-class Edge extends createClass(edgeProps) {
+});
+class Edge extends createClass()(edgeProps) {
   //
 }
-const triangleProps = {
+const triangleProps = props({
   edge0: Edge,
   edge1: Edge,
   edge2: Edge,
@@ -9458,7 +9430,7 @@ const triangleProps = {
   removed: BooleanType(false),
   inQueue: BooleanType(false),
   iteration: 0
-};
+});
 const vectorAB$4 = /* @__PURE__ */ Vec3.create();
 const y10 = /* @__PURE__ */ Vec3.create();
 const y20 = /* @__PURE__ */ Vec3.create();
@@ -9537,7 +9509,7 @@ function initTriangle(m, inIdx0, inIdx1, inIdx2, inPositions, minTriangleArea, b
     }
   }
 }
-class Triangle2 extends createClass(triangleProps) {
+class Triangle2 extends createClass()(triangleProps) {
   isFacing(inPosition) {
     vectorAB$4.subtractVectors(inPosition, this.centroid);
     return this.normal.dot(vectorAB$4) > 0;
@@ -10047,15 +10019,13 @@ const p10 = /* @__PURE__ */ Vec3.create();
 const p12 = /* @__PURE__ */ Vec3.create();
 const q10 = /* @__PURE__ */ Vec3.create();
 const q12 = /* @__PURE__ */ Vec3.create();
-const penetrationDepthProps = {
+const penetrationDepthProps = props({
   status: 0,
   penetrationAxis: Vec3,
   pointA: Vec3,
   pointB: Vec3
-};
-class PenetrationDepth extends createClass(
-  penetrationDepthProps
-) {
+});
+class PenetrationDepth extends createClass()(penetrationDepthProps) {
 }
 const transformed_a = /* @__PURE__ */ new TransformedConvexObject();
 const closest = /* @__PURE__ */ GjkClosestPoints.create();
@@ -11320,13 +11290,15 @@ class CollideShapesModule {
     );
   }
 }
-const estimateCollisionResponseResultProps = {
+const estimateCollisionResponseResultProps = props({
   deltaLinearVelocityA: Vec3,
   deltaAngularVelocityA: Vec3,
   deltaLinearVelocityB: Vec3,
   deltaAngularVelocityB: Vec3
-};
-class EstimateCollisionResponseResult extends createClass(estimateCollisionResponseResultProps) {
+});
+class EstimateCollisionResponseResult extends createClass()(
+  estimateCollisionResponseResultProps
+) {
 }
 function estimateCollisionResponse(result2, manifold, timeStepSizeSeconds) {
   result2.reset();
@@ -11993,11 +11965,11 @@ class ManifoldCache {
 const contactPairCacheMaxDeltaPositionSquared = squared(1e-3);
 const contactPairCacheCosMaxDeltaRotationDiv2 = Math.cos(degreesToRadians(2) / 2);
 const negatedPenetrationAxis = /* @__PURE__ */ Vec3.create();
-const vec3BufferProps = {
+const vec3BufferProps = props({
   numItems: 0,
   vec3List: ReferenceListType(Vec3)
-};
-class Vec3Buffer extends createClass(vec3BufferProps) {
+});
+class Vec3Buffer extends createClass()(vec3BufferProps) {
   getVec3(out, index) {
     out.copy(this.vec3List.getAtIndex(index));
   }
@@ -12500,10 +12472,10 @@ class BvhModule {
     startOffset = this.world.pools.bvhNodes.toArray(array, startOffset);
     startOffset = this.world.pools.bodyPairNode.toArray(array, startOffset);
     startOffset = this.world.pools.bodyPairEdge.toArray(array, startOffset);
-    array[startOffset++] = this.dynamicTree.root?.index ?? -1;
-    array[startOffset++] = this.dynamicTree.root?.version ?? -1;
-    array[startOffset++] = this.staticTree.root?.index ?? -1;
-    array[startOffset++] = this.staticTree.root?.version ?? -1;
+    array[startOffset++] = this.dynamicTree.root?.poolIndex ?? -1;
+    array[startOffset++] = this.dynamicTree.root?.poolVersion ?? -1;
+    array[startOffset++] = this.staticTree.root?.poolIndex ?? -1;
+    array[startOffset++] = this.staticTree.root?.poolVersion ?? -1;
     return startOffset;
   }
   fromArray(array, startOffset) {
@@ -12531,21 +12503,21 @@ class BvhModule {
       edgeA: this.world.pools.bodyPairEdge,
       edgeB: this.world.pools.bodyPairEdge
     }, startOffsetBodyPairNode);
-    const dynamicTreeRootIndex = array[startOffset++];
-    const dynamicTreeRootVersion = array[startOffset++];
-    const staticTreeRootIndex = array[startOffset++];
-    const staticTreeRootVersion = array[startOffset++];
-    if (dynamicTreeRootIndex >= 0) {
-      this.dynamicTree.root = this.world.pools.bvhNodes.array[dynamicTreeRootIndex];
-      if (dynamicTreeRootVersion !== this.dynamicTree.root.version) {
+    const dynamicTreeRootPoolIndex = array[startOffset++];
+    const dynamicTreeRootPoolVersion = array[startOffset++];
+    const staticTreeRootPoolIndex = array[startOffset++];
+    const staticTreeRootPoolVersion = array[startOffset++];
+    if (dynamicTreeRootPoolIndex >= 0) {
+      this.dynamicTree.root = this.world.pools.bvhNodes.array[dynamicTreeRootPoolIndex];
+      if (dynamicTreeRootPoolVersion !== this.dynamicTree.root.poolVersion) {
         this.dynamicTree.root = null;
       }
     } else {
       this.dynamicTree.root = null;
     }
-    if (staticTreeRootIndex >= 0) {
-      this.staticTree.root = this.world.pools.bvhNodes.array[staticTreeRootIndex];
-      if (staticTreeRootVersion !== this.staticTree.root.version) {
+    if (staticTreeRootPoolIndex >= 0) {
+      this.staticTree.root = this.world.pools.bvhNodes.array[staticTreeRootPoolIndex];
+      if (staticTreeRootPoolVersion !== this.staticTree.root.poolVersion) {
         this.staticTree.root = null;
       }
     } else {
@@ -15273,7 +15245,7 @@ class World {
         if (bodyA === bodyB) {
           continue;
         }
-        if (bodyA.index > bodyB.index) {
+        if (bodyA.poolIndex > bodyB.poolIndex) {
           continue;
         }
         yield [bodyA, bodyB];
@@ -15294,7 +15266,7 @@ class World {
         if (bodyA === bodyB) {
           continue;
         }
-        if (bodyA.index > bodyB.index) {
+        if (bodyA.poolIndex > bodyB.poolIndex) {
           continue;
         }
         if (bodyA.computedBounds.intersectsAabb(bodyB.computedBounds) === false) {