melonjs 18.1.0 → 18.2.1

package/build/camera/camera2d.d.ts

@@ -1,104 +1,204 @@
+import { Rect } from "./../geometries/rectangle.ts";
+import type { Color } from "../math/color.ts";
+import { Matrix2d } from "../math/matrix2d.ts";
+import { Matrix3d } from "../math/matrix3d.ts";
+import { Vector2d } from "../math/vector2d.ts";
+import { Vector3d } from "../math/vector3d.ts";
+import { Bounds } from "./../physics/bounds.ts";
+import type Container from "./../renderable/container.js";
+import Renderable from "./../renderable/renderable.js";
+import type Tween from "../tweens/tween.ts";
+import type Renderer from "./../video/renderer.js";
+/**
+ * @import Entity from "./../renderable/entity/entity.js";
+ * @import Sprite from "./../renderable/sprite.js";
+ * @import NineSliceSprite from "./../renderable/nineslicesprite.js";
+ */
+interface AxisEnum {
+    readonly NONE: 0;
+    readonly HORIZONTAL: 1;
+    readonly VERTICAL: 2;
+    readonly BOTH: 3;
+}
+interface ShakeState {
+    intensity: number;
+    duration: number;
+    axis: number;
+    onComplete: (() => void) | null | undefined;
+}
+interface FadeState {
+    color: Color | null;
+    tween: Tween | null;
+}
 /**
  * a 2D orthographic camera
  * @category Camera
+ * @example
+ * // create a minimap camera in the top-right corner showing the full level
+ * const minimap = new Camera2d(0, 0, 180, 100);
+ * minimap.name = "minimap";
+ * minimap.screenX = game.viewport.width - 190;
+ * minimap.screenY = 10;
+ * minimap.autoResize = false;
+ * minimap.setBounds(0, 0, levelWidth, levelHeight);
+ * minimap.zoom = Math.min(180 / levelWidth, 100 / levelHeight);
+ *
+ * // add the camera to the current stage
+ * this.cameras.set("minimap", minimap);
  */
 export default class Camera2d extends Renderable {
     /**
      * Axis definition
-     * @enum {number}
-     * @property {number} NONE no axis
-     * @property {number} HORIZONTAL horizontal axis only
-     * @property {number} VERTICAL vertical axis only
-     * @property {number} BOTH both axis
-     * @readonly
-     */
-    readonly AXIS: {
-        NONE: number;
-        HORIZONTAL: number;
-        VERTICAL: number;
-        BOTH: number;
-    };
+     * NONE no axis
+     * HORIZONTAL horizontal axis only
+     * VERTICAL vertical axis only
+     * BOTH both axis
+     */
+    AXIS: AxisEnum;
     /**
      * Camera bounds
-     * @type {Bounds}
      */
     bounds: Bounds;
     /**
      * enable or disable damping
-     * @private
      * @default true
      */
-    private smoothFollow;
+    smoothFollow: boolean;
     /**
      * Camera damping for smooth transition [0 .. 1].
      * 1 being the maximum value and will snap the camera to the target position
-     * @type {number}
      * @default 1.0
      */
     damping: number;
     /**
      * the closest point relative to the camera
-     * @type {number}
      * @default -1000
      */
     near: number;
     /**
      * the furthest point relative to the camera.
-     * @type {number}
      * @default 1000
      */
     far: number;
+    /**
+     * the x position on the screen where this camera viewport is rendered.
+     * @default 0
+     */
+    screenX: number;
+    /**
+     * the y position on the screen where this camera viewport is rendered.
+     * @default 0
+     */
+    screenY: number;
+    /**
+     * @ignore
+     */
+    _zoom: number;
+    /**
+     * the world-space projection matrix for non-default cameras (offset/zoomed).
+     * Maps world coordinates to the camera's screen viewport.
+     */
+    worldProjection: Matrix3d;
+    /**
+     * the screen-space projection matrix for non-default cameras.
+     * Maps coordinates so that (0,0) aligns with the camera's screenX/screenY position.
+     * Used for rendering floating elements (e.g. background layers) in the correct screen area.
+     */
+    screenProjection: Matrix3d;
+    /**
+     * Whether this camera should automatically resize when the canvas resizes.
+     * Set to false for non-default cameras with fixed dimensions
+     * (e.g. minimap, split-screen viewports).
+     * @default true
+     */
+    autoResize: boolean;
+    /**
+     * cached world view bounds
+     * @ignore
+     */
+    _worldView: Bounds;
     /**
      * the default camera projection matrix
      * (2d cameras use an orthographic projection by default).
-     * @type {Matrix3d}
      */
     projectionMatrix: Matrix3d;
     /**
      * the invert camera transform used to unproject points
      * @ignore
-     * @type {Matrix2d}
      */
     invCurrentTransform: Matrix2d;
+    /** offset for shake effect */
     offset: Vector2d;
-    target: Vector2d | null;
+    /** target to follow */
+    target: Vector2d | Vector3d | null;
+    /** default value follow */
     follow_axis: number;
     /**
      * shake variables
      * @ignore
      */
-    _shake: {
-        intensity: number;
-        duration: number;
-        axis: number;
-        onComplete: null;
-    };
+    _shake: ShakeState;
     /**
      * flash variables
      * @ignore
      */
-    _fadeOut: {
-        color: null;
-        tween: null;
-    };
+    _fadeOut: FadeState;
     /**
      * fade variables
      * @ignore
      */
-    _fadeIn: {
-        color: null;
-        tween: null;
-    };
+    _fadeIn: FadeState;
+    /** the camera deadzone */
+    deadzone: Rect;
+    /**
+     * @param minX - start x offset
+     * @param minY - start y offset
+     * @param maxX - end x offset
+     * @param maxY - end y offset
+     */
+    constructor(minX: number, minY: number, maxX: number, maxY: number);
     /** @ignore */
     _updateProjectionMatrix(): void;
     /** @ignore */
-    _followH(target: any): number;
+    _followH(target: Vector2d | Vector3d): number;
     /** @ignore */
-    _followV(target: any): number;
+    _followV(target: Vector2d | Vector3d): number;
+    /**
+     * the zoom level of this camera.
+     * Values less than 1 zoom out (show more of the world),
+     * values greater than 1 zoom in (show less of the world).
+     * @default 1
+     * @example
+     * // zoom out to show the full level in a 180x100 minimap
+     * camera.zoom = Math.min(180 / levelWidth, 100 / levelHeight);
+     */
+    get zoom(): number;
+    set zoom(value: number);
+    /**
+     * Whether this camera is using default settings (no screen offset, no zoom).
+     * Non-default cameras use custom projections for viewport positioning and scaling.
+     * @returns true if this camera has no screen offset and zoom is 1
+     */
+    get isDefault(): boolean;
+    /**
+     * The world-space bounds currently visible through this camera,
+     * taking into account position and zoom level.
+     * @returns the visible world area
+     */
+    get worldView(): Bounds;
+    /**
+     * Set the camera screen position and size in a single call.
+     * @param x - x position on screen
+     * @param y - y position on screen
+     * @param [w] - width (defaults to current width)
+     * @param [h] - height (defaults to current height)
+     * @returns this camera for chaining
+     */
+    setViewport(x: number, y: number, w?: number, h?: number): this;
     /**
      * reset the camera position to specified coordinates
-     * @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
+     * @param [x=0] - initial position of the camera on the x axis
+     * @param [y=0] - initial position of the camera on the y axis
      */
     reset(x?: number, y?: number): void;
     /**
@@ -106,38 +206,37 @@ export default class Camera2d extends Renderable {
      * the "deadzone" defines an area within the current camera in which
      * the followed renderable can move without scrolling the camera.
      * @see {@link follow}
-     * @param {number} w - deadzone width
-     * @param {number} h - deadzone height
+     * @param w - deadzone width
+     * @param h - deadzone height
      */
     setDeadzone(w: number, h: number): void;
-    deadzone: Rect | undefined;
     /**
      * resize the camera
-     * @param {number} w - new width of the camera
-     * @param {number} h - new height of the camera
-     * @returns {Camera2d} this camera
+     * @param w - new width of the camera
+     * @param h - new height of the camera
+     * @returns this camera
      */
-    resize(w: number, h: number): Camera2d;
+    resize(w: number, h: number): this;
     /**
      * 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.
-     * @param {number} x - world left limit
-     * @param {number} y - world top limit
-     * @param {number} w - world width limit
-     * @param {number} h - world height limit
+     * @param x - world left limit
+     * @param y - world top limit
+     * @param w - world width limit
+     * @param h - world height limit
      */
     setBounds(x: number, y: number, w: number, h: number): void;
     /**
      * set the camera to follow the specified renderable. <br>
      * (this will put the camera center around the given target)
-     * @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
+     * @param target - renderable or position vector to follow
+     * @param [axis=me.game.viewport.AXIS.BOTH] - Which axis to follow (see {@link Camera2d.AXIS})
+     * @param [damping=1] - default damping value
      * @example
      * // 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, damping?: number): void;
+    follow(target: Renderable | Vector2d | Vector3d, axis?: number, damping?: number): void;
     /**
      * unfollow the current target
      */
@@ -145,8 +244,8 @@ export default class Camera2d extends Renderable {
     /**
      * move the camera upper-left position by the specified offset.
      * @see {@link focusOn}
-     * @param {number} x - horizontal offset
-     * @param {number} y - vertical offset
+     * @param x - horizontal offset
+     * @param y - vertical offset
      * @example
      * // Move the camera up by four pixels
      * me.game.viewport.move(0, -4);
@@ -155,33 +254,33 @@ export default class Camera2d extends Renderable {
     /**
      * move the camera upper-left position to the specified coordinates
      * @see {@link focusOn}
-     * @param {number} x
-     * @param {number} y
+     * @param x - horizontal position
+     * @param y - vertical position
      */
     moveTo(x: number, y: number): void;
     /** @ignore */
-    updateTarget(): void;
+    updateTarget(_dt?: number): void;
     /** @ignore */
-    update(dt: any): boolean;
+    update(dt?: number): boolean;
     /**
      * shake the camera
-     * @param {number} intensity - maximum offset that the screen can be moved
+     * @param intensity - maximum offset that the screen can be moved
      * while shaking
-     * @param {number} duration - expressed in milliseconds
-     * @param {number} [axis=me.game.viewport.AXIS.BOTH] - specify on which axis to apply the shake effect (see {@link Camera2d.AXIS})
-     * @param {Function} [onComplete] - callback once shaking effect is over
-     * @param {boolean} [force] - if true this will override the current effect
+     * @param duration - expressed in milliseconds
+     * @param [axis=me.game.viewport.AXIS.BOTH] - specify on which axis to apply the shake effect (see {@link Camera2d.AXIS})
+     * @param [onComplete] - callback once shaking effect is over
+     * @param [force] - if true this will override the current effect
      * @example
      * // shake it baby !
      * me.game.viewport.shake(10, 500, me.game.viewport.AXIS.BOTH);
      */
-    shake(intensity: number, duration: number, axis?: number, onComplete?: Function, force?: boolean): void;
+    shake(intensity: number, duration: number, axis?: number, onComplete?: () => void, force?: boolean): void;
     /**
      * fadeOut(flash) effect<p>
      * screen is filled with the specified color and slowly goes back to normal
-     * @param {Color|string} color - a CSS color value
-     * @param {number} [duration=1000] - expressed in milliseconds
-     * @param {Function} [onComplete] - callback once effect is over
+     * @param color - a CSS color value
+     * @param [duration=1000] - expressed in milliseconds
+     * @param [onComplete] - callback once effect is over
      * @example
      * // fade the camera to white upon dying, reload the level, and then fade out back
      * me.game.viewport.fadeIn("#fff", 150, function() {
@@ -190,65 +289,56 @@ export default class Camera2d extends Renderable {
      *     me.game.viewport.fadeOut("#fff", 150);
      * });
      */
-    fadeOut(color: Color | string, duration?: number, onComplete?: Function): void;
+    fadeOut(color: Color | string, duration?: number, onComplete?: () => void): void;
     /**
      * fadeIn effect <p>
      * fade to the specified color
-     * @param {Color|string} color - a CSS color value
-     * @param {number} [duration=1000] - expressed in milliseconds
-     * @param {Function} [onComplete] - callback once effect is over
+     * @param color - a CSS color value
+     * @param [duration=1000] - expressed in milliseconds
+     * @param [onComplete] - callback once effect is over
      * @example
      * // flash the camera to white for 75ms
      * me.game.viewport.fadeIn("#FFFFFF", 75);
      */
-    fadeIn(color: Color | string, duration?: number, onComplete?: Function): void;
+    fadeIn(color: Color | string, duration?: number, onComplete?: () => void): void;
     /**
      * set the camera position around the specified object
-     * @param {Renderable|Entity|Sprite|NineSliceSprite} target - the renderable to focus the camera on
+     * @param target - the renderable to focus the camera on
      */
-    focusOn(target: Renderable | Entity | Sprite | NineSliceSprite): void;
+    focusOn(target: Renderable): void;
     /**
      * check if the specified renderable is in the camera
-     * @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
+     * @param obj - to be checked against
+     * @param [floating = obj.floating] - if visibility check should be done against screen coordinates
+     * @returns true if within the viewport
      */
-    isVisible(obj: Renderable | Entity | Sprite | NineSliceSprite, floating?: boolean): boolean;
+    isVisible(obj: Renderable, floating?: boolean): boolean;
     /**
      * convert the given "local" (screen) coordinates into world coordinates
-     * @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 {Vector2d} [v] - an optional vector object where to set the converted value
-     * @returns {Vector2d}
+     * @param x - the x coordinate of the local point to be converted
+     * @param y - the y coordinate of the local point to be converted
+     * @param [v] - an optional vector object where to set the converted value
+     * @returns the converted world coordinates as a Vector2d
      */
     localToWorld(x: number, y: number, v?: Vector2d): Vector2d;
     /**
      * convert the given world coordinates into "local" (screen) coordinates
-     * @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
+     * @param x - the x world coordinate to be converted
+     * @param y - the y world coordinate to be converted
+     * @param [v] - an optional vector object where to set the converted value
+     * @returns a vector with the converted local coordinates
      */
-    worldToLocal(x: number, y: number, v?: number): Vector2d;
+    worldToLocal(x: number, y: number, v?: Vector2d): Vector2d;
     /**
      * render the camera effects
      * @ignore
      */
-    drawFX(renderer: any): void;
+    drawFX(renderer: Renderer): void;
     /**
      * draw all objects visible in this viewport
      * @ignore
      */
-    draw(renderer: any, container: any): void;
+    draw(renderer: Renderer, container: Container): void;
 }
-import Renderable from "./../renderable/renderable.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";
+export {};
 //# sourceMappingURL=camera2d.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"camera2d.d.ts","sourceRoot":"","sources":["../../src/camera/camera2d.js"],"names":[],"mappings":"AA8BA;;;GAGG;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,CASpB;IAED;;;;;;OAMG;IACH,gBALW,MAAM,KACN,MAAM,MACN,MAAM,GACJ,QAAQ,CASpB;IAED;;;OAGG;IACH,4BAkCC;IAED;;;OAGG;IACH,0CA8BC;CACD;uBAxqBsB,+BAA+B;4BAY7B,wBAAwB;yBAhBxB,qBAAqB;yBADrB,qBAAqB;yBAEP,qBAAqB;qBANvC,8BAA8B;2BAsB3B,oBAAoB;wBACrB,kCAAkC;wBAClC,2BAA2B;iCAClB,oCAAoC"}
+{"version":3,"file":"camera2d.d.ts","sourceRoot":"","sources":["../../src/camera/camera2d.ts"],"names":[],"mappings":"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"}

package/build/geometries/roundrect.d.ts

@@ -1,14 +1,22 @@
 import { Vector2d } from "../math/vector2d.ts";
-import { Rect } from "./rectangle.ts";
+import { Polygon } from "./polygon.ts";
 /**
  * a rectangle object with rounded corners
  * @category Geometry
  */
-export declare class RoundRect extends Rect {
+export declare class RoundRect extends Polygon {
     /**
      * Corner radius.
      */
     _radius: number;
+    /**
+     * stored width
+     */
+    _width: number;
+    /**
+     * stored height
+     */
+    _height: number;
     /**
      * the shape type (used internally)
      */
@@ -21,37 +29,94 @@ export declare class RoundRect extends Rect {
      * @param [radius=20] - the radius of the rounded corner
      */
     constructor(x: number, y: number, width: number, height: number, radius?: number);
+    /**
+     * width of the RoundRect
+     */
+    get width(): number;
+    set width(value: number);
+    /**
+     * height of the RoundRect
+     */
+    get height(): number;
+    set height(value: number);
+    /**
+     * left coordinate of the RoundRect
+     */
+    get left(): number;
+    /**
+     * right coordinate of the RoundRect
+     */
+    get right(): number;
+    /**
+     * top coordinate of the RoundRect
+     */
+    get top(): number;
+    /**
+     * bottom coordinate of the RoundRect
+     */
+    get bottom(): number;
+    /**
+     * absolute center of this RoundRect on the horizontal axis
+     */
+    get centerX(): number;
+    /**
+     * absolute center of this RoundRect on the vertical axis
+     */
+    get centerY(): number;
     /**
      * the radius of the rounded corner
      * @default 20
      */
     get radius(): number;
     set radius(value: number);
+    /**
+     * Rebuild polygon vertices to approximate the rounded corners.
+     * Reuses existing Vector2d instances when the vertex count matches.
+     * @ignore
+     */
+    _updateVertices(): void;
+    /**
+     * Set new dimensions for the rounded rectangle.
+     * @param width - The new width.
+     * @param height - The new height.
+     */
+    setSize(width: number, height: number): this;
+    /**
+     * resize the rounded rectangle
+     * @param w - new width
+     * @param h - new height
+     * @returns this rounded rectangle
+     */
+    resize(w: number, h: number): this;
     /**
      * copy the position, size and radius of the given rounded rectangle into this one
      * @param rrect - source rounded rectangle
-     * @returns new rectangle
+     * @returns this rounded rectangle
      */
     copy(rrect: RoundRect): this;
     /**
-     * Returns true if the rounded rectangle contains the given point or rectangle
-     * @param x -  x coordinate or a vector point, or a Rect to test
+     * Returns true if the rounded rectangle contains the given point
+     * @param x - x coordinate or a vector point
      * @param [y] - y coordinate
-     * @returns True if the rounded rectangle contain the given point or rectangle, otherwise false
-     * @example
-     * if (rect.contains(10, 10)) {
-     *   // do something
-     * }
-     * // or
-     * if (rect.contains(myVector2d)) {
-     *   // do something
-     * }
-     * if (rect.contains(myRect)) {
-     *   // do something
-     * }
+     * @returns True if the rounded rectangle contains the given point
      */
     contains(x: number, y: number): boolean;
     contains(vector: Vector2d): boolean;
+    /**
+     * Returns true if the rounded rectangle contains the given rectangle
+     * @param rectangle - rectangle to test
+     * @param rectangle.left - left coordinate
+     * @param rectangle.right - right coordinate
+     * @param rectangle.top - top coordinate
+     * @param rectangle.bottom - bottom coordinate
+     * @returns true if contained
+     */
+    containsRectangle(rectangle: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    }): boolean;
     /**
      * check if this RoundRect is identical to the specified one
      * @param rrect - Other rounded rectangle.

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

@@ -1 +1 @@
-{"version":3,"file":"roundrect.d.ts","sourceRoot":"","sources":["../../src/geometries/roundrect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE/C,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAMtC;;;GAGG;AACH,qBAAa,SAAU,SAAQ,IAAI;IAClC;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACM,IAAI,SAAe;IAE5B;;;;;;OAMG;gBAEF,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,MAAM,SAAiB;IAOxB;;;OAGG;IACH,IAAI,MAAM,WAET;IACD,IAAI,MAAM,CAAC,KAAK,QAAA,EASf;IAED;;;;OAIG;IACM,IAAI,CAAC,KAAK,EAAE,SAAS;IAO9B;;;;;;;;;;;;;;;;OAgBG;IACM,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;IACvC,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,OAAO;IAyD5C;;;;OAIG;IACM,MAAM,CAAC,KAAK,EAAE,SAAS;IAIhC;;;OAGG;IACM,KAAK;CASd;AAED,eAAO,MAAM,oBAAoB,iIAmB/B,CAAC"}
+{"version":3,"file":"roundrect.d.ts","sourceRoot":"","sources":["../../src/geometries/roundrect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE/C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAkGvC;;;GAGG;AACH,qBAAa,SAAU,SAAQ,OAAO;IACrC;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACM,IAAI,SAAe;IAE5B;;;;;;OAMG;gBAEF,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,MAAM,SAAiB;IAexB;;OAEG;IACH,IAAI,KAAK,WAER;IACD,IAAI,KAAK,CAAC,KAAK,QAAA,EAId;IAED;;OAEG;IACH,IAAI,MAAM,WAET;IACD,IAAI,MAAM,CAAC,KAAK,QAAA,EAIf;IAED;;OAEG;IACH,IAAI,IAAI,WAEP;IAED;;OAEG;IACH,IAAI,KAAK,WAER;IAED;;OAEG;IACH,IAAI,GAAG,WAEN;IAED;;OAEG;IACH,IAAI,MAAM,WAET;IAED;;OAEG;IACH,IAAI,OAAO,WAEV;IAED;;OAEG;IACH,IAAI,OAAO,WAEV;IAED;;;OAGG;IACH,IAAI,MAAM,WAET;IACD,IAAI,MAAM,CAAC,KAAK,QAAA,EAWf;IAED;;;;OAIG;IACH,eAAe;IAmBf;;;;OAIG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAQrC;;;;;OAKG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAI3B;;;;OAIG;IACH,IAAI,CAAC,KAAK,EAAE,SAAS;IAOrB;;;;;OAKG;IACM,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;IACvC,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,OAAO;IAyD5C;;;;;;;;OAQG;IACH,iBAAiB,CAAC,SAAS,EAAE;QAC5B,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;QACZ,MAAM,EAAE,MAAM,CAAC;KACf;IASD;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,SAAS;IAUvB;;;OAGG;IACM,KAAK;CASd;AAED,eAAO,MAAM,oBAAoB,iIAmB/B,CAAC"}