web-input-system 0.0.0-stage → 0.4.0

package/dist/index.js

@@ -0,0 +1,885 @@
+// src/asset.ts
+function defineInputAsset(def) {
+  return { def };
+}
+
+// src/composites.ts
+function axis1D(opts) {
+  return { kind: "axis1d", ...opts };
+}
+function vector2D(opts) {
+  return { kind: "vector2d", normalize: opts.normalize ?? true, ...opts };
+}
+function isComposite(binding) {
+  return typeof binding === "object" && binding !== null && (binding.kind === "axis1d" || binding.kind === "vector2d");
+}
+
+// src/interactions.ts
+function press() {
+  return { kind: "press" };
+}
+function hold(duration) {
+  return { kind: "hold", duration };
+}
+function tap(maxDuration = 0.25) {
+  return { kind: "tap", maxDuration };
+}
+function doubleTap(maxInterval = 0.3, maxDuration = 0.25) {
+  return { kind: "doubleTap", maxInterval, maxDuration };
+}
+function createInteraction(def, hooks) {
+  switch (def.kind) {
+    case "press":
+      return null;
+    case "hold":
+      return new HoldInteraction(def.duration, hooks);
+    case "tap":
+      return new TapInteraction(def.maxDuration, hooks);
+    case "doubleTap":
+      return new DoubleTapInteraction(def.maxInterval, def.maxDuration, hooks);
+  }
+}
+var HoldInteraction = class {
+  constructor(duration, hooks) {
+    this.duration = duration;
+    this.hooks = hooks;
+  }
+  duration;
+  hooks;
+  phase = "idle";
+  timer = 0;
+  onPress() {
+    this.phase = "holding";
+    this.timer = 0;
+    this.hooks.started();
+  }
+  onRelease() {
+    if (this.phase === "idle") return;
+    this.phase = "idle";
+    this.hooks.canceled();
+  }
+  tick(dt) {
+    if (this.phase !== "holding") return;
+    this.timer += dt;
+    if (this.timer >= this.duration) {
+      this.phase = "done";
+      this.hooks.performed();
+    }
+  }
+  reset() {
+    this.phase = "idle";
+    this.timer = 0;
+  }
+};
+var TapInteraction = class {
+  constructor(maxDuration, hooks) {
+    this.maxDuration = maxDuration;
+    this.hooks = hooks;
+  }
+  maxDuration;
+  hooks;
+  phase = "idle";
+  timer = 0;
+  onPress() {
+    this.phase = "pressing";
+    this.timer = 0;
+    this.hooks.started();
+  }
+  onRelease() {
+    if (this.phase !== "pressing") return;
+    this.phase = "idle";
+    this.hooks.performed();
+    this.hooks.canceled();
+  }
+  tick(dt) {
+    if (this.phase !== "pressing") return;
+    this.timer += dt;
+    if (this.timer > this.maxDuration) {
+      this.phase = "idle";
+      this.hooks.canceled();
+    }
+  }
+  reset() {
+    this.phase = "idle";
+    this.timer = 0;
+  }
+};
+var DoubleTapInteraction = class {
+  constructor(maxInterval, maxDuration, hooks) {
+    this.maxInterval = maxInterval;
+    this.maxDuration = maxDuration;
+    this.hooks = hooks;
+  }
+  maxInterval;
+  maxDuration;
+  hooks;
+  phase = "idle";
+  timer = 0;
+  onPress() {
+    if (this.phase === "idle") {
+      this.phase = "press1";
+      this.timer = 0;
+      this.hooks.started();
+    } else if (this.phase === "wait2") {
+      this.phase = "press2";
+      this.timer = 0;
+    }
+  }
+  onRelease() {
+    if (this.phase === "press1") {
+      if (this.timer <= this.maxDuration) {
+        this.phase = "wait2";
+        this.timer = 0;
+      } else {
+        this.cancel();
+      }
+    } else if (this.phase === "press2") {
+      if (this.timer <= this.maxDuration) {
+        this.phase = "idle";
+        this.hooks.performed();
+        this.hooks.canceled();
+      } else {
+        this.cancel();
+      }
+    }
+  }
+  tick(dt) {
+    if (this.phase === "idle") return;
+    this.timer += dt;
+    const expired = this.phase === "press1" && this.timer > this.maxDuration || this.phase === "wait2" && this.timer > this.maxInterval || this.phase === "press2" && this.timer > this.maxDuration;
+    if (expired) this.cancel();
+  }
+  reset() {
+    this.phase = "idle";
+    this.timer = 0;
+  }
+  cancel() {
+    this.phase = "idle";
+    this.hooks.canceled();
+  }
+};
+
+// src/processors.ts
+function scale(factor) {
+  return {
+    number: (v) => v * factor,
+    vector2: (v) => ({ x: v.x * factor, y: v.y * factor })
+  };
+}
+function invert() {
+  return {
+    number: (v) => -v,
+    vector2: (v) => ({ x: -v.x, y: -v.y })
+  };
+}
+function invertX() {
+  return { vector2: (v) => ({ x: -v.x, y: v.y }) };
+}
+function invertY() {
+  return { vector2: (v) => ({ x: v.x, y: -v.y }) };
+}
+function deadzone(min = 0.125, max = 0.925) {
+  return {
+    number: (v) => {
+      const a = Math.abs(v);
+      if (a < min) return 0;
+      if (a >= max) return Math.sign(v);
+      return Math.sign(v) * ((a - min) / (max - min));
+    }
+  };
+}
+function clamp(min, max) {
+  return { number: (v) => Math.min(max, Math.max(min, v)) };
+}
+function normalize() {
+  return {
+    vector2: (v) => {
+      const len = Math.hypot(v.x, v.y);
+      return len > 0 ? { x: v.x / len, y: v.y / len } : v;
+    }
+  };
+}
+
+// src/action.ts
+var InputAction = class {
+  /** Action name in 'map.action' form, for logging and debugging. */
+  name;
+  /** Current phase ('waiting' = never triggered or fully reset). */
+  get phase() {
+    return this._phase;
+  }
+  _phase = "waiting";
+  runtime;
+  listeners = {
+    started: /* @__PURE__ */ new Set(),
+    performed: /* @__PURE__ */ new Set(),
+    canceled: /* @__PURE__ */ new Set()
+  };
+  constructor(name, runtime) {
+    this.name = name;
+    this.runtime = runtime;
+  }
+  /** Subscribe to performed (value produced/changed). Returns an unsubscribe fn. */
+  performed(cb) {
+    return this.subscribe("performed", cb);
+  }
+  /** Subscribe to started (first frame leaving the default value). Returns an unsubscribe fn. */
+  started(cb) {
+    return this.subscribe("started", cb);
+  }
+  /** Subscribe to canceled (release / back to default / map deactivated). Returns an unsubscribe fn. */
+  canceled(cb) {
+    return this.subscribe("canceled", cb);
+  }
+  subscribe(phase, cb) {
+    const set = this.listeners[phase];
+    set.add(cb);
+    return () => set.delete(cb);
+  }
+  /** Poll the current value (type default — false / 0 / {0,0} — while the map is inactive). */
+  readValue() {
+    return this.runtime.readValue();
+  }
+  /** Whether the action is currently actuated (button: held; value: non-default). */
+  isPressed() {
+    return this.runtime.isPressed();
+  }
+  /** [internal] Called by the manager during dispatch. */
+  _emit(phase, value) {
+    this._phase = phase;
+    const ctx = {
+      action: this.name,
+      value,
+      phase,
+      time: typeof performance !== "undefined" ? performance.now() : 0
+    };
+    for (const cb of this.listeners[phase]) cb(ctx);
+  }
+  /** [internal] Reset phase without dispatching (used by dispose). */
+  _reset() {
+    this._phase = "waiting";
+  }
+};
+
+// src/actionMap.ts
+var InputActionMap = class {
+  name;
+  /** [internal] Notifies the manager to re-evaluate dispatch on toggle. */
+  onToggle;
+  _enabled = true;
+  constructor(name, onToggle) {
+    this.name = name;
+    this.onToggle = onToggle;
+  }
+  get enabled() {
+    return this._enabled;
+  }
+  enable() {
+    if (this._enabled) return;
+    this._enabled = true;
+    this.onToggle();
+  }
+  disable() {
+    if (!this._enabled) return;
+    this._enabled = false;
+    this.onToggle();
+  }
+};
+
+// src/types.ts
+var MOUSE_LEFT_BUTTON = "<Mouse>/leftButton";
+var MOUSE_MIDDLE_BUTTON = "<Mouse>/middleButton";
+var MOUSE_RIGHT_BUTTON = "<Mouse>/rightButton";
+var MOUSE_DELTA = "<Mouse>/delta";
+var MOUSE_WHEEL_Y = "<Mouse>/wheelY";
+function mouseButtonPath(button) {
+  switch (button) {
+    case 0:
+      return MOUSE_LEFT_BUTTON;
+    case 1:
+      return MOUSE_MIDDLE_BUTTON;
+    case 2:
+      return MOUSE_RIGHT_BUTTON;
+    default:
+      return `<Mouse>/button${button}`;
+  }
+}
+function isDeltaControl(path) {
+  return path === MOUSE_DELTA || path === MOUSE_WHEEL_Y;
+}
+
+// src/manager.ts
+var InputManager = class {
+  /** Auto-tracked from pointerlockchange; hosts may also override manually. */
+  isPointerLocked = false;
+  maps = /* @__PURE__ */ new Map();
+  actions = /* @__PURE__ */ new Map();
+  /** control path → actions bound to it (dispatch entry point). */
+  controlIndex = /* @__PURE__ */ new Map();
+  /** All bound keyboard codes, computed once (preventDefault lookup). */
+  boundKeyCodes = /* @__PURE__ */ new Set();
+  controls = /* @__PURE__ */ new Map();
+  contextGetter;
+  contextValue;
+  gateMouse;
+  doPreventDefault;
+  disposers = [];
+  /** Active rebind capture session (at most one at a time). */
+  capture = null;
+  /** 'map/action' → replacement bindings (the serializable overrides table). */
+  overrides = /* @__PURE__ */ new Map();
+  constructor(asset, options = {}) {
+    this.contextGetter = options.context;
+    this.gateMouse = options.gateMouseByPointerLock ?? false;
+    this.doPreventDefault = options.preventDefault ?? true;
+    for (const [mapName, mapDef] of Object.entries(asset.def.maps)) {
+      const runtimeMap = {
+        map: new InputActionMap(mapName, () => this.syncAll()),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        def: mapDef
+      };
+      this.maps.set(mapName, runtimeMap);
+      for (const [actionName, actionDef] of Object.entries(mapDef.actions)) {
+        const valueType = actionDef.type === "button" ? "button" : actionDef.value;
+        const ra = {
+          action: null,
+          mapName,
+          defaultBindings: actionDef.bindings ?? [],
+          bindings: actionDef.bindings ?? [],
+          valueType,
+          processors: actionDef.type === "value" ? actionDef.processors ?? [] : [],
+          interaction: null,
+          held: false,
+          dispatched: false,
+          lastValue: defaultValue(valueType)
+        };
+        ra.action = new InputAction(`${mapName}.${actionName}`, {
+          readValue: () => this.readActionValue(ra),
+          isPressed: () => this.isActionPressed(ra)
+        });
+        const interactions = actionDef.type === "button" ? actionDef.interactions : void 0;
+        if (interactions && interactions.length > 0) {
+          if (interactions.length > 1) {
+            throw new Error(
+              `InputManager: '${mapName}/${actionName}' declares ${interactions.length} interactions; only one per action is supported`
+            );
+          }
+          ra.interaction = createInteraction(interactions[0], {
+            started: () => {
+              ra.dispatched = true;
+              ra.action._emit("started", true);
+            },
+            performed: () => {
+              ra.action._emit("performed", true);
+            },
+            canceled: () => {
+              ra.dispatched = false;
+              ra.action._emit("canceled", false);
+            }
+          });
+        }
+        this.actions.set(`${mapName}/${actionName}`, ra);
+      }
+    }
+    this.rebuildIndexes();
+    const target = options.target ?? (typeof window !== "undefined" ? window : void 0);
+    if (target) this.attach(target);
+  }
+  // ==================== Lookup ====================
+  /** Get an action; map/action names and the value type are inferred from the asset. */
+  action(mapName, actionName) {
+    const ra = this.actions.get(`${mapName}/${actionName}`);
+    if (!ra) throw new Error(`InputManager: unknown action '${mapName}/${actionName}'`);
+    return ra.action;
+  }
+  /** Get an action map (enable/disable). */
+  map(name) {
+    const rm = this.maps.get(name);
+    if (!rm) throw new Error(`InputManager: unknown action map '${name}'`);
+    return rm.map;
+  }
+  /** Raw control held-state polling, bypassing map gating (hold-to-row etc.). */
+  isControlDown(path) {
+    return this.control(path).pressed;
+  }
+  /** Push-style context (alternative to the `context` sampler, which wins if both exist). */
+  setContext(ctx) {
+    this.contextValue = ctx;
+    this.syncAll();
+  }
+  /** Call at the end of every frame: advances interaction timers, then resets delta accumulators. */
+  update(dt) {
+    var _a;
+    for (const ra of this.actions.values()) (_a = ra.interaction) == null ? void 0 : _a.tick(dt);
+    const delta = this.controls.get(MOUSE_DELTA);
+    if (delta) {
+      delta.x = 0;
+      delta.y = 0;
+    }
+    const wheel = this.controls.get(MOUSE_WHEEL_Y);
+    if (wheel) {
+      wheel.x = 0;
+      wheel.y = 0;
+    }
+  }
+  // ==================== Rebinding ====================
+  /** Effective bindings of an action (overrides applied). */
+  getBindings(mapName, actionName) {
+    return this.requireAction(mapName, actionName).bindings;
+  }
+  /**
+   * Replace an action's bindings at runtime (recorded in the overrides table).
+   * For composite bindings, read current bindings with getBindings, swap the
+   * control path of one part, and pass the updated array back.
+   */
+  setBindings(mapName, actionName, bindings) {
+    this.setBindingsInternal(`${mapName}/${actionName}`, bindings);
+  }
+  /** Restore asset defaults: one action, or everything when called without arguments. */
+  resetBindings(mapName, actionName) {
+    if (mapName !== void 0 && actionName !== void 0) {
+      const ra = this.actions.get(`${mapName}/${actionName}`);
+      if (ra) ra.bindings = ra.defaultBindings;
+      this.overrides.delete(`${mapName}/${actionName}`);
+    } else {
+      for (const [key, ra] of this.actions) ra.bindings = ra.defaultBindings;
+      this.overrides.clear();
+    }
+    this.rebuildIndexes();
+    this.syncAll();
+  }
+  /** Export the overrides table (JSON-serializable; persistence is the host's job). */
+  exportOverrides() {
+    const out = {};
+    for (const [key, bindings] of this.overrides) out[key] = bindings;
+    return out;
+  }
+  /**
+   * Apply a previously exported overrides table. Unknown action paths are
+   * skipped (overrides may come from an older version of the asset).
+   */
+  applyOverrides(overrides) {
+    for (const [key, bindings] of Object.entries(overrides)) {
+      const ra = this.actions.get(key);
+      if (!ra) continue;
+      ra.bindings = bindings;
+      this.overrides.set(key, bindings);
+    }
+    this.rebuildIndexes();
+    this.syncAll();
+  }
+  /** Conflict detection: which actions currently bind this control. */
+  findActionsByControl(path) {
+    const out = [];
+    for (const ra of this.controlIndex.get(path) ?? []) {
+      out.push({ map: ra.mapName, action: ra.action.name.split(".").pop() });
+    }
+    return out;
+  }
+  /**
+   * Capture the next discrete input (keyboard key or mouse button) and make it
+   * the action's only binding. Normal dispatch is suppressed while capturing;
+   * blur cancels the session. Returns a function to cancel manually.
+   */
+  startRebind(mapName, actionName, callbacks, options = {}) {
+    var _a, _b;
+    this.requireAction(mapName, actionName);
+    (_b = (_a = this.capture) == null ? void 0 : _a.onCancel) == null ? void 0 : _b.call(_a);
+    const session = {
+      mapName,
+      actionName,
+      cancelOn: options.cancelOn ?? ["Escape"],
+      onComplete: callbacks.onComplete,
+      onCancel: callbacks.onCancel
+    };
+    this.capture = session;
+    return () => {
+      var _a2;
+      if (this.capture === session) {
+        this.capture = null;
+        (_a2 = session.onCancel) == null ? void 0 : _a2.call(session);
+      }
+    };
+  }
+  /** True while a rebind capture is waiting for input. */
+  get isRebinding() {
+    return this.capture !== null;
+  }
+  requireAction(mapName, actionName) {
+    const ra = this.actions.get(`${mapName}/${actionName}`);
+    if (!ra) throw new Error(`InputManager: unknown action '${mapName}/${actionName}'`);
+    return ra;
+  }
+  setBindingsInternal(key, bindings) {
+    const ra = this.actions.get(key);
+    if (!ra) throw new Error(`InputManager: unknown action '${key}'`);
+    ra.bindings = bindings;
+    this.overrides.set(key, bindings);
+    this.rebuildIndexes();
+    this.syncAll();
+  }
+  /** Rebuild control→action index and bound-key set from effective bindings. */
+  rebuildIndexes() {
+    this.controlIndex.clear();
+    this.boundKeyCodes.clear();
+    for (const ra of this.actions.values()) {
+      for (const path of flattenControlPaths(ra.bindings)) {
+        const list = this.controlIndex.get(path);
+        if (list) list.push(ra);
+        else this.controlIndex.set(path, [ra]);
+        if (!path.startsWith("<")) this.boundKeyCodes.add(path);
+      }
+    }
+  }
+  /** Feed a control press into the capture session. Returns true when consumed. */
+  handleCapture(path) {
+    var _a;
+    const session = this.capture;
+    if (!session) return false;
+    this.capture = null;
+    if (session.cancelOn.includes(path)) {
+      (_a = session.onCancel) == null ? void 0 : _a.call(session);
+      return true;
+    }
+    this.setBindingsInternal(`${session.mapName}/${session.actionName}`, [path]);
+    session.onComplete(path);
+    return true;
+  }
+  // ==================== Evaluation ====================
+  getCtx() {
+    return this.contextGetter ? this.contextGetter() : this.contextValue;
+  }
+  isMapActive(mapName) {
+    const rm = this.maps.get(mapName);
+    if (!rm || !rm.map.enabled) return false;
+    const predicate = rm.def.active;
+    return predicate ? predicate(this.getCtx()) : true;
+  }
+  control(path) {
+    let st = this.controls.get(path);
+    if (!st) {
+      st = { pressed: false, x: 0, y: 0 };
+      this.controls.set(path, st);
+    }
+    return st;
+  }
+  /** override: delta dispatch substitutes the event delta for the frame accumulator (prevents double-counting). */
+  evaluate(ra, override) {
+    let raw;
+    switch (ra.valueType) {
+      case "button":
+        raw = ra.bindings.some((b) => this.bindingPressed(b));
+        break;
+      case "axis":
+        raw = ra.bindings.reduce((sum, b) => sum + this.bindingAxis(b, override), 0);
+        break;
+      case "vector2": {
+        let x = 0;
+        let y = 0;
+        for (const b of ra.bindings) {
+          const v = this.bindingVector(b, override);
+          x += v.x;
+          y += v.y;
+        }
+        raw = { x, y };
+        break;
+      }
+    }
+    return applyProcessors(ra.processors, ra.valueType, raw);
+  }
+  bindingPressed(b) {
+    if (isComposite(b)) {
+      return b.kind === "axis1d" ? this.control(b.negative).pressed || this.control(b.positive).pressed : this.control(b.up).pressed || this.control(b.down).pressed || this.control(b.left).pressed || this.control(b.right).pressed;
+    }
+    const st = this.control(b);
+    return isDeltaControl(b) ? st.x !== 0 || st.y !== 0 : st.pressed;
+  }
+  bindingAxis(b, override) {
+    if (isComposite(b)) {
+      if (b.kind !== "axis1d") return 0;
+      return (this.control(b.positive).pressed ? 1 : 0) - (this.control(b.negative).pressed ? 1 : 0);
+    }
+    if (b === MOUSE_WHEEL_Y) return override && override.path === b ? override.y : this.control(b).y;
+    if (b === MOUSE_DELTA) return override && override.path === b ? override.x : this.control(b).x;
+    return this.control(b).pressed ? 1 : 0;
+  }
+  bindingVector(b, override) {
+    if (isComposite(b)) {
+      if (b.kind !== "vector2d") return { x: 0, y: 0 };
+      return compositeVector(b, (p) => this.control(p).pressed);
+    }
+    if (b === MOUSE_DELTA) {
+      if (override && override.path === b) return { x: override.x, y: override.y };
+      const st = this.control(b);
+      return { x: st.x, y: st.y };
+    }
+    if (b === MOUSE_WHEEL_Y) {
+      const y = override && override.path === b ? override.y : this.control(b).y;
+      return { x: 0, y };
+    }
+    return { x: 0, y: this.control(b).pressed ? 1 : 0 };
+  }
+  readActionValue(ra) {
+    if (!this.isMapActive(ra.mapName)) return defaultValue(ra.valueType);
+    return this.evaluate(ra);
+  }
+  isActionPressed(ra) {
+    if (!this.isMapActive(ra.mapName)) return false;
+    const v = this.evaluate(ra);
+    return ra.valueType === "button" ? v : !isDefaultValue(ra.valueType, v);
+  }
+  // ==================== Dispatch ====================
+  /** Discrete controls (keyboard / mouse buttons): three-phase state machine. */
+  syncAction(ra) {
+    if (!this.isMapActive(ra.mapName)) {
+      if (ra.interaction) {
+        ra.held = false;
+        ra.interaction.reset();
+      }
+      if (ra.dispatched) {
+        ra.dispatched = false;
+        ra.action._emit("canceled", defaultValue(ra.valueType));
+      }
+      return;
+    }
+    const value = this.evaluate(ra);
+    if (ra.valueType === "button") {
+      if (ra.interaction) {
+        const pressed = value;
+        if (pressed !== ra.held) {
+          ra.held = pressed;
+          if (pressed) ra.interaction.onPress();
+          else ra.interaction.onRelease();
+        }
+        return;
+      }
+      if (value && !ra.dispatched) {
+        ra.dispatched = true;
+        ra.action._emit("started", value);
+        ra.action._emit("performed", value);
+      } else if (!value && ra.dispatched) {
+        ra.dispatched = false;
+        ra.action._emit("canceled", value);
+      }
+      return;
+    }
+    if (isDefaultValue(ra.valueType, value)) {
+      if (ra.dispatched) {
+        ra.dispatched = false;
+        ra.action._emit("canceled", value);
+      }
+    } else {
+      if (!ra.dispatched) {
+        ra.dispatched = true;
+        ra.action._emit("started", value);
+        ra.action._emit("performed", value);
+      } else if (!valueEquals(ra.lastValue, value)) {
+        ra.action._emit("performed", value);
+      }
+    }
+    ra.lastValue = value;
+  }
+  syncControls(paths) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const path of paths) {
+      for (const ra of this.controlIndex.get(path) ?? []) {
+        if (seen.has(ra)) continue;
+        seen.add(ra);
+        this.syncAction(ra);
+      }
+    }
+  }
+  syncAll() {
+    for (const ra of this.actions.values()) this.syncAction(ra);
+  }
+  /** Delta controls (mouse motion / wheel): performed per event, no started/canceled lifecycle. */
+  dispatchDelta(path, x, y) {
+    const st = this.control(path);
+    st.x += x;
+    st.y += y;
+    for (const ra of this.controlIndex.get(path) ?? []) {
+      if (!this.isMapActive(ra.mapName)) continue;
+      const value = this.evaluate(ra, { path, x, y });
+      if (!isDefaultValue(ra.valueType, value)) {
+        ra.action._emit("performed", value);
+        ra.lastValue = value;
+      }
+    }
+  }
+  mouseGateOpen() {
+    return !this.gateMouse || this.isPointerLocked;
+  }
+  // ==================== DOM wiring ====================
+  attach(target) {
+    const doc = target.document;
+    const onKeyDown = (e) => {
+      const el = e.target;
+      if (el && (el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.isContentEditable)) return;
+      if (e.repeat) return;
+      if (this.handleCapture(e.code)) return;
+      this.control(e.code).pressed = true;
+      if (this.doPreventDefault && this.boundKeyCodes.has(e.code)) e.preventDefault();
+      this.syncControls([e.code]);
+    };
+    const onKeyUp = (e) => {
+      this.control(e.code).pressed = false;
+      this.syncControls([e.code]);
+    };
+    const onMouseMove = (e) => {
+      if (!this.mouseGateOpen()) return;
+      this.dispatchDelta(MOUSE_DELTA, e.movementX, e.movementY);
+    };
+    const onWheel = (e) => {
+      if (!this.mouseGateOpen()) return;
+      this.dispatchDelta(MOUSE_WHEEL_Y, 0, e.deltaY);
+      if (this.doPreventDefault && (this.controlIndex.get(MOUSE_WHEEL_Y) ?? []).some((ra) => this.isMapActive(ra.mapName))) {
+        e.preventDefault();
+      }
+    };
+    const onMouseDown = (e) => {
+      const path = mouseButtonPath(e.button);
+      this.control(path).pressed = true;
+      if (this.handleCapture(path)) return;
+      if (this.mouseGateOpen()) this.syncControls([path]);
+    };
+    const onMouseUp = (e) => {
+      const path = mouseButtonPath(e.button);
+      this.control(path).pressed = false;
+      if (this.mouseGateOpen()) this.syncControls([path]);
+    };
+    const clearAll = () => {
+      var _a;
+      for (const st of this.controls.values()) {
+        st.pressed = false;
+      }
+      if (this.capture) {
+        const session = this.capture;
+        this.capture = null;
+        (_a = session.onCancel) == null ? void 0 : _a.call(session);
+      }
+      this.syncAll();
+    };
+    const onBlur = () => clearAll();
+    const onVisibilityChange = () => {
+      if (doc.hidden) clearAll();
+    };
+    const onPointerLockChange = () => {
+      this.isPointerLocked = doc.pointerLockElement != null;
+      this.syncAll();
+    };
+    target.addEventListener("keydown", onKeyDown);
+    target.addEventListener("keyup", onKeyUp);
+    target.addEventListener("mousemove", onMouseMove);
+    target.addEventListener("wheel", onWheel, { passive: false });
+    target.addEventListener("mousedown", onMouseDown);
+    target.addEventListener("mouseup", onMouseUp);
+    target.addEventListener("blur", onBlur);
+    doc.addEventListener("visibilitychange", onVisibilityChange);
+    doc.addEventListener("pointerlockchange", onPointerLockChange);
+    this.disposers.push(
+      () => target.removeEventListener("keydown", onKeyDown),
+      () => target.removeEventListener("keyup", onKeyUp),
+      () => target.removeEventListener("mousemove", onMouseMove),
+      () => target.removeEventListener("wheel", onWheel),
+      () => target.removeEventListener("mousedown", onMouseDown),
+      () => target.removeEventListener("mouseup", onMouseUp),
+      () => target.removeEventListener("blur", onBlur),
+      () => doc.removeEventListener("visibilitychange", onVisibilityChange),
+      () => doc.removeEventListener("pointerlockchange", onPointerLockChange)
+    );
+  }
+  dispose() {
+    this.disposers.forEach((d) => d());
+    this.disposers.length = 0;
+    for (const ra of this.actions.values()) {
+      ra.dispatched = false;
+      ra.action._reset();
+    }
+    this.controls.clear();
+  }
+};
+function createInput(asset, options) {
+  return new InputManager(asset, options);
+}
+function flattenControlPaths(bindings) {
+  const out = [];
+  for (const b of bindings) {
+    if (isComposite(b)) {
+      if (b.kind === "axis1d") out.push(b.negative, b.positive);
+      else out.push(b.up, b.down, b.left, b.right);
+    } else {
+      out.push(b);
+    }
+  }
+  return out;
+}
+function compositeVector(b, pressed) {
+  let x = (pressed(b.right) ? 1 : 0) - (pressed(b.left) ? 1 : 0);
+  let y = (pressed(b.up) ? 1 : 0) - (pressed(b.down) ? 1 : 0);
+  if (b.normalize && x !== 0 && y !== 0) {
+    const inv = 1 / Math.hypot(x, y);
+    x *= inv;
+    y *= inv;
+  }
+  return { x, y };
+}
+function defaultValue(type) {
+  return type === "button" ? false : type === "axis" ? 0 : { x: 0, y: 0 };
+}
+function applyProcessors(processors, type, value) {
+  if (processors.length === 0) return value;
+  if (type === "axis") {
+    let v = value;
+    for (const p of processors) if (p.number) v = p.number(v);
+    return v;
+  }
+  if (type === "vector2") {
+    let v = value;
+    for (const p of processors) if (p.vector2) v = p.vector2(v);
+    return v;
+  }
+  return value;
+}
+function isDefaultValue(type, v) {
+  if (type === "button") return !v;
+  if (type === "axis") return v === 0;
+  const vec = v;
+  return vec.x === 0 && vec.y === 0;
+}
+function valueEquals(a, b) {
+  if (typeof a === "object" && typeof b === "object" && a !== null && b !== null) {
+    const va = a;
+    const vb = b;
+    return va.x === vb.x && va.y === vb.y;
+  }
+  return a === b;
+}
+export {
+  InputAction,
+  InputActionMap,
+  InputManager,
+  MOUSE_DELTA,
+  MOUSE_LEFT_BUTTON,
+  MOUSE_MIDDLE_BUTTON,
+  MOUSE_RIGHT_BUTTON,
+  MOUSE_WHEEL_Y,
+  axis1D,
+  clamp,
+  createInput,
+  deadzone,
+  defineInputAsset,
+  doubleTap,
+  hold,
+  invert,
+  invertX,
+  invertY,
+  isComposite,
+  isDeltaControl,
+  mouseButtonPath,
+  normalize,
+  press,
+  scale,
+  tap,
+  vector2D
+};
+//# sourceMappingURL=index.js.map