melonjs 17.3.0 → 18.0.0

package/{dist/types → build}/input/gamepad.d.ts

@@ -1,12 +1,9 @@
 /**
  * Associate a gamepad event to a keycode
- * @name bindGamepad
- * @memberof input
- * @public
  * @param {number} index - Gamepad index
  * @param {object} button - Button/Axis definition
  * @param {string} button.type - "buttons" or "axes"
- * @param {number} button.code - button or axis code id (See {@link input.GAMEPAD.BUTTONS}, {@link input.GAMEPAD.AXES})
+ * @param {number} button.code - button or axis code id (See {@link input.GAMEPAD})
  * @param {number} [button.threshold=1] - value indicating when the axis should trigger the keycode (e.g. -0.5 or 0.5)
  * @param {number} keyCode - (See {@link input.KEY})
  * @example
@@ -25,11 +22,8 @@ export function bindGamepad(index: number, button: {
 }, keyCode: number): void;
 /**
  * unbind the defined keycode
- * @name unbindGamepad
- * @memberof input
- * @public
  * @param {number} index - Gamepad index
- * @param {number} button - (See {@link input.GAMEPAD.BUTTONS})
+ * @param {number} button - (See {@link input.GAMEPAD})
  * @example
  * me.input.unbindGamepad(0, me.input.GAMEPAD.BUTTONS.FACE_1);
  */
@@ -37,9 +31,6 @@ export function unbindGamepad(index: number, button: number): void;
 /**
  * Set deadzone for analog gamepad inputs<br>
  * The default deadzone is 0.1 (10%) Analog values less than this will be ignored
- * @name setGamepadDeadzone
- * @memberof input
- * @public
  * @param {number} value - Deadzone value
  */
 export function setGamepadDeadzone(value: number): void;
@@ -93,3 +84,4 @@ export namespace GAMEPAD {
  * @ignore
  */
 export function setGamepadMapping(id: any, mapping: any): void;
+//# sourceMappingURL=gamepad.d.ts.map

package/build/input/gamepad.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gamepad.d.ts","sourceRoot":"","sources":["../../src/input/gamepad.js"],"names":[],"mappings":"AAiXA;;;;;;;;;;;;;;;;GAgBG;AACH,mCAfW,MAAM,UAEd;IAAuB,IAAI,EAAnB,MAAM;IACS,IAAI,EAAnB,MAAM;IACU,SAAS;CACjC,WAAQ,MAAM,QAiEhB;AAED;;;;;;GAMG;AACH,qCALW,MAAM,UACN,MAAM,QAShB;AAED;;;;GAIG;AACH,0CAFW,MAAM,QAIhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA1ZD;;;;;;;GAOG;AACH,+DA0BC"}

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

@@ -10,6 +10,8 @@
  * @memberof input
  */
 export let preventDefault: boolean;
-export * from "./pointerevent.js";
-export * from "./keyboard.js";
 export * from "./gamepad.js";
+export * from "./key.ts";
+export * from "./keyboard.ts";
+export * from "./pointerevent.js";
+//# sourceMappingURL=input.d.ts.map

package/build/input/input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../src/input/input.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;GAOG;AACH,2BALU,OAAO,CAKgB"}

package/build/input/key.d.ts

@@ -0,0 +1,105 @@
+/**
+ * standard keyboard constants
+ */
+export declare const KEY: {
+    BACKSPACE: number;
+    TAB: number;
+    ENTER: number;
+    SHIFT: number;
+    CTRL: number;
+    ALT: number;
+    PAUSE: number;
+    CAPS_LOCK: number;
+    ESC: number;
+    SPACE: number;
+    PAGE_UP: number;
+    PAGE_DOWN: number;
+    END: number;
+    HOME: number;
+    LEFT: number;
+    UP: number;
+    RIGHT: number;
+    DOWN: number;
+    PRINT_SCREEN: number;
+    INSERT: number;
+    DELETE: number;
+    NUM0: number;
+    NUM1: number;
+    NUM2: number;
+    NUM3: number;
+    NUM4: number;
+    NUM5: number;
+    NUM6: number;
+    NUM7: number;
+    NUM8: number;
+    NUM9: number;
+    A: number;
+    B: number;
+    C: number;
+    D: number;
+    E: number;
+    F: number;
+    G: number;
+    H: number;
+    I: number;
+    J: number;
+    K: number;
+    L: number;
+    M: number;
+    N: number;
+    O: number;
+    P: number;
+    Q: number;
+    R: number;
+    S: number;
+    T: number;
+    U: number;
+    V: number;
+    W: number;
+    X: number;
+    Y: number;
+    Z: number;
+    WINDOW_KEY: number;
+    NUMPAD0: number;
+    NUMPAD1: number;
+    NUMPAD2: number;
+    NUMPAD3: number;
+    NUMPAD4: number;
+    NUMPAD5: number;
+    NUMPAD6: number;
+    NUMPAD7: number;
+    NUMPAD8: number;
+    NUMPAD9: number;
+    MULTIPLY: number;
+    ADD: number;
+    SUBSTRACT: number;
+    DECIMAL: number;
+    DIVIDE: number;
+    F1: number;
+    F2: number;
+    F3: number;
+    F4: number;
+    F5: number;
+    F6: number;
+    F7: number;
+    F8: number;
+    F9: number;
+    F10: number;
+    F11: number;
+    F12: number;
+    TILDE: number;
+    NUM_LOCK: number;
+    SCROLL_LOCK: number;
+    SEMICOLON: number;
+    PLUS: number;
+    COMMA: number;
+    MINUS: number;
+    PERIOD: number;
+    FORWAND_SLASH: number;
+    GRAVE_ACCENT: number;
+    OPEN_BRACKET: number;
+    BACK_SLASH: number;
+    CLOSE_BRACKET: number;
+    SINGLE_QUOTE: number;
+};
+//# sourceMappingURL=key.d.ts.map

package/build/input/key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key.d.ts","sourceRoot":"","sources":["../../src/input/key.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoGf,CAAC"}

package/build/input/keyboard.d.ts

@@ -0,0 +1,72 @@
+/**
+ * the default target element for keyboard events (usually the window element in which the game is running)
+ */
+export declare const keyBoardEventTarget: null;
+export declare function initKeyboardEvent(): void;
+/**
+ * return the key press status of the specified action
+ * @param action - user defined corresponding action
+ * @returns true if pressed
+ * @example
+ * if (me.input.isKeyPressed('left')) {
+ *    //do something
+ * }
+ * else if (me.input.isKeyPressed('right')) {
+ *    //do something else...
+ * }
+ */
+export declare function isKeyPressed(action: string): boolean;
+/**
+ * return the key status of the specified action
+ * @param action - user defined corresponding action
+ * @returns down (true) or up(false)
+ */
+export declare function keyStatus(action: string): boolean;
+/**
+ * trigger the specified key (simulated) event <br>
+ * @param keyCode - (See {@link input.KEY})
+ * @param [status=false] - true to trigger a key down event, or false for key up event
+ * @param [mouseButton] - the mouse button to trigger
+ * @example
+ * // trigger a key press
+ * me.input.triggerKeyEvent(me.input.KEY.LEFT, true);
+ */
+export declare function triggerKeyEvent(keyCode: number, status: boolean, mouseButton?: number): void;
+/**
+ * associate a user defined action to a keycode
+ * @param keyCode - (See {@link input.KEY})
+ * @param action - user defined corresponding action
+ * @param [lock=false] - cancel the keypress event once read
+ * @param [preventDefault=input.preventDefault] - prevent default browser action
+ * @example
+ * // enable the keyboard
+ * me.input.bindKey(me.input.KEY.LEFT,  "left");
+ * me.input.bindKey(me.input.KEY.RIGHT, "right");
+ * me.input.bindKey(me.input.KEY.X,     "jump", true);
+ * me.input.bindKey(me.input.KEY.F1,    "options", true, true);
+ */
+export declare const bindKey: (keyCode: number, action: string, lock?: boolean, preventDefault?: boolean) => void;
+/**
+ * return the action associated with the given keycode
+ * @param keyCode - (See {@link input.KEY})
+ * @returns user defined associated action
+ */
+export declare function getBindingKey(keyCode: number): string;
+/**
+ * unlock a key manually
+ * @param action - user defined corresponding action
+ * @example
+ * // Unlock jump when touching the ground
+ * if (!this.falling && !this.jumping) {
+ *     me.input.unlockKey("jump");
+ * }
+ */
+export declare function unlockKey(action: string): void;
+/**
+ * unbind the defined keycode
+ * @param keyCode - (See {@link input.KEY})
+ * @example
+ * me.input.unbindKey(me.input.KEY.LEFT);
+ */
+export declare function unbindKey(keyCode: number): void;
+//# sourceMappingURL=keyboard.d.ts.map

package/build/input/keyboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard.d.ts","sourceRoot":"","sources":["../../src/input/keyboard.ts"],"names":[],"mappings":"AAmFA;;GAEG;AACH,eAAO,MAAM,mBAAmB,MAAO,CAAC;AAExC,wBAAgB,iBAAiB,SAahC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,WAQ1C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,WAEvC;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC9B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,OAAO,EACf,WAAW,CAAC,EAAE,MAAM,QAIpB;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO,GACnB,SAAS,MAAM,EACf,QAAQ,MAAM,EACd,OAAO,OAAO,EACd,wBAAqC,SASrC,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,UAE5C;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,QAEvC;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,QASxC"}

package/build/input/pointer.d.ts

@@ -0,0 +1,180 @@
+export default Pointer;
+/**
+ * a pointer object, representing a single finger on a touch enabled device.
+ */
+declare class Pointer extends Bounds {
+    /**
+     * @ignore
+     */
+    constructor(x?: number, y?: number, w?: number, h?: number);
+    /**
+     * constant for left button
+     * @public
+     * @type {number}
+     */
+    public LEFT: number;
+    /**
+     * constant for middle button
+     * @public
+     * @type {number}
+     */
+    public MIDDLE: number;
+    /**
+     * constant for right button
+     * @public
+     * @type {number}
+     */
+    public RIGHT: number;
+    /**
+     * the originating Event Object
+     * @type {PointerEvent|TouchEvent|MouseEvent}
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent}
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent}
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent}
+     */
+    event: PointerEvent | TouchEvent | MouseEvent;
+    /**
+     * the button property indicates which button was pressed on the mouse to trigger the event.
+     * @type {number}
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button}
+     */
+    button: number;
+    /**
+     * indicates whether or not the pointer device that created the event is the primary pointer.
+     * @type {boolean}
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/isPrimary}
+     */
+    isPrimary: boolean;
+    /**
+     * the horizontal coordinate at which the event occurred, relative to the left edge of the entire document.
+     * @type {number}
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/pageX}
+     */
+    pageX: number;
+    /**
+     * the vertical coordinate at which the event occurred, relative to the left edge of the entire document.
+     * @type {number}
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/pageY}
+     */
+    pageY: number;
+    /**
+     * the horizontal coordinate within the application's client area at which the event occurred
+     * @type {number}
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/clientX}
+     */
+    clientX: number;
+    /**
+     * the vertical coordinate within the application's client area at which the event occurred
+     * @type {number}
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/clientY}
+     */
+    clientY: number;
+    /**
+     * the difference in the X coordinate of the pointer since the previous move event
+     * @type {number}
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/movementX}
+     */
+    movementX: number;
+    /**
+     * the difference in the Y coordinate of the pointer since the previous move event
+     * @type {number}
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/movementY}
+     */
+    movementY: number;
+    /**
+     * an unsigned long representing the unit of the delta values scroll amount
+     * @type {number}
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/deltaMode}
+     */
+    deltaMode: number;
+    /**
+     * a double representing the horizontal scroll amount in the Wheel Event deltaMode unit.
+     * @type {number}
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/deltaX}
+     */
+    deltaX: number;
+    /**
+     * a double representing the vertical scroll amount in the Wheel Event deltaMode unit.
+     * @type {number}
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/deltaY}
+     */
+    deltaY: number;
+    /**
+     * a double representing the scroll amount in the z-axis, in the Wheel Event deltaMode unit.
+     * @type {number}
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/deltaZ}
+     */
+    deltaZ: number;
+    /**
+     * Event normalized X coordinate within the game canvas itself<br>
+     * <img src="images/event_coord.png"/>
+     * @type {number}
+     */
+    gameX: number;
+    /**
+     * Event normalized Y coordinate within the game canvas itself<br>
+     * <img src="images/event_coord.png"/>
+     * @type {number}
+     */
+    gameY: number;
+    /**
+     * Event X coordinate relative to the viewport
+     * @type {number}
+     */
+    gameScreenX: number;
+    /**
+     * Event Y coordinate relative to the viewport
+     * @type {number}
+     */
+    gameScreenY: number;
+    /**
+     * Event X coordinate relative to the map
+     * @type {number}
+     */
+    gameWorldX: number;
+    /**
+     * Event Y coordinate relative to the map
+     * @type {number}
+     */
+    gameWorldY: number;
+    /**
+     * Event X coordinate relative to the holding container
+     * @type {number}
+     */
+    gameLocalX: number;
+    /**
+     * Event Y coordinate relative to the holding container
+     * @type {number}
+     */
+    gameLocalY: number;
+    /**
+     * The unique identifier of the contact for a touch, mouse or pen
+     * @type {number}
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/pointerId}
+     */
+    pointerId: number;
+    /**
+     * true if not originally a pointer event
+     * @type {boolean}
+     */
+    isNormalized: boolean;
+    /**
+     * true if the pointer is currently locked
+     * @type {boolean}
+     */
+    locked: boolean;
+    bind: number[];
+    /**
+     * initialize the Pointer object using the given Event Object
+     * @private
+     * @param {Event} event - the original Event object
+     * @param {number} [pageX=0] - the horizontal coordinate at which the event occurred, relative to the left edge of the entire document
+     * @param {number} [pageY=0] - the vertical coordinate at which the event occurred, relative to the left edge of the entire document
+     * @param {number} [clientX=0] - the horizontal coordinate within the application's client area at which the event occurred
+     * @param {number} [clientY=0] - the vertical coordinate within the application's client area at which the event occurred
+     * @param {number} [pointerId=1] - the Pointer, Touch or Mouse event Id (1)
+     */
+    private setEvent;
+}
+import { Bounds } from "./../physics/bounds.ts";
+//# sourceMappingURL=pointer.d.ts.map

package/build/input/pointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointer.d.ts","sourceRoot":"","sources":["../../src/input/pointer.js"],"names":[],"mappings":";AAYA;;GAEG;AACH;IACC;;OAEG;IACH,4DAuMC;IAhMA;;;;OAIG;IACH,aAFU,MAAM,CAEH;IAEb;;;;OAIG;IACH,eAFU,MAAM,CAED;IAEf;;;;OAIG;IACH,cAFU,MAAM,CAEF;IAEd;;;;;;OAMG;IACH,OALU,YAAY,GAAC,UAAU,GAAC,UAAU,CAKtB;IAStB;;;;OAIG;IACH,QAHU,MAAM,CAGD;IAEf;;;;OAIG;IACH,WAHU,OAAO,CAGK;IAEtB;;;;OAIG;IACH,OAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,OAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,SAHU,MAAM,CAGA;IAEhB;;;;OAIG;IACH,SAHU,MAAM,CAGA;IAEhB;;;;OAIG;IACH,WAHU,MAAM,CAGE;IAElB;;;;OAIG;IACH,WAHU,MAAM,CAGE;IAElB;;;;OAIG;IACH,WAHU,MAAM,CAGE;IAElB;;;;OAIG;IACH,QAHU,MAAM,CAGD;IAEf;;;;OAIG;IACH,QAHU,MAAM,CAGD;IAEf;;;;OAIG;IACH,QAHU,MAAM,CAGD;IAEf;;;;OAIG;IACH,OAFU,MAAM,CAEF;IAEd;;;;OAIG;IACH,OAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,aAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,aAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,YAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,YAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,YAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,YAFU,MAAM,CAEG;IAEnB;;;;OAIG;IACH,WAHU,MAAM,CAGU;IAE1B;;;OAGG;IACH,cAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,QAFU,OAAO,CAEE;IAGnB,eAAqB;IAGtB;;;;;;;;;OASG;IACH,iBAyEC;CACD;uBA9SsB,wBAAwB"}

package/{dist/types → build}/input/pointerevent.d.ts

@@ -7,7 +7,7 @@ export function hasActiveEvents(): boolean;
 /**
  * return true if there are register pointer events
  * @memberof input
- * @see registerPointerEvent
+ * @see {@link registerPointerEvent}
  * @returns true if there are pending events
  */
 export function hasRegisteredEvents(): boolean;
@@ -26,16 +26,16 @@ export function hasRegisteredEvents(): boolean;
  *    // do something with pos !
  * };
  */
-export function globalToLocal(x: number, y: number, v?: any): Vector2d;
+export function globalToLocal(x: number, y: number, v?: Vector2d): Vector2d;
 /**
  * enable/disable all gestures on the given element.<br>
  * by default melonJS will disable browser handling of all panning and zooming gestures.
  * @memberof input
- * @see https://developer.mozilla.org/en-US/docs/Web/CSS/touch-action
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/CSS/touch-action}
  * @param {HTMLCanvasElement} element
  * @param {string} [value="none"]
  */
-export function setTouchAction(element: HTMLCanvasElement, value?: string | undefined): void;
+export function setTouchAction(element: HTMLCanvasElement, value?: string): void;
 /**
  * Associate a pointer event to a keycode<br>
  * Left button – 0
@@ -60,12 +60,12 @@ export function bindPointer(...args: any[]): void;
  * @example
  * me.input.unbindPointer(me.input.pointer.LEFT);
  */
-export function unbindPointer(button?: number | undefined): void;
+export function unbindPointer(button?: number): void;
 /**
  * allows registration of event listeners on the object target. <br>
  * melonJS will pass a me.Pointer object to the defined callback.
  * @see Pointer
- * @see {@link http://www.w3.org/TR/pointerevents/#list-of-pointer-events|W3C Pointer Event list}
+ * @see {@link http://www.w3.org/TR/pointerevents/#list-of-pointer-events | W3C Pointer Event list}
  * @memberof input
  * @param {string} eventType - The event type for which the object is registering <br>
  * melonJS currently supports: <br>
@@ -109,7 +109,7 @@ export function registerPointerEvent(eventType: string, region: Rect | Polygon |
  * // release the registered region on the 'pointerdown' event
  * me.input.releasePointerEvent('pointerdown', this);
  */
-export function releasePointerEvent(eventType: string, region: Rect | Polygon | Line | Ellipse, callback?: Function | undefined): void;
+export function releasePointerEvent(eventType: string, region: Rect | Polygon | Line | Ellipse, callback?: Function): void;
 /**
  * allows the removal of all registered event listeners from the object target.
  * @memberof input
@@ -140,12 +140,12 @@ export function requestPointerLock(): boolean;
  */
 export function exitPointerLock(): boolean;
 /**
-  * the default target element for pointer events (usually the canvas element in which the game is rendered)
-  * @public
-  * @type {EventTarget}
-  * @name pointerEventTarget
-  * @memberof input
-  */
+ * the default target element for pointer events (usually the canvas element in which the game is rendered)
+ * @public
+ * @type {EventTarget}
+ * @name pointerEventTarget
+ * @memberof input
+ */
 export let pointerEventTarget: EventTarget;
 /**
  * Pointer information (current position and size)
@@ -154,7 +154,7 @@ export let pointerEventTarget: EventTarget;
  * @name pointer
  * @memberof input
  */
-export let pointer: Rect;
+export const pointer: Rect;
 /**
  * indicates if the pointer is currently locked
  * @public
@@ -173,4 +173,6 @@ export let locked: boolean;
  * @memberof input
  */
 export let throttlingInterval: number;
-import Rect from "./../geometries/rectangle.js";
+import type { Vector2d } from "../math/vector2d.js";
+import { Rect } from "./../geometries/rectangle.ts";
+//# sourceMappingURL=pointerevent.d.ts.map

package/build/input/pointerevent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointerevent.d.ts","sourceRoot":"","sources":["../../src/input/pointerevent.js"],"names":[],"mappings":"AA6iBA;;;;GAIG;AACH,2CAEC;AAED;;;;;GAKG;AACH,+CAEC;AAED;;;;;;;;;;;;;;GAcG;AACH,iCAXW,MAAM,KACN,MAAM,MACN,QAAQ,GACN,QAAQ,CAoBpB;AAED;;;;;;;GAOG;AACH,wCAHW,iBAAiB,UACjB,MAAM,QAIhB;AAED;;;;;;;;;;;;;;;GAeG;AACH,kDAaC;AAED;;;;;;GAMG;AACH,uCAJW,MAAM,QAOhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,gDA9BW,MAAM,UAYN,IAAI,GAAC,OAAO,GAAC,IAAI,GAAC,OAAO,4BA0DnC;AAED;;;;;;;;;;GAUG;AACH,+CAPW,MAAM,UACN,IAAI,GAAC,OAAO,GAAC,IAAI,GAAC,OAAO,6BAuCnC;AAED;;;;;;;GAOG;AACH,gDALW,IAAI,GAAC,OAAO,GAAC,IAAI,GAAC,OAAO,QAWnC;AAED;;;;;;;;;;;;GAYG;AACH,sCATa,OAAO,CAgBnB;AAED;;;;GAIG;AACH,mCAFa,OAAO,CAQnB;AA1TD;;;;;;GAMG;AACH,+BAJU,WAAW,CAIgB;AAErC;;;;;;GAMG;AACH,sBAJU,IAAI,CAIiC;AAE/C;;;;;;GAMG;AACH,mBAJU,OAAO,CAIS;AAE1B;;;;;;;;GAQG;AACH,+BAJU,MAAM,CAIc;8BAzhBH,qBAAqB;qBAlB3B,8BAA8B"}

package/{dist/types → build}/lang/console.d.ts

@@ -5,3 +5,4 @@
  * @param {string} version - the version since when the lass,function or property is deprecated
  */
 export function warning(deprecated: string, replacement: string, version: string): void;
+//# sourceMappingURL=console.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../src/lang/console.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oCAJW,MAAM,eACN,MAAM,WACN,MAAM,QA4BhB"}

package/build/lang/deprecated.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @deprecated since 17.1.0
+ * @see CanvasRenderTarget
+ */
+export class CanvasTexture extends CanvasRenderTarget {
+    /**
+     * @param {number} width - the desired width of the canvas
+     * @param {number} height - the desired height of the canvas
+     * @param {object} attributes - The attributes to create both the canvas and context
+     * @param {boolean} [attributes.context="2d"] - the context type to be created ("2d", "webgl", "webgl2")
+     * @param {boolean} [attributes.offscreenCanvas=false] - will create an offscreenCanvas if true instead of a standard canvas
+     * @param {boolean} [attributes.willReadFrequently=false] - Indicates whether or not a lot of read-back operations are planned
+     * @param {boolean} [attributes.antiAlias=false] - Whether to enable anti-aliasing, use false (default) for a pixelated effect.
+     */
+    constructor(width: number, height: number, attributes: {
+        context?: boolean | undefined;
+        offscreenCanvas?: boolean | undefined;
+        willReadFrequently?: boolean | undefined;
+        antiAlias?: boolean | undefined;
+    });
+}
+export * as Math from "./../math/math.ts";
+import CanvasRenderTarget from "../video/rendertarget/canvasrendertarget.js";
+//# sourceMappingURL=deprecated.d.ts.map

package/build/lang/deprecated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deprecated.d.ts","sourceRoot":"","sources":["../../src/lang/deprecated.js"],"names":[],"mappings":"AASA;;;GAGG;AACH;IACC;;;;;;;;OAQG;IACH,mBARW,MAAM,UACN,MAAM,cAEd;QAA6B,OAAO;QACP,eAAe;QACf,kBAAkB;QAClB,SAAS;KACxC,EAIA;CACD;;+BA1B8B,6CAA6C"}

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

@@ -1,5 +1,4 @@
-export default level;
-declare namespace level {
+export namespace level {
     /**
      * add a level into the game manager (usually called by the preloader)
      * @name add
@@ -10,7 +9,7 @@ declare namespace level {
      * @param {Function} [callback] - a function to be called once the level is loaded
      * @returns {boolean} true if the level was loaded
      */
-    function add(format: string, levelId: string, callback?: Function | undefined): boolean;
+    function add(format: string, levelId: string, callback?: Function): boolean;
     /**
      * load a level into the game manager<br>
      * (will also create all level defined entities, etc..)
@@ -55,7 +54,7 @@ declare namespace level {
         onLoaded?: Function | undefined;
         flatten?: boolean | undefined;
         setViewportBounds?: boolean | undefined;
-    } | undefined): boolean;
+    }): boolean;
     /**
      * return the current level id<br>
      * @name getCurrentLevelId
@@ -89,7 +88,7 @@ declare namespace level {
         container?: any;
         onLoaded?: Function | undefined;
         flatten?: boolean | undefined;
-    } | undefined): object;
+    }): object;
     /**
      * load the next level
      * @name next
@@ -105,7 +104,7 @@ declare namespace level {
         container?: any;
         onLoaded?: Function | undefined;
         flatten?: boolean | undefined;
-    } | undefined): boolean;
+    }): boolean;
     /**
      * load the previous level<br>
      * @name previous
@@ -121,7 +120,7 @@ declare namespace level {
         container?: any;
         onLoaded?: Function | undefined;
         flatten?: boolean | undefined;
-    } | undefined): boolean;
+    }): boolean;
     /**
      * return the amount of level preloaded
      * @name levelCount
@@ -132,3 +131,4 @@ declare namespace level {
     function levelCount(): number;
 }
 import TMXTileMap from "./tiled/TMXTileMap.js";
+//# sourceMappingURL=level.d.ts.map

package/build/level/level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"level.d.ts","sourceRoot":"","sources":["../../src/level/level.js"],"names":[],"mappings":";IAkFC;;;;;;;;;OASG;IACH,qBALW,MAAM,WACN,MAAM,wBAEJ,OAAO,CA0BnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,uBAjCW,MAAM,YAEd;QAA4B,SAAS;QACV,QAAQ;QACT,OAAO;QACP,iBAAiB;KAC3C,GAAU,OAAO,CA8DnB;IAED;;;;;;OAMG;IACH,8BAFa,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,4BAFa,UAAU,CAItB;IAED;;;;;;;;;;OAUG;IACH,0BALG;QAA4B,SAAS;QACV,QAAQ;QACT,OAAO;KACjC,GAAU,MAAM,CAMlB;IAED;;;;;;;;;;OAUG;IACH,wBALG;QAA4B,SAAS;QACV,QAAQ;QACT,OAAO;KACjC,GAAU,OAAO,CASnB;IAED;;;;;;;;;;OAUG;IACH,4BALG;QAA4B,SAAS;QACV,QAAQ;QACT,OAAO;KACjC,GAAU,OAAO,CASnB;IAED;;;;;;OAMG;IACH,uBAFa,MAAM,CAIlB;;uBAvRqB,uBAAuB"}

package/{dist/types → build}/level/tiled/TMXGroup.d.ts

@@ -1,5 +1,4 @@
 /**
- * @classdesc
  * object group definition as defined in Tiled.
  * (group definition is translated into the virtual `me.game.world` using `me.Container`)
  * @ignore
@@ -38,7 +37,7 @@ export default class TMXGroup {
     z: number;
     /**
      * group objects list definition
-     * @see TMXObject
+     * @see {@link TMXObject}
      * @type {object[]}
      */
     objects: object[];
@@ -59,3 +58,4 @@ export default class TMXGroup {
      */
     getObjectByIndex(idx: any): object;
 }
+//# sourceMappingURL=TMXGroup.d.ts.map

package/build/level/tiled/TMXGroup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TMXGroup.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXGroup.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH;IACC,yCA6EC;IA5EA;;;OAGG;IACH,MAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,OAFU,MAAM,CAEY;IAE5B;;;OAGG;IACH,QAFU,MAAM,CAEc;IAE9B;;;OAGG;IACH,WAFU,MAAM,CAEe;IAE/B;;;OAGG;IACH,OAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,GAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,SAFU,MAAM,EAAE,CAED;IAGjB,gBAA2E;IAkC5E;;;OAGG;IACH,gBAGC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,mCAEC;CACD"}