ai-remote 0.4.2 → 0.4.4

package/dist/protocols/rdp/rail.js

@@ -1,382 +0,0 @@
-import { Reader, Writer } from "./buffer.js";
-const RAIL_ORDER = {
-  EXEC: 1,
-  ACTIVATE: 2,
-  SYSPARAM: 3,
-  SYSCOMMAND: 4,
-  HANDSHAKE: 5,
-  WINDOW_MOVE: 8,
-  CLIENT_STATUS: 11,
-  EXEC_RESULT: 128,
-  HANDSHAKE_EX: 19
-};
-const RAIL_EXEC_RESULT = {
-  0: "The remote application started.",
-  1: "The RemoteApp host could not load its application monitoring hook.",
-  2: "The RemoteApp host could not decode the application launch request.",
-  3: "The requested application is not in the host RemoteApp allowlist.",
-  5: "The requested remote application was not found.",
-  6: "The RemoteApp host could not start the requested application.",
-  7: "The RemoteApp session is locked and cannot start the application."
-};
-const SYS_COMMAND = {
-  MINIMIZE: 61472,
-  MAXIMIZE: 61488,
-  CLOSE: 61536,
-  RESTORE: 61728
-};
-const SHOW_STATE = {
-  HIDDEN: 0,
-  MINIMIZED: 2,
-  MAXIMIZED: 3,
-  NORMAL: 5
-};
-const WINDOW_ORDER = {
-  TYPE_WINDOW: 16777216,
-  STATE_NEW: 268435456,
-  STATE_DELETED: 536870912,
-  ICON: 1073741824,
-  CACHED_ICON: 2147483648
-};
-const WINDOW_FIELD = {
-  OWNER: 2,
-  TITLE: 4,
-  STYLE: 8,
-  SHOW: 16,
-  WND_RECTS: 256,
-  WND_SIZE: 1024,
-  WND_OFFSET: 2048,
-  CLIENT_AREA_OFFSET: 16384,
-  CLIENT_DELTA: 32768,
-  CLIENT_AREA_SIZE: 65536,
-  RP_CONTENT: 131072,
-  ROOT_PARENT: 262144,
-  VISIBILITY: 524288,
-  VIS_OFFSET: 2097152
-};
-const STYLE_CHILD = 1073741824;
-const EX_STYLE_TOOLWINDOW = 128;
-const EX_STYLE_NOACTIVATE = 134217728;
-const DRAWING_ORDER_CLASS_MASK = 3;
-const DRAWING_ORDER_ALT_SECONDARY = 2;
-const ALTSEC_WINDOW = 11;
-const CLIENT_BUILD = 2600;
-const CLIENT_STATUS_SUPPRESS_ICON_ORDERS = 1024;
-const SYSTEM_PARAMETER = {
-  MOUSE_BUTTON_SWAP: 33,
-  DRAG_FULL_WINDOWS: 37,
-  WORK_AREA: 47,
-  HIGH_CONTRAST: 67,
-  KEYBOARD_PREF: 69,
-  KEYBOARD_CUES: 4107
-};
-function utf16Bytes(text) {
-  const writer = new Writer(text.length * 2);
-  writer.utf16le(text);
-  return writer.take();
-}
-function pdu(orderType, body) {
-  const writer = new Writer(body.length + 4);
-  writer.u16le(orderType).u16le(body.length + 4).raw(body);
-  return writer.take();
-}
-function signed32(value) {
-  return value | 0;
-}
-function railHandshake(buildNumber = CLIENT_BUILD) {
-  return pdu(RAIL_ORDER.HANDSHAKE, new Writer(4).u32le(buildNumber).take());
-}
-function railClientStatus(flags = CLIENT_STATUS_SUPPRESS_ICON_ORDERS) {
-  return pdu(RAIL_ORDER.CLIENT_STATUS, new Writer(4).u32le(flags).take());
-}
-function railBooleanSystemParameter(parameter, enabled) {
-  return pdu(RAIL_ORDER.SYSPARAM, new Writer(5).u32le(parameter).u8(enabled ? 1 : 0).take());
-}
-function railHighContrast() {
-  const body = new Writer(16);
-  body.u32le(SYSTEM_PARAMETER.HIGH_CONTRAST);
-  body.u32le(126);
-  body.u32le(2);
-  body.u16le(0).u16le(0);
-  return pdu(RAIL_ORDER.SYSPARAM, body.take());
-}
-function railWorkArea(width, height) {
-  const body = new Writer(12);
-  body.u32le(SYSTEM_PARAMETER.WORK_AREA);
-  body.u16le(0).u16le(0).u16le(width).u16le(height);
-  return pdu(RAIL_ORDER.SYSPARAM, body.take());
-}
-function railSystemParameters(width, height) {
-  return [
-    railHighContrast(),
-    railBooleanSystemParameter(SYSTEM_PARAMETER.MOUSE_BUTTON_SWAP, false),
-    railBooleanSystemParameter(SYSTEM_PARAMETER.KEYBOARD_PREF, false),
-    railBooleanSystemParameter(SYSTEM_PARAMETER.DRAG_FULL_WINDOWS, true),
-    railBooleanSystemParameter(SYSTEM_PARAMETER.KEYBOARD_CUES, false),
-    railWorkArea(width, height)
-  ];
-}
-function railActivate(windowId, enabled = true) {
-  const body = new Writer(5);
-  body.u32le(windowId).u8(enabled ? 1 : 0);
-  return pdu(RAIL_ORDER.ACTIVATE, body.take());
-}
-function railSysCommand(windowId, command) {
-  const body = new Writer(6);
-  body.u32le(windowId).u16le(command);
-  return pdu(RAIL_ORDER.SYSCOMMAND, body.take());
-}
-function railWindowMove(windowId, { left, top, right, bottom }) {
-  const body = new Writer(12);
-  body.u32le(windowId);
-  body.u16le(left & 65535).u16le(top & 65535);
-  body.u16le(right & 65535).u16le(bottom & 65535);
-  return pdu(RAIL_ORDER.WINDOW_MOVE, body.take());
-}
-function railExecute({ program, workingDir = "", arguments: args = "" }) {
-  const exe = utf16Bytes(program || "");
-  const cwd = utf16Bytes(workingDir || "");
-  const argv = utf16Bytes(args || "");
-  if (exe.length === 0 || exe.length > 520) {
-    throw new Error("RemoteApp program must be between 1 and 260 Unicode characters.");
-  }
-  if (cwd.length > 520) throw new Error("RemoteApp working directory is too long.");
-  if (argv.length > 16e3) throw new Error("RemoteApp arguments are too long.");
-  const body = new Writer(8 + exe.length + cwd.length + argv.length);
-  body.u16le(0);
-  body.u16le(exe.length).u16le(cwd.length).u16le(argv.length);
-  body.raw(exe).raw(cwd).raw(argv);
-  return pdu(RAIL_ORDER.EXEC, body.take());
-}
-function decodeUtf16(bytes) {
-  let result = "";
-  for (let i = 0; i + 1 < bytes.length; i += 2) {
-    const codeUnit = bytes[i] | bytes[i + 1] << 8;
-    if (codeUnit === 0) break;
-    result += String.fromCharCode(codeUnit);
-  }
-  return result;
-}
-function readRectangles(reader, count) {
-  const rectangles = [];
-  for (let index = 0; index < count && reader.remaining >= 8; index++) {
-    const left = reader.u16le();
-    const top = reader.u16le();
-    const right = reader.u16le();
-    const bottom = reader.u16le();
-    rectangles.push({ left, top, right, bottom });
-  }
-  return rectangles;
-}
-function parseWindowFields(reader, fieldFlags) {
-  const fields = {};
-  if (fieldFlags & WINDOW_FIELD.OWNER) fields.ownerWindowId = reader.u32le();
-  if (fieldFlags & WINDOW_FIELD.STYLE) {
-    fields.style = reader.u32le();
-    fields.extendedStyle = reader.u32le();
-  }
-  if (fieldFlags & WINDOW_FIELD.SHOW) fields.showState = reader.u8();
-  if (fieldFlags & WINDOW_FIELD.TITLE) {
-    const titleBytes = reader.u16le();
-    fields.title = decodeUtf16(reader.raw(Math.min(titleBytes, reader.remaining)));
-  }
-  if (fieldFlags & WINDOW_FIELD.CLIENT_AREA_OFFSET) {
-    fields.clientOffsetX = signed32(reader.u32le());
-    fields.clientOffsetY = signed32(reader.u32le());
-  }
-  if (fieldFlags & WINDOW_FIELD.CLIENT_AREA_SIZE) {
-    fields.clientWidth = signed32(reader.u32le());
-    fields.clientHeight = signed32(reader.u32le());
-  }
-  if (fieldFlags & WINDOW_FIELD.RP_CONTENT) reader.u8();
-  if (fieldFlags & WINDOW_FIELD.ROOT_PARENT) reader.u32le();
-  if (fieldFlags & WINDOW_FIELD.WND_OFFSET) {
-    fields.x = signed32(reader.u32le());
-    fields.y = signed32(reader.u32le());
-  }
-  if (fieldFlags & WINDOW_FIELD.CLIENT_DELTA) {
-    reader.u32le();
-    reader.u32le();
-  }
-  if (fieldFlags & WINDOW_FIELD.WND_SIZE) {
-    fields.width = signed32(reader.u32le());
-    fields.height = signed32(reader.u32le());
-  }
-  if (fieldFlags & WINDOW_FIELD.WND_RECTS) {
-    fields.windowRects = readRectangles(reader, reader.u16le());
-  }
-  if (fieldFlags & WINDOW_FIELD.VIS_OFFSET) {
-    fields.visibleOffsetX = signed32(reader.u32le());
-    fields.visibleOffsetY = signed32(reader.u32le());
-  }
-  if (fieldFlags & WINDOW_FIELD.VISIBILITY) {
-    fields.visibilityRects = readRectangles(reader, reader.u16le());
-  }
-  return fields;
-}
-function isPrimaryWindow(candidate) {
-  if (!candidate) return false;
-  if (candidate.ownerWindowId) return false;
-  if ((candidate.style || 0) & STYLE_CHILD) return false;
-  if ((candidate.extendedStyle || 0) & (EX_STYLE_TOOLWINDOW | EX_STYLE_NOACTIVATE)) return false;
-  return true;
-}
-function parseRemoteAppWindowOrders(reader) {
-  if (reader.remaining < 6) throw new Error("RDP RemoteApp orders update is truncated.");
-  reader.u16le();
-  const numberOrders = reader.u16le();
-  reader.u16le();
-  const events = [];
-  for (let index = 0; index < numberOrders && reader.remaining > 0; index++) {
-    const orderStart = reader.offset;
-    const controlFlags = reader.u8();
-    const orderClass = controlFlags & DRAWING_ORDER_CLASS_MASK;
-    const orderType = controlFlags >> 2;
-    if (orderClass !== DRAWING_ORDER_ALT_SECONDARY || orderType !== ALTSEC_WINDOW) break;
-    if (reader.remaining < 6) throw new Error("RDP RemoteApp window-order header is truncated.");
-    const orderSize = reader.u16le();
-    const fieldFlags = reader.u32le();
-    const orderEnd = orderStart + orderSize;
-    if (orderSize < 7 || orderEnd > reader.bytes.length) {
-      throw new Error("RDP RemoteApp window order has an invalid size.");
-    }
-    const describesWindow = Boolean(fieldFlags & WINDOW_ORDER.TYPE_WINDOW);
-    const isIconOrder = Boolean(fieldFlags & (WINDOW_ORDER.ICON | WINDOW_ORDER.CACHED_ICON));
-    if (describesWindow && !isIconOrder && orderEnd - reader.offset >= 4) {
-      const windowId = reader.u32le();
-      let fields = {};
-      try {
-        fields = parseWindowFields(reader, fieldFlags);
-      } catch (error) {
-        console.warn("[RDP] Dropped an unreadable RemoteApp window order", {
-          windowId,
-          fieldFlags: `0x${(fieldFlags >>> 0).toString(16)}`,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-      let type = "update";
-      if (fieldFlags & WINDOW_ORDER.STATE_DELETED) type = "deleted";
-      else if (fieldFlags & WINDOW_ORDER.STATE_NEW) type = "new";
-      events.push({ type, windowId, fieldFlags, ...fields });
-    }
-    reader.offset = orderEnd;
-    if (reader.offset <= orderStart) break;
-  }
-  return events;
-}
-function parseRailPdus(bytes) {
-  const reader = new Reader(bytes);
-  const messages = [];
-  while (reader.remaining >= 4) {
-    const orderType = reader.u16le();
-    const orderLength = reader.u16le();
-    if (orderLength < 4 || orderLength - 4 > reader.remaining) {
-      throw new Error("RDP RemoteApp channel delivered a malformed PDU.");
-    }
-    const body = new Reader(reader.raw(orderLength - 4));
-    if (orderType === RAIL_ORDER.HANDSHAKE && body.remaining >= 4) {
-      messages.push({ type: "handshake", buildNumber: body.u32le() });
-      continue;
-    }
-    if (orderType === RAIL_ORDER.HANDSHAKE_EX && body.remaining >= 8) {
-      messages.push({ type: "handshake", buildNumber: body.u32le(), flags: body.u32le(), extended: true });
-      continue;
-    }
-    if (orderType === RAIL_ORDER.EXEC_RESULT && body.remaining >= 12) {
-      const flags = body.u16le();
-      const result = body.u16le();
-      const rawResult = body.u32le();
-      body.u16le();
-      const nameLength = body.u16le();
-      const program = decodeUtf16(body.raw(Math.min(nameLength, body.remaining)));
-      messages.push({ type: "execute-result", flags, result, rawResult, program });
-      continue;
-    }
-    messages.push({ type: "unknown", orderType, body: body.rest().slice() });
-  }
-  return messages;
-}
-class RailChannel {
-  application;
-  width;
-  height;
-  send;
-  onReady;
-  onResult;
-  started;
-  constructor({ application, width, height, send, onReady, onResult }) {
-    this.application = application;
-    this.width = width;
-    this.height = height;
-    this.send = send;
-    this.onReady = onReady;
-    this.onResult = onResult;
-    this.started = false;
-  }
-  receive(bytes) {
-    for (const message of parseRailPdus(bytes)) {
-      if (message.type === "handshake") {
-        if (this.started) continue;
-        this.started = true;
-        this.send(railHandshake(CLIENT_BUILD));
-        this.send(railClientStatus());
-        for (const systemParameter of railSystemParameters(this.width, this.height)) {
-          this.send(systemParameter);
-        }
-        this.send(railExecute(this.application));
-        this.onReady?.(message);
-        continue;
-      }
-      if (message.type === "execute-result") {
-        this.onResult?.({
-          ...message,
-          ok: message.result === 0,
-          message: RAIL_EXEC_RESULT[message.result] || `The RemoteApp host returned launch result 0x${message.result.toString(16).padStart(4, "0")}.`
-        });
-      }
-    }
-  }
-  /** Republish the client's work area, which is what maximize resizes into. */
-  setWorkArea(width, height) {
-    if (!this.started || width <= 0 || height <= 0) return false;
-    if (width === this.width && height === this.height) return false;
-    this.width = width;
-    this.height = height;
-    this.send(railWorkArea(width, height));
-    return true;
-  }
-  activate(windowId) {
-    if (!this.started) return false;
-    this.send(railActivate(windowId, true));
-    return true;
-  }
-  sysCommand(windowId, command) {
-    if (!this.started) return false;
-    this.send(railSysCommand(windowId, command));
-    return true;
-  }
-  moveWindow(windowId, rectangle) {
-    if (!this.started) return false;
-    this.send(railWindowMove(windowId, rectangle));
-    return true;
-  }
-}
-export {
-  RAIL_EXEC_RESULT,
-  RAIL_ORDER,
-  RailChannel,
-  SHOW_STATE,
-  SYS_COMMAND,
-  WINDOW_ORDER,
-  isPrimaryWindow,
-  parseRailPdus,
-  parseRemoteAppWindowOrders,
-  railActivate,
-  railClientStatus,
-  railExecute,
-  railHandshake,
-  railSysCommand,
-  railSystemParameters,
-  railWindowMove,
-  railWorkArea
-};

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

@@ -1,13 +0,0 @@
-export declare function rleDecompress(src: Uint8Array, width: number, height: number, bytesPerPixel: number): Uint32Array<ArrayBuffer>;
-/**
- * Reverse the row order of a decoded rectangle. RDP stores bitmaps bottom-up
- * and a canvas expects top-down, so without this every rectangle is painted
- * upside down.
- */
-export declare function flipRows(pixels: Uint8Array, width: number): Uint32Array<ArrayBuffer> | Uint8Array<ArrayBufferLike>;
-/** Read uncompressed bitmap data, which RDP stores bottom-up. */
-export declare function readUncompressed(src: Uint8Array, width: number, height: number, bytesPerPixel: number): Uint32Array<ArrayBuffer>;
-/** Expand raw pixel values into RGBA for putImageData. */
-export declare function pixelsToRgba(pixels: Uint8Array, bitsPerPixel: number, palette: Uint32Array): Uint8ClampedArray<ArrayBuffer>;
-/** Decode one TS_BITMAP_DATA rectangle to RGBA. */
-export declare function decodeBitmapRect(rect: BitmapRect, palette: Uint32Array): Uint8ClampedArray<ArrayBuffer>;

package/dist/protocols/rdp/rle.js

@@ -1,275 +0,0 @@
-const REGULAR_BG_RUN = 0;
-const REGULAR_FG_RUN = 1;
-const REGULAR_FGBG_IMAGE = 2;
-const REGULAR_COLOR_RUN = 3;
-const REGULAR_COLOR_IMAGE = 4;
-const LITE_SET_FG_FG_RUN = 12;
-const LITE_SET_FG_FGBG_IMAGE = 13;
-const LITE_DITHERED_RUN = 14;
-const MEGA_MEGA_BG_RUN = 240;
-const MEGA_MEGA_FG_RUN = 241;
-const MEGA_MEGA_FGBG_IMAGE = 242;
-const MEGA_MEGA_COLOR_RUN = 243;
-const MEGA_MEGA_COLOR_IMAGE = 244;
-const MEGA_MEGA_SET_FG_RUN = 246;
-const MEGA_MEGA_SET_FGBG_IMAGE = 247;
-const MEGA_MEGA_DITHERED_RUN = 248;
-const SPECIAL_FGBG_1 = 249;
-const SPECIAL_FGBG_2 = 250;
-const SPECIAL_WHITE = 253;
-const SPECIAL_BLACK = 254;
-const MASK_SPECIAL_FGBG_1 = 3;
-const MASK_SPECIAL_FGBG_2 = 5;
-function extractCodeId(header) {
-  if ((header & 192) !== 192) return header >> 5;
-  if ((header & 240) === 240) return header;
-  return header >> 4;
-}
-function rleDecompress(src, width, height, bytesPerPixel) {
-  const pixels = new Uint32Array(width * height);
-  const white = bytesPerPixel >= 4 ? 4294967295 : (1 << bytesPerPixel * 8) - 1;
-  let srcOffset = 0;
-  let dest = 0;
-  let foreground = white;
-  let insertForegroundPixel = false;
-  let firstLine = true;
-  const readPixel = () => {
-    let value = 0;
-    for (let i = 0; i < bytesPerPixel; i++) value |= src[srcOffset + i] << i * 8;
-    srcOffset += bytesPerPixel;
-    return value >>> 0;
-  };
-  const runLengthOf = (code) => {
-    const header = src[srcOffset];
-    if (code === REGULAR_FGBG_IMAGE) {
-      const packed = header & 31;
-      if (packed === 0) {
-        srcOffset += 2;
-        return src[srcOffset - 1] + 1;
-      }
-      srcOffset += 1;
-      return packed * 8;
-    }
-    if (code === LITE_SET_FG_FGBG_IMAGE) {
-      const packed = header & 15;
-      if (packed === 0) {
-        srcOffset += 2;
-        return src[srcOffset - 1] + 1;
-      }
-      srcOffset += 1;
-      return packed * 8;
-    }
-    if (code === REGULAR_BG_RUN || code === REGULAR_FG_RUN || code === REGULAR_COLOR_RUN || code === REGULAR_COLOR_IMAGE) {
-      const packed = header & 31;
-      if (packed === 0) {
-        srcOffset += 2;
-        return src[srcOffset - 1] + 32;
-      }
-      srcOffset += 1;
-      return packed;
-    }
-    if (code === LITE_SET_FG_FG_RUN || code === LITE_DITHERED_RUN) {
-      const packed = header & 15;
-      if (packed === 0) {
-        srcOffset += 2;
-        return src[srcOffset - 1] + 16;
-      }
-      srcOffset += 1;
-      return packed;
-    }
-    const length = src[srcOffset + 1] | src[srcOffset + 2] << 8;
-    srcOffset += 3;
-    return length;
-  };
-  const writeFgBgImage = (bitmask, count) => {
-    let mask = 1;
-    for (let i = 0; i < count; i++) {
-      if (firstLine) {
-        pixels[dest] = bitmask & mask ? foreground : 0;
-      } else {
-        const above = pixels[dest - width];
-        pixels[dest] = bitmask & mask ? (above ^ foreground) >>> 0 : above;
-      }
-      dest++;
-      mask = mask << 1 & 255;
-    }
-  };
-  while (srcOffset < src.length && dest < pixels.length) {
-    if (firstLine && dest >= width) firstLine = false;
-    const code = extractCodeId(src[srcOffset]);
-    if (code === REGULAR_BG_RUN || code === MEGA_MEGA_BG_RUN) {
-      let runLength = runLengthOf(code);
-      if (firstLine) {
-        if (insertForegroundPixel) {
-          pixels[dest++] = foreground;
-          runLength--;
-        }
-        while (runLength-- > 0 && dest < pixels.length) pixels[dest++] = 0;
-      } else {
-        if (insertForegroundPixel) {
-          pixels[dest] = (pixels[dest - width] ^ foreground) >>> 0;
-          dest++;
-          runLength--;
-        }
-        while (runLength-- > 0 && dest < pixels.length) {
-          pixels[dest] = pixels[dest - width];
-          dest++;
-        }
-      }
-      insertForegroundPixel = true;
-      continue;
-    }
-    insertForegroundPixel = false;
-    switch (code) {
-      case REGULAR_FG_RUN:
-      case MEGA_MEGA_FG_RUN:
-      case LITE_SET_FG_FG_RUN:
-      case MEGA_MEGA_SET_FG_RUN: {
-        let runLength = runLengthOf(code);
-        if (code === LITE_SET_FG_FG_RUN || code === MEGA_MEGA_SET_FG_RUN) foreground = readPixel();
-        if (firstLine) {
-          while (runLength-- > 0 && dest < pixels.length) pixels[dest++] = foreground;
-        } else {
-          while (runLength-- > 0 && dest < pixels.length) {
-            pixels[dest] = (pixels[dest - width] ^ foreground) >>> 0;
-            dest++;
-          }
-        }
-        break;
-      }
-      case LITE_DITHERED_RUN:
-      case MEGA_MEGA_DITHERED_RUN: {
-        let runLength = runLengthOf(code);
-        const pixelA = readPixel();
-        const pixelB = readPixel();
-        while (runLength-- > 0 && dest < pixels.length - 1) {
-          pixels[dest++] = pixelA;
-          pixels[dest++] = pixelB;
-        }
-        break;
-      }
-      case REGULAR_COLOR_RUN:
-      case MEGA_MEGA_COLOR_RUN: {
-        let runLength = runLengthOf(code);
-        const color = readPixel();
-        while (runLength-- > 0 && dest < pixels.length) pixels[dest++] = color;
-        break;
-      }
-      case REGULAR_FGBG_IMAGE:
-      case MEGA_MEGA_FGBG_IMAGE:
-      case LITE_SET_FG_FGBG_IMAGE:
-      case MEGA_MEGA_SET_FGBG_IMAGE: {
-        let runLength = runLengthOf(code);
-        if (code === LITE_SET_FG_FGBG_IMAGE || code === MEGA_MEGA_SET_FGBG_IMAGE) {
-          foreground = readPixel();
-        }
-        while (runLength > 8) {
-          writeFgBgImage(src[srcOffset++], 8);
-          runLength -= 8;
-        }
-        if (runLength > 0) writeFgBgImage(src[srcOffset++], runLength);
-        break;
-      }
-      case REGULAR_COLOR_IMAGE:
-      case MEGA_MEGA_COLOR_IMAGE: {
-        let runLength = runLengthOf(code);
-        while (runLength-- > 0 && dest < pixels.length) pixels[dest++] = readPixel();
-        break;
-      }
-      case SPECIAL_FGBG_1:
-        srcOffset++;
-        writeFgBgImage(MASK_SPECIAL_FGBG_1, 8);
-        break;
-      case SPECIAL_FGBG_2:
-        srcOffset++;
-        writeFgBgImage(MASK_SPECIAL_FGBG_2, 8);
-        break;
-      case SPECIAL_WHITE:
-        srcOffset++;
-        pixels[dest++] = white;
-        break;
-      case SPECIAL_BLACK:
-        srcOffset++;
-        pixels[dest++] = 0;
-        break;
-      default:
-        throw new Error(`RDP: unsupported bitmap compression order 0x${code.toString(16)}`);
-    }
-  }
-  return pixels;
-}
-function flipRows(pixels, width) {
-  if (width <= 0) return pixels;
-  const height = Math.floor(pixels.length / width);
-  if (height < 2) return pixels;
-  const flipped = new Uint32Array(pixels.length);
-  for (let y = 0; y < height; y++) {
-    flipped.set(pixels.subarray(y * width, (y + 1) * width), (height - 1 - y) * width);
-  }
-  return flipped;
-}
-function readUncompressed(src, width, height, bytesPerPixel) {
-  const pixels = new Uint32Array(width * height);
-  for (let y = 0; y < height; y++) {
-    const destRow = (height - 1 - y) * width;
-    let offset = y * width * bytesPerPixel;
-    for (let x = 0; x < width; x++) {
-      let value = 0;
-      for (let i = 0; i < bytesPerPixel; i++) value |= src[offset + i] << i * 8;
-      pixels[destRow + x] = value >>> 0;
-      offset += bytesPerPixel;
-    }
-  }
-  return pixels;
-}
-function pixelsToRgba(pixels, bitsPerPixel, palette) {
-  const rgba = new Uint8ClampedArray(pixels.length * 4);
-  for (let i = 0; i < pixels.length; i++) {
-    const value = pixels[i];
-    let r;
-    let g;
-    let b;
-    switch (bitsPerPixel) {
-      case 15:
-        r = (value >> 10 & 31) * 255 / 31;
-        g = (value >> 5 & 31) * 255 / 31;
-        b = (value & 31) * 255 / 31;
-        break;
-      case 16:
-        r = (value >> 11 & 31) * 255 / 31;
-        g = (value >> 5 & 63) * 255 / 63;
-        b = (value & 31) * 255 / 31;
-        break;
-      case 8: {
-        const index = (value & 255) * 3;
-        r = palette ? palette[index] : value;
-        g = palette ? palette[index + 1] : value;
-        b = palette ? palette[index + 2] : value;
-        break;
-      }
-      default:
-        r = value >> 16 & 255;
-        g = value >> 8 & 255;
-        b = value & 255;
-        break;
-    }
-    const offset = i * 4;
-    rgba[offset] = r;
-    rgba[offset + 1] = g;
-    rgba[offset + 2] = b;
-    rgba[offset + 3] = 255;
-  }
-  return rgba;
-}
-function decodeBitmapRect(rect, palette) {
-  const bytesPerPixel = Math.max(1, Math.ceil(rect.bitsPerPixel / 8));
-  const pixels = rect.compressed ? flipRows(rleDecompress(rect.data, rect.width, rect.height, bytesPerPixel), rect.width) : readUncompressed(rect.data, rect.width, rect.height, bytesPerPixel);
-  return pixelsToRgba(pixels, rect.bitsPerPixel, palette);
-}
-export {
-  decodeBitmapRect,
-  flipRows,
-  pixelsToRgba,
-  readUncompressed,
-  rleDecompress
-};