like2d 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+import { Scene } from './scene';
+declare class Like {
+    private canvas;
+    private ctx;
+    private currentScene;
+    private isRunning;
+    private lastTime;
+    private currentWidth;
+    private currentHeight;
+    graphics: import("./graphics").Graphics;
+    audio: import("./audio").Audio;
+    keyboard: import("./keyboard").Keyboard;
+    mouse: import("./mouse").Mouse;
+    input: import("./input").Input;
+    gamepad: import("./gamepad").Gamepad;
+    timer: import("./timer").Timer;
+    constructor();
+    init(container: HTMLElement, width?: number, height?: number): Promise<void>;
+    toggleFullscreen(): void;
+    private setupInputHandlers;
+    setScene(scene: Scene): void;
+    start(scene: Scene): void;
+    private loop;
+    getCanvas(): HTMLCanvasElement | null;
+    getContext(): CanvasRenderingContext2D | null;
+    getWidth(): number;
+    getHeight(): number;
+}
+export declare const like: Like;
+export declare const love: Like;
+export { Source } from './audio';
+export type { SourceOptions } from './audio';
+export { timer } from './timer';
+export type { Scene } from './scene';
+export { ImageHandle } from './graphics';
+export type { Color, Quad, ShapeProps, DrawProps, PrintProps } from './graphics';
+export { input } from './input';
+export { gamepad, getButtonName } from './gamepad';
+export type { StickPosition } from './gamepad';
+export type { Vector2 } from './vector2';
+export { V2 } from './vector2';
+export type { Rect } from './rect';
+export { R } from './rect';
+export type { Event } from './events';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,cAAM,IAAI;IACR,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,GAAG,CAAyC;IACpD,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,YAAY,CAAO;IAC3B,OAAO,CAAC,aAAa,CAAO;IAE5B,QAAQ,gCAAY;IACpB,KAAK,0BAAS;IACd,QAAQ,gCAAY;IACpB,KAAK,0BAAS;IACd,KAAK,0BAAS;IACd,OAAO,8BAAW;IAClB,KAAK,0BAAS;;IAIR,IAAI,CAAC,SAAS,EAAE,WAAW,EAAE,KAAK,GAAE,MAAY,EAAE,MAAM,GAAE,MAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IA0B5F,gBAAgB,IAAI,IAAI;IAYxB,OAAO,CAAC,kBAAkB;IAwC1B,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAkB5B,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAczB,OAAO,CAAC,IAAI;IAiDZ,SAAS,IAAI,iBAAiB,GAAG,IAAI;IAIrC,UAAU,IAAI,wBAAwB,GAAG,IAAI;IAI7C,QAAQ,IAAI,MAAM;IAIlB,SAAS,IAAI,MAAM;CAGpB;AAED,eAAO,MAAM,IAAI,MAAa,CAAC;AAC/B,eAAO,MAAM,IAAI,MAAO,CAAC;AACzB,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,YAAY,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACjF,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AACnD,YAAY,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,YAAY,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,EAAE,EAAE,MAAM,WAAW,CAAC;AAC/B,YAAY,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAC3B,YAAY,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,250 @@
+import { graphics } from './graphics';
+import { audio } from './audio';
+import { keyboard } from './keyboard';
+import { mouse } from './mouse';
+import { input } from './input';
+import { gamepad } from './gamepad';
+import { timer } from './timer';
+class Like {
+    constructor() {
+        Object.defineProperty(this, "canvas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "ctx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "currentScene", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        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, "currentWidth", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 800
+        });
+        Object.defineProperty(this, "currentHeight", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 600
+        });
+        Object.defineProperty(this, "graphics", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: graphics
+        });
+        Object.defineProperty(this, "audio", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: audio
+        });
+        Object.defineProperty(this, "keyboard", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: keyboard
+        });
+        Object.defineProperty(this, "mouse", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: mouse
+        });
+        Object.defineProperty(this, "input", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: input
+        });
+        Object.defineProperty(this, "gamepad", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: gamepad
+        });
+        Object.defineProperty(this, "timer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: timer
+        });
+    }
+    async init(container, width = 800, height = 600) {
+        this.currentWidth = width;
+        this.currentHeight = height;
+        this.canvas = document.createElement('canvas');
+        this.canvas.width = width;
+        this.canvas.height = height;
+        this.canvas.style.border = '1px solid #ccc';
+        this.canvas.style.display = 'block';
+        this.ctx = this.canvas.getContext('2d');
+        if (!this.ctx) {
+            throw new Error('Failed to get 2D context');
+        }
+        graphics.setContext(this.ctx);
+        mouse.setCanvas(this.canvas);
+        container.appendChild(this.canvas);
+        this.setupInputHandlers();
+        // Initialize gamepad mapping database
+        await gamepad.init();
+    }
+    toggleFullscreen() {
+        if (!this.canvas)
+            return;
+        if (!document.fullscreenElement) {
+            this.canvas.requestFullscreen().catch(err => {
+                console.error(`Error attempting to enable fullscreen: ${err.message}`);
+            });
+        }
+        else {
+            document.exitFullscreen();
+        }
+    }
+    setupInputHandlers() {
+        window.addEventListener('keydown', (e) => {
+            if (this.currentScene?.handleEvent) {
+                this.currentScene.handleEvent({ type: 'keypressed', scancode: e.code, keycode: e.key });
+            }
+        });
+        window.addEventListener('keyup', (e) => {
+            if (this.currentScene?.handleEvent) {
+                this.currentScene.handleEvent({ type: 'keyreleased', scancode: e.code, keycode: e.key });
+            }
+        });
+        if (this.canvas) {
+            this.canvas.addEventListener('mousedown', (e) => {
+                if (this.currentScene?.handleEvent) {
+                    const rect = this.canvas.getBoundingClientRect();
+                    this.currentScene.handleEvent({
+                        type: 'mousepressed',
+                        x: e.clientX - rect.left,
+                        y: e.clientY - rect.top,
+                        button: e.button + 1
+                    });
+                }
+            });
+            this.canvas.addEventListener('mouseup', (e) => {
+                if (this.currentScene?.handleEvent) {
+                    const rect = this.canvas.getBoundingClientRect();
+                    this.currentScene.handleEvent({
+                        type: 'mousereleased',
+                        x: e.clientX - rect.left,
+                        y: e.clientY - rect.top,
+                        button: e.button + 1
+                    });
+                }
+            });
+        }
+    }
+    setScene(scene) {
+        this.currentScene = scene;
+        timer.resetSceneTime();
+        if (this.canvas) {
+            if (scene.width !== this.currentWidth || scene.height !== this.currentHeight) {
+                this.currentWidth = scene.width;
+                this.currentHeight = scene.height;
+                this.canvas.width = scene.width;
+                this.canvas.height = scene.height;
+            }
+        }
+        if (this.isRunning && scene.load) {
+            scene.load();
+        }
+    }
+    start(scene) {
+        if (this.isRunning)
+            return;
+        this.setScene(scene);
+        this.isRunning = true;
+        if (this.currentScene?.load) {
+            this.currentScene.load();
+        }
+        this.lastTime = performance.now();
+        this.loop();
+    }
+    loop() {
+        if (!this.isRunning || !this.currentScene)
+            return;
+        const currentTime = performance.now();
+        const dt = (currentTime - this.lastTime) / 1000;
+        this.lastTime = currentTime;
+        if (timer.isSleeping()) {
+            requestAnimationFrame(() => this.loop());
+            return;
+        }
+        timer.update(dt);
+        const { pressed, released, gamepadPressed, gamepadReleased } = input.update();
+        // Trigger action callbacks
+        if (this.currentScene?.handleEvent) {
+            for (const action of pressed) {
+                this.currentScene.handleEvent({ type: 'actionpressed', action });
+            }
+        }
+        if (this.currentScene?.handleEvent) {
+            for (const action of released) {
+                this.currentScene.handleEvent({ type: 'actionreleased', action });
+            }
+        }
+        // Trigger gamepad callbacks
+        if (this.currentScene?.handleEvent) {
+            for (const { gamepadIndex, buttonIndex, buttonName } of gamepadPressed) {
+                this.currentScene.handleEvent({ type: 'gamepadpressed', gamepadIndex, buttonIndex, buttonName });
+            }
+        }
+        if (this.currentScene?.handleEvent) {
+            for (const { gamepadIndex, buttonIndex, buttonName } of gamepadReleased) {
+                this.currentScene.handleEvent({ type: 'gamepadreleased', gamepadIndex, buttonIndex, buttonName });
+            }
+        }
+        this.currentScene.update(dt);
+        if (this.ctx) {
+            graphics.clear();
+            this.currentScene.draw();
+        }
+        requestAnimationFrame(() => this.loop());
+    }
+    getCanvas() {
+        return this.canvas;
+    }
+    getContext() {
+        return this.ctx;
+    }
+    getWidth() {
+        return this.currentWidth;
+    }
+    getHeight() {
+        return this.currentHeight;
+    }
+}
+export const like = new Like();
+export const love = like;
+export { Source } from './audio';
+export { timer } from './timer';
+export { ImageHandle } from './graphics';
+export { input } from './input';
+export { gamepad, getButtonName } from './gamepad';
+export { V2 } from './vector2';
+export { R } from './rect';

package/dist/input-state.d.ts

@@ -0,0 +1,14 @@
+export declare class InputStateTracker<T> {
+    private prevState;
+    private currState;
+    update(pressedKeys: Set<T>): {
+        justPressed: T[];
+        justReleased: T[];
+    };
+    isDown(key: T): boolean;
+    justPressed(key: T): boolean;
+    justReleased(key: T): boolean;
+    getCurrentState(): Set<T>;
+    clear(): void;
+}
+//# sourceMappingURL=input-state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"input-state.d.ts","sourceRoot":"","sources":["../src/input-state.ts"],"names":[],"mappings":"AAAA,qBAAa,iBAAiB,CAAC,CAAC;IAC9B,OAAO,CAAC,SAAS,CAAgB;IACjC,OAAO,CAAC,SAAS,CAAgB;IAEjC,MAAM,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,CAAC,GAAG;QAAE,WAAW,EAAE,CAAC,EAAE,CAAC;QAAC,YAAY,EAAE,CAAC,EAAE,CAAA;KAAE;IAuBpE,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIvB,WAAW,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAI5B,YAAY,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAI7B,eAAe,IAAI,GAAG,CAAC,CAAC,CAAC;IAIzB,KAAK,IAAI,IAAI;CAId"}

package/dist/input-state.js

@@ -0,0 +1,50 @@
+export class InputStateTracker {
+    constructor() {
+        Object.defineProperty(this, "prevState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "currState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+    }
+    update(pressedKeys) {
+        const justPressed = [];
+        const justReleased = [];
+        const nextState = new Set(pressedKeys);
+        for (const key of nextState) {
+            if (!this.currState.has(key)) {
+                justPressed.push(key);
+            }
+        }
+        for (const key of this.currState) {
+            if (!nextState.has(key)) {
+                justReleased.push(key);
+            }
+        }
+        this.prevState = new Set(this.currState);
+        this.currState = nextState;
+        return { justPressed, justReleased };
+    }
+    isDown(key) {
+        return this.currState.has(key);
+    }
+    justPressed(key) {
+        return !this.prevState.has(key) && this.currState.has(key);
+    }
+    justReleased(key) {
+        return this.prevState.has(key) && !this.currState.has(key);
+    }
+    getCurrentState() {
+        return new Set(this.currState);
+    }
+    clear() {
+        this.prevState.clear();
+        this.currState.clear();
+    }
+}

package/dist/input.d.ts

@@ -0,0 +1,36 @@
+export type InputType = 'keyboard' | 'mouse' | 'gamepad';
+export interface InputBinding {
+    type: InputType;
+    code: string;
+    gamepadIndex?: number;
+}
+export declare class Input {
+    private actionMap;
+    private actionStateTracker;
+    map(action: string, inputs: string[]): void;
+    unmap(action: string): void;
+    isDown(action: string): boolean;
+    justPressed(action: string): boolean;
+    justReleased(action: string): boolean;
+    update(): {
+        pressed: string[];
+        released: string[];
+        gamepadPressed: Array<{
+            gamepadIndex: number;
+            buttonIndex: number;
+            buttonName: string;
+            rawButtonIndex: number;
+        }>;
+        gamepadReleased: Array<{
+            gamepadIndex: number;
+            buttonIndex: number;
+            buttonName: string;
+            rawButtonIndex: number;
+        }>;
+    };
+    private parseInput;
+    private isBindingActive;
+    clear(): void;
+}
+export declare const input: Input;
+//# sourceMappingURL=input.d.ts.map

package/dist/input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../src/input.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,OAAO,GAAG,SAAS,CAAC;AAEzD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAaD,qBAAa,KAAK;IAChB,OAAO,CAAC,SAAS,CAAqC;IACtD,OAAO,CAAC,kBAAkB,CAAmC;IAE7D,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI;IAK3C,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAK3B,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAO/B,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIpC,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIrC,MAAM,IAAI;QACR,OAAO,EAAE,MAAM,EAAE,CAAC;QAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;QACnB,cAAc,EAAE,KAAK,CAAC;YAAE,YAAY,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,cAAc,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QACjH,eAAe,EAAE,KAAK,CAAC;YAAE,YAAY,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,cAAc,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KACnH;IAqBD,OAAO,CAAC,UAAU;IA8BlB,OAAO,CAAC,eAAe;IA6BvB,KAAK,IAAI,IAAI;CAId;AAED,eAAO,MAAM,KAAK,OAAc,CAAC"}

package/dist/input.js

@@ -0,0 +1,127 @@
+import { keyboard } from "./keyboard";
+import { mouse } from "./mouse";
+import { gamepad } from "./gamepad";
+import { InputStateTracker } from './input-state';
+import { getButtonIndex } from './gamepad-button-map';
+const buttonMap = {
+    'Left': 1,
+    'Right': 3,
+    'Middle': 2,
+    '1': 1,
+    '2': 2,
+    '3': 3,
+    '4': 4,
+    '5': 5,
+};
+export class Input {
+    constructor() {
+        Object.defineProperty(this, "actionMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "actionStateTracker", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new InputStateTracker()
+        });
+    }
+    map(action, inputs) {
+        const bindings = inputs.map(input => this.parseInput(input));
+        this.actionMap.set(action, bindings);
+    }
+    unmap(action) {
+        this.actionMap.delete(action);
+        this.actionStateTracker.clear();
+    }
+    isDown(action) {
+        const bindings = this.actionMap.get(action);
+        if (!bindings)
+            return false;
+        return bindings.some(binding => this.isBindingActive(binding));
+    }
+    justPressed(action) {
+        return this.actionStateTracker.justPressed(action);
+    }
+    justReleased(action) {
+        return this.actionStateTracker.justReleased(action);
+    }
+    update() {
+        const { pressed: gamepadPressed, released: gamepadReleased } = gamepad.update();
+        const activeActions = new Set();
+        for (const [action] of this.actionMap) {
+            if (this.isDown(action)) {
+                activeActions.add(action);
+            }
+        }
+        const { justPressed, justReleased } = this.actionStateTracker.update(activeActions);
+        return {
+            pressed: justPressed,
+            released: justReleased,
+            gamepadPressed,
+            gamepadReleased,
+        };
+    }
+    parseInput(input) {
+        const normalized = input.trim();
+        if (normalized.startsWith('Mouse')) {
+            const buttonCode = normalized.replace('Mouse', '');
+            return { type: 'mouse', code: buttonCode };
+        }
+        if (normalized.startsWith('GP')) {
+            // Format: GP ButtonBottom, GP LB, GP RT, etc. - any gamepad
+            // Format: GP0 ButtonBottom, GP1 LB, etc. - specific gamepad
+            const rest = normalized.slice(2); // Remove "GP" prefix
+            // Check if there's a gamepad index
+            const match = rest.match(/^(\d+)\s+(.+)$/);
+            if (match) {
+                // Specific gamepad: GP0 ButtonBottom
+                const gamepadIndex = parseInt(match[1], 10);
+                const buttonName = match[2].trim();
+                return { type: 'gamepad', code: buttonName, gamepadIndex };
+            }
+            else {
+                // Any gamepad: GP ButtonBottom
+                const buttonName = rest.trim();
+                return { type: 'gamepad', code: buttonName };
+            }
+        }
+        return { type: 'keyboard', code: normalized };
+    }
+    isBindingActive(binding) {
+        switch (binding.type) {
+            case 'keyboard':
+                return keyboard.isDown(binding.code);
+            case 'mouse': {
+                const button = buttonMap[binding.code];
+                if (button !== undefined) {
+                    return mouse.isDown(button);
+                }
+                return false;
+            }
+            case 'gamepad': {
+                const buttonIndex = getButtonIndex(binding.code);
+                if (buttonIndex !== undefined) {
+                    if (binding.gamepadIndex !== undefined) {
+                        // Check specific gamepad
+                        return gamepad.isButtonDown(binding.gamepadIndex, buttonIndex);
+                    }
+                    else {
+                        // Check any gamepad
+                        return gamepad.isButtonDownOnAny(buttonIndex);
+                    }
+                }
+                return false;
+            }
+            default:
+                return false;
+        }
+    }
+    clear() {
+        this.actionMap.clear();
+        this.actionStateTracker.clear();
+    }
+}
+export const input = new Input();

package/dist/keyboard.d.ts

@@ -0,0 +1,9 @@
+export declare class Keyboard {
+    private pressedScancodes;
+    constructor();
+    private setupEventListeners;
+    isDown(scancode: string): boolean;
+    isAnyDown(...scancodes: string[]): boolean;
+}
+export declare const keyboard: Keyboard;
+//# sourceMappingURL=keyboard.d.ts.map

package/dist/keyboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard.d.ts","sourceRoot":"","sources":["../src/keyboard.ts"],"names":[],"mappings":"AAAA,qBAAa,QAAQ;IACnB,OAAO,CAAC,gBAAgB,CAAqB;;IAM7C,OAAO,CAAC,mBAAmB;IAkB3B,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIjC,SAAS,CAAC,GAAG,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO;CAG3C;AAED,eAAO,MAAM,QAAQ,UAAiB,CAAC"}

package/dist/keyboard.js

@@ -0,0 +1,33 @@
+export class Keyboard {
+    constructor() {
+        Object.defineProperty(this, "pressedScancodes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        this.setupEventListeners();
+    }
+    setupEventListeners() {
+        window.addEventListener('keydown', (e) => {
+            if (e.code) {
+                this.pressedScancodes.add(e.code);
+            }
+        });
+        window.addEventListener('keyup', (e) => {
+            if (e.code) {
+                this.pressedScancodes.delete(e.code);
+            }
+        });
+        window.addEventListener('blur', () => {
+            this.pressedScancodes.clear();
+        });
+    }
+    isDown(scancode) {
+        return this.pressedScancodes.has(scancode);
+    }
+    isAnyDown(...scancodes) {
+        return scancodes.some(code => this.pressedScancodes.has(code));
+    }
+}
+export const keyboard = new Keyboard();

package/dist/mouse.d.ts

@@ -0,0 +1,20 @@
+import type { Vector2 } from './vector2';
+export declare class Mouse {
+    private x;
+    private y;
+    private buttons;
+    private canvas;
+    constructor();
+    setCanvas(canvas: HTMLCanvasElement): void;
+    private setupEventListeners;
+    getPosition(): Vector2;
+    getX(): number;
+    getY(): number;
+    isDown(button: number): boolean;
+    getPressedButtons(): Set<number>;
+    isVisible(): boolean;
+    setVisible(visible: boolean): void;
+    getRelativeMode(): boolean;
+}
+export declare const mouse: Mouse;
+//# sourceMappingURL=mouse.d.ts.map

package/dist/mouse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mouse.d.ts","sourceRoot":"","sources":["../src/mouse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,qBAAa,KAAK;IAChB,OAAO,CAAC,CAAC,CAAK;IACd,OAAO,CAAC,CAAC,CAAK;IACd,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,MAAM,CAAkC;;IAMhD,SAAS,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAI1C,OAAO,CAAC,mBAAmB;IAyB3B,WAAW,IAAI,OAAO;IAItB,IAAI,IAAI,MAAM;IAId,IAAI,IAAI,MAAM;IAId,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAI/B,iBAAiB,IAAI,GAAG,CAAC,MAAM,CAAC;IAIhC,SAAS,IAAI,OAAO;IAIpB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAQlC,eAAe,IAAI,OAAO;CAG3B;AAED,eAAO,MAAM,KAAK,OAAc,CAAC"}