like2d 2.9.0 → 2.10.0

package/dist/input/mouse.d.ts

@@ -0,0 +1,108 @@
+import { type Vector2 } from '../math/vector2';
+import { type MouseButton, type LikeMouseEvent } from '../events';
+import { EngineProps } from '../engine';
+type MouseMode = {
+    lock: false;
+    visible: boolean;
+    scrollBlock: boolean;
+} | {
+    lock: true;
+    speed: number;
+};
+export type MouseSetMode = Partial<MouseMode> & {
+    lock: boolean;
+};
+/**
+ * Mouse input handling. Bound to canvas. Emits relative movement when pointer locked.
+ */
+export declare class Mouse {
+    private dispatch;
+    private pos;
+    private lastPos;
+    private buttons;
+    /** The canvas reference is the DOM / display canvas, this keeps
+     * track of the internal (apparent) canvas size.
+     */
+    private canvasSize;
+    private canvas;
+    private lockedMode;
+    private unlockedMode;
+    private enableLock;
+    constructor(props: EngineProps<LikeMouseEvent>);
+    private handleMouseMove;
+    private handleMouseDown;
+    private handleMouseUp;
+    private handleWheel;
+    /** Mouse position, transformed to canvas pixels. */
+    getPosition(): Vector2;
+    /** Check if button is held. Button 1 = left, 2 = middle, 3 = right. */
+    isDown(button: MouseButton): boolean;
+    /** All currently held buttons. */
+    getPressedButtons(): Set<MouseButton>;
+    /**
+     * Set the current cursor mode.
+     *
+     * ### Normal mode
+     * Consider setting `scrollBlock` to false (default is true) if you want
+     * your element to blend into the webpage for freer scrolling.
+     *
+     * ```ts
+     * {
+     *   lock: false,
+     *   visible: true, // disable to hide cursor.
+     *   scrollBlock: true, // disable scroll while hovering canvas. Default: true
+     * }
+     * ```
+     *
+     * ### Captured mode
+     * In locked mode, the cursor cannot escape the canvas.
+     * It also becomes invisible.
+     * However, it can move infinitely, sensitivity can be controlled,
+     * and the emulated cursor (in `pos` of {@link mousemoved}) can be freely repositioned.
+     *
+     * ```ts
+     * {
+     *   lock: true,
+     *   speed: 1.0, // mouse sensitivity
+     * }
+     * ```
+     * Avoid binding the `ESC` key in captured mode. This will exit the capture and
+     * reset mode to default.
+     *
+     * ### Note on `pos` vs `delta`
+     * Event {@link mousemoved} passes both `pos` and `delta` args.
+     *
+     * Though the emulated cursor in locked mode
+     * (locked mode doesn't natively track absolute position)
+     * may be stuck on canvas edges, the `delta` field always
+     * represents mouse movement, even against edges.
+     */
+    setMode(mode: MouseSetMode): void;
+    getMode(): MouseMode;
+    /**
+     * Only applicable in capture mode -- sets the position
+     * of the emulated mouse.
+     */
+    setCapturedPos(pos: Vector2): void;
+    /**
+     * Enable/disable pointer lock (capture).
+     *
+     * For more fine-grained control, use {@link setMode} which
+     * also documents behaviors more thoroughly.
+     */
+    lockPointer(lock: boolean): void;
+    /**
+     * True when pointer is locked to canvas.
+     */
+    isPointerLocked(): boolean;
+    /**
+     * @returns whether the pointer is visible.
+     */
+    isCursorVisible(): boolean;
+    /** I beleve you wanted to use `like.mouse.setMode({lock: true})`
+     * or `like.mouse.lockPointer().
+     */
+    setRelativeMode?: never;
+}
+export {};
+//# sourceMappingURL=mouse.d.ts.map

package/dist/input/mouse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mouse.d.ts","sourceRoot":"","sources":["../../src/input/mouse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,OAAO,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,KAAK,WAAW,EAAmB,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AACnF,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAMxC,KAAK,SAAS,GACV;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,GACvD;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAElC,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,SAAS,CAAC,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAElE;;GAEG;AACH,qBAAa,KAAK;IAChB,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,GAAG,CAAmB;IAC9B,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,OAAO,CAA0B;IACzC;;OAEG;IACH,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,MAAM,CAAoB;IAIlC,OAAO,CAAC,UAAU,CAAsD;IACxE,OAAO,CAAC,YAAY,CAAgF;IACpG,OAAO,CAAC,UAAU,CAAS;gBAEf,KAAK,EAAE,WAAW,CAAC,cAAc,CAAC;IAwC9C,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,WAAW;IAMnB,oDAAoD;IACpD,WAAW,IAAI,OAAO;IAItB,uEAAuE;IACvE,MAAM,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO;IAIpC,kCAAkC;IAClC,iBAAiB,IAAI,GAAG,CAAC,WAAW,CAAC;IAIrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,OAAO,CAAC,IAAI,EAAE,YAAY;IAgB1B,OAAO,IAAI,SAAS;IAIpB;;;OAGG;IACH,cAAc,CAAC,GAAG,EAAE,OAAO;IAQ3B;;;;;OAKG;IACH,WAAW,CAAC,IAAI,EAAE,OAAO;IAUzB;;OAEG;IACH,eAAe,IAAI,OAAO;IAI1B;;OAEG;IACH,eAAe,IAAI,OAAO;IAI1B;;OAEG;IACH,eAAe,CAAC,EAAE,KAAK,CAAC;CACzB"}

package/dist/input/mouse.js

@@ -0,0 +1,241 @@
+import { Vec2 } from '../math/vector2';
+const mouseButtons = ["left", "middle", "right"];
+const numToButton = (i) => mouseButtons[i];
+/**
+ * Mouse input handling. Bound to canvas. Emits relative movement when pointer locked.
+ */
+export class Mouse {
+    constructor(props) {
+        Object.defineProperty(this, "dispatch", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pos", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [0, 0]
+        });
+        Object.defineProperty(this, "lastPos", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [0, 0]
+        });
+        Object.defineProperty(this, "buttons", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        /** The canvas reference is the DOM / display canvas, this keeps
+         * track of the internal (apparent) canvas size.
+         */
+        Object.defineProperty(this, "canvasSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [800, 600]
+        });
+        Object.defineProperty(this, "canvas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // We keep track of a locked mode and an unlocked mode, so that when capture changes
+        // we can use the settings from last time.
+        Object.defineProperty(this, "lockedMode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: { lock: true, speed: 1 }
+        });
+        Object.defineProperty(this, "unlockedMode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: { lock: false, visible: true, scrollBlock: true }
+        });
+        Object.defineProperty(this, "enableLock", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /** I beleve you wanted to use `like.mouse.setMode({lock: true})`
+         * or `like.mouse.lockPointer().
+         */
+        Object.defineProperty(this, "setRelativeMode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.canvas = props.canvas;
+        this.dispatch = props.dispatch;
+        const { abort } = props;
+        this.canvas.addEventListener("like:mousemoved", this.handleMouseMove.bind(this), { signal: abort });
+        this.canvas.addEventListener("mousedown", this.handleMouseDown.bind(this), {
+            signal: abort,
+        });
+        window.addEventListener("mouseup", this.handleMouseUp.bind(this), {
+            signal: abort,
+        });
+        this.canvas.addEventListener("wheel", this.handleWheel.bind(this), {
+            passive: false,
+            signal: abort,
+        });
+        this.canvas.addEventListener("mouseleave", () => this.buttons.clear(), {
+            signal: abort,
+        });
+        this.canvas.addEventListener("pointerlockchanged", () => {
+            if (!this.isPointerLocked())
+                this.enableLock = false;
+        }, { signal: abort });
+        this.canvas.addEventListener("like:resizeCanvas", (e) => {
+            this.canvasSize = e.detail.size;
+        }, { signal: abort });
+    }
+    handleMouseMove(e) {
+        if (this.isPointerLocked() && this.enableLock) {
+            /** In pointer-lock mode, simulate a real cursor bounded by the canvas. */
+            this.setCapturedPos(Vec2.add(this.pos, Vec2.mul(e.detail.delta, this.lockedMode.speed)));
+            this.dispatch('mousemoved', [this.pos, e.detail.delta]);
+        }
+        else {
+            /** In non-pointer locked mode, calculate deltas ourselves. */
+            this.pos = e.detail.pos;
+            this.dispatch('mousemoved', [this.pos, Vec2.sub(this.pos, this.lastPos)]);
+        }
+        this.lastPos = this.pos;
+    }
+    handleMouseDown(e) {
+        // hack: ignore right clicks because they cause a refocus
+        if (!this.isPointerLocked() && e.button == 2)
+            return;
+        this.buttons.add(numToButton(e.button));
+        this.dispatch('mousepressed', [[e.offsetX, e.offsetY], numToButton(e.button)]);
+        this.canvas?.focus();
+    }
+    handleMouseUp(e) {
+        this.buttons.delete(numToButton(e.button));
+        this.dispatch('mousereleased', [[e.offsetX, e.offsetY], numToButton(e.button)]);
+    }
+    handleWheel(e) {
+        if (this.unlockedMode.scrollBlock) {
+            e.preventDefault();
+        }
+    }
+    /** Mouse position, transformed to canvas pixels. */
+    getPosition() {
+        return this.pos;
+    }
+    /** Check if button is held. Button 1 = left, 2 = middle, 3 = right. */
+    isDown(button) {
+        return this.buttons.has(button);
+    }
+    /** All currently held buttons. */
+    getPressedButtons() {
+        return new Set(this.buttons);
+    }
+    /**
+     * Set the current cursor mode.
+     *
+     * ### Normal mode
+     * Consider setting `scrollBlock` to false (default is true) if you want
+     * your element to blend into the webpage for freer scrolling.
+     *
+     * ```ts
+     * {
+     *   lock: false,
+     *   visible: true, // disable to hide cursor.
+     *   scrollBlock: true, // disable scroll while hovering canvas. Default: true
+     * }
+     * ```
+     *
+     * ### Captured mode
+     * In locked mode, the cursor cannot escape the canvas.
+     * It also becomes invisible.
+     * However, it can move infinitely, sensitivity can be controlled,
+     * and the emulated cursor (in `pos` of {@link mousemoved}) can be freely repositioned.
+     *
+     * ```ts
+     * {
+     *   lock: true,
+     *   speed: 1.0, // mouse sensitivity
+     * }
+     * ```
+     * Avoid binding the `ESC` key in captured mode. This will exit the capture and
+     * reset mode to default.
+     *
+     * ### Note on `pos` vs `delta`
+     * Event {@link mousemoved} passes both `pos` and `delta` args.
+     *
+     * Though the emulated cursor in locked mode
+     * (locked mode doesn't natively track absolute position)
+     * may be stuck on canvas edges, the `delta` field always
+     * represents mouse movement, even against edges.
+     */
+    setMode(mode) {
+        this.lockPointer(mode.lock);
+        if (mode.lock) {
+            this.lockedMode = {
+                ...this.lockedMode,
+                ...mode,
+            };
+        }
+        else {
+            this.unlockedMode = {
+                ...this.unlockedMode,
+                ...mode
+            };
+            this.canvas.style.cursor = this.unlockedMode.visible ? 'auto' : 'none';
+        }
+    }
+    getMode() {
+        return this.enableLock ? this.lockedMode : this.unlockedMode;
+    }
+    /**
+     * Only applicable in capture mode -- sets the position
+     * of the emulated mouse.
+     */
+    setCapturedPos(pos) {
+        if (this.isPointerLocked()) {
+            this.pos = Vec2.clamp(pos, [0, 0], this.canvasSize);
+        }
+        else {
+            console.log("[Mouse] Attempt to set cursor position while not captured.");
+        }
+    }
+    /**
+     * Enable/disable pointer lock (capture).
+     *
+     * For more fine-grained control, use {@link setMode} which
+     * also documents behaviors more thoroughly.
+     */
+    lockPointer(lock) {
+        this.enableLock = lock;
+        const wasLocked = this.isPointerLocked();
+        if (lock && !wasLocked) {
+            this.canvas.requestPointerLock();
+        }
+        else if (!lock && wasLocked) {
+            document.exitPointerLock();
+        }
+    }
+    /**
+     * True when pointer is locked to canvas.
+     */
+    isPointerLocked() {
+        return document.pointerLockElement == this.canvas;
+    }
+    /**
+     * @returns whether the pointer is visible.
+     */
+    isCursorVisible() {
+        return this.enableLock || !this.unlockedMode.visible;
+    }
+}

package/dist/like.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @module like
+ * @description A catalogue of subsystems
+ */
+import type { Audio } from './audio/index';
+import type { Timer } from './timer/index';
+import type { Input } from './input/index';
+import type { Keyboard } from './input/keyboard';
+import type { Mouse } from './input/mouse';
+import type { Gamepad } from './input/gamepad';
+import type { Canvas } from './graphics/canvas';
+import type { BoundGraphics } from './graphics/index';
+import { EventMap, EventType, LikeEvent } from './events';
+import { Scene } from './scene';
+export type TopLevelEventHandler = (event: LikeEvent) => void;
+type Callback<K extends EventType> = (...args: EventMap[K]) => void;
+type Callbacks = {
+    [K in EventType]?: Callback<K>;
+};
+/**
+ * The main Like instance.
+ * Use this object much how you would the `love` object in Love2D.
+ * This is the interface returned by {@link createLike}.
+ */
+export type Like = Callbacks & {
+    /** Handle a pool of pseudo-synchronous audio sources with global volume control and more. */
+    readonly audio: Audio;
+    /** Misc. time functions, including sleeping the game. ZZZ */
+    readonly timer: Timer;
+    /** Bind inputs to actions that call `like.actionpressed`, or query them here also. */
+    readonly input: Input;
+    /** Check if scancodes are down / pressed. */
+    readonly keyboard: Keyboard;
+    /** Mouse module: Get a properly scaled mouse position, set capture and more. */
+    readonly mouse: Mouse;
+    /** Gamepad module: Map gamepads and check their buttons. */
+    readonly gamepad: Gamepad;
+    /** Get and set screen size, choosing between native and pixel perfect prescaling. Plus fullscreen control. */
+    readonly canvas: Canvas;
+    /** Graphics module: LOVE-style rendering, plus a pseudo-synchronous way to load images. */
+    gfx: BoundGraphics;
+    /** I think you meant to type `canvas`. */
+    window?: never;
+    /**
+     * Start the game loop. Call this only once.
+     * @returns Promise that resolves when the engine is ready
+     */
+    start(): Promise<void>;
+    /**
+     * Only call this when you're done with LIKE. Everything will stop
+     * running, and probably break if you try to use it.
+     */
+    dispose(): void;
+    /**
+     * A simple way to set the current scene, which acts like a pluggable
+     * set of callbacks.
+     */
+    setScene(scene?: Scene): void;
+    /**
+     * LIKE's runtime is built around calling handleEvent.
+     *
+     * This function recieves all events. If set to undefined,
+     * `like.callOwnHandlers(ev)` is the default behavior.
+     *
+     * Otherwise, you can really customize LIKE by setting this
+     * to a custom handler.
+     *
+     * For example, the scene architecture is built around
+     * setting this function.
+     */
+    handleEvent?: TopLevelEventHandler;
+    /**
+     * Used as the default `like.handleEvent`, simply dispatches
+     * an event into LIKE callbacks.
+     * @param event
+     */
+    callOwnHandlers(event: LikeEvent): void;
+};
+export {};
+//# sourceMappingURL=like.d.ts.map

package/dist/like.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"like.d.ts","sourceRoot":"","sources":["../src/like.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC1D,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,MAAM,MAAM,oBAAoB,GAAG,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;AAE9D,KAAK,QAAQ,CAAC,CAAC,SAAS,SAAS,IAAI,CAAC,GAAG,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;AAEpE,KAAK,SAAS,GAAG;KACd,CAAC,IAAI,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;CAC/B,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,IAAI,GAAG,SAAS,GAAG;IAC7B,6FAA6F;IAC7F,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,sFAAsF;IACtF,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,6CAA6C;IAC7C,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,4DAA4D;IAC5D,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,8GAA8G;IAC9G,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,2FAA2F;IAC3F,GAAG,EAAE,aAAa,CAAC;IAEnB,0CAA0C;IAC1C,MAAM,CAAC,EAAE,KAAK,CAAC;IAEf;;;OAGG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB;;;OAGG;IACH,OAAO,IAAI,IAAI,CAAC;IAEhB;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IAE9B;;;;;;;;;;;OAWG;IACH,WAAW,CAAC,EAAE,oBAAoB,CAAC;IAEnC;;;;OAIG;IACH,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;CACzC,CAAA"}

package/dist/like.js

@@ -0,0 +1,5 @@
+/**
+ * @module like
+ * @description A catalogue of subsystems
+ */
+export {};

package/dist/math/index.d.ts

@@ -1,2 +1,18 @@
+/**
+ * @module math
+ *
+ * A purely functional math library, mostly for 2d.
+ *
+ * Check out {@link vector2} and {@link rect}
+ *
+ * Why purely functional?
+ *   1. About as fast as it can get -- the JIT will pick up on these.
+ *   2. Plays nice with stream iterators.
+ *   3. JS is likely to add a pipe operator in the future.
+ *   4. Construction is as easy as building an array.
+ */
+/** True modulus, conspicuously missing from JS */
 export declare const mod: (a: number, b: number) => number;
+export { type Vector2, Vec2 } from "./vector2";
+export { type Rectangle, Rect } from "./rect";
 //# sourceMappingURL=index.d.ts.map

package/dist/math/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/math/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,GAAG,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,WAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/math/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,kDAAkD;AAClD,eAAO,MAAM,GAAG,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,WAAsB,CAAC;AAE/D,OAAO,EAAE,KAAK,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,KAAK,SAAS,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC"}

package/dist/math/index.js

@@ -1 +1,17 @@
+/**
+ * @module math
+ *
+ * A purely functional math library, mostly for 2d.
+ *
+ * Check out {@link vector2} and {@link rect}
+ *
+ * Why purely functional?
+ *   1. About as fast as it can get -- the JIT will pick up on these.
+ *   2. Plays nice with stream iterators.
+ *   3. JS is likely to add a pipe operator in the future.
+ *   4. Construction is as easy as building an array.
+ */
+/** True modulus, conspicuously missing from JS */
 export const mod = (a, b) => ((a % b) + b) % b;
+export { Vec2 } from "./vector2";
+export { Rect } from "./rect";

package/dist/math/rect.d.ts

@@ -41,31 +41,28 @@ import { type Vector2 } from '../math/vector2';
  *
  * */
 export type Rectangle = [number, number, number, number];
-/**
- * A set of
- */
-export declare namespace Rect {
-    function fromPoints(a: Vector2, b: Vector2): Rectangle;
-    function fromCenter(center: Vector2, size: Vector2): Rectangle;
-    function position(r: Rectangle): Vector2;
-    function size(r: Rectangle): Vector2;
-    function center(r: Rectangle): Vector2;
-    function topLeft(r: Rectangle): Vector2;
-    function topRight(r: Rectangle): Vector2;
-    function bottomLeft(r: Rectangle): Vector2;
-    function bottomRight(r: Rectangle): Vector2;
-    function area(r: Rectangle): number;
-    function isEmpty(r: Rectangle): boolean;
-    function clampPoint(r: Rectangle, point: Vector2): Vector2;
-    function containsPoint(r: Rectangle, point: Vector2): boolean;
-    function containsRect(r: Rectangle, other: Rectangle): boolean;
-    function intersects(r: Rectangle, other: Rectangle): boolean;
-    function intersection(r: Rectangle, other: Rectangle): Rectangle;
-    function union(r: Rectangle, other: Rectangle): Rectangle;
-    function inflate(r: Rectangle, amount: number): Rectangle;
-    function offset(r: Rectangle, delta: Vector2): Rectangle;
-    function setPosition(r: Rectangle, pos: Vector2): Rectangle;
-    function setSize(r: Rectangle, size: Vector2): Rectangle;
-    function setCenter(r: Rectangle, center: Vector2): Rectangle;
-}
+export declare const Rect: {
+    fromPoints(a: Vector2, b: Vector2): Rectangle;
+    fromCenter(center: Vector2, size: Vector2): Rectangle;
+    position(r: Rectangle): Vector2;
+    size(r: Rectangle): Vector2;
+    center(r: Rectangle): Vector2;
+    topLeft(r: Rectangle): Vector2;
+    topRight(r: Rectangle): Vector2;
+    bottomLeft(r: Rectangle): Vector2;
+    bottomRight(r: Rectangle): Vector2;
+    area(r: Rectangle): number;
+    isEmpty(r: Rectangle): boolean;
+    clampPoint(r: Rectangle, point: Vector2): Vector2;
+    containsPoint(r: Rectangle, point: Vector2): boolean;
+    containsRect(r: Rectangle, other: Rectangle): boolean;
+    intersects(r: Rectangle, other: Rectangle): boolean;
+    intersection(r: Rectangle, other: Rectangle): Rectangle;
+    union(r: Rectangle, other: Rectangle): Rectangle;
+    inflate(r: Rectangle, amount: number): Rectangle;
+    offset(r: Rectangle, delta: Vector2): Rectangle;
+    setPosition(r: Rectangle, pos: Vector2): Rectangle;
+    setSize(r: Rectangle, size: Vector2): Rectangle;
+    setCenter(r: Rectangle, center: Vector2): Rectangle;
+};
 //# sourceMappingURL=rect.d.ts.map

package/dist/math/rect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rect.d.ts","sourceRoot":"","sources":["../../src/math/rect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAwCK;AACL,MAAM,MAAM,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAEzD;;GAEG;AACH,yBAAiB,IAAI,CAAC;IACpB,SAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,SAAS,CAM5D;IAED,SAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,GAAG,SAAS,CAOpE;IAED,SAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAE9C;IAED,SAAgB,IAAI,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAE1C;IAED,SAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAE5C;IAED,SAAgB,OAAO,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAE7C;IAED,SAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAE9C;IAED,SAAgB,UAAU,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAEhD;IAED,SAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAEjD;IAED,SAAgB,IAAI,CAAC,CAAC,EAAE,SAAS,GAAG,MAAM,CAEzC;IAED,SAAgB,OAAO,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAE7C;IAED,SAAgB,UAAU,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAEhE;IAED,SAAgB,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAOnE;IAED,SAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAOpE;IAED,SAAgB,UAAU,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAOlE;IAED,SAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,GAAG,SAAS,CAWtE;IAED,SAAgB,KAAK,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,GAAG,SAAS,CAM/D;IAED,SAAgB,OAAO,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAO/D;IAED,SAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,SAAS,CAE9D;IAED,SAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,OAAO,GAAG,SAAS,CAEjE;IAED,SAAgB,OAAO,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,GAAG,SAAS,CAE9D;IAED,SAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,GAAG,SAAS,CAOlE;CACF"}
+{"version":3,"file":"rect.d.ts","sourceRoot":"","sources":["../../src/math/rect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAwCK;AACL,MAAM,MAAM,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAEzD,eAAO,MAAM,IAAI;kBACD,OAAO,KAAK,OAAO,GAAG,SAAS;uBAQ1B,OAAO,QAAQ,OAAO,GAAG,SAAS;gBASzC,SAAS,GAAG,OAAO;YAIvB,SAAS,GAAG,OAAO;cAIjB,SAAS,GAAG,OAAO;eAIlB,SAAS,GAAG,OAAO;gBAIlB,SAAS,GAAG,OAAO;kBAIjB,SAAS,GAAG,OAAO;mBAIlB,SAAS,GAAG,OAAO;YAI1B,SAAS,GAAG,MAAM;eAIf,SAAS,GAAG,OAAO;kBAIhB,SAAS,SAAS,OAAO,GAAG,OAAO;qBAIhC,SAAS,SAAS,OAAO,GAAG,OAAO;oBASpC,SAAS,SAAS,SAAS,GAAG,OAAO;kBASvC,SAAS,SAAS,SAAS,GAAG,OAAO;oBASnC,SAAS,SAAS,SAAS,GAAG,SAAS;aAa9C,SAAS,SAAS,SAAS,GAAG,SAAS;eAQrC,SAAS,UAAU,MAAM,GAAG,SAAS;cAStC,SAAS,SAAS,OAAO,GAAG,SAAS;mBAIhC,SAAS,OAAO,OAAO,GAAG,SAAS;eAIvC,SAAS,QAAQ,OAAO,GAAG,SAAS;iBAIlC,SAAS,UAAU,OAAO,GAAG,SAAS;CAQpD,CAAC"}