interaction-system 1.0.0

package/dist/index.cjs.js

@@ -0,0 +1,1983 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const buffer = require("buffer");
+const _MotionEvent = class _MotionEvent {
+};
+_MotionEvent.ACTION_DOWN = 0;
+_MotionEvent.ACTION_UP = 1;
+_MotionEvent.ACTION_MOVE = 2;
+_MotionEvent.BUTTON_PRIMARY = 1 << 0;
+_MotionEvent.BUTTON_SECONDARY = 1 << 1;
+_MotionEvent.BUTTON_TERTIARY = 1 << 2;
+let MotionEvent = _MotionEvent;
+const _ControlMessage = class _ControlMessage {
+  constructor(type) {
+    this.type = type;
+  }
+  toBuffer() {
+    throw Error("Not implemented");
+  }
+  toString() {
+    return "ControlMessage";
+  }
+  toJSON() {
+    return {
+      type: this.type
+    };
+  }
+};
+_ControlMessage.TYPE_KEYCODE = 0;
+_ControlMessage.TYPE_TEXT = 1;
+_ControlMessage.TYPE_TOUCH = 2;
+_ControlMessage.TYPE_SCROLL = 3;
+_ControlMessage.TYPE_BACK_OR_SCREEN_ON = 4;
+_ControlMessage.TYPE_EXPAND_NOTIFICATION_PANEL = 5;
+_ControlMessage.TYPE_EXPAND_SETTINGS_PANEL = 6;
+_ControlMessage.TYPE_COLLAPSE_PANELS = 7;
+_ControlMessage.TYPE_GET_CLIPBOARD = 8;
+_ControlMessage.TYPE_SET_CLIPBOARD = 9;
+_ControlMessage.TYPE_SET_SCREEN_POWER_MODE = 10;
+_ControlMessage.TYPE_ROTATE_DEVICE = 11;
+_ControlMessage.TYPE_CHANGE_STREAM_PARAMETERS = 101;
+_ControlMessage.TYPE_PUSH_FILE = 102;
+let ControlMessage = _ControlMessage;
+const _TouchControlMessage = class _TouchControlMessage extends ControlMessage {
+  constructor(action, pointerId, position, pressure, buttons) {
+    super(ControlMessage.TYPE_TOUCH);
+    this.action = action;
+    this.pointerId = pointerId;
+    this.position = position;
+    this.pressure = pressure;
+    this.buttons = buttons;
+  }
+  /**
+   * @override
+   */
+  toBuffer() {
+    const buffer$1 = buffer.Buffer.alloc(_TouchControlMessage.PAYLOAD_LENGTH + 1);
+    let offset = 0;
+    offset = buffer$1.writeUInt8(this.type, offset);
+    offset = buffer$1.writeUInt8(this.action, offset);
+    offset = buffer$1.writeUInt32BE(0, offset);
+    offset = buffer$1.writeUInt32BE(this.pointerId, offset);
+    offset = buffer$1.writeUInt32BE(this.position.point.x, offset);
+    offset = buffer$1.writeUInt32BE(this.position.point.y, offset);
+    offset = buffer$1.writeUInt16BE(this.position.screenSize.width, offset);
+    offset = buffer$1.writeUInt16BE(this.position.screenSize.height, offset);
+    offset = buffer$1.writeUInt16BE(this.pressure * _TouchControlMessage.MAX_PRESSURE_VALUE, offset);
+    buffer$1.writeUInt32BE(this.buttons, offset);
+    return buffer$1;
+  }
+  toString() {
+    return `TouchControlMessage{action=${this.action}, pointerId=${this.pointerId}, position=${this.position}, pressure=${this.pressure}, buttons=${this.buttons}}`;
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      action: this.action,
+      pointerId: this.pointerId,
+      position: this.position.toJSON(),
+      pressure: this.pressure,
+      buttons: this.buttons
+    };
+  }
+};
+_TouchControlMessage.PAYLOAD_LENGTH = 28;
+_TouchControlMessage.MAX_PRESSURE_VALUE = 65535;
+let TouchControlMessage = _TouchControlMessage;
+class Size {
+  constructor(width, height) {
+    this.width = width;
+    this.height = height;
+    this.w = width;
+    this.h = height;
+  }
+  static equals(a, b) {
+    if (!a && !b) {
+      return true;
+    }
+    return !!a && !!b && a.equals(b);
+  }
+  static copy(a) {
+    if (!a) {
+      return null;
+    }
+    return new Size(a.width, a.height);
+  }
+  length() {
+    return this.w * this.h;
+  }
+  rotate() {
+    return new Size(this.height, this.width);
+  }
+  equals(o) {
+    if (this === o) {
+      return true;
+    }
+    if (!o) {
+      return false;
+    }
+    return this.width === o.width && this.height === o.height;
+  }
+  intersect(o) {
+    if (!o) {
+      return this;
+    }
+    const minH = Math.min(this.height, o.height);
+    const minW = Math.min(this.width, o.width);
+    return new Size(minW, minH);
+  }
+  getHalfSize() {
+    return new Size(this.width >>> 1, this.height >>> 1);
+  }
+  toString() {
+    return `Size{width=${this.width}, height=${this.height}}`;
+  }
+  toJSON() {
+    return {
+      width: this.width,
+      height: this.height
+    };
+  }
+}
+class Point {
+  constructor(x, y) {
+    this.x = Math.round(x);
+    this.y = Math.round(y);
+  }
+  equals(o) {
+    if (this === o) {
+      return true;
+    }
+    if (o === null) {
+      return false;
+    }
+    return this.x === o.x && this.y === o.y;
+  }
+  distance(to) {
+    const x = this.x - to.x;
+    const y = this.y - to.y;
+    return Math.sqrt(x * x + y * y);
+  }
+  toString() {
+    return `Point{x=${this.x}, y=${this.y}}`;
+  }
+  toJSON() {
+    return {
+      x: this.x,
+      y: this.y
+    };
+  }
+}
+class Position {
+  constructor(point, screenSize) {
+    this.point = point;
+    this.screenSize = screenSize;
+  }
+  equals(o) {
+    if (this === o) {
+      return true;
+    }
+    if (o === null) {
+      return false;
+    }
+    return this.point.equals(o.point) && this.screenSize.equals(o.screenSize);
+  }
+  rotate(rotation) {
+    switch (rotation) {
+      case 1:
+        return new Position(
+          new Point(this.screenSize.height - this.point.y, this.point.x),
+          this.screenSize.rotate()
+        );
+      case 2:
+        return new Position(
+          new Point(this.screenSize.width - this.point.x, this.screenSize.height - this.point.y),
+          this.screenSize
+        );
+      case 3:
+        return new Position(
+          new Point(this.point.y, this.screenSize.width - this.point.x),
+          this.screenSize.rotate()
+        );
+      default:
+        return this;
+    }
+  }
+  toString() {
+    return `Position{point=${this.point}, screenSize=${this.screenSize}}`;
+  }
+  toJSON() {
+    return {
+      point: this.point.toJSON(),
+      screenSize: this.screenSize.toJSON()
+    };
+  }
+}
+const _Util = class _Util {
+  /**
+   * 将 UTF-8 字节数组转换为 JavaScript 字符串
+   * @param bytes UTF-8 字节数组
+   * @returns 16位 Unicode 字符串
+   */
+  static utf8ByteArrayToString(bytes) {
+    var out = [], pos = 0, c = 0;
+    while (pos < bytes.length) {
+      var c1 = bytes[pos++];
+      if (c1 < 128) {
+        out[c++] = String.fromCharCode(c1);
+      } else if (c1 > 191 && c1 < 224) {
+        var c2 = bytes[pos++];
+        out[c++] = String.fromCharCode((c1 & 31) << 6 | c2 & 63);
+      } else if (c1 > 239 && c1 < 365) {
+        var c2 = bytes[pos++];
+        var c3 = bytes[pos++];
+        var c4 = bytes[pos++];
+        var u = ((c1 & 7) << 18 | (c2 & 63) << 12 | (c3 & 63) << 6 | c4 & 63) - 65536;
+        out[c++] = String.fromCharCode(55296 + (u >> 10));
+        out[c++] = String.fromCharCode(56320 + (u & 1023));
+      } else {
+        var c2 = bytes[pos++];
+        var c3 = bytes[pos++];
+        out[c++] = String.fromCharCode((c1 & 15) << 12 | (c2 & 63) << 6 | c3 & 63);
+      }
+    }
+    return out.join("");
+  }
+  /**
+   * 检测浏览器是否支持 passive 事件监听器
+   * 参考: https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md
+   * @returns 是否支持 passive 选项
+   */
+  static supportsPassive() {
+    if (typeof _Util.supportsPassiveValue === "boolean") {
+      return _Util.supportsPassiveValue;
+    }
+    let supportsPassive = false;
+    try {
+      const opts = Object.defineProperty({}, "passive", {
+        get: function() {
+          supportsPassive = true;
+        }
+      });
+      window.addEventListener("testPassive", null, opts);
+      window.removeEventListener("testPassive", null, opts);
+    } catch (error) {
+    }
+    return _Util.supportsPassiveValue = supportsPassive;
+  }
+};
+_Util.stringToUtf8ByteArray = function(str) {
+  var out = [], p = 0;
+  for (var i = 0; i < str.length; i++) {
+    var c = str.charCodeAt(i);
+    if (c < 128) {
+      out[p++] = c;
+    } else if (c < 2048) {
+      out[p++] = c >> 6 | 192;
+      out[p++] = c & 63 | 128;
+    } else if ((c & 64512) == 55296 && i + 1 < str.length && (str.charCodeAt(i + 1) & 64512) == 56320) {
+      c = 65536 + ((c & 1023) << 10) + (str.charCodeAt(++i) & 1023);
+      out[p++] = c >> 18 | 240;
+      out[p++] = c >> 12 & 63 | 128;
+      out[p++] = c >> 6 & 63 | 128;
+      out[p++] = c & 63 | 128;
+    } else {
+      out[p++] = c >> 12 | 224;
+      out[p++] = c >> 6 & 63 | 128;
+      out[p++] = c & 63 | 128;
+    }
+  }
+  return Uint8Array.from(out);
+};
+let Util = _Util;
+const TouchPointPNG = "../assets/images/touch_point.png";
+const CenterPointPNG = "../assets/images/center_point.png";
+const TAG$2 = "[TouchHandler]";
+const _InteractionHandler = class _InteractionHandler {
+  constructor(player, touchEventsNames, keyEventsNames) {
+    this.player = player;
+    this.touchEventsNames = touchEventsNames;
+    this.keyEventsNames = keyEventsNames;
+    this.multiTouchActive = false;
+    this.multiTouchShift = false;
+    this.dirtyPlace = [];
+    this.over = false;
+    this.tag = player.getTouchableElement();
+    this.ctx = this.tag.getContext("2d");
+    _InteractionHandler.loadImages();
+    _InteractionHandler.bindGlobalListeners(this);
+  }
+  static bindGlobalListeners(interactionHandler) {
+    interactionHandler.touchEventsNames.forEach((eventName) => {
+      let set = _InteractionHandler.eventListeners.get(eventName);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        document.body.addEventListener(eventName, this.onInteractionEvent, _InteractionHandler.options);
+        this.eventListeners.set(eventName, set);
+      }
+      set.add(interactionHandler);
+    });
+    interactionHandler.keyEventsNames.forEach((eventName) => {
+      let set = _InteractionHandler.eventListeners.get(eventName);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        document.body.addEventListener(eventName, this.onKeyEvent);
+        this.eventListeners.set(eventName, set);
+      }
+      set.add(interactionHandler);
+    });
+  }
+  static unbindListeners(touchHandler) {
+    touchHandler.touchEventsNames.forEach((eventName) => {
+      const set = _InteractionHandler.eventListeners.get(eventName);
+      if (!set) {
+        return;
+      }
+      set.delete(touchHandler);
+      if (set.size <= 0) {
+        this.eventListeners.delete(eventName);
+        document.body.removeEventListener(eventName, this.onInteractionEvent);
+      }
+    });
+    touchHandler.keyEventsNames.forEach((eventName) => {
+      const set = _InteractionHandler.eventListeners.get(eventName);
+      if (!set) {
+        return;
+      }
+      set.delete(touchHandler);
+      if (set.size <= 0) {
+        this.eventListeners.delete(eventName);
+        document.body.removeEventListener(eventName, this.onKeyEvent);
+      }
+    });
+  }
+  static loadImages() {
+    if (this.pointImagesLoaded) {
+      return;
+    }
+    const total = 2;
+    let current = 0;
+    const onload = (event) => {
+      if (++current === total) {
+        this.pointImagesLoaded = true;
+      }
+      if (event.target === this.touchPointImage) {
+        this.touchPointRadius = this.touchPointImage.width / 2;
+      } else if (event.target === this.centerPointImage) {
+        this.centerPointRadius = this.centerPointImage.width / 2;
+      }
+    };
+    const touch = this.touchPointImage = new Image();
+    touch.src = TouchPointPNG;
+    touch.onload = onload;
+    const center = this.centerPointImage = new Image();
+    center.src = CenterPointPNG;
+    center.onload = onload;
+  }
+  static getPointerId(type, identifier) {
+    if (this.idToPointerMap.has(identifier)) {
+      const pointerId2 = this.idToPointerMap.get(identifier);
+      if (type === "touchend" || type === "touchcancel") {
+        this.idToPointerMap.delete(identifier);
+        this.pointerToIdMap.delete(pointerId2);
+      }
+      return pointerId2;
+    }
+    let pointerId = 0;
+    while (this.pointerToIdMap.has(pointerId)) {
+      pointerId++;
+    }
+    this.idToPointerMap.set(identifier, pointerId);
+    this.pointerToIdMap.set(pointerId, identifier);
+    return pointerId;
+  }
+  static buildTouchOnClient(event, screenInfo) {
+    const action = this.mapTypeToAction(event.type);
+    const { width, height } = screenInfo.videoSize;
+    const target = event.target;
+    const rect = target.getBoundingClientRect();
+    let { clientWidth, clientHeight } = target;
+    let touchX = event.clientX - rect.left;
+    let touchY = event.clientY - rect.top;
+    let invalid = false;
+    if (touchX < 0 || touchX > clientWidth || touchY < 0 || touchY > clientHeight) {
+      invalid = true;
+    }
+    const eps = 1e5;
+    const ratio = width / height;
+    const shouldBe = Math.round(eps * ratio);
+    const haveNow = Math.round(eps * clientWidth / clientHeight);
+    if (shouldBe > haveNow) {
+      const realHeight = Math.ceil(clientWidth / ratio);
+      const top = (clientHeight - realHeight) / 2;
+      if (touchY < top || touchY > top + realHeight) {
+        invalid = true;
+      }
+      touchY -= top;
+      clientHeight = realHeight;
+    } else if (shouldBe < haveNow) {
+      const realWidth = Math.ceil(clientHeight * ratio);
+      const left = (clientWidth - realWidth) / 2;
+      if (touchX < left || touchX > left + realWidth) {
+        invalid = true;
+      }
+      touchX -= left;
+      clientWidth = realWidth;
+    }
+    const x = touchX * width / clientWidth;
+    const y = touchY * height / clientHeight;
+    const size = new Size(width, height);
+    const point = new Point(x, y);
+    const position = new Position(point, size);
+    if (x < 0 || y < 0 || x > width || y > height) {
+      invalid = true;
+    }
+    return {
+      client: {
+        width: clientWidth,
+        height: clientHeight
+      },
+      touch: {
+        invalid,
+        action,
+        position,
+        buttons: event.buttons
+      }
+    };
+  }
+  static validateMessage(originalEvent, message, storage, logPrefix) {
+    const messages = [];
+    const { action, pointerId } = message;
+    const previous = storage.get(pointerId);
+    if (action === MotionEvent.ACTION_UP) {
+      if (!previous) {
+        console.warn(logPrefix, "Received ACTION_UP while there are no DOWN stored");
+      } else {
+        storage.delete(pointerId);
+        messages.push(message);
+      }
+    } else if (action === MotionEvent.ACTION_DOWN) {
+      if (previous) {
+        console.warn(logPrefix, "Received ACTION_DOWN while already has one stored");
+      } else {
+        storage.set(pointerId, message);
+        messages.push(message);
+      }
+    } else if (action === MotionEvent.ACTION_MOVE) {
+      if (!previous) {
+        if (originalEvent instanceof MouseEvent && originalEvent.buttons || window["TouchEvent"] && originalEvent instanceof TouchEvent) {
+          console.warn(logPrefix, "Received ACTION_MOVE while there are no DOWN stored");
+          const emulated = _InteractionHandler.createEmulatedMessage(MotionEvent.ACTION_DOWN, message);
+          messages.push(emulated);
+          storage.set(pointerId, emulated);
+        }
+      } else {
+        messages.push(message);
+        storage.set(pointerId, message);
+      }
+    }
+    return messages;
+  }
+  static createEmulatedMessage(action, event) {
+    const { pointerId, position, buttons } = event;
+    let pressure = event.pressure;
+    if (action === MotionEvent.ACTION_UP) {
+      pressure = 0;
+    }
+    return new TouchControlMessage(action, pointerId, position, pressure, buttons);
+  }
+  static mapTypeToAction(type) {
+    return this.EVENT_ACTION_MAP[type];
+  }
+  getTouch(e, screenInfo, ctrlKey, shiftKey) {
+    const touchOnClient = _InteractionHandler.buildTouchOnClient(e, screenInfo);
+    if (!touchOnClient) {
+      return null;
+    }
+    const { client, touch } = touchOnClient;
+    const result = [touch];
+    if (!ctrlKey) {
+      this.multiTouchActive = false;
+      this.multiTouchCenter = void 0;
+      this.multiTouchShift = false;
+      this.clearCanvas();
+      return result;
+    }
+    const { position, action, buttons } = touch;
+    const { point, screenSize } = position;
+    const { width, height } = screenSize;
+    const { x, y } = point;
+    if (!this.multiTouchActive) {
+      if (shiftKey) {
+        this.multiTouchCenter = point;
+        this.multiTouchShift = true;
+      } else {
+        this.multiTouchCenter = new Point(client.width / 2, client.height / 2);
+      }
+    }
+    this.multiTouchActive = true;
+    let opposite;
+    let invalid = false;
+    if (this.multiTouchShift && this.multiTouchCenter) {
+      const oppoX = 2 * this.multiTouchCenter.x - x;
+      const oppoY = 2 * this.multiTouchCenter.y - y;
+      opposite = new Point(oppoX, oppoY);
+      if (!(oppoX <= width && oppoX >= 0 && oppoY <= height && oppoY >= 0)) {
+        invalid = true;
+      }
+    } else {
+      opposite = new Point(client.width - x, client.height - y);
+      invalid = touch.invalid;
+    }
+    if (opposite) {
+      result.push({
+        invalid,
+        action,
+        buttons,
+        position: new Position(opposite, screenSize)
+      });
+    }
+    return result;
+  }
+  drawCircle(ctx, point, radius) {
+    ctx.beginPath();
+    ctx.arc(point.x, point.y, radius, 0, Math.PI * 2, true);
+    ctx.stroke();
+  }
+  drawLine(point1, point2) {
+    if (!this.ctx) {
+      return;
+    }
+    this.ctx.save();
+    this.ctx.strokeStyle = _InteractionHandler.STROKE_STYLE;
+    this.ctx.beginPath();
+    this.ctx.moveTo(point1.x, point1.y);
+    this.ctx.lineTo(point2.x, point2.y);
+    this.ctx.stroke();
+    this.ctx.restore();
+  }
+  drawPoint(point, radius, image) {
+    if (!this.ctx) {
+      return;
+    }
+    let { lineWidth } = this.ctx;
+    if (_InteractionHandler.pointImagesLoaded && image) {
+      radius = image.width / 2;
+      lineWidth = 0;
+      this.ctx.drawImage(image, point.x - radius, point.y - radius);
+    } else {
+      this.drawCircle(this.ctx, point, radius);
+    }
+    const topLeft = new Point(point.x - radius - lineWidth, point.y - radius - lineWidth);
+    const bottomRight = new Point(point.x + radius + lineWidth, point.y + radius + lineWidth);
+    this.updateDirty(topLeft, bottomRight);
+  }
+  drawPointer(point) {
+    this.drawPoint(point, _InteractionHandler.touchPointRadius, _InteractionHandler.touchPointImage);
+    if (this.multiTouchCenter) {
+      this.drawLine(this.multiTouchCenter, point);
+    }
+  }
+  drawCenter(point) {
+    this.drawPoint(point, _InteractionHandler.centerPointRadius, _InteractionHandler.centerPointImage);
+  }
+  updateDirty(topLeft, bottomRight) {
+    if (!this.dirtyPlace.length) {
+      this.dirtyPlace.push(topLeft, bottomRight);
+      return;
+    }
+    const currentTopLeft = this.dirtyPlace[0];
+    const currentBottomRight = this.dirtyPlace[1];
+    const newTopLeft = new Point(Math.min(currentTopLeft.x, topLeft.x), Math.min(currentTopLeft.y, topLeft.y));
+    const newBottomRight = new Point(
+      Math.max(currentBottomRight.x, bottomRight.x),
+      Math.max(currentBottomRight.y, bottomRight.y)
+    );
+    this.dirtyPlace.length = 0;
+    this.dirtyPlace.push(newTopLeft, newBottomRight);
+  }
+  clearCanvas() {
+    const { clientWidth, clientHeight } = this.tag;
+    const ctx = this.ctx;
+    if (ctx && this.dirtyPlace.length) {
+      const topLeft = this.dirtyPlace[0];
+      const bottomRight = this.dirtyPlace[1];
+      this.dirtyPlace.length = 0;
+      const x = Math.max(topLeft.x, 0);
+      const y = Math.max(topLeft.y, 0);
+      const w = Math.min(clientWidth, bottomRight.x - x);
+      const h = Math.min(clientHeight, bottomRight.y - y);
+      ctx.clearRect(x, y, w, h);
+      ctx.strokeStyle = _InteractionHandler.STROKE_STYLE;
+    }
+  }
+  formatTouchEvent(e, screenInfo, storage) {
+    const logPrefix = `${TAG$2}[formatTouchEvent]`;
+    const messages = [];
+    const touches = e.changedTouches;
+    if (touches && touches.length) {
+      for (let i = 0, l = touches.length; i < l; i++) {
+        const touch = touches[i];
+        const pointerId = _InteractionHandler.getPointerId(e.type, touch.identifier);
+        if (touch.target !== this.tag) {
+          continue;
+        }
+        const previous = storage.get(pointerId);
+        const item = {
+          clientX: touch.clientX,
+          clientY: touch.clientY,
+          type: e.type,
+          buttons: MotionEvent.BUTTON_PRIMARY,
+          target: e.target
+        };
+        const event = _InteractionHandler.buildTouchOnClient(item, screenInfo);
+        if (event) {
+          const { action, buttons, position, invalid } = event.touch;
+          let pressure = 1;
+          if (action === MotionEvent.ACTION_UP) {
+            pressure = 0;
+          } else if (typeof touch.force === "number") {
+            pressure = touch.force;
+          }
+          if (!invalid) {
+            const message = new TouchControlMessage(action, pointerId, position, pressure, buttons);
+            messages.push(
+              ..._InteractionHandler.validateMessage(e, message, storage, `${logPrefix}[validate]`)
+            );
+          } else {
+            if (previous) {
+              messages.push(_InteractionHandler.createEmulatedMessage(MotionEvent.ACTION_UP, previous));
+              storage.delete(pointerId);
+            }
+          }
+        } else {
+          console.error(logPrefix, `Failed to format touch`, touch);
+        }
+      }
+    } else {
+      console.error(logPrefix, 'No "touches"', e);
+    }
+    return messages;
+  }
+  buildTouchEvent(e, screenInfo, storage) {
+    const logPrefix = `${TAG$2}[buildTouchEvent]`;
+    const touches = this.getTouch(e, screenInfo, e.ctrlKey, e.shiftKey);
+    if (!touches) {
+      return [];
+    }
+    const messages = [];
+    const points = [];
+    this.clearCanvas();
+    touches.forEach((touch, pointerId) => {
+      const { action, buttons, position } = touch;
+      const previous = storage.get(pointerId);
+      if (!touch.invalid) {
+        let pressure = 1;
+        if (action === MotionEvent.ACTION_UP) {
+          pressure = 0;
+        }
+        const message = new TouchControlMessage(action, pointerId, position, pressure, buttons);
+        messages.push(..._InteractionHandler.validateMessage(e, message, storage, `${logPrefix}[validate]`));
+        points.push(touch.position.point);
+      } else {
+        if (previous) {
+          points.push(previous.position.point);
+        }
+      }
+    });
+    if (this.multiTouchActive) {
+      if (this.multiTouchCenter) {
+        this.drawCenter(this.multiTouchCenter);
+      }
+      points.forEach((point) => {
+        this.drawPointer(point);
+      });
+    }
+    const hasActionUp = messages.find((message) => {
+      return message.action === MotionEvent.ACTION_UP;
+    });
+    if (hasActionUp && storage.size) {
+      console.warn(logPrefix, "Looks like one of Multi-touch pointers was not raised up");
+      storage.forEach((message) => {
+        messages.push(_InteractionHandler.createEmulatedMessage(MotionEvent.ACTION_UP, message));
+      });
+      storage.clear();
+    }
+    return messages;
+  }
+  release() {
+    _InteractionHandler.unbindListeners(this);
+  }
+};
+_InteractionHandler.SIMULATE_MULTI_TOUCH = "SIMULATE_MULTI_TOUCH";
+_InteractionHandler.STROKE_STYLE = "#00BEA4";
+_InteractionHandler.EVENT_ACTION_MAP = {
+  touchstart: MotionEvent.ACTION_DOWN,
+  touchend: MotionEvent.ACTION_UP,
+  touchmove: MotionEvent.ACTION_MOVE,
+  touchcancel: MotionEvent.ACTION_UP,
+  mousedown: MotionEvent.ACTION_DOWN,
+  mousemove: MotionEvent.ACTION_MOVE,
+  mouseup: MotionEvent.ACTION_UP,
+  [_InteractionHandler.SIMULATE_MULTI_TOUCH]: -1
+};
+_InteractionHandler.options = Util.supportsPassive() ? { passive: false } : false;
+_InteractionHandler.idToPointerMap = /* @__PURE__ */ new Map();
+_InteractionHandler.pointerToIdMap = /* @__PURE__ */ new Map();
+_InteractionHandler.touchPointRadius = 10;
+_InteractionHandler.centerPointRadius = 5;
+_InteractionHandler.pointImagesLoaded = false;
+_InteractionHandler.eventListeners = /* @__PURE__ */ new Map();
+_InteractionHandler.onInteractionEvent = (event) => {
+  const set = _InteractionHandler.eventListeners.get(event.type);
+  if (!set) {
+    return;
+  }
+  set.forEach((instance) => {
+    instance.onInteraction(event);
+  });
+};
+_InteractionHandler.onKeyEvent = (event) => {
+  const set = _InteractionHandler.eventListeners.get(event.type);
+  if (!set) {
+    return;
+  }
+  set.forEach((instance) => {
+    instance.onKey(event);
+  });
+};
+let InteractionHandler = _InteractionHandler;
+const _ScrollControlMessage = class _ScrollControlMessage extends ControlMessage {
+  constructor(position, hScroll, vScroll) {
+    super(ControlMessage.TYPE_SCROLL);
+    this.position = position;
+    this.hScroll = hScroll;
+    this.vScroll = vScroll;
+  }
+  /**
+   * @override
+   */
+  toBuffer() {
+    const buffer$1 = buffer.Buffer.alloc(_ScrollControlMessage.PAYLOAD_LENGTH + 1);
+    let offset = 0;
+    offset = buffer$1.writeUInt8(this.type, offset);
+    offset = buffer$1.writeUInt32BE(this.position.point.x, offset);
+    offset = buffer$1.writeUInt32BE(this.position.point.y, offset);
+    offset = buffer$1.writeUInt16BE(this.position.screenSize.width, offset);
+    offset = buffer$1.writeUInt16BE(this.position.screenSize.height, offset);
+    offset = buffer$1.writeInt32BE(this.hScroll, offset);
+    buffer$1.writeInt32BE(this.vScroll, offset);
+    return buffer$1;
+  }
+  toString() {
+    return `ScrollControlMessage{hScroll=${this.hScroll}, vScroll=${this.vScroll}, position=${this.position}}`;
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      position: this.position.toJSON(),
+      hScroll: this.hScroll,
+      vScroll: this.vScroll
+    };
+  }
+};
+_ScrollControlMessage.PAYLOAD_LENGTH = 20;
+let ScrollControlMessage = _ScrollControlMessage;
+const TAG$1 = "[FeaturedTouchHandler]";
+const _FeaturedInteractionHandler = class _FeaturedInteractionHandler extends InteractionHandler {
+  constructor(player, listener) {
+    super(player, _FeaturedInteractionHandler.touchEventsNames, _FeaturedInteractionHandler.keyEventsNames);
+    this.listener = listener;
+    this.storedFromMouseEvent = /* @__PURE__ */ new Map();
+    this.storedFromTouchEvent = /* @__PURE__ */ new Map();
+    this.onMouseEnter = () => {
+      this.over = true;
+    };
+    this.onMouseLeave = () => {
+      this.lastPosition = void 0;
+      this.over = false;
+      this.storedFromMouseEvent.forEach((message) => {
+        this.listener.sendMessage(InteractionHandler.createEmulatedMessage(MotionEvent.ACTION_UP, message));
+      });
+      this.storedFromMouseEvent.clear();
+      this.clearCanvas();
+    };
+    this.tag.addEventListener("mouseleave", this.onMouseLeave);
+    this.tag.addEventListener("mouseenter", this.onMouseEnter);
+  }
+  buildScrollEvent(event, screenInfo) {
+    const messages = [];
+    const touchOnClient = InteractionHandler.buildTouchOnClient(event, screenInfo);
+    if (touchOnClient) {
+      const hScroll = event.deltaX > 0 ? -1 : event.deltaX < -0 ? 1 : 0;
+      const vScroll = event.deltaY > 0 ? -1 : event.deltaY < -0 ? 1 : 0;
+      const time = Date.now();
+      if (!this.lastScrollEvent || time - this.lastScrollEvent.time > _FeaturedInteractionHandler.SCROLL_EVENT_THROTTLING_TIME || this.lastScrollEvent.vScroll !== vScroll || this.lastScrollEvent.hScroll !== hScroll) {
+        this.lastScrollEvent = { time, hScroll, vScroll };
+        messages.push(new ScrollControlMessage(touchOnClient.touch.position, hScroll, vScroll));
+      }
+    }
+    return messages;
+  }
+  onInteraction(event) {
+    const screenInfo = this.player.getScreenInfo();
+    if (!screenInfo) {
+      return;
+    }
+    let messages;
+    let storage;
+    if (event instanceof MouseEvent) {
+      if (event.target !== this.tag) {
+        return;
+      }
+      if (window["WheelEvent"] && event instanceof WheelEvent) {
+        messages = this.buildScrollEvent(event, screenInfo);
+      } else {
+        storage = this.storedFromMouseEvent;
+        messages = this.buildTouchEvent(event, screenInfo, storage);
+      }
+      if (this.over) {
+        this.lastPosition = event;
+      }
+    } else if (window["TouchEvent"] && event instanceof TouchEvent) {
+      if (event.target !== this.tag) {
+        return;
+      }
+      storage = this.storedFromTouchEvent;
+      messages = this.formatTouchEvent(event, screenInfo, storage);
+    } else {
+      console.error(TAG$1, "Unsupported event", event);
+      return;
+    }
+    if (event.cancelable) {
+      event.preventDefault();
+    }
+    event.stopPropagation();
+    messages.forEach((message) => {
+      this.listener.sendMessage(message);
+    });
+  }
+  onKey(event) {
+    if (!this.lastPosition) {
+      return;
+    }
+    const screenInfo = this.player.getScreenInfo();
+    if (!screenInfo) {
+      return;
+    }
+    const { ctrlKey, shiftKey } = event;
+    const { target, button, buttons, clientY, clientX } = this.lastPosition;
+    const type = InteractionHandler.SIMULATE_MULTI_TOUCH;
+    const props = { ctrlKey, shiftKey, type, target, button, buttons, clientX, clientY };
+    this.buildTouchEvent(props, screenInfo, /* @__PURE__ */ new Map());
+  }
+  release() {
+    super.release();
+    this.tag.removeEventListener("mouseleave", this.onMouseLeave);
+    this.tag.removeEventListener("mouseenter", this.onMouseEnter);
+    this.storedFromMouseEvent.clear();
+  }
+};
+_FeaturedInteractionHandler.touchEventsNames = [
+  "touchstart",
+  "touchend",
+  "touchmove",
+  "touchcancel",
+  "mousedown",
+  "mouseup",
+  "mousemove",
+  "wheel"
+];
+_FeaturedInteractionHandler.keyEventsNames = ["keydown", "keyup"];
+_FeaturedInteractionHandler.SCROLL_EVENT_THROTTLING_TIME = 30;
+let FeaturedInteractionHandler = _FeaturedInteractionHandler;
+const TAG = "[SimpleTouchHandler]";
+const _SimpleInteractionHandler = class _SimpleInteractionHandler extends InteractionHandler {
+  constructor(player, listener) {
+    super(player, _SimpleInteractionHandler.touchEventsNames, []);
+    this.listener = listener;
+    this.storage = /* @__PURE__ */ new Map();
+  }
+  onInteraction(event) {
+    let handled = false;
+    if (!(event instanceof MouseEvent)) {
+      return;
+    }
+    if (event.target === this.tag) {
+      const screenInfo = this.player.getScreenInfo();
+      if (!screenInfo) {
+        return;
+      }
+      const events = this.buildTouchEvent(event, screenInfo, this.storage);
+      if (events.length > 1) {
+        console.warn(TAG, "Too many events", events);
+        return;
+      }
+      const downEventName = "mousedown";
+      if (events.length === 1) {
+        handled = true;
+        if (event.type === downEventName) {
+          this.startPosition = events[0].position;
+        } else {
+          if (this.startPosition) {
+            this.endPosition = events[0].position;
+          } else {
+            console.warn(TAG, `Received "${event.type}" before "${downEventName}"`);
+          }
+        }
+        if (this.startPosition) {
+          this.drawPointer(this.startPosition.point);
+        }
+        if (this.endPosition) {
+          this.drawPointer(this.endPosition.point);
+          if (this.startPosition) {
+            this.drawLine(this.startPosition.point, this.endPosition.point);
+          }
+        }
+        if (event.type === "mouseup") {
+          if (this.startPosition && this.endPosition) {
+            this.clearCanvas();
+            if (this.startPosition.point.distance(this.endPosition.point) < 10) {
+              this.listener.performClick(this.endPosition);
+            } else {
+              this.listener.performScroll(this.startPosition, this.endPosition);
+            }
+          }
+        }
+      }
+      if (handled) {
+        if (event.cancelable) {
+          event.preventDefault();
+        }
+        event.stopPropagation();
+      }
+    }
+    if (event.type === "mouseup") {
+      this.startPosition = void 0;
+      this.endPosition = void 0;
+    }
+  }
+  onKey() {
+    throw Error(`${TAG} Unsupported`);
+  }
+};
+_SimpleInteractionHandler.touchEventsNames = ["mousedown", "mouseup", "mousemove"];
+let SimpleInteractionHandler = _SimpleInteractionHandler;
+const _KeyCodeControlMessage = class _KeyCodeControlMessage extends ControlMessage {
+  constructor(action, keycode, repeat, metaState) {
+    super(ControlMessage.TYPE_KEYCODE);
+    this.action = action;
+    this.keycode = keycode;
+    this.repeat = repeat;
+    this.metaState = metaState;
+  }
+  /**
+   * @override
+   */
+  toBuffer() {
+    const buffer$1 = buffer.Buffer.alloc(_KeyCodeControlMessage.PAYLOAD_LENGTH + 1);
+    let offset = 0;
+    offset = buffer$1.writeInt8(this.type, offset);
+    offset = buffer$1.writeInt8(this.action, offset);
+    offset = buffer$1.writeInt32BE(this.keycode, offset);
+    offset = buffer$1.writeInt32BE(this.repeat, offset);
+    buffer$1.writeInt32BE(this.metaState, offset);
+    return buffer$1;
+  }
+  toString() {
+    return `KeyCodeControlMessage{action=${this.action}, keycode=${this.keycode}, metaState=${this.metaState}}`;
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      action: this.action,
+      keycode: this.keycode,
+      metaState: this.metaState,
+      repeat: this.repeat
+    };
+  }
+};
+_KeyCodeControlMessage.PAYLOAD_LENGTH = 13;
+let KeyCodeControlMessage = _KeyCodeControlMessage;
+const _TextControlMessage = class _TextControlMessage extends ControlMessage {
+  constructor(text) {
+    super(ControlMessage.TYPE_TEXT);
+    this.text = text;
+  }
+  getText() {
+    return this.text;
+  }
+  /**
+   * @override
+   */
+  toBuffer() {
+    const length = this.text.length;
+    const buffer$1 = buffer.Buffer.alloc(length + 1 + _TextControlMessage.TEXT_SIZE_FIELD_LENGTH);
+    let offset = 0;
+    offset = buffer$1.writeUInt8(this.type, offset);
+    offset = buffer$1.writeUInt32BE(length, offset);
+    buffer$1.write(this.text, offset);
+    return buffer$1;
+  }
+  toString() {
+    return `TextControlMessage{text=${this.text}}`;
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      text: this.text
+    };
+  }
+};
+_TextControlMessage.TEXT_SIZE_FIELD_LENGTH = 4;
+let TextControlMessage = _TextControlMessage;
+var FilePushState = /* @__PURE__ */ ((FilePushState2) => {
+  FilePushState2[FilePushState2["NEW"] = 0] = "NEW";
+  FilePushState2[FilePushState2["START"] = 1] = "START";
+  FilePushState2[FilePushState2["APPEND"] = 2] = "APPEND";
+  FilePushState2[FilePushState2["FINISH"] = 3] = "FINISH";
+  FilePushState2[FilePushState2["CANCEL"] = 4] = "CANCEL";
+  return FilePushState2;
+})(FilePushState || {});
+const _CommandControlMessage = class _CommandControlMessage extends ControlMessage {
+  constructor(type) {
+    super(type);
+    this.type = type;
+  }
+  /**
+   * 注意: createSetVideoSettingsCommand 方法依赖 VideoSettings 类
+   * 该方法未包含在此独立模块中
+   * 如需使用，请在应用中自行实现或从原项目导入
+   */
+  // public static createSetVideoSettingsCommand(videoSettings: VideoSettings): CommandControlMessage {
+  //     ...
+  // }
+  static createSetClipboardCommand(text, paste = false) {
+    const event = new _CommandControlMessage(ControlMessage.TYPE_SET_CLIPBOARD);
+    const textBytes = text ? Util.stringToUtf8ByteArray(text) : null;
+    const textLength = textBytes ? textBytes.length : 0;
+    let offset = 0;
+    const buffer$1 = buffer.Buffer.alloc(1 + 1 + 4 + textLength);
+    offset = buffer$1.writeInt8(event.type, offset);
+    offset = buffer$1.writeInt8(paste ? 1 : 0, offset);
+    offset = buffer$1.writeInt32BE(textLength, offset);
+    if (textBytes) {
+      textBytes.forEach((byte, index) => {
+        buffer$1.writeUInt8(byte, index + offset);
+      });
+    }
+    event.buffer = buffer$1;
+    return event;
+  }
+  static createSetScreenPowerModeCommand(mode) {
+    const event = new _CommandControlMessage(ControlMessage.TYPE_SET_SCREEN_POWER_MODE);
+    let offset = 0;
+    const buffer$1 = buffer.Buffer.alloc(1 + 1);
+    offset = buffer$1.writeInt8(event.type, offset);
+    buffer$1.writeUInt8(mode ? 1 : 0, offset);
+    event.buffer = buffer$1;
+    return event;
+  }
+  static createPushFileCommand(params) {
+    const { id, fileName, fileSize, chunk, state } = params;
+    if (state === 1) {
+      return this.createPushFileStartCommand(id, fileName, fileSize);
+    }
+    if (state === 2) {
+      if (!chunk) {
+        throw TypeError("Invalid type");
+      }
+      return this.createPushFileChunkCommand(id, chunk);
+    }
+    if (state === 4 || state === 3 || state === 0) {
+      return this.createPushFileOtherCommand(id, state);
+    }
+    throw TypeError(`Unsupported state: "${state}"`);
+  }
+  static createPushFileStartCommand(id, fileName, fileSize) {
+    const event = new _CommandControlMessage(ControlMessage.TYPE_PUSH_FILE);
+    const text = Util.stringToUtf8ByteArray(fileName);
+    const typeField = 1;
+    const idField = 2;
+    const stateField = 1;
+    const sizeField = 4;
+    const textLengthField = 2;
+    const textLength = text.length;
+    let offset = _CommandControlMessage.PAYLOAD_LENGTH;
+    const buffer$1 = buffer.Buffer.alloc(
+      offset + typeField + idField + stateField + sizeField + textLengthField + textLength
+    );
+    buffer$1.writeUInt8(event.type, offset);
+    offset += typeField;
+    buffer$1.writeInt16BE(id, offset);
+    offset += idField;
+    buffer$1.writeInt8(1, offset);
+    offset += stateField;
+    buffer$1.writeUInt32BE(fileSize, offset);
+    offset += sizeField;
+    buffer$1.writeUInt16BE(textLength, offset);
+    offset += textLengthField;
+    text.forEach((byte, index) => {
+      buffer$1.writeUInt8(byte, index + offset);
+    });
+    event.buffer = buffer$1;
+    return event;
+  }
+  static createPushFileChunkCommand(id, chunk) {
+    const event = new _CommandControlMessage(ControlMessage.TYPE_PUSH_FILE);
+    const typeField = 1;
+    const idField = 2;
+    const stateField = 1;
+    const chunkLengthField = 4;
+    const chunkLength = chunk.byteLength;
+    let offset = _CommandControlMessage.PAYLOAD_LENGTH;
+    const buffer$1 = buffer.Buffer.alloc(offset + typeField + idField + stateField + chunkLengthField + chunkLength);
+    buffer$1.writeUInt8(event.type, offset);
+    offset += typeField;
+    buffer$1.writeInt16BE(id, offset);
+    offset += idField;
+    buffer$1.writeInt8(2, offset);
+    offset += stateField;
+    buffer$1.writeUInt32BE(chunkLength, offset);
+    offset += chunkLengthField;
+    Array.from(chunk).forEach((byte, index) => {
+      buffer$1.writeUInt8(byte, index + offset);
+    });
+    event.buffer = buffer$1;
+    return event;
+  }
+  static createPushFileOtherCommand(id, state) {
+    const event = new _CommandControlMessage(ControlMessage.TYPE_PUSH_FILE);
+    const typeField = 1;
+    const idField = 2;
+    const stateField = 1;
+    let offset = _CommandControlMessage.PAYLOAD_LENGTH;
+    const buffer$1 = buffer.Buffer.alloc(offset + typeField + idField + stateField);
+    buffer$1.writeUInt8(event.type, offset);
+    offset += typeField;
+    buffer$1.writeInt16BE(id, offset);
+    offset += idField;
+    buffer$1.writeInt8(state, offset);
+    event.buffer = buffer$1;
+    return event;
+  }
+  static pushFileCommandFromBuffer(buffer2) {
+    let offset = 0;
+    const type = buffer2.readUInt8(offset);
+    offset += 1;
+    if (type !== _CommandControlMessage.TYPE_PUSH_FILE) {
+      throw TypeError(`Incorrect type: "${type}"`);
+    }
+    const id = buffer2.readInt16BE(offset);
+    offset += 2;
+    const state = buffer2.readInt8(offset);
+    offset += 1;
+    let chunk;
+    let fileSize;
+    let fileName;
+    if (state === 2) {
+      const chunkLength = buffer2.readUInt32BE(offset);
+      offset += 4;
+      chunk = buffer2.slice(offset, offset + chunkLength);
+    } else if (state === 1) {
+      fileSize = buffer2.readUInt32BE(offset);
+      offset += 4;
+      const textLength = buffer2.readUInt16BE(offset);
+      offset += 2;
+      fileName = Util.utf8ByteArrayToString(buffer2.slice(offset, offset + textLength));
+    }
+    return { id, state, chunk, fileName, fileSize };
+  }
+  /**
+   * @override
+   */
+  toBuffer() {
+    if (!this.buffer) {
+      const buffer$1 = buffer.Buffer.alloc(_CommandControlMessage.PAYLOAD_LENGTH + 1);
+      buffer$1.writeUInt8(this.type, 0);
+      this.buffer = buffer$1;
+    }
+    return this.buffer;
+  }
+  toString() {
+    const buffer2 = this.buffer ? `, buffer=[${this.buffer.join(",")}]` : "";
+    return `CommandControlMessage{action=${this.type}${buffer2}}`;
+  }
+};
+_CommandControlMessage.PAYLOAD_LENGTH = 0;
+_CommandControlMessage.Commands = /* @__PURE__ */ new Map([
+  [ControlMessage.TYPE_EXPAND_NOTIFICATION_PANEL, "Expand notifications"],
+  [ControlMessage.TYPE_EXPAND_SETTINGS_PANEL, "Expand settings"],
+  [ControlMessage.TYPE_COLLAPSE_PANELS, "Collapse panels"],
+  [ControlMessage.TYPE_GET_CLIPBOARD, "Get clipboard"],
+  [ControlMessage.TYPE_SET_CLIPBOARD, "Set clipboard"],
+  [ControlMessage.TYPE_ROTATE_DEVICE, "Rotate device"],
+  [ControlMessage.TYPE_CHANGE_STREAM_PARAMETERS, "Change video settings"]
+]);
+let CommandControlMessage = _CommandControlMessage;
+const _KeyEvent = class _KeyEvent {
+};
+_KeyEvent.ACTION_DOWN = 0;
+_KeyEvent.ACTION_UP = 1;
+_KeyEvent.KEYCODE_0 = 7;
+_KeyEvent.KEYCODE_1 = 8;
+_KeyEvent.KEYCODE_11 = 227;
+_KeyEvent.KEYCODE_12 = 228;
+_KeyEvent.KEYCODE_2 = 9;
+_KeyEvent.KEYCODE_3 = 10;
+_KeyEvent.KEYCODE_3D_MODE = 206;
+_KeyEvent.KEYCODE_4 = 11;
+_KeyEvent.KEYCODE_5 = 12;
+_KeyEvent.KEYCODE_6 = 13;
+_KeyEvent.KEYCODE_7 = 14;
+_KeyEvent.KEYCODE_8 = 15;
+_KeyEvent.KEYCODE_9 = 16;
+_KeyEvent.KEYCODE_A = 29;
+_KeyEvent.KEYCODE_ALL_APPS = 284;
+_KeyEvent.KEYCODE_ALT_LEFT = 57;
+_KeyEvent.KEYCODE_ALT_RIGHT = 58;
+_KeyEvent.KEYCODE_APOSTROPHE = 75;
+_KeyEvent.KEYCODE_APP_SWITCH = 187;
+_KeyEvent.KEYCODE_ASSIST = 219;
+_KeyEvent.KEYCODE_AT = 77;
+_KeyEvent.KEYCODE_AVR_INPUT = 182;
+_KeyEvent.KEYCODE_AVR_POWER = 181;
+_KeyEvent.KEYCODE_B = 30;
+_KeyEvent.KEYCODE_BACK = 4;
+_KeyEvent.KEYCODE_BACKSLASH = 73;
+_KeyEvent.KEYCODE_BOOKMARK = 174;
+_KeyEvent.KEYCODE_BREAK = 121;
+_KeyEvent.KEYCODE_BRIGHTNESS_DOWN = 220;
+_KeyEvent.KEYCODE_BRIGHTNESS_UP = 221;
+_KeyEvent.KEYCODE_BUTTON_1 = 188;
+_KeyEvent.KEYCODE_BUTTON_10 = 197;
+_KeyEvent.KEYCODE_BUTTON_11 = 198;
+_KeyEvent.KEYCODE_BUTTON_12 = 199;
+_KeyEvent.KEYCODE_BUTTON_13 = 200;
+_KeyEvent.KEYCODE_BUTTON_14 = 201;
+_KeyEvent.KEYCODE_BUTTON_15 = 202;
+_KeyEvent.KEYCODE_BUTTON_16 = 203;
+_KeyEvent.KEYCODE_BUTTON_2 = 189;
+_KeyEvent.KEYCODE_BUTTON_3 = 190;
+_KeyEvent.KEYCODE_BUTTON_4 = 191;
+_KeyEvent.KEYCODE_BUTTON_5 = 192;
+_KeyEvent.KEYCODE_BUTTON_6 = 193;
+_KeyEvent.KEYCODE_BUTTON_7 = 194;
+_KeyEvent.KEYCODE_BUTTON_8 = 195;
+_KeyEvent.KEYCODE_BUTTON_9 = 196;
+_KeyEvent.KEYCODE_BUTTON_A = 96;
+_KeyEvent.KEYCODE_BUTTON_B = 97;
+_KeyEvent.KEYCODE_BUTTON_C = 98;
+_KeyEvent.KEYCODE_BUTTON_L1 = 102;
+_KeyEvent.KEYCODE_BUTTON_L2 = 104;
+_KeyEvent.KEYCODE_BUTTON_MODE = 110;
+_KeyEvent.KEYCODE_BUTTON_R1 = 103;
+_KeyEvent.KEYCODE_BUTTON_R2 = 105;
+_KeyEvent.KEYCODE_BUTTON_SELECT = 109;
+_KeyEvent.KEYCODE_BUTTON_START = 108;
+_KeyEvent.KEYCODE_BUTTON_THUMBL = 106;
+_KeyEvent.KEYCODE_BUTTON_THUMBR = 107;
+_KeyEvent.KEYCODE_BUTTON_X = 99;
+_KeyEvent.KEYCODE_BUTTON_Y = 100;
+_KeyEvent.KEYCODE_BUTTON_Z = 101;
+_KeyEvent.KEYCODE_C = 31;
+_KeyEvent.KEYCODE_CALCULATOR = 210;
+_KeyEvent.KEYCODE_CALENDAR = 208;
+_KeyEvent.KEYCODE_CALL = 5;
+_KeyEvent.KEYCODE_CAMERA = 27;
+_KeyEvent.KEYCODE_CAPS_LOCK = 115;
+_KeyEvent.KEYCODE_CAPTIONS = 175;
+_KeyEvent.KEYCODE_CHANNEL_DOWN = 167;
+_KeyEvent.KEYCODE_CHANNEL_UP = 166;
+_KeyEvent.KEYCODE_CLEAR = 28;
+_KeyEvent.KEYCODE_COMMA = 55;
+_KeyEvent.KEYCODE_CONTACTS = 207;
+_KeyEvent.KEYCODE_COPY = 278;
+_KeyEvent.KEYCODE_CTRL_LEFT = 113;
+_KeyEvent.KEYCODE_CTRL_RIGHT = 114;
+_KeyEvent.KEYCODE_CUT = 277;
+_KeyEvent.KEYCODE_D = 32;
+_KeyEvent.KEYCODE_DEL = 67;
+_KeyEvent.KEYCODE_DPAD_CENTER = 23;
+_KeyEvent.KEYCODE_DPAD_DOWN = 20;
+_KeyEvent.KEYCODE_DPAD_DOWN_LEFT = 269;
+_KeyEvent.KEYCODE_DPAD_DOWN_RIGHT = 271;
+_KeyEvent.KEYCODE_DPAD_LEFT = 21;
+_KeyEvent.KEYCODE_DPAD_RIGHT = 22;
+_KeyEvent.KEYCODE_DPAD_UP = 19;
+_KeyEvent.KEYCODE_DPAD_UP_LEFT = 268;
+_KeyEvent.KEYCODE_DPAD_UP_RIGHT = 270;
+_KeyEvent.KEYCODE_DVR = 173;
+_KeyEvent.KEYCODE_E = 33;
+_KeyEvent.KEYCODE_EISU = 212;
+_KeyEvent.KEYCODE_ENDCALL = 6;
+_KeyEvent.KEYCODE_ENTER = 66;
+_KeyEvent.KEYCODE_ENVELOPE = 65;
+_KeyEvent.KEYCODE_EQUALS = 70;
+_KeyEvent.KEYCODE_ESCAPE = 111;
+_KeyEvent.KEYCODE_EXPLORER = 64;
+_KeyEvent.KEYCODE_F = 34;
+_KeyEvent.KEYCODE_F1 = 131;
+_KeyEvent.KEYCODE_F10 = 140;
+_KeyEvent.KEYCODE_F11 = 141;
+_KeyEvent.KEYCODE_F12 = 142;
+_KeyEvent.KEYCODE_F2 = 132;
+_KeyEvent.KEYCODE_F3 = 133;
+_KeyEvent.KEYCODE_F4 = 134;
+_KeyEvent.KEYCODE_F5 = 135;
+_KeyEvent.KEYCODE_F6 = 136;
+_KeyEvent.KEYCODE_F7 = 137;
+_KeyEvent.KEYCODE_F8 = 138;
+_KeyEvent.KEYCODE_F9 = 139;
+_KeyEvent.KEYCODE_FOCUS = 80;
+_KeyEvent.KEYCODE_FORWARD = 125;
+_KeyEvent.KEYCODE_FORWARD_DEL = 112;
+_KeyEvent.KEYCODE_FUNCTION = 119;
+_KeyEvent.KEYCODE_G = 35;
+_KeyEvent.KEYCODE_GRAVE = 68;
+_KeyEvent.KEYCODE_GUIDE = 172;
+_KeyEvent.KEYCODE_H = 36;
+_KeyEvent.KEYCODE_HEADSETHOOK = 79;
+_KeyEvent.KEYCODE_HELP = 259;
+_KeyEvent.KEYCODE_HENKAN = 214;
+_KeyEvent.KEYCODE_HOME = 3;
+_KeyEvent.KEYCODE_I = 37;
+_KeyEvent.KEYCODE_INFO = 165;
+_KeyEvent.KEYCODE_INSERT = 124;
+_KeyEvent.KEYCODE_J = 38;
+_KeyEvent.KEYCODE_K = 39;
+_KeyEvent.KEYCODE_KANA = 218;
+_KeyEvent.KEYCODE_KATAKANA_HIRAGANA = 215;
+_KeyEvent.KEYCODE_L = 40;
+_KeyEvent.KEYCODE_LANGUAGE_SWITCH = 204;
+_KeyEvent.KEYCODE_LAST_CHANNEL = 229;
+_KeyEvent.KEYCODE_LEFT_BRACKET = 71;
+_KeyEvent.KEYCODE_M = 41;
+_KeyEvent.KEYCODE_MANNER_MODE = 205;
+_KeyEvent.KEYCODE_MEDIA_AUDIO_TRACK = 222;
+_KeyEvent.KEYCODE_MEDIA_CLOSE = 128;
+_KeyEvent.KEYCODE_MEDIA_EJECT = 129;
+_KeyEvent.KEYCODE_MEDIA_FAST_FORWARD = 90;
+_KeyEvent.KEYCODE_MEDIA_NEXT = 87;
+_KeyEvent.KEYCODE_MEDIA_PAUSE = 127;
+_KeyEvent.KEYCODE_MEDIA_PLAY = 126;
+_KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE = 85;
+_KeyEvent.KEYCODE_MEDIA_PREVIOUS = 88;
+_KeyEvent.KEYCODE_MEDIA_RECORD = 130;
+_KeyEvent.KEYCODE_MEDIA_REWIND = 89;
+_KeyEvent.KEYCODE_MEDIA_SKIP_BACKWARD = 273;
+_KeyEvent.KEYCODE_MEDIA_SKIP_FORWARD = 272;
+_KeyEvent.KEYCODE_MEDIA_STEP_BACKWARD = 275;
+_KeyEvent.KEYCODE_MEDIA_STEP_FORWARD = 274;
+_KeyEvent.KEYCODE_MEDIA_STOP = 86;
+_KeyEvent.KEYCODE_MEDIA_TOP_MENU = 226;
+_KeyEvent.KEYCODE_MENU = 82;
+_KeyEvent.KEYCODE_META_LEFT = 117;
+_KeyEvent.KEYCODE_META_RIGHT = 118;
+_KeyEvent.KEYCODE_MINUS = 69;
+_KeyEvent.KEYCODE_MOVE_END = 123;
+_KeyEvent.KEYCODE_MOVE_HOME = 122;
+_KeyEvent.KEYCODE_MUHENKAN = 213;
+_KeyEvent.KEYCODE_MUSIC = 209;
+_KeyEvent.KEYCODE_MUTE = 91;
+_KeyEvent.KEYCODE_N = 42;
+_KeyEvent.KEYCODE_NAVIGATE_IN = 262;
+_KeyEvent.KEYCODE_NAVIGATE_NEXT = 261;
+_KeyEvent.KEYCODE_NAVIGATE_OUT = 263;
+_KeyEvent.KEYCODE_NAVIGATE_PREVIOUS = 260;
+_KeyEvent.KEYCODE_NOTIFICATION = 83;
+_KeyEvent.KEYCODE_NUM = 78;
+_KeyEvent.KEYCODE_NUMPAD_0 = 144;
+_KeyEvent.KEYCODE_NUMPAD_1 = 145;
+_KeyEvent.KEYCODE_NUMPAD_2 = 146;
+_KeyEvent.KEYCODE_NUMPAD_3 = 147;
+_KeyEvent.KEYCODE_NUMPAD_4 = 148;
+_KeyEvent.KEYCODE_NUMPAD_5 = 149;
+_KeyEvent.KEYCODE_NUMPAD_6 = 150;
+_KeyEvent.KEYCODE_NUMPAD_7 = 151;
+_KeyEvent.KEYCODE_NUMPAD_8 = 152;
+_KeyEvent.KEYCODE_NUMPAD_9 = 153;
+_KeyEvent.KEYCODE_NUMPAD_ADD = 157;
+_KeyEvent.KEYCODE_NUMPAD_COMMA = 159;
+_KeyEvent.KEYCODE_NUMPAD_DIVIDE = 154;
+_KeyEvent.KEYCODE_NUMPAD_DOT = 158;
+_KeyEvent.KEYCODE_NUMPAD_ENTER = 160;
+_KeyEvent.KEYCODE_NUMPAD_EQUALS = 161;
+_KeyEvent.KEYCODE_NUMPAD_LEFT_PAREN = 162;
+_KeyEvent.KEYCODE_NUMPAD_MULTIPLY = 155;
+_KeyEvent.KEYCODE_NUMPAD_RIGHT_PAREN = 163;
+_KeyEvent.KEYCODE_NUMPAD_SUBTRACT = 156;
+_KeyEvent.KEYCODE_NUM_LOCK = 143;
+_KeyEvent.KEYCODE_O = 43;
+_KeyEvent.KEYCODE_P = 44;
+_KeyEvent.KEYCODE_PAGE_DOWN = 93;
+_KeyEvent.KEYCODE_PAGE_UP = 92;
+_KeyEvent.KEYCODE_PAIRING = 225;
+_KeyEvent.KEYCODE_PASTE = 279;
+_KeyEvent.KEYCODE_PERIOD = 56;
+_KeyEvent.KEYCODE_PICTSYMBOLS = 94;
+_KeyEvent.KEYCODE_PLUS = 81;
+_KeyEvent.KEYCODE_POUND = 18;
+_KeyEvent.KEYCODE_POWER = 26;
+_KeyEvent.KEYCODE_PROFILE_SWITCH = 288;
+_KeyEvent.KEYCODE_PROG_BLUE = 186;
+_KeyEvent.KEYCODE_PROG_GREEN = 184;
+_KeyEvent.KEYCODE_PROG_RED = 183;
+_KeyEvent.KEYCODE_PROG_YELLOW = 185;
+_KeyEvent.KEYCODE_Q = 45;
+_KeyEvent.KEYCODE_R = 46;
+_KeyEvent.KEYCODE_REFRESH = 285;
+_KeyEvent.KEYCODE_RIGHT_BRACKET = 72;
+_KeyEvent.KEYCODE_RO = 217;
+_KeyEvent.KEYCODE_S = 47;
+_KeyEvent.KEYCODE_SCROLL_LOCK = 116;
+_KeyEvent.KEYCODE_SEARCH = 84;
+_KeyEvent.KEYCODE_SEMICOLON = 74;
+_KeyEvent.KEYCODE_SETTINGS = 176;
+_KeyEvent.KEYCODE_SHIFT_LEFT = 59;
+_KeyEvent.KEYCODE_SHIFT_RIGHT = 60;
+_KeyEvent.KEYCODE_SLASH = 76;
+_KeyEvent.KEYCODE_SLEEP = 223;
+_KeyEvent.KEYCODE_SOFT_LEFT = 1;
+_KeyEvent.KEYCODE_SOFT_RIGHT = 2;
+_KeyEvent.KEYCODE_SOFT_SLEEP = 276;
+_KeyEvent.KEYCODE_SPACE = 62;
+_KeyEvent.KEYCODE_STAR = 17;
+_KeyEvent.KEYCODE_STB_INPUT = 180;
+_KeyEvent.KEYCODE_STB_POWER = 179;
+_KeyEvent.KEYCODE_STEM_1 = 265;
+_KeyEvent.KEYCODE_STEM_2 = 266;
+_KeyEvent.KEYCODE_STEM_3 = 267;
+_KeyEvent.KEYCODE_STEM_PRIMARY = 264;
+_KeyEvent.KEYCODE_SWITCH_CHARSET = 95;
+_KeyEvent.KEYCODE_SYM = 63;
+_KeyEvent.KEYCODE_SYSRQ = 120;
+_KeyEvent.KEYCODE_SYSTEM_NAVIGATION_DOWN = 281;
+_KeyEvent.KEYCODE_SYSTEM_NAVIGATION_LEFT = 282;
+_KeyEvent.KEYCODE_SYSTEM_NAVIGATION_RIGHT = 283;
+_KeyEvent.KEYCODE_SYSTEM_NAVIGATION_UP = 280;
+_KeyEvent.KEYCODE_T = 48;
+_KeyEvent.KEYCODE_TAB = 61;
+_KeyEvent.KEYCODE_THUMBS_DOWN = 287;
+_KeyEvent.KEYCODE_THUMBS_UP = 286;
+_KeyEvent.KEYCODE_TV = 170;
+_KeyEvent.KEYCODE_TV_ANTENNA_CABLE = 242;
+_KeyEvent.KEYCODE_TV_AUDIO_DESCRIPTION = 252;
+_KeyEvent.KEYCODE_TV_AUDIO_DESCRIPTION_MIX_DOWN = 254;
+_KeyEvent.KEYCODE_TV_AUDIO_DESCRIPTION_MIX_UP = 253;
+_KeyEvent.KEYCODE_TV_CONTENTS_MENU = 256;
+_KeyEvent.KEYCODE_TV_DATA_SERVICE = 230;
+_KeyEvent.KEYCODE_TV_INPUT = 178;
+_KeyEvent.KEYCODE_TV_INPUT_COMPONENT_1 = 249;
+_KeyEvent.KEYCODE_TV_INPUT_COMPONENT_2 = 250;
+_KeyEvent.KEYCODE_TV_INPUT_COMPOSITE_1 = 247;
+_KeyEvent.KEYCODE_TV_INPUT_COMPOSITE_2 = 248;
+_KeyEvent.KEYCODE_TV_INPUT_HDMI_1 = 243;
+_KeyEvent.KEYCODE_TV_INPUT_HDMI_2 = 244;
+_KeyEvent.KEYCODE_TV_INPUT_HDMI_3 = 245;
+_KeyEvent.KEYCODE_TV_INPUT_HDMI_4 = 246;
+_KeyEvent.KEYCODE_TV_INPUT_VGA_1 = 251;
+_KeyEvent.KEYCODE_TV_MEDIA_CONTEXT_MENU = 257;
+_KeyEvent.KEYCODE_TV_NETWORK = 241;
+_KeyEvent.KEYCODE_TV_NUMBER_ENTRY = 234;
+_KeyEvent.KEYCODE_TV_POWER = 177;
+_KeyEvent.KEYCODE_TV_RADIO_SERVICE = 232;
+_KeyEvent.KEYCODE_TV_SATELLITE = 237;
+_KeyEvent.KEYCODE_TV_SATELLITE_BS = 238;
+_KeyEvent.KEYCODE_TV_SATELLITE_CS = 239;
+_KeyEvent.KEYCODE_TV_SATELLITE_SERVICE = 240;
+_KeyEvent.KEYCODE_TV_TELETEXT = 233;
+_KeyEvent.KEYCODE_TV_TERRESTRIAL_ANALOG = 235;
+_KeyEvent.KEYCODE_TV_TERRESTRIAL_DIGITAL = 236;
+_KeyEvent.KEYCODE_TV_TIMER_PROGRAMMING = 258;
+_KeyEvent.KEYCODE_TV_ZOOM_MODE = 255;
+_KeyEvent.KEYCODE_U = 49;
+_KeyEvent.KEYCODE_UNKNOWN = 0;
+_KeyEvent.KEYCODE_V = 50;
+_KeyEvent.KEYCODE_VOICE_ASSIST = 231;
+_KeyEvent.KEYCODE_VOLUME_DOWN = 25;
+_KeyEvent.KEYCODE_VOLUME_MUTE = 164;
+_KeyEvent.KEYCODE_VOLUME_UP = 24;
+_KeyEvent.KEYCODE_W = 51;
+_KeyEvent.KEYCODE_WAKEUP = 224;
+_KeyEvent.KEYCODE_WINDOW = 171;
+_KeyEvent.KEYCODE_X = 52;
+_KeyEvent.KEYCODE_Y = 53;
+_KeyEvent.KEYCODE_YEN = 216;
+_KeyEvent.KEYCODE_Z = 54;
+_KeyEvent.KEYCODE_ZENKAKU_HANKAKU = 211;
+_KeyEvent.KEYCODE_ZOOM_IN = 168;
+_KeyEvent.KEYCODE_ZOOM_OUT = 169;
+_KeyEvent.META_ALT_LEFT_ON = 16;
+_KeyEvent.META_ALT_MASK = 50;
+_KeyEvent.META_ALT_ON = 2;
+_KeyEvent.META_ALT_RIGHT_ON = 32;
+_KeyEvent.META_CAPS_LOCK_ON = 1048576;
+_KeyEvent.META_CTRL_LEFT_ON = 8192;
+_KeyEvent.META_CTRL_MASK = 28672;
+_KeyEvent.META_CTRL_ON = 4096;
+_KeyEvent.META_CTRL_RIGHT_ON = 16384;
+_KeyEvent.META_FUNCTION_ON = 8;
+_KeyEvent.META_META_LEFT_ON = 131072;
+_KeyEvent.META_META_MASK = 458752;
+_KeyEvent.META_META_ON = 65536;
+_KeyEvent.META_META_RIGHT_ON = 262144;
+_KeyEvent.META_NUM_LOCK_ON = 2097152;
+_KeyEvent.META_SCROLL_LOCK_ON = 4194304;
+_KeyEvent.META_SHIFT_LEFT_ON = 64;
+_KeyEvent.META_SHIFT_MASK = 193;
+_KeyEvent.META_SHIFT_ON = 1;
+_KeyEvent.META_SHIFT_RIGHT_ON = 128;
+_KeyEvent.META_SYM_ON = 4;
+let KeyEvent = _KeyEvent;
+const _UIEventsCode = class _UIEventsCode {
+};
+_UIEventsCode.Backquote = "Backquote";
+_UIEventsCode.Backslash = "Backslash";
+_UIEventsCode.BracketLeft = "BracketLeft";
+_UIEventsCode.BracketRight = "BracketRight";
+_UIEventsCode.Comma = "Comma";
+_UIEventsCode.Digit0 = "Digit0";
+_UIEventsCode.Digit1 = "Digit1";
+_UIEventsCode.Digit2 = "Digit2";
+_UIEventsCode.Digit3 = "Digit3";
+_UIEventsCode.Digit4 = "Digit4";
+_UIEventsCode.Digit5 = "Digit5";
+_UIEventsCode.Digit6 = "Digit6";
+_UIEventsCode.Digit7 = "Digit7";
+_UIEventsCode.Digit8 = "Digit8";
+_UIEventsCode.Digit9 = "Digit9";
+_UIEventsCode.Equal = "Equal";
+_UIEventsCode.IntlBackslash = "IntlBackslash";
+_UIEventsCode.IntlRo = "IntlRo";
+_UIEventsCode.IntlYen = "IntlYen";
+_UIEventsCode.KeyA = "KeyA";
+_UIEventsCode.KeyB = "KeyB";
+_UIEventsCode.KeyC = "KeyC";
+_UIEventsCode.KeyD = "KeyD";
+_UIEventsCode.KeyE = "KeyE";
+_UIEventsCode.KeyF = "KeyF";
+_UIEventsCode.KeyG = "KeyG";
+_UIEventsCode.KeyH = "KeyH";
+_UIEventsCode.KeyI = "KeyI";
+_UIEventsCode.KeyJ = "KeyJ";
+_UIEventsCode.KeyK = "KeyK";
+_UIEventsCode.KeyL = "KeyL";
+_UIEventsCode.KeyM = "KeyM";
+_UIEventsCode.KeyN = "KeyN";
+_UIEventsCode.KeyO = "KeyO";
+_UIEventsCode.KeyP = "KeyP";
+_UIEventsCode.KeyQ = "KeyQ";
+_UIEventsCode.KeyR = "KeyR";
+_UIEventsCode.KeyS = "KeyS";
+_UIEventsCode.KeyT = "KeyT";
+_UIEventsCode.KeyU = "KeyU";
+_UIEventsCode.KeyV = "KeyV";
+_UIEventsCode.KeyW = "KeyW";
+_UIEventsCode.KeyX = "KeyX";
+_UIEventsCode.KeyY = "KeyY";
+_UIEventsCode.KeyZ = "KeyZ";
+_UIEventsCode.Minus = "Minus";
+_UIEventsCode.Period = "Period";
+_UIEventsCode.Quote = "Quote";
+_UIEventsCode.Semicolon = "Semicolon";
+_UIEventsCode.Slash = "Slash";
+_UIEventsCode.AltLeft = "AltLeft";
+_UIEventsCode.AltRight = "AltRight";
+_UIEventsCode.Backspace = "Backspace";
+_UIEventsCode.CapsLock = "CapsLock";
+_UIEventsCode.ContextMenu = "ContextMenu";
+_UIEventsCode.ControlLeft = "ControlLeft";
+_UIEventsCode.ControlRight = "ControlRight";
+_UIEventsCode.Enter = "Enter";
+_UIEventsCode.MetaLeft = "MetaLeft";
+_UIEventsCode.MetaRight = "MetaRight";
+_UIEventsCode.ShiftLeft = "ShiftLeft";
+_UIEventsCode.ShiftRight = "ShiftRight";
+_UIEventsCode.Space = "Space";
+_UIEventsCode.Tab = "Tab";
+_UIEventsCode.Convert = "Convert";
+_UIEventsCode.KanaMode = "KanaMode";
+_UIEventsCode.Lang1 = "Lang1";
+_UIEventsCode.Lang2 = "Lang2";
+_UIEventsCode.Lang3 = "Lang3";
+_UIEventsCode.Lang4 = "Lang4";
+_UIEventsCode.Lang5 = "Lang5";
+_UIEventsCode.NonConvert = "NonConvert";
+_UIEventsCode.Delete = "Delete";
+_UIEventsCode.End = "End";
+_UIEventsCode.Help = "Help";
+_UIEventsCode.Home = "Home";
+_UIEventsCode.Insert = "Insert";
+_UIEventsCode.PageDown = "PageDown";
+_UIEventsCode.PageUp = "PageUp";
+_UIEventsCode.ArrowDown = "ArrowDown";
+_UIEventsCode.ArrowLeft = "ArrowLeft";
+_UIEventsCode.ArrowRight = "ArrowRight";
+_UIEventsCode.ArrowUp = "ArrowUp";
+_UIEventsCode.NumLock = "NumLock";
+_UIEventsCode.Numpad0 = "Numpad0";
+_UIEventsCode.Numpad1 = "Numpad1";
+_UIEventsCode.Numpad2 = "Numpad2";
+_UIEventsCode.Numpad3 = "Numpad3";
+_UIEventsCode.Numpad4 = "Numpad4";
+_UIEventsCode.Numpad5 = "Numpad5";
+_UIEventsCode.Numpad6 = "Numpad6";
+_UIEventsCode.Numpad7 = "Numpad7";
+_UIEventsCode.Numpad8 = "Numpad8";
+_UIEventsCode.Numpad9 = "Numpad9";
+_UIEventsCode.NumpadAdd = "NumpadAdd";
+_UIEventsCode.NumpadBackspace = "NumpadBackspace";
+_UIEventsCode.NumpadClear = "NumpadClear";
+_UIEventsCode.NumpadClearEntry = "NumpadClearEntry";
+_UIEventsCode.NumpadComma = "NumpadComma";
+_UIEventsCode.NumpadDecimal = "NumpadDecimal";
+_UIEventsCode.NumpadDivide = "NumpadDivide";
+_UIEventsCode.NumpadEnter = "NumpadEnter";
+_UIEventsCode.NumpadEqual = "NumpadEqual";
+_UIEventsCode.NumpadHash = "NumpadHash";
+_UIEventsCode.NumpadMemoryAdd = "NumpadMemoryAdd";
+_UIEventsCode.NumpadMemoryClear = "NumpadMemoryClear";
+_UIEventsCode.NumpadMemoryRecall = "NumpadMemoryRecall";
+_UIEventsCode.NumpadMemoryStore = "NumpadMemoryStore";
+_UIEventsCode.NumpadMemorySubtract = "NumpadMemorySubtract";
+_UIEventsCode.NumpadMultiply = "NumpadMultiply";
+_UIEventsCode.NumpadParenLeft = "NumpadParenLeft";
+_UIEventsCode.NumpadParenRight = "NumpadParenRight";
+_UIEventsCode.NumpadStar = "NumpadStar";
+_UIEventsCode.NumpadSubtract = "NumpadSubtract";
+_UIEventsCode.Escape = "Escape";
+_UIEventsCode.F1 = "F1";
+_UIEventsCode.F2 = "F2";
+_UIEventsCode.F3 = "F3";
+_UIEventsCode.F4 = "F4";
+_UIEventsCode.F5 = "F5";
+_UIEventsCode.F6 = "F6";
+_UIEventsCode.F7 = "F7";
+_UIEventsCode.F8 = "F8";
+_UIEventsCode.F9 = "F9";
+_UIEventsCode.F10 = "F10";
+_UIEventsCode.F11 = "F11";
+_UIEventsCode.F12 = "F12";
+_UIEventsCode.Fn = "Fn";
+_UIEventsCode.FnLock = "FnLock";
+_UIEventsCode.PrintScreen = "PrintScreen";
+_UIEventsCode.ScrollLock = "ScrollLock";
+_UIEventsCode.Pause = "Pause";
+_UIEventsCode.BrowserBack = "BrowserBack";
+_UIEventsCode.BrowserFavorites = "BrowserFavorites";
+_UIEventsCode.BrowserForward = "BrowserForward";
+_UIEventsCode.BrowserHome = "BrowserHome";
+_UIEventsCode.BrowserRefresh = "BrowserRefresh";
+_UIEventsCode.BrowserSearch = "BrowserSearch";
+_UIEventsCode.BrowserStop = "BrowserStop";
+_UIEventsCode.Eject = "Eject";
+_UIEventsCode.LaunchApp1 = "LaunchApp1";
+_UIEventsCode.LaunchApp2 = "LaunchApp2";
+_UIEventsCode.LaunchMail = "LaunchMail";
+_UIEventsCode.MediaPlayPause = "MediaPlayPause";
+_UIEventsCode.MediaSelect = "MediaSelect";
+_UIEventsCode.MediaStop = "MediaStop";
+_UIEventsCode.MediaTrackNext = "MediaTrackNext";
+_UIEventsCode.MediaTrackPrevious = "MediaTrackPrevious";
+_UIEventsCode.Power = "Power";
+_UIEventsCode.Sleep = "Sleep";
+_UIEventsCode.AudioVolumeDown = "AudioVolumeDown";
+_UIEventsCode.AudioVolumeMute = "AudioVolumeMute";
+_UIEventsCode.AudioVolumeUp = "AudioVolumeUp";
+_UIEventsCode.WakeUp = "WakeUp";
+_UIEventsCode.Hyper = "Hyper";
+_UIEventsCode.Super = "Super";
+_UIEventsCode.Turbo = "Turbo";
+_UIEventsCode.Abort = "Abort";
+_UIEventsCode.Resume = "Resume";
+_UIEventsCode.Suspend = "Suspend";
+_UIEventsCode.Again = "Again";
+_UIEventsCode.Copy = "Copy";
+_UIEventsCode.Cut = "Cut";
+_UIEventsCode.Find = "Find";
+_UIEventsCode.Open = "Open";
+_UIEventsCode.Paste = "Paste";
+_UIEventsCode.Props = "Props";
+_UIEventsCode.Select = "Select";
+_UIEventsCode.Undo = "Undo";
+_UIEventsCode.Hiragana = "Hiragana";
+_UIEventsCode.Katakana = "Katakana";
+_UIEventsCode.Unidentified = "Unidentified";
+let UIEventsCode = _UIEventsCode;
+const KeyToCodeMap = /* @__PURE__ */ new Map([
+  [UIEventsCode.Backquote, KeyEvent.KEYCODE_GRAVE],
+  [UIEventsCode.Backslash, KeyEvent.KEYCODE_BACKSLASH],
+  [UIEventsCode.BracketLeft, KeyEvent.KEYCODE_LEFT_BRACKET],
+  [UIEventsCode.BracketRight, KeyEvent.KEYCODE_RIGHT_BRACKET],
+  [UIEventsCode.Comma, KeyEvent.KEYCODE_COMMA],
+  [UIEventsCode.Digit0, KeyEvent.KEYCODE_0],
+  [UIEventsCode.Digit1, KeyEvent.KEYCODE_1],
+  [UIEventsCode.Digit2, KeyEvent.KEYCODE_2],
+  [UIEventsCode.Digit3, KeyEvent.KEYCODE_3],
+  [UIEventsCode.Digit4, KeyEvent.KEYCODE_4],
+  [UIEventsCode.Digit5, KeyEvent.KEYCODE_5],
+  [UIEventsCode.Digit6, KeyEvent.KEYCODE_6],
+  [UIEventsCode.Digit7, KeyEvent.KEYCODE_7],
+  [UIEventsCode.Digit8, KeyEvent.KEYCODE_8],
+  [UIEventsCode.Digit9, KeyEvent.KEYCODE_9],
+  [UIEventsCode.Equal, KeyEvent.KEYCODE_EQUALS],
+  [UIEventsCode.IntlRo, KeyEvent.KEYCODE_RO],
+  [UIEventsCode.IntlYen, KeyEvent.KEYCODE_YEN],
+  [UIEventsCode.KeyA, KeyEvent.KEYCODE_A],
+  [UIEventsCode.KeyB, KeyEvent.KEYCODE_B],
+  [UIEventsCode.KeyC, KeyEvent.KEYCODE_C],
+  [UIEventsCode.KeyD, KeyEvent.KEYCODE_D],
+  [UIEventsCode.KeyE, KeyEvent.KEYCODE_E],
+  [UIEventsCode.KeyF, KeyEvent.KEYCODE_F],
+  [UIEventsCode.KeyG, KeyEvent.KEYCODE_G],
+  [UIEventsCode.KeyH, KeyEvent.KEYCODE_H],
+  [UIEventsCode.KeyI, KeyEvent.KEYCODE_I],
+  [UIEventsCode.KeyJ, KeyEvent.KEYCODE_J],
+  [UIEventsCode.KeyK, KeyEvent.KEYCODE_K],
+  [UIEventsCode.KeyL, KeyEvent.KEYCODE_L],
+  [UIEventsCode.KeyM, KeyEvent.KEYCODE_M],
+  [UIEventsCode.KeyN, KeyEvent.KEYCODE_N],
+  [UIEventsCode.KeyO, KeyEvent.KEYCODE_O],
+  [UIEventsCode.KeyP, KeyEvent.KEYCODE_P],
+  [UIEventsCode.KeyQ, KeyEvent.KEYCODE_Q],
+  [UIEventsCode.KeyR, KeyEvent.KEYCODE_R],
+  [UIEventsCode.KeyS, KeyEvent.KEYCODE_S],
+  [UIEventsCode.KeyT, KeyEvent.KEYCODE_T],
+  [UIEventsCode.KeyU, KeyEvent.KEYCODE_U],
+  [UIEventsCode.KeyV, KeyEvent.KEYCODE_V],
+  [UIEventsCode.KeyW, KeyEvent.KEYCODE_W],
+  [UIEventsCode.KeyX, KeyEvent.KEYCODE_X],
+  [UIEventsCode.KeyY, KeyEvent.KEYCODE_Y],
+  [UIEventsCode.KeyZ, KeyEvent.KEYCODE_Z],
+  [UIEventsCode.Minus, KeyEvent.KEYCODE_MINUS],
+  [UIEventsCode.Period, KeyEvent.KEYCODE_PERIOD],
+  [UIEventsCode.Quote, KeyEvent.KEYCODE_APOSTROPHE],
+  [UIEventsCode.Semicolon, KeyEvent.KEYCODE_SEMICOLON],
+  [UIEventsCode.Slash, KeyEvent.KEYCODE_SLASH],
+  [UIEventsCode.KanaMode, KeyEvent.KEYCODE_KANA],
+  [UIEventsCode.Delete, KeyEvent.KEYCODE_FORWARD_DEL],
+  [UIEventsCode.End, KeyEvent.KEYCODE_MOVE_END],
+  [UIEventsCode.Help, KeyEvent.KEYCODE_HELP],
+  [UIEventsCode.Home, KeyEvent.KEYCODE_MOVE_HOME],
+  [UIEventsCode.Insert, KeyEvent.KEYCODE_INSERT],
+  [UIEventsCode.PageDown, KeyEvent.KEYCODE_PAGE_DOWN],
+  [UIEventsCode.PageUp, KeyEvent.KEYCODE_PAGE_UP],
+  [UIEventsCode.AltLeft, KeyEvent.KEYCODE_ALT_LEFT],
+  [UIEventsCode.AltRight, KeyEvent.KEYCODE_ALT_RIGHT],
+  [UIEventsCode.Backspace, KeyEvent.KEYCODE_DEL],
+  [UIEventsCode.CapsLock, KeyEvent.KEYCODE_CAPS_LOCK],
+  [UIEventsCode.ControlLeft, KeyEvent.KEYCODE_CTRL_LEFT],
+  [UIEventsCode.ControlRight, KeyEvent.KEYCODE_CTRL_RIGHT],
+  [UIEventsCode.Enter, KeyEvent.KEYCODE_ENTER],
+  [UIEventsCode.MetaLeft, KeyEvent.KEYCODE_META_LEFT],
+  [UIEventsCode.MetaRight, KeyEvent.KEYCODE_META_RIGHT],
+  [UIEventsCode.ShiftLeft, KeyEvent.KEYCODE_SHIFT_LEFT],
+  [UIEventsCode.ShiftRight, KeyEvent.KEYCODE_SHIFT_RIGHT],
+  [UIEventsCode.Space, KeyEvent.KEYCODE_SPACE],
+  [UIEventsCode.Tab, KeyEvent.KEYCODE_TAB],
+  [UIEventsCode.ArrowLeft, KeyEvent.KEYCODE_DPAD_LEFT],
+  [UIEventsCode.ArrowUp, KeyEvent.KEYCODE_DPAD_UP],
+  [UIEventsCode.ArrowRight, KeyEvent.KEYCODE_DPAD_RIGHT],
+  [UIEventsCode.ArrowDown, KeyEvent.KEYCODE_DPAD_DOWN],
+  [UIEventsCode.NumLock, KeyEvent.KEYCODE_NUM_LOCK],
+  [UIEventsCode.Numpad0, KeyEvent.KEYCODE_NUMPAD_0],
+  [UIEventsCode.Numpad1, KeyEvent.KEYCODE_NUMPAD_1],
+  [UIEventsCode.Numpad2, KeyEvent.KEYCODE_NUMPAD_2],
+  [UIEventsCode.Numpad3, KeyEvent.KEYCODE_NUMPAD_3],
+  [UIEventsCode.Numpad4, KeyEvent.KEYCODE_NUMPAD_4],
+  [UIEventsCode.Numpad5, KeyEvent.KEYCODE_NUMPAD_5],
+  [UIEventsCode.Numpad6, KeyEvent.KEYCODE_NUMPAD_7],
+  [UIEventsCode.Numpad8, KeyEvent.KEYCODE_NUMPAD_8],
+  [UIEventsCode.Numpad9, KeyEvent.KEYCODE_NUMPAD_9],
+  [UIEventsCode.NumpadAdd, KeyEvent.KEYCODE_NUMPAD_ADD],
+  [UIEventsCode.NumpadComma, KeyEvent.KEYCODE_NUMPAD_COMMA],
+  [UIEventsCode.NumpadDecimal, KeyEvent.KEYCODE_NUMPAD_DOT],
+  [UIEventsCode.NumpadDivide, KeyEvent.KEYCODE_NUMPAD_DIVIDE],
+  [UIEventsCode.NumpadEnter, KeyEvent.KEYCODE_NUMPAD_ENTER],
+  [UIEventsCode.NumpadEqual, KeyEvent.KEYCODE_NUMPAD_EQUALS],
+  [UIEventsCode.NumpadMultiply, KeyEvent.KEYCODE_NUMPAD_MULTIPLY],
+  [UIEventsCode.NumpadParenLeft, KeyEvent.KEYCODE_NUMPAD_LEFT_PAREN],
+  [UIEventsCode.NumpadParenRight, KeyEvent.KEYCODE_NUMPAD_RIGHT_PAREN],
+  [UIEventsCode.NumpadSubtract, KeyEvent.KEYCODE_NUMPAD_SUBTRACT],
+  [UIEventsCode.Escape, KeyEvent.KEYCODE_ESCAPE],
+  [UIEventsCode.F1, KeyEvent.KEYCODE_F1],
+  [UIEventsCode.F2, KeyEvent.KEYCODE_F2],
+  [UIEventsCode.F3, KeyEvent.KEYCODE_F3],
+  [UIEventsCode.F4, KeyEvent.KEYCODE_F4],
+  [UIEventsCode.F5, KeyEvent.KEYCODE_F5],
+  [UIEventsCode.F6, KeyEvent.KEYCODE_F6],
+  [UIEventsCode.F7, KeyEvent.KEYCODE_F7],
+  [UIEventsCode.F8, KeyEvent.KEYCODE_F8],
+  [UIEventsCode.F9, KeyEvent.KEYCODE_F9],
+  [UIEventsCode.F10, KeyEvent.KEYCODE_F10],
+  [UIEventsCode.F11, KeyEvent.KEYCODE_F11],
+  [UIEventsCode.F12, KeyEvent.KEYCODE_F12],
+  [UIEventsCode.Fn, KeyEvent.KEYCODE_FUNCTION],
+  [UIEventsCode.PrintScreen, KeyEvent.KEYCODE_SYSRQ],
+  [UIEventsCode.Pause, KeyEvent.KEYCODE_BREAK]
+]);
+const _KeyInputHandler = class _KeyInputHandler {
+  static attachListeners() {
+    document.body.addEventListener("keydown", this.handler);
+    document.body.addEventListener("keyup", this.handler);
+  }
+  static detachListeners() {
+    document.body.removeEventListener("keydown", this.handler);
+    document.body.removeEventListener("keyup", this.handler);
+  }
+  static addEventListener(listener) {
+    if (!this.listeners.size) {
+      this.attachListeners();
+    }
+    this.listeners.add(listener);
+  }
+  static removeEventListener(listener) {
+    this.listeners.delete(listener);
+    if (!this.listeners.size) {
+      this.detachListeners();
+    }
+  }
+};
+_KeyInputHandler.repeatCounter = /* @__PURE__ */ new Map();
+_KeyInputHandler.listeners = /* @__PURE__ */ new Set();
+_KeyInputHandler.handler = (event) => {
+  const keyboardEvent = event;
+  const keyCode = KeyToCodeMap.get(keyboardEvent.code);
+  if (!keyCode) {
+    return;
+  }
+  let action;
+  let repeatCount = 0;
+  if (keyboardEvent.type === "keydown") {
+    action = KeyEvent.ACTION_DOWN;
+    if (keyboardEvent.repeat) {
+      let count = _KeyInputHandler.repeatCounter.get(keyCode);
+      if (typeof count !== "number") {
+        count = 1;
+      } else {
+        count++;
+      }
+      repeatCount = count;
+      _KeyInputHandler.repeatCounter.set(keyCode, count);
+    }
+  } else if (keyboardEvent.type === "keyup") {
+    action = KeyEvent.ACTION_UP;
+    _KeyInputHandler.repeatCounter.delete(keyCode);
+  } else {
+    return;
+  }
+  const metaState = (keyboardEvent.getModifierState("Alt") ? KeyEvent.META_ALT_ON : 0) | (keyboardEvent.getModifierState("Shift") ? KeyEvent.META_SHIFT_ON : 0) | (keyboardEvent.getModifierState("Control") ? KeyEvent.META_CTRL_ON : 0) | (keyboardEvent.getModifierState("Meta") ? KeyEvent.META_META_ON : 0) | (keyboardEvent.getModifierState("CapsLock") ? KeyEvent.META_CAPS_LOCK_ON : 0) | (keyboardEvent.getModifierState("ScrollLock") ? KeyEvent.META_SCROLL_LOCK_ON : 0) | (keyboardEvent.getModifierState("NumLock") ? KeyEvent.META_NUM_LOCK_ON : 0);
+  const controlMessage = new KeyCodeControlMessage(
+    action,
+    keyCode,
+    repeatCount,
+    metaState
+  );
+  _KeyInputHandler.listeners.forEach((listener) => {
+    listener.onKeyEvent(controlMessage);
+  });
+  event.preventDefault();
+};
+let KeyInputHandler = _KeyInputHandler;
+class Rect {
+  constructor(left, top, right, bottom) {
+    this.left = left;
+    this.top = top;
+    this.right = right;
+    this.bottom = bottom;
+    this.left = left;
+    this.top = top;
+    this.right = right;
+    this.bottom = bottom;
+  }
+  static equals(a, b) {
+    if (!a && !b) {
+      return true;
+    }
+    return !!a && !!b && a.equals(b);
+  }
+  static copy(a) {
+    if (!a) {
+      return null;
+    }
+    return new Rect(a.left, a.top, a.right, a.bottom);
+  }
+  equals(o) {
+    if (this === o) {
+      return true;
+    }
+    if (!o) {
+      return false;
+    }
+    return this.left === o.left && this.top === o.top && this.right === o.right && this.bottom === o.bottom;
+  }
+  getWidth() {
+    return this.right - this.left;
+  }
+  getHeight() {
+    return this.bottom - this.top;
+  }
+  toString() {
+    return `Rect{left=${this.left}, top=${this.top}, right=${this.right}, bottom=${this.bottom}}`;
+  }
+  toJSON() {
+    return {
+      left: this.left,
+      right: this.right,
+      top: this.top,
+      bottom: this.bottom
+    };
+  }
+}
+const _ScreenInfo = class _ScreenInfo {
+  constructor(contentRect, videoSize, deviceRotation) {
+    this.contentRect = contentRect;
+    this.videoSize = videoSize;
+    this.deviceRotation = deviceRotation;
+  }
+  static fromBuffer(buffer2) {
+    const left = buffer2.readInt32BE(0);
+    const top = buffer2.readInt32BE(4);
+    const right = buffer2.readInt32BE(8);
+    const bottom = buffer2.readInt32BE(12);
+    const width = buffer2.readInt32BE(16);
+    const height = buffer2.readInt32BE(20);
+    const deviceRotation = buffer2.readUInt8(24);
+    return new _ScreenInfo(new Rect(left, top, right, bottom), new Size(width, height), deviceRotation);
+  }
+  equals(o) {
+    if (!o) {
+      return false;
+    }
+    return this.contentRect.equals(o.contentRect) && this.videoSize.equals(o.videoSize) && this.deviceRotation === o.deviceRotation;
+  }
+  toString() {
+    return `ScreenInfo{contentRect=${this.contentRect}, videoSize=${this.videoSize}, deviceRotation=${this.deviceRotation}}`;
+  }
+};
+_ScreenInfo.BUFFER_LENGTH = 25;
+let ScreenInfo = _ScreenInfo;
+exports.CommandControlMessage = CommandControlMessage;
+exports.ControlMessage = ControlMessage;
+exports.FeaturedInteractionHandler = FeaturedInteractionHandler;
+exports.FilePushState = FilePushState;
+exports.InteractionHandler = InteractionHandler;
+exports.KeyCodeControlMessage = KeyCodeControlMessage;
+exports.KeyEvent = KeyEvent;
+exports.KeyInputHandler = KeyInputHandler;
+exports.KeyToCodeMap = KeyToCodeMap;
+exports.MotionEvent = MotionEvent;
+exports.Point = Point;
+exports.Position = Position;
+exports.Rect = Rect;
+exports.ScreenInfo = ScreenInfo;
+exports.ScrollControlMessage = ScrollControlMessage;
+exports.SimpleInteractionHandler = SimpleInteractionHandler;
+exports.Size = Size;
+exports.TextControlMessage = TextControlMessage;
+exports.TouchControlMessage = TouchControlMessage;
+exports.UIEventsCode = UIEventsCode;
+exports.Util = Util;
+//# sourceMappingURL=index.cjs.js.map