like2d 2.9.0 → 2.10.1

package/dist/like.d.ts

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

package/dist/like.d.ts.map

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

package/dist/like.js

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

package/dist/math/index.d.ts

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

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

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

package/dist/math/index.js

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

package/dist/math/rect.d.ts

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

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

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

package/dist/math/rect.js

@@ -1,88 +1,69 @@
 import { Vec2 } from '../math/vector2';
-/**
- * A set of
- */
-export var Rect;
-(function (Rect) {
-    function fromPoints(a, b) {
+export const Rect = {
+    fromPoints(a, b) {
         const minX = Math.min(a[0], b[0]);
         const minY = Math.min(a[1], b[1]);
         const maxX = Math.max(a[0], b[0]);
         const maxY = Math.max(a[1], b[1]);
         return [minX, minY, maxX - minX, maxY - minY];
-    }
-    Rect.fromPoints = fromPoints;
-    function fromCenter(center, size) {
+    },
+    fromCenter(center, size) {
         return [
             center[0] - size[0] / 2,
             center[1] - size[1] / 2,
             size[0],
             size[1],
         ];
-    }
-    Rect.fromCenter = fromCenter;
-    function position(r) {
+    },
+    position(r) {
         return [r[0], r[1]];
-    }
-    Rect.position = position;
-    function size(r) {
+    },
+    size(r) {
         return [r[2], r[3]];
-    }
-    Rect.size = size;
-    function center(r) {
+    },
+    center(r) {
         return [r[0] + r[2] / 2, r[1] + r[3] / 2];
-    }
-    Rect.center = center;
-    function topLeft(r) {
+    },
+    topLeft(r) {
         return [r[0], r[1]];
-    }
-    Rect.topLeft = topLeft;
-    function topRight(r) {
+    },
+    topRight(r) {
         return [r[0] + r[2], r[1]];
-    }
-    Rect.topRight = topRight;
-    function bottomLeft(r) {
+    },
+    bottomLeft(r) {
         return [r[0], r[1] + r[3]];
-    }
-    Rect.bottomLeft = bottomLeft;
-    function bottomRight(r) {
+    },
+    bottomRight(r) {
         return [r[0] + r[2], r[1] + r[3]];
-    }
-    Rect.bottomRight = bottomRight;
-    function area(r) {
+    },
+    area(r) {
         return r[2] * r[3];
-    }
-    Rect.area = area;
-    function isEmpty(r) {
+    },
+    isEmpty(r) {
         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) {
+    },
+    clampPoint(r, point) {
+        return Vec2.clamp(point, this.position(r), this.bottomRight(r));
+    },
+    containsPoint(r, point) {
         return (point[0] >= r[0] &&
             point[0] <= r[0] + r[2] &&
             point[1] >= r[1] &&
             point[1] <= r[1] + r[3]);
-    }
-    Rect.containsPoint = containsPoint;
-    function containsRect(r, other) {
+    },
+    containsRect(r, other) {
         return (other[0] >= r[0] &&
             other[0] + other[2] <= r[0] + r[2] &&
             other[1] >= r[1] &&
             other[1] + other[3] <= r[1] + r[3]);
-    }
-    Rect.containsRect = containsRect;
-    function intersects(r, other) {
+    },
+    intersects(r, other) {
         return (r[0] < other[0] + other[2] &&
             r[0] + r[2] > other[0] &&
             r[1] < other[1] + other[3] &&
             r[1] + r[3] > other[1]);
-    }
-    Rect.intersects = intersects;
-    function intersection(r, other) {
+    },
+    intersection(r, other) {
         const x1 = Math.max(r[0], other[0]);
         const y1 = Math.max(r[1], other[1]);
         const x2 = Math.min(r[0] + r[2], other[0] + other[2]);
@@ -93,44 +74,37 @@ export var Rect;
             return [0, 0, 0, 0];
         }
         return [x1, y1, w, h];
-    }
-    Rect.intersection = intersection;
-    function union(r, other) {
+    },
+    union(r, other) {
         const x1 = Math.min(r[0], other[0]);
         const y1 = Math.min(r[1], other[1]);
         const x2 = Math.max(r[0] + r[2], other[0] + other[2]);
         const y2 = Math.max(r[1] + r[3], other[1] + other[3]);
         return [x1, y1, x2 - x1, y2 - y1];
-    }
-    Rect.union = union;
-    function inflate(r, amount) {
+    },
+    inflate(r, amount) {
         return [
             r[0] - amount,
             r[1] - amount,
             r[2] + amount * 2,
             r[3] + amount * 2,
         ];
-    }
-    Rect.inflate = inflate;
-    function offset(r, delta) {
+    },
+    offset(r, delta) {
         return [r[0] + delta[0], r[1] + delta[1], r[2], r[3]];
-    }
-    Rect.offset = offset;
-    function setPosition(r, pos) {
+    },
+    setPosition(r, pos) {
         return [pos[0], pos[1], r[2], r[3]];
-    }
-    Rect.setPosition = setPosition;
-    function setSize(r, size) {
+    },
+    setSize(r, size) {
         return [r[0], r[1], size[0], size[1]];
-    }
-    Rect.setSize = setSize;
-    function setCenter(r, center) {
+    },
+    setCenter(r, center) {
         return [
             center[0] - r[2] / 2,
             center[1] - r[3] / 2,
             r[2],
             r[3],
         ];
-    }
-    Rect.setCenter = setCenter;
-})(Rect || (Rect = {}));
+    },
+};

package/dist/math/vector2.d.ts

@@ -1,3 +1,4 @@
+export type Pair<T> = [T, T];
 /** A pair of numbers `[x, y]`
  * representing for example:
  *  - position in 2D space
@@ -6,6 +7,11 @@
  *
  * See {@link Vec2} for full library.
  *
+ * Note that mutating Vector2 is allowed, but discouraged
+ * except for memory-demanding situations.
+ * 1. Setting `position[0]` has clunky syntax compared to the library
+ * 2. Any references to `position` will change their value.
+ *
  * ## Examples
  *
  * #### Constructing a Vector2
@@ -28,8 +34,8 @@
  *
  * #### Summing an array of Vector2
  * ```ts
- * const nums: Vector2[] = [[50, 100], [-5, -5], [0, 99]];
- * const sum = nums.reduce(Vec2.add);
+ * const vecs: Vector2[] = [[50, 100], [-5, -5], [0, 99]];
+ * const sum = vecs.reduce(Vec2.add);
  * ```
  *
  * #### Using LIKE graphics API
@@ -41,38 +47,87 @@
  * )
  * like.graphics.circle('fill', 'blue', pos, 20);
  * ```
+ *
+ * #### Getting the bounding box of an array of `Vector2`s
+ * ```ts
+ * const upperLeft = myVector2List.reduce(Vec2.min);
+ * const lowerRight = myVector2List.reduce(Vec2.max);
+ * const boundingBox = Rect.fromPoints(upperLeft, lowerRight);
+ * ```
+ *
+ * #### Squaring each element of a Vector2
+ * ```ts
+ * const squareVec2 = Vec2.map(a: number => a**2);
+ * squareVec2([6, 7]) // returns [36, 42]
+ * // one in one line...
+ * Vec2.map(a: number => a**2)([6, 7]);
+ * ```
+ *
  * */
-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): {
+export type Vector2 = Pair<number>;
+/**
+ * According to benchmarks, constructing funcs with these helpers is just as fast as loose coords in v8.
+ * Why not, then?
+ * If you're writing hyper-optimized Vector2 code, just use loose math anyway
+ * -- it will likely logically optimize down further, if you do the algebra.
+ */
+/** @see {@link Vec2.map} */
+declare function map2x1<I, O>(op: (a: I) => O): (a: Pair<I>) => Pair<O>;
+/** @see {@link Vec2.map2} */
+declare function map2x2<I, O>(op: (a: I, b: I) => O): (a: Pair<I>, b: I | Pair<I>) => Pair<O>;
+export declare const Vec2: {
+    /**
+     * Turn a unary function into a pair-wise unary function.
+     * @param op A function that takes one arg and returns something.
+     * @returns A function that takes a pair such as `[number, number]` (Vector2) and transforms it with `op`.
+     */
+    map: typeof map2x1;
+    /**
+     * Turn a binary function into a pair-wise binary function, for example one that operates on two `Vector2`s.
+     * @param op A function that takes two values and calculates one.
+     * @returns A function that runs `op` pair-wise on both arguments, constructing a new pair.
+     */
+    map2: typeof map2x2;
+    add: (a: Pair<number>, b: number | Pair<number>) => Pair<number>;
+    sub: (a: Pair<number>, b: number | Pair<number>) => Pair<number>;
+    mul: (a: Pair<number>, b: number | Pair<number>) => Pair<number>;
+    div: (a: Pair<number>, b: number | Pair<number>) => Pair<number>;
+    /** Returns the maximum of two coordinates,
+     * i.e. the lower right corner of a bounding box containing them. */
+    max: (a: Pair<number>, b: number | Pair<number>) => Pair<number>;
+    /** Returns the minimum of two coordinates,
+     * i.e. the upper left corner of a bounding box containing them. */
+    min: (a: Pair<number>, b: number | Pair<number>) => Pair<number>;
+    /** Apply a true modulus (i.e. where -1 % 3 == 2) to a Vector2.
+     *
+     * For JS-style modulus (who wants that?) use `Vec2.map2((a,b) => a % b)` */
+    mod: (a: Pair<number>, b: number | Pair<number>) => Pair<number>;
+    /** Apply deep (not referential) equality to a pair of Vec2s.
+     * @param epsilon Tolerance factor for inexact matches.
+     */
+    eq(v: Vector2, other: Vector2, epsilon: 0): boolean;
+    dot(a: Vector2, b: Vector2): number;
+    cross(a: Vector2, b: Vector2): number;
+    lengthSq(v: Vector2): number;
+    length(v: Vector2): number;
+    /** Set the length of a Vector2 to 1.0 while preserving its angle. */
+    normalize(v: Vector2): Vector2;
+    distance(a: Vector2, b: Vector2): number;
+    lerp(a: Vector2, b: Vector2, t: number): Vector2;
+    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;
-}
+    fromPolar(r: number, angle: number): Vector2;
+    angle(v: Vector2): number;
+    rotate(v: Vector2, angle: number): Vector2;
+    negate: (a: Pair<number>) => Pair<number>;
+    floor: (a: Pair<number>) => Pair<number>;
+    ceil: (a: Pair<number>) => Pair<number>;
+    round: (a: Pair<number>) => Pair<number>;
+    clamp(v: Vector2, min: Vector2, max: Vector2): Vector2;
+    fromAngle(angle: number, len?: number): Vector2;
+    zero(): Vector2;
+};
+export {};
 //# sourceMappingURL=vector2.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"vector2.d.ts","sourceRoot":"","sources":["../../src/math/vector2.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgEK;AAEL,MAAM,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;AAEnC;;;;;GAKG;AAEH,4BAA4B;AAC5B,iBAAS,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAE9D;AAED,6BAA6B;AAC7B,iBAAS,MAAM,CAAC,CAAC,EAAE,CAAC,EAClB,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,GACpB,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAKzC;AAED,eAAO,MAAM,IAAI;IACf;;;;OAIG;;IAEH;;;;OAIG;;;;;;IAOH;wEACoE;;IAEpE;uEACmE;;IAEnE;;gFAE4E;;IAG5E;;OAEG;UACG,OAAO,SAAS,OAAO,WAAW,CAAC,GAAG,OAAO;WAM5C,OAAO,KAAK,OAAO,GAAG,MAAM;aAI1B,OAAO,KAAK,OAAO,GAAG,MAAM;gBAIzB,OAAO,GAAG,MAAM;cAIlB,OAAO,GAAG,MAAM;IAI1B,qEAAqE;iBACxD,OAAO,GAAG,OAAO;gBAMlB,OAAO,KAAK,OAAO,GAAG,MAAM;YAIhC,OAAO,KAAK,OAAO,KAAK,MAAM,GAAG,OAAO;eAIrC,OAAO,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE;iBAOpC,MAAM,SAAS,MAAM,GAAG,OAAO;aAInC,OAAO,GAAG,MAAM;cAIf,OAAO,SAAS,MAAM,GAAG,OAAO;;;;;aAWjC,OAAO,OAAO,OAAO,OAAO,OAAO,GAAG,OAAO;qBAOrC,MAAM,QAAO,MAAM,GAAO,OAAO;YAI1C,OAAO;CAGhB,CAAC"}