@spiffcommerce/preview 3.6.2-rc.4 → 3.6.2-rc.5

package/dist/node_modules/@babylonjs/core/Events/deviceInputEvents.esm.js

@@ -0,0 +1,13 @@
+var P;
+(function(o) {
+  o[o.PointerMove = 0] = "PointerMove", o[o.PointerDown = 1] = "PointerDown", o[o.PointerUp = 2] = "PointerUp";
+})(P || (P = {}));
+class r {
+}
+r.DOM_DELTA_PIXEL = 0;
+r.DOM_DELTA_LINE = 1;
+r.DOM_DELTA_PAGE = 2;
+export {
+  P as DeviceInputEventType,
+  r as EventConstants
+};

package/dist/node_modules/@babylonjs/core/Events/keyboardEvents.esm.js

@@ -0,0 +1,41 @@
+class t {
+}
+t.KEYDOWN = 1;
+t.KEYUP = 2;
+class b {
+  /**
+   * Instantiates a new keyboard info.
+   * This class is used to store keyboard related info for the onKeyboardObservable event.
+   * @param type Defines the type of event (KeyboardEventTypes)
+   * @param event Defines the related dom event
+   */
+  constructor(e, s) {
+    this.type = e, this.event = s;
+  }
+}
+class a extends b {
+  /**
+   * Defines whether the engine should skip the next onKeyboardObservable associated to this pre.
+   * @deprecated use skipOnKeyboardObservable property instead
+   */
+  get skipOnPointerObservable() {
+    return this.skipOnKeyboardObservable;
+  }
+  set skipOnPointerObservable(e) {
+    this.skipOnKeyboardObservable = e;
+  }
+  /**
+   * Instantiates a new keyboard pre info.
+   * This class is used to store keyboard related info for the onPreKeyboardObservable event.
+   * @param type Defines the type of event (KeyboardEventTypes)
+   * @param event Defines the related dom event
+   */
+  constructor(e, s) {
+    super(e, s), this.type = e, this.event = s, this.skipOnKeyboardObservable = !1;
+  }
+}
+export {
+  t as KeyboardEventTypes,
+  b as KeyboardInfo,
+  a as KeyboardInfoPre
+};

package/dist/node_modules/@babylonjs/core/Events/pointerEvents.esm.js

@@ -0,0 +1,63 @@
+import { Vector2 as a } from "../Maths/math.vector.esm.js";
+class t {
+}
+t.POINTERDOWN = 1;
+t.POINTERUP = 2;
+t.POINTERMOVE = 4;
+t.POINTERWHEEL = 8;
+t.POINTERPICK = 16;
+t.POINTERTAP = 32;
+t.POINTERDOUBLETAP = 64;
+class r {
+  /**
+   * Instantiates the base class of pointers info.
+   * @param type Defines the type of event (PointerEventTypes)
+   * @param event Defines the related dom event
+   */
+  constructor(n, i) {
+    this.type = n, this.event = i;
+  }
+}
+class P extends r {
+  /**
+   * Instantiates a PointerInfoPre to store pointer related info to the onPrePointerObservable event.
+   * @param type Defines the type of event (PointerEventTypes)
+   * @param event Defines the related dom event
+   * @param localX Defines the local x coordinates of the pointer when the event occured
+   * @param localY Defines the local y coordinates of the pointer when the event occured
+   */
+  constructor(n, i, s, o) {
+    super(n, i), this.ray = null, this.originalPickingInfo = null, this.skipOnPointerObservable = !1, this.localPosition = new a(s, o);
+  }
+}
+class I extends r {
+  /**
+   * Defines the picking info associated with this PointerInfo object (if applicable)
+   */
+  get pickInfo() {
+    return this._pickInfo || this._generatePickInfo(), this._pickInfo;
+  }
+  /**
+   * Instantiates a PointerInfo to store pointer related info to the onPointerObservable event.
+   * @param type Defines the type of event (PointerEventTypes)
+   * @param event Defines the related dom event
+   * @param pickInfo Defines the picking info associated to the info (if any)
+   * @param inputManager Defines the InputManager to use if there is no pickInfo
+   */
+  constructor(n, i, s, o = null) {
+    super(n, i), this._pickInfo = s, this._inputManager = o;
+  }
+  /**
+   * Generates the picking info if needed
+   */
+  /** @internal */
+  _generatePickInfo() {
+    this._inputManager && (this._pickInfo = this._inputManager._pickMove(this.event), this._inputManager._setRayOnPointerInfo(this._pickInfo, this.event), this._inputManager = null);
+  }
+}
+export {
+  t as PointerEventTypes,
+  I as PointerInfo,
+  r as PointerInfoBase,
+  P as PointerInfoPre
+};

package/dist/node_modules/@babylonjs/core/Inputs/pointerPickingConfiguration.esm.js

@@ -0,0 +1,8 @@
+class s {
+  constructor() {
+    this.pointerDownFastCheck = !1, this.pointerUpFastCheck = !1, this.pointerMoveFastCheck = !1, this.skipPointerMovePicking = !1, this.skipPointerDownPicking = !1, this.skipPointerUpPicking = !1;
+  }
+}
+export {
+  s as PointerPickingConfiguration
+};

package/dist/node_modules/@babylonjs/core/Inputs/scene.inputManager.esm.js

@@ -0,0 +1,418 @@
+import { PointerEventTypes as h, PointerInfo as b, PointerInfoPre as N } from "../Events/pointerEvents.esm.js";
+import { AbstractActionManager as k } from "../Actions/abstractActionManager.esm.js";
+import { PickingInfo as I } from "../Collisions/pickingInfo.esm.js";
+import { Vector2 as y, Matrix as A } from "../Maths/math.vector.esm.js";
+import { ActionEvent as p } from "../Actions/actionEvent.esm.js";
+import { KeyboardInfoPre as E, KeyboardEventTypes as m, KeyboardInfo as U } from "../Events/keyboardEvents.esm.js";
+import { PointerInput as d, DeviceType as w } from "../DeviceInput/InputDevices/deviceEnums.esm.js";
+import { DeviceSourceManager as x } from "../DeviceInput/InputDevices/deviceSourceManager.esm.js";
+import { EngineStore as F } from "../Engines/engineStore.esm.js";
+class S {
+  constructor() {
+    this._singleClick = !1, this._doubleClick = !1, this._hasSwiped = !1, this._ignore = !1;
+  }
+  get singleClick() {
+    return this._singleClick;
+  }
+  get doubleClick() {
+    return this._doubleClick;
+  }
+  get hasSwiped() {
+    return this._hasSwiped;
+  }
+  get ignore() {
+    return this._ignore;
+  }
+  set singleClick(e) {
+    this._singleClick = e;
+  }
+  set doubleClick(e) {
+    this._doubleClick = e;
+  }
+  set hasSwiped(e) {
+    this._hasSwiped = e;
+  }
+  set ignore(e) {
+    this._ignore = e;
+  }
+}
+class _ {
+  /**
+   * Creates a new InputManager
+   * @param scene - defines the hosting scene
+   */
+  constructor(e) {
+    this._alreadyAttached = !1, this._meshPickProceed = !1, this._currentPickResult = null, this._previousPickResult = null, this._totalPointersPressed = 0, this._doubleClickOccured = !1, this._isSwiping = !1, this._swipeButtonPressed = -1, this._skipPointerTap = !1, this._isMultiTouchGesture = !1, this._pointerX = 0, this._pointerY = 0, this._startingPointerPosition = new y(0, 0), this._previousStartingPointerPosition = new y(0, 0), this._startingPointerTime = 0, this._previousStartingPointerTime = 0, this._pointerCaptures = {}, this._meshUnderPointerId = {}, this._movePointerInfo = null, this._cameraObserverCount = 0, this._delayedClicks = [null, null, null, null, null], this._deviceSourceManager = null, this._scene = e || F.LastCreatedScene, this._scene;
+  }
+  /**
+   * Gets the mesh that is currently under the pointer
+   * @returns Mesh that the pointer is pointer is hovering over
+   */
+  get meshUnderPointer() {
+    return this._movePointerInfo && (this._movePointerInfo._generatePickInfo(), this._movePointerInfo = null), this._pointerOverMesh;
+  }
+  /**
+   * When using more than one pointer (for example in XR) you can get the mesh under the specific pointer
+   * @param pointerId - the pointer id to use
+   * @returns The mesh under this pointer id or null if not found
+   */
+  getMeshUnderPointerByPointerId(e) {
+    return this._meshUnderPointerId[e] || null;
+  }
+  /**
+   * Gets the pointer coordinates in 2D without any translation (ie. straight out of the pointer event)
+   * @returns Vector with X/Y values directly from pointer event
+   */
+  get unTranslatedPointer() {
+    return new y(this._unTranslatedPointerX, this._unTranslatedPointerY);
+  }
+  /**
+   * Gets or sets the current on-screen X position of the pointer
+   * @returns Translated X with respect to screen
+   */
+  get pointerX() {
+    return this._pointerX;
+  }
+  set pointerX(e) {
+    this._pointerX = e;
+  }
+  /**
+   * Gets or sets the current on-screen Y position of the pointer
+   * @returns Translated Y with respect to screen
+   */
+  get pointerY() {
+    return this._pointerY;
+  }
+  set pointerY(e) {
+    this._pointerY = e;
+  }
+  _updatePointerPosition(e) {
+    const s = this._scene.getEngine().getInputElementClientRect();
+    s && (this._pointerX = e.clientX - s.left, this._pointerY = e.clientY - s.top, this._unTranslatedPointerX = this._pointerX, this._unTranslatedPointerY = this._pointerY);
+  }
+  _processPointerMove(e, s) {
+    const n = this._scene, a = n.getEngine(), i = a.getInputElement();
+    i && (i.tabIndex = a.canvasTabIndex, n.doNotHandleCursors || (i.style.cursor = n.defaultCursor)), this._setCursorAndPointerOverMesh(e, s, n);
+    for (const r of n._pointerMoveStage) {
+      e = e || this._pickMove(s);
+      const l = !!(e != null && e.pickedMesh);
+      e = r.action(this._unTranslatedPointerX, this._unTranslatedPointerY, e, l, i);
+    }
+    const o = s.inputIndex >= d.MouseWheelX && s.inputIndex <= d.MouseWheelZ ? h.POINTERWHEEL : h.POINTERMOVE;
+    n.onPointerMove && (e = e || this._pickMove(s), n.onPointerMove(s, e, o));
+    let t;
+    e ? (t = new b(o, s, e), this._setRayOnPointerInfo(e, s)) : (t = new b(o, s, null, this), this._movePointerInfo = t), n.onPointerObservable.hasObservers() && n.onPointerObservable.notifyObservers(t, o);
+  }
+  // Pointers handling
+  /** @internal */
+  _setRayOnPointerInfo(e, s) {
+    const n = this._scene;
+    e && n._pickingAvailable && (e.ray || (e.ray = n.createPickingRay(s.offsetX, s.offsetY, A.Identity(), n.activeCamera)));
+  }
+  /** @internal */
+  _addCameraPointerObserver(e, s) {
+    return this._cameraObserverCount++, this._scene.onPointerObservable.add(e, s);
+  }
+  /** @internal */
+  _removeCameraPointerObserver(e) {
+    return this._cameraObserverCount--, this._scene.onPointerObservable.remove(e);
+  }
+  _checkForPicking() {
+    return !!(this._scene.onPointerObservable.observers.length > this._cameraObserverCount || this._scene.onPointerPick);
+  }
+  _checkPrePointerObservable(e, s, n) {
+    const a = this._scene, i = new N(n, s, this._unTranslatedPointerX, this._unTranslatedPointerY);
+    return e && (i.originalPickingInfo = e, i.ray = e.ray, e.originMesh && (i.nearInteractionPickingInfo = e)), a.onPrePointerObservable.notifyObservers(i, n), !!i.skipOnPointerObservable;
+  }
+  /** @internal */
+  _pickMove(e) {
+    const s = this._scene, n = s.pick(this._unTranslatedPointerX, this._unTranslatedPointerY, s.pointerMovePredicate, s.pointerMoveFastCheck, s.cameraToUseForPointers, s.pointerMoveTrianglePredicate);
+    return this._setCursorAndPointerOverMesh(n, e, s), n;
+  }
+  _setCursorAndPointerOverMesh(e, s, n) {
+    const i = n.getEngine().getInputElement();
+    if (e != null && e.pickedMesh) {
+      if (this.setPointerOverMesh(e.pickedMesh, s.pointerId, e, s), !n.doNotHandleCursors && i && this._pointerOverMesh) {
+        const o = this._pointerOverMesh._getActionManagerForTrigger();
+        o && o.hasPointerTriggers && (i.style.cursor = o.hoverCursor || n.hoverCursor);
+      }
+    } else
+      this.setPointerOverMesh(null, s.pointerId, e, s);
+  }
+  /**
+   * Use this method to simulate a pointer move on a mesh
+   * The pickResult parameter can be obtained from a scene.pick or scene.pickWithRay
+   * @param pickResult - pickingInfo of the object wished to simulate pointer event on
+   * @param pointerEventInit - pointer event state to be used when simulating the pointer event (eg. pointer id for multitouch)
+   */
+  simulatePointerMove(e, s) {
+    const n = new PointerEvent("pointermove", s);
+    n.inputIndex = d.Move, !this._checkPrePointerObservable(e, n, h.POINTERMOVE) && this._processPointerMove(e, n);
+  }
+  /**
+   * Use this method to simulate a pointer down on a mesh
+   * The pickResult parameter can be obtained from a scene.pick or scene.pickWithRay
+   * @param pickResult - pickingInfo of the object wished to simulate pointer event on
+   * @param pointerEventInit - pointer event state to be used when simulating the pointer event (eg. pointer id for multitouch)
+   */
+  simulatePointerDown(e, s) {
+    const n = new PointerEvent("pointerdown", s);
+    n.inputIndex = n.button + 2, !this._checkPrePointerObservable(e, n, h.POINTERDOWN) && this._processPointerDown(e, n);
+  }
+  _processPointerDown(e, s) {
+    const n = this._scene;
+    if (e != null && e.pickedMesh) {
+      this._pickedDownMesh = e.pickedMesh;
+      const o = e.pickedMesh._getActionManagerForTrigger();
+      if (o) {
+        if (o.hasPickTriggers)
+          switch (o.processTrigger(5, p.CreateNew(e.pickedMesh, s)), s.button) {
+            case 0:
+              o.processTrigger(2, p.CreateNew(e.pickedMesh, s));
+              break;
+            case 1:
+              o.processTrigger(4, p.CreateNew(e.pickedMesh, s));
+              break;
+            case 2:
+              o.processTrigger(3, p.CreateNew(e.pickedMesh, s));
+              break;
+          }
+        o.hasSpecificTrigger(8) && window.setTimeout(() => {
+          const t = n.pick(this._unTranslatedPointerX, this._unTranslatedPointerY, (r) => r.isPickable && r.isVisible && r.isReady() && r.actionManager && r.actionManager.hasSpecificTrigger(8) && r === this._pickedDownMesh, !1, n.cameraToUseForPointers);
+          t != null && t.pickedMesh && o && this._totalPointersPressed !== 0 && Date.now() - this._startingPointerTime > _.LongPressDelay && !this._isPointerSwiping() && (this._startingPointerTime = 0, o.processTrigger(8, p.CreateNew(t.pickedMesh, s)));
+        }, _.LongPressDelay);
+      }
+    } else
+      for (const o of n._pointerDownStage)
+        e = o.action(this._unTranslatedPointerX, this._unTranslatedPointerY, e, s, !1);
+    let a;
+    const i = h.POINTERDOWN;
+    e ? (n.onPointerDown && n.onPointerDown(s, e, i), a = new b(i, s, e), this._setRayOnPointerInfo(e, s)) : a = new b(i, s, null, this), n.onPointerObservable.hasObservers() && n.onPointerObservable.notifyObservers(a, i);
+  }
+  /**
+   * @internal
+   * @internals Boolean if delta for pointer exceeds drag movement threshold
+   */
+  _isPointerSwiping() {
+    return this._isSwiping;
+  }
+  /**
+   * Use this method to simulate a pointer up on a mesh
+   * The pickResult parameter can be obtained from a scene.pick or scene.pickWithRay
+   * @param pickResult - pickingInfo of the object wished to simulate pointer event on
+   * @param pointerEventInit - pointer event state to be used when simulating the pointer event (eg. pointer id for multitouch)
+   * @param doubleTap - indicates that the pointer up event should be considered as part of a double click (false by default)
+   */
+  simulatePointerUp(e, s, n) {
+    const a = new PointerEvent("pointerup", s);
+    a.inputIndex = d.Move;
+    const i = new S();
+    n ? i.doubleClick = !0 : i.singleClick = !0, !this._checkPrePointerObservable(e, a, h.POINTERUP) && this._processPointerUp(e, a, i);
+  }
+  _processPointerUp(e, s, n) {
+    const a = this._scene;
+    if (e != null && e.pickedMesh) {
+      if (this._pickedUpMesh = e.pickedMesh, this._pickedDownMesh === this._pickedUpMesh && (a.onPointerPick && a.onPointerPick(s, e), n.singleClick && !n.ignore && a.onPointerObservable.observers.length > this._cameraObserverCount)) {
+        const o = h.POINTERPICK, t = new b(o, s, e);
+        this._setRayOnPointerInfo(e, s), a.onPointerObservable.notifyObservers(t, o);
+      }
+      const i = e.pickedMesh._getActionManagerForTrigger();
+      if (i && !n.ignore) {
+        i.processTrigger(7, p.CreateNew(e.pickedMesh, s, e)), !n.hasSwiped && n.singleClick && i.processTrigger(1, p.CreateNew(e.pickedMesh, s, e));
+        const o = e.pickedMesh._getActionManagerForTrigger(6);
+        n.doubleClick && o && o.processTrigger(6, p.CreateNew(e.pickedMesh, s, e));
+      }
+    } else if (!n.ignore)
+      for (const i of a._pointerUpStage)
+        e = i.action(this._unTranslatedPointerX, this._unTranslatedPointerY, e, s, n.doubleClick);
+    if (this._pickedDownMesh && this._pickedDownMesh !== this._pickedUpMesh) {
+      const i = this._pickedDownMesh._getActionManagerForTrigger(16);
+      i && i.processTrigger(16, p.CreateNew(this._pickedDownMesh, s));
+    }
+    if (!n.ignore) {
+      const i = new b(h.POINTERUP, s, e);
+      if (this._setRayOnPointerInfo(e, s), a.onPointerObservable.notifyObservers(i, h.POINTERUP), a.onPointerUp && a.onPointerUp(s, e, h.POINTERUP), !n.hasSwiped && !this._skipPointerTap && !this._isMultiTouchGesture) {
+        let o = 0;
+        if (n.singleClick ? o = h.POINTERTAP : n.doubleClick && (o = h.POINTERDOUBLETAP), o) {
+          const t = new b(o, s, e);
+          a.onPointerObservable.hasObservers() && a.onPointerObservable.hasSpecificMask(o) && a.onPointerObservable.notifyObservers(t, o);
+        }
+      }
+    }
+  }
+  /**
+   * Gets a boolean indicating if the current pointer event is captured (meaning that the scene has already handled the pointer down)
+   * @param pointerId - defines the pointer id to use in a multi-touch scenario (0 by default)
+   * @returns true if the pointer was captured
+   */
+  isPointerCaptured(e = 0) {
+    return this._pointerCaptures[e];
+  }
+  /**
+   * Attach events to the canvas (To handle actionManagers triggers and raise onPointerMove, onPointerDown and onPointerUp
+   * @param attachUp - defines if you want to attach events to pointerup
+   * @param attachDown - defines if you want to attach events to pointerdown
+   * @param attachMove - defines if you want to attach events to pointermove
+   * @param elementToAttachTo - defines the target DOM element to attach to (will use the canvas by default)
+   */
+  attachControl(e = !0, s = !0, n = !0, a = null) {
+    const i = this._scene, o = i.getEngine();
+    a || (a = o.getInputElement()), this._alreadyAttached && this.detachControl(), a && (this._alreadyAttachedTo = a), this._deviceSourceManager = new x(o), this._initActionManager = (t) => {
+      if (!this._meshPickProceed) {
+        const r = i.skipPointerUpPicking || i._registeredActions === 0 && !this._checkForPicking() && !i.onPointerUp ? null : i.pick(this._unTranslatedPointerX, this._unTranslatedPointerY, i.pointerUpPredicate, i.pointerUpFastCheck, i.cameraToUseForPointers);
+        this._currentPickResult = r, r && (t = r.hit && r.pickedMesh ? r.pickedMesh._getActionManagerForTrigger() : null), this._meshPickProceed = !0;
+      }
+      return t;
+    }, this._delayedSimpleClick = (t, r, l) => {
+      if ((Date.now() - this._previousStartingPointerTime > _.DoubleClickDelay && !this._doubleClickOccured || t !== this._previousButtonPressed) && (this._doubleClickOccured = !1, r.singleClick = !0, r.ignore = !1, this._delayedClicks[t])) {
+        const c = this._delayedClicks[t].evt, g = h.POINTERTAP, O = new b(g, c, this._currentPickResult);
+        i.onPointerObservable.hasObservers() && i.onPointerObservable.hasSpecificMask(g) && i.onPointerObservable.notifyObservers(O, g), this._delayedClicks[t] = null;
+      }
+    }, this._initClickEvent = (t, r, l, c) => {
+      var g, O;
+      const P = new S();
+      this._currentPickResult = null;
+      let u = null, T = t.hasSpecificMask(h.POINTERPICK) || r.hasSpecificMask(h.POINTERPICK) || t.hasSpecificMask(h.POINTERTAP) || r.hasSpecificMask(h.POINTERTAP) || t.hasSpecificMask(h.POINTERDOUBLETAP) || r.hasSpecificMask(h.POINTERDOUBLETAP);
+      !T && k && (u = this._initActionManager(u, P), u && (T = u.hasPickTriggers));
+      let C = !1;
+      if (T) {
+        const f = l.button;
+        if (P.hasSwiped = this._isPointerSwiping(), !P.hasSwiped) {
+          let M = !_.ExclusiveDoubleClickMode;
+          if (M || (M = !t.hasSpecificMask(h.POINTERDOUBLETAP) && !r.hasSpecificMask(h.POINTERDOUBLETAP), M && !k.HasSpecificTrigger(6) && (u = this._initActionManager(u, P), u && (M = !u.hasSpecificTrigger(6)))), M)
+            (Date.now() - this._previousStartingPointerTime > _.DoubleClickDelay || f !== this._previousButtonPressed) && (P.singleClick = !0, c(P, this._currentPickResult), C = !0);
+          else {
+            const D = {
+              evt: l,
+              clickInfo: P,
+              timeoutId: window.setTimeout(this._delayedSimpleClick.bind(this, f, P, c), _.DoubleClickDelay)
+            };
+            this._delayedClicks[f] = D;
+          }
+          let v = t.hasSpecificMask(h.POINTERDOUBLETAP) || r.hasSpecificMask(h.POINTERDOUBLETAP);
+          !v && k.HasSpecificTrigger(6) && (u = this._initActionManager(u, P), u && (v = u.hasSpecificTrigger(6))), v && (f === this._previousButtonPressed && Date.now() - this._previousStartingPointerTime < _.DoubleClickDelay && !this._doubleClickOccured ? (!P.hasSwiped && !this._isPointerSwiping() ? (this._previousStartingPointerTime = 0, this._doubleClickOccured = !0, P.doubleClick = !0, P.ignore = !1, _.ExclusiveDoubleClickMode && this._delayedClicks[f] && (clearTimeout((g = this._delayedClicks[f]) === null || g === void 0 ? void 0 : g.timeoutId), this._delayedClicks[f] = null), c(P, this._currentPickResult)) : (this._doubleClickOccured = !1, this._previousStartingPointerTime = this._startingPointerTime, this._previousStartingPointerPosition.x = this._startingPointerPosition.x, this._previousStartingPointerPosition.y = this._startingPointerPosition.y, this._previousButtonPressed = f, _.ExclusiveDoubleClickMode ? (this._delayedClicks[f] && (clearTimeout((O = this._delayedClicks[f]) === null || O === void 0 ? void 0 : O.timeoutId), this._delayedClicks[f] = null), c(P, this._previousPickResult)) : c(P, this._currentPickResult)), C = !0) : (this._doubleClickOccured = !1, this._previousStartingPointerTime = this._startingPointerTime, this._previousStartingPointerPosition.x = this._startingPointerPosition.x, this._previousStartingPointerPosition.y = this._startingPointerPosition.y, this._previousButtonPressed = f));
+        }
+      }
+      C || c(P, this._currentPickResult);
+    }, this._onPointerMove = (t) => {
+      if (this._updatePointerPosition(t), !this._isSwiping && this._swipeButtonPressed !== -1 && (this._isSwiping = Math.abs(this._startingPointerPosition.x - this._pointerX) > _.DragMovementThreshold || Math.abs(this._startingPointerPosition.y - this._pointerY) > _.DragMovementThreshold), o.isPointerLock && o._verifyPointerLock(), this._checkPrePointerObservable(null, t, t.inputIndex >= d.MouseWheelX && t.inputIndex <= d.MouseWheelZ ? h.POINTERWHEEL : h.POINTERMOVE) || !i.cameraToUseForPointers && !i.activeCamera)
+        return;
+      if (i.skipPointerMovePicking) {
+        this._processPointerMove(new I(), t);
+        return;
+      }
+      i.pointerMovePredicate || (i.pointerMovePredicate = (l) => l.isPickable && l.isVisible && l.isReady() && l.isEnabled() && (l.enablePointerMoveEvents || i.constantlyUpdateMeshUnderPointer || l._getActionManagerForTrigger() !== null) && (!i.cameraToUseForPointers || (i.cameraToUseForPointers.layerMask & l.layerMask) !== 0));
+      const r = i._registeredActions > 0 || i.constantlyUpdateMeshUnderPointer ? this._pickMove(t) : null;
+      this._processPointerMove(r, t);
+    }, this._onPointerDown = (t) => {
+      var r;
+      if (this._totalPointersPressed++, this._pickedDownMesh = null, this._meshPickProceed = !1, _.ExclusiveDoubleClickMode) {
+        for (let c = 0; c < this._delayedClicks.length; c++)
+          if (this._delayedClicks[c])
+            if (t.button === c)
+              clearTimeout((r = this._delayedClicks[c]) === null || r === void 0 ? void 0 : r.timeoutId);
+            else {
+              const g = this._delayedClicks[c].clickInfo;
+              this._doubleClickOccured = !1, g.singleClick = !0, g.ignore = !1;
+              const O = this._delayedClicks[c].evt, P = h.POINTERTAP, u = new b(P, O, this._currentPickResult);
+              i.onPointerObservable.hasObservers() && i.onPointerObservable.hasSpecificMask(P) && i.onPointerObservable.notifyObservers(u, P), this._delayedClicks[c] = null;
+            }
+      }
+      if (this._updatePointerPosition(t), this._swipeButtonPressed === -1 && (this._swipeButtonPressed = t.button), i.preventDefaultOnPointerDown && a && (t.preventDefault(), a.focus()), this._startingPointerPosition.x = this._pointerX, this._startingPointerPosition.y = this._pointerY, this._startingPointerTime = Date.now(), this._checkPrePointerObservable(null, t, h.POINTERDOWN) || !i.cameraToUseForPointers && !i.activeCamera)
+        return;
+      this._pointerCaptures[t.pointerId] = !0, i.pointerDownPredicate || (i.pointerDownPredicate = (c) => c.isPickable && c.isVisible && c.isReady() && c.isEnabled() && (!i.cameraToUseForPointers || (i.cameraToUseForPointers.layerMask & c.layerMask) !== 0)), this._pickedDownMesh = null;
+      let l;
+      i.skipPointerDownPicking || i._registeredActions === 0 && !this._checkForPicking() && !i.onPointerDown ? l = new I() : l = i.pick(this._unTranslatedPointerX, this._unTranslatedPointerY, i.pointerDownPredicate, i.pointerDownFastCheck, i.cameraToUseForPointers), this._processPointerDown(l, t);
+    }, this._onPointerUp = (t) => {
+      this._totalPointersPressed !== 0 && (this._totalPointersPressed--, this._pickedUpMesh = null, this._meshPickProceed = !1, this._updatePointerPosition(t), i.preventDefaultOnPointerUp && a && (t.preventDefault(), a.focus()), this._initClickEvent(i.onPrePointerObservable, i.onPointerObservable, t, (r, l) => {
+        if (i.onPrePointerObservable.hasObservers() && (this._skipPointerTap = !1, !r.ignore)) {
+          if (this._checkPrePointerObservable(null, t, h.POINTERUP)) {
+            this._swipeButtonPressed === t.button && (this._isSwiping = !1, this._swipeButtonPressed = -1), t.buttons === 0 && (this._pointerCaptures[t.pointerId] = !1);
+            return;
+          }
+          r.hasSwiped || (r.singleClick && i.onPrePointerObservable.hasSpecificMask(h.POINTERTAP) && this._checkPrePointerObservable(null, t, h.POINTERTAP) && (this._skipPointerTap = !0), r.doubleClick && i.onPrePointerObservable.hasSpecificMask(h.POINTERDOUBLETAP) && this._checkPrePointerObservable(null, t, h.POINTERDOUBLETAP) && (this._skipPointerTap = !0));
+        }
+        if (!this._pointerCaptures[t.pointerId]) {
+          this._swipeButtonPressed === t.button && (this._isSwiping = !1, this._swipeButtonPressed = -1);
+          return;
+        }
+        t.buttons === 0 && (this._pointerCaptures[t.pointerId] = !1), !(!i.cameraToUseForPointers && !i.activeCamera) && (i.pointerUpPredicate || (i.pointerUpPredicate = (c) => c.isPickable && c.isVisible && c.isReady() && c.isEnabled() && (!i.cameraToUseForPointers || (i.cameraToUseForPointers.layerMask & c.layerMask) !== 0)), !this._meshPickProceed && (k && k.HasTriggers || this._checkForPicking() || i.onPointerUp) && this._initActionManager(null, r), l || (l = this._currentPickResult), this._processPointerUp(l, t, r), this._previousPickResult = this._currentPickResult, this._swipeButtonPressed === t.button && (this._isSwiping = !1, this._swipeButtonPressed = -1));
+      }));
+    }, this._onKeyDown = (t) => {
+      const r = m.KEYDOWN;
+      if (i.onPreKeyboardObservable.hasObservers()) {
+        const l = new E(r, t);
+        if (i.onPreKeyboardObservable.notifyObservers(l, r), l.skipOnKeyboardObservable)
+          return;
+      }
+      if (i.onKeyboardObservable.hasObservers()) {
+        const l = new U(r, t);
+        i.onKeyboardObservable.notifyObservers(l, r);
+      }
+      i.actionManager && i.actionManager.processTrigger(14, p.CreateNewFromScene(i, t));
+    }, this._onKeyUp = (t) => {
+      const r = m.KEYUP;
+      if (i.onPreKeyboardObservable.hasObservers()) {
+        const l = new E(r, t);
+        if (i.onPreKeyboardObservable.notifyObservers(l, r), l.skipOnKeyboardObservable)
+          return;
+      }
+      if (i.onKeyboardObservable.hasObservers()) {
+        const l = new U(r, t);
+        i.onKeyboardObservable.notifyObservers(l, r);
+      }
+      i.actionManager && i.actionManager.processTrigger(15, p.CreateNewFromScene(i, t));
+    }, this._deviceSourceManager.onDeviceConnectedObservable.add((t) => {
+      t.deviceType === w.Mouse ? t.onInputChangedObservable.add((r) => {
+        r.inputIndex === d.LeftClick || r.inputIndex === d.MiddleClick || r.inputIndex === d.RightClick || r.inputIndex === d.BrowserBack || r.inputIndex === d.BrowserForward ? s && t.getInput(r.inputIndex) === 1 ? this._onPointerDown(r) : e && t.getInput(r.inputIndex) === 0 && this._onPointerUp(r) : n && (r.inputIndex === d.Move ? this._onPointerMove(r) : (r.inputIndex === d.MouseWheelX || r.inputIndex === d.MouseWheelY || r.inputIndex === d.MouseWheelZ) && this._onPointerMove(r));
+      }) : t.deviceType === w.Touch ? t.onInputChangedObservable.add((r) => {
+        r.inputIndex === d.LeftClick && (s && t.getInput(r.inputIndex) === 1 ? (this._onPointerDown(r), this._totalPointersPressed > 1 && (this._isMultiTouchGesture = !0)) : e && t.getInput(r.inputIndex) === 0 && (this._onPointerUp(r), this._totalPointersPressed === 0 && (this._isMultiTouchGesture = !1))), n && r.inputIndex === d.Move && this._onPointerMove(r);
+      }) : t.deviceType === w.Keyboard && t.onInputChangedObservable.add((r) => {
+        r.type === "keydown" ? this._onKeyDown(r) : r.type === "keyup" && this._onKeyUp(r);
+      });
+    }), this._alreadyAttached = !0;
+  }
+  /**
+   * Detaches all event handlers
+   */
+  detachControl() {
+    this._alreadyAttached && (this._deviceSourceManager.dispose(), this._deviceSourceManager = null, this._alreadyAttachedTo && !this._scene.doNotHandleCursors && (this._alreadyAttachedTo.style.cursor = this._scene.defaultCursor), this._alreadyAttached = !1, this._alreadyAttachedTo = null);
+  }
+  /**
+   * Force the value of meshUnderPointer
+   * @param mesh - defines the mesh to use
+   * @param pointerId - optional pointer id when using more than one pointer. Defaults to 0
+   * @param pickResult - optional pickingInfo data used to find mesh
+   * @param evt - optional pointer event
+   */
+  setPointerOverMesh(e, s = 0, n, a) {
+    if (this._meshUnderPointerId[s] === e && (!e || !e._internalAbstractMeshDataInfo._pointerOverDisableMeshTesting))
+      return;
+    const i = this._meshUnderPointerId[s];
+    let o;
+    i && (o = i._getActionManagerForTrigger(10), o && o.processTrigger(10, p.CreateNew(i, a, { pointerId: s }))), e ? (this._meshUnderPointerId[s] = e, this._pointerOverMesh = e, o = e._getActionManagerForTrigger(9), o && o.processTrigger(9, p.CreateNew(e, a, { pointerId: s, pickResult: n }))) : (delete this._meshUnderPointerId[s], this._pointerOverMesh = null);
+  }
+  /**
+   * Gets the mesh under the pointer
+   * @returns a Mesh or null if no mesh is under the pointer
+   */
+  getPointerOverMesh() {
+    return this.meshUnderPointer;
+  }
+  /**
+   * @param mesh - Mesh to invalidate
+   * @internal
+   */
+  _invalidateMesh(e) {
+    this._pointerOverMesh === e && (this._pointerOverMesh = null), this._pickedDownMesh === e && (this._pickedDownMesh = null), this._pickedUpMesh === e && (this._pickedUpMesh = null);
+    for (const s in this._meshUnderPointerId)
+      this._meshUnderPointerId[s] === e && delete this._meshUnderPointerId[s];
+  }
+}
+_.DragMovementThreshold = 10;
+_.LongPressDelay = 500;
+_.DoubleClickDelay = 300;
+_.ExclusiveDoubleClickMode = !1;
+export {
+  _ as InputManager
+};