inpt 0.0.0

package/dist/index.js

@@ -0,0 +1,1182 @@
+/**
+ * inpt v0.0.0 build Sun Jan 18 2026
+ * https://github.com/vanruesc/input-manager
+ * Copyright 2026 Raoul van Rüschen
+ * @license Zlib
+ */
+
+// src/core/BoundAction.ts
+function getEnabledFlagCount(bitmask) {
+  let n = bitmask - (bitmask >>> 1 & 1431655765);
+  n = (n & 858993459) + (n >>> 2 & 858993459);
+  return (n + (n >>> 4) & 252645135) * 16843009 >>> 24;
+}
+var BoundAction = class {
+  /**
+   * The action.
+   */
+  action;
+  /**
+   * Required modifiers stored as a bitmask.
+   */
+  modifiers;
+  /**
+   * The number of enabled modifier flags.
+   */
+  modifierCount;
+  /**
+   * Constructs a new bound action.
+   *
+   * @param action - An action.
+   * @param modifiers - Required modifiers stored as a bitmask.
+   */
+  constructor(action, modifiers) {
+    this.action = action;
+    this.modifiers = modifiers;
+    this.modifierCount = getEnabledFlagCount(modifiers);
+  }
+};
+
+// src/core/Input.ts
+function modifiersToBitmask(modifiers) {
+  let flags = 0;
+  if (modifiers.includes("Alt")) {
+    flags = (flags | 1) >>> 0;
+  }
+  if (modifiers.includes("Ctrl")) {
+    flags = (flags | 2) >>> 0;
+  }
+  if (modifiers.includes("Meta")) {
+    flags = (flags | 4) >>> 0;
+  }
+  if (modifiers.includes("Shift")) {
+    flags = (flags | 8) >>> 0;
+  }
+  return flags;
+}
+var Input = class {
+  /**
+   * @see {@link value}
+   */
+  _value;
+  /**
+   * @see {@link modifiers}
+   */
+  _modifiers;
+  /**
+   * Constructs new input data.
+   *
+   * @param value - The primary input value.
+   * @param options - Additional options.
+   */
+  constructor(value, { modifiers } = {}) {
+    this._value = value;
+    this._modifiers = 0;
+    if (modifiers !== void 0) {
+      this.modifiers = modifiers;
+    }
+  }
+  /**
+   * The primary input value.
+   */
+  get value() {
+    return this._value;
+  }
+  set value(value) {
+    this._value = value;
+  }
+  /**
+   * The required modifiers, stored as a bitmask.
+   *
+   * Modifiers can be set directly as a bitmask or as a list of modifier keys.
+   */
+  get modifiers() {
+    return this._modifiers;
+  }
+  set modifiers(value) {
+    if (typeof value === "number") {
+      this._modifiers = value;
+      return;
+    }
+    this._modifiers = modifiersToBitmask(value);
+  }
+};
+
+// node_modules/.pnpm/synthetic-event@2.0.0/node_modules/synthetic-event/dist/index.js
+var EventTarget = class {
+  /**
+   * A collection of event listener functions.
+   */
+  listenerFunctions;
+  /**
+   * A collection of event listener objects.
+   */
+  listenerObjects;
+  /**
+   * Constructs a new event target.
+   */
+  constructor() {
+    this.listenerFunctions = /* @__PURE__ */ new Map();
+    this.listenerObjects = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Registers an event handler of a specific event type on the event target.
+   *
+   * @param type - The event type to listen for.
+   * @param listener - An event listener or callback.
+   */
+  addEventListener(type, listener) {
+    if (typeof listener === "function") {
+      if (this.listenerFunctions.has(type)) {
+        const listeners = this.listenerFunctions.get(type);
+        listeners.add(listener);
+      } else {
+        const listeners = /* @__PURE__ */ new Set([listener]);
+        this.listenerFunctions.set(type, listeners);
+      }
+      return;
+    }
+    if (this.listenerObjects.has(type)) {
+      const listeners = this.listenerObjects.get(type);
+      listeners.add(listener);
+    } else {
+      const listeners = /* @__PURE__ */ new Set([listener]);
+      this.listenerObjects.set(type, listeners);
+    }
+  }
+  /**
+   * Removes an event handler of a specific event type from the event target.
+   *
+   * @param type - The event type to remove.
+   * @param listener - The event listener to remove.
+   */
+  hasEventListener(type, listener) {
+    if (typeof listener === "function") {
+      if (!this.listenerFunctions.has(type)) {
+        return false;
+      }
+      const listeners2 = this.listenerFunctions.get(type);
+      return listeners2.has(listener);
+    }
+    if (!this.listenerObjects.has(type)) {
+      return false;
+    }
+    const listeners = this.listenerObjects.get(type);
+    return listeners.has(listener);
+  }
+  /**
+   * Removes an event handler of a specific event type from the event target.
+   *
+   * @param type - The event type to remove.
+   * @param listener - The event listener to remove.
+   */
+  removeEventListener(type, listener) {
+    if (typeof listener === "function") {
+      if (!this.listenerFunctions.has(type)) {
+        return;
+      }
+      const listeners2 = this.listenerFunctions.get(type);
+      if (listeners2.delete(listener) && listeners2.size === 0) {
+        this.listenerFunctions.delete(type);
+      }
+      return;
+    }
+    if (!this.listenerObjects.has(type)) {
+      return;
+    }
+    const listeners = this.listenerObjects.get(type);
+    if (listeners.delete(listener) && listeners.size === 0) {
+      this.listenerObjects.delete(type);
+    }
+  }
+  /**
+   * Dispatches an event at the specified event target, invoking the affected event listeners in the appropriate order.
+   *
+   * Event listeners can safely be added and removed while an event is being dispatched.
+   *
+   * @see https://262.ecma-international.org/#sec-map.prototype.foreach for more information on the iteration behavior.
+   * @param event - The event to dispatch.
+   * @param target - An event target.
+   */
+  dispatchEvent(event, target = this) {
+    const listenerFunctions = target.listenerFunctions;
+    const listenerObjects = target.listenerObjects;
+    event.target = target;
+    if (listenerFunctions.has(event.type)) {
+      const listeners = listenerFunctions.get(event.type);
+      for (const listener of listeners) {
+        listener.call(target, event);
+      }
+    }
+    if (listenerObjects.has(event.type)) {
+      const listeners = listenerObjects.get(event.type);
+      for (const listener of listeners) {
+        listener.handleEvent(event);
+      }
+    }
+  }
+  /**
+   * Removes all listeners.
+   */
+  clearEventListeners() {
+    this.listenerFunctions.clear();
+    this.listenerObjects.clear();
+  }
+};
+
+// src/core/WheelRotation.ts
+var WheelRotation = /* @__PURE__ */ ((WheelRotation2) => {
+  WheelRotation2["NEGATIVE_X"] = "-x";
+  WheelRotation2["POSITIVE_X"] = "+x";
+  WheelRotation2["NEGATIVE_Y"] = "-y";
+  WheelRotation2["POSITIVE_Y"] = "+y";
+  return WheelRotation2;
+})(WheelRotation || {});
+function getWheelRotation(event) {
+  if (event.deltaY !== 0) {
+    return event.deltaY < 0 ? "-y" /* NEGATIVE_Y */ : "+y" /* POSITIVE_Y */;
+  } else if (event.deltaX !== 0) {
+    return event.deltaX < 0 ? "-x" /* NEGATIVE_X */ : "+x" /* POSITIVE_X */;
+  }
+  return void 0;
+}
+
+// src/settings/Bindings.ts
+function getModifiersFromEvent(event) {
+  let flags = 0;
+  if (event.altKey) {
+    flags = (flags | 1) >>> 0;
+  }
+  if (event.ctrlKey) {
+    flags = (flags | 2) >>> 0;
+  }
+  if (event.metaKey) {
+    flags = (flags | 4) >>> 0;
+  }
+  if (event.shiftKey) {
+    flags = (flags | 8) >>> 0;
+  }
+  return flags;
+}
+var Bindings = class _Bindings {
+  /**
+   * The default bindings.
+   */
+  defaultActions;
+  /**
+   * A collection that maps inputs to actions.
+   */
+  actions;
+  /**
+   * Constructs new input bindings.
+   */
+  constructor() {
+    this.defaultActions = /* @__PURE__ */ new Map();
+    this.actions = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Resets the current bindings to match the default bindings.
+   *
+   * @return This instance.
+   */
+  reset() {
+    this.actions = new Map(this.defaultActions);
+    return this;
+  }
+  /**
+   * Resets the current bindings and establishes default bindings.
+   *
+   * @param actions - A collection that maps inputs to actions.
+   * @return This instance.
+   */
+  setDefault(actions) {
+    this.actions.clear();
+    for (const entry of actions) {
+      this.set(entry[0], entry[1]);
+    }
+    this.defaultActions = new Map(this.actions);
+    return this;
+  }
+  /**
+   * Clears the default bindings.
+   *
+   * @return This instance.
+   */
+  clearDefault() {
+    this.defaultActions.clear();
+    return this;
+  }
+  /**
+   * Clears the current bindings.
+   *
+   * @return This instance.
+   */
+  clear() {
+    this.actions.clear();
+    return this;
+  }
+  /**
+   * Copies the given bindings, including the default bindings.
+   *
+   * @param bindings - Bindings.
+   * @return This instance.
+   */
+  copy(bindings) {
+    this.defaultActions = new Map(bindings.defaultActions);
+    this.actions = new Map(bindings.actions);
+    return this;
+  }
+  /**
+   * Clones these bindings.
+   *
+   * @return The cloned bindings.
+   */
+  clone() {
+    const clone = new _Bindings();
+    return clone.copy(this);
+  }
+  /**
+   * Checks if any actions are bound to the given input.
+   *
+   * @param input - An input.
+   * @return Whether the given input is bound to an action.
+   */
+  has(input) {
+    if (input instanceof Input) {
+      const value = input.value;
+      const modifiers = input.modifiers;
+      return this.actions.get(value)?.some((x) => x.modifiers === modifiers) !== void 0;
+    }
+    return this.actions.has(input);
+  }
+  /**
+   * Returns the action that exactly matches the given input.
+   *
+   * @param input - An input.
+   * @return The action, or undefined if the input is not bound to any action.
+   */
+  get(input) {
+    let value = input;
+    let modifiers = 0;
+    if (input instanceof Input) {
+      value = input.value;
+      modifiers = input.modifiers;
+    }
+    return this.actions.get(value)?.find((x) => x.modifiers === modifiers)?.action;
+  }
+  /**
+   * Binds an action to an input.
+   *
+   * @param input - An input.
+   * @param action - An action.
+   * @return This instance.
+   */
+  set(input, action) {
+    let value = input;
+    let modifiers = 0;
+    if (input instanceof Input) {
+      value = input.value;
+      modifiers = input.modifiers;
+    }
+    if (this.actions.has(value)) {
+      const boundActions = this.actions.get(value);
+      if (!boundActions.some((x) => x.action === action && x.modifiers === modifiers)) {
+        boundActions.push(new BoundAction(action, modifiers));
+      }
+    } else {
+      this.actions.set(value, [new BoundAction(action, modifiers)]);
+    }
+    return this;
+  }
+  /**
+   * Unbinds an action.
+   *
+   * @param input - The input.
+   * @return Whether the binding existed.
+   */
+  delete(input) {
+    let value = input;
+    let modifiers = 0;
+    if (input instanceof Input) {
+      value = input.value;
+      modifiers = input.modifiers;
+    }
+    const boundActions = this.actions.get(value);
+    const match = boundActions?.find((x) => x.modifiers === modifiers);
+    if (boundActions === void 0 || match === void 0) {
+      return false;
+    }
+    if (boundActions.length === 1) {
+      return this.actions.delete(value);
+    }
+    boundActions.splice(boundActions.indexOf(match), 1);
+    return true;
+  }
+  /**
+   * Returns all actions that match the given mouse event.
+   *
+   * @param event - A mouse event
+   * @return The matching actions sorted by specificity, DESC, or undefined if there is no bound action.
+   */
+  matchMouseEvent(event) {
+    const value = event.button;
+    const modifiers = getModifiersFromEvent(event);
+    return this.match(value, modifiers);
+  }
+  /**
+   * Returns all actions that match the given wheel event.
+   *
+   * @param event - A wheel event
+   * @return The matching actions sorted by specificity, DESC, or undefined if there is no bound action.
+   */
+  matchWheelEvent(event) {
+    const value = getWheelRotation(event);
+    const modifiers = getModifiersFromEvent(event);
+    return this.match(value, modifiers);
+  }
+  /**
+   * Returns all actions that match the given keyboard event.
+   *
+   * @param event - A keyboard event
+   * @return The matching actions sorted by specificity, DESC, or undefined if there is no bound action.
+   */
+  matchKeyboardEvent(event) {
+    const value = event.code;
+    const modifiers = getModifiersFromEvent(event);
+    return this.match(value, modifiers);
+  }
+  /**
+   * Returns all actions that match the given input.
+   *
+   * @param input - An input.
+   * @param modifiers - A modifier bitmask. Default is `~0 >>> 0` which allows all modifiers.
+   * @return The matching actions sorted by specificity, DESC, or undefined if there is no bound action.
+   */
+  match(input, modifiers = ~0 >>> 0) {
+    if (!this.actions.has(input)) {
+      return void 0;
+    }
+    return this.actions.get(input).filter((x) => (x.modifiers & modifiers) === x.modifiers).sort((a, b) => b.modifierCount - a.modifierCount).map((x) => x.action);
+  }
+  /**
+   * Copies the given JSON data.
+   *
+   * @param json - The JSON data.
+   * @return This instance.
+   */
+  fromJSON(json) {
+    if (typeof json === "string") {
+      json = JSON.parse(json);
+    }
+    this.defaultActions = new Map(json.defaultActions);
+    this.actions = new Map(json.actions);
+    return this;
+  }
+  toJSON() {
+    return {
+      defaultActions: [...this.defaultActions],
+      actions: [...this.actions]
+    };
+  }
+};
+
+// src/settings/PointerSettings.ts
+var PointerSettings = class _PointerSettings extends EventTarget {
+  // #region Backing Data
+  /**
+   * @see {@link sensitivityX}
+   */
+  _sensitivityX;
+  /**
+   * @see {@link sensitivityY}
+   */
+  _sensitivityY;
+  /**
+   * @see {@link lockBehavior}
+   */
+  _lockBehavior;
+  // #endregion
+  /**
+   * Constructs new pointer settings.
+   */
+  constructor() {
+    super();
+    this._sensitivityX = 1e-3;
+    this._sensitivityY = 1e-3;
+    this._lockBehavior = /* @__PURE__ */ new Map();
+  }
+  /**
+   * The horizontal sensitivity.
+   *
+   * This sensitivity acts as a baseline scale for pointer movement deltas.
+   *
+   * @defaultValue 1e-3
+   */
+  get sensitivityX() {
+    return this._sensitivityX;
+  }
+  set sensitivityX(value) {
+    this._sensitivityX = value;
+    this.dispatchEvent({ type: "change" });
+  }
+  /**
+   * The vertical sensitivity.
+   *
+   * This sensitivity acts as a baseline scale for pointer movement deltas.
+   *
+   * @defaultValue 1e-3
+   */
+  get sensitivityY() {
+    return this._sensitivityY;
+  }
+  set sensitivityY(value) {
+    this._sensitivityY = value;
+    this.dispatchEvent({ type: "change" });
+  }
+  /**
+   * Sets the horizontal and vertical rotation sensitivity.
+   *
+   * This sensitivity acts as a baseline scale for pointer movement deltas.
+   *
+   * @defaultValue 1e-3
+   */
+  set sensitivity(value) {
+    this._sensitivityX = value;
+    this._sensitivityY = value;
+    this.dispatchEvent({ type: "change" });
+  }
+  /**
+   * Defines the pointer lock behavior.
+   *
+   * The behavior defaults to `none` if not set.
+   *
+   * @see {@link setLockBehavior} for changing the pointer behavior.
+   * @internal
+   */
+  get lockBehavior() {
+    return this._lockBehavior;
+  }
+  set lockBehavior(value) {
+    this._lockBehavior = value;
+  }
+  /**
+   * Returns the pointer behavior for a specific button.
+   *
+   * @param button - A pointer button.
+   * @return The behavior.
+   */
+  getLockBehavior(button) {
+    return this._lockBehavior.get(button) ?? "none";
+  }
+  /**
+   * Sets the pointer behavior for a specific button.
+   *
+   * @param button - The button.
+   * @param behavior - The behavior.
+   */
+  setLockBehavior(button, behavior) {
+    this._lockBehavior.set(button, behavior);
+    this.dispatchEvent({ type: "change" });
+  }
+  /**
+   * Copies the given pointer settings.
+   *
+   * @param settings - Pointer settings.
+   * @return This instance.
+   */
+  copy(settings) {
+    this.lockBehavior = new Map(settings.lockBehavior);
+    this.sensitivity = settings.sensitivity;
+    return this;
+  }
+  /**
+   * Clones this pointer settings instance.
+   *
+   * @return The cloned pointer settings.
+   */
+  clone() {
+    const clone = new _PointerSettings();
+    return clone.copy(this);
+  }
+  /**
+   * Copies the given JSON data.
+   *
+   * @param json - The JSON data.
+   * @return This instance.
+   */
+  fromJSON(json) {
+    if (typeof json === "string") {
+      json = JSON.parse(json);
+    }
+    this.lockBehavior = new Map(json.lockBehavior);
+    this.sensitivity = json.sensitivity;
+    return this;
+  }
+  toJSON() {
+    return {
+      behaviour: Array.from(this.lockBehavior.entries()),
+      sensitivity: this.sensitivity
+    };
+  }
+};
+
+// src/settings/InputSettings.ts
+var InputSettings = class _InputSettings extends EventTarget {
+  /**
+   * Key bindings.
+   */
+  keyBindings;
+  /**
+   * Pointer bindings.
+   */
+  pointerBindings;
+  /**
+   * Pointer settings.
+   */
+  pointer;
+  /**
+   * Constructs new pointer settings.
+   */
+  constructor() {
+    super();
+    this.keyBindings = new Bindings();
+    this.pointerBindings = new Bindings();
+    this.pointer = new PointerSettings();
+    this.pointer.addEventListener("change", (e) => this.dispatchEvent(e));
+  }
+  /**
+   * Copies the given pointer settings.
+   *
+   * @param settings - Pointer settings.
+   * @return This instance.
+   */
+  copy(settings) {
+    this.keyBindings.copy(settings.keyBindings);
+    this.pointerBindings.copy(settings.pointerBindings);
+    this.pointer.copy(settings.pointer);
+    return this;
+  }
+  /**
+   * Clones this pointer settings instance.
+   *
+   * @return The cloned pointer settings.
+   */
+  clone() {
+    const clone = new _InputSettings();
+    return clone.copy(this);
+  }
+  /**
+   * Copies the given JSON data.
+   *
+   * @param json - The JSON data.
+   * @return This instance.
+   */
+  fromJSON(json) {
+    if (typeof json === "string") {
+      json = JSON.parse(json);
+    }
+    this.keyBindings.fromJSON(json.keyBindings);
+    this.pointerBindings.fromJSON(json.pointerBindings);
+    this.pointer.fromJSON(json.pointer);
+    return this;
+  }
+  toJSON() {
+    return {
+      keyBindings: this.keyBindings,
+      pointerBindings: this.pointerBindings,
+      pointer: this.pointer
+    };
+  }
+  /**
+   * Exports these settings as a data blob.
+   *
+   * @return The settings blob.
+   */
+  toBlob() {
+    return new Blob([JSON.stringify(this)], {
+      type: "text/json"
+    });
+  }
+};
+
+// src/core/InputManager.ts
+var screen = { x: 0, y: 0 };
+var InputManager = class extends EventTarget {
+  // #region Backing Data
+  /**
+   * @see {@link domElement}
+   */
+  _domElement;
+  /**
+   * @see {@link enabled}
+   */
+  _enabled;
+  // #endregion
+  // #region Input State
+  /**
+   * A collection that organizes active pointer events by ID.
+   */
+  pointerEvents;
+  /**
+   * A collection of deferred mouse events that are handled when the pointer lock state changes.
+   */
+  deferredMouseEvents;
+  /**
+   * A collection of actions that are currently active.
+   */
+  activeActions;
+  // #endregion
+  // #region Reusable Events
+  movementEvent;
+  // #endregion
+  /**
+   * The settings.
+   */
+  settings;
+  /**
+   * Constructs a new input manager.
+   *
+   * @param options - The options.
+   */
+  constructor({ settings = new InputSettings(), domElement = null } = {}) {
+    super();
+    this._domElement = null;
+    this._enabled = false;
+    this.pointerEvents = /* @__PURE__ */ new Map();
+    this.deferredMouseEvents = /* @__PURE__ */ new Set();
+    this.activeActions = /* @__PURE__ */ new Set();
+    this.movementEvent = {
+      type: "move",
+      pointerCount: 0,
+      deltaX: 0,
+      deltaY: 0,
+      x: 0,
+      y: 0
+    };
+    this.settings = settings;
+    settings.addEventListener("change", this);
+    this.domElement = domElement;
+    this.enabled = true;
+  }
+  /**
+   * A DOM element that acts as the primary event target.
+   */
+  get domElement() {
+    return this._domElement;
+  }
+  set domElement(value) {
+    this.removeEventListeners();
+    this._domElement = value;
+    if (this.enabled) {
+      this.addEventListeners();
+    }
+  }
+  /**
+   * Determines whether the input listeners are currently enabled.
+   */
+  get enabled() {
+    return this._enabled;
+  }
+  set enabled(value) {
+    if (value === this.enabled) {
+      return;
+    }
+    this._enabled = value;
+    if (value) {
+      this.addEventListeners();
+    } else {
+      this.removeEventListeners();
+      this.resetInputState();
+    }
+  }
+  /**
+   * Indicates whether the pointer is currently locked.
+   */
+  get pointerLocked() {
+    return document.pointerLockElement === this.domElement;
+  }
+  /**
+   * Registers event listeners.
+   */
+  addEventListeners() {
+    if (this.domElement === null || typeof document === "undefined") {
+      return;
+    }
+    const domElement = this.domElement;
+    domElement.style.touchAction = "none";
+    document.addEventListener("pointerlockchange", this);
+    document.addEventListener("pointerlockerror", this);
+    document.addEventListener("visibilitychange", this);
+    document.body.addEventListener("keyup", this);
+    document.body.addEventListener("keydown", this);
+    domElement.addEventListener("pointermove", this, { passive: true });
+    domElement.addEventListener("mousedown", this);
+    domElement.addEventListener("mouseup", this);
+    domElement.addEventListener("pointerdown", this);
+    domElement.addEventListener("pointerup", this);
+    domElement.addEventListener("pointercancel", this);
+    domElement.addEventListener("wheel", this);
+    domElement.addEventListener("contextmenu", this);
+  }
+  /**
+   * Unregisters event listeners.
+   */
+  removeEventListeners() {
+    if (this.domElement === null || typeof document === "undefined") {
+      return;
+    }
+    const domElement = this.domElement;
+    domElement.style.touchAction = "";
+    document.removeEventListener("pointerlockchange", this);
+    document.removeEventListener("pointerlockerror", this);
+    document.removeEventListener("visibilitychange", this);
+    document.body.removeEventListener("keyup", this);
+    document.body.removeEventListener("keydown", this);
+    domElement.removeEventListener("pointermove", this);
+    domElement.removeEventListener("mousedown", this);
+    domElement.removeEventListener("mouseup", this);
+    domElement.removeEventListener("pointerdown", this);
+    domElement.removeEventListener("pointerup", this);
+    domElement.removeEventListener("pointercancel", this);
+    domElement.removeEventListener("wheel", this);
+    domElement.removeEventListener("contextmenu", this);
+  }
+  /**
+   * Reset the input state.
+   */
+  resetInputState() {
+    this.pointerEvents.clear();
+    this.deferredMouseEvents.clear();
+    this.activeActions.clear();
+    this.unlockPointer();
+    this.dispatchEvent({
+      type: "reset"
+    });
+  }
+  /**
+   * Locks the pointer.
+   *
+   * @return A promise that resolves when the pointer has been locked.
+   */
+  async lockPointer() {
+    if (this.domElement?.requestPointerLock === void 0 || this.pointerLocked) {
+      return;
+    }
+    try {
+      await this.domElement.requestPointerLock();
+    } catch (e) {
+      console.warn(e);
+    }
+  }
+  /**
+   * Unlocks the pointer.
+   */
+  unlockPointer() {
+    if (document.exitPointerLock === void 0 || !this.pointerLocked) {
+      return;
+    }
+    document.exitPointerLock();
+  }
+  // #region Event Handling
+  /**
+   * Handles pointer move events.
+   *
+   * @param event - A pointer event.
+   */
+  onPointerMove(event) {
+    if (this.pointerEvents.has(event.pointerId)) {
+      this.pointerEvents.set(event.pointerId, event);
+    } else if (!this.pointerLocked) {
+      return;
+    }
+    let { movementX, movementY } = event;
+    if (movementX === void 0 || movementY === void 0) {
+      movementX = event.screenX - screen.x;
+      movementY = event.screenY - screen.y;
+      screen.x = event.screenX;
+      screen.y = event.screenY;
+    }
+    const movementEvent = this.movementEvent;
+    const sensitivityX = this.settings.pointer.sensitivityX;
+    const sensitivityY = this.settings.pointer.sensitivityY;
+    movementEvent.pointerCount = this.pointerEvents.size;
+    movementEvent.deltaX = movementX * sensitivityX;
+    movementEvent.deltaY = movementY * sensitivityY;
+    movementEvent.x = event.screenX;
+    movementEvent.y = event.screenY;
+    this.dispatchEvent(movementEvent);
+  }
+  /**
+   * Handles pointer lock change events.
+   */
+  onPointerLockChange() {
+    if (this.pointerLocked) {
+      for (const event of this.deferredMouseEvents) {
+        this.onMouseDown(event);
+      }
+      return;
+    }
+    for (const event of this.deferredMouseEvents) {
+      this.onMouseUp(event);
+    }
+    this.deferredMouseEvents.clear();
+  }
+  /**
+   * Handles `mousedown` events.
+   *
+   * Mouse events are used because pointer events don't fire for other mouse buttons while a pointer is active.
+   *
+   * @param event - A mouse event.
+   */
+  onMouseDownNative(event) {
+    const behavior = this.settings.pointer.getLockBehavior(event.button);
+    if (behavior === "lock") {
+      this.deferredMouseEvents.add(event);
+      void this.lockPointer();
+      if (this.pointerLocked) {
+        this.onMouseDown(event);
+      }
+      return;
+    }
+    if (behavior === "lock-hold") {
+      void this.lockPointer();
+    }
+    this.onMouseDown(event);
+  }
+  /**
+   * Handles `mouseup` events.
+   *
+   * Mouse events are used because pointer events don't fire for other mouse buttons while a pointer is active.
+   *
+   * @param event - A mouse event.
+   */
+  onMouseUpNative(event) {
+    if (this.settings.pointer.getLockBehavior(event.button) !== "lock") {
+      this.onMouseUp(event);
+    }
+  }
+  /**
+   * Handles `mousedown` events.
+   *
+   * @param event - A mouse event.
+   */
+  onMouseDown(event) {
+    const actions = this.settings.pointerBindings.matchMouseEvent(event);
+    if (actions === void 0 || actions.length === 0) {
+      return;
+    }
+    this.dispatchEvent({
+      type: "activate",
+      action: actions[0]
+    });
+    this.activeActions.add(actions[0]);
+  }
+  /**
+   * Handles `mouseup` events.
+   *
+   * @param event - A mouse event.
+   */
+  onMouseUp(event) {
+    const actions = this.settings.pointerBindings.match(event.button);
+    if (actions === void 0 || actions.length === 0) {
+      return;
+    }
+    for (const action of actions) {
+      if (!this.activeActions.has(action)) {
+        continue;
+      }
+      this.dispatchEvent({
+        type: "deactivate",
+        action
+      });
+      this.activeActions.delete(action);
+    }
+  }
+  /**
+   * Handles `pointerdown` events.
+   *
+   * @param event - A pointer event.
+   */
+  onPointerDown(event) {
+    this.pointerEvents.set(event.pointerId, event);
+    screen.x = event.screenX;
+    screen.y = event.screenY;
+    if (!this.pointerLocked && this.settings.pointer.getLockBehavior(event.button) === "none") {
+      this.domElement?.setPointerCapture(event.pointerId);
+    }
+    if (event.pointerType !== "mouse") {
+      this.onMouseDown(event);
+      event.preventDefault();
+    }
+  }
+  /**
+   * Handles `pointerup` events.
+   *
+   * @param event - A pointer event.
+   */
+  onPointerUp(event) {
+    this.pointerEvents.delete(event.pointerId);
+    if (event.pointerType !== "mouse") {
+      this.onMouseUp(event);
+      event.preventDefault();
+    }
+  }
+  /**
+   * Handles `contextmenu` events.
+   *
+   * @param event - A pointer event.
+   */
+  onContextMenu(event) {
+    if (this.settings.pointerBindings.matchMouseEvent(event)?.length !== 0) {
+      event.preventDefault();
+    }
+  }
+  /**
+   * Handles `wheel` events.
+   *
+   * @param event - A wheel event.
+   */
+  onWheel(event) {
+    const actions = this.settings.pointerBindings.matchWheelEvent(event);
+    if (actions === void 0 || actions.length === 0) {
+      return;
+    }
+    event.preventDefault();
+    this.dispatchEvent({
+      type: "activate",
+      action: actions[0]
+    });
+    this.activeActions.add(actions[0]);
+  }
+  /**
+   * Handles `keydown` events.
+   *
+   * @param event - A keyboard event.
+   */
+  onKeyDown(event) {
+    if (event.repeat) {
+      return;
+    }
+    const actions = this.settings.keyBindings.matchKeyboardEvent(event);
+    if (actions === void 0 || actions.length === 0) {
+      return;
+    }
+    event.preventDefault();
+    this.dispatchEvent({
+      type: "activate",
+      action: actions[0]
+    });
+    this.activeActions.add(actions[0]);
+  }
+  /**
+   * Handles `keyup` events.
+   *
+   * @param event - A keyboard event.
+   */
+  onKeyUp(event) {
+    const actions = this.settings.keyBindings.match(event.code);
+    if (actions === void 0 || actions.length === 0) {
+      return;
+    }
+    event.preventDefault();
+    for (const action of actions) {
+      if (!this.activeActions.has(action)) {
+        continue;
+      }
+      this.dispatchEvent({
+        type: "deactivate",
+        action
+      });
+      this.activeActions.delete(action);
+    }
+  }
+  /**
+   * Handles `pointercancel` events.
+   *
+   * @param event - A pointer event.
+   */
+  onPointerCancel(event) {
+    this.resetInputState();
+  }
+  /**
+   * Cancels active interactions on visibility loss.
+   */
+  onVisibilityChange() {
+    if (document.hidden) {
+      this.resetInputState();
+    }
+  }
+  handleEvent(event) {
+    switch (event.type) {
+      case "pointermove":
+        this.onPointerMove(event);
+        break;
+      case "mousedown":
+        this.onMouseDownNative(event);
+        break;
+      case "mouseup":
+        this.onMouseUpNative(event);
+        break;
+      case "pointerdown":
+        this.onPointerDown(event);
+        break;
+      case "pointerup":
+        this.onPointerUp(event);
+        break;
+      case "pointercancel":
+        this.onPointerCancel(event);
+        break;
+      case "pointerlockchange":
+        this.onPointerLockChange();
+        break;
+      case "contextmenu":
+        this.onContextMenu(event);
+        break;
+      case "wheel":
+        this.onWheel(event);
+        break;
+      case "keydown":
+        this.onKeyDown(event);
+        break;
+      case "keyup":
+        this.onKeyUp(event);
+        break;
+      case "visibilitychange":
+        this.onVisibilityChange();
+        break;
+    }
+  }
+  // #endregion
+  dispose() {
+    this.enabled = false;
+  }
+};
+
+// src/core/PointerButton.ts
+var PointerButton = /* @__PURE__ */ ((PointerButton2) => {
+  PointerButton2[PointerButton2["MAIN"] = 0] = "MAIN";
+  PointerButton2[PointerButton2["AUXILIARY"] = 1] = "AUXILIARY";
+  PointerButton2[PointerButton2["SECONDARY"] = 2] = "SECONDARY";
+  return PointerButton2;
+})(PointerButton || {});
+export {
+  Bindings,
+  BoundAction,
+  Input,
+  InputManager,
+  InputSettings,
+  PointerButton,
+  PointerSettings,
+  WheelRotation,
+  getWheelRotation
+};
+/*! Bundled license information:
+
+synthetic-event/dist/index.js:
+  (**
+   * synthetic-event v2.0.0 build Sat Jan 10 2026
+   * https://github.com/vanruesc/synthetic-event
+   * Copyright 2026 Raoul van Rüschen
+   * @license Zlib
+   *)
+*/