like2d 2.9.0 → 2.10.1

package/dist/input/input.d.ts

@@ -0,0 +1,76 @@
+import type { Keyboard } from './keyboard';
+import type { Mouse } from './mouse';
+import { Gamepad, GamepadTarget } from './gamepad';
+import { LikeButton } from './gamepad-mapping';
+import { MouseButton, Dispatcher } from '../events';
+export type InputType = InputBinding['type'];
+export type InputBinding = {
+    type: 'keyboard';
+    scancode: string;
+} | {
+    type: 'mouse';
+    button: MouseButton;
+} | {
+    type: 'gamepad';
+    gamepad: GamepadTarget;
+    button: LikeButton;
+};
+export declare class Input {
+    private dispatch;
+    private currState;
+    private prevState;
+    private actionTable;
+    private keyboard;
+    private mouse;
+    private gamepad;
+    constructor(dispatch: Dispatcher<'actionpressed' | 'actionreleased'>, deps: {
+        keyboard: Keyboard;
+        mouse: Mouse;
+        gamepad: Gamepad;
+    });
+    /**
+     * This is the easiest way to set-and-forget input => action mapping.
+     *
+     * Or, it's a helper to remove actions -- `setAction(action)`
+     * will simply clear the action away.
+     *
+     * For input strings:
+     *  - Mouse is `MouseLeft`, `MouseRight`, or `MouseMiddle`.
+     *  - Joypad is 'Left', 'L1', or any joypad button. {@link LikeButton}
+     *  - Keyboard is the name of scancodes, which are based on key positions. Choose from a subset of portable, web-safe scancodes:
+     *    - Alphabetical: `KeyA`, `KeyB`, ...
+     *    - Numeric: `Digit0`, `Digit1`, ...
+     *    - `ArrowLeft`, `ArrowRight`, `ArrowUp`, `ArrowDown`
+     *    - `ShiftLeft`, `ShiftRight`
+     *    - `Minus`
+     *    - `Equal` (also has a plus sign)
+     *    - `BracketLeft` and `BracketRight`
+     *    - `Semicolon`
+     *    - `Quote`
+     *    - `Backquote` (also has tilde)
+     *    - `Backslash`
+     *    - `Comma`
+     *    - `Period`
+     *    - `Slash`
+     *    - `Backspace`
+     *    - `Enter`
+     *
+     * @param action
+     * @param inputs
+     */
+    setAction(action: string, inputs?: (string | InputBinding)[]): void;
+    /**
+     * Map a single input onto an action.
+     */
+    appendToAction(action: string, input: InputBinding | string): void;
+    /**
+     * Get the mapping entry for a specific action.
+     */
+    getActionMapping(action: string): InputBinding[];
+    isDown(action: string): boolean;
+    justPressed(action: string): boolean;
+    justReleased(action: string): boolean;
+    update(): void;
+    private isBindingActive;
+}
+//# sourceMappingURL=input.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../src/input/input.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,EAAc,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEpD,MAAM,MAAM,SAAS,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;AAC7C,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,WAAW,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,CAAC;AAEpE,qBAAa,KAAK;IASd,OAAO,CAAC,QAAQ;IARlB,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,WAAW,CAAsC;IACzD,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,OAAO,CAAU;gBAGf,QAAQ,EAAE,UAAU,CAAC,eAAe,GAAG,gBAAgB,CAAC,EAChE,IAAI,EAAE;QACJ,QAAQ,EAAE,QAAQ,CAAC;QACnB,KAAK,EAAE,KAAK,CAAC;QACb,OAAO,EAAE,OAAO,CAAC;KAClB;IAOH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,CAAC,MAAM,GAAG,YAAY,CAAC,EAAO,GAAG,IAAI;IAUvE;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,MAAM;IAM3D;;OAEG;IACH,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,EAAE;IAIhD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAM/B,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIpC,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIrC,MAAM;IAgBN,OAAO,CAAC,eAAe;CAaxB"}

package/dist/input/input.js

@@ -0,0 +1,163 @@
+import { allButtons } from './gamepad-mapping';
+export class Input {
+    constructor(dispatch, deps) {
+        Object.defineProperty(this, "dispatch", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: dispatch
+        });
+        Object.defineProperty(this, "currState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "prevState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "actionTable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "keyboard", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "mouse", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "gamepad", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.keyboard = deps.keyboard;
+        this.mouse = deps.mouse;
+        this.gamepad = deps.gamepad;
+    }
+    /**
+     * This is the easiest way to set-and-forget input => action mapping.
+     *
+     * Or, it's a helper to remove actions -- `setAction(action)`
+     * will simply clear the action away.
+     *
+     * For input strings:
+     *  - Mouse is `MouseLeft`, `MouseRight`, or `MouseMiddle`.
+     *  - Joypad is 'Left', 'L1', or any joypad button. {@link LikeButton}
+     *  - Keyboard is the name of scancodes, which are based on key positions. Choose from a subset of portable, web-safe scancodes:
+     *    - Alphabetical: `KeyA`, `KeyB`, ...
+     *    - Numeric: `Digit0`, `Digit1`, ...
+     *    - `ArrowLeft`, `ArrowRight`, `ArrowUp`, `ArrowDown`
+     *    - `ShiftLeft`, `ShiftRight`
+     *    - `Minus`
+     *    - `Equal` (also has a plus sign)
+     *    - `BracketLeft` and `BracketRight`
+     *    - `Semicolon`
+     *    - `Quote`
+     *    - `Backquote` (also has tilde)
+     *    - `Backslash`
+     *    - `Comma`
+     *    - `Period`
+     *    - `Slash`
+     *    - `Backspace`
+     *    - `Enter`
+     *
+     * @param action
+     * @param inputs
+     */
+    setAction(action, inputs = []) {
+        if (inputs.length) {
+            this.actionTable[action] = inputs.map(parseInput);
+        }
+        else {
+            delete this.actionTable[action];
+            this.currState.delete(action);
+            this.prevState.delete(action);
+        }
+    }
+    /**
+     * Map a single input onto an action.
+     */
+    appendToAction(action, input) {
+        const am = this.actionTable[action] ?? [];
+        am.push(parseInput(input));
+        this.actionTable[action] = am;
+    }
+    /**
+     * Get the mapping entry for a specific action.
+     */
+    getActionMapping(action) {
+        return this.actionTable[action] ?? [];
+    }
+    isDown(action) {
+        const bindings = this.actionTable[action];
+        if (!bindings)
+            return false;
+        return bindings.some((binding) => this.isBindingActive(binding));
+    }
+    justPressed(action) {
+        return this.currState.has(action) && !this.prevState.has(action);
+    }
+    justReleased(action) {
+        return !this.currState.has(action) && this.prevState.has(action);
+    }
+    update() {
+        [this.prevState, this.currState] = [this.currState, this.prevState];
+        this.currState.clear();
+        for (const action of Object.keys(this.actionTable)) {
+            if (this.isDown(action)) {
+                if (!this.prevState.has(action)) {
+                    this.dispatch('actionpressed', [action]);
+                }
+                this.currState.add(action);
+            }
+            else if (this.prevState.has(action)) {
+                this.dispatch('actionreleased', [action]);
+            }
+        }
+    }
+    isBindingActive(binding) {
+        switch (binding.type) {
+            case "keyboard":
+                return this.keyboard.isDown(binding.scancode);
+            case "mouse":
+                return this.mouse.isDown(binding.button);
+            case "gamepad": {
+                return !!this.gamepad.isDown(binding.gamepad, binding.button);
+            }
+            default:
+                return false;
+        }
+    }
+}
+function parseInput(input) {
+    if (typeof input !== "string")
+        return input;
+    const normalized = input.trim();
+    if (normalized.startsWith("Mouse")) {
+        const buttonCode = normalized.replace("Mouse", "").toLowerCase();
+        return { type: "mouse", button: buttonCode };
+    }
+    if (allButtons.has(input) ||
+        normalized.startsWith("Button") ||
+        normalized.startsWith("Axis")) {
+        return {
+            type: "gamepad",
+            gamepad: "any",
+            button: normalized,
+        };
+    }
+    return { type: "keyboard", scancode: normalized };
+}

package/dist/input/keyboard.d.ts

@@ -0,0 +1,15 @@
+import { EngineProps } from "../engine";
+type KEvent = 'keypressed' | 'keyreleased';
+export declare class Keyboard {
+    private pressedScancodes;
+    private canvas;
+    private dispatch;
+    constructor(props: EngineProps<KEvent>);
+    private handleKeyDown;
+    private handleKeyUp;
+    private handleBlur;
+    isDown(scancode: string): boolean;
+    isAnyDown(...scancodes: string[]): boolean;
+}
+export {};
+//# sourceMappingURL=keyboard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard.d.ts","sourceRoot":"","sources":["../../src/input/keyboard.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAGxC,KAAK,MAAM,GAAG,YAAY,GAAG,aAAa,CAAC;AAE3C,qBAAa,QAAQ;IACnB,OAAO,CAAC,gBAAgB,CAAqB;IAC7C,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,QAAQ,CAAqB;gBAEzB,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC;IAUtC,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,UAAU;IAIlB,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIjC,SAAS,CAAC,GAAG,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO;CAG3C"}

package/dist/{core → input}/keyboard.js

@@ -1,11 +1,5 @@
-export class KeyboardInternal {
-    constructor(canvas, dispatch) {
-        Object.defineProperty(this, "dispatch", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: dispatch
-        });
+export class Keyboard {
+    constructor(props) {
         Object.defineProperty(this, "pressedScancodes", {
             enumerable: true,
             configurable: true,
@@ -16,20 +10,20 @@ export class KeyboardInternal {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: null
+            value: void 0
         });
-        Object.defineProperty(this, "abort", {
+        Object.defineProperty(this, "dispatch", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new AbortController()
+            value: void 0
         });
-        this.canvas = canvas;
-        if (this.canvas) {
-            this.canvas.addEventListener('keydown', this.handleKeyDown.bind(this), { signal: this.abort.signal });
-            this.canvas.addEventListener('keyup', this.handleKeyUp.bind(this), { signal: this.abort.signal });
-            this.canvas.addEventListener('blur', this.handleBlur.bind(this), { signal: this.abort.signal });
-        }
+        this.canvas = props.canvas;
+        this.dispatch = props.dispatch;
+        const { abort } = props;
+        this.canvas.addEventListener('keydown', this.handleKeyDown.bind(this), { signal: abort });
+        this.canvas.addEventListener('keyup', this.handleKeyUp.bind(this), { signal: abort });
+        this.canvas.addEventListener('blur', this.handleBlur.bind(this), { signal: abort });
     }
     handleKeyDown(e) {
         const scrollKeys = ['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight', 'Space', 'PageUp', 'PageDown', 'Home', 'End'];
@@ -50,10 +44,6 @@ export class KeyboardInternal {
     handleBlur() {
         this.pressedScancodes.clear();
     }
-    _dispose() {
-        this.abort.abort();
-        this.pressedScancodes.clear();
-    }
     isDown(scancode) {
         return this.pressedScancodes.has(scancode);
     }

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;
+    }
+}