melonjs 11.0.0 → 13.1.0

package/dist/melonjs.module.d.ts

@@ -234,22 +234,24 @@ export class Body {
      */
     public collisionType: number;
     /**
-     * body velocity
+     * The current velocity of the body.
+     * See to apply a force if you need to modify a body velocity
+     * @see Body.force
      * @public
      * @type {Vector2d}
      * @default <0,0>
      */
     public vel: Vector2d;
     /**
-     * body force or acceleration (automatically) applied to the body.
-     * when defining a force, user should also define a max velocity
+     * body force to apply to this the body in the current step.
+     * (any positive or negative force will be cancelled after every world/body update cycle)
      * @public
      * @type {Vector2d}
      * @default <0,0>
      * @see Body.setMaxVelocity
      * @example
      * // define a default maximum acceleration, initial force and friction
-     * this.body.force.set(0, 0);
+     * this.body.force.set(1, 0);
      * this.body.friction.set(0.4, 0);
      * this.body.setMaxVelocity(3, 15);
      *
@@ -259,8 +261,6 @@ export class Body {
      *          this.body.force.x = -this.body.maxVel.x;
      *      } else if (me.input.isKeyPressed("right")) {
      *         this.body.force.x = this.body.maxVel.x;
-     *     } else {
-     *         this.body.force.x = 0;
      *     }
      * }
      */
@@ -486,23 +486,14 @@ export class Body {
      * @param {number} y vertical friction
      */
     setFriction(x?: number, y?: number): void;
-    /**
-     * compute the new velocity value
-     * @ignore
-     */
-    computeVelocity(): void;
     /**
      * Updates the parent's position as well as computes the new body's velocity based
-     * on the values of force/friction/gravity.  Velocity chages are proportional to the
+     * on the values of force/friction.  Velocity chages are proportional to the
      * me.timer.tick value (which can be used to scale velocities).  The approach to moving the
      * parent renderable is to compute new values of the Body.vel property then add them to
      * the parent.pos value thus changing the postion the amount of Body.vel each time the
      * update call is made. <br>
      * Updates to Body.vel are bounded by maxVel (which defaults to viewport size if not set) <br>
-     *
-     * In addition, when the gravity calcuation is made, if the Body.vel.y > 0 then the Body.falling
-     * property is set to true and Body.jumping is set to !Body.falling.
-     *
      * At this time a call to Body.Update does not call the onBodyUpdate callback that is listed in the constructor arguments.
      * @protected
      * @param {number} dt time since the last update in milliseconds.
@@ -1058,7 +1049,6 @@ export class CanvasRenderer extends Renderer {
      * @param {number} options.width The width of the canvas without scaling
      * @param {number} options.height The height of the canvas without scaling
      * @param {HTMLCanvasElement} [options.canvas] The html canvas to draw to on screen
-     * @param {boolean} [options.doubleBuffering=false] Whether to enable double buffering
      * @param {boolean} [options.antiAlias=false] Whether to enable anti-aliasing
      * @param {boolean} [options.transparent=false] Whether to enable transparency on the canvas (performance hit when enabled)
      * @param {boolean} [options.subPixel=false] Whether to enable subpixel renderering (performance hit when enabled)
@@ -1070,7 +1060,6 @@ export class CanvasRenderer extends Renderer {
         width: number;
         height: number;
         canvas?: HTMLCanvasElement;
-        doubleBuffering?: boolean;
         antiAlias?: boolean;
         transparent?: boolean;
         subPixel?: boolean;
@@ -1079,8 +1068,6 @@ export class CanvasRenderer extends Renderer {
         zoomY?: number;
     });
     context: CanvasRenderingContext2D;
-    backBufferCanvas: HTMLCanvasElement | OffscreenCanvas;
-    backBufferContext2D: CanvasRenderingContext2D;
     cache: TextureCache;
     /**
      * Reset the canvas transform to identity
@@ -1106,12 +1093,6 @@ export class CanvasRenderer extends Renderer {
      * @param {CanvasRenderingContext2D} [context]
      */
     setBlendMode(mode?: string, context?: CanvasRenderingContext2D): void;
-    /**
-     * render the main framebuffer on screen
-     * @name flush
-     * @memberof CanvasRenderer
-     */
-    flush(): void;
     /**
      * Clears the main framebuffer with the given color
      * @name clearColor
@@ -1304,18 +1285,11 @@ export class CanvasRenderer extends Renderer {
      * @param {number} radius
      */
     fillRoundRect(x: number, y: number, width: number, height: number, radius: number): void;
-    /**
-     * return a reference to the system 2d Context
-     * @name getContext
-     * @memberof CanvasRenderer
-     * @returns {CanvasRenderingContext2D}
-     */
-    getContext(): CanvasRenderingContext2D;
     /**
      * return a reference to the font 2d Context
      * @ignore
      */
-    getFontContext(): CanvasRenderingContext2D;
+    getFontContext(): CanvasRenderingContext2D | WebGLRenderingContext;
     /**
      * save the canvas context
      * @name save
@@ -1458,34 +1432,28 @@ export class Color {
     /**
      * Color Red Component [0 .. 255]
      * @type {number}
-     * @memberof Color
      */
     get r(): number;
     set g(arg: number);
     /**
      * Color Green Component [0 .. 255]
      * @type {number}
-     * @memberof Color
      */
     get g(): number;
     set b(arg: number);
     /**
      * Color Blue Component [0 .. 255]
      * @type {number}
-     * @memberof Color
      */
     get b(): number;
     set alpha(arg: number);
     /**
      * Color Alpha Component [0.0 .. 1.0]
      * @type {number}
-     * @memberof Color
      */
     get alpha(): number;
     /**
      * Set this color to the specified value.
-     * @name setColor
-     * @memberof Color
      * @param {number} r red component [0 .. 255]
      * @param {number} g green component [0 .. 255]
      * @param {number} b blue component [0 .. 255]
@@ -1493,41 +1461,47 @@ export class Color {
      * @returns {Color} Reference to this object for method chaining
      */
     setColor(r: number, g: number, b: number, alpha?: number): Color;
+    /**
+     * set this color to the specified HSV value
+     * @param {number} h hue (a value from 0 to 1)
+     * @param {number} s saturation (a value from 0 to 1)
+     * @param {number} v value (a value from 0 to 1)
+     * @returns {Color} Reference to this object for method chaining
+     */
+    setHSV(h: number, s: number, v: number): Color;
+    /**
+     * set this color to the specified HSL value
+     * @param {number} h hue (a value from 0 to 1)
+     * @param {number} s saturation (a value from 0 to 1)
+     * @param {number} l lightness (a value from 0 to 1)
+     * @returns {Color} Reference to this object for method chaining
+     */
+    setHSL(h: number, s: number, l: number): Color;
     /**
      * Create a new copy of this color object.
-     * @name clone
-     * @memberof Color
      * @returns {Color} Reference to the newly cloned object
      */
     clone(): Color;
     /**
      * Copy a color object or CSS color into this one.
-     * @name copy
-     * @memberof Color
      * @param {Color|string} color
      * @returns {Color} Reference to this object for method chaining
      */
     copy(color: Color | string): Color;
     /**
      * Blend this color with the given one using addition.
-     * @name add
-     * @memberof Color
      * @param {Color} color
      * @returns {Color} Reference to this object for method chaining
      */
     add(color: Color): Color;
     /**
      * Darken this color value by 0..1
-     * @name darken
-     * @memberof Color
      * @param {number} scale
      * @returns {Color} Reference to this object for method chaining
      */
     darken(scale: number): Color;
     /**
      * Linearly interpolate between this color and the given one.
-     * @name lerp
-     * @memberof Color
      * @param {Color} color
      * @param {number} alpha with alpha = 0 being this color, and alpha = 1 being the given one.
      * @returns {Color} Reference to this object for method chaining
@@ -1535,16 +1509,12 @@ export class Color {
     lerp(color: Color, alpha: number): Color;
     /**
      * Lighten this color value by 0..1
-     * @name lighten
-     * @memberof Color
      * @param {number} scale
      * @returns {Color} Reference to this object for method chaining
      */
     lighten(scale: number): Color;
     /**
      * Generate random r,g,b values for this color object
-     * @name random
-     * @memberof Color
      * @param {number} [min=0] minimum value for the random range
      * @param {number} [max=255] maxmium value for the random range
      * @returns {Color} Reference to this object for method chaining
@@ -1553,8 +1523,6 @@ export class Color {
     /**
      * Return true if the r,g,b,a values of this color are equal with the
      * given one.
-     * @name equals
-     * @memberof Color
      * @param {Color} color
      * @returns {boolean}
      */
@@ -1562,16 +1530,12 @@ export class Color {
     /**
      * Parse a CSS color string and set this color to the corresponding
      * r,g,b values
-     * @name parseCSS
-     * @memberof Color
      * @param {string} cssColor
      * @returns {Color} Reference to this object for method chaining
      */
     parseCSS(cssColor: string): Color;
     /**
      * Parse an RGB or RGBA CSS color string
-     * @name parseRGB
-     * @memberof Color
      * @param {string} rgbColor
      * @returns {Color} Reference to this object for method chaining
      */
@@ -1579,8 +1543,6 @@ export class Color {
     /**
      * Parse a Hex color ("#RGB", "#RGBA" or "#RRGGBB", "#RRGGBBAA" format) and set this color to
      * the corresponding r,g,b,a values
-     * @name parseHex
-     * @memberof Color
      * @param {string} hexColor
      * @param {boolean} [argb = false] true if format is #ARGB, or #AARRGGBB (as opposed to #RGBA or #RGGBBAA)
      * @returns {Color} Reference to this object for method chaining
@@ -1588,44 +1550,32 @@ export class Color {
     parseHex(hexColor: string, argb?: boolean): Color;
     /**
      * Pack this color into a Uint32 ARGB representation
-     * @name toUint32
-     * @memberof Color
      * @param {number} [alpha=1.0] alpha value [0.0 .. 1.0]
      * @returns {number}
      */
     toUint32(alpha?: number): number;
     /**
      * return an array representation of this object
-     * @name toArray
-     * @memberof Color
      * @returns {Float32Array}
      */
     toArray(): Float32Array;
     /**
-     * Get the color in "#RRGGBB" format
-     * @name toHex
-     * @memberof Color
+     * return the color in "#RRGGBB" format
      * @returns {string}
      */
     toHex(): string;
     /**
      * Get the color in "#RRGGBBAA" format
-     * @name toHex8
-     * @memberof Color
      * @returns {string}
      */
     toHex8(alpha?: number): string;
     /**
      * Get the color in "rgb(R,G,B)" format
-     * @name toRGB
-     * @memberof Color
      * @returns {string}
      */
     toRGB(): string;
     /**
      * Get the color in "rgba(R,G,B,A)" format
-     * @name toRGBA
-     * @memberof Color
      * @param {number} [alpha=1.0] alpha value [0.0 .. 1.0]
      * @returns {string}
      */
@@ -1956,7 +1906,7 @@ export class Container extends Renderable {
      * @memberof Container
      * @public
      * @param {Renderable} child
-     * @param {boolean} [keepalive=False] True to prevent calling child.destroy()
+     * @param {boolean} [keepalive=false] true to prevent calling child.destroy()
      */
     public removeChild(child: Renderable, keepalive?: boolean): void;
     /**
@@ -3626,6 +3576,15 @@ export class ObservableVector2d extends Vector2d {
      * @returns {ObservableVector2d} Reference to this object for method chaining
      */
     lerp(v: Vector2d | ObservableVector2d, alpha: number): ObservableVector2d;
+    /**
+     * interpolate the position of this vector towards the given one while nsure that the distance never exceeds the given step.
+     * @name moveTowards
+     * @memberof ObservableVector2d
+     * @param {Vector2d|ObservableVector2d} target
+     * @param {number} step the maximum step per iteration (Negative values will push the vector away from the target)
+     * @returns {ObservableVector2d} Reference to this object for method chaining
+     */
+    moveTowards(target: Vector2d | ObservableVector2d, step: number): ObservableVector2d;
     /**
      * return the distance between this vector and the passed one
      * @name distance
@@ -3909,6 +3868,15 @@ export class ObservableVector3d extends Vector3d {
      * @returns {ObservableVector3d} Reference to this object for method chaining
      */
     lerp(v: Vector3d | ObservableVector3d, alpha: number): ObservableVector3d;
+    /**
+     * interpolate the position of this vector on the x and y axis towards the given one while ensure that the distance never exceeds the given step.
+     * @name moveTowards
+     * @memberof ObservableVector3d
+     * @param {Vector2d|ObservableVector2d|Vector3d|ObservableVector3d} target
+     * @param {number} step the maximum step per iteration (Negative values will push the vector away from the target)
+     * @returns {ObservableVector3d} Reference to this object for method chaining
+     */
+    moveTowards(target: Vector2d | ObservableVector2d | Vector3d | ObservableVector3d, step: number): ObservableVector3d;
     /**
      * return the distance between this vector and the passed one
      * @name distance
@@ -5409,16 +5377,18 @@ export class Polygon {
  */
 export class QuadTree {
     /**
+     * @param {World} world the physic world this QuadTree belongs to
      * @param {Bounds} bounds bounds of the node
      * @param {number} [max_objects=4] max objects a node can hold before splitting into 4 subnodes
      * @param {number} [max_levels=4] total max levels inside root Quadtree
      * @param {number} [level] deepth level, required for subnodes
      */
-    constructor(bounds: Bounds, max_objects?: number, max_levels?: number, level?: number);
+    constructor(world: World, bounds: Bounds, max_objects?: number, max_levels?: number, level?: number);
+    world: World;
+    bounds: Bounds;
     max_objects: number;
     max_levels: number;
     level: number;
-    bounds: Bounds;
     objects: any[];
     nodes: any[];
     split(): void;
@@ -6159,7 +6129,6 @@ export class Renderer {
      * @param {number} options.width The width of the canvas without scaling
      * @param {number} options.height The height of the canvas without scaling
      * @param {HTMLCanvasElement} [options.canvas] The html canvas to draw to on screen
-     * @param {boolean} [options.doubleBuffering=false] Whether to enable double buffering
      * @param {boolean} [options.antiAlias=false] Whether to enable anti-aliasing, use false (default) for a pixelated effect.
      * @param {boolean} [options.failIfMajorPerformanceCaveat=true] If true, the renderer will switch to CANVAS mode if the performances of a WebGL context would be dramatically lower than that of a native application making equivalent OpenGL calls.
      * @param {boolean} [options.transparent=false] Whether to enable transparency on the canvas (performance hit when enabled)
@@ -6173,7 +6142,6 @@ export class Renderer {
         width: number;
         height: number;
         canvas?: HTMLCanvasElement;
-        doubleBuffering?: boolean;
         antiAlias?: boolean;
         failIfMajorPerformanceCaveat?: boolean;
         transparent?: boolean;
@@ -6219,8 +6187,6 @@ export class Renderer {
      */
     currentBlendMode: string;
     canvas: any;
-    backBufferCanvas: any;
-    context: any;
     currentColor: Color;
     currentTint: Color;
     projectionMatrix: Matrix3d;
@@ -6231,6 +6197,12 @@ export class Renderer {
      * @memberof Renderer
      */
     clear(): void;
+    /**
+     * render the main framebuffer on screen
+     * @name flush
+     * @memberof Renderer
+     */
+    flush(): void;
     /**
      * Reset context state
      * @name reset
@@ -6238,27 +6210,19 @@ export class Renderer {
      */
     reset(): void;
     /**
-     * return a reference to the system canvas
+     * return a reference to the canvas which this renderer draws to
      * @name getCanvas
      * @memberof Renderer
      * @returns {HTMLCanvasElement}
      */
     getCanvas(): HTMLCanvasElement;
     /**
-     * return a reference to the screen canvas
-     * @name getScreenCanvas
-     * @memberof Renderer
-     * @returns {HTMLCanvasElement}
-     */
-    getScreenCanvas(): HTMLCanvasElement;
-    /**
-     * return a reference to the screen canvas corresponding 2d Context<br>
-     * (will return buffered context if double buffering is enabled, or a reference to the Screen Context)
-     * @name getScreenContext
+     * return a reference to this renderer canvas corresponding Context
+     * @name getContext
      * @memberof Renderer
-     * @returns {CanvasRenderingContext2D}
+     * @returns {CanvasRenderingContext2D|WebGLRenderingContext}
      */
-    getScreenContext(): CanvasRenderingContext2D;
+    getContext(): CanvasRenderingContext2D | WebGLRenderingContext;
     /**
      * returns the current blend mode for this renderer
      * @name getBlendMode
@@ -6397,6 +6361,25 @@ export class Renderer {
      */
     drawFont(): void;
     get Texture(): typeof TextureAtlas;
+    /**
+     * return a reference to the screen canvas
+     * @name getScreenCanvas
+     * @memberof Renderer
+     * @returns {HTMLCanvasElement}
+     * @deprecated since 13.1.0
+     * @see getCanvas();
+     */
+    getScreenCanvas(): HTMLCanvasElement;
+    /**
+     * return a reference to the screen canvas corresponding 2d Context<br>
+     * (will return buffered context if double buffering is enabled, or a reference to the Screen Context)
+     * @name getScreenContext
+     * @memberof Renderer
+     * @returns {CanvasRenderingContext2D}
+     * @deprecated since 13.1.0
+     * @see getContext();
+     */
+    getScreenContext(): CanvasRenderingContext2D;
 }
 /**
  * @classdesc
@@ -7004,6 +6987,14 @@ export class TMXLayer extends Renderable {
      * @name TMXLayer#renderorder
      */
     public renderorder: string;
+    /**
+     * the layer class
+     * @public
+     * @type {string}
+     * @name class
+     * @name TMXLayer#class
+     */
+    public class: string;
     name: any;
     cols: number;
     rows: number;
@@ -7335,6 +7326,13 @@ export class TMXTileMap {
      * @name TMXTileMap#tiledversion
      */
     public tiledversion: string;
+    /**
+     * The map class.
+     * @public
+     * @type {string}
+     * @name TMXTileMap#class
+     */
+    public class: string;
     tilesets: TMXTilesetGroup;
     layers: any[];
     objectGroups: any[];
@@ -7440,6 +7438,13 @@ export class TMXTileset {
      * @name TMXTileset#isCollection
      */
     public isCollection: boolean;
+    /**
+     * the tileset class
+     * @public
+     * @type {boolean}
+     * @name TMXTileset#class
+     */
+    public class: boolean;
     /**
      * Tileset animations
      * @private
@@ -7630,9 +7635,6 @@ export class Text extends Renderable {
     public fontSize: number;
     canvasTexture: any;
     metrics: TextMetrics;
-    /** @ignore */
-    onDeactivateEvent(): void;
-    glTextureUnit: any;
     /**
      * make the font bold
      * @returns {Text} this object for chaining
@@ -7660,6 +7662,7 @@ export class Text extends Renderable {
      * @returns {Text} this object for chaining
      */
     setText(value?: number | string | string[]): Text;
+    glTextureUnit: any;
     /**
      * measure the given text size in pixels
      * @param {CanvasRenderer|WebGLRenderer} renderer reference to the active renderer
@@ -8472,6 +8475,15 @@ export class Vector2d {
      * @returns {Vector2d} Reference to this object for method chaining
      */
     lerp(v: Vector2d, alpha: number): Vector2d;
+    /**
+     * interpolate the position of this vector towards the given one by the given maximum step.
+     * @name moveTowards
+     * @memberof Vector2d
+     * @param {Vector2d} target
+     * @param {number} step the maximum step per iteration (Negative values will push the vector away from the target)
+     * @returns {Vector2d} Reference to this object for method chaining
+     */
+    moveTowards(target: Vector2d, step: number): Vector2d;
     /**
      * return the distance between this vector and the passed one
      * @name distance
@@ -8795,6 +8807,15 @@ export class Vector3d {
      * @returns {Vector3d} Reference to this object for method chaining
      */
     lerp(v: Vector3d, alpha: number): Vector3d;
+    /**
+     * interpolate the position of this vector on the x and y axis towards the given one by the given maximum step.
+     * @name moveTowards
+     * @memberof Vector3d
+     * @param {Vector2d|Vector3d} target
+     * @param {number} step the maximum step per iteration (Negative values will push the vector away from the target)
+     * @returns {Vector3d} Reference to this object for method chaining
+     */
+    moveTowards(target: Vector2d | Vector3d, step: number): Vector3d;
     /**
      * return the distance between this vector and the passed one
      * @name distance
@@ -9058,7 +9079,6 @@ export class WebGLRenderer extends Renderer {
      * @param {number} options.width The width of the canvas without scaling
      * @param {number} options.height The height of the canvas without scaling
      * @param {HTMLCanvasElement} [options.canvas] The html canvas to draw to on screen
-     * @param {boolean} [options.doubleBuffering=false] Whether to enable double buffering
      * @param {boolean} [options.antiAlias=false] Whether to enable anti-aliasing
      * @param {boolean} [options.failIfMajorPerformanceCaveat=true] If true, the renderer will switch to CANVAS mode if the performances of a WebGL context would be dramatically lower than that of a native application making equivalent OpenGL calls.
      * @param {boolean} [options.transparent=false] Whether to enable transparency on the canvas (performance hit when enabled)
@@ -9073,7 +9093,6 @@ export class WebGLRenderer extends Renderer {
         width: number;
         height: number;
         canvas?: HTMLCanvasElement;
-        doubleBuffering?: boolean;
         antiAlias?: boolean;
         failIfMajorPerformanceCaveat?: boolean;
         transparent?: boolean;
@@ -9205,12 +9224,6 @@ export class WebGLRenderer extends Renderer {
      * var basic      = renderer.createPattern(image, "no-repeat");
      */
     createPattern(image: new (width?: number, height?: number) => HTMLImageElement, repeat: string): TextureAtlas;
-    /**
-     * Flush the compositor to the frame buffer
-     * @name flush
-     * @memberof WebGLRenderer
-     */
-    flush(): void;
     /**
      * Clears the gl context with the given color.
      * @name clearColor
@@ -9267,13 +9280,6 @@ export class WebGLRenderer extends Renderer {
      * @see WebGLRenderer#createPattern
      */
     drawPattern(pattern: TextureAtlas, x: number, y: number, width: number, height: number): void;
-    /**
-     * return a reference to the screen canvas corresponding WebGL Context
-     * @name getScreenContext
-     * @memberof WebGLRenderer
-     * @returns {WebGLRenderingContext}
-     */
-    getScreenContext(): WebGLRenderingContext;
     /**
      * Returns the WebGL Context object of the given Canvas
      * @name getContextGL
@@ -9562,6 +9568,12 @@ export class World extends Container {
      * @param {number} [height=game.viewport.height] height of the container
      */
     constructor(x?: number, y?: number, width?: number, height?: number);
+    /**
+     * the application (game) this physic world belong to
+     * @public
+     * @type {Application}
+     */
+    public app: Application;
     /**
      * the rate at which the game world is updated,
      * may be greater than or lower than the display fps
@@ -9629,6 +9641,14 @@ export class World extends Container {
      * @returns {World} this game world
      */
     removeBody(body: Body): World;
+    /**
+     * Apply gravity to the given body
+     * @name bodyApplyVelocity
+     * @memberof World
+     * @private
+     * @param {Body} body
+     */
+    private bodyApplyGravity;
 }
 export var audio: Readonly<{
     __proto__: any;
@@ -9740,29 +9760,7 @@ export namespace collision {
      */
     function rayCast(line: Line, result?: Renderable[]): Renderable[];
 }
-export namespace device {
-    const devicePixelRatio: number;
-    const isFullscreen: boolean;
-    const sound: boolean;
-    /**
-     * @public
-     * @name turnOnPointerLock
-     * @returns {boolean} return true if the request was successfully submitted
-     * @memberof device#
-     * @deprecated since 10.3.0
-     * @see input.requestPointerLock
-     */
-    function turnOnPointerLock(): boolean;
-    /**
-     * @public
-     * @name turnOffPointerLock
-     * @returns {boolean} return true if the request was successfully submitted
-     * @memberof device#
-     * @deprecated since 10.3.0
-     * @see input.exitPointerLock
-     */
-    function turnOffPointerLock(): boolean;
-}
+export var device: any;
 export var event: Readonly<{
     __proto__: any;
     DOM_READY: string;
@@ -9805,21 +9803,13 @@ export var event: Readonly<{
     once: typeof once;
     off: typeof off;
 }>;
-export var game: Readonly<{
-    __proto__: any;
-    readonly viewport: Camera2d;
-    readonly world: World;
-    mergeGroup: true;
-    sortOn: string;
-    readonly lastUpdate: number;
-    onLevelLoaded: typeof onLevelLoaded;
-    reset: typeof reset;
-    updateFrameRate: typeof updateFrameRate;
-    getParentContainer: typeof getParentContainer;
-    repaint: typeof repaint;
-    update: typeof update;
-    draw: typeof draw;
-}>;
+/**
+ * game is a default instance of a melonJS Application and represents your current game,
+ * it contains all the objects, tilemap layers, current viewport, collision map, etc...<br>
+ * @namespace game
+ * @see Application
+ */
+export let game: Application;
 /**
  * a flag indicating that melonJS is fully initialized
  * @type {boolean}
@@ -10154,7 +10144,7 @@ export namespace level {
      * @param {string} levelId level id
      * @param {object} [options] additional optional parameters
      * @param {Container} [options.container=game.world] container in which to load the specified level
-     * @param {Function} [options.onLoaded=ame.onLevelLoaded] callback for when the level is fully loaded
+     * @param {Function} [options.onLoaded=game.onLevelLoaded] callback for when the level is fully loaded
      * @param {boolean} [options.flatten=game.mergeGroup] if true, flatten all objects into the given container
      * @param {boolean} [options.setViewportBounds=true] if true, set the viewport bounds to the map size
      * @returns {boolean} true if the level was successfully loaded
@@ -10199,7 +10189,7 @@ export namespace level {
      * @param {string} levelId level id
      * @param {object} [options] additional optional parameters
      * @param {Container} [options.container=game.world] container in which to load the specified level
-     * @param {Function} [options.onLoaded=ame.onLevelLoaded] callback for when the level is fully loaded
+     * @param {Function} [options.onLoaded=game.onLevelLoaded] callback for when the level is fully loaded
      * @param {boolean} [options.flatten=game.mergeGroup] if true, flatten all objects into the given container
      * @param {boolean} [options.setViewportBounds=true] if true, set the viewport bounds to the map size
      * @returns {boolean} true if the level was successfully loaded
@@ -10468,6 +10458,8 @@ export namespace loader {
      *   {name: "tileset-platformer", type: "image",  src: "data/map/tileset.png"},
      *   // PNG packed texture
      *   {name: "texture", type:"image", src: "data/gfx/texture.png"}
+     *   // PNG base64 encoded image
+     *   {name: "texture", type:"image", src: "data:image/png;base64,iVBORw0KAAAQAAAAEACA..."}
      *   // TSX file
      *   {name: "meta_tiles", type: "tsx", src: "data/map/meta_tiles.tsx"},
      *   // TMX level (XML & JSON)
@@ -10478,6 +10470,8 @@ export namespace loader {
      *   // audio resources
      *   {name: "bgmusic", type: "audio",  src: "data/audio/"},
      *   {name: "cling",   type: "audio",  src: "data/audio/"},
+     *   // base64 encoded audio resources
+     *   {name: "band",   type: "audio",  src: "data:audio/wav;base64,..."},
      *   // binary file
      *   {name: "ymTrack", type: "binary", src: "data/audio/main.ym"},
      *   // JSON file (used for texturePacker)
@@ -10515,6 +10509,8 @@ export namespace loader {
      *   {name: "tileset-platformer", type: "image",  src: "data/map/tileset.png"},
      *   // PNG packed texture
      *   {name: "texture", type:"image", src: "data/gfx/texture.png"}
+     *   // PNG base64 encoded image
+     *   {name: "texture", type:"image", src: "data:image/png;base64,iVBORw0KAAAQAAAAEACA..."}
      *   // TSX file
      *   {name: "meta_tiles", type: "tsx", src: "data/map/meta_tiles.tsx"},
      *   // TMX level (XML & JSON)
@@ -10525,6 +10521,8 @@ export namespace loader {
      *   // audio resources
      *   {name: "bgmusic", type: "audio",  src: "data/audio/"},
      *   {name: "cling",   type: "audio",  src: "data/audio/"},
+     *   // base64 encoded audio resources
+     *   {name: "band",   type: "audio",  src: "data:audio/wav;base64,..."},
      *   // binary file
      *   {name: "ymTrack", type: "binary", src: "data/audio/main.ym"},
      *   // JSON file (used for texturePacker)
@@ -10554,13 +10552,14 @@ export namespace loader {
      * @param {string} res.type  "audio", binary", "image", "json", "tmx", "tsx"
      * @param {string} res.src  path and/or file name of the resource (for audio assets only the path is required)
      * @param {boolean} [res.stream] Set to true to force HTML5 Audio, which allows not to wait for large file to be downloaded before playing.
-     * @param {Function} onload function to be called when the resource is loaded
-     * @param {Function} onerror function to be called in case of error
+     * @param {Function} [onload] function to be called when the resource is loaded
+     * @param {Function} [onerror] function to be called in case of error
      * @returns {number} the amount of corresponding resource to be preloaded
      * @example
      * // load an image asset
      * me.loader.load({name: "avatar",  type:"image",  src: "data/avatar.png"}, this.onload.bind(this), this.onerror.bind(this));
-     *
+     * // load a base64 image asset
+     *  me.loader.load({name: "avatar", type:"image", src: "data:image/png;base64,iVBORw0KAAAQAAAAEACA..."};
      * // start loading music
      * me.loader.load({
      *     name   : "bgmusic",
@@ -10575,7 +10574,7 @@ export namespace loader {
         type: string;
         src: string;
         stream?: boolean;
-    }, onload: Function, onerror: Function): number;
+    }, onload?: Function, onerror?: Function): number;
     /**
      * Load a single resource (to be used if you need to load additional resource during the game)
      * @name load
@@ -10586,13 +10585,14 @@ export namespace loader {
      * @param {string} res.type  "audio", binary", "image", "json", "tmx", "tsx"
      * @param {string} res.src  path and/or file name of the resource (for audio assets only the path is required)
      * @param {boolean} [res.stream] Set to true to force HTML5 Audio, which allows not to wait for large file to be downloaded before playing.
-     * @param {Function} onload function to be called when the resource is loaded
-     * @param {Function} onerror function to be called in case of error
+     * @param {Function} [onload] function to be called when the resource is loaded
+     * @param {Function} [onerror] function to be called in case of error
      * @returns {number} the amount of corresponding resource to be preloaded
      * @example
      * // load an image asset
      * me.loader.load({name: "avatar",  type:"image",  src: "data/avatar.png"}, this.onload.bind(this), this.onerror.bind(this));
-     *
+     * // load a base64 image asset
+     *  me.loader.load({name: "avatar", type:"image", src: "data:image/png;base64,iVBORw0KAAAQAAAAEACA..."};
      * // start loading music
      * me.loader.load({
      *     name   : "bgmusic",
@@ -10607,7 +10607,7 @@ export namespace loader {
         type: string;
         src: string;
         stream?: boolean;
-    }, onload: Function, onerror: Function): number;
+    }, onload?: Function, onerror?: Function): number;
     /**
      * unload specified resource to free memory
      * @name unload
@@ -11115,20 +11115,6 @@ export namespace state {
      */
     export function isCurrent(state: number): boolean;
 }
-/**
- * the default global Timer instance
- * @namespace timer
- * @see Timer
- * @example
- * // set a timer to call "myFunction" after 1000ms
- * timer.setTimeout(myFunction, 1000);
- * // set a timer to call "myFunction" after 1000ms (respecting the pause state) and passing param1 and param2
- * timer.setTimeout(myFunction, 1000, true, param1, param2);
- * // set a timer to call "myFunction" every 1000ms
- * timer.setInterval(myFunction, 1000);
- * // set a timer to call "myFunction" every 1000ms (respecting the pause state) and passing param1 and param2
- * timer.setInterval(myFunction, 1000, true, param1, param2);
- */
 export const timer: Timer;
 export namespace utils {
     export { agentUtils as agent };
@@ -11157,7 +11143,7 @@ export var video: Readonly<{
     AUTO: 2;
     readonly parent: HTMLElement;
     scaleRatio: Vector2d;
-    readonly renderer: CanvasRenderer | WebGLRenderer;
+    readonly renderer: WebGLRenderer | CanvasRenderer;
     init: typeof init;
     createCanvas: typeof createCanvas;
     getParent: typeof getParent;
@@ -11593,6 +11579,109 @@ declare class VertexArrayBuffer {
      */
     isEmpty(): boolean;
 }
+/**
+ * @classdesc
+ * An Application represents a single melonJS game.
+ * An Application is responsible for updating (each frame) all the related object status and draw them.
+ * @see game
+ */
+declare class Application {
+    /**
+     * a reference to the current active stage "default" camera
+     * @public
+     * @type {Camera2d}
+     */
+    public viewport: Camera2d;
+    /**
+     * a reference to the game world, <br>
+     * a world is a virtual environment containing all the game objects
+     * @public
+     * @type {World}
+     */
+    public world: World;
+    /**
+     * when true, all objects will be added under the root world container.<br>
+     * When false, a `me.Container` object will be created for each corresponding groups
+     * @public
+     * @type {boolean}
+     * @default true
+     */
+    public mergeGroup: boolean;
+    /**
+     * Specify the property to be used when sorting renderables.
+     * Accepted values : "x", "y", "z"
+     * @public
+     * @type {string}
+     * @default "z"
+     */
+    public sortOn: string;
+    /**
+     * Last time the game update loop was executed. <br>
+     * Use this value to implement frame prediction in drawing events,
+     * for creating smooth motion while running game update logic at
+     * a lower fps.
+     * @public
+     * @type {DOMHighResTimeStamp}
+     * @name lastUpdate
+     * @memberof Application
+     */
+    public lastUpdate: DOMHighResTimeStamp;
+    isDirty: boolean;
+    isAlwaysDirty: boolean;
+    frameCounter: number;
+    frameRate: number;
+    accumulator: number;
+    accumulatorMax: number;
+    accumulatorUpdateDelta: number;
+    stepSize: number;
+    updateDelta: number;
+    lastUpdateStart: number;
+    updateAverageDelta: number;
+    /**
+     * init the game instance (create a physic world, update starting time, etc..)
+     */
+    init(): void;
+    /**
+     * reset the game Object manager
+     * destroy all current objects
+     */
+    reset(): void;
+    /**
+     * Fired when a level is fully loaded and all renderable instantiated. <br>
+     * Additionnaly the level id will also be passed to the called function.
+     * @example
+     * // call myFunction () everytime a level is loaded
+     * me.game.onLevelLoaded = this.myFunction.bind(this);
+     */
+    onLevelLoaded(): void;
+    /**
+     * Update the renderer framerate using the system config variables.
+     * @see timer.maxfps
+     * @see World.fps
+     */
+    updateFrameRate(): void;
+    /**
+     * Returns the parent container of the specified Child in the game world
+     * @param {Renderable} child
+     * @returns {Container}
+     */
+    getParentContainer(child: Renderable): Container;
+    /**
+     * force the redraw (not update) of all objects
+     */
+    repaint(): void;
+    /**
+     * update all objects related to this game active scene/stage
+     * @param {number} time current timestamp as provided by the RAF callback
+     * @param {Stage} stage the current stage
+     */
+    update(time: number, stage: Stage): void;
+    /**
+     * draw the active scene/stage associated to this game
+     * @param {Stage} stage the current stage
+     */
+    draw(stage: Stage): void;
+}
 /**
  * Initialize and configure the audio support.<br>
  * melonJS supports a wide array of audio codecs that have varying browser support :
@@ -11894,55 +11983,6 @@ declare function once(eventName: string | symbol, listener: Function, context?:
  * me.event.off("event-name", myFunction);
  */
 declare function off(eventName: string | symbol, listener: Function): {};
-/**
- * Fired when a level is fully loaded and all entities instantiated. <br>
- * Additionnaly the level id will also be passed to the called function.
- * @function game.onLevelLoaded
- * @example
- * // call myFunction () everytime a level is loaded
- * me.game.onLevelLoaded = this.myFunction.bind(this);
- */
-declare function onLevelLoaded(): void;
-/**
- * reset the game Object manager<br>
- * destroy all current objects
- * @function game.reset
- */
-declare function reset(): void;
-/**
- * Update the renderer framerate using the system config variables.
- * @function game.updateFrameRate
- * @see timer.maxfps
- * @see World.fps
- */
-declare function updateFrameRate(): void;
-/**
- * Returns the parent container of the specified Child in the game world
- * @function game.getParentContainer
- * @param {Renderable} child
- * @returns {Container}
- */
-declare function getParentContainer(child: Renderable): Container;
-/**
- * force the redraw (not update) of all objects
- * @function game.repaint
- */
-declare function repaint(): void;
-/**
- * update all objects of the game manager
- * @ignore
- * @function game.update
- * @param {number} time current timestamp as provided by the RAF callback
- * @param {Stage} stage the current stage
- */
-declare function update(time: number, stage: Stage): void;
-/**
- * draw the current scene/stage
- * @function game.draw
- * @ignore
- * @param {Stage} stage the current stage
- */
-declare function draw(stage: Stage): void;
 /**
  * Translate the specified x and y values from the global (absolute)
  * coordinate to local (viewport) relative coordinate.
@@ -12337,48 +12377,41 @@ declare class ObjectPool {
 /**
  * @classdesc
  * a Timer class to manage timing related function (FPS, Game Tick, Time...)
-  * @see {@link timer} the default global timer instance
+ * @see {@link timer} the default global timer instance
  */
 declare class Timer {
     /**
-     * Last game tick value.<br/>
-     * Use this value to scale velocities during frame drops due to slow
-     * hardware or when setting an FPS limit. (See {@link timer.maxfps})
-     * This feature is disabled by default. Enable me.timer.interpolation to
-     * use it.
+     * Last game tick value. <br>
+     * Use this value to scale velocities during frame drops due to slow hardware or when setting an FPS limit.
+     * This feature is disabled by default (Enable interpolation to use it).
      * @public
-     * @see timer.interpolation
+     * @see interpolation
+     * @See maxfps
      * @type {number}
      * @name tick
-     * @memberof timer
      */
     public tick: number;
     /**
-     * Last measured fps rate.<br/>
-     * This feature is disabled by default, unless the debugPanel is enabled/visible
+     * Last measured fps rate.<br>
+     * This feature is disabled by default, unless the debugPanel is enabled/visible.
      * @public
      * @type {number}
      * @name fps
-     * @memberof timer
      */
     public fps: number;
     /**
      * Set the maximum target display frame per second
      * @public
-     * @see timer.tick
+     * @see tick
      * @type {number}
-     * @name maxfps
      * @default 60
-     * @memberof timer
      */
     public maxfps: number;
     /**
      * Enable/disable frame interpolation
-     * @see timer.tick
+     * @see tick
      * @type {boolean}
      * @default false
-     * @name interpolation
-     * @memberof timer
      */
     interpolation: boolean;
     framecount: number;
@@ -12392,15 +12425,11 @@ declare class Timer {
     timerId: number;
     /**
      * reset time (e.g. usefull in case of pause)
-     * @name reset
-     * @memberof timer
      * @ignore
      */
     reset(): void;
     /**
      * Calls a function once after a specified delay. See me.timer.setInterval to repeativly call a function.
-     * @name setTimeout
-     * @memberof timer
      * @param {Function} fn the function you want to execute after delay milliseconds.
      * @param {number} delay the number of milliseconds (thousandths of a second) that the function call should be delayed by.
      * @param {boolean} [pauseable=true] respects the pause state of the engine.
@@ -12415,8 +12444,6 @@ declare class Timer {
     setTimeout(fn: Function, delay: number, pauseable?: boolean, ...args: any[]): number;
     /**
      * Calls a function continously at the specified interval.  See setTimeout to call function a single time.
-     * @name setInterval
-     * @memberof timer
      * @param {Function} fn the function to execute
      * @param {number} delay the number of milliseconds (thousandths of a second) on how often to execute the function
      * @param {boolean} [pauseable=true] respects the pause state of the engine.
@@ -12431,38 +12458,28 @@ declare class Timer {
     setInterval(fn: Function, delay: number, pauseable?: boolean, ...args: any[]): number;
     /**
      * Clears the delay set by me.timer.setTimeout().
-     * @name clearTimeout
-     * @memberof timer
      * @param {number} timeoutID ID of the timeout to be cleared
      */
     clearTimeout(timeoutID: number): void;
     /**
      * Clears the Interval set by me.timer.setInterval().
-     * @name clearInterval
-     * @memberof timer
      * @param {number} intervalID ID of the interval to be cleared
      */
     clearInterval(intervalID: number): void;
     /**
      * Return the current timestamp in milliseconds <br>
      * since the game has started or since linux epoch (based on browser support for High Resolution Timer)
-     * @name getTime
-     * @memberof timer
      * @returns {number}
      */
     getTime(): number;
     /**
      * Return elapsed time in milliseconds since the last update
-     * @name getDelta
-     * @memberof timer
      * @returns {number}
      */
     getDelta(): number;
     /**
      * compute the actual frame time and fps rate
-     * @name computeFPS
      * @ignore
-     * @memberof timer
      */
     countFPS(): void;
     /**
@@ -12500,11 +12517,10 @@ declare var fileUtils: Readonly<{
 declare var stringUtils: Readonly<{
     __proto__: any;
     capitalize: typeof capitalize;
-    trimLeft: typeof trimLeft;
-    trimRight: typeof trimRight;
     isNumeric: typeof isNumeric;
     isBoolean: typeof isBoolean;
     toHex: typeof toHex$1;
+    isDataUrl: typeof isDataUrl;
 }>;
 declare var fnUtils: Readonly<{
     __proto__: any;
@@ -12534,7 +12550,6 @@ declare var fnUtils: Readonly<{
  * @param {object} [options] The optional video/renderer parameters.<br> (see Renderer(s) documentation for further specific options)
  * @param {string|HTMLElement} [options.parent=document.body] the DOM parent element to hold the canvas in the HTML file
  * @param {number} [options.renderer=video.AUTO] renderer to use (me.video.CANVAS, me.video.WEBGL, me.video.AUTO)
- * @param {boolean} [options.doubleBuffering=false] enable/disable double buffering
  * @param {number|string} [options.scale=1.0] enable scaling of the canvas ('auto' for automatic scaling)
  * @param {string} [options.scaleMethod="fit"] screen scaling modes ('fit','fill-min','fill-max','flex','flex-width','flex-height','stretch')
  * @param {boolean} [options.preferWebGL1=false] if true the renderer will only use WebGL 1
@@ -12549,14 +12564,12 @@ declare var fnUtils: Readonly<{
  *     parent : "screen",
  *     renderer : me.video.AUTO,
  *     scale : "auto",
- *     scaleMethod : "fit",
- *     doubleBuffering : true
+ *     scaleMethod : "fit"
  * });
  */
 declare function init(width: number, height: number, options?: {
     parent?: string | HTMLElement;
     renderer?: number;
-    doubleBuffering?: boolean;
     scale?: number | string;
     scaleMethod?: string;
     preferWebGL1?: boolean;
@@ -12570,10 +12583,10 @@ declare function init(width: number, height: number, options?: {
  * @function video.createCanvas
  * @param {number} width width
  * @param {number} height height
- * @param {boolean} [offscreenCanvas=false] will return an OffscreenCanvas if supported
+ * @param {boolean} [returnOffscreenCanvas=false] will return an OffscreenCanvas if supported
  * @returns {HTMLCanvasElement|OffscreenCanvas}
  */
-declare function createCanvas(width: number, height: number, offscreenCanvas?: boolean): HTMLCanvasElement | OffscreenCanvas;
+declare function createCanvas(width: number, height: number, returnOffscreenCanvas?: boolean): HTMLCanvasElement | OffscreenCanvas;
 /**
  * return a reference to the parent DOM element holding the main canvas
  * @function video.getParent
@@ -12681,24 +12694,6 @@ declare function getExtension(path: string): string;
  * @returns {string} the capitalized string
  */
 declare function capitalize(str: string): string;
-/**
- * returns the string stripped of whitespace from the left.
- * @public
- * @memberof utils.string
- * @name trimLeft
- * @param {string} str the string to be trimmed
- * @returns {string} trimmed string
- */
-declare function trimLeft(str: string): string;
-/**
- * returns the string stripped of whitespace from the right.
- * @public
- * @memberof utils.string
- * @name trimRight
- * @param {string} str the string to be trimmed
- * @returns {string} trimmed string
- */
-declare function trimRight(str: string): string;
 /**
  * returns true if the given string contains a numeric integer or float value
  * @public
@@ -12726,6 +12721,16 @@ declare function isBoolean(str: string): boolean;
  * @returns {string} the converted hexadecimal value
  */
 declare function toHex$1(str: string): string;
+/**
+ * returns true if the given string is a data url in the `data:[<mediatype>][;base64],<data>` format.
+ * (this will not test the validity of the Data or Base64 encoding)
+ * @public
+ * @memberof utils.string
+ * @name isDataUrl
+ * @param {string} str the string (url) to be tested
+ * @returns {boolean} true if the string is a data url
+ */
+declare function isDataUrl(str: string): boolean;
 /**
  * a collection of utility functions
  * @namespace utils.function