like2d 2.8.0 → 2.9.0

package/dist/engine.js

@@ -1,116 +1,99 @@
-import { Audio } from './core/audio';
-import { Input } from './core/input';
-import { Timer } from './core/timer';
-import { Keyboard } from './core/keyboard';
-import { Mouse } from './core/mouse';
-import { Gamepad } from './core/gamepad';
-import { newState, bindGraphics } from './core/graphics';
-import { CanvasManager } from './core/canvas-manager';
+/**
+ * @module engine
+ * @description Core game engine - lifecycle management and event dispatch.
+ *
+ * You've reached the most evil part of the codebase -- the man
+ * behind the curtain.
+ *
+ * The secret force gluing everything together.
+ *
+ * If you want to use modules independently, look here first.
+ *
+ * ## Memory Management
+ *
+ * Always call `dispose()` when destroying an engine instance:
+ * - Removes all event listeners
+ * - Stops the game loop
+ * - Removes canvas from DOM
+ * - Cleans up canvas manager resources
+ *
+ */
+import { AudioInternal } from './core/audio';
+import { InputInternal } from './core/input';
+import { TimerInternal } from './core/timer';
+import { KeyboardInternal } from './core/keyboard';
+import { MouseInternal } from './core/mouse';
+import { GamepadInternal } from './core/gamepad';
+import { bindGraphics } from './core/graphics';
+import { CanvasInternal } from './core/canvas';
+import { sceneDispatch } from './scene';
+/**
+ * Core game engine managing the event loop and subsystems.
+ *
+ * Normally you don't instantiate this directly - use {@link createLike} instead.
+ * The Engine class is exposed for advanced use cases like testing or
+ * custom initialization sequences.
+ *
+ * All subsystems are accessible via the {@link like} property.
+ */
 export class Engine {
     constructor(container) {
-        Object.defineProperty(this, "canvas", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "isRunning", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "lastTime", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
         Object.defineProperty(this, "container", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "canvasManager", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "handleEvent", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
+            value: container
         });
-        Object.defineProperty(this, "currentScene", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "gfxState", {
+        Object.defineProperty(this, "canvas", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        // Event handler references for cleanup
-        Object.defineProperty(this, "windowFocusHandler", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "windowBlurHandler", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "canvasFocusHandler", {
+        Object.defineProperty(this, "isRunning", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: null
+            value: false
         });
-        Object.defineProperty(this, "canvasBlurHandler", {
+        Object.defineProperty(this, "lastTime", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: null
+            value: 0
         });
-        Object.defineProperty(this, "fullscreenChangeHandler", {
+        Object.defineProperty(this, "abort", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: null
+            value: new AbortController()
         });
+        /**
+         * The Like interface providing access to all engine subsystems.
+         * This object is passed to all scene callbacks and game code.
+         */
         Object.defineProperty(this, "like", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.canvas = document.createElement('canvas');
-        this.canvas.style.border = '1px solid #ccc';
-        this.canvas.style.display = 'block';
-        const ctx = this.canvas.getContext('2d');
-        if (!ctx)
-            throw new Error('Failed to get 2D context');
-        this.container = container;
-        this.container.appendChild(this.canvas);
-        this.canvasManager = new CanvasManager(this.canvas, this.container, ctx, { pixelResolution: null, fullscreen: false });
-        const renderTarget = this.canvasManager.getRenderTarget();
-        this.gfxState = newState(renderTarget.ctx);
-        let gfx = bindGraphics(this.gfxState);
-        const audio = new Audio();
-        const timer = new Timer();
-        const keyboard = new Keyboard(this.canvas);
-        const mouse = new Mouse(this.canvas, (cssX, cssY) => this.canvasManager.transformMousePosition(cssX, cssY));
-        const gamepad = new Gamepad();
-        const input = new Input({ keyboard, mouse, gamepad });
+        this.canvas = new CanvasInternal(this.dispatch.bind(this));
+        const canvas = this.canvas._displayCanvas;
+        canvas.addEventListener("like:updateRenderTarget", (event) => {
+            if (!(event instanceof CustomEvent))
+                return;
+            this.like.gfx = bindGraphics(event.detail.target.getContext('2d'));
+        });
+        this.container.appendChild(canvas);
+        let gfx = bindGraphics(canvas.getContext('2d'));
+        const dispatch = this.dispatch.bind(this);
+        const audio = new AudioInternal();
+        const timer = new TimerInternal();
+        const keyboard = new KeyboardInternal(canvas, dispatch);
+        const mouse = new MouseInternal(canvas, dispatch);
+        const gamepad = new GamepadInternal(dispatch);
+        const input = new InputInternal({ keyboard, mouse, gamepad });
         this.like = {
             audio,
             timer,
@@ -119,76 +102,50 @@ export class Engine {
             mouse,
             gamepad,
             gfx,
-            setMode: (m) => this.setMode(m),
-            getMode: () => this.canvasManager.getMode(),
-            getCanvasSize: () => this.canvasManager.getCanvasSize(),
+            canvas: this.canvas,
+            start: this.start.bind(this),
+            dispose: this.dispose.bind(this),
             setScene: (scene) => {
-                this.currentScene = scene;
-                scene?.load?.(this.like);
+                if (scene) {
+                    this.like.handleEvent = (event) => sceneDispatch(scene, this.like, event);
+                    this.dispatch("load", []);
+                }
+                else {
+                    this.like.handleEvent = undefined;
+                }
             },
-        };
-        this.canvasManager.onResize = () => {
-            const target = this.canvasManager.getRenderTarget();
-            this.gfxState = newState(target.ctx);
-            this.like.gfx = bindGraphics(this.gfxState);
-        };
-        keyboard.onKeyEvent = (scancode, keycode, type) => {
-            this.dispatch(type === 'keydown' ? 'keypressed' : 'keyreleased', [scancode, keycode]);
-        };
-        mouse.onMouseMove = (pos, relative) => {
-            this.dispatch('mousemoved', [pos, relative]);
-        };
-        mouse.onMouseDown = (pos, button) => {
-            this.dispatch('mousepressed', [pos, button]);
-        };
-        mouse.onMouseUp = (pos, button) => {
-            this.dispatch('mousereleased', [pos, button]);
-        };
-        gamepad.onButtonEvent = (gpIndex, buttonIndex, buttonName, pressed) => {
-            this.dispatch(pressed ? 'gamepadpressed' : 'gamepadreleased', [gpIndex, buttonIndex, buttonName]);
-        };
-        this.windowFocusHandler = () => this.dispatch('focus', []);
-        this.windowBlurHandler = () => this.dispatch('blur', []);
-        this.canvasFocusHandler = () => this.dispatch('focus', []);
-        this.canvasBlurHandler = () => this.dispatch('blur', []);
-        this.fullscreenChangeHandler = () => {
-            const mode = this.canvasManager.getMode();
-            const isFullscreen = !!document.fullscreenElement;
-            if (mode.fullscreen !== isFullscreen) {
-                this.canvasManager.setMode({ ...mode, fullscreen: isFullscreen });
+            callOwnHandlers: (event) => {
+                if (event.type in this.like)
+                    this.like[event.type](...event.args);
             }
         };
-        window.addEventListener('focus', this.windowFocusHandler);
-        window.addEventListener('blur', this.windowBlurHandler);
-        this.canvas.addEventListener('focus', this.canvasFocusHandler);
-        this.canvas.addEventListener('blur', this.canvasBlurHandler);
-        document.addEventListener('fullscreenchange', this.fullscreenChangeHandler);
+        window.addEventListener('focus', () => this.dispatch('focus', ['tab']));
+        window.addEventListener('blur', () => this.dispatch('blur', ['tab']));
+        canvas.addEventListener('focus', () => this.dispatch('focus', ['canvas']));
+        canvas.addEventListener('focus', () => this.dispatch('focus', ['canvas']));
     }
     dispatch(type, args) {
-        if (!this.handleEvent)
-            return;
-        const event = { type, args, timestamp: performance.now() };
-        if (this.currentScene) {
-            this.currentScene.handleEvent?.(this.like, event);
-            const method = this.currentScene[event.type];
-            method?.call(this.currentScene, this.like, ...args);
+        const event = { type, args, timestamp: this.like.timer.getTime() };
+        if (this.like.handleEvent) {
+            this.like.handleEvent(event);
         }
         else {
-            this.handleEvent(event);
-        }
-    }
-    setMode(mode) {
-        const currentMode = this.canvasManager.getMode();
-        if ('fullscreen' in mode && mode.fullscreen !== currentMode.fullscreen) {
-            mode.fullscreen ? this.container.requestFullscreen().catch(console.error) : document.exitFullscreen();
+            this.like.callOwnHandlers(event);
         }
-        this.canvasManager.setMode({ ...currentMode, ...mode });
     }
-    async start(handleEvent) {
-        this.handleEvent = handleEvent;
+    /**
+     * Start the game loop.
+     *
+     * @remarks
+     * This method:
+     * 1. Dispatches the initial `load` event
+     * 2. Starts the requestAnimationFrame loop
+     *
+     * The engine runs until dispose() is called.
+     */
+    async start() {
         this.isRunning = true;
         this.lastTime = performance.now();
-        await this.like.gamepad.init();
         const loop = () => {
             if (!this.isRunning)
                 return;
@@ -196,37 +153,41 @@ export class Engine {
             const dt = (now - this.lastTime) / 1000;
             this.lastTime = now;
             if (!this.like.timer.isSleeping()) {
-                this.like.timer.update(dt);
-                const { pressed, released } = this.like.input.update();
+                this.like.timer._update(dt);
+                const { pressed, released } = this.like.input._update();
                 pressed.forEach(action => this.dispatch('actionpressed', [action]));
                 released.forEach(action => this.dispatch('actionreleased', [action]));
                 this.dispatch('update', [dt]);
             }
             this.dispatch('draw', []);
-            this.canvasManager.present();
+            this.canvas._present();
             requestAnimationFrame(loop);
         };
         this.dispatch('load', []);
         requestAnimationFrame(loop);
     }
+    /**
+     * Clean up all resources and stop the engine.
+     *
+     * @remarks
+     * This method:
+     * - Stops the game loop
+     * - Removes all event listeners (keyboard, mouse, window, fullscreen)
+     * - Disposes canvas manager (removes resize observer)
+     * - Removes the canvas element from the DOM
+     *
+     * The engine cannot be restarted after disposal - create a new instance.
+     */
     dispose() {
+        const canvas = this.canvas._displayCanvas;
         this.isRunning = false;
-        this.like.keyboard.dispose();
-        this.like.mouse.dispose();
-        this.like.gamepad.dispose();
-        this.canvasManager.dispose();
-        if (this.windowFocusHandler)
-            window.removeEventListener('focus', this.windowFocusHandler);
-        if (this.windowBlurHandler)
-            window.removeEventListener('blur', this.windowBlurHandler);
-        if (this.canvasFocusHandler)
-            this.canvas.removeEventListener('focus', this.canvasFocusHandler);
-        if (this.canvasBlurHandler)
-            this.canvas.removeEventListener('blur', this.canvasBlurHandler);
-        if (this.fullscreenChangeHandler)
-            document.removeEventListener('fullscreenchange', this.fullscreenChangeHandler);
-        if (this.canvas.parentNode === this.container) {
-            this.container.removeChild(this.canvas);
+        this.like.keyboard._dispose();
+        this.like.mouse._dispose();
+        this.like.gamepad._dispose();
+        this.canvas._dispose();
+        this.abort.abort();
+        if (canvas.parentNode === this.container) {
+            this.container.removeChild(canvas);
         }
     }
 }

package/dist/index.d.ts

@@ -1,25 +1,46 @@
-import type { EventMap, EventType } from './core/events';
+/**
+ * @module like2d
+ * @description A cozy web-native 2D game framework.
+ *
+ * See main like/README.md file an for overview of Like2D.
+ */
+import type { LikeEvent } from './core/events';
 import type { Like } from './core/like';
 export type { Like } from './core/like';
-export type { Vector2 } from './core/vector2';
-export { Vec2 } from './core/vector2';
-export { Rect } from './core/rect';
-export type { Like2DEvent, EventType, EventMap } from './core/events';
-export type { CanvasMode, PartialCanvasMode } from './core/canvas-config';
-export type { Color, Quad, ShapeProps, DrawProps, PrintProps } from './core/graphics';
+export type { LikeEvent, EventType, EventMap } from './core/events';
+export type { CanvasSize, CanvasModeOptions as CanvasModeFlags } from './core/canvas';
+export type { Color, ShapeProps, DrawProps, PrintProps } from './core/graphics';
 export { ImageHandle } from './core/graphics';
-export type { Source, SourceOptions } from './core/audio';
-export type { Scene } from './scene';
-export { StartupScene } from './scenes/startup';
-export { getGPName, GP } from './core/gamepad';
-export type { StickPosition } from './core/gamepad';
-type Callback<K extends EventType> = (...args: EventMap[K]) => void;
-type Callbacks = {
-    [K in EventType]?: Callback<K>;
-};
-export type LikeWithCallbacks = Like & Callbacks & {
-    start(): Promise<void>;
-    dispose(): void;
-};
-export declare function createLike(container: HTMLElement): LikeWithCallbacks;
+export type { AudioSource, AudioSourceOptions } from './core/audio';
+export { type LikeButton } from './core/gamepad';
+export type TopLevelEventHandler = (event: LikeEvent) => void;
+/**
+ * Create a new Like2D game instance attached to a DOM container.
+ *
+ * This is the entry point for all Like2D games. It creates a canvas element,
+ * initializes all subsystems (graphics, audio, input), and returns an object
+ * where you can assign game callbacks.
+ *
+ * ### How to bind callbacks
+ *
+ * ```ts
+ * export const like = createLike();
+ *
+ * like.start();
+ *
+ * like.draw = () => { like.gfx.clear('yellow') }
+ *
+ * like.update = function (dt: number) {
+ *   if (dt === Math.random()) {
+ *     console.log("You just won the Powerball!")
+ *   }
+ * }
+ * ```
+ *
+ * @param container - The HTML element to attach the game canvas to.
+ *                    Must be in the DOM.
+ * @returns A {@link Like} instance ready for callback assignment
+ *
+ */
+export declare function createLike(container: HTMLElement): Like;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAe,QAAQ,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACtE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,YAAY,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,YAAY,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACnC,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACtE,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC1E,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AACtF,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC1D,YAAY,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AAC/C,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD,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,MAAM,MAAM,iBAAiB,GAAG,IAAI,GAAG,SAAS,GAAG;IACjD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,OAAO,IAAI,IAAI,CAAC;CACjB,CAAC;AAEF,wBAAgB,UAAU,CAAC,SAAS,EAAE,WAAW,GAAG,iBAAiB,CAapE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,YAAY,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACpE,YAAY,EAAE,UAAU,EAAE,iBAAiB,IAAI,eAAe,EAAE,MAAM,eAAe,CAAC;AACtF,YAAY,EAAE,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,YAAY,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACpE,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD,MAAM,MAAM,oBAAoB,GAAG,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,WAAW,GAAG,IAAI,CAGvD"}

package/dist/index.js

@@ -1,19 +1,40 @@
+/**
+ * @module like2d
+ * @description A cozy web-native 2D game framework.
+ *
+ * See main like/README.md file an for overview of Like2D.
+ */
 import { Engine } from './engine';
-export { Vec2 } from './core/vector2';
-export { Rect } from './core/rect';
 export { ImageHandle } from './core/graphics';
-export { StartupScene } from './scenes/startup';
-export { getGPName, GP } from './core/gamepad';
+/**
+ * Create a new Like2D game instance attached to a DOM container.
+ *
+ * This is the entry point for all Like2D games. It creates a canvas element,
+ * initializes all subsystems (graphics, audio, input), and returns an object
+ * where you can assign game callbacks.
+ *
+ * ### How to bind callbacks
+ *
+ * ```ts
+ * export const like = createLike();
+ *
+ * like.start();
+ *
+ * like.draw = () => { like.gfx.clear('yellow') }
+ *
+ * like.update = function (dt: number) {
+ *   if (dt === Math.random()) {
+ *     console.log("You just won the Powerball!")
+ *   }
+ * }
+ * ```
+ *
+ * @param container - The HTML element to attach the game canvas to.
+ *                    Must be in the DOM.
+ * @returns A {@link Like} instance ready for callback assignment
+ *
+ */
 export function createLike(container) {
     const engine = new Engine(container);
-    const callbacks = {};
-    const handleEvent = (event) => {
-        const cb = callbacks[event.type];
-        if (cb)
-            cb(...event.args);
-    };
-    return Object.assign(engine.like, callbacks, {
-        start: () => engine.start(handleEvent),
-        dispose: () => engine.dispose(),
-    });
+    return engine.like;
 }

package/dist/math/index.d.ts

@@ -0,0 +1,2 @@
+export declare const mod: (a: number, b: number) => number;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

package/dist/math/index.js

@@ -0,0 +1 @@
+export const mod = (a, b) => ((a % b) + b) % b;

package/dist/math/rect.d.ts

@@ -0,0 +1,71 @@
+import { type Vector2 } from '../math/vector2';
+/**
+ * A four-coordinate type `[x, y, width, height]`.
+ * Full reference {@link Rect}.
+ *
+ * ## Examples
+ *
+ * ### Construct a rectangle
+ * ```ts
+ * const beastPen: Rectangle = [20, 25, 40, 50];
+ * ```
+ *
+ * ### Construct around a center point and size
+ * ```ts
+ * const beastPen: Rectangle = Rect.setCenter(
+ *   [0, 0, ...penSize],
+ *   beastPos
+ * );
+ * ```
+ * ### Deconstruct a rect
+ * ```ts
+ * [x, y, w, h] = beastPen;
+ * ```
+ * ### Deconstruct into points
+ * ```ts
+ * const penPos = Rect.position(beastPen);
+ * const penSize = Rect.size(beastPen);
+ * ```
+ *
+ * ### Check if beast is in his pen
+ * ```ts
+ * const isInPen = Rect.containsPoint(
+ *   beastPen,
+ *   beast.pos,
+ * )
+ * ```
+ * ### Put the beast back in his pen
+ * ```ts
+ * beast.pos = Rect.clampPoint(beast.pos, beastPen)
+ * ```
+ *
+ * */
+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;
+}
+//# sourceMappingURL=rect.d.ts.map

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

@@ -0,0 +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"}

package/dist/{core → math}/rect.js

@@ -1,3 +1,7 @@
+import { Vec2 } from '../math/vector2';
+/**
+ * A set of
+ */
 export var Rect;
 (function (Rect) {
     function fromPoints(a, b) {
@@ -53,6 +57,10 @@ export var Rect;
         return r[2] <= 0 || r[3] <= 0;
     }
     Rect.isEmpty = isEmpty;
+    function clampPoint(r, point) {
+        return Vec2.clamp(point, Rect.position(r), Rect.bottomRight(r));
+    }
+    Rect.clampPoint = clampPoint;
     function containsPoint(r, point) {
         return (point[0] >= r[0] &&
             point[0] <= r[0] + r[2] &&