@perplexdotgg/bounce 1.5.0 → 1.5.2

package/build/bounce.js

@@ -1,6 +1,6 @@
-import { props, createClass, ChildType, NumberType, LazyReferenceListType, BooleanType, LazyReferenceType, ReferenceListType, ReferenceType } from "monomorph";
+import { createClass, ChildType, NumberType, LazyReferenceListType, BooleanType, LazyReferenceType, ReferenceListType, ReferenceType } from "monomorph";
 const mat3Keys = ["e0", "e1", "e2", "e3", "e4", "e5", "e6", "e7", "e8"];
-const mat3Props = props({
+const mat3Props = {
   e0: 0,
   e1: 0,
   e2: 0,
@@ -10,8 +10,8 @@ const mat3Props = props({
   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 = props({
+const vec3Props = {
   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 = props({
+const lineProps = {
   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 = props({
+const quatProps = {
   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 = props({
+const mat4Props = {
   e0: 0,
   e1: 0,
   e2: 0,
@@ -1177,8 +1177,8 @@ const mat4Props = props({
   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 = props({
+const planeProps = {
   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 = props({
+const segmentProps = {
   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 = props({
+const aabbProps = {
   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 = props({
+const triangleProps$1 = {
   computedBounds: ChildType(Aabb, void 0, true),
   normal: ChildType(Vec3, void 0, true),
   a: Vec3,
@@ -2116,10 +2116,10 @@ const triangleProps$1 = props({
   // 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 = props({
+const faceProps = {
   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 = props({
+const baseConstraintProps = {
   // 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 = props({
     /* local */
   ),
   isEnabled: BooleanType(true)
-});
+};
 const localToWorldTransformA$1 = /* @__PURE__ */ Mat4.create();
 const point$1 = /* @__PURE__ */ Vec3.create();
-const contactManifoldProps = props({
+const contactManifoldProps = {
   // meta data
   bodyA: LazyReferenceType((() => Body)),
   bodyB: LazyReferenceType((() => Body)),
@@ -2323,8 +2323,8 @@ const contactManifoldProps = props({
   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,14 +2444,14 @@ class ContactManifoldPool {
     return manifold;
   }
 }
-const contactPairProps = props({
+const contactPairProps = {
   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);
   }
@@ -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 = props({
+const directionalConstraintProps = {
   mR1PlusUxAxis: Vec3,
   mR2xAxis: Vec3,
   mInvI1_R1PlusUxAxis: Vec3,
@@ -2477,8 +2477,10 @@ const directionalConstraintProps = props({
   bias: 0,
   softness: 0,
   totalLambda: 0
-});
-class DirectionalConstraint extends createClass()(directionalConstraintProps) {
+};
+class DirectionalConstraint extends createClass(
+  directionalConstraintProps
+) {
   isSpringActive() {
     return this.softness !== 0;
   }
@@ -2608,14 +2610,16 @@ class DirectionalConstraint extends createClass()(directionalConstraintProps) {
     }
   }
 }
-const contactConstraintProps = props({
+const contactConstraintProps = {
   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;
@@ -2637,7 +2641,7 @@ class ContactConstraint extends createClass()(contactConstraintProps) {
     this.normalConstraint.warmStart(bodyA, bodyB, inverseMassA, inverseMassB, normal4);
   }
 }
-const manifoldConstraintProps = props({
+const manifoldConstraintProps = {
   bodyA: LazyReferenceType((() => Body)),
   bodyB: LazyReferenceType((() => Body)),
   subShapeIdA: 0,
@@ -2651,8 +2655,10 @@ const manifoldConstraintProps = props({
   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);
@@ -2752,14 +2758,14 @@ function computeClosestPowersOfTwo(n2) {
   const next = 1 << Math.ceil(Math.log2(n2));
   return { previous, next };
 }
-const isometryProps = props({
+const isometryProps = {
   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);
@@ -3307,11 +3313,11 @@ class TransformedConvexObject {
     out.transformFromMat4(this.transform.matrix);
   }
 }
-const transformedConvexShapeProps = props({
+const transformedConvexShapeProps = {
   transform: Isometry
-});
+};
 const direction = /* @__PURE__ */ Vec3.create();
-class TransformedConvexShape extends createClass()(
+class TransformedConvexShape extends createClass(
   transformedConvexShapeProps
 ) {
   constructor() {
@@ -3325,10 +3331,12 @@ class TransformedConvexShape extends createClass()(
     out.transformByMat4(this.transform.matrix);
   }
 }
-const convexRadiusObjectProps = props({
+const convexRadiusObjectProps = {
   radius: 0
-});
-class ConvexRadiusObject extends createClass()(convexRadiusObjectProps) {
+};
+class ConvexRadiusObject extends createClass(
+  convexRadiusObjectProps
+) {
   constructor() {
     super();
     this.convexShape = null;
@@ -3375,10 +3383,10 @@ var ShapeType = /* @__PURE__ */ ((ShapeType2) => {
   ShapeType2[ShapeType2["triangleMesh"] = 7] = "triangleMesh";
   return ShapeType2;
 })(ShapeType || {});
-const sphereNoConvexProps = props({
+const sphereNoConvexProps = {
   radius: 0
-});
-class SphereNoConvex extends createClass()(sphereNoConvexProps) {
+};
+class SphereNoConvex extends createClass(sphereNoConvexProps) {
   getConvexRadius() {
     return this.radius;
   }
@@ -3386,10 +3394,10 @@ class SphereNoConvex extends createClass()(sphereNoConvexProps) {
     out.zero();
   }
 }
-const sphereWithConvexProps = props({
+const sphereWithConvexProps = {
   radius: 0
-});
-class SphereWithConvex extends createClass()(sphereWithConvexProps) {
+};
+class SphereWithConvex extends createClass(sphereWithConvexProps) {
   getConvexRadius() {
     return 0;
   }
@@ -3402,7 +3410,7 @@ class SphereWithConvex extends createClass()(sphereWithConvexProps) {
     }
   }
 }
-const sphereProps = props({
+const sphereProps = {
   computedCenterOfMass: ChildType(Vec3, void 0, true),
   computedVolume: NumberType(0, true),
   computedAabb: ChildType(Aabb, void 0, true),
@@ -3410,11 +3418,11 @@ const sphereProps = props({
   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({ afterConstructorCode: afterConstructorCode$a })(sphereProps) {
+class Sphere extends createClass(sphereProps, { afterConstructorCode: afterConstructorCode$a }) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.sphere;
@@ -3510,12 +3518,12 @@ const isometry$8 = /* @__PURE__ */ Isometry.create();
 const absLocalSurfacePosition = /* @__PURE__ */ Vec3.create();
 const tempVector$4 = /* @__PURE__ */ Vec3.create();
 const defaultConvexRadius = 0.05;
-const boxSupportProps = props({
+const boxSupportProps = {
   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);
   }
@@ -3523,7 +3531,7 @@ class BoxSupport extends createClass()(boxSupportProps) {
     return this.convexRadius;
   }
 }
-const boxProps = props({
+const boxProps = {
   computedCenterOfMass: ChildType(Vec3, void 0, true),
   computedVolume: NumberType(0, true),
   computedAabb: ChildType(Aabb, void 0, true),
@@ -3533,11 +3541,11 @@ const boxProps = props({
   depth: 0,
   boxSupport: ChildType(BoxSupport, void 0, true),
   copyForDiff: LazyReferenceType((() => Box))
-});
+};
 const afterConstructorCode$9 = `
   this.world = null;
 `;
-class Box extends createClass({ afterConstructorCode: afterConstructorCode$9 })(boxProps) {
+class Box extends createClass(boxProps, { afterConstructorCode: afterConstructorCode$9 }) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.box;
@@ -3654,23 +3662,23 @@ function updateShape$6(shape) {
   updateVolume$4(shape);
   updateLocalBounds$6(shape);
 }
-const bodyPairNodeProps = props({
+const bodyPairNodeProps = {
   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 = props({
+const bodyPairEdgeProps = {
   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) {
@@ -3909,12 +3917,12 @@ class BodyPairsModule {
     }
   }
 }
-const rayProps = props({
+const rayProps = {
   origin: Vec3,
   direction: Vec3,
   length: 0
-});
-class Ray extends createClass()(rayProps) {
+};
+class Ray extends createClass(rayProps) {
   intersectsAabb(aabb) {
     return aabb.intersectsRay(this);
   }
@@ -4028,15 +4036,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 = props({
+const bvhNodeProps$1 = {
   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;
@@ -4560,20 +4568,20 @@ class BvhTree {
     }
   }
 }
-const basicTransformProps = props({
+const basicTransformProps = {
   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 = props({
+const numberValueProps = {
   value: 0
-});
-class NumberValue extends createClass()(numberValueProps) {
+};
+class NumberValue extends createClass(numberValueProps) {
   toObject() {
     return {
       value: this.value
@@ -4635,12 +4643,12 @@ class ConvexHullWithConvex {
     throw new Error("Method not implemented.");
   }
 }
-const convexHullPointProps = props({
+const convexHullPointProps = {
   position: Vec3,
   numFaces: 0,
   faces: Vec3
-});
-class ConvexHullPoint extends createClass()(convexHullPointProps) {
+};
+class ConvexHullPoint extends createClass(convexHullPointProps) {
   toObject() {
     return {
       position: this.position.toObject(),
@@ -4649,11 +4657,11 @@ class ConvexHullPoint extends createClass()(convexHullPointProps) {
     };
   }
 }
-const convexHullFaceProps = props({
+const convexHullFaceProps = {
   firstVertex: 0,
   numVertices: 0
-});
-class ConvexHullFace extends createClass()(convexHullFaceProps) {
+};
+class ConvexHullFace extends createClass(convexHullFaceProps) {
   toObject() {
     return {
       firstVertex: this.firstVertex,
@@ -4661,7 +4669,7 @@ class ConvexHullFace extends createClass()(convexHullFaceProps) {
     };
   }
 }
-const convexHullProps = props({
+const convexHullProps = {
   computedCenterOfMass: ChildType(Vec3, void 0, true),
   computedVolume: NumberType(0, true),
   computedAabb: ChildType(Aabb, void 0, true),
@@ -4680,14 +4688,14 @@ const convexHullProps = props({
   // { 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({ afterConstructorCode: afterConstructorCode$8 })(convexHullProps) {
+class ConvexHull extends createClass(convexHullProps, { afterConstructorCode: afterConstructorCode$8 }) {
   computeSupportShape(inMode, inScale) {
     if (this.convexRadius === 0) {
       this.shapeWithConvex.shape = this;
@@ -4872,12 +4880,14 @@ const vertex = /* @__PURE__ */ Vec3.create();
 const multiplier = /* @__PURE__ */ Vec3.create();
 const transform$1 = /* @__PURE__ */ Mat4.create();
 const isometry$6 = /* @__PURE__ */ Isometry.create();
-const cylinderSupportShapeProps = props({
+const cylinderSupportShapeProps = {
   halfHeight: 0,
   radius: 0,
   convexRadius: 0
-});
-class CylinderSupportShape extends createClass()(cylinderSupportShapeProps) {
+};
+class CylinderSupportShape extends createClass(
+  cylinderSupportShapeProps
+) {
   getConvexRadius() {
     return this.convexRadius;
   }
@@ -4900,7 +4910,7 @@ class CylinderSupportShape extends createClass()(cylinderSupportShapeProps) {
     throw new Error("Method not implemented.");
   }
 }
-const cylinderProps = props({
+const cylinderProps = {
   computedCenterOfMass: ChildType(Vec3, void 0, true),
   computedVolume: NumberType(0, true),
   computedAabb: ChildType(Aabb, void 0, true),
@@ -4910,11 +4920,11 @@ const cylinderProps = props({
   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({ afterConstructorCode: afterConstructorCode$7 })(cylinderProps) {
+class Cylinder extends createClass(cylinderProps, { afterConstructorCode: afterConstructorCode$7 }) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.cylinder;
@@ -5070,11 +5080,11 @@ const support = /* @__PURE__ */ Vec3.create();
 const supportTop = /* @__PURE__ */ Vec3.create();
 const negatedScaledHalfHeightOfCylinder = /* @__PURE__ */ Vec3.create();
 const supportBottom = /* @__PURE__ */ Vec3.create();
-const capsuleNoConvexProps = props({
+const capsuleNoConvexProps = {
   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);
@@ -5089,11 +5099,13 @@ class CapsuleNoConvex extends createClass()(capsuleNoConvexProps) {
     throw new Error("Method not implemented.");
   }
 }
-const capsuleWithConvexProps = props({
+const capsuleWithConvexProps = {
   halfHeightOfCylinder: Vec3,
   radius: 0
-});
-class CapsuleWithConvex extends createClass()(capsuleWithConvexProps) {
+};
+class CapsuleWithConvex extends createClass(
+  capsuleWithConvexProps
+) {
   computeSupport(out, direction2) {
     const len = direction2.length();
     if (len > 0) {
@@ -5114,7 +5126,7 @@ class CapsuleWithConvex extends createClass()(capsuleWithConvexProps) {
     throw new Error("Method not implemented.");
   }
 }
-const capsuleProps = props({
+const capsuleProps = {
   computedCenterOfMass: ChildType(Vec3, void 0, true),
   computedVolume: NumberType(0, true),
   computedAabb: ChildType(Aabb, void 0, true),
@@ -5123,11 +5135,11 @@ const capsuleProps = props({
   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({ afterConstructorCode: afterConstructorCode$6 })(capsuleProps) {
+class Capsule extends createClass(capsuleProps, { afterConstructorCode: afterConstructorCode$6 }) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.capsule;
@@ -5272,7 +5284,7 @@ function updateShape$3(shape) {
   updateVolume$2(shape);
   updateLocalBounds$3(shape);
 }
-const transformedShapeProps = props({
+const transformedShapeProps = {
   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),
@@ -5284,11 +5296,14 @@ const transformedShapeProps = props({
   ["shape" + ShapeType.sphere]: ReferenceType(Sphere, void 0, true),
   // triangleMesh not supported
   transform: BasicTransform
-});
+};
 const afterConstructorCode$5 = `
   this.world = null;
 `;
-class TransformedShape extends createClass({ afterConstructorCode: afterConstructorCode$5 })(transformedShapeProps) {
+class TransformedShape extends createClass(
+  transformedShapeProps,
+  { afterConstructorCode: afterConstructorCode$5 }
+) {
   get shape() {
     return this["shape" + this.shapeType];
   }
@@ -5310,18 +5325,18 @@ const transformedCenterOfMass = /* @__PURE__ */ Vec3.create();
 const transformSubshapeToCompound = /* @__PURE__ */ Isometry.create();
 const subShapeDirection = /* @__PURE__ */ Vec3.create();
 const subShapeToWorld = /* @__PURE__ */ Isometry.create();
-const compoundShapeProps = props({
+const compoundShapeProps = {
   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({ afterConstructorCode: afterConstructorCode$4 })(compoundShapeProps) {
+class CompoundShape extends createClass(compoundShapeProps, { afterConstructorCode: afterConstructorCode$4 }) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.compoundShape;
@@ -5525,7 +5540,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 = props({
+const heightMapProps = {
   computedCenterOfMass: ChildType(Vec3, void 0, true),
   computedVolume: NumberType(0, true),
   computedAabb: ChildType(Aabb, {}, true),
@@ -5538,18 +5553,18 @@ const heightMapProps = props({
   // 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({ afterConstructorCode: afterConstructorCode$3 })(heightMapProps) {
+class HeightMap extends createClass(heightMapProps, { afterConstructorCode: afterConstructorCode$3 }) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.heightMap;
@@ -5676,8 +5691,8 @@ class HeightMap extends createClass({ afterConstructorCode: afterConstructorCode
     }
   }
   /**
-   * 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 = [];
@@ -5780,15 +5795,15 @@ function updateShape$1(shape) {
   updateVolume(shape);
   updateLocalBounds$1(shape);
 }
-const bvhNodeProps = props({
+const bvhNodeProps = {
   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
@@ -5843,10 +5858,12 @@ function splitObjects(objects) {
   const rightObjects = objects.slice(mid);
   return [leftObjects, rightObjects];
 }
-const triangleMeshBvhTreeProps = props({
+const triangleMeshBvhTreeProps = {
   nodes: ReferenceListType(TriangleMeshBvhNode)
-});
-class TriangleMeshBvhTree extends createClass()(triangleMeshBvhTreeProps) {
+};
+class TriangleMeshBvhTree extends createClass(
+  triangleMeshBvhTreeProps
+) {
   constructor() {
     super(...arguments);
     this.intersectStack = [];
@@ -6041,7 +6058,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 = props({
+const triangleMeshProps = {
   computedCenterOfMass: ChildType(Vec3, void 0, true),
   computedVolume: NumberType(0, true),
   computedAabb: ChildType(Aabb, void 0, true),
@@ -6052,11 +6069,11 @@ const triangleMeshProps = props({
   triangles: ReferenceListType(Triangle$1),
   copyForDiff: LazyReferenceType((() => TriangleMesh)),
   bvh: LazyReferenceType((() => TriangleMeshBvhTree))
-});
+};
 const afterConstructorCode$2 = `
   this.world = null;
 `;
-class TriangleMesh extends createClass({ afterConstructorCode: afterConstructorCode$2 })(triangleMeshProps) {
+class TriangleMesh extends createClass(triangleMeshProps, { afterConstructorCode: afterConstructorCode$2 }) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.triangleMesh;
@@ -6144,7 +6161,7 @@ function updateShape(shape) {
   updateCopyForDiff(shape);
   updateLocalBounds(shape);
 }
-const constraintOptionsProps = props({
+const constraintOptionsProps = {
   /**
    * Value used to scale the amount of position error to correct per solve iteration. Expected to be in the interval [0, 1]
    */
@@ -6157,10 +6174,12 @@ const constraintOptionsProps = props({
    * 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 = props({
+const pointConstraintComponentProps = {
   bodyA: LazyReferenceType((() => Body)),
   bodyB: LazyReferenceType((() => Body)),
   options: ChildType(ConstraintOptions, {
@@ -6174,8 +6193,8 @@ const pointConstraintComponentProps = props({
   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();
@@ -6284,15 +6303,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 = props({
+const pointConstraintProps = {
   ...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;
@@ -6361,7 +6380,7 @@ PointConstraint.create = function() {
   constraint.world.sleepModule.wakeBodyUp(constraint.bodyB);
   return constraint;
 };
-const rotationEulerComponentProps = props({
+const rotationEulerComponentProps = {
   bodyA: LazyReferenceType((() => Body)),
   bodyB: LazyReferenceType((() => Body)),
   options: ChildType(ConstraintOptions, {
@@ -6373,8 +6392,10 @@ const rotationEulerComponentProps = props({
   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();
@@ -6466,7 +6487,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 = props({
+const fixedConstraintProps = {
   ...baseConstraintProps,
   positionA: ChildType(Vec3),
   positionB: ChildType(Vec3),
@@ -6485,8 +6506,8 @@ const fixedConstraintProps = props({
   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;
@@ -6619,7 +6640,7 @@ var SpringMode = /* @__PURE__ */ ((SpringMode2) => {
   SpringMode2[SpringMode2["UseStiffness"] = 1] = "UseStiffness";
   return SpringMode2;
 })(SpringMode || {});
-const springProps = props({
+const springProps = {
   mode: NumberType(
     0
     /* UseFrequency */
@@ -6627,8 +6648,8 @@ const springProps = props({
   damping: 0,
   frequency: 0,
   stiffness: 0
-});
-class Spring extends createClass()(springProps) {
+};
+class Spring extends createClass(springProps) {
   hasStiffness() {
     return this.frequency > 0;
   }
@@ -6636,11 +6657,11 @@ class Spring extends createClass()(springProps) {
     return this.frequency >= 0 && this.damping >= 0 && this.stiffness >= 0;
   }
 }
-const springComponentProps = props({
+const springComponentProps = {
   bias: 0,
   softness: 0
-});
-class SpringComponent extends createClass()(springComponentProps) {
+};
+class SpringComponent extends createClass(springComponentProps) {
   getBias(lambda2) {
     return this.softness * lambda2 + this.bias;
   }
@@ -6682,7 +6703,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 = props({
+const axisComponentProps = {
   bodyA: LazyReferenceType((() => Body)),
   bodyB: LazyReferenceType((() => Body)),
   options: ChildType(ConstraintOptions, {
@@ -6697,8 +6718,8 @@ const axisComponentProps = props({
   effectiveMass: 0,
   totalLambda: 0,
   springComponent: SpringComponent
-});
-class AxisComponent extends createClass()(axisComponentProps) {
+};
+class AxisComponent extends createClass(axisComponentProps) {
   deactivate() {
     this.effectiveMass = 0;
     this.totalLambda = 0;
@@ -6853,7 +6874,7 @@ const localToWorldTransformB = /* @__PURE__ */ Mat4.create();
 const armA = /* @__PURE__ */ Vec3.create();
 const armB = /* @__PURE__ */ Vec3.create();
 const vectorAB$5 = /* @__PURE__ */ Vec3.create();
-const distanceConstraintProps = props({
+const distanceConstraintProps = {
   ...baseConstraintProps,
   positionA: ChildType(Vec3, { x: 0, y: 0, z: 0 }),
   positionB: ChildType(Vec3, { x: 0, y: 0, z: 0 }),
@@ -6868,8 +6889,8 @@ const distanceConstraintProps = props({
   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;
@@ -7016,7 +7037,7 @@ var MotorMode = /* @__PURE__ */ ((MotorMode2) => {
   MotorMode2[MotorMode2["Velocity"] = 2] = "Velocity";
   return MotorMode2;
 })(MotorMode || {});
-const motorProps = props({
+const motorProps = {
   spring: ChildType(Spring, { mode: SpringMode.UseFrequency, damping: 1, frequency: 2, stiffness: 2 }),
   minForce: NumberType(-Infinity),
   maxForce: NumberType(Infinity),
@@ -7026,8 +7047,8 @@ const motorProps = props({
     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;
   }
@@ -7039,7 +7060,7 @@ const perpendicular$1 = /* @__PURE__ */ Vec3.create();
 const summedInverseInertia = /* @__PURE__ */ Mat3.create();
 const massBA = /* @__PURE__ */ Vec3.create();
 const massCA = /* @__PURE__ */ Vec3.create();
-const hingeComponentProps = props({
+const hingeComponentProps = {
   bodyA: LazyReferenceType((() => Body)),
   bodyB: LazyReferenceType((() => Body)),
   options: ChildType(ConstraintOptions, {
@@ -7060,7 +7081,7 @@ const hingeComponentProps = props({
   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]);
@@ -7068,7 +7089,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;
@@ -7186,7 +7207,7 @@ class HingeComponent extends createClass()(hingeComponentProps) {
 const spinBA = /* @__PURE__ */ Vec3.create();
 const deltaSpin$1 = /* @__PURE__ */ Vec3.create();
 const inverseEffectiveMass = /* @__PURE__ */ Vec3.create();
-const angleComponentProps = props({
+const angleComponentProps = {
   bodyA: LazyReferenceType((() => Body)),
   bodyB: LazyReferenceType((() => Body)),
   options: ChildType(ConstraintOptions, {
@@ -7199,8 +7220,8 @@ const angleComponentProps = props({
   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;
@@ -7353,7 +7374,7 @@ const rotateLocalToWorldB = /* @__PURE__ */ Mat3.create();
 const worldHingeA = /* @__PURE__ */ Vec3.create();
 const worldHingeB = /* @__PURE__ */ Vec3.create();
 const transformLocalToWorld = /* @__PURE__ */ Mat4.create();
-const hingeConstraintProps = props({
+const hingeConstraintProps = {
   ...baseConstraintProps,
   // init data
   pointA: ChildType(Vec3, { x: 0, y: 0, z: 0 }),
@@ -7385,8 +7406,8 @@ const hingeConstraintProps = props({
   rotationConstraintPart: HingeComponent,
   rotationLimitsConstraintPart: AngleComponent,
   motorConstraintPart: AngleComponent
-});
-class HingeConstraint extends createClass()(hingeConstraintProps) {
+};
+class HingeConstraint extends createClass(hingeConstraintProps) {
   constructor() {
     super(...arguments);
     this.type = ConstraintType.hingeConstraint;
@@ -7689,7 +7710,7 @@ HingeConstraint.create = function() {
   constraint.world.sleepModule.wakeBodyUp(constraint.bodyB);
   return constraint;
 };
-const constraintPairNodeProps = props({
+const constraintPairNodeProps = {
   bodyA: LazyReferenceType((() => Body)),
   bodyB: LazyReferenceType((() => Body)),
   edgeA: LazyReferenceType((() => ConstraintPairEdge)),
@@ -7699,13 +7720,14 @@ const constraintPairNodeProps = props({
   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({ afterConstructorCode: afterConstructorCode$1 })(
-  constraintPairNodeProps
+class ConstraintPairNode extends createClass(
+  constraintPairNodeProps,
+  { afterConstructorCode: afterConstructorCode$1 }
 ) {
   containsStaticBody() {
     return this.bodyA.type === BodyType.static || this.bodyB.type === BodyType.static;
@@ -7723,12 +7745,14 @@ class ConstraintPairNode extends createClass({ afterConstructorCode: afterConstr
     this.constraintType = value.type;
   }
 }
-const constraintPairEdgeProps = props({
+const constraintPairEdgeProps = {
   node: LazyReferenceType((() => ConstraintPairNode)),
   next: LazyReferenceType((() => ConstraintPairEdge)),
   prev: LazyReferenceType((() => ConstraintPairEdge))
-});
-class ConstraintPairEdge extends createClass()(constraintPairEdgeProps) {
+};
+class ConstraintPairEdge extends createClass(
+  constraintPairEdgeProps
+) {
 }
 class ConstraintPairsModule {
   constructor(constraintPairNodePool, constraintPairEdgePool) {
@@ -7969,7 +7993,7 @@ var ColliderType = /* @__PURE__ */ ((ColliderType2) => {
   ColliderType2[ColliderType2["attractor"] = 3] = "attractor";
   return ColliderType2;
 })(ColliderType || {});
-const bodyProps = props({
+const bodyProps = {
   type: NumberType(
     0
     /* dynamic */
@@ -8023,11 +8047,11 @@ const bodyProps = props({
     (() => ConstraintPairEdge)
   ),
   visitGeneration: NumberType(0, true)
-});
+};
 const afterConstructorCode = `
   this.world = null;
 `;
-class Body extends createClass({ afterConstructorCode })(bodyProps) {
+class Body extends createClass(bodyProps, { afterConstructorCode }) {
   get shape() {
     return this["shape" + this.shapeType];
   }
@@ -8382,7 +8406,7 @@ function updateBody(body2, updateBroadphase = true) {
     body2.markBodyAsDirty();
   }
 }
-const castResultProps = props({
+const castResultProps = {
   status: NumberType(
     2
     /* Indeterminate */
@@ -8406,8 +8430,8 @@ const castResultProps = props({
   faceB: Face,
   fraction: 0,
   isBackFaceHit: BooleanType(false)
-});
-class CastResult extends createClass()(castResultProps) {
+};
+class CastResult extends createClass(castResultProps) {
   /**
    * swaps the A and B data
    */
@@ -8483,21 +8507,21 @@ function computeBarycentricCoordinates2d(outBarycentric, a3, b3, squaredToleranc
   }
   outBarycentric.isValid = true;
 }
-const closestPointResultProps = props({
+const closestPointResultProps = {
   point: Vec3,
   pointSet: 0
-});
-class ClosestPointResult extends createClass()(closestPointResultProps) {
+};
+class ClosestPointResult extends createClass(
+  closestPointResultProps
+) {
 }
-const barycentricCoordinatesResultProps = props({
+const barycentricCoordinatesResultProps = {
   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();
@@ -8708,13 +8732,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 = props({
+const vec4Props = {
   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();
@@ -8816,30 +8840,32 @@ function computeClosestPointOnTetrahedron(result2, inA, inB, inC, inD, mustInclu
     }
   }
 }
-const closestPointToSimplexProps = props({
+const closestPointToSimplexProps = {
   point: Vec3,
   squaredDistance: 0,
   pointSet: 0,
   closestPointFound: BooleanType(false)
-});
-class ClosestPointToSimplex extends createClass()(closestPointToSimplexProps) {
+};
+class ClosestPointToSimplex extends createClass(
+  closestPointToSimplexProps
+) {
 }
-const gjkClosestPointsProps = props({
+const gjkClosestPointsProps = {
   squaredDistance: 0,
   penetrationAxis: Vec3,
   pointA: Vec3,
   pointB: Vec3
-});
-class GjkClosestPoints extends createClass()(gjkClosestPointsProps) {
+};
+class GjkClosestPoints extends createClass(gjkClosestPointsProps) {
 }
-const gjkCastShapeResultProps = props({
+const gjkCastShapeResultProps = {
   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();
@@ -9328,7 +9354,7 @@ var CollisionStatus = /* @__PURE__ */ ((CollisionStatus2) => {
   CollisionStatus2[CollisionStatus2["Indeterminate"] = 2] = "Indeterminate";
   return CollisionStatus2;
 })(CollisionStatus || {});
-const collisionResultProps = props({
+const collisionResultProps = {
   status: NumberType(
     2
     /* Indeterminate */
@@ -9350,8 +9376,8 @@ const collisionResultProps = props({
   isBackFace: BooleanType(false),
   faceA: Face,
   faceB: Face
-});
-class CollisionResult extends createClass()(collisionResultProps) {
+};
+class CollisionResult extends createClass(collisionResultProps) {
   /**
    * swaps the A and B data
    */
@@ -9410,15 +9436,15 @@ var BackFaceMode = /* @__PURE__ */ ((BackFaceMode2) => {
   BackFaceMode2[BackFaceMode2["CollideWithBackFaces"] = 1] = "CollideWithBackFaces";
   return BackFaceMode2;
 })(BackFaceMode || {});
-const edgeProps = props({
+const edgeProps = {
   neighbourTriangle: LazyReferenceType((() => Triangle2)),
   neighbourEdge: 0,
   startIndex: 0
-});
-class Edge extends createClass()(edgeProps) {
+};
+class Edge extends createClass(edgeProps) {
   //
 }
-const triangleProps = props({
+const triangleProps = {
   edge0: Edge,
   edge1: Edge,
   edge2: Edge,
@@ -9432,7 +9458,7 @@ const triangleProps = props({
   removed: BooleanType(false),
   inQueue: BooleanType(false),
   iteration: 0
-});
+};
 const vectorAB$4 = /* @__PURE__ */ Vec3.create();
 const y10 = /* @__PURE__ */ Vec3.create();
 const y20 = /* @__PURE__ */ Vec3.create();
@@ -9511,7 +9537,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;
@@ -10021,13 +10047,15 @@ const p10 = /* @__PURE__ */ Vec3.create();
 const p12 = /* @__PURE__ */ Vec3.create();
 const q10 = /* @__PURE__ */ Vec3.create();
 const q12 = /* @__PURE__ */ Vec3.create();
-const penetrationDepthProps = props({
+const penetrationDepthProps = {
   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();
@@ -11292,15 +11320,13 @@ class CollideShapesModule {
     );
   }
 }
-const estimateCollisionResponseResultProps = props({
+const estimateCollisionResponseResultProps = {
   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();
@@ -11967,11 +11993,11 @@ class ManifoldCache {
 const contactPairCacheMaxDeltaPositionSquared = squared(1e-3);
 const contactPairCacheCosMaxDeltaRotationDiv2 = Math.cos(degreesToRadians(2) / 2);
 const negatedPenetrationAxis = /* @__PURE__ */ Vec3.create();
-const vec3BufferProps = props({
+const vec3BufferProps = {
   numItems: 0,
   vec3List: ReferenceListType(Vec3)
-});
-class Vec3Buffer extends createClass()(vec3BufferProps) {
+};
+class Vec3Buffer extends createClass(vec3BufferProps) {
   getVec3(out, index) {
     out.copy(this.vec3List.getAtIndex(index));
   }