like2d 2.8.0 → 2.9.0

package/dist/math/vector2.d.ts

@@ -0,0 +1,78 @@
+/** A pair of numbers `[x, y]`
+ * representing for example:
+ *  - position in 2D space
+ *  - width and height
+ *  - velocity
+ *
+ * See {@link Vec2} for full library.
+ *
+ * ## Examples
+ *
+ * #### Constructing a Vector2
+ * ```ts
+ * const onionSize: Vector2 = [width, height];
+ * ```
+ *
+ * #### Deconstructing a Vector2
+ * ```ts
+ * const [width, height] = onionSize;
+ * ```
+ *
+ * #### Making math less repetitive.
+ * ```ts
+ * x += dx * speed;
+ * y += dy * speed;
+ * // becomes...
+ * pos = Vec2.add(pos, Vec2.mul(delta, speed))
+ * ```
+ *
+ * #### Summing an array of Vector2
+ * ```ts
+ * const nums: Vector2[] = [[50, 100], [-5, -5], [0, 99]];
+ * const sum = nums.reduce(Vec2.add);
+ * ```
+ *
+ * #### Using LIKE graphics API
+ * ```ts
+ * // Draw a circle in the center of the canvas.
+ * const pos = Vec2.div(
+ *   like.canvas.getSize(),
+ *   2,
+ * )
+ * like.graphics.circle('fill', 'blue', pos, 20);
+ * ```
+ * */
+export type Vector2 = [number, number];
+/** Library of Vec2 functions. See {@link Vector2} for overview. */
+export declare namespace Vec2 {
+    function add(a: Vector2, b: Vector2): Vector2;
+    function sub(a: Vector2, b: Vector2): Vector2;
+    function mul(v: Vector2, other: Vector2 | number): Vector2;
+    function div(v: Vector2, other: Vector2 | number): Vector2;
+    function mod(v: Vector2, other: Vector2 | number): Vector2;
+    function eq(v: Vector2, other: Vector2): boolean;
+    function dot(a: Vector2, b: Vector2): number;
+    function cross(a: Vector2, b: Vector2): number;
+    function lengthSq(v: Vector2): number;
+    function length(v: Vector2): number;
+    function normalize(v: Vector2): Vector2;
+    function distance(a: Vector2, b: Vector2): number;
+    function lerp(a: Vector2, b: Vector2, t: number): Vector2;
+    function toPolar(v: Vector2): {
+        r: number;
+        angle: number;
+    };
+    function fromPolar(r: number, angle: number): Vector2;
+    function angle(v: Vector2): number;
+    function rotate(v: Vector2, angle: number): Vector2;
+    function negate(v: Vector2): Vector2;
+    function floor(v: Vector2): Vector2;
+    function ceil(v: Vector2): Vector2;
+    function round(v: Vector2): Vector2;
+    function min(a: Vector2, b: Vector2): Vector2;
+    function max(a: Vector2, b: Vector2): Vector2;
+    function clamp(v: Vector2, min: Vector2, max: Vector2): Vector2;
+    function fromAngle(angle: number, len?: number): Vector2;
+    function zero(): Vector2;
+}
+//# sourceMappingURL=vector2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vector2.d.ts","sourceRoot":"","sources":["../../src/math/vector2.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA2CK;AACL,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEvC,mEAAmE;AACnE,yBAAiB,IAAI,CAAC;IACpB,SAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAEnD;IAED,SAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAEnD;IAED,SAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,CAKhE;IAED,SAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,CAKhE;IAED,SAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,CAKhE;IAED,SAAgB,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAEtD;IAED,SAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAElD;IAED,SAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAEpD;IAED,SAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAE3C;IAED,SAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAEzC;IAED,SAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAI7C;IAED,SAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAEvD;IAED,SAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAE/D;IAED,SAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAKhE;IAED,SAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAE3D;IAED,SAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAExC;IAED,SAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAIzD;IAED,SAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAE1C;IAED,SAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAEzC;IAED,SAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAExC;IAED,SAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAEzC;IAED,SAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAEnD;IAED,SAAgB,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAEnD;IAED,SAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,GAAG,OAAO,CAKrE;IAED,SAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,GAAE,MAAU,GAAG,OAAO,CAEjE;IAED,SAAgB,IAAI,IAAI,OAAO,CAE9B;CACF"}

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

@@ -1,3 +1,5 @@
+import { mod as mmod } from ".";
+/** Library of Vec2 functions. See {@link Vector2} for overview. */
 export var Vec2;
 (function (Vec2) {
     function add(a, b) {
@@ -22,6 +24,17 @@ export var Vec2;
         return [v[0] / other[0], v[1] / other[1]];
     }
     Vec2.div = div;
+    function mod(v, other) {
+        if (typeof other === 'number') {
+            return [mmod(v[0], other), mmod(v[1], other)];
+        }
+        return [mmod(v[0], other[0]), mmod(v[1], other[1])];
+    }
+    Vec2.mod = mod;
+    function eq(v, other) {
+        return v[0] == other[0] && v[1] == other[1];
+    }
+    Vec2.eq = eq;
     function dot(a, b) {
         return a[0] * b[0] + a[1] * b[1];
     }
@@ -53,6 +66,17 @@ export var Vec2;
         return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
     }
     Vec2.lerp = lerp;
+    function toPolar(v) {
+        return {
+            r: Vec2.length(v),
+            angle: Vec2.angle(v),
+        };
+    }
+    Vec2.toPolar = toPolar;
+    function fromPolar(r, angle) {
+        return [r * Math.cos(angle), r * Math.sin(angle)];
+    }
+    Vec2.fromPolar = fromPolar;
     function angle(v) {
         return Math.atan2(v[1], v[0]);
     }

package/dist/prefab-scenes/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module prefab-scenes
+ *
+ * A set of built-in scenes to aid with game development.
+ */
+export { StartScreen } from "./startScreen";
+//# sourceMappingURL=index.d.ts.map

package/dist/prefab-scenes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/prefab-scenes/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}

package/dist/prefab-scenes/index.js

@@ -0,0 +1,6 @@
+/**
+ * @module prefab-scenes
+ *
+ * A set of built-in scenes to aid with game development.
+ */
+export { StartScreen } from "./startScreen";

package/dist/prefab-scenes/startScreen.d.ts

@@ -0,0 +1,59 @@
+import { type Scene } from '../scene';
+import { Like } from '..';
+/**
+ * ## Why
+ *
+ *  1. Because the LIKE logo looks awesome.
+ *  2. Autoplay restriction, doesn't let you play audio until the page is clicked.
+ *  3. You have to click on the game in order to send inputs, anyway.
+ *  4. It's polite.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { createLike, StartScreen } from 'like';
+ * import { GameScene } from './game';
+ *
+ * const container = document.getElementById("myGame");
+ * const like = createLike(container);
+ *
+ * // these callbacks will be ignored until the scene is clicked
+ * like.update = function () { ... }
+ * like.draw = function () { ... }
+ *
+ * // Set up the start screen
+ * like.setScene(new StartScreen())
+ * like.start();
+ * ```
+ *
+ * Alternatively, copy-paste this code into your own project and modify it freely.
+ * Update imports:
+ *
+ * ```ts
+ * import { type Scene } from 'like/scene';
+ * import type { ImageHandle } from 'like/core/graphics';
+ * import { Vec2 } from 'like/math/vector2';
+ * import { Like } from 'like';
+ * ```
+ *
+ * ## Custom Rendering
+ *
+ * Pass a custom draw function to replace the default logo:
+ *
+ * ```typescript
+ * const startup = new StartupScene(gameScene, (like) => {
+ *   like.gfx.clear([0, 0, 0, 1]);
+ *   like.gfx.print([1, 1, 1], 'Click to Start', [100, 100]);
+ * });
+ * ```
+ */
+export declare class StartScreen implements Scene {
+    private next;
+    private onDraw?;
+    private logo;
+    constructor(next: Scene, onDraw?: ((like: Like) => void) | undefined);
+    load(like: Like): void;
+    draw(like: Like): void;
+    mousepressed(like: Like): void;
+}
+//# sourceMappingURL=startScreen.d.ts.map

package/dist/prefab-scenes/startScreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startScreen.d.ts","sourceRoot":"","sources":["../../src/prefab-scenes/startScreen.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,UAAU,CAAC;AAGtC,OAAO,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAI1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,qBAAa,WAAY,YAAW,KAAK;IAIrC,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,MAAM,CAAC;IAJjB,OAAO,CAAC,IAAI,CAAe;gBAGjB,IAAI,EAAE,KAAK,EACX,MAAM,CAAC,GAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,aAAA;IAGvC,IAAI,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAItB,IAAI,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAWtB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;CAG/B"}

package/dist/{scenes/startup.js → prefab-scenes/startScreen.js}

@@ -1,13 +1,53 @@
-import { Vec2 } from '../core/vector2';
+import { Vec2 } from '../math/vector2';
 const LOGO = 'data:image/svg+xml;base64,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';
 /**
- * A simple startup scene that waits for a mouse click before advancing.
+ * ## Why
  *
- * This exists to work around browser autoplay restrictions - browsers require
- * user interaction (like a click) before allowing audio playback. Show this
- * scene first, then transition to your game scene on click.
+ *  1. Because the LIKE logo looks awesome.
+ *  2. Autoplay restriction, doesn't let you play audio until the page is clicked.
+ *  3. You have to click on the game in order to send inputs, anyway.
+ *  4. It's polite.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { createLike, StartScreen } from 'like';
+ * import { GameScene } from './game';
+ *
+ * const container = document.getElementById("myGame");
+ * const like = createLike(container);
+ *
+ * // these callbacks will be ignored until the scene is clicked
+ * like.update = function () { ... }
+ * like.draw = function () { ... }
+ *
+ * // Set up the start screen
+ * like.setScene(new StartScreen())
+ * like.start();
+ * ```
+ *
+ * Alternatively, copy-paste this code into your own project and modify it freely.
+ * Update imports:
+ *
+ * ```ts
+ * import { type Scene } from 'like/scene';
+ * import type { ImageHandle } from 'like/core/graphics';
+ * import { Vec2 } from 'like/math/vector2';
+ * import { Like } from 'like';
+ * ```
+ *
+ * ## Custom Rendering
+ *
+ * Pass a custom draw function to replace the default logo:
+ *
+ * ```typescript
+ * const startup = new StartupScene(gameScene, (like) => {
+ *   like.gfx.clear([0, 0, 0, 1]);
+ *   like.gfx.print([1, 1, 1], 'Click to Start', [100, 100]);
+ * });
+ * ```
  */
-export class StartupScene {
+export class StartScreen {
     constructor(next, onDraw) {
         Object.defineProperty(this, "next", {
             enumerable: true,
@@ -37,12 +77,12 @@ export class StartupScene {
         }
         else if (this.logo.isReady()) {
             like.gfx.clear([0.05, 0.05, 0.08, 1]);
-            const winSize = like.gfx.getCanvasSize();
+            const winSize = like.canvas.getSize();
             const scale = (winSize[0] * 0.5) / this.logo.size[0];
             like.gfx.draw(this.logo, Vec2.div(winSize, 2), { scale, origin: Vec2.div(this.logo.size, 2) });
         }
     }
-    mousepressed(like, _pos, _button) {
+    mousepressed(like) {
         like.setScene(this.next);
     }
 }

package/dist/scene.d.ts

@@ -1,10 +1,108 @@
-import type { Like2DEvent, EventMap, EventType } from './core/events';
+/**
+ * @module scene
+ * @description A helpful callback / state management layer, plus utility scenes.
+ *
+ */
+import type { LikeEvent, EventMap } from './core/events';
 import type { Like } from './core/like';
-type EventHandler<K extends EventType> = (like: Like, ...args: EventMap[K]) => void;
+/**
+ * An interface for creating scenes.
+ *
+ * ## Why Scenes?
+ *
+ * For any game with more than one scene, we have to either:
+ *  - switch-case on game state in every single callback
+ *  - rebind all of the callbacks ourselves
+ *  - wrap handleEvent (hint: that's what this does)
+ *
+ * Also, some no need to pass around a `like` object.
+ * Here, `like` instead piggybacks on a closure that follows around
+ * your running scene and shows up as an additional first argument
+ * to every callback.
+ *
+ * ## Quick Start
+ *
+ * Have a scene handle all the callbacks, disabling global
+ * callbacks.
+ * ```typescript
+ * // set up a scene
+ * class MagicalGrowingRectangle extends Scene {
+ *   rectangleSize = 10;
+ *   constructor() {}
+ *
+ *   keypressed(_like: Like) {
+ *     this.rectangleSize += 10;
+ *   }
+ *
+ *   draw(like: Like) {
+ *     like.gfx.rectangle('fill', 'green',
+ *       [10, 10, this.rectangleSize, this.rectangleSize])
+ *   }
+ * }
+ *
+ * like.setScene(new MagicalGrowingRectangle());
+ * ```
+ *
+ * To get back to global callbacks, just use `like.handleEvent = undefined`
+ *
+ * ## Scene Lifecycle
+ *
+ * Works a lot like global callbacks.
+ *
+ * 1. `like.setScene(scene)` is called
+ * 2. Scene's `load` callback fires immediately
+ * 3. `update` and `draw` begin on next frame
+ * 4. Scene receives input events as they occur
+ *
+ * ## Composing scenes
+ *
+ * Thought you'd never ask.
+ * Just like the `like` object, scenes have handleEvent on them.
+ * So, you could layer them like this, for example:
+ *
+ * ```typescript
+ * class UI implements Scene {
+ *   constructor(public game: Game) {}
+ *
+ *   handleEvent(like: Like, event: Like2DEvent) {
+ *     // Block mouse events in order to create a top bar.
+ *     const mouseY = like.mouse.getPosition()[1];
+ *     if (!event.type.startsWith('mouse') || mouseY > 100) {
+ *       sceneDispatch(this.game, like, event);
+ *     }
+ *
+ *     // Then, call my own callbacks.
+ *     // By calling it here, the UI draws on top.
+ *     callSceneHandlers(this, like, event);
+ *   }
+ *   ...
+ * }
+ *
+ * class Game implements Scene {
+ *   ...
+ * }
+ *
+ * like.setScene(new UI(new Game()))
+ * ```
+ *
+ * Composing scenes lets you filter events, layer game elements,
+ * and more. Don't sleep on it.
+ */
 export type Scene = {
-    [K in EventType]?: EventHandler<K>;
+    [K in keyof EventMap]?: (like: Like, ...args: EventMap[K]) => void;
 } & {
-    handleEvent?(like: Like, event: Like2DEvent): void;
+    handleEvent?(like: Like, event: LikeEvent): void;
 };
-export {};
+/**
+ * Used to call a scene's own handlers like `update` or `draw`,
+ * typically at the end of handleEvent
+ * after modifying the event stream or composing sub-scenes.
+ */
+export declare const callSceneHandlers: (scene: Scene, like: Like, event: LikeEvent) => void;
+/**
+ * Used to call sub scenes while respecting potential `handleEvent` within them.
+ * The main scene is similar to a sub-scene of the root (like) object in this
+ * regard.
+ */
+export declare const sceneDispatch: (scene: Scene, like: Like, event: LikeEvent) => void;
 //# sourceMappingURL=scene.d.ts.map

package/dist/scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../src/scene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACtE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,KAAK,YAAY,CAAC,CAAC,SAAS,SAAS,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;AAEpF,MAAM,MAAM,KAAK,GAAG;KACjB,CAAC,IAAI,SAAS,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC;CACnC,GAAG;IACF,WAAW,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;CACpD,CAAC"}
+{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../src/scene.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AAEH,MAAM,MAAM,KAAK,GAAG;KACjB,CAAC,IAAI,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI;CACnE,GAAG;IACF,WAAW,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;CAClD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,KAAK,EAAE,MAAM,IAAI,EAAE,OAAO,SAAS,SAI3E,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,KAAK,EAAE,MAAM,IAAI,EAAE,OAAO,SAAS,SAMvE,CAAA"}

package/dist/scene.js

@@ -1 +1,28 @@
-export {};
+/**
+ * @module scene
+ * @description A helpful callback / state management layer, plus utility scenes.
+ *
+ */
+/**
+ * Used to call a scene's own handlers like `update` or `draw`,
+ * typically at the end of handleEvent
+ * after modifying the event stream or composing sub-scenes.
+ */
+export const callSceneHandlers = (scene, like, event) => {
+    if (event.type in scene) {
+        scene[event.type](like, ...event.args);
+    }
+};
+/**
+ * Used to call sub scenes while respecting potential `handleEvent` within them.
+ * The main scene is similar to a sub-scene of the root (like) object in this
+ * regard.
+ */
+export const sceneDispatch = (scene, like, event) => {
+    if (scene.handleEvent) {
+        scene.handleEvent(like, event);
+    }
+    else {
+        callSceneHandlers(scene, like, event);
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "like2d",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "description": "A web-native game framework inspired by Love2D",
   "type": "module",
   "main": "./dist/index.js",
@@ -10,6 +10,22 @@
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
+    },
+    "./scene": {
+      "import": "./dist/scene.js",
+      "types": "./dist/scene.d.ts"
+    },
+    "./math/*": {
+      "import": "./dist/math/*.js",
+      "types": "./dist/math/*.d.ts"
+    },
+    "./prefab-scenes": {
+      "import": "./dist/prefab-scenes/index.js",
+      "types": "./dist/prefab-scenes/index.d.ts"
+    },
+    "./internal/*": {
+      "import": "./dist/core/*.js",
+      "types": "./dist/core/*.d.ts"
     }
   },
   "files": [
@@ -19,7 +35,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsc && cp src/gamecontrollerdb.txt dist/",
+    "build": "tsc",
     "typecheck": "tsc --noEmit",
     "lint": "echo 'No linting configured'",
     "clean": "rm -rf dist",

package/dist/core/canvas-config.d.ts

@@ -1,22 +0,0 @@
-import type { Vector2 } from './vector2';
-export type CanvasMode = {
-    pixelResolution: Vector2 | null;
-    fullscreen: boolean;
-};
-export type PartialCanvasMode = {
-    pixelResolution?: Vector2 | null;
-    fullscreen?: boolean;
-};
-/**
- * Calculate the scale and offset for rendering fixed-size content to a target canvas.
- * This is useful when you want to render in "native" mode but maintain a fixed game resolution.
- *
- * @param canvasSize - The actual canvas size in pixels
- * @param gameSize - The desired game resolution (fixed size)
- * @returns Object containing the scale factor and offset for centering
- */
-export declare function calcFixedScale(canvasSize: Vector2, gameSize: Vector2): {
-    scale: number;
-    offset: Vector2;
-};
-//# sourceMappingURL=canvas-config.d.ts.map

package/dist/core/canvas-config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"canvas-config.d.ts","sourceRoot":"","sources":["../../src/core/canvas-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,MAAM,MAAM,UAAU,GAAG;IACvB,eAAe,EAAE,OAAO,GAAG,IAAI,CAAC;IAChC,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,eAAe,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACjC,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CAKzG"}

package/dist/core/canvas-config.js

@@ -1,14 +0,0 @@
-/**
- * Calculate the scale and offset for rendering fixed-size content to a target canvas.
- * This is useful when you want to render in "native" mode but maintain a fixed game resolution.
- *
- * @param canvasSize - The actual canvas size in pixels
- * @param gameSize - The desired game resolution (fixed size)
- * @returns Object containing the scale factor and offset for centering
- */
-export function calcFixedScale(canvasSize, gameSize) {
-    const scale = Math.min(canvasSize[0] / gameSize[0], canvasSize[1] / gameSize[1]);
-    const scaledGame = [gameSize[0] * scale, gameSize[1] * scale];
-    const offset = [(canvasSize[0] - scaledGame[0]) * 0.5, (canvasSize[1] - scaledGame[1]) * 0.5];
-    return { scale, offset };
-}

package/dist/core/canvas-manager.d.ts

@@ -1,32 +0,0 @@
-import type { CanvasMode, PartialCanvasMode } from './canvas-config';
-import { type Vector2 } from './vector2';
-export declare class CanvasManager {
-    private canvas;
-    private container;
-    private ctx;
-    private config;
-    private resizeObserver;
-    private pixelCanvas;
-    private pixelCtx;
-    private onWindowResize;
-    onResize: ((size: Vector2, pixelSize: Vector2, fullscreen: boolean) => void) | null;
-    constructor(canvas: HTMLCanvasElement, container: HTMLElement, ctx: CanvasRenderingContext2D, config?: CanvasMode);
-    private listenForPixelRatioChanges;
-    setMode(mode: PartialCanvasMode): void;
-    getMode(): CanvasMode;
-    private applyConfig;
-    private applyPixelMode;
-    private applyNativeMode;
-    dispose(): void;
-    present(): void;
-    getDisplayCanvas(): HTMLCanvasElement;
-    /** Canvas to render to. Pixel canvas in pixel mode, display canvas otherwise. */
-    getRenderTarget(): {
-        canvas: HTMLCanvasElement;
-        ctx: CanvasRenderingContext2D;
-    };
-    /** Render target size in pixels. Pixel resolution in pixel mode, scaled size otherwise. */
-    getCanvasSize(): Vector2;
-    transformMousePosition(offsetX: number, offsetY: number): Vector2;
-}
-//# sourceMappingURL=canvas-manager.d.ts.map

package/dist/core/canvas-manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"canvas-manager.d.ts","sourceRoot":"","sources":["../../src/core/canvas-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACrE,OAAO,EAAQ,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAmB/C,qBAAa,aAAa;IAUtB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,GAAG;IACX,OAAO,CAAC,MAAM;IAZhB,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,WAAW,CAAkC;IACrD,OAAO,CAAC,QAAQ,CAAyC;IAEzD,OAAO,CAAC,cAAc,CAA4B;IAE3C,QAAQ,EAAE,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,KAAK,IAAI,CAAC,GAAG,IAAI,CAAQ;gBAGxF,MAAM,EAAE,iBAAiB,EACzB,SAAS,EAAE,WAAW,EACtB,GAAG,EAAE,wBAAwB,EAC7B,MAAM,GAAE,UAAyD;IAW3E,OAAO,CAAC,0BAA0B;IAQlC,OAAO,CAAC,IAAI,EAAE,iBAAiB,GAAG,IAAI;IAKtC,OAAO,IAAI,UAAU;IAIrB,OAAO,CAAC,WAAW;IAwBnB,OAAO,CAAC,cAAc;IAqBtB,OAAO,CAAC,eAAe;IAkBvB,OAAO,IAAI,IAAI;IAQf,OAAO,IAAI,IAAI;IAaf,gBAAgB,IAAI,iBAAiB;IAIrC,iFAAiF;IACjF,eAAe,IAAI;QAAE,MAAM,EAAE,iBAAiB,CAAC;QAAC,GAAG,EAAE,wBAAwB,CAAA;KAAE;IAO/E,2FAA2F;IAC3F,aAAa,IAAI,OAAO;IAKxB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO;CAYlE"}