@codexo/exojs 0.6.5 → 0.6.7

package/dist/exo.esm.js

@@ -10851,6 +10851,89 @@ var ChannelOffset;
     ChannelOffset[ChannelOffset["Pointers"] = 256] = "Pointers";
     ChannelOffset[ChannelOffset["Gamepads"] = 512] = "Gamepads";
 })(ChannelOffset || (ChannelOffset = {}));
+/** Maximum number of simultaneous tracked pointers (mouse / touch / pen). */
+const maxPointers = 16;
+/** Number of channel slots reserved per pointer. 16 pointers × 16 slots = 256 (fills the Pointers category exactly). */
+const pointerSlotSize = 16;
+/**
+ * Channel offsets for unified pointer (mouse / touch / pen) state.
+ *
+ * The un-prefixed aliases (Active, X, Y, …) are identical to Slot0Active, Slot0X, Slot0Y, …
+ * and address the primary pointer (slot 0). Use Slot{N}Active / Slot{N}X / Slot{N}Y for
+ * multi-pointer (e.g. pinch) access. Other per-slot channels beyond Active/X/Y are reachable
+ * via arithmetic: `Pointer.X + slotIndex * pointerSlotSize + channelOffset` (Pointer.X = PointerChannel.X).
+ *
+ * @internal — accessed publicly via the `Pointer` class namespace (see Pointer.ts).
+ */
+var PointerChannel;
+(function (PointerChannel) {
+    // --- Convenience aliases for the primary pointer (slot 0) ---
+    PointerChannel[PointerChannel["Active"] = 256] = "Active";
+    PointerChannel[PointerChannel["X"] = 257] = "X";
+    PointerChannel[PointerChannel["Y"] = 258] = "Y";
+    PointerChannel[PointerChannel["Pressure"] = 259] = "Pressure";
+    PointerChannel[PointerChannel["Width"] = 260] = "Width";
+    PointerChannel[PointerChannel["Height"] = 261] = "Height";
+    PointerChannel[PointerChannel["Twist"] = 262] = "Twist";
+    PointerChannel[PointerChannel["TiltX"] = 263] = "TiltX";
+    PointerChannel[PointerChannel["TiltY"] = 264] = "TiltY";
+    PointerChannel[PointerChannel["Left"] = 265] = "Left";
+    PointerChannel[PointerChannel["Right"] = 266] = "Right";
+    PointerChannel[PointerChannel["Middle"] = 267] = "Middle";
+    PointerChannel[PointerChannel["IsMouse"] = 268] = "IsMouse";
+    PointerChannel[PointerChannel["IsTouch"] = 269] = "IsTouch";
+    PointerChannel[PointerChannel["IsPen"] = 270] = "IsPen";
+    PointerChannel[PointerChannel["IsPrimary"] = 271] = "IsPrimary";
+    // --- Per-slot Active/X/Y for multi-pointer access ---
+    PointerChannel[PointerChannel["Slot0Active"] = 256] = "Slot0Active";
+    PointerChannel[PointerChannel["Slot0X"] = 257] = "Slot0X";
+    PointerChannel[PointerChannel["Slot0Y"] = 258] = "Slot0Y";
+    PointerChannel[PointerChannel["Slot1Active"] = 272] = "Slot1Active";
+    PointerChannel[PointerChannel["Slot1X"] = 273] = "Slot1X";
+    PointerChannel[PointerChannel["Slot1Y"] = 274] = "Slot1Y";
+    PointerChannel[PointerChannel["Slot2Active"] = 288] = "Slot2Active";
+    PointerChannel[PointerChannel["Slot2X"] = 289] = "Slot2X";
+    PointerChannel[PointerChannel["Slot2Y"] = 290] = "Slot2Y";
+    PointerChannel[PointerChannel["Slot3Active"] = 304] = "Slot3Active";
+    PointerChannel[PointerChannel["Slot3X"] = 305] = "Slot3X";
+    PointerChannel[PointerChannel["Slot3Y"] = 306] = "Slot3Y";
+    PointerChannel[PointerChannel["Slot4Active"] = 320] = "Slot4Active";
+    PointerChannel[PointerChannel["Slot4X"] = 321] = "Slot4X";
+    PointerChannel[PointerChannel["Slot4Y"] = 322] = "Slot4Y";
+    PointerChannel[PointerChannel["Slot5Active"] = 336] = "Slot5Active";
+    PointerChannel[PointerChannel["Slot5X"] = 337] = "Slot5X";
+    PointerChannel[PointerChannel["Slot5Y"] = 338] = "Slot5Y";
+    PointerChannel[PointerChannel["Slot6Active"] = 352] = "Slot6Active";
+    PointerChannel[PointerChannel["Slot6X"] = 353] = "Slot6X";
+    PointerChannel[PointerChannel["Slot6Y"] = 354] = "Slot6Y";
+    PointerChannel[PointerChannel["Slot7Active"] = 368] = "Slot7Active";
+    PointerChannel[PointerChannel["Slot7X"] = 369] = "Slot7X";
+    PointerChannel[PointerChannel["Slot7Y"] = 370] = "Slot7Y";
+    PointerChannel[PointerChannel["Slot8Active"] = 384] = "Slot8Active";
+    PointerChannel[PointerChannel["Slot8X"] = 385] = "Slot8X";
+    PointerChannel[PointerChannel["Slot8Y"] = 386] = "Slot8Y";
+    PointerChannel[PointerChannel["Slot9Active"] = 400] = "Slot9Active";
+    PointerChannel[PointerChannel["Slot9X"] = 401] = "Slot9X";
+    PointerChannel[PointerChannel["Slot9Y"] = 402] = "Slot9Y";
+    PointerChannel[PointerChannel["Slot10Active"] = 416] = "Slot10Active";
+    PointerChannel[PointerChannel["Slot10X"] = 417] = "Slot10X";
+    PointerChannel[PointerChannel["Slot10Y"] = 418] = "Slot10Y";
+    PointerChannel[PointerChannel["Slot11Active"] = 432] = "Slot11Active";
+    PointerChannel[PointerChannel["Slot11X"] = 433] = "Slot11X";
+    PointerChannel[PointerChannel["Slot11Y"] = 434] = "Slot11Y";
+    PointerChannel[PointerChannel["Slot12Active"] = 448] = "Slot12Active";
+    PointerChannel[PointerChannel["Slot12X"] = 449] = "Slot12X";
+    PointerChannel[PointerChannel["Slot12Y"] = 450] = "Slot12Y";
+    PointerChannel[PointerChannel["Slot13Active"] = 464] = "Slot13Active";
+    PointerChannel[PointerChannel["Slot13X"] = 465] = "Slot13X";
+    PointerChannel[PointerChannel["Slot13Y"] = 466] = "Slot13Y";
+    PointerChannel[PointerChannel["Slot14Active"] = 480] = "Slot14Active";
+    PointerChannel[PointerChannel["Slot14X"] = 481] = "Slot14X";
+    PointerChannel[PointerChannel["Slot14Y"] = 482] = "Slot14Y";
+    PointerChannel[PointerChannel["Slot15Active"] = 496] = "Slot15Active";
+    PointerChannel[PointerChannel["Slot15X"] = 497] = "Slot15X";
+    PointerChannel[PointerChannel["Slot15Y"] = 498] = "Slot15Y";
+})(PointerChannel || (PointerChannel = {}));
 var Keyboard;
 (function (Keyboard) {
     Keyboard[Keyboard["Backspace"] = 8] = "Backspace";
@@ -11132,14 +11215,21 @@ class Pointer {
     tilt;
     stateFlags = new Flags();
     _canvas;
+    _channels;
+    _slotIndex;
+    _channelBase;
     _buttons;
     _pressure;
     _rotation;
+    _isPrimary;
     _currentState = PointerState.Unknown;
-    constructor(event, canvas) {
-        const { pointerId, pointerType, clientX, clientY, width, height, tiltX, tiltY, buttons, pressure, twist } = event;
+    constructor(event, canvas, channels, slotIndex) {
+        const { pointerId, pointerType, clientX, clientY, width, height, tiltX, tiltY, buttons, pressure, twist, isPrimary } = event;
         const { left, top } = canvas.getBoundingClientRect();
         this._canvas = canvas;
+        this._channels = channels;
+        this._slotIndex = slotIndex;
+        this._channelBase = ChannelOffset.Pointers + slotIndex * pointerSlotSize;
         this.id = pointerId;
         this.type = pointerType;
         this.position = new Vector(clientX - left, clientY - top);
@@ -11148,7 +11238,9 @@ class Pointer {
         this._buttons = buttons;
         this._pressure = pressure;
         this._rotation = twist;
+        this._isPrimary = isPrimary;
         this.stateFlags.push(PointerStateFlag.Over);
+        this._writeChannels(true);
     }
     get x() {
         return this.position.x;
@@ -11171,48 +11263,71 @@ class Pointer {
     get rotation() {
         return this._rotation;
     }
+    get twist() {
+        return this._rotation;
+    }
+    get tiltX() {
+        return this.tilt.x;
+    }
+    get tiltY() {
+        return this.tilt.y;
+    }
+    get isPrimary() {
+        return this._isPrimary;
+    }
+    get slotIndex() {
+        return this._slotIndex;
+    }
     get currentState() {
         return this._currentState;
     }
     handleEnter(event) {
         this.handleEvent(event);
         this._currentState = PointerState.InsideCanvas;
+        this._writeChannels(true);
     }
     handleLeave(event) {
         this.handleEvent(event);
         this.stateFlags.push(PointerStateFlag.Leave);
         this._currentState = PointerState.OutsideCanvas;
+        this._writeChannels(false);
     }
     handlePress(event) {
         this.handleEvent(event);
         this.startPos.copy(this.position);
         this.stateFlags.push(PointerStateFlag.Down);
         this._currentState = PointerState.Pressed;
+        this._writeChannels(true);
     }
     handleMove(event) {
         this.handleEvent(event);
         this.stateFlags.push(PointerStateFlag.Move);
         this._currentState = PointerState.Moving;
+        this._writeChannels(true);
     }
     handleRelease(event) {
         this.handleEvent(event);
         this.stateFlags.push(PointerStateFlag.Up);
         this._currentState = PointerState.Released;
+        this._writeChannels(true);
     }
     handleCancel(event) {
         this.handleEvent(event);
         this.stateFlags.push(PointerStateFlag.Cancel);
         this._currentState = PointerState.Cancelled;
+        this._writeChannels(false);
     }
     destroy() {
+        this._clearChannels();
         this.position.destroy();
         this.startPos.destroy();
         this.size.destroy();
         this.tilt.destroy();
         this._canvas = null;
+        this._channels = null;
     }
     handleEvent(event) {
-        const { clientX, clientY, width, height, tiltX, tiltY, buttons, pressure, twist } = event;
+        const { clientX, clientY, width, height, tiltX, tiltY, buttons, pressure, twist, isPrimary } = event;
         const { left, top } = this._canvas.getBoundingClientRect();
         this.position.set(clientX - left, clientY - top);
         this.size.set(width, height);
@@ -11220,8 +11335,263 @@ class Pointer {
         this._buttons = buttons;
         this._pressure = pressure;
         this._rotation = twist;
+        this._isPrimary = isPrimary;
         return this;
     }
+    /** Write the full 16-channel per-pointer state into the shared channel buffer. */
+    _writeChannels(active) {
+        const ch = this._channels;
+        const canvas = this._canvas;
+        if (!ch || !canvas) {
+            return;
+        }
+        const base = this._channelBase;
+        const w = canvas.width || 1;
+        const h = canvas.height || 1;
+        if (!active) {
+            // Zero the entire slot for a clean release.
+            for (let i = 0; i < pointerSlotSize; i++) {
+                ch[base + i] = 0;
+            }
+            return;
+        }
+        const x = Math.min(1, Math.max(0, this.position.x / w));
+        const y = Math.min(1, Math.max(0, this.position.y / h));
+        ch[base + 0] = 1; // active
+        ch[base + 1] = x; // x (normalized)
+        ch[base + 2] = y; // y (normalized)
+        ch[base + 3] = this._pressure; // pressure
+        ch[base + 4] = Math.min(1, this.size.width / w); // width (normalized)
+        ch[base + 5] = Math.min(1, this.size.height / h); // height (normalized)
+        ch[base + 6] = this._rotation / 359; // twist (0..359 → 0..1)
+        ch[base + 7] = (this.tilt.x + 90) / 180; // tiltX (-90..90 → 0..1)
+        ch[base + 8] = (this.tilt.y + 90) / 180; // tiltY (-90..90 → 0..1)
+        ch[base + 9] = (this._buttons & 1) ? 1 : 0; // button.left
+        ch[base + 10] = (this._buttons & 2) ? 1 : 0; // button.right
+        ch[base + 11] = (this._buttons & 4) ? 1 : 0; // button.middle
+        ch[base + 12] = this.type === 'mouse' ? 1 : 0; // isMouse
+        ch[base + 13] = this.type === 'touch' ? 1 : 0; // isTouch
+        ch[base + 14] = this.type === 'pen' ? 1 : 0; // isPen
+        ch[base + 15] = this._isPrimary ? 1 : 0; // isPrimary
+    }
+    /** Zero the slot when this pointer is fully released/destroyed. */
+    _clearChannels() {
+        const ch = this._channels;
+        if (!ch) {
+            return;
+        }
+        const base = this._channelBase;
+        for (let i = 0; i < pointerSlotSize; i++) {
+            ch[base + i] = 0;
+        }
+    }
+}
+/**
+ * Namespace merged onto the `Pointer` class to expose channel-offset constants.
+ * All members mirror `PointerChannel` so callers can write `Pointer.Active`, `Pointer.X`, etc.
+ *
+ * The un-prefixed members (Active, X, Y, …) address slot 0 (the primary pointer).
+ * For multi-touch access use `Pointer.Slot{N}Active / Slot{N}X / Slot{N}Y`, or compute:
+ * `Pointer.X + slotIndex * pointerSlotSize + channelOffset`.
+ */
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (Pointer) {
+    /* eslint-disable @typescript-eslint/naming-convention */
+    // --- Primary-pointer convenience aliases (slot 0) ---
+    Pointer.Active = PointerChannel.Active;
+    Pointer.X = PointerChannel.X;
+    Pointer.Y = PointerChannel.Y;
+    Pointer.Pressure = PointerChannel.Pressure;
+    Pointer.Width = PointerChannel.Width;
+    Pointer.Height = PointerChannel.Height;
+    Pointer.Twist = PointerChannel.Twist;
+    Pointer.TiltX = PointerChannel.TiltX;
+    Pointer.TiltY = PointerChannel.TiltY;
+    Pointer.Left = PointerChannel.Left;
+    Pointer.Right = PointerChannel.Right;
+    Pointer.Middle = PointerChannel.Middle;
+    Pointer.IsMouse = PointerChannel.IsMouse;
+    Pointer.IsTouch = PointerChannel.IsTouch;
+    Pointer.IsPen = PointerChannel.IsPen;
+    Pointer.IsPrimary = PointerChannel.IsPrimary;
+    // --- Per-slot Active/X/Y for multi-pointer access ---
+    Pointer.Slot0Active = PointerChannel.Slot0Active;
+    Pointer.Slot0X = PointerChannel.Slot0X;
+    Pointer.Slot0Y = PointerChannel.Slot0Y;
+    Pointer.Slot1Active = PointerChannel.Slot1Active;
+    Pointer.Slot1X = PointerChannel.Slot1X;
+    Pointer.Slot1Y = PointerChannel.Slot1Y;
+    Pointer.Slot2Active = PointerChannel.Slot2Active;
+    Pointer.Slot2X = PointerChannel.Slot2X;
+    Pointer.Slot2Y = PointerChannel.Slot2Y;
+    Pointer.Slot3Active = PointerChannel.Slot3Active;
+    Pointer.Slot3X = PointerChannel.Slot3X;
+    Pointer.Slot3Y = PointerChannel.Slot3Y;
+    Pointer.Slot4Active = PointerChannel.Slot4Active;
+    Pointer.Slot4X = PointerChannel.Slot4X;
+    Pointer.Slot4Y = PointerChannel.Slot4Y;
+    Pointer.Slot5Active = PointerChannel.Slot5Active;
+    Pointer.Slot5X = PointerChannel.Slot5X;
+    Pointer.Slot5Y = PointerChannel.Slot5Y;
+    Pointer.Slot6Active = PointerChannel.Slot6Active;
+    Pointer.Slot6X = PointerChannel.Slot6X;
+    Pointer.Slot6Y = PointerChannel.Slot6Y;
+    Pointer.Slot7Active = PointerChannel.Slot7Active;
+    Pointer.Slot7X = PointerChannel.Slot7X;
+    Pointer.Slot7Y = PointerChannel.Slot7Y;
+    Pointer.Slot8Active = PointerChannel.Slot8Active;
+    Pointer.Slot8X = PointerChannel.Slot8X;
+    Pointer.Slot8Y = PointerChannel.Slot8Y;
+    Pointer.Slot9Active = PointerChannel.Slot9Active;
+    Pointer.Slot9X = PointerChannel.Slot9X;
+    Pointer.Slot9Y = PointerChannel.Slot9Y;
+    Pointer.Slot10Active = PointerChannel.Slot10Active;
+    Pointer.Slot10X = PointerChannel.Slot10X;
+    Pointer.Slot10Y = PointerChannel.Slot10Y;
+    Pointer.Slot11Active = PointerChannel.Slot11Active;
+    Pointer.Slot11X = PointerChannel.Slot11X;
+    Pointer.Slot11Y = PointerChannel.Slot11Y;
+    Pointer.Slot12Active = PointerChannel.Slot12Active;
+    Pointer.Slot12X = PointerChannel.Slot12X;
+    Pointer.Slot12Y = PointerChannel.Slot12Y;
+    Pointer.Slot13Active = PointerChannel.Slot13Active;
+    Pointer.Slot13X = PointerChannel.Slot13X;
+    Pointer.Slot13Y = PointerChannel.Slot13Y;
+    Pointer.Slot14Active = PointerChannel.Slot14Active;
+    Pointer.Slot14X = PointerChannel.Slot14X;
+    Pointer.Slot14Y = PointerChannel.Slot14Y;
+    Pointer.Slot15Active = PointerChannel.Slot15Active;
+    Pointer.Slot15X = PointerChannel.Slot15X;
+    Pointer.Slot15Y = PointerChannel.Slot15Y;
+    /* eslint-enable @typescript-eslint/naming-convention */
+})(Pointer || (Pointer = {}));
+
+/** Long-press threshold in milliseconds. */
+const longPressMs = 500;
+/**
+ * Internal gesture recognizer — NOT exported publicly.
+ * Receives pointer lifecycle events from InputManager and fires gesture signals.
+ */
+class GestureRecognizer {
+    onPinch;
+    onRotate;
+    onLongPress;
+    distanceThreshold;
+    // Active touch pointers (only touch type; index in order of arrival).
+    touchPointers = new Map();
+    // Long-press state per pointer.
+    longPressEntries = new Map();
+    // Previous two-touch distance and angle for incremental deltas.
+    prevDistance = -1;
+    prevAngle = 0;
+    // Reusable Vector for center dispatches (avoids heap churn).
+    centerVec = new Vector();
+    constructor(distanceThreshold, onPinch, onRotate, onLongPress) {
+        this.distanceThreshold = distanceThreshold;
+        this.onPinch = onPinch;
+        this.onRotate = onRotate;
+        this.onLongPress = onLongPress;
+    }
+    onPointerDown(pointer) {
+        if (pointer.type === 'touch') {
+            this.touchPointers.set(pointer.id, pointer);
+            this._resetTwoTouchBaseline();
+        }
+        // Start long-press timer for every pointer type.
+        const timerId = setTimeout(() => {
+            this.longPressEntries.delete(pointer.id);
+            this.onLongPress.dispatch(pointer);
+        }, longPressMs);
+        this.longPressEntries.set(pointer.id, {
+            pointerId: pointer.id,
+            pointer,
+            timerId,
+            startX: pointer.x,
+            startY: pointer.y,
+        });
+    }
+    onPointerMove(pointer, distanceThreshold) {
+        // Cancel long-press if moved beyond threshold.
+        const entry = this.longPressEntries.get(pointer.id);
+        if (entry) {
+            const dx = pointer.x - entry.startX;
+            const dy = pointer.y - entry.startY;
+            if (Math.sqrt(dx * dx + dy * dy) > distanceThreshold) {
+                clearTimeout(entry.timerId);
+                this.longPressEntries.delete(pointer.id);
+            }
+        }
+        if (pointer.type !== 'touch') {
+            return;
+        }
+        // Update the stored pointer reference's position via the live object.
+        // (We store the actual Pointer object so position is already updated by the caller.)
+        if (this.touchPointers.size < 2) {
+            return;
+        }
+        this._processTwoTouchGestures();
+    }
+    onPointerUp(pointer) {
+        this._cancelLongPress(pointer.id);
+    }
+    onPointerLeave(pointer) {
+        this._cancelLongPress(pointer.id);
+        if (pointer.type === 'touch') {
+            this.touchPointers.delete(pointer.id);
+            this._resetTwoTouchBaseline();
+        }
+    }
+    onPointerCancel(pointer) {
+        this._cancelLongPress(pointer.id);
+        if (pointer.type === 'touch') {
+            this.touchPointers.delete(pointer.id);
+            this._resetTwoTouchBaseline();
+        }
+    }
+    destroy() {
+        for (const entry of this.longPressEntries.values()) {
+            clearTimeout(entry.timerId);
+        }
+        this.longPressEntries.clear();
+        this.touchPointers.clear();
+        this.centerVec.destroy();
+    }
+    _cancelLongPress(pointerId) {
+        const entry = this.longPressEntries.get(pointerId);
+        if (entry) {
+            clearTimeout(entry.timerId);
+            this.longPressEntries.delete(pointerId);
+        }
+    }
+    _resetTwoTouchBaseline() {
+        this.prevDistance = -1;
+        this.prevAngle = 0;
+    }
+    _processTwoTouchGestures() {
+        const iter = this.touchPointers.values();
+        const pA = iter.next().value;
+        const pB = iter.next().value;
+        const dx = pB.x - pA.x;
+        const dy = pB.y - pA.y;
+        const currentDistance = Math.sqrt(dx * dx + dy * dy);
+        const currentAngle = Math.atan2(dy, dx);
+        const centerX = (pA.x + pB.x) / 2;
+        const centerY = (pA.y + pB.y) / 2;
+        this.centerVec.set(centerX, centerY);
+        if (this.prevDistance > 0) {
+            const scale = currentDistance / this.prevDistance;
+            // Only fire if there's a meaningful distance change.
+            if (Math.abs(scale - 1) > 0.0001) {
+                this.onPinch.dispatch(scale, this.centerVec);
+            }
+            const angleDelta = currentAngle - this.prevAngle;
+            if (Math.abs(angleDelta) > 0.0001) {
+                this.onRotate.dispatch(angleDelta, this.centerVec);
+            }
+        }
+        this.prevDistance = currentDistance;
+        this.prevAngle = currentAngle;
+    }
 }
 
 var GamepadChannel;
@@ -11602,6 +11972,10 @@ class InputManager {
     channelsPressed = [];
     channelsReleased = [];
     gamepadDefinitions;
+    // Slot allocation for unified pointer tracking (mouse / touch / pen).
+    pointerSlots = new Map(); // pointerId → slotIndex
+    freeSlots = Array.from({ length: maxPointers }, (_, i) => i);
+    gestureRecognizer;
     canvasFocusedValue;
     pointerDistanceThreshold;
     keyDownHandler = this.handleKeyDown.bind(this);
@@ -11630,12 +12004,23 @@ class InputManager {
     onGamepadConnected = new Signal();
     onGamepadDisconnected = new Signal();
     onGamepadUpdated = new Signal();
+    /** Fires on every two-touch-pointer move where the distance between them changed. `scale` > 1 = spreading, < 1 = pinching. */
+    onPinch = new Signal();
+    /** Fires on every two-touch-pointer move where the angle between them changed. `angleDelta` is in radians. */
+    onRotate = new Signal();
+    /** Fires when a pointer has been held without significant movement for ≥ 500 ms. */
+    onLongPress = new Signal();
     constructor(app) {
         const { gamepadDefinitions = [], pointerDistanceThreshold } = app.options;
         this.canvas = app.canvas;
         this.canvasFocusedValue = document.activeElement === this.canvas;
         this.pointerDistanceThreshold = pointerDistanceThreshold;
         this.gamepadDefinitions = [...gamepadDefinitions, ...builtInGamepadDefinitions];
+        // Disable the browser's default pan/zoom/double-tap-zoom on touch devices so
+        // pointer events reach the canvas without being swallowed by the browser's
+        // native touch gestures.
+        this.canvas.style.touchAction = 'none';
+        this.gestureRecognizer = new GestureRecognizer(pointerDistanceThreshold, this.onPinch, this.onRotate, this.onLongPress);
         this.addEventListeners();
     }
     get pointersInCanvas() {
@@ -11688,6 +12073,7 @@ class InputManager {
     }
     destroy() {
         this.removeEventListeners();
+        this.gestureRecognizer.destroy();
         for (const pointer of Object.values(this.pointers)) {
             pointer.destroy();
         }
@@ -11699,6 +12085,8 @@ class InputManager {
         this.gamepadsValue.length = 0;
         this.channelsPressed.length = 0;
         this.channelsReleased.length = 0;
+        this.pointerSlots.clear();
+        this.freeSlots.length = 0;
         this.wheelOffset.destroy();
         this.flags.destroy();
         this.onPointerEnter.destroy();
@@ -11715,62 +12103,153 @@ class InputManager {
         this.onGamepadConnected.destroy();
         this.onGamepadDisconnected.destroy();
         this.onGamepadUpdated.destroy();
+        this.onPinch.destroy();
+        this.onRotate.destroy();
+        this.onLongPress.destroy();
+    }
+    _assignSlot(pointerId) {
+        if (this.pointerSlots.has(pointerId)) {
+            return this.pointerSlots.get(pointerId);
+        }
+        if (this.freeSlots.length === 0) {
+            return null; // All 16 slots occupied — silently drop.
+        }
+        const slot = this.freeSlots.shift();
+        this.pointerSlots.set(pointerId, slot);
+        return slot;
+    }
+    _releaseSlot(pointerId) {
+        const slot = this.pointerSlots.get(pointerId);
+        if (slot !== undefined) {
+            this.pointerSlots.delete(pointerId);
+            // Push to the front so slot 0 is recovered first, keeping allocation predictable.
+            this.freeSlots.unshift(slot);
+        }
     }
     handleKeyDown(event) {
+        // Game-engine convention: keys only register while the canvas
+        // owns focus. Otherwise typing into adjacent <input> fields would
+        // also drive game state, which is never what users want.
+        if (!this.canvasFocusedValue) {
+            return;
+        }
         const channel = ChannelOffset.Keyboard + event.keyCode;
         this.channels[channel] = 1;
         this.channelsPressed.push(channel);
         this.flags.push(InputManagerFlag.KeyDown);
+        // Consume the event: stop default browser actions (page scroll on
+        // arrow/space, find-as-you-type on /, etc.) and stop propagation
+        // so other listeners on the page don't double-handle.
+        stopEvent(event);
     }
     handleKeyUp(event) {
+        if (!this.canvasFocusedValue) {
+            return;
+        }
         const channel = ChannelOffset.Keyboard + event.keyCode;
         this.channels[channel] = 0;
         this.channelsReleased.push(channel);
         this.flags.push(InputManagerFlag.KeyUp);
+        stopEvent(event);
     }
     handlePointerOver(event) {
-        this.pointers[event.pointerId] = new Pointer(event, this.canvas);
+        const slot = this._assignSlot(event.pointerId);
+        if (slot === null) {
+            return; // 17th+ simultaneous pointer — silently drop.
+        }
+        this.pointers[event.pointerId] = new Pointer(event, this.canvas, this.channels, slot);
         this.flags.push(InputManagerFlag.PointerUpdate);
     }
     handlePointerLeave(event) {
-        this.pointers[event.pointerId].handleLeave(event);
+        const pointer = this.pointers[event.pointerId];
+        if (!pointer) {
+            return;
+        }
+        pointer.handleLeave(event);
+        this.gestureRecognizer.onPointerLeave(pointer);
+        this._releaseSlot(event.pointerId);
         this.flags.push(InputManagerFlag.PointerUpdate);
     }
     handlePointerDown(event) {
         this.canvas.focus();
         this.canvasFocusedValue = true;
-        this.pointers[event.pointerId].handlePress(event);
+        const pointer = this.pointers[event.pointerId];
+        if (!pointer) {
+            return;
+        }
+        pointer.handlePress(event);
+        this.gestureRecognizer.onPointerDown(pointer);
         this.flags.push(InputManagerFlag.PointerUpdate);
-        event.preventDefault();
+        // preventDefault stops native drag / text-selection;
+        // stopImmediatePropagation prevents bubbling to host-page click
+        // handlers so an embedded canvas doesn't accidentally trigger UI
+        // outside its bounds.
+        stopEvent(event);
     }
     handlePointerMove(event) {
-        this.pointers[event.pointerId].handleMove(event);
+        const pointer = this.pointers[event.pointerId];
+        if (!pointer) {
+            return;
+        }
+        pointer.handleMove(event);
+        this.gestureRecognizer.onPointerMove(pointer, this.pointerDistanceThreshold);
         this.flags.push(InputManagerFlag.PointerUpdate);
     }
     handlePointerUp(event) {
-        this.pointers[event.pointerId].handleRelease(event);
+        const pointer = this.pointers[event.pointerId];
+        if (!pointer) {
+            return;
+        }
+        pointer.handleRelease(event);
+        this.gestureRecognizer.onPointerUp(pointer);
         this.flags.push(InputManagerFlag.PointerUpdate);
-        event.preventDefault();
+        stopEvent(event);
     }
     handlePointerCancel(event) {
-        this.pointers[event.pointerId].handleCancel(event);
+        const pointer = this.pointers[event.pointerId];
+        if (!pointer) {
+            return;
+        }
+        pointer.handleCancel(event);
+        this.gestureRecognizer.onPointerCancel(pointer);
+        this._releaseSlot(event.pointerId);
         this.flags.push(InputManagerFlag.PointerUpdate);
     }
     handleMouseWheel(event) {
+        if (!this.canvasFocusedValue) {
+            return;
+        }
         this.wheelOffset.set(event.deltaX, event.deltaY);
         this.flags.push(InputManagerFlag.MouseWheel);
-        if (this.canvasFocusedValue) {
-            event.preventDefault();
-        }
+        stopEvent(event);
     }
     handleCanvasFocus() {
         this.canvasFocusedValue = true;
     }
     handleCanvasBlur() {
         this.canvasFocusedValue = false;
+        this.releaseAllKeyboardChannels();
     }
     handleWindowBlur() {
         this.canvasFocusedValue = false;
+        this.releaseAllKeyboardChannels();
+    }
+    /**
+     * Force every currently-held keyboard channel back to zero and emit
+     * onKeyUp for each. Called on canvas/window blur so keys held when
+     * focus leaves don't stay stuck "down" forever — without this, a user
+     * who alt-tabs while pressing W would have W register as held until
+     * they manually release while focus is back.
+     */
+    releaseAllKeyboardChannels() {
+        for (let offset = 0; offset < ChannelSize.Category; offset++) {
+            const channel = ChannelOffset.Keyboard + offset;
+            if (this.channels[channel] !== 0) {
+                this.channels[channel] = 0;
+                this.channelsReleased.push(channel);
+                this.flags.push(InputManagerFlag.KeyUp);
+            }
+        }
     }
     addEventListeners() {
         const activeWindow = window;
@@ -18509,5 +18988,5 @@ const createRapierPhysicsWorld = async (options = {}) => {
     return await RapierPhysicsWorld.create(options);
 };
 
-export { AbstractAssetFactory, AbstractMedia, AbstractWebGl2BatchedRenderer, AbstractWebGl2Renderer, AbstractWebGpuRenderer, AnimatedSprite, Application, ApplicationStatus, ArcadeStickGamepadMapping, AudioAnalyser, BinaryFactory, BlendModes, BlurFilter, Bounds, BufferTypes, BufferUsage, BundleLoadError, CacheFirstStrategy, CallbackRenderPass, Capabilities, ChannelOffset, ChannelSize, Circle, Clock, CollisionType, Color, ColorAffector, ColorFilter, Container, Drawable, Ellipse, FactoryRegistry, Filter, Flags, FontFactory, ForceAffector, GameCubeGamepadMapping, Gamepad, GamepadChannel, GamepadControl, GamepadMapping, GamepadMappingFamily, GamepadPromptLayouts, GenericDualAnalogGamepadMapping, Graphics, ImageFactory, IndexedDbDatabase, IndexedDbStore, Input, InputManager, Interval, JoyConLeftGamepadMapping, JoyConRightGamepadMapping, Json, JsonFactory, Keyboard, Line, Loader, Matrix, Mesh, Music, MusicFactory, NetworkOnlyStrategy, ObservableSize, ObservableVector, Particle, ParticleOptions, ParticleSystem, PlayStationGamepadMapping, Pointer, PointerState, PointerStateFlag, PolarVector, Polygon, Quadtree, Random, RapierPhysicsBinding, RapierPhysicsWorld, Rectangle, RenderBackendType, RenderNode, RenderTarget, RenderTargetPass, RenderTexture, RendererRegistry, RenderingPrimitives, Sampler, ScaleAffector, ScaleModes, Scene, SceneManager, SceneNode, Segment, Shader, ShaderAttribute, ShaderPrimitives, ShaderUniform, Signal, Size, Sound, SoundFactory, Sprite, SpriteFlags, Spritesheet, SteamControllerGamepadMapping, SvgAsset, SvgFactory, SwitchProGamepadMapping, Text, TextAsset, TextFactory, TextStyle, Texture, TextureFactory, Time, Timer, TorqueAffector, UniversalEmitter, Vector, Video, VideoFactory, View, ViewFlags, VoronoiRegion, VttAsset, VttFactory, WasmFactory, WebGl2Backend, WebGl2MeshRenderer, WebGl2ParticleRenderer, WebGl2RenderBuffer, WebGl2ShaderBlock, WebGl2SpriteRenderer, WebGl2VertexArrayObject, WebGpuBackend, WebGpuMeshRenderer, WebGpuParticleRenderer, WebGpuSpriteRenderer, WrapModes, XboxGamepadMapping, bezierCurveTo, buildCircle, buildEllipse, buildLine, buildPath, buildPolygon, buildRectangle, buildStar, builtInGamepadDefinitions, canvasSourceToDataUrl, clamp, createRapierPhysicsWorld, createRenderStats, createWebGl2ShaderProgram, decodeAudioData, defineAssetManifest, degreesPerRadian, degreesToRadians, determineMimeType, emptyArrayBuffer, getAudioContext, getCanvasSourceSize, getCollisionCircleCircle, getCollisionCircleRectangle, getCollisionPolygonCircle, getCollisionRectangleRectangle, getCollisionSat, getDistance, getOfflineAudioContext, getPreciseTime, getTextureSourceSize, getVoronoiRegion$1 as getVoronoiRegion, getWebGpuBlendState, hours, inRange, intersectionCircleCircle, intersectionCircleEllipse, intersectionCirclePoly, intersectionEllipseEllipse, intersectionEllipsePoly, intersectionLineCircle, intersectionLineEllipse, intersectionLineLine, intersectionLinePoly, intersectionLineRect, intersectionPointCircle, intersectionPointEllipse, intersectionPointLine, intersectionPointPoint, intersectionPointPoly, intersectionPointRect, intersectionPolyPoly, intersectionRectCircle, intersectionRectEllipse, intersectionRectPoly, intersectionRectRect, intersectionSat, isAudioContextReady, isPowerOfTwo, lerp, matchesIds, milliseconds, minutes, noop$1 as noop, normalizeIds, onAudioContextReady, parseGamepadDescriptor, quadraticCurveTo, radiansPerDegree, radiansToDegrees, rand, removeArrayItems, resetRenderStats, resolveDefinition, resolveGamepadDefinition, seconds, sign$1 as sign, stopEvent, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio, tau, trimRotation, webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl2PrimitiveTypeNames };
+export { AbstractAssetFactory, AbstractMedia, AbstractWebGl2BatchedRenderer, AbstractWebGl2Renderer, AbstractWebGpuRenderer, AnimatedSprite, Application, ApplicationStatus, ArcadeStickGamepadMapping, AudioAnalyser, BinaryFactory, BlendModes, BlurFilter, Bounds, BufferTypes, BufferUsage, BundleLoadError, CacheFirstStrategy, CallbackRenderPass, Capabilities, ChannelOffset, ChannelSize, Circle, Clock, CollisionType, Color, ColorAffector, ColorFilter, Container, Drawable, Ellipse, FactoryRegistry, Filter, Flags, FontFactory, ForceAffector, GameCubeGamepadMapping, Gamepad, GamepadChannel, GamepadControl, GamepadMapping, GamepadMappingFamily, GamepadPromptLayouts, GenericDualAnalogGamepadMapping, Graphics, ImageFactory, IndexedDbDatabase, IndexedDbStore, Input, InputManager, Interval, JoyConLeftGamepadMapping, JoyConRightGamepadMapping, Json, JsonFactory, Keyboard, Line, Loader, Matrix, Mesh, Music, MusicFactory, NetworkOnlyStrategy, ObservableSize, ObservableVector, Particle, ParticleOptions, ParticleSystem, PlayStationGamepadMapping, Pointer, PointerState, PointerStateFlag, PolarVector, Polygon, Quadtree, Random, RapierPhysicsBinding, RapierPhysicsWorld, Rectangle, RenderBackendType, RenderNode, RenderTarget, RenderTargetPass, RenderTexture, RendererRegistry, RenderingPrimitives, Sampler, ScaleAffector, ScaleModes, Scene, SceneManager, SceneNode, Segment, Shader, ShaderAttribute, ShaderPrimitives, ShaderUniform, Signal, Size, Sound, SoundFactory, Sprite, SpriteFlags, Spritesheet, SteamControllerGamepadMapping, SvgAsset, SvgFactory, SwitchProGamepadMapping, Text, TextAsset, TextFactory, TextStyle, Texture, TextureFactory, Time, Timer, TorqueAffector, UniversalEmitter, Vector, Video, VideoFactory, View, ViewFlags, VoronoiRegion, VttAsset, VttFactory, WasmFactory, WebGl2Backend, WebGl2MeshRenderer, WebGl2ParticleRenderer, WebGl2RenderBuffer, WebGl2ShaderBlock, WebGl2SpriteRenderer, WebGl2VertexArrayObject, WebGpuBackend, WebGpuMeshRenderer, WebGpuParticleRenderer, WebGpuSpriteRenderer, WrapModes, XboxGamepadMapping, bezierCurveTo, buildCircle, buildEllipse, buildLine, buildPath, buildPolygon, buildRectangle, buildStar, builtInGamepadDefinitions, canvasSourceToDataUrl, clamp, createRapierPhysicsWorld, createRenderStats, createWebGl2ShaderProgram, decodeAudioData, defineAssetManifest, degreesPerRadian, degreesToRadians, determineMimeType, emptyArrayBuffer, getAudioContext, getCanvasSourceSize, getCollisionCircleCircle, getCollisionCircleRectangle, getCollisionPolygonCircle, getCollisionRectangleRectangle, getCollisionSat, getDistance, getOfflineAudioContext, getPreciseTime, getTextureSourceSize, getVoronoiRegion$1 as getVoronoiRegion, getWebGpuBlendState, hours, inRange, intersectionCircleCircle, intersectionCircleEllipse, intersectionCirclePoly, intersectionEllipseEllipse, intersectionEllipsePoly, intersectionLineCircle, intersectionLineEllipse, intersectionLineLine, intersectionLinePoly, intersectionLineRect, intersectionPointCircle, intersectionPointEllipse, intersectionPointLine, intersectionPointPoint, intersectionPointPoly, intersectionPointRect, intersectionPolyPoly, intersectionRectCircle, intersectionRectEllipse, intersectionRectPoly, intersectionRectRect, intersectionSat, isAudioContextReady, isPowerOfTwo, lerp, matchesIds, maxPointers, milliseconds, minutes, noop$1 as noop, normalizeIds, onAudioContextReady, parseGamepadDescriptor, pointerSlotSize, quadraticCurveTo, radiansPerDegree, radiansToDegrees, rand, removeArrayItems, resetRenderStats, resolveDefinition, resolveGamepadDefinition, seconds, sign$1 as sign, stopEvent, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio, tau, trimRotation, webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl2PrimitiveTypeNames };
 //# sourceMappingURL=exo.esm.js.map