melonjs 17.3.0 → 18.0.0

package/build/utils/array.d.ts

@@ -0,0 +1,30 @@
+/**
+ * a collection of array utility functions
+ */
+/**
+ * Remove the specified object from the given Array
+ * @param arr - array from which to remove an object
+ * @param obj - to be removed
+ * @returns the modified Array
+ * let arr = [ "foo", "bar", "baz" ];
+ * // remove "foo" from the array
+ * me.utils.array.remove(arr, "foo");
+ */
+export declare function remove<T>(arr: T[], obj: T): T[];
+/**
+ * return a random array element
+ * @param arr - array to pick a element
+ * @returns random member of array
+ * @example
+ * // Select a random array element
+ * let arr = [ "foo", "bar", "baz" ];
+ * console.log(me.utils.array.random(arr));
+ */
+export declare function random<T>(arr: T[]): T;
+/**
+ * return a weighted random array element, favoring the earlier entries
+ * @param arr - array to pick a element
+ * @returns random member of array
+ */
+export declare function weightedRandom<T>(arr: T[]): T;
+//# sourceMappingURL=array.d.ts.map

package/build/utils/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/utils/array.ts"],"names":[],"mappings":"AAKA;;GAEG;AAEH;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,CAM/C;AAED;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,KAEjC;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,KAEzC"}

package/build/utils/file.d.ts

@@ -0,0 +1,16 @@
+/**
+ * a collection of file utility functions
+ */
+/**
+ * return the base name of the file without path info
+ * @param path -  path containing the basename to extract
+ * @returns the base name without path information.
+ */
+export declare function getBasename(path: string): string;
+/**
+ * return the extension of the file in the given path
+ * @param path - path containing the filename and extension to extract
+ * @returns filename extension.
+ */
+export declare function getExtension(path: string): string;
+//# sourceMappingURL=file.d.ts.map

package/build/utils/file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/utils/file.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,UAEvC;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,UAExC"}

package/build/utils/function.d.ts

@@ -0,0 +1,24 @@
+/**
+ * a collection of utility functions
+ */
+/**
+ * Executes a function as soon as the interpreter is idle (stack empty).
+ * @param func - The function to be deferred.
+ * @param thisArg - The value to be passed as the this parameter to the target function when the deferred function is called
+ * @param args - Optional additional arguments to carry for the function.
+ * @returns id that can be used to clear the deferred function using
+ * clearTimeout
+ * @example
+ * // execute myFunc() when the stack is empty,
+ * // with the current context and [1, 2, 3] as parameter
+ * me.utils.function.defer(myFunc, this, 1, 2, 3);
+ */
+export declare function defer(func: () => unknown, thisArg: unknown, ...args: unknown[]): number;
+/**
+ * returns a function that, when invoked will only be triggered at most once during a given window of time
+ * @param fn - the function to be throttled.
+ * @param [wait] - the delay in ms
+ * @returns the function that will be throttled
+ */
+export declare const throttle: (fn: () => void, wait?: number) => (...args: []) => void;
+//# sourceMappingURL=function.d.ts.map

package/build/utils/function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../src/utils/function.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CACpB,IAAI,EAAE,MAAM,OAAO,EACnB,OAAO,EAAE,OAAO,EAChB,GAAG,IAAI,EAAE,OAAO,EAAE,UAGlB;AAED;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,IAAI,MAAM,IAAI,EAAE,OAAM,MAAY,MAIlD,GAAG,MAAM,EAAE,SAkBnB,CAAC"}

package/build/utils/semver.d.ts

@@ -0,0 +1,2 @@
+export declare const compare: (a: string, b: string) => 0 | 1 | -1;
+//# sourceMappingURL=semver.d.ts.map

package/build/utils/semver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semver.d.ts","sourceRoot":"","sources":["../../src/utils/semver.ts"],"names":[],"mappings":"AAqEA,eAAO,MAAM,OAAO,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,eAE3C,CAAC"}

package/build/utils/string.d.ts

@@ -0,0 +1,35 @@
+/**
+ * a collection of string utility functions
+ */
+/**
+ * converts the first character of the given string to uppercase
+ * @param str - the string to be capitalized
+ * @returns the capitalized string
+ */
+export declare function capitalize(str: string): string;
+/**
+ * returns true if the given string contains a numeric integer or float value
+ * @param str - the string to be tested
+ * @returns true if string contains only digits
+ */
+export declare function isNumeric(str: string): boolean;
+/**
+ * returns true if the given string contains a true or false
+ * @param str - the string to be tested
+ * @returns true if the string is either true or false
+ */
+export declare function isBoolean(str: string): boolean;
+/**
+ * convert a string to the corresponding hexadecimal value
+ * @param str - the string to be converted
+ * @returns the converted hexadecimal value
+ */
+export declare function toHex(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)
+ * @param str - the string (url) to be tested
+ * @returns true if the string is a data url
+ */
+export declare function isDataUrl(str: string): boolean;
+//# sourceMappingURL=string.d.ts.map

package/build/utils/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/utils/string.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,UAErC;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,WAKpC;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,WAGpC;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,UAOhC;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,WAEpC"}

package/build/utils/types.d.ts

@@ -0,0 +1,5 @@
+export type XYPoint = {
+    x: number;
+    y: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/build/utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/utils/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/build/utils/utils.d.ts

@@ -0,0 +1,49 @@
+export * as agent from "./agent.js";
+export * as array from "./array.js";
+export * as file from "./file.js";
+export * as function from "./function.js";
+export * as string from "./string.js";
+/**
+ * Compare two version strings
+ * @param v1 - First version string to compare
+ * @param v2 - second version string to compare
+ * @returns Return 0 if v1 == v2, or 1 if v1 is greater, or -1 if v2 is greater
+ * @example
+ * if (me.utils.checkVersion("7.0.0") > 0) {
+ *     console.error(
+ *         "melonJS is too old. Expected: 7.0.0, Got: 6.3.0"
+ *     );
+ * }
+ */
+export declare function checkVersion(v1: string, v2: string): 0 | 1 | -1;
+/**
+ * parse the fragment (hash) from a URL and returns them into
+ * @param [url] - an optional params string or URL containing fragment (hash) params to be parsed
+ * @returns an object representing the deserialized params string.
+ * [hitbox=false] draw the hitbox in the debug panel (if enabled)
+ * [velocity=false] draw the entities velocity in the debug panel (if enabled)
+ * [quadtree=false] draw the quadtree in the debug panel (if enabled)
+ * [webgl=false] force the renderer to WebGL
+ * [debug=false] display the debug panel (if preloaded)
+ * [debugToggleKey="s"] show/hide the debug panel (if preloaded)
+ * @example
+ * // http://www.example.com/index.html#debug&hitbox=true&mytag=value
+ * let UriFragment = me.utils.getUriFragment();
+ * console.log(UriFragment["mytag"]); //> "value"
+ */
+export declare function getUriFragment(url: string): Record<string, string | boolean>;
+/**
+ * reset the GUID Base Name
+ * the idea here being to have a unique ID
+ * per level / object
+ * @ignore
+ */
+export declare function resetGUID(base: string, index?: number): void;
+/**
+ * create and return a very simple GUID
+ * Game Unique ID
+ * @ignore
+ */
+export declare function createGUID(index?: number): string;
+export declare const isStringArray: (value: unknown) => value is string[];
+//# sourceMappingURL=utils.d.ts.map

package/build/utils/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils/utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAWtC;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,cAalD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,oCA0CzC;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,SAAI,QAIhD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,SAAI,UAInC;AAED,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAAM,EAO7D,CAAC"}

package/build/version.d.ts

@@ -0,0 +1,5 @@
+/**
+ * current melonJS version
+ */
+export declare const version: string;
+//# sourceMappingURL=version.d.ts.map

package/build/version.d.ts.map

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

package/{dist/types → build}/video/canvas/canvas_renderer.d.ts

@@ -1,7 +1,14 @@
 /**
- * @classdesc
+ * additional import for TypeScript
+ * @import {Rect} from "./../../geometries/rectangle.ts";
+ * @import {RoundRect} from "./../../geometries/roundrect.ts";
+ * @import {Polygon} from "../../geometries/polygon.ts";
+ * @import {Line} from "./../../geometries/line.ts";
+ * @import {Ellipse} from "./../../geometries/ellipse.ts";
+ * @import {Matrix2d} from "../../math/matrix2d.ts";
+ */
+/**
  * a canvas renderer object
- * @augments Renderer
  */
 export default class CanvasRenderer extends Renderer {
     cache: TextureCache;
@@ -13,24 +20,24 @@ export default class CanvasRenderer extends Renderer {
      * set a blend mode for the given context. <br>
      * Supported blend mode between Canvas and WebGL remderer : <br>
      * - "normal" : this is the default mode and draws new content on top of the existing content <br>
-     * <img src="images/normal-blendmode.png" width="510"/> <br>
+     * <img src="../images/normal-blendmode.png" width="510"/> <br>
      * - "multiply" : the pixels of the top layer are multiplied with the corresponding pixel of the bottom layer. A darker picture is the result. <br>
-     * <img src="images/multiply-blendmode.png" width="510"/> <br>
+     * <img src="../images/multiply-blendmode.png" width="510"/> <br>
      * - "additive or lighter" : where both content overlap the color is determined by adding color values. <br>
-     * <img src="images/lighter-blendmode.png" width="510"/> <br>
+     * <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>
+     * <img src="../images/screen-blendmode.png" width="510"/> <br>
      * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation
      * @param {string} [mode="normal"] - blend mode : "normal", "multiply", "lighter, "additive", "screen"
      * @param {CanvasRenderingContext2D} [context]
      */
-    setBlendMode(mode?: string | undefined, context?: CanvasRenderingContext2D | undefined): void;
+    setBlendMode(mode?: string, context?: CanvasRenderingContext2D): void;
     /**
      * Clears the main framebuffer with the given color
      * @param {Color|string} [color="#000000"] - CSS color.
      * @param {boolean} [opaque=false] - Allow transparency [default] or clear the surface completely [true]
      */
-    clearColor(color?: string | Color | undefined, opaque?: boolean | undefined): void;
+    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)).
      * @param {number} x - x axis of the coordinate for the rectangle starting point.
@@ -128,18 +135,18 @@ export default class CanvasRenderer extends Renderer {
     roundRect(x: number, y: number, width: number, height: number, radii: any): void;
     /**
      * stroke the given shape or the current defined path
-     * @param {Rect|RoundRect|Polygon|Line|Ellipse} [shape] - a shape object to stroke
+     * @param {Rect|RoundRect|Polygon|Line|Ellipse|Bounds} [shape] - a shape object to stroke
      * @param {boolean} [fill=false] - fill the shape with the current color if true
      */
-    stroke(shape?: Rect | RoundRect | Polygon | Line | Ellipse, fill?: boolean | undefined): void;
+    stroke(shape?: Rect | RoundRect | Polygon | Line | Ellipse | Bounds, fill?: boolean): void;
     /**
      * fill the given shape or the current defined path
-     * @param {Rect|RoundRect|Polygon|Line|Ellipse} [shape] - a shape object to fill
+     * @param {Rect|RoundRect|Polygon|Line|Ellipse|Bounds} [shape] - a shape object to fill
      */
-    fill(shape?: Rect | RoundRect | Polygon | Line | Ellipse): void;
+    fill(shape?: Rect | RoundRect | Polygon | Line | Ellipse | Bounds): void;
     /**
      * add a straight line from the current point to the start of the current sub-path. If the shape has already been closed or has only one point, this function does nothing
-    */
+     */
     closePath(): void;
     /**
      * Stroke an arc at the specified coordinates with given radius, start and end points
@@ -151,7 +158,7 @@ export default class CanvasRenderer extends Renderer {
      * @param {boolean} [antiClockwise=false] - draw arc anti-clockwise
      * @param {boolean} [fill=false] - also fill the shape with the current color if true
      */
-    strokeArc(x: number, y: number, radius: number, start: number, end: number, antiClockwise?: boolean | undefined, fill?: boolean | undefined): void;
+    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
      * @param {number} x - arc center point x-axis
@@ -161,7 +168,7 @@ export default class CanvasRenderer extends Renderer {
      * @param {number} end - end angle in radians
      * @param {boolean} [antiClockwise=false] - draw arc anti-clockwise
      */
-    fillArc(x: number, y: number, radius: number, start: number, end: number, antiClockwise?: boolean | undefined): void;
+    fillArc(x: number, y: number, radius: number, start: number, end: number, antiClockwise?: boolean): void;
     /**
      * Stroke an ellipse at the specified coordinates with given radius
      * @param {number} x - ellipse center point x-axis
@@ -170,7 +177,7 @@ export default class CanvasRenderer extends Renderer {
      * @param {number} h - vertical radius of the ellipse
      * @param {boolean} [fill=false] - also fill the shape with the current color if true
      */
-    strokeEllipse(x: number, y: number, w: number, h: number, fill?: boolean | undefined): void;
+    strokeEllipse(x: number, y: number, w: number, h: number, fill?: boolean): void;
     /**
      * Fill an ellipse at the specified coordinates with given radius
      * @param {number} x - ellipse center point x-axis
@@ -200,7 +207,7 @@ export default class CanvasRenderer extends Renderer {
      * @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 | undefined): void;
+    strokePolygon(poly: Polygon, fill?: boolean): void;
     /**
      * Fill the given me.Polygon on the screen
      * @param {Polygon} poly - the shape to draw
@@ -214,7 +221,7 @@ export default class CanvasRenderer extends Renderer {
      * @param {number} height
      * @param {boolean} [fill=false] - also fill the shape with the current color if true
      */
-    strokeRect(x: number, y: number, width: number, height: number, fill?: boolean | undefined): void;
+    strokeRect(x: number, y: number, width: number, height: number, fill?: boolean): void;
     /**
      * Draw a filled rectangle at the specified coordinates
      * @param {number} x
@@ -232,7 +239,7 @@ export default class CanvasRenderer extends Renderer {
      * @param {number} radius
      * @param {boolean} [fill=false] - also fill the shape with the current color if true
      */
-    strokeRoundRect(x: number, y: number, width: number, height: number, radius: number, fill?: boolean | undefined): void;
+    strokeRoundRect(x: number, y: number, width: number, height: number, radius: number, fill?: boolean): void;
     /**
      * Draw a rounded filled rectangle at the specified coordinates
      * @param {number} x
@@ -322,11 +329,24 @@ export default class CanvasRenderer extends Renderer {
     /**
      * @ignore
      */
-    set lineWidth(value: number | ((width: number) => void));
+    set lineWidth(value: number);
     /**
      * sets or returns the thickness of lines for shape drawing
+     * @type {number}
+     * @default 1
+     */
+    get lineWidth(): number;
+    /**
+     * @ignore
+     */
+    set lineJoin(value: string);
+    /**
+     * sets or returns the shape used to join two line segments where they meet.
+     * There are three possible values for this property: "round", "bevel", and "miter"
+     * @type {string}
+     * @default "miter"
      */
-    get lineWidth(): number | ((width: number) => void);
+    get lineJoin(): string;
     /**
      * Reset (overrides) the renderer transformation matrix to the
      * identity one, and then apply the given transformation matrix.
@@ -367,7 +387,23 @@ export default class CanvasRenderer extends Renderer {
      * @param {number} height
      */
     clipRect(x: number, y: number, width: number, height: number): void;
+    /**
+     * A mask limits rendering elements to the shape and position of the given mask object.
+     * If the drawing or rendering area is larger than the mask, only the intersecting part of the renderable will be visible.
+     * (Note Mask are not preserved through renderer context save and restore and need so be manually cleared)
+     * @see CanvasRenderer#clearMask
+     * @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, invert?: boolean): void;
 }
 import Renderer from "./../renderer.js";
 import TextureCache from "./../texture/cache.js";
-import Color from "./../../math/color.js";
+import { Color } from "./../../math/color.ts";
+import type { Rect } from "./../../geometries/rectangle.ts";
+import type { RoundRect } from "./../../geometries/roundrect.ts";
+import type { Polygon } from "../../geometries/polygon.ts";
+import type { Line } from "./../../geometries/line.ts";
+import type { Ellipse } from "./../../geometries/ellipse.ts";
+import type { Matrix2d } from "../../math/matrix2d.ts";
+//# sourceMappingURL=canvas_renderer.d.ts.map

package/build/video/canvas/canvas_renderer.d.ts.map

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

package/{dist/types → build}/video/renderer.d.ts

@@ -1,12 +1,19 @@
 /**
- * @classdesc
+ * @import {Rect} from "./../geometries/rectangle.ts";
+ * @import {RoundRect} from "./../geometries/roundrect.ts";
+ * @import {Polygon} from "../geometries/polygon.ts";
+ * @import {Line} from "./../geometries/line.ts";
+ * @import {Ellipse} from "./../geometries/ellipse.ts";
+ * @import {Bounds} from "./../physics/bounds.ts";
+ */
+/**
  * a base renderer object
  */
 export default class Renderer {
     /**
      * @param {ApplicationSettings} [options] - optional parameters for the renderer
      */
-    constructor(options?: any);
+    constructor(options?: ApplicationSettings);
     /**
      * The renderer renderTarget
      * @name renderTarget
@@ -54,10 +61,17 @@ export default class Renderer {
      * @type {string}
      */
     type: string;
+    /**
+     * The background color used to clear the main framebuffer.
+     * Note: alpha value will be set based on the transparent property of the renderer settings.
+     * @default black
+     * @type {Color}
+     */
+    backgroundColor: Color;
     /**
      * @ignore
      */
-    currentScissor: Int32Array;
+    currentScissor: Int32Array<ArrayBuffer>;
     /**
      * @ignore
      */
@@ -135,7 +149,7 @@ export default class Renderer {
      * enable/disable image smoothing (scaling interpolation) for the current render target
      * @param {boolean} [enable=false]
      */
-    setAntiAlias(enable?: boolean | undefined): void;
+    setAntiAlias(enable?: boolean): void;
     /**
      * set/change the current projection matrix (WebGL only)
      * @param {Matrix3d} matrix
@@ -143,15 +157,15 @@ export default class Renderer {
     setProjection(matrix: Matrix3d): void;
     /**
      * stroke the given shape
-     * @param {Rect|RoundRect|Polygon|Line|Ellipse} shape - a shape object to stroke
+     * @param {Rect|RoundRect|Polygon|Line|Ellipse|Bounds} shape - a shape object to stroke
      * @param {boolean} [fill=false] - fill the shape with the current color if true
      */
-    stroke(shape: Rect | RoundRect | Polygon | Line | Ellipse, fill?: boolean | undefined): void;
+    stroke(shape: Rect | RoundRect | Polygon | Line | Ellipse | Bounds, fill?: boolean): void;
     /**
      * fill the given shape
-     * @param {Rect|RoundRect|Polygon|Line|Ellipse} shape - a shape object to fill
+     * @param {Rect|RoundRect|Polygon|Line|Ellipse|Bounds} shape - a shape object to fill
      */
-    fill(shape: Rect | RoundRect | Polygon | Line | Ellipse): void;
+    fill(shape: Rect | RoundRect | Polygon | Line | Ellipse | Bounds): void;
     /**
      * tint the given image or canvas using the given color
      * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas} src - the source image to be tinted
@@ -159,7 +173,7 @@ export default class Renderer {
      * @param {string} [mode="multiply"] - the composition mode used to tint the image
      * @returns {HTMLCanvasElement|OffscreenCanvas} a new canvas or offscreencanvas (if supported) element representing the tinted image
      */
-    tint(src: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas, color: Color | string, mode?: string | undefined): HTMLCanvasElement | OffscreenCanvas;
+    tint(src: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas, color: Color | string, mode?: string): HTMLCanvasElement | OffscreenCanvas;
     /**
      * 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.
@@ -167,7 +181,7 @@ export default class 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, invert?: boolean | undefined): void;
+    setMask(): void;
     /**
      * disable (remove) the rendering mask set through setMask.
      * @see Renderer#setMask
@@ -178,7 +192,7 @@ export default class Renderer {
      * @param {Color} tint - the tint color
      * @param {number} [alpha] - an alpha value to be applied to the tint
      */
-    setTint(tint: Color, alpha?: number | undefined): void;
+    setTint(tint: Color, alpha?: number): void;
     /**
      * clear the rendering tint set through setTint.
      * @see Renderer#setTint
@@ -192,7 +206,7 @@ export default class Renderer {
      * @example
      * renderer.convertToBlob().then((blob) => console.log(blob));
      */
-    toBlob(type?: string | undefined, quality?: number | undefined): Promise<any>;
+    toBlob(type?: string, quality?: number): Promise<any>;
     /**
      * creates an ImageBitmap object of the last frame rendered
      * (not supported by standard Canvas)
@@ -202,7 +216,7 @@ export default class Renderer {
      * @example
      * renderer.transferToImageBitmap().then((image) => console.log(image));
      */
-    toImageBitmap(type?: string | undefined, quality?: number | undefined): Promise<any>;
+    toImageBitmap(type?: string, quality?: number): Promise<any>;
     /**
      * returns a data URL containing a representation of the last frame rendered
      * @param {string} [type="image/png"] - A string indicating the image format
@@ -211,10 +225,17 @@ export default class Renderer {
      * @example
      * renderer.toDataURL().then((dataURL) => console.log(dataURL));
      */
-    toDataURL(type?: string | undefined, quality?: number | undefined): Promise<any>;
+    toDataURL(type?: string, quality?: number): Promise<any>;
 }
 import CanvasRenderTarget from "./rendertarget/canvasrendertarget.js";
-import Vector2d from "../math/vector2.js";
+import { Vector2d } from "../math/vector2d.ts";
 import Path2D from "./../geometries/path2d.js";
-import Color from "./../math/color.js";
-import Matrix3d from "./../math/matrix3.js";
+import { Color } from "./../math/color.ts";
+import { Matrix3d } from "../math/matrix3d.ts";
+import type { Rect } from "./../geometries/rectangle.ts";
+import type { Bounds } from "./../physics/bounds.ts";
+import type { RoundRect } from "./../geometries/roundrect.ts";
+import type { Polygon } from "../geometries/polygon.ts";
+import type { Line } from "./../geometries/line.ts";
+import type { Ellipse } from "./../geometries/ellipse.ts";
+//# sourceMappingURL=renderer.d.ts.map

package/build/video/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/video/renderer.js"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AAEH;;GAEG;AACH;IACC;;OAEG;IACH,sBAFW,mBAAmB,EA6G7B;IA1GA;;;;OAIG;IACH,cAFU,kBAAkB,CAS3B;IAED;;;;OAIG;IACH,iBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,oBAFU,MAAM,CAE6C;IAE7D;;;;OAIG;IACH,YAHU,QAAQ,CAGsD;IAExE;;;;OAIG;IACH,gBAFU,OAAO,CAES;IAE1B;;;;OAIG;IACH,WAHU,MAAM,CAGU;IAE1B;;;OAGG;IACH,QAFU,MAAM,CAEU;IAE1B;;;;OAIG;IACH,MAFU,MAAM,CAEK;IAErB;;;;;OAKG;IACH,iBAFU,KAAK,CAOd;IAED;;OAEG;IACH,wCAKE;IAEF;;OAEG;IACH,kBAAkB;IAElB;;OAEG;IACH,yBAA8B;IAG9B,oBAA2C;IAG3C,mBAAgD;IAGhD,2BAAsC;IAGtC,iBAAiB;IAWlB,kBANa,MAAM,EAQlB;IAVD;;;OAGG;IACH,cAFa,MAAM,CAIlB;IAcD,iBANa,MAAM,EAQlB;IAVD;;;OAGG;IACH,aAFa,MAAM,CAIlB;IAMD;;OAEG;IACH,cAAU;IAEV;;OAEG;IACH,cAAU;IAEV;;OAEG;IACH,cAWC;IAED;;;OAGG;IACH,aAFa,iBAAiB,CAI7B;IAED;;;OAGG;IACH,cAFa,wBAAwB,GAAC,qBAAqB,CAI1D;IAED;;;OAGG;IACH,gBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,YAFa,KAAK,CAIjB;IAED;;;OAGG;IACH,eAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAHW,IAAI,GAAC,MAAM,GACT,OAAO,CASnB;IAED;;;;OAIG;IACH,cAHW,MAAM,UACN,MAAM,QAchB;IAED;;;OAGG;IACH,sBAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,sBAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,cAHW,IAAI,GAAC,SAAS,GAAC,OAAO,GAAC,IAAI,GAAC,OAAO,GAAC,MAAM,SAC1C,OAAO,QA8CjB;IAED;;;OAGG;IACH,YAFW,IAAI,GAAC,SAAS,GAAC,OAAO,GAAC,IAAI,GAAC,OAAO,GAAC,MAAM,QAIpD;IAED;;;;;;OAMG;IACH,UALW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,SAClD,KAAK,GAAC,MAAM,SACZ,MAAM,GACJ,iBAAiB,GAAC,eAAe,CAyB7C;IAED;;;;;;OAMG;IACH,gBAAY;IAEZ;;;OAGG;IACH,kBAAc;IAEd;;;;OAIG;IACH,cAHW,KAAK,UACL,MAAM,QAMhB;IAED;;;OAGG;IACH,kBAGC;IAED;;;;;;;OAOG;IACH,cANW,MAAM,YACN,MAAM,gBAOhB;IAED;;;;;;;;OAQG;IACH,qBANW,MAAM,YACN,MAAM,gBAOhB;IAED;;;;;;;OAOG;IACH,iBANW,MAAM,YACN,MAAM,gBAOhB;CACD;+BA5a8B,sCAAsC;yBAF5C,qBAAqB;mBAH3B,2BAA2B;sBACxB,oBAAoB;yBACjB,qBAAqB;0BAMvB,8BAA8B;4BAK5B,wBAAwB;+BAJrB,8BAA8B;6BAChC,0BAA0B;0BAC7B,yBAAyB;6BACtB,4BAA4B"}

package/{dist/types → build}/video/rendertarget/canvasrendertarget.d.ts

@@ -6,26 +6,33 @@ declare class CanvasRenderTarget {
     /**
      * @param {number} width - the desired width of the canvas
      * @param {number} height - the desired height of the canvas
-     * @param {Settings} attributes - The attributes to create both the canvas and context
-     * @param {boolean} [attributes.context="2d"] - the context type to be created ("2d", "webgl")
+     * @param {object} attributes - The attributes to create both the canvas and context
+     * @param {string} [attributes.context="2d"] - the context type to be created ("2d", "webgl")
      * @param {boolean} [attributes.preferWebGL1=false] - set to true for force using WebGL1 instead of WebGL2 (if supported)
      * @param {boolean} [attributes.transparent=false] - specify if the canvas contains an alpha channel
      * @param {boolean} [attributes.offscreenCanvas=false] - will create an offscreenCanvas if true instead of a standard canvas
      * @param {boolean} [attributes.willReadFrequently=false] - Indicates whether or not a lot of read-back operations are planned
      * @param {boolean} [attributes.antiAlias=false] - Whether to enable anti-aliasing, use false (default) for a pixelated effect.
      */
-    constructor(width: number, height: number, attributes?: Settings);
+    constructor(width: number, height: number, attributes?: {
+        context?: string | undefined;
+        preferWebGL1?: boolean | undefined;
+        transparent?: boolean | undefined;
+        offscreenCanvas?: boolean | undefined;
+        willReadFrequently?: boolean | undefined;
+        antiAlias?: boolean | undefined;
+    });
     /**
      * the canvas created for this CanvasRenderTarget
      * @type {HTMLCanvasElement|OffscreenCanvas}
      */
-    canvas: HTMLCanvasElement | OffscreenCanvas;
     /**
      * the rendering context of this CanvasRenderTarget
      * @type {CanvasRenderingContext2D|WebGLRenderingContext}
      */
-    context: CanvasRenderingContext2D | WebGLRenderingContext;
-    attributes: any;
+    attributes: CanvasRenderingContext2D | WebGLRenderingContext;
+    canvas: any;
+    context: any;
     WebGLVersion: any;
     /**
      * @ignore
@@ -39,7 +46,7 @@ declare class CanvasRenderTarget {
      * enable/disable image smoothing (scaling interpolation)
      * @param {boolean} [enable=false] - whether to enable or not image smoothing (scaling interpolation)
      */
-    setAntiAlias(enable?: boolean | undefined): void;
+    setAntiAlias(enable?: boolean): void;
     /**
      * Resizes the canvas texture to the given width and height.
      * @param {number} width - the desired width
@@ -64,7 +71,7 @@ declare class CanvasRenderTarget {
      * @example
      * renderTarget.convertToBlob().then((blob) => console.log(blob));
      */
-    toBlob(type?: string | undefined, quality?: number | undefined): Promise<any>;
+    toBlob(type?: string, quality?: number): Promise<any>;
     /**
      * creates an ImageBitmap object from the most recently rendered image of this canvas texture
      * @param {string} [type="image/png"] - A string indicating the image format
@@ -73,7 +80,7 @@ declare class CanvasRenderTarget {
      * @example
      * renderTarget.transferToImageBitmap().then((bitmap) => console.log(bitmap));
      */
-    toImageBitmap(type?: string | undefined, quality?: number | undefined): Promise<any>;
+    toImageBitmap(type?: string, quality?: number): Promise<any>;
     /**
      * returns a data URL containing a representation of the most recently rendered image of this canvas texture
      * (not supported by OffscreenCanvas)
@@ -83,7 +90,7 @@ declare class CanvasRenderTarget {
      * @example
      * renderer.toDataURL().then((dataURL) => console.log(dataURL));
      */
-    toDataURL(type?: string | undefined, quality?: number | undefined): Promise<any>;
+    toDataURL(type?: string, quality?: number): Promise<any>;
     /**
      * invalidate the current CanvasRenderTarget, and force a reupload of the corresponding texture
      * (call this if you modify the canvas content between two draw calls)
@@ -110,3 +117,6 @@ declare class CanvasRenderTarget {
      */
     public get height(): number;
 }
+import type CanvasRenderer from "./../canvas/canvas_renderer.js";
+import type WebGLRenderer from "./../webgl/webgl_renderer.js";
+//# sourceMappingURL=canvasrendertarget.d.ts.map

package/build/video/rendertarget/canvasrendertarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvasrendertarget.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/canvasrendertarget.js"],"names":[],"mappings":";AA8EA;;GAEG;AACH;IACC;;;;;;;;;;OAUG;IACH,mBAVW,MAAM,UACN,MAAM,eAEd;QAA4B,OAAO;QACN,YAAY;QACZ,WAAW;QACX,eAAe;QACf,kBAAkB;QAClB,SAAS;KACxC,EAuCA;IArCA;;;OAGG;IAGH;;;OAGG;IAGH,YAJU,wBAAwB,GAAC,qBAAqB,CAIU;IASjE,YAA+B;IAUhC,aAA0D;IAE1D,kBAAgC;IAMjC;;OAEG;IACH,4CAGC;IAED;;OAEG;IACH,cAGC;IAED;;;OAGG;IACH,sBAFW,OAAO,QAwBjB;IAED;;;;OAIG;IACH,cAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;;;;;OAQG;IACH,gBANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ,SAAS,CAUrB;IAED;;;;;;;OAOG;IACH,cANW,MAAM,YACN,MAAM,gBAmBhB;IAED;;;;;;;OAOG;IACH,qBANW,MAAM,YACN,MAAM,gBAmBhB;IAED;;;;;;;;OAQG;IACH,iBANW,MAAM,YACN,MAAM,gBAShB;IAED;;;;OAIG;IACH,qBAFW,cAAc,GAAC,aAAa,QAYtC;IALC,mBAEC;IAKH;;OAEG;IACH,gBAGC;IAWD,sBANU,MAAM,EAQf;IAXD;;;;OAIG;IACH,oBAFU,MAAM,CAIf;IAeD,uBANU,MAAM,EAQf;IAXD;;;;OAIG;IACH,qBAFU,MAAM,CAIf;CAKD;gCAzT8B,gCAAgC;+BACjC,8BAA8B"}