@hellpig/anarchy-engine 21.3.0 → 21.4.1

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/shape.js

@@ -0,0 +1,2 @@
+import{VectorOps,RotationOps}from"../math.js";import"../rapier_wasm3d.js";import{ShapeContact}from"./contact.js";import{PointProjection}from"./point.js";import{RayIntersection}from"./ray.js";import{ShapeCastHit}from"./toi.js";import{RawShape,RawShapeType}from"../rapier_wasm3d_bg.js";class Shape{static fromRaw(rawSet,handle){const rawType=rawSet.coShapeType(handle);let extents,borderRadius,vs,indices,halfHeight,radius,normal;switch(rawType){case RawShapeType.Ball:return new Ball(rawSet.coRadius(handle));case RawShapeType.Cuboid:return extents=rawSet.coHalfExtents(handle),new Cuboid(extents.x,extents.y,extents.z);case RawShapeType.RoundCuboid:return extents=rawSet.coHalfExtents(handle),borderRadius=rawSet.coRoundRadius(handle),new RoundCuboid(extents.x,extents.y,extents.z,borderRadius);case RawShapeType.Capsule:return halfHeight=rawSet.coHalfHeight(handle),radius=rawSet.coRadius(handle),new Capsule(halfHeight,radius);case RawShapeType.Segment:return vs=rawSet.coVertices(handle),new Segment(VectorOps.new(vs[0],vs[1],vs[2]),VectorOps.new(vs[3],vs[4],vs[5]));case RawShapeType.Polyline:return vs=rawSet.coVertices(handle),indices=rawSet.coIndices(handle),new Polyline(vs,indices);case RawShapeType.Triangle:return vs=rawSet.coVertices(handle),new Triangle(VectorOps.new(vs[0],vs[1],vs[2]),VectorOps.new(vs[3],vs[4],vs[5]),VectorOps.new(vs[6],vs[7],vs[8]));case RawShapeType.RoundTriangle:return vs=rawSet.coVertices(handle),borderRadius=rawSet.coRoundRadius(handle),new RoundTriangle(VectorOps.new(vs[0],vs[1],vs[2]),VectorOps.new(vs[3],vs[4],vs[5]),VectorOps.new(vs[6],vs[7],vs[8]),borderRadius);case RawShapeType.HalfSpace:return normal=VectorOps.fromRaw(rawSet.coHalfspaceNormal(handle)),new HalfSpace(normal);case RawShapeType.Voxels:const vox_data=rawSet.coVoxelData(handle),vox_size=rawSet.coVoxelSize(handle);return new Voxels(vox_data,vox_size);case RawShapeType.TriMesh:vs=rawSet.coVertices(handle),indices=rawSet.coIndices(handle);const tri_flags=rawSet.coTriMeshFlags(handle);return new TriMesh(vs,indices,tri_flags);case RawShapeType.HeightField:const scale=rawSet.coHeightfieldScale(handle),heights=rawSet.coHeightfieldHeights(handle),nrows=rawSet.coHeightfieldNRows(handle),ncols=rawSet.coHeightfieldNCols(handle),hf_flags=rawSet.coHeightFieldFlags(handle);return new Heightfield(nrows,ncols,heights,scale,hf_flags);case RawShapeType.ConvexPolyhedron:return vs=rawSet.coVertices(handle),indices=rawSet.coIndices(handle),new ConvexPolyhedron(vs,indices);case RawShapeType.RoundConvexPolyhedron:return vs=rawSet.coVertices(handle),indices=rawSet.coIndices(handle),borderRadius=rawSet.coRoundRadius(handle),new RoundConvexPolyhedron(vs,indices,borderRadius);case RawShapeType.Cylinder:return halfHeight=rawSet.coHalfHeight(handle),radius=rawSet.coRadius(handle),new Cylinder(halfHeight,radius);case RawShapeType.RoundCylinder:return halfHeight=rawSet.coHalfHeight(handle),radius=rawSet.coRadius(handle),borderRadius=rawSet.coRoundRadius(handle),new RoundCylinder(halfHeight,radius,borderRadius);case RawShapeType.Cone:return halfHeight=rawSet.coHalfHeight(handle),radius=rawSet.coRadius(handle),new Cone(halfHeight,radius);case RawShapeType.RoundCone:return halfHeight=rawSet.coHalfHeight(handle),radius=rawSet.coRadius(handle),borderRadius=rawSet.coRoundRadius(handle),new RoundCone(halfHeight,radius,borderRadius);default:throw new Error("unknown shape type: "+rawType)}}castShape(shapePos1,shapeRot1,shapeVel1,shape2,shapePos2,shapeRot2,shapeVel2,targetDistance,maxToi,stopAtPenetration){let rawPos1=VectorOps.intoRaw(shapePos1),rawRot1=RotationOps.intoRaw(shapeRot1),rawVel1=VectorOps.intoRaw(shapeVel1),rawPos2=VectorOps.intoRaw(shapePos2),rawRot2=RotationOps.intoRaw(shapeRot2),rawVel2=VectorOps.intoRaw(shapeVel2),rawShape1=this.intoRaw(),rawShape2=shape2.intoRaw(),result=ShapeCastHit.fromRaw(null,rawShape1.castShape(rawPos1,rawRot1,rawVel1,rawShape2,rawPos2,rawRot2,rawVel2,targetDistance,maxToi,stopAtPenetration));return rawPos1.free(),rawRot1.free(),rawVel1.free(),rawPos2.free(),rawRot2.free(),rawVel2.free(),rawShape1.free(),rawShape2.free(),result}intersectsShape(shapePos1,shapeRot1,shape2,shapePos2,shapeRot2){let rawPos1=VectorOps.intoRaw(shapePos1),rawRot1=RotationOps.intoRaw(shapeRot1),rawPos2=VectorOps.intoRaw(shapePos2),rawRot2=RotationOps.intoRaw(shapeRot2),rawShape1=this.intoRaw(),rawShape2=shape2.intoRaw(),result=rawShape1.intersectsShape(rawPos1,rawRot1,rawShape2,rawPos2,rawRot2);return rawPos1.free(),rawRot1.free(),rawPos2.free(),rawRot2.free(),rawShape1.free(),rawShape2.free(),result}contactShape(shapePos1,shapeRot1,shape2,shapePos2,shapeRot2,prediction){let rawPos1=VectorOps.intoRaw(shapePos1),rawRot1=RotationOps.intoRaw(shapeRot1),rawPos2=VectorOps.intoRaw(shapePos2),rawRot2=RotationOps.intoRaw(shapeRot2),rawShape1=this.intoRaw(),rawShape2=shape2.intoRaw(),result=ShapeContact.fromRaw(rawShape1.contactShape(rawPos1,rawRot1,rawShape2,rawPos2,rawRot2,prediction));return rawPos1.free(),rawRot1.free(),rawPos2.free(),rawRot2.free(),rawShape1.free(),rawShape2.free(),result}containsPoint(shapePos,shapeRot,point){let rawPos=VectorOps.intoRaw(shapePos),rawRot=RotationOps.intoRaw(shapeRot),rawPoint=VectorOps.intoRaw(point),rawShape=this.intoRaw(),result=rawShape.containsPoint(rawPos,rawRot,rawPoint);return rawPos.free(),rawRot.free(),rawPoint.free(),rawShape.free(),result}projectPoint(shapePos,shapeRot,point,solid){let rawPos=VectorOps.intoRaw(shapePos),rawRot=RotationOps.intoRaw(shapeRot),rawPoint=VectorOps.intoRaw(point),rawShape=this.intoRaw(),result=PointProjection.fromRaw(rawShape.projectPoint(rawPos,rawRot,rawPoint,solid));return rawPos.free(),rawRot.free(),rawPoint.free(),rawShape.free(),result}intersectsRay(ray,shapePos,shapeRot,maxToi){let rawPos=VectorOps.intoRaw(shapePos),rawRot=RotationOps.intoRaw(shapeRot),rawRayOrig=VectorOps.intoRaw(ray.origin),rawRayDir=VectorOps.intoRaw(ray.dir),rawShape=this.intoRaw(),result=rawShape.intersectsRay(rawPos,rawRot,rawRayOrig,rawRayDir,maxToi);return rawPos.free(),rawRot.free(),rawRayOrig.free(),rawRayDir.free(),rawShape.free(),result}castRay(ray,shapePos,shapeRot,maxToi,solid){let rawPos=VectorOps.intoRaw(shapePos),rawRot=RotationOps.intoRaw(shapeRot),rawRayOrig=VectorOps.intoRaw(ray.origin),rawRayDir=VectorOps.intoRaw(ray.dir),rawShape=this.intoRaw(),result=rawShape.castRay(rawPos,rawRot,rawRayOrig,rawRayDir,maxToi,solid);return rawPos.free(),rawRot.free(),rawRayOrig.free(),rawRayDir.free(),rawShape.free(),result}castRayAndGetNormal(ray,shapePos,shapeRot,maxToi,solid){let rawPos=VectorOps.intoRaw(shapePos),rawRot=RotationOps.intoRaw(shapeRot),rawRayOrig=VectorOps.intoRaw(ray.origin),rawRayDir=VectorOps.intoRaw(ray.dir),rawShape=this.intoRaw(),result=RayIntersection.fromRaw(rawShape.castRayAndGetNormal(rawPos,rawRot,rawRayOrig,rawRayDir,maxToi,solid));return rawPos.free(),rawRot.free(),rawRayOrig.free(),rawRayDir.free(),rawShape.free(),result}}var ShapeType,HeightFieldFlags,TriMeshFlags;!function(ShapeType){ShapeType[ShapeType.Ball=0]="Ball",ShapeType[ShapeType.Cuboid=1]="Cuboid",ShapeType[ShapeType.Capsule=2]="Capsule",ShapeType[ShapeType.Segment=3]="Segment",ShapeType[ShapeType.Polyline=4]="Polyline",ShapeType[ShapeType.Triangle=5]="Triangle",ShapeType[ShapeType.TriMesh=6]="TriMesh",ShapeType[ShapeType.HeightField=7]="HeightField",ShapeType[ShapeType.ConvexPolyhedron=9]="ConvexPolyhedron",ShapeType[ShapeType.Cylinder=10]="Cylinder",ShapeType[ShapeType.Cone=11]="Cone",ShapeType[ShapeType.RoundCuboid=12]="RoundCuboid",ShapeType[ShapeType.RoundTriangle=13]="RoundTriangle",ShapeType[ShapeType.RoundCylinder=14]="RoundCylinder",ShapeType[ShapeType.RoundCone=15]="RoundCone",ShapeType[ShapeType.RoundConvexPolyhedron=16]="RoundConvexPolyhedron",ShapeType[ShapeType.HalfSpace=17]="HalfSpace",ShapeType[ShapeType.Voxels=18]="Voxels"}(ShapeType||(ShapeType={})),function(HeightFieldFlags){HeightFieldFlags[HeightFieldFlags.FIX_INTERNAL_EDGES=1]="FIX_INTERNAL_EDGES"}(HeightFieldFlags||(HeightFieldFlags={})),function(TriMeshFlags){TriMeshFlags[TriMeshFlags.DELETE_BAD_TOPOLOGY_TRIANGLES=4]="DELETE_BAD_TOPOLOGY_TRIANGLES",TriMeshFlags[TriMeshFlags.ORIENTED=8]="ORIENTED",TriMeshFlags[TriMeshFlags.MERGE_DUPLICATE_VERTICES=16]="MERGE_DUPLICATE_VERTICES",TriMeshFlags[TriMeshFlags.DELETE_DEGENERATE_TRIANGLES=32]="DELETE_DEGENERATE_TRIANGLES",TriMeshFlags[TriMeshFlags.DELETE_DUPLICATE_TRIANGLES=64]="DELETE_DUPLICATE_TRIANGLES",TriMeshFlags[TriMeshFlags.FIX_INTERNAL_EDGES=144]="FIX_INTERNAL_EDGES"}(TriMeshFlags||(TriMeshFlags={}));class Ball extends Shape{constructor(radius){super(),this.type=ShapeType.Ball,this.radius=radius}intoRaw(){return RawShape.ball(this.radius)}}class HalfSpace extends Shape{constructor(normal){super(),this.type=ShapeType.HalfSpace,this.normal=normal}intoRaw(){let n=VectorOps.intoRaw(this.normal),result=RawShape.halfspace(n);return n.free(),result}}class Cuboid extends Shape{constructor(hx,hy,hz){super(),this.type=ShapeType.Cuboid,this.halfExtents=VectorOps.new(hx,hy,hz)}intoRaw(){return RawShape.cuboid(this.halfExtents.x,this.halfExtents.y,this.halfExtents.z)}}class RoundCuboid extends Shape{constructor(hx,hy,hz,borderRadius){super(),this.type=ShapeType.RoundCuboid,this.halfExtents=VectorOps.new(hx,hy,hz),this.borderRadius=borderRadius}intoRaw(){return RawShape.roundCuboid(this.halfExtents.x,this.halfExtents.y,this.halfExtents.z,this.borderRadius)}}class Capsule extends Shape{constructor(halfHeight,radius){super(),this.type=ShapeType.Capsule,this.halfHeight=halfHeight,this.radius=radius}intoRaw(){return RawShape.capsule(this.halfHeight,this.radius)}}class Segment extends Shape{constructor(a,b){super(),this.type=ShapeType.Segment,this.a=a,this.b=b}intoRaw(){let ra=VectorOps.intoRaw(this.a),rb=VectorOps.intoRaw(this.b),result=RawShape.segment(ra,rb);return ra.free(),rb.free(),result}}class Triangle extends Shape{constructor(a,b,c){super(),this.type=ShapeType.Triangle,this.a=a,this.b=b,this.c=c}intoRaw(){let ra=VectorOps.intoRaw(this.a),rb=VectorOps.intoRaw(this.b),rc=VectorOps.intoRaw(this.c),result=RawShape.triangle(ra,rb,rc);return ra.free(),rb.free(),rc.free(),result}}class RoundTriangle extends Shape{constructor(a,b,c,borderRadius){super(),this.type=ShapeType.RoundTriangle,this.a=a,this.b=b,this.c=c,this.borderRadius=borderRadius}intoRaw(){let ra=VectorOps.intoRaw(this.a),rb=VectorOps.intoRaw(this.b),rc=VectorOps.intoRaw(this.c),result=RawShape.roundTriangle(ra,rb,rc,this.borderRadius);return ra.free(),rb.free(),rc.free(),result}}class Polyline extends Shape{constructor(vertices,indices){super(),this.type=ShapeType.Polyline,this.vertices=vertices,this.indices=null!=indices?indices:new Uint32Array(0)}intoRaw(){return RawShape.polyline(this.vertices,this.indices)}}class Voxels extends Shape{constructor(data,voxelSize){super(),this.type=ShapeType.Voxels,this.data=data,this.voxelSize=voxelSize}intoRaw(){let result,voxelSize=VectorOps.intoRaw(this.voxelSize);return result=this.data instanceof Int32Array?RawShape.voxels(voxelSize,this.data):RawShape.voxelsFromPoints(voxelSize,this.data),voxelSize.free(),result}}class TriMesh extends Shape{constructor(vertices,indices,flags){super(),this.type=ShapeType.TriMesh,this.vertices=vertices,this.indices=indices,this.flags=flags}intoRaw(){return RawShape.trimesh(this.vertices,this.indices,this.flags)}}class ConvexPolyhedron extends Shape{constructor(vertices,indices){super(),this.type=ShapeType.ConvexPolyhedron,this.vertices=vertices,this.indices=indices}intoRaw(){return this.indices?RawShape.convexMesh(this.vertices,this.indices):RawShape.convexHull(this.vertices)}}class RoundConvexPolyhedron extends Shape{constructor(vertices,indices,borderRadius){super(),this.type=ShapeType.RoundConvexPolyhedron,this.vertices=vertices,this.indices=indices,this.borderRadius=borderRadius}intoRaw(){return this.indices?RawShape.roundConvexMesh(this.vertices,this.indices,this.borderRadius):RawShape.roundConvexHull(this.vertices,this.borderRadius)}}class Heightfield extends Shape{constructor(nrows,ncols,heights,scale,flags){super(),this.type=ShapeType.HeightField,this.nrows=nrows,this.ncols=ncols,this.heights=heights,this.scale=scale,this.flags=flags}intoRaw(){let rawScale=VectorOps.intoRaw(this.scale),rawShape=RawShape.heightfield(this.nrows,this.ncols,this.heights,rawScale,this.flags);return rawScale.free(),rawShape}}class Cylinder extends Shape{constructor(halfHeight,radius){super(),this.type=ShapeType.Cylinder,this.halfHeight=halfHeight,this.radius=radius}intoRaw(){return RawShape.cylinder(this.halfHeight,this.radius)}}class RoundCylinder extends Shape{constructor(halfHeight,radius,borderRadius){super(),this.type=ShapeType.RoundCylinder,this.borderRadius=borderRadius,this.halfHeight=halfHeight,this.radius=radius}intoRaw(){return RawShape.roundCylinder(this.halfHeight,this.radius,this.borderRadius)}}class Cone extends Shape{constructor(halfHeight,radius){super(),this.type=ShapeType.Cone,this.halfHeight=halfHeight,this.radius=radius}intoRaw(){return RawShape.cone(this.halfHeight,this.radius)}}class RoundCone extends Shape{constructor(halfHeight,radius,borderRadius){super(),this.type=ShapeType.RoundCone,this.halfHeight=halfHeight,this.radius=radius,this.borderRadius=borderRadius}intoRaw(){return RawShape.roundCone(this.halfHeight,this.radius,this.borderRadius)}}export{Ball,Capsule,Cone,ConvexPolyhedron,Cuboid,Cylinder,HalfSpace,HeightFieldFlags,Heightfield,Polyline,RoundCone,RoundConvexPolyhedron,RoundCuboid,RoundCylinder,RoundTriangle,Segment,Shape,ShapeType,TriMesh,TriMeshFlags,Triangle,Voxels};
+//# sourceMappingURL=shape.js.map

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/geometry/shape.js"],"sourcesContent":["import { VectorOps, RotationOps } from \"../math\";\nimport { RawShape, RawShapeType } from \"../raw\";\nimport { ShapeContact } from \"./contact\";\nimport { PointProjection } from \"./point\";\nimport { RayIntersection } from \"./ray\";\nimport { ShapeCastHit } from \"./toi\";\nexport class Shape {\n    /**\n     * instant mode without cache\n     */\n    static fromRaw(rawSet, handle) {\n        const rawType = rawSet.coShapeType(handle);\n        let extents;\n        let borderRadius;\n        let vs;\n        let indices;\n        let halfHeight;\n        let radius;\n        let normal;\n        switch (rawType) {\n            case RawShapeType.Ball:\n                return new Ball(rawSet.coRadius(handle));\n            case RawShapeType.Cuboid:\n                extents = rawSet.coHalfExtents(handle);\n                // #if DIM3\n                return new Cuboid(extents.x, extents.y, extents.z);\n            // #endif\n            case RawShapeType.RoundCuboid:\n                extents = rawSet.coHalfExtents(handle);\n                borderRadius = rawSet.coRoundRadius(handle);\n                // #if DIM3\n                return new RoundCuboid(extents.x, extents.y, extents.z, borderRadius);\n            // #endif\n            case RawShapeType.Capsule:\n                halfHeight = rawSet.coHalfHeight(handle);\n                radius = rawSet.coRadius(handle);\n                return new Capsule(halfHeight, radius);\n            case RawShapeType.Segment:\n                vs = rawSet.coVertices(handle);\n                // #if DIM3\n                return new Segment(VectorOps.new(vs[0], vs[1], vs[2]), VectorOps.new(vs[3], vs[4], vs[5]));\n            // #endif\n            case RawShapeType.Polyline:\n                vs = rawSet.coVertices(handle);\n                indices = rawSet.coIndices(handle);\n                return new Polyline(vs, indices);\n            case RawShapeType.Triangle:\n                vs = rawSet.coVertices(handle);\n                // #if DIM3\n                return new Triangle(VectorOps.new(vs[0], vs[1], vs[2]), VectorOps.new(vs[3], vs[4], vs[5]), VectorOps.new(vs[6], vs[7], vs[8]));\n            // #endif\n            case RawShapeType.RoundTriangle:\n                vs = rawSet.coVertices(handle);\n                borderRadius = rawSet.coRoundRadius(handle);\n                // #if DIM3\n                return new RoundTriangle(VectorOps.new(vs[0], vs[1], vs[2]), VectorOps.new(vs[3], vs[4], vs[5]), VectorOps.new(vs[6], vs[7], vs[8]), borderRadius);\n            // #endif\n            case RawShapeType.HalfSpace:\n                normal = VectorOps.fromRaw(rawSet.coHalfspaceNormal(handle));\n                return new HalfSpace(normal);\n            case RawShapeType.Voxels:\n                const vox_data = rawSet.coVoxelData(handle);\n                const vox_size = rawSet.coVoxelSize(handle);\n                return new Voxels(vox_data, vox_size);\n            case RawShapeType.TriMesh:\n                vs = rawSet.coVertices(handle);\n                indices = rawSet.coIndices(handle);\n                const tri_flags = rawSet.coTriMeshFlags(handle);\n                return new TriMesh(vs, indices, tri_flags);\n            case RawShapeType.HeightField:\n                const scale = rawSet.coHeightfieldScale(handle);\n                const heights = rawSet.coHeightfieldHeights(handle);\n                // #if DIM3\n                const nrows = rawSet.coHeightfieldNRows(handle);\n                const ncols = rawSet.coHeightfieldNCols(handle);\n                const hf_flags = rawSet.coHeightFieldFlags(handle);\n                return new Heightfield(nrows, ncols, heights, scale, hf_flags);\n            // #endif\n            // #if DIM3\n            case RawShapeType.ConvexPolyhedron:\n                vs = rawSet.coVertices(handle);\n                indices = rawSet.coIndices(handle);\n                return new ConvexPolyhedron(vs, indices);\n            case RawShapeType.RoundConvexPolyhedron:\n                vs = rawSet.coVertices(handle);\n                indices = rawSet.coIndices(handle);\n                borderRadius = rawSet.coRoundRadius(handle);\n                return new RoundConvexPolyhedron(vs, indices, borderRadius);\n            case RawShapeType.Cylinder:\n                halfHeight = rawSet.coHalfHeight(handle);\n                radius = rawSet.coRadius(handle);\n                return new Cylinder(halfHeight, radius);\n            case RawShapeType.RoundCylinder:\n                halfHeight = rawSet.coHalfHeight(handle);\n                radius = rawSet.coRadius(handle);\n                borderRadius = rawSet.coRoundRadius(handle);\n                return new RoundCylinder(halfHeight, radius, borderRadius);\n            case RawShapeType.Cone:\n                halfHeight = rawSet.coHalfHeight(handle);\n                radius = rawSet.coRadius(handle);\n                return new Cone(halfHeight, radius);\n            case RawShapeType.RoundCone:\n                halfHeight = rawSet.coHalfHeight(handle);\n                radius = rawSet.coRadius(handle);\n                borderRadius = rawSet.coRoundRadius(handle);\n                return new RoundCone(halfHeight, radius, borderRadius);\n            // #endif\n            default:\n                throw new Error(\"unknown shape type: \" + rawType);\n        }\n    }\n    /**\n     * Computes the time of impact between two moving shapes.\n     * @param shapePos1 - The initial position of this sahpe.\n     * @param shapeRot1 - The rotation of this shape.\n     * @param shapeVel1 - The velocity of this shape.\n     * @param shape2 - The second moving shape.\n     * @param shapePos2 - The initial position of the second shape.\n     * @param shapeRot2 - The rotation of the second shape.\n     * @param shapeVel2 - The velocity of the second shape.\n     * @param targetDistance − If the shape moves closer to this distance from a collider, a hit\n     *                         will be returned.\n     * @param maxToi - The maximum time when the impact can happen.\n     * @param stopAtPenetration - If set to `false`, the linear shape-cast won’t immediately stop if\n     *   the shape is penetrating another shape at its starting point **and** its trajectory is such\n     *   that it’s on a path to exit that penetration state.\n     * @returns If the two moving shapes collider at some point along their trajectories, this returns the\n     *  time at which the two shape collider as well as the contact information during the impact. Returns\n     *  `null`if the two shapes never collide along their paths.\n     */\n    castShape(shapePos1, shapeRot1, shapeVel1, shape2, shapePos2, shapeRot2, shapeVel2, targetDistance, maxToi, stopAtPenetration) {\n        let rawPos1 = VectorOps.intoRaw(shapePos1);\n        let rawRot1 = RotationOps.intoRaw(shapeRot1);\n        let rawVel1 = VectorOps.intoRaw(shapeVel1);\n        let rawPos2 = VectorOps.intoRaw(shapePos2);\n        let rawRot2 = RotationOps.intoRaw(shapeRot2);\n        let rawVel2 = VectorOps.intoRaw(shapeVel2);\n        let rawShape1 = this.intoRaw();\n        let rawShape2 = shape2.intoRaw();\n        let result = ShapeCastHit.fromRaw(null, rawShape1.castShape(rawPos1, rawRot1, rawVel1, rawShape2, rawPos2, rawRot2, rawVel2, targetDistance, maxToi, stopAtPenetration));\n        rawPos1.free();\n        rawRot1.free();\n        rawVel1.free();\n        rawPos2.free();\n        rawRot2.free();\n        rawVel2.free();\n        rawShape1.free();\n        rawShape2.free();\n        return result;\n    }\n    /**\n     * Tests if this shape intersects another shape.\n     *\n     * @param shapePos1 - The position of this shape.\n     * @param shapeRot1 - The rotation of this shape.\n     * @param shape2  - The second shape to test.\n     * @param shapePos2 - The position of the second shape.\n     * @param shapeRot2 - The rotation of the second shape.\n     * @returns `true` if the two shapes intersect, `false` if they don’t.\n     */\n    intersectsShape(shapePos1, shapeRot1, shape2, shapePos2, shapeRot2) {\n        let rawPos1 = VectorOps.intoRaw(shapePos1);\n        let rawRot1 = RotationOps.intoRaw(shapeRot1);\n        let rawPos2 = VectorOps.intoRaw(shapePos2);\n        let rawRot2 = RotationOps.intoRaw(shapeRot2);\n        let rawShape1 = this.intoRaw();\n        let rawShape2 = shape2.intoRaw();\n        let result = rawShape1.intersectsShape(rawPos1, rawRot1, rawShape2, rawPos2, rawRot2);\n        rawPos1.free();\n        rawRot1.free();\n        rawPos2.free();\n        rawRot2.free();\n        rawShape1.free();\n        rawShape2.free();\n        return result;\n    }\n    /**\n     * Computes one pair of contact points between two shapes.\n     *\n     * @param shapePos1 - The initial position of this sahpe.\n     * @param shapeRot1 - The rotation of this shape.\n     * @param shape2 - The second shape.\n     * @param shapePos2 - The initial position of the second shape.\n     * @param shapeRot2 - The rotation of the second shape.\n     * @param prediction - The prediction value, if the shapes are separated by a distance greater than this value, test will fail.\n     * @returns `null` if the shapes are separated by a distance greater than prediction, otherwise contact details. The result is given in world-space.\n     */\n    contactShape(shapePos1, shapeRot1, shape2, shapePos2, shapeRot2, prediction) {\n        let rawPos1 = VectorOps.intoRaw(shapePos1);\n        let rawRot1 = RotationOps.intoRaw(shapeRot1);\n        let rawPos2 = VectorOps.intoRaw(shapePos2);\n        let rawRot2 = RotationOps.intoRaw(shapeRot2);\n        let rawShape1 = this.intoRaw();\n        let rawShape2 = shape2.intoRaw();\n        let result = ShapeContact.fromRaw(rawShape1.contactShape(rawPos1, rawRot1, rawShape2, rawPos2, rawRot2, prediction));\n        rawPos1.free();\n        rawRot1.free();\n        rawPos2.free();\n        rawRot2.free();\n        rawShape1.free();\n        rawShape2.free();\n        return result;\n    }\n    containsPoint(shapePos, shapeRot, point) {\n        let rawPos = VectorOps.intoRaw(shapePos);\n        let rawRot = RotationOps.intoRaw(shapeRot);\n        let rawPoint = VectorOps.intoRaw(point);\n        let rawShape = this.intoRaw();\n        let result = rawShape.containsPoint(rawPos, rawRot, rawPoint);\n        rawPos.free();\n        rawRot.free();\n        rawPoint.free();\n        rawShape.free();\n        return result;\n    }\n    projectPoint(shapePos, shapeRot, point, solid) {\n        let rawPos = VectorOps.intoRaw(shapePos);\n        let rawRot = RotationOps.intoRaw(shapeRot);\n        let rawPoint = VectorOps.intoRaw(point);\n        let rawShape = this.intoRaw();\n        let result = PointProjection.fromRaw(rawShape.projectPoint(rawPos, rawRot, rawPoint, solid));\n        rawPos.free();\n        rawRot.free();\n        rawPoint.free();\n        rawShape.free();\n        return result;\n    }\n    intersectsRay(ray, shapePos, shapeRot, maxToi) {\n        let rawPos = VectorOps.intoRaw(shapePos);\n        let rawRot = RotationOps.intoRaw(shapeRot);\n        let rawRayOrig = VectorOps.intoRaw(ray.origin);\n        let rawRayDir = VectorOps.intoRaw(ray.dir);\n        let rawShape = this.intoRaw();\n        let result = rawShape.intersectsRay(rawPos, rawRot, rawRayOrig, rawRayDir, maxToi);\n        rawPos.free();\n        rawRot.free();\n        rawRayOrig.free();\n        rawRayDir.free();\n        rawShape.free();\n        return result;\n    }\n    castRay(ray, shapePos, shapeRot, maxToi, solid) {\n        let rawPos = VectorOps.intoRaw(shapePos);\n        let rawRot = RotationOps.intoRaw(shapeRot);\n        let rawRayOrig = VectorOps.intoRaw(ray.origin);\n        let rawRayDir = VectorOps.intoRaw(ray.dir);\n        let rawShape = this.intoRaw();\n        let result = rawShape.castRay(rawPos, rawRot, rawRayOrig, rawRayDir, maxToi, solid);\n        rawPos.free();\n        rawRot.free();\n        rawRayOrig.free();\n        rawRayDir.free();\n        rawShape.free();\n        return result;\n    }\n    castRayAndGetNormal(ray, shapePos, shapeRot, maxToi, solid) {\n        let rawPos = VectorOps.intoRaw(shapePos);\n        let rawRot = RotationOps.intoRaw(shapeRot);\n        let rawRayOrig = VectorOps.intoRaw(ray.origin);\n        let rawRayDir = VectorOps.intoRaw(ray.dir);\n        let rawShape = this.intoRaw();\n        let result = RayIntersection.fromRaw(rawShape.castRayAndGetNormal(rawPos, rawRot, rawRayOrig, rawRayDir, maxToi, solid));\n        rawPos.free();\n        rawRot.free();\n        rawRayOrig.free();\n        rawRayDir.free();\n        rawShape.free();\n        return result;\n    }\n}\n// #if DIM3\n/**\n * An enumeration representing the type of a shape.\n */\nexport var ShapeType;\n(function (ShapeType) {\n    ShapeType[ShapeType[\"Ball\"] = 0] = \"Ball\";\n    ShapeType[ShapeType[\"Cuboid\"] = 1] = \"Cuboid\";\n    ShapeType[ShapeType[\"Capsule\"] = 2] = \"Capsule\";\n    ShapeType[ShapeType[\"Segment\"] = 3] = \"Segment\";\n    ShapeType[ShapeType[\"Polyline\"] = 4] = \"Polyline\";\n    ShapeType[ShapeType[\"Triangle\"] = 5] = \"Triangle\";\n    ShapeType[ShapeType[\"TriMesh\"] = 6] = \"TriMesh\";\n    ShapeType[ShapeType[\"HeightField\"] = 7] = \"HeightField\";\n    // Compound = 8,\n    ShapeType[ShapeType[\"ConvexPolyhedron\"] = 9] = \"ConvexPolyhedron\";\n    ShapeType[ShapeType[\"Cylinder\"] = 10] = \"Cylinder\";\n    ShapeType[ShapeType[\"Cone\"] = 11] = \"Cone\";\n    ShapeType[ShapeType[\"RoundCuboid\"] = 12] = \"RoundCuboid\";\n    ShapeType[ShapeType[\"RoundTriangle\"] = 13] = \"RoundTriangle\";\n    ShapeType[ShapeType[\"RoundCylinder\"] = 14] = \"RoundCylinder\";\n    ShapeType[ShapeType[\"RoundCone\"] = 15] = \"RoundCone\";\n    ShapeType[ShapeType[\"RoundConvexPolyhedron\"] = 16] = \"RoundConvexPolyhedron\";\n    ShapeType[ShapeType[\"HalfSpace\"] = 17] = \"HalfSpace\";\n    ShapeType[ShapeType[\"Voxels\"] = 18] = \"Voxels\";\n})(ShapeType || (ShapeType = {}));\n// NOTE: this **must** match the bits in the HeightFieldFlags on the rust side.\n/**\n * Flags controlling the behavior of some operations involving heightfields.\n */\nexport var HeightFieldFlags;\n(function (HeightFieldFlags) {\n    /**\n     * If set, a special treatment will be applied to contact manifold calculation to eliminate\n     * or fix contacts normals that could lead to incorrect bumps in physics simulation (especially\n     * on flat surfaces).\n     *\n     * This is achieved by taking into account adjacent triangle normals when computing contact\n     * points for a given triangle.\n     */\n    HeightFieldFlags[HeightFieldFlags[\"FIX_INTERNAL_EDGES\"] = 1] = \"FIX_INTERNAL_EDGES\";\n})(HeightFieldFlags || (HeightFieldFlags = {}));\n// #endif\n// NOTE: this **must** match the TriMeshFlags on the rust side.\n/**\n * Flags controlling the behavior of the triangle mesh creation and of some\n * operations involving triangle meshes.\n */\nexport var TriMeshFlags;\n(function (TriMeshFlags) {\n    // NOTE: these two flags are not really useful in JS.\n    //\n    // /**\n    //  * If set, the half-edge topology of the trimesh will be computed if possible.\n    //  */\n    // HALF_EDGE_TOPOLOGY = 0b0000_0001,\n    // /** If set, the half-edge topology and connected components of the trimesh will be computed if possible.\n    //  *\n    //  * Because of the way it is currently implemented, connected components can only be computed on\n    //  * a mesh where the half-edge topology computation succeeds. It will no longer be the case in the\n    //  * future once we decouple the computations.\n    //  */\n    // CONNECTED_COMPONENTS = 0b0000_0010,\n    /**\n     * If set, any triangle that results in a failing half-hedge topology computation will be deleted.\n     */\n    TriMeshFlags[TriMeshFlags[\"DELETE_BAD_TOPOLOGY_TRIANGLES\"] = 4] = \"DELETE_BAD_TOPOLOGY_TRIANGLES\";\n    /**\n     * If set, the trimesh will be assumed to be oriented (with outward normals).\n     *\n     * The pseudo-normals of its vertices and edges will be computed.\n     */\n    TriMeshFlags[TriMeshFlags[\"ORIENTED\"] = 8] = \"ORIENTED\";\n    /**\n     * If set, the duplicate vertices of the trimesh will be merged.\n     *\n     * Two vertices with the exact same coordinates will share the same entry on the\n     * vertex buffer and the index buffer is adjusted accordingly.\n     */\n    TriMeshFlags[TriMeshFlags[\"MERGE_DUPLICATE_VERTICES\"] = 16] = \"MERGE_DUPLICATE_VERTICES\";\n    /**\n     * If set, the triangles sharing two vertices with identical index values will be removed.\n     *\n     * Because of the way it is currently implemented, this methods implies that duplicate\n     * vertices will be merged. It will no longer be the case in the future once we decouple\n     * the computations.\n     */\n    TriMeshFlags[TriMeshFlags[\"DELETE_DEGENERATE_TRIANGLES\"] = 32] = \"DELETE_DEGENERATE_TRIANGLES\";\n    /**\n     * If set, two triangles sharing three vertices with identical index values (in any order)\n     * will be removed.\n     *\n     * Because of the way it is currently implemented, this methods implies that duplicate\n     * vertices will be merged. It will no longer be the case in the future once we decouple\n     * the computations.\n     */\n    TriMeshFlags[TriMeshFlags[\"DELETE_DUPLICATE_TRIANGLES\"] = 64] = \"DELETE_DUPLICATE_TRIANGLES\";\n    /**\n     * If set, a special treatment will be applied to contact manifold calculation to eliminate\n     * or fix contacts normals that could lead to incorrect bumps in physics simulation\n     * (especially on flat surfaces).\n     *\n     * This is achieved by taking into account adjacent triangle normals when computing contact\n     * points for a given triangle.\n     *\n     * /!\\ NOT SUPPORTED IN THE 2D VERSION OF RAPIER.\n     */\n    TriMeshFlags[TriMeshFlags[\"FIX_INTERNAL_EDGES\"] = 144] = \"FIX_INTERNAL_EDGES\";\n})(TriMeshFlags || (TriMeshFlags = {}));\n/**\n * A shape that is a sphere in 3D and a circle in 2D.\n */\nexport class Ball extends Shape {\n    /**\n     * Creates a new ball with the given radius.\n     * @param radius - The balls radius.\n     */\n    constructor(radius) {\n        super();\n        this.type = ShapeType.Ball;\n        this.radius = radius;\n    }\n    intoRaw() {\n        return RawShape.ball(this.radius);\n    }\n}\nexport class HalfSpace extends Shape {\n    /**\n     * Creates a new halfspace delimited by an infinite plane.\n     *\n     * @param normal - The outward normal of the plane.\n     */\n    constructor(normal) {\n        super();\n        this.type = ShapeType.HalfSpace;\n        this.normal = normal;\n    }\n    intoRaw() {\n        let n = VectorOps.intoRaw(this.normal);\n        let result = RawShape.halfspace(n);\n        n.free();\n        return result;\n    }\n}\n/**\n * A shape that is a box in 3D and a rectangle in 2D.\n */\nexport class Cuboid extends Shape {\n    // #if DIM3\n    /**\n     * Creates a new 3D cuboid.\n     * @param hx - The half width of the cuboid.\n     * @param hy - The half height of the cuboid.\n     * @param hz - The half depth of the cuboid.\n     */\n    constructor(hx, hy, hz) {\n        super();\n        this.type = ShapeType.Cuboid;\n        this.halfExtents = VectorOps.new(hx, hy, hz);\n    }\n    // #endif\n    intoRaw() {\n        // #if DIM3\n        return RawShape.cuboid(this.halfExtents.x, this.halfExtents.y, this.halfExtents.z);\n        // #endif\n    }\n}\n/**\n * A shape that is a box in 3D and a rectangle in 2D, with round corners.\n */\nexport class RoundCuboid extends Shape {\n    // #if DIM3\n    /**\n     * Creates a new 3D cuboid.\n     * @param hx - The half width of the cuboid.\n     * @param hy - The half height of the cuboid.\n     * @param hz - The half depth of the cuboid.\n     * @param borderRadius - The radius of the borders of this cuboid. This will\n     *   effectively increase the half-extents of the cuboid by this radius.\n     */\n    constructor(hx, hy, hz, borderRadius) {\n        super();\n        this.type = ShapeType.RoundCuboid;\n        this.halfExtents = VectorOps.new(hx, hy, hz);\n        this.borderRadius = borderRadius;\n    }\n    // #endif\n    intoRaw() {\n        // #if DIM3\n        return RawShape.roundCuboid(this.halfExtents.x, this.halfExtents.y, this.halfExtents.z, this.borderRadius);\n        // #endif\n    }\n}\n/**\n * A shape that is a capsule.\n */\nexport class Capsule extends Shape {\n    /**\n     * Creates a new capsule with the given radius and half-height.\n     * @param halfHeight - The balls half-height along the `y` axis.\n     * @param radius - The balls radius.\n     */\n    constructor(halfHeight, radius) {\n        super();\n        this.type = ShapeType.Capsule;\n        this.halfHeight = halfHeight;\n        this.radius = radius;\n    }\n    intoRaw() {\n        return RawShape.capsule(this.halfHeight, this.radius);\n    }\n}\n/**\n * A shape that is a segment.\n */\nexport class Segment extends Shape {\n    /**\n     * Creates a new segment shape.\n     * @param a - The first point of the segment.\n     * @param b - The second point of the segment.\n     */\n    constructor(a, b) {\n        super();\n        this.type = ShapeType.Segment;\n        this.a = a;\n        this.b = b;\n    }\n    intoRaw() {\n        let ra = VectorOps.intoRaw(this.a);\n        let rb = VectorOps.intoRaw(this.b);\n        let result = RawShape.segment(ra, rb);\n        ra.free();\n        rb.free();\n        return result;\n    }\n}\n/**\n * A shape that is a segment.\n */\nexport class Triangle extends Shape {\n    /**\n     * Creates a new triangle shape.\n     *\n     * @param a - The first point of the triangle.\n     * @param b - The second point of the triangle.\n     * @param c - The third point of the triangle.\n     */\n    constructor(a, b, c) {\n        super();\n        this.type = ShapeType.Triangle;\n        this.a = a;\n        this.b = b;\n        this.c = c;\n    }\n    intoRaw() {\n        let ra = VectorOps.intoRaw(this.a);\n        let rb = VectorOps.intoRaw(this.b);\n        let rc = VectorOps.intoRaw(this.c);\n        let result = RawShape.triangle(ra, rb, rc);\n        ra.free();\n        rb.free();\n        rc.free();\n        return result;\n    }\n}\n/**\n * A shape that is a triangle with round borders and a non-zero thickness.\n */\nexport class RoundTriangle extends Shape {\n    /**\n     * Creates a new triangle shape with round corners.\n     *\n     * @param a - The first point of the triangle.\n     * @param b - The second point of the triangle.\n     * @param c - The third point of the triangle.\n     * @param borderRadius - The radius of the borders of this triangle. In 3D,\n     *   this is also equal to half the thickness of the triangle.\n     */\n    constructor(a, b, c, borderRadius) {\n        super();\n        this.type = ShapeType.RoundTriangle;\n        this.a = a;\n        this.b = b;\n        this.c = c;\n        this.borderRadius = borderRadius;\n    }\n    intoRaw() {\n        let ra = VectorOps.intoRaw(this.a);\n        let rb = VectorOps.intoRaw(this.b);\n        let rc = VectorOps.intoRaw(this.c);\n        let result = RawShape.roundTriangle(ra, rb, rc, this.borderRadius);\n        ra.free();\n        rb.free();\n        rc.free();\n        return result;\n    }\n}\n/**\n * A shape that is a triangle mesh.\n */\nexport class Polyline extends Shape {\n    /**\n     * Creates a new polyline shape.\n     *\n     * @param vertices - The coordinates of the polyline's vertices.\n     * @param indices - The indices of the polyline's segments. If this is `null` or not provided, then\n     *    the vertices are assumed to form a line strip.\n     */\n    constructor(vertices, indices) {\n        super();\n        this.type = ShapeType.Polyline;\n        this.vertices = vertices;\n        this.indices = indices !== null && indices !== void 0 ? indices : new Uint32Array(0);\n    }\n    intoRaw() {\n        return RawShape.polyline(this.vertices, this.indices);\n    }\n}\n/**\n * A shape made of voxels.\n */\nexport class Voxels extends Shape {\n    /**\n     * Creates a new shape made of voxels.\n     *\n     * @param data - Defines the set of voxels. If this is a `Int32Array` then\n     *               each voxel is defined from its (signed) grid coordinates,\n     *               with 3 (resp 2) contiguous integers per voxel in 3D (resp 2D).\n     *               If this is a `Float32Array`, each voxel will be such that\n     *               they contain at least one point from this array (where each\n     *               point is defined from 3 (resp 2) contiguous numbers per point\n     *               in 3D (resp 2D).\n     * @param voxelSize - The size of each voxel.\n     */\n    constructor(data, voxelSize) {\n        super();\n        this.type = ShapeType.Voxels;\n        this.data = data;\n        this.voxelSize = voxelSize;\n    }\n    intoRaw() {\n        let voxelSize = VectorOps.intoRaw(this.voxelSize);\n        let result;\n        if (this.data instanceof Int32Array) {\n            result = RawShape.voxels(voxelSize, this.data);\n        }\n        else {\n            result = RawShape.voxelsFromPoints(voxelSize, this.data);\n        }\n        voxelSize.free();\n        return result;\n    }\n}\n/**\n * A shape that is a triangle mesh.\n */\nexport class TriMesh extends Shape {\n    /**\n     * Creates a new triangle mesh shape.\n     *\n     * @param vertices - The coordinates of the triangle mesh's vertices.\n     * @param indices - The indices of the triangle mesh's triangles.\n     */\n    constructor(vertices, indices, flags) {\n        super();\n        this.type = ShapeType.TriMesh;\n        this.vertices = vertices;\n        this.indices = indices;\n        this.flags = flags;\n    }\n    intoRaw() {\n        return RawShape.trimesh(this.vertices, this.indices, this.flags);\n    }\n}\n// #if DIM3\n/**\n * A shape that is a convex polygon.\n */\nexport class ConvexPolyhedron extends Shape {\n    /**\n     * Creates a new convex polygon shape.\n     *\n     * @param vertices - The coordinates of the convex polygon's vertices.\n     * @param indices - The index buffer of this convex mesh. If this is `null`\n     *   or `undefined`, the convex-hull of the input vertices will be computed\n     *   automatically. Otherwise, it will be assumed that the mesh you provide\n     *   is already convex.\n     */\n    constructor(vertices, indices) {\n        super();\n        this.type = ShapeType.ConvexPolyhedron;\n        this.vertices = vertices;\n        this.indices = indices;\n    }\n    intoRaw() {\n        if (!!this.indices) {\n            return RawShape.convexMesh(this.vertices, this.indices);\n        }\n        else {\n            return RawShape.convexHull(this.vertices);\n        }\n    }\n}\n/**\n * A shape that is a convex polygon.\n */\nexport class RoundConvexPolyhedron extends Shape {\n    /**\n     * Creates a new convex polygon shape.\n     *\n     * @param vertices - The coordinates of the convex polygon's vertices.\n     * @param indices - The index buffer of this convex mesh. If this is `null`\n     *   or `undefined`, the convex-hull of the input vertices will be computed\n     *   automatically. Otherwise, it will be assumed that the mesh you provide\n     *   is already convex.\n     * @param borderRadius - The radius of the borders of this convex polyhedron.\n     */\n    constructor(vertices, indices, borderRadius) {\n        super();\n        this.type = ShapeType.RoundConvexPolyhedron;\n        this.vertices = vertices;\n        this.indices = indices;\n        this.borderRadius = borderRadius;\n    }\n    intoRaw() {\n        if (!!this.indices) {\n            return RawShape.roundConvexMesh(this.vertices, this.indices, this.borderRadius);\n        }\n        else {\n            return RawShape.roundConvexHull(this.vertices, this.borderRadius);\n        }\n    }\n}\n/**\n * A shape that is a heightfield.\n */\nexport class Heightfield extends Shape {\n    /**\n     * Creates a new heightfield shape.\n     *\n     * @param nrows − The number of rows in the heights matrix.\n     * @param ncols - The number of columns in the heights matrix.\n     * @param heights - The heights of the heightfield along its local `y` axis,\n     *                  provided as a matrix stored in column-major order.\n     * @param scale - The dimensions of the heightfield's local `x,z` plane.\n     */\n    constructor(nrows, ncols, heights, scale, flags) {\n        super();\n        this.type = ShapeType.HeightField;\n        this.nrows = nrows;\n        this.ncols = ncols;\n        this.heights = heights;\n        this.scale = scale;\n        this.flags = flags;\n    }\n    intoRaw() {\n        let rawScale = VectorOps.intoRaw(this.scale);\n        let rawShape = RawShape.heightfield(this.nrows, this.ncols, this.heights, rawScale, this.flags);\n        rawScale.free();\n        return rawShape;\n    }\n}\n/**\n * A shape that is a 3D cylinder.\n */\nexport class Cylinder extends Shape {\n    /**\n     * Creates a new cylinder with the given radius and half-height.\n     * @param halfHeight - The balls half-height along the `y` axis.\n     * @param radius - The balls radius.\n     */\n    constructor(halfHeight, radius) {\n        super();\n        this.type = ShapeType.Cylinder;\n        this.halfHeight = halfHeight;\n        this.radius = radius;\n    }\n    intoRaw() {\n        return RawShape.cylinder(this.halfHeight, this.radius);\n    }\n}\n/**\n * A shape that is a 3D cylinder with round corners.\n */\nexport class RoundCylinder extends Shape {\n    /**\n     * Creates a new cylinder with the given radius and half-height.\n     * @param halfHeight - The balls half-height along the `y` axis.\n     * @param radius - The balls radius.\n     * @param borderRadius - The radius of the borders of this cylinder.\n     */\n    constructor(halfHeight, radius, borderRadius) {\n        super();\n        this.type = ShapeType.RoundCylinder;\n        this.borderRadius = borderRadius;\n        this.halfHeight = halfHeight;\n        this.radius = radius;\n    }\n    intoRaw() {\n        return RawShape.roundCylinder(this.halfHeight, this.radius, this.borderRadius);\n    }\n}\n/**\n * A shape that is a 3D cone.\n */\nexport class Cone extends Shape {\n    /**\n     * Creates a new cone with the given radius and half-height.\n     * @param halfHeight - The balls half-height along the `y` axis.\n     * @param radius - The balls radius.\n     */\n    constructor(halfHeight, radius) {\n        super();\n        this.type = ShapeType.Cone;\n        this.halfHeight = halfHeight;\n        this.radius = radius;\n    }\n    intoRaw() {\n        return RawShape.cone(this.halfHeight, this.radius);\n    }\n}\n/**\n * A shape that is a 3D cone with round corners.\n */\nexport class RoundCone extends Shape {\n    /**\n     * Creates a new cone with the given radius and half-height.\n     * @param halfHeight - The balls half-height along the `y` axis.\n     * @param radius - The balls radius.\n     * @param borderRadius - The radius of the borders of this cone.\n     */\n    constructor(halfHeight, radius, borderRadius) {\n        super();\n        this.type = ShapeType.RoundCone;\n        this.halfHeight = halfHeight;\n        this.radius = radius;\n        this.borderRadius = borderRadius;\n    }\n    intoRaw() {\n        return RawShape.roundCone(this.halfHeight, this.radius, this.borderRadius);\n    }\n}\n// #endif\n//# sourceMappingURL=shape.js.map"],"names":["Shape","fromRaw","rawSet","handle","rawType","coShapeType","extents","borderRadius","vs","indices","halfHeight","radius","normal","RawShapeType","Ball","coRadius","Cuboid","coHalfExtents","x","y","z","RoundCuboid","coRoundRadius","Capsule","coHalfHeight","Segment","coVertices","VectorOps","new","Polyline","coIndices","Triangle","RoundTriangle","HalfSpace","coHalfspaceNormal","Voxels","vox_data","coVoxelData","vox_size","coVoxelSize","TriMesh","tri_flags","coTriMeshFlags","HeightField","scale","coHeightfieldScale","heights","coHeightfieldHeights","nrows","coHeightfieldNRows","ncols","coHeightfieldNCols","hf_flags","coHeightFieldFlags","Heightfield","ConvexPolyhedron","RoundConvexPolyhedron","Cylinder","RoundCylinder","Cone","RoundCone","Error","castShape","shapePos1","shapeRot1","shapeVel1","shape2","shapePos2","shapeRot2","shapeVel2","targetDistance","maxToi","stopAtPenetration","rawPos1","intoRaw","rawRot1","RotationOps","rawVel1","rawPos2","rawRot2","rawVel2","rawShape1","this","rawShape2","result","ShapeCastHit","free","intersectsShape","contactShape","prediction","ShapeContact","containsPoint","shapePos","shapeRot","point","rawPos","rawRot","rawPoint","rawShape","projectPoint","solid","PointProjection","intersectsRay","ray","rawRayOrig","origin","rawRayDir","dir","castRay","castRayAndGetNormal","RayIntersection","ShapeType","HeightFieldFlags","TriMeshFlags","constructor","super","type","RawShape","ball","n","halfspace","hx","hy","hz","halfExtents","cuboid","roundCuboid","capsule","a","b","ra","rb","segment","c","rc","triangle","roundTriangle","vertices","Uint32Array","polyline","data","voxelSize","Int32Array","voxels","voxelsFromPoints","flags","trimesh","convexMesh","convexHull","roundConvexMesh","roundConvexHull","rawScale","heightfield","cylinder","roundCylinder","cone","roundCone"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/toi.js

@@ -0,0 +1,2 @@
+import{VectorOps}from"../math.js";class ShapeCastHit{constructor(time_of_impact,witness1,witness2,normal1,normal2){this.time_of_impact=time_of_impact,this.witness1=witness1,this.witness2=witness2,this.normal1=normal1,this.normal2=normal2}static fromRaw(colliderSet,raw){if(!raw)return null;const result=new ShapeCastHit(raw.time_of_impact(),VectorOps.fromRaw(raw.witness1()),VectorOps.fromRaw(raw.witness2()),VectorOps.fromRaw(raw.normal1()),VectorOps.fromRaw(raw.normal2()));return raw.free(),result}}class ColliderShapeCastHit extends ShapeCastHit{constructor(collider,time_of_impact,witness1,witness2,normal1,normal2){super(time_of_impact,witness1,witness2,normal1,normal2),this.collider=collider}static fromRaw(colliderSet,raw){if(!raw)return null;const result=new ColliderShapeCastHit(colliderSet.get(raw.colliderHandle()),raw.time_of_impact(),VectorOps.fromRaw(raw.witness1()),VectorOps.fromRaw(raw.witness2()),VectorOps.fromRaw(raw.normal1()),VectorOps.fromRaw(raw.normal2()));return raw.free(),result}}export{ColliderShapeCastHit,ShapeCastHit};
+//# sourceMappingURL=toi.js.map

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/toi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toi.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/geometry/toi.js"],"sourcesContent":["import { VectorOps } from \"../math\";\n/**\n * The intersection between a ray and a collider.\n */\nexport class ShapeCastHit {\n    constructor(time_of_impact, witness1, witness2, normal1, normal2) {\n        this.time_of_impact = time_of_impact;\n        this.witness1 = witness1;\n        this.witness2 = witness2;\n        this.normal1 = normal1;\n        this.normal2 = normal2;\n    }\n    static fromRaw(colliderSet, raw) {\n        if (!raw)\n            return null;\n        const result = new ShapeCastHit(raw.time_of_impact(), VectorOps.fromRaw(raw.witness1()), VectorOps.fromRaw(raw.witness2()), VectorOps.fromRaw(raw.normal1()), VectorOps.fromRaw(raw.normal2()));\n        raw.free();\n        return result;\n    }\n}\n/**\n * The intersection between a ray and a collider.\n */\nexport class ColliderShapeCastHit extends ShapeCastHit {\n    constructor(collider, time_of_impact, witness1, witness2, normal1, normal2) {\n        super(time_of_impact, witness1, witness2, normal1, normal2);\n        this.collider = collider;\n    }\n    static fromRaw(colliderSet, raw) {\n        if (!raw)\n            return null;\n        const result = new ColliderShapeCastHit(colliderSet.get(raw.colliderHandle()), raw.time_of_impact(), VectorOps.fromRaw(raw.witness1()), VectorOps.fromRaw(raw.witness2()), VectorOps.fromRaw(raw.normal1()), VectorOps.fromRaw(raw.normal2()));\n        raw.free();\n        return result;\n    }\n}\n//# sourceMappingURL=toi.js.map"],"names":["ShapeCastHit","constructor","time_of_impact","witness1","witness2","normal1","normal2","this","fromRaw","colliderSet","raw","result","VectorOps","free","ColliderShapeCastHit","collider","super","get","colliderHandle"],"mappings":"kCAIO,MAAMA,aACT,WAAAC,CAAYC,eAAgBC,SAAUC,SAAUC,QAASC,SACrDC,KAAKL,eAAiBA,eACtBK,KAAKJ,SAAWA,SAChBI,KAAKH,SAAWA,SAChBG,KAAKF,QAAUA,QACfE,KAAKD,QAAUA,OACnB,CACA,cAAOE,CAAQC,YAAaC,KACxB,IAAKA,IACD,OAAO,KACX,MAAMC,OAAS,IAAIX,aAAaU,IAAIR,iBAAkBU,UAAUJ,QAAQE,IAAIP,YAAaS,UAAUJ,QAAQE,IAAIN,YAAaQ,UAAUJ,QAAQE,IAAIL,WAAYO,UAAUJ,QAAQE,IAAIJ,YAEpL,OADAI,IAAIG,OACGF,MACX,EAKG,MAAMG,6BAA6Bd,aACtC,WAAAC,CAAYc,SAAUb,eAAgBC,SAAUC,SAAUC,QAASC,SAC/DU,MAAMd,eAAgBC,SAAUC,SAAUC,QAASC,SACnDC,KAAKQ,SAAWA,QACpB,CACA,cAAOP,CAAQC,YAAaC,KACxB,IAAKA,IACD,OAAO,KACX,MAAMC,OAAS,IAAIG,qBAAqBL,YAAYQ,IAAIP,IAAIQ,kBAAmBR,IAAIR,iBAAkBU,UAAUJ,QAAQE,IAAIP,YAAaS,UAAUJ,QAAQE,IAAIN,YAAaQ,UAAUJ,QAAQE,IAAIL,WAAYO,UAAUJ,QAAQE,IAAIJ,YAEnO,OADAI,IAAIG,OACGF,MACX","x_google_ignoreList":[0]}

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/math.js

@@ -0,0 +1,2 @@
+import"./rapier_wasm3d.js";import{RawVector,RawRotation}from"./rapier_wasm3d_bg.js";class Vector3{constructor(x,y,z){this.x=x,this.y=y,this.z=z}}class VectorOps{static new(x,y,z){return new Vector3(x,y,z)}static intoRaw(v){return new RawVector(v.x,v.y,v.z)}static zeros(){return VectorOps.new(0,0,0)}static fromRaw(raw){if(!raw)return null;let res=VectorOps.new(raw.x,raw.y,raw.z);return raw.free(),res}static copy(out,input){out.x=input.x,out.y=input.y,out.z=input.z}}class Quaternion{constructor(x,y,z,w){this.x=x,this.y=y,this.z=z,this.w=w}}class RotationOps{static identity(){return new Quaternion(0,0,0,1)}static fromRaw(raw){if(!raw)return null;let res=new Quaternion(raw.x,raw.y,raw.z,raw.w);return raw.free(),res}static intoRaw(rot){return new RawRotation(rot.x,rot.y,rot.z,rot.w)}static copy(out,input){out.x=input.x,out.y=input.y,out.z=input.z,out.w=input.w}}class SdpMatrix3{get m11(){return this.elements[0]}get m12(){return this.elements[1]}get m21(){return this.m12}get m13(){return this.elements[2]}get m31(){return this.m13}get m22(){return this.elements[3]}get m23(){return this.elements[4]}get m32(){return this.m23}get m33(){return this.elements[5]}constructor(elements){this.elements=elements}}class SdpMatrix3Ops{static fromRaw(raw){const sdpMatrix3=new SdpMatrix3(raw.elements());return raw.free(),sdpMatrix3}}export{Quaternion,RotationOps,SdpMatrix3,SdpMatrix3Ops,Vector3,VectorOps};
+//# sourceMappingURL=math.js.map

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/math.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.js","sources":["../../../../../../../../../../../node_modules/@dimforge/rapier3d/math.js"],"sourcesContent":["import { RawVector, RawRotation } from \"./raw\";\n/**\n * A 3D vector.\n */\nexport class Vector3 {\n    constructor(x, y, z) {\n        this.x = x;\n        this.y = y;\n        this.z = z;\n    }\n}\nexport class VectorOps {\n    static new(x, y, z) {\n        return new Vector3(x, y, z);\n    }\n    static intoRaw(v) {\n        return new RawVector(v.x, v.y, v.z);\n    }\n    static zeros() {\n        return VectorOps.new(0.0, 0.0, 0.0);\n    }\n    // FIXME: type ram: RawVector?\n    static fromRaw(raw) {\n        if (!raw)\n            return null;\n        let res = VectorOps.new(raw.x, raw.y, raw.z);\n        raw.free();\n        return res;\n    }\n    static copy(out, input) {\n        out.x = input.x;\n        out.y = input.y;\n        out.z = input.z;\n    }\n}\n/**\n * A quaternion.\n */\nexport class Quaternion {\n    constructor(x, y, z, w) {\n        this.x = x;\n        this.y = y;\n        this.z = z;\n        this.w = w;\n    }\n}\nexport class RotationOps {\n    static identity() {\n        return new Quaternion(0.0, 0.0, 0.0, 1.0);\n    }\n    static fromRaw(raw) {\n        if (!raw)\n            return null;\n        let res = new Quaternion(raw.x, raw.y, raw.z, raw.w);\n        raw.free();\n        return res;\n    }\n    static intoRaw(rot) {\n        return new RawRotation(rot.x, rot.y, rot.z, rot.w);\n    }\n    static copy(out, input) {\n        out.x = input.x;\n        out.y = input.y;\n        out.z = input.z;\n        out.w = input.w;\n    }\n}\n/**\n * A 3D symmetric-positive-definite matrix.\n */\nexport class SdpMatrix3 {\n    /**\n     * Matrix element at row 1, column 1.\n     */\n    get m11() {\n        return this.elements[0];\n    }\n    /**\n     * Matrix element at row 1, column 2.\n     */\n    get m12() {\n        return this.elements[1];\n    }\n    /**\n     * Matrix element at row 2, column 1.\n     */\n    get m21() {\n        return this.m12;\n    }\n    /**\n     * Matrix element at row 1, column 3.\n     */\n    get m13() {\n        return this.elements[2];\n    }\n    /**\n     * Matrix element at row 3, column 1.\n     */\n    get m31() {\n        return this.m13;\n    }\n    /**\n     * Matrix element at row 2, column 2.\n     */\n    get m22() {\n        return this.elements[3];\n    }\n    /**\n     * Matrix element at row 2, column 3.\n     */\n    get m23() {\n        return this.elements[4];\n    }\n    /**\n     * Matrix element at row 3, column 2.\n     */\n    get m32() {\n        return this.m23;\n    }\n    /**\n     * Matrix element at row 3, column 3.\n     */\n    get m33() {\n        return this.elements[5];\n    }\n    constructor(elements) {\n        this.elements = elements;\n    }\n}\nexport class SdpMatrix3Ops {\n    static fromRaw(raw) {\n        const sdpMatrix3 = new SdpMatrix3(raw.elements());\n        raw.free();\n        return sdpMatrix3;\n    }\n}\n// #endif\n//# sourceMappingURL=math.js.map"],"names":["Vector3","constructor","x","y","z","this","VectorOps","intoRaw","v","RawVector","zeros","new","fromRaw","raw","res","free","copy","out","input","Quaternion","w","RotationOps","identity","rot","RawRotation","SdpMatrix3","m11","elements","m12","m21","m13","m31","m22","m23","m32","m33","SdpMatrix3Ops","sdpMatrix3"],"mappings":"oFAIO,MAAMA,QACT,WAAAC,CAAYC,EAAGC,EAAGC,GACdC,KAAKH,EAAIA,EACTG,KAAKF,EAAIA,EACTE,KAAKD,EAAIA,CACb,EAEG,MAAME,UACT,UAAO,CAAIJ,EAAGC,EAAGC,GACb,OAAO,IAAIJ,QAAQE,EAAGC,EAAGC,EAC7B,CACA,cAAOG,CAAQC,GACX,OAAO,IAAIC,UAAUD,EAAEN,EAAGM,EAAEL,EAAGK,EAAEJ,EACrC,CACA,YAAOM,GACH,OAAOJ,UAAUK,IAAI,EAAK,EAAK,EACnC,CAEA,cAAOC,CAAQC,KACX,IAAKA,IACD,OAAO,KACX,IAAIC,IAAMR,UAAUK,IAAIE,IAAIX,EAAGW,IAAIV,EAAGU,IAAIT,GAE1C,OADAS,IAAIE,OACGD,GACX,CACA,WAAOE,CAAKC,IAAKC,OACbD,IAAIf,EAAIgB,MAAMhB,EACde,IAAId,EAAIe,MAAMf,EACdc,IAAIb,EAAIc,MAAMd,CAClB,EAKG,MAAMe,WACT,WAAAlB,CAAYC,EAAGC,EAAGC,EAAGgB,GACjBf,KAAKH,EAAIA,EACTG,KAAKF,EAAIA,EACTE,KAAKD,EAAIA,EACTC,KAAKe,EAAIA,CACb,EAEG,MAAMC,YACT,eAAOC,GACH,OAAO,IAAIH,WAAW,EAAK,EAAK,EAAK,EACzC,CACA,cAAOP,CAAQC,KACX,IAAKA,IACD,OAAO,KACX,IAAIC,IAAM,IAAIK,WAAWN,IAAIX,EAAGW,IAAIV,EAAGU,IAAIT,EAAGS,IAAIO,GAElD,OADAP,IAAIE,OACGD,GACX,CACA,cAAOP,CAAQgB,KACX,OAAO,IAAIC,YAAYD,IAAIrB,EAAGqB,IAAIpB,EAAGoB,IAAInB,EAAGmB,IAAIH,EACpD,CACA,WAAOJ,CAAKC,IAAKC,OACbD,IAAIf,EAAIgB,MAAMhB,EACde,IAAId,EAAIe,MAAMf,EACdc,IAAIb,EAAIc,MAAMd,EACda,IAAIG,EAAIF,MAAME,CAClB,EAKG,MAAMK,WAIT,OAAIC,GACA,OAAOrB,KAAKsB,SAAS,EACzB,CAIA,OAAIC,GACA,OAAOvB,KAAKsB,SAAS,EACzB,CAIA,OAAIE,GACA,OAAOxB,KAAKuB,GAChB,CAIA,OAAIE,GACA,OAAOzB,KAAKsB,SAAS,EACzB,CAIA,OAAII,GACA,OAAO1B,KAAKyB,GAChB,CAIA,OAAIE,GACA,OAAO3B,KAAKsB,SAAS,EACzB,CAIA,OAAIM,GACA,OAAO5B,KAAKsB,SAAS,EACzB,CAIA,OAAIO,GACA,OAAO7B,KAAK4B,GAChB,CAIA,OAAIE,GACA,OAAO9B,KAAKsB,SAAS,EACzB,CACA,WAAA1B,CAAY0B,UACRtB,KAAKsB,SAAWA,QACpB,EAEG,MAAMS,cACT,cAAOxB,CAAQC,KACX,MAAMwB,WAAa,IAAIZ,WAAWZ,IAAIc,YAEtC,OADAd,IAAIE,OACGsB,UACX","x_google_ignoreList":[0]}

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/pipeline/debug_render_pipeline.js

@@ -0,0 +1,2 @@
+import"../rapier_wasm3d.js";import{RawDebugRenderPipeline}from"../rapier_wasm3d_bg.js";class DebugRenderBuffers{constructor(vertices,colors){this.vertices=vertices,this.colors=colors}}class DebugRenderPipeline{free(){this.raw&&this.raw.free(),this.raw=void 0,this.vertices=void 0,this.colors=void 0}constructor(raw){this.raw=raw||new RawDebugRenderPipeline}render(bodies,colliders,impulse_joints,multibody_joints,narrow_phase,filterFlags,filterPredicate){this.raw.render(bodies.raw,colliders.raw,impulse_joints.raw,multibody_joints.raw,narrow_phase.raw,filterFlags,colliders.castClosure(filterPredicate)),this.vertices=this.raw.vertices(),this.colors=this.raw.colors()}}export{DebugRenderBuffers,DebugRenderPipeline};
+//# sourceMappingURL=debug_render_pipeline.js.map

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/pipeline/debug_render_pipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug_render_pipeline.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/pipeline/debug_render_pipeline.js"],"sourcesContent":["import { RawDebugRenderPipeline } from \"../raw\";\n/**\n * The vertex and color buffers for debug-redering the physics scene.\n */\nexport class DebugRenderBuffers {\n    constructor(vertices, colors) {\n        this.vertices = vertices;\n        this.colors = colors;\n    }\n}\n/**\n * A pipeline for rendering the physics scene.\n *\n * To avoid leaking WASM resources, this MUST be freed manually with `debugRenderPipeline.free()`\n * once you are done using it (and all the rigid-bodies it created).\n */\nexport class DebugRenderPipeline {\n    /**\n     * Release the WASM memory occupied by this serialization pipeline.\n     */\n    free() {\n        if (!!this.raw) {\n            this.raw.free();\n        }\n        this.raw = undefined;\n        this.vertices = undefined;\n        this.colors = undefined;\n    }\n    constructor(raw) {\n        this.raw = raw || new RawDebugRenderPipeline();\n    }\n    render(bodies, colliders, impulse_joints, multibody_joints, narrow_phase, filterFlags, filterPredicate) {\n        this.raw.render(bodies.raw, colliders.raw, impulse_joints.raw, multibody_joints.raw, narrow_phase.raw, filterFlags, colliders.castClosure(filterPredicate));\n        this.vertices = this.raw.vertices();\n        this.colors = this.raw.colors();\n    }\n}\n//# sourceMappingURL=debug_render_pipeline.js.map"],"names":["DebugRenderBuffers","constructor","vertices","colors","this","DebugRenderPipeline","free","raw","undefined","RawDebugRenderPipeline","render","bodies","colliders","impulse_joints","multibody_joints","narrow_phase","filterFlags","filterPredicate","castClosure"],"mappings":"uFAIO,MAAMA,mBACT,WAAAC,CAAYC,SAAUC,QAClBC,KAAKF,SAAWA,SAChBE,KAAKD,OAASA,MAClB,EAQG,MAAME,oBAIT,IAAAC,GACUF,KAAKG,KACPH,KAAKG,IAAID,OAEbF,KAAKG,SAAMC,EACXJ,KAAKF,cAAWM,EAChBJ,KAAKD,YAASK,CAClB,CACA,WAAAP,CAAYM,KACRH,KAAKG,IAAMA,KAAO,IAAIE,sBAC1B,CACA,MAAAC,CAAOC,OAAQC,UAAWC,eAAgBC,iBAAkBC,aAAcC,YAAaC,iBACnFb,KAAKG,IAAIG,OAAOC,OAAOJ,IAAKK,UAAUL,IAAKM,eAAeN,IAAKO,iBAAiBP,IAAKQ,aAAaR,IAAKS,YAAaJ,UAAUM,YAAYD,kBAC1Ib,KAAKF,SAAWE,KAAKG,IAAIL,WACzBE,KAAKD,OAASC,KAAKG,IAAIJ,QAC3B","x_google_ignoreList":[0]}

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/pipeline/event_queue.js

@@ -0,0 +1,2 @@
+import"../rapier_wasm3d.js";var ActiveEvents;!function(ActiveEvents){ActiveEvents[ActiveEvents.NONE=0]="NONE",ActiveEvents[ActiveEvents.COLLISION_EVENTS=1]="COLLISION_EVENTS",ActiveEvents[ActiveEvents.CONTACT_FORCE_EVENTS=2]="CONTACT_FORCE_EVENTS"}(ActiveEvents||(ActiveEvents={}));export{ActiveEvents};
+//# sourceMappingURL=event_queue.js.map

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/pipeline/event_queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event_queue.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/pipeline/event_queue.js"],"sourcesContent":["import { RawEventQueue } from \"../raw\";\nimport { VectorOps } from \"../math\";\n/**\n * Flags indicating what events are enabled for colliders.\n */\nexport var ActiveEvents;\n(function (ActiveEvents) {\n    ActiveEvents[ActiveEvents[\"NONE\"] = 0] = \"NONE\";\n    /**\n     * Enable collision events.\n     */\n    ActiveEvents[ActiveEvents[\"COLLISION_EVENTS\"] = 1] = \"COLLISION_EVENTS\";\n    /**\n     * Enable contact force events.\n     */\n    ActiveEvents[ActiveEvents[\"CONTACT_FORCE_EVENTS\"] = 2] = \"CONTACT_FORCE_EVENTS\";\n})(ActiveEvents || (ActiveEvents = {}));\n/**\n * Event occurring when the sum of the magnitudes of the\n * contact forces between two colliders exceed a threshold.\n *\n * This object should **not** be stored anywhere. Its properties can only be\n * read from within the closure given to `EventHandler.drainContactForceEvents`.\n */\nexport class TempContactForceEvent {\n    free() {\n        if (!!this.raw) {\n            this.raw.free();\n        }\n        this.raw = undefined;\n    }\n    /**\n     * The first collider involved in the contact.\n     */\n    collider1() {\n        return this.raw.collider1();\n    }\n    /**\n     * The second collider involved in the contact.\n     */\n    collider2() {\n        return this.raw.collider2();\n    }\n    /**\n     * The sum of all the forces between the two colliders.\n     */\n    totalForce() {\n        return VectorOps.fromRaw(this.raw.total_force());\n    }\n    /**\n     * The sum of the magnitudes of each force between the two colliders.\n     *\n     * Note that this is **not** the same as the magnitude of `self.total_force`.\n     * Here we are summing the magnitude of all the forces, instead of taking\n     * the magnitude of their sum.\n     */\n    totalForceMagnitude() {\n        return this.raw.total_force_magnitude();\n    }\n    /**\n     * The world-space (unit) direction of the force with strongest magnitude.\n     */\n    maxForceDirection() {\n        return VectorOps.fromRaw(this.raw.max_force_direction());\n    }\n    /**\n     * The magnitude of the largest force at a contact point of this contact pair.\n     */\n    maxForceMagnitude() {\n        return this.raw.max_force_magnitude();\n    }\n}\n/**\n * A structure responsible for collecting events generated\n * by the physics engine.\n *\n * To avoid leaking WASM resources, this MUST be freed manually with `eventQueue.free()`\n * once you are done using it.\n */\nexport class EventQueue {\n    /**\n     * Creates a new event collector.\n     *\n     * @param autoDrain -setting this to `true` is strongly recommended. If true, the collector will\n     * be automatically drained before each `world.step(collector)`. If false, the collector will\n     * keep all events in memory unless it is manually drained/cleared; this may lead to unbounded use of\n     * RAM if no drain is performed.\n     */\n    constructor(autoDrain, raw) {\n        this.raw = raw || new RawEventQueue(autoDrain);\n    }\n    /**\n     * Release the WASM memory occupied by this event-queue.\n     */\n    free() {\n        if (!!this.raw) {\n            this.raw.free();\n        }\n        this.raw = undefined;\n    }\n    /**\n     * Applies the given javascript closure on each collision event of this collector, then clear\n     * the internal collision event buffer.\n     *\n     * @param f - JavaScript closure applied to each collision event. The\n     * closure must take three arguments: two integers representing the handles of the colliders\n     * involved in the collision, and a boolean indicating if the collision started (true) or stopped\n     * (false).\n     */\n    drainCollisionEvents(f) {\n        this.raw.drainCollisionEvents(f);\n    }\n    /**\n     * Applies the given javascript closure on each contact force event of this collector, then clear\n     * the internal collision event buffer.\n     *\n     * @param f - JavaScript closure applied to each collision event. The\n     *            closure must take one `TempContactForceEvent` argument.\n     */\n    drainContactForceEvents(f) {\n        let event = new TempContactForceEvent();\n        this.raw.drainContactForceEvents((raw) => {\n            event.raw = raw;\n            f(event);\n            event.free();\n        });\n    }\n    /**\n     * Removes all events contained by this collector\n     */\n    clear() {\n        this.raw.clear();\n    }\n}\n//# sourceMappingURL=event_queue.js.map"],"names":["ActiveEvents"],"mappings":"4BAKU,IAACA,cACX,SAAWA,cACPA,aAAaA,aAAmB,KAAI,GAAK,OAIzCA,aAAaA,aAA+B,iBAAI,GAAK,mBAIrDA,aAAaA,aAAmC,qBAAI,GAAK,sBAC5D,CAVD,CAUGA,eAAiBA,aAAe,CAAA","x_google_ignoreList":[0]}

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/pipeline/physics_hooks.js

@@ -0,0 +1,2 @@
+var ActiveHooks,SolverFlags;!function(ActiveHooks){ActiveHooks[ActiveHooks.NONE=0]="NONE",ActiveHooks[ActiveHooks.FILTER_CONTACT_PAIRS=1]="FILTER_CONTACT_PAIRS",ActiveHooks[ActiveHooks.FILTER_INTERSECTION_PAIRS=2]="FILTER_INTERSECTION_PAIRS"}(ActiveHooks||(ActiveHooks={})),function(SolverFlags){SolverFlags[SolverFlags.EMPTY=0]="EMPTY",SolverFlags[SolverFlags.COMPUTE_IMPULSE=1]="COMPUTE_IMPULSE"}(SolverFlags||(SolverFlags={}));export{ActiveHooks,SolverFlags};
+//# sourceMappingURL=physics_hooks.js.map

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/pipeline/physics_hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"physics_hooks.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/pipeline/physics_hooks.js"],"sourcesContent":["export var ActiveHooks;\n(function (ActiveHooks) {\n    ActiveHooks[ActiveHooks[\"NONE\"] = 0] = \"NONE\";\n    ActiveHooks[ActiveHooks[\"FILTER_CONTACT_PAIRS\"] = 1] = \"FILTER_CONTACT_PAIRS\";\n    ActiveHooks[ActiveHooks[\"FILTER_INTERSECTION_PAIRS\"] = 2] = \"FILTER_INTERSECTION_PAIRS\";\n    // MODIFY_SOLVER_CONTACTS = 0b0100, /* Not supported yet in JS. */\n})(ActiveHooks || (ActiveHooks = {}));\nexport var SolverFlags;\n(function (SolverFlags) {\n    SolverFlags[SolverFlags[\"EMPTY\"] = 0] = \"EMPTY\";\n    SolverFlags[SolverFlags[\"COMPUTE_IMPULSE\"] = 1] = \"COMPUTE_IMPULSE\";\n})(SolverFlags || (SolverFlags = {}));\n//# sourceMappingURL=physics_hooks.js.map"],"names":["ActiveHooks","SolverFlags"],"mappings":"AAAU,IAACA,YAOAC,aANX,SAAWD,aACPA,YAAYA,YAAkB,KAAI,GAAK,OACvCA,YAAYA,YAAkC,qBAAI,GAAK,uBACvDA,YAAYA,YAAuC,0BAAI,GAAK,2BAE/D,CALD,CAKGA,cAAgBA,YAAc,CAAA,IAEjC,SAAWC,aACPA,YAAYA,YAAmB,MAAI,GAAK,QACxCA,YAAYA,YAA6B,gBAAI,GAAK,iBACrD,CAHD,CAGGA,cAAgBA,YAAc,CAAA","x_google_ignoreList":[0]}

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/pipeline/physics_pipeline.js

@@ -0,0 +1,2 @@
+import"../rapier_wasm3d.js";import{VectorOps}from"../math.js";import{RawPhysicsPipeline}from"../rapier_wasm3d_bg.js";class PhysicsPipeline{free(){this.raw&&this.raw.free(),this.raw=void 0}constructor(raw){this.raw=raw||new RawPhysicsPipeline}step(gravity,integrationParameters,islands,broadPhase,narrowPhase,bodies,colliders,impulseJoints,multibodyJoints,ccdSolver,eventQueue,hooks){let rawG=VectorOps.intoRaw(gravity);eventQueue?this.raw.stepWithEvents(rawG,integrationParameters.raw,islands.raw,broadPhase.raw,narrowPhase.raw,bodies.raw,colliders.raw,impulseJoints.raw,multibodyJoints.raw,ccdSolver.raw,eventQueue.raw,hooks,hooks?hooks.filterContactPair:null,hooks?hooks.filterIntersectionPair:null):this.raw.step(rawG,integrationParameters.raw,islands.raw,broadPhase.raw,narrowPhase.raw,bodies.raw,colliders.raw,impulseJoints.raw,multibodyJoints.raw,ccdSolver.raw),rawG.free()}}export{PhysicsPipeline};
+//# sourceMappingURL=physics_pipeline.js.map

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/pipeline/physics_pipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"physics_pipeline.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/pipeline/physics_pipeline.js"],"sourcesContent":["import { RawPhysicsPipeline } from \"../raw\";\nimport { VectorOps } from \"../math\";\nexport class PhysicsPipeline {\n    free() {\n        if (!!this.raw) {\n            this.raw.free();\n        }\n        this.raw = undefined;\n    }\n    constructor(raw) {\n        this.raw = raw || new RawPhysicsPipeline();\n    }\n    step(gravity, integrationParameters, islands, broadPhase, narrowPhase, bodies, colliders, impulseJoints, multibodyJoints, ccdSolver, eventQueue, hooks) {\n        let rawG = VectorOps.intoRaw(gravity);\n        if (!!eventQueue) {\n            this.raw.stepWithEvents(rawG, integrationParameters.raw, islands.raw, broadPhase.raw, narrowPhase.raw, bodies.raw, colliders.raw, impulseJoints.raw, multibodyJoints.raw, ccdSolver.raw, eventQueue.raw, hooks, !!hooks ? hooks.filterContactPair : null, !!hooks ? hooks.filterIntersectionPair : null);\n        }\n        else {\n            this.raw.step(rawG, integrationParameters.raw, islands.raw, broadPhase.raw, narrowPhase.raw, bodies.raw, colliders.raw, impulseJoints.raw, multibodyJoints.raw, ccdSolver.raw);\n        }\n        rawG.free();\n    }\n}\n//# sourceMappingURL=physics_pipeline.js.map"],"names":["PhysicsPipeline","free","this","raw","undefined","constructor","RawPhysicsPipeline","step","gravity","integrationParameters","islands","broadPhase","narrowPhase","bodies","colliders","impulseJoints","multibodyJoints","ccdSolver","eventQueue","hooks","rawG","VectorOps","intoRaw","stepWithEvents","filterContactPair","filterIntersectionPair"],"mappings":"qHAEO,MAAMA,gBACT,IAAAC,GACUC,KAAKC,KACPD,KAAKC,IAAIF,OAEbC,KAAKC,SAAMC,CACf,CACA,WAAAC,CAAYF,KACRD,KAAKC,IAAMA,KAAO,IAAIG,kBAC1B,CACA,IAAAC,CAAKC,QAASC,sBAAuBC,QAASC,WAAYC,YAAaC,OAAQC,UAAWC,cAAeC,gBAAiBC,UAAWC,WAAYC,OAC7I,IAAIC,KAAOC,UAAUC,QAAQd,SACvBU,WACFhB,KAAKC,IAAIoB,eAAeH,KAAMX,sBAAsBN,IAAKO,QAAQP,IAAKQ,WAAWR,IAAKS,YAAYT,IAAKU,OAAOV,IAAKW,UAAUX,IAAKY,cAAcZ,IAAKa,gBAAgBb,IAAKc,UAAUd,IAAKe,WAAWf,IAAKgB,MAASA,MAAQA,MAAMK,kBAAoB,KAAQL,MAAQA,MAAMM,uBAAyB,MAGnSvB,KAAKC,IAAII,KAAKa,KAAMX,sBAAsBN,IAAKO,QAAQP,IAAKQ,WAAWR,IAAKS,YAAYT,IAAKU,OAAOV,IAAKW,UAAUX,IAAKY,cAAcZ,IAAKa,gBAAgBb,IAAKc,UAAUd,KAE9KiB,KAAKnB,MACT","x_google_ignoreList":[0]}

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/pipeline/serialization_pipeline.js

@@ -0,0 +1,2 @@
+import"../rapier_wasm3d.js";import{VectorOps}from"../math.js";import{World}from"./world.js";import{RawSerializationPipeline}from"../rapier_wasm3d_bg.js";class SerializationPipeline{free(){this.raw&&this.raw.free(),this.raw=void 0}constructor(raw){this.raw=raw||new RawSerializationPipeline}serializeAll(gravity,integrationParameters,islands,broadPhase,narrowPhase,bodies,colliders,impulseJoints,multibodyJoints){let rawGra=VectorOps.intoRaw(gravity);const res=this.raw.serializeAll(rawGra,integrationParameters.raw,islands.raw,broadPhase.raw,narrowPhase.raw,bodies.raw,colliders.raw,impulseJoints.raw,multibodyJoints.raw);return rawGra.free(),res}deserializeAll(data){return World.fromRaw(this.raw.deserializeAll(data))}}export{SerializationPipeline};
+//# sourceMappingURL=serialization_pipeline.js.map

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/pipeline/serialization_pipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialization_pipeline.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/pipeline/serialization_pipeline.js"],"sourcesContent":["import { RawSerializationPipeline } from \"../raw\";\nimport { VectorOps } from \"../math\";\nimport { World } from \"./world\";\n/**\n * A pipeline for serializing the physics scene.\n *\n * To avoid leaking WASM resources, this MUST be freed manually with `serializationPipeline.free()`\n * once you are done using it (and all the rigid-bodies it created).\n */\nexport class SerializationPipeline {\n    /**\n     * Release the WASM memory occupied by this serialization pipeline.\n     */\n    free() {\n        if (!!this.raw) {\n            this.raw.free();\n        }\n        this.raw = undefined;\n    }\n    constructor(raw) {\n        this.raw = raw || new RawSerializationPipeline();\n    }\n    /**\n     * Serialize a complete physics state into a single byte array.\n     * @param gravity - The current gravity affecting the simulation.\n     * @param integrationParameters - The integration parameters of the simulation.\n     * @param broadPhase - The broad-phase of the simulation.\n     * @param narrowPhase - The narrow-phase of the simulation.\n     * @param bodies - The rigid-bodies taking part into the simulation.\n     * @param colliders - The colliders taking part into the simulation.\n     * @param impulseJoints - The impulse joints taking part into the simulation.\n     * @param multibodyJoints - The multibody joints taking part into the simulation.\n     */\n    serializeAll(gravity, integrationParameters, islands, broadPhase, narrowPhase, bodies, colliders, impulseJoints, multibodyJoints) {\n        let rawGra = VectorOps.intoRaw(gravity);\n        const res = this.raw.serializeAll(rawGra, integrationParameters.raw, islands.raw, broadPhase.raw, narrowPhase.raw, bodies.raw, colliders.raw, impulseJoints.raw, multibodyJoints.raw);\n        rawGra.free();\n        return res;\n    }\n    /**\n     * Deserialize the complete physics state from a single byte array.\n     *\n     * @param data - The byte array to deserialize.\n     */\n    deserializeAll(data) {\n        return World.fromRaw(this.raw.deserializeAll(data));\n    }\n}\n//# sourceMappingURL=serialization_pipeline.js.map"],"names":["SerializationPipeline","free","this","raw","undefined","constructor","RawSerializationPipeline","serializeAll","gravity","integrationParameters","islands","broadPhase","narrowPhase","bodies","colliders","impulseJoints","multibodyJoints","rawGra","VectorOps","intoRaw","res","deserializeAll","data","World","fromRaw"],"mappings":"yJASO,MAAMA,sBAIT,IAAAC,GACUC,KAAKC,KACPD,KAAKC,IAAIF,OAEbC,KAAKC,SAAMC,CACf,CACA,WAAAC,CAAYF,KACRD,KAAKC,IAAMA,KAAO,IAAIG,wBAC1B,CAYA,YAAAC,CAAaC,QAASC,sBAAuBC,QAASC,WAAYC,YAAaC,OAAQC,UAAWC,cAAeC,iBAC7G,IAAIC,OAASC,UAAUC,QAAQX,SAC/B,MAAMY,IAAMlB,KAAKC,IAAII,aAAaU,OAAQR,sBAAsBN,IAAKO,QAAQP,IAAKQ,WAAWR,IAAKS,YAAYT,IAAKU,OAAOV,IAAKW,UAAUX,IAAKY,cAAcZ,IAAKa,gBAAgBb,KAEjL,OADAc,OAAOhB,OACAmB,GACX,CAMA,cAAAC,CAAeC,MACX,OAAOC,MAAMC,QAAQtB,KAAKC,IAAIkB,eAAeC,MACjD","x_google_ignoreList":[0]}

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/pipeline/world.js

@@ -0,0 +1,2 @@
+import{VectorOps}from"../math.js";import{PhysicsPipeline}from"./physics_pipeline.js";import{SerializationPipeline}from"./serialization_pipeline.js";import{DebugRenderPipeline,DebugRenderBuffers}from"./debug_render_pipeline.js";import{IntegrationParameters}from"../dynamics/integration_parameters.js";import{IslandManager}from"../dynamics/island_manager.js";import{BroadPhase}from"../geometry/broad_phase.js";import{NarrowPhase}from"../geometry/narrow_phase.js";import{RigidBodySet}from"../dynamics/rigid_body_set.js";import{ColliderSet}from"../geometry/collider_set.js";import{ImpulseJointSet}from"../dynamics/impulse_joint_set.js";import{MultibodyJointSet}from"../dynamics/multibody_joint_set.js";import{CCDSolver}from"../dynamics/ccd_solver.js";import{KinematicCharacterController}from"../control/character_controller.js";import{PidController}from"../control/pid_controller.js";import{DynamicRayCastVehicleController}from"../control/ray_cast_vehicle_controller.js";class World{free(){this.integrationParameters.free(),this.islands.free(),this.broadPhase.free(),this.narrowPhase.free(),this.bodies.free(),this.colliders.free(),this.impulseJoints.free(),this.multibodyJoints.free(),this.ccdSolver.free(),this.physicsPipeline.free(),this.serializationPipeline.free(),this.debugRenderPipeline.free(),this.characterControllers.forEach(controller=>controller.free()),this.pidControllers.forEach(controller=>controller.free()),this.vehicleControllers.forEach(controller=>controller.free()),this.integrationParameters=void 0,this.islands=void 0,this.broadPhase=void 0,this.narrowPhase=void 0,this.bodies=void 0,this.colliders=void 0,this.ccdSolver=void 0,this.impulseJoints=void 0,this.multibodyJoints=void 0,this.physicsPipeline=void 0,this.serializationPipeline=void 0,this.debugRenderPipeline=void 0,this.characterControllers=void 0,this.pidControllers=void 0,this.vehicleControllers=void 0}constructor(gravity,rawIntegrationParameters,rawIslands,rawBroadPhase,rawNarrowPhase,rawBodies,rawColliders,rawImpulseJoints,rawMultibodyJoints,rawCCDSolver,rawPhysicsPipeline,rawSerializationPipeline,rawDebugRenderPipeline){this.gravity=gravity,this.integrationParameters=new IntegrationParameters(rawIntegrationParameters),this.islands=new IslandManager(rawIslands),this.broadPhase=new BroadPhase(rawBroadPhase),this.narrowPhase=new NarrowPhase(rawNarrowPhase),this.bodies=new RigidBodySet(rawBodies),this.colliders=new ColliderSet(rawColliders),this.impulseJoints=new ImpulseJointSet(rawImpulseJoints),this.multibodyJoints=new MultibodyJointSet(rawMultibodyJoints),this.ccdSolver=new CCDSolver(rawCCDSolver),this.physicsPipeline=new PhysicsPipeline(rawPhysicsPipeline),this.serializationPipeline=new SerializationPipeline(rawSerializationPipeline),this.debugRenderPipeline=new DebugRenderPipeline(rawDebugRenderPipeline),this.characterControllers=new Set,this.pidControllers=new Set,this.vehicleControllers=new Set,this.impulseJoints.finalizeDeserialization(this.bodies),this.bodies.finalizeDeserialization(this.colliders),this.colliders.finalizeDeserialization(this.bodies)}static fromRaw(raw){return raw?new World(VectorOps.fromRaw(raw.takeGravity()),raw.takeIntegrationParameters(),raw.takeIslandManager(),raw.takeBroadPhase(),raw.takeNarrowPhase(),raw.takeBodies(),raw.takeColliders(),raw.takeImpulseJoints(),raw.takeMultibodyJoints()):null}takeSnapshot(){return this.serializationPipeline.serializeAll(this.gravity,this.integrationParameters,this.islands,this.broadPhase,this.narrowPhase,this.bodies,this.colliders,this.impulseJoints,this.multibodyJoints)}static restoreSnapshot(data){return(new SerializationPipeline).deserializeAll(data)}debugRender(filterFlags,filterPredicate){return this.debugRenderPipeline.render(this.bodies,this.colliders,this.impulseJoints,this.multibodyJoints,this.narrowPhase,filterFlags,filterPredicate),new DebugRenderBuffers(this.debugRenderPipeline.vertices,this.debugRenderPipeline.colors)}step(eventQueue,hooks){this.physicsPipeline.step(this.gravity,this.integrationParameters,this.islands,this.broadPhase,this.narrowPhase,this.bodies,this.colliders,this.impulseJoints,this.multibodyJoints,this.ccdSolver,eventQueue,hooks)}propagateModifiedBodyPositionsToColliders(){this.bodies.raw.propagateModifiedBodyPositionsToColliders(this.colliders.raw)}get timestep(){return this.integrationParameters.dt}set timestep(dt){this.integrationParameters.dt=dt}get lengthUnit(){return this.integrationParameters.lengthUnit}set lengthUnit(unitsPerMeter){this.integrationParameters.lengthUnit=unitsPerMeter}get numSolverIterations(){return this.integrationParameters.numSolverIterations}set numSolverIterations(niter){this.integrationParameters.numSolverIterations=niter}get numInternalPgsIterations(){return this.integrationParameters.numInternalPgsIterations}set numInternalPgsIterations(niter){this.integrationParameters.numInternalPgsIterations=niter}get maxCcdSubsteps(){return this.integrationParameters.maxCcdSubsteps}set maxCcdSubsteps(substeps){this.integrationParameters.maxCcdSubsteps=substeps}createRigidBody(body){return this.bodies.createRigidBody(this.colliders,body)}createCharacterController(offset){let controller=new KinematicCharacterController(offset,this.integrationParameters,this.broadPhase,this.narrowPhase,this.bodies,this.colliders);return this.characterControllers.add(controller),controller}removeCharacterController(controller){this.characterControllers.delete(controller),controller.free()}createPidController(kp,ki,kd,axes){let controller=new PidController(this.integrationParameters,this.bodies,kp,ki,kd,axes);return this.pidControllers.add(controller),controller}removePidController(controller){this.pidControllers.delete(controller),controller.free()}createVehicleController(chassis){let controller=new DynamicRayCastVehicleController(chassis,this.broadPhase,this.narrowPhase,this.bodies,this.colliders);return this.vehicleControllers.add(controller),controller}removeVehicleController(controller){this.vehicleControllers.delete(controller),controller.free()}createCollider(desc,parent){return this.colliders.createCollider(this.bodies,desc,parent?parent.handle:void 0)}createImpulseJoint(params,parent1,parent2,wakeUp){return this.impulseJoints.createJoint(this.bodies,params,parent1.handle,parent2.handle,wakeUp)}createMultibodyJoint(params,parent1,parent2,wakeUp){return this.multibodyJoints.createJoint(params,parent1.handle,parent2.handle,wakeUp)}getRigidBody(handle){return this.bodies.get(handle)}getCollider(handle){return this.colliders.get(handle)}getImpulseJoint(handle){return this.impulseJoints.get(handle)}getMultibodyJoint(handle){return this.multibodyJoints.get(handle)}removeRigidBody(body){this.bodies&&this.bodies.remove(body.handle,this.islands,this.colliders,this.impulseJoints,this.multibodyJoints)}removeCollider(collider,wakeUp){this.colliders&&this.colliders.remove(collider.handle,this.islands,this.bodies,wakeUp)}removeImpulseJoint(joint,wakeUp){this.impulseJoints&&this.impulseJoints.remove(joint.handle,wakeUp)}removeMultibodyJoint(joint,wakeUp){this.impulseJoints&&this.multibodyJoints.remove(joint.handle,wakeUp)}forEachCollider(f){this.colliders.forEach(f)}forEachRigidBody(f){this.bodies.forEach(f)}forEachActiveRigidBody(f){this.bodies.forEachActiveRigidBody(this.islands,f)}castRay(ray,maxToi,solid,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){return this.broadPhase.castRay(this.narrowPhase,this.bodies,this.colliders,ray,maxToi,solid,filterFlags,filterGroups,filterExcludeCollider?filterExcludeCollider.handle:null,filterExcludeRigidBody?filterExcludeRigidBody.handle:null,this.colliders.castClosure(filterPredicate))}castRayAndGetNormal(ray,maxToi,solid,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){return this.broadPhase.castRayAndGetNormal(this.narrowPhase,this.bodies,this.colliders,ray,maxToi,solid,filterFlags,filterGroups,filterExcludeCollider?filterExcludeCollider.handle:null,filterExcludeRigidBody?filterExcludeRigidBody.handle:null,this.colliders.castClosure(filterPredicate))}intersectionsWithRay(ray,maxToi,solid,callback,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){this.broadPhase.intersectionsWithRay(this.narrowPhase,this.bodies,this.colliders,ray,maxToi,solid,callback,filterFlags,filterGroups,filterExcludeCollider?filterExcludeCollider.handle:null,filterExcludeRigidBody?filterExcludeRigidBody.handle:null,this.colliders.castClosure(filterPredicate))}intersectionWithShape(shapePos,shapeRot,shape,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){let handle=this.broadPhase.intersectionWithShape(this.narrowPhase,this.bodies,this.colliders,shapePos,shapeRot,shape,filterFlags,filterGroups,filterExcludeCollider?filterExcludeCollider.handle:null,filterExcludeRigidBody?filterExcludeRigidBody.handle:null,this.colliders.castClosure(filterPredicate));return null!=handle?this.colliders.get(handle):null}projectPoint(point,solid,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){return this.broadPhase.projectPoint(this.narrowPhase,this.bodies,this.colliders,point,solid,filterFlags,filterGroups,filterExcludeCollider?filterExcludeCollider.handle:null,filterExcludeRigidBody?filterExcludeRigidBody.handle:null,this.colliders.castClosure(filterPredicate))}projectPointAndGetFeature(point,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){return this.broadPhase.projectPointAndGetFeature(this.narrowPhase,this.bodies,this.colliders,point,filterFlags,filterGroups,filterExcludeCollider?filterExcludeCollider.handle:null,filterExcludeRigidBody?filterExcludeRigidBody.handle:null,this.colliders.castClosure(filterPredicate))}intersectionsWithPoint(point,callback,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){this.broadPhase.intersectionsWithPoint(this.narrowPhase,this.bodies,this.colliders,point,this.colliders.castClosure(callback),filterFlags,filterGroups,filterExcludeCollider?filterExcludeCollider.handle:null,filterExcludeRigidBody?filterExcludeRigidBody.handle:null,this.colliders.castClosure(filterPredicate))}castShape(shapePos,shapeRot,shapeVel,shape,targetDistance,maxToi,stopAtPenetration,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){return this.broadPhase.castShape(this.narrowPhase,this.bodies,this.colliders,shapePos,shapeRot,shapeVel,shape,targetDistance,maxToi,stopAtPenetration,filterFlags,filterGroups,filterExcludeCollider?filterExcludeCollider.handle:null,filterExcludeRigidBody?filterExcludeRigidBody.handle:null,this.colliders.castClosure(filterPredicate))}intersectionsWithShape(shapePos,shapeRot,shape,callback,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){this.broadPhase.intersectionsWithShape(this.narrowPhase,this.bodies,this.colliders,shapePos,shapeRot,shape,this.colliders.castClosure(callback),filterFlags,filterGroups,filterExcludeCollider?filterExcludeCollider.handle:null,filterExcludeRigidBody?filterExcludeRigidBody.handle:null,this.colliders.castClosure(filterPredicate))}collidersWithAabbIntersectingAabb(aabbCenter,aabbHalfExtents,callback){this.broadPhase.collidersWithAabbIntersectingAabb(this.narrowPhase,this.bodies,this.colliders,aabbCenter,aabbHalfExtents,this.colliders.castClosure(callback))}contactPairsWith(collider1,f){this.narrowPhase.contactPairsWith(collider1.handle,this.colliders.castClosure(f))}intersectionPairsWith(collider1,f){this.narrowPhase.intersectionPairsWith(collider1.handle,this.colliders.castClosure(f))}contactPair(collider1,collider2,f){this.narrowPhase.contactPair(collider1.handle,collider2.handle,f)}intersectionPair(collider1,collider2){return this.narrowPhase.intersectionPair(collider1.handle,collider2.handle)}set profilerEnabled(enabled){this.physicsPipeline.raw.set_profiler_enabled(enabled)}get profilerEnabled(){return this.physicsPipeline.raw.is_profiler_enabled()}timingStep(){return this.physicsPipeline.raw.timing_step()}timingCollisionDetection(){return this.physicsPipeline.raw.timing_collision_detection()}timingBroadPhase(){return this.physicsPipeline.raw.timing_broad_phase()}timingNarrowPhase(){return this.physicsPipeline.raw.timing_narrow_phase()}timingSolver(){return this.physicsPipeline.raw.timing_solver()}timingVelocityAssembly(){return this.physicsPipeline.raw.timing_velocity_assembly()}timingVelocityResolution(){return this.physicsPipeline.raw.timing_velocity_resolution()}timingVelocityUpdate(){return this.physicsPipeline.raw.timing_velocity_update()}timingVelocityWriteback(){return this.physicsPipeline.raw.timing_velocity_writeback()}timingCcd(){return this.physicsPipeline.raw.timing_ccd()}timingCcdToiComputation(){return this.physicsPipeline.raw.timing_ccd_toi_computation()}timingCcdBroadPhase(){return this.physicsPipeline.raw.timing_ccd_broad_phase()}timingCcdNarrowPhase(){return this.physicsPipeline.raw.timing_ccd_narrow_phase()}timingCcdSolver(){return this.physicsPipeline.raw.timing_ccd_solver()}timingIslandConstruction(){return this.physicsPipeline.raw.timing_island_construction()}timingUserChanges(){return this.physicsPipeline.raw.timing_user_changes()}}export{World};
+//# sourceMappingURL=world.js.map

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/pipeline/world.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"world.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/pipeline/world.js"],"sourcesContent":["import { BroadPhase, ColliderSet, NarrowPhase, } from \"../geometry\";\nimport { CCDSolver, IntegrationParameters, IslandManager, ImpulseJointSet, MultibodyJointSet, RigidBodySet, } from \"../dynamics\";\nimport { VectorOps } from \"../math\";\nimport { PhysicsPipeline } from \"./physics_pipeline\";\nimport { SerializationPipeline } from \"./serialization_pipeline\";\nimport { DebugRenderBuffers, DebugRenderPipeline } from \"./debug_render_pipeline\";\nimport { KinematicCharacterController, PidController, } from \"../control\";\n// #if DIM3\nimport { DynamicRayCastVehicleController } from \"../control\";\n// #endif\n/**\n * The physics world.\n *\n * This contains all the data-structures necessary for creating and simulating\n * bodies with contacts, joints, and external forces.\n */\nexport class World {\n    // #endif\n    /**\n     * Release the WASM memory occupied by this physics world.\n     *\n     * All the fields of this physics world will be freed as well,\n     * so there is no need to call their `.free()` methods individually.\n     */\n    free() {\n        this.integrationParameters.free();\n        this.islands.free();\n        this.broadPhase.free();\n        this.narrowPhase.free();\n        this.bodies.free();\n        this.colliders.free();\n        this.impulseJoints.free();\n        this.multibodyJoints.free();\n        this.ccdSolver.free();\n        this.physicsPipeline.free();\n        this.serializationPipeline.free();\n        this.debugRenderPipeline.free();\n        this.characterControllers.forEach((controller) => controller.free());\n        this.pidControllers.forEach((controller) => controller.free());\n        // #if DIM3\n        this.vehicleControllers.forEach((controller) => controller.free());\n        // #endif\n        this.integrationParameters = undefined;\n        this.islands = undefined;\n        this.broadPhase = undefined;\n        this.narrowPhase = undefined;\n        this.bodies = undefined;\n        this.colliders = undefined;\n        this.ccdSolver = undefined;\n        this.impulseJoints = undefined;\n        this.multibodyJoints = undefined;\n        this.physicsPipeline = undefined;\n        this.serializationPipeline = undefined;\n        this.debugRenderPipeline = undefined;\n        this.characterControllers = undefined;\n        this.pidControllers = undefined;\n        // #if DIM3\n        this.vehicleControllers = undefined;\n        // #endif\n    }\n    constructor(gravity, rawIntegrationParameters, rawIslands, rawBroadPhase, rawNarrowPhase, rawBodies, rawColliders, rawImpulseJoints, rawMultibodyJoints, rawCCDSolver, rawPhysicsPipeline, rawSerializationPipeline, rawDebugRenderPipeline) {\n        this.gravity = gravity;\n        this.integrationParameters = new IntegrationParameters(rawIntegrationParameters);\n        this.islands = new IslandManager(rawIslands);\n        this.broadPhase = new BroadPhase(rawBroadPhase);\n        this.narrowPhase = new NarrowPhase(rawNarrowPhase);\n        this.bodies = new RigidBodySet(rawBodies);\n        this.colliders = new ColliderSet(rawColliders);\n        this.impulseJoints = new ImpulseJointSet(rawImpulseJoints);\n        this.multibodyJoints = new MultibodyJointSet(rawMultibodyJoints);\n        this.ccdSolver = new CCDSolver(rawCCDSolver);\n        this.physicsPipeline = new PhysicsPipeline(rawPhysicsPipeline);\n        this.serializationPipeline = new SerializationPipeline(rawSerializationPipeline);\n        this.debugRenderPipeline = new DebugRenderPipeline(rawDebugRenderPipeline);\n        this.characterControllers = new Set();\n        this.pidControllers = new Set();\n        // #if DIM3\n        this.vehicleControllers = new Set();\n        // #endif\n        this.impulseJoints.finalizeDeserialization(this.bodies);\n        this.bodies.finalizeDeserialization(this.colliders);\n        this.colliders.finalizeDeserialization(this.bodies);\n    }\n    static fromRaw(raw) {\n        if (!raw)\n            return null;\n        return new World(VectorOps.fromRaw(raw.takeGravity()), raw.takeIntegrationParameters(), raw.takeIslandManager(), raw.takeBroadPhase(), raw.takeNarrowPhase(), raw.takeBodies(), raw.takeColliders(), raw.takeImpulseJoints(), raw.takeMultibodyJoints());\n    }\n    /**\n     * Takes a snapshot of this world.\n     *\n     * Use `World.restoreSnapshot` to create a new physics world with a state identical to\n     * the state when `.takeSnapshot()` is called.\n     */\n    takeSnapshot() {\n        return this.serializationPipeline.serializeAll(this.gravity, this.integrationParameters, this.islands, this.broadPhase, this.narrowPhase, this.bodies, this.colliders, this.impulseJoints, this.multibodyJoints);\n    }\n    /**\n     * Creates a new physics world from a snapshot.\n     *\n     * This new physics world will be an identical copy of the snapshoted physics world.\n     */\n    static restoreSnapshot(data) {\n        let deser = new SerializationPipeline();\n        return deser.deserializeAll(data);\n    }\n    /**\n     * Computes all the lines (and their colors) needed to render the scene.\n     *\n     * @param filterFlags - Flags for excluding whole subsets of colliders from rendering.\n     * @param filterPredicate - Any collider for which this closure returns `false` will be excluded from the\n     *                          debug rendering.\n     */\n    debugRender(filterFlags, filterPredicate) {\n        this.debugRenderPipeline.render(this.bodies, this.colliders, this.impulseJoints, this.multibodyJoints, this.narrowPhase, filterFlags, filterPredicate);\n        return new DebugRenderBuffers(this.debugRenderPipeline.vertices, this.debugRenderPipeline.colors);\n    }\n    /**\n     * Advance the simulation by one time step.\n     *\n     * All events generated by the physics engine are ignored.\n     *\n     * @param EventQueue - (optional) structure responsible for collecting\n     *   events generated by the physics engine.\n     */\n    step(eventQueue, hooks) {\n        this.physicsPipeline.step(this.gravity, this.integrationParameters, this.islands, this.broadPhase, this.narrowPhase, this.bodies, this.colliders, this.impulseJoints, this.multibodyJoints, this.ccdSolver, eventQueue, hooks);\n    }\n    /**\n     * Update colliders positions after rigid-bodies moved.\n     *\n     * When a rigid-body moves, the positions of the colliders attached to it need to be updated. This update is\n     * generally automatically done at the beginning and the end of each simulation step with World.step.\n     * If the positions need to be updated without running a simulation step this method can be called manually.\n     */\n    propagateModifiedBodyPositionsToColliders() {\n        this.bodies.raw.propagateModifiedBodyPositionsToColliders(this.colliders.raw);\n    }\n    // TODO: This needs to trigger a broad-phase update but without emitting collision events?\n    // /**\n    //  * Ensure subsequent scene queries take into account the collider positions set before this method is called.\n    //  *\n    //  * This does not step the physics simulation forward.\n    //  */\n    // public updateSceneQueries() {\n    //     this.propagateModifiedBodyPositionsToColliders();\n    //     this.queryPipeline.update(this.colliders);\n    // }\n    /**\n     * The current simulation timestep.\n     */\n    get timestep() {\n        return this.integrationParameters.dt;\n    }\n    /**\n     * Sets the new simulation timestep.\n     *\n     * The simulation timestep governs by how much the physics state of the world will\n     * be integrated. A simulation timestep should:\n     * - be as small as possible. Typical values evolve around 0.016 (assuming the chosen unit is milliseconds,\n     * corresponds to the time between two frames of a game running at 60FPS).\n     * - not vary too much during the course of the simulation. A timestep with large variations may\n     * cause instabilities in the simulation.\n     *\n     * @param dt - The timestep length, in seconds.\n     */\n    set timestep(dt) {\n        this.integrationParameters.dt = dt;\n    }\n    /**\n     * The approximate size of most dynamic objects in the scene.\n     *\n     * See the documentation of the `World.lengthUnit` setter for further details.\n     */\n    get lengthUnit() {\n        return this.integrationParameters.lengthUnit;\n    }\n    /**\n     * The approximate size of most dynamic objects in the scene.\n     *\n     * This value is used internally to estimate some length-based tolerance. In particular, the\n     * values `IntegrationParameters.allowedLinearError`,\n     * `IntegrationParameters.maxPenetrationCorrection`,\n     * `IntegrationParameters.predictionDistance`, `RigidBodyActivation.linearThreshold`\n     * are scaled by this value implicitly.\n     *\n     * This value can be understood as the number of units-per-meter in your physical world compared\n     * to a human-sized world in meter. For example, in a 2d game, if your typical object size is 100\n     * pixels, set the `[`Self::length_unit`]` parameter to 100.0. The physics engine will interpret\n     * it as if 100 pixels is equivalent to 1 meter in its various internal threshold.\n     * (default `1.0`).\n     */\n    set lengthUnit(unitsPerMeter) {\n        this.integrationParameters.lengthUnit = unitsPerMeter;\n    }\n    /**\n     * The number of solver iterations run by the constraints solver for calculating forces (default: `4`).\n     */\n    get numSolverIterations() {\n        return this.integrationParameters.numSolverIterations;\n    }\n    /**\n     * Sets the number of solver iterations run by the constraints solver for calculating forces (default: `4`).\n     *\n     * The greater this value is, the most rigid and realistic the physics simulation will be.\n     * However a greater number of iterations is more computationally intensive.\n     *\n     * @param niter - The new number of solver iterations.\n     */\n    set numSolverIterations(niter) {\n        this.integrationParameters.numSolverIterations = niter;\n    }\n    /**\n     * Number of internal Project Gauss Seidel (PGS) iterations run at each solver iteration (default: `1`).\n     */\n    get numInternalPgsIterations() {\n        return this.integrationParameters.numInternalPgsIterations;\n    }\n    /**\n     * Sets the Number of internal Project Gauss Seidel (PGS) iterations run at each solver iteration (default: `1`).\n     *\n     * Increasing this parameter will improve stability of the simulation. It will have a lesser effect than\n     * increasing `numSolverIterations` but is also less computationally expensive.\n     *\n     * @param niter - The new number of internal PGS iterations.\n     */\n    set numInternalPgsIterations(niter) {\n        this.integrationParameters.numInternalPgsIterations = niter;\n    }\n    /**\n     * The number of substeps continuous collision-detection can run (default: `1`).\n     */\n    get maxCcdSubsteps() {\n        return this.integrationParameters.maxCcdSubsteps;\n    }\n    /**\n     * Sets the number of substeps continuous collision-detection can run (default: `1`).\n     *\n     * CCD operates using a \"motion clamping\" mechanism where all fast-moving object trajectories will\n     * be truncated to their first impact on their path. The number of CCD substeps beyond 1 indicate how\n     * many times that trajectory will be updated and continued after a hit. This can results in smoother\n     * paths, but at a significant computational cost.\n     *\n     * @param niter - The new maximum number of CCD substeps. Setting to `0` disables CCD entirely.\n     */\n    set maxCcdSubsteps(substeps) {\n        this.integrationParameters.maxCcdSubsteps = substeps;\n    }\n    /**\n     * Creates a new rigid-body from the given rigid-body descriptor.\n     *\n     * @param body - The description of the rigid-body to create.\n     */\n    createRigidBody(body) {\n        return this.bodies.createRigidBody(this.colliders, body);\n    }\n    /**\n     * Creates a new character controller.\n     *\n     * @param offset - The artificial gap added between the character’s chape and its environment.\n     */\n    createCharacterController(offset) {\n        let controller = new KinematicCharacterController(offset, this.integrationParameters, this.broadPhase, this.narrowPhase, this.bodies, this.colliders);\n        this.characterControllers.add(controller);\n        return controller;\n    }\n    /**\n     * Removes a character controller from this world.\n     *\n     * @param controller - The character controller to remove.\n     */\n    removeCharacterController(controller) {\n        this.characterControllers.delete(controller);\n        controller.free();\n    }\n    /**\n     * Creates a new PID (Proportional-Integral-Derivative) controller.\n     *\n     * @param kp - The Proportional gain applied to the instantaneous linear position errors.\n     *             This is usually set to a multiple of the inverse of simulation step time\n     *             (e.g. `60` if the delta-time is `1.0 / 60.0`).\n     * @param ki - The linear gain applied to the Integral part of the PID controller.\n     * @param kd - The Derivative gain applied to the instantaneous linear velocity errors.\n     *             This is usually set to a value in `[0.0, 1.0]` where `0.0` implies no damping\n     *             (no correction of velocity errors) and `1.0` implies complete damping (velocity errors\n     *             are corrected in a single simulation step).\n     * @param axes - The axes affected by this controller.\n     *               Only coordinate axes with a bit flags set to `true` will be taken into\n     *               account when calculating the errors and corrections.\n     */\n    createPidController(kp, ki, kd, axes) {\n        let controller = new PidController(this.integrationParameters, this.bodies, kp, ki, kd, axes);\n        this.pidControllers.add(controller);\n        return controller;\n    }\n    /**\n     * Removes a PID controller from this world.\n     *\n     * @param controller - The PID controller to remove.\n     */\n    removePidController(controller) {\n        this.pidControllers.delete(controller);\n        controller.free();\n    }\n    // #if DIM3\n    /**\n     * Creates a new vehicle controller.\n     *\n     * @param chassis - The rigid-body used as the chassis of the vehicle controller. When the vehicle\n     *                  controller is updated, it will change directly the rigid-body’s velocity. This\n     *                  rigid-body must be a dynamic or kinematic-velocity-based rigid-body.\n     */\n    createVehicleController(chassis) {\n        let controller = new DynamicRayCastVehicleController(chassis, this.broadPhase, this.narrowPhase, this.bodies, this.colliders);\n        this.vehicleControllers.add(controller);\n        return controller;\n    }\n    /**\n     * Removes a vehicle controller from this world.\n     *\n     * @param controller - The vehicle controller to remove.\n     */\n    removeVehicleController(controller) {\n        this.vehicleControllers.delete(controller);\n        controller.free();\n    }\n    // #endif\n    /**\n     * Creates a new collider.\n     *\n     * @param desc - The description of the collider.\n     * @param parent - The rigid-body this collider is attached to.\n     */\n    createCollider(desc, parent) {\n        let parentHandle = parent ? parent.handle : undefined;\n        return this.colliders.createCollider(this.bodies, desc, parentHandle);\n    }\n    /**\n     * Creates a new impulse joint from the given joint descriptor.\n     *\n     * @param params - The description of the joint to create.\n     * @param parent1 - The first rigid-body attached to this joint.\n     * @param parent2 - The second rigid-body attached to this joint.\n     * @param wakeUp - Should the attached rigid-bodies be awakened?\n     */\n    createImpulseJoint(params, parent1, parent2, wakeUp) {\n        return this.impulseJoints.createJoint(this.bodies, params, parent1.handle, parent2.handle, wakeUp);\n    }\n    /**\n     * Creates a new multibody joint from the given joint descriptor.\n     *\n     * @param params - The description of the joint to create.\n     * @param parent1 - The first rigid-body attached to this joint.\n     * @param parent2 - The second rigid-body attached to this joint.\n     * @param wakeUp - Should the attached rigid-bodies be awakened?\n     */\n    createMultibodyJoint(params, parent1, parent2, wakeUp) {\n        return this.multibodyJoints.createJoint(params, parent1.handle, parent2.handle, wakeUp);\n    }\n    /**\n     * Retrieves a rigid-body from its handle.\n     *\n     * @param handle - The integer handle of the rigid-body to retrieve.\n     */\n    getRigidBody(handle) {\n        return this.bodies.get(handle);\n    }\n    /**\n     * Retrieves a collider from its handle.\n     *\n     * @param handle - The integer handle of the collider to retrieve.\n     */\n    getCollider(handle) {\n        return this.colliders.get(handle);\n    }\n    /**\n     * Retrieves an impulse joint from its handle.\n     *\n     * @param handle - The integer handle of the impulse joint to retrieve.\n     */\n    getImpulseJoint(handle) {\n        return this.impulseJoints.get(handle);\n    }\n    /**\n     * Retrieves an multibody joint from its handle.\n     *\n     * @param handle - The integer handle of the multibody joint to retrieve.\n     */\n    getMultibodyJoint(handle) {\n        return this.multibodyJoints.get(handle);\n    }\n    /**\n     * Removes the given rigid-body from this physics world.\n     *\n     * This will remove this rigid-body as well as all its attached colliders and joints.\n     * Every other bodies touching or attached by joints to this rigid-body will be woken-up.\n     *\n     * @param body - The rigid-body to remove.\n     */\n    removeRigidBody(body) {\n        if (this.bodies) {\n            this.bodies.remove(body.handle, this.islands, this.colliders, this.impulseJoints, this.multibodyJoints);\n        }\n    }\n    /**\n     * Removes the given collider from this physics world.\n     *\n     * @param collider - The collider to remove.\n     * @param wakeUp - If set to `true`, the rigid-body this collider is attached to will be awaken.\n     */\n    removeCollider(collider, wakeUp) {\n        if (this.colliders) {\n            this.colliders.remove(collider.handle, this.islands, this.bodies, wakeUp);\n        }\n    }\n    /**\n     * Removes the given impulse joint from this physics world.\n     *\n     * @param joint - The impulse joint to remove.\n     * @param wakeUp - If set to `true`, the rigid-bodies attached by this joint will be awaken.\n     */\n    removeImpulseJoint(joint, wakeUp) {\n        if (this.impulseJoints) {\n            this.impulseJoints.remove(joint.handle, wakeUp);\n        }\n    }\n    /**\n     * Removes the given multibody joint from this physics world.\n     *\n     * @param joint - The multibody joint to remove.\n     * @param wakeUp - If set to `true`, the rigid-bodies attached by this joint will be awaken.\n     */\n    removeMultibodyJoint(joint, wakeUp) {\n        if (this.impulseJoints) {\n            this.multibodyJoints.remove(joint.handle, wakeUp);\n        }\n    }\n    /**\n     * Applies the given closure to each collider managed by this physics world.\n     *\n     * @param f(collider) - The function to apply to each collider managed by this physics world. Called as `f(collider)`.\n     */\n    forEachCollider(f) {\n        this.colliders.forEach(f);\n    }\n    /**\n     * Applies the given closure to each rigid-body managed by this physics world.\n     *\n     * @param f(body) - The function to apply to each rigid-body managed by this physics world. Called as `f(collider)`.\n     */\n    forEachRigidBody(f) {\n        this.bodies.forEach(f);\n    }\n    /**\n     * Applies the given closure to each active rigid-body managed by this physics world.\n     *\n     * After a short time of inactivity, a rigid-body is automatically deactivated (\"asleep\") by\n     * the physics engine in order to save computational power. A sleeping rigid-body never moves\n     * unless it is moved manually by the user.\n     *\n     * @param f - The function to apply to each active rigid-body managed by this physics world. Called as `f(collider)`.\n     */\n    forEachActiveRigidBody(f) {\n        this.bodies.forEachActiveRigidBody(this.islands, f);\n    }\n    /**\n     * Find the closest intersection between a ray and the physics world.\n     *\n     * @param ray - The ray to cast.\n     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively\n     *   limits the length of the ray to `ray.dir.norm() * maxToi`.\n     * @param solid - If `false` then the ray will attempt to hit the boundary of a shape, even if its\n     *   origin already lies inside of a shape. In other terms, `true` implies that all shapes are plain,\n     *   whereas `false` implies that all shapes are hollow for this ray-cast.\n     * @param groups - Used to filter the colliders that can or cannot be hit by the ray.\n     * @param filter - The callback to filter out which collider will be hit.\n     */\n    castRay(ray, maxToi, solid, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        return this.broadPhase.castRay(this.narrowPhase, this.bodies, this.colliders, ray, maxToi, solid, filterFlags, filterGroups, filterExcludeCollider ? filterExcludeCollider.handle : null, filterExcludeRigidBody ? filterExcludeRigidBody.handle : null, this.colliders.castClosure(filterPredicate));\n    }\n    /**\n     * Find the closest intersection between a ray and the physics world.\n     *\n     * This also computes the normal at the hit point.\n     * @param ray - The ray to cast.\n     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively\n     *   limits the length of the ray to `ray.dir.norm() * maxToi`.\n     * @param solid - If `false` then the ray will attempt to hit the boundary of a shape, even if its\n     *   origin already lies inside of a shape. In other terms, `true` implies that all shapes are plain,\n     *   whereas `false` implies that all shapes are hollow for this ray-cast.\n     * @param groups - Used to filter the colliders that can or cannot be hit by the ray.\n     */\n    castRayAndGetNormal(ray, maxToi, solid, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        return this.broadPhase.castRayAndGetNormal(this.narrowPhase, this.bodies, this.colliders, ray, maxToi, solid, filterFlags, filterGroups, filterExcludeCollider ? filterExcludeCollider.handle : null, filterExcludeRigidBody ? filterExcludeRigidBody.handle : null, this.colliders.castClosure(filterPredicate));\n    }\n    /**\n     * Cast a ray and collects all the intersections between a ray and the scene.\n     *\n     * @param ray - The ray to cast.\n     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively\n     *   limits the length of the ray to `ray.dir.norm() * maxToi`.\n     * @param solid - If `false` then the ray will attempt to hit the boundary of a shape, even if its\n     *   origin already lies inside of a shape. In other terms, `true` implies that all shapes are plain,\n     *   whereas `false` implies that all shapes are hollow for this ray-cast.\n     * @param groups - Used to filter the colliders that can or cannot be hit by the ray.\n     * @param callback - The callback called once per hit (in no particular order) between a ray and a collider.\n     *   If this callback returns `false`, then the cast will stop and no further hits will be detected/reported.\n     */\n    intersectionsWithRay(ray, maxToi, solid, callback, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        this.broadPhase.intersectionsWithRay(this.narrowPhase, this.bodies, this.colliders, ray, maxToi, solid, callback, filterFlags, filterGroups, filterExcludeCollider ? filterExcludeCollider.handle : null, filterExcludeRigidBody ? filterExcludeRigidBody.handle : null, this.colliders.castClosure(filterPredicate));\n    }\n    /**\n     * Gets the handle of up to one collider intersecting the given shape.\n     *\n     * @param shapePos - The position of the shape used for the intersection test.\n     * @param shapeRot - The orientation of the shape used for the intersection test.\n     * @param shape - The shape used for the intersection test.\n     * @param groups - The bit groups and filter associated to the ray, in order to only\n     *   hit the colliders with collision groups compatible with the ray's group.\n     */\n    intersectionWithShape(shapePos, shapeRot, shape, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        let handle = this.broadPhase.intersectionWithShape(this.narrowPhase, this.bodies, this.colliders, shapePos, shapeRot, shape, filterFlags, filterGroups, filterExcludeCollider ? filterExcludeCollider.handle : null, filterExcludeRigidBody ? filterExcludeRigidBody.handle : null, this.colliders.castClosure(filterPredicate));\n        return handle != null ? this.colliders.get(handle) : null;\n    }\n    /**\n     * Find the projection of a point on the closest collider.\n     *\n     * @param point - The point to project.\n     * @param solid - If this is set to `true` then the collider shapes are considered to\n     *   be plain (if the point is located inside of a plain shape, its projection is the point\n     *   itself). If it is set to `false` the collider shapes are considered to be hollow\n     *   (if the point is located inside of an hollow shape, it is projected on the shape's\n     *   boundary).\n     * @param groups - The bit groups and filter associated to the point to project, in order to only\n     *   project on colliders with collision groups compatible with the ray's group.\n     */\n    projectPoint(point, solid, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        return this.broadPhase.projectPoint(this.narrowPhase, this.bodies, this.colliders, point, solid, filterFlags, filterGroups, filterExcludeCollider ? filterExcludeCollider.handle : null, filterExcludeRigidBody ? filterExcludeRigidBody.handle : null, this.colliders.castClosure(filterPredicate));\n    }\n    /**\n     * Find the projection of a point on the closest collider.\n     *\n     * @param point - The point to project.\n     * @param groups - The bit groups and filter associated to the point to project, in order to only\n     *   project on colliders with collision groups compatible with the ray's group.\n     */\n    projectPointAndGetFeature(point, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        return this.broadPhase.projectPointAndGetFeature(this.narrowPhase, this.bodies, this.colliders, point, filterFlags, filterGroups, filterExcludeCollider ? filterExcludeCollider.handle : null, filterExcludeRigidBody ? filterExcludeRigidBody.handle : null, this.colliders.castClosure(filterPredicate));\n    }\n    /**\n     * Find all the colliders containing the given point.\n     *\n     * @param point - The point used for the containment test.\n     * @param groups - The bit groups and filter associated to the point to test, in order to only\n     *   test on colliders with collision groups compatible with the ray's group.\n     * @param callback - A function called with the handles of each collider with a shape\n     *   containing the `point`.\n     */\n    intersectionsWithPoint(point, callback, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        this.broadPhase.intersectionsWithPoint(this.narrowPhase, this.bodies, this.colliders, point, this.colliders.castClosure(callback), filterFlags, filterGroups, filterExcludeCollider ? filterExcludeCollider.handle : null, filterExcludeRigidBody ? filterExcludeRigidBody.handle : null, this.colliders.castClosure(filterPredicate));\n    }\n    /**\n     * Casts a shape at a constant linear velocity and retrieve the first collider it hits.\n     * This is similar to ray-casting except that we are casting a whole shape instead of\n     * just a point (the ray origin).\n     *\n     * @param shapePos - The initial position of the shape to cast.\n     * @param shapeRot - The initial rotation of the shape to cast.\n     * @param shapeVel - The constant velocity of the shape to cast (i.e. the cast direction).\n     * @param shape - The shape to cast.\n     * @param targetDistance − If the shape moves closer to this distance from a collider, a hit\n     *                         will be returned.\n     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively\n     *   limits the distance traveled by the shape to `shapeVel.norm() * maxToi`.\n     * @param stopAtPenetration - If set to `false`, the linear shape-cast won’t immediately stop if\n     *   the shape is penetrating another shape at its starting point **and** its trajectory is such\n     *   that it’s on a path to exit that penetration state.\n     * @param groups - The bit groups and filter associated to the shape to cast, in order to only\n     *   test on colliders with collision groups compatible with this group.\n     */\n    castShape(shapePos, shapeRot, shapeVel, shape, targetDistance, maxToi, stopAtPenetration, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        return this.broadPhase.castShape(this.narrowPhase, this.bodies, this.colliders, shapePos, shapeRot, shapeVel, shape, targetDistance, maxToi, stopAtPenetration, filterFlags, filterGroups, filterExcludeCollider ? filterExcludeCollider.handle : null, filterExcludeRigidBody ? filterExcludeRigidBody.handle : null, this.colliders.castClosure(filterPredicate));\n    }\n    /**\n     * Retrieve all the colliders intersecting the given shape.\n     *\n     * @param shapePos - The position of the shape to test.\n     * @param shapeRot - The orientation of the shape to test.\n     * @param shape - The shape to test.\n     * @param groups - The bit groups and filter associated to the shape to test, in order to only\n     *   test on colliders with collision groups compatible with this group.\n     * @param callback - A function called with the handles of each collider intersecting the `shape`.\n     */\n    intersectionsWithShape(shapePos, shapeRot, shape, callback, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        this.broadPhase.intersectionsWithShape(this.narrowPhase, this.bodies, this.colliders, shapePos, shapeRot, shape, this.colliders.castClosure(callback), filterFlags, filterGroups, filterExcludeCollider ? filterExcludeCollider.handle : null, filterExcludeRigidBody ? filterExcludeRigidBody.handle : null, this.colliders.castClosure(filterPredicate));\n    }\n    /**\n     * Finds the handles of all the colliders with an AABB intersecting the given AABB.\n     *\n     * @param aabbCenter - The center of the AABB to test.\n     * @param aabbHalfExtents - The half-extents of the AABB to test.\n     * @param callback - The callback that will be called with the handles of all the colliders\n     *                   currently intersecting the given AABB.\n     */\n    collidersWithAabbIntersectingAabb(aabbCenter, aabbHalfExtents, callback) {\n        this.broadPhase.collidersWithAabbIntersectingAabb(this.narrowPhase, this.bodies, this.colliders, aabbCenter, aabbHalfExtents, this.colliders.castClosure(callback));\n    }\n    /**\n     * Enumerates all the colliders potentially in contact with the given collider.\n     *\n     * @param collider1 - The second collider involved in the contact.\n     * @param f - Closure that will be called on each collider that is in contact with `collider1`.\n     */\n    contactPairsWith(collider1, f) {\n        this.narrowPhase.contactPairsWith(collider1.handle, this.colliders.castClosure(f));\n    }\n    /**\n     * Enumerates all the colliders intersecting the given colliders, assuming one of them\n     * is a sensor.\n     */\n    intersectionPairsWith(collider1, f) {\n        this.narrowPhase.intersectionPairsWith(collider1.handle, this.colliders.castClosure(f));\n    }\n    /**\n     * Iterates through all the contact manifolds between the given pair of colliders.\n     *\n     * @param collider1 - The first collider involved in the contact.\n     * @param collider2 - The second collider involved in the contact.\n     * @param f - Closure that will be called on each contact manifold between the two colliders. If the second argument\n     *            passed to this closure is `true`, then the contact manifold data is flipped, i.e., methods like `localNormal1`\n     *            actually apply to the `collider2` and fields like `localNormal2` apply to the `collider1`.\n     */\n    contactPair(collider1, collider2, f) {\n        this.narrowPhase.contactPair(collider1.handle, collider2.handle, f);\n    }\n    /**\n     * Returns `true` if `collider1` and `collider2` intersect and at least one of them is a sensor.\n     * @param collider1 − The first collider involved in the intersection.\n     * @param collider2 − The second collider involved in the intersection.\n     */\n    intersectionPair(collider1, collider2) {\n        return this.narrowPhase.intersectionPair(collider1.handle, collider2.handle);\n    }\n    /**\n     * Sets whether internal performance profiling is enabled (default: false).\n     *\n     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.\n     */\n    set profilerEnabled(enabled) {\n        this.physicsPipeline.raw.set_profiler_enabled(enabled);\n    }\n    /**\n     * Indicates if the internal performance profiling is enabled.\n     *\n     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.\n     */\n    get profilerEnabled() {\n        return this.physicsPipeline.raw.is_profiler_enabled();\n    }\n    /**\n     * The time spent in milliseconds by the last step to run the entire simulation step.\n     *\n     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.\n     */\n    timingStep() {\n        return this.physicsPipeline.raw.timing_step();\n    }\n    /**\n     * The time spent in milliseconds by the last step to run the collision-detection\n     * (broad-phase + narrow-phase).\n     *\n     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.\n     */\n    timingCollisionDetection() {\n        return this.physicsPipeline.raw.timing_collision_detection();\n    }\n    /**\n     * The time spent in milliseconds by the last step to run the broad-phase.\n     *\n     * This timing is included in `timingCollisionDetection`.\n     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.\n     */\n    timingBroadPhase() {\n        return this.physicsPipeline.raw.timing_broad_phase();\n    }\n    /**\n     * The time spent in milliseconds by the last step to run the narrow-phase.\n     *\n     * This timing is included in `timingCollisionDetection`.\n     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.\n     */\n    timingNarrowPhase() {\n        return this.physicsPipeline.raw.timing_narrow_phase();\n    }\n    /**\n     * The time spent in milliseconds by the last step to run the constraint solver.\n     *\n     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.\n     */\n    timingSolver() {\n        return this.physicsPipeline.raw.timing_solver();\n    }\n    /**\n     * The time spent in milliseconds by the last step to run the constraint\n     * initialization.\n     *\n     * This timing is included in `timingSolver`.\n     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.\n     */\n    timingVelocityAssembly() {\n        return this.physicsPipeline.raw.timing_velocity_assembly();\n    }\n    /**\n     * The time spent in milliseconds by the last step to run the constraint\n     * resolution.\n     *\n     * This timing is included in `timingSolver`.\n     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.\n     */\n    timingVelocityResolution() {\n        return this.physicsPipeline.raw.timing_velocity_resolution();\n    }\n    /**\n     * The time spent in milliseconds by the last step to run the rigid-body\n     * velocity update.\n     *\n     * This timing is included in `timingSolver`.\n     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.\n     */\n    timingVelocityUpdate() {\n        return this.physicsPipeline.raw.timing_velocity_update();\n    }\n    /**\n     * The time spent in milliseconds by writing rigid-body velocities\n     * calculated by the solver back into the rigid-bodies.\n     *\n     * This timing is included in `timingSolver`.\n     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.\n     */\n    timingVelocityWriteback() {\n        return this.physicsPipeline.raw.timing_velocity_writeback();\n    }\n    /**\n     * The total time spent in CCD detection and resolution.\n     *\n     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.\n     */\n    timingCcd() {\n        return this.physicsPipeline.raw.timing_ccd();\n    }\n    /**\n     * The total time spent searching for the continuous hits during CCD.\n     *\n     * This timing is included in `timingCcd`.\n     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.\n     */\n    timingCcdToiComputation() {\n        return this.physicsPipeline.raw.timing_ccd_toi_computation();\n    }\n    /**\n     * The total time spent in the broad-phase during CCD.\n     *\n     * This timing is included in `timingCcd`.\n     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.\n     */\n    timingCcdBroadPhase() {\n        return this.physicsPipeline.raw.timing_ccd_broad_phase();\n    }\n    /**\n     * The total time spent in the narrow-phase during CCD.\n     *\n     * This timing is included in `timingCcd`.\n     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.\n     */\n    timingCcdNarrowPhase() {\n        return this.physicsPipeline.raw.timing_ccd_narrow_phase();\n    }\n    /**\n     * The total time spent in the constraints resolution during CCD.\n     *\n     * This timing is included in `timingCcd`.\n     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.\n     */\n    timingCcdSolver() {\n        return this.physicsPipeline.raw.timing_ccd_solver();\n    }\n    /**\n     * The total time spent in the islands calculation during CCD.\n     *\n     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.\n     */\n    timingIslandConstruction() {\n        return this.physicsPipeline.raw.timing_island_construction();\n    }\n    /**\n     * The total time spent propagating detected user changes.\n     *\n     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.\n     */\n    timingUserChanges() {\n        return this.physicsPipeline.raw.timing_user_changes();\n    }\n}\n//# sourceMappingURL=world.js.map"],"names":["World","free","this","integrationParameters","islands","broadPhase","narrowPhase","bodies","colliders","impulseJoints","multibodyJoints","ccdSolver","physicsPipeline","serializationPipeline","debugRenderPipeline","characterControllers","forEach","controller","pidControllers","vehicleControllers","undefined","constructor","gravity","rawIntegrationParameters","rawIslands","rawBroadPhase","rawNarrowPhase","rawBodies","rawColliders","rawImpulseJoints","rawMultibodyJoints","rawCCDSolver","rawPhysicsPipeline","rawSerializationPipeline","rawDebugRenderPipeline","IntegrationParameters","IslandManager","BroadPhase","NarrowPhase","RigidBodySet","ColliderSet","ImpulseJointSet","MultibodyJointSet","CCDSolver","PhysicsPipeline","SerializationPipeline","DebugRenderPipeline","Set","finalizeDeserialization","fromRaw","raw","VectorOps","takeGravity","takeIntegrationParameters","takeIslandManager","takeBroadPhase","takeNarrowPhase","takeBodies","takeColliders","takeImpulseJoints","takeMultibodyJoints","takeSnapshot","serializeAll","restoreSnapshot","data","deserializeAll","debugRender","filterFlags","filterPredicate","render","DebugRenderBuffers","vertices","colors","step","eventQueue","hooks","propagateModifiedBodyPositionsToColliders","timestep","dt","lengthUnit","unitsPerMeter","numSolverIterations","niter","numInternalPgsIterations","maxCcdSubsteps","substeps","createRigidBody","body","createCharacterController","offset","KinematicCharacterController","add","removeCharacterController","delete","createPidController","kp","ki","kd","axes","PidController","removePidController","createVehicleController","chassis","DynamicRayCastVehicleController","removeVehicleController","createCollider","desc","parent","handle","createImpulseJoint","params","parent1","parent2","wakeUp","createJoint","createMultibodyJoint","getRigidBody","get","getCollider","getImpulseJoint","getMultibodyJoint","removeRigidBody","remove","removeCollider","collider","removeImpulseJoint","joint","removeMultibodyJoint","forEachCollider","f","forEachRigidBody","forEachActiveRigidBody","castRay","ray","maxToi","solid","filterGroups","filterExcludeCollider","filterExcludeRigidBody","castClosure","castRayAndGetNormal","intersectionsWithRay","callback","intersectionWithShape","shapePos","shapeRot","shape","projectPoint","point","projectPointAndGetFeature","intersectionsWithPoint","castShape","shapeVel","targetDistance","stopAtPenetration","intersectionsWithShape","collidersWithAabbIntersectingAabb","aabbCenter","aabbHalfExtents","contactPairsWith","collider1","intersectionPairsWith","contactPair","collider2","intersectionPair","profilerEnabled","enabled","set_profiler_enabled","is_profiler_enabled","timingStep","timing_step","timingCollisionDetection","timing_collision_detection","timingBroadPhase","timing_broad_phase","timingNarrowPhase","timing_narrow_phase","timingSolver","timing_solver","timingVelocityAssembly","timing_velocity_assembly","timingVelocityResolution","timing_velocity_resolution","timingVelocityUpdate","timing_velocity_update","timingVelocityWriteback","timing_velocity_writeback","timingCcd","timing_ccd","timingCcdToiComputation","timing_ccd_toi_computation","timingCcdBroadPhase","timing_ccd_broad_phase","timingCcdNarrowPhase","timing_ccd_narrow_phase","timingCcdSolver","timing_ccd_solver","timingIslandConstruction","timing_island_construction","timingUserChanges","timing_user_changes"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/rapier_wasm3d.js

@@ -0,0 +1,2 @@
+import*as rapier_wasm3d_bg from"./rapier_wasm3d_bg.wasm.js";import{__wbg_set_wasm}from"./rapier_wasm3d_bg.js";export{RawBroadPhase,RawCCDSolver,RawCharacterCollision,RawColliderSet,RawColliderShapeCastHit,RawContactForceEvent,RawContactManifold,RawContactPair,RawDebugRenderPipeline,RawDeserializedWorld,RawDynamicRayCastVehicleController,RawEventQueue,RawGenericJoint,RawImpulseJointSet,RawIntegrationParameters,RawIslandManager,RawJointAxis,RawJointType,RawKinematicCharacterController,RawMultibodyJointSet,RawNarrowPhase,RawPhysicsPipeline,RawPidController,RawPointColliderProjection,RawPointProjection,RawRayColliderHit,RawRayColliderIntersection,RawRayIntersection,RawRigidBodySet,RawRotation,RawSdpMatrix3,RawSerializationPipeline,RawShape,RawShapeCastHit,RawShapeContact,RawShapeType,RawVector,__wbg_bind_c8359b1cba058168,__wbg_buffer_609cc3eee51ed158,__wbg_call_672a4d21634d4a24,__wbg_call_7cccdd69e0791ae2,__wbg_call_833bed5770ea2041,__wbg_call_b8adc8b1d0a0d8eb,__wbg_length_3b4f022188ae8db6,__wbg_length_a446193dc22c12f8,__wbg_new_a12002a7f91c75be,__wbg_newnoargs_105ed471475aaf50,__wbg_newwithbyteoffsetandlength_d97e637ebe145a9a,__wbg_newwithbyteoffsetandlength_e6b7e69acd4c7354,__wbg_newwithlength_5a5efe313cfd59f1,__wbg_now_2c95c9de01293173,__wbg_performance_7a3ffd0b17f663ad,__wbg_rawcontactforceevent_new,__wbg_rawraycolliderintersection_new,__wbg_set_10bad9bee0e9c58b,__wbg_set_65595bdd868b3009,__wbg_static_accessor_GLOBAL_88a902d13a557d07,__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0,__wbg_static_accessor_SELF_37c5d418e4bf5819,__wbg_static_accessor_WINDOW_5de37043a91a9c40,__wbindgen_boolean_get,__wbindgen_is_function,__wbindgen_is_undefined,__wbindgen_memory,__wbindgen_number_get,__wbindgen_number_new,__wbindgen_object_clone_ref,__wbindgen_object_drop_ref,__wbindgen_throw}from"./rapier_wasm3d_bg.js";__wbg_set_wasm(rapier_wasm3d_bg);export{__wbg_set_wasm};
+//# sourceMappingURL=rapier_wasm3d.js.map

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/rapier_wasm3d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rapier_wasm3d.js","sources":["../../../../../../../../../../../node_modules/@dimforge/rapier3d/rapier_wasm3d.js"],"sourcesContent":["import * as wasm from \"./rapier_wasm3d_bg.wasm\";\nexport * from \"./rapier_wasm3d_bg.js\";\nimport { __wbg_set_wasm } from \"./rapier_wasm3d_bg.js\";\n__wbg_set_wasm(wasm);"],"names":["__wbg_set_wasm","wasm"],"mappings":"uyDAGAA,eAAeC","x_google_ignoreList":[0]}