@newkrok/nape-js 3.3.15 → 3.3.17

package/dist/index.d.cts

@@ -25,13 +25,13 @@ declare function getNape(): any;
  *
  * Converted from nape-compiled.js lines 83820–84273, 134996.
  */
-type Any$F = any;
+type Any$H = any;
 declare class ZPP_Vec2 {
     static zpp_pool: ZPP_Vec2 | null;
     static __name__: string[];
-    static _nape: Any$F;
-    static _zpp: Any$F;
-    static _wrapFn: ((zpp: ZPP_Vec2) => Any$F) | null;
+    static _nape: Any$H;
+    static _zpp: Any$H;
+    static _wrapFn: ((zpp: ZPP_Vec2) => Any$H) | null;
     x: number;
     y: number;
     next: ZPP_Vec2 | null;
@@ -40,18 +40,18 @@ declare class ZPP_Vec2 {
     pushmod: boolean;
     _inuse: boolean;
     weak: boolean;
-    outer: Any$F;
+    outer: Any$H;
     _immutable: boolean;
     _isimmutable: (() => void) | null;
     _validate: (() => void) | null;
     _invalidate: ((self: ZPP_Vec2) => void) | null;
-    __class__: Any$F;
+    __class__: Any$H;
     /** Static factory with optional pooling and immutability. */
     static get(x: number, y: number, immutable?: boolean): ZPP_Vec2;
     validate(): void;
     invalidate(): void;
     immutable(): void;
-    wrapper(): Any$F;
+    wrapper(): Any$H;
     free(): void;
     alloc(): void;
     elem(): ZPP_Vec2;
@@ -203,20 +203,20 @@ type NapeInner = any;
  *
  * Converted from nape-compiled.js lines 83412–83434.
  */
-type Any$E = any;
+type Any$G = any;
 declare class ZPP_Vec3 {
     static __name__: string[];
-    static _zpp: Any$E;
-    static _wrapFn: ((zpp: ZPP_Vec3) => Any$E) | null;
-    outer: Any$E;
+    static _zpp: Any$G;
+    static _wrapFn: ((zpp: ZPP_Vec3) => Any$G) | null;
+    outer: Any$G;
     x: number;
     y: number;
     z: number;
     immutable: boolean;
     _validate: (() => void) | null;
-    __class__: Any$E;
+    __class__: Any$G;
     validate(): void;
-    wrapper(): Any$E;
+    wrapper(): Any$G;
 }
 
 /**
@@ -280,13 +280,13 @@ declare class Vec3 {
  *
  * Converted from nape-compiled.js lines 73495–73561, 133826.
  */
-type Any$D = any;
+type Any$F = any;
 declare class ZPP_Mat23 {
     static __name__: string[];
-    static _nape: Any$D;
-    static _wrapFn: ((zpp: ZPP_Mat23) => Any$D) | null;
+    static _nape: Any$F;
+    static _wrapFn: ((zpp: ZPP_Mat23) => Any$F) | null;
     static zpp_pool: ZPP_Mat23 | null;
-    outer: Any$D;
+    outer: Any$F;
     a: number;
     b: number;
     c: number;
@@ -295,13 +295,13 @@ declare class ZPP_Mat23 {
     ty: number;
     _invalidate: (() => void) | null;
     next: ZPP_Mat23 | null;
-    __class__: Any$D;
+    __class__: Any$F;
     /** Static factory with pooling. */
     static get(): ZPP_Mat23;
     /** Create an identity matrix from pool. */
     static identity(): ZPP_Mat23;
     /** Create a public wrapper, recycling any existing inner. */
-    wrapper(): Any$D;
+    wrapper(): Any$F;
     invalidate(): void;
     set(m: ZPP_Mat23): void;
     setas(a: number, b: number, c: number, d: number, tx: number, ty: number): void;
@@ -362,13 +362,13 @@ declare class Mat23 {
  *
  * Converted from nape-compiled.js lines 69554–69563.
  */
-type Any$C = any;
+type Any$E = any;
 declare class ZPP_GeomPoly {
     static __name__: string[];
-    outer: Any$C;
-    vertices: Any$C;
-    __class__: Any$C;
-    constructor(outer?: Any$C);
+    outer: Any$E;
+    vertices: Any$E;
+    __class__: Any$E;
+    constructor(outer?: Any$E);
 }
 
 /**
@@ -392,7 +392,7 @@ declare class Winding {
     toString(): string;
 }
 
-type Any$B = any;
+type Any$D = any;
 /**
  * A polygon represented as a circular doubly-linked list of vertices.
  *
@@ -407,8 +407,8 @@ declare class GeomPoly {
     zpp_inner: ZPP_GeomPoly;
     zpp_pool: GeomPoly | null;
     zpp_disp: boolean;
-    get _inner(): Any$B;
-    constructor(vertices?: Any$B);
+    get _inner(): Any$D;
+    constructor(vertices?: Any$D);
     private _checkDisposed;
     /** @internal Get compiled ZPP_GeomVert class */
     private static _gvClass;
@@ -434,12 +434,12 @@ declare class GeomPoly {
     private static _addVertices;
     /** @internal After copying, dispose weak Vec2 inputs */
     private static _disposeWeakInputs;
-    static get(vertices?: Any$B): GeomPoly;
+    static get(vertices?: Any$D): GeomPoly;
     empty(): boolean;
     size(): number;
-    iterator(): Any$B;
-    forwardIterator(): Any$B;
-    backwardsIterator(): Any$B;
+    iterator(): Any$D;
+    forwardIterator(): Any$D;
+    backwardsIterator(): Any$D;
     current(): Vec2;
     push(vertex: Vec2): this;
     pop(): this;
@@ -452,7 +452,7 @@ declare class GeomPoly {
     copy(): GeomPoly;
     dispose(): void;
     area(): number;
-    winding(): Any$B;
+    winding(): Any$D;
     contains(point: Vec2): boolean;
     isClockwise(): boolean;
     isConvex(): boolean;
@@ -460,14 +460,14 @@ declare class GeomPoly {
     isMonotone(): boolean;
     isDegenerate(): boolean;
     simplify(epsilon: number): GeomPoly;
-    simpleDecomposition(output?: Any$B): Any$B;
-    monotoneDecomposition(output?: Any$B): Any$B;
-    convexDecomposition(delaunay?: boolean, output?: Any$B): Any$B;
-    triangularDecomposition(delaunay?: boolean, output?: Any$B): Any$B;
+    simpleDecomposition(output?: Any$D): Any$D;
+    monotoneDecomposition(output?: Any$D): Any$D;
+    convexDecomposition(delaunay?: boolean, output?: Any$D): Any$D;
+    triangularDecomposition(delaunay?: boolean, output?: Any$D): Any$D;
     inflate(inflation: number): GeomPoly;
-    cut(start: Vec2, end: Vec2, boundedStart?: boolean, boundedEnd?: boolean, output?: Any$B): Any$B;
-    transform(matrix: Any$B): this;
-    bounds(): Any$B;
+    cut(start: Vec2, end: Vec2, boundedStart?: boolean, boundedEnd?: boolean, output?: Any$D): Any$D;
+    transform(matrix: Any$D): this;
+    bounds(): Any$D;
     top(): Vec2;
     bottom(): Vec2;
     left(): Vec2;
@@ -483,30 +483,30 @@ declare class GeomPoly {
  *
  * Converted from nape-compiled.js lines 63546–63965, 134951.
  */
-type Any$A = any;
+type Any$C = any;
 declare class ZPP_AABB {
     static zpp_pool: ZPP_AABB | null;
     static __name__: string[];
-    static _nape: Any$A;
-    static _zpp: Any$A;
-    static _wrapFn: ((zpp: ZPP_AABB) => Any$A) | null;
+    static _nape: Any$C;
+    static _zpp: Any$C;
+    static _wrapFn: ((zpp: ZPP_AABB) => Any$C) | null;
     _invalidate: ((self: ZPP_AABB) => void) | null;
     _validate: (() => void) | null;
     _immutable: boolean;
-    outer: Any$A;
+    outer: Any$C;
     next: ZPP_AABB | null;
     minx: number;
     miny: number;
     maxx: number;
     maxy: number;
-    wrap_min: Any$A;
-    wrap_max: Any$A;
-    __class__: Any$A;
+    wrap_min: Any$C;
+    wrap_max: Any$C;
+    __class__: Any$C;
     /** Static factory with pooling. */
     static get(minx: number, miny: number, maxx: number, maxy: number): ZPP_AABB;
     validate(): void;
     invalidate(): void;
-    wrapper(): Any$A;
+    wrapper(): Any$C;
     alloc(): void;
     free(): void;
     copy(): ZPP_AABB;
@@ -517,10 +517,10 @@ declare class ZPP_AABB {
     private static _makeVec2Wrapper;
     getmin(): void;
     dom_min(): void;
-    mod_min(min: Any$A): void;
+    mod_min(min: Any$C): void;
     getmax(): void;
     dom_max(): void;
-    mod_max(max: Any$A): void;
+    mod_max(max: Any$C): void;
     intersectX(x: ZPP_AABB): boolean;
     intersectY(x: ZPP_AABB): boolean;
     intersect(x: ZPP_AABB): boolean;
@@ -584,18 +584,18 @@ declare class AABB {
  *
  * Converted from nape-compiled.js lines 72949–72972.
  */
-type Any$z = any;
+type Any$B = any;
 declare class ZPP_MatMN {
     static __name__: string[];
-    outer: Any$z;
+    outer: Any$B;
     m: number;
     n: number;
     x: number[];
-    __class__: Any$z;
+    __class__: Any$B;
     constructor(m: number, n: number);
 }
 
-type Any$y = any;
+type Any$A = any;
 /**
  * Variable-sized M×N matrix.
  *
@@ -606,7 +606,7 @@ declare class MatMN {
     zpp_inner: ZPP_MatMN;
     get _inner(): NapeInner;
     constructor(rows: number, cols: number);
-    static _wrap(inner: Any$y): MatMN;
+    static _wrap(inner: Any$A): MatMN;
     get rows(): number;
     get cols(): number;
     x(row: number, col: number): number;
@@ -616,7 +616,7 @@ declare class MatMN {
     mul(matrix: MatMN): MatMN;
 }
 
-type Any$x = any;
+type Any$z = any;
 /**
  * Isosurface extraction using the marching squares algorithm.
  *
@@ -639,7 +639,7 @@ declare class MarchingSquares {
      * @param output - Optional GeomPolyList to populate. If null, a new one is created.
      * @returns The populated GeomPolyList.
      */
-    static run(iso: (x: number, y: number) => number, bounds: AABB, cellsize: Vec2, quality?: number, subgrid?: Vec2 | null, combine?: boolean, output?: Any$x): Any$x;
+    static run(iso: (x: number, y: number) => number, bounds: AABB, cellsize: Vec2, quality?: number, subgrid?: Vec2 | null, combine?: boolean, output?: Any$z): Any$z;
 }
 
 /**
@@ -675,31 +675,31 @@ declare class Ray {
  *
  * Converted from nape-compiled.js lines 38897–39076, 86860–86862.
  */
-type Any$w = any;
+type Any$y = any;
 declare class ZPP_ConvexRayResult {
     static __name__: string[];
     static rayPool: ZPP_ConvexRayResult | null;
     static convexPool: ZPP_ConvexRayResult | null;
     static internal: boolean;
-    static _createRayResult: (() => Any$w) | null;
-    static _createConvexResult: (() => Any$w) | null;
-    normal: Any$w;
-    shape: Any$w;
-    convex: Any$w;
-    position: Any$w;
-    ray: Any$w;
+    static _createRayResult: (() => Any$y) | null;
+    static _createConvexResult: (() => Any$y) | null;
+    normal: Any$y;
+    shape: Any$y;
+    convex: Any$y;
+    position: Any$y;
+    ray: Any$y;
     inner: boolean;
     next: ZPP_ConvexRayResult | null;
     toiDistance: number;
-    __class__: Any$w;
-    static getRay(normal: Any$w, time: number, inner: boolean, shape: Any$w): Any$w;
-    static getConvex(normal: Any$w, position: Any$w, toiDistance: number, shape: Any$w): Any$w;
+    __class__: Any$y;
+    static getRay(normal: Any$y, time: number, inner: boolean, shape: Any$y): Any$y;
+    static getConvex(normal: Any$y, position: Any$y, toiDistance: number, shape: Any$y): Any$y;
     disposed(): void;
     free(): void;
     private static _disposeVec2;
 }
 
-type Any$v = any;
+type Any$x = any;
 /**
  * Result from a convex-cast query.
  *
@@ -714,18 +714,18 @@ declare class ConvexResult {
     get _inner(): NapeInner;
     constructor();
     /** @internal */
-    static _wrap(inner: Any$v): ConvexResult;
+    static _wrap(inner: Any$x): ConvexResult;
     get normal(): Vec2;
     get position(): Vec2;
     get toi(): number;
-    get shape(): Any$v;
+    get shape(): Any$x;
     dispose(): void;
     toString(): string;
     /** @internal */
     private _disposed;
 }
 
-type Any$u = any;
+type Any$w = any;
 /**
  * Result from a raycast query.
  *
@@ -740,18 +740,18 @@ declare class RayResult {
     get _inner(): NapeInner;
     constructor();
     /** @internal */
-    static _wrap(inner: Any$u): RayResult;
+    static _wrap(inner: Any$w): RayResult;
     get normal(): Vec2;
     get distance(): number;
     get inner(): boolean;
-    get shape(): Any$u;
+    get shape(): Any$w;
     dispose(): void;
     toString(): string;
     /** @internal */
     private _disposed;
 }
 
-type Any$t = any;
+type Any$v = any;
 /**
  * Static utility class for geometric queries between shapes and bodies.
  *
@@ -769,7 +769,7 @@ declare class Geom {
      * @param out2 - Output Vec2 for closest point on body2.
      * @returns The distance between the two bodies.
      */
-    static distanceBody(body1: Any$t, body2: Any$t, out1: Vec2, out2: Vec2): number;
+    static distanceBody(body1: Any$v, body2: Any$v, out1: Vec2, out2: Vec2): number;
     /**
      * Calculate minimum distance between two shapes and return closest points.
      * @param shape1 - First shape (must be part of a body).
@@ -778,28 +778,28 @@ declare class Geom {
      * @param out2 - Output Vec2 for closest point on shape2.
      * @returns The distance between the two shapes.
      */
-    static distance(shape1: Any$t, shape2: Any$t, out1: Vec2, out2: Vec2): number;
+    static distance(shape1: Any$v, shape2: Any$v, out1: Vec2, out2: Vec2): number;
     /**
      * Test if two bodies intersect (any of their shapes overlap).
      * @param body1 - First body (must have shapes).
      * @param body2 - Second body (must have shapes).
      * @returns True if the bodies intersect.
      */
-    static intersectsBody(body1: Any$t, body2: Any$t): boolean;
+    static intersectsBody(body1: Any$v, body2: Any$v): boolean;
     /**
      * Test if two shapes intersect.
      * @param shape1 - First shape (must be part of a body).
      * @param shape2 - Second shape (must be part of a body).
      * @returns True if the shapes intersect.
      */
-    static intersects(shape1: Any$t, shape2: Any$t): boolean;
+    static intersects(shape1: Any$v, shape2: Any$v): boolean;
     /**
      * Test if shape1 fully contains shape2.
      * @param shape1 - Containing shape (must be part of a body).
      * @param shape2 - Contained shape (must be part of a body).
      * @returns True if shape1 contains shape2.
      */
-    static contains(shape1: Any$t, shape2: Any$t): boolean;
+    static contains(shape1: Any$v, shape2: Any$v): boolean;
 }
 
 /**
@@ -820,15 +820,15 @@ declare class NapeList<T> implements Iterable<T> {
     at(index: number): T;
     /** Add an element to the list. */
     add(item: T & {
-        _inner: NapeInner;
+        _inner?: NapeInner;
     }): void;
     /** Remove an element from the list. */
     remove(item: T & {
-        _inner: NapeInner;
+        _inner?: NapeInner;
     }): void;
     /** Check if the list contains an element. */
     has(item: T & {
-        _inner: NapeInner;
+        _inner?: NapeInner;
     }): boolean;
     /** Remove all elements. */
     clear(): void;
@@ -836,7 +836,7 @@ declare class NapeList<T> implements Iterable<T> {
     get empty(): boolean;
     /** Push an element to the end. */
     push(item: T & {
-        _inner: NapeInner;
+        _inner?: NapeInner;
     }): void;
     /** Pop the last element. */
     pop(): T;
@@ -844,7 +844,7 @@ declare class NapeList<T> implements Iterable<T> {
     shift(): T;
     /** Unshift an element to the front. */
     unshift(item: T & {
-        _inner: NapeInner;
+        _inner?: NapeInner;
     }): void;
     /** Iterate over all elements. */
     [Symbol.iterator](): Iterator<T>;
@@ -863,7 +863,7 @@ declare class NapeList<T> implements Iterable<T> {
  *
  * Converted from nape-compiled.js lines 87523–87601, 135477–135481.
  */
-type Any$s = any;
+type Any$u = any;
 declare class ZPP_Material {
     static zpp_pool: ZPP_Material | null;
     static WAKE: number;
@@ -876,27 +876,27 @@ declare class ZPP_Material {
      * _nape  = the `nape` public namespace (for wrapper creation)
      * _zpp   = the `zpp_nape` internal namespace (for ZNPList_ZPP_Shape)
      */
-    static _nape: Any$s;
-    static _zpp: Any$s;
+    static _nape: Any$u;
+    static _zpp: Any$u;
     /**
      * Wrapper factory callback, registered by the modernized Material class.
      * When set, wrapper() uses this instead of creating a compiled Material.
      */
-    static _wrapFn: ((zpp: ZPP_Material) => Any$s) | null;
+    static _wrapFn: ((zpp: ZPP_Material) => Any$u) | null;
     elasticity: number;
     dynamicFriction: number;
     staticFriction: number;
     density: number;
     rollingFriction: number;
-    shapes: Any$s;
-    wrap_shapes: Any$s;
-    outer: Any$s;
-    userData: Any$s;
+    shapes: Any$u;
+    wrap_shapes: Any$u;
+    outer: Any$u;
+    userData: Any$u;
     next: ZPP_Material | null;
-    __class__: Any$s;
+    __class__: Any$u;
     constructor();
     /** Create/return the public nape.phys.Material wrapper for this internal object. */
-    wrapper(): Any$s;
+    wrapper(): Any$u;
     /** Called when this object is returned to the pool. */
     free(): void;
     /** Called when this object is taken from the pool. */
@@ -904,9 +904,9 @@ declare class ZPP_Material {
     /** Initialize the shapes list (called during feature construction). */
     feature_cons(): void;
     /** Register a shape that uses this material. */
-    addShape(shape: Any$s): void;
+    addShape(shape: Any$u): void;
     /** Unregister a shape that no longer uses this material. */
-    remShape(shape: Any$s): void;
+    remShape(shape: Any$u): void;
     /** Create a copy with the same property values. */
     copy(): ZPP_Material;
     /** Copy all property values from another ZPP_Material. */
@@ -966,36 +966,36 @@ declare class Material {
  *
  * Converted from nape-compiled.js lines 87335–87523, 135403.
  */
-type Any$r = any;
+type Any$t = any;
 declare class ZPP_FluidProperties {
     static zpp_pool: ZPP_FluidProperties | null;
     static __name__: string[];
-    static _nape: Any$r;
-    static _zpp: Any$r;
-    static _wrapFn: ((zpp: ZPP_FluidProperties) => Any$r) | null;
+    static _nape: Any$t;
+    static _zpp: Any$t;
+    static _wrapFn: ((zpp: ZPP_FluidProperties) => Any$t) | null;
     viscosity: number;
     density: number;
     gravityx: number;
     gravityy: number;
-    wrap_gravity: Any$r;
-    shapes: Any$r;
-    wrap_shapes: Any$r;
-    outer: Any$r;
-    userData: Any$r;
+    wrap_gravity: Any$t;
+    shapes: Any$t;
+    wrap_shapes: Any$t;
+    outer: Any$t;
+    userData: Any$t;
     next: ZPP_FluidProperties | null;
-    __class__: Any$r;
+    __class__: Any$t;
     constructor();
     /** Create/return the public nape.phys.FluidProperties wrapper. */
-    wrapper(): Any$r;
+    wrapper(): Any$t;
     free(): void;
     alloc(): void;
     feature_cons(): void;
-    addShape(shape: Any$r): void;
-    remShape(shape: Any$r): void;
+    addShape(shape: Any$t): void;
+    remShape(shape: Any$t): void;
     /** Copy with object pooling. */
     copy(): ZPP_FluidProperties;
     /** Called when gravity Vec2 wrapper is invalidated (user set new gravity). */
-    gravity_invalidate(x: Any$r): void;
+    gravity_invalidate(x: Any$t): void;
     /** Sync the gravity Vec2 wrapper with internal values. */
     gravity_validate(): void;
     /** Lazily create and return the gravity Vec2 wrapper. */
@@ -1046,33 +1046,33 @@ declare class FluidProperties {
  *
  * Converted from nape-compiled.js lines 63255–63366, 135329.
  */
-type Any$q = any;
+type Any$s = any;
 declare class ZPP_InteractionFilter {
     static zpp_pool: ZPP_InteractionFilter | null;
     static __name__: string[];
-    static _nape: Any$q;
-    static _zpp: Any$q;
-    static _wrapFn: ((zpp: ZPP_InteractionFilter) => Any$q) | null;
+    static _nape: Any$s;
+    static _zpp: Any$s;
+    static _wrapFn: ((zpp: ZPP_InteractionFilter) => Any$s) | null;
     collisionGroup: number;
     collisionMask: number;
     sensorGroup: number;
     sensorMask: number;
     fluidGroup: number;
     fluidMask: number;
-    shapes: Any$q;
-    wrap_shapes: Any$q;
-    outer: Any$q;
-    userData: Any$q;
+    shapes: Any$s;
+    wrap_shapes: Any$s;
+    outer: Any$s;
+    userData: Any$s;
     next: ZPP_InteractionFilter | null;
-    __class__: Any$q;
+    __class__: Any$s;
     constructor();
     /** Create/return the public nape.dynamics.InteractionFilter wrapper. */
-    wrapper(): Any$q;
+    wrapper(): Any$s;
     free(): void;
     alloc(): void;
     feature_cons(): void;
-    addShape(shape: Any$q): void;
-    remShape(shape: Any$q): void;
+    addShape(shape: Any$s): void;
+    remShape(shape: Any$s): void;
     /** Create a copy with object pooling. */
     copy(): ZPP_InteractionFilter;
     /** Test whether two filters allow collision between their shapes. */
@@ -1136,22 +1136,22 @@ declare class InteractionFilter {
  *
  * Converted from nape-compiled.js lines 63367–63463, 135330–135331.
  */
-type Any$p = any;
+type Any$r = any;
 declare class ZPP_InteractionGroup {
     static SHAPE: number;
     static BODY: number;
     static __name__: string[];
-    static _zpp: Any$p;
-    static _wrapFn: ((zpp: ZPP_InteractionGroup) => Any$p) | null;
-    outer: Any$p;
+    static _zpp: Any$r;
+    static _wrapFn: ((zpp: ZPP_InteractionGroup) => Any$r) | null;
+    outer: Any$r;
     ignore: boolean;
     group: ZPP_InteractionGroup | null;
-    groups: Any$p;
-    wrap_groups: Any$p;
-    interactors: Any$p;
-    wrap_interactors: Any$p;
+    groups: Any$r;
+    wrap_groups: Any$r;
+    interactors: Any$r;
+    wrap_interactors: Any$r;
     depth: number;
-    __class__: Any$p;
+    __class__: Any$r;
     constructor();
     /** Set or change the parent group. */
     setGroup(group: ZPP_InteractionGroup | null): void;
@@ -1162,9 +1162,9 @@ declare class ZPP_InteractionGroup {
     /** Remove a child group. */
     remGroup(group: ZPP_InteractionGroup): void;
     /** Register an interactor in this group. */
-    addInteractor(intx: Any$p): void;
+    addInteractor(intx: Any$r): void;
     /** Unregister an interactor from this group. */
-    remInteractor(intx: Any$p, flag?: number): void;
+    remInteractor(intx: Any$r, flag?: number): void;
 }
 
 /**
@@ -1371,28 +1371,28 @@ declare class Constraint {
  *
  * Converted from nape-compiled.js lines 27259–27304, 112053–112139.
  */
-type Any$o = any;
+type Any$q = any;
 declare class ZPP_Listener {
     static __name__: string[];
-    static _nape: Any$o;
-    static _zpp: Any$o;
+    static _nape: Any$q;
+    static _zpp: Any$q;
     static internal: boolean;
-    static types: Any$o[];
-    static events: Any$o[];
-    space: Any$o;
-    interaction: Any$o;
-    constraint: Any$o;
-    body: Any$o;
+    static types: Any$q[];
+    static events: Any$q[];
+    space: Any$q;
+    interaction: Any$q;
+    constraint: Any$q;
+    body: Any$q;
     precedence: number;
     event: number;
     type: number;
     id: number;
-    outer: Any$o;
-    __class__: Any$o;
+    outer: Any$q;
+    __class__: Any$q;
     constructor();
     /** Sort comparator: higher precedence first, then by id descending. */
     static setlt(a: ZPP_Listener, b: ZPP_Listener): boolean;
-    swapEvent(_event: number): void;
+    swapEvent(_event?: number): void;
     invalidate_precedence(): void;
     addedToSpace(): void;
     removedFromSpace(): void;
@@ -1464,20 +1464,20 @@ declare class ListenerType {
  * Fully modernized from nape-compiled.js lines 231–433.
  */
 
-type Any$n = any;
+type Any$p = any;
 declare class Listener {
     static __name__: string[];
     zpp_inner: ZPP_Listener;
-    get _inner(): Any$n;
+    get _inner(): Any$p;
     constructor();
-    static _wrap(inner: Any$n): Listener;
+    static _wrap(inner: Any$p): Listener;
     get type(): ListenerType;
     get event(): CbEvent;
     set event(event: CbEvent);
     get precedence(): number;
     set precedence(precedence: number);
     get space(): Space | null;
-    set space(space: Space | Any$n | null);
+    set space(space: Space | Any$p | null);
     toString(): string;
 }
 
@@ -1554,10 +1554,274 @@ declare class BodyType {
     toString(): string;
 }
 
+/**
+ * ZPP_Body — Internal body representation for the nape physics engine.
+ *
+ * Core physics body managing position, velocity, mass, inertia, shapes, and
+ * CCD (continuous collision detection) sweep integration.
+ * Extends ZPP_Interactor (still in compiled code — methods copied at init time).
+ *
+ * Converted from nape-compiled.js lines 52431–54547.
+ */
+
+type Any$o = any;
+declare class ZPP_Body {
+    static __name__: string[];
+    static __super__: Any$o;
+    /**
+     * Namespace references, set by the compiled module after import.
+     * _nape = the `nape` public namespace
+     * _zpp = the `zpp_nape` internal namespace
+     */
+    static _nape: Any$o;
+    static _zpp: Any$o;
+    static types: Any$o[];
+    static bodystack: Any$o;
+    static bodyset: Any$o;
+    static cur_graph_depth: number;
+    static bodysetlt(a: Any$o, b: Any$o): boolean;
+    static __static(): Any$o;
+    outer_i: Any$o;
+    id: number;
+    userData: Any$o;
+    ishape: Any$o;
+    ibody: Any$o;
+    icompound: Any$o;
+    wrap_cbTypes: Any$o;
+    cbSet: Any$o;
+    cbTypes: Any$o;
+    group: Any$o;
+    cbsets: Any$o;
+    outer: Any$o;
+    world: boolean;
+    type: number;
+    compound: Any$o;
+    shapes: Any$o;
+    wrap_shapes: Any$o;
+    space: Any$o;
+    arbiters: Any$o;
+    wrap_arbiters: Any$o;
+    constraints: Any$o;
+    wrap_constraints: Any$o;
+    component: Any$o;
+    graph_depth: number;
+    sweepTime: number;
+    sweep_angvel: number;
+    sweepFrozen: boolean;
+    sweepRadius: number;
+    bullet: boolean;
+    bulletEnabled: boolean;
+    disableCCD: boolean;
+    pre_posx: number;
+    pre_posy: number;
+    posx: number;
+    posy: number;
+    wrap_pos: Any$o;
+    velx: number;
+    vely: number;
+    wrap_vel: Any$o;
+    forcex: number;
+    forcey: number;
+    wrap_force: Any$o;
+    kinvelx: number;
+    kinvely: number;
+    wrap_kinvel: Any$o;
+    svelx: number;
+    svely: number;
+    wrap_svel: Any$o;
+    wrapcvel: Any$o;
+    angvel: number;
+    torque: number;
+    kinangvel: number;
+    pre_rot: number;
+    rot: number;
+    axisx: number;
+    axisy: number;
+    zip_axis: boolean;
+    kinematicDelaySleep: boolean;
+    mass: number;
+    zip_mass: boolean;
+    massMode: number;
+    imass: number;
+    smass: number;
+    cmass: number;
+    nomove: boolean;
+    gravMass: number;
+    zip_gravMass: boolean;
+    gravMassMode: number;
+    gravMassScale: number;
+    zip_gravMassScale: boolean;
+    inertiaMode: number;
+    inertia: number;
+    zip_inertia: boolean;
+    cinertia: number;
+    iinertia: number;
+    sinertia: number;
+    norotate: boolean;
+    aabb: ZPP_AABB;
+    zip_aabb: boolean;
+    localCOMx: number;
+    localCOMy: number;
+    zip_localCOM: boolean;
+    worldCOMx: number;
+    worldCOMy: number;
+    zip_worldCOM: boolean;
+    wrap_localCOM: Any$o;
+    wrap_worldCOM: Any$o;
+    __class__: Any$o;
+    constructor();
+    isStatic(): boolean;
+    isDynamic(): boolean;
+    isKinematic(): boolean;
+    invalidate_type(): void;
+    invalidate_shapes(): void;
+    init_bodysetlist(): void;
+    connectedBodies_cont(b: Any$o): void;
+    connectedBodies(depth: number, output: Any$o): Any$o;
+    interactingBodies(type: number, output: Any$o): Any$o;
+    atRest(dt: number): boolean;
+    refreshArbiters(): void;
+    sweepIntegrate(dt: number): void;
+    sweepValidate(s: Any$o): void;
+    invalidate_pos(): void;
+    pos_invalidate(pos: Any$o): void;
+    pos_validate(): void;
+    vel_invalidate(vel: Any$o): void;
+    vel_validate(): void;
+    kinvel_invalidate(vel: Any$o): void;
+    kinvel_validate(): void;
+    svel_invalidate(vel: Any$o): void;
+    svel_validate(): void;
+    force_invalidate(force: Any$o): void;
+    force_validate(): void;
+    private _setupVec2Wrapper;
+    setupPosition(): void;
+    setupVelocity(): void;
+    setupkinvel(): void;
+    setupsvel(): void;
+    setupForce(): void;
+    cvel_validate(): void;
+    setup_cvel(): void;
+    invalidate_rot(): void;
+    validate_axis(): void;
+    quick_validate_axis(): void;
+    delta_rot(dr: number): void;
+    invalidate_mass(): void;
+    validate_mass(): void;
+    invalidate_gravMass(): void;
+    validate_gravMass(): void;
+    invalidate_gravMassScale(): void;
+    validate_gravMassScale(): void;
+    invalidate_inertia(): void;
+    validate_inertia(): void;
+    invalidate_wake(): void;
+    invalidate_aabb(): void;
+    validate_aabb(): void;
+    private _validateCircleAABB;
+    private _validatePolygonAABB;
+    aabb_validate(): void;
+    invalidate_localCOM(): void;
+    invalidate_worldCOM(): void;
+    private _computePolygonLocalCOM;
+    validate_localCOM(): void;
+    validate_worldCOM(): void;
+    getlocalCOM(): void;
+    getworldCOM(): void;
+    __immutable_midstep(): void;
+    clear(): void;
+    shapes_adder(s: Any$o): boolean;
+    shapes_subber(s: Any$o): void;
+    shapes_invalidate(_param: Any$o): void;
+    shapes_modifiable(): void;
+    addedToSpace(): void;
+    removedFromSpace(): void;
+    private _removeArbiterFromList;
+    copy(): Any$o;
+    wake: () => void;
+    __iaddedToSpace: () => void;
+    __iremovedFromSpace: () => void;
+    immutable_midstep: (name: string) => void;
+    copyto: (ret: Any$o) => void;
+    insert_cbtype: (cb: Any$o) => void;
+    alloc_cbSet: () => void;
+    dealloc_cbSet: () => void;
+    setupcbTypes: () => void;
+    immutable_cbTypes: () => void;
+    wrap_cbTypes_subber: (pcb: Any$o) => void;
+    wrap_cbTypes_adder: (cb: Any$o) => void;
+    setGroup: (group: Any$o) => void;
+    lookup_group: () => Any$o;
+    getSpace: () => Any$o;
+    isShape: () => boolean;
+    isBody: () => boolean;
+    isCompound: () => boolean;
+    static _initialized: boolean;
+    static _init(zpp: Any$o, nape: Any$o): void;
+}
+
+type Any$n = any;
 /**
  * A rigid body in the physics simulation.
+ *
+ * Fully modernized — uses ZPP_Body directly (extracted to TypeScript).
  */
 declare class Body extends Interactor {
+    static __name__: string[];
+    static __super__: Any$n;
+    /** Direct access to the extracted internal ZPP_Body. */
+    zpp_inner: ZPP_Body;
+    debugDraw: boolean;
+    /** @internal */ set_type: (type: Any$n) => Any$n;
+    /** @internal */ set_position: (position: Any$n) => Any$n;
+    /** @internal */ set_rotation: (rotation: number) => number;
+    /** @internal */ set_velocity: (velocity: Any$n) => Any$n;
+    /** @internal */ set_angularVel: (angularVel: number) => number;
+    /** @internal */ set_kinematicVel: (kinematicVel: Any$n) => Any$n;
+    /** @internal */ set_kinAngVel: (kinAngVel: number) => number;
+    /** @internal */ set_surfaceVel: (surfaceVel: Any$n) => Any$n;
+    /** @internal */ set_force: (force: Any$n) => Any$n;
+    /** @internal */ set_torque: (torque: number) => number;
+    /** @internal */ get_mass: () => number;
+    /** @internal */ set_mass: (mass: number) => number;
+    /** @internal */ get_inertia: () => number;
+    /** @internal */ set_inertia: (inertia: number) => number;
+    /** @internal */ get_gravMass: () => number;
+    /** @internal */ set_gravMass: (gravMass: number) => number;
+    /** @internal */ get_gravMassScale: () => number;
+    /** @internal */ set_gravMassScale: (gravMassScale: number) => number;
+    /** @internal */ set_allowMovement: (v: boolean) => boolean;
+    /** @internal */ set_allowRotation: (v: boolean) => boolean;
+    /** @internal */ set_space: (space: Any$n) => Any$n;
+    /** @internal */ set_compound: (compound: Any$n) => Any$n;
+    /** @internal */ get_localCOM: () => Any$n;
+    /** @internal */ get_worldCOM: () => Any$n;
+    /** @internal */ integrate: (deltaTime: number) => Any$n;
+    /** @internal */ applyImpulse: (impulse: Any$n, pos?: Any$n, sleepable?: boolean) => void;
+    /** @internal */ applyAngularImpulse: (impulse: number, sleepable?: boolean) => void;
+    /** @internal */ setVelocityFromTarget: (targetPosition: Any$n, targetRotation: number, deltaTime: number) => Any$n;
+    /** @internal */ localPointToWorld: (point: Any$n, weak?: boolean) => Any$n;
+    /** @internal */ worldPointToLocal: (point: Any$n, weak?: boolean) => Any$n;
+    /** @internal */ localVectorToWorld: (vector: Any$n, weak?: boolean) => Any$n;
+    /** @internal */ worldVectorToLocal: (vector: Any$n, weak?: boolean) => Any$n;
+    /** @internal */ translateShapes: (translation: Any$n) => void;
+    /** @internal */ rotateShapes: (angle: number) => void;
+    /** @internal */ scaleShapes: (scaleX: number, scaleY: number) => void;
+    /** @internal */ align: () => void;
+    /** @internal */ rotate: (centre: Any$n, angle: number) => void;
+    /** @internal */ setShapeMaterials: (material: Any$n) => void;
+    /** @internal */ setShapeFilters: (filter: Any$n) => void;
+    /** @internal */ setShapeFluidProperties: (fluidProperties: Any$n) => void;
+    /** @internal */ contains: (point: Any$n) => boolean;
+    /** @internal */ crushFactor: () => number;
+    /** @internal */ connectedBodies: (depth?: number, output?: Any$n) => Any$n;
+    /** @internal */ interactingBodies: (type?: Any$n, depth?: number, output?: Any$n) => Any$n;
+    /** @internal */ get_massMode: () => Any$n;
+    /** @internal */ set_massMode: (mode: Any$n) => Any$n;
+    /** @internal */ get_inertiaMode: () => Any$n;
+    /** @internal */ set_inertiaMode: (mode: Any$n) => Any$n;
+    /** @internal */ get_gravMassMode: () => Any$n;
+    /** @internal */ set_gravMassMode: (mode: Any$n) => Any$n;
+    /** @internal */ _toString: () => string;
     constructor(type?: BodyType, position?: Vec2);
     /** @internal */
     static _wrap(inner: NapeInner): Body;
@@ -1606,34 +1870,40 @@ declare class Body extends Interactor {
     get shapes(): NapeList<Shape>;
     get space(): Space;
     set space(value: Space | null);
-    get compound(): NapeInner;
-    set compound(value: {
-        _inner: NapeInner;
-    } | null);
+    get compound(): Any$n;
+    set compound(value: Any$n);
     get bounds(): AABB;
     get constraintVelocity(): Vec2;
     get localCOM(): Vec2;
     get worldCOM(): Vec2;
-    integrate(deltaTime: number): void;
-    applyImpulse(impulse: Vec2, pos?: Vec2, sleepable?: boolean): void;
-    applyAngularImpulse(impulse: number, sleepable?: boolean): void;
-    setVelocityFromTarget(targetPosition: Vec2, targetRotation: number, deltaTime: number): void;
-    localPointToWorld(point: Vec2, weak?: boolean): Vec2;
-    worldPointToLocal(point: Vec2, weak?: boolean): Vec2;
-    localVectorToWorld(vector: Vec2, weak?: boolean): Vec2;
-    worldVectorToLocal(vector: Vec2, weak?: boolean): Vec2;
-    translateShapes(translation: Vec2): void;
-    rotateShapes(angle: number): void;
-    scaleShapes(scaleX: number, scaleY: number): void;
-    align(): void;
-    rotate(centre: Vec2, angle: number): void;
-    setShapeMaterials(material: Material): void;
-    setShapeFilters(filter: InteractionFilter): void;
-    setShapeFluidProperties(fluidProperties: FluidProperties): void;
-    contains(point: Vec2): boolean;
-    crushFactor(): number;
     copy(): Body;
     toString(): string;
+    get_type(): Any$n;
+    get_shapes(): Any$n;
+    get_isBullet(): boolean;
+    set_isBullet(v: boolean): boolean;
+    get_disableCCD(): boolean;
+    set_disableCCD(v: boolean): boolean;
+    get_position(): Any$n;
+    get_velocity(): Any$n;
+    get_rotation(): number;
+    get_angularVel(): number;
+    get_kinematicVel(): Any$n;
+    get_kinAngVel(): number;
+    get_surfaceVel(): Any$n;
+    get_force(): Any$n;
+    get_torque(): number;
+    get_bounds(): Any$n;
+    get_constraintVelocity(): Any$n;
+    get_constraintMass(): number;
+    get_constraintInertia(): number;
+    get_allowMovement(): boolean;
+    get_allowRotation(): boolean;
+    get_isSleeping(): boolean;
+    get_compound(): Any$n;
+    get_space(): Any$n;
+    get_arbiters(): Any$n;
+    get_constraints(): Any$n;
 }
 
 /**
@@ -1972,7 +2242,7 @@ declare class Arbiter {
      * Total impulse of this arbiter. Base implementation returns Vec3(0,0,0).
      * Overridden by CollisionArbiter and FluidArbiter.
      */
-    totalImpulse(body?: Any$k, freshOnly?: boolean): Vec3;
+    totalImpulse(body?: Any$k, _freshOnly?: boolean): Vec3;
     toString(): string;
     /** @internal */
     protected _activeCheck(): void;
@@ -2059,7 +2329,7 @@ declare class FluidArbiter extends Arbiter {
     /** Drag impulse applied by this fluid arbiter. */
     dragImpulse(body?: Any$i): Vec3;
     /** Total impulse (buoyancy + drag). */
-    totalImpulse(body?: Any$i, freshOnly?: boolean): Vec3;
+    totalImpulse(body?: Any$i, _freshOnly?: boolean): Vec3;
 }
 
 type Any$h = any;