melonjs 17.4.0 → 18.0.0

package/{dist/types → build}/camera/camera2d.d.ts

@@ -1,7 +1,5 @@
 /**
- * @classdesc
  * a 2D orthographic camera
- * @augments Renderable
  */
 export default class Camera2d extends Renderable {
     /**
@@ -12,8 +10,6 @@ export default class Camera2d extends Renderable {
      * @property {number} VERTICAL vertical axis only
      * @property {number} BOTH both axis
      * @readonly
-     * @name AXIS
-     * @memberof Camera2d
      */
     readonly AXIS: {
         NONE: number;
@@ -23,12 +19,9 @@ export default class Camera2d extends Renderable {
     };
     /**
      * Camera bounds
-     * @public
      * @type {Bounds}
-     * @name bounds
-     * @memberof Camera2d
      */
-    public bounds: Bounds;
+    bounds: Bounds;
     /**
      * enable or disable damping
      * @private
@@ -38,61 +31,59 @@ export default class Camera2d extends Renderable {
     /**
      * Camera damping for smooth transition [0 .. 1].
      * 1 being the maximum value and will snap the camera to the target position
-     * @public
      * @type {number}
-     * @name damping
      * @default 1.0
-     * @memberof Camera2d
      */
-    public damping: number;
+    damping: number;
     /**
      * the closest point relative to the camera
-     * @public
      * @type {number}
-     * @name near
      * @default -1000
-     * @memberof Camera2d
      */
-    public near: number;
+    near: number;
     /**
      * the furthest point relative to the camera.
-     * @public
      * @type {number}
-     * @name far
      * @default 1000
-     * @memberof Camera2d
      */
-    public far: number;
+    far: number;
     /**
      * the default camera projection matrix
      * (2d cameras use an orthographic projection by default).
-     * @public
      * @type {Matrix3d}
-     * @name projectionMatrix
-     * @memberof Camera2d
      */
-    public projectionMatrix: Matrix3d;
+    projectionMatrix: Matrix3d;
     /**
      * the invert camera transform used to unproject points
      * @ignore
      * @type {Matrix2d}
-     * @name invCurrentTransform
-     * @memberof Camera2d
      */
     invCurrentTransform: Matrix2d;
     offset: Vector2d;
     target: Vector2d | null;
     follow_axis: number;
+    /**
+     * shake variables
+     * @ignore
+     */
     _shake: {
         intensity: number;
         duration: number;
         axis: number;
         onComplete: null;
     };
+    /**
+     * flash variables
+     * @ignore
+     */
     _fadeOut: {
         color: null;
         tween: null;
     };
+    /**
+     * fade variables
+     * @ignore
+     */
     _fadeIn: {
         color: null;
         tween: null;
@@ -100,24 +91,20 @@ export default class Camera2d extends Renderable {
     /** @ignore */
     _updateProjectionMatrix(): void;
     /** @ignore */
-    _followH(target: any): number | undefined;
+    _followH(target: any): number;
     /** @ignore */
-    _followV(target: any): number | undefined;
+    _followV(target: any): number;
     /**
      * reset the camera position to specified coordinates
-     * @name reset
-     * @memberof Camera2d
      * @param {number} [x=0] - initial position of the camera on the x axis
      * @param {number} [y=0] - initial position of the camera on the y axis
      */
-    reset(x?: number | undefined, y?: number | undefined): void;
+    reset(x?: number, y?: number): void;
     /**
      * change the deadzone settings.
      * the "deadzone" defines an area within the current camera in which
      * the followed renderable can move without scrolling the camera.
-     * @name setDeadzone
-     * @see Camera2d.follow
-     * @memberof Camera2d
+     * @see {@link follow}
      * @param {number} w - deadzone width
      * @param {number} h - deadzone height
      */
@@ -125,8 +112,6 @@ export default class Camera2d extends Renderable {
     deadzone: Rect | undefined;
     /**
      * resize the camera
-     * @name resize
-     * @memberof Camera2d
      * @param {number} w - new width of the camera
      * @param {number} h - new height of the camera
      * @returns {Camera2d} this camera
@@ -135,8 +120,6 @@ export default class Camera2d extends Renderable {
     /**
      * set the camera boundaries (set to the world limit by default).
      * the camera is bound to the given coordinates and cannot move/be scrolled outside of it.
-     * @name setBounds
-     * @memberof Camera2d
      * @param {number} x - world left limit
      * @param {number} y - world top limit
      * @param {number} w - world width limit
@@ -146,8 +129,6 @@ export default class Camera2d extends Renderable {
     /**
      * set the camera to follow the specified renderable. <br>
      * (this will put the camera center around the given target)
-     * @name follow
-     * @memberof Camera2d
      * @param {Renderable|Vector2d} target - renderable or position vector to follow
      * @param {number} [axis=me.game.viewport.AXIS.BOTH] - Which axis to follow (see {@link Camera2d.AXIS})
      * @param {number} [damping=1] - default damping value
@@ -155,18 +136,14 @@ export default class Camera2d extends Renderable {
      * // set the camera to follow this renderable on both axis, and enable damping
      * me.game.viewport.follow(this, me.game.viewport.AXIS.BOTH, 0.1);
      */
-    follow(target: Renderable | Vector2d, axis?: number | undefined, damping?: number | undefined): void;
+    follow(target: Renderable | Vector2d, axis?: number, damping?: number): void;
     /**
      * unfollow the current target
-     * @name unfollow
-     * @memberof Camera2d
      */
     unfollow(): void;
     /**
      * move the camera upper-left position by the specified offset.
-     * @name move
-     * @memberof Camera2d
-     * @see Camera2d.focusOn
+     * @see {@link focusOn}
      * @param {number} x - horizontal offset
      * @param {number} y - vertical offset
      * @example
@@ -176,9 +153,7 @@ export default class Camera2d extends Renderable {
     move(x: number, y: number): void;
     /**
      * move the camera upper-left position to the specified coordinates
-     * @name moveTo
-     * @memberof Camera2d
-     * @see Camera2d.focusOn
+     * @see {@link focusOn}
      * @param {number} x
      * @param {number} y
      */
@@ -189,8 +164,6 @@ export default class Camera2d extends Renderable {
     update(dt: any): boolean;
     /**
      * shake the camera
-     * @name shake
-     * @memberof Camera2d
      * @param {number} intensity - maximum offset that the screen can be moved
      * while shaking
      * @param {number} duration - expressed in milliseconds
@@ -201,12 +174,10 @@ export default class Camera2d extends Renderable {
      * // shake it baby !
      * me.game.viewport.shake(10, 500, me.game.viewport.AXIS.BOTH);
      */
-    shake(intensity: number, duration: number, axis?: number | undefined, onComplete?: Function | undefined, force?: boolean | undefined): void;
+    shake(intensity: number, duration: number, axis?: number, onComplete?: Function, force?: boolean): void;
     /**
      * fadeOut(flash) effect<p>
      * screen is filled with the specified color and slowly goes back to normal
-     * @name fadeOut
-     * @memberof Camera2d
      * @param {Color|string} color - a CSS color value
      * @param {number} [duration=1000] - expressed in milliseconds
      * @param {Function} [onComplete] - callback once effect is over
@@ -218,12 +189,10 @@ export default class Camera2d extends Renderable {
      *     me.game.viewport.fadeOut("#fff", 150);
      * });
      */
-    fadeOut(color: Color | string, duration?: number | undefined, onComplete?: Function | undefined): void;
+    fadeOut(color: Color | string, duration?: number, onComplete?: Function): void;
     /**
      * fadeIn effect <p>
      * fade to the specified color
-     * @name fadeIn
-     * @memberof Camera2d
      * @param {Color|string} color - a CSS color value
      * @param {number} [duration=1000] - expressed in milliseconds
      * @param {Function} [onComplete] - callback once effect is over
@@ -231,43 +200,35 @@ export default class Camera2d extends Renderable {
      * // flash the camera to white for 75ms
      * me.game.viewport.fadeIn("#FFFFFF", 75);
      */
-    fadeIn(color: Color | string, duration?: number | undefined, onComplete?: Function | undefined): void;
+    fadeIn(color: Color | string, duration?: number, onComplete?: Function): void;
     /**
      * set the camera position around the specified object
-     * @name focusOn
-     * @memberof Camera2d
      * @param {Renderable|Entity|Sprite|NineSliceSprite} target - the renderable to focus the camera on
      */
     focusOn(target: Renderable | Entity | Sprite | NineSliceSprite): void;
     /**
      * check if the specified renderable is in the camera
-     * @name isVisible
-     * @memberof Camera2d
      * @param {Renderable|Entity|Sprite|NineSliceSprite} obj - to be checked against
      * @param {boolean} [floating = obj.floating] - if visibility check should be done against screen coordinates
      * @returns {boolean} true if within the viewport
      */
-    isVisible(obj: Renderable | Entity | Sprite | NineSliceSprite, floating?: boolean | undefined): boolean;
+    isVisible(obj: Renderable | Entity | Sprite | NineSliceSprite, floating?: boolean): boolean;
     /**
      * convert the given "local" (screen) coordinates into world coordinates
-     * @name localToWorld
-     * @memberof Camera2d
      * @param {number} x - the x coordinate of the local point to be converted
      * @param {number} y - the y coordinate of the local point to be converted
-     * @param {number} [v] - an optional vector object where to set the converted value
+     * @param {Vector2d} [v] - an optional vector object where to set the converted value
      * @returns {Vector2d}
      */
-    localToWorld(x: number, y: number, v?: number | undefined): Vector2d;
+    localToWorld(x: number, y: number, v?: Vector2d): Vector2d;
     /**
      * convert the given world coordinates into "local" (screen) coordinates
-     * @name worldToLocal
-     * @memberof Camera2d
      * @param {number} x
      * @param {number} y
      * @param {number} [v] - an optional vector object where to set the converted value
      * @returns {Vector2d} a vector with the converted local coordinates
      */
-    worldToLocal(x: number, y: number, v?: number | undefined): Vector2d;
+    worldToLocal(x: number, y: number, v?: number): Vector2d;
     /**
      * render the camera effects
      * @ignore
@@ -280,12 +241,13 @@ export default class Camera2d extends Renderable {
     draw(renderer: any, container: any): void;
 }
 import Renderable from "./../renderable/renderable.js";
-import type Bounds from "./../physics/bounds.js";
-import Matrix3d from "./../math/matrix3.js";
-import Matrix2d from "./../math/matrix2.js";
-import Vector2d from "./../math/vector2.js";
-import Rect from "./../geometries/rectangle.js";
-import type Color from "./../math/color.js";
+import type { Bounds } from "./../physics/bounds.ts";
+import { Matrix3d } from "../math/matrix3d.ts";
+import { Matrix2d } from "../math/matrix2d.ts";
+import { Vector2d } from "../math/vector2d.ts";
+import { Rect } from "./../geometries/rectangle.ts";
+import type { Color } from "./../math/color.ts";
 import type Entity from "./../renderable/entity/entity.js";
 import type Sprite from "./../renderable/sprite.js";
 import type NineSliceSprite from "./../renderable/nineslicesprite.js";
+//# sourceMappingURL=camera2d.d.ts.map

package/build/camera/camera2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera2d.d.ts","sourceRoot":"","sources":["../../src/camera/camera2d.js"],"names":[],"mappings":"AA8BA;;GAEG;AACH;IAUE;;;;;;;;OAQG;IACH;;;;;MAKC;IAED;;;OAGG;IACH,QAFU,MAAM,CAEc;IAE9B;;;;OAIG;IACH,qBAAwB;IAExB;;;;;OAKG;IACH,SAHU,MAAM,CAGE;IAElB;;;;OAIG;IACH,MAHU,MAAM,CAGC;IAEjB;;;;OAIG;IACH,KAHU,MAAM,CAGD;IAEf;;;;OAIG;IACH,kBAFU,QAAQ,CAEoB;IAEtC;;;;OAIG;IACH,qBAFU,QAAQ,CAEuB;IAGzC,iBAA4B;IAG5B,wBAAkB;IAGlB,oBAAiC;IAEjC;;;OAGG;IACH;;;;;MAKC;IAED;;;OAGG;IACH;;;MAGC;IAED;;;OAGG;IACH;;;MAGC;IA2BF,cAAc;IAEd,gCASC;IAED,cAAc;IACd,8BAWC;IAED,cAAc;IACd,8BAWC;IAID;;;;OAIG;IACH,UAHW,MAAM,MACN,MAAM,QAoBhB;IAED;;;;;;;OAOG;IACH,eAHW,MAAM,KACN,MAAM,QAoBhB;IAhBC,2BAAoC;IAkBtC;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,GACJ,QAAQ,CAsBpB;IAED;;;;;;;OAOG;IACH,aALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAQhB;IAED;;;;;;;;;OASG;IACH,eAPW,UAAU,GAAC,QAAQ,SACnB,MAAM,YACN,MAAM,QA4BhB;IAED;;OAEG;IACH,iBAGC;IAED;;;;;;;;OAQG;IACH,QANW,MAAM,KACN,MAAM,QAOhB;IAED;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAahB;IAED,cAAc;IACd,qBA6CC;IAED,cAAc;IACd,yBAgDC;IAED;;;;;;;;;;;OAWG;IACH,iBAVW,MAAM,YAEN,MAAM,SACN,MAAM,iCAEN,OAAO,QAajB;IAED;;;;;;;;;;;;;OAaG;IACH,eAXW,KAAK,GAAC,MAAM,aACZ,MAAM,+BAkBhB;IAED;;;;;;;;;OASG;IACH,cAPW,KAAK,GAAC,MAAM,aACZ,MAAM,+BAgBhB;IAED;;;OAGG;IACH,gBAFW,UAAU,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,QAQlD;IAED;;;;;OAKG;IACH,eAJW,UAAU,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,aACxC,OAAO,GACL,OAAO,CAUnB;IAED;;;;;;OAMG;IACH,gBALW,MAAM,KACN,MAAM,MACN,QAAQ,GACN,QAAQ,CAUpB;IAED;;;;;;OAMG;IACH,gBALW,MAAM,KACN,MAAM,MACN,MAAM,GACJ,QAAQ,CAUpB;IAED;;;OAGG;IACH,4BAkCC;IAED;;;OAGG;IACH,0CA8BC;CACD;uBAzqBsB,+BAA+B;4BAY7B,wBAAwB;yBAhBxB,qBAAqB;yBADrB,qBAAqB;yBAEP,qBAAqB;qBANvC,8BAA8B;2BAsB3B,oBAAoB;wBACrB,kCAAkC;wBAClC,2BAA2B;iCAClB,oCAAoC"}

package/build/const.d.ts

@@ -0,0 +1,14 @@
+/**
+ * constant to select the HTML5 Canvas renderer
+ */
+export declare const CANVAS = 0;
+/**
+ * constant to select select the WebGL renderer
+ */
+export declare const WEBGL = 1;
+/**
+ * constant to auto-select the renderer (Attempt WebGL first, with fallback to Canvas)
+ */
+export declare const AUTO = 2;
+export type RendererType = typeof CANVAS | typeof WEBGL | typeof AUTO;
+//# sourceMappingURL=const.d.ts.map

package/build/const.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../src/const.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,MAAM,IAAI,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,KAAK,IAAI,CAAC;AAEvB;;GAEG;AACH,eAAO,MAAM,IAAI,IAAI,CAAC;AAEtB,MAAM,MAAM,YAAY,GAAG,OAAO,MAAM,GAAG,OAAO,KAAK,GAAG,OAAO,IAAI,CAAC"}

package/build/geometries/earcut.d.ts

@@ -0,0 +1,3 @@
+export declare function earcut(data: number[], holeIndices?: number[] | null, dim?: number | undefined): number[];
+export declare function signedArea(data: number[], start: number, end: number, dim: number): number;
+//# sourceMappingURL=earcut.d.ts.map

package/build/geometries/earcut.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"earcut.d.ts","sourceRoot":"","sources":["../../src/geometries/earcut.ts"],"names":[],"mappings":"AAAA,wBAAgB,MAAM,CACrB,IAAI,EAAE,MAAM,EAAE,EACd,WAAW,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAC7B,GAAG,GAAE,MAAM,GAAG,SAAa,GACzB,MAAM,EAAE,CAoCV;AA0tBD,wBAAgB,UAAU,CACzB,IAAI,EAAE,MAAM,EAAE,EACd,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,UAQX"}

package/build/geometries/ellipse.d.ts

@@ -0,0 +1,117 @@
+import { Vector2d } from "../math/vector2d.ts";
+import { Bounds } from "../physics/bounds.ts";
+/**
+ * an ellipse Object
+ */
+export declare class Ellipse {
+    /**
+     * the center coordinates of the ellipse
+     */
+    pos: Vector2d;
+    /**
+     * The bounding rectangle for this shape
+     */
+    _bounds: Bounds;
+    /**
+     * Maximum radius of the ellipse
+     */
+    radius: number;
+    /**
+     * Pre-scaled radius vector for ellipse
+     */
+    radiusV: Vector2d;
+    /**
+     * Radius squared, for pythagorean theorom
+     */
+    radiusSq: Vector2d;
+    /**
+     * x/y scaling ratio for ellipse
+     */
+    ratio: Vector2d;
+    /**
+     * the shape type (used internally)
+     */
+    type: string;
+    /**
+     * @param x - the center x coordinate of the ellipse
+     * @param y - the center y coordinate of the ellipse
+     * @param w - width (diameter) of the ellipse
+     * @param h - height (diameter) of the ellipse
+     */
+    constructor(x: number, y: number, w: number, h: number);
+    /**
+     * set new value to the Ellipse shape
+     * @param x - the center x coordinate of the ellipse
+     * @param y - the center y coordinate of the ellipse
+     * @param w - width (diameter) of the ellipse
+     * @param h - height (diameter) of the ellipse
+     * @returns this instance for objecf chaining
+     */
+    setShape(x: number, y: number, w: number, h: number): this;
+    /**
+     * Rotate this Ellipse (counter-clockwise) by the specified angle (in radians).
+     * @param angle - The angle to rotate (in radians)
+     * @param [v] - an optional point to rotate around
+     * @returns Reference to this object for method chaining
+     */
+    rotate(angle: number, v?: Vector2d): this;
+    /**
+     * Scale this Ellipse by the specified scalar.
+     * @param x - the scale factor along the x-axis
+     * @param [y=x] - the scale factor along the y-axis
+     * @returns Reference to this object for method chaining
+     */
+    scale(x: number, y?: number): this;
+    /**
+     * Scale this Ellipse by the specified vector.
+     * @param v - Scaling vector.
+     * @returns Reference to this object for method chaining
+     */
+    scaleV(v: Vector2d): this;
+    /**
+     * apply the given transformation matrix to this ellipse
+     * @returns Reference to this object for method chaining
+     */
+    transform(): this;
+    /**
+     * translate the circle/ellipse by the specified offset
+     * @param x -  x coordinate or a vector point to translate by
+     * @param [y] - y offset
+     * @returns this ellipse
+     * @example
+     * ellipse.translate(10, 10);
+     * // or
+     * ellipse.translate(myVector2d);
+     */
+    translate(x: number, y: number): Ellipse;
+    translate(vector: Vector2d): Ellipse;
+    /**
+     * check if this circle/ellipse contains the specified point
+     * @param x -  x coordinate or a vector point to check
+     * @param [y] -  y coordinate
+     * @param args
+     * @returns true if contains
+     * @example
+     * if (circle.contains(10, 10)) {
+     *   // do something
+     * }
+     * // or
+     * if (circle.contains(myVector2d)) {
+     *  // do something
+     * }
+     */
+    contains(x: number, y: number): boolean;
+    contains(vector: Vector2d): boolean;
+    /**
+     * returns the bounding box for this shape, the smallest Rectangle object completely containing this shape.
+     * @returns this shape bounding box Rectangle object
+     */
+    getBounds(): Bounds;
+    /**
+     * clone this Ellipse
+     * @returns new Ellipse
+     */
+    clone(): Ellipse;
+}
+export declare const ellipsePool: import("../system/pool.ts").Pool<Ellipse, [x: number, y: number, width: number, height: number]>;
+//# sourceMappingURL=ellipse.d.ts.map

package/build/geometries/ellipse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ellipse.d.ts","sourceRoot":"","sources":["../../src/geometries/ellipse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAgB,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,MAAM,EAAc,MAAM,sBAAsB,CAAC;AAG1D;;GAEG;AACH,qBAAa,OAAO;IACnB;;OAEG;IACH,GAAG,EAAE,QAAQ,CAAC;IAEd;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,OAAO,EAAE,QAAQ,CAAC;IAElB;;OAEG;IACH,QAAQ,EAAE,QAAQ,CAAC;IAEnB;;OAEG;IACH,KAAK,EAAE,QAAQ,CAAC;IAEhB;;OAEG;IACH,IAAI,SAAa;IAEjB;;;;;OAKG;gBACS,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAUtD;;;;;;;OAOG;IACH,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAqBnD;;;;;OAKG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,QAAQ;IASlC;;;;;OAKG;IACH,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,SAAI;IAStB;;;;OAIG;IACH,MAAM,CAAC,CAAC,EAAE,QAAQ;IAIlB;;;OAGG;IACH,SAAS;IAKT;;;;;;;;;OASG;IACH,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;IACxC,SAAS,CAAC,MAAM,EAAE,QAAQ,GAAG,OAAO;IAoBpC;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;IACvC,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,OAAO;IAmBnC;;;OAGG;IACH,SAAS;IAOT;;;OAGG;IACH,KAAK;CAQL;AAED,eAAO,MAAM,WAAW,kGAYtB,CAAC"}

package/build/geometries/line.d.ts

@@ -0,0 +1,39 @@
+import { Vector2d } from "../math/vector2d.ts";
+import { LineVertices, Polygon } from "./polygon.ts";
+/**
+ * a line segment Object
+ * @param x - origin point of the Line
+ * @param y - origin point of the Line
+ * @param points - array of vectors defining the Line
+ */
+export declare class Line extends Polygon {
+    /**
+     * Returns true if the Line contains the given point
+     * @param x -  x coordinate or a vector point to check
+     * @param [y] -  y coordinate
+     * @returns true if contains
+     * @example
+     * if (line.contains(10, 10)) {
+     *   // do something
+     * }
+     * // or
+     * if (line.contains(myVector2d)) {
+     *   // do something
+     * }
+     */
+    contains(x: number, y: number): boolean;
+    contains(vector: Vector2d): boolean;
+    /**
+     * Computes the calculated collision edges and normals.
+     * This **must** be called if the `points` array, `angle`, or `offset` is modified manually.
+     * @returns this instance for objecf chaining
+     */
+    recalc(): this;
+    /**
+     * clone this line segment
+     * @returns new Line
+     */
+    clone(): Line;
+}
+export declare const linePool: import("../system/pool.ts").Pool<Line, [x: number, y: number, points: LineVertices]>;
+//# sourceMappingURL=line.d.ts.map

package/build/geometries/line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../src/geometries/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAgB,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAErD;;;;;GAKG;AACH,qBAAa,IAAK,SAAQ,OAAO;IAChC;;;;;;;;;;;;;OAaG;IACM,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;IACvC,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,OAAO;IAyB5C;;;;OAIG;IACM,MAAM;IA6Bf;;;OAGG;IACM,KAAK;CAOd;AAED,eAAO,MAAM,QAAQ,sFAYnB,CAAC"}

package/build/geometries/observablePoint.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Represents a point in a 2D coordinate system that can be observed for changes.
+ */
+/**
+ * Represents an observable point in 2D space.
+ */
+export declare class ObservablePoint {
+    private _callback;
+    private _point;
+    private _revoke;
+    private callBackEnabled;
+    type: "ObservablePoint";
+    /**
+     * Creates a new ObservablePoint instance.
+     * @param x - The x-coordinate of the point. Default is 0.
+     * @param y - The y-coordinate of the point. Default is 0.
+     * @param callback - The callback function to be called when the point changes. Default is undefined.
+     */
+    constructor(x?: number, y?: number, callback?: () => void);
+    /**
+     * Sets the x and y coordinates of the point.
+     * @param x - The new x-coordinate value.
+     * @param y - The new y-coordinate value.
+     * @returns Reference to this object for method chaining.
+     */
+    set(x?: number, y?: number): this;
+    /**
+     * Sets the x and y coordinates of the point without triggering the callback.
+     * @param x - The new x-coordinate value.
+     * @param y - The new y-coordinate value.
+     * @returns Reference to this object for method chaining.
+     */
+    setMuted(x?: number, y?: number): this;
+    /**
+     * Gets the x-coordinate of the point.
+     */
+    get x(): number;
+    /**
+     * Sets the x-coordinate of the point.
+     * @param value - The new x-coordinate value.
+     */
+    set x(value: number);
+    /**
+     * Gets the y-coordinate of the point.
+     */
+    get y(): number;
+    /**
+     * Sets the y-coordinate of the point.
+     * @param value - The new y-coordinate value.
+     */
+    set y(value: number);
+    /**
+     * Sets the callback function to be called when the point changes.
+     * @param callback - The callback function.
+     */
+    setCallback(callback: () => void): void;
+    /**
+     * Checks if the point is equal to the given coordinates or another ObservablePoint.
+     * @param x - The x-coordinate or the ObservablePoint to compare.
+     * @param y - The y-coordinate. Required if the first parameter is a number.
+     * @returns True if the point is equal to the given coordinates or another ObservablePoint, false otherwise.
+     */
+    equals(x: number, y: number): boolean;
+    equals(point: ObservablePoint): boolean;
+    /**
+     * Creates a clone of the ObservablePoint.
+     * @returns A new ObservablePoint instance with the same coordinates and callback function.
+     */
+    clone(): ObservablePoint;
+    /**
+     * Revokes the proxy object, preventing further access to the ObservablePoint instance.
+     */
+    revoke(): void;
+}
+//# sourceMappingURL=observablePoint.d.ts.map

package/build/geometries/observablePoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observablePoint.d.ts","sourceRoot":"","sources":["../../src/geometries/observablePoint.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH;;GAEG;AACH,qBAAa,eAAe;IAC3B,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,OAAO,CAAa;IAE5B,OAAO,CAAC,eAAe,CAAiB;IAExC,IAAI,EAAE,iBAAiB,CAAC;IAExB;;;;;OAKG;gBACS,CAAC,GAAE,MAAU,EAAE,CAAC,GAAE,MAAU,EAAE,QAAQ,CAAC,EAAE,MAAM,IAAI;IAuB/D;;;;;OAKG;IACH,GAAG,CAAC,CAAC,SAAI,EAAE,CAAC,SAAI;IAShB;;;;;OAKG;IACH,QAAQ,CAAC,CAAC,SAAI,EAAE,CAAC,SAAI;IAQrB;;OAEG;IACH,IAAI,CAAC,IAQQ,MAAM,CANlB;IAED;;;OAGG;IACH,IAAI,CAAC,CAAC,KAAK,EAAE,MAAM,EAElB;IAED;;OAEG;IACH,IAAI,CAAC,IAQQ,MAAM,CANlB;IAED;;;OAGG;IACH,IAAI,CAAC,CAAC,KAAK,EAAE,MAAM,EAElB;IAED;;;OAGG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,IAAI;IAIhC;;;;;OAKG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;IACrC,MAAM,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO;IAKvC;;;OAGG;IACH,KAAK;IAIL;;OAEG;IACH,MAAM;CAGN"}

package/{dist/types → build}/geometries/path2d.d.ts

@@ -1,12 +1,12 @@
+export default Path2D;
 /**
  * additional import for TypeScript
- * @import Point from "./point.js";
+ * @import {Point} from "./point.ts";
  */
 /**
- * @classdesc
  * a simplified path2d implementation, supporting only one path
  */
-export default class Path2D {
+declare class Path2D {
     constructor(svgPath: any);
     /**
      * the points defining the current path
@@ -20,7 +20,7 @@ export default class Path2D {
      */
     arcResolution: number;
     vertices: any[];
-    startPoint: object;
+    startPoint: Point;
     isDirty: boolean;
     /**
      * Parses an SVG path string and adds the points to the current path.
@@ -64,7 +64,7 @@ export default class Path2D {
      * @param {number} endAngle - the angle at which the arc ends in radians, measured from the positive x-axis.
      * @param {boolean} [anticlockwise=false] - an optional boolean value. If true, draws the arc counter-clockwise between the start and end angles.
      */
-    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean | undefined): void;
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
     /**
      * adds a circular arc to the path with the given control points and radius, connected to the previous point by a straight line.
      * @param {number} x1 - the x-axis coordinate of the first control point.
@@ -86,7 +86,7 @@ export default class Path2D {
      * @param {number} endAngle - the angle at which the ellipse ends, measured clockwise from the positive x-axis and expressed in radians.
      * @param {boolean} [anticlockwise=false] - an optional boolean value which, if true, draws the ellipse counterclockwise (anticlockwise).
      */
-    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise?: boolean | undefined): void;
+    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
     /**
      * Adds a quadratic Bézier curve to the path.
      * @param {number} cpX - The x-coordinate of the control point.
@@ -123,4 +123,5 @@ export default class Path2D {
      */
     roundRect(x: number, y: number, width: number, height: number, radius: number): void;
 }
-import type Point from "./point.js";
+import type { Point } from "./point.ts";
+//# sourceMappingURL=path2d.d.ts.map

package/build/geometries/path2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path2d.d.ts","sourceRoot":"","sources":["../../src/geometries/path2d.js"],"names":[],"mappings":";AAKA;;;GAGG;AAEH;;GAEG;AACH;IACC,0BA0BC;IAzBA;;;OAGG;IACH,QAFU,KAAK,EAAE,CAED;IAEhB;;;;OAIG;IACH,eAHU,MAAM,CAGM;IAGtB,gBAAkB;IAGlB,kBAAiC;IAGjC,iBAAoB;IAOrB;;;OAGG;IACH,sBAFW,MAAM,QA0EhB;IAED;;OAEG;IACH,kBAQC;IAED;;;;OAIG;IACH,kBASC;IAED;;;OAGG;IACH,mBAFa,KAAK,EAAE,CAkCnB;IAED;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAKhB;IAED;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAmBhB;IAED;;;;;;;;;OASG;IACH,OAPW,MAAM,KACN,MAAM,UACN,MAAM,cACN,MAAM,YACN,MAAM,kBACN,OAAO,QA2DjB;IAED;;;;;;;OAOG;IACH,UANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,UACN,MAAM,QAyDhB;IAED;;;;;;;;;;;OAWG;IACH,WATW,MAAM,KACN,MAAM,WACN,MAAM,WACN,MAAM,YACN,MAAM,cACN,MAAM,YACN,MAAM,kBACN,OAAO,QA0EjB;IAED;;;;;;OAMG;IACH,sBALW,MAAM,OACN,MAAM,KACN,MAAM,KACN,MAAM,QAyBhB;IAED;;;;;;;;OAQG;IACH,oBAPW,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,KACN,MAAM,KACN,MAAM,QA8BhB;IAED;;;;;;OAMG;IACH,QALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAgBhB;IAED;;;;;;;OAOG;IACH,aANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,MAAM,QAoBhB;CACD;2BA3iBuB,YAAY"}

package/build/geometries/point.d.ts

@@ -0,0 +1,44 @@
+/**
+ * represents a point in a 2d space
+ */
+export declare class Point {
+    /**
+     * the position of the point on the horizontal axis
+     * @default 0
+     */
+    x: number;
+    /**
+     * the position of the point on the vertical axis
+     * @default 0
+     */
+    y: number;
+    /**
+     * the shape type (used internally)
+     * @default "Point"
+     */
+    type: "Point";
+    constructor(x?: number, y?: number);
+    /**
+     * set the Point x and y properties to the given values
+     * @param x horizontal coordinate
+     * @param y vertical coordinate
+     * @returns Reference to this object for method chaining
+     */
+    set(x?: number, y?: number): this;
+    /**
+     * return true if this point is equal to the given point
+     * @param x horizontal coordinate
+     * @param [y] vertical coordinate
+     * @param args
+     * @returns
+     */
+    equals(x: number, y: number): boolean;
+    equals(point: Point): boolean;
+    /**
+     * clone this Point
+     * @returns new Point
+     */
+    clone(): Point;
+}
+export declare const pointPool: import("../system/pool").Pool<Point, [x?: number | undefined, y?: number | undefined]>;
+//# sourceMappingURL=point.d.ts.map