melonjs 13.0.0 → 13.2.0

package/dist/melonjs.module.d.ts

@@ -98,6 +98,14 @@ export class BitmapText extends Renderable {
      * @private
      */
     private fontData;
+    public set fillStyle(arg: Color);
+    /**
+     * defines the color used to tint the bitmap text
+     * @public
+     * @type {Color}
+     * @see Renderable#tint
+     */
+    public get fillStyle(): Color;
     metrics: TextMetrics;
     /**
      * change the font settings
@@ -112,14 +120,6 @@ export class BitmapText extends Renderable {
      * @returns {BitmapText} this object for chaining
      */
     setText(value?: number | string | string[]): BitmapText;
-    public set fillStyle(arg: Color);
-    /**
-     * defines the color used to tint the bitmap text
-     * @public
-     * @type {Color}
-     * @see Renderable#tint
-     */
-    public get fillStyle(): Color;
     /**
      * change the font display size
      * @param {number} scale ratio
@@ -189,10 +189,10 @@ export class BitmapTextData {
 export class Body {
     /**
      * @param {Renderable} ancestor the parent object this body is attached to
-     * @param {Rect|Rect[]|Polygon|Polygon[]|Line|Line[]|Ellipse|Ellipse[]|Bounds|Bounds[]|object} [shapes] a initial shape, list of shapes, or JSON object defining the body
+     * @param {Rect|Rect[]|Polygon|Polygon[]|Line|Line[]|Ellipse|Ellipse[]|Point|Point[]|Bounds|Bounds[]|object} [shapes] a initial shape, list of shapes, or JSON object defining the body
      * @param {Function} [onBodyUpdate] callback for when the body is updated (e.g. add/remove shapes)
      */
-    constructor(ancestor: Renderable, shapes?: Rect | Rect[] | Polygon | Polygon[] | Line | Line[] | Ellipse | Ellipse[] | Bounds | Bounds[] | object, onBodyUpdate?: Function);
+    constructor(ancestor: Renderable, shapes?: Rect | Rect[] | Polygon | Polygon[] | Line | Line[] | Ellipse | Ellipse[] | Point | Point[] | Bounds | Bounds[] | object, onBodyUpdate?: Function);
     /**
      * a reference to the parent object that contains this body,
      * or undefined if it has not been added to one.
@@ -210,9 +210,9 @@ export class Body {
     /**
      * The collision shapes of the body
      * @ignore
-     * @type {Polygon[]|Line[]|Ellipse[]}
+     * @type {Polygon[]|Line[]|Ellipse[]|Point|Point[]}
      */
-    shapes: Polygon[] | Line[] | Ellipse[];
+    shapes: Polygon[] | Line[] | Ellipse[] | Point | Point[];
     /**
      * The body collision mask, that defines what should collide with what.<br>
      * (by default will collide with all entities)
@@ -348,7 +348,7 @@ export class Body {
     /**
      * add a collision shape to this body <br>
      * (note: me.Rect objects will be converted to me.Polygon before being added)
-     * @param {Rect|Polygon|Line|Ellipse|Bounds|object} shape a shape or JSON object
+     * @param {Rect|Polygon|Line|Ellipse|Point|Point[]|Bounds|object} shape a shape or JSON object
      * @returns {number} the shape array length
      * @example
      * // add a rectangle shape
@@ -356,7 +356,7 @@ export class Body {
      * // add a shape from a JSON object
      * this.body.addShape(me.loader.getJSON("shapesdef").banana);
      */
-    addShape(shape: Rect | Polygon | Line | Ellipse | Bounds | object): number;
+    addShape(shape: Rect | Polygon | Line | Ellipse | Point | Point[] | Bounds | object): number;
     /**
      * set the body vertices to the given one
      * @param {Vector2d[]} vertices an array of me.Vector2d points defining a convex hull
@@ -663,10 +663,10 @@ export class Bounds {
      * add the given point to the bounds definition.
      * @name addPoint
      * @memberof Bounds
-     * @param {Vector2d} v
-     * @param {Matrix2d} [m] an optional transform to apply to the given point
+     * @param {Vector2d|Point} point the point to be added to the bounds
+     * @param {Matrix2d} [m] an optional transform to apply to the given point (only if the given point is a vector)
      */
-    addPoint(v: Vector2d, m?: Matrix2d): void;
+    addPoint(point: Vector2d | Point, m?: Matrix2d): void;
     /**
      * add the given quad coordinates to this bound definition, multiplied by the given matrix
      * @name addFrame
@@ -1049,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)
@@ -1061,7 +1060,6 @@ export class CanvasRenderer extends Renderer {
         width: number;
         height: number;
         canvas?: HTMLCanvasElement;
-        doubleBuffering?: boolean;
         antiAlias?: boolean;
         transparent?: boolean;
         subPixel?: boolean;
@@ -1070,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
@@ -1097,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
@@ -1296,17 +1286,28 @@ export class CanvasRenderer extends Renderer {
      */
     fillRoundRect(x: number, y: number, width: number, height: number, radius: number): void;
     /**
-     * return a reference to the system 2d Context
-     * @name getContext
+     * Stroke a Point at the specified coordinates
+     * @name strokePoint
      * @memberof CanvasRenderer
-     * @returns {CanvasRenderingContext2D}
+     * @param {number} x
+     * @param {number} y
      */
-    getContext(): CanvasRenderingContext2D;
+    strokePoint(x: number, y: number): void;
+    /**
+     * Draw a a point at the specified coordinates
+     * @name fillPoint
+     * @memberof CanvasRenderer
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     */
+    fillPoint(x: number, y: number): void;
     /**
      * return a reference to the font 2d Context
      * @ignore
      */
-    getFontContext(): CanvasRenderingContext2D;
+    getFontContext(): CanvasRenderingContext2D | WebGLRenderingContext;
     /**
      * save the canvas context
      * @name save
@@ -1449,34 +1450,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]
@@ -1484,41 +1479,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
@@ -1526,16 +1527,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
@@ -1544,8 +1541,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}
      */
@@ -1553,16 +1548,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
      */
@@ -1570,8 +1561,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
@@ -1579,44 +1568,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}
      */
@@ -2461,70 +2438,46 @@ export class GLShader {
     constructor(gl: WebGLRenderingContext, vertex: string, fragment: string, precision?: string);
     /**
      * the active gl rendering context
-     * @public
      * @type {WebGLRenderingContext}
-     * @name gl
-     * @memberof GLShader
      */
-    public gl: WebGLRenderingContext;
+    gl: WebGLRenderingContext;
     /**
      * the vertex shader source code
-     * @public
      * @type {string}
-     * @name vertex
-     * @memberof GLShader
      */
-    public vertex: string;
+    vertex: string;
     /**
      * the fragment shader source code
-     * @public
      * @type {string}
-     * @name vertex
-     * @memberof GLShader
      */
-    public fragment: string;
+    fragment: string;
     /**
      * the location attributes of the shader
-     * @public
      * @type {GLint[]}
-     * @name attributes
-     * @memberof GLShader
      */
-    public attributes: GLint[];
+    attributes: GLint[];
     /**
      * a reference to the shader program (once compiled)
-     * @public
      * @type {WebGLProgram}
-     * @name program
-     * @memberof GLShader
      */
-    public program: WebGLProgram;
+    program: WebGLProgram;
     /**
      * the uniforms of the shader
-     * @public
      * @type {object}
-     * @name uniforms
-     * @memberof GLShader
      */
-    public uniforms: object;
+    uniforms: object;
     /**
      * Installs this shader program as part of current rendering state
-     * @name bind
-     * @memberof GLShader
      */
     bind(): void;
     /**
      * returns the location of an attribute variable in this shader program
-     * @name getAttribLocation
-     * @memberof GLShader
      * @param {string} name the name of the attribute variable whose location to get.
      * @returns {GLint} number indicating the location of the variable name if found. Returns -1 otherwise
      */
     getAttribLocation(name: string): GLint;
     /**
      * Set the uniform to the given value
-     * @name setUniform
-     * @memberof GLShader
      * @param {string} name the uniform name
      * @param {object|Float32Array} value the value to assign to that uniform
      * @example
@@ -2533,8 +2486,6 @@ export class GLShader {
     setUniform(name: string, value: object | Float32Array): void;
     /**
      * activate the given vertex attribute for this shader
-     * @name setVertexAttributes
-     * @memberof GLShader
      * @param {WebGLRenderingContext} gl the current WebGL rendering context
      * @param {object[]} attributes an array of vertex attributes
      * @param {number} vertexByteSize the size of a single vertex in bytes
@@ -2542,8 +2493,6 @@ export class GLShader {
     setVertexAttributes(gl: WebGLRenderingContext, attributes: object[], vertexByteSize: number): void;
     /**
      * destroy this shader objects resources (program, attributes, uniforms)
-     * @name destroy
-     * @memberof GLShader
      */
     destroy(): void;
 }
@@ -3617,6 +3566,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
@@ -3900,6 +3858,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
@@ -4904,6 +4871,59 @@ export namespace ParticleEmitterSettings {
     const duration: number;
     const framesToSkip: number;
 }
+/**
+ * @classdesc
+ * represents a point in a 2d space
+ */
+export class Point {
+    constructor(x?: number, y?: number);
+    /**
+     * the position of the point on the horizontal axis
+     * @public
+     * @type {Number}
+     * @default 0
+     */
+    public x: number;
+    /**
+     * the position of the point on the vertical axis
+     * @public
+     * @type {Number}
+     * @default 0
+     */
+    public y: number;
+    /** @ignore */
+    onResetEvent(x?: number, y?: number): void;
+    /**
+     * set the Point x and y properties to the given values
+     * @param {number} x
+     * @param {number} y
+     * @returns {Point} Reference to this object for method chaining
+     */
+    set(x?: number, y?: number): Point;
+    /**
+     * return true if the two points are the same
+     * @name equals
+     * @memberof Point
+     * @method
+     * @param {Point} point
+     * @returns {boolean}
+     */
+    /**
+     * return true if this point is equal to the given values
+     * @name equals
+     * @memberof Point
+     * @param {number} x
+     * @param {number} y
+     * @returns {boolean}
+     */
+    equals(...args: any[]): boolean;
+    /**
+     * clone this Point
+     * @name clone
+     * @returns {Point} new Point
+     */
+    clone(): Point;
+}
 /**
  * @classdesc
  * a pointer object, representing a single finger on a touch enabled device.
@@ -5660,20 +5680,13 @@ export class Renderable extends Rect {
     isRenderable: boolean;
     /**
      * If true then physic collision and input events will not impact this renderable
-     * @public
      * @type {boolean}
      * @default true
-     * @name isKinematic
-     * @memberof Renderable
      */
-    public isKinematic: boolean;
+    isKinematic: boolean;
     /**
      * the renderable physic body
-     * @public
      * @type {Body}
-     * @see Body
-     * @name body
-     * @memberof Renderable#
      * @example
      *  // define a new Player Class
      *  class PlayerEntity extends me.Sprite {
@@ -5706,32 +5719,23 @@ export class Renderable extends Rect {
      *
      * }
      */
-    public body: Body;
+    body: Body;
     /**
      * the renderable default transformation matrix
-     * @public
      * @type {Matrix2d}
-     * @name currentTransform
-     * @memberof Renderable#
      */
-    public currentTransform: Matrix2d;
+    currentTransform: Matrix2d;
     /**
      * (G)ame (U)nique (Id)entifier" <br>
      * a GUID will be allocated for any renderable object added <br>
      * to an object container (including the `me.game.world` container)
-     * @public
      * @type {string}
-     * @name GUID
-     * @memberof Renderable
      */
-    public GUID: string;
+    GUID: string;
     /**
      * an event handler that is called when the renderable leave or enter a camera viewport
-     * @public
      * @type {Function}
      * @default undefined
-     * @name onVisibilityChange
-     * @memberof Renderable#
      * @example
      * this.onVisibilityChange = function(inViewport) {
      *     if (inViewport === true) {
@@ -5739,44 +5743,32 @@ export class Renderable extends Rect {
      *     }
      * };
      */
-    public onVisibilityChange: Function;
+    onVisibilityChange: Function;
     /**
      * Whether the renderable object will always update, even when outside of the viewport<br>
-     * @public
      * @type {boolean}
      * @default false
-     * @name alwaysUpdate
-     * @memberof Renderable
      */
-    public alwaysUpdate: boolean;
+    alwaysUpdate: boolean;
     /**
      * Whether to update this object when the game is paused.
-     * @public
      * @type {boolean}
      * @default false
-     * @name updateWhenPaused
-     * @memberof Renderable
      */
-    public updateWhenPaused: boolean;
+    updateWhenPaused: boolean;
     /**
      * make the renderable object persistent over level changes<br>
-     * @public
      * @type {boolean}
      * @default false
-     * @name isPersistent
-     * @memberof Renderable
      */
-    public isPersistent: boolean;
+    isPersistent: boolean;
     /**
      * If true, this renderable will be rendered using screen coordinates,
      * as opposed to world coordinates. Use this, for example, to define UI elements.
-     * @public
      * @type {boolean}
      * @default false
-     * @name floating
-     * @memberof Renderable
      */
-    public floating: boolean;
+    floating: boolean;
     /**
      * The anchor point is used for attachment behavior, and/or when applying transformations.<br>
      * The coordinate system places the origin at the top left corner of the frame (0, 0) and (1, 1) means the bottom-right corner<br>
@@ -5785,21 +5777,15 @@ export class Renderable extends Rect {
      * <br>
      * <i><b>Note:</b> Object created through Tiled will have their anchorPoint set to (0, 0) to match Tiled Level editor implementation.
      * To specify a value through Tiled, use a json expression like `json:{"x":0.5,"y":0.5}`. </i>
-     * @public
      * @type {ObservableVector2d}
      * @default <0.5,0.5>
-     * @name anchorPoint
-     * @memberof Renderable#
      */
-    public anchorPoint: ObservableVector2d;
+    anchorPoint: ObservableVector2d;
     /**
      * When enabled, an object container will automatically apply
      * any defined transformation before calling the child draw method.
-     * @public
      * @type {boolean}
      * @default true
-     * @name autoTransform
-     * @memberof Renderable
      * @example
      * // enable "automatic" transformation when the object is activated
      * onActivateEvent: function () {
@@ -5812,34 +5798,27 @@ export class Renderable extends Rect {
      *     ....
      * }
      */
-    public autoTransform: boolean;
+    autoTransform: boolean;
     /**
      * Define the renderable opacity<br>
      * Set to zero if you do not wish an object to be drawn
      * @see Renderable#setOpacity
      * @see Renderable#getOpacity
-     * @public
      * @type {number}
      * @default 1.0
-     * @name Renderable#alpha
      */
-    public alpha: number;
+    alpha: number;
     /**
      * a reference to the parent object that contains this renderable
-     * @public
      * @type {Container|Entity}
      * @default undefined
-     * @name Renderable#ancestor
      */
-    public ancestor: Container | Entity;
+    ancestor: Container | Entity;
     /**
      * A mask limits rendering elements to the shape and position of the given mask object.
      * So, if the renderable is larger than the mask, only the intersecting part of the renderable will be visible.
-     * @public
      * @type {Rect|RoundRect|Polygon|Line|Ellipse}
-     * @name mask
      * @default undefined
-     * @memberof Renderable#
      * @example
      * // apply a mask in the shape of a Star
      * myNPCSprite.mask = new me.Polygon(myNPCSprite.width / 2, 0, [
@@ -5856,55 +5835,31 @@ export class Renderable extends Rect {
      *    {x: -14, y: 30}
      * ]);
      */
-    public mask: Rect | RoundRect | Polygon | Line | Ellipse;
-    /**
-     * define a tint for this renderable. a (255, 255, 255) r, g, b value will remove the tint effect.
-     * @public
-     * @type {Color}
-     * @name tint
-     * @default (255, 255, 255)
-     * @memberof Renderable#
-     * @example
-     * // add a red tint to this renderable
-     * this.tint.setColor(255, 128, 128);
-     * // remove the tint
-     * this.tint.setColor(255, 255, 255);
-     */
-    public tint: Color;
+    mask: Rect | RoundRect | Polygon | Line | Ellipse;
     /**
      * the blend mode to be applied to this renderable (see renderer setBlendMode for available blend mode)
-     * @public
      * @type {string}
-     * @name blendMode
      * @default "normal"
      * @see CanvasRenderer#setBlendMode
      * @see WebGLRenderer#setBlendMode
-     * @memberof Renderable#
      */
-    public blendMode: string;
+    blendMode: string;
     /**
      * The name of the renderable
-     * @public
      * @type {string}
-     * @name name
      * @default ""
-     * @memberof Renderable
      */
-    public name: string;
+    name: string;
     /**
      * Position of the Renderable relative to its parent container
      * @public
      * @type {ObservableVector3d}
-     * @name pos
-     * @memberof Renderable#
      */
     public pos: ObservableVector3d;
     /**
      * when true the renderable will be redrawn during the next update cycle
      * @type {boolean}
-     * @name isDirty
      * @default false
-     * @memberof Renderable#
      */
     isDirty: boolean;
     _flip: {
@@ -5914,30 +5869,35 @@ export class Renderable extends Rect {
     _inViewport: boolean;
     /**
      * Whether the renderable object is floating, or contained in a floating container
-     * @public
      * @see Renderable#floating
      * @type {boolean}
-     * @name isFloating
-     * @memberof Renderable
      */
-    public get isFloating(): boolean;
-    public set inViewport(arg: boolean);
+    get isFloating(): boolean;
+    set tint(arg: Color);
+    /**
+     * define a tint for this renderable. a (255, 255, 255) r, g, b value will remove the tint effect.
+     * @type {Color}
+     * @default (255, 255, 255)
+     * @example
+     * // add a red tint to this renderable
+     * this.tint.setColor(255, 128, 128);
+     * // remove the tint
+     * this.tint.setColor(255, 255, 255);
+     */
+    get tint(): Color;
+    _tint: any;
+    set inViewport(arg: boolean);
     /**
      * Whether the renderable object is visible and within the viewport
-     * @public
      * @type {boolean}
      * @default false
-     * @name inViewport
-     * @memberof Renderable
      */
-    public get inViewport(): boolean;
+    get inViewport(): boolean;
     /**
      * returns true if this renderable is flipped on the horizontal axis
      * @public
      * @see Renderable#flipX
      * @type {boolean}
-     * @name isFlippedX
-     * @memberof Renderable
      */
     public get isFlippedX(): boolean;
     /**
@@ -5945,29 +5905,21 @@ export class Renderable extends Rect {
      * @public
      * @see Renderable#flipY
      * @type {boolean}
-     * @name isFlippedY
-     * @memberof Renderable
      */
     public get isFlippedY(): boolean;
     /**
      * get the renderable alpha channel value<br>
-     * @name getOpacity
-     * @memberof Renderable
      * @returns {number} current opacity value between 0 and 1
      */
     getOpacity(): number;
     /**
      * set the renderable alpha channel value<br>
-     * @name setOpacity
-     * @memberof Renderable
      * @param {number} alpha opacity value between 0.0 and 1.0
      */
     setOpacity(alpha: number): void;
     /**
      * flip the renderable on the horizontal axis (around the center of the renderable)
      * @see Matrix2d#scaleX
-     * @name flipX
-     * @memberof Renderable
      * @param {boolean} [flip=true] `true` to flip this renderable.
      * @returns {Renderable} Reference to this object for method chaining
      */
@@ -5975,16 +5927,12 @@ export class Renderable extends Rect {
     /**
      * flip the renderable on the vertical axis (around the center of the renderable)
      * @see Matrix2d#scaleY
-     * @name flipY
-     * @memberof Renderable
      * @param {boolean} [flip=true] `true` to flip this renderable.
      * @returns {Renderable} Reference to this object for method chaining
      */
     flipY(flip?: boolean): Renderable;
     /**
      * multiply the renderable currentTransform with the given matrix
-     * @name transform
-     * @memberof Renderable
      * @see Renderable#currentTransform
      * @param {Matrix2d} m the transformation matrix
      * @returns {Renderable} Reference to this object for method chaining
@@ -5992,32 +5940,24 @@ export class Renderable extends Rect {
     transform(m: Matrix2d): Renderable;
     /**
      * return the angle to the specified target
-     * @name angleTo
-     * @memberof Renderable
      * @param {Renderable|Vector2d|Vector3d} target
      * @returns {number} angle in radians
      */
     angleTo(target: Renderable | Vector2d | Vector3d): number;
     /**
      * return the distance to the specified target
-     * @name distanceTo
-     * @memberof Renderable
      * @param {Renderable|Vector2d|Vector3d} target
      * @returns {number} distance
      */
     distanceTo(target: Renderable | Vector2d | Vector3d): number;
     /**
      * Rotate this renderable towards the given target.
-     * @name lookAt
-     * @memberof Renderable
      * @param {Renderable|Vector2d|Vector3d} target the renderable or position to look at
      * @returns {Renderable} Reference to this object for method chaining
      */
     lookAt(target: Renderable | Vector2d | Vector3d): Renderable;
     /**
      * Rotate this renderable by the specified angle (in radians).
-     * @name rotate
-     * @memberof Renderable
      * @param {number} angle The angle to rotate (in radians)
      * @param {Vector2d|ObservableVector2d} [v] an optional point to rotate around
      * @returns {Renderable} Reference to this object for method chaining
@@ -6029,8 +5969,6 @@ export class Renderable extends Rect {
      * when rendering.  It does not scale the object itself.  For example if the renderable
      * is an image, the image.width and image.height properties are unaltered but the currentTransform
      * member will be changed.
-     * @name scale
-     * @memberof Renderable
      * @param {number} x a number representing the abscissa of the scaling vector.
      * @param {number} [y=x] a number representing the ordinate of the scaling vector.
      * @returns {Renderable} Reference to this object for method chaining
@@ -6038,33 +5976,23 @@ export class Renderable extends Rect {
     scale(x: number, y?: number): Renderable;
     /**
      * scale the renderable around his anchor point
-     * @name scaleV
-     * @memberof Renderable
      * @param {Vector2d} v scaling vector
      * @returns {Renderable} Reference to this object for method chaining
      */
     scaleV(v: Vector2d): Renderable;
     /**
-     * update function. <br>
-     * automatically called by the game manager {@link game}
-     * @name update
-     * @memberof Renderable
-     * @protected
+     * update function (automatically called by melonJS).
      * @param {number} dt time since the last update in milliseconds.
      * @returns {boolean} true if the renderable is dirty
      */
-    protected update(dt: number): boolean;
+    update(dt: number): boolean;
     /**
      * update the renderable's bounding rect (private)
      * @ignore
-     * @name updateBoundsPos
-     * @memberof Renderable
      */
     updateBoundsPos(newX: any, newY: any): void;
     /**
      * return the renderable absolute position in the game world
-     * @name getAbsolutePosition
-     * @memberof Renderable
      * @returns {Vector2d}
      */
     getAbsolutePosition(): Vector2d;
@@ -6072,45 +6000,42 @@ export class Renderable extends Rect {
     /**
      * called when the anchor point value is changed
      * @private
-     * @name onAnchorUpdate
-     * @memberof Renderable
      * @param {number} x the new X value to be set for the anchor
      * @param {number} y the new Y value to be set for the anchor
      */
     private onAnchorUpdate;
     /**
-     * prepare the rendering context before drawing
-     * (apply defined transforms, anchor point). <br>
-     * automatically called by the game manager {@link game}
-     * @name preDraw
-     * @memberof Renderable
-     * @protected
+     * Prepare the rendering context before drawing (automatically called by melonJS).
+     * This will apply any defined transforms, anchor point, tint or blend mode and translate the context accordingly to this renderable position.
+     * @see Renderable#draw
+     * @see Renderable#postDraw
      * @param {CanvasRenderer|WebGLRenderer} renderer a renderer object
      */
-    protected preDraw(renderer: CanvasRenderer | WebGLRenderer): void;
-    /**
-     * draw this renderable (automatically called by melonJS)
-     * @name draw
-     * @memberof Renderable
-     * @protected
+    preDraw(renderer: CanvasRenderer | WebGLRenderer): void;
+    /**
+     * Draw this renderable (automatically called by melonJS).
+     * All draw operations for renderable are made respectively
+     * to the position or transforms set or applied by the preDraw method.
+     * The main draw loop will first call preDraw() to prepare the context for drawing the renderable,
+     * then draw() to draw the renderable, and finally postDraw() to clear the context.
+     * If you override this method, be mindful about the drawing logic; for example if you draw a shape
+     * from the draw method, you should make sure that your draw it at the 0, 0 coordinates.
+     * @see Renderable#preDraw
+     * @see Renderable#postDraw
      * @param {CanvasRenderer|WebGLRenderer} renderer a renderer instance
      * @param {Camera2d} [viewport] the viewport to (re)draw
      */
-    protected draw(renderer: CanvasRenderer | WebGLRenderer, viewport?: Camera2d): void;
+    draw(renderer: CanvasRenderer | WebGLRenderer, viewport?: Camera2d): void;
     /**
-     * restore the rendering context after drawing. <br>
-     * automatically called by the game manager {@link game}
-     * @name postDraw
-     * @memberof Renderable
-     * @protected
+     * restore the rendering context after drawing (automatically called by melonJS).
+     * @see Renderable#preDraw
+     * @see Renderable#draw
      * @param {CanvasRenderer|WebGLRenderer} renderer a renderer object
      */
-    protected postDraw(renderer: CanvasRenderer | WebGLRenderer): void;
+    postDraw(renderer: CanvasRenderer | WebGLRenderer): void;
     /**
      * onCollision callback, triggered in case of collision,
      * when this renderable body is colliding with another one
-     * @name onCollision
-     * @memberof Renderable
      * @param {ResponseObject} response the collision response object
      * @param {Renderable} other the other renderable touching this one (a reference to response.a or response.b)
      * @returns {boolean} true if the object should respond to the collision (its position and velocity will be corrected)
@@ -6137,8 +6062,6 @@ export class Renderable extends Rect {
     /**
      * OnDestroy Notification function<br>
      * Called by engine before deleting the object
-     * @name onDestroyEvent
-     * @memberof Renderable
      */
     onDestroyEvent(): void;
 }
@@ -6152,10 +6075,10 @@ 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 (not applicable when using the WebGL Renderer)
      * @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)
+     * @param {boolean} [options.transparent=false] Whether to enable transparency on the canvas
+     * @param {boolean} [options.premultipliedAlpha=true] in WebGL, whether the renderer will assume that colors have premultiplied alpha when canvas transparency is enabled
      * @param {boolean} [options.blendMode="normal"] the default blend mode to use ("normal", "multiply")
      * @param {boolean} [options.subPixel=false] Whether to enable subpixel rendering (performance hit when enabled)
      * @param {boolean} [options.verbose=false] Enable the verbose mode that provides additional details as to what the renderer is doing
@@ -6166,10 +6089,10 @@ export class Renderer {
         width: number;
         height: number;
         canvas?: HTMLCanvasElement;
-        doubleBuffering?: boolean;
         antiAlias?: boolean;
         failIfMajorPerformanceCaveat?: boolean;
         transparent?: boolean;
+        premultipliedAlpha?: boolean;
         blendMode?: boolean;
         subPixel?: boolean;
         verbose?: boolean;
@@ -6179,24 +6102,18 @@ export class Renderer {
     /**
      * The given constructor options
      * @public
-     * @name settings
-     * @memberof Renderer#
      * @type {object}
      */
     public settings: object;
     /**
      * true if the current rendering context is valid
-     * @name isContextValid
-     * @memberof Renderer#
      * @default true
-     * type {boolean}
+     * @type {boolean}
      */
     isContextValid: boolean;
     /**
      * The Path2D instance used by the renderer to draw primitives
-     * @name path2D
      * @type {Path2D}
-     * @memberof Renderer#
      */
     path2D: Path2D;
     /**
@@ -6212,58 +6129,40 @@ export class Renderer {
      */
     currentBlendMode: string;
     canvas: any;
-    backBufferCanvas: any;
-    context: any;
     currentColor: Color;
     currentTint: Color;
     projectionMatrix: Matrix3d;
     uvOffset: number;
     /**
      * prepare the framebuffer for drawing a new frame
-     * @name clear
-     * @memberof Renderer
      */
     clear(): void;
+    /**
+     * render the main framebuffer on screen
+     */
+    flush(): void;
     /**
      * Reset context state
-     * @name reset
-     * @memberof Renderer
      */
     reset(): void;
     /**
-     * return a reference to the system canvas
-     * @name getCanvas
-     * @memberof Renderer
+     * return a reference to the canvas which this renderer draws to
      * @returns {HTMLCanvasElement}
      */
     getCanvas(): HTMLCanvasElement;
     /**
-     * return a reference to the screen canvas
-     * @name getScreenCanvas
-     * @memberof Renderer
-     * @returns {HTMLCanvasElement}
+     * return a reference to this renderer canvas corresponding Context
+     * @returns {CanvasRenderingContext2D|WebGLRenderingContext}
      */
-    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}
-     */
-    getScreenContext(): CanvasRenderingContext2D;
+    getContext(): CanvasRenderingContext2D | WebGLRenderingContext;
     /**
      * returns the current blend mode for this renderer
-     * @name getBlendMode
-     * @memberof Renderer
      * @returns {string} blend mode
      */
     getBlendMode(): string;
     /**
      * Returns the 2D Context object of the given Canvas<br>
      * Also configures anti-aliasing and blend modes based on constructor options.
-     * @name getContext2d
-     * @memberof Renderer
      * @param {HTMLCanvasElement} canvas
      * @param {boolean} [transparent=true] use false to disable transparency
      * @returns {CanvasRenderingContext2D}
@@ -6271,67 +6170,49 @@ export class Renderer {
     getContext2d(canvas: HTMLCanvasElement, transparent?: boolean): CanvasRenderingContext2D;
     /**
      * return the width of the system Canvas
-     * @name getWidth
-     * @memberof Renderer
      * @returns {number}
      */
     getWidth(): number;
     /**
      * return the height of the system Canvas
-     * @name getHeight
-     * @memberof Renderer
      * @returns {number} height of the system Canvas
      */
     getHeight(): number;
     /**
      * get the current fill & stroke style color.
-     * @name getColor
-     * @memberof Renderer
      * @returns {Color} current global color
      */
     getColor(): Color;
     /**
      * return the current global alpha
-     * @name globalAlpha
-     * @memberof Renderer
      * @returns {number}
      */
     globalAlpha(): number;
     /**
      * check if the given rect or bounds overlaps with the renderer screen coordinates
-     * @name overlaps
-     * @memberof Renderer
      * @param {Rect|Bounds} bounds
      * @returns {boolean} true if overlaps
      */
     overlaps(bounds: Rect | Bounds): boolean;
     /**
      * resizes the system canvas
-     * @name resize
-     * @memberof Renderer
      * @param {number} width new width of the canvas
      * @param {number} height new height of the canvas
      */
     resize(width: number, height: number): void;
     /**
      * enable/disable image smoothing (scaling interpolation) for the given context
-     * @name setAntiAlias
-     * @memberof Renderer
      * @param {CanvasRenderingContext2D} context
      * @param {boolean} [enable=false]
      */
     setAntiAlias(context: CanvasRenderingContext2D, enable?: boolean): void;
     /**
      * set/change the current projection matrix (WebGL only)
-     * @name setProjection
-     * @memberof Renderer
      * @param {Matrix3d} matrix
      */
     setProjection(matrix: Matrix3d): void;
     /**
      * stroke the given shape
-     * @name stroke
-     * @memberof Renderer
      * @param {Rect|RoundRect|Polygon|Line|Ellipse} shape a shape object to stroke
      * @param {boolean} [fill=false] fill the shape with the current color if true
      */
@@ -6345,8 +6226,6 @@ export class Renderer {
     fill(shape: Rect | RoundRect | Polygon | Line | Ellipse): void;
     /**
      * tint the given image or canvas using the given color
-     * @name tint
-     * @memberof Renderer
      * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas} src the source image to be tinted
      * @param {Color|string} color the color that will be used to tint the image
      * @param {string} [mode="multiply"] the composition mode used to tint the image
@@ -6357,32 +6236,24 @@ export class Renderer {
      * A mask limits rendering elements to the shape and position of the given mask object.
      * So, if the renderable is larger than the mask, only the intersecting part of the renderable will be visible.
      * Mask are not preserved through renderer context save and restore.
-     * @name setMask
-     * @memberof Renderer
      * @param {Rect|RoundRect|Polygon|Line|Ellipse} [mask] the shape defining the mask to be applied
      * @param {boolean} [invert=false] either the given shape should define what is visible (default) or the opposite
      */
     setMask(mask?: Rect | RoundRect | Polygon | Line | Ellipse): void;
     /**
      * disable (remove) the rendering mask set through setMask.
-     * @name clearMask
      * @see Renderer#setMask
-     * @memberof Renderer
      */
     clearMask(): void;
     /**
      * set a coloring tint for sprite based renderables
-     * @name setTint
-     * @memberof Renderer
      * @param {Color} tint the tint color
      * @param {number} [alpha] an alpha value to be applied to the tint
      */
     setTint(tint: Color, alpha?: number): void;
     /**
      * clear the rendering tint set through setTint.
-     * @name clearTint
      * @see Renderer#setTint
-     * @memberof Renderer
      */
     clearTint(): void;
     /**
@@ -6390,6 +6261,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
@@ -6997,6 +6887,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;
@@ -7328,6 +7226,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[];
@@ -7433,6 +7338,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
@@ -8463,6 +8375,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
@@ -8786,6 +8707,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
@@ -8857,40 +8787,33 @@ export class WebGLCompositor {
     viewMatrix: any;
     /**
      * a reference to the active WebGL shader
-     * @name activeShader
-     * @memberof WebGLCompositor
      * @type {GLShader}
      */
     activeShader: GLShader;
     /**
      * primitive type to render (gl.POINTS, gl.LINE_STRIP, gl.LINE_LOOP, gl.LINES, gl.TRIANGLE_STRIP, gl.TRIANGLE_FAN, gl.TRIANGLES)
-     * @name mode
-     * @see WebGLCompositor
-     * @memberof WebGLCompositor
+     * @type {number}
      * @default gl.TRIANGLES
      */
-    mode: any;
+    mode: number;
     /**
      * an array of vertex attribute properties
-     * @name attributes
      * @see WebGLCompositor.addAttribute
-     * @memberof WebGLCompositor
+     * @type {Array}
      */
     attributes: any[];
     /**
      * the size of a single vertex in bytes
      * (will automatically be calculated as attributes definitions are added)
-     * @name vertexByteSize
      * @see WebGLCompositor.addAttribute
-     * @memberof WebGLCompositor
+     * @type {number}
      */
     vertexByteSize: number;
     /**
      * the size of a single vertex in floats
      * (will automatically be calculated as attributes definitions are added)
-     * @name vertexSize
      * @see WebGLCompositor.addAttribute
-     * @memberof WebGLCompositor
+     * @type {number}
      */
     vertexSize: number;
     primitiveShader: GLShader;
@@ -8903,8 +8826,6 @@ export class WebGLCompositor {
     reset(): void;
     /**
      * add vertex attribute property definition to the compositor
-     * @name addAttribute
-     * @memberof WebGLCompositor
      * @param {string} name name of the attribute in the vertex shader
      * @param {number} size number of components per vertex attribute. Must be 1, 2, 3, or 4.
      * @param {GLenum} type data type of each component in the array
@@ -8914,8 +8835,6 @@ export class WebGLCompositor {
     addAttribute(name: string, size: number, type: GLenum, normalized: boolean, offset: number): void;
     /**
      * Sets the viewport
-     * @name setViewport
-     * @memberof WebGLCompositor
      * @param {number} x x position of viewport
      * @param {number} y y position of viewport
      * @param {number} w width of viewport
@@ -8924,8 +8843,6 @@ export class WebGLCompositor {
     setViewport(x: number, y: number, w: number, h: number): void;
     /**
      * Create a WebGL texture from an image
-     * @name createTexture2D
-     * @memberof WebGLCompositor
      * @param {number} unit Destination texture unit
      * @param {Image|HTMLCanvasElement|ImageData|Uint8Array[]|Float32Array[]} image Source image
      * @param {number} filter gl.LINEAR or gl.NEAREST
@@ -8940,32 +8857,24 @@ export class WebGLCompositor {
     createTexture2D(unit: number, image: (new (width?: number, height?: number) => HTMLImageElement) | HTMLCanvasElement | ImageData | Uint8Array[] | Float32Array[], filter: number, repeat?: string, w?: number, h?: number, b?: number, premultipliedAlpha?: boolean, mipmap?: boolean): WebGLTexture;
     /**
      * delete the given WebGL texture
-     * @name bindTexture2D
-     * @memberof WebGLCompositor
      * @param {WebGLTexture} [texture] a WebGL texture to delete
      * @param {number} [unit] Texture unit to delete
      */
     deleteTexture2D(texture?: WebGLTexture): void;
     /**
      * returns the WebGL texture associated to the given texture unit
-     * @name bindTexture2D
-     * @memberof WebGLCompositor
      * @param {number} unit Texture unit to which a texture is bound
      * @returns {WebGLTexture} texture a WebGL texture
      */
     getTexture2D(unit: number): WebGLTexture;
     /**
      * assign the given WebGL texture to the current batch
-     * @name bindTexture2D
-     * @memberof WebGLCompositor
      * @param {WebGLTexture} texture a WebGL texture
      * @param {number} unit Texture unit to which the given texture is bound
      */
     bindTexture2D(texture: WebGLTexture, unit: number): void;
     /**
      * unbind the given WebGL texture, forcing it to be reuploaded
-     * @name unbindTexture2D
-     * @memberof WebGLCompositor
      * @param {WebGLTexture} [texture] a WebGL texture
      * @param {number} [unit] a WebGL texture
      * @returns {number} unit the unit number that was associated with the given texture
@@ -8977,23 +8886,17 @@ export class WebGLCompositor {
     uploadTexture(texture: any, w: any, h: any, b: any, force?: boolean): any;
     /**
      * set/change the current projection matrix
-     * @name setProjection
-     * @memberof WebGLCompositor
      * @param {Matrix3d} matrix
      */
     setProjection(matrix: Matrix3d): void;
     /**
      * Select the shader to use for compositing
-     * @name useShader
      * @see GLShader
-     * @memberof WebGLCompositor
      * @param {GLShader} shader a reference to a GLShader instance
      */
     useShader(shader: GLShader): void;
     /**
      * Add a textured quad
-     * @name addQuad
-     * @memberof WebGLCompositor
      * @param {TextureAtlas} texture Source texture atlas
      * @param {number} x Destination x-coordinate
      * @param {number} y Destination y-coordinate
@@ -9009,34 +8912,28 @@ export class WebGLCompositor {
     /**
      * Flush batched texture operations to the GPU
      * @param {number} [mode=gl.TRIANGLES] the GL drawing mode
-     * @memberof WebGLCompositor
      */
     flush(mode?: number): void;
     /**
      * Draw an array of vertices
-     * @name drawVertices
-     * @memberof WebGLCompositor
      * @param {GLenum} mode primitive type to render (gl.POINTS, gl.LINE_STRIP, gl.LINE_LOOP, gl.LINES, gl.TRIANGLE_STRIP, gl.TRIANGLE_FAN, gl.TRIANGLES)
      * @param {Vector2d[]} verts vertices
      * @param {number} [vertexCount=verts.length] amount of points defined in the points array
      */
     drawVertices(mode: GLenum, verts: Vector2d[], vertexCount?: number): void;
     /**
-     * Specify the color values used when clearing color buffers. The values are clamped between 0 and 1.
-     * @name clearColor
-     * @memberof WebGLCompositor
-     * @param {number} [r=0] - the red color value used when the color buffers are cleared
-     * @param {number} [g=0] - the green color value used when the color buffers are cleared
-     * @param {number} [b=0] - the blue color value used when the color buffers are cleared
-     * @param {number} [a=0] - the alpha color value used when the color buffers are cleared
+     * Clear the frame buffer
+     * @param {number} [alpha = 0.0] - the alpha value used when clearing the framebuffer
      */
-    clearColor(r?: number, g?: number, b?: number, a?: number): void;
+    clear(alpha?: number): void;
     /**
-     * Clear the frame buffer
-     * @name clear
-     * @memberof WebGLCompositor
+     * Specify the color values used when clearing color buffers. The values are clamped between 0 and 1.
+     * @param {number} [r = 0] - the red color value used when the color buffers are cleared
+     * @param {number} [g = 0] - the green color value used when the color buffers are cleared
+     * @param {number} [b = 0] - the blue color value used when the color buffers are cleared
+     * @param {number} [a = 0] - the alpha color value used when the color buffers are cleared
      */
-    clear(): void;
+    clearColor(r?: number, g?: number, b?: number, a?: number): void;
 }
 /**
  * @classdesc
@@ -9049,10 +8946,10 @@ 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 (not applicable when using the WebGL Renderer)
      * @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)
+     * @param {boolean} [options.transparent=false] Whether to enable transparency on the canvas
+     * @param {boolean} [options.premultipliedAlpha=true] in WebGL, whether the renderer will assume that colors have premultiplied alpha when canvas transparency is enabled
      * @param {boolean} [options.subPixel=false] Whether to enable subpixel renderering (performance hit when enabled)
      * @param {boolean} [options.preferWebGL1=false] if true the renderer will only use WebGL 1
      * @param {string} [options.powerPreference="default"] a hint to the user agent indicating what configuration of GPU is suitable for the WebGL context ("default", "high-performance", "low-power"). To be noted that Safari and Chrome (since version 80) both default to "low-power" to save battery life and improve the user experience on these dual-GPU machines.
@@ -9064,10 +8961,10 @@ export class WebGLRenderer extends Renderer {
         width: number;
         height: number;
         canvas?: HTMLCanvasElement;
-        doubleBuffering?: boolean;
         antiAlias?: boolean;
         failIfMajorPerformanceCaveat?: boolean;
         transparent?: boolean;
+        premultipliedAlpha?: boolean;
         subPixel?: boolean;
         preferWebGL1?: boolean;
         powerPreference?: string;
@@ -9077,8 +8974,6 @@ export class WebGLRenderer extends Renderer {
     });
     /**
      * The WebGL version used by this renderer (1 or 2)
-     * @name WebGLVersion
-     * @memberof WebGLRenderer#
      * @type {number}
      * @default 1
      * @readonly
@@ -9086,8 +8981,6 @@ export class WebGLRenderer extends Renderer {
     readonly WebGLVersion: number;
     /**
      * The vendor string of the underlying graphics driver.
-     * @name GPUVendor
-     * @memberof WebGLRenderer#
      * @type {string}
      * @default null
      * @readonly
@@ -9095,8 +8988,6 @@ export class WebGLRenderer extends Renderer {
     readonly GPUVendor: string;
     /**
      * The renderer string of the underlying graphics driver.
-     * @name GPURenderer
-     * @memberof WebGLRenderer#
      * @type {string}
      * @default null
      * @readonly
@@ -9105,15 +8996,12 @@ export class WebGLRenderer extends Renderer {
     /**
      * The WebGL context
      * @name gl
-     * @memberof WebGLRenderer
      * @type {WebGLRenderingContext}
      */
     context: WebGLRenderingContext;
     gl: WebGLRenderingContext;
     /**
      * Maximum number of texture unit supported under the current context
-     * @name maxTextures
-     * @memberof WebGLRenderer#
      * @type {number}
      * @readonly
      */
@@ -9136,37 +9024,27 @@ export class WebGLRenderer extends Renderer {
     _blendStack: any[];
     /**
      * The current transformation matrix used for transformations on the overall scene
-     * @name currentTransform
      * @type {Matrix2d}
-     * @memberof WebGLRenderer#
      */
     currentTransform: Matrix2d;
     /**
      * The current compositor used by the renderer
-     * @name currentCompositor
      * @type {WebGLCompositor}
-     * @memberof WebGLRenderer#
      */
     currentCompositor: WebGLCompositor;
     /**
      * The list of active compositors
-     * @name compositors
      * @type {Map<WebGLCompositor>}
-     * @memberof WebGLRenderer#
      */
     compositors: Map<WebGLCompositor, any>;
     cache: TextureCache;
     /**
      * set the active compositor for this renderer
-     * @name setCompositor
      * @param {WebGLCompositor|string} compositor a compositor name or instance
-     * @memberof WebGLRenderer
      */
     setCompositor(compositor?: WebGLCompositor | string): void;
     /**
      * Reset the gl transform to identity
-     * @name resetTransform
-     * @memberof WebGLRenderer
      */
     resetTransform(): void;
     /**
@@ -9183,8 +9061,6 @@ export class WebGLRenderer extends Renderer {
     fontTexture: TextureAtlas;
     /**
      * Create a pattern with the specified repetition
-     * @name createPattern
-     * @memberof WebGLRenderer
      * @param {Image} image Source image
      * @param {string} repeat Define how the pattern should be repeated
      * @returns {TextureAtlas}
@@ -9196,24 +9072,14 @@ 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
-     * @memberof WebGLRenderer
      * @param {Color|string} [color="#000000"] CSS color.
      * @param {boolean} [opaque=false] Allow transparency [default] or clear the surface completely [true]
      */
     clearColor(color?: Color | string, opaque?: boolean): void;
     /**
      * Erase the pixels in the given rectangular area by setting them to transparent black (rgba(0,0,0,0)).
-     * @name clearRect
-     * @memberof WebGLRenderer
      * @param {number} x x axis of the coordinate for the rectangle starting point.
      * @param {number} y y axis of the coordinate for the rectangle starting point.
      * @param {number} width The rectangle's width.
@@ -9226,8 +9092,6 @@ export class WebGLRenderer extends Renderer {
     drawFont(bounds: any): void;
     /**
      * Draw an image to the gl context
-     * @name drawImage
-     * @memberof WebGLRenderer
      * @param {Image} image An element to draw into the context. The specification permits any canvas image source (CanvasImageSource), specifically, a CSSImageValue, an HTMLImageElement, an SVGImageElement, an HTMLVideoElement, an HTMLCanvasElement, an ImageBitmap, or an OffscreenCanvas.
      * @param {number} sx The X coordinate of the top left corner of the sub-rectangle of the source image to draw into the destination context.
      * @param {number} sy The Y coordinate of the top left corner of the sub-rectangle of the source image to draw into the destination context.
@@ -9248,8 +9112,6 @@ export class WebGLRenderer extends Renderer {
     drawImage(image: new (width?: number, height?: number) => HTMLImageElement, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): void;
     /**
      * Draw a pattern within the given rectangle.
-     * @name drawPattern
-     * @memberof WebGLRenderer
      * @param {TextureAtlas} pattern Pattern object
      * @param {number} x
      * @param {number} y
@@ -9259,26 +9121,15 @@ export class WebGLRenderer extends Renderer {
      */
     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
-     * @memberof WebGLRenderer
+     * Returns the WebGL Context object of the given canvas element
      * @param {HTMLCanvasElement} canvas
-     * @param {boolean} [transparent=true] use false to disable transparency
+     * @param {boolean} [transparent=false] use true to enable transparency
      * @returns {WebGLRenderingContext}
      */
     getContextGL(canvas: HTMLCanvasElement, transparent?: boolean): WebGLRenderingContext;
     /**
      * Returns the WebGLContext instance for the renderer
      * return a reference to the system 2d Context
-     * @name getContext
-     * @memberof WebGLRenderer
      * @returns {WebGLRenderingContext}
      */
     getContext(): WebGLRenderingContext;
@@ -9293,9 +9144,7 @@ export class WebGLRenderer extends Renderer {
      * <img src="images/lighter-blendmode.png" width="510"/> <br>
      * - "screen" : The pixels are inverted, multiplied, and inverted again. A lighter picture is the result (opposite of multiply) <br>
      * <img src="images/screen-blendmode.png" width="510"/> <br>
-     * @name setBlendMode
      * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation
-     * @memberof WebGLRenderer
      * @param {string} [mode="normal"] blend mode : "normal", "multiply", "lighter", "additive", "screen"
      * @param {WebGLRenderingContext} [gl]
      */
@@ -9308,27 +9157,19 @@ export class WebGLRenderer extends Renderer {
     getFontContext(): CanvasRenderingContext2D;
     /**
      * restores the canvas context
-     * @name restore
-     * @memberof WebGLRenderer
      */
     restore(): void;
     /**
      * saves the canvas context
-     * @name save
-     * @memberof WebGLRenderer
      */
     save(): void;
     /**
      * rotates the uniform matrix
-     * @name rotate
-     * @memberof WebGLRenderer
      * @param {number} angle in radians
      */
     rotate(angle: number): void;
     /**
      * scales the uniform matrix
-     * @name scale
-     * @memberof WebGLRenderer
      * @param {number} x
      * @param {number} y
      */
@@ -9340,37 +9181,27 @@ export class WebGLRenderer extends Renderer {
     setAntiAlias(context: any, enable: any): void;
     /**
      * Set the global alpha
-     * @name setGlobalAlpha
-     * @memberof WebGLRenderer
      * @param {number} alpha 0.0 to 1.0 values accepted.
      */
     setGlobalAlpha(alpha: number): void;
     /**
      * Return the global alpha
-     * @name getGlobalAlpha
-     * @memberof WebGLRenderer
      * @returns {number} global alpha value
      */
     getGlobalAlpha(): number;
     /**
      * Set the current fill & stroke style color.
      * By default, or upon reset, the value is set to #000000.
-     * @name setColor
-     * @memberof WebGLRenderer
      * @param {Color|string} color css color string.
      */
     setColor(color: Color | string): void;
     /**
      * Set the line width
-     * @name setLineWidth
-     * @memberof WebGLRenderer
      * @param {number} width Line width
      */
     setLineWidth(width: number): void;
     /**
      * Stroke an arc at the specified coordinates with given radius, start and end points
-     * @name strokeArc
-     * @memberof WebGLRenderer
      * @param {number} x arc center point x-axis
      * @param {number} y arc center point y-axis
      * @param {number} radius
@@ -9382,8 +9213,6 @@ export class WebGLRenderer extends Renderer {
     strokeArc(x: number, y: number, radius: number, start: number, end: number, antiClockwise?: boolean, fill?: boolean): void;
     /**
      * Fill an arc at the specified coordinates with given radius, start and end points
-     * @name fillArc
-     * @memberof WebGLRenderer
      * @param {number} x arc center point x-axis
      * @param {number} y arc center point y-axis
      * @param {number} radius
@@ -9394,8 +9223,6 @@ export class WebGLRenderer extends Renderer {
     fillArc(x: number, y: number, radius: number, start: number, end: number, antiClockwise?: boolean): void;
     /**
      * Stroke an ellipse at the specified coordinates with given radius
-     * @name strokeEllipse
-     * @memberof WebGLRenderer
      * @param {number} x ellipse center point x-axis
      * @param {number} y ellipse center point y-axis
      * @param {number} w horizontal radius of the ellipse
@@ -9405,8 +9232,6 @@ export class WebGLRenderer extends Renderer {
     strokeEllipse(x: number, y: number, w: number, h: number, fill?: boolean): void;
     /**
      * Fill an ellipse at the specified coordinates with given radius
-     * @name fillEllipse
-     * @memberof WebGLRenderer
      * @param {number} x ellipse center point x-axis
      * @param {number} y ellipse center point y-axis
      * @param {number} w horizontal radius of the ellipse
@@ -9415,8 +9240,6 @@ export class WebGLRenderer extends Renderer {
     fillEllipse(x: number, y: number, w: number, h: number): void;
     /**
      * Stroke a line of the given two points
-     * @name strokeLine
-     * @memberof WebGLRenderer
      * @param {number} startX the start x coordinate
      * @param {number} startY the start y coordinate
      * @param {number} endX the end x coordinate
@@ -9425,8 +9248,6 @@ export class WebGLRenderer extends Renderer {
     strokeLine(startX: number, startY: number, endX: number, endY: number): void;
     /**
      * Fill a line of the given two points
-     * @name fillLine
-     * @memberof WebGLRenderer
      * @param {number} startX the start x coordinate
      * @param {number} startY the start y coordinate
      * @param {number} endX the end x coordinate
@@ -9435,23 +9256,17 @@ export class WebGLRenderer extends Renderer {
     fillLine(startX: number, startY: number, endX: number, endY: number): void;
     /**
      * Stroke a me.Polygon on the screen with a specified color
-     * @name strokePolygon
-     * @memberof WebGLRenderer
      * @param {Polygon} poly the shape to draw
      * @param {boolean} [fill=false] also fill the shape with the current color if true
      */
     strokePolygon(poly: Polygon, fill?: boolean): void;
     /**
      * Fill a me.Polygon on the screen
-     * @name fillPolygon
-     * @memberof WebGLRenderer
      * @param {Polygon} poly the shape to draw
      */
     fillPolygon(poly: Polygon): void;
     /**
      * Draw a stroke rectangle at the specified coordinates
-     * @name strokeRect
-     * @memberof WebGLRenderer
      * @param {number} x
      * @param {number} y
      * @param {number} width
@@ -9461,8 +9276,6 @@ export class WebGLRenderer extends Renderer {
     strokeRect(x: number, y: number, width: number, height: number, fill?: boolean): void;
     /**
      * Draw a filled rectangle at the specified coordinates
-     * @name fillRect
-     * @memberof WebGLRenderer
      * @param {number} x
      * @param {number} y
      * @param {number} width
@@ -9471,8 +9284,6 @@ export class WebGLRenderer extends Renderer {
     fillRect(x: number, y: number, width: number, height: number): void;
     /**
      * Stroke a rounded rectangle at the specified coordinates
-     * @name strokeRoundRect
-     * @memberof WebGLRenderer
      * @param {number} x
      * @param {number} y
      * @param {number} width
@@ -9483,8 +9294,6 @@ export class WebGLRenderer extends Renderer {
     strokeRoundRect(x: number, y: number, width: number, height: number, radius: number, fill?: boolean): void;
     /**
      * Draw a rounded filled rectangle at the specified coordinates
-     * @name fillRoundRect
-     * @memberof WebGLRenderer
      * @param {number} x
      * @param {number} y
      * @param {number} width
@@ -9492,25 +9301,33 @@ export class WebGLRenderer extends Renderer {
      * @param {number} radius
      */
     fillRoundRect(x: number, y: number, width: number, height: number, radius: number): void;
+    /**
+     * Stroke a Point at the specified coordinates
+     * @param {number} x
+     * @param {number} y
+     */
+    strokePoint(x: number, y: number): void;
+    /**
+     * Draw a a point at the specified coordinates
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     */
+    fillPoint(x: number, y: number): void;
     /**
      * Reset (overrides) the renderer transformation matrix to the
      * identity one, and then apply the given transformation matrix.
-     * @name setTransform
-     * @memberof WebGLRenderer
      * @param {Matrix2d} mat2d Matrix to transform by
      */
     setTransform(mat2d: Matrix2d): void;
     /**
      * Multiply given matrix into the renderer tranformation matrix
-     * @name transform
-     * @memberof WebGLRenderer
      * @param {Matrix2d} mat2d Matrix to transform by
      */
     transform(mat2d: Matrix2d): void;
     /**
      * Translates the uniform matrix by the given coordinates
-     * @name translate
-     * @memberof WebGLRenderer
      * @param {number} x
      * @param {number} y
      */
@@ -9521,8 +9338,6 @@ export class WebGLRenderer extends Renderer {
      * You can however save the current region using the save(),
      * and restore it (with the restore() method) any time in the future.
      * (<u>this is an experimental feature !</u>)
-     * @name clipRect
-     * @memberof WebGLRenderer
      * @param {number} x
      * @param {number} y
      * @param {number} width
@@ -9533,8 +9348,6 @@ export class WebGLRenderer extends Renderer {
      * A mask limits rendering elements to the shape and position of the given mask object.
      * So, if the renderable is larger than the mask, only the intersecting part of the renderable will be visible.
      * Mask are not preserved through renderer context save and restore.
-     * @name setMask
-     * @memberof WebGLRenderer
      * @param {Rect|RoundRect|Polygon|Line|Ellipse} [mask] a shape defining the mask to be applied
      * @param {boolean} [invert=false] either the given shape should define what is visible (default) or the opposite
      */
@@ -12535,7 +12348,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
@@ -12550,14 +12362,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;