ai-remote 0.4.2 → 0.4.4

package/dist/protocols/rdp/display.js

@@ -1,588 +0,0 @@
-import { decodeBitmapRect } from "./rle.js";
-import { TOGGLE_FLAG } from "./pdu.js";
-const IS_MAC = /Mac|iPod|iPhone|iPad/.test(
-  globalThis.navigator?.platform || globalThis.navigator?.userAgent || ""
-);
-const COMMAND_TO_CONTROL = {
-  MetaLeft: "ControlLeft",
-  MetaRight: "ControlRight"
-};
-const WHEEL_STEP_PIXELS = 60;
-const WHEEL_LINE_PIXELS = 16;
-const TOUCH_SCROLL_STEP = 20;
-const MAX_ZOOM = 8;
-const MIN_ZOOM = 1;
-class RdpDisplay {
-  constructor(container) {
-    this.container = container;
-    this.canvas = document.createElement("canvas");
-    this.canvas.tabIndex = 0;
-    this.canvas.style.display = "block";
-    this.canvas.style.position = "absolute";
-    this.canvas.style.outline = "none";
-    this.canvas.style.imageRendering = "auto";
-    this.canvas.style.boxShadow = "none";
-    this.context = this.canvas.getContext("2d", { alpha: false });
-    this.viewportElement = document.createElement("div");
-    this.viewportElement.style.position = "relative";
-    this.viewportElement.style.overflow = "hidden";
-    this.viewportElement.style.margin = "auto";
-    this.viewportElement.style.background = "#000";
-    this.viewportElement.style.boxShadow = "0 10px 30px rgba(0, 0, 0, 0.8)";
-    this.viewportElement.appendChild(this.canvas);
-    container.replaceChildren(this.viewportElement);
-    this.scrollHost = container.parentElement || container;
-    this.width = 0;
-    this.height = 0;
-    this.viewport = { x: 0, y: 0, width: 0, height: 0 };
-    this.scale = 1;
-    this.scaleViewport = true;
-    this.zoom = 1;
-    this.userZoomed = false;
-    this.viewOnly = false;
-    this.client = null;
-    this.palette = null;
-    this.cursorCache = /* @__PURE__ */ new Map();
-    this.heldKeys = /* @__PURE__ */ new Set();
-    this.keyboardSynced = false;
-    this.onWindowResize = () => this.applyScale();
-    window.addEventListener("resize", this.onWindowResize);
-    this.resizeObserver = typeof ResizeObserver === "function" ? new ResizeObserver(() => this.applyScale()) : null;
-    this.resizeObserver?.observe(this.scrollHost);
-  }
-  resize(width, height) {
-    this.width = width;
-    this.height = height;
-    this.canvas.width = width;
-    this.canvas.height = height;
-    this.context.fillStyle = "#000";
-    this.context.fillRect(0, 0, width, height);
-    this.setViewport({ x: 0, y: 0, width, height });
-  }
-  /**
-   * Choose the part of the desktop that is on screen. Everything else about
-   * the session -- painting, input coordinates, the remote pointer -- keeps
-   * working in desktop coordinates, so only the framing changes here.
-   */
-  setViewport({ x = 0, y = 0, width, height } = {}) {
-    if (!this.width || !this.height) return;
-    const left = Math.max(0, Math.min(this.width - 1, Math.floor(x)));
-    const top = Math.max(0, Math.min(this.height - 1, Math.floor(y)));
-    this.viewport = {
-      x: left,
-      y: top,
-      width: Math.max(1, Math.min(this.width - left, Math.floor(width || this.width))),
-      height: Math.max(1, Math.min(this.height - top, Math.floor(height || this.height)))
-    };
-    this.canvas.dataset.viewport = [
-      this.viewport.x,
-      this.viewport.y,
-      this.viewport.width,
-      this.viewport.height
-    ].join(",");
-    this.applyScale();
-  }
-  /** The space a fitted desktop has to fit into: the window, not the content. */
-  #available() {
-    const host = this.scrollHost;
-    return {
-      width: host.clientWidth || this.container.clientWidth || 1,
-      height: host.clientHeight || this.container.clientHeight || 1
-    };
-  }
-  /** The scale at which the whole desktop is on screen, letterboxed. */
-  #fitScale(available = this.#available()) {
-    const fitted = Math.min(
-      available.width / this.viewport.width,
-      available.height / this.viewport.height
-    );
-    return Number.isFinite(fitted) && fitted > 0 ? fitted : 1;
-  }
-  /**
-   * The zoom to open a session at.
-   *
-   * On a laptop the fitted view is the right one: the whole desktop is on
-   * screen and readable, and that is where this stays. On a phone it is not --
-   * a 1024x768 desktop fitted to a 375pt-wide window lands at about a third of
-   * full size, a band of unreadable pixels across the middle of a tall black
-   * screen. When fitting would land under LEGIBLE_SCALE the desktop is scaled
-   * to fill the window instead: the short edge matches exactly and the long one
-   * is panned. Everything is still reachable, and a pinch still gets back to
-   * the whole desktop. Legible first and complete second is the right way round
-   * on a screen this size.
-   */
-  #defaultZoom() {
-    return 1;
-  }
-  applyScale() {
-    if (!this.width || !this.height) return;
-    const viewport = this.viewport;
-    const available = this.#available();
-    const fitted = this.#fitScale(available);
-    if (!this.userZoomed) this.zoom = this.#defaultZoom();
-    const scale = (this.scaleViewport ? fitted : 1) * this.zoom;
-    this.scale = scale;
-    this.viewportElement.style.width = `${viewport.width * scale}px`;
-    this.viewportElement.style.height = `${viewport.height * scale}px`;
-    this.canvas.style.width = `${this.width * scale}px`;
-    this.canvas.style.height = `${this.height * scale}px`;
-    this.canvas.style.left = `${-viewport.x * scale}px`;
-    this.canvas.style.top = `${-viewport.y * scale}px`;
-  }
-  /**
-   * Zoom about a point, keeping whatever is under it in place. `focal` is in
-   * client coordinates -- the midpoint between two fingers, usually.
-   */
-  setZoom(next, focal = null) {
-    const clamped = Math.min(MAX_ZOOM, Math.max(MIN_ZOOM, next));
-    if (!Number.isFinite(clamped) || clamped === this.zoom) return;
-    const host = this.scrollHost;
-    const before = this.scale;
-    const bounds = host.getBoundingClientRect();
-    const anchorX = focal ? focal.x - bounds.left : bounds.width / 2;
-    const anchorY = focal ? focal.y - bounds.top : bounds.height / 2;
-    const contentX = host.scrollLeft + anchorX;
-    const contentY = host.scrollTop + anchorY;
-    this.zoom = clamped;
-    this.applyScale();
-    const ratio = before > 0 ? this.scale / before : 1;
-    host.scrollLeft = contentX * ratio - anchorX;
-    host.scrollTop = contentY * ratio - anchorY;
-  }
-  /** Move the visible window over the desktop. Returns what it actually used. */
-  panBy(dx, dy) {
-    const host = this.scrollHost;
-    const beforeX = host.scrollLeft;
-    const beforeY = host.scrollTop;
-    host.scrollLeft = beforeX - dx;
-    host.scrollTop = beforeY - dy;
-    return {
-      x: beforeX - host.scrollLeft,
-      y: beforeY - host.scrollTop
-    };
-  }
-  /** True when the desktop is larger than the window on either axis. */
-  canPan() {
-    if (this.zoom <= 1.05) return false;
-    const host = this.scrollHost;
-    return host.scrollWidth > host.clientWidth + 2 || host.scrollHeight > host.clientHeight + 2;
-  }
-  setScaleViewport(enabled) {
-    this.scaleViewport = enabled;
-    if (!enabled) this.userZoomed = false;
-    this.applyScale();
-  }
-  /** Back to the opening view: whole desktop fitted on screen. */
-  resetZoom() {
-    this.userZoomed = false;
-    this.zoom = 1;
-    this.applyScale();
-    const host = this.scrollHost;
-    host.scrollLeft = 0;
-    host.scrollTop = 0;
-  }
-  drawRects(rects, palette) {
-    if (palette) this.palette = palette;
-    for (const rect of rects) {
-      if (rect.width === 0 || rect.height === 0) continue;
-      try {
-        const rgba = decodeBitmapRect(rect, this.palette);
-        const image = new ImageData(rgba, rect.width, rect.height);
-        this.context.putImageData(image, rect.left, rect.top);
-      } catch (error) {
-        console.warn("[RDP] Dropped an undecodable bitmap rectangle", {
-          geometry: `${rect.width}x${rect.height}+${rect.left}+${rect.top}`,
-          bitsPerPixel: rect.bitsPerPixel,
-          compressed: rect.compressed,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }
-  }
-  // --- cursor ---------------------------------------------------------------
-  /**
-   * Turn an RDP pointer bitmap into a CSS cursor. RDP stores both masks
-   * bottom-up with rows padded to an even number of bytes, and a set AND-mask
-   * bit means "leave this pixel alone", which becomes transparency here.
-   */
-  #cursorFromPointer(pointer) {
-    const { width, height, xorBpp, xorMask, andMask, hotSpotX, hotSpotY } = pointer;
-    if (!width || !height) return null;
-    const xorBytesPerRow = Math.ceil(width * xorBpp / 8 / 2) * 2;
-    const andBytesPerRow = Math.ceil(width / 8 / 2) * 2;
-    const rgba = new Uint8ClampedArray(width * height * 4);
-    for (let y = 0; y < height; y++) {
-      const sourceRow = height - 1 - y;
-      for (let x = 0; x < width; x++) {
-        const andByte = andMask[sourceRow * andBytesPerRow + (x >> 3)];
-        const transparent = andByte !== void 0 && (andByte & 128 >> (x & 7)) !== 0;
-        let r = 0;
-        let g = 0;
-        let b = 0;
-        let a = transparent ? 0 : 255;
-        if (xorBpp === 1) {
-          const bit = xorMask[sourceRow * xorBytesPerRow + (x >> 3)] & 128 >> (x & 7);
-          r = g = b = bit ? 255 : 0;
-        } else {
-          const bytesPerPixel = xorBpp / 8;
-          const offset = sourceRow * xorBytesPerRow + x * bytesPerPixel;
-          if (xorBpp === 16) {
-            const value = xorMask[offset] | xorMask[offset + 1] << 8;
-            r = (value >> 11 & 31) * 255 / 31;
-            g = (value >> 5 & 63) * 255 / 63;
-            b = (value & 31) * 255 / 31;
-          } else {
-            b = xorMask[offset] || 0;
-            g = xorMask[offset + 1] || 0;
-            r = xorMask[offset + 2] || 0;
-            if (xorBpp === 32 && xorMask[offset + 3] !== void 0 && andMask.length === 0) {
-              a = xorMask[offset + 3];
-            }
-          }
-        }
-        const target = (y * width + x) * 4;
-        rgba[target] = r;
-        rgba[target + 1] = g;
-        rgba[target + 2] = b;
-        rgba[target + 3] = a;
-      }
-    }
-    const cursorCanvas = document.createElement("canvas");
-    cursorCanvas.width = width;
-    cursorCanvas.height = height;
-    cursorCanvas.getContext("2d").putImageData(new ImageData(rgba, width, height), 0, 0);
-    const hotX = Math.min(hotSpotX || 0, width - 1);
-    const hotY = Math.min(hotSpotY || 0, height - 1);
-    return `url(${cursorCanvas.toDataURL("image/png")}) ${hotX} ${hotY}, default`;
-  }
-  applyPointer(pointer) {
-    if (pointer.kind === "system") {
-      this.canvas.style.cursor = pointer.hidden ? "none" : "default";
-      return;
-    }
-    if (pointer.kind === "position") {
-      return;
-    }
-    if (pointer.kind === "cached") {
-      const cached = this.cursorCache.get(pointer.cacheIndex);
-      if (cached) this.canvas.style.cursor = cached;
-      return;
-    }
-    if (pointer.kind === "bitmap") {
-      try {
-        const cursor = this.#cursorFromPointer(pointer);
-        if (!cursor) return;
-        this.cursorCache.set(pointer.cacheIndex, cursor);
-        this.canvas.style.cursor = cursor;
-      } catch (error) {
-        console.warn("[RDP] Could not build a cursor from the host pointer update", error);
-      }
-    }
-  }
-  // --- input ----------------------------------------------------------------
-  #toRemote(event) {
-    const bounds = this.canvas.getBoundingClientRect();
-    const scaleX = this.width / (bounds.width || 1);
-    const scaleY = this.height / (bounds.height || 1);
-    return {
-      x: Math.max(0, Math.min(this.width - 1, (event.clientX - bounds.left) * scaleX)),
-      y: Math.max(0, Math.min(this.height - 1, (event.clientY - bounds.top) * scaleY))
-    };
-  }
-  #syncKeyboardOnce(event) {
-    if (this.keyboardSynced || !this.client) return;
-    this.keyboardSynced = true;
-    let flags = 0;
-    if (event.getModifierState?.("CapsLock")) flags |= TOGGLE_FLAG.CAPS_LOCK;
-    if (event.getModifierState?.("NumLock")) flags |= TOGGLE_FLAG.NUM_LOCK;
-    if (event.getModifierState?.("ScrollLock")) flags |= TOGGLE_FLAG.SCROLL_LOCK;
-    this.client.sendKeyboardSync(flags);
-  }
-  attachInput(client) {
-    this.client = client;
-    this.keyboardSynced = false;
-    const canSend = () => this.client && this.client.connected && !this.viewOnly;
-    let pendingMove = null;
-    let moveScheduled = false;
-    let pendingWheelDelta = 0;
-    let touchIsDown = false;
-    let lastTouchX = 0;
-    let lastTouchY = 0;
-    let lastTouchScrollY = 0;
-    let lastTouchScrollX = 0;
-    let gestureStartMid = { x: 0, y: 0 };
-    let gestureStartDistance = 0;
-    let lastPinchDistance = 0;
-    let pendingTouchWheelDelta = 0;
-    let touchMode = null;
-    const touchMidpoint = (touches) => ({
-      x: (touches[0].clientX + touches[1].clientX) / 2,
-      y: (touches[0].clientY + touches[1].clientY) / 2
-    });
-    const touchDistance = (touches) => Math.hypot(
-      touches[0].clientX - touches[1].clientX,
-      touches[0].clientY - touches[1].clientY
-    );
-    const flushMove = () => {
-      moveScheduled = false;
-      if (pendingMove && canSend()) this.client.sendMouseMove(pendingMove.x, pendingMove.y);
-      pendingMove = null;
-    };
-    this.handlers = {
-      mousemove: (event) => {
-        if (!canSend()) return;
-        pendingMove = this.#toRemote(event);
-        if (!moveScheduled) {
-          moveScheduled = true;
-          requestAnimationFrame(flushMove);
-        }
-      },
-      mousedown: (event) => {
-        this.canvas.focus();
-        if (!canSend()) return;
-        event.preventDefault();
-        const { x, y } = this.#toRemote(event);
-        this.client.sendMouseButton(event.button, true, x, y);
-      },
-      mouseup: (event) => {
-        if (!canSend()) return;
-        event.preventDefault();
-        const { x, y } = this.#toRemote(event);
-        this.client.sendMouseButton(event.button, false, x, y);
-      },
-      contextmenu: (event) => event.preventDefault(),
-      wheel: (event) => {
-        if (!canSend()) return;
-        event.preventDefault();
-        let delta = event.deltaY;
-        if (event.deltaMode === WheelEvent.DOM_DELTA_LINE) delta *= WHEEL_LINE_PIXELS;
-        if (event.deltaMode === WheelEvent.DOM_DELTA_PAGE) {
-          delta *= Math.max(1, this.canvas.clientHeight || this.height);
-        }
-        if (!delta) return;
-        if (pendingWheelDelta && Math.sign(pendingWheelDelta) !== Math.sign(delta)) {
-          pendingWheelDelta = 0;
-        }
-        pendingWheelDelta += delta;
-        if (Math.abs(pendingWheelDelta) < WHEEL_STEP_PIXELS) return;
-        const direction = Math.sign(pendingWheelDelta);
-        pendingWheelDelta -= direction * WHEEL_STEP_PIXELS;
-        const { x, y } = this.#toRemote(event);
-        this.client.sendWheel(direction, x, y);
-      },
-      touchstart: (event) => {
-        this.canvas.focus();
-        if (!canSend()) return;
-        event.preventDefault();
-        if (event.touches.length === 1) {
-          touchMode = "tap";
-          const touch = event.touches[0];
-          lastTouchX = touch.clientX;
-          lastTouchY = touch.clientY;
-          const { x, y } = this.#toRemote(touch);
-          this.client.sendMouseMove(x, y);
-          this.client.sendMouseButton(0, true, x, y);
-          touchIsDown = true;
-        } else if (event.touches.length === 2) {
-          touchMode = "undecided";
-          if (touchIsDown) {
-            const { x, y } = this.#toRemote({ clientX: lastTouchX, clientY: lastTouchY });
-            this.client.sendMouseButton(0, false, x, y);
-            touchIsDown = false;
-          }
-          const mid = touchMidpoint(event.touches);
-          const dist = touchDistance(event.touches);
-          gestureStartMid = { x: mid.x, y: mid.y };
-          gestureStartDistance = dist;
-          lastTouchScrollY = mid.y;
-          lastTouchScrollX = mid.x;
-          lastPinchDistance = dist;
-          pendingTouchWheelDelta = 0;
-        }
-      },
-      touchmove: (event) => {
-        if (!canSend()) return;
-        event.preventDefault();
-        if (event.touches.length === 1 && touchMode === "tap") {
-          const touch = event.touches[0];
-          lastTouchX = touch.clientX;
-          lastTouchY = touch.clientY;
-          const { x, y } = this.#toRemote(touch);
-          this.client.sendMouseMove(x, y);
-        } else if (event.touches.length === 2) {
-          const mid = touchMidpoint(event.touches);
-          const currX = mid.x;
-          const currY = mid.y;
-          const distance = touchDistance(event.touches);
-          const deltaY = lastTouchScrollY - currY;
-          const deltaX = lastTouchScrollX - currX;
-          lastTouchScrollY = currY;
-          lastTouchScrollX = currX;
-          const totalMove = Math.hypot(currX - gestureStartMid.x, currY - gestureStartMid.y);
-          const pinchDelta = Math.abs(distance - gestureStartDistance);
-          const pinchRatio = gestureStartDistance > 0 ? distance / gestureStartDistance : 1;
-          if (touchMode === "undecided" || touchMode === "gesture") {
-            if (pinchDelta > 20 && Math.abs(pinchRatio - 1) > 0.15 && pinchDelta > totalMove * 0.8) {
-              touchMode = "pinch";
-            } else if (totalMove > 8) {
-              touchMode = "scroll";
-            }
-          }
-          if (touchMode === "pinch") {
-            if (lastPinchDistance > 0 && Math.abs(distance - lastPinchDistance) > 1) {
-              this.userZoomed = true;
-              this.setZoom(this.zoom * (distance / lastPinchDistance), { x: currX, y: currY });
-            }
-            lastPinchDistance = distance;
-          } else if (touchMode === "scroll") {
-            lastPinchDistance = distance;
-            if (this.canPan()) {
-              this.panBy(deltaX * -1, deltaY * -1);
-              pendingTouchWheelDelta = 0;
-              return;
-            }
-            if (deltaY && pendingTouchWheelDelta && Math.sign(pendingTouchWheelDelta) !== Math.sign(deltaY)) {
-              pendingTouchWheelDelta = 0;
-            }
-            pendingTouchWheelDelta += deltaY;
-            while (Math.abs(pendingTouchWheelDelta) >= TOUCH_SCROLL_STEP) {
-              const direction = Math.sign(pendingTouchWheelDelta);
-              pendingTouchWheelDelta -= direction * TOUCH_SCROLL_STEP;
-              const { x, y } = this.#toRemote({ clientX: currX, clientY: currY });
-              this.client.sendWheel(direction, x, y);
-            }
-          }
-        }
-      },
-      touchend: (event) => {
-        if (!canSend()) return;
-        event.preventDefault();
-        if (event.touches.length === 0) {
-          if (touchIsDown) {
-            const { x, y } = this.#toRemote({ clientX: lastTouchX, clientY: lastTouchY });
-            this.client.sendMouseButton(0, false, x, y);
-            touchIsDown = false;
-          }
-          if (touchMode === "pinch" && this.zoom <= 1.05) {
-            this.resetZoom();
-          }
-          touchMode = null;
-          pendingTouchWheelDelta = 0;
-          lastPinchDistance = 0;
-        } else if (event.touches.length === 1) {
-          if (touchMode === "gesture" || touchMode === "pinch" || touchMode === "scroll" || touchMode === "undecided") {
-            if (touchMode === "pinch" && this.zoom <= 1.05) {
-              this.resetZoom();
-            }
-            touchMode = null;
-            lastPinchDistance = 0;
-            pendingTouchWheelDelta = 0;
-          }
-        }
-      },
-      touchcancel: (event) => {
-        if (!canSend()) return;
-        if (touchIsDown) {
-          const { x, y } = this.#toRemote({ clientX: lastTouchX, clientY: lastTouchY });
-          this.client.sendMouseButton(0, false, x, y);
-          touchIsDown = false;
-        }
-        if (touchMode === "pinch" && this.zoom <= 1.05) {
-          this.resetZoom();
-        }
-        touchMode = null;
-        pendingTouchWheelDelta = 0;
-        lastPinchDistance = 0;
-      },
-      keydown: (event) => {
-        if (!canSend()) return;
-        this.#syncKeyboardOnce(event);
-        if (this.#isPasteShortcut(event)) return;
-        const code = this.#translateCode(event.code);
-        if (!this.client.sendKeyByCode(code, true)) return;
-        event.preventDefault();
-        if (IS_MAC && event.metaKey && !COMMAND_TO_CONTROL[event.code]) {
-          this.client.sendKeyByCode(code, false);
-          return;
-        }
-        this.heldKeys.add(code);
-      },
-      keyup: (event) => {
-        if (!canSend()) return;
-        if (this.#isPasteShortcut(event)) return;
-        const code = this.#translateCode(event.code);
-        if (this.client.sendKeyByCode(code, false)) {
-          this.heldKeys.delete(code);
-          event.preventDefault();
-        }
-      },
-      paste: (event) => {
-        if (!canSend()) return;
-        const target = event.target;
-        const onTheScreen = target instanceof Node && this.container.contains(target);
-        if (document.activeElement !== this.canvas && !onTheScreen) return;
-        event.preventDefault();
-        const text = event.clipboardData?.getData("text/plain") || "";
-        if (text) this.client.pasteToHost(text);
-      },
-      blur: () => this.releaseAllKeys()
-    };
-    this.canvas.addEventListener("mousemove", this.handlers.mousemove);
-    this.canvas.addEventListener("mousedown", this.handlers.mousedown);
-    this.canvas.addEventListener("mouseup", this.handlers.mouseup);
-    this.canvas.addEventListener("contextmenu", this.handlers.contextmenu);
-    this.canvas.addEventListener("wheel", this.handlers.wheel, { passive: false });
-    this.canvas.addEventListener("touchstart", this.handlers.touchstart, { passive: false });
-    this.canvas.addEventListener("touchmove", this.handlers.touchmove, { passive: false });
-    this.canvas.addEventListener("touchend", this.handlers.touchend, { passive: false });
-    this.canvas.addEventListener("touchcancel", this.handlers.touchcancel, { passive: false });
-    this.canvas.addEventListener("keydown", this.handlers.keydown);
-    this.canvas.addEventListener("keyup", this.handlers.keyup);
-    this.canvas.addEventListener("blur", this.handlers.blur);
-    document.addEventListener("paste", this.handlers.paste);
-  }
-  /** Command on a Mac stands in for Control everywhere the host is concerned. */
-  #translateCode(code) {
-    return IS_MAC ? COMMAND_TO_CONTROL[code] || code : code;
-  }
-  #isPasteShortcut(event) {
-    if (event.code !== "KeyV") return false;
-    return IS_MAC ? event.metaKey : event.ctrlKey;
-  }
-  /** A key held while focus moves away would otherwise stay down on the host. */
-  releaseAllKeys() {
-    if (!this.client) return;
-    for (const code of this.heldKeys) this.client.sendKeyByCode(code, false);
-    this.heldKeys.clear();
-  }
-  focus() {
-    this.canvas.focus();
-  }
-  blur() {
-    this.canvas.blur();
-  }
-  destroy() {
-    this.releaseAllKeys();
-    window.removeEventListener("resize", this.onWindowResize);
-    this.resizeObserver?.disconnect();
-    if (this.handlers) {
-      this.canvas.removeEventListener("mousemove", this.handlers.mousemove);
-      this.canvas.removeEventListener("mousedown", this.handlers.mousedown);
-      this.canvas.removeEventListener("mouseup", this.handlers.mouseup);
-      this.canvas.removeEventListener("contextmenu", this.handlers.contextmenu);
-      this.canvas.removeEventListener("wheel", this.handlers.wheel);
-      this.canvas.removeEventListener("touchstart", this.handlers.touchstart);
-      this.canvas.removeEventListener("touchmove", this.handlers.touchmove);
-      this.canvas.removeEventListener("touchend", this.handlers.touchend);
-      this.canvas.removeEventListener("touchcancel", this.handlers.touchcancel);
-      this.canvas.removeEventListener("keydown", this.handlers.keydown);
-      this.canvas.removeEventListener("keyup", this.handlers.keyup);
-      this.canvas.removeEventListener("blur", this.handlers.blur);
-      document.removeEventListener("paste", this.handlers.paste);
-    }
-    this.client = null;
-  }
-}
-export {
-  RdpDisplay
-};

package/dist/protocols/rdp/gcc.d.ts

@@ -1,23 +0,0 @@
-/** RDP 5.0 and later. Anything newer would oblige us to speak newer PDUs. */
-export declare const RDP_VERSION_5_PLUS = 524292;
-export declare const ENCRYPTION_LEVEL: {
-    NONE: number;
-    LOW: number;
-    CLIENT_COMPATIBLE: number;
-    HIGH: number;
-    FIPS: number;
-};
-export declare function clientData(options: any): Uint8Array<ArrayBufferLike>;
-/**
- * Walk the host's answer. Only the security and network blocks carry anything
- * the client must act on; the core block is kept for logging.
- */
-export declare function parseServerData(blocks: any): {
-    version: any;
-    encryptionMethod: number;
-    encryptionLevel: number;
-    serverRandom: any;
-    publicKey: any;
-    ioChannelId: number;
-    channelIds: any[];
-};