@codexo/exojs-physics 0.15.2 → 0.16.0

package/dist/esm/ContactModifier.d.ts

@@ -0,0 +1,85 @@
+import type { Collider } from './Collider';
+import type { ContactRecord } from './ContactGraph';
+import type { PhysicsBody } from './PhysicsBody';
+/**
+ * A solid contact as the world's {@link ContactModifier} sees it: the pair that
+ * produced it, the contact normal, and the three per-step controls the modifier
+ * may change. Everything else is read-only.
+ *
+ * The object is reused for every contact and is only valid for the duration of
+ * the callback - read what you need, write the controls, do not retain it.
+ *
+ * Writing a control affects this step only; the values are re-derived from the
+ * two colliders before the modifier runs again.
+ *
+ * A chain collider is solved per edge, so a body touching several edges of one
+ * chain reaches the modifier once per edge, each time with the same authored
+ * collider pair. Decide from the contact's own normal and penetration rather
+ * than from the pair's identity if that distinction matters.
+ */
+export interface ContactModifierContext {
+    readonly colliderA: Collider;
+    readonly colliderB: Collider;
+    readonly bodyA: PhysicsBody;
+    readonly bodyB: PhysicsBody;
+    /** X of the unit contact normal, pointing from A towards B. */
+    readonly normalX: number;
+    /** Y of the unit contact normal, pointing from A towards B. */
+    readonly normalY: number;
+    /** Manifold points backing this contact: `1` for a vertex/face hit, `2` for a face/face hit. */
+    readonly pointCount: number;
+    /** Deepest penetration across the manifold points, in px. */
+    readonly maxPenetration: number;
+    /**
+     * Set to `false` to skip this contact in the solver for this step. The
+     * contact stays geometrically touching, so `collisionStart`/`collisionEnd`
+     * still describe the real geometry; it just applies no impulse, and it does
+     * not join the two bodies into one sleeping island. Its warm-start impulses
+     * are dropped while it is disabled, so re-enabling it starts cold rather than
+     * releasing a stale impulse.
+     */
+    enabled: boolean;
+    /**
+     * Coulomb friction for this step. Defaults to `√(a.friction × b.friction)`
+     * over the two colliders.
+     */
+    friction: number;
+    /**
+     * Restitution for this step. Defaults to `max(a.restitution, b.restitution)`
+     * over the two colliders.
+     */
+    restitution: number;
+}
+/**
+ * Called once per solid contact per fixed step, after contact generation and
+ * before the solver runs, to adjust that contact for this step - the hook
+ * one-way platforms, conditional friction and per-pair material overrides are
+ * built on.
+ *
+ * A world has at most one modifier. It runs before islands are built, so
+ * disabling a contact also keeps the two bodies from sleeping as one.
+ */
+export type ContactModifier = (contact: ContactModifierContext) => void;
+/**
+ * The single reused {@link ContactModifierContext} instance. Bound to one record
+ * at a time so a step over thousands of contacts allocates nothing.
+ * @internal
+ */
+export declare class MutableContactModifierContext implements ContactModifierContext {
+    colliderA: Collider;
+    colliderB: Collider;
+    bodyA: PhysicsBody;
+    bodyB: PhysicsBody;
+    normalX: number;
+    normalY: number;
+    pointCount: number;
+    maxPenetration: number;
+    enabled: boolean;
+    friction: number;
+    restitution: number;
+    /** Point this context at `record` and load its current per-step values. */
+    bind(record: ContactRecord): void;
+    /** Write the (possibly modified) controls back onto the bound record. */
+    flush(record: ContactRecord): void;
+}
+//# sourceMappingURL=ContactModifier.d.ts.map

package/dist/esm/ContactModifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContactModifier.d.ts","sourceRoot":"","sources":["../../src/ContactModifier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,gGAAgG;IAChG,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,6DAA6D;IAC7D,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC;;;;;;;OAOG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,EAAE,sBAAsB,KAAK,IAAI,CAAC;AAExE;;;;GAIG;AACH,qBAAa,6BAA8B,YAAW,sBAAsB;IACnE,SAAS,EAAG,QAAQ,CAAC;IACrB,SAAS,EAAG,QAAQ,CAAC;IACrB,KAAK,EAAG,WAAW,CAAC;IACpB,KAAK,EAAG,WAAW,CAAC;IACpB,OAAO,SAAK;IACZ,OAAO,SAAK;IACZ,UAAU,SAAK;IACf,cAAc,SAAK;IACnB,OAAO,UAAQ;IACf,QAAQ,SAAK;IACb,WAAW,SAAK;IAEvB,2EAA2E;IACpE,IAAI,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;IA0BxC,yEAAyE;IAClE,KAAK,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;CAK1C"}

package/dist/esm/ContactModifier.js

@@ -0,0 +1,49 @@
+//#region src/ContactModifier.ts
+/**
+* The single reused {@link ContactModifierContext} instance. Bound to one record
+* at a time so a step over thousands of contacts allocates nothing.
+* @internal
+*/
+var MutableContactModifierContext = class {
+	colliderA;
+	colliderB;
+	bodyA;
+	bodyB;
+	normalX = 0;
+	normalY = 0;
+	pointCount = 0;
+	maxPenetration = 0;
+	enabled = true;
+	friction = 0;
+	restitution = 0;
+	/** Point this context at `record` and load its current per-step values. */
+	bind(record) {
+		const manifold = record.manifold;
+		this.colliderA = record.ownerA;
+		this.colliderB = record.ownerB;
+		this.bodyA = record.ownerA.body;
+		this.bodyB = record.ownerB.body;
+		this.normalX = manifold.normalX;
+		this.normalY = manifold.normalY;
+		this.pointCount = manifold.pointCount;
+		let deepest = 0;
+		for (let i = 0; i < manifold.pointCount; i++) {
+			const penetration = (i === 0 ? manifold.points[0] : manifold.points[1]).penetration;
+			deepest = penetration > deepest ? penetration : deepest;
+		}
+		this.maxPenetration = deepest;
+		this.enabled = record.enabled;
+		this.friction = record.friction;
+		this.restitution = record.restitution;
+	}
+	/** Write the (possibly modified) controls back onto the bound record. */
+	flush(record) {
+		record.enabled = this.enabled;
+		record.friction = this.friction;
+		record.restitution = this.restitution;
+	}
+};
+
+//#endregion
+export { MutableContactModifierContext };
+//# sourceMappingURL=ContactModifier.js.map

package/dist/esm/ContactModifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContactModifier.js","names":[],"sources":["../../src/ContactModifier.ts"],"sourcesContent":["import type { Collider } from './Collider';\nimport type { ContactRecord } from './ContactGraph';\nimport type { PhysicsBody } from './PhysicsBody';\n\n/**\n * A solid contact as the world's {@link ContactModifier} sees it: the pair that\n * produced it, the contact normal, and the three per-step controls the modifier\n * may change. Everything else is read-only.\n *\n * The object is reused for every contact and is only valid for the duration of\n * the callback - read what you need, write the controls, do not retain it.\n *\n * Writing a control affects this step only; the values are re-derived from the\n * two colliders before the modifier runs again.\n *\n * A chain collider is solved per edge, so a body touching several edges of one\n * chain reaches the modifier once per edge, each time with the same authored\n * collider pair. Decide from the contact's own normal and penetration rather\n * than from the pair's identity if that distinction matters.\n */\nexport interface ContactModifierContext {\n  readonly colliderA: Collider;\n  readonly colliderB: Collider;\n  readonly bodyA: PhysicsBody;\n  readonly bodyB: PhysicsBody;\n  /** X of the unit contact normal, pointing from A towards B. */\n  readonly normalX: number;\n  /** Y of the unit contact normal, pointing from A towards B. */\n  readonly normalY: number;\n  /** Manifold points backing this contact: `1` for a vertex/face hit, `2` for a face/face hit. */\n  readonly pointCount: number;\n  /** Deepest penetration across the manifold points, in px. */\n  readonly maxPenetration: number;\n  /**\n   * Set to `false` to skip this contact in the solver for this step. The\n   * contact stays geometrically touching, so `collisionStart`/`collisionEnd`\n   * still describe the real geometry; it just applies no impulse, and it does\n   * not join the two bodies into one sleeping island. Its warm-start impulses\n   * are dropped while it is disabled, so re-enabling it starts cold rather than\n   * releasing a stale impulse.\n   */\n  enabled: boolean;\n  /**\n   * Coulomb friction for this step. Defaults to `√(a.friction × b.friction)`\n   * over the two colliders.\n   */\n  friction: number;\n  /**\n   * Restitution for this step. Defaults to `max(a.restitution, b.restitution)`\n   * over the two colliders.\n   */\n  restitution: number;\n}\n\n/**\n * Called once per solid contact per fixed step, after contact generation and\n * before the solver runs, to adjust that contact for this step - the hook\n * one-way platforms, conditional friction and per-pair material overrides are\n * built on.\n *\n * A world has at most one modifier. It runs before islands are built, so\n * disabling a contact also keeps the two bodies from sleeping as one.\n */\nexport type ContactModifier = (contact: ContactModifierContext) => void;\n\n/**\n * The single reused {@link ContactModifierContext} instance. Bound to one record\n * at a time so a step over thousands of contacts allocates nothing.\n * @internal\n */\nexport class MutableContactModifierContext implements ContactModifierContext {\n  public colliderA!: Collider;\n  public colliderB!: Collider;\n  public bodyA!: PhysicsBody;\n  public bodyB!: PhysicsBody;\n  public normalX = 0;\n  public normalY = 0;\n  public pointCount = 0;\n  public maxPenetration = 0;\n  public enabled = true;\n  public friction = 0;\n  public restitution = 0;\n\n  /** Point this context at `record` and load its current per-step values. */\n  public bind(record: ContactRecord): void {\n    const manifold = record.manifold;\n\n    this.colliderA = record.ownerA;\n    this.colliderB = record.ownerB;\n    this.bodyA = record.ownerA.body;\n    this.bodyB = record.ownerB.body;\n    this.normalX = manifold.normalX;\n    this.normalY = manifold.normalY;\n    this.pointCount = manifold.pointCount;\n\n    let deepest = 0;\n\n    for (let i = 0; i < manifold.pointCount; i++) {\n      // i < pointCount <= 2, so the point exists.\n      const penetration = (i === 0 ? manifold.points[0] : manifold.points[1]).penetration;\n\n      deepest = penetration > deepest ? penetration : deepest;\n    }\n\n    this.maxPenetration = deepest;\n    this.enabled = record.enabled;\n    this.friction = record.friction;\n    this.restitution = record.restitution;\n  }\n\n  /** Write the (possibly modified) controls back onto the bound record. */\n  public flush(record: ContactRecord): void {\n    record.enabled = this.enabled;\n    record.friction = this.friction;\n    record.restitution = this.restitution;\n  }\n}\n"],"mappings":";;;;;;AAsEA,IAAa,gCAAb,MAA6E;CAC3E,AAAO;CACP,AAAO;CACP,AAAO;CACP,AAAO;CACP,AAAO,UAAU;CACjB,AAAO,UAAU;CACjB,AAAO,aAAa;CACpB,AAAO,iBAAiB;CACxB,AAAO,UAAU;CACjB,AAAO,WAAW;CAClB,AAAO,cAAc;;CAGrB,AAAO,KAAK,QAA6B;EACvC,MAAM,WAAW,OAAO;EAExB,KAAK,YAAY,OAAO;EACxB,KAAK,YAAY,OAAO;EACxB,KAAK,QAAQ,OAAO,OAAO;EAC3B,KAAK,QAAQ,OAAO,OAAO;EAC3B,KAAK,UAAU,SAAS;EACxB,KAAK,UAAU,SAAS;EACxB,KAAK,aAAa,SAAS;EAE3B,IAAI,UAAU;EAEd,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,YAAY,KAAK;GAE5C,MAAM,eAAe,MAAM,IAAI,SAAS,OAAO,KAAK,SAAS,OAAO,GAAE,CAAE;GAExE,UAAU,cAAc,UAAU,cAAc;EAClD;EAEA,KAAK,iBAAiB;EACtB,KAAK,UAAU,OAAO;EACtB,KAAK,WAAW,OAAO;EACvB,KAAK,cAAc,OAAO;CAC5B;;CAGA,AAAO,MAAM,QAA6B;EACxC,OAAO,UAAU,KAAK;EACtB,OAAO,WAAW,KAAK;EACvB,OAAO,cAAc,KAAK;CAC5B;AACF"}

package/dist/esm/PhysicsBody.d.ts

@@ -1,13 +1,14 @@
+import type { PointLike } from '@codexo/exojs';
 import { Vector } from '@codexo/exojs';
 import { Collider, type ColliderOptions } from './Collider';
 import type { Transform } from './math';
-import type { BodyType, VectorLike } from './types';
+import type { BodyType } from './types';
 /** Construction options for a body. */
 export interface BodyOptions {
     /** Simulation role. Default `'dynamic'`. */
     type?: BodyType;
     /** Initial world position. Default `(0, 0)`. */
-    position?: VectorLike;
+    position?: Readonly<PointLike>;
     /** Initial rotation in radians. Default `0`. */
     angle?: number;
     /** Linear damping applied to the velocity each sub-step. Default `0`. */
@@ -18,7 +19,7 @@ export interface BodyOptions {
     gravityScale?: number;
     /** When `true`, the body never rotates under contacts (infinite rotational inertia). Default `false`. */
     fixedRotation?: boolean;
-    /** When `true`, the body is swept against static geometry each step (CCD) so it cannot tunnel through thin walls. Default `false`. */
+    /** When `true`, the body's colliders are shape-cast along each step's motion (CCD) so it cannot tunnel through thin geometry. Default `false`. */
     isBullet?: boolean;
     /** Colliders to attach up-front. Each may be a {@link Collider} instance or its {@link ColliderOptions}. */
     colliders?: Array<Collider | ColliderOptions>;
@@ -50,7 +51,7 @@ export declare class PhysicsBody {
     gravityScale: number;
     /** When `true`, rotational inertia is treated as infinite. */
     fixedRotation: boolean;
-    /** When `true`, the body is swept against static geometry each step (CCD) so it cannot tunnel through thin walls. */
+    /** When `true`, the body's colliders are shape-cast along each step's motion (CCD) so it cannot tunnel through thin geometry. */
     isBullet: boolean;
     /** Total mass (0 for static/kinematic). */
     mass: number;
@@ -68,32 +69,42 @@ export declare class PhysicsBody {
     angularVelocity: number;
     /** When `false`, this body is never put to sleep. Default `true`. */
     allowSleep: boolean;
-    /** @internal — Delta position X accumulated across the frame's sub-steps by the TGS integrator; written into the transform once per frame by {@link _finalizePosition}. */
+    /** @internal - Delta position X accumulated across the frame's sub-steps by the TGS integrator; written into the transform once per frame by {@link _finalizePosition}. */
     _deltaPosX: number;
-    /** @internal — Delta position Y accumulated across the frame's sub-steps by the TGS integrator. */
+    /** @internal - Delta position Y accumulated across the frame's sub-steps by the TGS integrator. */
     _deltaPosY: number;
-    /** @internal — Delta rotation (radians) accumulated across the frame's sub-steps by the TGS integrator. */
+    /** @internal - Delta rotation (radians) accumulated across the frame's sub-steps by the TGS integrator. */
     _deltaAngle: number;
-    /** @internal — `cos(_deltaAngle)`, cached so the solver can rotate the contact anchors by the live sub-step rotation without a per-contact trig call. */
+    /** @internal - `cos(_deltaAngle)`, cached so the solver can rotate the contact anchors by the live sub-step rotation without a per-contact trig call. */
     _deltaCos: number;
-    /** @internal — `sin(_deltaAngle)`, cached alongside {@link _deltaCos}. */
+    /** @internal - `sin(_deltaAngle)`, cached alongside {@link _deltaCos}. */
     _deltaSin: number;
     private _forceX;
     private _forceY;
     private _torque;
-    /** @internal — seconds the body has stayed below the sleep thresholds (frozen while asleep). Read by the world's island pass. */
+    /** @internal - seconds the body has stayed below the sleep thresholds (frozen while asleep). Read by the world's island pass. */
     _sleepTime: number;
-    /** @internal — dense union-find index assigned by the world's island pass each step. */
+    /** @internal - dense union-find index assigned by the world's island pass each step. */
     _islandIndex: number;
-    /** @internal — world-space centre of mass at the start of the current fixed step (CCD swept-test origin). */
+    /**
+     * @internal - raised by {@link setTransform}, cleared once the fixed step that
+     * saw it completes. A static/kinematic body driven by teleporting carries no
+     * velocity, so this is the world's only signal that such a body moved and its
+     * sleeping contact partners must be woken.
+     */
+    _teleported: boolean;
+    /** @internal - world-space centre of mass at the start of the current fixed step (CCD swept-test origin). */
     _ccdPrevX: number;
-    /** @internal — see {@link _ccdPrevX}. */
+    /** @internal - see {@link _ccdPrevX}. */
     _ccdPrevY: number;
     private _sleeping;
     private _id;
     private _owner;
     private _attached;
     private readonly _transform;
+    private _previousX;
+    private _previousY;
+    private _previousAngle;
     private readonly _colliders;
     private _comX;
     private _comY;
@@ -110,6 +121,20 @@ export declare class PhysicsBody {
     get y(): number;
     /** Rotation in radians. */
     get angle(): number;
+    /**
+     * World X at the start of the most recent fixed step. With {@link x} it
+     * brackets the last step, which is what an interpolating presentation blends
+     * between; a teleport collapses it onto {@link x}. Never read by the solver.
+     */
+    get previousX(): number;
+    /** World Y at the start of the most recent fixed step; see {@link previousX}. */
+    get previousY(): number;
+    /**
+     * Rotation in radians at the start of the most recent fixed step; see
+     * {@link previousX}. Body angles are continuous and unbounded, never wrapped
+     * to a range, so this and {@link angle} can be blended with a plain lerp.
+     */
+    get previousAngle(): number;
     /** A fresh `Vector` copy of the body's world position. */
     get position(): Vector;
     /** The body's world transform (read-only; mutate via {@link setTransform}). */
@@ -128,7 +153,7 @@ export declare class PhysicsBody {
     get isMassReady(): boolean;
     /** `true` after the owning world has destroyed this body. */
     get destroyed(): boolean;
-    /** `true` when the body is asleep — skipped by the integrator and solver until woken. */
+    /** `true` when the body is asleep - skipped by the integrator and solver until woken. */
     get isSleeping(): boolean;
     /**
      * Attach a collider to this body. Accepts a {@link Collider} instance or its
@@ -143,7 +168,7 @@ export declare class PhysicsBody {
      * Set the body's world transform. Resets the body's cached collider geometry
      * immediately so subsequent queries see the new placement. Returns `this`.
      */
-    setTransform(position: VectorLike, angle?: number): this;
+    setTransform(position: Readonly<PointLike>, angle?: number): this;
     /** Refresh every collider's world geometry from the current transform. */
     synchronizeColliders(): void;
     /** World-space centre of mass X (body origin + rotated local centre of mass). */
@@ -167,17 +192,17 @@ export declare class PhysicsBody {
      */
     applyImpulse(impulseX: number, impulseY: number, pointX?: number, pointY?: number): this;
     /**
-     * @internal — integrate velocity from gravity, accumulated forces/torque and
+     * @internal - integrate velocity from gravity, accumulated forces/torque and
      * damping over the sub-step `h`. No-op for static/kinematic (infinite mass
      * keeps their velocity solver-driven only). Called once per TGS sub-step, so
      * gravity/forces are applied with `h` each sub-step (`N·h = dt`, same total
      * impulse, but the small-step position error scales with `h²`). The
-     * force/torque accumulators are **not** cleared here — they are consumed by
+     * force/torque accumulators are **not** cleared here - they are consumed by
      * every sub-step and cleared once per frame by {@link _finalizePosition}.
      */
     _integrateVelocity(h: number, gravityX: number, gravityY: number): void;
     /**
-     * @internal — accumulate this sub-step's velocity into the per-frame delta
+     * @internal - accumulate this sub-step's velocity into the per-frame delta
      * position/rotation (TGS sub-stepping). The transform itself is **not** moved
      * here; {@link _finalizePosition} writes the accumulated delta once per frame.
      * Tracking the delta (rather than moving the transform each sub-step) lets the
@@ -186,13 +211,13 @@ export declare class PhysicsBody {
      */
     _integratePosition(h: number): void;
     /**
-     * @internal — advance the sleep timer over one fixed step `dt`. A body below
+     * @internal - advance the sleep timer over one fixed step `dt`. A body below
      * both velocity thresholds accumulates time; a too-fast body, or one that opts
      * out via {@link allowSleep}, resets it. The sleep/wake decision is made per
      * island by the world (so a stack sleeps as a unit) from {@link _sleepTime}.
      */
     _accumulateSleepTime(dt: number, linearThreshold: number, angularThreshold: number): void;
-    /** @internal — set the sleep state. Sleeping zeroes the velocity; waking resets the sleep timer. */
+    /** @internal - set the sleep state. Sleeping zeroes the velocity; waking resets the sleep timer. */
     _setSleeping(sleeping: boolean): void;
     /**
      * Wake the body if it is asleep, resetting its sleep timer. The rest of its
@@ -201,7 +226,7 @@ export declare class PhysicsBody {
      */
     wake(): this;
     /**
-     * @internal — apply the frame's accumulated delta position/rotation to the
+     * @internal - apply the frame's accumulated delta position/rotation to the
      * transform (rotating about the centre of mass), re-sync collider geometry and
      * clear the force/torque accumulators. Called once per frame after the
      * sub-step loop. Static bodies never move; the force clear still runs (forces
@@ -213,7 +238,7 @@ export declare class PhysicsBody {
     /** Internal: detach a collider (called by the world during destruction). */
     _removeCollider(collider: Collider): void;
     /**
-     * @internal — join `owner`'s world with the allocated `id`. Allocates ids for
+     * @internal - join `owner`'s world with the allocated `id`. Allocates ids for
      * and registers every held collider, then aggregates the mass model and
      * synchronises world geometry. Called once by {@link PhysicsWorld.add}.
      *
@@ -228,6 +253,15 @@ export declare class PhysicsBody {
     _attachToWorld(owner: BodyOwner, id: number): void;
     /** Internal: mark destroyed (called by the world). */
     _markDestroyed(): void;
+    /**
+     * A dynamic body has to carry mass. Boundary geometry (a segment, a chain)
+     * reports no mass properties, and a collider may also be given zero density,
+     * so a dynamic body can end up with none at all - which the solver cannot tell
+     * apart from a static body, since both have `invMass === 0`. Rejecting it is
+     * the difference between a clear error and a body that silently stops moving.
+     */
+    private _assertDynamicCarriesMass;
     /** Recompute mass, centre of mass and rotational inertia from the colliders. */
     private _recomputeMass;
 }
+//# sourceMappingURL=PhysicsBody.d.ts.map

package/dist/esm/PhysicsBody.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsBody.d.ts","sourceRoot":"","sources":["../../src/PhysicsBody.ts"],"names":[],"mappings":"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"}