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

package/dist/node_modules/@babylonjs/core/DeviceInput/InputDevices/deviceSourceManager.esm.js

@@ -0,0 +1,106 @@
+import { DeviceType as r } from "./deviceEnums.esm.js";
+import { Observable as c } from "../../Misc/observable.esm.js";
+import { InternalDeviceSourceManager as o } from "../internalDeviceSourceManager.esm.js";
+class d {
+  // Public Functions
+  /**
+   * Gets a DeviceSource, given a type and slot
+   * @param deviceType - Type of Device
+   * @param deviceSlot - Slot or ID of device
+   * @returns DeviceSource
+   */
+  getDeviceSource(e, i) {
+    if (i === void 0) {
+      if (this._firstDevice[e] === void 0)
+        return null;
+      i = this._firstDevice[e];
+    }
+    return !this._devices[e] || this._devices[e][i] === void 0 ? null : this._devices[e][i];
+  }
+  /**
+   * Gets an array of DeviceSource objects for a given device type
+   * @param deviceType - Type of Device
+   * @returns All available DeviceSources of a given type
+   */
+  getDeviceSources(e) {
+    return this._devices[e] ? this._devices[e].filter((i) => !!i) : [];
+  }
+  /**
+   * Default constructor
+   * @param engine - Used to get canvas (if applicable)
+   */
+  constructor(e) {
+    const i = Object.keys(r).length / 2;
+    this._devices = new Array(i), this._firstDevice = new Array(i), this._engine = e, this._engine._deviceSourceManager || (this._engine._deviceSourceManager = new o(e)), this._engine._deviceSourceManager._refCount++, this.onDeviceConnectedObservable = new c((s) => {
+      for (const n of this._devices)
+        if (n)
+          for (const t of n)
+            t && this.onDeviceConnectedObservable.notifyObserver(s, t);
+    }), this.onDeviceDisconnectedObservable = new c(), this._engine._deviceSourceManager.registerManager(this), this._onDisposeObserver = e.onDisposeObservable.add(() => {
+      this.dispose();
+    });
+  }
+  /**
+   * Dispose of DeviceSourceManager
+   */
+  dispose() {
+    this.onDeviceConnectedObservable.clear(), this.onDeviceDisconnectedObservable.clear(), this._engine._deviceSourceManager && (this._engine._deviceSourceManager.unregisterManager(this), --this._engine._deviceSourceManager._refCount < 1 && (this._engine._deviceSourceManager.dispose(), delete this._engine._deviceSourceManager)), this._engine.onDisposeObservable.remove(this._onDisposeObserver);
+  }
+  // Hidden Functions
+  /**
+   * @param deviceSource - Source to add
+   * @internal
+   */
+  _addDevice(e) {
+    this._devices[e.deviceType] || (this._devices[e.deviceType] = new Array()), this._devices[e.deviceType][e.deviceSlot] || (this._devices[e.deviceType][e.deviceSlot] = e, this._updateFirstDevices(e.deviceType)), this.onDeviceConnectedObservable.notifyObservers(e);
+  }
+  /**
+   * @param deviceType - DeviceType
+   * @param deviceSlot - DeviceSlot
+   * @internal
+   */
+  _removeDevice(e, i) {
+    var s, n;
+    const t = (s = this._devices[e]) === null || s === void 0 ? void 0 : s[i];
+    this.onDeviceDisconnectedObservable.notifyObservers(t), !((n = this._devices[e]) === null || n === void 0) && n[i] && delete this._devices[e][i], this._updateFirstDevices(e);
+  }
+  /**
+   * @param deviceType - DeviceType
+   * @param deviceSlot - DeviceSlot
+   * @param eventData - Event
+   * @internal
+   */
+  _onInputChanged(e, i, s) {
+    var n, t;
+    (t = (n = this._devices[e]) === null || n === void 0 ? void 0 : n[i]) === null || t === void 0 || t.onInputChangedObservable.notifyObservers(s);
+  }
+  // Private Functions
+  _updateFirstDevices(e) {
+    switch (e) {
+      case r.Keyboard:
+      case r.Mouse:
+        this._firstDevice[e] = 0;
+        break;
+      case r.Touch:
+      case r.DualSense:
+      case r.DualShock:
+      case r.Xbox:
+      case r.Switch:
+      case r.Generic: {
+        delete this._firstDevice[e];
+        const i = this._devices[e];
+        if (i) {
+          for (let s = 0; s < i.length; s++)
+            if (i[s]) {
+              this._firstDevice[e] = s;
+              break;
+            }
+        }
+        break;
+      }
+    }
+  }
+}
+export {
+  d as DeviceSourceManager
+};

package/dist/node_modules/@babylonjs/core/DeviceInput/eventFactory.esm.js

@@ -0,0 +1,118 @@
+import { EventConstants as K } from "../Events/deviceInputEvents.esm.js";
+import { DeviceType as s, PointerInput as i, NativePointerInput as f } from "./InputDevices/deviceEnums.esm.js";
+class p {
+  /**
+   * Create device input events based on provided type and slot
+   *
+   * @param deviceType Type of device
+   * @param deviceSlot "Slot" or index that device is referenced in
+   * @param inputIndex Id of input to be checked
+   * @param currentState Current value for given input
+   * @param deviceInputSystem Reference to DeviceInputSystem
+   * @param elementToAttachTo HTMLElement to reference as target for inputs
+   * @returns IUIEvent object
+   */
+  static CreateDeviceEvent(o, t, a, l, r, n, e) {
+    switch (o) {
+      case s.Keyboard:
+        return this._CreateKeyboardEvent(a, l, r, n);
+      case s.Mouse:
+        if (a === i.MouseWheelX || a === i.MouseWheelY || a === i.MouseWheelZ)
+          return this._CreateWheelEvent(o, t, a, l, r, n);
+      case s.Touch:
+        return this._CreatePointerEvent(o, t, a, l, r, n, e);
+      default:
+        throw `Unable to generate event for device ${s[o]}`;
+    }
+  }
+  /**
+   * Creates pointer event
+   *
+   * @param deviceType Type of device
+   * @param deviceSlot "Slot" or index that device is referenced in
+   * @param inputIndex Id of input to be checked
+   * @param currentState Current value for given input
+   * @param deviceInputSystem Reference to DeviceInputSystem
+   * @param elementToAttachTo HTMLElement to reference as target for inputs
+   * @returns IUIEvent object (Pointer)
+   */
+  static _CreatePointerEvent(o, t, a, l, r, n, e) {
+    const h = this._CreateMouseEvent(o, t, a, l, r, n);
+    o === s.Mouse ? (h.deviceType = s.Mouse, h.pointerId = 1, h.pointerType = "mouse") : (h.deviceType = s.Touch, h.pointerId = e ?? t, h.pointerType = "touch");
+    let C = 0;
+    return C += r.pollInput(o, t, i.LeftClick), C += r.pollInput(o, t, i.RightClick) * 2, C += r.pollInput(o, t, i.MiddleClick) * 4, h.buttons = C, a === i.Move ? h.type = "pointermove" : a >= i.LeftClick && a <= i.RightClick && (h.type = l === 1 ? "pointerdown" : "pointerup", h.button = a - 2), h;
+  }
+  /**
+   * Create Mouse Wheel Event
+   * @param deviceType Type of device
+   * @param deviceSlot "Slot" or index that device is referenced in
+   * @param inputIndex Id of input to be checked
+   * @param currentState Current value for given input
+   * @param deviceInputSystem Reference to DeviceInputSystem
+   * @param elementToAttachTo HTMLElement to reference as target for inputs
+   * @returns IUIEvent object (Wheel)
+   */
+  static _CreateWheelEvent(o, t, a, l, r, n) {
+    const e = this._CreateMouseEvent(o, t, a, l, r, n);
+    switch (e.pointerId = 1, e.type = "wheel", e.deltaMode = K.DOM_DELTA_PIXEL, e.deltaX = 0, e.deltaY = 0, e.deltaZ = 0, a) {
+      case i.MouseWheelX:
+        e.deltaX = l;
+        break;
+      case i.MouseWheelY:
+        e.deltaY = l;
+        break;
+      case i.MouseWheelZ:
+        e.deltaZ = l;
+        break;
+    }
+    return e;
+  }
+  /**
+   * Create Mouse Event
+   * @param deviceType Type of device
+   * @param deviceSlot "Slot" or index that device is referenced in
+   * @param inputIndex Id of input to be checked
+   * @param currentState Current value for given input
+   * @param deviceInputSystem Reference to DeviceInputSystem
+   * @param elementToAttachTo HTMLElement to reference as target for inputs
+   * @returns IUIEvent object (Mouse)
+   */
+  static _CreateMouseEvent(o, t, a, l, r, n) {
+    const e = this._CreateEvent(n), h = r.pollInput(o, t, i.Horizontal), C = r.pollInput(o, t, i.Vertical);
+    return n ? (e.movementX = 0, e.movementY = 0, e.offsetX = e.movementX - n.getBoundingClientRect().x, e.offsetY = e.movementY - n.getBoundingClientRect().y) : (e.movementX = r.pollInput(o, t, f.DeltaHorizontal), e.movementY = r.pollInput(o, t, f.DeltaVertical), e.offsetX = 0, e.offsetY = 0), this._CheckNonCharacterKeys(e, r), e.clientX = h, e.clientY = C, e.x = h, e.y = C, e.deviceType = o, e.deviceSlot = t, e.inputIndex = a, e;
+  }
+  /**
+   * Create Keyboard Event
+   * @param inputIndex Id of input to be checked
+   * @param currentState Current value for given input
+   * @param deviceInputSystem Reference to DeviceInputSystem
+   * @param elementToAttachTo HTMLElement to reference as target for inputs
+   * @returns IEvent object (Keyboard)
+   */
+  static _CreateKeyboardEvent(o, t, a, l) {
+    const r = this._CreateEvent(l);
+    return this._CheckNonCharacterKeys(r, a), r.deviceType = s.Keyboard, r.deviceSlot = 0, r.inputIndex = o, r.type = t === 1 ? "keydown" : "keyup", r.key = String.fromCharCode(o), r.keyCode = o, r;
+  }
+  /**
+   * Add parameters for non-character keys (Ctrl, Alt, Meta, Shift)
+   * @param evt Event object to add parameters to
+   * @param deviceInputSystem DeviceInputSystem to pull values from
+   */
+  static _CheckNonCharacterKeys(o, t) {
+    const a = t.isDeviceAvailable(s.Keyboard), l = a && t.pollInput(s.Keyboard, 0, 18) === 1, r = a && t.pollInput(s.Keyboard, 0, 17) === 1, n = a && (t.pollInput(s.Keyboard, 0, 91) === 1 || t.pollInput(s.Keyboard, 0, 92) === 1 || t.pollInput(s.Keyboard, 0, 93) === 1), e = a && t.pollInput(s.Keyboard, 0, 16) === 1;
+    o.altKey = l, o.ctrlKey = r, o.metaKey = n, o.shiftKey = e;
+  }
+  /**
+   * Create base event object
+   * @param elementToAttachTo Value to use as event target
+   * @returns
+   */
+  static _CreateEvent(o) {
+    const t = {};
+    return t.preventDefault = () => {
+    }, t.target = o, t;
+  }
+}
+export {
+  p as DeviceEventFactory
+};

package/dist/node_modules/@babylonjs/core/DeviceInput/internalDeviceSourceManager.esm.js

@@ -0,0 +1,46 @@
+import { DeviceType as _ } from "./InputDevices/deviceEnums.esm.js";
+import { NativeDeviceInputSystem as g } from "./nativeDeviceInputSystem.esm.js";
+import { WebDeviceInputSystem as v } from "./webDeviceInputSystem.esm.js";
+import { DeviceSource as c } from "./InputDevices/deviceSource.esm.js";
+class y {
+  constructor(a) {
+    this._registeredManagers = new Array(), this._refCount = 0, this.registerManager = (s) => {
+      for (let e = 0; e < this._devices.length; e++) {
+        const t = this._devices[e];
+        for (const i in t) {
+          const h = +i;
+          s._addDevice(new c(this._deviceInputSystem, e, h));
+        }
+      }
+      this._registeredManagers.push(s);
+    }, this.unregisterManager = (s) => {
+      const e = this._registeredManagers.indexOf(s);
+      e > -1 && this._registeredManagers.splice(e, 1);
+    };
+    const d = Object.keys(_).length / 2;
+    this._devices = new Array(d);
+    const n = (s, e) => {
+      this._devices[s] || (this._devices[s] = new Array()), this._devices[s][e] || (this._devices[s][e] = e);
+      for (const t of this._registeredManagers) {
+        const i = new c(this._deviceInputSystem, s, e);
+        t._addDevice(i);
+      }
+    }, r = (s, e) => {
+      var t;
+      !((t = this._devices[s]) === null || t === void 0) && t[e] && delete this._devices[s][e];
+      for (const i of this._registeredManagers)
+        i._removeDevice(s, e);
+    }, o = (s, e, t) => {
+      if (t)
+        for (const i of this._registeredManagers)
+          i._onInputChanged(s, e, t);
+    };
+    typeof _native < "u" ? this._deviceInputSystem = new g(n, r, o) : this._deviceInputSystem = new v(a, n, r, o);
+  }
+  dispose() {
+    this._deviceInputSystem.dispose();
+  }
+}
+export {
+  y as InternalDeviceSourceManager
+};

package/dist/node_modules/@babylonjs/core/DeviceInput/nativeDeviceInputSystem.esm.js

@@ -0,0 +1,50 @@
+import { DeviceEventFactory as v } from "./eventFactory.esm.js";
+import { DeviceType as u } from "./InputDevices/deviceEnums.esm.js";
+class l {
+  constructor(t, e, n) {
+    this._nativeInput = _native.DeviceInputSystem ? new _native.DeviceInputSystem(t, e, (i, s, p, r) => {
+      const a = v.CreateDeviceEvent(i, s, p, r, this);
+      n(i, s, a);
+    }) : this._createDummyNativeInput();
+  }
+  // Public functions
+  /**
+   * Checks for current device input value, given an id and input index. Throws exception if requested device not initialized.
+   * @param deviceType Enum specifying device type
+   * @param deviceSlot "Slot" or index that device is referenced in
+   * @param inputIndex Id of input to be checked
+   * @returns Current value of input
+   */
+  pollInput(t, e, n) {
+    return this._nativeInput.pollInput(t, e, n);
+  }
+  /**
+   * Check for a specific device in the DeviceInputSystem
+   * @param deviceType Type of device to check for
+   * @returns bool with status of device's existence
+   */
+  isDeviceAvailable(t) {
+    return t === u.Mouse || t === u.Touch;
+  }
+  /**
+   * Dispose of all the observables
+   */
+  dispose() {
+    this._nativeInput.dispose();
+  }
+  /**
+   * For versions of BabylonNative that don't have the NativeInput plugin initialized, create a dummy version
+   * @returns Object with dummy functions
+   */
+  _createDummyNativeInput() {
+    return {
+      pollInput: () => 0,
+      isDeviceAvailable: () => !1,
+      dispose: () => {
+      }
+    };
+  }
+}
+export {
+  l as NativeDeviceInputSystem
+};

package/dist/node_modules/@babylonjs/core/DeviceInput/webDeviceInputSystem.esm.js

@@ -0,0 +1,354 @@
+import { IsNavigatorAvailable as f } from "../Misc/domManagement.esm.js";
+import { Tools as v } from "../Misc/tools.esm.js";
+import { DeviceEventFactory as l } from "./eventFactory.esm.js";
+import { PointerInput as a, DeviceType as o } from "./InputDevices/deviceEnums.esm.js";
+const m = 255, T = Object.keys(a).length / 2;
+class D {
+  constructor(t, s, e, i) {
+    this._inputs = [], this._keyboardActive = !1, this._pointerActive = !1, this._usingSafari = v.IsSafari(), this._usingMacOS = f() && /(Mac|iPhone|iPod|iPad)/i.test(navigator.platform), this._keyboardDownEvent = (n) => {
+    }, this._keyboardUpEvent = (n) => {
+    }, this._keyboardBlurEvent = (n) => {
+    }, this._pointerMoveEvent = (n) => {
+    }, this._pointerDownEvent = (n) => {
+    }, this._pointerUpEvent = (n) => {
+    }, this._pointerCancelEvent = (n) => {
+    }, this._pointerWheelEvent = (n) => {
+    }, this._pointerBlurEvent = (n) => {
+    }, this._eventsAttached = !1, this._mouseId = -1, this._isUsingFirefox = f() && navigator.userAgent && navigator.userAgent.indexOf("Firefox") !== -1, this._maxTouchPoints = 0, this._pointerInputClearObserver = null, this._gamepadConnectedEvent = (n) => {
+    }, this._gamepadDisconnectedEvent = (n) => {
+    }, this._eventPrefix = v.GetPointerPrefix(t), this._engine = t, this._onDeviceConnected = s, this._onDeviceDisconnected = e, this._onInputChanged = i, this._mouseId = this._isUsingFirefox ? 0 : 1, this._enableEvents(), this._usingMacOS && (this._metaKeys = []), this._engine._onEngineViewChanged || (this._engine._onEngineViewChanged = () => {
+      this._enableEvents();
+    });
+  }
+  // Public functions
+  /**
+   * Checks for current device input value, given an id and input index. Throws exception if requested device not initialized.
+   * @param deviceType Enum specifying device type
+   * @param deviceSlot "Slot" or index that device is referenced in
+   * @param inputIndex Id of input to be checked
+   * @returns Current value of input
+   */
+  pollInput(t, s, e) {
+    const i = this._inputs[t][s];
+    if (!i)
+      throw `Unable to find device ${o[t]}`;
+    t >= o.DualShock && t <= o.DualSense && this._updateDevice(t, s, e);
+    const n = i[e];
+    if (n === void 0)
+      throw `Unable to find input ${e} for device ${o[t]} in slot ${s}`;
+    return e === a.Move && v.Warn("Unable to provide information for PointerInput.Move.  Try using PointerInput.Horizontal or PointerInput.Vertical for move data."), n;
+  }
+  /**
+   * Check for a specific device in the DeviceInputSystem
+   * @param deviceType Type of device to check for
+   * @returns bool with status of device's existence
+   */
+  isDeviceAvailable(t) {
+    return this._inputs[t] !== void 0;
+  }
+  /**
+   * Dispose of all the eventlisteners
+   */
+  dispose() {
+    this._onDeviceConnected = () => {
+    }, this._onDeviceDisconnected = () => {
+    }, this._onInputChanged = () => {
+    }, delete this._engine._onEngineViewChanged, this._elementToAttachTo && this._disableEvents();
+  }
+  /**
+   * Enable listening for user input events
+   */
+  _enableEvents() {
+    const t = this === null || this === void 0 ? void 0 : this._engine.getInputElement();
+    if (t && (!this._eventsAttached || this._elementToAttachTo !== t)) {
+      if (this._disableEvents(), this._inputs) {
+        for (const s of this._inputs)
+          if (s)
+            for (const e in s) {
+              const i = +e, n = s[i];
+              if (n)
+                for (let r = 0; r < n.length; r++)
+                  n[r] = 0;
+            }
+      }
+      this._elementToAttachTo = t, this._elementToAttachTo.tabIndex = this._elementToAttachTo.tabIndex !== -1 ? this._elementToAttachTo.tabIndex : this._engine.canvasTabIndex, this._handleKeyActions(), this._handlePointerActions(), this._handleGamepadActions(), this._eventsAttached = !0, this._checkForConnectedDevices();
+    }
+  }
+  /**
+   * Disable listening for user input events
+   */
+  _disableEvents() {
+    this._elementToAttachTo && (this._elementToAttachTo.removeEventListener("blur", this._keyboardBlurEvent), this._elementToAttachTo.removeEventListener("blur", this._pointerBlurEvent), this._elementToAttachTo.removeEventListener("keydown", this._keyboardDownEvent), this._elementToAttachTo.removeEventListener("keyup", this._keyboardUpEvent), this._elementToAttachTo.removeEventListener(this._eventPrefix + "move", this._pointerMoveEvent), this._elementToAttachTo.removeEventListener(this._eventPrefix + "down", this._pointerDownEvent), this._elementToAttachTo.removeEventListener(this._eventPrefix + "up", this._pointerUpEvent), this._elementToAttachTo.removeEventListener(this._eventPrefix + "cancel", this._pointerCancelEvent), this._elementToAttachTo.removeEventListener(this._wheelEventName, this._pointerWheelEvent), window.removeEventListener("gamepadconnected", this._gamepadConnectedEvent), window.removeEventListener("gamepaddisconnected", this._gamepadDisconnectedEvent)), this._pointerInputClearObserver && this._engine.onEndFrameObservable.remove(this._pointerInputClearObserver), this._eventsAttached = !1;
+  }
+  /**
+   * Checks for existing connections to devices and register them, if necessary
+   * Currently handles gamepads and mouse
+   */
+  _checkForConnectedDevices() {
+    if (navigator.getGamepads) {
+      const t = navigator.getGamepads();
+      for (const s of t)
+        s && this._addGamePad(s);
+    }
+    typeof matchMedia == "function" && matchMedia("(pointer:fine)").matches && this._addPointerDevice(o.Mouse, 0, 0, 0);
+  }
+  // Private functions
+  /**
+   * Add a gamepad to the DeviceInputSystem
+   * @param gamepad A single DOM Gamepad object
+   */
+  _addGamePad(t) {
+    const s = this._getGamepadDeviceType(t.id), e = t.index;
+    this._gamepads = this._gamepads || new Array(t.index + 1), this._registerDevice(s, e, t.buttons.length + t.axes.length), this._gamepads[e] = s;
+  }
+  /**
+   * Add pointer device to DeviceInputSystem
+   * @param deviceType Type of Pointer to add
+   * @param deviceSlot Pointer ID (0 for mouse, pointerId for Touch)
+   * @param currentX Current X at point of adding
+   * @param currentY Current Y at point of adding
+   */
+  _addPointerDevice(t, s, e, i) {
+    this._pointerActive || (this._pointerActive = !0), this._registerDevice(t, s, T);
+    const n = this._inputs[t][s];
+    n[0] = e, n[1] = i;
+  }
+  /**
+   * Add device and inputs to device array
+   * @param deviceType Enum specifying device type
+   * @param deviceSlot "Slot" or index that device is referenced in
+   * @param numberOfInputs Number of input entries to create for given device
+   */
+  _registerDevice(t, s, e) {
+    if (s === void 0)
+      throw `Unable to register device ${o[t]} to undefined slot.`;
+    if (this._inputs[t] || (this._inputs[t] = {}), !this._inputs[t][s]) {
+      const i = new Array(e);
+      i.fill(0), this._inputs[t][s] = i, this._onDeviceConnected(t, s);
+    }
+  }
+  /**
+   * Given a specific device name, remove that device from the device map
+   * @param deviceType Enum specifying device type
+   * @param deviceSlot "Slot" or index that device is referenced in
+   */
+  _unregisterDevice(t, s) {
+    this._inputs[t][s] && (delete this._inputs[t][s], this._onDeviceDisconnected(t, s));
+  }
+  /**
+   * Handle all actions that come from keyboard interaction
+   */
+  _handleKeyActions() {
+    this._keyboardDownEvent = (t) => {
+      this._keyboardActive || (this._keyboardActive = !0, this._registerDevice(o.Keyboard, 0, m));
+      const s = this._inputs[o.Keyboard][0];
+      if (s) {
+        s[t.keyCode] = 1;
+        const e = t;
+        e.inputIndex = t.keyCode, this._usingMacOS && t.metaKey && t.key !== "Meta" && (this._metaKeys.includes(t.keyCode) || this._metaKeys.push(t.keyCode)), this._onInputChanged(o.Keyboard, 0, e);
+      }
+    }, this._keyboardUpEvent = (t) => {
+      this._keyboardActive || (this._keyboardActive = !0, this._registerDevice(o.Keyboard, 0, m));
+      const s = this._inputs[o.Keyboard][0];
+      if (s) {
+        s[t.keyCode] = 0;
+        const e = t;
+        if (e.inputIndex = t.keyCode, this._usingMacOS && t.key === "Meta" && this._metaKeys.length > 0) {
+          for (const i of this._metaKeys) {
+            const n = l.CreateDeviceEvent(o.Keyboard, 0, i, 0, this, this._elementToAttachTo);
+            s[i] = 0, this._onInputChanged(o.Keyboard, 0, n);
+          }
+          this._metaKeys.splice(0, this._metaKeys.length);
+        }
+        this._onInputChanged(o.Keyboard, 0, e);
+      }
+    }, this._keyboardBlurEvent = () => {
+      if (this._keyboardActive) {
+        const t = this._inputs[o.Keyboard][0];
+        for (let s = 0; s < t.length; s++)
+          if (t[s] !== 0) {
+            t[s] = 0;
+            const e = l.CreateDeviceEvent(o.Keyboard, 0, s, 0, this, this._elementToAttachTo);
+            this._onInputChanged(o.Keyboard, 0, e);
+          }
+        this._usingMacOS && this._metaKeys.splice(0, this._metaKeys.length);
+      }
+    }, this._elementToAttachTo.addEventListener("keydown", this._keyboardDownEvent), this._elementToAttachTo.addEventListener("keyup", this._keyboardUpEvent), this._elementToAttachTo.addEventListener("blur", this._keyboardBlurEvent);
+  }
+  /**
+   * Handle all actions that come from pointer interaction
+   */
+  _handlePointerActions() {
+    this._maxTouchPoints = f() && navigator.maxTouchPoints || 2, this._activeTouchIds || (this._activeTouchIds = new Array(this._maxTouchPoints));
+    for (let e = 0; e < this._maxTouchPoints; e++)
+      this._activeTouchIds[e] = -1;
+    this._pointerMoveEvent = (e) => {
+      const i = this._getPointerType(e), n = i === o.Mouse ? 0 : this._activeTouchIds.indexOf(e.pointerId);
+      this._inputs[i] || (this._inputs[i] = {}), this._inputs[i][n] || this._addPointerDevice(i, n, e.clientX, e.clientY);
+      const r = this._inputs[i][n];
+      if (r) {
+        const c = e;
+        c.inputIndex = a.Move, r[a.Horizontal] = e.clientX, r[a.Vertical] = e.clientY, e.pointerId === void 0 && (e.pointerId = this._mouseId), this._onInputChanged(i, n, c), !this._usingSafari && e.button !== -1 && (c.inputIndex = e.button + 2, r[e.button + 2] = r[e.button + 2] ? 0 : 1, this._onInputChanged(i, n, c));
+      }
+    }, this._pointerDownEvent = (e) => {
+      const i = this._getPointerType(e);
+      let n = i === o.Mouse ? 0 : e.pointerId;
+      if (i === o.Touch) {
+        const c = this._activeTouchIds.indexOf(-1);
+        if (c >= 0)
+          n = c, this._activeTouchIds[c] = e.pointerId;
+        else {
+          v.Warn(`Max number of touches exceeded.  Ignoring touches in excess of ${this._maxTouchPoints}`);
+          return;
+        }
+      }
+      this._inputs[i] || (this._inputs[i] = {}), this._inputs[i][n] ? i === o.Touch && this._onDeviceConnected(i, n) : this._addPointerDevice(i, n, e.clientX, e.clientY);
+      const r = this._inputs[i][n];
+      if (r) {
+        const c = r[a.Horizontal], d = r[a.Vertical];
+        if (i === o.Mouse) {
+          if (e.pointerId === void 0 && (e.pointerId = this._mouseId), !document.pointerLockElement)
+            try {
+              this._elementToAttachTo.setPointerCapture(this._mouseId);
+            } catch {
+            }
+        } else if (e.pointerId && !document.pointerLockElement)
+          try {
+            this._elementToAttachTo.setPointerCapture(e.pointerId);
+          } catch {
+          }
+        r[a.Horizontal] = e.clientX, r[a.Vertical] = e.clientY, r[e.button + 2] = 1;
+        const h = e;
+        h.inputIndex = e.button + 2, this._onInputChanged(i, n, h), (c !== e.clientX || d !== e.clientY) && (h.inputIndex = a.Move, this._onInputChanged(i, n, h));
+      }
+    }, this._pointerUpEvent = (e) => {
+      var i, n, r, c, d;
+      const h = this._getPointerType(e), _ = h === o.Mouse ? 0 : this._activeTouchIds.indexOf(e.pointerId);
+      if (h === o.Touch) {
+        if (_ === -1)
+          return;
+        this._activeTouchIds[_] = -1;
+      }
+      const u = (i = this._inputs[h]) === null || i === void 0 ? void 0 : i[_];
+      if (u && u[e.button + 2] !== 0) {
+        const E = u[a.Horizontal], g = u[a.Vertical];
+        u[a.Horizontal] = e.clientX, u[a.Vertical] = e.clientY, u[e.button + 2] = 0;
+        const p = e;
+        e.pointerId === void 0 && (e.pointerId = this._mouseId), (E !== e.clientX || g !== e.clientY) && (p.inputIndex = a.Move, this._onInputChanged(h, _, p)), p.inputIndex = e.button + 2, h === o.Mouse && this._mouseId >= 0 && (!((r = (n = this._elementToAttachTo).hasPointerCapture) === null || r === void 0) && r.call(n, this._mouseId)) ? this._elementToAttachTo.releasePointerCapture(this._mouseId) : e.pointerId && (!((d = (c = this._elementToAttachTo).hasPointerCapture) === null || d === void 0) && d.call(c, e.pointerId)) && this._elementToAttachTo.releasePointerCapture(e.pointerId), this._onInputChanged(h, _, p), h === o.Touch && this._onDeviceDisconnected(h, _);
+      }
+    }, this._pointerCancelEvent = (e) => {
+      var i, n, r, c;
+      if (e.pointerType === "mouse") {
+        const d = this._inputs[o.Mouse][0];
+        this._mouseId >= 0 && (!((n = (i = this._elementToAttachTo).hasPointerCapture) === null || n === void 0) && n.call(i, this._mouseId)) && this._elementToAttachTo.releasePointerCapture(this._mouseId);
+        for (let h = a.LeftClick; h <= a.BrowserForward; h++)
+          if (d[h] === 1) {
+            d[h] = 0;
+            const _ = l.CreateDeviceEvent(o.Mouse, 0, h, 0, this, this._elementToAttachTo);
+            this._onInputChanged(o.Mouse, 0, _);
+          }
+      } else {
+        const d = this._activeTouchIds.indexOf(e.pointerId);
+        !((c = (r = this._elementToAttachTo).hasPointerCapture) === null || c === void 0) && c.call(r, e.pointerId) && this._elementToAttachTo.releasePointerCapture(e.pointerId), this._inputs[o.Touch][d][a.LeftClick] = 0;
+        const h = l.CreateDeviceEvent(o.Touch, d, a.LeftClick, 0, this, this._elementToAttachTo, e.pointerId);
+        this._onInputChanged(o.Touch, d, h), this._activeTouchIds[d] = -1, this._onDeviceDisconnected(o.Touch, d);
+      }
+    }, this._wheelEventName = "onwheel" in document.createElement("div") ? "wheel" : document.onmousewheel !== void 0 ? "mousewheel" : "DOMMouseScroll";
+    let t = !1;
+    const s = function() {
+    };
+    try {
+      const e = Object.defineProperty({}, "passive", {
+        get: function() {
+          t = !0;
+        }
+      });
+      this._elementToAttachTo.addEventListener("test", s, e), this._elementToAttachTo.removeEventListener("test", s, e);
+    } catch {
+    }
+    this._pointerBlurEvent = () => {
+      var e, i, n, r, c;
+      if (this.isDeviceAvailable(o.Mouse)) {
+        const d = this._inputs[o.Mouse][0];
+        this._mouseId >= 0 && (!((i = (e = this._elementToAttachTo).hasPointerCapture) === null || i === void 0) && i.call(e, this._mouseId)) && this._elementToAttachTo.releasePointerCapture(this._mouseId);
+        for (let h = a.LeftClick; h <= a.BrowserForward; h++)
+          if (d[h] === 1) {
+            d[h] = 0;
+            const _ = l.CreateDeviceEvent(o.Mouse, 0, h, 0, this, this._elementToAttachTo);
+            this._onInputChanged(o.Mouse, 0, _);
+          }
+      }
+      if (this.isDeviceAvailable(o.Touch)) {
+        const d = this._inputs[o.Touch];
+        for (let h = 0; h < this._activeTouchIds.length; h++) {
+          const _ = this._activeTouchIds[h];
+          if (!((r = (n = this._elementToAttachTo).hasPointerCapture) === null || r === void 0) && r.call(n, _) && this._elementToAttachTo.releasePointerCapture(_), _ !== -1 && ((c = d[h]) === null || c === void 0 ? void 0 : c[a.LeftClick]) === 1) {
+            d[h][a.LeftClick] = 0;
+            const u = l.CreateDeviceEvent(o.Touch, h, a.LeftClick, 0, this, this._elementToAttachTo, _);
+            this._onInputChanged(o.Touch, h, u), this._activeTouchIds[h] = -1, this._onDeviceDisconnected(o.Touch, h);
+          }
+        }
+      }
+    }, this._pointerWheelEvent = (e) => {
+      const i = o.Mouse, n = 0;
+      this._inputs[i] || (this._inputs[i] = []), this._inputs[i][n] || (this._pointerActive = !0, this._registerDevice(i, n, T));
+      const r = this._inputs[i][n];
+      if (r) {
+        r[a.MouseWheelX] = e.deltaX || 0, r[a.MouseWheelY] = e.deltaY || e.wheelDelta || 0, r[a.MouseWheelZ] = e.deltaZ || 0;
+        const c = e;
+        e.pointerId === void 0 && (e.pointerId = this._mouseId), r[a.MouseWheelX] !== 0 && (c.inputIndex = a.MouseWheelX, this._onInputChanged(i, n, c)), r[a.MouseWheelY] !== 0 && (c.inputIndex = a.MouseWheelY, this._onInputChanged(i, n, c)), r[a.MouseWheelZ] !== 0 && (c.inputIndex = a.MouseWheelZ, this._onInputChanged(i, n, c));
+      }
+    }, this._elementToAttachTo.addEventListener(this._eventPrefix + "move", this._pointerMoveEvent), this._elementToAttachTo.addEventListener(this._eventPrefix + "down", this._pointerDownEvent), this._elementToAttachTo.addEventListener(this._eventPrefix + "up", this._pointerUpEvent), this._elementToAttachTo.addEventListener(this._eventPrefix + "cancel", this._pointerCancelEvent), this._elementToAttachTo.addEventListener("blur", this._pointerBlurEvent), this._elementToAttachTo.addEventListener(this._wheelEventName, this._pointerWheelEvent, t ? { passive: !1 } : !1), this._pointerInputClearObserver = this._engine.onEndFrameObservable.add(() => {
+      if (this.isDeviceAvailable(o.Mouse)) {
+        const e = this._inputs[o.Mouse][0];
+        e[a.MouseWheelX] = 0, e[a.MouseWheelY] = 0, e[a.MouseWheelZ] = 0;
+      }
+    });
+  }
+  /**
+   * Handle all actions that come from gamepad interaction
+   */
+  _handleGamepadActions() {
+    this._gamepadConnectedEvent = (t) => {
+      this._addGamePad(t.gamepad);
+    }, this._gamepadDisconnectedEvent = (t) => {
+      if (this._gamepads) {
+        const s = this._getGamepadDeviceType(t.gamepad.id), e = t.gamepad.index;
+        this._unregisterDevice(s, e), delete this._gamepads[e];
+      }
+    }, window.addEventListener("gamepadconnected", this._gamepadConnectedEvent), window.addEventListener("gamepaddisconnected", this._gamepadDisconnectedEvent);
+  }
+  /**
+   * Update all non-event based devices with each frame
+   * @param deviceType Enum specifying device type
+   * @param deviceSlot "Slot" or index that device is referenced in
+   * @param inputIndex Id of input to be checked
+   */
+  _updateDevice(t, s, e) {
+    const i = navigator.getGamepads()[s];
+    if (i && t === this._gamepads[s]) {
+      const n = this._inputs[t][s];
+      e >= i.buttons.length ? n[e] = i.axes[e - i.buttons.length].valueOf() : n[e] = i.buttons[e].value;
+    }
+  }
+  /**
+   * Gets DeviceType from the device name
+   * @param deviceName Name of Device from DeviceInputSystem
+   * @returns DeviceType enum value
+   */
+  _getGamepadDeviceType(t) {
+    return t.indexOf("054c") !== -1 ? t.indexOf("0ce6") !== -1 ? o.DualSense : o.DualShock : t.indexOf("Xbox One") !== -1 || t.search("Xbox 360") !== -1 || t.search("xinput") !== -1 ? o.Xbox : t.indexOf("057e") !== -1 ? o.Switch : o.Generic;
+  }
+  /**
+   * Get DeviceType from a given pointer/mouse/touch event.
+   * @param evt PointerEvent to evaluate
+   * @returns DeviceType interpreted from event
+   */
+  _getPointerType(t) {
+    let s = o.Mouse;
+    return (t.pointerType === "touch" || t.pointerType === "pen" || t.touches) && (s = o.Touch), s;
+  }
+}
+export {
+  D as WebDeviceInputSystem
+};