like2d 2.8.0 → 2.10.0

package/dist/input/gamepad-mapping.js

@@ -0,0 +1,146 @@
+/**
+ * @module GamepadMapping
+ *
+ * A database, generated on module load,
+ * which uses SDL's database to coerce
+ * browser APIs into physical gamepad button
+ * mappings.
+ *
+ * Browser API shortcomings:
+ *  - No standard way of exposing vendor and product
+ *  - Almost nothing is standard
+ *  - Vendor and product alone doesn't suffice for GUID -- Different controllers have the same.
+ *  - D-pads either get mapped to an axis (last pair of axes in Chromium) or buttons (Firefox).
+ *  - Analog axes get mapped differently in Firefox and Chromium.
+ *
+ * How we overcome them:
+ *  - We parse out vendor and product based on currently known formats.
+ *  - We go with best-match and always fall back on manual mapping.
+ */
+/**
+ * ref: https://www.w3.org/TR/gamepad/#dfn-standard-gamepad
+ * note: `num` is only the corresponding number on standard mapping above.
+ *
+ * The point of the mapping system is to apply that _or_ non-standard mappings,
+ * Which are exceedingly common.
+ */
+const buttonMap = [
+    { sdl: "a", like: "BBottom", num: 0, name: "Bottom Face Button" },
+    { sdl: "b", like: "BRight", num: 1, name: "Right Face Button" },
+    { sdl: "x", like: "BLeft", num: 2, name: "Left Face Button" },
+    { sdl: "y", like: "BTop", num: 3, name: "Top Face Button" },
+    { sdl: "leftshoulder", like: "L1", num: 4, name: "Left shoulder (front)" },
+    { sdl: "rightshoulder", like: "R1", num: 5, name: "Right shoulder (front)" },
+    { sdl: "lefttrigger", like: "L2", num: 6, name: "Left shoulder (rear)" },
+    { sdl: "righttrigger", like: "R2", num: 7, name: "Right shoulder (rear)" },
+    { sdl: "back", like: "MenuLeft", num: 8, name: "Left Menu Button" },
+    { sdl: "start", like: "MenuRight", num: 9, name: "Right Menu Button" },
+    { sdl: "leftstick", like: "LeftStick", num: 10, name: "Left Stick Button" },
+    {
+        sdl: "rightstick",
+        like: "RightStick",
+        num: 11,
+        name: "Right Stick Button",
+    },
+    { sdl: "dpup", like: "Up", num: 12, name: "D-Pad Up" },
+    { sdl: "dpdown", like: "Down", num: 13, name: "D-Pad Down" },
+    { sdl: "dpleft", like: "Left", num: 14, name: "D-Pad Left" },
+    { sdl: "dpright", like: "Right", num: 15, name: "D-Pad right" },
+];
+export const defaultMapping = (stickCount) => ({
+    buttons: {},
+    sticks: Array(stickCount / 2)
+        .fill(0)
+        .map((_, i) => [
+        { index: i * 2, invert: false },
+        { index: i * 2 + 1, invert: false },
+    ]),
+});
+export const standardButtonMapping = () => Object.fromEntries(buttonMap.map(({ like, num }) => [num, like]));
+export const allButtons = new Set(buttonMap.map(({ like }) => like));
+export const fullButtonName = new Map(buttonMap.map(({ like, name }) => [like, name]));
+export const mapStick = (gp, mapping) => {
+    return mapping.map((axis) => (axis.invert ? -1 : 1) * (gp.axes[axis.index] ?? 0));
+};
+//// ************* SDL Gamepad auto-binding system ******************* ////
+// @ts-ignore
+import gamecontrollerdb from "../gamecontrollerdb.txt?raw";
+const sdlButtonSet = new Set(buttonMap.map(({ sdl }) => sdl));
+const sdlToLikeMap = new Map(buttonMap.map(({ sdl, like }) => [sdl, like]));
+const mappingDb = generateMappingDb(gamecontrollerdb);
+function generateMappingDb(db) {
+    const dbEntries = db
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((line) => line !== "" && !line.startsWith("#"))
+        .map(parseDbLine);
+    console.log(`[Gamepad] Parsed ${dbEntries.length} entries from DB`);
+    const mappingDb = Object.fromEntries(dbEntries);
+    console.log(`[Gamepad] Final entry count: ${Object.keys(mappingDb).length}`);
+    return mappingDb;
+}
+function parseDbLine(line) {
+    const [guid, name, ...mappings] = line.split(",");
+    mappings.pop();
+    const vpNum = 0x1 * parseInt(guid.substring(16, 18), 16) +
+        0x100 * parseInt(guid.substring(18, 20), 16) +
+        0x10000 * parseInt(guid.substring(8, 10), 16) +
+        0x1000000 * parseInt(guid.substring(10, 12), 16);
+    const mapping = Object.fromEntries(mappings
+        .map((s) => {
+        const [sdl, bname] = s.split(":");
+        const browserIndex = sdlRawButtonToBrowser(bname);
+        return (browserIndex !== undefined &&
+            sdlButtonSet.has(sdl) && [browserIndex, sdlToLikeMap.get(sdl)]);
+    })
+        .filter((v) => !!v));
+    return [vpNum, { name, mapping }];
+}
+function sdlRawButtonToBrowser(btn) {
+    return btn.startsWith("b")
+        ? Number(btn.substring(1))
+        : btn.startsWith("h")
+            ? { 1: 12, 2: 13, 4: 14, 8: 15 }[Number(btn.substring(3))]
+            : undefined;
+}
+export function getSdlMapping(gamepad) {
+    const parsed = tryParseId(gamepad.id);
+    if (parsed) {
+        const [vendorStr, productStr, nameStr] = parsed;
+        const vendor = parseInt(vendorStr, 16);
+        const product = parseInt(productStr, 16);
+        const name = nameStr.trim();
+        const mapping = mappingDb[vendor * 0x10000 + product];
+        if (mapping) {
+            console.log(`[Gamepad] Found SDL db mapping for '${name}'`);
+            return {
+                vendor,
+                product,
+                name,
+                sdlName: mapping.name,
+                mapping: mapping.mapping,
+            };
+        }
+        else {
+            console.log(`[Gamepad] No SDL db mapping found for '${gamepad.id}.`);
+        }
+    }
+    else {
+        console.log(`[Gamepad] Failed to parse id: ${gamepad.id}. Please report this bug with the name of your web browser.`);
+    }
+}
+function tryParseId(id) {
+    const infoC = id.match(/^([^(]+)\(Vendor: ([0-9a-f]+) Product: ([0-9a-f]+)/i);
+    if (infoC) {
+        // chrome pattern: Name(Vendor: VEND Product: PROD)
+        const [, name, vendor, product] = infoC;
+        return [vendor, product, name.trim()];
+    }
+    else {
+        // firefox pattern: VEND-PROD-Name
+        const infoF = id.split("-");
+        if (infoF.length == 3) {
+            return infoF;
+        }
+    }
+}

package/dist/input/gamepad.d.ts

@@ -0,0 +1,74 @@
+import { GamepadMapping, LikeButton } from './gamepad-mapping';
+import { type LikeGamepadEvent } from '../events';
+import { Vector2 } from '../math/vector2';
+import { EngineProps } from '../engine';
+/** A selector for a gamepad. */
+export type GamepadTarget = number | "any";
+/** LIKE Gamepad Wrapper
+ *
+ *  - Allows events/callbacks to be sent from joy buttons.
+ *  - Can track if any gamepad has a button pressed / just pressed.
+ *  - Remaps raw input numbers to readable strings -- by default using SDL database.
+ *
+ * If you're planning on supporting gamepads, please include a
+ * way to generate {@link GamepadMapping} and set it with {@link Gamepad.setMapping}.
+ *
+ * If you don't want to make your own, take a look at `prefab-scenes/mapGamepad`.
+ */
+export declare class Gamepad {
+    private dispatch;
+    private gamepads;
+    private autoLoadMapping;
+    constructor(props: EngineProps<LikeGamepadEvent>);
+    private onGamepadConnected;
+    /**
+     * @private
+     * Called by the engine every frame.
+     */
+    update(): void;
+    /**
+     *
+     * @param target Which controller?
+     * @returns all of the sticks. Convention is 0 = left, 1 = right.
+     */
+    getSticks(target: number): Vector2[];
+    fullButtonName(name: LikeButton): string;
+    private checkButton;
+    /** Check if a gamepad button is down. */
+    isDown(target: GamepadTarget, button: LikeButton | number): boolean | undefined;
+    /**
+     * Returns true for only one frame/update if a button is pressed.
+     * Considered an alternative to `like.gamepadpressed`.
+     */
+    justPressed(target: GamepadTarget, button: LikeButton | number): boolean | undefined;
+    /**
+     * Get a controller mapping.
+     * Note that modifying this mapping in place will modify the target controller.
+     * However, use `setMapping` to finalize the mapping.
+     */
+    getMapping(index: number): GamepadMapping | undefined;
+    /**
+     * Set the mapping for a particular controller.
+     *
+     * Set `save = false` if you don't want this written into localstorage.
+     */
+    setMapping(index: number, mapping: GamepadMapping, save?: boolean): void;
+    /**
+     * Get saved mapping from db, if it exists.
+     */
+    loadMapping(index: number): GamepadMapping | undefined;
+    /**
+     * Save a mapping to persistant storage
+     */
+    saveMapping(index: number, mapping: GamepadMapping): void;
+    /**
+     * Enable automatically loading mappings.
+     *
+     * When a gamepad with a known (to this system) ID is plugged in,
+     * this will load the previously saved mapping.
+     *
+     * @param enable
+     */
+    enableAutoLoadMapping(enable: boolean): void;
+}
+//# sourceMappingURL=gamepad.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gamepad.d.ts","sourceRoot":"","sources":["../../src/input/gamepad.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,cAAc,EAAiB,UAAU,EAAY,MAAM,mBAAmB,CAAC;AACxH,OAAO,EAAmB,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC;AACnE,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,gCAAgC;AAChC,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,KAAK,CAAC;AAE3C;;;;;;;;;;GAUG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,QAAQ,CAA+B;IAC/C,OAAO,CAAC,QAAQ,CAAoC;IACpD,OAAO,CAAC,eAAe,CAAQ;gBAEnB,KAAK,EAAE,WAAW,CAAC,gBAAgB,CAAC;IAgChD,OAAO,CAAC,kBAAkB;IA+B1B;;;OAGG;IACH,MAAM,IAAI,IAAI;IAId;;;;OAIG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,EAAE;IAQpC,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM;IAIxC,OAAO,CAAC,WAAW;IAYnB,yCAAyC;IACzC,MAAM,CACJ,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,UAAU,GAAG,MAAM,GAC1B,OAAO,GAAG,SAAS;IAItB;;;OAGG;IACH,WAAW,CACT,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,UAAU,GAAG,MAAM,GAC1B,OAAO,GAAG,SAAS;IAItB;;;;OAIG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAIrD;;;;OAIG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,EAAE,IAAI,UAAO;IAU9D;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAYtD;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc;IASlD;;;;;;;OAOG;IACH,qBAAqB,CAAC,MAAM,EAAE,OAAO;CAGtC"}

package/dist/input/gamepad.js

@@ -0,0 +1,288 @@
+import { defaultMapping, fullButtonName, getSdlMapping, mapStick } from './gamepad-mapping';
+/** LIKE Gamepad Wrapper
+ *
+ *  - Allows events/callbacks to be sent from joy buttons.
+ *  - Can track if any gamepad has a button pressed / just pressed.
+ *  - Remaps raw input numbers to readable strings -- by default using SDL database.
+ *
+ * If you're planning on supporting gamepads, please include a
+ * way to generate {@link GamepadMapping} and set it with {@link Gamepad.setMapping}.
+ *
+ * If you don't want to make your own, take a look at `prefab-scenes/mapGamepad`.
+ */
+export class Gamepad {
+    constructor(props) {
+        Object.defineProperty(this, "dispatch", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "gamepads", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "autoLoadMapping", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        this.dispatch = props.dispatch;
+        const { abort } = props;
+        // Register event listeners
+        window.addEventListener("gamepadconnected", this.onGamepadConnected.bind(this), {
+            signal: abort,
+        });
+        window.addEventListener("gamepaddisconnected", (ev) => {
+            console.log(`[Gamepad] Disconnected ${ev.gamepad.id}`);
+            delete this.gamepads[ev.gamepad.index];
+            this.dispatch("gamepaddisconnected", [ev.gamepad.index]);
+        }, { signal: abort });
+        window.addEventListener("blur", () => {
+            for (const gps of Object.values(this.gamepads)) {
+                gps.clear();
+            }
+        }, { signal: abort });
+    }
+    onGamepadConnected(ev) {
+        const gps = new GamepadState(ev.gamepad.index);
+        this.gamepads[ev.gamepad.index] = gps;
+        console.log(`[Gamepad] Connected ${ev.gamepad.id}. buttons: ${ev.gamepad.buttons.length}, axes: ${ev.gamepad.axes.length}`);
+        const mapping = this.loadMapping(ev.gamepad.index);
+        if (this.autoLoadMapping && mapping) {
+            gps.mapping = mapping;
+            console.log(`[Gamepad] Applied presaved mapping.`);
+        }
+        else if (ev.gamepad.mapping == 'standard') {
+            gps.mapping = defaultMapping(ev.gamepad.axes.length / 2);
+            console.log(`Loaded standard mapping.`);
+        }
+        else {
+            const sdlMapping = getSdlMapping(ev.gamepad);
+            if (sdlMapping) {
+                gps.mapping.buttons = sdlMapping.mapping;
+                console.log(`[Gamepad] Connected, applied SDL database mapping.`);
+            }
+            else {
+                console.log(`[Gamepad] Could not find mapping for gamepad. Consider remapping it.`);
+            }
+        }
+        this.dispatch("gamepadconnected", [ev.gamepad.index]);
+    }
+    /**
+     * @private
+     * Called by the engine every frame.
+     */
+    update() {
+        Object.values(this.gamepads).forEach((gp) => gp.update(this.dispatch));
+    }
+    /**
+     *
+     * @param target Which controller?
+     * @returns all of the sticks. Convention is 0 = left, 1 = right.
+     */
+    getSticks(target) {
+        const gp = this.gamepads[target];
+        if (gp) {
+            return gp.getSticks();
+        }
+        return [];
+    }
+    fullButtonName(name) {
+        return fullButtonName.get(name) ?? name;
+    }
+    checkButton(target, button, mode) {
+        if (target == "any") {
+            return Object.values(this.gamepads).some((gp) => gp[mode](button));
+        }
+        else {
+            return this.gamepads[target]?.[mode](button);
+        }
+    }
+    /** Check if a gamepad button is down. */
+    isDown(target, button) {
+        return this.checkButton(target, button, "isDown");
+    }
+    /**
+     * Returns true for only one frame/update if a button is pressed.
+     * Considered an alternative to `like.gamepadpressed`.
+     */
+    justPressed(target, button) {
+        return this.checkButton(target, button, "justPressed");
+    }
+    /**
+     * Get a controller mapping.
+     * Note that modifying this mapping in place will modify the target controller.
+     * However, use `setMapping` to finalize the mapping.
+     */
+    getMapping(index) {
+        return this.gamepads[index]?.mapping;
+    }
+    /**
+     * Set the mapping for a particular controller.
+     *
+     * Set `save = false` if you don't want this written into localstorage.
+     */
+    setMapping(index, mapping, save = true) {
+        const gp = this.gamepads[index];
+        if (gp) {
+            gp.mapping = mapping;
+            if (save) {
+                this.saveMapping(index, mapping);
+            }
+        }
+    }
+    /**
+     * Get saved mapping from db, if it exists.
+     */
+    loadMapping(index) {
+        const gp = navigator.getGamepads()?.[index];
+        if (gp) {
+            const path = getLocalstoragePath(gp);
+            console.log(`[Gamepad] Found saved mapping for ${gp.id}.`);
+            const item = localStorage.getItem(path);
+            if (item) {
+                return JSON.parse(item);
+            }
+        }
+    }
+    /**
+     * Save a mapping to persistant storage
+     */
+    saveMapping(index, mapping) {
+        const gp = navigator.getGamepads()?.[index];
+        if (gp) {
+            const path = getLocalstoragePath(gp);
+            console.log(`[Gamepad] Saved mapping ${path} to localStorage.`);
+            localStorage.setItem(path, JSON.stringify(mapping));
+        }
+    }
+    /**
+     * Enable automatically loading mappings.
+     *
+     * When a gamepad with a known (to this system) ID is plugged in,
+     * this will load the previously saved mapping.
+     *
+     * @param enable
+     */
+    enableAutoLoadMapping(enable) {
+        this.autoLoadMapping = enable;
+    }
+}
+function getLocalstoragePath(gamepad) {
+    return `${gamepad.axes.length}A${gamepad.buttons.length}B${gamepad.id}`;
+}
+const maxButtons = 64;
+/** Internal class: Using it externally could result
+ * in a gamepad being disconnected and still trying to maintain
+ * its state.
+ */
+class GamepadState {
+    constructor(index) {
+        Object.defineProperty(this, "index", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: index
+        });
+        Object.defineProperty(this, "mapping", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "downNums", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "lastDownNums", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "down", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "lastDown", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        const gp = navigator.getGamepads()[this.index];
+        this.mapping = defaultMapping(gp.axes.length);
+    }
+    isDown(button) {
+        return typeof (button) == "number" ? !!this.downNums[button] : !!this.down[button];
+    }
+    justPressed(button) {
+        return typeof (button) == "number" ?
+            (!!this.downNums[button] && !this.lastDownNums[button]) :
+            (!!this.down[button] && !this.lastDown[button]);
+    }
+    map(button) {
+        return (this.mapping.buttons[button] ??
+            (button < maxButtons
+                ? `Button${button}`
+                : `Axis${Math.floor((button - maxButtons) / 2)}${button % 2 ? "-" : "+"}`));
+    }
+    update(dispatch) {
+        const gp = navigator.getGamepads()[this.index];
+        if (!gp)
+            return;
+        [this.downNums, this.lastDownNums] = [this.lastDownNums, this.downNums];
+        for (const k in this.downNums) {
+            delete this.downNums[Number(k)];
+        }
+        gp.buttons.forEach((btn, i) => {
+            if (btn.pressed) {
+                this.downNums[i] = true;
+            }
+        });
+        gp.axes.forEach((axis, i) => {
+            const pos = Math.round(axis);
+            if (pos == 0)
+                return;
+            const index = 64 + i * 2 + (pos == -1 ? 1 : 0);
+            this.downNums[index] = true;
+        });
+        [this.down, this.lastDown] = [this.lastDown, this.down];
+        for (const k in this.down) {
+            delete this.down[k];
+        }
+        for (const i in this.downNums) {
+            const name = this.map(Number(i));
+            this.down[name] = true;
+            if (!this.lastDownNums[Number(i)]) {
+                dispatch("gamepadpressed", [this.index, name, Number(i)]);
+            }
+        }
+        for (const i in this.lastDownNums) {
+            if (!this.downNums[Number(i)]) {
+                const name = this.map(Number(i));
+                dispatch("gamepadreleased", [this.index, name, Number(i)]);
+            }
+        }
+    }
+    getSticks() {
+        const gp = navigator.getGamepads()[this.index];
+        return this.mapping.sticks.map((stick) => mapStick(gp, stick));
+    }
+    clear() {
+        for (const k in this.lastDown) {
+            delete this.lastDown[k];
+        }
+        for (const k in this.down) {
+            delete this.down[k];
+        }
+    }
+}

package/dist/input/index.d.ts

@@ -0,0 +1,6 @@
+export type { Input, InputType, InputBinding, } from "./input";
+export type { GamepadTarget, Gamepad, } from "./gamepad";
+export type { LikeButton, GamepadMapping, StickMapping, StickAxisMapping, } from "./gamepad-mapping";
+export { defaultMapping, allButtons } from "./gamepad-mapping";
+export type { MouseSetMode, Mouse, } from "./mouse";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/input/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,KAAK,EACL,SAAS,EACT,YAAY,GACb,MAAM,SAAS,CAAC;AAEjB,YAAY,EACV,aAAa,EACb,OAAO,GACR,MAAM,WAAW,CAAA;AAElB,YAAY,EACV,UAAU,EACV,cAAc,EACd,YAAY,EACZ,gBAAgB,GACjB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/D,YAAY,EACV,YAAY,EACZ,KAAK,GACN,MAAM,SAAS,CAAC"}

package/dist/input/index.js

@@ -0,0 +1 @@
+export { defaultMapping, allButtons } from "./gamepad-mapping";

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;IAiBN,OAAO,CAAC,eAAe;CAaxB"}