melonjs 17.3.0 → 18.0.0

package/build/physics/bounds.d.ts

@@ -0,0 +1,192 @@
+import { Point } from "../geometries/point.ts";
+import { Matrix2d } from "../math/matrix2d.ts";
+import { Vector2d } from "../math/vector2d.ts";
+import { XYPoint } from "../utils/types.ts";
+/**
+ * a bound object contains methods for creating and manipulating axis-aligned bounding boxes (AABB).
+ */
+export declare class Bounds {
+    _center: Vector2d;
+    type: "Bounds";
+    min: XYPoint;
+    max: XYPoint;
+    /**
+     * Constructs a Bounds object with optional vertices.
+     * @param [vertices] - An array of Vector2d or Point to initialize the bounds.
+     */
+    constructor(vertices?: Vector2d[] | Point[] | XYPoint[]);
+    /**
+     * Resets the bounds to its initial state.
+     */
+    clear(): void;
+    /**
+     * Sets the bounds to the given minimum and maximum values.
+     * @param minX - The minimum x value.
+     * @param minY - The minimum y value.
+     * @param maxX - The maximum x value.
+     * @param maxY - The maximum y value.
+     */
+    setMinMax(minX: number, minY: number, maxX: number, maxY: number): void;
+    /**
+     * Gets the x position of the bounds.
+     * @returns The x position.
+     */
+    get x(): number;
+    /**
+     * Sets the x position of the bounds.
+     * @param value - The new x position.
+     */
+    set x(value: number);
+    /**
+     * Gets the y position of the bounds.
+     * @returns The y position.
+     */
+    get y(): number;
+    /**
+     * Sets the y position of the bounds.
+     * @param value - The new y position.
+     */
+    set y(value: number);
+    /**
+     * Gets the width of the bounds.
+     * @returns The width.
+     */
+    get width(): number;
+    /**
+     * Sets the width of the bounds.
+     * @param value - The new width.
+     */
+    set width(value: number);
+    /**
+     * Gets the height of the bounds.
+     * @returns The height.
+     */
+    get height(): number;
+    /**
+     * Sets the height of the bounds.
+     * @param value - The new height.
+     */
+    set height(value: number);
+    /**
+     * Gets the left coordinate of the bounds.
+     * @returns The left coordinate.
+     */
+    get left(): number;
+    /**
+     * Gets the right coordinate of the bounds.
+     * @returns The right coordinate.
+     */
+    get right(): number;
+    /**
+     * Gets the top coordinate of the bounds.
+     * @returns The top coordinate.
+     */
+    get top(): number;
+    /**
+     * Gets the bottom coordinate of the bounds.
+     * @returns The bottom coordinate.
+     */
+    get bottom(): number;
+    /**
+     * Gets the center position of the bounds on the x axis.
+     * @returns The center x coordinate.
+     */
+    get centerX(): number;
+    /**
+     * Gets the center position of the bounds on the y axis.
+     * @returns The center y coordinate.
+     */
+    get centerY(): number;
+    /**
+     * Gets the center position of the bounds.
+     * @returns The center position as a Vector2d.
+     */
+    get center(): Vector2d;
+    /**
+     * Centers the bounds position around the given coordinates.
+     * @param x - The x coordinate to center around.
+     * @param y - The y coordinate to center around.
+     * @returns The current Bounds instance for method chaining.
+     */
+    centerOn(x: number, y: number): this;
+    /**
+     * Updates the bounds using the given vertices.
+     * @param vertices - An array of Vector2d or Point to update the bounds.
+     */
+    update(vertices: Vector2d[] | Point[] | XYPoint[]): void;
+    /**
+     * Adds the given vertices to the bounds definition.
+     * @param vertices - An array of Vector2d or Point to add to the bounds.
+     * @param [clear] - Whether to reset the bounds before adding the new vertices. Defaults to false.
+     */
+    add(vertices: Vector2d[] | Point[] | XYPoint[], clear?: boolean): void;
+    /**
+     * Adds the given bounds to the bounds definition.
+     * @param bounds - The bounds to add.
+     * @param [clear] - Whether to reset the bounds before adding the new bounds.
+     */
+    addBounds(bounds: Bounds, clear?: boolean): void;
+    /**
+     * Adds the given point to the bounds definition.
+     * @param point - The point to add to the bounds.
+     * @param [m] - An optional transform to apply to the given point.
+     */
+    addPoint(point: Vector2d | Point, m?: Matrix2d): void;
+    /**
+     * Adds the given quad coordinates to this bounds definition, multiplied by the given matrix.
+     * @param x0 - The left x coordinate of the quad.
+     * @param y0 - The top y coordinate of the quad.
+     * @param x1 - The right x coordinate of the quad.
+     * @param y1 - The bottom y coordinate of the quad.
+     * @param [m] - An optional transform to apply to the given coordinates.
+     */
+    addFrame(x0: number, y0: number, x1: number, y1: number, m?: Matrix2d): void;
+    /**
+     * Returns true if the bounds contain the given point or vector.
+     * @param xOrVectorOrBounds - The x coordinate, vector, or bounds to check.
+     * @param [y] - The y coordinate if the first parameter is a number.
+     * @returns True if the bounds contain the point or vector, otherwise false.
+     */
+    contains(x: number, y: number): boolean;
+    contains(vector: Vector2d | Bounds): boolean;
+    /**
+     * Returns true if the two bounds intersect.
+     * @param bounds - The bounds to check for intersection.
+     * @returns True if the bounds overlap, otherwise false.
+     */
+    overlaps(bounds: Bounds): boolean;
+    /**
+     * Determines whether all coordinates of this bounds are finite numbers.
+     * @returns False if any coordinates are positive or negative Infinity or NaN; otherwise, true.
+     */
+    isFinite(): boolean;
+    /**
+     * Translates the bounds by the given point or vector.
+     * @param xOrVector - The x coordinate or vector to translate by.
+     * @param [y] - The y coordinate if the first parameter is a number.
+     */
+    translate(x: number, y: number): void;
+    translate(vector: Vector2d): void;
+    /**
+     * Shifts the bounds to the given x, y position or vector.
+     * @param xOrVector - The x coordinate or vector to shift to.
+     * @param [y] - The y coordinate if the first parameter is a number.
+     */
+    shift(x: number, y: number): void;
+    shift(vector: Vector2d): void;
+    /**
+     * Creates a clone of this bounds.
+     * @returns A new Bounds object that is a copy of this bounds.
+     */
+    clone(): Bounds;
+    /**
+     * Returns a polygon whose edges are the same as this bounds.
+     * @returns A new Polygon that represents this bounds.
+     */
+    toPolygon(): import("../index.js").Polygon;
+}
+/**
+ * A pool for creating and reusing Bounds objects.
+ */
+export declare const boundsPool: import("../system/pool.ts").Pool<Bounds, [vertices?: Vector2d[] | Point[] | undefined]>;
+//# sourceMappingURL=bounds.d.ts.map

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

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

package/{dist/types → build}/physics/collision.d.ts

@@ -1,5 +1,4 @@
-export default collision;
-declare namespace collision {
+export namespace collision {
     let maxChildren: number;
     let maxDepth: number;
     namespace types {
@@ -24,7 +23,7 @@ declare namespace collision {
      * @returns {Array.<Renderable>} an array of intersecting physic objects
      * @example
      *    // define a line accross the viewport
-     *    let ray = new me.Line(
+     *    let ray = new Line(
      *        // absolute position of the line
      *        0, 0, [
      *        // starting point relative to the initial position
@@ -40,5 +39,8 @@ declare namespace collision {
      *        // ...
      *    }
      */
-    function rayCast(line: Line, result?: Renderable[] | undefined): Renderable[];
+    function rayCast(line: Line, result?: Array<Renderable>): Array<Renderable>;
 }
+import type { Line } from "./../geometries/line.ts";
+import type Renderable from "./../renderable/renderable.js";
+//# sourceMappingURL=collision.d.ts.map

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

@@ -0,0 +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"}

package/{dist/types → build}/physics/detector.d.ts

@@ -1,7 +1,8 @@
+export default Detector;
 /**
  * the Detector class contains methods for detecting collisions between bodies using a broadphase algorithm.
  */
-export default class Detector {
+declare class Detector {
     /**
      * @param {Container} world - the physic world this detector is bind to
      */
@@ -43,13 +44,13 @@ export default class Detector {
      * @returns {Array.<Renderable>} an array of intersecting physic objects
      * @example
      *    // define a line accross the viewport
-     *    let ray = new me.Line(
+     *    let ray = new Line(
      *        // absolute position of the line
      *        0, 0, [
      *        // starting point relative to the initial position
-     *        new me.Vector2d(0, 0),
+     *        new Vector2d(0, 0),
      *        // ending point
-     *        new me.Vector2d(me.game.viewport.width, me.game.viewport.height)
+     *        new Vector2d(me.game.viewport.width, me.game.viewport.height)
      *    ]);
      *
      *    // check for collition
@@ -59,6 +60,13 @@ export default class Detector {
      *        // ...
      *    }
      */
-    rayCast(line: Line, result?: Renderable[] | undefined): Array<Renderable>;
+    rayCast(line: Line, result?: Array<Renderable>): Array<Renderable>;
 }
+import type Container from "./../renderable/container.js";
 import ResponseObject from "./response.js";
+import type Renderable from "./../renderable/renderable.js";
+import type Entity from "./../renderable/entity/entity.js";
+import type Sprite from "./../renderable/sprite.js";
+import type NineSliceSprite from "./../renderable/nineslicesprite.js";
+import type { Line } from "./../geometries/line.ts";
+//# sourceMappingURL=detector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"detector.d.ts","sourceRoot":"","sources":["../../src/physics/detector.js"],"names":[],"mappings":";AA0CA;;GAEG;AACH;IACC;;OAEG;IACH,mBAFW,SAAS,EAYnB;IARA,iBAAkB;IAElB;;;;OAIG;IACH,UAFU,cAAc,CAEY;IAGrC;;;;;;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,8BACF,OAAO,CAkCnB;IAED;;;;;OAKG;IACH,iBAHW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,GAChD,OAAO,CA8EnB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,cArBW,IAAI,WACJ,KAAK,CAAE,UAAU,CAAC,GAChB,KAAK,CAAE,UAAU,CAAC,CAiE9B;CACD;2BApQyB,8BAA8B;2BAlB7B,eAAe;4BAmBf,+BAA+B;wBAFnC,kCAAkC;wBAGlC,2BAA2B;iCAClB,oCAAoC;0BAC7C,yBAAyB"}

package/{dist/types → build}/physics/quadtree.d.ts

@@ -1,5 +1,4 @@
 /**
- * @classdesc
  * a QuadTree implementation in JavaScript, a 2d spatial subdivision algorithm.
  * @see game.world.broadphase
  */
@@ -11,7 +10,7 @@ export default class QuadTree {
      * @param {number} [max_levels=4] - total max levels inside root Quadtree
      * @param {number} [level] - deepth level, required for subnodes
      */
-    constructor(world: World, bounds: Bounds, max_objects?: number | undefined, max_levels?: number | undefined, level?: number | undefined);
+    constructor(world: World, bounds: Bounds, max_objects?: number, max_levels?: number, level?: number);
     world: World;
     bounds: Bounds;
     max_objects: number;
@@ -23,8 +22,6 @@ export default class QuadTree {
     getIndex(item: any): number;
     /**
      * Insert the given object container into the node.
-     * @name insertContainer
-     * @memberof QuadTree
      * @param {Container} container - group of objects to be added
      */
     insertContainer(container: Container): void;
@@ -32,48 +29,40 @@ export default class QuadTree {
      * Insert the given object into the node. If the node
      * exceeds the capacity, it will split and add all
      * objects to their corresponding subnodes.
-     * @name insert
-     * @memberof QuadTree
      * @param {object} item - object to be added
      */
     insert(item: object): void;
     /**
      * Return all objects that could collide with the given object
-     * @name retrieve
-     * @memberof QuadTree
      * @param {object} item - object to be checked against
      * @param {object} [fn] - a sorting function for the returned array
      * @returns {object[]} array with all detected objects
      */
-    retrieve(item: object, fn?: object | undefined): object[];
+    retrieve(item: object, fn?: object, result: any): object[];
     /**
      * Remove the given item from the quadtree.
      * (this function won't recalculate the impacted node)
-     * @name remove
-     * @memberof QuadTree
      * @param {object} item - object to be removed
      * @returns {boolean} true if the item was found and removed.
      */
     remove(item: object): boolean;
     /**
      * return true if the node is prunable
-     * @name isPrunable
-     * @memberof QuadTree
      * @returns {boolean} true if the node is prunable
      */
     isPrunable(): boolean;
     /**
      * return true if the node has any children
-     * @name hasChildren
-     * @memberof QuadTree
      * @returns {boolean} true if the node has any children
      */
     hasChildren(): boolean;
     /**
      * clear the quadtree
-     * @name clear
-     * @memberof QuadTree
      * @param {Bounds} [bounds=this.bounds] - the bounds to be cleared
      */
-    clear(bounds?: any): void;
+    clear(bounds?: Bounds): void;
 }
+import type World from "./world.js";
+import type { Bounds } from "./bounds.ts";
+import type Container from "./../renderable/container.js";
+//# sourceMappingURL=quadtree.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quadtree.d.ts","sourceRoot":"","sources":["../../src/physics/quadtree.js"],"names":[],"mappings":"AA4DA;;;GAGG;AACH;IACC;;;;;;OAMG;IACH,mBANW,KAAK,UACL,MAAM,gBACN,MAAM,eACN,MAAM,UACN,MAAM,EAahB;IAVA,aAAkB;IAClB,eAAoB;IAEpB,oBAA8B;IAC9B,mBAA4B;IAE5B,cAAkB;IAElB,eAAiB;IACjB,aAAe;IAMhB,cA8DC;IAOD,4BA4CC;IAED;;;OAGG;IACH,2BAFW,SAAS,QAsBnB;IAED;;;;;OAKG;IACH,aAFW,MAAM,QAsChB;IAED;;;;;OAKG;IACH,eAJW,MAAM,OACN,MAAM,gBACJ,MAAM,EAAE,CAmCpB;IAED;;;;;OAKG;IACH,aAHW,MAAM,GACJ,OAAO,CAiCnB;IAED;;;OAGG;IACH,cAFa,OAAO,CAInB;IAED;;;OAGG;IACH,eAFa,OAAO,CAUnB;IAED;;;OAGG;IACH,eAFW,MAAM,QAsBhB;CACD;uBA5YqB,YAAY;4BAET,aAAa;2BADZ,8BAA8B"}

package/{dist/types → build}/physics/response.d.ts

@@ -1,6 +1,48 @@
+export default ResponseObject;
 /**
- * @classdesc
  * An object representing the result of an intersection.
+ */
+export type ResponseObject = {
+    /**
+     * The first object participating in the intersection
+     */
+    a: Renderable;
+    /**
+     * The second object participating in the intersection
+     */
+    b: Renderable;
+    /**
+     * Magnitude of the overlap on the shortest colliding axis
+     */
+    overlap: number;
+    /**
+     * The overlap vector (i.e. `overlapN.scale(overlap, overlap)`). If this vector is subtracted from the position of a, a and b will no longer be colliding
+     */
+    overlapV: Vector2d;
+    /**
+     * The shortest colliding axis (unit-vector)
+     */
+    overlapN: Vector2d;
+    /**
+     * Whether the first object is entirely inside the second
+     */
+    aInB: boolean;
+    /**
+     * Whether the second object is entirely inside the first
+     */
+    bInA: boolean;
+    /**
+     * The index of the colliding shape for the object a body
+     */
+    indexShapeA: number;
+    /**
+     * The index of the colliding shape for the object b body
+     */
+    indexShapeB: number;
+};
+/**
+ * An object representing the result of an intersection.
+ * @typedef {object} ResponseObject
  * @property {Renderable} a The first object participating in the intersection
  * @property {Renderable} b The second object participating in the intersection
  * @property {number} overlap Magnitude of the overlap on the shortest colliding axis
@@ -10,10 +52,8 @@
  * @property {boolean} bInA Whether the second object is entirely inside the first
  * @property {number} indexShapeA The index of the colliding shape for the object a body
  * @property {number} indexShapeB The index of the colliding shape for the object b body
- * @name ResponseObject
- * @public
  */
-export default class ResponseObject {
+declare class ResponseObject {
     a: any;
     b: any;
     overlapN: Vector2d;
@@ -34,4 +74,5 @@ export default class ResponseObject {
      */
     public clear(): object;
 }
-import Vector2d from "./../math/vector2.js";
+import { Vector2d } from "../math/vector2d.ts";
+//# sourceMappingURL=response.d.ts.map

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

@@ -0,0 +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;;;;UACR,OAAO;;;;UACP,OAAO;;;;iBACP,MAAM;;;;iBACN,MAAM;;AAXpB;;;;;;;;;;;;GAYG;AACH;IAEE,OAAa;IACb,OAAa;IACb,mBAA8B;IAC9B,mBAA8B;IAC9B,cAAgB;IAChB,cAAgB;IAChB,oBAAqB;IACrB,oBAAqB;IACrB,gBAA+B;IAGhC;;;;;;;;OAQG;IACH,gBAFa,MAAM,CASlB;CACD;yBA7CwB,qBAAqB"}

package/{dist/types → build}/physics/sat.d.ts

@@ -46,3 +46,11 @@ export function testPolygonEllipse(a: Renderable | Container | Entity | Sprite |
  * @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";
+import type Sprite from "./../renderable/sprite.js";
+import type NineSliceSprite from "./../renderable/nineslicesprite.js";
+import type { Polygon } from "../geometries/polygon.ts";
+import type { Ellipse } from "./../geometries/ellipse.ts";
+//# sourceMappingURL=sat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sat.d.ts","sourceRoot":"","sources":["../../src/physics/sat.js"],"names":[],"mappings":"AAyMA;;;;;;;;;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,CAiDnB;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,CAmCnB;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,CAmKnB;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;4BAjf0B,+BAA+B;2BADhC,8BAA8B;wBADjC,kCAAkC;wBAGlC,2BAA2B;iCAClB,oCAAoC;6BAC1C,0BAA0B;6BAC1B,4BAA4B"}

package/{dist/types → build}/physics/world.d.ts

@@ -1,7 +1,9 @@
 /**
- * @classdesc
+ * @import Application from "./../application/application.js";
+ * @import Body from "./body.js";
+ */
+/**
  * an object representing the physic world, and responsible for managing and updating all childs and physics
- * @augments Container
  */
 export default class World extends Container {
     /**
@@ -10,7 +12,7 @@ export default class World extends Container {
      * @param {number} [width=game.viewport.width] - width of the container
      * @param {number} [height=game.viewport.height] - height of the container
      */
-    constructor(x?: number | undefined, y?: number | undefined, width?: number | undefined, height?: number | undefined);
+    constructor(x?: number, y?: number, width?: number, height?: number);
     /**
      * the application (game) this physic world belong to
      * @type {Application}
@@ -90,6 +92,9 @@ export default class World extends Container {
     step(dt: number): void;
 }
 import Container from "../renderable/container.js";
-import Vector2d from "./../math/vector2.js";
+import type Application from "./../application/application.js";
+import { Vector2d } from "../math/vector2d.ts";
+import type Body from "./body.js";
 import QuadTree from "./quadtree.js";
 import Detector from "./detector.js";
+//# sourceMappingURL=world.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../src/physics/world.js"],"names":[],"mappings":"AAcA;;;GAGG;AAEH;;GAEG;AACH;IACC;;;;;OAKG;IACH,gBALW,MAAM,MACN,MAAM,UACN,MAAM,WACN,MAAM,EAqFhB;IAzEA;;;OAGG;IACH,KAFU,WAAW,CAED;IAEpB;;;;;;;;OAQG;IACH,QANU,MAAM,CAMO;IAEvB;;;;;OAKG;IACH,YAAa;IAEb;;;;OAIG;IACH,SAHU,QAAQ,CAGkB;IAEpC;;;;;;;OAOG;IACH,WAHU,OAAO,CAGK;IAEtB;;;OAGG;IACH,QAFU,GAAG,CAAC,IAAI,CAAC,CAEI;IAEvB;;;OAGG;IACH,YAFU,QAAQ,CAOjB;IAED;;;OAGG;IACH,UAFU,QAAQ,CAEgB;IA6CnC;;;;;OAKG;IACH,cAHW,IAAI,GACF,KAAK,CAQjB;IAED;;;;;OAKG;IACH,iBAHW,IAAI,GACF,KAAK,CAQjB;IAED;;;;OAIG;IACH,yBASC;IAuBD;;;OAGG;IACH,SAFW,MAAM,QAiChB;CACD;sBAtPqB,4BAA4B;6BAatB,iCAAiC;yBAdpC,qBAAqB;sBAezB,WAAW;qBAJX,eAAe;qBADf,eAAe"}

package/{dist/types → build}/plugin/plugin.d.ts

@@ -28,41 +28,41 @@ export function patch(proto: object, name: string, fn: Function): void;
  * // the `testPlugin` class instance can also be accessed through me.plugin.cache
  * me.plugin.cache.testPlugin.myfunction ();
  */
-export function register(plugin: plugin.BasePlugin, name?: string | undefined, ...args: any[]): void;
+export function register(plugin: plugin.BasePlugin, name?: string, ...args: any[]): void;
 /**
  * returns the the plugin instance with the specified class type or registered name
  * @name get
  * @memberof plugin
  * @param {object|string} classType - the Class Object or registered name of the plugin to retreive
- * @returns {BasePlugin} a plugin instance or undefined
+ * @returns {plugin.BasePlugin} a plugin instance or undefined
+ */
+export function get(classType: object | string): plugin.BasePlugin;
+/**
+ * @import Application from "./../application/application.js";
  */
-export function get(classType: object | string): BasePlugin;
 /**
  * Contains all registered plugins.
  * @name cache
  * @memberof plugin
+ * @type {Object.<plugin.BasePlugin>}
  */
-export let cache: {};
+export const cache: Object<plugin.BasePlugin>;
 /**
  * @namespace plugin
  */
 /**
  * a base Object class for plugin
  * (plugin must be installed using the register function)
- * @class
- * @name BasePlugin
  * @memberof plugin
  */
 export class BasePlugin {
     /**
      * @param {Application} [app] - a reference to the app/game that registered this plugin
      */
-    constructor(app?: any);
+    constructor(app?: Application);
     /**
      * define the minimum required version of melonJS<br>
      * this can be overridden by the plugin
-     * @type {string}
-     * @default "__VERSION__"
      */
     version: string;
     /**
@@ -71,12 +71,5 @@ export class BasePlugin {
      */
     app: Application;
 }
-/**
- * @class
- * @name Base
- * @memberof plugin
- * @deprecated since 15.1.6, see {@link plugin.BasePlugin}
- */
-export class Base extends BasePlugin {
-    constructor();
-}
+import type Application from "./../application/application.js";
+//# sourceMappingURL=plugin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/plugin/plugin.js"],"names":[],"mappings":"AA4CA;;;;;;;;;;;;;;;GAeG;AACH,6BAZW,MAAM,QACN,MAAM,sBAmChB;AAED;;;;;;;;;;;;GAYG;AACH,iCATW,MAAM,CAAC,UAAU,SACjB,MAAM,wBA0ChB;AAED;;;;;;GAMG;AACH,+BAHW,MAAM,GAAC,MAAM,GACX,MAAM,CAAC,UAAU,CAW7B;AAnJD;;GAEG;AAEH;;;;;GAKG;AACH,oBAFU,MAAM,CAAE,MAAM,CAAC,UAAU,CAAC,CAEZ;AAExB;;GAEG;AAEH;;;;GAIG;AACH;IACC;;OAEG;IACH,kBAFW,WAAW,EAcrB;IAXA;;;OAGG;IACH,gBAAsB;IAEtB;;;OAGG;IACH,KAFU,WAAW,CAEP;CAEf;6BArC2B,iCAAiC"}

package/build/polyfill/console.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=console.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../src/polyfill/console.ts"],"names":[],"mappings":""}

package/build/polyfill/index.d.ts

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

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

@@ -0,0 +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,gBAAgB,CAAC"}

package/build/polyfill/roundrect.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=roundrect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"roundrect.d.ts","sourceRoot":"","sources":["../../src/polyfill/roundrect.ts"],"names":[],"mappings":""}

package/build/pool.d.ts

@@ -0,0 +1,39 @@
+import { ellipsePool } from "./geometries/ellipse";
+import { linePool } from "./geometries/line";
+import { pointPool } from "./geometries/point";
+import { polygonPool } from "./geometries/polygon";
+import { rectPool } from "./geometries/rectangle";
+import { roundedRectanglePool } from "./geometries/roundrect";
+import { colorPool } from "./math/color";
+import { matrix2dPool } from "./math/matrix2d";
+import { matrix3dPool } from "./math/matrix3d";
+import { vector2dPool } from "./math/vector2d";
+import { vector3dPool } from "./math/vector3d";
+import type ParticleEmitter from "./particles/emitter";
+import type Particle from "./particles/particle";
+import { boundsPool } from "./physics/bounds";
+import { bitmapTextDataPool } from "./renderable/text/bitmaptextdata";
+import type { Pool } from "./system/pool";
+import { tweenPool } from "./tweens/tween";
+interface PoolMap {
+    vector2d: typeof vector2dPool;
+    vector3d: typeof vector3dPool;
+    point: typeof pointPool;
+    matrix2d: typeof matrix2dPool;
+    matrix3d: typeof matrix3dPool;
+    bounds: typeof boundsPool;
+    color: typeof colorPool;
+    polygon: typeof polygonPool;
+    line: typeof linePool;
+    rectangle: typeof rectPool;
+    roundedRectangle: typeof roundedRectanglePool;
+    ellipse: typeof ellipsePool;
+    tween: typeof tweenPool;
+    particle: Pool<Particle, [emitter: ParticleEmitter]>;
+    bitmapTextData: typeof bitmapTextDataPool;
+}
+type PoolKey = keyof PoolMap;
+export declare const getPool: <K extends PoolKey>(key: K) => PoolMap[K];
+export declare const getTotalPoolSize: () => number;
+export { createPool, registerPool } from "./system/pool";
+//# sourceMappingURL=pool.d.ts.map

package/build/pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../src/pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,eAAe,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE1C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAqB3C,UAAU,OAAO;IAChB,QAAQ,EAAE,OAAO,YAAY,CAAC;IAC9B,QAAQ,EAAE,OAAO,YAAY,CAAC;IAC9B,KAAK,EAAE,OAAO,SAAS,CAAC;IACxB,QAAQ,EAAE,OAAO,YAAY,CAAC;IAC9B,QAAQ,EAAE,OAAO,YAAY,CAAC;IAC9B,MAAM,EAAE,OAAO,UAAU,CAAC;IAC1B,KAAK,EAAE,OAAO,SAAS,CAAC;IACxB,OAAO,EAAE,OAAO,WAAW,CAAC;IAC5B,IAAI,EAAE,OAAO,QAAQ,CAAC;IACtB,SAAS,EAAE,OAAO,QAAQ,CAAC;IAC3B,gBAAgB,EAAE,OAAO,oBAAoB,CAAC;IAC9C,OAAO,EAAE,OAAO,WAAW,CAAC;IAC5B,KAAK,EAAE,OAAO,SAAS,CAAC;IACxB,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC;IACrD,cAAc,EAAE,OAAO,kBAAkB,CAAC;CAC1C;AAED,KAAK,OAAO,GAAG,MAAM,OAAO,CAAC;AAE7B,eAAO,MAAM,OAAO,GAAI,CAAC,SAAS,OAAO,EAAE,KAAK,CAAC,KAAG,OAAO,CAAC,CAAC,CAE5D,CAAC;AAEF,eAAO,MAAM,gBAAgB,QAAO,MAOnC,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC"}

package/{dist/types → build}/renderable/collectable.d.ts

@@ -1,7 +1,5 @@
 /**
- * @classdesc
  * a basic collectable helper class for immovable object (e.g. a coin)
- * @augments Sprite
  */
 export default class Collectable extends Sprite {
     /**
@@ -13,5 +11,7 @@ export default class Collectable extends Sprite {
     name: any;
     type: any;
     id: any;
+    body: any;
 }
 import Sprite from "./sprite.js";
+//# sourceMappingURL=collectable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectable.d.ts","sourceRoot":"","sources":["../../src/renderable/collectable.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IACC;;;;OAIG;IACH,eAJW,MAAM,KACN,MAAM,YACN,MAAM,EAgChB;IA1BA,UAAyB;IACzB,UAAyB;IACzB,QAAqB;IAWrB,UAAiC;CAclC;mBA1CkB,aAAa"}