@flare-engine/input 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -1,42 +1,6 @@
-import { Vec2 } from '@flare-engine/math';
-import { Signal } from '@flare-engine/events';
-
-/** State of a single pointer (primary touch or mouse). */
-interface Pointer {
-    /** Current position in screen coordinates. */
-    position: Vec2;
-    /** Position delta since last frame. */
-    delta: Vec2;
-    /** Whether the pointer is currently held down. */
-    isDown: boolean;
-    /** True only on the frame the pointer was pressed. */
-    justPressed: boolean;
-    /** True only on the frame the pointer was released. */
-    justReleased: boolean;
-}
-/** State of a single touch point in a multitouch scenario. */
-interface TouchPoint {
-    /** Unique touch identifier. */
-    id: number;
-    /** Current position in screen coordinates. */
-    position: Vec2;
-    /** Whether this touch is currently active. */
-    isDown: boolean;
-}
-/** Create a default pointer state. */
-declare function createPointer(): Pointer;
-/**
- * Update pointer state for a new frame.
- * Call this at the start of each frame to clear per-frame flags.
- */
-declare function resetPointerFrame(pointer: Pointer): void;
-/** Feed a pointer-down event into the pointer state. */
-declare function pointerDown(pointer: Pointer, x: number, y: number): void;
-/** Feed a pointer-move event into the pointer state. */
-declare function pointerMove(pointer: Pointer, x: number, y: number): void;
-/** Feed a pointer-up event into the pointer state. */
-declare function pointerUp(pointer: Pointer, x: number, y: number): void;
-
+import { Signal } from "@flare-engine/events";
+import { Vec2 } from "@flare-engine/math";
+//#region src/gamepad.d.ts
 /**
  * Gamepad — poll-based state for a single connected controller.
  *
@@ -46,60 +10,60 @@ declare function pointerUp(pointer: Pointer, x: number, y: number): void;
  */
 /** W3C Standard Gamepad button indices. */
 declare const GamepadButton: {
-    readonly A: 0;
-    readonly B: 1;
-    readonly X: 2;
-    readonly Y: 3;
-    readonly LB: 4;
-    readonly RB: 5;
-    readonly LT: 6;
-    readonly RT: 7;
-    readonly Back: 8;
-    readonly Start: 9;
-    readonly LS: 10;
-    readonly RS: 11;
-    readonly DpadUp: 12;
-    readonly DpadDown: 13;
-    readonly DpadLeft: 14;
-    readonly DpadRight: 15;
-    readonly Home: 16;
+  readonly A: 0;
+  readonly B: 1;
+  readonly X: 2;
+  readonly Y: 3;
+  readonly LB: 4;
+  readonly RB: 5;
+  readonly LT: 6;
+  readonly RT: 7;
+  readonly Back: 8;
+  readonly Start: 9;
+  readonly LS: 10;
+  readonly RS: 11;
+  readonly DpadUp: 12;
+  readonly DpadDown: 13;
+  readonly DpadLeft: 14;
+  readonly DpadRight: 15;
+  readonly Home: 16;
 };
 type GamepadButtonId = (typeof GamepadButton)[keyof typeof GamepadButton];
 /** W3C Standard Gamepad axes. */
 declare const GamepadAxis: {
-    readonly LeftX: 0;
-    readonly LeftY: 1;
-    readonly RightX: 2;
-    readonly RightY: 3;
+  readonly LeftX: 0;
+  readonly LeftY: 1;
+  readonly RightX: 2;
+  readonly RightY: 3;
 };
 type GamepadAxisId = (typeof GamepadAxis)[keyof typeof GamepadAxis];
 interface GamepadButtonState {
-    pressed: boolean;
-    value: number;
-    /** True for exactly one frame after a press. */
-    pressedThisFrame: boolean;
-    /** True for exactly one frame after a release. */
-    releasedThisFrame: boolean;
+  pressed: boolean;
+  value: number;
+  /** True for exactly one frame after a press. */
+  pressedThisFrame: boolean;
+  /** True for exactly one frame after a release. */
+  releasedThisFrame: boolean;
 }
 interface GamepadState {
-    connected: boolean;
-    id: string;
-    index: number;
-    buttons: GamepadButtonState[];
-    axes: number[];
-    /** Monotonically increasing timestamp from the source (ms). */
-    timestamp: number;
+  connected: boolean;
+  id: string;
+  index: number;
+  buttons: GamepadButtonState[];
+  axes: number[];
+  /** Monotonically increasing timestamp from the source (ms). */
+  timestamp: number;
 }
 /** Raw snapshot from a `GamepadSource` — values only, no derived state. */
 interface GamepadSnapshot {
-    id: string;
-    index: number;
-    buttons: {
-        pressed: boolean;
-        value: number;
-    }[];
-    axes: number[];
-    timestamp: number;
+  id: string;
+  index: number;
+  buttons: {
+    pressed: boolean;
+    value: number;
+  }[];
+  axes: number[];
+  timestamp: number;
 }
 declare function createGamepadState(index?: number, buttonCount?: number, axisCount?: number): GamepadState;
 /**
@@ -116,7 +80,8 @@ declare function isButtonDown(state: GamepadState, button: number): boolean;
 declare function wasButtonPressed(state: GamepadState, button: number): boolean;
 declare function wasButtonReleased(state: GamepadState, button: number): boolean;
 declare function getAxis(state: GamepadState, axis: number): number;
-
+//#endregion
+//#region src/gamepad-source.d.ts
 /**
  * Platform abstraction for sampling connected gamepads.
  *
@@ -128,28 +93,207 @@ declare function getAxis(state: GamepadState, axis: number): number;
  *   via the `GamepadSource` interface — the package itself ships no native deps.
  */
 interface GamepadSource {
-    poll(): (GamepadSnapshot | null)[];
+  poll(): (GamepadSnapshot | null)[];
 }
 interface NavigatorLike {
-    getGamepads?: () => (WebGamepad | null)[];
+  getGamepads?: () => (WebGamepad | null)[];
 }
 interface WebGamepad {
-    id: string;
-    index: number;
-    connected: boolean;
-    timestamp: number;
-    buttons: readonly {
-        pressed: boolean;
-        value: number;
-    }[];
-    axes: readonly number[];
+  id: string;
+  index: number;
+  connected: boolean;
+  timestamp: number;
+  buttons: readonly {
+    pressed: boolean;
+    value: number;
+  }[];
+  axes: readonly number[];
 }
 /**
  * Wrap `navigator.getGamepads()` (W3C Gamepad API). If `nav` is not supplied,
  * uses `globalThis.navigator`. Returns an empty array when the API is absent.
  */
 declare function createWebGamepadSource(nav?: NavigatorLike): GamepadSource;
-
+//#endregion
+//#region src/gestures.d.ts
+/** Swipe direction. */
+type SwipeDirection = 'left' | 'right' | 'up' | 'down';
+/** Gesture detection configuration. */
+interface GestureConfig {
+  /** Max time (seconds) for a tap (default 0.3). */
+  tapMaxDuration?: number;
+  /** Max distance (px) for a tap (default 20). */
+  tapMaxDistance?: number;
+  /** Min time (seconds) for a long press (default 0.5). */
+  longPressMinDuration?: number;
+  /** Min distance (px) for a swipe (default 50). */
+  swipeMinDistance?: number;
+  /** Max time (seconds) for a swipe (default 0.4). */
+  swipeMaxDuration?: number;
+}
+/** Swipe event data. */
+interface SwipeEvent {
+  direction: SwipeDirection;
+  distance: number;
+  duration: number;
+}
+/** Pinch event data. */
+interface PinchEvent {
+  /** Scale factor (>1 = spread, <1 = pinch). */
+  scale: number;
+  /** Center point between the two touches. */
+  center: Vec2;
+}
+/**
+ * GestureDetector recognizes tap, long press, swipe, and pinch gestures
+ * from raw pointer events.
+ */
+declare class GestureDetector {
+  readonly onTap: Signal<Vec2>;
+  readonly onLongPress: Signal<Vec2>;
+  readonly onSwipe: Signal<SwipeEvent>;
+  readonly onPinch: Signal<PinchEvent>;
+  private tapMaxDuration;
+  private tapMaxDistance;
+  private longPressMinDuration;
+  private swipeMinDistance;
+  private swipeMaxDuration;
+  private _startPos;
+  private _startTime;
+  private _isTracking;
+  private _longPressFired;
+  private _pinchStartDistance;
+  private _pinchTouches;
+  constructor(config?: GestureConfig);
+  /** Feed a pointer-down event. */
+  pointerDown(x: number, y: number): void;
+  /** Feed a pointer-up event. */
+  pointerUp(x: number, y: number, elapsedSinceDown: number): void;
+  /**
+   * Update gesture tracking. Call each frame with dt.
+   * @param dt Delta time in seconds.
+   * @param currentX Current pointer X.
+   * @param currentY Current pointer Y.
+   */
+  update(dt: number, currentX: number, currentY: number): void;
+  /**
+   * Feed a two-finger pinch update. Call when two touches are active.
+   * @param t1 First touch position.
+   * @param t2 Second touch position.
+   */
+  pinchUpdate(t1: Vec2, t2: Vec2): void;
+  /** Call when pinch ends (fewer than 2 touches). */
+  pinchEnd(): void;
+}
+//#endregion
+//#region src/keyboard.d.ts
+/** Minimal keyboard event shape — no DOM type dep. */
+interface KeyboardEventLike {
+  readonly code: string;
+  readonly type: string;
+  /** Optional — real DOM events have it; synthetic feeds may not. */
+  preventDefault?(): void;
+}
+/** Minimal event target shape for attaching keyboard listeners. */
+interface KeyboardEventTargetLike {
+  addEventListener(type: string, handler: (ev: KeyboardEventLike) => void): void;
+  removeEventListener(type: string, handler: (ev: KeyboardEventLike) => void): void;
+}
+/**
+ * Buffered per-frame keyboard state.
+ *
+ * Edge flags (`wasPressed`, `wasReleased`) clear each frame via `reset()`.
+ * `keyDown` / `keyUp` are the platform-neutral injection points: web feeds
+ * them via `attachKeyboardListeners`; mobile/RN feeds them from a
+ * hardware-keyboard native module or an on-screen source.
+ */
+interface KeyboardState {
+  /** True while the key is physically held. */
+  isDown(code: string): boolean;
+  /** True only on the frame the key was pressed. */
+  wasPressed(code: string): boolean;
+  /** True only on the frame the key was released. */
+  wasReleased(code: string): boolean;
+  /** Platform-neutral injection. OS auto-repeat is de-edged by the pressButton guard. */
+  keyDown(code: string): void;
+  /** Platform-neutral injection. */
+  keyUp(code: string): void;
+  /** Frame-start edge clear. Zero-alloc. */
+  reset(): void;
+  /** Blur/stuck-key guard: emits a release edge for every held code, then drops held. */
+  clear(): void;
+}
+/** Create a fresh keyboard state. */
+declare function createKeyboard(): KeyboardState;
+/** Free-function parity with `resetPointerFrame`. Delegates to `kb.reset()`. */
+declare function resetKeyboardFrame(kb: KeyboardState): void;
+/**
+ * Web turnkey adapter: registers `keydown`, `keyup`, and `blur` listeners on
+ * `target`. `blur` calls `kb.clear()` (stuck-key guard). Returns a detach fn.
+ *
+ * `target` is structural `{ addEventListener, removeEventListener }` — no DOM
+ * types dep. On web, pass `window`; for mobile/RN, feed `keyDown`/`keyUp`
+ * directly from a hardware-keyboard native module or an on-screen source.
+ *
+ * Does NOT call `preventDefault` — bare use lets Space/arrows scroll and Tab
+ * move DOM focus. For game-mode input, attach your own listener that calls
+ * `preventDefault` for game keys and forwards `kb.keyDown(ev.code)`.
+ */
+declare function attachKeyboardListeners(kb: KeyboardState, target: KeyboardEventTargetLike): () => void;
+/**
+ * Action → code binding map. Keys are action names; values are arrays of
+ * `KeyboardEvent.code` strings. Multiple codes OR-reduce (any bound key
+ * triggers the action).
+ */
+type KeyBindings = Readonly<Record<string, readonly string[]>>;
+/** True if any bound code for `action` is currently held. */
+declare function isActionDown(kb: KeyboardState, bindings: KeyBindings, action: string): boolean;
+/** True if any bound code for `action` was pressed this frame. */
+declare function wasActionPressed(kb: KeyboardState, bindings: KeyBindings, action: string): boolean;
+/**
+ * True if any bound code for `action` was released this frame AND no bound
+ * code is still held. Release fires only when the last held bound key lifts.
+ */
+declare function wasActionReleased(kb: KeyboardState, bindings: KeyBindings, action: string): boolean;
+//#endregion
+//#region src/pointer.d.ts
+/** State of a single pointer (primary touch or mouse). */
+interface Pointer {
+  /** Current position in screen coordinates. */
+  position: Vec2;
+  /** Position delta since last frame. */
+  delta: Vec2;
+  /** Whether the pointer is currently held down. */
+  isDown: boolean;
+  /** True only on the frame the pointer was pressed. */
+  justPressed: boolean;
+  /** True only on the frame the pointer was released. */
+  justReleased: boolean;
+}
+/** State of a single touch point in a multitouch scenario. */
+interface TouchPoint {
+  /** Unique touch identifier. */
+  id: number;
+  /** Current position in screen coordinates. */
+  position: Vec2;
+  /** Whether this touch is currently active. */
+  isDown: boolean;
+}
+/** Create a default pointer state. */
+declare function createPointer(): Pointer;
+/**
+ * Update pointer state for a new frame.
+ * Call this at the start of each frame to clear per-frame flags.
+ */
+declare function resetPointerFrame(pointer: Pointer): void;
+/** Feed a pointer-down event into the pointer state. */
+declare function pointerDown(pointer: Pointer, x: number, y: number): void;
+/** Feed a pointer-move event into the pointer state. */
+declare function pointerMove(pointer: Pointer, x: number, y: number): void;
+/** Feed a pointer-up event into the pointer state. */
+declare function pointerUp(pointer: Pointer, x: number, y: number): void;
+//#endregion
+//#region src/remap.d.ts
 /**
  * Button / axis remap table.
  *
@@ -160,13 +304,13 @@ declare function createWebGamepadSource(nav?: NavigatorLike): GamepadSource;
  * Y on some controllers; `scale` supports half-range triggers.
  */
 interface AxisMap {
-    index: number;
-    invert: boolean;
-    scale: number;
+  index: number;
+  invert: boolean;
+  scale: number;
 }
 interface RemapTable {
-    buttons: number[];
-    axes: AxisMap[];
+  buttons: number[];
+  axes: AxisMap[];
 }
 declare function createIdentityRemap(buttonCount?: number, axisCount?: number): RemapTable;
 /** Apply a remap table to a raw snapshot, returning a new snapshot with logical ordering. */
@@ -176,14 +320,15 @@ declare function applyRemap(snapshot: GamepadSnapshot, table: RemapTable): Gamep
  * but declared locally so this package does not take a hard dep on storage.
  */
 interface RemapStore {
-    get(key: string): Promise<string | null>;
-    set(key: string, value: string): Promise<void>;
+  get(key: string): Promise<string | null>;
+  set(key: string, value: string): Promise<void>;
 }
 /** Persist a remap table under the given key. Throws on invalid table shape. */
 declare function saveRemap(store: RemapStore, key: string, table: RemapTable): Promise<void>;
 /** Load a remap table. Returns `null` if absent or malformed. */
 declare function loadRemap(store: RemapStore, key: string): Promise<RemapTable | null>;
-
+//#endregion
+//#region src/input-manager.d.ts
 /**
  * InputManager provides a polling-based input model.
  *
@@ -191,121 +336,73 @@ declare function loadRemap(store: RemapStore, key: string): Promise<RemapTable |
  * Feed events from the platform (RN touch/gesture handlers) via the on* methods.
  */
 declare class InputManager {
-    /** Primary pointer (first touch or mouse). */
-    readonly pointer: Pointer;
-    /** All active touch points. */
-    readonly touches: TouchPoint[];
-    private _touchMap;
-    private _gamepads;
-    private _gamepadDeadZone;
-    private _gamepadRemaps;
-    /** Call once per frame to reset per-frame flags. */
-    update(): void;
-    /** Feed a touch/pointer begin event. */
-    onPointerDown(id: number, x: number, y: number): void;
-    /** Feed a touch/pointer move event. */
-    onPointerMove(id: number, x: number, y: number): void;
-    /** Feed a touch/pointer end event. */
-    onPointerUp(id: number, x: number, y: number): void;
-    /** Access the gamepad state at `index`. Allocates on first access. */
-    gamepad(index: number): GamepadState;
-    /** Dead zone in [0, 1). Axes at or below this magnitude read as 0. */
-    setGamepadDeadZone(deadZone: number): void;
-    /** Install a remap table for a specific gamepad index. Pass `null` to clear. */
-    setGamepadRemap(index: number, table: RemapTable | null): void;
-    /** Poll all gamepads from the given source, applying remap + dead zones. */
-    pollGamepads(source: GamepadSource): void;
-    private _addOrUpdateTouch;
-    private _removeTouch;
-}
-
-/** Swipe direction. */
-type SwipeDirection = 'left' | 'right' | 'up' | 'down';
-/** Gesture detection configuration. */
-interface GestureConfig {
-    /** Max time (seconds) for a tap (default 0.3). */
-    tapMaxDuration?: number;
-    /** Max distance (px) for a tap (default 20). */
-    tapMaxDistance?: number;
-    /** Min time (seconds) for a long press (default 0.5). */
-    longPressMinDuration?: number;
-    /** Min distance (px) for a swipe (default 50). */
-    swipeMinDistance?: number;
-    /** Max time (seconds) for a swipe (default 0.4). */
-    swipeMaxDuration?: number;
-}
-/** Swipe event data. */
-interface SwipeEvent {
-    direction: SwipeDirection;
-    distance: number;
-    duration: number;
-}
-/** Pinch event data. */
-interface PinchEvent {
-    /** Scale factor (>1 = spread, <1 = pinch). */
-    scale: number;
-    /** Center point between the two touches. */
-    center: Vec2;
+  /** Primary pointer (first touch or mouse). */
+  readonly pointer: Pointer;
+  /** Buffered keyboard state. Feed via `attachKeyboardListeners` (web) or `keyboard.keyDown`/`keyUp` (mobile/RN). */
+  readonly keyboard: KeyboardState;
+  /** All active touch points. */
+  readonly touches: TouchPoint[];
+  private _touchMap;
+  private _gamepads;
+  private _gamepadDeadZone;
+  private _gamepadRemaps;
+  /** Call once per frame to reset per-frame flags. */
+  update(): void;
+  /** Feed a touch/pointer begin event. */
+  onPointerDown(id: number, x: number, y: number): void;
+  /** Feed a touch/pointer move event. */
+  onPointerMove(id: number, x: number, y: number): void;
+  /** Feed a touch/pointer end event. */
+  onPointerUp(id: number, x: number, y: number): void;
+  /** Access the gamepad state at `index`. Allocates on first access. */
+  gamepad(index: number): GamepadState;
+  /** Dead zone in [0, 1). Axes at or below this magnitude read as 0. */
+  setGamepadDeadZone(deadZone: number): void;
+  /** Install a remap table for a specific gamepad index. Pass `null` to clear. */
+  setGamepadRemap(index: number, table: RemapTable | null): void;
+  /** Poll all gamepads from the given source, applying remap + dead zones. */
+  pollGamepads(source: GamepadSource): void;
+  private _addOrUpdateTouch;
+  private _removeTouch;
 }
-/**
- * GestureDetector recognizes tap, long press, swipe, and pinch gestures
- * from raw pointer events.
- */
-declare class GestureDetector {
-    readonly onTap: Signal<Vec2>;
-    readonly onLongPress: Signal<Vec2>;
-    readonly onSwipe: Signal<SwipeEvent>;
-    readonly onPinch: Signal<PinchEvent>;
-    private tapMaxDuration;
-    private tapMaxDistance;
-    private longPressMinDuration;
-    private swipeMinDistance;
-    private swipeMaxDuration;
-    private _startPos;
-    private _startTime;
-    private _isTracking;
-    private _longPressFired;
-    private _pinchStartDistance;
-    private _pinchTouches;
-    constructor(config?: GestureConfig);
-    /** Feed a pointer-down event. */
-    pointerDown(x: number, y: number): void;
-    /** Feed a pointer-up event. */
-    pointerUp(x: number, y: number, elapsedSinceDown: number): void;
-    /**
-     * Update gesture tracking. Call each frame with dt.
-     * @param dt Delta time in seconds.
-     * @param currentX Current pointer X.
-     * @param currentY Current pointer Y.
-     */
-    update(dt: number, currentX: number, currentY: number): void;
-    /**
-     * Feed a two-finger pinch update. Call when two touches are active.
-     * @param t1 First touch position.
-     * @param t2 Second touch position.
-     */
-    pinchUpdate(t1: Vec2, t2: Vec2): void;
-    /** Call when pinch ends (fewer than 2 touches). */
-    pinchEnd(): void;
+//#endregion
+//#region src/virtual-button.d.ts
+/** Virtual button state — pure data, no UI. */
+interface VirtualButtonState {
+  /** Whether the button is currently pressed. */
+  isPressed: boolean;
+  /** Whether the button was just pressed this frame. */
+  justPressed: boolean;
+  /** Whether the button was just released this frame. */
+  justReleased: boolean;
 }
-
+/** Create a default button state. */
+declare function createButtonState(): VirtualButtonState;
+/** Call at the start of each frame to reset per-frame flags. */
+declare function resetButtonFrame(state: VirtualButtonState): void;
+/** Call when the button is pressed. */
+declare function pressButton(state: VirtualButtonState): void;
+/** Call when the button is released. */
+declare function releaseButton(state: VirtualButtonState): void;
+//#endregion
+//#region src/virtual-joystick.d.ts
 /** Virtual joystick configuration. */
 interface VirtualJoystickConfig {
-    /** Dead zone radius in pixels (default 10). */
-    deadZone?: number;
-    /** Maximum radius in pixels (default 50). */
-    maxRadius?: number;
+  /** Dead zone radius in pixels (default 10). */
+  deadZone?: number;
+  /** Maximum radius in pixels (default 50). */
+  maxRadius?: number;
 }
 /** Virtual joystick state — pure data, no UI. */
 interface VirtualJoystickState {
-    /** Whether the joystick is currently being touched. */
-    active: boolean;
-    /** Normalized direction vector (-1 to 1 per axis). */
-    direction: Vec2;
-    /** Magnitude 0-1 (0 = center/dead zone, 1 = max radius). */
-    magnitude: number;
-    /** Raw offset from center in pixels. */
-    offset: Vec2;
+  /** Whether the joystick is currently being touched. */
+  active: boolean;
+  /** Normalized direction vector (-1 to 1 per axis). */
+  direction: Vec2;
+  /** Magnitude 0-1 (0 = center/dead zone, 1 = max radius). */
+  magnitude: number;
+  /** Raw offset from center in pixels. */
+  offset: Vec2;
 }
 /** Create a default joystick state. */
 declare function createJoystickState(): VirtualJoystickState;
@@ -322,23 +419,6 @@ declare function createJoystickState(): VirtualJoystickState;
 declare function updateJoystick(state: VirtualJoystickState, centerX: number, centerY: number, touchX: number, touchY: number, config?: VirtualJoystickConfig): void;
 /** Reset joystick state when touch is released. */
 declare function releaseJoystick(state: VirtualJoystickState): void;
-
-/** Virtual button state — pure data, no UI. */
-interface VirtualButtonState {
-    /** Whether the button is currently pressed. */
-    isPressed: boolean;
-    /** Whether the button was just pressed this frame. */
-    justPressed: boolean;
-    /** Whether the button was just released this frame. */
-    justReleased: boolean;
-}
-/** Create a default button state. */
-declare function createButtonState(): VirtualButtonState;
-/** Call at the start of each frame to reset per-frame flags. */
-declare function resetButtonFrame(state: VirtualButtonState): void;
-/** Call when the button is pressed. */
-declare function pressButton(state: VirtualButtonState): void;
-/** Call when the button is released. */
-declare function releaseButton(state: VirtualButtonState): void;
-
-export { type AxisMap, GamepadAxis, type GamepadAxisId, GamepadButton, type GamepadButtonId, type GamepadButtonState, type GamepadSnapshot, type GamepadSource, type GamepadState, type GestureConfig, GestureDetector, InputManager, type PinchEvent, type Pointer, type RemapStore, type RemapTable, type SwipeDirection, type SwipeEvent, type TouchPoint, type VirtualButtonState, type VirtualJoystickConfig, type VirtualJoystickState, applyRemap, createButtonState, createGamepadState, createIdentityRemap, createJoystickState, createPointer, createWebGamepadSource, getAxis, isButtonDown, loadRemap, pointerDown, pointerMove, pointerUp, pressButton, releaseButton, releaseJoystick, resetButtonFrame, resetGamepadFrame, resetPointerFrame, saveRemap, updateGamepadFromSnapshot, updateJoystick, wasButtonPressed, wasButtonReleased };
+//#endregion
+export { type AxisMap, GamepadAxis, type GamepadAxisId, GamepadButton, type GamepadButtonId, type GamepadButtonState, type GamepadSnapshot, type GamepadSource, type GamepadState, type GestureConfig, GestureDetector, InputManager, type KeyBindings, type KeyboardEventLike, type KeyboardEventTargetLike, type KeyboardState, type PinchEvent, type Pointer, type RemapStore, type RemapTable, type SwipeDirection, type SwipeEvent, type TouchPoint, type VirtualButtonState, type VirtualJoystickConfig, type VirtualJoystickState, applyRemap, attachKeyboardListeners, createButtonState, createGamepadState, createIdentityRemap, createJoystickState, createKeyboard, createPointer, createWebGamepadSource, getAxis, isActionDown, isButtonDown, loadRemap, pointerDown, pointerMove, pointerUp, pressButton, releaseButton, releaseJoystick, resetButtonFrame, resetGamepadFrame, resetKeyboardFrame, resetPointerFrame, saveRemap, updateGamepadFromSnapshot, updateJoystick, wasActionPressed, wasActionReleased, wasButtonPressed, wasButtonReleased };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/gamepad.ts","../src/gamepad-source.ts","../src/gestures.ts","../src/keyboard.ts","../src/pointer.ts","../src/remap.ts","../src/input-manager.ts","../src/virtual-button.ts","../src/virtual-joystick.ts"],"mappings":"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"}