melonjs 20.2.0 → 20.4.0

package/build/physics/builtin/detector.d.ts

@@ -14,286 +14,6 @@ declare class Detector {
      * @type {ResponseObject}
      */
     response: ResponseObject;
-    /**
-     * Pairs (key → [renderableA, renderableB]) that were colliding in
-     * the previous step. Diffed against `_frameSeen` at end of step
-     * to fire `onCollisionEnd` for pairs that just separated.
-     * @ignore
-     */
-    _activePairs: Map<any, any>;
-    /**
-     * Pairs seen during the current step. Built up as the per-object
-     * `collisions()` calls run; consumed by `endFrame()`.
-     * @ignore
-     */
-    _frameSeen: Map<any, any>;
-    /**
-     * Two-slot pool of "symmetric view" objects passed to the new
-     * collision lifecycle handlers (`onCollisionStart` /
-     * `onCollisionActive` / `onCollisionEnd`). Each view carries the
-     * receiver-symmetric form: `a` = receiver, `b` = partner,
-     * `normal` = MTV of receiver, `depth` = penetration scalar,
-     * plus the SAT-legacy `overlapN` / `overlapV` / `overlap` fields
-     * flipped to match the same convention.
-     *
-     * Two slots are needed because both views may be live at the
-     * same time (one handler can dispatch into the other through
-     * world mutation). Slot 0 is used for the original-a-side
-     * dispatch, slot 1 for the original-b-side.
-     * @ignore
-     */
-    _symViews: {
-        a: null;
-        b: null;
-        overlap: number;
-        overlapN: {
-            x: number;
-            y: number;
-        };
-        overlapV: {
-            x: number;
-            y: number;
-        };
-        normal: {
-            x: number;
-            y: number;
-        };
-        depth: number;
-        overlapNZ: number;
-        overlapZ: number;
-        normalZ: number;
-        indexShapeA: number;
-        indexShapeB: number;
-        isTriggerContact: boolean;
-    }[];
-    /**
-     * Shape-pair contacts that were overlapping in the previous step (#1596).
-     * Keyed by `_shapePairKey`, diffed against `_frameShapeSeen` in
-     * `endFrame()` to fire `onShapeCollisionEnd`. Populated only when someone
-     * subscribes, so a game that does not use the feature keeps these empty.
-     * @ignore
-     */
-    _activeShapePairs: Map<any, any>;
-    /** @ignore */
-    _frameShapeSeen: Map<any, any>;
-    /**
-     * Two-slot pool of receiver-symmetric shape-contact views, mirroring
-     * `_symViews`: `a` is the receiver, `b` the partner, and `shapeA` /
-     * `indexShapeA` are always the RECEIVER's shape. Two slots because both
-     * sides may be live at once when a handler mutates the world.
-     * @ignore
-     */
-    _shapeViews: {
-        a: null;
-        b: null;
-        shapeA: null;
-        shapeB: null;
-        overlap: number;
-        overlapN: {
-            x: number;
-            y: number;
-        };
-        overlapV: {
-            x: number;
-            y: number;
-        };
-        normal: {
-            x: number;
-            y: number;
-        };
-        depth: number;
-        overlapNZ: number;
-        overlapZ: number;
-        normalZ: number;
-        indexShapeA: number;
-        indexShapeB: number;
-        isTrigger: boolean;
-    }[];
-    /**
-     * The pair currently being enumerated, so the contact callback can be a
-     * single pre-bound function rather than a closure allocated per body pair
-     * per frame.
-     * @ignore
-     */
-    _contactObjA: Container | Renderable | Entity | Sprite | NineSliceSprite | null;
-    _contactObjB: any;
-    /** @ignore */
-    _onShapeContact: (shapeA: any, indexA: any, shapeB: any, indexB: any, isTrigger: any, res: any) => void;
-    /**
-     * Populate one of the pooled symmetric views from a SAT response.
-     * `flip=false` builds the view for `response.a`'s side (legacy
-     * fields kept as-is, `normal = -overlapN` = MTV of original a).
-     * `flip=true` builds it for `response.b`'s side: `a` / `b` swap,
-     * `overlapN` / `overlapV` negated, `normal = +overlapN` (the MTV
-     * of original b).
-     * @ignore
-     */
-    _fillSymView(slot: any, satResponse: any, flip: any): {
-        a: null;
-        b: null;
-        overlap: number;
-        overlapN: {
-            x: number;
-            y: number;
-        };
-        overlapV: {
-            x: number;
-            y: number;
-        };
-        normal: {
-            x: number;
-            y: number;
-        };
-        depth: number;
-        overlapNZ: number;
-        overlapZ: number;
-        normalZ: number;
-        indexShapeA: number;
-        indexShapeB: number;
-        isTriggerContact: boolean;
-    };
-    /**
-     * Called by the adapter at the start of a physics step. Resets the
-     * "seen this frame" set so the end-of-step diff can fire
-     * `onCollisionEnd` for pairs that no longer overlap.
-     * @ignore
-     */
-    beginFrame(): void;
-    /**
-     * Called by the adapter at the end of a physics step. Diffs the
-     * "seen this frame" set against the previous-frame active pairs:
-     *   - pairs in active but not seen → fire onCollisionEnd
-     *   - swap active ← seen for the next step's diff
-     * @ignore
-     */
-    endFrame(): void;
-    /**
-     * Identity-only shape-contact view for `onShapeCollisionEnd`: the shapes
-     * have separated, so every geometric field is zeroed rather than left
-     * holding the last overlap, which would read as a live contact.
-     * @ignore
-     */
-    _fillEndedView(slot: any, receiver: any, partner: any, ownShape: any, otherShape: any): {
-        a: null;
-        b: null;
-        shapeA: null;
-        shapeB: null;
-        overlap: number;
-        overlapN: {
-            x: number;
-            y: number;
-        };
-        overlapV: {
-            x: number;
-            y: number;
-        };
-        normal: {
-            x: number;
-            y: number;
-        };
-        depth: number;
-        overlapNZ: number;
-        overlapZ: number;
-        normalZ: number;
-        indexShapeA: number;
-        indexShapeB: number;
-        isTrigger: boolean;
-    };
-    /**
-     * Build a stable order-independent key for a pair of renderables,
-     * using their GUID. Returns undefined if either lacks a GUID (defensive
-     * — detached or pool-recycled objects mid-step).
-     * @ignore
-     */
-    _pairKey(a: any, b: any): string | undefined;
-    /**
-     * Re-run the narrowphase for a remembered shape pair and repopulate
-     * `response` from it.
-     *
-     * The scan clears `response` on every test, so whichever pair won has to be
-     * measured again before handlers and the solver read it. Indices are looked
-     * up here rather than carried from the scan because an enumeration handler
-     * may have mutated either body in between: `removeShape()` re-indexes, and
-     * `destroy()` empties the array outright. A shape that is no longer on its
-     * body has no contact left to resolve, so this reports failure and the
-     * caller falls through instead of throwing.
-     * @ignore
-     * @returns {boolean} true when the pair was re-measured
-     */
-    _retest(bodyA: any, bodyB: any, shapeA: any, shapeB: any, response: any): boolean;
-    /**
-     * Stable, order-independent key for one SHAPE pair (#1596).
-     *
-     * The renderable GUIDs order the pair, exactly as `_pairKey` does, and the
-     * two shape ids MUST swap alongside them: keying `guidA|guidB|idA|idB`
-     * without that swap gives the same physical contact two different keys
-     * depending on which object the outer loop visited first, and the contact
-     * would then End and Start every step.
-     *
-     * Shape identity is `_contactId`, stamped once in `Body#addShape` and never
-     * derived from array position, because `removeShape()` re-indexes every
-     * surviving shape.
-     * @ignore
-     */
-    _shapePairKey(a: any, b: any, shapeA: any, shapeB: any): string | undefined;
-    /**
-     * True when an object subscribes to any shape-contact event.
-     *
-     * This is the opt-in gate: `collides()` only runs the full M x N scan when
-     * this returns true for one of the two objects, so an application that
-     * never declares these handlers performs exactly the narrowphase work it
-     * did before the feature existed.
-     * @ignore
-     */
-    _wantsShapeContacts(obj: any): boolean;
-    /**
-     * Populate a pooled shape-contact view, same flip convention as
-     * `_fillSymView`: `flip=false` builds the view for `response.a`'s side,
-     * `flip=true` for `response.b`'s, so `shapeA` is always the receiver's.
-     * @ignore
-     */
-    _fillShapeView(slot: any, satResponse: any, flip: any, shapeA: any, shapeB: any, isTrigger: any): {
-        a: null;
-        b: null;
-        shapeA: null;
-        shapeB: null;
-        overlap: number;
-        overlapN: {
-            x: number;
-            y: number;
-        };
-        overlapV: {
-            x: number;
-            y: number;
-        };
-        normal: {
-            x: number;
-            y: number;
-        };
-        depth: number;
-        overlapNZ: number;
-        overlapZ: number;
-        normalZ: number;
-        indexShapeA: number;
-        indexShapeB: number;
-        isTrigger: boolean;
-    };
-    /**
-     * Fire Start / Active for one overlapping shape pair. Called back from
-     * `collides()` once per pair, in scan order.
-     * @ignore
-     */
-    _dispatchShapeContact(shapeA: any, shapeB: any, isTrigger: any, response: any): void;
-    /**
-     * Drop the references the enumeration callback reads.
-     *
-     * They are plain fields rather than a per-pair closure so the hot path
-     * allocates nothing, which means they outlive the pair unless cleared, and
-     * would hold two renderables (and everything they reach) against garbage
-     * collection until the next subscribed pair happened to overwrite them.
-     * @ignore
-     */
-    _clearContactPair(): void;
     /**
      * determine if two objects should collide (based on both respective objects body collision mask and type).<br>
      * you can redefine this function if you need any specific rules over what should collide with what.
@@ -309,38 +29,6 @@ declare class Detector {
      * @returns {boolean} true if colliding
      */
     collides(bodyA: Body, bodyB: Body, response?: ResponseObject, onContact?: undefined): boolean;
-    /**
-     * find all the collisions for the specified object using a broadphase algorithm
-     * @ignore
-     * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} objA - object to be tested for collision
-     * @returns {boolean} in case of collision, false otherwise
-     */
-    collisions(objA: Renderable | Container | Entity | Sprite | NineSliceSprite): boolean;
-    /**
-     * Checks for object colliding with the given line
-     * @ignore
-     * @param {Line} line - line to be tested for collision
-     * @param {Array.<Renderable>} [result] - a user defined array that will be populated with intersecting physic objects.
-     * @returns {Array.<Renderable>} an array of intersecting physic objects
-     * @example
-     *    // define a line accross the viewport
-     *    let ray = new Line(
-     *        // absolute position of the line
-     *        0, 0, [
-     *        // starting point relative to the initial position
-     *        new Vector2d(0, 0),
-     *        // ending point
-     *        new Vector2d(app.viewport.width, app.viewport.height)
-     *    ]);
-     *
-     *    // check for collition
-     *    result = me.collision.rayCast(ray);
-     *
-     *    if (result.length > 0) {
-     *        // ...
-     *    }
-     */
-    rayCast(line: Line, result?: Array<Renderable>): Array<Renderable>;
 }
 import type Container from "../../renderable/container.js";
 import ResponseObject from "../response.js";

package/build/physics/builtin/detector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"detector.d.ts","sourceRoot":"","sources":["../../../src/physics/builtin/detector.js"],"names":[],"mappings":";AAyEA;;GAEG;AACH;IACC;;OAEG;IACH,mBAFW,SAAS,EA2JnB;IAvJA,iBAAkB;IAElB;;;;OAIG;IACH,UAFU,cAAc,CAEY;IAEpC;;;;;OAKG;IACH,4BAA6B;IAC7B;;;;OAIG;IACH,0BAA2B;IAC3B;;;;;;;;;;;;;;OAcG;IACH;;;;;;;;;;;;;;;;;;;;;;;QAsCC;IAED;;;;;;OAMG;IACH,iCAAkC;IAClC,cAAc;IACd,+BAAgC;IAEhC;;;;;;OAMG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;QAmCC;IAED;;;;;OAKG;IACH,gFAAwB;IACxB,kBAAwB;IACxB,cAAc;IACd,wGASC;IAGF;;;;;;;;OAQG;IACH;;;;;;;;;;;;;;;;;;;;;;;MA0CC;IAED;;;;;OAKG;IACH,mBAGC;IAED;;;;;;OAMG;IACH,iBA0DC;IAED;;;;;OAKG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;MAsBC;IAED;;;;;OAKG;IACH,6CAOC;IAED;;;;;;;;;;;;;OAaG;IACH,0EAFa,OAAO,CAuBnB;IAED;;;;;;;;;;;;;OAaG;IACH,4EAqBC;IAED;;;;;;;;OAQG;IACH,uCAMC;IAED;;;;;OAKG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;MA2CC;IAED;;;;OAIG;IACH,qFAyCC;IAED;;;;;;;;OAQG;IACH,0BAGC;IAED;;;;;;OAMG;IACH,iBAJW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,KAClD,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,GAChD,OAAO,CAiBnB;IAED;;;;;OAKG;IACH,gBAJW,IAAI,SACJ,IAAI,qDACF,OAAO,CAyJnB;IAED;;;;;OAKG;IACH,iBAHW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,GAChD,OAAO,CA6QnB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,cArBW,IAAI,WACJ,KAAK,CAAE,UAAU,CAAC,GAChB,KAAK,CAAE,UAAU,CAAC,CAqC9B;CACD;2BA9hCyB,+BAA+B;2BA7D9B,gBAAgB;4BA8DhB,gCAAgC;wBAFpC,mCAAmC;wBAGnC,4BAA4B;iCACnB,qCAAqC;0BAC9C,0BAA0B"}
+{"version":3,"file":"detector.d.ts","sourceRoot":"","sources":["../../../src/physics/builtin/detector.js"],"names":[],"mappings":";AA0EA;;GAEG;AACH;IACC;;OAEG;IACH,mBAFW,SAAS,EA2KnB;IAvKA,iBAAkB;IAElB;;;;OAIG;IACH,UAFU,cAAc,CAEY;IAEpC;;;;;;OAMG;IACH,4BAA6B;IAC7B;;;;;OAKG;IACH,0BAA2B;IAC3B;;;;;;;;;;;;;;;OAeG;IACH;;;;;;;;;;;;;;;;;;;;;;;QAsCC;IAED;;;;;;;OAOG;IACH,iCAAkC;IAClC;;;OAGG;IACH,+BAAgC;IAEhC;;;;;;;OAOG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;QAmCC;IAED;;;;;;OAMG;IACH,gFAAwB;IACxB;;;OAGG;IACH,kBAAwB;IACxB;;;OAGG;IACH,wGASC;IAGF;;;;;;;;;OASG;IACH;;;;;;;;;;;;;;;;;;;;;;;MA0CC;IAED;;;;;;OAMG;IACH,mBAGC;IAED;;;;;;;OAOG;IACH,iBA0DC;IAED;;;;;;OAMG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;MAsBC;IAED;;;;;;OAMG;IACH,6CAOC;IAED;;;;;;;;;;;;;;OAcG;IACH,0EAFa,OAAO,CAuBnB;IAED;;;;;;;;;;;;;;OAcG;IACH,4EAqBC;IAED;;;;;;;;;OASG;IACH,uCAMC;IAED;;;;;;OAMG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;MA2CC;IAED;;;;;OAKG;IACH,qFAyCC;IAED;;;;;;;;;OASG;IACH,0BAGC;IAED;;;;;;OAMG;IACH,iBAJW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,KAClD,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,GAChD,OAAO,CAiBnB;IAED;;;;;OAKG;IACH,gBAJW,IAAI,SACJ,IAAI,qDACF,OAAO,CAyJnB;IAED;;;;;;OAMG;IACH,iBAHW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,GAChD,OAAO,CA6QnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,cArBW,IAAI,WACJ,KAAK,CAAE,UAAU,CAAC,GAChB,KAAK,CAAE,UAAU,CAAC,CAqC9B;CACD;2BA3jCyB,+BAA+B;2BA9D9B,gBAAgB;4BA+DhB,gCAAgC;wBAFpC,mCAAmC;wBAGnC,4BAA4B;iCACnB,qCAAqC;0BAC9C,0BAA0B"}

package/build/physics/builtin/sat.d.ts

@@ -1,51 +1,4 @@
-/**
- * Checks whether polygons collide.
- * @ignore
- * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} a - a reference to the object A.
- * @param {Polygon} polyA - a reference to the object A Polygon to be tested
- * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} b - a reference to the object B.
- * @param {Polygon} polyB - a reference to the object B Polygon to be tested
- * @param {Response=} response - Response object (optional) that will be populated if they intersect.
- * @returns {boolean} true if they intersect, false if they don't.
- */
-export function testPolygonPolygon(a: Renderable | Container | Entity | Sprite | NineSliceSprite, polyA: Polygon, b: Renderable | Container | Entity | Sprite | NineSliceSprite, polyB: Polygon, response?: Response | undefined): boolean;
-/**
- * Check if two Ellipse collide.
- * @ignore
- * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} a - a reference to the object A.
- * @param {Ellipse} ellipseA - a reference to the object A Ellipse to be tested
- * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} b - a reference to the object B.
- * @param {Ellipse} ellipseB - a reference to the object B Ellipse to be tested
- * @param {Response=} response - Response object (optional) that will be populated if
- *   the circles intersect.
- * @returns {boolean} true if the circles intersect, false if they don't.
- */
-export function testEllipseEllipse(a: Renderable | Container | Entity | Sprite | NineSliceSprite, ellipseA: Ellipse, b: Renderable | Container | Entity | Sprite | NineSliceSprite, ellipseB: Ellipse, response?: Response | undefined): boolean;
-/**
- * Check if a polygon and an ellipse collide.
- * @ignore
- * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} a - a reference to the object A.
- * @param {Polygon} polyA - a reference to the object A Polygon to be tested
- * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} b - a reference to the object B.
- * @param {Ellipse} ellipseB - a reference to the object B Ellipse to be tested
- * @param {Response=} response - Response object (optional) that will be populated if they intersect.
- * @returns {boolean} true if they intersect, false if they don't.
- */
-export function testPolygonEllipse(a: Renderable | Container | Entity | Sprite | NineSliceSprite, polyA: Polygon, b: Renderable | Container | Entity | Sprite | NineSliceSprite, ellipseB: Ellipse, response?: Response | undefined): boolean;
-/**
- * Check if an ellipse and a polygon collide. <br>
- * **NOTE:** This is slightly less efficient than testPolygonEllipse as it just
- * runs testPolygonEllipse and reverses the response at the end.
- * @ignore
- * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} a - a reference to the object A.
- * @param {Ellipse} ellipseA - a reference to the object A Ellipse to be tested
- * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} b - a reference to the object B.
- * @param {Polygon} polyB - a reference to the object B Polygon to be tested
- * @param {Response=} response - Response object (optional) that will be populated if
- *   they intersect.
- * @returns {boolean} true if they intersect, false if they don't.
- */
-export function testEllipsePolygon(a: Renderable | Container | Entity | Sprite | NineSliceSprite, ellipseA: Ellipse, b: Renderable | Container | Entity | Sprite | NineSliceSprite, polyB: Polygon, response?: Response | undefined): boolean;
+
 import type Renderable from "../../renderable/renderable.js";
 import type Container from "../../renderable/container.js";
 import type Entity from "../../renderable/entity/entity.js";

package/build/physics/builtin/sat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sat.d.ts","sourceRoot":"","sources":["../../../src/physics/builtin/sat.js"],"names":[],"mappings":"AAiNA;;;;;;;;;GASG;AACH,sCAPW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,aACP,QAAQ,YAAC,GACP,OAAO,CA8CnB;AAED;;;;;;;;;;GAUG;AACH,sCARW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,aACP,QAAQ,YAAC,GAEP,OAAO,CAiEnB;AAED;;;;;;;;;GASG;AACH,sCAPW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,aACP,QAAQ,YAAC,GACP,OAAO,CAsKnB;AAED;;;;;;;;;;;;GAYG;AACH,sCARW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,aACP,QAAQ,YAAC,GAEP,OAAO,CAiBnB;4BAvhB0B,gCAAgC;2BADjC,+BAA+B;wBADlC,mCAAmC;wBAGnC,4BAA4B;iCACnB,qCAAqC;6BAC3C,6BAA6B;6BAC7B,6BAA6B"}
+{"version":3,"file":"sat.d.ts","sourceRoot":"","sources":["../../../src/physics/builtin/sat.js"],"names":[],"mappings":"AA2NA;;;;;;;;;;GAUG;AACH,sCAPW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,aACP,QAAQ,YAAC,GACP,OAAO,CA8CnB;AAED;;;;;;;;;;;GAWG;AACH,sCARW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,aACP,QAAQ,YAAC,GAEP,OAAO,CAiEnB;AAED;;;;;;;;;;GAUG;AACH,sCAPW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,aACP,QAAQ,YAAC,GACP,OAAO,CAsKnB;AAED;;;;;;;;;;;;;GAaG;AACH,sCARW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,aACP,QAAQ,YAAC,GAEP,OAAO,CAiBnB;4BAriB0B,gCAAgC;2BADjC,+BAA+B;wBADlC,mCAAmC;wBAGnC,4BAA4B;iCACnB,qCAAqC;6BAC3C,6BAA6B;6BAC7B,6BAA6B"}

package/build/physics/builtin/sat3d.d.ts

@@ -1,59 +1,4 @@
-/**
- * Check whether two axis-aligned 3D boxes collide.
- *
- * This is the only narrowphase in the engine that can produce a **Z**
- * pushback. The separating-axis set of two AABBs is just the three world axes,
- * so there is no projection loop: penetration on each axis is
- * `(halfA + halfB) - |centerDelta|`, a non-positive value on any axis means
- * separated, and the minimum translation vector is the axis with the smallest
- * positive penetration.
- *
- * The MTV is a single axis, so exactly one of `overlapN.x`, `overlapN.y` and
- * `overlapNZ` comes back non-zero — see {@link ResponseObject#overlapNZ}. When
- * that axis is Z the 2D fields stay at zero, which is what makes a legacy 2D
- * `onCollision` handler safely inert on a depth-only contact rather than
- * wrong.
- * @ignore
- * @param {Renderable} a - a reference to the object A.
- * @param {Box3d} boxA - a reference to the object A Box3d to be tested
- * @param {Renderable} b - a reference to the object B.
- * @param {Box3d} boxB - a reference to the object B Box3d to be tested
- * @param {object} [response] - Response object that will be populated if they intersect.
- * @returns {boolean} true if they intersect, false if they don't.
- */
-export function testBox3dBox3d(a: Renderable, boxA: Box3d, b: Renderable, boxB: Box3d, response?: object): boolean;
-/**
- * Check whether a {@link Box3d} collides with a planar shape.
- *
- * The planar shape is treated as **unbounded along Z** — an infinitely
- * extruded prism of its own outline — so the pair reduces to the ordinary 2D
- * test between the box's XY footprint and that outline, and the box's z can
- * never make it miss. See {@link Box3d} for why that is the compatible
- * reading: it is what keeps an existing 2D game's world shapes colliding
- * unchanged the moment one `Box3d` body is introduced.
- *
- * `overlapZ` is left at `0` by construction, since neither participant has a
- * finite depth to resolve against.
- * @ignore
- */
-export function testBox3dPolygon(a: any, boxA: any, b: any, polyB: any, response: any): boolean;
-/**
- * Planar-shape-first form of {@link testBox3dPolygon}.
- * @ignore
- */
-export function testPolygonBox3d(a: any, polyA: any, b: any, boxB: any, response: any): boolean;
-/**
- * {@link Box3d} against an {@link Ellipse}, with the ellipse unbounded along
- * Z. See {@link testBox3dPolygon}.
- * @ignore
- */
-export function testBox3dEllipse(a: any, boxA: any, b: any, ellipseB: any, response: any): boolean;
-/**
- * {@link Ellipse} against a {@link Box3d}, with the ellipse unbounded along
- * Z. See {@link testBox3dPolygon}.
- * @ignore
- */
-export function testEllipseBox3d(a: any, ellipseA: any, b: any, boxB: any, response: any): boolean;
+
 import type Renderable from "../../renderable/renderable.js";
 import type { Box3d } from "../../geometries/box3d.ts";
 //# sourceMappingURL=sat3d.d.ts.map

package/build/physics/builtin/sat3d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sat3d.d.ts","sourceRoot":"","sources":["../../../src/physics/builtin/sat3d.js"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,kCAPW,UAAU,QACV,KAAK,KACL,UAAU,QACV,KAAK,aACL,MAAM,GACJ,OAAO,CA6EnB;AAED;;;;;;;;;;;;;GAaG;AACH,gGAEC;AAED;;;GAGG;AACH,gGAEC;AAED;;;;GAIG;AACH,mGAEC;AAED;;;;GAIG;AACH,mGAEC;4BAtK0B,gCAAgC;2BAHnC,2BAA2B"}
+{"version":3,"file":"sat3d.d.ts","sourceRoot":"","sources":["../../../src/physics/builtin/sat3d.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,kCAPW,UAAU,QACV,KAAK,KACL,UAAU,QACV,KAAK,aACL,MAAM,GACJ,OAAO,CA6EnB;AAED;;;;;;;;;;;;;;GAcG;AACH,gGAEC;AAED;;;;GAIG;AACH,gGAEC;AAED;;;;;GAKG;AACH,mGAEC;AAED;;;;;GAKG;AACH,mGAEC;4BA5K0B,gCAAgC;2BAHnC,2BAA2B"}

package/build/physics/collision.d.ts

@@ -15,8 +15,6 @@ export namespace collision {
     }
     /**
      * Checks for object colliding with the given line
-     * @name rayCast
-     * @memberof collision
      * @public
      * @param {Line} line - line to be tested for collision
      * @param {Array.<Renderable>} [result] - a user defined array that will be populated with intersecting physic objects.

package/build/physics/collision.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collision.d.ts","sourceRoot":"","sources":["../../src/physics/collision.js"],"names":[],"mappings":";qBAmBW,MAAM;kBAWN,MAAM;;;;;;;;;;;;;IAmEhB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,uBArBW,IAAI,WACJ,KAAK,CAAE,UAAU,CAAC,GAChB,KAAK,CAAE,UAAU,CAAC,CAqB9B;;0BA1HqB,yBAAyB;4BACrB,+BAA+B"}
+{"version":3,"file":"collision.d.ts","sourceRoot":"","sources":["../../src/physics/collision.js"],"names":[],"mappings":";qBAiBW,MAAM;kBASN,MAAM;;;;;;;;;;;;;IAiEhB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,uBArBW,IAAI,WACJ,KAAK,CAAE,UAAU,CAAC,GAChB,KAAK,CAAE,UAAU,CAAC,CAqB9B;;0BAlHqB,yBAAyB;4BACrB,+BAA+B"}

package/build/physics/response.d.ts

@@ -100,7 +100,6 @@ declare class ResponseObject {
      * Call this between tests if you are going to reuse a single <br>
      * Response object for multiple intersection tests <br>
      * (recommended as it will avoid allocating extra memory) <br>
-     * @name clear
      * @public
      * @returns {object} this object for chaining
      */

package/build/physics/response.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../src/physics/response.js"],"names":[],"mappings":";;;;;;;;OAKc,UAAU;;;;OACV,UAAU;;;;aACV,MAAM;;;;cACN,QAAQ;;;;cACR,QAAQ;;;;eACR,MAAM;;;;cACN,MAAM;;;;UACN,OAAO;;;;UACP,OAAO;;;;iBACP,MAAM;;;;iBACN,MAAM;;AAbpB;;;;;;;;;;;;;;GAcG;AACH;IAEE,OAAa;IACb,OAAa;IACb,mBAA8B;IAC9B,mBAA8B;IAC9B;;;;;;;;;;;;;;;;;;OAkBG;IACH,kBAAkB;IAClB,iBAAiB;IACjB,cAAgB;IAChB,cAAgB;IAChB,oBAAqB;IACrB,oBAAqB;IACrB,0BAA6B;IAC7B,gBAA+B;IAGhC;;;;;;;;OAQG;IACH,gBAFa,MAAM,CAelB;CACD;yBA3EwB,qBAAqB"}
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../src/physics/response.js"],"names":[],"mappings":";;;;;;;;OAKc,UAAU;;;;OACV,UAAU;;;;aACV,MAAM;;;;cACN,QAAQ;;;;cACR,QAAQ;;;;eACR,MAAM;;;;cACN,MAAM;;;;UACN,OAAO;;;;UACP,OAAO;;;;iBACP,MAAM;;;;iBACN,MAAM;;AAbpB;;;;;;;;;;;;;;GAcG;AACH;IAEE,OAAa;IACb,OAAa;IACb,mBAA8B;IAC9B,mBAA8B;IAC9B;;;;;;;;;;;;;;;;;;OAkBG;IACH,kBAAkB;IAClB,iBAAiB;IACjB,cAAgB;IAChB,cAAgB;IAChB,oBAAqB;IACrB,oBAAqB;IACrB,0BAA6B;IAC7B,gBAA+B;IAGhC;;;;;;;OAOG;IACH,gBAFa,MAAM,CAelB;CACD;yBA1EwB,qBAAqB"}

package/build/physics/world.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../src/physics/world.js"],"names":[],"mappings":"AA8BA;;;GAGG;AACH;IACC;;;;;;OAMG;IACH,gBANW,MAAM,MACN,MAAM,UACN,MAAM,WACN,MAAM,YACN,cAAc,EAuIxB;IArHA;;;OAGG;IACH,KAFU,WAAW,CAED;IAEpB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,QANU,MAAM,CAMO;IAEvB;;;;;OAKG;IACH,YAAa;IAEb;;;;;;;OAOG;IACH,WAHU,OAAO,CAGK;IAEtB;;;;;;;;;;;;;;OAcG;IACH,YAHU,OAAO,CAGK;IAEtB;;;;;;OAMG;IACH,SAFU,cAAc,CAEsB;IAG9C;;;;;;;;;;;;;;;OAeG;IACH,YAFU,OAAO,4BAA4B,EAAE,UAAU,CAEjB;IAcxC,0BAMC;IA2CF;;;;;;;;;;;OAWG;IACH,cAFa,GAAG,CAAC,IAAI,CAAC,CAOrB;IASD,eALa,QAAQ,EAOpB;IATD;;;OAGG;IACH,eAFa,QAAQ,CAIpB;IAKD;;;;OAIG;IACH,gBAFa,QAAQ,GAAG,SAAS,CAIhC;IAsCD;;;;;;;OAOG;IACH,cAHW,IAAI,GACF,KAAK,CASjB;IAED;;;;;OAKG;IACH,iBAHW,IAAI,GACF,KAAK,CASjB;IAED;;;;;OAKG;IACH,yBAIC;IAuBD;;;OAGG;IACH,SAFW,MAAM,QAWhB;CACD;sBAjXqB,4BAA4B;6BAatB,iCAAiC;oCAI1B,cAAc;sBAH5B,mBAAmB;8BAEX,qBAAqB;0BADzB,uBAAuB"}
+{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../src/physics/world.js"],"names":[],"mappings":"AA+BA;;;GAGG;AACH;IACC;;;;;;OAMG;IACH,gBANW,MAAM,MACN,MAAM,UACN,MAAM,WACN,MAAM,YACN,cAAc,EAuIxB;IArHA;;;OAGG;IACH,KAFU,WAAW,CAED;IAEpB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,QANU,MAAM,CAMO;IAEvB;;;;;OAKG;IACH,YAAa;IAEb;;;;;;;OAOG;IACH,WAHU,OAAO,CAGK;IAEtB;;;;;;;;;;;;;;OAcG;IACH,YAHU,OAAO,CAGK;IAEtB;;;;;;OAMG;IACH,SAFU,cAAc,CAEsB;IAG9C;;;;;;;;;;;;;;;OAeG;IACH,YAFU,OAAO,4BAA4B,EAAE,UAAU,CAEjB;IAcxC,0BAMC;IA4CF;;;;;;;;;;;OAWG;IACH,cAFa,GAAG,CAAC,IAAI,CAAC,CAOrB;IASD,eALa,QAAQ,EAOpB;IATD;;;OAGG;IACH,eAFa,QAAQ,CAIpB;IAKD;;;;OAIG;IACH,gBAFa,QAAQ,GAAG,SAAS,CAIhC;IAsCD;;;;;;;OAOG;IACH,cAHW,IAAI,GACF,KAAK,CASjB;IAED;;;;;OAKG;IACH,iBAHW,IAAI,GACF,KAAK,CASjB;IAED;;;;;OAKG;IACH,yBAIC;IAuBD;;;OAGG;IACH,SAFW,MAAM,QAWhB;CACD;sBAnXqB,4BAA4B;6BAatB,iCAAiC;oCAI1B,cAAc;sBAH5B,mBAAmB;8BAEX,qBAAqB;0BADzB,uBAAuB"}

package/build/plugin/plugin.d.ts

@@ -39,8 +39,16 @@ export declare class BasePlugin {
 export declare function patch(proto: Record<string, any>, name: string, fn: (...args: any[]) => any): void;
 /**
  * Register a plugin.
+ *
+ * The registry is module-global, not per-application: a name can only be
+ * registered once for the lifetime of the page.
+ *
+ * Note the ordering — the instance is constructed *before* the base-class and
+ * version checks can run, because both read the instance. A plugin whose
+ * constructor has side effects (event subscriptions, engine patches) will have
+ * applied them by the time `Plugin version mismatch` throws.
  * @param pluginClass - Plugin class to instantiate and register
- * @param name - a unique name for this plugin
+ * @param name - a unique name for this plugin; defaults to the class name
  * @param args - all extra parameters will be passed to the plugin constructor
  * @example
  * // register a new plugin

package/build/plugin/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/plugin/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,iCAAiC,CAAC;AAK/D;;GAEG;AACH,eAAO,MAAM,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAM,CAAC;AAEpD;;GAEG;AAEH;;;GAGG;AACH,qBAAa,UAAU;IACtB;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,GAAG,EAAE,WAAW,CAAC;gBAEL,GAAG,GAAE,WAAkB;CAInC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CACpB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC1B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GACzB,IAAI,CAwBN;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CACvB,WAAW,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,UAAU,EAC/C,IAAI,CAAC,EAAE,MAAM,EACb,GAAG,IAAI,EAAE,GAAG,EAAE,GACZ,IAAI,CA2BN;AAED;;;;GAIG;AACH,wBAAgB,GAAG,CAClB,SAAS,EAAE,MAAM,GAAG,CAAC,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,UAAU,CAAC,GACtD,UAAU,GAAG,SAAS,CAUxB"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/plugin/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,iCAAiC,CAAC;AAK/D;;GAEG;AACH,eAAO,MAAM,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAM,CAAC;AAEpD;;GAEG;AAEH;;;GAGG;AACH,qBAAa,UAAU;IACtB;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,GAAG,EAAE,WAAW,CAAC;gBAEL,GAAG,GAAE,WAAkB;CAInC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CACpB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC1B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GACzB,IAAI,CAwBN;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CACvB,WAAW,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,UAAU,EAC/C,IAAI,CAAC,EAAE,MAAM,EACb,GAAG,IAAI,EAAE,GAAG,EAAE,GACZ,IAAI,CA2BN;AAED;;;;GAIG;AACH,wBAAgB,GAAG,CAClB,SAAS,EAAE,MAAM,GAAG,CAAC,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,UAAU,CAAC,GACtD,UAAU,GAAG,SAAS,CAUxB"}

package/build/polyfill/index.d.ts

@@ -1,7 +1,4 @@
-import "core-js/proposals/global-this";
-import "core-js/es/string/trim-start";
-import "core-js/es/string/trim-end";
 import "./console.ts";
 import "./ellipse.ts";
-import "./roundrect.js";
+import "./roundrect.ts";
 //# sourceMappingURL=index.d.ts.map

package/build/polyfill/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/polyfill/index.ts"],"names":[],"mappings":"AACA,OAAO,+BAA+B,CAAC;AAGvC,OAAO,8BAA8B,CAAC;AACtC,OAAO,4BAA4B,CAAC;AAGpC,OAAO,cAAc,CAAC;AACtB,OAAO,cAAc,CAAC;AACtB,OAAO,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/polyfill/index.ts"],"names":[],"mappings":"AASA,OAAO,cAAc,CAAC;AACtB,OAAO,cAAc,CAAC;AACtB,OAAO,gBAAgB,CAAC"}

package/build/renderable/anchorPoint.d.ts

@@ -4,77 +4,5 @@
  * Same normalized convention as {@link Renderable#anchorPoint}: x 0=left →
  * 1=right, y 0=top → 1=bottom.
  */
-/**
- * Named anchor-point presets accepted anywhere `settings.anchorPoint` is —
- * self-documenting shorthands for the common `{x, y}` pairs.
- * @ignore
- */
-export declare const ANCHOR_POINT_PRESETS: Readonly<{
-    center: Readonly<{
-        x: 0.5;
-        y: 0.5;
-    }>;
-    top: Readonly<{
-        x: 0.5;
-        y: 0;
-    }>;
-    bottom: Readonly<{
-        x: 0.5;
-        y: 1;
-    }>;
-    left: Readonly<{
-        x: 0;
-        y: 0.5;
-    }>;
-    right: Readonly<{
-        x: 1;
-        y: 0.5;
-    }>;
-    "top-left": Readonly<{
-        x: 0;
-        y: 0;
-    }>;
-    "top-right": Readonly<{
-        x: 1;
-        y: 0;
-    }>;
-    "bottom-left": Readonly<{
-        x: 0;
-        y: 1;
-    }>;
-    "bottom-right": Readonly<{
-        x: 1;
-        y: 1;
-    }>;
-}>;
-/**
- * An anchor value as accepted by `settings.anchorPoint`: a preset name or
- * any object with numeric `x`/`y` (plain object, Vector2d, ObservablePoint).
- * @ignore
- */
-export type AnchorPointValue = keyof typeof ANCHOR_POINT_PRESETS | {
-    x: number;
-    y: number;
-};
-/**
- * Resolve a `settings.anchorPoint` value — a preset name or an `{x, y}`
- * object — into a fresh `{x, y}` pair (never a shared/frozen object).
- * Values are passed through unclamped: anchors outside 0..1 are legal.
- *
- * Invalid values (unknown preset, malformed object, non-finite numbers) are
- * handled per surface:
- * - with a `fallback` (the legacy 2D classes): logs a console warning and
- *   returns the fallback — full backward compatibility with the historical
- *   silent `set(undefined, undefined)` → `(0, 0)` outcome, nothing that
- *   constructed before can start throwing;
- * - without (new surfaces, e.g. Sprite3d): throws.
- * @ignore
- */
-export declare function resolveAnchorPoint(value: unknown, owner?: string, fallback?: {
-    x: number;
-    y: number;
-}): {
-    x: number;
-    y: number;
-};
+export {};
 //# sourceMappingURL=anchorPoint.d.ts.map

package/build/renderable/anchorPoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anchorPoint.d.ts","sourceRoot":"","sources":["../../src/renderable/anchorPoint.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU/B,CAAC;AAEH;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GACzB,MAAM,OAAO,oBAAoB,GACjC;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAe5B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,OAAO,EACd,KAAK,SAAe,EACpB,QAAQ,CAAC,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GACjC;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAyB1B"}
+{"version":3,"file":"anchorPoint.d.ts","sourceRoot":"","sources":["../../src/renderable/anchorPoint.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/build/renderable/animation.d.ts

@@ -13,13 +13,6 @@ export interface AnimationOptions {
     loop: boolean;
     /** playback rate multiplier (1 = authored speed). */
     speed: number;
-    /**
-     * the argument was a bare function — the legacy `Sprite` callback whose
-     * `false` return holds the last frame. Carried so callers can preserve that
-     * exact contract; not part of the public options shape.
-     * @ignore
-     */
-    legacyFn?: boolean;
 }
 /**
  * Normalize the polymorphic second argument of `setCurrentAnimation` into a

package/build/renderable/animation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"animation.d.ts","sourceRoot":"","sources":["../../src/renderable/animation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAChC,yFAAyF;IACzF,UAAU,CAAC,EAAE,CAAC,MAAM,OAAO,CAAC,GAAG,SAAS,CAAC;IACzC,gEAAgE;IAChE,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,mEAAmE;IACnE,IAAI,EAAE,OAAO,CAAC;IACd,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACpC,GAAG,CAAC,EACD,MAAM,GACN,CAAC,MAAM,OAAO,CAAC,GACf;IACA,UAAU,CAAC,EAAE,MAAM,OAAO,CAAC;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CACd,GAGD,IAAI,GACL,gBAAgB,CAiBlB"}
+{"version":3,"file":"animation.d.ts","sourceRoot":"","sources":["../../src/renderable/animation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAChC,yFAAyF;IACzF,UAAU,CAAC,EAAE,CAAC,MAAM,OAAO,CAAC,GAAG,SAAS,CAAC;IACzC,gEAAgE;IAChE,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,mEAAmE;IACnE,IAAI,EAAE,OAAO,CAAC;IACd,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;CASd;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACpC,GAAG,CAAC,EACD,MAAM,GACN,CAAC,MAAM,OAAO,CAAC,GACf;IACA,UAAU,CAAC,EAAE,MAAM,OAAO,CAAC;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CACd,GAGD,IAAI,GACL,gBAAgB,CAiBlB"}

package/build/renderable/colorlayer.d.ts

@@ -28,11 +28,6 @@ export default class ColorLayer extends Renderable {
      * @param {Camera2d} [viewport] - the viewport to (re)draw
      */
     draw(renderer: CanvasRenderer | WebGLRenderer, viewport?: Camera2d): void;
-    /**
-     * Destroy function
-     * @ignore
-     */
-    destroy(): void;
 }
 import Renderable from "./renderable.js";
 import type { Color } from "./../math/color.ts";