@hellpig/anarchy-engine 21.4.1 → 22.0.1

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

@@ -1 +0,0 @@
-{"version":3,"file":"pid_controller.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/control/pid_controller.js"],"sourcesContent":["import { RawPidController } from \"../raw\";\nimport { RotationOps, VectorOps } from \"../math\";\n// TODO: unify with the JointAxesMask\n/**\n * An enum representing the possible joint axes controlled by a PidController.\n * They can be ORed together, like:\n * PidAxesMask.LinX || PidAxesMask.LinY\n * to get a pid controller that only constraints the translational X and Y axes.\n *\n * Possible axes are:\n *\n * - `X`: X translation axis\n * - `Y`: Y translation axis\n * - `Z`: Z translation axis\n * - `AngX`: X angular rotation axis (3D only)\n * - `AngY`: Y angular rotation axis (3D only)\n * - `AngZ`: Z angular rotation axis\n */\nexport var PidAxesMask;\n(function (PidAxesMask) {\n    PidAxesMask[PidAxesMask[\"None\"] = 0] = \"None\";\n    PidAxesMask[PidAxesMask[\"LinX\"] = 1] = \"LinX\";\n    PidAxesMask[PidAxesMask[\"LinY\"] = 2] = \"LinY\";\n    PidAxesMask[PidAxesMask[\"LinZ\"] = 4] = \"LinZ\";\n    // #if DIM3\n    PidAxesMask[PidAxesMask[\"AngX\"] = 8] = \"AngX\";\n    PidAxesMask[PidAxesMask[\"AngY\"] = 16] = \"AngY\";\n    // #endif\n    PidAxesMask[PidAxesMask[\"AngZ\"] = 32] = \"AngZ\";\n    // #if DIM3\n    PidAxesMask[PidAxesMask[\"AllLin\"] = 7] = \"AllLin\";\n    PidAxesMask[PidAxesMask[\"AllAng\"] = 56] = \"AllAng\";\n    // #endif\n    PidAxesMask[PidAxesMask[\"All\"] = 63] = \"All\";\n})(PidAxesMask || (PidAxesMask = {}));\n/**\n * A controller for controlling dynamic bodies using the\n * Proportional-Integral-Derivative correction model.\n */\nexport class PidController {\n    constructor(params, bodies, kp, ki, kd, axes) {\n        this.params = params;\n        this.bodies = bodies;\n        this.raw = new RawPidController(kp, ki, kd, axes);\n    }\n    /** @internal */\n    free() {\n        if (!!this.raw) {\n            this.raw.free();\n        }\n        this.raw = undefined;\n    }\n    setKp(kp, axes) {\n        this.raw.set_kp(kp, axes);\n    }\n    setKi(ki, axes) {\n        this.raw.set_kp(ki, axes);\n    }\n    setKd(kd, axes) {\n        this.raw.set_kp(kd, axes);\n    }\n    setAxes(axes) {\n        this.raw.set_axes_mask(axes);\n    }\n    resetIntegrals() {\n        this.raw.reset_integrals();\n    }\n    applyLinearCorrection(body, targetPosition, targetLinvel) {\n        let rawPos = VectorOps.intoRaw(targetPosition);\n        let rawVel = VectorOps.intoRaw(targetLinvel);\n        this.raw.apply_linear_correction(this.params.dt, this.bodies.raw, body.handle, rawPos, rawVel);\n        rawPos.free();\n        rawVel.free();\n    }\n    // #if DIM3\n    applyAngularCorrection(body, targetRotation, targetAngVel) {\n        let rawPos = RotationOps.intoRaw(targetRotation);\n        let rawVel = VectorOps.intoRaw(targetAngVel);\n        this.raw.apply_angular_correction(this.params.dt, this.bodies.raw, body.handle, rawPos, rawVel);\n        rawPos.free();\n        rawVel.free();\n    }\n    // #endif\n    linearCorrection(body, targetPosition, targetLinvel) {\n        let rawPos = VectorOps.intoRaw(targetPosition);\n        let rawVel = VectorOps.intoRaw(targetLinvel);\n        let correction = this.raw.linear_correction(this.params.dt, this.bodies.raw, body.handle, rawPos, rawVel);\n        rawPos.free();\n        rawVel.free();\n        return VectorOps.fromRaw(correction);\n    }\n    // #if DIM3\n    angularCorrection(body, targetRotation, targetAngVel) {\n        let rawPos = RotationOps.intoRaw(targetRotation);\n        let rawVel = VectorOps.intoRaw(targetAngVel);\n        let correction = this.raw.angular_correction(this.params.dt, this.bodies.raw, body.handle, rawPos, rawVel);\n        rawPos.free();\n        rawVel.free();\n        return VectorOps.fromRaw(correction);\n    }\n}\n//# sourceMappingURL=pid_controller.js.map"],"names":["PidAxesMask","PidController","constructor","params","bodies","kp","ki","kd","axes","this","raw","RawPidController","free","undefined","setKp","set_kp","setKi","setKd","setAxes","set_axes_mask","resetIntegrals","reset_integrals","applyLinearCorrection","body","targetPosition","targetLinvel","rawPos","VectorOps","intoRaw","rawVel","apply_linear_correction","dt","handle","applyAngularCorrection","targetRotation","targetAngVel","RotationOps","apply_angular_correction","linearCorrection","correction","linear_correction","fromRaw","angularCorrection","angular_correction"],"mappings":"+HAkBU,IAACA,aACX,SAAWA,aACPA,YAAYA,YAAkB,KAAI,GAAK,OACvCA,YAAYA,YAAkB,KAAI,GAAK,OACvCA,YAAYA,YAAkB,KAAI,GAAK,OACvCA,YAAYA,YAAkB,KAAI,GAAK,OAEvCA,YAAYA,YAAkB,KAAI,GAAK,OACvCA,YAAYA,YAAkB,KAAI,IAAM,OAExCA,YAAYA,YAAkB,KAAI,IAAM,OAExCA,YAAYA,YAAoB,OAAI,GAAK,SACzCA,YAAYA,YAAoB,OAAI,IAAM,SAE1CA,YAAYA,YAAiB,IAAI,IAAM,KAC1C,CAfD,CAeGA,cAAgBA,YAAc,CAAA,IAK1B,MAAMC,cACT,WAAAC,CAAYC,OAAQC,OAAQC,GAAIC,GAAIC,GAAIC,MACpCC,KAAKN,OAASA,OACdM,KAAKL,OAASA,OACdK,KAAKC,IAAM,IAAIC,iBAAiBN,GAAIC,GAAIC,GAAIC,KAChD,CAEA,IAAAI,GACUH,KAAKC,KACPD,KAAKC,IAAIE,OAEbH,KAAKC,SAAMG,CACf,CACA,KAAAC,CAAMT,GAAIG,MACNC,KAAKC,IAAIK,OAAOV,GAAIG,KACxB,CACA,KAAAQ,CAAMV,GAAIE,MACNC,KAAKC,IAAIK,OAAOT,GAAIE,KACxB,CACA,KAAAS,CAAMV,GAAIC,MACNC,KAAKC,IAAIK,OAAOR,GAAIC,KACxB,CACA,OAAAU,CAAQV,MACJC,KAAKC,IAAIS,cAAcX,KAC3B,CACA,cAAAY,GACIX,KAAKC,IAAIW,iBACb,CACA,qBAAAC,CAAsBC,KAAMC,eAAgBC,cACxC,IAAIC,OAASC,UAAUC,QAAQJ,gBAC3BK,OAASF,UAAUC,QAAQH,cAC/BhB,KAAKC,IAAIoB,wBAAwBrB,KAAKN,OAAO4B,GAAItB,KAAKL,OAAOM,IAAKa,KAAKS,OAAQN,OAAQG,QACvFH,OAAOd,OACPiB,OAAOjB,MACX,CAEA,sBAAAqB,CAAuBV,KAAMW,eAAgBC,cACzC,IAAIT,OAASU,YAAYR,QAAQM,gBAC7BL,OAASF,UAAUC,QAAQO,cAC/B1B,KAAKC,IAAI2B,yBAAyB5B,KAAKN,OAAO4B,GAAItB,KAAKL,OAAOM,IAAKa,KAAKS,OAAQN,OAAQG,QACxFH,OAAOd,OACPiB,OAAOjB,MACX,CAEA,gBAAA0B,CAAiBf,KAAMC,eAAgBC,cACnC,IAAIC,OAASC,UAAUC,QAAQJ,gBAC3BK,OAASF,UAAUC,QAAQH,cAC3Bc,WAAa9B,KAAKC,IAAI8B,kBAAkB/B,KAAKN,OAAO4B,GAAItB,KAAKL,OAAOM,IAAKa,KAAKS,OAAQN,OAAQG,QAGlG,OAFAH,OAAOd,OACPiB,OAAOjB,OACAe,UAAUc,QAAQF,WAC7B,CAEA,iBAAAG,CAAkBnB,KAAMW,eAAgBC,cACpC,IAAIT,OAASU,YAAYR,QAAQM,gBAC7BL,OAASF,UAAUC,QAAQO,cAC3BI,WAAa9B,KAAKC,IAAIiC,mBAAmBlC,KAAKN,OAAO4B,GAAItB,KAAKL,OAAOM,IAAKa,KAAKS,OAAQN,OAAQG,QAGnG,OAFAH,OAAOd,OACPiB,OAAOjB,OACAe,UAAUc,QAAQF,WAC7B","x_google_ignoreList":[0]}

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

@@ -1,2 +0,0 @@
-import"../rapier_wasm3d.js";import{VectorOps}from"../math.js";import{RawDynamicRayCastVehicleController}from"../rapier_wasm3d_bg.js";class DynamicRayCastVehicleController{constructor(chassis,broadPhase,narrowPhase,bodies,colliders){this.raw=new RawDynamicRayCastVehicleController(chassis.handle),this.broadPhase=broadPhase,this.narrowPhase=narrowPhase,this.bodies=bodies,this.colliders=colliders,this._chassis=chassis}free(){this.raw&&this.raw.free(),this.raw=void 0}updateVehicle(dt,filterFlags,filterGroups,filterPredicate){this.raw.update_vehicle(dt,this.broadPhase.raw,this.narrowPhase.raw,this.bodies.raw,this.colliders.raw,filterFlags,filterGroups,this.colliders.castClosure(filterPredicate))}currentVehicleSpeed(){return this.raw.current_vehicle_speed()}chassis(){return this._chassis}get indexUpAxis(){return this.raw.index_up_axis()}set indexUpAxis(axis){this.raw.set_index_up_axis(axis)}get indexForwardAxis(){return this.raw.index_forward_axis()}set setIndexForwardAxis(axis){this.raw.set_index_forward_axis(axis)}addWheel(chassisConnectionCs,directionCs,axleCs,suspensionRestLength,radius){let rawChassisConnectionCs=VectorOps.intoRaw(chassisConnectionCs),rawDirectionCs=VectorOps.intoRaw(directionCs),rawAxleCs=VectorOps.intoRaw(axleCs);this.raw.add_wheel(rawChassisConnectionCs,rawDirectionCs,rawAxleCs,suspensionRestLength,radius),rawChassisConnectionCs.free(),rawDirectionCs.free(),rawAxleCs.free()}numWheels(){return this.raw.num_wheels()}wheelChassisConnectionPointCs(i){return VectorOps.fromRaw(this.raw.wheel_chassis_connection_point_cs(i))}setWheelChassisConnectionPointCs(i,value){let rawValue=VectorOps.intoRaw(value);this.raw.set_wheel_chassis_connection_point_cs(i,rawValue),rawValue.free()}wheelSuspensionRestLength(i){return this.raw.wheel_suspension_rest_length(i)}setWheelSuspensionRestLength(i,value){this.raw.set_wheel_suspension_rest_length(i,value)}wheelMaxSuspensionTravel(i){return this.raw.wheel_max_suspension_travel(i)}setWheelMaxSuspensionTravel(i,value){this.raw.set_wheel_max_suspension_travel(i,value)}wheelRadius(i){return this.raw.wheel_radius(i)}setWheelRadius(i,value){this.raw.set_wheel_radius(i,value)}wheelSuspensionStiffness(i){return this.raw.wheel_suspension_stiffness(i)}setWheelSuspensionStiffness(i,value){this.raw.set_wheel_suspension_stiffness(i,value)}wheelSuspensionCompression(i){return this.raw.wheel_suspension_compression(i)}setWheelSuspensionCompression(i,value){this.raw.set_wheel_suspension_compression(i,value)}wheelSuspensionRelaxation(i){return this.raw.wheel_suspension_relaxation(i)}setWheelSuspensionRelaxation(i,value){this.raw.set_wheel_suspension_relaxation(i,value)}wheelMaxSuspensionForce(i){return this.raw.wheel_max_suspension_force(i)}setWheelMaxSuspensionForce(i,value){this.raw.set_wheel_max_suspension_force(i,value)}wheelBrake(i){return this.raw.wheel_brake(i)}setWheelBrake(i,value){this.raw.set_wheel_brake(i,value)}wheelSteering(i){return this.raw.wheel_steering(i)}setWheelSteering(i,value){this.raw.set_wheel_steering(i,value)}wheelEngineForce(i){return this.raw.wheel_engine_force(i)}setWheelEngineForce(i,value){this.raw.set_wheel_engine_force(i,value)}wheelDirectionCs(i){return VectorOps.fromRaw(this.raw.wheel_direction_cs(i))}setWheelDirectionCs(i,value){let rawValue=VectorOps.intoRaw(value);this.raw.set_wheel_direction_cs(i,rawValue),rawValue.free()}wheelAxleCs(i){return VectorOps.fromRaw(this.raw.wheel_axle_cs(i))}setWheelAxleCs(i,value){let rawValue=VectorOps.intoRaw(value);this.raw.set_wheel_axle_cs(i,rawValue),rawValue.free()}wheelFrictionSlip(i){return this.raw.wheel_friction_slip(i)}setWheelFrictionSlip(i,value){this.raw.set_wheel_friction_slip(i,value)}wheelSideFrictionStiffness(i){return this.raw.wheel_side_friction_stiffness(i)}setWheelSideFrictionStiffness(i,value){this.raw.set_wheel_side_friction_stiffness(i,value)}wheelRotation(i){return this.raw.wheel_rotation(i)}wheelForwardImpulse(i){return this.raw.wheel_forward_impulse(i)}wheelSideImpulse(i){return this.raw.wheel_side_impulse(i)}wheelSuspensionForce(i){return this.raw.wheel_suspension_force(i)}wheelContactNormal(i){return VectorOps.fromRaw(this.raw.wheel_contact_normal_ws(i))}wheelContactPoint(i){return VectorOps.fromRaw(this.raw.wheel_contact_point_ws(i))}wheelSuspensionLength(i){return this.raw.wheel_suspension_length(i)}wheelHardPoint(i){return VectorOps.fromRaw(this.raw.wheel_hard_point_ws(i))}wheelIsInContact(i){return this.raw.wheel_is_in_contact(i)}wheelGroundObject(i){return this.colliders.get(this.raw.wheel_ground_object(i))}}export{DynamicRayCastVehicleController};
-//# sourceMappingURL=ray_cast_vehicle_controller.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ray_cast_vehicle_controller.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/control/ray_cast_vehicle_controller.js"],"sourcesContent":["import { RawDynamicRayCastVehicleController } from \"../raw\";\nimport { VectorOps } from \"../math\";\n/**\n * A character controller to simulate vehicles using ray-casting for the wheels.\n */\nexport class DynamicRayCastVehicleController {\n    constructor(chassis, broadPhase, narrowPhase, bodies, colliders) {\n        this.raw = new RawDynamicRayCastVehicleController(chassis.handle);\n        this.broadPhase = broadPhase;\n        this.narrowPhase = narrowPhase;\n        this.bodies = bodies;\n        this.colliders = colliders;\n        this._chassis = chassis;\n    }\n    /** @internal */\n    free() {\n        if (!!this.raw) {\n            this.raw.free();\n        }\n        this.raw = undefined;\n    }\n    /**\n     * Updates the vehicle’s velocity based on its suspension, engine force, and brake.\n     *\n     * This directly updates the velocity of its chassis rigid-body.\n     *\n     * @param dt - Time increment used to integrate forces.\n     * @param filterFlags - Flag to exclude categories of objects from the wheels’ ray-cast.\n     * @param filterGroups - Only colliders compatible with these groups will be hit by the wheels’ ray-casts.\n     * @param filterPredicate - Callback to filter out which collider will be hit by the wheels’ ray-casts.\n     */\n    updateVehicle(dt, filterFlags, filterGroups, filterPredicate) {\n        this.raw.update_vehicle(dt, this.broadPhase.raw, this.narrowPhase.raw, this.bodies.raw, this.colliders.raw, filterFlags, filterGroups, this.colliders.castClosure(filterPredicate));\n    }\n    /**\n     * The current forward speed of the vehicle.\n     */\n    currentVehicleSpeed() {\n        return this.raw.current_vehicle_speed();\n    }\n    /**\n     * The rigid-body used as the chassis.\n     */\n    chassis() {\n        return this._chassis;\n    }\n    /**\n     * The chassis’ local _up_ direction (`0 = x, 1 = y, 2 = z`).\n     */\n    get indexUpAxis() {\n        return this.raw.index_up_axis();\n    }\n    /**\n     * Sets the chassis’ local _up_ direction (`0 = x, 1 = y, 2 = z`).\n     */\n    set indexUpAxis(axis) {\n        this.raw.set_index_up_axis(axis);\n    }\n    /**\n     * The chassis’ local _forward_ direction (`0 = x, 1 = y, 2 = z`).\n     */\n    get indexForwardAxis() {\n        return this.raw.index_forward_axis();\n    }\n    /**\n     * Sets the chassis’ local _forward_ direction (`0 = x, 1 = y, 2 = z`).\n     */\n    set setIndexForwardAxis(axis) {\n        this.raw.set_index_forward_axis(axis);\n    }\n    /**\n     * Adds a new wheel attached to this vehicle.\n     * @param chassisConnectionCs  - The position of the wheel relative to the chassis.\n     * @param directionCs - The direction of the wheel’s suspension, relative to the chassis. The ray-casting will\n     *                      happen following this direction to detect the ground.\n     * @param axleCs - The wheel’s axle axis, relative to the chassis.\n     * @param suspensionRestLength - The rest length of the wheel’s suspension spring.\n     * @param radius - The wheel’s radius.\n     */\n    addWheel(chassisConnectionCs, directionCs, axleCs, suspensionRestLength, radius) {\n        let rawChassisConnectionCs = VectorOps.intoRaw(chassisConnectionCs);\n        let rawDirectionCs = VectorOps.intoRaw(directionCs);\n        let rawAxleCs = VectorOps.intoRaw(axleCs);\n        this.raw.add_wheel(rawChassisConnectionCs, rawDirectionCs, rawAxleCs, suspensionRestLength, radius);\n        rawChassisConnectionCs.free();\n        rawDirectionCs.free();\n        rawAxleCs.free();\n    }\n    /**\n     * The number of wheels attached to this vehicle.\n     */\n    numWheels() {\n        return this.raw.num_wheels();\n    }\n    /*\n     *\n     * Access to wheel properties.\n     *\n     */\n    /*\n     * Getters + setters\n     */\n    /**\n     * The position of the i-th wheel, relative to the chassis.\n     */\n    wheelChassisConnectionPointCs(i) {\n        return VectorOps.fromRaw(this.raw.wheel_chassis_connection_point_cs(i));\n    }\n    /**\n     * Sets the position of the i-th wheel, relative to the chassis.\n     */\n    setWheelChassisConnectionPointCs(i, value) {\n        let rawValue = VectorOps.intoRaw(value);\n        this.raw.set_wheel_chassis_connection_point_cs(i, rawValue);\n        rawValue.free();\n    }\n    /**\n     * The rest length of the i-th wheel’s suspension spring.\n     */\n    wheelSuspensionRestLength(i) {\n        return this.raw.wheel_suspension_rest_length(i);\n    }\n    /**\n     * Sets the rest length of the i-th wheel’s suspension spring.\n     */\n    setWheelSuspensionRestLength(i, value) {\n        this.raw.set_wheel_suspension_rest_length(i, value);\n    }\n    /**\n     * The maximum distance the i-th wheel suspension can travel before and after its resting length.\n     */\n    wheelMaxSuspensionTravel(i) {\n        return this.raw.wheel_max_suspension_travel(i);\n    }\n    /**\n     * Sets the maximum distance the i-th wheel suspension can travel before and after its resting length.\n     */\n    setWheelMaxSuspensionTravel(i, value) {\n        this.raw.set_wheel_max_suspension_travel(i, value);\n    }\n    /**\n     * The i-th wheel’s radius.\n     */\n    wheelRadius(i) {\n        return this.raw.wheel_radius(i);\n    }\n    /**\n     * Sets the i-th wheel’s radius.\n     */\n    setWheelRadius(i, value) {\n        this.raw.set_wheel_radius(i, value);\n    }\n    /**\n     * The i-th wheel’s suspension stiffness.\n     *\n     * Increase this value if the suspension appears to not push the vehicle strong enough.\n     */\n    wheelSuspensionStiffness(i) {\n        return this.raw.wheel_suspension_stiffness(i);\n    }\n    /**\n     * Sets the i-th wheel’s suspension stiffness.\n     *\n     * Increase this value if the suspension appears to not push the vehicle strong enough.\n     */\n    setWheelSuspensionStiffness(i, value) {\n        this.raw.set_wheel_suspension_stiffness(i, value);\n    }\n    /**\n     * The i-th wheel’s suspension’s damping when it is being compressed.\n     */\n    wheelSuspensionCompression(i) {\n        return this.raw.wheel_suspension_compression(i);\n    }\n    /**\n     * The i-th wheel’s suspension’s damping when it is being compressed.\n     */\n    setWheelSuspensionCompression(i, value) {\n        this.raw.set_wheel_suspension_compression(i, value);\n    }\n    /**\n     * The i-th wheel’s suspension’s damping when it is being released.\n     *\n     * Increase this value if the suspension appears to overshoot.\n     */\n    wheelSuspensionRelaxation(i) {\n        return this.raw.wheel_suspension_relaxation(i);\n    }\n    /**\n     * Sets the i-th wheel’s suspension’s damping when it is being released.\n     *\n     * Increase this value if the suspension appears to overshoot.\n     */\n    setWheelSuspensionRelaxation(i, value) {\n        this.raw.set_wheel_suspension_relaxation(i, value);\n    }\n    /**\n     * The maximum force applied by the i-th wheel’s suspension.\n     */\n    wheelMaxSuspensionForce(i) {\n        return this.raw.wheel_max_suspension_force(i);\n    }\n    /**\n     * Sets the maximum force applied by the i-th wheel’s suspension.\n     */\n    setWheelMaxSuspensionForce(i, value) {\n        this.raw.set_wheel_max_suspension_force(i, value);\n    }\n    /**\n     * The maximum amount of braking impulse applied on the i-th wheel to slow down the vehicle.\n     */\n    wheelBrake(i) {\n        return this.raw.wheel_brake(i);\n    }\n    /**\n     * Set the maximum amount of braking impulse applied on the i-th wheel to slow down the vehicle.\n     */\n    setWheelBrake(i, value) {\n        this.raw.set_wheel_brake(i, value);\n    }\n    /**\n     * The steering angle (radians) for the i-th wheel.\n     */\n    wheelSteering(i) {\n        return this.raw.wheel_steering(i);\n    }\n    /**\n     * Sets the steering angle (radians) for the i-th wheel.\n     */\n    setWheelSteering(i, value) {\n        this.raw.set_wheel_steering(i, value);\n    }\n    /**\n     * The forward force applied by the i-th wheel on the chassis.\n     */\n    wheelEngineForce(i) {\n        return this.raw.wheel_engine_force(i);\n    }\n    /**\n     * Sets the forward force applied by the i-th wheel on the chassis.\n     */\n    setWheelEngineForce(i, value) {\n        this.raw.set_wheel_engine_force(i, value);\n    }\n    /**\n     * The direction of the i-th wheel’s suspension, relative to the chassis.\n     *\n     * The ray-casting will happen following this direction to detect the ground.\n     */\n    wheelDirectionCs(i) {\n        return VectorOps.fromRaw(this.raw.wheel_direction_cs(i));\n    }\n    /**\n     * Sets the direction of the i-th wheel’s suspension, relative to the chassis.\n     *\n     * The ray-casting will happen following this direction to detect the ground.\n     */\n    setWheelDirectionCs(i, value) {\n        let rawValue = VectorOps.intoRaw(value);\n        this.raw.set_wheel_direction_cs(i, rawValue);\n        rawValue.free();\n    }\n    /**\n     * The i-th wheel’s axle axis, relative to the chassis.\n     *\n     * The axis index defined as 0 = X, 1 = Y, 2 = Z.\n     */\n    wheelAxleCs(i) {\n        return VectorOps.fromRaw(this.raw.wheel_axle_cs(i));\n    }\n    /**\n     * Sets the i-th wheel’s axle axis, relative to the chassis.\n     *\n     * The axis index defined as 0 = X, 1 = Y, 2 = Z.\n     */\n    setWheelAxleCs(i, value) {\n        let rawValue = VectorOps.intoRaw(value);\n        this.raw.set_wheel_axle_cs(i, rawValue);\n        rawValue.free();\n    }\n    /**\n     * Parameter controlling how much traction the tire has.\n     *\n     * The larger the value, the more instantaneous braking will happen (with the risk of\n     * causing the vehicle to flip if it’s too strong).\n     */\n    wheelFrictionSlip(i) {\n        return this.raw.wheel_friction_slip(i);\n    }\n    /**\n     * Sets the parameter controlling how much traction the tire has.\n     *\n     * The larger the value, the more instantaneous braking will happen (with the risk of\n     * causing the vehicle to flip if it’s too strong).\n     */\n    setWheelFrictionSlip(i, value) {\n        this.raw.set_wheel_friction_slip(i, value);\n    }\n    /**\n     * The multiplier of friction between a tire and the collider it’s on top of.\n     *\n     * The larger the value, the stronger side friction will be.\n     */\n    wheelSideFrictionStiffness(i) {\n        return this.raw.wheel_side_friction_stiffness(i);\n    }\n    /**\n     * The multiplier of friction between a tire and the collider it’s on top of.\n     *\n     * The larger the value, the stronger side friction will be.\n     */\n    setWheelSideFrictionStiffness(i, value) {\n        this.raw.set_wheel_side_friction_stiffness(i, value);\n    }\n    /*\n     * Getters only.\n     */\n    /**\n     *  The i-th wheel’s current rotation angle (radians) on its axle.\n     */\n    wheelRotation(i) {\n        return this.raw.wheel_rotation(i);\n    }\n    /**\n     *  The forward impulses applied by the i-th wheel on the chassis.\n     */\n    wheelForwardImpulse(i) {\n        return this.raw.wheel_forward_impulse(i);\n    }\n    /**\n     *  The side impulses applied by the i-th wheel on the chassis.\n     */\n    wheelSideImpulse(i) {\n        return this.raw.wheel_side_impulse(i);\n    }\n    /**\n     *  The force applied by the i-th wheel suspension.\n     */\n    wheelSuspensionForce(i) {\n        return this.raw.wheel_suspension_force(i);\n    }\n    /**\n     *  The (world-space) contact normal between the i-th wheel and the floor.\n     */\n    wheelContactNormal(i) {\n        return VectorOps.fromRaw(this.raw.wheel_contact_normal_ws(i));\n    }\n    /**\n     *  The (world-space) point hit by the wheel’s ray-cast for the i-th wheel.\n     */\n    wheelContactPoint(i) {\n        return VectorOps.fromRaw(this.raw.wheel_contact_point_ws(i));\n    }\n    /**\n     *  The suspension length for the i-th wheel.\n     */\n    wheelSuspensionLength(i) {\n        return this.raw.wheel_suspension_length(i);\n    }\n    /**\n     *  The (world-space) starting point of the ray-cast for the i-th wheel.\n     */\n    wheelHardPoint(i) {\n        return VectorOps.fromRaw(this.raw.wheel_hard_point_ws(i));\n    }\n    /**\n     *  Is the i-th wheel in contact with the ground?\n     */\n    wheelIsInContact(i) {\n        return this.raw.wheel_is_in_contact(i);\n    }\n    /**\n     *  The collider hit by the ray-cast for the i-th wheel.\n     */\n    wheelGroundObject(i) {\n        return this.colliders.get(this.raw.wheel_ground_object(i));\n    }\n}\n//# sourceMappingURL=ray_cast_vehicle_controller.js.map"],"names":["DynamicRayCastVehicleController","constructor","chassis","broadPhase","narrowPhase","bodies","colliders","this","raw","RawDynamicRayCastVehicleController","handle","_chassis","free","undefined","updateVehicle","dt","filterFlags","filterGroups","filterPredicate","update_vehicle","castClosure","currentVehicleSpeed","current_vehicle_speed","indexUpAxis","index_up_axis","axis","set_index_up_axis","indexForwardAxis","index_forward_axis","setIndexForwardAxis","set_index_forward_axis","addWheel","chassisConnectionCs","directionCs","axleCs","suspensionRestLength","radius","rawChassisConnectionCs","VectorOps","intoRaw","rawDirectionCs","rawAxleCs","add_wheel","numWheels","num_wheels","wheelChassisConnectionPointCs","i","fromRaw","wheel_chassis_connection_point_cs","setWheelChassisConnectionPointCs","value","rawValue","set_wheel_chassis_connection_point_cs","wheelSuspensionRestLength","wheel_suspension_rest_length","setWheelSuspensionRestLength","set_wheel_suspension_rest_length","wheelMaxSuspensionTravel","wheel_max_suspension_travel","setWheelMaxSuspensionTravel","set_wheel_max_suspension_travel","wheelRadius","wheel_radius","setWheelRadius","set_wheel_radius","wheelSuspensionStiffness","wheel_suspension_stiffness","setWheelSuspensionStiffness","set_wheel_suspension_stiffness","wheelSuspensionCompression","wheel_suspension_compression","setWheelSuspensionCompression","set_wheel_suspension_compression","wheelSuspensionRelaxation","wheel_suspension_relaxation","setWheelSuspensionRelaxation","set_wheel_suspension_relaxation","wheelMaxSuspensionForce","wheel_max_suspension_force","setWheelMaxSuspensionForce","set_wheel_max_suspension_force","wheelBrake","wheel_brake","setWheelBrake","set_wheel_brake","wheelSteering","wheel_steering","setWheelSteering","set_wheel_steering","wheelEngineForce","wheel_engine_force","setWheelEngineForce","set_wheel_engine_force","wheelDirectionCs","wheel_direction_cs","setWheelDirectionCs","set_wheel_direction_cs","wheelAxleCs","wheel_axle_cs","setWheelAxleCs","set_wheel_axle_cs","wheelFrictionSlip","wheel_friction_slip","setWheelFrictionSlip","set_wheel_friction_slip","wheelSideFrictionStiffness","wheel_side_friction_stiffness","setWheelSideFrictionStiffness","set_wheel_side_friction_stiffness","wheelRotation","wheel_rotation","wheelForwardImpulse","wheel_forward_impulse","wheelSideImpulse","wheel_side_impulse","wheelSuspensionForce","wheel_suspension_force","wheelContactNormal","wheel_contact_normal_ws","wheelContactPoint","wheel_contact_point_ws","wheelSuspensionLength","wheel_suspension_length","wheelHardPoint","wheel_hard_point_ws","wheelIsInContact","wheel_is_in_contact","wheelGroundObject","get","wheel_ground_object"],"mappings":"qIAKO,MAAMA,gCACT,WAAAC,CAAYC,QAASC,WAAYC,YAAaC,OAAQC,WAClDC,KAAKC,IAAM,IAAIC,mCAAmCP,QAAQQ,QAC1DH,KAAKJ,WAAaA,WAClBI,KAAKH,YAAcA,YACnBG,KAAKF,OAASA,OACdE,KAAKD,UAAYA,UACjBC,KAAKI,SAAWT,OACpB,CAEA,IAAAU,GACUL,KAAKC,KACPD,KAAKC,IAAII,OAEbL,KAAKC,SAAMK,CACf,CAWA,aAAAC,CAAcC,GAAIC,YAAaC,aAAcC,iBACzCX,KAAKC,IAAIW,eAAeJ,GAAIR,KAAKJ,WAAWK,IAAKD,KAAKH,YAAYI,IAAKD,KAAKF,OAAOG,IAAKD,KAAKD,UAAUE,IAAKQ,YAAaC,aAAcV,KAAKD,UAAUc,YAAYF,iBACtK,CAIA,mBAAAG,GACI,OAAOd,KAAKC,IAAIc,uBACpB,CAIA,OAAApB,GACI,OAAOK,KAAKI,QAChB,CAIA,eAAIY,GACA,OAAOhB,KAAKC,IAAIgB,eACpB,CAIA,eAAID,CAAYE,MACZlB,KAAKC,IAAIkB,kBAAkBD,KAC/B,CAIA,oBAAIE,GACA,OAAOpB,KAAKC,IAAIoB,oBACpB,CAIA,uBAAIC,CAAoBJ,MACpBlB,KAAKC,IAAIsB,uBAAuBL,KACpC,CAUA,QAAAM,CAASC,oBAAqBC,YAAaC,OAAQC,qBAAsBC,QACrE,IAAIC,uBAAyBC,UAAUC,QAAQP,qBAC3CQ,eAAiBF,UAAUC,QAAQN,aACnCQ,UAAYH,UAAUC,QAAQL,QAClC3B,KAAKC,IAAIkC,UAAUL,uBAAwBG,eAAgBC,UAAWN,qBAAsBC,QAC5FC,uBAAuBzB,OACvB4B,eAAe5B,OACf6B,UAAU7B,MACd,CAIA,SAAA+B,GACI,OAAOpC,KAAKC,IAAIoC,YACpB,CAYA,6BAAAC,CAA8BC,GAC1B,OAAOR,UAAUS,QAAQxC,KAAKC,IAAIwC,kCAAkCF,GACxE,CAIA,gCAAAG,CAAiCH,EAAGI,OAChC,IAAIC,SAAWb,UAAUC,QAAQW,OACjC3C,KAAKC,IAAI4C,sCAAsCN,EAAGK,UAClDA,SAASvC,MACb,CAIA,yBAAAyC,CAA0BP,GACtB,OAAOvC,KAAKC,IAAI8C,6BAA6BR,EACjD,CAIA,4BAAAS,CAA6BT,EAAGI,OAC5B3C,KAAKC,IAAIgD,iCAAiCV,EAAGI,MACjD,CAIA,wBAAAO,CAAyBX,GACrB,OAAOvC,KAAKC,IAAIkD,4BAA4BZ,EAChD,CAIA,2BAAAa,CAA4Bb,EAAGI,OAC3B3C,KAAKC,IAAIoD,gCAAgCd,EAAGI,MAChD,CAIA,WAAAW,CAAYf,GACR,OAAOvC,KAAKC,IAAIsD,aAAahB,EACjC,CAIA,cAAAiB,CAAejB,EAAGI,OACd3C,KAAKC,IAAIwD,iBAAiBlB,EAAGI,MACjC,CAMA,wBAAAe,CAAyBnB,GACrB,OAAOvC,KAAKC,IAAI0D,2BAA2BpB,EAC/C,CAMA,2BAAAqB,CAA4BrB,EAAGI,OAC3B3C,KAAKC,IAAI4D,+BAA+BtB,EAAGI,MAC/C,CAIA,0BAAAmB,CAA2BvB,GACvB,OAAOvC,KAAKC,IAAI8D,6BAA6BxB,EACjD,CAIA,6BAAAyB,CAA8BzB,EAAGI,OAC7B3C,KAAKC,IAAIgE,iCAAiC1B,EAAGI,MACjD,CAMA,yBAAAuB,CAA0B3B,GACtB,OAAOvC,KAAKC,IAAIkE,4BAA4B5B,EAChD,CAMA,4BAAA6B,CAA6B7B,EAAGI,OAC5B3C,KAAKC,IAAIoE,gCAAgC9B,EAAGI,MAChD,CAIA,uBAAA2B,CAAwB/B,GACpB,OAAOvC,KAAKC,IAAIsE,2BAA2BhC,EAC/C,CAIA,0BAAAiC,CAA2BjC,EAAGI,OAC1B3C,KAAKC,IAAIwE,+BAA+BlC,EAAGI,MAC/C,CAIA,UAAA+B,CAAWnC,GACP,OAAOvC,KAAKC,IAAI0E,YAAYpC,EAChC,CAIA,aAAAqC,CAAcrC,EAAGI,OACb3C,KAAKC,IAAI4E,gBAAgBtC,EAAGI,MAChC,CAIA,aAAAmC,CAAcvC,GACV,OAAOvC,KAAKC,IAAI8E,eAAexC,EACnC,CAIA,gBAAAyC,CAAiBzC,EAAGI,OAChB3C,KAAKC,IAAIgF,mBAAmB1C,EAAGI,MACnC,CAIA,gBAAAuC,CAAiB3C,GACb,OAAOvC,KAAKC,IAAIkF,mBAAmB5C,EACvC,CAIA,mBAAA6C,CAAoB7C,EAAGI,OACnB3C,KAAKC,IAAIoF,uBAAuB9C,EAAGI,MACvC,CAMA,gBAAA2C,CAAiB/C,GACb,OAAOR,UAAUS,QAAQxC,KAAKC,IAAIsF,mBAAmBhD,GACzD,CAMA,mBAAAiD,CAAoBjD,EAAGI,OACnB,IAAIC,SAAWb,UAAUC,QAAQW,OACjC3C,KAAKC,IAAIwF,uBAAuBlD,EAAGK,UACnCA,SAASvC,MACb,CAMA,WAAAqF,CAAYnD,GACR,OAAOR,UAAUS,QAAQxC,KAAKC,IAAI0F,cAAcpD,GACpD,CAMA,cAAAqD,CAAerD,EAAGI,OACd,IAAIC,SAAWb,UAAUC,QAAQW,OACjC3C,KAAKC,IAAI4F,kBAAkBtD,EAAGK,UAC9BA,SAASvC,MACb,CAOA,iBAAAyF,CAAkBvD,GACd,OAAOvC,KAAKC,IAAI8F,oBAAoBxD,EACxC,CAOA,oBAAAyD,CAAqBzD,EAAGI,OACpB3C,KAAKC,IAAIgG,wBAAwB1D,EAAGI,MACxC,CAMA,0BAAAuD,CAA2B3D,GACvB,OAAOvC,KAAKC,IAAIkG,8BAA8B5D,EAClD,CAMA,6BAAA6D,CAA8B7D,EAAGI,OAC7B3C,KAAKC,IAAIoG,kCAAkC9D,EAAGI,MAClD,CAOA,aAAA2D,CAAc/D,GACV,OAAOvC,KAAKC,IAAIsG,eAAehE,EACnC,CAIA,mBAAAiE,CAAoBjE,GAChB,OAAOvC,KAAKC,IAAIwG,sBAAsBlE,EAC1C,CAIA,gBAAAmE,CAAiBnE,GACb,OAAOvC,KAAKC,IAAI0G,mBAAmBpE,EACvC,CAIA,oBAAAqE,CAAqBrE,GACjB,OAAOvC,KAAKC,IAAI4G,uBAAuBtE,EAC3C,CAIA,kBAAAuE,CAAmBvE,GACf,OAAOR,UAAUS,QAAQxC,KAAKC,IAAI8G,wBAAwBxE,GAC9D,CAIA,iBAAAyE,CAAkBzE,GACd,OAAOR,UAAUS,QAAQxC,KAAKC,IAAIgH,uBAAuB1E,GAC7D,CAIA,qBAAA2E,CAAsB3E,GAClB,OAAOvC,KAAKC,IAAIkH,wBAAwB5E,EAC5C,CAIA,cAAA6E,CAAe7E,GACX,OAAOR,UAAUS,QAAQxC,KAAKC,IAAIoH,oBAAoB9E,GAC1D,CAIA,gBAAA+E,CAAiB/E,GACb,OAAOvC,KAAKC,IAAIsH,oBAAoBhF,EACxC,CAIA,iBAAAiF,CAAkBjF,GACd,OAAOvC,KAAKD,UAAU0H,IAAIzH,KAAKC,IAAIyH,oBAAoBnF,GAC3D","x_google_ignoreList":[0]}

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

@@ -1,2 +0,0 @@
-import"../rapier_wasm3d.js";import{RawCCDSolver}from"../rapier_wasm3d_bg.js";class CCDSolver{free(){this.raw&&this.raw.free(),this.raw=void 0}constructor(raw){this.raw=raw||new RawCCDSolver}}export{CCDSolver};
-//# sourceMappingURL=ccd_solver.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ccd_solver.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/dynamics/ccd_solver.js"],"sourcesContent":["import { RawCCDSolver } from \"../raw\";\n/**\n * The CCD solver responsible for resolving Continuous Collision Detection.\n *\n * To avoid leaking WASM resources, this MUST be freed manually with `ccdSolver.free()`\n * once you are done using it.\n */\nexport class CCDSolver {\n    /**\n     * Release the WASM memory occupied by this narrow-phase.\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 RawCCDSolver();\n    }\n}\n//# sourceMappingURL=ccd_solver.js.map"],"names":["CCDSolver","free","this","raw","undefined","constructor","RawCCDSolver"],"mappings":"6EAOO,MAAMA,UAIT,IAAAC,GACUC,KAAKC,KACPD,KAAKC,IAAIF,OAEbC,KAAKC,SAAMC,CACf,CACA,WAAAC,CAAYF,KACRD,KAAKC,IAAMA,KAAO,IAAIG,YAC1B","x_google_ignoreList":[0]}

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

@@ -1,2 +0,0 @@
-var CoefficientCombineRule;!function(CoefficientCombineRule){CoefficientCombineRule[CoefficientCombineRule.Average=0]="Average",CoefficientCombineRule[CoefficientCombineRule.Min=1]="Min",CoefficientCombineRule[CoefficientCombineRule.Multiply=2]="Multiply",CoefficientCombineRule[CoefficientCombineRule.Max=3]="Max"}(CoefficientCombineRule||(CoefficientCombineRule={}));export{CoefficientCombineRule};
-//# sourceMappingURL=coefficient_combine_rule.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"coefficient_combine_rule.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/dynamics/coefficient_combine_rule.js"],"sourcesContent":["/**\n * A rule applied to combine coefficients.\n *\n * Use this when configuring the `ColliderDesc` to specify\n * how friction and restitution coefficient should be combined\n * in a contact.\n */\nexport var CoefficientCombineRule;\n(function (CoefficientCombineRule) {\n    CoefficientCombineRule[CoefficientCombineRule[\"Average\"] = 0] = \"Average\";\n    CoefficientCombineRule[CoefficientCombineRule[\"Min\"] = 1] = \"Min\";\n    CoefficientCombineRule[CoefficientCombineRule[\"Multiply\"] = 2] = \"Multiply\";\n    CoefficientCombineRule[CoefficientCombineRule[\"Max\"] = 3] = \"Max\";\n})(CoefficientCombineRule || (CoefficientCombineRule = {}));\n//# sourceMappingURL=coefficient_combine_rule.js.map"],"names":["CoefficientCombineRule"],"mappings":"AAOU,IAACA,wBACX,SAAWA,wBACPA,uBAAuBA,uBAAgC,QAAI,GAAK,UAChEA,uBAAuBA,uBAA4B,IAAI,GAAK,MAC5DA,uBAAuBA,uBAAiC,SAAI,GAAK,WACjEA,uBAAuBA,uBAA4B,IAAI,GAAK,KAC/D,CALD,CAKGA,yBAA2BA,uBAAyB,CAAA","x_google_ignoreList":[0]}

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

@@ -1,2 +0,0 @@
-import{RotationOps,VectorOps}from"../math.js";import"../rapier_wasm3d.js";import{RawJointType,RawJointAxis}from"../rapier_wasm3d_bg.js";var JointType,MotorModel,JointAxesMask;!function(JointType){JointType[JointType.Revolute=0]="Revolute",JointType[JointType.Fixed=1]="Fixed",JointType[JointType.Prismatic=2]="Prismatic",JointType[JointType.Rope=3]="Rope",JointType[JointType.Spring=4]="Spring",JointType[JointType.Spherical=5]="Spherical",JointType[JointType.Generic=6]="Generic"}(JointType||(JointType={})),function(MotorModel){MotorModel[MotorModel.AccelerationBased=0]="AccelerationBased",MotorModel[MotorModel.ForceBased=1]="ForceBased"}(MotorModel||(MotorModel={})),function(JointAxesMask){JointAxesMask[JointAxesMask.LinX=1]="LinX",JointAxesMask[JointAxesMask.LinY=2]="LinY",JointAxesMask[JointAxesMask.LinZ=4]="LinZ",JointAxesMask[JointAxesMask.AngX=8]="AngX",JointAxesMask[JointAxesMask.AngY=16]="AngY",JointAxesMask[JointAxesMask.AngZ=32]="AngZ"}(JointAxesMask||(JointAxesMask={}));class ImpulseJoint{constructor(rawSet,bodySet,handle){this.rawSet=rawSet,this.bodySet=bodySet,this.handle=handle}static newTyped(rawSet,bodySet,handle){switch(rawSet.jointType(handle)){case RawJointType.Revolute:return new RevoluteImpulseJoint(rawSet,bodySet,handle);case RawJointType.Prismatic:return new PrismaticImpulseJoint(rawSet,bodySet,handle);case RawJointType.Fixed:return new FixedImpulseJoint(rawSet,bodySet,handle);case RawJointType.Spring:return new SpringImpulseJoint(rawSet,bodySet,handle);case RawJointType.Rope:return new RopeImpulseJoint(rawSet,bodySet,handle);case RawJointType.Spherical:return new SphericalImpulseJoint(rawSet,bodySet,handle);case RawJointType.Generic:return new GenericImpulseJoint(rawSet,bodySet,handle);default:return new ImpulseJoint(rawSet,bodySet,handle)}}finalizeDeserialization(bodySet){this.bodySet=bodySet}isValid(){return this.rawSet.contains(this.handle)}body1(){return this.bodySet.get(this.rawSet.jointBodyHandle1(this.handle))}body2(){return this.bodySet.get(this.rawSet.jointBodyHandle2(this.handle))}type(){return this.rawSet.jointType(this.handle)}frameX1(){return RotationOps.fromRaw(this.rawSet.jointFrameX1(this.handle))}frameX2(){return RotationOps.fromRaw(this.rawSet.jointFrameX2(this.handle))}anchor1(){return VectorOps.fromRaw(this.rawSet.jointAnchor1(this.handle))}anchor2(){return VectorOps.fromRaw(this.rawSet.jointAnchor2(this.handle))}setAnchor1(newPos){const rawPoint=VectorOps.intoRaw(newPos);this.rawSet.jointSetAnchor1(this.handle,rawPoint),rawPoint.free()}setAnchor2(newPos){const rawPoint=VectorOps.intoRaw(newPos);this.rawSet.jointSetAnchor2(this.handle,rawPoint),rawPoint.free()}setContactsEnabled(enabled){this.rawSet.jointSetContactsEnabled(this.handle,enabled)}contactsEnabled(){return this.rawSet.jointContactsEnabled(this.handle)}}class UnitImpulseJoint extends ImpulseJoint{limitsEnabled(){return this.rawSet.jointLimitsEnabled(this.handle,this.rawAxis())}limitsMin(){return this.rawSet.jointLimitsMin(this.handle,this.rawAxis())}limitsMax(){return this.rawSet.jointLimitsMax(this.handle,this.rawAxis())}setLimits(min,max){this.rawSet.jointSetLimits(this.handle,this.rawAxis(),min,max)}configureMotorModel(model){this.rawSet.jointConfigureMotorModel(this.handle,this.rawAxis(),model)}configureMotorVelocity(targetVel,factor){this.rawSet.jointConfigureMotorVelocity(this.handle,this.rawAxis(),targetVel,factor)}configureMotorPosition(targetPos,stiffness,damping){this.rawSet.jointConfigureMotorPosition(this.handle,this.rawAxis(),targetPos,stiffness,damping)}configureMotor(targetPos,targetVel,stiffness,damping){this.rawSet.jointConfigureMotor(this.handle,this.rawAxis(),targetPos,targetVel,stiffness,damping)}}class FixedImpulseJoint extends ImpulseJoint{}class RopeImpulseJoint extends ImpulseJoint{}class SpringImpulseJoint extends ImpulseJoint{}class PrismaticImpulseJoint extends UnitImpulseJoint{rawAxis(){return RawJointAxis.LinX}}class RevoluteImpulseJoint extends UnitImpulseJoint{rawAxis(){return RawJointAxis.AngX}}class GenericImpulseJoint extends ImpulseJoint{}class SphericalImpulseJoint extends ImpulseJoint{}export{FixedImpulseJoint,GenericImpulseJoint,ImpulseJoint,JointAxesMask,JointType,MotorModel,PrismaticImpulseJoint,RevoluteImpulseJoint,RopeImpulseJoint,SphericalImpulseJoint,SpringImpulseJoint,UnitImpulseJoint};
-//# sourceMappingURL=impulse_joint.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"impulse_joint.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/dynamics/impulse_joint.js"],"sourcesContent":["import { VectorOps, RotationOps } from \"../math\";\nimport { RawGenericJoint, RawJointAxis, RawJointType, } from \"../raw\";\n/**\n * An enum grouping all possible types of joints:\n *\n * - `Revolute`: A revolute joint that removes all degrees of freedom between the affected\n *               bodies except for the rotation along one axis.\n * - `Fixed`: A fixed joint that removes all relative degrees of freedom between the affected bodies.\n * - `Prismatic`: A prismatic joint that removes all degrees of freedom between the affected\n *                bodies except for the translation along one axis.\n * - `Spherical`: (3D only) A spherical joint that removes all relative linear degrees of freedom between the affected bodies.\n * - `Generic`: (3D only) A joint with customizable degrees of freedom, allowing any of the 6 axes to be locked.\n */\nexport var JointType;\n(function (JointType) {\n    JointType[JointType[\"Revolute\"] = 0] = \"Revolute\";\n    JointType[JointType[\"Fixed\"] = 1] = \"Fixed\";\n    JointType[JointType[\"Prismatic\"] = 2] = \"Prismatic\";\n    JointType[JointType[\"Rope\"] = 3] = \"Rope\";\n    JointType[JointType[\"Spring\"] = 4] = \"Spring\";\n    // #if DIM3\n    JointType[JointType[\"Spherical\"] = 5] = \"Spherical\";\n    JointType[JointType[\"Generic\"] = 6] = \"Generic\";\n    // #endif\n})(JointType || (JointType = {}));\nexport var MotorModel;\n(function (MotorModel) {\n    MotorModel[MotorModel[\"AccelerationBased\"] = 0] = \"AccelerationBased\";\n    MotorModel[MotorModel[\"ForceBased\"] = 1] = \"ForceBased\";\n})(MotorModel || (MotorModel = {}));\n/**\n * An enum representing the possible joint axes of a generic joint.\n * They can be ORed together, like:\n * JointAxesMask.LinX || JointAxesMask.LinY\n * to get a joint that is only free in the X and Y translational (positional) axes.\n *\n * Possible free axes are:\n *\n * - `X`: X translation axis\n * - `Y`: Y translation axis\n * - `Z`: Z translation axis\n * - `AngX`: X angular rotation axis\n * - `AngY`: Y angular rotations axis\n * - `AngZ`: Z angular rotation axis\n */\nexport var JointAxesMask;\n(function (JointAxesMask) {\n    JointAxesMask[JointAxesMask[\"LinX\"] = 1] = \"LinX\";\n    JointAxesMask[JointAxesMask[\"LinY\"] = 2] = \"LinY\";\n    JointAxesMask[JointAxesMask[\"LinZ\"] = 4] = \"LinZ\";\n    JointAxesMask[JointAxesMask[\"AngX\"] = 8] = \"AngX\";\n    JointAxesMask[JointAxesMask[\"AngY\"] = 16] = \"AngY\";\n    JointAxesMask[JointAxesMask[\"AngZ\"] = 32] = \"AngZ\";\n})(JointAxesMask || (JointAxesMask = {}));\nexport class ImpulseJoint {\n    constructor(rawSet, bodySet, handle) {\n        this.rawSet = rawSet;\n        this.bodySet = bodySet;\n        this.handle = handle;\n    }\n    static newTyped(rawSet, bodySet, handle) {\n        switch (rawSet.jointType(handle)) {\n            case RawJointType.Revolute:\n                return new RevoluteImpulseJoint(rawSet, bodySet, handle);\n            case RawJointType.Prismatic:\n                return new PrismaticImpulseJoint(rawSet, bodySet, handle);\n            case RawJointType.Fixed:\n                return new FixedImpulseJoint(rawSet, bodySet, handle);\n            case RawJointType.Spring:\n                return new SpringImpulseJoint(rawSet, bodySet, handle);\n            case RawJointType.Rope:\n                return new RopeImpulseJoint(rawSet, bodySet, handle);\n            // #if DIM3\n            case RawJointType.Spherical:\n                return new SphericalImpulseJoint(rawSet, bodySet, handle);\n            case RawJointType.Generic:\n                return new GenericImpulseJoint(rawSet, bodySet, handle);\n            // #endif\n            default:\n                return new ImpulseJoint(rawSet, bodySet, handle);\n        }\n    }\n    /** @internal */\n    finalizeDeserialization(bodySet) {\n        this.bodySet = bodySet;\n    }\n    /**\n     * Checks if this joint is still valid (i.e. that it has\n     * not been deleted from the joint set yet).\n     */\n    isValid() {\n        return this.rawSet.contains(this.handle);\n    }\n    /**\n     * The first rigid-body this joint it attached to.\n     */\n    body1() {\n        return this.bodySet.get(this.rawSet.jointBodyHandle1(this.handle));\n    }\n    /**\n     * The second rigid-body this joint is attached to.\n     */\n    body2() {\n        return this.bodySet.get(this.rawSet.jointBodyHandle2(this.handle));\n    }\n    /**\n     * The type of this joint given as a string.\n     */\n    type() {\n        return this.rawSet.jointType(this.handle);\n    }\n    // #if DIM3\n    /**\n     * The rotation quaternion that aligns this joint's first local axis to the `x` axis.\n     */\n    frameX1() {\n        return RotationOps.fromRaw(this.rawSet.jointFrameX1(this.handle));\n    }\n    // #endif\n    // #if DIM3\n    /**\n     * The rotation matrix that aligns this joint's second local axis to the `x` axis.\n     */\n    frameX2() {\n        return RotationOps.fromRaw(this.rawSet.jointFrameX2(this.handle));\n    }\n    // #endif\n    /**\n     * The position of the first anchor of this joint.\n     *\n     * The first anchor gives the position of the application point on the\n     * local frame of the first rigid-body it is attached to.\n     */\n    anchor1() {\n        return VectorOps.fromRaw(this.rawSet.jointAnchor1(this.handle));\n    }\n    /**\n     * The position of the second anchor of this joint.\n     *\n     * The second anchor gives the position of the application point on the\n     * local frame of the second rigid-body it is attached to.\n     */\n    anchor2() {\n        return VectorOps.fromRaw(this.rawSet.jointAnchor2(this.handle));\n    }\n    /**\n     * Sets the position of the first anchor of this joint.\n     *\n     * The first anchor gives the position of the application point on the\n     * local frame of the first rigid-body it is attached to.\n     */\n    setAnchor1(newPos) {\n        const rawPoint = VectorOps.intoRaw(newPos);\n        this.rawSet.jointSetAnchor1(this.handle, rawPoint);\n        rawPoint.free();\n    }\n    /**\n     * Sets the position of the second anchor of this joint.\n     *\n     * The second anchor gives the position of the application point on the\n     * local frame of the second rigid-body it is attached to.\n     */\n    setAnchor2(newPos) {\n        const rawPoint = VectorOps.intoRaw(newPos);\n        this.rawSet.jointSetAnchor2(this.handle, rawPoint);\n        rawPoint.free();\n    }\n    /**\n     * Controls whether contacts are computed between colliders attached\n     * to the rigid-bodies linked by this joint.\n     */\n    setContactsEnabled(enabled) {\n        this.rawSet.jointSetContactsEnabled(this.handle, enabled);\n    }\n    /**\n     * Indicates if contacts are enabled between colliders attached\n     * to the rigid-bodies linked by this joint.\n     */\n    contactsEnabled() {\n        return this.rawSet.jointContactsEnabled(this.handle);\n    }\n}\nexport class UnitImpulseJoint extends ImpulseJoint {\n    /**\n     * Are the limits enabled for this joint?\n     */\n    limitsEnabled() {\n        return this.rawSet.jointLimitsEnabled(this.handle, this.rawAxis());\n    }\n    /**\n     * The min limit of this joint.\n     */\n    limitsMin() {\n        return this.rawSet.jointLimitsMin(this.handle, this.rawAxis());\n    }\n    /**\n     * The max limit of this joint.\n     */\n    limitsMax() {\n        return this.rawSet.jointLimitsMax(this.handle, this.rawAxis());\n    }\n    /**\n     * Sets the limits of this joint.\n     *\n     * @param min - The minimum bound of this joint’s free coordinate.\n     * @param max - The maximum bound of this joint’s free coordinate.\n     */\n    setLimits(min, max) {\n        this.rawSet.jointSetLimits(this.handle, this.rawAxis(), min, max);\n    }\n    configureMotorModel(model) {\n        this.rawSet.jointConfigureMotorModel(this.handle, this.rawAxis(), model);\n    }\n    configureMotorVelocity(targetVel, factor) {\n        this.rawSet.jointConfigureMotorVelocity(this.handle, this.rawAxis(), targetVel, factor);\n    }\n    configureMotorPosition(targetPos, stiffness, damping) {\n        this.rawSet.jointConfigureMotorPosition(this.handle, this.rawAxis(), targetPos, stiffness, damping);\n    }\n    configureMotor(targetPos, targetVel, stiffness, damping) {\n        this.rawSet.jointConfigureMotor(this.handle, this.rawAxis(), targetPos, targetVel, stiffness, damping);\n    }\n}\nexport class FixedImpulseJoint extends ImpulseJoint {\n}\nexport class RopeImpulseJoint extends ImpulseJoint {\n}\nexport class SpringImpulseJoint extends ImpulseJoint {\n}\nexport class PrismaticImpulseJoint extends UnitImpulseJoint {\n    rawAxis() {\n        return RawJointAxis.LinX;\n    }\n}\nexport class RevoluteImpulseJoint extends UnitImpulseJoint {\n    rawAxis() {\n        return RawJointAxis.AngX;\n    }\n}\n// #if DIM3\nexport class GenericImpulseJoint extends ImpulseJoint {\n}\nexport class SphericalImpulseJoint extends ImpulseJoint {\n}\n// #endif\nexport class JointData {\n    constructor() { }\n    /**\n     * Creates a new joint descriptor that builds a Fixed joint.\n     *\n     * A fixed joint removes all the degrees of freedom between the affected bodies, ensuring their\n     * anchor and local frames coincide in world-space.\n     *\n     * @param anchor1 - Point where the joint is attached on the first rigid-body affected by this joint. Expressed in the\n     *                  local-space of the rigid-body.\n     * @param frame1 - The reference orientation of the joint wrt. the first rigid-body.\n     * @param anchor2 - Point where the joint is attached on the second rigid-body affected by this joint. Expressed in the\n     *                  local-space of the rigid-body.\n     * @param frame2 - The reference orientation of the joint wrt. the second rigid-body.\n     */\n    static fixed(anchor1, frame1, anchor2, frame2) {\n        let res = new JointData();\n        res.anchor1 = anchor1;\n        res.anchor2 = anchor2;\n        res.frame1 = frame1;\n        res.frame2 = frame2;\n        res.jointType = JointType.Fixed;\n        return res;\n    }\n    static spring(rest_length, stiffness, damping, anchor1, anchor2) {\n        let res = new JointData();\n        res.anchor1 = anchor1;\n        res.anchor2 = anchor2;\n        res.length = rest_length;\n        res.stiffness = stiffness;\n        res.damping = damping;\n        res.jointType = JointType.Spring;\n        return res;\n    }\n    static rope(length, anchor1, anchor2) {\n        let res = new JointData();\n        res.anchor1 = anchor1;\n        res.anchor2 = anchor2;\n        res.length = length;\n        res.jointType = JointType.Rope;\n        return res;\n    }\n    // #if DIM3\n    /**\n     * Create a new joint descriptor that builds generic joints.\n     *\n     * A generic joint allows customizing its degrees of freedom\n     * by supplying a mask of the joint axes that should remain locked.\n     *\n     * @param anchor1 - Point where the joint is attached on the first rigid-body affected by this joint. Expressed in the\n     *                  local-space of the rigid-body.\n     * @param anchor2 - Point where the joint is attached on the second rigid-body affected by this joint. Expressed in the\n     *                  local-space of the rigid-body.\n     * @param axis - The X axis of the joint, expressed in the local-space of the rigid-bodies it is attached to.\n     * @param axesMask - Mask representing the locked axes of the joint. You can use logical OR to select these from\n     *                   the JointAxesMask enum. For example, passing (JointAxesMask.AngX || JointAxesMask.AngY) will\n     *                   create a joint locked in the X and Y rotational axes.\n     */\n    static generic(anchor1, anchor2, axis, axesMask) {\n        let res = new JointData();\n        res.anchor1 = anchor1;\n        res.anchor2 = anchor2;\n        res.axis = axis;\n        res.axesMask = axesMask;\n        res.jointType = JointType.Generic;\n        return res;\n    }\n    /**\n     * Create a new joint descriptor that builds spherical joints.\n     *\n     * A spherical joint allows three relative rotational degrees of freedom\n     * by preventing any relative translation between the anchors of the\n     * two attached rigid-bodies.\n     *\n     * @param anchor1 - Point where the joint is attached on the first rigid-body affected by this joint. Expressed in the\n     *                  local-space of the rigid-body.\n     * @param anchor2 - Point where the joint is attached on the second rigid-body affected by this joint. Expressed in the\n     *                  local-space of the rigid-body.\n     */\n    static spherical(anchor1, anchor2) {\n        let res = new JointData();\n        res.anchor1 = anchor1;\n        res.anchor2 = anchor2;\n        res.jointType = JointType.Spherical;\n        return res;\n    }\n    /**\n     * Creates a new joint descriptor that builds a Prismatic joint.\n     *\n     * A prismatic joint removes all the degrees of freedom between the\n     * affected bodies, except for the translation along one axis.\n     *\n     * @param anchor1 - Point where the joint is attached on the first rigid-body affected by this joint. Expressed in the\n     *                  local-space of the rigid-body.\n     * @param anchor2 - Point where the joint is attached on the second rigid-body affected by this joint. Expressed in the\n     *                  local-space of the rigid-body.\n     * @param axis - Axis of the joint, expressed in the local-space of the rigid-bodies it is attached to.\n     */\n    static prismatic(anchor1, anchor2, axis) {\n        let res = new JointData();\n        res.anchor1 = anchor1;\n        res.anchor2 = anchor2;\n        res.axis = axis;\n        res.jointType = JointType.Prismatic;\n        return res;\n    }\n    /**\n     * Create a new joint descriptor that builds Revolute joints.\n     *\n     * A revolute joint removes all degrees of freedom between the affected\n     * bodies except for the rotation along one axis.\n     *\n     * @param anchor1 - Point where the joint is attached on the first rigid-body affected by this joint. Expressed in the\n     *                  local-space of the rigid-body.\n     * @param anchor2 - Point where the joint is attached on the second rigid-body affected by this joint. Expressed in the\n     *                  local-space of the rigid-body.\n     * @param axis - Axis of the joint, expressed in the local-space of the rigid-bodies it is attached to.\n     */\n    static revolute(anchor1, anchor2, axis) {\n        let res = new JointData();\n        res.anchor1 = anchor1;\n        res.anchor2 = anchor2;\n        res.axis = axis;\n        res.jointType = JointType.Revolute;\n        return res;\n    }\n    // #endif\n    intoRaw() {\n        let rawA1 = VectorOps.intoRaw(this.anchor1);\n        let rawA2 = VectorOps.intoRaw(this.anchor2);\n        let rawAx;\n        let result;\n        let limitsEnabled = false;\n        let limitsMin = 0.0;\n        let limitsMax = 0.0;\n        switch (this.jointType) {\n            case JointType.Fixed:\n                let rawFra1 = RotationOps.intoRaw(this.frame1);\n                let rawFra2 = RotationOps.intoRaw(this.frame2);\n                result = RawGenericJoint.fixed(rawA1, rawFra1, rawA2, rawFra2);\n                rawFra1.free();\n                rawFra2.free();\n                break;\n            case JointType.Spring:\n                result = RawGenericJoint.spring(this.length, this.stiffness, this.damping, rawA1, rawA2);\n                break;\n            case JointType.Rope:\n                result = RawGenericJoint.rope(this.length, rawA1, rawA2);\n                break;\n            case JointType.Prismatic:\n                rawAx = VectorOps.intoRaw(this.axis);\n                if (!!this.limitsEnabled) {\n                    limitsEnabled = true;\n                    limitsMin = this.limits[0];\n                    limitsMax = this.limits[1];\n                }\n                // #if DIM3\n                result = RawGenericJoint.prismatic(rawA1, rawA2, rawAx, limitsEnabled, limitsMin, limitsMax);\n                // #endif\n                rawAx.free();\n                break;\n            // #if DIM3\n            case JointType.Generic:\n                rawAx = VectorOps.intoRaw(this.axis);\n                // implicit type cast: axesMask is a JointAxesMask bitflag enum,\n                // we're treating it as a u8 on the Rust side\n                let rawAxesMask = this.axesMask;\n                result = RawGenericJoint.generic(rawA1, rawA2, rawAx, rawAxesMask);\n                break;\n            case JointType.Spherical:\n                result = RawGenericJoint.spherical(rawA1, rawA2);\n                break;\n            case JointType.Revolute:\n                rawAx = VectorOps.intoRaw(this.axis);\n                result = RawGenericJoint.revolute(rawA1, rawA2, rawAx);\n                rawAx.free();\n                break;\n            // #endif\n        }\n        rawA1.free();\n        rawA2.free();\n        return result;\n    }\n}\n//# sourceMappingURL=impulse_joint.js.map"],"names":["JointType","MotorModel","JointAxesMask","ImpulseJoint","constructor","rawSet","bodySet","handle","this","newTyped","jointType","RawJointType","Revolute","RevoluteImpulseJoint","Prismatic","PrismaticImpulseJoint","Fixed","FixedImpulseJoint","Spring","SpringImpulseJoint","Rope","RopeImpulseJoint","Spherical","SphericalImpulseJoint","Generic","GenericImpulseJoint","finalizeDeserialization","isValid","contains","body1","get","jointBodyHandle1","body2","jointBodyHandle2","type","frameX1","RotationOps","fromRaw","jointFrameX1","frameX2","jointFrameX2","anchor1","VectorOps","jointAnchor1","anchor2","jointAnchor2","setAnchor1","newPos","rawPoint","intoRaw","jointSetAnchor1","free","setAnchor2","jointSetAnchor2","setContactsEnabled","enabled","jointSetContactsEnabled","contactsEnabled","jointContactsEnabled","UnitImpulseJoint","limitsEnabled","jointLimitsEnabled","rawAxis","limitsMin","jointLimitsMin","limitsMax","jointLimitsMax","setLimits","min","max","jointSetLimits","configureMotorModel","model","jointConfigureMotorModel","configureMotorVelocity","targetVel","factor","jointConfigureMotorVelocity","configureMotorPosition","targetPos","stiffness","damping","jointConfigureMotorPosition","configureMotor","jointConfigureMotor","RawJointAxis","LinX","AngX"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -1,2 +0,0 @@
-import"../rapier_wasm3d.js";import{Coarena}from"../coarena.js";import{ImpulseJoint}from"./impulse_joint.js";import{RawImpulseJointSet}from"../rapier_wasm3d_bg.js";class ImpulseJointSet{free(){this.raw&&this.raw.free(),this.raw=void 0,this.map&&this.map.clear(),this.map=void 0}constructor(raw){this.raw=raw||new RawImpulseJointSet,this.map=new Coarena,raw&&raw.forEachJointHandle(handle=>{this.map.set(handle,ImpulseJoint.newTyped(raw,null,handle))})}finalizeDeserialization(bodies){this.map.forEach(joint=>joint.finalizeDeserialization(bodies))}createJoint(bodies,desc,parent1,parent2,wakeUp){const rawParams=desc.intoRaw(),handle=this.raw.createJoint(rawParams,parent1,parent2,wakeUp);rawParams.free();let joint=ImpulseJoint.newTyped(this.raw,bodies,handle);return this.map.set(handle,joint),joint}remove(handle,wakeUp){this.raw.remove(handle,wakeUp),this.unmap(handle)}forEachJointHandleAttachedToRigidBody(handle,f){this.raw.forEachJointAttachedToRigidBody(handle,f)}unmap(handle){this.map.delete(handle)}len(){return this.map.len()}contains(handle){return null!=this.get(handle)}get(handle){return this.map.get(handle)}forEach(f){this.map.forEach(f)}getAll(){return this.map.getAll()}}export{ImpulseJointSet};
-//# sourceMappingURL=impulse_joint_set.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"impulse_joint_set.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/dynamics/impulse_joint_set.js"],"sourcesContent":["import { RawImpulseJointSet } from \"../raw\";\nimport { Coarena } from \"../coarena\";\nimport { ImpulseJoint,\n// #endif\n } from \"./impulse_joint\";\n/**\n * A set of joints.\n *\n * To avoid leaking WASM resources, this MUST be freed manually with `jointSet.free()`\n * once you are done using it (and all the joints it created).\n */\nexport class ImpulseJointSet {\n    /**\n     * Release the WASM memory occupied by this joint set.\n     */\n    free() {\n        if (!!this.raw) {\n            this.raw.free();\n        }\n        this.raw = undefined;\n        if (!!this.map) {\n            this.map.clear();\n        }\n        this.map = undefined;\n    }\n    constructor(raw) {\n        this.raw = raw || new RawImpulseJointSet();\n        this.map = new Coarena();\n        // Initialize the map with the existing elements, if any.\n        if (raw) {\n            raw.forEachJointHandle((handle) => {\n                this.map.set(handle, ImpulseJoint.newTyped(raw, null, handle));\n            });\n        }\n    }\n    /** @internal */\n    finalizeDeserialization(bodies) {\n        this.map.forEach((joint) => joint.finalizeDeserialization(bodies));\n    }\n    /**\n     * Creates a new joint and return its integer handle.\n     *\n     * @param bodies - The set of rigid-bodies containing the bodies the joint is attached to.\n     * @param desc - The joint's parameters.\n     * @param parent1 - The handle of the first rigid-body this joint is attached to.\n     * @param parent2 - The handle of the second rigid-body this joint is attached to.\n     * @param wakeUp - Should the attached rigid-bodies be awakened?\n     */\n    createJoint(bodies, desc, parent1, parent2, wakeUp) {\n        const rawParams = desc.intoRaw();\n        const handle = this.raw.createJoint(rawParams, parent1, parent2, wakeUp);\n        rawParams.free();\n        let joint = ImpulseJoint.newTyped(this.raw, bodies, handle);\n        this.map.set(handle, joint);\n        return joint;\n    }\n    /**\n     * Remove a joint from this set.\n     *\n     * @param handle - The integer handle of the joint.\n     * @param wakeUp - If `true`, the rigid-bodies attached by the removed joint will be woken-up automatically.\n     */\n    remove(handle, wakeUp) {\n        this.raw.remove(handle, wakeUp);\n        this.unmap(handle);\n    }\n    /**\n     * Calls the given closure with the integer handle of each impulse joint attached to this rigid-body.\n     *\n     * @param f - The closure called with the integer handle of each impulse joint attached to the rigid-body.\n     */\n    forEachJointHandleAttachedToRigidBody(handle, f) {\n        this.raw.forEachJointAttachedToRigidBody(handle, f);\n    }\n    /**\n     * Internal function, do not call directly.\n     * @param handle\n     */\n    unmap(handle) {\n        this.map.delete(handle);\n    }\n    /**\n     * The number of joints on this set.\n     */\n    len() {\n        return this.map.len();\n    }\n    /**\n     * Does this set contain a joint with the given handle?\n     *\n     * @param handle - The joint handle to check.\n     */\n    contains(handle) {\n        return this.get(handle) != null;\n    }\n    /**\n     * Gets the joint with the given handle.\n     *\n     * Returns `null` if no joint with the specified handle exists.\n     *\n     * @param handle - The integer handle of the joint to retrieve.\n     */\n    get(handle) {\n        return this.map.get(handle);\n    }\n    /**\n     * Applies the given closure to each joint contained by this set.\n     *\n     * @param f - The closure to apply.\n     */\n    forEach(f) {\n        this.map.forEach(f);\n    }\n    /**\n     * Gets all joints in the list.\n     *\n     * @returns joint list.\n     */\n    getAll() {\n        return this.map.getAll();\n    }\n}\n//# sourceMappingURL=impulse_joint_set.js.map"],"names":["ImpulseJointSet","free","this","raw","undefined","map","clear","constructor","RawImpulseJointSet","Coarena","forEachJointHandle","handle","set","ImpulseJoint","newTyped","finalizeDeserialization","bodies","forEach","joint","createJoint","desc","parent1","parent2","wakeUp","rawParams","intoRaw","remove","unmap","forEachJointHandleAttachedToRigidBody","f","forEachJointAttachedToRigidBody","delete","len","contains","get","getAll"],"mappings":"mKAWO,MAAMA,gBAIT,IAAAC,GACUC,KAAKC,KACPD,KAAKC,IAAIF,OAEbC,KAAKC,SAAMC,EACLF,KAAKG,KACPH,KAAKG,IAAIC,QAEbJ,KAAKG,SAAMD,CACf,CACA,WAAAG,CAAYJ,KACRD,KAAKC,IAAMA,KAAO,IAAIK,mBACtBN,KAAKG,IAAM,IAAII,QAEXN,KACAA,IAAIO,mBAAoBC,SACpBT,KAAKG,IAAIO,IAAID,OAAQE,aAAaC,SAASX,IAAK,KAAMQ,UAGlE,CAEA,uBAAAI,CAAwBC,QACpBd,KAAKG,IAAIY,QAASC,OAAUA,MAAMH,wBAAwBC,QAC9D,CAUA,WAAAG,CAAYH,OAAQI,KAAMC,QAASC,QAASC,QACxC,MAAMC,UAAYJ,KAAKK,UACjBd,OAAST,KAAKC,IAAIgB,YAAYK,UAAWH,QAASC,QAASC,QACjEC,UAAUvB,OACV,IAAIiB,MAAQL,aAAaC,SAASZ,KAAKC,IAAKa,OAAQL,QAEpD,OADAT,KAAKG,IAAIO,IAAID,OAAQO,OACdA,KACX,CAOA,MAAAQ,CAAOf,OAAQY,QACXrB,KAAKC,IAAIuB,OAAOf,OAAQY,QACxBrB,KAAKyB,MAAMhB,OACf,CAMA,qCAAAiB,CAAsCjB,OAAQkB,GAC1C3B,KAAKC,IAAI2B,gCAAgCnB,OAAQkB,EACrD,CAKA,KAAAF,CAAMhB,QACFT,KAAKG,IAAI0B,OAAOpB,OACpB,CAIA,GAAAqB,GACI,OAAO9B,KAAKG,IAAI2B,KACpB,CAMA,QAAAC,CAAStB,QACL,OAA2B,MAApBT,KAAKgC,IAAIvB,OACpB,CAQA,GAAAuB,CAAIvB,QACA,OAAOT,KAAKG,IAAI6B,IAAIvB,OACxB,CAMA,OAAAM,CAAQY,GACJ3B,KAAKG,IAAIY,QAAQY,EACrB,CAMA,MAAAM,GACI,OAAOjC,KAAKG,IAAI8B,QACpB","x_google_ignoreList":[0]}

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

@@ -1,2 +0,0 @@
-import"../rapier_wasm3d.js";import{RawIntegrationParameters}from"../rapier_wasm3d_bg.js";class IntegrationParameters{constructor(raw){this.raw=raw||new RawIntegrationParameters}free(){this.raw&&this.raw.free(),this.raw=void 0}get dt(){return this.raw.dt}get contact_erp(){return this.raw.contact_erp}get lengthUnit(){return this.raw.lengthUnit}get normalizedAllowedLinearError(){return this.raw.normalizedAllowedLinearError}get normalizedPredictionDistance(){return this.raw.normalizedPredictionDistance}get numSolverIterations(){return this.raw.numSolverIterations}get numInternalPgsIterations(){return this.raw.numInternalPgsIterations}get minIslandSize(){return this.raw.minIslandSize}get maxCcdSubsteps(){return this.raw.maxCcdSubsteps}set dt(value){this.raw.dt=value}set contact_natural_frequency(value){this.raw.contact_natural_frequency=value}set lengthUnit(value){this.raw.lengthUnit=value}set normalizedAllowedLinearError(value){this.raw.normalizedAllowedLinearError=value}set normalizedPredictionDistance(value){this.raw.normalizedPredictionDistance=value}set numSolverIterations(value){this.raw.numSolverIterations=value}set numInternalPgsIterations(value){this.raw.numInternalPgsIterations=value}set minIslandSize(value){this.raw.minIslandSize=value}set maxCcdSubsteps(value){this.raw.maxCcdSubsteps=value}}export{IntegrationParameters};
-//# sourceMappingURL=integration_parameters.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"integration_parameters.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/dynamics/integration_parameters.js"],"sourcesContent":["import { RawIntegrationParameters } from \"../raw\";\nexport class IntegrationParameters {\n    constructor(raw) {\n        this.raw = raw || new RawIntegrationParameters();\n    }\n    /**\n     * Free the WASM memory used by these integration parameters.\n     */\n    free() {\n        if (!!this.raw) {\n            this.raw.free();\n        }\n        this.raw = undefined;\n    }\n    /**\n     * The timestep length (default: `1.0 / 60.0`)\n     */\n    get dt() {\n        return this.raw.dt;\n    }\n    /**\n     * The Error Reduction Parameter in `[0, 1]` is the proportion of\n     * the positional error to be corrected at each time step (default: `0.2`).\n     */\n    get contact_erp() {\n        return this.raw.contact_erp;\n    }\n    get lengthUnit() {\n        return this.raw.lengthUnit;\n    }\n    /**\n     * Normalized amount of penetration the engine won’t attempt to correct (default: `0.001m`).\n     *\n     * This threshold considered by the physics engine is this value multiplied by the `lengthUnit`.\n     */\n    get normalizedAllowedLinearError() {\n        return this.raw.normalizedAllowedLinearError;\n    }\n    /**\n     * The maximal normalized distance separating two objects that will generate predictive contacts (default: `0.002`).\n     *\n     * This threshold considered by the physics engine is this value multiplied by the `lengthUnit`.\n     */\n    get normalizedPredictionDistance() {\n        return this.raw.normalizedPredictionDistance;\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.raw.numSolverIterations;\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.raw.numInternalPgsIterations;\n    }\n    /**\n     * Minimum number of dynamic bodies in each active island (default: `128`).\n     */\n    get minIslandSize() {\n        return this.raw.minIslandSize;\n    }\n    /**\n     * Maximum number of substeps performed by the  solver (default: `1`).\n     */\n    get maxCcdSubsteps() {\n        return this.raw.maxCcdSubsteps;\n    }\n    set dt(value) {\n        this.raw.dt = value;\n    }\n    set contact_natural_frequency(value) {\n        this.raw.contact_natural_frequency = value;\n    }\n    set lengthUnit(value) {\n        this.raw.lengthUnit = value;\n    }\n    set normalizedAllowedLinearError(value) {\n        this.raw.normalizedAllowedLinearError = value;\n    }\n    set normalizedPredictionDistance(value) {\n        this.raw.normalizedPredictionDistance = value;\n    }\n    /**\n     * Sets the number of solver iterations run by the constraints solver for calculating forces (default: `4`).\n     */\n    set numSolverIterations(value) {\n        this.raw.numSolverIterations = value;\n    }\n    /**\n     * Sets the number of internal Project Gauss Seidel (PGS) iterations run at each solver iteration (default: `1`).\n     */\n    set numInternalPgsIterations(value) {\n        this.raw.numInternalPgsIterations = value;\n    }\n    set minIslandSize(value) {\n        this.raw.minIslandSize = value;\n    }\n    set maxCcdSubsteps(value) {\n        this.raw.maxCcdSubsteps = value;\n    }\n}\n//# sourceMappingURL=integration_parameters.js.map"],"names":["IntegrationParameters","constructor","raw","this","RawIntegrationParameters","free","undefined","dt","contact_erp","lengthUnit","normalizedAllowedLinearError","normalizedPredictionDistance","numSolverIterations","numInternalPgsIterations","minIslandSize","maxCcdSubsteps","value","contact_natural_frequency"],"mappings":"yFACO,MAAMA,sBACT,WAAAC,CAAYC,KACRC,KAAKD,IAAMA,KAAO,IAAIE,wBAC1B,CAIA,IAAAC,GACUF,KAAKD,KACPC,KAAKD,IAAIG,OAEbF,KAAKD,SAAMI,CACf,CAIA,MAAIC,GACA,OAAOJ,KAAKD,IAAIK,EACpB,CAKA,eAAIC,GACA,OAAOL,KAAKD,IAAIM,WACpB,CACA,cAAIC,GACA,OAAON,KAAKD,IAAIO,UACpB,CAMA,gCAAIC,GACA,OAAOP,KAAKD,IAAIQ,4BACpB,CAMA,gCAAIC,GACA,OAAOR,KAAKD,IAAIS,4BACpB,CAIA,uBAAIC,GACA,OAAOT,KAAKD,IAAIU,mBACpB,CAIA,4BAAIC,GACA,OAAOV,KAAKD,IAAIW,wBACpB,CAIA,iBAAIC,GACA,OAAOX,KAAKD,IAAIY,aACpB,CAIA,kBAAIC,GACA,OAAOZ,KAAKD,IAAIa,cACpB,CACA,MAAIR,CAAGS,OACHb,KAAKD,IAAIK,GAAKS,KAClB,CACA,6BAAIC,CAA0BD,OAC1Bb,KAAKD,IAAIe,0BAA4BD,KACzC,CACA,cAAIP,CAAWO,OACXb,KAAKD,IAAIO,WAAaO,KAC1B,CACA,gCAAIN,CAA6BM,OAC7Bb,KAAKD,IAAIQ,6BAA+BM,KAC5C,CACA,gCAAIL,CAA6BK,OAC7Bb,KAAKD,IAAIS,6BAA+BK,KAC5C,CAIA,uBAAIJ,CAAoBI,OACpBb,KAAKD,IAAIU,oBAAsBI,KACnC,CAIA,4BAAIH,CAAyBG,OACzBb,KAAKD,IAAIW,yBAA2BG,KACxC,CACA,iBAAIF,CAAcE,OACdb,KAAKD,IAAIY,cAAgBE,KAC7B,CACA,kBAAID,CAAeC,OACfb,KAAKD,IAAIa,eAAiBC,KAC9B","x_google_ignoreList":[0]}

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

@@ -1,2 +0,0 @@
-import"../rapier_wasm3d.js";import{RawIslandManager}from"../rapier_wasm3d_bg.js";class IslandManager{free(){this.raw&&this.raw.free(),this.raw=void 0}constructor(raw){this.raw=raw||new RawIslandManager}forEachActiveRigidBodyHandle(f){this.raw.forEachActiveRigidBodyHandle(f)}}export{IslandManager};
-//# sourceMappingURL=island_manager.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"island_manager.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/dynamics/island_manager.js"],"sourcesContent":["import { RawIslandManager } from \"../raw\";\n/**\n * The CCD solver responsible for resolving Continuous Collision Detection.\n *\n * To avoid leaking WASM resources, this MUST be freed manually with `ccdSolver.free()`\n * once you are done using it.\n */\nexport class IslandManager {\n    /**\n     * Release the WASM memory occupied by this narrow-phase.\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 RawIslandManager();\n    }\n    /**\n     * Applies the given closure to the handle of each active rigid-bodies contained by this set.\n     *\n     * A rigid-body is active if it is not sleeping, i.e., if it moved recently.\n     *\n     * @param f - The closure to apply.\n     */\n    forEachActiveRigidBodyHandle(f) {\n        this.raw.forEachActiveRigidBodyHandle(f);\n    }\n}\n//# sourceMappingURL=island_manager.js.map"],"names":["IslandManager","free","this","raw","undefined","constructor","RawIslandManager","forEachActiveRigidBodyHandle","f"],"mappings":"iFAOO,MAAMA,cAIT,IAAAC,GACUC,KAAKC,KACPD,KAAKC,IAAIF,OAEbC,KAAKC,SAAMC,CACf,CACA,WAAAC,CAAYF,KACRD,KAAKC,IAAMA,KAAO,IAAIG,gBAC1B,CAQA,4BAAAC,CAA6BC,GACzBN,KAAKC,IAAII,6BAA6BC,EAC1C","x_google_ignoreList":[0]}

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

@@ -1,2 +0,0 @@
-import"../rapier_wasm3d.js";import{RawJointType,RawJointAxis}from"../rapier_wasm3d_bg.js";class MultibodyJoint{constructor(rawSet,handle){this.rawSet=rawSet,this.handle=handle}static newTyped(rawSet,handle){switch(rawSet.jointType(handle)){case RawJointType.Revolute:return new RevoluteMultibodyJoint(rawSet,handle);case RawJointType.Prismatic:return new PrismaticMultibodyJoint(rawSet,handle);case RawJointType.Fixed:return new FixedMultibodyJoint(rawSet,handle);case RawJointType.Spherical:return new SphericalMultibodyJoint(rawSet,handle);default:return new MultibodyJoint(rawSet,handle)}}isValid(){return this.rawSet.contains(this.handle)}setContactsEnabled(enabled){this.rawSet.jointSetContactsEnabled(this.handle,enabled)}contactsEnabled(){return this.rawSet.jointContactsEnabled(this.handle)}}class UnitMultibodyJoint extends MultibodyJoint{}class FixedMultibodyJoint extends MultibodyJoint{}class PrismaticMultibodyJoint extends UnitMultibodyJoint{rawAxis(){return RawJointAxis.LinX}}class RevoluteMultibodyJoint extends UnitMultibodyJoint{rawAxis(){return RawJointAxis.AngX}}class SphericalMultibodyJoint extends MultibodyJoint{}export{FixedMultibodyJoint,MultibodyJoint,PrismaticMultibodyJoint,RevoluteMultibodyJoint,SphericalMultibodyJoint,UnitMultibodyJoint};
-//# sourceMappingURL=multibody_joint.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"multibody_joint.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/dynamics/multibody_joint.js"],"sourcesContent":["import { RawJointAxis, RawJointType, } from \"../raw\";\nexport class MultibodyJoint {\n    constructor(rawSet, handle) {\n        this.rawSet = rawSet;\n        this.handle = handle;\n    }\n    static newTyped(rawSet, handle) {\n        switch (rawSet.jointType(handle)) {\n            case RawJointType.Revolute:\n                return new RevoluteMultibodyJoint(rawSet, handle);\n            case RawJointType.Prismatic:\n                return new PrismaticMultibodyJoint(rawSet, handle);\n            case RawJointType.Fixed:\n                return new FixedMultibodyJoint(rawSet, handle);\n            // #if DIM3\n            case RawJointType.Spherical:\n                return new SphericalMultibodyJoint(rawSet, handle);\n            // #endif\n            default:\n                return new MultibodyJoint(rawSet, handle);\n        }\n    }\n    /**\n     * Checks if this joint is still valid (i.e. that it has\n     * not been deleted from the joint set yet).\n     */\n    isValid() {\n        return this.rawSet.contains(this.handle);\n    }\n    // /**\n    //  * The unique integer identifier of the first rigid-body this joint it attached to.\n    //  */\n    // public bodyHandle1(): RigidBodyHandle {\n    //     return this.rawSet.jointBodyHandle1(this.handle);\n    // }\n    //\n    // /**\n    //  * The unique integer identifier of the second rigid-body this joint is attached to.\n    //  */\n    // public bodyHandle2(): RigidBodyHandle {\n    //     return this.rawSet.jointBodyHandle2(this.handle);\n    // }\n    //\n    // /**\n    //  * The type of this joint given as a string.\n    //  */\n    // public type(): JointType {\n    //     return this.rawSet.jointType(this.handle);\n    // }\n    //\n    // // #if DIM3\n    // /**\n    //  * The rotation quaternion that aligns this joint's first local axis to the `x` axis.\n    //  */\n    // public frameX1(): Rotation {\n    //     return RotationOps.fromRaw(this.rawSet.jointFrameX1(this.handle));\n    // }\n    //\n    // // #endif\n    //\n    // // #if DIM3\n    // /**\n    //  * The rotation matrix that aligns this joint's second local axis to the `x` axis.\n    //  */\n    // public frameX2(): Rotation {\n    //     return RotationOps.fromRaw(this.rawSet.jointFrameX2(this.handle));\n    // }\n    //\n    // // #endif\n    //\n    // /**\n    //  * The position of the first anchor of this joint.\n    //  *\n    //  * The first anchor gives the position of the points application point on the\n    //  * local frame of the first rigid-body it is attached to.\n    //  */\n    // public anchor1(): Vector {\n    //     return VectorOps.fromRaw(this.rawSet.jointAnchor1(this.handle));\n    // }\n    //\n    // /**\n    //  * The position of the second anchor of this joint.\n    //  *\n    //  * The second anchor gives the position of the points application point on the\n    //  * local frame of the second rigid-body it is attached to.\n    //  */\n    // public anchor2(): Vector {\n    //     return VectorOps.fromRaw(this.rawSet.jointAnchor2(this.handle));\n    // }\n    /**\n     * Controls whether contacts are computed between colliders attached\n     * to the rigid-bodies linked by this joint.\n     */\n    setContactsEnabled(enabled) {\n        this.rawSet.jointSetContactsEnabled(this.handle, enabled);\n    }\n    /**\n     * Indicates if contacts are enabled between colliders attached\n     * to the rigid-bodies linked by this joint.\n     */\n    contactsEnabled() {\n        return this.rawSet.jointContactsEnabled(this.handle);\n    }\n}\nexport class UnitMultibodyJoint extends MultibodyJoint {\n}\nexport class FixedMultibodyJoint extends MultibodyJoint {\n}\nexport class PrismaticMultibodyJoint extends UnitMultibodyJoint {\n    rawAxis() {\n        return RawJointAxis.LinX;\n    }\n}\nexport class RevoluteMultibodyJoint extends UnitMultibodyJoint {\n    rawAxis() {\n        return RawJointAxis.AngX;\n    }\n}\n// #if DIM3\nexport class SphericalMultibodyJoint extends MultibodyJoint {\n}\n// #endif\n//# sourceMappingURL=multibody_joint.js.map"],"names":["MultibodyJoint","constructor","rawSet","handle","this","newTyped","jointType","RawJointType","Revolute","RevoluteMultibodyJoint","Prismatic","PrismaticMultibodyJoint","Fixed","FixedMultibodyJoint","Spherical","SphericalMultibodyJoint","isValid","contains","setContactsEnabled","enabled","jointSetContactsEnabled","contactsEnabled","jointContactsEnabled","UnitMultibodyJoint","rawAxis","RawJointAxis","LinX","AngX"],"mappings":"0FACO,MAAMA,eACT,WAAAC,CAAYC,OAAQC,QAChBC,KAAKF,OAASA,OACdE,KAAKD,OAASA,MAClB,CACA,eAAOE,CAASH,OAAQC,QACpB,OAAQD,OAAOI,UAAUH,SACrB,KAAKI,aAAaC,SACd,OAAO,IAAIC,uBAAuBP,OAAQC,QAC9C,KAAKI,aAAaG,UACd,OAAO,IAAIC,wBAAwBT,OAAQC,QAC/C,KAAKI,aAAaK,MACd,OAAO,IAAIC,oBAAoBX,OAAQC,QAE3C,KAAKI,aAAaO,UACd,OAAO,IAAIC,wBAAwBb,OAAQC,QAE/C,QACI,OAAO,IAAIH,eAAeE,OAAQC,QAE9C,CAKA,OAAAa,GACI,OAAOZ,KAAKF,OAAOe,SAASb,KAAKD,OACrC,CAiEA,kBAAAe,CAAmBC,SACff,KAAKF,OAAOkB,wBAAwBhB,KAAKD,OAAQgB,QACrD,CAKA,eAAAE,GACI,OAAOjB,KAAKF,OAAOoB,qBAAqBlB,KAAKD,OACjD,EAEG,MAAMoB,2BAA2BvB,gBAEjC,MAAMa,4BAA4Bb,gBAElC,MAAMW,gCAAgCY,mBACzC,OAAAC,GACI,OAAOC,aAAaC,IACxB,EAEG,MAAMjB,+BAA+Bc,mBACxC,OAAAC,GACI,OAAOC,aAAaE,IACxB,EAGG,MAAMZ,gCAAgCf","x_google_ignoreList":[0]}

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

@@ -1,2 +0,0 @@
-import"../rapier_wasm3d.js";import{Coarena}from"../coarena.js";import{MultibodyJoint}from"./multibody_joint.js";import{RawMultibodyJointSet}from"../rapier_wasm3d_bg.js";class MultibodyJointSet{free(){this.raw&&this.raw.free(),this.raw=void 0,this.map&&this.map.clear(),this.map=void 0}constructor(raw){this.raw=raw||new RawMultibodyJointSet,this.map=new Coarena,raw&&raw.forEachJointHandle(handle=>{this.map.set(handle,MultibodyJoint.newTyped(this.raw,handle))})}createJoint(desc,parent1,parent2,wakeUp){const rawParams=desc.intoRaw(),handle=this.raw.createJoint(rawParams,parent1,parent2,wakeUp);rawParams.free();let joint=MultibodyJoint.newTyped(this.raw,handle);return this.map.set(handle,joint),joint}remove(handle,wake_up){this.raw.remove(handle,wake_up),this.map.delete(handle)}unmap(handle){this.map.delete(handle)}len(){return this.map.len()}contains(handle){return null!=this.get(handle)}get(handle){return this.map.get(handle)}forEach(f){this.map.forEach(f)}forEachJointHandleAttachedToRigidBody(handle,f){this.raw.forEachJointAttachedToRigidBody(handle,f)}getAll(){return this.map.getAll()}}export{MultibodyJointSet};
-//# sourceMappingURL=multibody_joint_set.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"multibody_joint_set.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/dynamics/multibody_joint_set.js"],"sourcesContent":["import { RawMultibodyJointSet } from \"../raw\";\nimport { Coarena } from \"../coarena\";\nimport { MultibodyJoint,\n// #endif\n } from \"./multibody_joint\";\n/**\n * A set of joints.\n *\n * To avoid leaking WASM resources, this MUST be freed manually with `jointSet.free()`\n * once you are done using it (and all the joints it created).\n */\nexport class MultibodyJointSet {\n    /**\n     * Release the WASM memory occupied by this joint set.\n     */\n    free() {\n        if (!!this.raw) {\n            this.raw.free();\n        }\n        this.raw = undefined;\n        if (!!this.map) {\n            this.map.clear();\n        }\n        this.map = undefined;\n    }\n    constructor(raw) {\n        this.raw = raw || new RawMultibodyJointSet();\n        this.map = new Coarena();\n        // Initialize the map with the existing elements, if any.\n        if (raw) {\n            raw.forEachJointHandle((handle) => {\n                this.map.set(handle, MultibodyJoint.newTyped(this.raw, handle));\n            });\n        }\n    }\n    /**\n     * Creates a new joint and return its integer handle.\n     *\n     * @param desc - The joint's parameters.\n     * @param parent1 - The handle of the first rigid-body this joint is attached to.\n     * @param parent2 - The handle of the second rigid-body this joint is attached to.\n     * @param wakeUp - Should the attached rigid-bodies be awakened?\n     */\n    createJoint(desc, parent1, parent2, wakeUp) {\n        const rawParams = desc.intoRaw();\n        const handle = this.raw.createJoint(rawParams, parent1, parent2, wakeUp);\n        rawParams.free();\n        let joint = MultibodyJoint.newTyped(this.raw, handle);\n        this.map.set(handle, joint);\n        return joint;\n    }\n    /**\n     * Remove a joint from this set.\n     *\n     * @param handle - The integer handle of the joint.\n     * @param wake_up - If `true`, the rigid-bodies attached by the removed joint will be woken-up automatically.\n     */\n    remove(handle, wake_up) {\n        this.raw.remove(handle, wake_up);\n        this.map.delete(handle);\n    }\n    /**\n     * Internal function, do not call directly.\n     * @param handle\n     */\n    unmap(handle) {\n        this.map.delete(handle);\n    }\n    /**\n     * The number of joints on this set.\n     */\n    len() {\n        return this.map.len();\n    }\n    /**\n     * Does this set contain a joint with the given handle?\n     *\n     * @param handle - The joint handle to check.\n     */\n    contains(handle) {\n        return this.get(handle) != null;\n    }\n    /**\n     * Gets the joint with the given handle.\n     *\n     * Returns `null` if no joint with the specified handle exists.\n     *\n     * @param handle - The integer handle of the joint to retrieve.\n     */\n    get(handle) {\n        return this.map.get(handle);\n    }\n    /**\n     * Applies the given closure to each joint contained by this set.\n     *\n     * @param f - The closure to apply.\n     */\n    forEach(f) {\n        this.map.forEach(f);\n    }\n    /**\n     * Calls the given closure with the integer handle of each multibody joint attached to this rigid-body.\n     *\n     * @param f - The closure called with the integer handle of each multibody joint attached to the rigid-body.\n     */\n    forEachJointHandleAttachedToRigidBody(handle, f) {\n        this.raw.forEachJointAttachedToRigidBody(handle, f);\n    }\n    /**\n     * Gets all joints in the list.\n     *\n     * @returns joint list.\n     */\n    getAll() {\n        return this.map.getAll();\n    }\n}\n//# sourceMappingURL=multibody_joint_set.js.map"],"names":["MultibodyJointSet","free","this","raw","undefined","map","clear","constructor","RawMultibodyJointSet","Coarena","forEachJointHandle","handle","set","MultibodyJoint","newTyped","createJoint","desc","parent1","parent2","wakeUp","rawParams","intoRaw","joint","remove","wake_up","delete","unmap","len","contains","get","forEach","f","forEachJointHandleAttachedToRigidBody","forEachJointAttachedToRigidBody","getAll"],"mappings":"yKAWO,MAAMA,kBAIT,IAAAC,GACUC,KAAKC,KACPD,KAAKC,IAAIF,OAEbC,KAAKC,SAAMC,EACLF,KAAKG,KACPH,KAAKG,IAAIC,QAEbJ,KAAKG,SAAMD,CACf,CACA,WAAAG,CAAYJ,KACRD,KAAKC,IAAMA,KAAO,IAAIK,qBACtBN,KAAKG,IAAM,IAAII,QAEXN,KACAA,IAAIO,mBAAoBC,SACpBT,KAAKG,IAAIO,IAAID,OAAQE,eAAeC,SAASZ,KAAKC,IAAKQ,UAGnE,CASA,WAAAI,CAAYC,KAAMC,QAASC,QAASC,QAChC,MAAMC,UAAYJ,KAAKK,UACjBV,OAAST,KAAKC,IAAIY,YAAYK,UAAWH,QAASC,QAASC,QACjEC,UAAUnB,OACV,IAAIqB,MAAQT,eAAeC,SAASZ,KAAKC,IAAKQ,QAE9C,OADAT,KAAKG,IAAIO,IAAID,OAAQW,OACdA,KACX,CAOA,MAAAC,CAAOZ,OAAQa,SACXtB,KAAKC,IAAIoB,OAAOZ,OAAQa,SACxBtB,KAAKG,IAAIoB,OAAOd,OACpB,CAKA,KAAAe,CAAMf,QACFT,KAAKG,IAAIoB,OAAOd,OACpB,CAIA,GAAAgB,GACI,OAAOzB,KAAKG,IAAIsB,KACpB,CAMA,QAAAC,CAASjB,QACL,OAA2B,MAApBT,KAAK2B,IAAIlB,OACpB,CAQA,GAAAkB,CAAIlB,QACA,OAAOT,KAAKG,IAAIwB,IAAIlB,OACxB,CAMA,OAAAmB,CAAQC,GACJ7B,KAAKG,IAAIyB,QAAQC,EACrB,CAMA,qCAAAC,CAAsCrB,OAAQoB,GAC1C7B,KAAKC,IAAI8B,gCAAgCtB,OAAQoB,EACrD,CAMA,MAAAG,GACI,OAAOhC,KAAKG,IAAI6B,QACpB","x_google_ignoreList":[0]}

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

@@ -1,2 +0,0 @@
-import{VectorOps,RotationOps,SdpMatrix3Ops}from"../math.js";var RigidBodyType;!function(RigidBodyType){RigidBodyType[RigidBodyType.Dynamic=0]="Dynamic",RigidBodyType[RigidBodyType.Fixed=1]="Fixed",RigidBodyType[RigidBodyType.KinematicPositionBased=2]="KinematicPositionBased",RigidBodyType[RigidBodyType.KinematicVelocityBased=3]="KinematicVelocityBased"}(RigidBodyType||(RigidBodyType={}));class RigidBody{constructor(rawSet,colliderSet,handle){this.rawSet=rawSet,this.colliderSet=colliderSet,this.handle=handle}finalizeDeserialization(colliderSet){this.colliderSet=colliderSet}isValid(){return this.rawSet.contains(this.handle)}lockTranslations(locked,wakeUp){return this.rawSet.rbLockTranslations(this.handle,locked,wakeUp)}lockRotations(locked,wakeUp){return this.rawSet.rbLockRotations(this.handle,locked,wakeUp)}setEnabledTranslations(enableX,enableY,enableZ,wakeUp){return this.rawSet.rbSetEnabledTranslations(this.handle,enableX,enableY,enableZ,wakeUp)}restrictTranslations(enableX,enableY,enableZ,wakeUp){this.setEnabledTranslations(enableX,enableY,enableZ,wakeUp)}setEnabledRotations(enableX,enableY,enableZ,wakeUp){return this.rawSet.rbSetEnabledRotations(this.handle,enableX,enableY,enableZ,wakeUp)}restrictRotations(enableX,enableY,enableZ,wakeUp){this.setEnabledRotations(enableX,enableY,enableZ,wakeUp)}dominanceGroup(){return this.rawSet.rbDominanceGroup(this.handle)}setDominanceGroup(group){this.rawSet.rbSetDominanceGroup(this.handle,group)}additionalSolverIterations(){return this.rawSet.rbAdditionalSolverIterations(this.handle)}setAdditionalSolverIterations(iters){this.rawSet.rbSetAdditionalSolverIterations(this.handle,iters)}enableCcd(enabled){this.rawSet.rbEnableCcd(this.handle,enabled)}setSoftCcdPrediction(distance){this.rawSet.rbSetSoftCcdPrediction(this.handle,distance)}softCcdPrediction(){return this.rawSet.rbSoftCcdPrediction(this.handle)}translation(){let res=this.rawSet.rbTranslation(this.handle);return VectorOps.fromRaw(res)}rotation(){let res=this.rawSet.rbRotation(this.handle);return RotationOps.fromRaw(res)}nextTranslation(){let res=this.rawSet.rbNextTranslation(this.handle);return VectorOps.fromRaw(res)}nextRotation(){let res=this.rawSet.rbNextRotation(this.handle);return RotationOps.fromRaw(res)}setTranslation(tra,wakeUp){this.rawSet.rbSetTranslation(this.handle,tra.x,tra.y,tra.z,wakeUp)}setLinvel(vel,wakeUp){let rawVel=VectorOps.intoRaw(vel);this.rawSet.rbSetLinvel(this.handle,rawVel,wakeUp),rawVel.free()}gravityScale(){return this.rawSet.rbGravityScale(this.handle)}setGravityScale(factor,wakeUp){this.rawSet.rbSetGravityScale(this.handle,factor,wakeUp)}setRotation(rot,wakeUp){this.rawSet.rbSetRotation(this.handle,rot.x,rot.y,rot.z,rot.w,wakeUp)}setAngvel(vel,wakeUp){let rawVel=VectorOps.intoRaw(vel);this.rawSet.rbSetAngvel(this.handle,rawVel,wakeUp),rawVel.free()}setNextKinematicTranslation(t){this.rawSet.rbSetNextKinematicTranslation(this.handle,t.x,t.y,t.z)}setNextKinematicRotation(rot){this.rawSet.rbSetNextKinematicRotation(this.handle,rot.x,rot.y,rot.z,rot.w)}linvel(){return VectorOps.fromRaw(this.rawSet.rbLinvel(this.handle))}velocityAtPoint(point){const rawPoint=VectorOps.intoRaw(point);let result=VectorOps.fromRaw(this.rawSet.rbVelocityAtPoint(this.handle,rawPoint));return rawPoint.free(),result}angvel(){return VectorOps.fromRaw(this.rawSet.rbAngvel(this.handle))}mass(){return this.rawSet.rbMass(this.handle)}effectiveInvMass(){return VectorOps.fromRaw(this.rawSet.rbEffectiveInvMass(this.handle))}invMass(){return this.rawSet.rbInvMass(this.handle)}localCom(){return VectorOps.fromRaw(this.rawSet.rbLocalCom(this.handle))}worldCom(){return VectorOps.fromRaw(this.rawSet.rbWorldCom(this.handle))}invPrincipalInertia(){return VectorOps.fromRaw(this.rawSet.rbInvPrincipalInertia(this.handle))}principalInertia(){return VectorOps.fromRaw(this.rawSet.rbPrincipalInertia(this.handle))}principalInertiaLocalFrame(){return RotationOps.fromRaw(this.rawSet.rbPrincipalInertiaLocalFrame(this.handle))}effectiveWorldInvInertia(){return SdpMatrix3Ops.fromRaw(this.rawSet.rbEffectiveWorldInvInertia(this.handle))}effectiveAngularInertia(){return SdpMatrix3Ops.fromRaw(this.rawSet.rbEffectiveAngularInertia(this.handle))}sleep(){this.rawSet.rbSleep(this.handle)}wakeUp(){this.rawSet.rbWakeUp(this.handle)}isCcdEnabled(){return this.rawSet.rbIsCcdEnabled(this.handle)}numColliders(){return this.rawSet.rbNumColliders(this.handle)}collider(i){return this.colliderSet.get(this.rawSet.rbCollider(this.handle,i))}setEnabled(enabled){this.rawSet.rbSetEnabled(this.handle,enabled)}isEnabled(){return this.rawSet.rbIsEnabled(this.handle)}bodyType(){return this.rawSet.rbBodyType(this.handle)}setBodyType(type,wakeUp){return this.rawSet.rbSetBodyType(this.handle,type,wakeUp)}isSleeping(){return this.rawSet.rbIsSleeping(this.handle)}isMoving(){return this.rawSet.rbIsMoving(this.handle)}isFixed(){return this.rawSet.rbIsFixed(this.handle)}isKinematic(){return this.rawSet.rbIsKinematic(this.handle)}isDynamic(){return this.rawSet.rbIsDynamic(this.handle)}linearDamping(){return this.rawSet.rbLinearDamping(this.handle)}angularDamping(){return this.rawSet.rbAngularDamping(this.handle)}setLinearDamping(factor){this.rawSet.rbSetLinearDamping(this.handle,factor)}recomputeMassPropertiesFromColliders(){this.rawSet.rbRecomputeMassPropertiesFromColliders(this.handle,this.colliderSet.raw)}setAdditionalMass(mass,wakeUp){this.rawSet.rbSetAdditionalMass(this.handle,mass,wakeUp)}setAdditionalMassProperties(mass,centerOfMass,principalAngularInertia,angularInertiaLocalFrame,wakeUp){let rawCom=VectorOps.intoRaw(centerOfMass),rawPrincipalInertia=VectorOps.intoRaw(principalAngularInertia),rawInertiaFrame=RotationOps.intoRaw(angularInertiaLocalFrame);this.rawSet.rbSetAdditionalMassProperties(this.handle,mass,rawCom,rawPrincipalInertia,rawInertiaFrame,wakeUp),rawCom.free(),rawPrincipalInertia.free(),rawInertiaFrame.free()}setAngularDamping(factor){this.rawSet.rbSetAngularDamping(this.handle,factor)}resetForces(wakeUp){this.rawSet.rbResetForces(this.handle,wakeUp)}resetTorques(wakeUp){this.rawSet.rbResetTorques(this.handle,wakeUp)}addForce(force,wakeUp){const rawForce=VectorOps.intoRaw(force);this.rawSet.rbAddForce(this.handle,rawForce,wakeUp),rawForce.free()}applyImpulse(impulse,wakeUp){const rawImpulse=VectorOps.intoRaw(impulse);this.rawSet.rbApplyImpulse(this.handle,rawImpulse,wakeUp),rawImpulse.free()}addTorque(torque,wakeUp){const rawTorque=VectorOps.intoRaw(torque);this.rawSet.rbAddTorque(this.handle,rawTorque,wakeUp),rawTorque.free()}applyTorqueImpulse(torqueImpulse,wakeUp){const rawTorqueImpulse=VectorOps.intoRaw(torqueImpulse);this.rawSet.rbApplyTorqueImpulse(this.handle,rawTorqueImpulse,wakeUp),rawTorqueImpulse.free()}addForceAtPoint(force,point,wakeUp){const rawForce=VectorOps.intoRaw(force),rawPoint=VectorOps.intoRaw(point);this.rawSet.rbAddForceAtPoint(this.handle,rawForce,rawPoint,wakeUp),rawForce.free(),rawPoint.free()}applyImpulseAtPoint(impulse,point,wakeUp){const rawImpulse=VectorOps.intoRaw(impulse),rawPoint=VectorOps.intoRaw(point);this.rawSet.rbApplyImpulseAtPoint(this.handle,rawImpulse,rawPoint,wakeUp),rawImpulse.free(),rawPoint.free()}userForce(){return VectorOps.fromRaw(this.rawSet.rbUserForce(this.handle))}userTorque(){return VectorOps.fromRaw(this.rawSet.rbUserTorque(this.handle))}}class RigidBodyDesc{constructor(status){this.enabled=!0,this.status=status,this.translation=VectorOps.zeros(),this.rotation=RotationOps.identity(),this.gravityScale=1,this.linvel=VectorOps.zeros(),this.mass=0,this.massOnly=!1,this.centerOfMass=VectorOps.zeros(),this.translationsEnabledX=!0,this.translationsEnabledY=!0,this.angvel=VectorOps.zeros(),this.principalAngularInertia=VectorOps.zeros(),this.angularInertiaLocalFrame=RotationOps.identity(),this.translationsEnabledZ=!0,this.rotationsEnabledX=!0,this.rotationsEnabledY=!0,this.rotationsEnabledZ=!0,this.linearDamping=0,this.angularDamping=0,this.canSleep=!0,this.sleeping=!1,this.ccdEnabled=!1,this.softCcdPrediction=0,this.dominanceGroup=0,this.additionalSolverIterations=0}static dynamic(){return new RigidBodyDesc(RigidBodyType.Dynamic)}static kinematicPositionBased(){return new RigidBodyDesc(RigidBodyType.KinematicPositionBased)}static kinematicVelocityBased(){return new RigidBodyDesc(RigidBodyType.KinematicVelocityBased)}static fixed(){return new RigidBodyDesc(RigidBodyType.Fixed)}static newDynamic(){return new RigidBodyDesc(RigidBodyType.Dynamic)}static newKinematicPositionBased(){return new RigidBodyDesc(RigidBodyType.KinematicPositionBased)}static newKinematicVelocityBased(){return new RigidBodyDesc(RigidBodyType.KinematicVelocityBased)}static newStatic(){return new RigidBodyDesc(RigidBodyType.Fixed)}setDominanceGroup(group){return this.dominanceGroup=group,this}setAdditionalSolverIterations(iters){return this.additionalSolverIterations=iters,this}setEnabled(enabled){return this.enabled=enabled,this}setTranslation(x,y,z){if("number"!=typeof x||"number"!=typeof y||"number"!=typeof z)throw TypeError("The translation components must be numbers.");return this.translation={x:x,y:y,z:z},this}setRotation(rot){return RotationOps.copy(this.rotation,rot),this}setGravityScale(scale){return this.gravityScale=scale,this}setAdditionalMass(mass){return this.mass=mass,this.massOnly=!0,this}setLinvel(x,y,z){if("number"!=typeof x||"number"!=typeof y||"number"!=typeof z)throw TypeError("The linvel components must be numbers.");return this.linvel={x:x,y:y,z:z},this}setAngvel(vel){return VectorOps.copy(this.angvel,vel),this}setAdditionalMassProperties(mass,centerOfMass,principalAngularInertia,angularInertiaLocalFrame){return this.mass=mass,VectorOps.copy(this.centerOfMass,centerOfMass),VectorOps.copy(this.principalAngularInertia,principalAngularInertia),RotationOps.copy(this.angularInertiaLocalFrame,angularInertiaLocalFrame),this.massOnly=!1,this}enabledTranslations(translationsEnabledX,translationsEnabledY,translationsEnabledZ){return this.translationsEnabledX=translationsEnabledX,this.translationsEnabledY=translationsEnabledY,this.translationsEnabledZ=translationsEnabledZ,this}restrictTranslations(translationsEnabledX,translationsEnabledY,translationsEnabledZ){return this.enabledTranslations(translationsEnabledX,translationsEnabledY,translationsEnabledZ)}lockTranslations(){return this.enabledTranslations(!1,!1,!1)}enabledRotations(rotationsEnabledX,rotationsEnabledY,rotationsEnabledZ){return this.rotationsEnabledX=rotationsEnabledX,this.rotationsEnabledY=rotationsEnabledY,this.rotationsEnabledZ=rotationsEnabledZ,this}restrictRotations(rotationsEnabledX,rotationsEnabledY,rotationsEnabledZ){return this.enabledRotations(rotationsEnabledX,rotationsEnabledY,rotationsEnabledZ)}lockRotations(){return this.restrictRotations(!1,!1,!1)}setLinearDamping(damping){return this.linearDamping=damping,this}setAngularDamping(damping){return this.angularDamping=damping,this}setCanSleep(can){return this.canSleep=can,this}setSleeping(sleeping){return this.sleeping=sleeping,this}setCcdEnabled(enabled){return this.ccdEnabled=enabled,this}setSoftCcdPrediction(distance){return this.softCcdPrediction=distance,this}setUserData(data){return this.userData=data,this}}export{RigidBody,RigidBodyDesc,RigidBodyType};
-//# sourceMappingURL=rigid_body.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"rigid_body.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/dynamics/rigid_body.js"],"sourcesContent":["import { RotationOps, VectorOps } from \"../math\";\n// #if DIM3\nimport { SdpMatrix3Ops } from \"../math\";\n/**\n * The simulation status of a rigid-body.\n */\n// TODO: rename this to RigidBodyType\nexport var RigidBodyType;\n(function (RigidBodyType) {\n    /**\n     * A `RigidBodyType::Dynamic` body can be affected by all external forces.\n     */\n    RigidBodyType[RigidBodyType[\"Dynamic\"] = 0] = \"Dynamic\";\n    /**\n     * A `RigidBodyType::Fixed` body cannot be affected by external forces.\n     */\n    RigidBodyType[RigidBodyType[\"Fixed\"] = 1] = \"Fixed\";\n    /**\n     * A `RigidBodyType::KinematicPositionBased` body cannot be affected by any external forces but can be controlled\n     * by the user at the position level while keeping realistic one-way interaction with dynamic bodies.\n     *\n     * One-way interaction means that a kinematic body can push a dynamic body, but a kinematic body\n     * cannot be pushed by anything. In other words, the trajectory of a kinematic body can only be\n     * modified by the user and is independent from any contact or joint it is involved in.\n     */\n    RigidBodyType[RigidBodyType[\"KinematicPositionBased\"] = 2] = \"KinematicPositionBased\";\n    /**\n     * A `RigidBodyType::KinematicVelocityBased` body cannot be affected by any external forces but can be controlled\n     * by the user at the velocity level while keeping realistic one-way interaction with dynamic bodies.\n     *\n     * One-way interaction means that a kinematic body can push a dynamic body, but a kinematic body\n     * cannot be pushed by anything. In other words, the trajectory of a kinematic body can only be\n     * modified by the user and is independent from any contact or joint it is involved in.\n     */\n    RigidBodyType[RigidBodyType[\"KinematicVelocityBased\"] = 3] = \"KinematicVelocityBased\";\n})(RigidBodyType || (RigidBodyType = {}));\n/**\n * A rigid-body.\n */\nexport class RigidBody {\n    constructor(rawSet, colliderSet, handle) {\n        this.rawSet = rawSet;\n        this.colliderSet = colliderSet;\n        this.handle = handle;\n    }\n    /** @internal */\n    finalizeDeserialization(colliderSet) {\n        this.colliderSet = colliderSet;\n    }\n    /**\n     * Checks if this rigid-body is still valid (i.e. that it has\n     * not been deleted from the rigid-body set yet.\n     */\n    isValid() {\n        return this.rawSet.contains(this.handle);\n    }\n    /**\n     * Locks or unlocks the ability of this rigid-body to translate.\n     *\n     * @param locked - If `true`, this rigid-body will no longer translate due to forces and impulses.\n     * @param wakeUp - If `true`, this rigid-body will be automatically awaken if it is currently asleep.\n     */\n    lockTranslations(locked, wakeUp) {\n        return this.rawSet.rbLockTranslations(this.handle, locked, wakeUp);\n    }\n    /**\n     * Locks or unlocks the ability of this rigid-body to rotate.\n     *\n     * @param locked - If `true`, this rigid-body will no longer rotate due to torques and impulses.\n     * @param wakeUp - If `true`, this rigid-body will be automatically awaken if it is currently asleep.\n     */\n    lockRotations(locked, wakeUp) {\n        return this.rawSet.rbLockRotations(this.handle, locked, wakeUp);\n    }\n    // #if DIM3\n    /**\n     * Locks or unlocks the ability of this rigid-body to translate along individual coordinate axes.\n     *\n     * @param enableX - If `false`, this rigid-body will no longer translate due to torques and impulses, along the X coordinate axis.\n     * @param enableY - If `false`, this rigid-body will no longer translate due to torques and impulses, along the Y coordinate axis.\n     * @param enableZ - If `false`, this rigid-body will no longer translate due to torques and impulses, along the Z coordinate axis.\n     * @param wakeUp - If `true`, this rigid-body will be automatically awaken if it is currently asleep.\n     */\n    setEnabledTranslations(enableX, enableY, enableZ, wakeUp) {\n        return this.rawSet.rbSetEnabledTranslations(this.handle, enableX, enableY, enableZ, wakeUp);\n    }\n    /**\n     * Locks or unlocks the ability of this rigid-body to translate along individual coordinate axes.\n     *\n     * @param enableX - If `false`, this rigid-body will no longer translate due to torques and impulses, along the X coordinate axis.\n     * @param enableY - If `false`, this rigid-body will no longer translate due to torques and impulses, along the Y coordinate axis.\n     * @param enableZ - If `false`, this rigid-body will no longer translate due to torques and impulses, along the Z coordinate axis.\n     * @param wakeUp - If `true`, this rigid-body will be automatically awaken if it is currently asleep.\n     * @deprecated use `this.setEnabledTranslations` with the same arguments instead.\n     */\n    restrictTranslations(enableX, enableY, enableZ, wakeUp) {\n        this.setEnabledTranslations(enableX, enableY, enableZ, wakeUp);\n    }\n    /**\n     * Locks or unlocks the ability of this rigid-body to rotate along individual coordinate axes.\n     *\n     * @param enableX - If `false`, this rigid-body will no longer rotate due to torques and impulses, along the X coordinate axis.\n     * @param enableY - If `false`, this rigid-body will no longer rotate due to torques and impulses, along the Y coordinate axis.\n     * @param enableZ - If `false`, this rigid-body will no longer rotate due to torques and impulses, along the Z coordinate axis.\n     * @param wakeUp - If `true`, this rigid-body will be automatically awaken if it is currently asleep.\n     */\n    setEnabledRotations(enableX, enableY, enableZ, wakeUp) {\n        return this.rawSet.rbSetEnabledRotations(this.handle, enableX, enableY, enableZ, wakeUp);\n    }\n    /**\n     * Locks or unlocks the ability of this rigid-body to rotate along individual coordinate axes.\n     *\n     * @param enableX - If `false`, this rigid-body will no longer rotate due to torques and impulses, along the X coordinate axis.\n     * @param enableY - If `false`, this rigid-body will no longer rotate due to torques and impulses, along the Y coordinate axis.\n     * @param enableZ - If `false`, this rigid-body will no longer rotate due to torques and impulses, along the Z coordinate axis.\n     * @param wakeUp - If `true`, this rigid-body will be automatically awaken if it is currently asleep.\n     * @deprecated use `this.setEnabledRotations` with the same arguments instead.\n     */\n    restrictRotations(enableX, enableY, enableZ, wakeUp) {\n        this.setEnabledRotations(enableX, enableY, enableZ, wakeUp);\n    }\n    // #endif\n    /**\n     * The dominance group, in [-127, +127] this rigid-body is part of.\n     */\n    dominanceGroup() {\n        return this.rawSet.rbDominanceGroup(this.handle);\n    }\n    /**\n     * Sets the dominance group of this rigid-body.\n     *\n     * @param group - The dominance group of this rigid-body. Must be a signed integer in the range [-127, +127].\n     */\n    setDominanceGroup(group) {\n        this.rawSet.rbSetDominanceGroup(this.handle, group);\n    }\n    /**\n     * The number of additional solver iterations that will be run for this\n     * rigid-body and everything that interacts with it directly or indirectly\n     * through contacts or joints.\n     */\n    additionalSolverIterations() {\n        return this.rawSet.rbAdditionalSolverIterations(this.handle);\n    }\n    /**\n     * Sets the number of additional solver iterations that will be run for this\n     * rigid-body and everything that interacts with it directly or indirectly\n     * through contacts or joints.\n     *\n     * Compared to increasing the global `World.numSolverIteration`, setting this\n     * value lets you increase accuracy on only a subset of the scene, resulting in reduced\n     * performance loss.\n     *\n     * @param iters - The new number of additional solver iterations (default: 0).\n     */\n    setAdditionalSolverIterations(iters) {\n        this.rawSet.rbSetAdditionalSolverIterations(this.handle, iters);\n    }\n    /**\n     * Enable or disable CCD (Continuous Collision Detection) for this rigid-body.\n     *\n     * @param enabled - If `true`, CCD will be enabled for this rigid-body.\n     */\n    enableCcd(enabled) {\n        this.rawSet.rbEnableCcd(this.handle, enabled);\n    }\n    /**\n     * Sets the soft-CCD prediction distance for this rigid-body.\n     *\n     * See the documentation of `RigidBodyDesc.setSoftCcdPrediction` for\n     * additional details.\n     */\n    setSoftCcdPrediction(distance) {\n        this.rawSet.rbSetSoftCcdPrediction(this.handle, distance);\n    }\n    /**\n     * Gets the soft-CCD prediction distance for this rigid-body.\n     *\n     * See the documentation of `RigidBodyDesc.setSoftCcdPrediction` for\n     * additional details.\n     */\n    softCcdPrediction() {\n        return this.rawSet.rbSoftCcdPrediction(this.handle);\n    }\n    /**\n     * The world-space translation of this rigid-body.\n     */\n    translation() {\n        let res = this.rawSet.rbTranslation(this.handle);\n        return VectorOps.fromRaw(res);\n    }\n    /**\n     * The world-space orientation of this rigid-body.\n     */\n    rotation() {\n        let res = this.rawSet.rbRotation(this.handle);\n        return RotationOps.fromRaw(res);\n    }\n    /**\n     * The world-space next translation of this rigid-body.\n     *\n     * If this rigid-body is kinematic this value is set by the `setNextKinematicTranslation`\n     * method and is used for estimating the kinematic body velocity at the next timestep.\n     * For non-kinematic bodies, this value is currently unspecified.\n     */\n    nextTranslation() {\n        let res = this.rawSet.rbNextTranslation(this.handle);\n        return VectorOps.fromRaw(res);\n    }\n    /**\n     * The world-space next orientation of this rigid-body.\n     *\n     * If this rigid-body is kinematic this value is set by the `setNextKinematicRotation`\n     * method and is used for estimating the kinematic body velocity at the next timestep.\n     * For non-kinematic bodies, this value is currently unspecified.\n     */\n    nextRotation() {\n        let res = this.rawSet.rbNextRotation(this.handle);\n        return RotationOps.fromRaw(res);\n    }\n    /**\n     * Sets the translation of this rigid-body.\n     *\n     * @param tra - The world-space position of the rigid-body.\n     * @param wakeUp - Forces the rigid-body to wake-up so it is properly affected by forces if it\n     *                 wasn't moving before modifying its position.\n     */\n    setTranslation(tra, wakeUp) {\n        // #if DIM3\n        this.rawSet.rbSetTranslation(this.handle, tra.x, tra.y, tra.z, wakeUp);\n        // #endif\n    }\n    /**\n     * Sets the linear velocity of this rigid-body.\n     *\n     * @param vel - The linear velocity to set.\n     * @param wakeUp - Forces the rigid-body to wake-up if it was asleep.\n     */\n    setLinvel(vel, wakeUp) {\n        let rawVel = VectorOps.intoRaw(vel);\n        this.rawSet.rbSetLinvel(this.handle, rawVel, wakeUp);\n        rawVel.free();\n    }\n    /**\n     * The scale factor applied to the gravity affecting\n     * this rigid-body.\n     */\n    gravityScale() {\n        return this.rawSet.rbGravityScale(this.handle);\n    }\n    /**\n     * Sets the scale factor applied to the gravity affecting\n     * this rigid-body.\n     *\n     * @param factor - The scale factor to set. A value of 0.0 means\n     *   that this rigid-body will on longer be affected by gravity.\n     * @param wakeUp - Forces the rigid-body to wake-up if it was asleep.\n     */\n    setGravityScale(factor, wakeUp) {\n        this.rawSet.rbSetGravityScale(this.handle, factor, wakeUp);\n    }\n    // #if DIM3\n    /**\n     * Sets the rotation quaternion of this rigid-body.\n     *\n     * This does nothing if a zero quaternion is provided.\n     *\n     * @param rotation - The rotation to set.\n     * @param wakeUp - Forces the rigid-body to wake-up so it is properly affected by forces if it\n     * wasn't moving before modifying its position.\n     */\n    setRotation(rot, wakeUp) {\n        this.rawSet.rbSetRotation(this.handle, rot.x, rot.y, rot.z, rot.w, wakeUp);\n    }\n    /**\n     * Sets the angular velocity fo this rigid-body.\n     *\n     * @param vel - The angular velocity to set.\n     * @param wakeUp - Forces the rigid-body to wake-up if it was asleep.\n     */\n    setAngvel(vel, wakeUp) {\n        let rawVel = VectorOps.intoRaw(vel);\n        this.rawSet.rbSetAngvel(this.handle, rawVel, wakeUp);\n        rawVel.free();\n    }\n    // #endif\n    /**\n     * If this rigid body is kinematic, sets its future translation after the next timestep integration.\n     *\n     * This should be used instead of `rigidBody.setTranslation` to make the dynamic object\n     * interacting with this kinematic body behave as expected. Internally, Rapier will compute\n     * an artificial velocity for this rigid-body from its current position and its next kinematic\n     * position. This velocity will be used to compute forces on dynamic bodies interacting with\n     * this body.\n     *\n     * @param t - The kinematic translation to set.\n     */\n    setNextKinematicTranslation(t) {\n        // #if DIM3\n        this.rawSet.rbSetNextKinematicTranslation(this.handle, t.x, t.y, t.z);\n        // #endif\n    }\n    // #if DIM3\n    /**\n     * If this rigid body is kinematic, sets its future rotation after the next timestep integration.\n     *\n     * This should be used instead of `rigidBody.setRotation` to make the dynamic object\n     * interacting with this kinematic body behave as expected. Internally, Rapier will compute\n     * an artificial velocity for this rigid-body from its current position and its next kinematic\n     * position. This velocity will be used to compute forces on dynamic bodies interacting with\n     * this body.\n     *\n     * @param rot - The kinematic rotation to set.\n     */\n    setNextKinematicRotation(rot) {\n        this.rawSet.rbSetNextKinematicRotation(this.handle, rot.x, rot.y, rot.z, rot.w);\n    }\n    // #endif\n    /**\n     * The linear velocity of this rigid-body.\n     */\n    linvel() {\n        return VectorOps.fromRaw(this.rawSet.rbLinvel(this.handle));\n    }\n    /**\n     * The velocity of the given world-space point on this rigid-body.\n     */\n    velocityAtPoint(point) {\n        const rawPoint = VectorOps.intoRaw(point);\n        let result = VectorOps.fromRaw(this.rawSet.rbVelocityAtPoint(this.handle, rawPoint));\n        rawPoint.free();\n        return result;\n    }\n    // #if DIM3\n    /**\n     * The angular velocity of this rigid-body.\n     */\n    angvel() {\n        return VectorOps.fromRaw(this.rawSet.rbAngvel(this.handle));\n    }\n    // #endif\n    /**\n     * The mass of this rigid-body.\n     */\n    mass() {\n        return this.rawSet.rbMass(this.handle);\n    }\n    /**\n     * The inverse mass taking into account translation locking.\n     */\n    effectiveInvMass() {\n        return VectorOps.fromRaw(this.rawSet.rbEffectiveInvMass(this.handle));\n    }\n    /**\n     * The inverse of the mass of a rigid-body.\n     *\n     * If this is zero, the rigid-body is assumed to have infinite mass.\n     */\n    invMass() {\n        return this.rawSet.rbInvMass(this.handle);\n    }\n    /**\n     * The center of mass of a rigid-body expressed in its local-space.\n     */\n    localCom() {\n        return VectorOps.fromRaw(this.rawSet.rbLocalCom(this.handle));\n    }\n    /**\n     * The world-space center of mass of the rigid-body.\n     */\n    worldCom() {\n        return VectorOps.fromRaw(this.rawSet.rbWorldCom(this.handle));\n    }\n    // #if DIM3\n    /**\n     * The inverse of the principal angular inertia of the rigid-body.\n     *\n     * Components set to zero are assumed to be infinite along the corresponding principal axis.\n     */\n    invPrincipalInertia() {\n        return VectorOps.fromRaw(this.rawSet.rbInvPrincipalInertia(this.handle));\n    }\n    // #endif\n    // #if DIM3\n    /**\n     * The angular inertia along the principal inertia axes of the rigid-body.\n     */\n    principalInertia() {\n        return VectorOps.fromRaw(this.rawSet.rbPrincipalInertia(this.handle));\n    }\n    // #endif\n    // #if DIM3\n    /**\n     * The principal vectors of the local angular inertia tensor of the rigid-body.\n     */\n    principalInertiaLocalFrame() {\n        return RotationOps.fromRaw(this.rawSet.rbPrincipalInertiaLocalFrame(this.handle));\n    }\n    // #endif\n    // #if DIM3\n    /**\n     * The world-space inverse angular inertia tensor of the rigid-body,\n     * taking into account rotation locking.\n     */\n    effectiveWorldInvInertia() {\n        return SdpMatrix3Ops.fromRaw(this.rawSet.rbEffectiveWorldInvInertia(this.handle));\n    }\n    // #endif\n    // #if DIM3\n    /**\n     * The effective world-space angular inertia (that takes the potential rotation locking into account) of\n     * this rigid-body.\n     */\n    effectiveAngularInertia() {\n        return SdpMatrix3Ops.fromRaw(this.rawSet.rbEffectiveAngularInertia(this.handle));\n    }\n    // #endif\n    /**\n     * Put this rigid body to sleep.\n     *\n     * A sleeping body no longer moves and is no longer simulated by the physics engine unless\n     * it is waken up. It can be woken manually with `this.wakeUp()` or automatically due to\n     * external forces like contacts.\n     */\n    sleep() {\n        this.rawSet.rbSleep(this.handle);\n    }\n    /**\n     * Wakes this rigid-body up.\n     *\n     * A dynamic rigid-body that does not move during several consecutive frames will\n     * be put to sleep by the physics engine, i.e., it will stop being simulated in order\n     * to avoid useless computations.\n     * This methods forces a sleeping rigid-body to wake-up. This is useful, e.g., before modifying\n     * the position of a dynamic body so that it is properly simulated afterwards.\n     */\n    wakeUp() {\n        this.rawSet.rbWakeUp(this.handle);\n    }\n    /**\n     * Is CCD enabled for this rigid-body?\n     */\n    isCcdEnabled() {\n        return this.rawSet.rbIsCcdEnabled(this.handle);\n    }\n    /**\n     * The number of colliders attached to this rigid-body.\n     */\n    numColliders() {\n        return this.rawSet.rbNumColliders(this.handle);\n    }\n    /**\n     * Retrieves the `i-th` collider attached to this rigid-body.\n     *\n     * @param i - The index of the collider to retrieve. Must be a number in `[0, this.numColliders()[`.\n     *         This index is **not** the same as the unique identifier of the collider.\n     */\n    collider(i) {\n        return this.colliderSet.get(this.rawSet.rbCollider(this.handle, i));\n    }\n    /**\n     * Sets whether this rigid-body is enabled or not.\n     *\n     * @param enabled - Set to `false` to disable this rigid-body and all its attached colliders.\n     */\n    setEnabled(enabled) {\n        this.rawSet.rbSetEnabled(this.handle, enabled);\n    }\n    /**\n     * Is this rigid-body enabled?\n     */\n    isEnabled() {\n        return this.rawSet.rbIsEnabled(this.handle);\n    }\n    /**\n     * The status of this rigid-body: static, dynamic, or kinematic.\n     */\n    bodyType() {\n        return this.rawSet.rbBodyType(this.handle);\n    }\n    /**\n     * Set a new status for this rigid-body: static, dynamic, or kinematic.\n     */\n    setBodyType(type, wakeUp) {\n        return this.rawSet.rbSetBodyType(this.handle, type, wakeUp);\n    }\n    /**\n     * Is this rigid-body sleeping?\n     */\n    isSleeping() {\n        return this.rawSet.rbIsSleeping(this.handle);\n    }\n    /**\n     * Is the velocity of this rigid-body not zero?\n     */\n    isMoving() {\n        return this.rawSet.rbIsMoving(this.handle);\n    }\n    /**\n     * Is this rigid-body static?\n     */\n    isFixed() {\n        return this.rawSet.rbIsFixed(this.handle);\n    }\n    /**\n     * Is this rigid-body kinematic?\n     */\n    isKinematic() {\n        return this.rawSet.rbIsKinematic(this.handle);\n    }\n    /**\n     * Is this rigid-body dynamic?\n     */\n    isDynamic() {\n        return this.rawSet.rbIsDynamic(this.handle);\n    }\n    /**\n     * The linear damping coefficient of this rigid-body.\n     */\n    linearDamping() {\n        return this.rawSet.rbLinearDamping(this.handle);\n    }\n    /**\n     * The angular damping coefficient of this rigid-body.\n     */\n    angularDamping() {\n        return this.rawSet.rbAngularDamping(this.handle);\n    }\n    /**\n     * Sets the linear damping factor applied to this rigid-body.\n     *\n     * @param factor - The damping factor to set.\n     */\n    setLinearDamping(factor) {\n        this.rawSet.rbSetLinearDamping(this.handle, factor);\n    }\n    /**\n     * Recompute the mass-properties of this rigid-bodies based on its currently attached colliders.\n     */\n    recomputeMassPropertiesFromColliders() {\n        this.rawSet.rbRecomputeMassPropertiesFromColliders(this.handle, this.colliderSet.raw);\n    }\n    /**\n     * Sets the rigid-body's additional mass.\n     *\n     * The total angular inertia of the rigid-body will be scaled automatically based on this additional mass. If this\n     * scaling effect isn’t desired, use Self::additional_mass_properties instead of this method.\n     *\n     * This is only the \"additional\" mass because the total mass of the rigid-body is equal to the sum of this\n     * additional mass and the mass computed from the colliders (with non-zero densities) attached to this rigid-body.\n     *\n     * That total mass (which includes the attached colliders’ contributions) will be updated at the name physics step,\n     * or can be updated manually with `this.recomputeMassPropertiesFromColliders`.\n     *\n     * This will override any previous additional mass-properties set by `this.setAdditionalMass`,\n     * `this.setAdditionalMassProperties`, `RigidBodyDesc::setAdditionalMass`, or\n     * `RigidBodyDesc.setAdditionalMassfProperties` for this rigid-body.\n     *\n     * @param mass - The additional mass to set.\n     * @param wakeUp - If `true` then the rigid-body will be woken up if it was put to sleep because it did not move for a while.\n     */\n    setAdditionalMass(mass, wakeUp) {\n        this.rawSet.rbSetAdditionalMass(this.handle, mass, wakeUp);\n    }\n    // #if DIM3\n    /**\n     * Sets the rigid-body's additional mass-properties.\n     *\n     * This is only the \"additional\" mass-properties because the total mass-properties of the rigid-body is equal to the\n     * sum of this additional mass-properties and the mass computed from the colliders (with non-zero densities) attached\n     * to this rigid-body.\n     *\n     * That total mass-properties (which include the attached colliders’ contributions) will be updated at the name\n     * physics step, or can be updated manually with `this.recomputeMassPropertiesFromColliders`.\n     *\n     * This will override any previous mass-properties set by `this.setAdditionalMass`,\n     * `this.setAdditionalMassProperties`, `RigidBodyDesc.setAdditionalMass`, or `RigidBodyDesc.setAdditionalMassProperties`\n     * for this rigid-body.\n     *\n     * If `wake_up` is true then the rigid-body will be woken up if it was put to sleep because it did not move for a while.\n     */\n    setAdditionalMassProperties(mass, centerOfMass, principalAngularInertia, angularInertiaLocalFrame, wakeUp) {\n        let rawCom = VectorOps.intoRaw(centerOfMass);\n        let rawPrincipalInertia = VectorOps.intoRaw(principalAngularInertia);\n        let rawInertiaFrame = RotationOps.intoRaw(angularInertiaLocalFrame);\n        this.rawSet.rbSetAdditionalMassProperties(this.handle, mass, rawCom, rawPrincipalInertia, rawInertiaFrame, wakeUp);\n        rawCom.free();\n        rawPrincipalInertia.free();\n        rawInertiaFrame.free();\n    }\n    // #endif\n    /**\n     * Sets the linear damping factor applied to this rigid-body.\n     *\n     * @param factor - The damping factor to set.\n     */\n    setAngularDamping(factor) {\n        this.rawSet.rbSetAngularDamping(this.handle, factor);\n    }\n    /**\n     * Resets to zero the user forces (but not torques) applied to this rigid-body.\n     *\n     * @param wakeUp - should the rigid-body be automatically woken-up?\n     */\n    resetForces(wakeUp) {\n        this.rawSet.rbResetForces(this.handle, wakeUp);\n    }\n    /**\n     * Resets to zero the user torques applied to this rigid-body.\n     *\n     * @param wakeUp - should the rigid-body be automatically woken-up?\n     */\n    resetTorques(wakeUp) {\n        this.rawSet.rbResetTorques(this.handle, wakeUp);\n    }\n    /**\n     * Adds a force at the center-of-mass of this rigid-body.\n     *\n     * @param force - the world-space force to add to the rigid-body.\n     * @param wakeUp - should the rigid-body be automatically woken-up?\n     */\n    addForce(force, wakeUp) {\n        const rawForce = VectorOps.intoRaw(force);\n        this.rawSet.rbAddForce(this.handle, rawForce, wakeUp);\n        rawForce.free();\n    }\n    /**\n     * Applies an impulse at the center-of-mass of this rigid-body.\n     *\n     * @param impulse - the world-space impulse to apply on the rigid-body.\n     * @param wakeUp - should the rigid-body be automatically woken-up?\n     */\n    applyImpulse(impulse, wakeUp) {\n        const rawImpulse = VectorOps.intoRaw(impulse);\n        this.rawSet.rbApplyImpulse(this.handle, rawImpulse, wakeUp);\n        rawImpulse.free();\n    }\n    // #if DIM3\n    /**\n     * Adds a torque at the center-of-mass of this rigid-body.\n     *\n     * @param torque - the world-space torque to add to the rigid-body.\n     * @param wakeUp - should the rigid-body be automatically woken-up?\n     */\n    addTorque(torque, wakeUp) {\n        const rawTorque = VectorOps.intoRaw(torque);\n        this.rawSet.rbAddTorque(this.handle, rawTorque, wakeUp);\n        rawTorque.free();\n    }\n    // #endif\n    // #if DIM3\n    /**\n     * Applies an impulsive torque at the center-of-mass of this rigid-body.\n     *\n     * @param torqueImpulse - the world-space torque impulse to apply on the rigid-body.\n     * @param wakeUp - should the rigid-body be automatically woken-up?\n     */\n    applyTorqueImpulse(torqueImpulse, wakeUp) {\n        const rawTorqueImpulse = VectorOps.intoRaw(torqueImpulse);\n        this.rawSet.rbApplyTorqueImpulse(this.handle, rawTorqueImpulse, wakeUp);\n        rawTorqueImpulse.free();\n    }\n    // #endif\n    /**\n     * Adds a force at the given world-space point of this rigid-body.\n     *\n     * @param force - the world-space force to add to the rigid-body.\n     * @param point - the world-space point where the impulse is to be applied on the rigid-body.\n     * @param wakeUp - should the rigid-body be automatically woken-up?\n     */\n    addForceAtPoint(force, point, wakeUp) {\n        const rawForce = VectorOps.intoRaw(force);\n        const rawPoint = VectorOps.intoRaw(point);\n        this.rawSet.rbAddForceAtPoint(this.handle, rawForce, rawPoint, wakeUp);\n        rawForce.free();\n        rawPoint.free();\n    }\n    /**\n     * Applies an impulse at the given world-space point of this rigid-body.\n     *\n     * @param impulse - the world-space impulse to apply on the rigid-body.\n     * @param point - the world-space point where the impulse is to be applied on the rigid-body.\n     * @param wakeUp - should the rigid-body be automatically woken-up?\n     */\n    applyImpulseAtPoint(impulse, point, wakeUp) {\n        const rawImpulse = VectorOps.intoRaw(impulse);\n        const rawPoint = VectorOps.intoRaw(point);\n        this.rawSet.rbApplyImpulseAtPoint(this.handle, rawImpulse, rawPoint, wakeUp);\n        rawImpulse.free();\n        rawPoint.free();\n    }\n    /**\n     * Retrieves the constant force(s) the user added to this rigid-body\n     * Returns zero if the rigid-body is not dynamic.\n     */\n    userForce() {\n        return VectorOps.fromRaw(this.rawSet.rbUserForce(this.handle));\n    }\n    // #if DIM3\n    /**\n     * Retrieves the constant torque(s) the user added to this rigid-body\n     * Returns zero if the rigid-body is not dynamic.\n     */\n    userTorque() {\n        return VectorOps.fromRaw(this.rawSet.rbUserTorque(this.handle));\n    }\n}\nexport class RigidBodyDesc {\n    constructor(status) {\n        this.enabled = true;\n        this.status = status;\n        this.translation = VectorOps.zeros();\n        this.rotation = RotationOps.identity();\n        this.gravityScale = 1.0;\n        this.linvel = VectorOps.zeros();\n        this.mass = 0.0;\n        this.massOnly = false;\n        this.centerOfMass = VectorOps.zeros();\n        this.translationsEnabledX = true;\n        this.translationsEnabledY = true;\n        // #if DIM3\n        this.angvel = VectorOps.zeros();\n        this.principalAngularInertia = VectorOps.zeros();\n        this.angularInertiaLocalFrame = RotationOps.identity();\n        this.translationsEnabledZ = true;\n        this.rotationsEnabledX = true;\n        this.rotationsEnabledY = true;\n        this.rotationsEnabledZ = true;\n        // #endif\n        this.linearDamping = 0.0;\n        this.angularDamping = 0.0;\n        this.canSleep = true;\n        this.sleeping = false;\n        this.ccdEnabled = false;\n        this.softCcdPrediction = 0.0;\n        this.dominanceGroup = 0;\n        this.additionalSolverIterations = 0;\n    }\n    /**\n     * A rigid-body descriptor used to build a dynamic rigid-body.\n     */\n    static dynamic() {\n        return new RigidBodyDesc(RigidBodyType.Dynamic);\n    }\n    /**\n     * A rigid-body descriptor used to build a position-based kinematic rigid-body.\n     */\n    static kinematicPositionBased() {\n        return new RigidBodyDesc(RigidBodyType.KinematicPositionBased);\n    }\n    /**\n     * A rigid-body descriptor used to build a velocity-based kinematic rigid-body.\n     */\n    static kinematicVelocityBased() {\n        return new RigidBodyDesc(RigidBodyType.KinematicVelocityBased);\n    }\n    /**\n     * A rigid-body descriptor used to build a fixed rigid-body.\n     */\n    static fixed() {\n        return new RigidBodyDesc(RigidBodyType.Fixed);\n    }\n    /**\n     * A rigid-body descriptor used to build a dynamic rigid-body.\n     *\n     * @deprecated The method has been renamed to `.dynamic()`.\n     */\n    static newDynamic() {\n        return new RigidBodyDesc(RigidBodyType.Dynamic);\n    }\n    /**\n     * A rigid-body descriptor used to build a position-based kinematic rigid-body.\n     *\n     * @deprecated The method has been renamed to `.kinematicPositionBased()`.\n     */\n    static newKinematicPositionBased() {\n        return new RigidBodyDesc(RigidBodyType.KinematicPositionBased);\n    }\n    /**\n     * A rigid-body descriptor used to build a velocity-based kinematic rigid-body.\n     *\n     * @deprecated The method has been renamed to `.kinematicVelocityBased()`.\n     */\n    static newKinematicVelocityBased() {\n        return new RigidBodyDesc(RigidBodyType.KinematicVelocityBased);\n    }\n    /**\n     * A rigid-body descriptor used to build a fixed rigid-body.\n     *\n     * @deprecated The method has been renamed to `.fixed()`.\n     */\n    static newStatic() {\n        return new RigidBodyDesc(RigidBodyType.Fixed);\n    }\n    setDominanceGroup(group) {\n        this.dominanceGroup = group;\n        return this;\n    }\n    /**\n     * Sets the number of additional solver iterations that will be run for this\n     * rigid-body and everything that interacts with it directly or indirectly\n     * through contacts or joints.\n     *\n     * Compared to increasing the global `World.numSolverIteration`, setting this\n     * value lets you increase accuracy on only a subset of the scene, resulting in reduced\n     * performance loss.\n     *\n     * @param iters - The new number of additional solver iterations (default: 0).\n     */\n    setAdditionalSolverIterations(iters) {\n        this.additionalSolverIterations = iters;\n        return this;\n    }\n    /**\n     * Sets whether the created rigid-body will be enabled or disabled.\n     * @param enabled − If set to `false` the rigid-body will be disabled at creation.\n     */\n    setEnabled(enabled) {\n        this.enabled = enabled;\n        return this;\n    }\n    // #if DIM3\n    /**\n     * Sets the initial translation of the rigid-body to create.\n     *\n     * @param tra - The translation to set.\n     */\n    setTranslation(x, y, z) {\n        if (typeof x != \"number\" ||\n            typeof y != \"number\" ||\n            typeof z != \"number\")\n            throw TypeError(\"The translation components must be numbers.\");\n        this.translation = { x: x, y: y, z: z };\n        return this;\n    }\n    // #endif\n    /**\n     * Sets the initial rotation of the rigid-body to create.\n     *\n     * @param rot - The rotation to set.\n     */\n    setRotation(rot) {\n        // #if DIM3\n        RotationOps.copy(this.rotation, rot);\n        // #endif\n        return this;\n    }\n    /**\n     * Sets the scale factor applied to the gravity affecting\n     * the rigid-body being built.\n     *\n     * @param scale - The scale factor. Set this to `0.0` if the rigid-body\n     *   needs to ignore gravity.\n     */\n    setGravityScale(scale) {\n        this.gravityScale = scale;\n        return this;\n    }\n    /**\n     * Sets the initial mass of the rigid-body being built, before adding colliders' contributions.\n     *\n     * @param mass − The initial mass of the rigid-body to create.\n     */\n    setAdditionalMass(mass) {\n        this.mass = mass;\n        this.massOnly = true;\n        return this;\n    }\n    // #if DIM3\n    /**\n     * Sets the initial linear velocity of the rigid-body to create.\n     *\n     * @param x - The linear velocity to set along the `x` axis.\n     * @param y - The linear velocity to set along the `y` axis.\n     * @param z - The linear velocity to set along the `z` axis.\n     */\n    setLinvel(x, y, z) {\n        if (typeof x != \"number\" ||\n            typeof y != \"number\" ||\n            typeof z != \"number\")\n            throw TypeError(\"The linvel components must be numbers.\");\n        this.linvel = { x: x, y: y, z: z };\n        return this;\n    }\n    /**\n     * Sets the initial angular velocity of the rigid-body to create.\n     *\n     * @param vel - The angular velocity to set.\n     */\n    setAngvel(vel) {\n        VectorOps.copy(this.angvel, vel);\n        return this;\n    }\n    /**\n     * Sets the mass properties of the rigid-body being built.\n     *\n     * Note that the final mass properties of the rigid-bodies depends\n     * on the initial mass-properties of the rigid-body (set by this method)\n     * to which is added the contributions of all the colliders with non-zero density\n     * attached to this rigid-body.\n     *\n     * Therefore, if you want your provided mass properties to be the final\n     * mass properties of your rigid-body, don't attach colliders to it, or\n     * only attach colliders with densities equal to zero.\n     *\n     * @param mass − The initial mass of the rigid-body to create.\n     * @param centerOfMass − The initial center-of-mass of the rigid-body to create.\n     * @param principalAngularInertia − The initial principal angular inertia of the rigid-body to create.\n     *                                  These are the eigenvalues of the angular inertia matrix.\n     * @param angularInertiaLocalFrame − The initial local angular inertia frame of the rigid-body to create.\n     *                                   These are the eigenvectors of the angular inertia matrix.\n     */\n    setAdditionalMassProperties(mass, centerOfMass, principalAngularInertia, angularInertiaLocalFrame) {\n        this.mass = mass;\n        VectorOps.copy(this.centerOfMass, centerOfMass);\n        VectorOps.copy(this.principalAngularInertia, principalAngularInertia);\n        RotationOps.copy(this.angularInertiaLocalFrame, angularInertiaLocalFrame);\n        this.massOnly = false;\n        return this;\n    }\n    /**\n     * Allow translation of this rigid-body only along specific axes.\n     * @param translationsEnabledX - Are translations along the X axis enabled?\n     * @param translationsEnabledY - Are translations along the y axis enabled?\n     * @param translationsEnabledZ - Are translations along the Z axis enabled?\n     */\n    enabledTranslations(translationsEnabledX, translationsEnabledY, translationsEnabledZ) {\n        this.translationsEnabledX = translationsEnabledX;\n        this.translationsEnabledY = translationsEnabledY;\n        this.translationsEnabledZ = translationsEnabledZ;\n        return this;\n    }\n    /**\n     * Allow translation of this rigid-body only along specific axes.\n     * @param translationsEnabledX - Are translations along the X axis enabled?\n     * @param translationsEnabledY - Are translations along the y axis enabled?\n     * @param translationsEnabledZ - Are translations along the Z axis enabled?\n     * @deprecated use `this.enabledTranslations` with the same arguments instead.\n     */\n    restrictTranslations(translationsEnabledX, translationsEnabledY, translationsEnabledZ) {\n        return this.enabledTranslations(translationsEnabledX, translationsEnabledY, translationsEnabledZ);\n    }\n    /**\n     * Locks all translations that would have resulted from forces on\n     * the created rigid-body.\n     */\n    lockTranslations() {\n        return this.enabledTranslations(false, false, false);\n    }\n    /**\n     * Allow rotation of this rigid-body only along specific axes.\n     * @param rotationsEnabledX - Are rotations along the X axis enabled?\n     * @param rotationsEnabledY - Are rotations along the y axis enabled?\n     * @param rotationsEnabledZ - Are rotations along the Z axis enabled?\n     */\n    enabledRotations(rotationsEnabledX, rotationsEnabledY, rotationsEnabledZ) {\n        this.rotationsEnabledX = rotationsEnabledX;\n        this.rotationsEnabledY = rotationsEnabledY;\n        this.rotationsEnabledZ = rotationsEnabledZ;\n        return this;\n    }\n    /**\n     * Allow rotation of this rigid-body only along specific axes.\n     * @param rotationsEnabledX - Are rotations along the X axis enabled?\n     * @param rotationsEnabledY - Are rotations along the y axis enabled?\n     * @param rotationsEnabledZ - Are rotations along the Z axis enabled?\n     * @deprecated use `this.enabledRotations` with the same arguments instead.\n     */\n    restrictRotations(rotationsEnabledX, rotationsEnabledY, rotationsEnabledZ) {\n        return this.enabledRotations(rotationsEnabledX, rotationsEnabledY, rotationsEnabledZ);\n    }\n    /**\n     * Locks all rotations that would have resulted from forces on\n     * the created rigid-body.\n     */\n    lockRotations() {\n        return this.restrictRotations(false, false, false);\n    }\n    // #endif\n    /**\n     * Sets the linear damping of the rigid-body to create.\n     *\n     * This will progressively slowdown the translational movement of the rigid-body.\n     *\n     * @param damping - The angular damping coefficient. Should be >= 0. The higher this\n     *                  value is, the stronger the translational slowdown will be.\n     */\n    setLinearDamping(damping) {\n        this.linearDamping = damping;\n        return this;\n    }\n    /**\n     * Sets the angular damping of the rigid-body to create.\n     *\n     * This will progressively slowdown the rotational movement of the rigid-body.\n     *\n     * @param damping - The angular damping coefficient. Should be >= 0. The higher this\n     *                  value is, the stronger the rotational slowdown will be.\n     */\n    setAngularDamping(damping) {\n        this.angularDamping = damping;\n        return this;\n    }\n    /**\n     * Sets whether or not the rigid-body to create can sleep.\n     *\n     * @param can - true if the rigid-body can sleep, false if it can't.\n     */\n    setCanSleep(can) {\n        this.canSleep = can;\n        return this;\n    }\n    /**\n     * Sets whether or not the rigid-body is to be created asleep.\n     *\n     * @param can - true if the rigid-body should be in sleep, default false.\n     */\n    setSleeping(sleeping) {\n        this.sleeping = sleeping;\n        return this;\n    }\n    /**\n     * Sets whether Continuous Collision Detection (CCD) is enabled for this rigid-body.\n     *\n     * @param enabled - true if the rigid-body has CCD enabled.\n     */\n    setCcdEnabled(enabled) {\n        this.ccdEnabled = enabled;\n        return this;\n    }\n    /**\n     * Sets the maximum prediction distance Soft Continuous Collision-Detection.\n     *\n     * When set to 0, soft-CCD is disabled. Soft-CCD helps prevent tunneling especially of\n     * slow-but-thin to moderately fast objects. The soft CCD prediction distance indicates how\n     * far in the object’s path the CCD algorithm is allowed to inspect. Large values can impact\n     * performance badly by increasing the work needed from the broad-phase.\n     *\n     * It is a generally cheaper variant of regular CCD (that can be enabled with\n     * `RigidBodyDesc::setCcdEnabled` since it relies on predictive constraints instead of\n     * shape-cast and substeps.\n     */\n    setSoftCcdPrediction(distance) {\n        this.softCcdPrediction = distance;\n        return this;\n    }\n    /**\n     * Sets the user-defined object of this rigid-body.\n     *\n     * @param userData - The user-defined object to set.\n     */\n    setUserData(data) {\n        this.userData = data;\n        return this;\n    }\n}\n//# sourceMappingURL=rigid_body.js.map"],"names":["RigidBodyType","RigidBody","constructor","rawSet","colliderSet","handle","this","finalizeDeserialization","isValid","contains","lockTranslations","locked","wakeUp","rbLockTranslations","lockRotations","rbLockRotations","setEnabledTranslations","enableX","enableY","enableZ","rbSetEnabledTranslations","restrictTranslations","setEnabledRotations","rbSetEnabledRotations","restrictRotations","dominanceGroup","rbDominanceGroup","setDominanceGroup","group","rbSetDominanceGroup","additionalSolverIterations","rbAdditionalSolverIterations","setAdditionalSolverIterations","iters","rbSetAdditionalSolverIterations","enableCcd","enabled","rbEnableCcd","setSoftCcdPrediction","distance","rbSetSoftCcdPrediction","softCcdPrediction","rbSoftCcdPrediction","translation","res","rbTranslation","VectorOps","fromRaw","rotation","rbRotation","RotationOps","nextTranslation","rbNextTranslation","nextRotation","rbNextRotation","setTranslation","tra","rbSetTranslation","x","y","z","setLinvel","vel","rawVel","intoRaw","rbSetLinvel","free","gravityScale","rbGravityScale","setGravityScale","factor","rbSetGravityScale","setRotation","rot","rbSetRotation","w","setAngvel","rbSetAngvel","setNextKinematicTranslation","t","rbSetNextKinematicTranslation","setNextKinematicRotation","rbSetNextKinematicRotation","linvel","rbLinvel","velocityAtPoint","point","rawPoint","result","rbVelocityAtPoint","angvel","rbAngvel","mass","rbMass","effectiveInvMass","rbEffectiveInvMass","invMass","rbInvMass","localCom","rbLocalCom","worldCom","rbWorldCom","invPrincipalInertia","rbInvPrincipalInertia","principalInertia","rbPrincipalInertia","principalInertiaLocalFrame","rbPrincipalInertiaLocalFrame","effectiveWorldInvInertia","SdpMatrix3Ops","rbEffectiveWorldInvInertia","effectiveAngularInertia","rbEffectiveAngularInertia","sleep","rbSleep","rbWakeUp","isCcdEnabled","rbIsCcdEnabled","numColliders","rbNumColliders","collider","i","get","rbCollider","setEnabled","rbSetEnabled","isEnabled","rbIsEnabled","bodyType","rbBodyType","setBodyType","type","rbSetBodyType","isSleeping","rbIsSleeping","isMoving","rbIsMoving","isFixed","rbIsFixed","isKinematic","rbIsKinematic","isDynamic","rbIsDynamic","linearDamping","rbLinearDamping","angularDamping","rbAngularDamping","setLinearDamping","rbSetLinearDamping","recomputeMassPropertiesFromColliders","rbRecomputeMassPropertiesFromColliders","raw","setAdditionalMass","rbSetAdditionalMass","setAdditionalMassProperties","centerOfMass","principalAngularInertia","angularInertiaLocalFrame","rawCom","rawPrincipalInertia","rawInertiaFrame","rbSetAdditionalMassProperties","setAngularDamping","rbSetAngularDamping","resetForces","rbResetForces","resetTorques","rbResetTorques","addForce","force","rawForce","rbAddForce","applyImpulse","impulse","rawImpulse","rbApplyImpulse","addTorque","torque","rawTorque","rbAddTorque","applyTorqueImpulse","torqueImpulse","rawTorqueImpulse","rbApplyTorqueImpulse","addForceAtPoint","rbAddForceAtPoint","applyImpulseAtPoint","rbApplyImpulseAtPoint","userForce","rbUserForce","userTorque","rbUserTorque","RigidBodyDesc","status","zeros","identity","massOnly","translationsEnabledX","translationsEnabledY","translationsEnabledZ","rotationsEnabledX","rotationsEnabledY","rotationsEnabledZ","canSleep","sleeping","ccdEnabled","dynamic","Dynamic","kinematicPositionBased","KinematicPositionBased","kinematicVelocityBased","KinematicVelocityBased","fixed","Fixed","newDynamic","newKinematicPositionBased","newKinematicVelocityBased","newStatic","TypeError","copy","scale","enabledTranslations","enabledRotations","damping","setCanSleep","can","setSleeping","setCcdEnabled","setUserData","data","userData"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -1,2 +0,0 @@
-import"../rapier_wasm3d.js";import{Coarena}from"../coarena.js";import{VectorOps,RotationOps}from"../math.js";import{RigidBody}from"./rigid_body.js";import{RawRigidBodySet}from"../rapier_wasm3d_bg.js";class RigidBodySet{free(){this.raw&&this.raw.free(),this.raw=void 0,this.map&&this.map.clear(),this.map=void 0}constructor(raw){this.raw=raw||new RawRigidBodySet,this.map=new Coarena,raw&&raw.forEachRigidBodyHandle(handle=>{this.map.set(handle,new RigidBody(raw,null,handle))})}finalizeDeserialization(colliderSet){this.map.forEach(rb=>rb.finalizeDeserialization(colliderSet))}createRigidBody(colliderSet,desc){let rawTra=VectorOps.intoRaw(desc.translation),rawRot=RotationOps.intoRaw(desc.rotation),rawLv=VectorOps.intoRaw(desc.linvel),rawCom=VectorOps.intoRaw(desc.centerOfMass),rawAv=VectorOps.intoRaw(desc.angvel),rawPrincipalInertia=VectorOps.intoRaw(desc.principalAngularInertia),rawInertiaFrame=RotationOps.intoRaw(desc.angularInertiaLocalFrame),handle=this.raw.createRigidBody(desc.enabled,rawTra,rawRot,desc.gravityScale,desc.mass,desc.massOnly,rawCom,rawLv,rawAv,rawPrincipalInertia,rawInertiaFrame,desc.translationsEnabledX,desc.translationsEnabledY,desc.translationsEnabledZ,desc.rotationsEnabledX,desc.rotationsEnabledY,desc.rotationsEnabledZ,desc.linearDamping,desc.angularDamping,desc.status,desc.canSleep,desc.sleeping,desc.softCcdPrediction,desc.ccdEnabled,desc.dominanceGroup,desc.additionalSolverIterations);rawTra.free(),rawRot.free(),rawLv.free(),rawCom.free(),rawAv.free(),rawPrincipalInertia.free(),rawInertiaFrame.free();const body=new RigidBody(this.raw,colliderSet,handle);return body.userData=desc.userData,this.map.set(handle,body),body}remove(handle,islands,colliders,impulseJoints,multibodyJoints){for(let i=0;i<this.raw.rbNumColliders(handle);i+=1)colliders.unmap(this.raw.rbCollider(handle,i));impulseJoints.forEachJointHandleAttachedToRigidBody(handle,handle=>impulseJoints.unmap(handle)),multibodyJoints.forEachJointHandleAttachedToRigidBody(handle,handle=>multibodyJoints.unmap(handle)),this.raw.remove(handle,islands.raw,colliders.raw,impulseJoints.raw,multibodyJoints.raw),this.map.delete(handle)}len(){return this.map.len()}contains(handle){return null!=this.get(handle)}get(handle){return this.map.get(handle)}forEach(f){this.map.forEach(f)}forEachActiveRigidBody(islands,f){islands.forEachActiveRigidBodyHandle(handle=>{f(this.get(handle))})}getAll(){return this.map.getAll()}}export{RigidBodySet};
-//# sourceMappingURL=rigid_body_set.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"rigid_body_set.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/dynamics/rigid_body_set.js"],"sourcesContent":["import { RawRigidBodySet } from \"../raw\";\nimport { Coarena } from \"../coarena\";\nimport { VectorOps, RotationOps } from \"../math\";\nimport { RigidBody, } from \"./rigid_body\";\n/**\n * A set of rigid bodies that can be handled by a physics pipeline.\n *\n * To avoid leaking WASM resources, this MUST be freed manually with `rigidBodySet.free()`\n * once you are done using it (and all the rigid-bodies it created).\n */\nexport class RigidBodySet {\n    /**\n     * Release the WASM memory occupied by this rigid-body set.\n     */\n    free() {\n        if (!!this.raw) {\n            this.raw.free();\n        }\n        this.raw = undefined;\n        if (!!this.map) {\n            this.map.clear();\n        }\n        this.map = undefined;\n    }\n    constructor(raw) {\n        this.raw = raw || new RawRigidBodySet();\n        this.map = new Coarena();\n        // deserialize\n        if (raw) {\n            raw.forEachRigidBodyHandle((handle) => {\n                this.map.set(handle, new RigidBody(raw, null, handle));\n            });\n        }\n    }\n    /**\n     * Internal method, do not call this explicitly.\n     */\n    finalizeDeserialization(colliderSet) {\n        this.map.forEach((rb) => rb.finalizeDeserialization(colliderSet));\n    }\n    /**\n     * Creates a new rigid-body and return its integer handle.\n     *\n     * @param desc - The description of the rigid-body to create.\n     */\n    createRigidBody(colliderSet, desc) {\n        let rawTra = VectorOps.intoRaw(desc.translation);\n        let rawRot = RotationOps.intoRaw(desc.rotation);\n        let rawLv = VectorOps.intoRaw(desc.linvel);\n        let rawCom = VectorOps.intoRaw(desc.centerOfMass);\n        // #if DIM3\n        let rawAv = VectorOps.intoRaw(desc.angvel);\n        let rawPrincipalInertia = VectorOps.intoRaw(desc.principalAngularInertia);\n        let rawInertiaFrame = RotationOps.intoRaw(desc.angularInertiaLocalFrame);\n        // #endif\n        let handle = this.raw.createRigidBody(desc.enabled, rawTra, rawRot, desc.gravityScale, desc.mass, desc.massOnly, rawCom, rawLv, \n        // #if DIM3\n        rawAv, rawPrincipalInertia, rawInertiaFrame, desc.translationsEnabledX, desc.translationsEnabledY, desc.translationsEnabledZ, desc.rotationsEnabledX, desc.rotationsEnabledY, desc.rotationsEnabledZ, \n        // #endif\n        desc.linearDamping, desc.angularDamping, desc.status, desc.canSleep, desc.sleeping, desc.softCcdPrediction, desc.ccdEnabled, desc.dominanceGroup, desc.additionalSolverIterations);\n        rawTra.free();\n        rawRot.free();\n        rawLv.free();\n        rawCom.free();\n        // #if DIM3\n        rawAv.free();\n        rawPrincipalInertia.free();\n        rawInertiaFrame.free();\n        // #endif\n        const body = new RigidBody(this.raw, colliderSet, handle);\n        body.userData = desc.userData;\n        this.map.set(handle, body);\n        return body;\n    }\n    /**\n     * Removes a rigid-body from this set.\n     *\n     * This will also remove all the colliders and joints attached to the rigid-body.\n     *\n     * @param handle - The integer handle of the rigid-body to remove.\n     * @param colliders - The set of colliders that may contain colliders attached to the removed rigid-body.\n     * @param impulseJoints - The set of impulse joints that may contain joints attached to the removed rigid-body.\n     * @param multibodyJoints - The set of multibody joints that may contain joints attached to the removed rigid-body.\n     */\n    remove(handle, islands, colliders, impulseJoints, multibodyJoints) {\n        // Unmap the entities that will be removed automatically because of the rigid-body removals.\n        for (let i = 0; i < this.raw.rbNumColliders(handle); i += 1) {\n            colliders.unmap(this.raw.rbCollider(handle, i));\n        }\n        impulseJoints.forEachJointHandleAttachedToRigidBody(handle, (handle) => impulseJoints.unmap(handle));\n        multibodyJoints.forEachJointHandleAttachedToRigidBody(handle, (handle) => multibodyJoints.unmap(handle));\n        // Remove the rigid-body.\n        this.raw.remove(handle, islands.raw, colliders.raw, impulseJoints.raw, multibodyJoints.raw);\n        this.map.delete(handle);\n    }\n    /**\n     * The number of rigid-bodies on this set.\n     */\n    len() {\n        return this.map.len();\n    }\n    /**\n     * Does this set contain a rigid-body with the given handle?\n     *\n     * @param handle - The rigid-body handle to check.\n     */\n    contains(handle) {\n        return this.get(handle) != null;\n    }\n    /**\n     * Gets the rigid-body with the given handle.\n     *\n     * @param handle - The handle of the rigid-body to retrieve.\n     */\n    get(handle) {\n        return this.map.get(handle);\n    }\n    /**\n     * Applies the given closure to each rigid-body contained by this set.\n     *\n     * @param f - The closure to apply.\n     */\n    forEach(f) {\n        this.map.forEach(f);\n    }\n    /**\n     * Applies the given closure to each active rigid-bodies contained by this set.\n     *\n     * A rigid-body is active if it is not sleeping, i.e., if it moved recently.\n     *\n     * @param f - The closure to apply.\n     */\n    forEachActiveRigidBody(islands, f) {\n        islands.forEachActiveRigidBodyHandle((handle) => {\n            f(this.get(handle));\n        });\n    }\n    /**\n     * Gets all rigid-bodies in the list.\n     *\n     * @returns rigid-bodies list.\n     */\n    getAll() {\n        return this.map.getAll();\n    }\n}\n//# sourceMappingURL=rigid_body_set.js.map"],"names":["RigidBodySet","free","this","raw","undefined","map","clear","constructor","RawRigidBodySet","Coarena","forEachRigidBodyHandle","handle","set","RigidBody","finalizeDeserialization","colliderSet","forEach","rb","createRigidBody","desc","rawTra","VectorOps","intoRaw","translation","rawRot","RotationOps","rotation","rawLv","linvel","rawCom","centerOfMass","rawAv","angvel","rawPrincipalInertia","principalAngularInertia","rawInertiaFrame","angularInertiaLocalFrame","enabled","gravityScale","mass","massOnly","translationsEnabledX","translationsEnabledY","translationsEnabledZ","rotationsEnabledX","rotationsEnabledY","rotationsEnabledZ","linearDamping","angularDamping","status","canSleep","sleeping","softCcdPrediction","ccdEnabled","dominanceGroup","additionalSolverIterations","body","userData","remove","islands","colliders","impulseJoints","multibodyJoints","i","rbNumColliders","unmap","rbCollider","forEachJointHandleAttachedToRigidBody","delete","len","contains","get","f","forEachActiveRigidBody","forEachActiveRigidBodyHandle","getAll"],"mappings":"wMAUO,MAAMA,aAIT,IAAAC,GACUC,KAAKC,KACPD,KAAKC,IAAIF,OAEbC,KAAKC,SAAMC,EACLF,KAAKG,KACPH,KAAKG,IAAIC,QAEbJ,KAAKG,SAAMD,CACf,CACA,WAAAG,CAAYJ,KACRD,KAAKC,IAAMA,KAAO,IAAIK,gBACtBN,KAAKG,IAAM,IAAII,QAEXN,KACAA,IAAIO,uBAAwBC,SACxBT,KAAKG,IAAIO,IAAID,OAAQ,IAAIE,UAAUV,IAAK,KAAMQ,UAG1D,CAIA,uBAAAG,CAAwBC,aACpBb,KAAKG,IAAIW,QAASC,IAAOA,GAAGH,wBAAwBC,aACxD,CAMA,eAAAG,CAAgBH,YAAaI,MACzB,IAAIC,OAASC,UAAUC,QAAQH,KAAKI,aAChCC,OAASC,YAAYH,QAAQH,KAAKO,UAClCC,MAAQN,UAAUC,QAAQH,KAAKS,QAC/BC,OAASR,UAAUC,QAAQH,KAAKW,cAEhCC,MAAQV,UAAUC,QAAQH,KAAKa,QAC/BC,oBAAsBZ,UAAUC,QAAQH,KAAKe,yBAC7CC,gBAAkBV,YAAYH,QAAQH,KAAKiB,0BAE3CzB,OAAST,KAAKC,IAAIe,gBAAgBC,KAAKkB,QAASjB,OAAQI,OAAQL,KAAKmB,aAAcnB,KAAKoB,KAAMpB,KAAKqB,SAAUX,OAAQF,MAEzHI,MAAOE,oBAAqBE,gBAAiBhB,KAAKsB,qBAAsBtB,KAAKuB,qBAAsBvB,KAAKwB,qBAAsBxB,KAAKyB,kBAAmBzB,KAAK0B,kBAAmB1B,KAAK2B,kBAEnL3B,KAAK4B,cAAe5B,KAAK6B,eAAgB7B,KAAK8B,OAAQ9B,KAAK+B,SAAU/B,KAAKgC,SAAUhC,KAAKiC,kBAAmBjC,KAAKkC,WAAYlC,KAAKmC,eAAgBnC,KAAKoC,4BACvJnC,OAAOnB,OACPuB,OAAOvB,OACP0B,MAAM1B,OACN4B,OAAO5B,OAEP8B,MAAM9B,OACNgC,oBAAoBhC,OACpBkC,gBAAgBlC,OAEhB,MAAMuD,KAAO,IAAI3C,UAAUX,KAAKC,IAAKY,YAAaJ,QAGlD,OAFA6C,KAAKC,SAAWtC,KAAKsC,SACrBvD,KAAKG,IAAIO,IAAID,OAAQ6C,MACdA,IACX,CAWA,MAAAE,CAAO/C,OAAQgD,QAASC,UAAWC,cAAeC,iBAE9C,IAAK,IAAIC,EAAI,EAAGA,EAAI7D,KAAKC,IAAI6D,eAAerD,QAASoD,GAAK,EACtDH,UAAUK,MAAM/D,KAAKC,IAAI+D,WAAWvD,OAAQoD,IAEhDF,cAAcM,sCAAsCxD,OAASA,QAAWkD,cAAcI,MAAMtD,SAC5FmD,gBAAgBK,sCAAsCxD,OAASA,QAAWmD,gBAAgBG,MAAMtD,SAEhGT,KAAKC,IAAIuD,OAAO/C,OAAQgD,QAAQxD,IAAKyD,UAAUzD,IAAK0D,cAAc1D,IAAK2D,gBAAgB3D,KACvFD,KAAKG,IAAI+D,OAAOzD,OACpB,CAIA,GAAA0D,GACI,OAAOnE,KAAKG,IAAIgE,KACpB,CAMA,QAAAC,CAAS3D,QACL,OAA2B,MAApBT,KAAKqE,IAAI5D,OACpB,CAMA,GAAA4D,CAAI5D,QACA,OAAOT,KAAKG,IAAIkE,IAAI5D,OACxB,CAMA,OAAAK,CAAQwD,GACJtE,KAAKG,IAAIW,QAAQwD,EACrB,CAQA,sBAAAC,CAAuBd,QAASa,GAC5Bb,QAAQe,6BAA8B/D,SAClC6D,EAAEtE,KAAKqE,IAAI5D,UAEnB,CAMA,MAAAgE,GACI,OAAOzE,KAAKG,IAAIsE,QACpB","x_google_ignoreList":[0]}

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

@@ -1,2 +0,0 @@
-import"../rapier_wasm3d.js";import{RayColliderHit,RayColliderIntersection}from"./ray.js";import{VectorOps,RotationOps}from"../math.js";import{PointColliderProjection}from"./point.js";import{ColliderShapeCastHit}from"./toi.js";import{RawBroadPhase}from"../rapier_wasm3d_bg.js";class BroadPhase{free(){this.raw&&this.raw.free(),this.raw=void 0}constructor(raw){this.raw=raw||new RawBroadPhase}castRay(narrowPhase,bodies,colliders,ray,maxToi,solid,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){let rawOrig=VectorOps.intoRaw(ray.origin),rawDir=VectorOps.intoRaw(ray.dir),result=RayColliderHit.fromRaw(colliders,this.raw.castRay(narrowPhase.raw,bodies.raw,colliders.raw,rawOrig,rawDir,maxToi,solid,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate));return rawOrig.free(),rawDir.free(),result}castRayAndGetNormal(narrowPhase,bodies,colliders,ray,maxToi,solid,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){let rawOrig=VectorOps.intoRaw(ray.origin),rawDir=VectorOps.intoRaw(ray.dir),result=RayColliderIntersection.fromRaw(colliders,this.raw.castRayAndGetNormal(narrowPhase.raw,bodies.raw,colliders.raw,rawOrig,rawDir,maxToi,solid,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate));return rawOrig.free(),rawDir.free(),result}intersectionsWithRay(narrowPhase,bodies,colliders,ray,maxToi,solid,callback,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){let rawOrig=VectorOps.intoRaw(ray.origin),rawDir=VectorOps.intoRaw(ray.dir);this.raw.intersectionsWithRay(narrowPhase.raw,bodies.raw,colliders.raw,rawOrig,rawDir,maxToi,solid,rawInter=>callback(RayColliderIntersection.fromRaw(colliders,rawInter)),filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate),rawOrig.free(),rawDir.free()}intersectionWithShape(narrowPhase,bodies,colliders,shapePos,shapeRot,shape,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){let rawPos=VectorOps.intoRaw(shapePos),rawRot=RotationOps.intoRaw(shapeRot),rawShape=shape.intoRaw(),result=this.raw.intersectionWithShape(narrowPhase.raw,bodies.raw,colliders.raw,rawPos,rawRot,rawShape,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate);return rawPos.free(),rawRot.free(),rawShape.free(),result}projectPoint(narrowPhase,bodies,colliders,point,solid,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){let rawPoint=VectorOps.intoRaw(point),result=PointColliderProjection.fromRaw(colliders,this.raw.projectPoint(narrowPhase.raw,bodies.raw,colliders.raw,rawPoint,solid,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate));return rawPoint.free(),result}projectPointAndGetFeature(narrowPhase,bodies,colliders,point,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){let rawPoint=VectorOps.intoRaw(point),result=PointColliderProjection.fromRaw(colliders,this.raw.projectPointAndGetFeature(narrowPhase.raw,bodies.raw,colliders.raw,rawPoint,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate));return rawPoint.free(),result}intersectionsWithPoint(narrowPhase,bodies,colliders,point,callback,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){let rawPoint=VectorOps.intoRaw(point);this.raw.intersectionsWithPoint(narrowPhase.raw,bodies.raw,colliders.raw,rawPoint,callback,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate),rawPoint.free()}castShape(narrowPhase,bodies,colliders,shapePos,shapeRot,shapeVel,shape,targetDistance,maxToi,stopAtPenetration,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){let rawPos=VectorOps.intoRaw(shapePos),rawRot=RotationOps.intoRaw(shapeRot),rawVel=VectorOps.intoRaw(shapeVel),rawShape=shape.intoRaw(),result=ColliderShapeCastHit.fromRaw(colliders,this.raw.castShape(narrowPhase.raw,bodies.raw,colliders.raw,rawPos,rawRot,rawVel,rawShape,targetDistance,maxToi,stopAtPenetration,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate));return rawPos.free(),rawRot.free(),rawVel.free(),rawShape.free(),result}intersectionsWithShape(narrowPhase,bodies,colliders,shapePos,shapeRot,shape,callback,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){let rawPos=VectorOps.intoRaw(shapePos),rawRot=RotationOps.intoRaw(shapeRot),rawShape=shape.intoRaw();this.raw.intersectionsWithShape(narrowPhase.raw,bodies.raw,colliders.raw,rawPos,rawRot,rawShape,callback,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate),rawPos.free(),rawRot.free(),rawShape.free()}collidersWithAabbIntersectingAabb(narrowPhase,bodies,colliders,aabbCenter,aabbHalfExtents,callback){let rawCenter=VectorOps.intoRaw(aabbCenter),rawHalfExtents=VectorOps.intoRaw(aabbHalfExtents);this.raw.collidersWithAabbIntersectingAabb(narrowPhase.raw,bodies.raw,colliders.raw,rawCenter,rawHalfExtents,callback),rawCenter.free(),rawHalfExtents.free()}}export{BroadPhase};
-//# sourceMappingURL=broad_phase.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"broad_phase.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/geometry/broad_phase.js"],"sourcesContent":["import { RawBroadPhase } from \"../raw\";\nimport { RayColliderHit, RayColliderIntersection } from \"./ray\";\nimport { RotationOps, VectorOps } from \"../math\";\nimport { PointColliderProjection } from \"./point\";\nimport { ColliderShapeCastHit } from \"./toi\";\n/**\n * The broad-phase used for coarse collision-detection.\n *\n * To avoid leaking WASM resources, this MUST be freed manually with `broadPhase.free()`\n * once you are done using it.\n */\nexport class BroadPhase {\n    /**\n     * Release the WASM memory occupied by this broad-phase.\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 RawBroadPhase();\n    }\n    /**\n     * Find the closest intersection between a ray and a set of collider.\n     *\n     * @param colliders - The set of colliders taking part in this pipeline.\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(narrowPhase, bodies, colliders, ray, maxToi, solid, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        let rawOrig = VectorOps.intoRaw(ray.origin);\n        let rawDir = VectorOps.intoRaw(ray.dir);\n        let result = RayColliderHit.fromRaw(colliders, this.raw.castRay(narrowPhase.raw, bodies.raw, colliders.raw, rawOrig, rawDir, maxToi, solid, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate));\n        rawOrig.free();\n        rawDir.free();\n        return result;\n    }\n    /**\n     * Find the closest intersection between a ray and a set of collider.\n     *\n     * This also computes the normal at the hit point.\n     * @param colliders - The set of colliders taking part in this pipeline.\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(narrowPhase, bodies, colliders, ray, maxToi, solid, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        let rawOrig = VectorOps.intoRaw(ray.origin);\n        let rawDir = VectorOps.intoRaw(ray.dir);\n        let result = RayColliderIntersection.fromRaw(colliders, this.raw.castRayAndGetNormal(narrowPhase.raw, bodies.raw, colliders.raw, rawOrig, rawDir, maxToi, solid, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate));\n        rawOrig.free();\n        rawDir.free();\n        return result;\n    }\n    /**\n     * Cast a ray and collects all the intersections between a ray and the scene.\n     *\n     * @param colliders - The set of colliders taking part in this pipeline.\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(narrowPhase, bodies, colliders, ray, maxToi, solid, callback, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        let rawOrig = VectorOps.intoRaw(ray.origin);\n        let rawDir = VectorOps.intoRaw(ray.dir);\n        let rawCallback = (rawInter) => {\n            return callback(RayColliderIntersection.fromRaw(colliders, rawInter));\n        };\n        this.raw.intersectionsWithRay(narrowPhase.raw, bodies.raw, colliders.raw, rawOrig, rawDir, maxToi, solid, rawCallback, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate);\n        rawOrig.free();\n        rawDir.free();\n    }\n    /**\n     * Gets the handle of up to one collider intersecting the given shape.\n     *\n     * @param colliders - The set of colliders taking part in this pipeline.\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(narrowPhase, bodies, colliders, shapePos, shapeRot, shape, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        let rawPos = VectorOps.intoRaw(shapePos);\n        let rawRot = RotationOps.intoRaw(shapeRot);\n        let rawShape = shape.intoRaw();\n        let result = this.raw.intersectionWithShape(narrowPhase.raw, bodies.raw, colliders.raw, rawPos, rawRot, rawShape, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate);\n        rawPos.free();\n        rawRot.free();\n        rawShape.free();\n        return result;\n    }\n    /**\n     * Find the projection of a point on the closest collider.\n     *\n     * @param colliders - The set of colliders taking part in this pipeline.\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(narrowPhase, bodies, colliders, point, solid, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        let rawPoint = VectorOps.intoRaw(point);\n        let result = PointColliderProjection.fromRaw(colliders, this.raw.projectPoint(narrowPhase.raw, bodies.raw, colliders.raw, rawPoint, solid, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate));\n        rawPoint.free();\n        return result;\n    }\n    /**\n     * Find the projection of a point on the closest collider.\n     *\n     * @param colliders - The set of colliders taking part in this pipeline.\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(narrowPhase, bodies, colliders, point, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        let rawPoint = VectorOps.intoRaw(point);\n        let result = PointColliderProjection.fromRaw(colliders, this.raw.projectPointAndGetFeature(narrowPhase.raw, bodies.raw, colliders.raw, rawPoint, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate));\n        rawPoint.free();\n        return result;\n    }\n    /**\n     * Find all the colliders containing the given point.\n     *\n     * @param colliders - The set of colliders taking part in this pipeline.\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(narrowPhase, bodies, colliders, point, callback, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        let rawPoint = VectorOps.intoRaw(point);\n        this.raw.intersectionsWithPoint(narrowPhase.raw, bodies.raw, colliders.raw, rawPoint, callback, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate);\n        rawPoint.free();\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 colliders - The set of colliders taking part in this pipeline.\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(narrowPhase, bodies, colliders, shapePos, shapeRot, shapeVel, shape, targetDistance, maxToi, stopAtPenetration, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        let rawPos = VectorOps.intoRaw(shapePos);\n        let rawRot = RotationOps.intoRaw(shapeRot);\n        let rawVel = VectorOps.intoRaw(shapeVel);\n        let rawShape = shape.intoRaw();\n        let result = ColliderShapeCastHit.fromRaw(colliders, this.raw.castShape(narrowPhase.raw, bodies.raw, colliders.raw, rawPos, rawRot, rawVel, rawShape, targetDistance, maxToi, stopAtPenetration, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate));\n        rawPos.free();\n        rawRot.free();\n        rawVel.free();\n        rawShape.free();\n        return result;\n    }\n    /**\n     * Retrieve all the colliders intersecting the given shape.\n     *\n     * @param colliders - The set of colliders taking part in this pipeline.\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(narrowPhase, bodies, colliders, shapePos, shapeRot, shape, callback, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        let rawPos = VectorOps.intoRaw(shapePos);\n        let rawRot = RotationOps.intoRaw(shapeRot);\n        let rawShape = shape.intoRaw();\n        this.raw.intersectionsWithShape(narrowPhase.raw, bodies.raw, colliders.raw, rawPos, rawRot, rawShape, callback, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate);\n        rawPos.free();\n        rawRot.free();\n        rawShape.free();\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(narrowPhase, bodies, colliders, aabbCenter, aabbHalfExtents, callback) {\n        let rawCenter = VectorOps.intoRaw(aabbCenter);\n        let rawHalfExtents = VectorOps.intoRaw(aabbHalfExtents);\n        this.raw.collidersWithAabbIntersectingAabb(narrowPhase.raw, bodies.raw, colliders.raw, rawCenter, rawHalfExtents, callback);\n        rawCenter.free();\n        rawHalfExtents.free();\n    }\n}\n//# sourceMappingURL=broad_phase.js.map"],"names":["BroadPhase","free","this","raw","undefined","constructor","RawBroadPhase","castRay","narrowPhase","bodies","colliders","ray","maxToi","solid","filterFlags","filterGroups","filterExcludeCollider","filterExcludeRigidBody","filterPredicate","rawOrig","VectorOps","intoRaw","origin","rawDir","dir","result","RayColliderHit","fromRaw","castRayAndGetNormal","RayColliderIntersection","intersectionsWithRay","callback","rawInter","intersectionWithShape","shapePos","shapeRot","shape","rawPos","rawRot","RotationOps","rawShape","projectPoint","point","rawPoint","PointColliderProjection","projectPointAndGetFeature","intersectionsWithPoint","castShape","shapeVel","targetDistance","stopAtPenetration","rawVel","ColliderShapeCastHit","intersectionsWithShape","collidersWithAabbIntersectingAabb","aabbCenter","aabbHalfExtents","rawCenter","rawHalfExtents"],"mappings":"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","x_google_ignoreList":[0]}